【tensorflow】连续输入+离散输入的神经网络模型训练代码
- 离散输入的转化问题
- 构造词典
- 创建离散数据、转化字典索引、创建连续数据
- 创建离散输入+连续输入模型
- 训练输出
- 全部代码 - 复制即用
查看本系列三种模型写法：
【tensorflow】连续输入的线性回归模型训练代码
【tensorflow】连续输入的神经网络模型训练代码
【tensorflow】连续输入+离散输入的神经网络模型训练代码
离散输入的转化问题
离散输入一般有几种处理方式：
1、如果是数字的话，可以直接输入到模型，或者正则化到[0-1]之间再输入。
但是离散的数字往往代表一个实体，比如它可能是id，去当数字输入到模型是不合适的。而且，离散的数据也不一定是数据，更多的是字符串。
2、如果是字符串，可以转化为one-hot编码，但是这样的话，为0的数据占90%以上。
3、所以此时就需要用到Embedding。在使用Embedding前，需要构造字典。
Embedding层形状为(input_length, dim, vocab_size)。input_length是输入的维度，dim表示一个词我要表征为几维度的向量，vocab_size表示词汇表的大小。输入需要是[0-vocab_size-1]之间的数字，所以我们需要把离散输入转化为数字，此时就要构造字典。
构造词典
第一步，创建离散的数据集：
import numpy as np
random_numbers = np.random.randint(low=1, high=1000000, size=10000)
// array([781702, 805689, 194619, ..., 268855, 114390, 963977])
第二步，提取离散的数据中的字典：
np.savetxt('voc.txt', [_ for _ in random_numbers], delimiter='\n', fmt='%d')
创建离散数据、转化字典索引、创建连续数据
# 加载词典
def get_vocab(path):
vocab_dict = {}
with open(path, 'r', encoding='utf-8') as file:
for index, line in enumerate(file):
word = line.strip()
vocab_dict[word] = index
print(f"\n===词典长度==={len(vocab_dict)}===\n")
return vocab_dict
def get_data():
# 设置随机种子，以确保结果可复现（可选）
np.random.seed(0)
# 生成随机数据
data = np.random.rand(10000, 10)
# 正则化数据
scaler = StandardScaler()
data = scaler.fit_transform(data)
random_numbers = np.random.randint(low=1, high=1000000, size=10000)
np.savetxt('voc.txt', [_ for _ in random_numbers], delimiter='\n', fmt='%d')
vocab_dict = get_vocab('voc.txt')
discrete = [vocab_dict[str(i)] for i in random_numbers]
# 生成随机数据
target = np.random.rand(10000, 1)
return train_test_split(data, target, discrete, test_size=0.1, random_state=42)
data_train, data_val, target_train, target_val, discrete_train, discrete_val = get_data()
get_vocab函数：
这个函数用于从指定路径的文件中加载词典。它会逐行读取文件内容，并将每一行的单词作为词典的键，行号作为对应的值。最终返回一个包含词典内容的字典对象。
path参数表示词典文件的路径。
函数内部使用open函数打开文件，按行读取文件内容。
对于每一行，使用strip方法去除行末尾的换行符等不需要的字符，并将其作为词典的键。
行号（即索引值）作为对应的值，并将键值对添加到词典中。
最后，返回包含词典内容的字典对象。
get_data函数：
这个函数用于生成随机数据，并结合词典将随机生成的整数映射为离散值。函数的执行过程如下：
首先，使用np.random.rand函数生成一个形状为(10000, 10)的随机数据矩阵data。
接下来，使用StandardScaler对数据进行正则化处理，将其转换为均值为0、标准差为1的数据。
然后，使用np.random.randint生成一个长度为10000、范围在1到1000000之间的随机整数数组random_numbers。
使用np.savetxt函数将random_numbers保存为文本文件voc.txt，每个整数占一行。
调用get_vocab函数，加载词典文件voc.txt，并将其存储在vocab_dict字典中。
根据词典，将random_numbers中的整数映射为对应的离散值，存储在discrete列表中。
最后，使用np.random.rand函数生成一个形状为(10000, 1)的随机目标值数组target。
函数返回了划分好的训练集和验证集数据，包括data_train、data_val、target_train、target_val、discrete_train和discrete_val。这些数据将在后续的模型训练和验证中使用。
创建离散输入+连续输入模型
def create_mlp(dim, regress=False):
model = Sequential()
model.add(Dense(64, input_dim=dim, activation="relu"))
model.add(Dense(64, activation="relu"))
# check to see if the regression node should be added
if regress:
model.add(Dense(1, activation="linear"))
# return our model
return model
def create_emb(dim, regress=False):
model = Sequential()
model.add(Embedding(input_length= dim, output_dim=8, input_dim=vocabulary_size))
model.add(LSTM(128))
model.add(Dense(64, activation="relu"))
# check to see if the regression node should be added
if regress:
model.add(Dense(1, activation="linear"))
# return our model
return model
mlp = create_mlp(10, regress=False)
emb = create_emb(1, regress=False)
combined = concatenate([mlp.output, emb.output])
z = Dense(2, activation="relu")(combined)
z = Dense(1, activation="linear")(z)
model = Model(inputs=[mlp.input, emb.input], outputs=z)
model.summary()
这段代码定义了两个函数create_mlp和create_emb，用于创建MLP（多层感知机）和Embedding-LSTM模型，并将它们结合起来构建一个联合模型。
create_mlp函数：
这个函数用于创建一个MLP模型。MLP是一种前馈神经网络，由多个全连接层组成。函数的输入参数dim表示输入维度，regress表示是否是回归任务。
创建一个Sequential模型对象。
添加一个具有64个神经元的全连接层，输入维度为dim，激活函数为ReLU。
添加第二个具有64个神经元的全连接层，激活函数为ReLU。
如果regress为True，则添加一个具有1个神经元的输出层，激活函数为线性激活函数（用于回归任务）。
返回构建好的MLP模型对象。
create_emb函数：
这个函数用于创建一个包含Embedding和LSTM的模型。Embedding是一种用于将离散的整数序列映射到低维连续向量的技术，而LSTM是一种长短期记忆网络。
创建一个Sequential模型对象。
添加一个Embedding层，指定输入长度为dim，输出维度为8，输入维度为vocabulary_size（词汇表大小）。
添加一个LSTM层，具有128个神经元。
添加一个具有64个神经元的全连接层，激活函数为ReLU。
如果regress为True，则添加一个具有1个神经元的输出层，激活函数为线性激活函数（用于回归任务）。
返回构建好的Embedding-LSTM模型对象。
接下来的代码将两个模型的输出通过concatenate函数进行合并。然后，构建一个新的模型model，输入为MLP模型的输入和Embedding-LSTM模型的输入，输出为合并后的结果。
使用Model函数定义一个新的模型对象，指定输入为MLP模型的输入和Embedding-LSTM模型的输入，输出为合并后的结果。
添加一个具有2个神经元的全连接层，激活函数为ReLU。
添加一个具有1个神经元的输出层，激活函数为线性激活函数。
打印模型的摘要信息，包括每层的名称、输出形状和参数数量。
通过以上步骤，你可以创建一个包含MLP和Embedding-LSTM的联合模型，并输出该模型的摘要信息，包括每层的配置和参数数量。
训练输出
模型结构如下：
模型训练过程中的输出如下：
全部代码 - 复制即用
from sklearn.model_selection import train_test_split
import tensorflow as tf
import numpy as np
from keras import Input, Model, Sequential
from keras.layers import Dense, concatenate, Embedding, LSTM
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd
# 加载词典
def get_vocab(path):
vocab_dict = {}
with open(path, 'r', encoding='utf-8') as file:
for index, line in enumerate(file):
word = line.strip()
vocab_dict[word] = index
print(f"\n===词典长度==={len(vocab_dict)}===\n")
return vocab_dict
def get_data():
# 设置随机种子，以确保结果可复现（可选）
np.random.seed(0)
# 生成随机数据
data = np.random.rand(10000, 10)
# 正则化数据
scaler = StandardScaler()
data = scaler.fit_transform(data)
random_numbers = np.random.randint(low=1, high=1000000, size=10000)
np.savetxt('voc.txt', [_ for _ in random_numbers], delimiter='\n', fmt='%d')
vocab_dict = get_vocab('voc.txt')
discrete = [vocab_dict[str(i)] for i in random_numbers]
discrete = np.array(discrete).reshape(-1, 1)
# 生成随机数据
target = np.random.rand(10000, 1)
return train_test_split(data, target, discrete, test_size=0.1, random_state=42)
data_train, data_val, target_train, target_val, discrete_train, discrete_val = get_data()
# 迭代轮次
train_epochs = 10
# 学习率
learning_rate = 0.0001
# 批大小
batch_size = 200
def create_mlp(dim, regress=False):
model = Sequential()
model.add(Dense(64, input_dim=dim, activation="relu"))
model.add(Dense(64, activation="relu"))
# check to see if the regression node should be added
if regress:
model.add(Dense(1, activation="linear"))
# return our model
return model
def create_emb(dim, regress=False):
model = Sequential()
model.add(Embedding(input_length= dim, output_dim=8, input_dim=100000))
model.add(LSTM(128))
model.add(Dense(64, activation="relu"))
# check to see if the regression node should be added
if regress:
model.add(Dense(1, activation="linear"))
# return our model
return model
mlp = create_mlp(10, regress=False)
emb = create_emb(1, regress=False)
combined = concatenate([mlp.output, emb.output])
z = Dense(2, activation="relu")(combined)
z = Dense(1, activation="linear")(z)
model = Model(inputs=[mlp.input, emb.input], outputs=z)
model.summary()
model.compile(loss="mse", optimizer=tf.train.GradientDescentOptimizer(learning_rate=learning_rate))
history = model.fit([data_train, discrete_train], target_train, epochs=train_epochs, batch_size=batch_size,
validation_data=([data_val, discrete_val], target_val))
