def dnn_class(X_train,y_train,X_test,y_test): model=Sequential() model.add(Dense(1000,input_dim=1583,kernel_initializer="glorot_uniform",activation="relu")) model.add(BatchNormalization()) model.add(Dense(1000,kernel_initializer="glorot_uniform",activation="relu")) model.add(BatchNormalization()) # ============================================================================= # model.add(Dropout(0.6)) # ============================================================================= model.add(Dense(1,activation="sigmoid",kernel_initializer="glorot_uniform")) adam=Adam(lr=0.01) # model.add(Dense(units=1,activation="relu",kernel_initializer="glorot_uniform")) sgd=SGD(lr=0.01, momentum=0.01, decay=0.0, nesterov=True) rms=RMSprop(lr=0.005) model.compile(optimizer=adam,loss="binary_crossentropy",metrics=["accuracy"]) callbacks=[EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True)] print(model.summary()) model.fit(X_train,y_train,batch_size=4,epochs=50,verbose=1,callbacks=callbacks,validation_data=(X_test,y_test)) pkl_filename = "keras_model.joblib" with open(pkl_filename, 'wb') as file: joblib.dump(model, file) y_pred=model.predict_classes(X_test) print(y_pred) evaluation2(y_test,y_pred,model,X_test,X_train,y_train)
def lstm(trainData, trainMark, testData, embedding_dim, embedding_matrix, maxlen, output_len): # 填充数据,将每个序列长度保持一致 trainData = list(sequence.pad_sequences(trainData, maxlen=maxlen, dtype='float64')) # sequence返回的是一个numpy数组,pad_sequences用于填充指定长度的序列,长则阶段,短则补0,由于下面序号为0时,对应值也为0,因此可以这样 testData = list(sequence.pad_sequences(testData, maxlen=maxlen, dtype='float64')) # sequence返回的是一个numpy数组,pad_sequences用于填充指定长度的序列,长则阶段,短则补0 # 建立lstm神经网络模型 model = Sequential() # 多个网络层的线性堆叠,可以通过传递一个layer的list来构造该模型,也可以通过.add()方法一个个的加上层 # model.add(Dense(256, input_shape=(train_total_vova_len,))) #使用全连接的输入层 model.add(Embedding(len(embedding_matrix), embedding_dim, weights=[embedding_matrix], mask_zero=False, input_length=maxlen)) # 指定输入层,将高维的one-hot转成低维的embedding表示,第一个参数大或等于0的整数,输入数据最大下标+1,第二个参数大于0的整数,代表全连接嵌入的维度 # lstm层,也是比较核心的层 model.add(LSTM(256)) # 256对应Embedding输出维度,128是输入维度可以推导出来 model.add(Dropout(0.5)) # 每次在参数更新的时候以一定的几率断开层的链接,用于防止过拟合 model.add(Dense(output_len)) # 全连接,这里用于输出层,1代表输出层维度,128代表LSTM层维度可以自行推导出来 model.add(Activation('softmax')) # 输出用sigmoid激活函数 # 编译该模型,categorical_crossentropy(亦称作对数损失,logloss),adam是一种优化器,class_mode表示分类模式 model.compile(loss='categorical_crossentropy', optimizer='sgd') # 正式运行该模型,我知道为什么了,因为没有补0!!每个array的长度是不一样的,因此才会报错 X = np.array(list(trainData)) # 输入数据 print("X:", X) Y = np.array(list(trainMark)) # 标签 print("Y:", Y) # batch_size:整数,指定进行梯度下降时每个batch包含的样本数 # nb_epoch:整数,训练的轮数,训练数据将会被遍历nb_epoch次 model.fit(X, Y, batch_size=200, nb_epoch=10) # 该函数的X、Y应该是多个输入:numpy list(其中每个元素为numpy.array),单个输入:numpy.array # 进行预测 A = np.array(list(testData)) # 输入数据 print("A:", A) classes = model.predict(A) # 这个是预测的数据 return classes
def train_model(): # (X_train, Y_train, X_test, Y_test) = prapare_train() X_ = [] with open('../data/train_matrix.out') as train_file: X_train = json.load(train_file) for x in X_train: a = len(x) print a/2 x1 = x[:a/2] x2 = x[a/2:] x3 = [] x3.append(x1) x3.append(x2) X_.append(x3) # X_test = pickle.load('../data/test_matrix.out') Y_train = [1,0,0]*3 # Y_test = [1,0,0]*3 # print len(X_train) - len(Y_train) # print len(X_test) - len(Y_test) model = Sequential() model = get_nn_model() model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # model.fit(X_train, Y_train, # batch_size=batch_size, # nb_epoch=nb_epoch, # validation_data=(X_test, Y_test)) #2 model.fit(X_, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_split = 0.2) print 'ok'
def main_separatemodels(): X1, X2, y = generate_data2(TRAINING_SIZE) X1_test, X2_test, y_test = generate_data2(TEST_SIZE) print('Defining network...', file=sys.stderr) firstlstm = Sequential() firstlstm.add(Embedding(VOCABULARY_SIZE, EMBEDDING_DIMENSION)) firstlstm.add(LSTM(EMBEDDING_DIMENSION, HIDDEN_DIMENSION, return_sequences=False)) secondlstm = Sequential() secondlstm.add(Embedding(VOCABULARY_SIZE, EMBEDDING_DIMENSION)) secondlstm.add(LSTM(EMBEDDING_DIMENSION, HIDDEN_DIMENSION, return_sequences=False)) model = Sequential() model.add(Merge([firstlstm, secondlstm], mode='concat')) model.add(Dense(HIDDEN_DIMENSION + HIDDEN_DIMENSION, 1, activation='sigmoid')) print('Compiling...', file=sys.stderr) model.compile(loss='binary_crossentropy', optimizer='adam', class_mode="binary") print('Training...', file=sys.stderr) model.fit([X1, X2], y, batch_size=BATCH_SIZE, nb_epoch=EPOCHS, validation_split=0.05, show_accuracy=True) print("Testing...", file=sys.stderr) score, acc = model.evaluate([X1_test, X2_test], y_test, batch_size=BATCH_SIZE, show_accuracy=True) print("Testing performance = " + str(score) + ", acc = " + str(acc))
def model(X_train, X_test, y_train, y_test, maxlen, max_features): embedding_size = 300 pool_length = 4 lstm_output_size = 100 batch_size = 200 nb_epoch = 1 model = Sequential() model.add(Embedding(max_features, embedding_size, input_length=maxlen)) model.add(Dropout({{uniform(0, 1)}})) # Note that we use unnamed parameters here, which is bad style, but is used here # to demonstrate that it works. Always prefer named parameters. model.add(Convolution1D({{choice([64, 128])}}, {{choice([6, 8])}}, border_mode='valid', activation='relu', subsample_length=1)) model.add(MaxPooling1D(pool_length=pool_length)) model.add(LSTM(lstm_output_size)) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print('Train...') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def test_LambdaCallback(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # Start an arbitrary process that should run during model training and be terminated after training has completed. def f(): while True: pass p = multiprocessing.Process(target=f) p.start() cleanup_callback = callbacks.LambdaCallback(on_train_end=lambda logs: p.terminate()) cbks = [cleanup_callback] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=5) p.join() assert not p.is_alive()
def test_TensorBoard_with_ReduceLROnPlateau(tmpdir): import shutil np.random.seed(np.random.randint(1, 1e7)) filepath = str(tmpdir / 'logs') (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) cbks = [ callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.5, patience=4, verbose=1), callbacks.TensorBoard( log_dir=filepath)] model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=2) assert os.path.isdir(filepath) shutil.rmtree(filepath) assert not tmpdir.listdir()
def ann(self): #print self.company.X_train.shape[1] model = Sequential() model.add(Dense(input_dim=self.search_inputs.X_train.shape[1], output_dim=10, init="glorot_uniform")) model.add(Activation('tanh')) model.add(Dropout(0.1)) model.add(Dense(input_dim=10, output_dim=10, init="uniform")) model.add(Activation('tanh')) model.add(Dropout(0.5)) model.add(Dense(input_dim=10, output_dim=1, init="glorot_uniform")) model.add(Activation("linear")) sgd = SGD(lr=0.3, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='mean_squared_error', optimizer='sgd') early_stopping = EarlyStopping(monitor='val_loss', patience=25) #epoch_score = model.evaluate(X_score, y_score, batch_size = 16) # this doesn't work # first model print "fitting first model" model.fit(self.search_inputs.X_train, self.search_inputs.y_train, nb_epoch=100, validation_split=.1, batch_size=100, verbose = 1, show_accuracy = True, shuffle = True, callbacks=[early_stopping]) #score = model.evaluate(self.company.X_cv, self.company.y_cv, show_accuracy=True, batch_size=16) self.ann_preds = model.predict(self.search_inputs.X_test) #just in case (like w/ svr) for i in range(0,len(self.ann_preds) - 1): if self.ann_preds[i] < 1: self.ann_preds[i] = 1.00 elif self.ann_preds[i] > 3: self.ann_preds[i] = 3.00 self.search_inputs.fin_df['relevance'] = np.array(self.ann_preds) # easy swap in / out final_file_ann = self.search_inputs.fin_df.to_csv(self.fin_file_name+'_ann.csv', float_format='%.5f', index=False)
def test_EarlyStopping(): np.random.seed(1337) (X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples, num_test=test_samples, input_shape=(input_dim,), classification=True, num_classes=num_class) y_test = np_utils.to_categorical(y_test) y_train = np_utils.to_categorical(y_train) model = Sequential() model.add(Dense(num_hidden, input_dim=input_dim, activation='relu')) model.add(Dense(num_class, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) mode = 'max' monitor = 'val_acc' patience = 0 cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)] history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20) mode = 'auto' monitor = 'val_acc' patience = 2 cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)] history = model.fit(X_train, y_train, batch_size=batch_size, validation_data=(X_test, y_test), callbacks=cbks, epochs=20)
def model(X_train, Y_train, X_test, Y_test): ''' Model providing function: Create Keras model with double curly brackets dropped-in as needed. Return value has to be a valid python dictionary with two customary keys: - loss: Specify a numeric evaluation metric to be minimized - status: Just use STATUS_OK and see hyperopt documentation if not feasible The last one is optional, though recommended, namely: - model: specify the model just created so that we can later use it again. ''' model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) model.fit(X_train, Y_train, batch_size={{choice([64, 128])}}, nb_epoch=1, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def train_rnn(character_corpus, seq_len, train_test_split_ratio): model = Sequential() model.add(Embedding(character_corpus.char_num(), 256)) model.add(LSTM(256, 5120, activation='sigmoid', inner_activation='hard_sigmoid', return_sequences=True)) model.add(Dropout(0.5)) model.add(TimeDistributedDense(5120, character_corpus.char_num())) model.add(Activation('time_distributed_softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') seq_X, seq_Y = character_corpus.make_sequences(seq_len) print "Sequences are made" train_seq_num = train_test_split_ratio*seq_X.shape[0] X_train = seq_X[:train_seq_num] Y_train = to_time_distributed_categorical(seq_Y[:train_seq_num], character_corpus.char_num()) X_test = seq_X[train_seq_num:] Y_test = to_time_distributed_categorical(seq_Y[train_seq_num:], character_corpus.char_num()) print "Begin train model" checkpointer = ModelCheckpoint(filepath="model.step", verbose=1, save_best_only=True) model.fit(X_train, Y_train, batch_size=256, nb_epoch=100, verbose=2, validation_data=(X_test, Y_test), callbacks=[checkpointer]) print "Model is trained" score = model.evaluate(X_test, Y_test, batch_size=512) print "valid score = ", score return model
def get_ts_model( trainX, trainY, look_back = 1, nb_epochs = 100 ): model = Sequential() # takes input array of shape (*, 1) where (2,1) - (row,col) array example looks like [23] # [43] model.add(LSTM(20, input_shape=(None , look_back) )) #model.add(LSTM(20, batch_input_shape=(None, None, look_back), return_sequences= True )) #print(model.summary) model.add( Dense(1) ) model.add(Dense(1)) model.add(Dense(1)) model.add(Dense(1)) model.add(Dense(1)) model.add(Dense(1)) #model.add(LSTM(1, return_sequences= True)) #model.add(LSTM(1)) # outputs array of shape (*,1) #model.add(Dense(1)) #model.compile(loss='mean_absolute_error', optimizer='SGD') # mape #model.compile(loss='poisson', optimizer='adam') # mape model.compile( loss = 'mean_squared_error', optimizer = 'adam' ) # values closer to zero are better. #model.compile(loss='mean_squared_error', optimizer='adagrad') # Values of MSE are used for comparative purposes of two or more statistical meythods. Heavily weight outliers, i.e weighs large errors more heavily than the small ones. # "In cases where this is undesired, mean absolute error is used. # REF: Available loss functions https://keras.io/objectives. print('Start : Training model') # default configuration model.fit(trainX, trainY, nb_epoch=nb_epochs, batch_size=1, verbose=2) #model.fit(trainX, trainY, nb_epoch=100, batch_size=1, verbose=2) print('Ends : Training Model') return model
def create_model(x_train, y_train, x_test, y_test): """ Create your model... """ layer_1_size = {{quniform(12, 256, 4)}} l1_dropout = {{uniform(0.001, 0.7)}} params = { 'l1_size': layer_1_size, 'l1_dropout': l1_dropout } num_classes = 10 model = Sequential() model.add(Dense(int(layer_1_size), activation='relu')) model.add(Dropout(l1_dropout)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=128, epochs=10, validation_data=(x_test, y_test)) score, acc = model.evaluate(x_test, y_test, verbose=0) out = { 'loss': -acc, 'score': score, 'status': STATUS_OK, 'model_params': params, } # optionally store a dump of your model here so you can get it from the database later temp_name = tempfile.gettempdir()+'/'+next(tempfile._get_candidate_names()) + '.h5' model.save(temp_name) with open(temp_name, 'rb') as infile: model_bytes = infile.read() out['model_serial'] = model_bytes return out
def runNN(train_X, train_y, test_X, test_y=None): #sc = preprocessing.StandardScaler() #train_X = sc.fit_transform(train_X) #test_X = sc.transform(test_X) train_y = np_utils.to_categorical(train_y, 2) model = Sequential() model.add(Dense(train_X.shape[1], 100, init='he_uniform')) model.add(Activation('relu')) model.add(Dropout(0.2)) model.add(Dense(100, 50, init='he_uniform')) model.add(Activation('relu')) model.add(Dropout(0.4)) model.add(Dense(50, 25, init='he_uniform')) model.add(Activation('relu')) model.add(Dropout(0.4)) model.add(Dense(25, 2, init='he_uniform')) model.add(Activation('softmax')) #sgd_opt = SGD(lr=0.01) model.compile(loss='binary_crossentropy', optimizer='adam') model.fit(train_X, train_y, batch_size=256, nb_epoch=50, validation_split=0.05, verbose=2) preds = model.predict(test_X, verbose=0)[:,1] print preds[:10] print "Test preds shape : ",preds.shape print "ROC AUC score : ", metrics.roc_auc_score(test_y, preds)
def train(): print('Build model...') model = Sequential() model.add(Embedding(max_features, 128, input_length=maxlen, dropout=0.2)) model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2)) # try using a GRU instead, for fun model.add(Dense(1)) model.add(Activation('sigmoid')) # try using different optimizers and different optimizer configs model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print('Train...') print(X_train.shape) print(y_train.shape) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=15, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc) with open("save_weight_lstm.pickle", mode="wb") as f: pickle.dump(model.get_weights(),f)
def model(X_train, Y_train, X_test, Y_test): from keras.models import Sequential from keras.layers.core import Dense, Dropout, Activation from keras.optimizers import RMSprop model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms) model.fit(X_train, Y_train, batch_size={{choice([64, 128])}}, nb_epoch=1, show_accuracy=True, verbose=2, validation_data=(X_test, Y_test)) score = model.evaluate(X_test, Y_test, show_accuracy=True, verbose=0) print('Test accuracy:', score[1]) return {'loss': -score[1], 'status': STATUS_OK}
def main(): train_X = np.load('train_X.npy') train_y = np.load('train_y.npy') test_X = np.load('test_X.npy') test_y = np.load('test_y.npy') model = Sequential() model.add(Flatten(input_shape=(15,60,2))) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(900)) model.add(Activation('sigmoid')) print model.summary() adam = Adam(0.001) #adagrad = Adagrad(lr=0.01) model.compile(loss='mse', optimizer=adam) model.fit(train_X, train_y, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(test_X, test_y)) model.save_weights('model.h5', overwrite=True)
def OptKeras(h1, h2, h3, d1, d2, d3, d4, ne): model = Sequential() model.add(Dense(dims, h1, init='glorot_uniform')) model.add(PReLU((h1,))) model.add(BatchNormalization((h1,))) model.add(Dropout(d1)) model.add(Dense(h1, h2, init='glorot_uniform')) model.add(PReLU((h2,))) model.add(BatchNormalization((h2,))) model.add(Dropout(d2)) model.add(Dense(h2, h3, init='glorot_uniform')) model.add(PReLU((h3,))) model.add(BatchNormalization((h3,))) model.add(Dropout(d3)) model.add(Dense(h3, nb_classes, init='glorot_uniform')) model.add(Activation('softmax')) sgd = SGD(lr = 0.1, decay = 1e-6, momentum = 0.9, nesterov = True) model.compile(loss='categorical_crossentropy', optimizer=sgd) print("Training model...kkk") model.fit(X, y, nb_epoch = ne, batch_size=1024, validation_split=0.2)
class MotifScoreRNN(Model): def __init__(self, input_shape, gru_size=10, tdd_size=4): self.model = Sequential() self.model.add(GRU(gru_size, return_sequences=True, input_shape=input_shape)) if tdd_size is not None: self.model.add(TimeDistributedDense(tdd_size)) self.model.add(Flatten()) self.model.add(Dense(1)) self.model.add(Activation('sigmoid')) print('Compiling model...') self.model.compile(optimizer='adam', loss='binary_crossentropy') def train(self, X, y, validation_data): print('Training model...') multitask = y.shape[1] > 1 if not multitask: num_positives = y.sum() num_sequences = len(y) num_negatives = num_sequences - num_positives self.model.fit( X, y, batch_size=128, nb_epoch=100, validation_data=validation_data, class_weight={True: num_sequences / num_positives, False: num_sequences / num_negatives} if not multitask else None, callbacks=[EarlyStopping(monitor='val_loss', patience=10)], verbose=True) def predict(self, X): return self.model.predict(X, batch_size=128, verbose=False)
def f_nn(params): from keras.models import Sequential from keras.layers.core import Dense, Dropout, Activation from keras.optimizers import Adadelta, Adam, rmsprop print ('Params testing: ', params) model = Sequential() model.add(Dense(output_dim=params['units1'], input_dim = X.shape[1])) model.add(Activation(params['activation1'])) model.add(Dropout(params['dropout1'])) model.add(Dense(output_dim=params['units2'], init = "glorot_uniform")) model.add(Activation(params['activation2'])) model.add(Dropout(params['dropout2'])) if params['choice']['layers']== 'three': model.add(Dense(output_dim=params['choice']['units3'], init = "glorot_uniform")) model.add(Activation(params['choice']['activation3'])) model.add(Dropout(params['choice']['dropout3'])) model.add(Dense(2)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer=params['optimizer']) model.fit(X, y, nb_epoch=params['nb_epochs'], batch_size=params['batch_size'], verbose = 1) pred_auc =model.predict_proba(X_val, batch_size = 128, verbose = 1) acc = log_loss(y_val, pred_auc) print("\n") print('logloss:', acc) sys.stdout.flush() return {'loss': acc, 'status': STATUS_OK}
def evaluate(lr, pos): (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = (X_train.astype("float32")).reshape((60000, 784)) X_test = (X_test.astype("float32")).reshape((10000, 784)) X_train /= 255 X_test /= 255 Y_train = np_utils.to_categorical(y_train, 10) Y_test = np_utils.to_categorical(y_test, 10) model = Sequential() model.add(Dense(output_dim=layer1, input_dim=784)) if pos == 0: model.add(BatchNormalization()) model.add(Activation("relu")) model.add(Dense(output_dim=layer2, input_dim=layer1)) if pos == 1: model.add(BatchNormalization()) model.add(Activation("relu")) model.add(Dense(output_dim=10, input_dim=layer2)) if pos == 2: model.add(BatchNormalization()) model.add(Activation("softmax")) model.compile( loss="categorical_crossentropy", optimizer=SGD(lr=lr, momentum=0.9, nesterov=True), metrics=["accuracy"] ) model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=(X_test, Y_test)) score = model.evaluate(X_test, Y_test, verbose=0) return score[1]
def model(X_train, X_test, Y_train, Y_test): model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([400, 512, 600])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) nb_epoch = 10 batch_size = 128 model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def imdb_lstm(): max_features = 20000 maxlen = 80 # cut texts after this number of words (among top max_features most common words) batch_size = 32 (X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=max_features) print type(X_train) exit(0) print len(X_train), 'train sequences' print len(X_test), 'test sequences' print('Pad sequences (samples x time)') X_train = sequence.pad_sequences(X_train, maxlen=maxlen) X_test = sequence.pad_sequences(X_test, maxlen=maxlen) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape) print('Build model...') model = Sequential() model.add(Embedding(max_features, 128, dropout=0.2)) model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2)) # try using a GRU instead, for fun model.add(Dense(1)) model.add(Activation('sigmoid')) # try using different optimizers and different optimizer configs model.compile(loss='binary_crossentropy', optimizer='adam',metrics=['accuracy']) print('Train...') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=15, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc)
class MLP: ''' [(output_dim, input_dim, init, activation, dropout)] ''' def __init__(self\ , structure\ , sgd_params_init = sgd_params(0.1,1e-6,0.9,True)\ , loss_name = 'mean_squared_error'): self.model = Sequential() for layers in structure: self.model.add(Dense(output_dim = layers.output_dim\ , input_dim = layers.input_dim\ , init = layers.init\ , activation = layers.activation)) if layers.dropout != None: self.model.add(Dropout(layers.dropout)) sgd = SGD(lr = sgd_params_init.lr\ , decay = sgd_params_init.decay\ , momentum = sgd_params_init.momentum\ , nesterov = sgd_params_init.nesterov) self.model.compile(loss = loss_name, optimizer = sgd) def train(self, X_train, y_train, nb_epoch = 20, batch_size = 16): self.model.fit(X_train, y_train, nb.epoch, batch_size) def test(self, X_test, y_test, batch_size = 16): return self.model.evaluate(X_test, y_test, batch_size)
def train_the_nn(features, label, look_back = 1): model = Sequential() model.add(Dense(8, input_dim=look_back, activation='relu')) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer = 'adam') model.fit(features, label, nb_epoch=200, batch_size=2, verbose=2) return model
def generateModel(self,docSeries): topics = docSeries.topicSeries.keys() seriesLength = 50 sequenceTuples = [] for j in range(len(topics)): topic = topics[j] topicLength = len(docSeries.topicSeries[topic]) for i in range(0,topicLength): if i+seriesLength < topicLength: sequenceTuples.append((docSeries.topicSeries[topic][i:i+seriesLength],j)) random.shuffle(sequenceTuples) X = [] y = [] for s,l in sequenceTuples: X.append(s) y.append(l) X = np.array(X).astype(np.uint8) y = np_utils.to_categorical(np.array(y)).astype(np.bool) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1) print len(X_train),len(y_train) print X.shape,y.shape model = Sequential() model.add(Embedding(50, 64, input_length = seriesLength, mask_zero = True)) model.add(LSTM(64,init='glorot_uniform',inner_init='orthogonal',activation='tanh',inner_activation='hard_sigmoid',return_sequences=False)) model.add(Dropout(0.5)) model.add(Dense(len(topics))) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', class_mode='categorical') early_stopping = EarlyStopping(patience=5, verbose=1) model.fit(X_train, y_train,nb_epoch=20,show_accuracy=True,verbose=1,shuffle=True) preds = model.predict_classes(X_test, batch_size=64, verbose=0) print '\n' print(classification_report(np.argmax(y_test, axis=1), preds, target_names=topics))
def trainNN(): # POSITIVE training data posPX, posSX = getAllWindowedMinMaxPositiveTrainingData('./sample/example30', preSize=10, postSize=20) posPY = np.array([[1]] * len(posPX)) posSY = np.array([[1]] * len(posSX)) # NEGATIVE training data negX = getSomeWindowedMinMaxNegativeTrainingData('./sample/example30/', size=30, num=200) negY = np.array([[0]] * 200) # ALL training data X = np.concatenate([posPX, posSX, negX]) Y = np.concatenate([posPY, posSY, negY]) # 使用keras创建神经网络 # Sequential是指一层层堆叠的神经网络 # Dense是指全连接层 # 定义model model = Sequential() model.add(Dense(50, input_dim=30, activation='sigmoid')) model.add(Dense(50, activation='sigmoid')) model.add(Dense(10, activation='sigmoid')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) # model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) model.fit(X, Y, epochs=200, batch_size=32) model.save('model.h5') return model
def CNN_3_layer(activation): Xtrain, ytrain, XCV, yCV, Xtest, ytest = load_data("mnist.pkl.gz") Xtrain = Xtrain.reshape(Xtrain.shape[0], 1, 28, 28) Xtest = Xtest.reshape(Xtest.shape[0], 1, 28, 28) XCV = Xtest.reshape(XCV.shape[0], 1, 28, 28) # 0~9 ten classes ytrain = np_utils.to_categorical(ytrain, 10) ytest = np_utils.to_categorical(ytest, 10) yCV = np_utils.to_categorical(yCV, 10) # Build the model model = Sequential() model.add(Convolution2D(32,3,3,border_mode='valid',input_shape=(1,28,28))) model.add(Activation(activation)) model.add(Convolution2D(32,3,3)) model.add(Activation(activation)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(16,3,3)) model.add(Activation(activation)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128)) model.add(Activation(activation)) model.add(Dropout(0.5)) model.add(Dense(10)) model.add(Activation('softmax')) # fit module print "fit module" model.compile(loss='categorical_crossentropy',optimizer='adadelta',metrics=['accuracy']) model.fit(Xtrain,ytrain,batch_size=100,nb_epoch=20,verbose=1,validation_data=(XCV,yCV)) score = model.evaluate(Xtest,ytest, verbose=0) print score[0] print score[1]
def trainModel(): inputs, correctOutputs = getNNData() print("Collected data") trainingInputs = inputs[:len(inputs)//2] trainingOutputs = correctOutputs[:len(correctOutputs)//2] testInputs = inputs[len(inputs)//2:] testOutputs = correctOutputs[len(correctOutputs)//2:] model = Sequential() model.add(Dense(24, input_shape=(24, ))) model.add(Activation('tanh')) model.add(Dense(24)) model.add(Activation('tanh')) model.add(Dense(5)) model.add(Activation('softmax')) model.summary() model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)) model.fit(trainingInputs, trainingOutputs, validation_data=(testInputs, testOutputs)) score = model.evaluate(testInputs, testOutputs, verbose=0) print(score) json_string = model.to_json() open('my_model_architecture.json', 'w').write(json_string) model.save_weights('my_model_weights.h5', overwrite=True)
def model(X_train, X_test, y_train, y_test, max_features, maxlen): model = Sequential() model.add(Embedding(max_features, 128, input_length=maxlen)) model.add(LSTM(128)) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) early_stopping = EarlyStopping(monitor='val_loss', patience=4) checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5', verbose=1, save_best_only=True) model.fit(X_train, y_train, batch_size={{choice([32, 64, 128])}}, nb_epoch=1, validation_split=0.08, callbacks=[early_stopping, checkpointer]) score, acc = model.evaluate(X_test, y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
store.append(b) trainX1 = numpy.array(trainX) testX1 = numpy.array(testX) trainY1 = numpy.array(trainY) testY1 = numpy.array(testY) store = numpy.array(store) ### reshape input to be [samples, time steps, features] trainX1 = numpy.reshape(trainX1, (trainX1.shape[0], 1, trainX1.shape[1])) testX1 = numpy.reshape(testX1, (testX1.shape[0], 1, testX1.shape[1])) ### create and fit the LSTM network model.fit(trainX1, trainY1, epochs=100, batch_size=50, verbose=2) ### make predictions model.save('models/model_weights_' + prefix_st + '.h5') print(i) trainPredict = predict_from_saved_model(trainX1) testPredict = predict_from_saved_model(testX1) p = [testY1[-1]] q = testPredict[-1][0] data.append([q]) trainPredict = scaler.inverse_transform(trainPredict) trainY1 = scaler.inverse_transform([trainY1]) testPredict = scaler.inverse_transform(testPredict) testY1 = scaler.inverse_transform([testY1])
#Train test split. X_tr, X_val, y_tr, y_val = train_test_split(x, y, test_size=0.2, random_state=63) """Step-5:Building the SimpleRNN, LSTM, GRU models.""" #Define SimpleRNN model. SimpleRNN_model = Sequential() SimpleRNN_model.add(Embedding(vocab, 50, input_length=length-1, trainable=True)) SimpleRNN_model.add(SimpleRNN(150, recurrent_dropout=0.1, dropout=0.1)) SimpleRNN_model.add(Dense(vocab, activation='softmax')) print(SimpleRNN_model.summary()) #Compile the SimpleRNN model. SimpleRNN_model.compile(loss='categorical_crossentropy', metrics=['acc'], optimizer='adam') SimpleRNN_model.fit(X_tr, y_tr, epochs=20, verbose=2, validation_data=(X_val, y_val)) #Define LSTM model. LSTM_model = Sequential() LSTM_model.add(Embedding(vocab, 50, input_length=length-1, trainable=True)) LSTM_model.add(LSTM(150, recurrent_dropout=0.1, dropout=0.1)) LSTM_model.add(Dense(vocab, activation='softmax')) print(LSTM_model.summary()) #Compile the LSTM model. LSTM_model.compile(loss='categorical_crossentropy', metrics=['acc'], optimizer='adam') LSTM_model.fit(X_tr, y_tr, epochs=100, verbose=2, validation_data=(X_val, y_val)) #Define GRU model. GRU_model = Sequential() GRU_model.add(Embedding(vocab, 50, input_length=length-1, trainable=True))
# posa steps istorikou krataei, dld gia eisodo x[0:lookback-1] provlepei thn eksodo x[lookback] look_back = 10 # posa steps tha kanw prediction next_pred = 30 trainX, trainY = create_dataset(train, look_back) testX, testY = create_dataset(test, look_back) trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1])) # model model = Sequential() model.add(LSTM(10, input_shape=(1, look_back))) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) model.fit(trainX, trainY, epochs=10, batch_size=1, verbose=2) # save model model.save('STOCK-LSTM.h5') # make predictions trainPredict = model.predict(trainX) print("trainX shape ",trainX.shape,"\ntrainPredict ",trainPredict.shape,"\ndataset ",dateset.shape) testPredict = model.predict(testX) # invert predictions trainPredict = scaler.inverse_transform(trainPredict) trainY = scaler.inverse_transform([trainY]) testPredict = scaler.inverse_transform(testPredict) testY = scaler.inverse_transform([testY]) # calculate root mean squared error trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0])) print('Train Score: %.2f MSE' % (trainScore))
# 딥러닝 텐서플로 케라스 교재 201p model.save('./model/sample/mnist/model_mnist.h5') # 훈련 from keras.callbacks import EarlyStopping, ModelCheckpoint early_stopping = EarlyStopping( monitor='loss', patience= 100, mode ='auto') model.compile(loss = 'categorical_crossentropy', optimizer='rmsprop', metrics = ['acc']) modelpath = './model/sample/mnist{epoch:02d} - {val_loss: .4f}.hdf5' checkpoint = ModelCheckpoint(filepath= modelpath, monitor= 'val_loss', save_best_only = True, save_weights_only= False, verbose=1) model.fit(x_train,y_train, epochs= 15, batch_size= 120, validation_split= 0.25 ,callbacks= [early_stopping,checkpoint]) model.save_weights('./model/sample/mnist/mnist_weight1.h5') # 평가 및 예측 loss, acc = model.evaluate(x_test,y_test, batch_size=1) print('loss :', loss) print('accuracy : ', acc)
class Network: def __init__(self, recall=True): if recall: self.model = load_model(RecallFile) else: self.model = Sequential() self.model.add(Dense(15, input_dim=14, activation='sigmoid')) self.model.add(Dense(30, activation='sigmoid')) self.model.add(Dense(10, activation='sigmoid')) self.model.add(Dense(3, activation='softmax')) self.model.compile(loss='binary_crossentropy', optimizer='nadam') def testOnData(self, data, tp): # Expects inputs + outputs total = len(data[0]) correct = 0 predictions = self.predict(data[0]).tolist() # print(data[0].tolist()) # print(predictions) if tp == 'pricelow': # Convert to 0s and 1s for analysis (PRICELOW) for s in range(len(predictions)): biggest = [0, 0] for value in predictions[s]: if value > biggest[0]: biggest[0] = value biggest[1] = predictions[s].index(value) output = [0, 0, 0] output[biggest[1]] = 1 predictions[s] = output if tp == 'airline': output = [0, 0, 0] # print(predictions) for s in range(len(predictions) ): # Convert to 0s and 1s for analysis (AIRLINE) for value in predictions[s]: if value >= 0.4: predictions[s][predictions[s].index(value)] = 1 else: predictions[s][predictions[s].index(value)] = 0 # print(predictions) # print(data[1].tolist()) for s in range(len(predictions)): if predictions[s] == data[1][s].tolist(): correct += 1 return [correct, total] def train(self, inputs, outputs): self.model.fit(inputs, outputs, nb_epoch=epochs) def predict(self, inputs): return self.model.predict(inputs) def saveModel(self): self.model.save(RecallFile)
# Adding the second hidden layer # classifier.add(Dense(output_dim=5, init='uniform', activation='relu')) # Adding the output layer classifier.add(Dense(output_dim=1, init='uniform', activation='relu')) # Compiling Neural Network classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # ------------------------------Training and Evaluation----------------------------------------------- # # split data into train-set and test-set kfold = RepeatedStratifiedKFold(n_splits=5, n_repeats=5) # kfold = StratifiedKFold(n_splits=5, shuffle=True) f1_measures = [] for train_set, test_set in kfold.split(X, y): # fitting our model classifier.fit(X[train_set], y[train_set], batch_size=15, epochs=50, verbose=0) # evaluate the model # 1. predicting the test set results y_pred = classifier.predict(X[test_set]) y_pred = (y_pred > 0.5).astype(int) # 2. calculate f1 measure: F1 = 2 * (precision * recall) / (precision + recall) f1_measures.append(f1_score(y_true=y[test_set], y_pred=y_pred)) print(np.mean(f1_measures))
y = array([4,5,6,7,8,9,10,11,12,13,50,60,70]) x = x.reshape(x.shape[0],x.shape[1],1) model = Sequential() model.add(LSTM(20,activation='relu',input_shape=(3,1))) model.add(Dense(100)) model.add(Dropout(0.2)) model.add(BatchNormalization()) model.add(Dense(100)) model.add(Dense(100)) model.add(Dense(100)) model.add(Dense(100)) model.add(Dense(100)) model.add(Dense(5)) model.add(Dense(1)) model.summary() #3.훈련 model.compile(loss ='mse', optimizer ='adam', metrics=['mse']) from keras.callbacks import EarlyStopping early_stopping = EarlyStopping(monitor='loss', patience=20, mode='auto') model.fit(x,y,epochs=1000,batch_size=1,verbose=1,callbacks=[early_stopping]) loss, mae = model.evaluate(x,y,batch_size=1) print(loss,mae) x_input = array([[6.5,7.5,8.5],[50,60,70],[70,80,90],[100,110,120]]) x_input = x_input.reshape(x_input.shape[0],x_input.shape[1],1) y_predict = model.predict(x_input) print(y_predict)
# Initialising the ANN classifier = Sequential() # Adding the input layer and the first hidden layer classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim =11 )) # Adding the second hidden layer classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu')) # Adding the output layer classifier.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid')) # Compiling the ANN classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) # Fitting the ANN to the Training set classifier.fit(X_train, y_train, batch_size =10 , epochs =20 ) # Part 3 - Making predictions and evaluating the model # Predicting the Test set results y_pred = classifier.predict(X_test) y_pred = (y_pred >0.5 ) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred)
model.summary() # Use early stopping to find the best model BEST_MODEL_FILEPATH="best_model" # Define early stopping based on validation loss # If three iterations in a row, validation loss is not improved compared with the previous one, stop training # Mode='min' indicate the loss needs to decrease earlyStopping=EarlyStopping(monitor='val_loss', patience=3, verbose=2, mode='min') # Define checkpoint to save best model which has max. validation acc checkpoint = ModelCheckpoint(BEST_MODEL_FILEPATH, monitor='val_acc', verbose=2, save_best_only=True, mode='max') # Fit model training = model.fit(X_train, y_train, shuffle = True, epochs = 1000, batch_size = 36, callbacks=[earlyStopping, checkpoint], validation_data=[X_test, y_test], verbose = 2) # In[4]: # Covert the fitting history from dictionary to dataframe history=pd.DataFrame.from_dict(training.history) history.columns=["train_loss", "train_acc", "val_loss", "val_acc"] history.index.name='epoch' #print(history) # Plot fitting history fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8,3)); history[["train_acc", "val_acc"]].plot(ax=axes[0]);
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1] * X_train.shape[2]).astype(float) X_test = X_test.reshape(X_test.shape[0], X_test.shape[1] * X_test.shape[2]).astype(float) #To make pixel value ranges between [0, 1] as asked in the assignment, also improves the performance of the ANN X_train/=255.0 X_test/=255.0 y_train = keras.utils.to_categorical(y_train, num_classes=num_classes) y_test = keras.utils.to_categorical(y_test, num_classes=num_classes) model = Sequential() model.add(Dense(20, input_dim=X_train.shape[1], activation='sigmoid')) model.add(Dense(num_classes, activation='softmax')) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(x=X_train, y=y_train, batch_size=batch_size, validation_split=0.2, epochs=epochs, verbose=1) plt.figure() plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('Model Accuracy') plt.ylabel('Accuracy') plt.xlabel('Number of Epochs') plt.legend(['Train Accuracy', 'Test Accuracy'], loc='upper left') plt.savefig('Accuracy.png') plt.close() plt.figure() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('Model Loss')
def modelling(task_no,train_input,test_input,hidden_nodes,number_epoch): n_hidden = hidden_nodes nb_classes = 784 optimizer = 'RMSprop' # optimizer = SGD(lr=0.001) loss = 'mean_squared_error' metrics = ['accuracy'] batch_size = 128 nb_epoch = number_epoch if task_no in ['4','5']: #laoding model json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model.h5") print("Loaded model from disk") loaded_model.compile(loss=loss, optimizer=optimizer, metrics=metrics) else: #initializing model # input_img = Input(shape=(784,)) # hidden_output = Dense(n_hidden, activation='relu')(input_img) # final_output = Dense(nb_classes, activation='linear')(hidden_output) # model = Model(input=input_img, output=final_output) # model.compile(loss=loss, optimizer=optimizer, metrics=metrics) model = Sequential() model.add(Dense(n_hidden, input_shape=(784,), activation='relu')) model.add(Dense(nb_classes, activation='linear')) model.compile(loss=loss, optimizer=optimizer, metrics=metrics) #In all tasks as the target and input is the same we are passing input at both the places if task_no == '1': #task1 history = model.fit(train_input,train_input, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(test_input, test_input), shuffle=True) return history elif task_no == '2': #task2 history = model.fit(train_input,train_input, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(test_input, test_input), shuffle=True) train_score = model.evaluate(train_input, train_input, verbose=1) test_score = model.evaluate(test_input, test_input, verbose=1) return [train_score[0],test_score[0]] elif task_no == '3': #task3 history = model.fit(train_input,train_input, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, shuffle=True) #saving mdoel to json file model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 model.save_weights("model.h5") print("Saved model to disk") weights, biases = model.layers[0].get_weights() return weights elif task_no in ['4','5']: #task4 output = loaded_model.predict(test_input) return output
# 序列反转 x_train = [x[::-1] for x in x_train] x_test = [x[::-1] for x in x_test] # 填充序列 x_train = sequence.pad_sequences(x_train, maxlen=maxlen) x_test = sequence.pad_sequences(x_test, maxlen=maxlen) model = Sequential() model.add(layers.Embedding(max_feature, 32)) model.add(layers.Bidirectional(layers.LSTM(32))) model.add(layers.Dense(1, activation='sigmoid')) model.compile( optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'] ) history = model.fit( x_train, y_train, epochs=10, batch_size=128, validation_split=0.2 ) loss = history.history['loss'] val_loss = history.history['val_loss'] epochs = range(1, len(loss)+1) plt.figure() plt.plot(epochs, loss, 'bo', label='Training loss') plt.plot(epochs, val_loss, 'b', label='Validation loss') plt.title('Training and validation loss') plt.legend() plt.show()
def model_train(): datasets = 'datasets' (images, labels, names, label) = ([], [], [], 0) for (subdirs, dirs, files) in os.walk(datasets): for subdir in dirs: if subdir == '.DS_Store': continue names.append(subdir) subjectpath = os.path.join(datasets, subdir) print('subjectpath',subjectpath) for filename in os.listdir(subjectpath): if filename == '.DS_Store': continue path = subjectpath + '/' + filename print('Path',path) imgRead = load_img(path,target_size = (64,64)) imgRead = img_to_array(imgRead) images.append(imgRead) labels.append(int(label)) print(label) label += 1 print(labels) print(np.shape(images)) print(np.shape(labels)) print(names) (width, height) = (130, 100) # Create a Numpy array from the two lists above (images, labels) = [np.array(lis) for lis in [images, labels]] # OpenCV trains a model from the images # NOTE FOR OpenCV2: remove '.face' X_train = np.array(images) Y_train = np.array(labels) nb_classes = label Y_train = to_categorical(Y_train, nb_classes) # Y_test = to_categorical(Y_test, nb_classes) input_shape = (64, 64, 3) X_train = X_train.astype('float32') X_train /= 255 # BUILD THE MODEL model = Sequential() model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape=input_shape)) model.add(Activation('relu')) model.add(Convolution2D(32, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Convolution2D(64, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Convolution2D(64, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) # TRAIN THE MODEL adam = Adam(lr=0.0001) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy']) print(model.summary()) model.fit(X_train, Y_train, batch_size=5, epochs=30, verbose=1) model.save('models/model.h5') print("saved the model ______________") pickle.dump(names, open("models/list.pkl", "wb")) print("saved the PKL PKL ______________")
def run_lstm(Xtr, Xte, ytr, yte, max_features, max_features2, out_size, embedding_size, hidden_size, batch_size, epochs=50, verbose=0, maxsent=0): print('Training and testing tensor shapes:', Xtr.shape, Xte.shape, ytr.shape, yte.shape) mf = max(max_features, max_features2) model1 = Sequential() model1.add( Embedding(input_dim=mf, output_dim=embedding_size, input_length=maxsent, mask_zero=True)) model2 = Sequential() model2.add(InputLayer(input_shape=(maxsent, Xtr.shape[2] - 1))) model = Sequential() model.add(Merge([model1, model2], mode='concat')) model.add(Dense(1)) model.add( LSTM(hidden_size, return_sequences=True, input_shape=(maxsent, Xtr.shape[2] - 1))) model.add(TimeDistributed(Dense(out_size))) model.add(Activation('softmax')) print 'compile...' model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #print(model.summary()) print('train...') model.fit([Xtr[:, :, 0], Xtr[:, :, 1:Xtr.shape[2]]], ytr, epochs=epochs, verbose=verbose, batch_size=batch_size, validation_data=([Xte[:, :, 0], Xte[:, :, 1:Xtr.shape[2]]], yte)) score = model.evaluate([Xte[:, :, 0], Xte[:, :, 1:Xtr.shape[2]]], yte, batch_size=batch_size, verbose=verbose) print('Raw test score:', score) pr = model.predict_classes([Xtr[:, :, 0], Xtr[:, :, 1:Xtr.shape[2]]], verbose=verbose) yh = ytr.argmax(2) # no encoding fyh, fpr = score2(yh, pr) print('Training...') print(' - accuracy:', accuracy_score(fyh, fpr)) print(' - confusion matrix:') print(confusion_matrix(fyh, fpr)) print(' - precision, recall, f1, support:') print precision_recall_fscore_support(fyh, fpr) pr = model.predict_classes([Xte[:, :, 0], Xte[:, :, 1:Xte.shape[2]]], verbose=verbose) yh = yte.argmax(2) fyh, fpr = score2(yh, pr) print('Testing...') print(' - accuracy:', accuracy_score(fyh, fpr)) print(' - confusion matrix:') print(confusion_matrix(fyh, fpr)) print(' - precision, recall, f1, support:') print precision_recall_fscore_support(fyh, fpr) print( '----------------------------------------------------------------------------------' )
df = df_pre.sample(frac=1) dataset = df.values X = dataset[:,0:12] Y = dataset[:,12] # 모델의 설정 model = Sequential() model.add(Dense(30, input_dim=12, activation='relu')) model.add(Dense(12, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # 모델 컴파일 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # 모델 저장 폴더 설정 MODEL_DIR = './model/' if not os.path.exists(MODEL_DIR): os.mkdir(MODEL_DIR) # 모델 저장 조건 설정 modelpath="./model/{epoch:02d}-{val_loss:.4f}.hdf5" checkpointer = ModelCheckpoint(filepath=modelpath, monitor='val_loss', verbose=1, save_best_only=True) # 모델 실행 및 저장 model.fit(X, Y, validation_split=0.2, epochs=200, batch_size=200, verbose=0, callbacks=[checkpointer])
model.add( Conv2D(32, 3, 3, activation='relu', padding='same', input_shape=(28, 28, 1))) model.add(Conv2D(32, 3, 3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(10, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() model.fit(X_train, y_train, batch_size=32, epochs=10, verbose=1) score = model.evaluate(X_test, y_test, verbose=0) print(score[1]) print(model.predict(X_test[0])) plt.imshow(X_test[0].reshape(28, 28)) plt.show()
# 필요한 라이브러리를 불러옵니다. import numpy as np import tensorflow as tf # 실행할 때마다 같은 결과를 출력하기 위해 설정하는 부분입니다. seed = 0 np.random.seed(seed) tf.set_random_seed(seed) # 준비된 수술 환자 데이터를 불러들입니다. Data_set = np.loadtxt("../dataset/ThoraricSurgery.csv", delimiter=",") # 환자의 기록과 수술 결과를 X와 Y로 구분하여 저장합니다. X = Data_set[:, 0:17] Y = Data_set[:, 17] # 딥러닝 구조를 결정합니다(모델을 설정하고 실행하는 부분입니다). model = Sequential() model.add(Dense(30, input_dim=17, activation='relu')) model.add(Dense(1, activation='sigmoid')) # 딥러닝을 실행합니다. #model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) model.fit(X, Y, epochs=30, batch_size=10) # 결과를 출력합니다. print("\n Accuracy: %.4f" % (model.evaluate(X, Y)[1]))
model.add(Activation('relu')) model.add(Conv2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(NB_CLASSES)) model.add(Activation('softmax')) model.summary() # train model.compile(loss='categorical_crossentropy', optimizer=OPTIM, metrics=['accuracy']) model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=NB_EPOCH, validation_split=VALIDATION_SPLIT, verbose=VERBOSE) score = model.evaluate(X_test, y_test, batch_size=BATCH_SIZE, verbose=VERBOSE) print("test score:", score[0]) print("test accuracy:", score[1]) #save model model_json = model.to_json() model.save_weights('cifar10_weights.h5', overwrite=True)
dataset = loadtxt('/content/AMD_withoutHeaders.csv', delimiter=',') x = dataset[:,0:12] y = dataset[:,12] #model format - models in Keras are defined as a sequence of layers #we will use a Sequential Model and add layers as needed model = Sequential() #model uses dense class for fully connected layers #first argument = # of neurons/nodes, 'activation' argument is the activation function #relu activation function applied for first 2 layers, 8 args, sigmoid last for binary output model.add(Dense(12, input_dim=12, activation='relu')) #input layer, where input_dim = number of input features model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) #compile model using bin_xen for loss fx and adam for stochastic gradient descent fx #adam is an optimization algorithm that tunes itself and gives good results in a wide range of problems model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) #fit model trains or 'fits' our model - training occurs over epochs and each epoch is split into batches #the number of epochs and batch size can be chosen experimentally by trial and error model.fit(x, y, epochs=180, batch_size=10) # after training our NN on the dataset, we will make class predictions with the model predictions = model.predict_classes(x) #summarize the first X cases - the goal is to achieve the lowest loss (0) and highest accuracy (1) possible for i in range(len(x)): print('%s => predicted %d (expected %d)' % (x[i].tolist(), predictions[i], y[i]))
# Adding the second hidden layer classifier.add(Dense(output_dim=15, init='uniform', activation='relu')) classifier.add(Dense(output_dim=10, init='uniform', activation='relu')) # Adding the output layer classifier.add(Dense(output_dim=9, init='uniform', activation='sigmoid')) # Compiling the ANN classifier.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # Convert labels to categorical one-hot encoding # Fitting the ANN to the Training set classifier.fit(X_train, y_train, batch_size=10, nb_epoch=500) # Predicting the Test set results y_pred = classifier.predict(X_test) y_pred_max_index = np.argmax(y_pred, axis=1) y_test_max_index = np.argmax(y_test, axis=1) # testing training set accuracy y_pred_2 = classifier.predict(X_train) y_pred_2_max_index = np.argmax(y_pred_2, axis=1) y_train_max_index = np.argmax(y_train, axis=1) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test_max_index, y_pred_max_index)
def TwoNN_crossval(combinations, train, train_y, test, test_y, dims): #this performs k-fold and evaluates acc_per_fold = [] loss_per_fold = [] reports = [] cf_matrices = [] num_folds = 10 kfold = KFold(n_splits=num_folds) inputs = np.concatenate((train, test), axis=0) targets = np.concatenate((train_y, test_y), axis=0) if len(combinations) == 1: for i in combinations.keys(): a, b, d = i # K-fold Cross Validation model evaluation fold_no = 1 for train, test in kfold.split(inputs, targets): model = Sequential() model.add(Dense(a, input_dim=dims, activation='relu')) model.add(Dense(b)) model.add(Dropout(0.2)) model.add(Activation('relu')) model.add(Dense(6, activation="softmax")) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print('------------------------------------------------------------------------') print(f'Training for fold {fold_no} ...') model.fit(inputs[train], targets[train], epochs=d, batch_size=32, verbose=0) # Generate generalization metrics scores = model.evaluate(inputs[test], targets[test], verbose=0) print( f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1] * 100}%') acc_per_fold.append(scores[1] * 100) loss_per_fold.append(scores[0]) Y = np.argmax(targets[test], axis=1) # here we build the precision/recall/f1 table for each fold y_pred = model.predict_classes(inputs[test]) reports.append(classification_report(Y, y_pred, output_dict=True)) cm = confusion_matrix(Y, y_pred) cm = cm / cm.astype(np.float).sum(axis=1) cf_matrices.append(cm.round(2)) # Increase fold number fold_no += 1 # == Provide average scores == print('------------------------------------------------------------------------') print('Score per fold') f1_report = [] for n in range(0, len(acc_per_fold)): #print('------------------------------------------------------------------------') #print(f'> Fold {n + 1} - Loss: {loss_per_fold[n]} - Accuracy: {acc_per_fold[n]}%') #print('------------------------------------------------------------------------') #print(f'> Per Class Report:\n{reports[n]}') f1_report.append(reports[n]['weighted avg']['f1-score']) print('------------------------------------------------------------------------') print(i) print('Average scores for all folds:') print(f'> Accuracy: {np.mean(acc_per_fold)} (+- {np.std(acc_per_fold)})') print(f'> F1-Score: {np.mean(f1_report).round(3)} (+-{np.std(f1_report).round(3)})') print(f'> Loss: {np.mean(loss_per_fold)}') print(f'> Confusion Matrix:\n{np.nanmean(cf_matrices, axis=0)}') print('------------------------------------------------------------------------') '''to be added if one wants to save the model: model_structure = model.to_json() with open(f"NN_tfidf_{i}.json", "w") as json_file: json_file.write(model_structure) model.save_weights(f"Weights_tfidf_{i}") ''' else: for (neurons, val) in combinations.items(): one_combo = dict() one_combo[neurons] = val TwoNN_crossval(one_combo, train, train_y, test, test_y, dims)
import keras from keras.layers import Dense from keras.models import Sequential from keras.utils import to_categorical # Convert the target to categorical: target target = to_categorical(df.survived) # Set up the model model = Sequential() # Add the first layer model.add(Dense(32, activation = 'relu', input_shape = (n_cols,))) # Add the output layer model.add(Dense(2, activation = 'softmax')) # Compile the model model.compile(optimizer = 'sgd', loss='categorical_crossentropy', metrics = ['accuracy'] ) # Fit the model model.fit(predictors, target) # save model from keras.models import load_model model.save('model_class.h5') model = load_model('model_class.h5') #predictions pred = model.predict(data) #两列,第0列是0的概率,第1列是1的概率
model.add(GRU(50, init=weight_variable, input_shape=(300, n_in))) model.add(BatchNormalization()) model.add(Dense(n_out, init=weight_variable)) model.add(Activation('sigmoid')) optimizer = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999) model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) epochs = 50 batch_size = 10 hist = model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_validation, Y_validation)) ###################### data_save ################################# json_string = model.to_json() open('train_GRU3.json', 'w').write(json_string) model.save_weights("train_GRU3_param.hdf5") model.save_weights("train_GRU3_param.h5") # Accuracy
autoencoder.add( Conv2D(filters=8, kernel_size=(3, 3), activation='relu', padding='same')) autoencoder.add(UpSampling2D(size=(2, 2))) autoencoder.add(Conv2D(filters=16, kernel_size=(3, 3), activation='relu')) autoencoder.add(UpSampling2D(size=(2, 2))) autoencoder.add( Conv2D(filters=1, kernel_size=(3, 3), activation='sigmoid', padding='same')) autoencoder.summary() autoencoder.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) autoencoder.fit(previsores_treinamento, previsores_treinamento, epochs=10, batch_size=256, validation_data=(previsores_teste, previsores_teste)) encoder = Model(inputs=autoencoder.input, outputs=autoencoder.get_layer('flatten_15').output) encoder.summary() imagens_codificadas = encoder.predict(previsores_teste) imagens_decodificadas = autoencoder.predict(previsores_teste) numero_imagens = 10 imagens_teste = np.random.randint(previsores_teste.shape[0], size=numero_imagens) plt.figure(figsize=(18, 18)) for i, indice_imagem in enumerate(imagens_teste):
model.add(Dropout(0.25)) # Adding a fully connected layer and then the output layer model.add(Flatten( )) # weights are being flattened (1D) before passing them to the Dense layer model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) # Final layer has output size of 10, corresponding to 10 digits model.add(Dense(10, activation='softmax')) # Compile the model and declare a loss function model.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy']) # To fit the model we have to declare the batch size and number of epochs to train for, then pass in the training data model.fit(X_train, Y_train, batch_size=32, nb_epoch=10, verbose=1) # Evaluate the model on test data score = model.evaluate(X_test, Y_test, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], score[1] * 100)) # Print the model metrics # serialize model to JSON model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 model.save_weights("model.h5") print("Saved model to disk")
model_adam.add(Dense(256)) model_adam.add(Activation('relu')) model_adam.add(Dense(1)) model_adam.add(Activation('sigmoid')) ''' Setting optimizer as Adam ''' from keras.optimizers import SGD, Adam, RMSprop, Adagrad model_adam.compile(loss='mean_squared_error', optimizer='Adam', metrics=['accuracy']) with tf.device('/gpu:0'): '''Fit models and use validation_split=0.1 ''' history_adam = model_adam.fit(X_train, Y_train, batch_size=batch_size, epochs=nb_epoch, verbose=1, shuffle=True, validation_split=0.1) model_adam.save_weights('cm-weights.hdf5') from sklearn.metrics import confusion_matrix, accuracy_score pred_y = np.sort(model_adam.predict(X_train), axis=0) print(pred_y) from sklearn import preprocessing min_max_scaler = preprocessing.MinMaxScaler() blah_y = min_max_scaler.fit_transform(pred_y).reshape(-1) print(blah_y) np.savetxt("pred_credit.csv", blah_y, delimiter=",")
class nn_new(): def __init__(self, input_data, output_data, hidden_layer_nodes, classification=False, layer_activation='relu ', output_activation='linear', epochs=60, batch_size=10, scale_range=(-1, 1)): self.hidden_layer_nodes = hidden_layer_nodes self.layer_activation = layer_activation if layer_activation in [ 'sigmoid', 'tanh', 'relu', 'elu', 'exponential', 'relu', 'linear', 'softmax', 'softplus', 'softsign' ] else 'relu' self.output_activation = output_activation if output_activation in [ 'sigmoid', 'tanh', 'relu', 'elu', 'exponential', 'relu', 'linear', 'softmax', 'softplus', 'softsign' ] else 'linear' self.classification = classification self.input_scaler = sklearn.preprocessing.MinMaxScaler( feature_range=scale_range) self.input_scaler.fit(input_data) input_data = self.input_scaler.transform(input_data) self.output_scaler = sklearn.preprocessing.MinMaxScaler( feature_range=scale_range) self.output_scaler.fit(output_data) if classification: self.metric = 'accuracy' if output_data.shape[1] > 1: # ASSUMES labels are one hot encoded self.output_activation = "softmax" self.loss = "categorical_crossentropy" else: # ASSUMES labels of 0 or 1 self.output_activation = "sigmoid" self.loss = 'binary_crossentropy' else: output_data = self.output_scaler.transform(output_data) self.metric = "mae" self.loss = "mse" self.model = Sequential() self.model.add( Dense(hidden_layer_nodes[0], input_dim=input_data.shape[1], kernel_initializer=initializers.he_uniform, activation=self.layer_activation)) for i in range(1, len(hidden_layer_nodes) - 1): self.model.add( Dense(hidden_layer_nodes[i], activation=self.layer_activation, kernel_initializer=initializers.he_uniform)) self.model.add( Dense(output_data.shape[1], activation=self.output_activation, kernel_initializer=initializers.he_uniform)) self.model.compile(loss=self.loss, optimizer='adam', metrics=[self.metric]) self.model.fit(input_data, output_data, epochs=epochs, batch_size=batch_size, verbose=2) # _, accuracy = self.model.evaluate(input_data, output_data) # print("Mean average error: ", accuracy) def predict(self, data): data = self.input_scaler.transform(data) unscaled_return = self.model.predict(data) return unscaled_return if self.classification else self.output_scaler.inverse_transform( unscaled_return)
metrics=['accuracy']) #x_train = x_train.astype('float32') #x_test = x_test.astype('float32') #x_train /= 255 #x_test /= 255 checkpointer = ModelCheckpoint(filepath=file_path, verbose=1, save_best_only=True) if not data_augmentation: print('Not using data augmentation.') model.fit(train_tensors, train_targets, batch_size=batch_size, epochs=epochs, validation_data=(valid_tensors, valid_targets), shuffle=True, callbacks=[checkpointer], verbose=1 ) else: print('Using real-time data augmentation.') # This will do preprocessing and realtime data augmentation: datagen = ImageDataGenerator( zca_epsilon=1e-06, # epsilon for ZCA whitening rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180) # randomly shift images horizontally (fraction of total width) width_shift_range=0.15, # randomly shift images vertically (fraction of total height) height_shift_range=0.15, shear_range=0.1, # set range for random shear zoom_range=0.1, # set range for random zoom
class lstm(): def __init__(self, training_input, training_labels, nr_outputs, hidden_layer_nodes, epochs=5, optimization_runs=1, scale_range=(0, 1), activation_function='softmax', history=3, dropout=0.2): self.output_data = training_labels #self.scaler = MinMaxScaler(feature_range=scale_range).fit(training_input) #self.input_data = self.scaler.transform(training_input).astype(np.float32) self.input_data = training_input self.nr_features = np.shape(self.input_data)[-1] self.nr_training_samples = np.shape(self.input_data)[0] self.nr_classes = nr_outputs self.nr_hidden_layers = len(hidden_layer_nodes) self.epochs = epochs self.hidden_layer_nodes = hidden_layer_nodes self.optimization_tries = optimization_runs self.activation_function = activation_function self.history = history self.dropout = dropout def fit(self): best = 10000000 for i in range(self.optimization_tries): self.model = Sequential() for i in range(self.nr_hidden_layers): if i == 0: self.model.add( LSTM(units=self.hidden_layer_nodes[i], activation=self.activation_function, kernel_initializer='random_normal', return_sequences=True, input_shape=(self.history, self.nr_features))) self.model.add(Dropout(self.dropout)) elif i == (self.nr_hidden_layers - 1): self.model.add( LSTM(units=self.hidden_layer_nodes[i], activation=self.activation_function, kernel_initializer='random_normal')) self.model.add(Dropout(self.dropout)) else: self.model.add( LSTM(units=self.hidden_layer_nodes[i], activation=self.activation_function, kernel_initializer='random_normal', return_sequences=True)) self.model.add(Dropout(self.dropout)) self.model.add(Dense(units=self.nr_classes)) self.model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae']) self.model.fit(self.input_data, self.output_data, epochs=self.epochs) model_loss = self.model.evaluate(self.input_data, self.output_data)[0] if model_loss < best: best = model_loss self.final_model = self.model def predict(self, data): #data = self.scaler.transform(data) #Kanske denna behöver castas till np float 32? prediction = self.model.predict(data, batch_size=1) return prediction
import numpy as np import matplotlib.pyplot as plt import pandas as pd from keras.models import Sequential from keras.layers import Dense,SimpleRNN test_data=np.array([[[0.5,0.6,0.7]],[[0.6,0.7,0.8]]]) test_data=test_data.reshape(2,3,1) x_data = np.array([[[0.1, 0.2, 0.3]], [[0.2, 0.3, 0.4]], [[0.3, 0.4, 0.5]], [[0.4, 0.5, 0.6]]]) y_data = np.array([[[0.2, 0.3, 0.4]], [[0.3, 0.4, 0.5]], [[0.4, 0.5, 0.6]], [[0.5, 0.6, 0.7]]]) x_data=x_data.reshape(4,3,1) y_data=y_data.reshape(4,3,1) model=Sequential() model.add(SimpleRNN(50,input_shape=(3,1),return_sequences=True)) model.add(SimpleRNN(40,return_sequences=True)) model.add(SimpleRNN(30,return_sequences=True)) model.add(Dense(1)) model.summary() model.compile(loss='mse',optimizer='adam',metrics='mse') model.fit(x_data,y_data,epochs=100,verbose=0) y=model.predict(test_data) print(y)