def model(x_train, num_labels, units, num_lstm_layers, model_type='lstm'): """ Simple RNN Model with multiple RNN layers and units. Inputs: - x_train: required for creating input shape for RNN layer in Keras - num_labels: number of output classes (int) - units: number of RNN units (float) - num_lstm_layers: number of RNN layers to add (int) - model_type: Type of RNN model (str) Returns - model: A Keras model """ model = Sequential([ LSTM(units, return_sequences=True, input_shape=(x_train.shape[1], x_train.shape[2])) if model_type == 'lstm' else GRU(units, return_sequences=True, input_shape=(x_train.shape[1], x_train.shape[2])) if model_type == 'gru' else SimpleRNN(units, return_sequences=True, input_shape=(x_train.shape[1], x_train.shape[2])), ] + [ LSTM(units, return_sequences=True) if model_type == 'lstm' else GRU(units, return_sequences=True) if model_type == 'gru' else SimpleRNN(units, return_sequences=True), ] * (num_lstm_layers - 1) + [Dense(num_labels, activation='softmax')]) print(model.summary()) return model
def __init__(self, maxlen, max_features, embedding_dims, class_num=1, last_activation='sigmoid'): super(RCNN, self).__init__() self.maxlen = maxlen self.max_features = max_features self.embedding_dims = embedding_dims self.class_num = class_num self.last_activation = last_activation self.embedding = Embedding(self.max_features, self.embedding_dims, input_length=self.maxlen) self.forward_rnn = SimpleRNN(128, return_sequences=True) self.backward_rnn = SimpleRNN(128, return_sequences=True, go_backwards=True) self.reverse = Lambda(lambda x: tf.reverse(x, axis=[1])) self.concatenate = Concatenate(axis=2) self.conv = Conv1D(64, kernel_size=1, activation='tanh') self.max_pooling = GlobalMaxPooling1D() self.classifier = Dense(self.class_num, activation=self.last_activation)
def build_model(self): input_current = Input((self.max_len, )) input_left = Input((self.max_len, )) input_right = Input((self.max_len, )) embedder = Embedding(self.max_features, self.embedding_size, input_length=self.max_len) embedding_current = embedder(input_current) embedding_left = embedder(input_left) embedding_right = embedder(input_right) x_left = SimpleRNN(128, return_sequences=True)(embedding_left) x_right = SimpleRNN(128, return_sequences=True, go_backwards=True)(embedding_right) x_right = Lambda(lambda x: K.reverse(x, axes=1))(x_right) x = Concatenate(axis=2)([x_left, embedding_current, x_right]) x = Conv1D(64, kernel_size=1, activation='tanh')(x) x = GlobalMaxPooling1D()(x) output = Dense(self.class_num, activation=self.activation)(x) model = Model(inputs=[input_current, input_left, input_right], outputs=output) return model
def birnn(): model = Sequential() model.add( Bidirectional(SimpleRNN(2**5, return_sequences=True), input_shape=(max_len, 1))) model.add(Bidirectional(SimpleRNN(2**5, return_sequences=True))) model.add(Bidirectional(SimpleRNN(2**5, return_sequences=False))) model.add(Dense(10)) model.add(Activation('softmax')) adam = optimizers.Adam(lr=0.001) model.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy']) model.summary() early_stopping = EarlyStopping(patience=10) history = model.fit(x_train, y_train, validation_split=0.1, epochs=epochs, batch_size=batch_size, verbose=1, callbacks=[early_stopping]) return model, history
def model_define(self): '''Defines the model architecture''' self.model1 = Sequential() self.model1.add(BatchNormalization(input_shape = (self.n_steps, self.n_features))) self.model1.add(Dropout(0.2)) if self.rnn_unit: if self.more_layer: self.model1.add(SimpleRNN(64, activation = 'relu', return_sequences = True)) self.model1.add(BatchNormalization()) self.model1.add(SimpleRNN(16, activation = 'relu')) else: self.model1.add(SimpleRNN(64, activation = 'relu')) else: if self.more_layer: self.model1.add(LSTM(64, activation = 'relu', return_sequences = True)) self.model1.add(BatchNormalization()) self.model1.add(LSTM(16, activation = 'relu')) else: self.model1.add(LSTM(64, activation = 'relu')) if self.n_steps_out > 0: self.model1.add(Dense(self.n_steps_out)) else: self.model1.add(Dense(1)) # Enables addition of layers and substitutes of computational units with a series of if statements self.model1.summary() # Print out a model architecture summary plot_model(self.model1, self.input_path + self.output_path + 'model.png', show_shapes = True) # Save a computational graph self.model1.save(self.input_path + self.output_path + 'model') # Save the model for future usage self.model1.compile(loss = keras.losses.logcosh, # Compile the model with set parameters optimizer = keras.optimizers.Adam(), metrics = ['mse'])
def build_rnn_model(vocabulary_size, input_length): model = Sequential() model.add(Embedding(vocabulary_size, 50, input_length=input_length)) model.add(SimpleRNN(25, return_sequences=True)) model.add(SimpleRNN(25)) model.add(Dense(50, activation='relu')) model.add(Dense(vocabulary_size, activation='softmax')) return model
def rnn_model(cfg,shapeX, shapeY): model_rnn = Sequential() model_rnn.add(SimpleRNN(units=50,return_sequences=True, input_shape=(shapeX, shapeY))) model_rnn.add(Dropout(0.2)) model_rnn.add(SimpleRNN(units=50)) model_rnn.add(Dropout(0.2)) model_rnn.add(Dense(units = 1)) model_rnn.compile( loss='mean_squared_error',optimizer=keras.optimizers.Adam(0.001)) return model_rnn
def residual_block(x, units, conv_num=3, activation='tanh'): # ( input, output node, for 문 반복 횟수, activation ) # Shortcut s = SimpleRNN(units, return_sequences=True)(x) for i in range(conv_num - 1): x = SimpleRNN(units, return_sequences=True)(x) # return_sequences=True 이거 사용해서 lstm shape 부분 3차원으로 맞춰줌 -> 자세한 내용 찾아봐야함 x = Activation(activation)(x) x = SimpleRNN(units)(x) x = Add()([x,s]) return Activation(activation)(x)
def create_model(model_type): clear_session() samples = 2000 epochs = 20 if model_type == 'Dense': x_train = np.random.uniform(0, 10, (samples, 5)) y_train = (np.mean(x_train, axis=1) ** 2) / 2 # half of squared mean of sample model = Sequential() model.add(Dense(128, activation='relu', input_shape=x_train.shape[1:])) model.add(BatchNormalization()) model.add(Dense(64, activation='tanh')) model.add(BatchNormalization()) model.add(Dense(32, activation='relu')) model.add(BatchNormalization()) model.add(Dense(16, activation='tanh')) model.add(BatchNormalization()) model.add(Dense(1, activation='linear')) elif model_type == 'SimpleRNN': x_train = np.random.uniform(0, 10, (samples, 10, 4)) y_train = (np.mean(x_train.take(axis=1, indices=8), axis=1) ** 2) / 2 # half of squared mean of sample's 8th index model = Sequential() model.add(SimpleRNN(128, return_sequences=True, input_shape=x_train.shape[1:])) model.add(BatchNormalization()) model.add(SimpleRNN(64, return_sequences=True)) model.add(BatchNormalization()) model.add(SimpleRNN(32)) model.add(BatchNormalization()) model.add(Dense(16, activation='relu')) model.add(BatchNormalization()) model.add(Dense(1, activation='linear')) elif model_type == 'GRU': x_train = np.random.uniform(0, 10, (samples, 10, 4)) y_train = (np.mean(x_train.take(axis=1, indices=8), axis=1) ** 2) / 2 # half of squared mean of sample's 8th index model = Sequential() model.add(GRU(128, input_shape=x_train.shape[1:], return_sequences=True, implementation=2)) model.add(BatchNormalization()) model.add(GRU(64, return_sequences=True, implementation=2)) model.add(BatchNormalization()) model.add(GRU(32, implementation=2)) model.add(BatchNormalization()) model.add(Dense(16, activation='relu')) model.add(BatchNormalization()) model.add(Dense(1, activation='linear')) else: raise Exception('Unknown model type: {}'.format(model_type)) model.compile(optimizer='adam', loss='mse') model.fit(x_train, y_train, batch_size=32, epochs=epochs, verbose=0) if WRITE_KERAS_MODELS: model.save('tests/{}.h5'.format(model_type)) return model, x_train.shape
def TS_model(bidirect=True, RNN='LSTM', layer_norm=False): inputs = layers.Input(shape=(9), name='input') inputs_extend = RepeatVector(500)(inputs) if bidirect == True: if RNN == 'LSTM': layer_1 = Bidirectional( LSTM(128, return_sequences=True, dropout=0.3))(inputs_extend) elif RNN == 'GRU': layer_1 = Bidirectional( GRU(128, return_sequences=True, dropout=0.3))(inputs_extend) else: layer_1 = Bidirectional( SimpleRNN(128, return_sequences=True, dropout=0.3))(inputs_extend) else: if RNN == 'LSTM': layer_1 = LSTM(128, return_sequences=True, dropout=0.3)(inputs_extend) elif RNN == 'GRU': layer_1 = GRU(128, return_sequences=True, dropout=0.3)(inputs_extend) else: layer_1 = SimpleRNN(128, return_sequences=True, dropout=0.3)(inputs_extend) if layer_norm == True: layer_1 = LayerNormalization()(layer_1) if bidirect == True: if RNN == 'LSTM': layer_2 = Bidirectional( LSTM(128, return_sequences=True, dropout=0.3))(layer_1) elif RNN == 'GRU': layer_2 = Bidirectional( GRU(128, return_sequences=True, dropout=0.3))(layer_1) else: layer_2 = Bidirectional( SimpleRNN(128, return_sequences=True, dropout=0.3))(layer_1) else: if RNN == 'LSTM': layer_2 = LSTM(128, return_sequences=True, dropout=0.3)(layer_1) elif RNN == 'GRU': layer_2 = GRU(128, return_sequences=True, dropout=0.3)(layer_1) else: layer_2 = SimpleRNN(128, return_sequences=True, dropout=0.3)(layer_1) if layer_norm == True: layer_2 = LayerNormalization()(layer_2) layer_3 = TimeDistributed(Dense(64, activation='elu'))(layer_2) outputs = TimeDistributed(Dense(1))(layer_3) model = Model(inputs, outputs) return model
def rnnModel(): model = Sequential() model.add(create_embedding_layer(word_index, MAX_SEQUENCE_LENGTH)) model.add(SimpleRNN(int(64), return_sequences=True, activation="relu")) model.add(Dropout(0.3)) model.add(SimpleRNN(int(64), activation="relu")) model.add(Dropout(0.3)) model.add(Dense(int(32))) model.add(Dropout(0.3)) model.add(Dense(7, activation='softmax')) return model
def MyRNN(isMeanPoolinng, stateDim, embedding): model = models.Sequential() model.add(embedding) if isMeanPoolinng: model.add(SimpleRNN(units=stateDim, return_sequences=True)) model.add(GlobalAveragePooling1D()) else: model.add(SimpleRNN(units=stateDim)) model.add(Dense(1, activation='sigmoid')) model.summary() return model
def rnnModel(): model = Sequential() model.add(create_embedding_layer(word_index)) model.add(SimpleRNN(256, activation="relu",return_sequences=True)) model.add(Dropout(0.3)) model.add(SimpleRNN(128, activation="relu")) model.add(Dropout(0.3)) model.add(Dense(64)) model.add(Dropout(0.3)) model.add(Dense(len(labels), activation='softmax')) return model
def create(self) -> tf.keras.models.Model: model = tf.keras.models.Sequential([InputLayer((50, 1), name='input')], name=self.name) for i in range(9): model.add( SimpleRNN(75, return_sequences=True, name='rnn0{}'.format(i + 1))) model.add(SimpleRNN(75, return_sequences=False, name='rnn10')) model.add(Dense(1, activation=None, name='output')) return model
def rnn_model(df): # Mapping event to number events = {'purchase':1,'cart': 2,'view': 3, 'remove_from_cart':4} df['event'] = df.event_type.map(events) sequence = df.groupby('user_session')['event'].apply(list) sequence = sequence.reset_index() # Filter the data to extract a Purchase when event=1 or not when event!=1 label. sequence['purchase'] = sequence['event'].apply(lambda x: 1 if 1 in x else 0) sequence = sequence[sequence['event'].map(len)> 1] productdf= pd.DataFrame(df.groupby('user_session')['product_id'].apply(list)).reset_index() productdf=productdf[productdf['product_id'].map(len)>1] #Add product list to the dataframe sequence['product']=productdf['product_id'] #The sequence data should not contain the "purchase field" so it is filtered out sequence['event']= sequence.event.apply(lambda row: list(filter(lambda a: a != 1, row))) # Chossing sequance length upto 5 for event pattren and Discard remaining sequences. short_sequence_5 = sequence[sequence['event'].map(len) <= 5] event_sequence = short_sequence_5['event'].to_list() # Padding sequences to have same length event = pad_sequences(event_sequence) short_sequence_5['event2']=event.tolist() #-----------------------------------------Spliting Data -----------------------------------------# X=short_sequence_5[['user_session','product','event2']] y = np.array(pd.get_dummies(short_sequence_5['purchase'] , prefix='Purchase')) X_train, X_test, y_train, y_test = train_test_split(X , y,test_size=0.3) #-------------------------Resizing is necessary since input to sequence models is (1,d)------------# Xe_train = np.array((X_train['event2'].tolist())) Xe_train=Xe_train.reshape((Xe_train.shape[0], 1, Xe_train.shape[1])) Xe_test = np.array((X_test['event2'].tolist())) Xe_test=Xe_test.reshape((Xe_test.shape[0], 1, Xe_test.shape[1])) #------------------------------------------------Initializing RNN model---------------------------------# model = Sequential() model.add(SimpleRNN(units=40, return_sequences = True, input_shape = (1,5) )) model.add(SimpleRNN(2*40)) model.add(Dense(2, activation='softmax')) model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.0003), loss='mean_absolute_error',metrics=['acc']) #-------------------------------------------------Fitting RNN Model--------------------------------------# model.fit(Xe_train, y_train,epochs=30 , batch_size=1000 , validation_data=(Xe_test, y_test)) model_adam = model #-------------------------------------------------Saving RNN Model--------------------------------------# model_adam.save("C:/Users/hano0/Desktop/DSI8/atom/RNNmodel.h5") print("Saved model to disk") #------------------------------------Returning Test Data for Prediction ------------------------# return Xe_test, y_test , X_test
def train_network(embedding_vector_dimensionality, embedding_dropout_factor, recurrent_dropout_factor, RNN_dropout_factor, layer_dropout_factor, recurrent_layer_sizes, lr, lr_decay, batch_size, epoch_no, max_train_size, max_test_size): X_train, y_train, X_test, y_test = load_data() if max_train_size and type(max_train_size) == int: X_train = X_train[:max_train_size] y_train = y_train[:max_train_size] if max_test_size and type(max_test_size) == int: X_test = X_test[:max_test_size] y_test = y_test[:max_test_size] print("Shape of the training input: (%d, %d)" % X_train.shape) print("Shape of the training output: (%d, %d)" % y_train.shape) model = Sequential() model.add( Embedding(get_word_count(), embedding_vector_dimensionality, input_length=X_train.shape[1])) model.add(Dropout(embedding_dropout_factor)) for size in recurrent_layer_sizes[:-1]: model.add( SimpleRNN(units=size, return_sequences=True, recurrent_dropout=recurrent_dropout_factor, dropout=RNN_dropout_factor)) model.add(Dropout(layer_dropout_factor)) model.add( SimpleRNN(units=recurrent_layer_sizes[-1], recurrent_dropout=recurrent_dropout_factor, dropout=RNN_dropout_factor)) model.add(Dropout(layer_dropout_factor)) model.add(Dense(y_train.shape[1], activation='sigmoid')) optimizer = Adam(lr=lr, decay=lr_decay) model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['binary_accuracy', c_score]) print(model.summary()) model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=epoch_no, batch_size=batch_size, callbacks=[ ModelCheckpoint("weights.hdf5", monitor='val_loss', save_best_only=True, mode='auto', period=1), LogPerformance() ]) scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1] * 100))
def create_rnn(dropout_rate, input_size): model = Sequential() model.add(SimpleRNN(32, return_sequences=True, input_shape=input_size)) model.add(SimpleRNN( 64, return_sequences=False, )) model.add(Dropout(dropout_rate)) model.add(Dense(128, activation='relu')) model.add(Dropout(dropout_rate)) model.add(Dense(2, activation='softmax')) return model
def build_model_RNN(self, config): seq_len = config['data']['sequence_length'] - 1 num_features = config['data']['num_features'] logging.info("[MODEL]: Building model...") self.model.add( SimpleRNN(100, input_shape=(seq_len, num_features), return_sequences=True)) self.model.add(SimpleRNN(100, return_sequences=False)) self.model.add(Dropout(0.2)) self.model.add(Dense(1, activation='linear')) opt = Adam(learning_rate=1e-4, clipnorm=1) self.model.compile(loss='mse', optimizer=opt)
def fit(self, series, train_size=0.70, window_size=30, epochs=100, batch_size=32, verbose=2): self.window_size = window_size self.batch_size = batch_size self.train_size = train_size # Build model model = Sequential() #model.add(BatchNormalization()) model.add( SimpleRNN(self.rnn_units[0], return_sequences=True, input_shape=[None, 1])) for n in self.rnn_units[1:]: model.add(SimpleRNN(n, return_sequences=True)) if not self.dropout == None: model.add(Dropout(self.dropout)) model.add(Dense(units=1)) # Compile model model.compile(loss=keras.losses.Huber(), optimizer='adam', metrics=['mae']) # Prepare data t = int(len(series) * train_size) train = series[:t] val = series[t:] train = seq2seq_window_dataset(train, window_size, batch_size) val = seq2seq_window_dataset(val, window_size, batch_size) # Callbacks and fitting checkpoint = keras.callbacks.ModelCheckpoint('best_rnn.h5', save_best_only=True) early_stopping = keras.callbacks.EarlyStopping(patience=50) model.fit(train, epochs=epochs, validation_data=val, callbacks=[early_stopping, checkpoint], verbose=verbose) print('Training completed') self.model = keras.models.load_model("best_rnn.h5") del model
def residual_block( x, filters, conv_num=3, activation='relu'): # ( input, output node, for 문 반복 횟수, activation ) # Shortcut s = Conv1D(filters, 1, padding='same')(x) for i in range(conv_num - 1): x = SimpleRNN(filters, return_sequences=True)(x) x = Activation(activation)(x) x = SimpleRNN(filters)(x) x = Add()([x, s]) x = Activation(activation)(x) return MaxPool1D(pool_size=2, strides=1)(x)
def sample_architecture(): """ return_sequence=True return every output at timestep t Necessary for stacking multiple RNN that will require a time factor to compute """ model = Sequential() model.add(Embedding(10000, 32)) model.add(SimpleRNN(32)) model.summary() model = Sequential() model.add(Embedding(10000, 32)) model.add(SimpleRNN(32, return_sequences=True)) model.add(SimpleRNN(32, return_sequences=True)) model.add(SimpleRNN(32, return_sequences=True)) model.add(SimpleRNN(32)) model.summary()
def build_train_model(self): #build model self.inputs = Input(shape=self.input_shape) self.y = SimpleRNN(units=self.units, kernel_regularizer=self.regul)(self.inputs) self.outputs = Dense(self.num_labels, activation='softmax')(self.y) self.model = Model(self.inputs, self.outputs) self.model.summary() print("\n") # train model self.model.compile(optimizer='sgd', loss='sparse_categorical_crossentropy', metrics=['accuracy']) self.model.fit(self.x_train, self.y_train, validation_data=(self.x_test, self.y_test), epochs=self.epochs, batch_size=self.batch_size) self.score = self.model.evaluate(self.x_test, self.y_test, batch_size=self.batch_size) print("\nTest accuracy: %.1f%%" % (100 * self.score[1])) print("\n")
def rnn_model(self, x_train, x_test, y_train, y_test): classes_num = self.dataset.getParameters()["classes_num"] model = Sequential() model.add(Embedding( self.VOCAB_SIZE, self.EMBEDING_DIM, input_length=self.INPUT_LENGTH)) model.add(SimpleRNN(128)) model.add(Dense(64, activation='relu')) model.add(Dense(classes_num, activation=self.ACTIVATION)) model.compile( loss=self.LOSSFUNC, optimizer='adam', metrics=['accuracy'] ) es_callback = EarlyStopping( monitor='val_loss', patience=3) model.summary() history = model.fit(x_train, y_train, epochs=self.EPOCHS, verbose=1, validation_data=(x_test, y_test), batch_size=self.BATCH_SIZE, callbacks=[es_callback]) loss, accuracy = model.evaluate(x_train, y_train, verbose=1) print("Training Accuracy: {:.4f}".format(accuracy)) loss, accuracy = model.evaluate(x_test, y_test, verbose=1) print("Testing Accuracy: {:.4f}".format(accuracy)) return history
def build_model(nb_words, rnn_model="SimpleRNN", embedding_matrix=None): ''' build_model function: inputs: rnn_model - which type of RNN layer to use, choose in (SimpleRNN, LSTM, GRU) embedding_matrix - whether to use pretrained embeddings or not ''' model = Sequential() # add an embedding layer if embedding_matrix is not None: model.add( Embedding(nb_words, 200, weights=[embedding_matrix], input_length=max_len, trainable=False)) else: model.add( Embedding(nb_words, 200, input_length=max_len, trainable=False)) # add an RNN layer according to rnn_model if rnn_model == "SimpleRNN": model.add(SimpleRNN(200)) elif rnn_model == "LSTM": model.add(LSTM(200)) else: model.add(GRU(200)) # model.add(Dense(500,activation='relu')) # model.add(Dense(500, activation='relu')) model.add(Dense(2, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def __init__(self, input_dim, hidden_dim, output_dim, sequence_length, activation='tanh', loss_fun='MSE', weight_decay=0, metabolic_cost=0, use_bias=True, recurrent_constraint=None): super(RNN, self).__init__() self.input_dim = input_dim self.hidden_dim = hidden_dim self.output_dim = output_dim self.sequence_length = sequence_length self.activation = activation self.encoder = Dense(hidden_dim, name='encoder', use_bias=use_bias) self.rnn = SimpleRNN(hidden_dim, return_sequences=True, activation=tf.keras.layers.Activation(activation), recurrent_initializer='glorot_uniform', recurrent_constraint=recurrent_constraint, name='RNN', use_bias=use_bias) self.decoder = Dense(output_dim, name='decoder', use_bias=use_bias) self.loss_fun = tf.keras.losses.get(loss_fun) self.weight_decay = weight_decay self.metabolic_cost = metabolic_cost
def create_model(self): """ Creates the model """ self.mod = Sequential() # Add the RNN layer # Note 1: For RNN, we set unroll=True to enable fast GPU usage # Note 2: You need to set the CuDNN version of LSTM unroll = tf.test.is_gpu_available() if (self.mod_type == 'lstm'): # LSTM model if tf.test.is_gpu_available(): self.mod.add(CuDNNLSTM(self.nh, input_shape=(self.nt, self.nin),\ return_sequences=False, name='RNN')) else: self.mod.add(LSTM(self.nh, input_shape=(self.nt, self.nin),\ return_sequences=False, name='RNN',unroll=unroll)) elif self.is_complex: # Complex RNN cell = ComplexRNNCell(nh=self.nh) self.mod.add(RNN(cell, input_shape=(self.nt, self.nin),\ return_sequences=False, name='RNN',unroll=True)) else: # Real RNN model self.mod.add(SimpleRNN(self.nh, input_shape=(self.nt, self.nin),\ return_sequences=False, name='RNN',activation='relu',unroll=unroll)) self.mod.add(Dense(nout, activation='softmax', name='Output')) self.mod.summary()
def rnn(company): df = pd.read_csv('pg4_data.csv', parse_dates=True, index_col='date') df = df[df.company == company] df.drop(['ticker', 'company'], inplace=True, axis=1) df['price'] = df.price.apply(lambda x: x.replace(',', '')) df['price'] = pd.to_numeric(df.price, errors='coerce') train_data = df[:-7] test_data = df[-7:] scaler = MinMaxScaler(feature_range=(0, 1)) train_scaled = scaler.fit_transform(train_data) test_scaled = scaler.transform(test_data) generator = TimeseriesGenerator(train_scaled, train_scaled, length=3, batch_size=1) model = Sequential() model.add(SimpleRNN(132, input_shape=(3, 1))) model.add(Dense(64)) model.add(Dense(1)) early_stops = EarlyStopping(monitor='val_loss', patience=2) validation = TimeseriesGenerator(test_scaled, test_scaled, length=3, batch_size=1) model.compile(optimizer='adam', loss='mse') model.fit(generator, epochs=20, validation_data=validation, callbacks=[early_stops]) test_prediction = [] first_eval_batch = test_scaled[-3:] current_batch = first_eval_batch.reshape(1, 3, 1) current_pred = model.predict(current_batch)[0] test_prediction.append(current_pred) current_batch = np.append(current_batch[:, 1:, :], [[current_pred]], axis=1) true_predictions = scaler.inverse_transform(test_prediction) return round(true_predictions[0][0], 2)
def build_rnf_model(self): seq_input = Input(shape=( self.window_len, 4, ), name='seq_input') chunked_input = DistributeInputLayer( filter_width=self.rnf_kernel_size, seq_len=self.window_len)(seq_input) # Shape:(?, L-F+1, F, D) # The TimeDistributed Layer treats index 1 in this input as \ # independent time steps. # So here, the same GRU is being applied to every chunk. print('RNF_kernel_size: {}'.format(self.rnf_kernel_size)) print('RNF_dimension: {}'.format(self.n_filters)) xs = TimeDistributed(SimpleRNN(self.n_filters))(chunked_input) xs = Activation('relu')(xs) # Shape:(?, L-F+1, RNF_DIM) # Note here, the LSTM is producing # a single output with dimension RNF_DIM # Include an L-1 norm at the subsequent dense layer. xs = MaxPooling1D(pool_size=15, strides=15)(xs) print(xs.shape) # Adding Dense Layers. xs = LSTM(32, activation='relu')(xs) print(xs.shape) xs = Dense(128, activation='relu')(xs) xs = Dropout(self.dropout_freq)(xs) print(xs.shape) xs = Dense(128, activation='relu')(xs) xs = Dropout(self.dropout_freq)(xs) result = Dense(1, activation='sigmoid')(xs) # Define the model input & output model = Model(inputs=seq_input, outputs=result) return model
def build_sequential_model(input_dim=376): opt = tf.keras.optimizers.Adam(learning_rate=0.1) model = tf.keras.Sequential() model.add(Masking(0, input_shape=(None, 13))) # model.add(Embedding(input_dim=377, output_dim=13)) model.add(Bidirectional(LSTM(units=52, return_sequences=True))) # model.add(Dropout(0.3)) # The output of GRU will be a 3D tensor of shape (batch_size, timesteps, 256) model.add(Bidirectional(GRU(208, return_sequences=True))) model.add(Dropout(0.4)) # model.add(Dropout(0.4, training=True)) # model.add(Activation('relu')) # The output of SimpleRNN will be a 2D tensor of shape (batch_size, 128) # model.add(Bidirectional(LSTM(units=52, return_sequences=True))) # model.add(Dropout(0.3)) model.add(Bidirectional(SimpleRNN(52))) model.add(Dropout(0.3)) # model.add(Dropout(0.3, training=True)) # model.add(Activation('relu')) model.add(Dense(13)) model.compile(loss='mse', optimizer=opt, metrics=[ tf.keras.metrics.MeanSquaredError(), tf.keras.metrics.RootMeanSquaredError(), tf.keras.metrics.MeanAbsoluteError() ]) return model
def _create_model(self, input_dim, out_dim1): rnn = SimpleRNN(batch_input_shape=(None, self._maxlen, input_dim), name='rnn1', kernel_initializer='glorot_uniform', bias_initializer='zeros', units=out_dim1, return_sequences=True, activation='linear') layer1 = Dense(name='layer1', units=1, kernel_initializer='glorot_uniform', bias_initializer='zeros', activation='linear' if self._is_regression else None) if self._with_functional_api: inputs = Input(name='layer_in', shape=(self._maxlen, input_dim)) outputs = layer1(rnn(inputs)) model = Model(inputs=inputs, outputs=outputs, name='rnn_constructor') else: model = Sequential([rnn, layer1], name='rnn_constructor') model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) return model