def test_sequential_model_saving_2(): # test with funkier config model = Sequential() model.add(Dense(2, input_dim=3)) model.add(RepeatVector(3)) model.add(TimeDistributed(Dense(3))) model.compile(loss=objectives.MSE, optimizer=optimizers.RMSprop(lr=0.0001), metrics=[metrics.categorical_accuracy], sample_weight_mode='temporal') x = np.random.random((1, 3)) y = np.random.random((1, 3, 3)) model.train_on_batch(x, y) out = model.predict(x) fname = 'tmp_' + str(np.random.randint(10000)) + '.h5' save_model(model, fname) new_model = load_model(fname) os.remove(fname) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05) # test that new updates are the same with both models x = np.random.random((1, 3)) y = np.random.random((1, 3, 3)) model.train_on_batch(x, y) new_model.train_on_batch(x, y) out = model.predict(x) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05)
def test_sequential_model_saving(): model = Sequential() model.add(Dense(2, input_shape=(3,))) model.add(RepeatVector(3)) model.add(TimeDistributed(Dense(3))) model.compile(loss=losses.MSE, optimizer=optimizers.RMSprop(lr=0.0001), metrics=[metrics.categorical_accuracy], sample_weight_mode='temporal') x = np.random.random((1, 3)) y = np.random.random((1, 3, 3)) model.train_on_batch(x, y) out = model.predict(x) _, fname = tempfile.mkstemp('.h5') save_model(model, fname) new_model = load_model(fname) os.remove(fname) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05) # test that new updates are the same with both models x = np.random.random((1, 3)) y = np.random.random((1, 3, 3)) model.train_on_batch(x, y) new_model.train_on_batch(x, y) out = model.predict(x) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05)
def test_merge_overlap(): left = Sequential() left.add(Dense(nb_hidden, input_shape=(input_dim,))) left.add(Activation('relu')) model = Sequential() model.add(Merge([left, left], mode='sum')) model.add(Dense(nb_class)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=1, validation_data=(X_test, y_test)) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=2, validation_data=(X_test, y_test)) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True, verbose=2, validation_split=0.1) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=1, validation_split=0.1) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False) model.train_on_batch(X_train[:32], y_train[:32]) loss = model.evaluate(X_train, y_train, verbose=0) assert(loss < 0.7) model.predict(X_test, verbose=0) model.predict_classes(X_test, verbose=0) model.predict_proba(X_test, verbose=0) model.get_config(verbose=0) fname = 'test_merge_overlap_temp.h5' model.save_weights(fname, overwrite=True) model.load_weights(fname) os.remove(fname) nloss = model.evaluate(X_train, y_train, verbose=0) assert(loss == nloss)
def test_nested_sequential(in_tmpdir): (x_train, y_train), (x_test, y_test) = _get_test_data() inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_split=0.1) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=0) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=False) model.train_on_batch(x_train[:32], y_train[:32]) loss = model.evaluate(x_test, y_test, verbose=0) model.predict(x_test, verbose=0) model.predict_classes(x_test, verbose=0) model.predict_proba(x_test, verbose=0) fname = 'test_nested_sequential_temp.h5' model.save_weights(fname, overwrite=True) inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights(fname) os.remove(fname) nloss = model.evaluate(x_test, y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() Sequential.from_config(config) model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
def test_sequential_model_saving(): model = Sequential() model.add(Dense(2, input_dim=3)) model.add(Dense(3)) model.compile(loss='mse', optimizer='rmsprop', metrics=['acc']) x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) out = model.predict(x) fname = 'tmp_' + str(np.random.randint(10000)) + '.h5' save_model(model, fname) new_model = load_model(fname) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05) # test that new updates are the same with both models x = np.random.random((1, 3)) y = np.random.random((1, 3)) model.train_on_batch(x, y) new_model.train_on_batch(x, y) out = model.predict(x) out2 = new_model.predict(x) assert_allclose(out, out2, atol=1e-05) # test load_weights on model file model.load_weights(fname) os.remove(fname)
def test_recursive(): # test layer-like API graph = containers.Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') seq = Sequential() seq.add(Dense(32, input_shape=(32,))) seq.add(graph) seq.add(Dense(4)) seq.compile('rmsprop', 'mse') seq.fit(X_train_graph, y_train_graph, batch_size=10, nb_epoch=10) loss = seq.evaluate(X_test_graph, y_test_graph) assert(loss < 2.5) loss = seq.evaluate(X_test_graph, y_test_graph, show_accuracy=True) seq.predict(X_test_graph) seq.get_config(verbose=1)
def save_bottleneck_features(): model = Sequential() model.add(Convolution2D(32, 3, 3, input_shape=(1, img_width, img_height))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) model.add(Convolution2D(64, 2, 2)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Convolution2D(128, 2, 2)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.3)) assert os.path.exists(weights_path), 'Model weights not found (see "weights_path" variable in script).' f = h5py.File(weights_path) layer_names = [n.decode('utf8') for n in f.attrs['layer_names']] weight_value_tuples = [] for k, name in enumerate(layer_names): if k >= len(model.layers): break g = f[name] weight_names = [n.decode('utf8') for n in g.attrs['weight_names']] if len(weight_names): weight_values = [g[weight_name] for weight_name in weight_names] layer = model.layers[k] symbolic_weights = layer.trainable_weights + layer.non_trainable_weights if len(weight_values) != len(symbolic_weights): raise Exception('Layer #' + str(k) + ' (named "' + layer.name + '" in the current model) was found to ' 'correspond to layer ' + name + ' in the save file. ' 'However the new layer ' + layer.name + ' expects ' + str(len(symbolic_weights)) + ' weights, but the saved weights have ' + str(len(weight_values)) + ' elements.') weight_value_tuples += zip(symbolic_weights, weight_values) K.batch_set_value(weight_value_tuples) f.close() print('Model loaded.') X, y = load2d() X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42) X_flipped, y_flipped = flip_image(X_train, y_train) X_train = np.vstack((X_train, X_flipped)) y_train = np.vstack((y_train, y_flipped)) bottleneck_features_train = model.predict(X_train) np.save(open('bottleneck_features_train.npy', 'w'), bottleneck_features_train) np.save(open('label_train.npy', 'w'), y_train) bottleneck_features_validation = model.predict(X_val) np.save(open('bottleneck_features_validation.npy', 'w'), bottleneck_features_validation) np.save(open('label_validation.npy', 'w'), y_val)
def test_autoencoder_advanced(): encoder = containers.Sequential([core.Dense(5, input_shape=(10,))]) decoder = containers.Sequential([core.Dense(10, input_shape=(5,))]) X_train = np.random.random((100, 10)) X_test = np.random.random((100, 10)) model = Sequential() model.add(core.Dense(output_dim=10, input_dim=10)) autoencoder = core.AutoEncoder(encoder=encoder, decoder=decoder, output_reconstruction=True) model.add(autoencoder) # training the autoencoder: model.compile(optimizer='sgd', loss='mse') assert autoencoder.output_reconstruction model.fit(X_train, X_train, nb_epoch=1, batch_size=32) # predicting compressed representations of inputs: autoencoder.output_reconstruction = False # the autoencoder has to be recompiled after modifying this property assert not autoencoder.output_reconstruction model.compile(optimizer='sgd', loss='mse') representations = model.predict(X_test) assert representations.shape == (100, 5) # the model is still trainable, although it now expects compressed representations as targets: model.fit(X_test, representations, nb_epoch=1, batch_size=32) # to keep training against the original inputs, just switch back output_reconstruction to True: autoencoder.output_reconstruction = True model.compile(optimizer='sgd', loss='mse') model.fit(X_train, X_train, nb_epoch=1) reconstructions = model.predict(X_test) assert reconstructions.shape == (100, 10)
class QNetwork: def __init__(self, learning_rate=0.01, state_size=2, action_size=3, hidden_size=10): self.model = Sequential() self.model.add(Dense(hidden_size, activation='relu', input_dim=state_size)) self.model.add(Dense(hidden_size, activation='relu')) self.model.add(Dense(action_size, activation='linear')) self.optimizer = Adam(lr=learning_rate) # 誤差を減らす学習方法はAdam # self.model.compile(loss='mse', optimizer=self.optimizer) self.model.compile(loss=huberloss, optimizer=self.optimizer) # 重みの学習 def replay(self, memory, batch_size, gamma, targetQN): inputs = np.zeros((batch_size, 2)) targets = np.zeros((batch_size, 3)) mini_batch = memory.sample(batch_size) for i, (state_b, action_b, reward_b, next_state_b) in enumerate(mini_batch): inputs[i:i + 1] = state_b target = reward_b if not (next_state_b == np.zeros(state_b.shape)).all(axis=1): # 価値計算(DDQNにも対応できるように、行動決定のQネットワークと価値観数のQネットワークは分離) retmainQs = self.model.predict(next_state_b)[0] next_action = np.argmax(retmainQs) # 最大の報酬を返す行動を選択する target = reward_b + gamma * targetQN.model.predict(next_state_b)[0][next_action] targets[i] = self.model.predict(state_b) # Qネットワークの出力 targets[i][action_b] = target # 教師信号 # shiglayさんよりアドバイスいただき、for文の外へ修正しました self.model.fit(inputs, targets, epochs=1, verbose=0) # epochsは訓練データの反復回数、verbose=0は表示なしの設定
def _test_smoke(channel_order=None): from kfs.layers.convolutional import Convolution2DEnergy_TemporalBasis from keras.models import Sequential #from keras.layers import Flatten, Dense input_shape = (12, 3, 64, 64) if channel_order is None: channel_order = K.image_data_format() if channel_order == 'channels_last': input_shape = (12, 64, 64, 3) rng = np.random.RandomState(42) datums = rng.randn(6, 12, 3, 64, 64).astype('float32') if channel_order == 'channels_last': datums = datums.transpose(0, 1, 3, 4, 2) nn2 = Sequential() nn2.add(Convolution2DEnergy_TemporalCorrelation(8, 16, 4, (5, 5), 7, padding='same', temporal_kernel_size=5, input_shape=input_shape)) nn2.compile(loss='mse', optimizer='sgd') pred2 = nn2.predict(datums) return nn2, nn2.predict(datums)
model.add(Dense(200, activation='relu')) model.add(Dense(1)) print(model.summary()) adam = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) model.compile(loss='mean_absolute_error', optimizer=adam, metrics=['accuracy']) model.fit(X_train, Y_train, epochs=30, batch_size=2048) print("Predicting ratings...") Y_predict = model.predict(X_train) Y_predict.shape = Y_predict.shape[0] MAE = np.sum(np.abs(Y_predict - Y_train)) / Y_predict.shape[0] print("The Mean Absolute Error for Nerual Network Is: " + str(MAE)) i = int(float(X_train.shape[1]) / 2.0) j = int(X_train.shape[1]) Y_predict2 = np.sum((X_train[:, :i] * X_train[:, i:j]), axis=1) MAE2 = np.sum(np.abs(Y_predict2 - Y_train)) / Y_predict.shape[0] print("The Mean Absolute Error for Simple Dot Product: " + str(MAE2))
# Predicting the dog or cat #from keras.preprocessing import image #import numpy as np # #test_image = image.load_img('dataset/test_set/dogs/dog.4002.jpg', target_size=(64, 64)) #test_image = image.img_to_array(test_image) #test_image = np.expand_dims(test_image, axis=0) # #classes = classifier.predict(test_image) #print(classes[0][0]) #if classes[0][0] >= 0.5: # print("dog") #else: # print("cat") from keras.preprocessing import image import numpy as np test_image = image.load_img('dataset/test_set/dogs/dog.4002.jpg', target_size=(64, 64)) test_image = image.img_to_array(test_image) test_image = np.array(test_image).astype('float32') / 255 test_image = np.expand_dims(test_image, axis=0) classes = classifier.predict(test_image) print(classes[0][0]) if classes[0][0] >= 0.5: print("dog") else: print("cat")
inner_init='glorot_normal', activation='sigmoid')) model.compile(loss='cosine_proximity', optimizer='adam', metrics=['accuracy']) model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM500.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM1000.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM1500.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM2000.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM2500.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM3000.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM3500.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM4000.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM4500.h5') model.fit(x_train, y_train, nb_epoch=500, validation_data=(x_test, y_test)) model.save('LSTM5000.h5') #from keras.models import load_model #model = load_model('LSTM1000.h5') predictions = model.predict(x_test) mod = gensim.models.Word2Vec.load('word2vec.bin') [mod.most_similar([predictions[10][i]])[0] for i in range(15)]
class Model(): def __init__(self, configs): self.model = Sequential() self.configs = configs def build_model(self, input_dim): for layer in self.configs['model']['layers']: neurons = layer['neurons'] if 'neurons' in layer else None dropout_rate = layer['rate'] if 'rate' in layer else None activation = layer['activation'] if 'activation' in layer else None return_seq = layer['return_seq'] if 'return_seq' in layer else None input_timesteps = layer['input_timesteps'] if 'input_timesteps' in layer else None if layer['type'] == 'dense': self.model.add(Dense(neurons, activation=activation)) if layer['type'] == 'lstm': self.model.add(LSTM(neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq)) if layer['type'] == 'dropout': self.model.add(Dropout(dropout_rate)) self.model.compile(loss=self.configs['model']['loss'], optimizer=self.configs['model']['optimizer']) print('[Model] Model Compiled') def train(self, x, y, epochs, batch_size): print('[Model] Training Started') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) save_fname = os.path.join(self.configs["data"]["save_dir"], '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath=save_fname, monitor='val_loss', save_best_only=True) ] # try this #y = y.reshape((y.shape[0], y.shape[1], 1)) self.model.fit( x, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks ) self.model.save(save_fname) print('[Model] Training Completed. Model saved as %s' % save_fname) def load_h5_model(self, model_name): self.model = load_model(model_name) def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch): print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) save_fname = os.path.join(self.configs["data"]["save_dir"], '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True) ] self.model.fit_generator( data_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, workers=1 ) print('[Model] Training Completed. Model saved as %s' % save_fname) def predict_point_by_point(self, data): #Predict each timestep given the last sequence of true data, in effect only predicting 1 step ahead each time print('[Model] Predicting Point-by-Point...') predicted = self.model.predict(data) predicted = np.reshape(predicted, (predicted.size,)) return predicted def predict_sequences_multiple(self, data, window_size, prediction_len): #Predict sequence of 50 steps before shifting prediction run forward by 50 steps print('[Model] Predicting Sequences Multiple...') prediction_seqs = [] for i in range(int(len(data)/prediction_len)): curr_frame = data[i*prediction_len] predicted = [] for j in range(prediction_len): predicted.append(self.model.predict(curr_frame[newaxis,:,:])[0,0]) curr_frame = curr_frame[1:] curr_frame = np.insert(curr_frame, [window_size-2], predicted[-1], axis=0) prediction_seqs.append(predicted) return prediction_seqs def predict_sequence_full(self, data, window_size): #Shift the window by 1 new prediction each time, re-run predictions on new window print('[Model] Predicting Sequences Full...') curr_frame = data[0] predicted = [] for i in range(len(data)): predicted.append(self.model.predict(curr_frame[newaxis,:,:])[0,0]) curr_frame = curr_frame[1:] curr_frame = np.insert(curr_frame, [window_size-2], predicted[-1], axis=0) return predicted
# In[40]: # Fit Train data with 10% data used for model inferencing. model.fit(X_train, y_train, validation_split=0.1, epochs=50, batch_size=250, callbacks=[checkpointer], verbose=1) # Load best weights from saved model checkpoint model.load_weights('weights.best.DeepNN.hdf5') # predict on test data y_pred = model.predict(X_test) # In[39]: # Compute MAE from predicted and actual loss print("Mean Absolute error: %.2f" % performance_metric(np.exp(y_test), np.exp(y_pred))) # In[48]: test_ids = df_test['id'] # In[53]: def save_predictions(ids=None, predictions=None, file=None):
disc_model.trainable = False adv_input = Input(shape=(100, )) x = generator_model(adv_input) adv_output = disc_model(x) adv_model = Model(inputs=adv_input, outputs=adv_output) adv_model.compile(loss='binary_crossentropy', optimizer='adam') adv_model.summary() ################################ train ################################## print("On commence l'entrainement") A_loss = [] for i in range(5000): print("nb -> " + str(i)) noise = np.random.uniform(-1, 1, size=[256, 100]) image_fake = generator_model.predict(noise) imageBatch = X_train[np.random.randint(0, X_train.shape[0], size=256)] y_true = np.ones(256) y_true *= 0.9 y_false = np.zeros(256) x = np.concatenate([imageBatch, image_fake]) y = np.concatenate([y_true, y_false]) disc_model.trainable = True d_loss = disc_model.train_on_batch(x, y) noise = np.random.uniform(-1, 1, size=[256, 100]) y = np.ones(256)
# Initialising the ANN classifier = Sequential() # Adding the input layer and the first hidden layer classifier.add( Dense(output_dim=6, init='uniform', activation='relu', input_dim=11)) # Adding the second hidden layer classifier.add(Dense(output_dim=6, init='uniform', activation='relu')) # Adding the output layer classifier.add(Dense(output_dim=1, init='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, nb_epoch=100) # Part 3 - Making the 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)
from keras.models import Sequential from keras.layers import Dense, Activation from keras.optimizers import RMSprop, adam import numpy as np x_data = [[73., 80., 75.], [93., 88., 93.], [89., 91., 90.], [96., 98., 100.], [73., 66., 70.]] #shape(5,3) y_data = [[152.], [185.], [180.], [196.], [142.]] model = Sequential() model.add(Dense(input_dim=3, units=1)) # 입력의 갯수 input_dim, units은 출력의 shape model.add(Activation('linear')) #활성화함수 선형차원 rmsprop = adam(lr=0.01) #RMSprop adagrad의 단점을 보완한 옵티마이져 model.compile(loss='mse', optimizer=rmsprop) model.fit(x_data, y_data, epochs=10000) #fit 트레이닝 y_predict = model.predict(np.array([[95., 100., 80]])) print(y_predict)
# create and fit the LSTM network model = Sequential() model.add(LSTM(32, input_shape=(look_back, 1))) # model.add(LSTM(16, return_sequences=True)) # model.add(LSTM(16)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam', metrics=['acc']) model.fit(trainX, trainY, epochs=200, batch_size=1, verbose=2, callbacks=[EarlyStopping(monitor='loss', patience=2), tensorboard]) # make predictions trainPredict = model.predict(trainX) 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 RMSE' % (trainScore)) testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0])) print('Test Score: %.2f RMSE' % (testScore)) # shift train predictions for plotting trainPredictPlot = np.empty_like(dataset) trainPredictPlot[:, :] = np.nan
'validation_data': (X_test, Y_test) }) # Fitting the model model.fit( **keras_dict ) yhat = [] if (train_test_split > 0): # Getting the last n time series _, X_test, _, _ = create_train_test() # Making the prediction list yhat = [y[0] for y in model.predict(X_test)] print(X_test) if len(yhat) > 0: # Constructing the forecast dataframe fc = data.tail(len(yhat)).copy() fc.reset_index(inplace=True) fc['forecast'] = yhat # Ploting the forecasts plt.figure(figsize=(12, 8)) for dtype in ['Sales', 'forecast']: plt.plot( 'Date',
# Part 3 - Making the predictions and visualising the results # Getting the real stock price of 2017 dataset_test = pd.read_csv('Google_Stock_Price_Test.csv') real_stock_price = dataset_test.iloc[:, 1:2].values # Getting the predicted stock price of 2017 dataset_total = pd.concat((dataset_train['Open'], dataset_test['Open']), axis = 0) inputs = dataset_total[len(dataset_total) - len(dataset_test) - 60:].values inputs = inputs.reshape(-1,1) inputs = sc.transform(inputs) X_test = [] for i in range(60, 80): X_test.append(inputs[i-60:i, 0]) X_test = np.array(X_test) X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1)) predicted_stock_price = regressor.predict(X_test) predicted_stock_price = sc.inverse_transform(predicted_stock_price) # Visualising the results plt.plot(real_stock_price, color = 'red', label = 'Real Google Stock Price') plt.plot(predicted_stock_price, color = 'blue', label = 'Predicted Google Stock Price') plt.title('Google Stock Price Prediction') plt.xlabel('Time') plt.ylabel('Google Stock Price') plt.legend() plt.show()
max_words = 200 input_length = 10 model = Sequential() model.add(Embedding(max_words, embedding_dim, input_length=input_length)) model.add(Convolution1D(128, kernel_size=3, activation='relu')) # 10 - 3 + 1 = 8 model.add(Convolution1D(64, kernel_size=3, activation='relu')) # 10 - 3 + 1 = 6 model.add(Convolution1D(32, kernel_size=3, activation='relu')) # 10 - 3 + 1 = 4 model.add(Flatten()) # 128 = 32 * 4 model.add(Dropout(0.2)) model.add(Dense(128, activation='sigmoid')) # W = 128 x 128 model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) model.summary() model.compile(loss='mse', optimizer='adam') input_array = np.random.randint(n_in, size=(mb, input_length)) output_array = model.predict(input_array) assert output_array.shape == (mb, 1) print( "Saving model with embedding into several Conv1D layers into Flatten and Dense for backend {} and keras major version {}" .format(backend, major_version)) model.save("{}embedding_conv1d_extended_{}_{}.h5".format( base_path, backend, major_version))
def run_gru(s): x_dims = len(x_cols[s.dataSet]) if s.dataSet in x_cols else s.lookback random.seed(6) np.random.seed(6) rnn = Sequential() rnn.add( GRU(s.nodes, input_shape=(None, x_dims), kernel_initializer='he_uniform', stateful=False)) #rnn.add(Dropout(0.15)) rnn.add(Dense(1, kernel_initializer='he_uniform')) opt = adam(lr=s.lr, decay=0.0) #1e-3) rnn.compile(loss='mae', optimizer=opt) # prepare dataset as pyBrain sequential dataset sequence = readDataSet(s.dataSet, s.dataSetDetailed, s) if s.limit_to: sequence = sequence[:s.limit_to] dp = DataProcessor() # standardize data by subtracting mean and dividing by std #(meanSeq, stdSeq) = dp.normalize('data', sequence) dp.windowed_normalize(sequence) for key in sequence.keys(): if key != "data": dp.normalize(key, sequence) predictedInput = np.zeros((len(sequence), )) targetInput = np.zeros((len(sequence), )) trueData = np.zeros((len(sequence), )) if s.dataSet in differenceSets: predictedInputNodiff = np.zeros((len(sequence), )) targetInputNodiff = np.zeros((len(sequence), )) if s.dataSet in differenceSets: backup_sequence = sequence sequence = dp.difference(sequence, s.lookback) allX = getX(sequence, s) allY = np.array(sequence['data']) for i in range(60): print i, sequence['data'][i] allX = allX[28:] allY = allY[48:] #if s.dataSet not in x_cols: # allY = allY[s.lookback:] trainX = allX[0:s.nTrain] trainY = allY[s.predictionStep:s.nTrain + s.predictionStep] print trainX[0] print trainY[0] trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) curBatch = 1.0 callback = LossCallback() temp_set = np.array(sequence['data'])[:48 + s.nTrain + 5] configure_batches(48, s.batch_size, np.reshape(temp_set, (temp_set.shape[0], 1, 1))) rnn.fit(trainX, trainY, epochs=s.epochs, batch_size=s.batch_size, verbose=min(s.max_verbosity, 2), callbacks=[callback]) for i in xrange(0, s.nTrain): targetInput[i] = allY[i + s.predictionStep] for i in tqdm(xrange(s.nTrain + s.predictionStep, len(allX)), disable=s.max_verbosity == 0): if i % s.retrain_interval == 0 and i > s.numLags + s.nTrain and s.online: trainX = allX[i - s.nTrain - s.predictionStep:i - s.predictionStep] trainY = allY[i - s.nTrain:i] trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) temp_set = np.array(sequence['data'])[i - s.nTrain - s.predictionStep - 48:i] configure_batches(48, s.batch_size, np.reshape(temp_set, (temp_set.shape[0], 1, 1))) rnn.fit(trainX, trainY, epochs=s.epochs, batch_size=s.batch_size, verbose=2, callbacks=[callback]) targetInput[i] = allY[i + s.predictionStep] predictedInput[i] = rnn.predict(np.reshape(allX[i], (1, 1, x_dims))) if i == 12546: print allX[i] print targetInput[i] if s.dataSet in differenceSets: predictedInputNodiff[i] = predictedInput[i] targetInputNodiff[i] = targetInput[i] predictedInput[i] = dp.inverse_difference(backup_sequence['data'], predictedInput[i], i - 1) targetInput[i] = dp.inverse_difference(backup_sequence['data'], targetInput[i], i - 1) predictedInput[0] = 0 trueData[i] = sequence['data'][i] #predictedInput = dp.denormalize(predictedInput, meanSeq, stdSeq) #targetInput = dp.denormalize(targetInput, meanSeq, stdSeq) dp.windowed_denormalize(predictedInput, targetInput) if s.dataSet in differenceSets: # predictedInputNodiff = dp.denormalize(predictedInputNodiff) # targetInputNodiff = dp.denormalize(targetInputNodiff) pass #trueData = (trueData * stdSeq) + meanSeq dp.saveResultToFile(s.dataSet, predictedInput, targetInput, 'gru', s.predictionStep, s.max_verbosity) skipTrain = error_ignore_first[s.dataSet] from plot import computeSquareDeviation squareDeviation = computeSquareDeviation(predictedInput, targetInput) squareDeviation[:skipTrain] = None nrmse = np.sqrt(np.nanmean(squareDeviation)) / np.nanstd(targetInput) if s.max_verbosity > 0: print "", s.nodes, "NRMSE {}".format(nrmse) mae = np.nanmean(np.abs(targetInput - predictedInput)) if s.max_verbosity > 0: print "MAE {}".format(mae) if s.dataSet in differenceSets: dp.saveResultToFile(s.dataSet, predictedInputNodiff, targetInputNodiff, 'gru_nodiff', s.predictionStep, s.max_verbosity) squareDeviation = computeSquareDeviation(predictedInputNodiff, targetInputNodiff) squareDeviation[:skipTrain] = None nrmse = np.sqrt( np.nanmean(squareDeviation)) / np.nanstd(targetInputNodiff) if s.max_verbosity > 0: print "", s.nodes, "NRMSE {}".format(nrmse) mae = np.nanmean(np.abs(targetInputNodiff - predictedInputNodiff)) if s.max_verbosity > 0: print "MAE {}".format(mae) mase = errors.get_mase(predictedInput, targetInput, np.roll(targetInput, 24)) if s.max_verbosity > 0: print "MAE {}".format(mae) return nrmse
model = Sequential() model.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(64, (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.5)) model.add(Dense(num_classes, activation='softmax')) # tb = TensorBoard(log_dir='./logs', histogram_freq=0) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.1) score = model.evaluate(x_test, y_test, verbose=0) pred = model.predict(x_test) numpy.savetxt('pred.csv', pred, delimiter=',') model.save("my_model.h5") print('Test loss:', score[0]) print('Test accuracy:', score[1]) model.save('cnn.h5')
# Train the model using SGD print('[INFO]: Training....') sgd = SGD(0.01) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) H = model.fit(train_x, train_y, validation_data=(test_x, test_y), epochs=100, batch_size=128) # Test the network print('[INFO]: Testing....') predictions = model.predict(test_x, batch_size=128) print( classification_report(test_y.argmax(axis=1), predictions.argmax(axis=1), target_names=[str(x) for x in lb.classes_])) plt.style.use('ggplot') plt.figure() plt.plot(np.arange(0, 100), H.history['loss'], label='train_loss') plt.plot(np.arange(0, 100), H.history['val_loss'], label='val_loss') plt.plot(np.arange(0, 100), H.history['acc'], label='train_acc') plt.plot(np.arange(0, 100), H.history['val_acc'], label='val_acc') plt.title('Training Loss & Accuracy') plt.xlabel('Epoch #') plt.ylabel('Loss/Accuracy') plt.legend()
# Evaluation on the test data test_files_names= test_set.filenames os.getcwd() os.chdir("D:\\NUS\\Semester1\\CI\\Neural Network\\Assignments_NN\\datasets\\test") training_set_arch1.class_indices predicted_labels_arch1=[] predicted_category_arch1=[] for i in range(len(test_files_names)): test_image = image.load_img(test_files_names[i], target_size = (32, 32)) test_image = image.img_to_array(test_image) test_image = np.expand_dims(test_image, axis = 0) result_arch1 = classmodel.predict(test_image) predicted_labels_arch1.append(result_arch1[0][0]) if result_arch1[0][0] == 1: prediction = 'woman' else: prediction = 'man' predicted_category_arch1.append(prediction) actual_category_arch1=[] for i in range(len(test_files_names)): actual_category_arch1.append([test_files_names[i].split("\\")][0][0]) confusion_matrix(actual_category_arch1,predicted_category_arch1) tn1, fp1, fn1, tp1 = confusion_matrix(actual_category_arch1,predicted_category_arch1).ravel()
model.add(Dense(1)) model.compile(optimizer='adam', loss='mae') model.summary() model.fit_generator(generator, epochs=100) model.history.history.keys() loss_per_epoch = model.history.history['loss'] plt.plot(range(len(loss_per_epoch)), loss_per_epoch) first_eval_batch = scaled_train[-90:] first_eval_batch first_eval_batch = first_eval_batch.reshape((1, 90, n_features)) test_predictions = [] first_eval_batch = scaled_train[-n_input:] current_batch = first_eval_batch.reshape((1, n_input, n_features)) for i in range(len(test)): current_pred = model.predict(current_batch)[0] test_predictions.append(current_pred) current_batch = np.append(current_batch[:, 1:, :], [[current_pred]], axis=1) true_predictions = scaler.inverse_transform(test_predictions) true_predictions test['Predictions'] = true_predictions Y_true = df.iloc[train_len:] Y_pred = test["Predictions"] from sklearn.metrics import mean_squared_error, mean_absolute_error MSE = mean_squared_error(Y_true, Y_pred) MAE = mean_absolute_error(Y_true, Y_pred) plt.plot(test["Predictions"], label="Pred", color="black", zorder=1)
import numpy as np from keras.models import Sequential from keras.layers.core import Dense # Define Training DATA i.e, Or Gate Inputs input = np.array([[1], [0]]) output = np.array([[0], [1]]) # Model Definition model = Sequential() model.add(Dense(16, input_dim=1, activation='linear')) model.add(Dense(1, activation='linear')) model.compile(loss='mean_squared_error', optimizer='adam', metrics=['binary_accuracy']) # Train Model model.fit(input, output, nb_epoch=100, verbose=2) # Validation print("Round off Values: \n", model.predict(input).round()) print("Actual Values: \n", model.predict(input))
classifier.add(Dense(128, activation='relu')) classifier.add(Dense(10, activation='softmax')) #compiling CNN classifier.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) classifier.fit(X_train, y_train, batch_size=32, epochs=30, validation_data=(X_test, y_test)) #predict values from validation set Y_pred = classifier.predict(X_test) # Convert predictions classes to one hot vectors Y_pred_classes = np.argmax(Y_pred, axis=1) # Convert validation observations to one hot vectors Y_true = np.argmax(y_test, axis=1) #plot confusion matrix from sklearn.metrics import confusion_matrix conf_matrix = confusion_matrix(Y_true, Y_pred_classes) #predicting test set results = classifier.predict(test) results = np.argmax(results, axis=1) results = pd.Series(results, name="label") g = plt.imshow(test[2][:, :, 0])
y = np_utils.to_categorical(dataY) # define the LSTM model model = Sequential() model.add( LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(256)) model.add(Dropout(0.2)) model.add(Dense(y.shape[1], activation='softmax')) # load the network weights filename = "chinese_shiji_lstm_model_20161123" model.load_weights(filename) model.compile(loss='categorical_crossentropy', optimizer='adam') # pick a random seed start = numpy.random.randint(0, len(dataX) - 1) pattern = dataX[start] print "Seed:" print "\"", ''.join([int_to_char[value] for value in pattern]), "\"" # generate characters for i in range(1000): x = numpy.reshape(pattern, (1, len(pattern), 1)) x = x / float(n_vocab) prediction = model.predict(x, verbose=0) index = numpy.argmax(prediction) result = int_to_char[index] seq_in = [int_to_char[value] for value in pattern] sys.stdout.write(result) pattern.append(index) pattern = pattern[1:len(pattern)] print "\nDone."
Pool_Valid_Loss = Valid_Loss print('Evaluating Test Accuracy Without Acquisition') score, acc = model.evaluate(X_test, Y_test, show_accuracy=True, verbose=0) all_accuracy = acc print('Starting Active Learning') for i in range(acquisition_iterations): print('POOLING ITERATION', i) score_All = np.zeros(shape=(X_Pool.shape[0], nb_classes)) for d in range(dropout_iterations): print('Dropout Iteration', d) dropout_score = model.predict(X_Pool, batch_size=batch_size, verbose=1) np.save( '/Users/Riashat/Documents/Cambridge_THESIS/Code/Experiments/keras/active_learning/Acquisition_Functions/Bayesian_Active_Learning/GPU/Max_Entropy/Dropout_Scores/' + 'Dropout_Score_' + str(d) + '.npy', dropout_score) score_All = score_All + dropout_score Avg_Pi = np.divide(score_All, dropout_iterations) Log_Avg_Pi = np.log2(Avg_Pi) Entropy_Avg_Pi = -np.multiply(Avg_Pi, Log_Avg_Pi) Entropy_Average_Pi = np.sum(Entropy_Avg_Pi, axis=1) U_X = Entropy_Average_Pi # THIS FINDS THE MINIMUM INDEX # a_1d = U_X.flatten() # x_pool_index = a_1d.argsort()[-Queries:]
test_datagen = ImageDataGenerator(rescale = 1./255) training_set = train_datagen.flow_from_directory('dataset/training_set', target_size = (64, 64), batch_size = 32, class_mode = 'binary') test_set = test_datagen.flow_from_directory('dataset/test_set', target_size = (64, 64), batch_size = 32, class_mode = 'binary') classifier.fit_generator(training_set, steps_per_epoch = 8000, epochs = 25, validation_data = test_set, validation_steps = 2000) # Part 3 - Making new predictions import numpy as np from keras.preprocessing import image test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', target_size = (64, 64)) test_image = image.img_to_array(test_image) test_image = np.expand_dims(test_image, axis = 0) result = classifier.predict(test_image) training_set.class_indices if result[0][0] == 1: prediction = 'dog' else: prediction = 'cat'
X_test = np.array(X_test) X_test.shape y_test = np.array(y_test) y_test.shape classifier.fit(X_train, y_train, batch_size=1000, epochs=10, validation_data=(X_test, y_test)) score, accuracy = classifier.evaluate(X_test, y_test) print('Test Score = ', score) print('Test Accuracy = ', accuracy) ############################ Preddict any random Value ############################### name = ["jagat jyoti mishra"] input_data = [] for i in name: tmp = [set_flag(char_index[j]) for j in str(i)] for k in range(0, 30 - len(str(i))): tmp.append(set_flag(char_index["END"])) input_data.append(tmp) input_data = np.array(input_data) classifier.predict(input_data)
x_train = x_train.reshape(x_train.shape[0],x_train.shape[1],1) print("x_train.shape : ", x_train.shape) # LSTM 모델을 완성하시오 # 2. 모델구성 model = Sequential() model.add(LSTM(17,activation='relu',input_shape=(4,1))) model.add(Dense(42)) model.add(Dense(39)) model.add(Dense(41)) model.add(Dense(1)) model.summary() # 3. 실행 from keras.callbacks import EarlyStopping els = EarlyStopping(monitor='loss', patience=8, mode='auto') model.compile(optimizer='adam',loss = 'mse') model.fit(x_train,y_train,epochs=20,batch_size=1,callbacks=[]) # 4. 테스트 x_predict = np.array([7,8,9,10]) print("x_predict.shape : ", x_predict.shape) x_predict = x_predict.reshape(x_predict[0],1) print("x_predict.shape : ", x_predict.shape) # x_predict = x_predict.reshape(x_predict[1],x_predict[0],1) print(x_predict,"\n",x_predict.shape) y_predict = model.predict(x_predict) print(y_predict)
optimizer='adam', metrics=['mean_absolute_error']) model.summary() #DEFINE THE CHECKPOINT from keras.callbacks import ModelCheckpoint checkpoint_name = 'Weights-{epoch:03d}--{val_loss:.5f}.hdf5' checkpoint = ModelCheckpoint(checkpoint_name, monitor='val_loss', verbose=1, save_best_only=True, mode='auto') callbacks_list = [checkpoint] model.fit(img_flat, df_y, epochs=10, batch_size=32, validation_split=0.2, callbacks=callbacks_list) #Save the good weights into a file wights_file = 'Weights-006--34.30850.hdf5' # choose the best checkpoint based on the name model.load_weights(wights_file) # load it model.compile(loss='mean_absolute_error', optimizer='adam', metrics=['mean_absolute_error']) predictions = model.predict(img_flat_test)
batch_size=512) #plot of training and validation loss with each epoch plt.clf() loss = history.history['loss'] val_loss = history.history['val_loss'] epochs = range(1, len(loss) + 1) plt.plot(epochs, loss, 'g', label='Training loss') plt.plot(epochs, val_loss, 'y', label='Validation loss') plt.title('Training and validation loss') plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() plt.show() #plot of training and validation accuracy with each epoch plt.clf() acc = history.history['acc'] val_acc = history.history['val_acc'] plt.plot(epochs, acc, 'g', label='Training acc') plt.plot(epochs, val_acc, 'y', label='Validation acc') plt.title('Training and validation accuracy') plt.xlabel('Epochs') plt.ylabel('Accuracy') plt.legend() plt.show() #predicting the test set results y_pred = model_lstm.predict(X_test) y_pred = np.argmax(y_pred, axis=1)
model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.3)) model.add(Dense(num_labels)) model.add(Activation('softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, batch_size=batch_size, epochs=30, verbose=1, validation_split=0.1) score = model.evaluate(x_test, y_test, batch_size=batch_size, verbose=1) print('Test accuracy:', score[1]) text_labels = encoder.classes_ for i in range(10): prediction = model.predict(np.array([x_test[i]])) print(prediction) predicted_label = text_labels[np.argmax(prediction[0])] print('Actual Class:' + Y_test[i]) print("Predicted Class: " + predicted_label)
image_arr = cv2.imread(image, cv2.IMREAD_UNCHANGED) image_arr = cv2.cvtColor(image_arr, cv2.COLOR_BGR2RGB ) T.append(cv2.resize(image_arr , (width, height), interpolation=cv2.INTER_AREA)) return T test = read_process_images(test_images) # test x_test = np.array(test) x_test.shape test_datagen = ImageDataGenerator(rescale=1./255) test_generator = test_datagen.flow(x_test, batch_size=batch_size) y_pred = np.argmax(model.predict(x_test), axis=-1) y_pred """JSON FILE GENERATION """ # initializing lists image_list = [] import os # 1.Get file names from directory image_list=os.listdir(r"/content/drive/My Drive/NewData/test_anonymous/") image_list.sort() print(image_list)
plt.plot(history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'validation'], loc='upper left') plt.show() # "Loss" plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'validation'], loc='upper left') plt.show() #--------------------------------------------------------------------------------- performace = classifier.evaluate(X_test,y_test) y_pred = classifier.predict_classes(X_test) result = classifier.predict(X_test) prob = classifier.predict_proba(X_test) np.savetxt("prob.csv",prob,fmt="%s",delimiter=",") from keras.models import load_model classifier.save('FCN.h5') model = load_model('FCN.h5')
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy',mcor,precision,recall, f1]) history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.1,callbacks=[early_stopping]) score = model.evaluate(x_val, y_val, batch_size=batch_size, verbose=1) score1 = score[0] acc1 = score[1] print('Test score:', score[0]) print('Test accuracy:', score[1]) predictions = model.predict(x_val,batch_size,1) # prec = precision(y_val,predictions) # r = recall(y_val,predictions) # f1_score = f1(y_val,predictions) TP = y_val*predictions TP_sum = 0 FP_sum = 0 FN_sum = 0 i = 0 for pred in predictions: print "Prediction: "+str(pred) print "Y valuation: "+str(y_val[i]) if pred[0] > 0.5 and y_val[i][0] == 1: TP_sum = TP_sum + 1 if pred[0] > 0.5 and y_val[i][0]==0: