def train_net(steps, epochs): # Get images X = [] for filename in os.listdir('./color_images/Train/'): X.append(img_to_array(load_img('./color_images/Train/' + filename))) # print(filename) X = np.array(X, dtype=float) # Set up training and test data split = int(0.95 * len(X)) Xtrain = X[:split] Xtrain = 1.0 / 255 * Xtrain # Design the neural network model = Sequential() model.add(InputLayer(input_shape=(None, None, 1))) model.add(Conv2D(8, (3, 3), input_shape=(None, None, 1), activation='relu', padding='same', strides=2)) model.add(Conv2D(8, (3, 3), activation='relu', padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same', strides=2)) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(Conv2D(32, (3, 3), activation='relu', padding='same', strides=2)) model.add(UpSampling2D((2, 2))) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(2, (3, 3), activation='tanh', padding='same')) # Finish model model.compile(optimizer='rmsprop', loss='mse') # Image transformer datagen = ImageDataGenerator( shear_range=0.2, zoom_range=0.2, rotation_range=20, horizontal_flip=True) # Generate training data batch_size = 50 def image_a_b_gen(batch_size): for batch in datagen.flow(Xtrain, batch_size=batch_size): lab_batch = rgb2lab(batch) X_batch = lab_batch[:, :, :, 0] Y_batch = lab_batch[:, :, :, 1:] / 128 yield (X_batch.reshape(X_batch.shape + (1,)), Y_batch) # Train model TensorBoard(log_dir='/output') model.fit_generator(image_a_b_gen(batch_size), steps_per_epoch=steps, epochs=epochs) # Test images Xtest = rgb2lab(1.0 / 255 * X[split:])[:, :, :, 0] Xtest = Xtest.reshape(Xtest.shape + (1,)) Ytest = rgb2lab(1.0 / 255 * X[split:])[:, :, :, 1:] Ytest = Ytest / 128 print(model.evaluate(Xtest, Ytest, batch_size=batch_size)) model.save('./result/network.h5') del model
def long_short_term_memory(data, settings): """Creates a Long short-term memory model (LSTM) and predictions. Args: data: pandas.DataFrame. settings: Dictionary object containing settings parameters. Returns: A dictionary containing the LSTM model and predictions. """ # INSTANTIATE MODEL model = Sequential() # TRAIN DATA GENERATOR train_generator = create_generator(data['train'], settings['morph'], shuffle=True) # ADDING LAYERS TO MODEL add_lstm_layers(model, data, settings, train_generator[0][0].shape) # COMPILE THE MODEL model.compile(loss=settings['loss'], optimizer=settings['optimizer']) # TRAIN USING TRAIN DATA model.fit_generator(train_generator, steps_per_epoch=len(train_generator), epochs=settings['epochs'], verbose=0) # TEST DATA GENERATOR test_generator = create_generator(data['test'], settings['morph'], shuffle=False) # PREDICT USING TEST DATA predictions = model.predict(test_generator) # denormalized_predictions = "" return {'model': model, 'predictions': predictions}
def runTrainingClassification(uuid, datasetDir, validDir, classNum, dropoutValue=0.2, batch_size=128, nb_epoch=20, step_size_train=10, alphaVal=0.75, depthMul=1): imageGen = ImageDataGenerator(rotation_range=30, width_shift_range=0.35, height_shift_range=0.35, zoom_range=0.35, shear_range=0.35, vertical_flip=False, horizontal_flip=False, brightness_range=[0.65, 1.35], rescale=1. / 255) trainSet = imageGen.flow_from_directory(datasetDir, target_size=(224, 224), color_mode='rgb', batch_size=batch_size, class_mode='categorical', shuffle=True) validSet = imageGen.flow_from_directory(validDir, target_size=(224, 224), color_mode='rgb', batch_size=32, class_mode='categorical', shuffle=True) class EarlyStoppingAtMinLoss(tf.keras.callbacks.Callback): def __init__(self, patience=3): super(EarlyStoppingAtMinLoss, self).__init__() self.patience = patience self.best_weights = None def on_train_begin(self, logs=None): self.wait = 0 self.stopped_epoch = 0 self.best = np.Inf self.last_acc = 0 self.atleastepoc = 0 def on_epoch_end(self, epoch, logs=None): current = logs.get('val_loss') val_acc = logs.get('val_acc') self.atleastepoc = self.atleastepoc + 1 if np.less(current, self.best ) or self.last_acc < 0.95 or self.atleastepoc < 25: self.best = current self.wait = 0 self.last_acc = val_acc self.best_weights = self.model.get_weights() else: self.wait += 1 if self.wait >= self.patience: self.stopped_epoch = epoch self.model.stop_training = True print( '\nRestoring model weights from the end of the best epoch.' ) self.model.set_weights(self.best_weights) def on_train_end(self, logs=None): if self.stopped_epoch > 0: print('Epoch %05d: early stopping' % (self.stopped_epoch + 1)) base_model = tf.keras.applications.MobileNet(input_shape=(224, 224, 3), alpha=alphaVal, depth_multiplier=depthMul, dropout=dropoutValue, pooling='avg', include_top=False, weights="imagenet", classes=classNum) mbnetModel = Sequential([ base_model, Dropout(dropoutValue, name='dropout'), Dense(classNum, activation='softmax') ]) if classNum == 2: mbnetModel.compile(loss='binary_crossentropy', optimizer=RAdam(), metrics=['accuracy']) else: mbnetModel.compile( loss= 'categorical_crossentropy', #loss_softmax_cross_entropy_with_logits_v2, optimizer=RAdam(), metrics=['accuracy']) history = History() try: mbnetModel.fit_generator(generator=trainSet, steps_per_epoch=step_size_train, callbacks=[EarlyStoppingAtMinLoss(), history], epochs=50, validation_data=validSet) except Exception as e: return (-14, f'Unexpected Error Found During Triaining, {e}') mbnetModel.save(f'{localSSDLoc}trained_h5_file/{uuid}_mbnet10.h5') converter = tf.lite.TFLiteConverter.from_keras_model_file( f'{localSSDLoc}trained_h5_file/{uuid}_mbnet10.h5', custom_objects={ 'RAdam': RAdam, 'loss_softmax_cross_entropy_with_logits_v2': loss_softmax_cross_entropy_with_logits_v2 }) tflite_model = converter.convert() open(f'{localSSDLoc}trained_tflite_file/{uuid}_mbnet10_quant.tflite', "wb").write(tflite_model) subprocess.run([ f'{nncaseLoc}/ncc', f'{localSSDLoc}trained_tflite_file/{uuid}_mbnet10_quant.tflite', f'{localSSDLoc}trained_kmodel_file/{uuid}_mbnet10_quant.kmodel', '-i', 'tflite', '-o', 'k210model', '--dataset', validDir ]) if os.path.isfile( f'{localSSDLoc}trained_kmodel_file/{uuid}_mbnet10_quant.kmodel'): return ( 0, f'{localSSDLoc}trained_kmodel_file/{uuid}_mbnet10_quant.kmodel', history, validSet, mbnetModel) else: return (-16, 'Unexpected Error Found During generating Kendryte k210model.')
check_point = ModelCheckpoint(file_name, monitor='val_my_metric', verbose=0, save_best_only=True, save_weights_only=False, mode='auto', period=1) tensor_board = TensorBoard(log_dir='logs/' + file_name[:-3] + '/', histogram_freq=0, write_graph=True, write_images=False) result = mlp.fit_generator(generator=generator(steps_per_epoch), steps_per_epoch=steps_per_epoch, epochs=training_epochs, shuffle=shuffle_samples, validation_data=(valid_x, valid_y), verbose=2, callbacks=[check_point, tensor_board]) print( "*************************Finish the softmax output layer training*****************************" ) # saver.save(sess, 'ckpt/sae.ckpt', global_step=epoch) # pred = mlp.predict(h # print(np.mean(np.abs(pred-train_y[-DATA_A_DAY:]))) mae = validate(mlp) predict(mlp) end = datetime.datetime.now()
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) """# Train the model""" import time #Total number of steps (batches of samples) to yield from generator before declaring one epoch finished steps = train_generator.n//train_generator.batch_size start = time.time() try: history = model.fit_generator(train_generator, epochs=20, verbose=1, steps_per_epoch = steps, validation_data = test_generator, validation_steps = test_generator.n//test_generator.batch_size ) except KeyboardInterrupt: pass end = time.time() enc_time = end-start print('Execution time:') print(str(enc_time)) print() """# Save the model""" filename = os.path.join(to_save, 'test2.h5') model.save(filename)
model.add(SeparableConv1D(10, kernel_size_second_layer, activation="relu")) model.add(AveragePooling1D()) model.add(SeparableConv1D(3, kernel_size_third_layer, activation="relu")) model.add(GlobalAveragePooling1D()) model.add(Dense(1, activation="sigmoid")) model.compile(optimizer=Adam(), loss="binary_crossentropy", metrics=["accuracy"]) model.build() model.summary() history = model.fit_generator( train_generator, epochs=1, validation_data=validation_generator, class_weight={ 0: 0.5, # false 1: 0.5 # true }, callbacks=[EarlyStopping(monitor="val_loss", patience=5)]) def plot_history(history): loss = history.history["loss"] val_loss = history.history["val_loss"] epochs = range(1, len(loss) + 1) plt.figure() plt.plot(epochs, loss, "bo", label="Training loss") plt.plot(epochs, val_loss, "b", label="Validation loss") plt.title("Training and validation loss") plt.legend() # plt.show()
featurewise_std_normalization=False, samplewise_std_normalization=False, zca_whitening=False, rotation_range=15, zoom_range=0.1, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=False, vertical_flip=False) datagen.fit(X_train) # Fit the model history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size), epochs=epochs, validation_data=(X_val, y_val), verbose=2, steps_per_epoch=X_train.shape[0], callbacks=[learning_rate_reduction]) # Plot the loss and accuracy curves for both training and validation sets fig, ax = plt.subplots(2, 1) ax[0].plot(history.history['loss'], color='b', label="Training loss") ax[0].plot(history.history['val_loss'], color='r', label="Validation loss", axes=ax[0]) legend = ax[0].legend(loc='best', shadow=True) ax[1].plot(history.history['acc'], color='b', label="Training accuracy") ax[1].plot(history.history['val_acc'], color='r', label="Validation accuracy")
test_set = test_datagen.flow_from_directory('dataset/test_set', target_size=(28, 28), batch_size=16, class_mode='categorical') # Utilize callback to store the weights of the best model checkpointer = ModelCheckpoint(filepath="best_weights.hdf5", monitor='val_acc', verbose=1, save_best_only=True) # Now it's time to train the model, here we include the callback to our checkpointer history = classifier.fit_generator(training_set, steps_per_epoch=100, epochs=20, callbacks=[checkpointer], validation_data=test_set, validation_steps=50) # Load our classifier with the weights of the best model # classifier.load_weights('best_weights.hdf5') # classifier.save('shapes_cnn.h5') # Displaying curves of loss and accuracy during training acc = history.history['accuracy'] val_acc = history.history['val_accuracy'] loss = history.history['loss'] val_loss = history.history['val_loss'] epochs = range(1, len(acc) + 1)
# Freezes the weights and other trainable parameters in each layer. # They will not be updated when we pass in our images of cats and dogs. for layer in model.layers: layer.trainable = False # add a layer of 2 outputs model.add(Dense(2, activation='softmax')) # print model model.summary() # Same compile as in original model model.compile(optimizer=Adam(learning_rate=.0001), loss='categorical_crossentropy', metrics=['accuracy']) # Learning on 40 images -> 4 steps and 10 images per step model.fit_generator(generator=train_batches, steps_per_epoch=4, validation_data=valid_batches, validation_steps=4, epochs=5, verbose=2) test_imgs, test_labels = next(test_batches) test_labels = test_labels[:,0] # Taking one batch so will be 10 images predictions = model.predict_generator(generator=test_batches, steps=1, verbose=0) print(np.round(predictions[:,0])) cm = confusion_matrix(y_true=test_labels, y_pred=np.round(predictions[:,0])) print('Configuration matrix') print(cm) """
class Classifier: def __init__(self, model_path, class_labels_json): self.class_labels = class_labels_json self.height = 150 self.width = 150 self.model_path = model_path self.model = Sequential() self.class_labels = self.read_class_labels_if_exists() def read_class_labels_if_exists(self): if exists(self.class_labels): with open(self.class_labels, 'r') as file: return json.load(file) else: return None def create(self): model = self.model model.add(Conv2D(32, (3, 3), input_shape=( self.width, self.height, 3))) # this means - 150 x 150 with 3 channels (RGB image) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten() ) # this converts our 3D feature maps to 1D feature vectors model.add(Dense(64)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1)) model.add(Activation('sigmoid')) self.model = self.compile(model) def compile(self, model): model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) return model def fit(self, train, test, model_path): self.model.fit_generator( train, steps_per_epoch=3000 / 16, # step size equal to the image count in train dir / batch size epochs=50, validation_data=test, validation_steps=1000 / 16) # step size equal to the image count in test dir / batch size self.model.save(model_path) def predict(self, path): if exists(self.model_path): model = load_model(self.model_path) X = imgprocess.load_img(path, target_size=(self.width, self.height)) X = imgprocess.img_to_array(X) X = np.expand_dims(X, axis=0) return self.interpret_class(X, model) def interpret_class(self, x, model): # predict_proba = model.predict_proba(x) # if predict_proba[0][0] < 0.5: # return "unknown" classes = model.predict_classes(x) if self.class_labels is None: return classes else: return [ k for k in self.class_labels if (self.class_labels[k] == classes[0][0]) ][0]
scaler = MinMaxScaler() scaler.fit(train) train = scaler.transform(train) test = scaler.transform(test) n_input = 12 n_features = 1 generator = TimeseriesGenerator(train, train, length=n_input, batch_size=6) model = Sequential() model.add(LSTM(200, activation='relu', input_shape=(n_input, n_features))) model.add(Dropout(0.15)) model.add(Dense(1)) model.compile(optimizer='adam', loss='mse') model.fit_generator(generator, epochs=50) pred_list = [] batch = train[-n_input:].reshape((1, n_input, n_features)) for i in range(n_input): pred_list.append(model.predict(batch)[0]) batch = numpy.append(batch[:, 1:, :], [[pred_list[i]]], axis=1) df_predict = pandas.DataFrame(scaler.inverse_transform(pred_list), index=df[-n_input:].index, columns=['Prediction']) df_test = pandas.concat([df, df_predict], axis=1) plt.isinteractive() plt.plot(df_test.index, df_test['Passengers']) plt.plot(df_test.index, df_test['Prediction'], color='r')
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) """# Train the model""" import time #Total number of steps (batches of samples) to yield from generator before declaring one epoch finished steps = train_generator.n//train_generator.batch_size start = time.time() try: history = model.fit_generator(train_generator, epochs=100, verbose=1, steps_per_epoch = steps, validation_data = test_generator, validation_steps = test_generator.n//test_generator.batch_size, callbacks=[keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', patience=8, restore_best_weights=True)] ) except KeyboardInterrupt: pass end = time.time() enc_time = end-start print('Execution time:') print(str(enc_time)) print() """# Save the model""" filename = os.path.join(to_save, 'best1000.h5') model.save(filename)