y_train # In[22]: one_hot_vec_size = y_train.shape[1] one_hot_vec_size # ## 3. 모델 구성하기 # In[23]: model = Sequential() model.add( LSTM(units=128, kernel_initializer='glorot_normal', bias_initializer='zero', batch_input_shape=(1, n_steps, n_inputs), stateful=True)) model.add( Dense(units=one_hot_vec_size, kernel_initializer='glorot_normal', bias_initializer='zero', activation='softmax')) # ## 4. 모델 학습과정 설정하기 # In[24]: model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
x_train = scaler.transform(x_train) x_val = scaler.transform(x_val) x_test = scaler.transform(x_test) # print(x_train.shape) # print(x_test.shape) # print(x_val.shape) x_train = x_train.reshape(323, 13, 1) x_test = x_test.reshape(102, 13, 1) x_val = x_val.reshape(81, 13, 1) #2. 모델구성 from tensorflow.keras.models import Model from tensorflow.keras.layers import Dense, Input, LSTM inputs = Input(shape=(13, 1)) dense1 = LSTM(50, activation='relu')(inputs) dense1 = Dense(100)(dense1) dense1 = Dense(100)(dense1) dense1 = Dense(200)(dense1) dense1 = Dense(100)(dense1) dense1 = Dense(50)(dense1) outputs = Dense(1)(dense1) model = Model(inputs=inputs, outputs=outputs) #3. 컴파일, 훈련 model.compile(loss='mse', optimizer='adam', metrics=['mae']) model.fit(x_train, y_train, batch_size=16, epochs=300,
y1 = array([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 50, 60, 70]) y2 = array([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 50, 60, 70]) x1_predict = array([55, 65, 75]) x2_predict = array([65, 75, 85]) x1 = x1.reshape(x1.shape[0], x1.shape[1], 1) x2 = x2.reshape(x2.shape[0], x2.shape[1], 1) #2. 모델구성 from tensorflow.keras.models import Model from tensorflow.keras.layers import Dense, Input, LSTM # 모델 1 input1 = Input(shape=(3, 1)) dense1 = LSTM(16, activation='relu')(input1) dense1 = Dense(40, activation='relu')(dense1) dense1 = Dense(80, activation='relu')(dense1) dense1 = Dense(160, activation='relu')(dense1) dense1 = Dense(80, activation='relu')(dense1) dense1 = Dense(40, activation='relu')(dense1) dense1 = Dense(20, activation='relu')(dense1) # output1 = Dense(3)(dense1) # 모델 2 input2 = Input(shape=(3, 1)) dense2 = LSTM(16, activation='relu')(input2) dense2 = Dense(1)(dense2) # output2 = Dense(3)(dense2) # 모델 병합 / concatenate
def Make_block( BLOCK_TYPE, BLOCK, DROPOUT_RATE, #FULLY_CONNECTED, NUM_FILTERS, KERNEL_SIZE, KERNEL_STRIDE, POOL_STRIDE, POOL_SIZE, PADDING, input_dim, model_type=None, end_seq=None): """ if model_type == "CNN": # First layer: Include input dim if BLOCK_TYPE == 1 & BLOCK == 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) # No need to specify input dim if BLOCK_TYPE == 1 & BLOCK > 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) if BLOCK_TYPE == 2 & BLOCK == 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) model.add(BatchNormalization()) if BLOCK_TYPE == 2 & BLOCK > 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) model.add(BatchNormalization()) if BLOCK_TYPE == 3 & BLOCK == 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) model.add(Dropout(DROPOUT_RATE)) if BLOCK_TYPE == 3 & BLOCK > 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) model.add(Dropout(DROPOUT_RATE)) if BLOCK_TYPE == 4 & BLOCK == 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) model.add(BatchNormalization()) model.add(Dropout(DROPOUT_RATE)) if BLOCK_TYPE == 4 & BLOCK > 1: model.add(Conv1D(NUM_FILTERS, kernel_size=KERNEL_SIZE, padding='valid', activation='relu', strides=KERNEL_STRIDE, use_bias=True, input_shape=input_dim)) model.add(MaxPooling1D(pool_size=POOL_SIZE, strides=POOL_STRIDE)) model.add(BatchNormalization()) model.add(Dropout(DROPOUT_RATE)) """ if model_type == "LSTM": if BLOCK == 1: FULLY_CONNECTED = FC_BLOCK1 if BLOCK == 2: FULLY_CONNECTED = FC_BLOCK2 if BLOCK == 3: FULLY_CONNECTED = FC_BLOCK3 if BLOCK == 4: FULLY_CONNECTED = FC_BLOCK4 # For contiunation of the recurrent sequences if end_seq == False: print("type", BLOCK_TYPE, "Seq = T") # First layer: Include input dim # Basic LSTM with recurrent dropout if BLOCK_TYPE == 1: model.add( LSTM(FULLY_CONNECTED, implementation=2, input_shape=input_dim, recurrent_dropout=DROPOUT_RATE, return_sequences=True)) # LSTM with batchNorm and recurrent dropout if BLOCK_TYPE == 2: model.add( LSTM(FULLY_CONNECTED, implementation=2, input_shape=input_dim, recurrent_dropout=DROPOUT_RATE, return_sequences=True)) model.add(BatchNormalization()) # LSTM with no dropout if BLOCK_TYPE == 3: model.add( CuDNNLSTM( FULLY_CONNECTED, #implementation=2, input_shape=input_dim, return_sequences=True)) # LSTM with batchNorm and no dropout if BLOCK_TYPE == 4: model.add( CuDNNLSTM( FULLY_CONNECTED, #implementation=2, input_shape=input_dim, return_sequences=True)) model.add(BatchNormalization()) # For ending the sequence if end_seq == True: print("type", BLOCK_TYPE, "Seq = F") # First layer: Include input dim # Basic LSTM with recurrent dropout if BLOCK_TYPE == 1: model.add( LSTM(FULLY_CONNECTED, implementation=2, recurrent_dropout=DROPOUT_RATE, input_shape=input_dim, return_sequences=False)) # LSTM with batchNorm and recurrent dropout if BLOCK_TYPE == 2: model.add( LSTM(FULLY_CONNECTED, implementation=2, recurrent_dropout=DROPOUT_RATE, input_shape=input_dim, return_sequences=False)) model.add(BatchNormalization()) # LSTM with no dropout if BLOCK_TYPE == 3: model.add( CuDNNLSTM( FULLY_CONNECTED, #implementation=2, input_shape=input_dim, return_sequences=False)) # LSTM with batchNorm and no dropout if BLOCK_TYPE == 4: model.add( CuDNNLSTM( FULLY_CONNECTED, #implementation=2, input_shape=input_dim, return_sequences=False)) model.add(BatchNormalization()) return
""" sms_length = 20 embedded_docs = pad_sequences(onehot_repr, padding = 'pre', maxlen = sms_length) print(embedded_docs) embedded_docs[0] """# **Model Creation** LSTM model """ embedding_vector_feature = 40 #coverting embedded doc into a vector of 40, this will now take 40 features model = Sequential() model.add(Embedding(voc_size, embedding_vector_feature, input_length=sms_length)) model.add(Bidirectional(LSTM(100))) # 2 lstm is build model.add(Dropout(0.3)) model.add(Dense(1, activation='sigmoid')) model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy']) print(model.summary()) len(embedded_docs), y.shape x_final = np.array(embedded_docs) y_final = np.array(y) """# Spliting the data into test and train part""" X_train, X_test, Y_train, Y_test = train_test_split(x_final, y_final, test_size = 0.35, random_state = 42) """# **Training the model**"""
x_predict2 : [[1.65016254 1.34013605 1.13340003]] ''' # 모델 부터 ~ # predict도 scale 변환해야 합니다~ # LSTM 함수형 모델 구성 from tensorflow.keras.models import Model, Sequential from tensorflow.keras.layers import Dense, LSTM, Input x = x.reshape(14, 3, 1) x_predict1 = x_predict1.reshape(1, 3, 1) x_predict2 = x_predict2.reshape(1, 3, 1) model = Sequential() model.add(LSTM(10, activation='relu', input_shape=(3, 1))) model.add(Dense(20)) model.add(Dense(10)) model.add(Dense(1)) model.summary() # 컴파일, 훈련 # from sklearn.model_selection import train_test_split # x_train, x_test, y_train, y_test = train_test_split( # x, y, shuffle=False, train_size=0.8 # ) from tensorflow.keras.callbacks import EarlyStopping, TensorBoard
train = reframed_train.values test = reframed_test.values valid = reframed_valid.values # split into input and outputs train_X, train_y = train[:, :-1], train[:, -1] test_X, test_y = test[:, :-1], test[:, -1] valid_X, valid_y = valid[:, :-1], valid[:, -1] # reshape input to be 3D [samples, timesteps, features] train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1])) test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1])) valid_X = valid_X.reshape((valid_X.shape[0], 1, valid_X.shape[1])) print(train_X.shape, train_y.shape, test_X.shape, test_y.shape, valid_X.shape, valid_y.shape) model = Sequential() model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2]))) model.add(Dense(25)) model.add(Dense(1)) model.compile(loss='mae', optimizer='adam') # fit network history = model.fit(train_X, train_y, epochs=100, batch_size=50, validation_data=(valid_X, valid_y), verbose=2, shuffle=False) # plot history plt.plot(history.history['loss'], label='train') plt.plot(history.history['val_loss'], label='valid') plt.legend() plt.show() # make a prediction yhat = model.predict(test_X) test_X = test_X.reshape((test_X.shape[0], test_X.shape[2]))
np.random.shuffle(y_train) tf.random.set_seed(7) x_train, y_train = np.array(x_train), np.array(y_train) x_train = np.reshape(x_train, (x_train.shape[0], 60, 1)) for i in range(60, len(test_set)): x_test.append(test_set[i-60:i, 0]) y_test.append(test_set[i, 0]) x_test, y_test = np.array(x_test), np.array(y_test) x_test = np.reshape(x_test, (x_test.shape[0], 60, 1)) model = tf.keras.Sequential([ LSTM(80, return_sequences=True), Dropout(0.2), LSTM(100), Dropout(0.2), Dense(1) ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='mean_squared_error') checkpoint_save_path = './checkpoint/LSTM_stock.ckpt' if os.path.exists(checkpoint_save_path + '.index'): print('----------------- load the model -------------------') model.load_weights(checkpoint_save_path)
plt.show() # Reconstructing the first window to see how well the model performs. plt.plot(x_train[0], 'red') plt.plot(x_train_pred[0], 'blue') plt.show() # Plotting the comparison of the dataset with the anomalies. anomalies_index = get_anomaly_indices(threshold=0.245, train_loss=train_mae_loss) compare(cpu_utilization, anomalies_index) # LSTM based auto-encoder model. model2 = Sequential() model2.add(LSTM(128, activation='relu', input_shape=(x_train.shape[1], x_train.shape[2]), return_sequences=True)) model2.add(LSTM(64, activation='relu', return_sequences=False)) model2.add(RepeatVector(x_train.shape[1])) model2.add(LSTM(64, activation='relu', return_sequences=True)) model2.add(LSTM(128, activation='relu', return_sequences=True)) model2.add(TimeDistributed(Dense(x_train.shape[2]))) model2.compile(optimizer='adam', loss='mse') model2.summary() history2 = model2.fit(x_train, x_train, epochs=50, batch_size=128, validation_split=0.1).history # Plotting the training and validation losses. fig, ax = plt.subplots(figsize=(14, 6), dpi=80) ax.plot(history2['loss'], 'b', label='Train', linewidth=2)
from tensorflow.keras.layers import Dense, LSTM, Dropout, Activation import os sequence_length = 100 FILE_PATH = "holmes.txt" BASENAME = os.path.basename(FILE_PATH) seed = "the hound of the baskervilles" char2int = pickle.load(open(f"{BASENAME}-char2int.pickle", "rb")) int2char = pickle.load(open(f"{BASENAME}-int2char.pickle", "rb")) vocab_size = len(char2int) model = Sequential([ LSTM(256, input_shape=(sequence_length, vocab_size), return_sequences=True), Dropout(0.3), LSTM(256), Dense(vocab_size, activation="softmax"), ]) # load the optimal weights model.load_weights(f"results/{BASENAME}-{sequence_length}.h5") s = seed n_chars = 1000 # generate n_chars characters generated = "" for i in tqdm.tqdm(range(n_chars), "Generating text"): # make the input sequence X = np.zeros((1, sequence_length, vocab_size))
y = y.reshape(y.shape[0],1) from sklearn.model_selection import train_test_split x_train, x_test , y_train , y_test = train_test_split(x , y , train_size=0.8, random_state=1) # 2. Model from tensorflow.keras.models import Sequential , Model from tensorflow.keras.layers import Dense, LSTM from tensorflow.keras.layers import Conv2D from tensorflow.keras.layers import MaxPooling2D from tensorflow.keras.layers import Flatten from tensorflow.keras.layers import Dropout from keras.layers import Input, concatenate input1 = Input(shape=(5,2)) LSTM1_1 = LSTM(50,activation='relu',name='LSTM1_1')(input1) dense1_1 = Dense(60,activation='relu',name='dense1_1')(LSTM1_1) dense1_2 = Dense(70,activation='relu',name='dense1_2')(dense1_1) dense1_3 = Dense(80,activation='relu',name='dense1_3')(dense1_2) dense1_4 = Dense(70,activation='relu',name='dense1_4')(dense1_3) dense1_5 = Dense(60,activation='relu',name='dense1_5')(dense1_4) dense1_6 = Dense(50,activation='relu',name='dense1_6')(dense1_5) dense1_7 = Dense(30,activation='relu',name='dense1_7')(dense1_6) dense1_8 = Dense(20,activation='relu',name='dense1_8')(dense1_7) dense1_9 = Dense(10,activation='relu',name='dense1_9')(dense1_8) output1 = Dense(1,name="output2")(dense1_9) model = Model(inputs=(input1),outputs=output1) model.summary()
ypred = model.predict(x_test_seq_pad) ypredout = np.argmax(ypred, axis=1) testscores = metrics.accuracy_score(y_test, ypredout) confusion = metrics.confusion_matrix(y_test, ypredout) print("accuracy:%.2f%%" % (testscores * 100)) print(metrics.classification_report(y_test, ypredout, digits=2)) print(confusion) # Bidirectional LSTM no_of_epochs = 10 model = Sequential() model.add(embedding_layer) model.add( Bidirectional( LSTM(output_size, activation=rnn_activation, recurrent_activation=recurrent_activation))) model.add(Dropout(0.25)) model.add(Dense(2)) model.add(Activation('sigmoid')) model.summary() model.compile(loss=loss, optimizer=optimizer, metrics=['accuracy']) print('Bidirectional LSTM') model.fit(x_seq_pad, y, batch_size=batch_size, epochs=no_of_epochs, validation_split=validation_split, shuffle=shuffle)
# Re-shaping data x_train_reshaped = x_train_processed.reshape(len(x_train_processed), 1755, 1) # Save copy of downsampled np.savetxt( '/mnt/ml4cvd/projects/skhurshid/bmi707/x_train_downsampled_3510.tsv', x_train_reshaped, fmt='%.1f') np.savetxt('/mnt/ml4cvd/projects/skhurshid/bmi707/y_train.tsv', y_train, fmt='%.1f') timesteps = 1755 data_dim = 1 # Model model = Sequential() model.add(LSTM( 16, return_sequences=False, input_shape=(timesteps, data_dim))) # returns a sequence of vectors of dimension 32 model.add(Dense(1, activation='sigmoid')) # Compile opt = optimizers.SGD(lr=0.01) model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy']) # Fit model.fit(x_train_reshaped, y_train, epochs=100, verbose=1)
QK = Activation("softmax",name=name)(QK) MV = Multiply()([V, QK]) return(MV) x_ly=tf.convert_to_tensor(train_x) #X_train_au1=X_train_au[:484] #print("lyric输入shape: ",x_ly.shape,"\n audio输入shape: ", # X_train_au.shape,"\n修改后的shape:",X_train_au1.shape) train_x=embedding_matrix train_y=tf.convert_to_tensor([[float(i)] for i in y_train]) #print(y_train) ly_input = Input((100,32), name='ly_input' ) au_input = Input((1,54), name='au_input') lstm_out_ly = LSTM(32)(ly_input) lstm_out_au = LSTM(32)(au_input) #x = keras.layers.concatenate([lstm_out, lstm_out1]) x = keras.layers.concatenate([lstm_out_ly, lstm_out_au]) print(x.shape) x = Att(64,x,"attention_vec") x = Dense(32, activation='relu')(x) main_output = Dense(1, activation='sigmoid', name='main_output')(x) model = Model(inputs=[ly_input, au_input], outputs=[main_output]) #model.compile(optimizer='rmsprop', loss='binary_crossentropy', loss_weights=[1., 0.2]) #model.compile(optimizer='rmsprop', # loss={'main_output': 'binary_crossentropy'}, # loss_weights={'main_output': 1.})
# and will not include the start character. decoder_target_data[i, t - 1, target_token_index[word]] = 1 #Model Build : latent_dim = 128 from tensorflow.keras.layers import Dense, LSTM, Embedding, Input from tensorflow.keras.models import Model from tensorflow.keras.utils import plot_model from tensorflow.keras.callbacks import EarlyStopping encoder_inputs = Input(shape=(None, )) encoder_embed_layer = Embedding(num_encoder_tokens, latent_dim)(encoder_inputs) encoder_LSTM = LSTM(latent_dim, return_state=True) encoder_outputs, state_h, state_c = encoder_LSTM(encoder_embed_layer) encoder_states = [state_h, state_c] # Set up the decoder, using `encoder_states` as initial state. decoder_inputs = Input(shape=(None, )) decoder_embed_layer = Embedding(num_decoder_tokens, latent_dim) final_decoder_embed_layer = decoder_embed_layer(decoder_inputs) decoder_LSTM = LSTM(latent_dim, return_sequences=True, return_state=True) decoder_outputs, _, _ = decoder_LSTM(final_decoder_embed_layer, initial_state=encoder_states)
import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout, LSTM mnist = tf.keras.datasets.mnist # mnist is a dataset of 28x28 images of handwritten digits and their labels (x_train, y_train), (x_test, y_test) = mnist.load_data( ) # unpacks images to x_train/x_test and labels to y_train/y_test x_train = x_train / 255.0 x_test = x_test / 255.0 model = Sequential() model.add( LSTM(128, input_shape=(x_train.shape[1:]), activation='relu', return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(128, activation='relu')) model.add(Dropout(0.1)) model.add(Dense(32, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(10, activation='softmax')) opt = tf.keras.optimizers.Adam(lr=0.001, decay=1e-6) model.compile( loss='sparse_categorical_crossentropy',
y_train.shape x_test.shape y_test.shape x_train=x_train.reshape(x_train.shape[0],x_train.shape[1],1) x_test=x_test.reshape(x_test.shape[0],x_test.shape[1],1) from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import LSTM model=Sequential() model.add(LSTM(50,return_sequences=True,input_shape=(100,1))) model.add(LSTM(50,return_sequences=True)) model.add(LSTM(50)) model.add(Dense(1)) model.compile(loss="mean_squared_error",optimizer='adam') model.summary() model.fit(x_train,y_train,validation_data=(x_test,y_test),epochs=100,batch_size=64,verbose=1) ###prediction with the models train_prediction=model.predict(x_train) test_prediction=model.predict(x_test)
target_data = target_data[p] pd.set_option('display.max_colwidth', -1) BUFFER_SIZE = len(input_data) BATCH_SIZE = 128 embedding_dim = 300 units = 128 vocab_in_size = len(input_lang.word2idx) vocab_out_size = len(target_lang.word2idx) # Create the Encoder layers first. encoder_inputs = Input(shape=(len_input,)) encoder_emb = Embedding(input_dim=vocab_in_size, output_dim=embedding_dim) # Create the Bidirectional LSTM encoder_lstm = Bidirectional(LSTM(units=units, return_sequences=True, return_state=True)) encoder_out, fstate_h, fstate_c, bstate_h, bstate_c = encoder_lstm(encoder_emb(encoder_inputs)) state_h = Concatenate()([fstate_h,bstate_h]) state_c = Concatenate()([bstate_h,bstate_c]) encoder_states = [state_h, state_c] # Now create the Decoder layers. decoder_inputs = Input(shape=(None,)) decoder_emb = Embedding(input_dim=vocab_out_size, output_dim=embedding_dim) decoder_lstm = LSTM(units=units*2, return_sequences=True, return_state=True) decoder_lstm_out, _, _ = decoder_lstm(decoder_emb(decoder_inputs), initial_state=encoder_states) # Two dense layers added to this model to improve inference capabilities. decoder_d1 = Dense(units, activation="relu") decoder_d2 = Dense(vocab_out_size, activation="softmax") decoder_out = decoder_d2(Dropout(rate=.2)(decoder_d1(Dropout(rate=.2)(decoder_lstm_out))))
############################## ###### # ###### # # ###### ############################## from tensorflow import keras from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, LSTM, Dropout lr = 1e-3 model = Sequential(name='red_recurrente_LSTM') model.add(LSTM(16, input_shape=(lag, 1), name='LSTM')) model.add(Dense(1, name='Dense')) model.compile(loss=keras.losses.MeanSquaredError(), optimizer=keras.optimizers.Adam(lr)) model.summary() ############################## ###### # # # # ############################## epochs = 200 batch_size = 10
encoded_answer = to_categorical(tf.squeeze(answer, axis=1), num_classes=vocab_size) ################################### # Model # ################################### context_model = Sequential() context_model.add(Embedding(vocab_size, EMBED_HIDDEN_SIZE, input_length=MAX_CONTEXT)) context_model.add(Dropout(0.3)) # summarize the model print(context_model.summary()) # generate embeddings for question and make adaptable to story question_model = Sequential() question_model.add(Embedding(vocab_size, EMBED_HIDDEN_SIZE, input_length=MAX_QUESTION)) question_model.add(Dropout(0.3)) question_model.add(LSTM(300, return_sequences=False)) question_model.add(RepeatVector(MAX_CONTEXT)) print(question_model.summary()) # merge the two merged_model = add([context_model.output, question_model.output]) model_combined = Sequential() model_combined.add(LSTM(300, return_sequences=False)) model_combined.add(Dropout(0.3)) model_combined.add(Dense(vocab_size, activation="softmax")) # combine models final_model = Model([context_model.input, question_model.input], model_combined(merged_model)) print(final_model.summary())
# y의 유니크한 값 출력 y_bunpo = np.unique(y_train) print(y_bunpo) ''' ############################ 전처리 ################################ from tensorflow.keras.preprocessing.sequence import pad_sequences x_train = pad_sequences(x_train, maxlen=100) x_test = pad_sequences(x_test, maxlen=100) from tensorflow.keras.models import Sequential, load_model from tensorflow.keras.layers import Dense, LSTM, Embedding, Flatten, Conv1D model = Sequential() model.add(Embedding(1000, 400, input_length=100)) model.add(LSTM(200)) model.add(Dense(1,activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint es = EarlyStopping(monitor='val_loss', patience=30,mode='min') lr = ReduceLROnPlateau(monitor='val_loss', patience=10, mode='min') file_path = 'c:/data/modelcheckpoint/checkpoint_85.hdf5' mc = ModelCheckpoint(file_path,monitor='val_acc', save_best_only=True, mode='max',verbose=1) model.fit(x_train,y_train, batch_size=16, epochs=200, validation_split=0.2, callbacks=[es,lr,mc]) loss, acc = model.evaluate(x_test,y_test,batch_size=16) print("Loss : ", loss) print("Accuracy : ", acc) model2 = load_model('c:/data/modelcheckpoint/checkpoint_85.hdf5')
# Build the dataset for t in range(len(series) - T): x, y = series[t:t + T], series[t + T] X.append(x) Y.append(y) X = np.array(X).reshape(-1, T, 1) # Now the data should be N x T x D Y = np.array(Y) N = len(X) print("X.shape", X.shape, "Y.shape", Y.shape) # X.shape (1249, 10, 1) Y.shape (1249,) # autoregressive RNN model i = Input(shape=(T, 1)) x = LSTM(units=5)(i) x = Dense(units=1)(x) model = Model(i, x) model.compile(loss='mse', optimizer=Adam(lr=0.1)) # train the RNN r = model.fit( X[:-N // 2], Y[:-N // 2], epochs=80, validation_data=(X[-N // 2:], Y[-N // 2:]), ) # Plot loss per iteration import matplotlib.pyplot as plt
x_val = data[p1:p2] y_val = labels[p1:p2] x_test = data[p2:] y_test = labels[p2:] print('train docs: ' + str(len(x_train))) print('val docs: ' + str(len(x_val))) print('test docs: ' + str(len(x_test))) print('(5) training model...') model = Sequential() model.add( Embedding(len(word_index) + 1, EMBEDDING_DIM, input_length=MAX_SEQUENCE_LENGTH)) model.add(LSTM(200, dropout=0.2, recurrent_dropout=0.2)) model.add(Dropout(0.2)) model.add(Dense(labels.shape[1], activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['acc']) print(model.metrics_names) model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=2, batch_size=128) # model.save('lstm.h5')
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=num_words) x_train = pad_sequences(x_train, maxlen=maxlen) x_test = pad_sequences(x_test, maxlen=maxlen) encoder_inputs = Input(shape=(maxlen, ), name='Encoder-Input') emb_layer = Embedding(num_words, embed_dim, input_length=maxlen, name='Word-Embedding', mask_zero=False) x = emb_layer(encoder_inputs) state_h = Bidirectional(LSTM(128, activation='relu', name='Encoder-Last-LSTM'))(x) encoder_model = Model(inputs=encoder_inputs, outputs=state_h, name='Encoder-Model') seq2seq_encoder_out = encoder_model(encoder_inputs) decoded = RepeatVector(maxlen)(seq2seq_encoder_out) decoder_lstm = Bidirectional( LSTM(128, return_sequences=True, name='Decoder-LSTM-before')) decoder_lstm_output = decoder_lstm(decoded) decoder_dense = Dense(num_words, activation='softmax', name='Final-Output-Dense-before') decoder_outputs = decoder_dense(decoder_lstm_output) seq2seq_Model = Model(encoder_inputs, decoder_outputs)
embedding_matrix = np.load('embedding_matrix.npy') SC = StandardScaler() y_train = SC.fit_transform(y_train.values.reshape(-1, 1)) y_val = SC.fit_transform(y_val.values.reshape(-1, 1)) y_test = SC.fit_transform(y_test.values.reshape(-1, 1)) input_1 = Input(shape=(train_text1_seq.shape[1], )) input_2 = Input(shape=(train_text2_seq.shape[1], )) embed = Embedding(input_dim=vocab_size, output_dim=300, weights=[embedding_matrix], input_length=train_text1_seq.shape[1], trainable=False) lstm_1 = embed(input_1) lstm_2 = embed(input_2) lstm = Bidirectional( LSTM(50, return_sequences=True, activation='relu', dropout=0.2)) vector_1 = lstm(lstm_1) vector_2 = lstm(lstm_2) vector_1 = Flatten()(vector_1) vector_2 = Flatten()(vector_2) conc = concatenate([vector_1, vector_2]) out = Dense(1)(conc) model = Model([input_1, input_2], out) callback = [EarlyStopping(patience=8)] model.compile(optimizer=Adam(0.00001), loss='mse', metrics=['mae']) model.load_weights('vcp8.h5') history = model.fit([train_text1_seq, train_text2_seq], y_train.values.reshape(-1, 1), epochs=100, batch_size=32, validation_data=([val_text1_seq, val_text2_seq],
return x, y def __len__(self): return self.n_batches def on_epoch_end(self): self._refresh_sample_keys() data = Data() backbone = keras_model(include_top=False, pooling='avg', weights='imagenet', input_shape=(224, 224, 3)) backbone.trainable = False rnn_model = Sequential() rnn_model.add(TimeDistributed(backbone)) rnn_model.add(LSTM(512, input_shape=(25, 2048), return_sequences=True)) rnn_model.add(Dropout(0.5)) rnn_model.add(LSTM(512, input_shape=(25, 2048), return_sequences=True)) rnn_model.add(Dropout(0.5)) rnn_model.add(TimeDistributed(Dense(5, activation="softmax"))) print("START LSTM TRAINING") rnn_model.layers[0].trainable = False rnn_model.compile(loss='categorical_crossentropy', optimizer="adam", metrics=['accuracy']) sequence = SliceDataGenerator(data, "KAG", batch_size=2) rnn_history = rnn_model.fit(sequence, epochs=300)
def lstm(MODEL_NAME, train_data, test_data, MAX_LEN=32): if MODEL_NAME == 'summalstm': print("summarizing data that are longer than MAX_LEN " + str(MAX_LEN)) log.info("summarizing data that are longer than MAX_LEN " + str(MAX_LEN)) if config.data_name == 'nsmc': summarizer = KeywordSummarizer(tokenize=komoran_tokenizer, min_count=1, min_cooccurrence=1) print("summarizing train data") train_data = kor_summa(summarizer, train_data, MAX_LEN) print("summarizing test data") test_data = kor_summa(summarizer, test_data, MAX_LEN) elif config.data_name == 'imdb': print("not implemented yet...") print("tokenizing...") log.info("tokenizing...") okt = Okt() print("tokenizing train_data") X_train = tokenize(train_data, okt) print("tokenizing test_data") X_test = tokenize(test_data, okt) print() log.info("") # encode print("encoding and preprocessing...") log.info("encoding and preprocessing...") tokenizer = Tokenizer() tokenizer.fit_on_texts(X_train) threshold = 3 total_cnt = len(tokenizer.word_index) rare_cnt = 0 total_freq = 0 rare_freq = 0 for key, value in tokenizer.word_counts.items(): total_freq = total_freq + value if (value < threshold): rare_cnt = rare_cnt + 1 rare_freq = rare_freq + value # delete rare tokens vocab_size = total_cnt - rare_cnt + 1 tokenizer = Tokenizer(vocab_size) tokenizer.fit_on_texts(X_train) X_train = tokenizer.texts_to_sequences(X_train) X_test = tokenizer.texts_to_sequences(X_test) y_train = np.array(train_data['label']) y_test = np.array(test_data['label']) drop_train = [ index for index, sentence in enumerate(X_train) if len(sentence) < 1 ] drop_test = [ index for index, sentence in enumerate(X_test) if len(sentence) < 1 ] # delete empty samples X_train = np.delete(X_train, drop_train, axis=0) y_train = np.delete(y_train, drop_train, axis=0) X_test = np.delete(X_test, drop_test, axis=0) y_test = np.delete(y_test, drop_test, axis=0) # 32 / 64 / 128 max_len = MAX_LEN # padding X_train = pad_sequences(X_train, maxlen=max_len) X_test = pad_sequences(X_test, maxlen=max_len) print() print("reached checkpoint!") log.info("reached checkpoint!") model = Sequential() model.add(Embedding(vocab_size, 100)) model.add(LSTM(128)) model.add(Dense(1, activation='sigmoid')) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=4) mc = ModelCheckpoint('best_model.h5', monitor='val_acc', mode='max', verbose=1, save_best_only=True) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(X_train, y_train, epochs=15, callbacks=[es, mc], batch_size=60, validation_split=0.1) loaded_model = load_model('best_model.h5') print("acc : %.4f" % (loaded_model.evaluate(X_test, y_test)[1])) log.info("acc : %.4f" % (loaded_model.evaluate(X_test, y_test)[1]))
def make_model(file_name="TD20200309210544.json", column_review="reviewText", column_rating="overall", json_balanced=True, have_corpus=True, size=10000): # Making a json file with balanced ratings if json_balanced == False: make_balance_json(r'static/DBAlpha/TrainingDB/Files/' + file_name, column_review, column_rating, "main/files/uniform_json.json", size / 5) dataset = read_json('main/files/uniform_json.json', lines=True) dataset = dataset[:size] # Making corpus, in case corpus doesn't exists if have_corpus == False: corpus = basic.preprocess_lemm_dataset(dataset, 'review') process_corpus.write_corpus(corpus) # If corpus exists, read it directly else: corpus = [] corpus = process_corpus.read_corpus() corpus = corpus[:size] # Getting the ratings y = dataset.iloc[:size, 0] # Maximum words to consider TRAINING_VOCAB = 5000 # Tokenizing the words upto the maximum vocabulary tokenizer = Tokenizer(num_words=TRAINING_VOCAB, lower=True, char_level=False) # Fitting the corpus to tokenizer tokenizer.fit_on_texts(corpus) training_sequences = tokenizer.texts_to_sequences(corpus) # Getting the encoding dictionary vocab_to_int = tokenizer.word_index sequence_length = 150 # Padding to maximum sequence length features = pad_sequences(training_sequences, maxlen=sequence_length) """ EMBEDDING_DIM = 300 # Loading google's words to vect embedding print("\nLoading the Google's word2vec \nPlease Wait...") word2vec_path = 'resources/GoogleNews-vectors-negative300.bin' word2vec = models.KeyedVectors.load_word2vec_format(word2vec_path, binary=True) train_embedding_weights = np.zeros((len(vocab_to_int), EMBEDDING_DIM)) for word,index in vocab_to_int.items(): if word in word2vec: train_embedding_weights[index,:] = word2vec[word] else: np.random.rand(EMBEDDING_DIM) print(train_embedding_weights.shape) """ # Variables for RNN LSTM vocab_size = len(vocab_to_int) embedding_dim = 512 # Training parameters batch_size = int(size // 100) num_epochs = 30 # Encoding y data into diffeerent categorical columns labelencoder_y = LabelEncoder() y = labelencoder_y.fit_transform(y) y = y.reshape(len(y), 1) onehotencoder = OneHotEncoder() y = onehotencoder.fit_transform(y).toarray() # Splitting the dataset into the Training set and Test set X_train, X_test, y_train, y_test = train_test_split(features, y, test_size=0.20, random_state=0) # Initialising the RNN model = Sequential() # Adding Layers to RNN #model.add(Embedding(vocab_size, embedding_dim, weights = [train_embedding_weights],input_length=sequence_length)) if size > 2000: model.add( Embedding(TRAINING_VOCAB, embedding_dim, input_length=sequence_length)) else: model.add( Embedding(TRAINING_VOCAB, size / 10, input_length=sequence_length)) model.add(LSTM(100, return_sequences=True)) model.add(LSTM(100)) model.add(Dense(units=200, kernel_initializer='uniform', activation='relu')) model.add(Dense(5, activation='sigmoid')) #rmsprop=optimizers.rmsprop(lr=0.01) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Fitting the ANN to the Training set model.fit(X_train, y_train, batch_size=batch_size, epochs=num_epochs) # Predicting the Test set results over trained model y_pred = model.predict(X_test) # Getting result in proper format that is initially probabilistic for i in range(len(y_pred)): ind_ = 0 max_ = y_pred[i][0] for j in range(5): if y_pred[i][j] > max_: max_ = y_pred[i][j] ind_ = j y_pred[i][j] = 0 y_pred[i][ind_] = 1 # Inverse Transforming the categorical encodings on y_pred and y_test y_pred = onehotencoder.inverse_transform(y_pred) y_test = onehotencoder.inverse_transform(y_test) # Measuring the performance accuracy = accuracy_score(y_test, y_pred, normalize=True, sample_weight=None) # file_name = re.sub(".json", "", file_name) with open(r'static/DBAlpha/TrainingDB/Models/TOKEN_' + file_name + ".pkl", 'wb') as handle: pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL) model.save(r'static/DBAlpha/TrainingDB/Models/' + file_name + '.h5') # Returning the performance parameters return accuracy
x_train = [] y_train = [] for x in range(prediction_days, len(scaled_data)): x_train.append(scaled_data[x - prediction_days:x, 0]) y_train.append(scaled_data[x, 0]) x_train, y_train = np.array(x_train), np.array(y_train) x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) # Build the model model = Sequential() model.add( LSTM(units=50, return_sequences=True, input_shape=(x_train.shape[1], 1))) model.add(Dropout(0.2)) model.add(LSTM(units=50, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(units=50)) model.add(Dropout(0.2)) model.add(Dense(units=1)) # Prediction of the next closing price model.compile(optimizer='adam', loss='mean_squared_error') model.fit(x_train, y_train, epochs=25, batch_size=32) # Load the test data test_start = dt.datetime(2020, 1, 1) test_end = dt.datetime.now() test_data = web.DataReader(company, 'yahoo', test_start, test_end)
cnn_model.add(Dropout(0.25)) cnn_model.add(Flatten()) cnn_model.add(Dense(128)) cnn_model.add(BatchNormalization()) cnn_model.add(LeakyReLU(alpha=.001)) cnn_model.add(Dropout(0.25)) # cnn_model.summary() timesteps = 4 lstm_model = Sequential() # lstm_model.add(Reshape((28, 512), input_shape=(28, 512))) lstm_model.add( LSTM(256, input_shape=(28, 128), dropout=0.15, return_sequences=True)) lstm_model.add(BatchNormalization()) lstm_model.add(LSTM(512, dropout=0.15, return_sequences=False)) lstm_model.add(Dense(256)) lstm_model.add(BatchNormalization()) lstm_model.add(LeakyReLU(alpha=.001)) lstm_model.summary() upsample_model = Sequential() upsample_model.add(Reshape((16, 16, 1), input_shape=(1, 256))) upsample_model.add(Conv2DTranspose(16, kernel_size=(4, 4), activation='relu')) upsample_model.add(BatchNormalization()) upsample_model.add(Conv2DTranspose(32, kernel_size=(4, 4), activation='relu')) upsample_model.add(BatchNormalization()) upsample_model.add(Conv2DTranspose(16, kernel_size=(4, 4), activation='relu')) upsample_model.add(BatchNormalization())