def train_lstm(n_symbols, embedding_weights, x_train, y_train, x_test, y_test):
print('Defining a simple Keras Model')
model = Sequential() # or Graph or whatever
model.add(Embedding(output_dim=vocab_dim,
input_dim=n_symbols,
mask_zero=True,
weights=[embedding_weights],
input_length=input_length))
model.add(LSTM(activation="sigmoid", units=50, recurrent_activation="hard_sigmoid"))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))
print('Compiling the Model...')
model.compile(loss='binary_crossentropy',
optimizer='adam', metrics=['accuracy'])
print("Train...")
model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=n_epoch, verbose=1, validation_data=(x_test, y_test))
print("Evaluate...")
score = model.evaluate(x_test, y_test,
batch_size=batch_size)
yaml_string = model.to_yaml()
with open('../lstm_data/lstm.yml', 'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
model.save_weights('../lstm_data/lstm.h5')
print('Test score:', score)
def train_rnn(cls,
n_dim,
x_train,
y_train,
x_test,
y_test,
log_file,
batch_size=10,
n_epoch=5):
"""
lstm训练模块
:return:
"""
print 'Defining a Simple Keras Model...'
model = Sequential()
# 特征已经整理完了,所以不加embedding
model.add(Dense(n_dim / 2, input_shape=(n_dim, ), activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_dim / 4, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_dim / 8, activation='relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))
print 'Compiling the Model...'
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print "Train..."
model.fit(x_train,
y_train,
batch_size=batch_size,
nb_epoch=n_epoch,
verbose=1,
validation_data=(x_train, y_train))
print "Evaluate..."
score = model.evaluate(x_test, y_test, batch_size=batch_size)
yaml_string = model.to_yaml()
with open('rnn_data/' + log_file + 'lstm.yml', 'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
model.save_weights('rnn_data/' + log_file + '_lstm.h5')
print 'Test score:', score
return model
def train_lstm(n_symbols, embedding_weights, x_train, y_train, x_test, y_test):
## 定义基本的网络结构
model = Sequential() # or Graph or whatever
## 对于LSTM 变长的文本使用Embedding 将其变成指定长度的向量
model.add(
Embedding(
output_dim=vocab_dim, #大于0的整数，代表全连接嵌入的维度
input_dim=n_symbols, #大或等于0的整数，字典长度，即输入数据最大下标+1
mask_zero=
True, #布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用递归层处理变长输入时有用。
weights=[embedding_weights],
input_length=input_length)) #当输入序列的长度固定时，该值为其长度
## 使用单层LSTM 输出的向量维度是50，输入的向量维度是vocab_dim,激活函数relu
model.add(
LSTM(activation="relu", units=50, recurrent_activation="hard_sigmoid"))
#relu运行速度快，并且可以减缓梯度消失
print('---' * 45)
model.add(Dropout(0.5)) #随机删除网络中的一些隐藏神经元,防止过拟合，实现一定程度的正则化
model.add(Dense(1)) #添加全连接层
model.add(Activation('sigmoid'))
print('Compiling the Model...')
## 优化函数使用的是adam，收敛效果较好
model.compile(
loss='binary_crossentropy', #对数损失，对于交叉熵，转化为log，计算方便
optimizer='adam',
metrics=['accuracy'])
print("Train...")
model.fit(x_train,
y_train,
batch_size=batch_size,
nb_epoch=n_epoch,
verbose=1,
validation_data=(x_test, y_test))
#plot_model(model, to_file='model.png')
print("Evaluate...")
score = model.evaluate(x_test, y_test, batch_size=batch_size)
yaml_string = model.to_yaml()
with open('../lstm_data/lstm.yml', 'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
model.save_weights('../lstm_data/lstm.h5')
print('Test score:', score)
def train_lstm(n_symbols, embedding_weights, x_train, y_train, x_test, y_test):
print('Defining a simple Keras Model')
model = Sequential() # or Graph or whatever output_dim 词向量的维度 input_dim：词汇表的大小 input_length :输入序列的长度。
model.add(Embedding(output_dim=vocab_dim,
input_dim=n_symbols,
mask_zero=True,
weights=[embedding_weights],
input_length=input_length))
model.add(LSTM(activation="sigmoid", units=50, recurrent_activation="hard_sigmoid"))
#rate: 在 0 和 1 之间浮动。需要丢弃的输入比例
model.add(Dropout(0.5))
# 指定输出尺寸。
model.add(Dense(1))
model.add(Activation('sigmoid'))
print('Compiling the Model...')
#损失函数，优化器，训练和测试期间的模型评估标准
model.compile(loss='binary_crossentropy',
optimizer='adam', metrics=['accuracy'])
print("Train...")
# 以给定数量的轮次 训练模型。
model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=n_epoch, verbose=1, validation_data=(x_test, y_test))
print("Evaluate...")
#训练和测试期间的模型评估标准 返回模型的误差值和评估标准值。
score = model.evaluate(x_test, y_test,
batch_size=batch_size)
#YAML 字符串的形式返回模型的表示
yaml_string = model.to_yaml()
with open('../lstm_data/lstm.yml', 'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
#保留权重文件。
model.save_weights('../lstm_data/lstm.h5')
print('Test score:', score)
def fitting(self):
dim_row = self.lags # tiempo
dim_col = 1 # features or chanels (Volume)
output_dim = 3 # 3 for categorical
#data = np.random.random((1000, dim_row, dim_col))
#clas = np.random.randint(3, size=(1000, 1))
##print(clas)
#clas = to_categorical(clas)
##print(clas)
data = self.X_train
data_test = self.X_test
data = data.values.reshape(-1, dim_row, dim_col)
data_test = data_test.values.reshape(-1, dim_row, dim_col)
clas = self.y_train
clas_test = self.y_test
clas = to_categorical(clas)
clas_test = to_categorical(clas_test)
cat0 = self.y_train.tolist().count(0)
cat1 = self.y_train.tolist().count(1)
cat2 = self.y_train.tolist().count(2)
print("may: ", cat1, " ", "menor: ", cat2, " ", "neutro: ", cat0)
n_samples_0 = cat0
n_samples_1 = (cat1 + cat2)/2.0
n_samples_2 = (cat1 + cat2)/2.0
class_weight={
0: 1.0,
1: n_samples_0/n_samples_1,
2: n_samples_0/n_samples_2}
def class_1_accuracy(y_true, y_pred):
# cojido de: http://www.deepideas.net/unbalanced-classes-machine-learning/
class_id_true = K.argmax(y_true, axis=-1)
class_id_preds = K.argmax(y_pred, axis=-1)
accuracy_mask = K.cast(K.equal(class_id_preds, 1), 'int32')
class_acc_tensor = K.cast(K.equal(class_id_true, class_id_preds), 'int32') * accuracy_mask
class_acc = K.sum(class_acc_tensor) / K.maximum(K.sum(accuracy_mask), 1)
return class_acc
class SecondOpinion(Callback):
def __init__(self, model, x_test, y_test, N):
self.model = model
self.x_test = x_test
self.y_test = y_test
self.N = N
self.epoch = 1
def on_epoch_end(self, epoch, logs={}):
if self.epoch % self.N == 0:
y_pred = self.model.predict(self.x_test)
pred_T = 0
pred_F = 0
for i in range(len(y_pred)):
if np.argmax(y_pred[i]) == 1 and np.argmax(self.y_test[i]) == 1:
pred_T += 1
if np.argmax(y_pred[i]) == 1 and np.argmax(self.y_test[i]) != 1:
pred_F += 1
if pred_T + pred_F > 0:
Pr_pos = pred_T/(pred_T + pred_F)
print("Yoe: epoch, Probabilidad pos: ", self.epoch, Pr_pos)
else:
print("Yoe Probabilidad pos: 0")
self.epoch += 1
#################################################################################################################
model = Sequential()
# model.add(Reshape(input_shape=(dim_row, dim_col), target_shape=(dim_row, dim_col, 1)))
if self.nConv > 0:
#model.add(Reshape((dim_row, dim_col, 1)))
model.add(Reshape(input_shape=(dim_row, dim_col), target_shape=(dim_row, dim_col, 1)))
for i in range(self.nConv):
model.add(Convolution2D(self.conv_nodes, kernel_size = (self.kernel_size, 1), padding = 'same', kernel_regularizer = regularizers.l2(0.01)))
model.add(Activation('relu'))
model.add(Reshape(target_shape=(dim_row, self.conv_nodes * dim_col)))
# Como nuestro output tiene una sola dimension no es necesario "return_sequences='True'"
# y tampoco es necesario usar TimeDistributed
if self.nConv == 0:
model.add(LSTM(units=self.lstm_nodes, return_sequences=True, activation='tanh', input_shape=(dim_row, dim_col)))
for i in range(self.nLSTM - 1):
model.add(LSTM(units=self.lstm_nodes, return_sequences=True, activation='tanh'))
model.add(Dropout(0.5))
model.add(TimeDistributed(Dense(units = output_dim))) # the dimension of index one will be considered to be the temporal dimension
model.add(Activation('softmax')) # for loss = 'categorical_crossentropy'
#model.add(Activation('sigmoid')) # for loss = 'binary_crossentropy'
# haciendo x: x[:, -1, :], la segunda dimension desaparece quedando solo
# los ULTIMOS elementos (-1) de dicha dimension:
# Try this to see:
# data = np.random.random((5, 3, 4))
# print(data)
# print(data[:, -1, :])
model.add(Lambda(lambda x: x[:, -1, :], output_shape = [output_dim]))
print(model.summary())
tensorboard_active = False
val_loss = False
second_opinion = True
callbacks = []
if tensorboard_active:
callbacks.append(TensorBoard(
log_dir=self.putmodel + "Tensor_board_data",
histogram_freq=0,
write_graph=True,
write_images=True))
if val_loss:
callbacks.append(EarlyStopping(
monitor='val_loss',
patience=5))
if second_opinion:
callbacks.append(SecondOpinion(model, data_test, clas_test, 10))
#model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = ['categorical_accuracy'])
#model.compile(loss = 'binary_crossentropy', optimizer=Adam(lr=self.learning), metrics = ['categorical_accuracy'])
model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy])
model.fit(x=data,
y=clas,
batch_size=self.batch_size, epochs=800, verbose=2,
callbacks = callbacks,
class_weight = class_weight)
#validation_data=(data_test, clas_test))
#####################################################################################################################
# serialize model to YAML
model_yaml = model.to_yaml()
with open("model.yaml", "w") as yaml_file:
yaml_file.write(model_yaml)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")
# # load YAML and create model
# yaml_file = open('model.yaml', 'r')
# loaded_model_yaml = yaml_file.read()
# yaml_file.close()
# loaded_model = model_from_yaml(loaded_model_yaml)
# # load weights into new model
# loaded_model.load_weights("model.h5")
# print("Loaded model from disk")
# loaded_model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy])
#
print("Computing prediction ...")
y_pred = model.predict_proba(data_test)
model.reset_states()
print("Computing train evaluation ...")
score_train = model.evaluate(data, clas, verbose=2)
print('Train loss:', score_train[0])
print('Train accuracy:', score_train[1])
model.reset_states()
# score_train_loaded = loaded_model.evaluate(data, clas, verbose=2)
# loaded_model.reset_states()
# print('Train loss loaded:', score_train[0])
# print('Train accuracy loaded:', score_train[1])
print("Computing test evaluation ...")
score_test = model.evaluate(data_test, clas_test, verbose=2)
print('Test loss:', score_test[0])
print('Test accuracy:', score_test[1])
model.reset_states()
# score_test_loaded = loaded_model.evaluate(data_test, clas_test, verbose=2)
# loaded_model.reset_states()
# print('Test loss loaded:', score_test[0])
# print('Test accuracy loaded:', score_test[1])
pred_T = 0
pred_F = 0
for i in range(len(y_pred)):
if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) == 1:
pred_T += 1
# print(y_pred[i])
if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) != 1:
pred_F += 1
if pred_T + pred_F > 0:
Pr_pos = pred_T/(pred_T + pred_F)
print("Yoe Probabilidad pos: ", Pr_pos)
else:
print("Yoe Probabilidad pos: 0")
history = DataFrame([[self.skip, self.nConv, self.nLSTM,
self.learning, self.batch_size,
self.conv_nodes, self.lstm_nodes,
score_train[0], score_train[1],
score_test[0], score_test[1]]], columns = ('Skip', 'cConv', 'nLSTM', 'learning',
'batch_size', 'conv_nodes', 'lstm_nodes',
'loss_train', 'acc_train', 'loss_test', 'acc_test'))
self.history = self.history.append(history)
# fully-connected layers
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Dropout(0.40))
model.add(Dense(111, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
with open(output_dir + '/model_architecture.yml', 'w') as f:
f.write(model.to_yaml())
plot_model(model, to_file=output_dir + '/model.png', show_shapes=True)
with open(output_dir + '/modelsummary.txt', 'w') as f:
with redirect_stdout(f):
model.summary()
with tf.device("/device:GPU:0"):
history = model.fit_generator(
train_generator,
steps_per_epoch=train_generator.n // batch_size,
epochs=epochs,
validation_data=validation_generator,
validation_steps=validation_generator.n // batch_size)
#callbacks (not inlcuded in report due to constraints)
es_loss = EarlyStopping()
es_acc = EarlyStopping(monitor='acc')
callbacks = [es_loss]
## nn training
history = net.fit(
x=X_train,
y=y_train,
validation_data=(X_valid, y_valid),
epochs=epochs,
use_multiprocessing=True,
callbacks=callbacks) #steps_per_epoch=len(X_train)/ batch_size
model_yaml = net.to_yaml()
with open("model.yaml", "w") as yaml_file:
yaml_file.write(model_yaml)
net.save("model.h5")
# accuracy visualization
yhat_valid = net.predict_classes(X_valid)
scikitplot.metrics.plot_confusion_matrix(np.argmax(y_valid, axis=1),
yhat_valid,
figsize=(7, 7))
pyplot.savefig("confusion_matrix.png")
print(
f'total wrong validation predictions: {np.sum(np.argmax(y_valid, axis=1) != yhat_valid)}\n\n'
)
loss, accuracy = model.evaluate(X_train, y_train, batch_size=batch_size)
print('\ntrain loss: ', loss)
print('\ntrain accuracy: ', accuracy)
from sklearn import metrics
y_pred = model.predict(X_train)
print(y_pred)
fpr, tpr, thresholds = metrics.roc_curve(y_train, y_pred, pos_label=1)
metrics.auc(fpr, tpr)
print('\ntrain AUC: ', metrics.auc(fpr, tpr))
loss, accuracy = model.evaluate(X_test, y_test, batch_size=batch_size)
yaml_string = model.to_yaml()
with open('DNN.yml', 'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
model.save_weights('DNN.h5')
print('\ntest loss: ', loss)
print('\ntest accuracy: ', accuracy)
print(y_pred)
from sklearn import metrics
y_pred = model.predict(X_test)
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred, pos_label=1)
metrics.auc(fpr, tpr)
print('\ntest AUC: ', metrics.auc(fpr, tpr))
def train_lstm(n_symbols, embedding_weights, text_train, label_train,
text_test, label_test):
print('Defining a simple Keras Model')
kernel_size = 3
filters = 250
"""
顺序模型是多个网络层的线性堆叠。
参数:
input_dim：大或等于0的整数，字典长度，即输入数据最大下标+1
output_dim：大于0的整数，代表全连接嵌入的维度
embeddings_initializer: 嵌入矩阵的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
embeddings_regularizer: 嵌入矩阵的正则项，为Regularizer对象
embeddings_constraint: 嵌入矩阵的约束项，为Constraints对象
mask_zero：布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用递归层处理变长输入时有用。设置为True的话，模型中后续的层必须都支持masking，否则会抛出异常。如果该值为True，则下标0在字典中不可用，input_dim应设置为|vocabulary| + 1。
input_length：当输入序列的长度固定时，该值为其长度。如果要在该层后接Flatten层，然后接Dense层，则必须指定该参数，否则Dense层的输出维度无法自动推断。
"""
model = Sequential() # or Graph or whatever
model.add(Embedding(n_symbols,
embedding_weights)) # 使用Embedding层将每个词编码转换为词向量
model.add(
Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
# 池化
model.add(GlobalMaxPooling1D())
model.add(Dense(label_train.shape[1],
activation='softmax')) # 第一个参数units: 全连接层输出的维度，即下一层神经元的个数。
model.add(Dropout(0.2))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
# 本函数编译模型以供训练
# binary_crossentropy二分类
print('Compiling the Model...')
model.compile(
loss='categorical_crossentropy', # 损失函数，为预定义损失函数名或一个目标函数
optimizer='rmsprop', # 优化器，为预定义优化器名或优化器对象
metrics=['accuracy'])
# 本函数用以训练模型
# 参数：
# x_train输入数据
# y_train标签
# batch_size：整数，指定进行梯度下降时每个batch包含的样本数
# epochs：整数，训练终止时的epoch值，训练将在达到该epoch值时停止
# verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录
# validation_data：形式为（X，y）或（X，y，sample_weights）的tuple，是指定的验证集。此参数将覆盖validation_spilt
print("Train...")
history = model.fit(text_train,
label_train,
batch_size=batch_size,
epochs=n_epoch,
verbose=2,
validation_data=(text_test, label_test))
"""
本函数按batch计算在某些输入数据上模型的误差
参数
x：输入数据，与fit一样，是numpy array或numpy array的list
y：标签，numpy array
batch_size：整数，含义同fit的同名参数
verbose：含义同fit的同名参数，但只能取0或1
sample_weight：numpy array，含义同fit的同名参数
"""
print("Evaluate...")
score = model.evaluate(text_test, label_test, batch_size=batch_size)
# model.to_yaml() 以 YAML 字符串的形式返回模型的表示
yaml_string = model.to_yaml()
# python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写
with open('D:/javafile/Text_classify_test/static/lstm_data/lstm.yml',
'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
# model.save_weights(filepath) 将模型权重存储为 HDF5 文件
model.save_weights(
'D:/javafile/Text_classify_test/static/lstm_data/lstm.h5')
# 输出误差
print(model.metrics_names)
print('Test score:', score)
# 绘制训练 & 验证的准确率值
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
# 绘制训练 & 验证的损失值
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
