def fit_lstm(train, batch_size, nb_epoch, neurons): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) model = Sequential() model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False) model.reset_states() return model
def fit_lstm(train, n_vars, n_seq, n_batch, nb_epoch, n_neurons): # reshape training into [samples, timesteps, features] X, y = train[:, 0:n_vars], train[:, n_vars:] X = X.reshape(X.shape[0], 1, X.shape[1]) # design network model = Sequential() model.add( LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True)) model.add(Dense(y.shape[1])) model.compile(loss='mean_squared_error', optimizer='adam') # fit network for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=n_batch, verbose=0, shuffle=False) model.reset_states() print('epoch %d is finished' % i) return model
""" [[1. 0. 0. 0. 0.] [0. 1. 0. 0. 0.] [0. 0. 1. 0. 0.] [0. 0. 0. 0. 1.]] """ print(seq2Y) model = Sequential() model.add(LSTM(20, batch_input_shape=(1, 1, 5), stateful=True)) model.add(Dense(5, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam') for i in range(650): model.fit(seq1X, seq1Y, epochs=1, batch_size=1, verbose=1, shuffle=False) model.reset_states() model.fit(seq2X, seq2Y, epochs=1, batch_size=1, verbose=0, shuffle=False) model.reset_states() n_batch = 1 print('Sequence 1') result = model.predict_classes(seq1X, batch_size=n_batch, verbose=0) model.reset_states() for i in range(len(result)): print('X=%.1f y=%.1f, yhat=%.1f' % (seq1[i], seq1[i + 1], result[i])) # 测试 LSTM对“数列2”预测 print('Sequence 2') result = model.predict_classes(seq2X, batch_size=n_batch, verbose=0) model.reset_states()
def fitting(self): dim_row = self.lags # tiempo dim_col = 1 # features or chanels (Volume) output_dim = 3 # 3 for categorical #data = np.random.random((1000, dim_row, dim_col)) #clas = np.random.randint(3, size=(1000, 1)) ##print(clas) #clas = to_categorical(clas) ##print(clas) data = self.X_train data_test = self.X_test data = data.values.reshape(-1, dim_row, dim_col) data_test = data_test.values.reshape(-1, dim_row, dim_col) clas = self.y_train clas_test = self.y_test clas = to_categorical(clas) clas_test = to_categorical(clas_test) cat0 = self.y_train.tolist().count(0) cat1 = self.y_train.tolist().count(1) cat2 = self.y_train.tolist().count(2) print("may: ", cat1, " ", "menor: ", cat2, " ", "neutro: ", cat0) n_samples_0 = cat0 n_samples_1 = (cat1 + cat2)/2.0 n_samples_2 = (cat1 + cat2)/2.0 class_weight={ 0: 1.0, 1: n_samples_0/n_samples_1, 2: n_samples_0/n_samples_2} def class_1_accuracy(y_true, y_pred): # cojido de: http://www.deepideas.net/unbalanced-classes-machine-learning/ class_id_true = K.argmax(y_true, axis=-1) class_id_preds = K.argmax(y_pred, axis=-1) accuracy_mask = K.cast(K.equal(class_id_preds, 1), 'int32') class_acc_tensor = K.cast(K.equal(class_id_true, class_id_preds), 'int32') * accuracy_mask class_acc = K.sum(class_acc_tensor) / K.maximum(K.sum(accuracy_mask), 1) return class_acc class SecondOpinion(Callback): def __init__(self, model, x_test, y_test, N): self.model = model self.x_test = x_test self.y_test = y_test self.N = N self.epoch = 1 def on_epoch_end(self, epoch, logs={}): if self.epoch % self.N == 0: y_pred = self.model.predict(self.x_test) pred_T = 0 pred_F = 0 for i in range(len(y_pred)): if np.argmax(y_pred[i]) == 1 and np.argmax(self.y_test[i]) == 1: pred_T += 1 if np.argmax(y_pred[i]) == 1 and np.argmax(self.y_test[i]) != 1: pred_F += 1 if pred_T + pred_F > 0: Pr_pos = pred_T/(pred_T + pred_F) print("Yoe: epoch, Probabilidad pos: ", self.epoch, Pr_pos) else: print("Yoe Probabilidad pos: 0") self.epoch += 1 ################################################################################################################# model = Sequential() # model.add(Reshape(input_shape=(dim_row, dim_col), target_shape=(dim_row, dim_col, 1))) if self.nConv > 0: #model.add(Reshape((dim_row, dim_col, 1))) model.add(Reshape(input_shape=(dim_row, dim_col), target_shape=(dim_row, dim_col, 1))) for i in range(self.nConv): model.add(Convolution2D(self.conv_nodes, kernel_size = (self.kernel_size, 1), padding = 'same', kernel_regularizer = regularizers.l2(0.01))) model.add(Activation('relu')) model.add(Reshape(target_shape=(dim_row, self.conv_nodes * dim_col))) # Como nuestro output tiene una sola dimension no es necesario "return_sequences='True'" # y tampoco es necesario usar TimeDistributed if self.nConv == 0: model.add(LSTM(units=self.lstm_nodes, return_sequences=True, activation='tanh', input_shape=(dim_row, dim_col))) for i in range(self.nLSTM - 1): model.add(LSTM(units=self.lstm_nodes, return_sequences=True, activation='tanh')) model.add(Dropout(0.5)) model.add(TimeDistributed(Dense(units = output_dim))) # the dimension of index one will be considered to be the temporal dimension model.add(Activation('softmax')) # for loss = 'categorical_crossentropy' #model.add(Activation('sigmoid')) # for loss = 'binary_crossentropy' # haciendo x: x[:, -1, :], la segunda dimension desaparece quedando solo # los ULTIMOS elementos (-1) de dicha dimension: # Try this to see: # data = np.random.random((5, 3, 4)) # print(data) # print(data[:, -1, :]) model.add(Lambda(lambda x: x[:, -1, :], output_shape = [output_dim])) print(model.summary()) tensorboard_active = False val_loss = False second_opinion = True callbacks = [] if tensorboard_active: callbacks.append(TensorBoard( log_dir=self.putmodel + "Tensor_board_data", histogram_freq=0, write_graph=True, write_images=True)) if val_loss: callbacks.append(EarlyStopping( monitor='val_loss', patience=5)) if second_opinion: callbacks.append(SecondOpinion(model, data_test, clas_test, 10)) #model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = ['categorical_accuracy']) #model.compile(loss = 'binary_crossentropy', optimizer=Adam(lr=self.learning), metrics = ['categorical_accuracy']) model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy]) model.fit(x=data, y=clas, batch_size=self.batch_size, epochs=800, verbose=2, callbacks = callbacks, class_weight = class_weight) #validation_data=(data_test, clas_test)) ##################################################################################################################### # serialize model to YAML model_yaml = model.to_yaml() with open("model.yaml", "w") as yaml_file: yaml_file.write(model_yaml) # serialize weights to HDF5 model.save_weights("model.h5") print("Saved model to disk") # # load YAML and create model # yaml_file = open('model.yaml', 'r') # loaded_model_yaml = yaml_file.read() # yaml_file.close() # loaded_model = model_from_yaml(loaded_model_yaml) # # load weights into new model # loaded_model.load_weights("model.h5") # print("Loaded model from disk") # loaded_model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy]) # print("Computing prediction ...") y_pred = model.predict_proba(data_test) model.reset_states() print("Computing train evaluation ...") score_train = model.evaluate(data, clas, verbose=2) print('Train loss:', score_train[0]) print('Train accuracy:', score_train[1]) model.reset_states() # score_train_loaded = loaded_model.evaluate(data, clas, verbose=2) # loaded_model.reset_states() # print('Train loss loaded:', score_train[0]) # print('Train accuracy loaded:', score_train[1]) print("Computing test evaluation ...") score_test = model.evaluate(data_test, clas_test, verbose=2) print('Test loss:', score_test[0]) print('Test accuracy:', score_test[1]) model.reset_states() # score_test_loaded = loaded_model.evaluate(data_test, clas_test, verbose=2) # loaded_model.reset_states() # print('Test loss loaded:', score_test[0]) # print('Test accuracy loaded:', score_test[1]) pred_T = 0 pred_F = 0 for i in range(len(y_pred)): if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) == 1: pred_T += 1 # print(y_pred[i]) if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) != 1: pred_F += 1 if pred_T + pred_F > 0: Pr_pos = pred_T/(pred_T + pred_F) print("Yoe Probabilidad pos: ", Pr_pos) else: print("Yoe Probabilidad pos: 0") history = DataFrame([[self.skip, self.nConv, self.nLSTM, self.learning, self.batch_size, self.conv_nodes, self.lstm_nodes, score_train[0], score_train[1], score_test[0], score_test[1]]], columns = ('Skip', 'cConv', 'nLSTM', 'learning', 'batch_size', 'conv_nodes', 'lstm_nodes', 'loss_train', 'acc_train', 'loss_test', 'acc_test')) self.history = self.history.append(history)
class LstmForecasterMultipleLookAhead(object): def __create_sliding_window_dataset(self, input_time_series, look_back, look_forward): data_x, data_y = [], [] for index in range(len(input_time_series) - look_back - look_forward): data_x.append(input_time_series[index:index + look_back]) data_y.append(input_time_series[index + look_back: index + look_back + look_forward]) return np.array(data_x), np.array(data_y) def __init__(self, time_series, look_back, look_forward, term_name, stateful=True, random_seed=None, verbose=False): self.__verbose = verbose self.__term_name = term_name if random_seed is not None: np.random.seed(random_seed) self.__source_time_series = np.reshape(time_series.astype(dtype=np.float), newshape=(-1, 1)) self.__look_back = look_back self.__look_forward = look_forward time_series_delta = time_series[1:] - time_series[:-1] self.__source_time_series_delta = np.reshape(time_series_delta.astype(dtype=np.float), newshape=(-1, 1)) self.__scaler = MinMaxScaler(feature_range=(-1, 1)) data_set = self.__scaler.fit_transform(self.__source_time_series_delta) data_set_x, data_set_y = self.__create_sliding_window_dataset(data_set, look_back, look_forward) self.__test_train_split = 0.67 train_size = int(len(data_set_x) * self.__test_train_split) train_x = data_set_x[0:train_size, :] train_y = data_set_y[0:train_size, :] test_x = data_set_x[train_size:, :] test_y = data_set_y[train_size:, :] self.__hidden_neurons = 100 # 20 # 100 if stateful: self.__model_name = 'encode-decode-stateful' self.__num_epochs = 200 batch_size = 1 self.__model = Sequential() self.__model.add( LSTM(batch_input_shape=(batch_size, None, 1), units=self.__hidden_neurons, return_sequences=False, stateful=True)) self.__model.add(RepeatVector(look_forward)) self.__model.add(LSTM(units=self.__hidden_neurons, return_sequences=True, stateful=True)) self.__model.add(TimeDistributed(Dense(1))) self.__model.add(Activation('linear')) if self.__verbose: self.__model.summary(print_fn=print) self.__model.compile(loss='mean_squared_error', optimizer='rmsprop', metrics=['accuracy']) epoch_iterator = range(self.__num_epochs) if self.__verbose: epoch_iterator = tqdm(epoch_iterator, unit='epoch') for _ in epoch_iterator: history = self.__model.fit(x=train_x, y=train_y, validation_data=(test_x, test_y), epochs=1, batch_size=batch_size, verbose=0) val_loss = history.history['val_loss'][0] loss = history.history['loss'][0] if self.__verbose: epoch_iterator.set_description(f"val loss={val_loss:0.3f} loss={loss:0.3f}") self.__model.reset_states() else: self.__model_name = 'encode-decode-stateless' self.__model = Sequential() self.__model.add(LSTM(input_shape=(None, 1), units=self.__hidden_neurons, return_sequences=False)) self.__model.add(RepeatVector(look_forward)) self.__model.add(LSTM(units=self.__hidden_neurons, return_sequences=True)) self.__model.add(TimeDistributed(Dense(1))) self.__model.add(Activation('linear')) if self.__verbose: self.__model.summary(print_fn=print) self.__model.compile(loss='mean_squared_error', optimizer='rmsprop', metrics=['accuracy']) early_stopping = EarlyStopping(monitor='loss', min_delta=0.000001, patience=50) # this big patience is important callbacks = [early_stopping] if self.__verbose: callbacks.append(TQDMCallback()) history = self.__model.fit(x=train_x, y=train_y, validation_data=(test_x, test_y), epochs=10000, callbacks=callbacks, verbose=0) self.__num_epochs = len(history.epoch) @property def configuration(self): return f'TTSplit={self.__test_train_split:.2} numEpochs={self.__num_epochs} numHN={self.__hidden_neurons}' def predict_counts(self, time_series=None): if time_series is None: time_series = self.__source_time_series source_time_series_delta = self.__source_time_series_delta else: time_series_delta = time_series[1:] - time_series[:-1] source_time_series_delta = np.reshape(time_series_delta.astype(dtype=np.float), newshape=(-1, 1)) data_set = self.__scaler.fit_transform(source_time_series_delta.astype(dtype=np.float)) data_set_seed = data_set[-self.__look_back:] reshaped_seed = np.reshape(data_set_seed, (1, -1, 1)) predicted_sequence_scaled_diff = self.__model.predict(reshaped_seed).reshape(-1, 1) predicted_sequence_diff = self.__scaler.inverse_transform(predicted_sequence_scaled_diff) previous_predicted_value = time_series[-1] predicted_values = [] for step in range(self.__look_forward): predicted_scaled_diff = previous_predicted_value + predicted_sequence_diff[step][0] predicted_values.append(predicted_scaled_diff) previous_predicted_value = predicted_scaled_diff return clip(predicted_values, 0, inf) def plot_prediction(self, ground_truth, prediction): common_plot_prediction(ground_truth, prediction, self.__term_name, self.__model_name, self.__look_back, self.__look_forward, self.__hidden_neurons, self.__num_epochs)