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()