def train(): from src.sequence.SignRecognitionSequence import SignRecognitionSequence seq = SignRecognitionSequence( './data/train/ppm/signrecognition_data_train.csv', './data/train/ppm/', im_size=IMAGE_SIZE, batch_size=32) X_valid = np.array([load_image(im) for im in seq.X_valid]) y_valid = seq.y_valid tensor_board = TensorBoard(log_dir='logs', histogram_freq=0, write_graph=True, write_images=True) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=0.00001) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=10, verbose=1, mode='auto', baseline=None, restore_best_weights=True) callbacks = [ #tf.keras.callbacks.ModelCheckpoint('models/my_model.h5', verbose=1,save_best_only=True), tensor_board, reduce_lr, early_stopping ] print('--------------------------') print("Performing training...") model = createModel() model.fit_generator(generator=seq, epochs=40, use_multiprocessing=False, workers=1, callbacks=callbacks, validation_data=(X_valid, y_valid)) return model
def finetune(train_path, test_path): train_datagen = ImageDataGenerator() test_datagen = ImageDataGenerator() print("获取测试数据... ...") test_generator = test_datagen.flow_from_directory(test_path, target_size=(224, 224), batch_size=4) print("获取训练数据... ...") train_generator = train_datagen.flow_from_directory(train_path, target_size=(224, 224), batch_size=4) print("开始训练... ...") logging = TensorBoard(log_dir='/home/app/program/micro_emotion/log') early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=1) model_check = ModelCheckpoint(filepath=model_path, monitor='val_loss', save_best_only=True) lr_decay = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, min_delta=0.001) model = RN.resnet10(include_top=False, pooling='avg', input_shape=(224, 224, 3), classes=5) x = model.output x = Dense(5, activation='softmax', name='fc8_micro')(x) model = Model(inputs=model.input, outputs=x) model.load_weights(pre_model, by_name=True) #model = frozen(model) model.compile(loss="categorical_crossentropy", optimizer=SGD(lr=0.01, momentum=0.9, decay=0.1 / 10), metrics=['accuracy']) history = model.fit_generator( train_generator, steps_per_epoch=62, epochs=30, validation_data=test_generator, validation_steps=30, callbacks=[logging, early_stopping, model_check, lr_decay])
def train(self, train_gen, val_gen, saved_model_path, epochs=100, steps=100, train_split=0.8, verbose=1, min_delta=.0005, patience=5, use_early_stop=True): """ train_gen: generator that yields an array of images an array of """ # checkpoint to save model after each epoch save_best = ModelCheckpoint(saved_model_path, monitor='val_loss', verbose=verbose, save_best_only=True, mode='min') # stop training if the validation error stops improving. early_stop = EarlyStopping(monitor='val_loss', min_delta=min_delta, patience=patience, verbose=verbose, mode='auto') callbacks_list = [save_best] if use_early_stop: callbacks_list.append(early_stop) hist = self.model.fit_generator(train_gen, steps_per_epoch=steps, epochs=epochs, verbose=1, validation_data=val_gen, callbacks=callbacks_list, validation_steps=steps * (1.0 - train_split) / train_split) return hist
def train(data, label, score, opts, vars): n_input = data[0].dim n_output = 1 print('load network architecture from ' + opts['network'] + '.py') print('#input: {} \n#output: {}'.format(n_input, n_output)) module = __import__(opts['network']) model = module.getModel(n_input, n_output) train_x = np.empty((len(data), n_input)) train_y = np.empty((len(data), n_output)) print('Data length {}'.format(len(data))) for sample in range(len(data)): train_x[sample] = np.reshape(data[sample], (n_input)) train_y[sample] = score[sample] train_x = train_x.astype('float32') model.compile(loss=correlation_coefficient_loss, optimizer=Adam(lr=0.00001)) #checkpoint #filepath="weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5" #checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=False, mode='max') early_stoppping = EarlyStopping(monitor='loss', min_delta=0.0001, patience=3) callbacks_list = [early_stoppping] model.fit(train_x, train_y, epochs=opts['n_epoch'], batch_size=opts['batch_size'], shuffle=True, callbacks=callbacks_list) vars['n_input'] = n_input vars['n_output'] = n_output vars['model'] = model
def get_callbacks( model_name: str ) -> List[Union[TensorBoard, EarlyStopping, ModelCheckpoint]]: """Accepts the model name as a string and returns multiple callbacks for training the keras model. Parameters ---------- model_name : str The name of the model as a string. Returns ------- List[Union[TensorBoard, EarlyStopping, ModelCheckpoint]] A list of multiple keras callbacks. """ logdir = ("logs/scalars/" + model_name + "_" + datetime.now().strftime("%Y%m%d-%H%M%S") ) # create a folder for each model. tensorboard_callback = TensorBoard(log_dir=logdir) # use tensorboard --logdir logs/scalars in your command line to startup tensorboard with the correct logs early_stopping_callback = EarlyStopping( monitor="val_mean_absolute_percentage_error", min_delta=1, # model should improve by at least 1% patience= 10, # amount of epochs with improvements worse than 1% until the model stops verbose=2, mode="min", restore_best_weights= True, # restore the best model with the lowest validation error ) model_checkpoint_callback = ModelCheckpoint( "./data/models/" + model_name, monitor="val_mean_absolute_percentage_error", verbose=0, save_best_only=True, # save the best model mode="min", save_freq="epoch", # save every epoch ) # saving eff_net takes quite a bit of time return [ tensorboard_callback, early_stopping_callback, model_checkpoint_callback ]
def callback_func(self, B1_dir): # Seek a mininum for validation loss and display the stopped epochs using verbose and adding delays es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=100) # Save best model using checkpoint model_path = os.path.join(B1_dir, 'VGGNet.h5') mcp = ModelCheckpoint(os.path.normcase(model_path), monitor='val_loss', mode='min', verbose=1, save_best_only=True) # Define callback function in a list callback_list = [es, mcp] return callback_list, model_path
def get_callbacks(WEIGHTS_FPATH, LOG_FPATH, monitor): callbacks = [ ModelCheckpoint(WEIGHTS_FPATH, monitor=monitor, save_best_only=True, save_weights_only=True, mode='auto'), EarlyStopping(monitor=monitor, patience=3), #LearningRateScheduler(anneal_lr), #LearningRateTracker(), ReduceLROnPlateau(monitor=monitor, factor=0.2, patience=2, min_lr=1e-7, mode='auto'), CSVLogger(LOG_FPATH, separator=' ', append=True), ] return callbacks
def train(self, train_part_df, validate_part_df, num_fold = 0): """ Keras Training """ print("-----DNN training-----") DNN_Train_Data = self.DNN_DataSet(train_part_df, neg_aug = self.neg_aug) DNN_validate_Data = self.DNN_DataSet(validate_part_df) scores_list = [] callbacks = [ EarlyStopping(monitor='val_loss', patience=self.patience, verbose=0), AccuracyEvaluation(validation_data=DNN_validate_Data, interval=1, cand_class_id_emb_attr = self.cand_class_id_emb_attr, eval_df = validate_part_df, model_type = self.model_type, class_id_dict = self.class_id_dict, class_to_id = self.class_to_id, scores = scores_list, TTA = self.TTA, img_model = self.img_flat_model, flags = self.flags, only_emb = self.only_emb) ] if self.model_type == 'DEM_BC_AUG': datagen = MixedImageDataGenerator( rotation_range=self.rotation_range, shear_range = self.shear_range, zoom_range=self.zoom_range, horizontal_flip=self.horizontal_flip) datagen.fit(DNN_Train_Data[0]) h = self.model.fit_generator( datagen.flow((DNN_Train_Data[0], DNN_Train_Data[1:]), None, batch_size=self.batch_size), validation_data=(DNN_validate_Data, None), steps_per_epoch = DNN_Train_Data[0].shape[0]//self.batch_size, epochs=self.epochs, shuffle=True, verbose = self.verbose, workers=2, use_multiprocessing=False, callbacks=callbacks) else: h = self.model.fit(DNN_Train_Data, validation_data = (DNN_validate_Data, None), epochs=self.epochs, batch_size = self.batch_size, shuffle=True, verbose = self.verbose, callbacks=callbacks) score_df = pd.DataFrame(scores_list, columns = self.class_id_dict.keys()) score_df.index.name = 'Epoch' score_df['Fold'] = num_fold self.scores.append(score_df) return self.model
def train_save_by_early_stop(recommend_model, model, train_data, test_data): """ 训练时按照验证集的loss,early stopping得到最优的模型;最后基于该模型测试 :return: """ if_Train = True if new_Para.param.pairwise else False train_labels = train_data[-1] train_instances_tuple = recommend_model.get_instances( *train_data[:-1], test_phase_flag=if_Train) train_model = recommend_model.get_pairwise_model( ) if new_Para.param.pairwise else model if new_Para.param.pairwise: train_model.compile(optimizer=recommend_model.optimizer, loss=lambda y_true, y_pred: y_pred, metrics=['accuracy']) else: train_model.compile(optimizer=recommend_model.optimizer, loss='binary_crossentropy', metrics=['accuracy']) early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=2, mode='min') hist = train_model.fit([*train_instances_tuple], train_labels, epochs=new_Para.param.num_epochs, batch_size=new_Para.param.small_batch_size, callbacks=[early_stopping], validation_split=new_Para.param.validation_split, shuffle=True) # model.save_weights( dataset.crt_ds.new_model_para_path.format(recommend_model.model_dir, 'min_loss')) # !!! 改正 model_name = recommend_model.get_simple_name() + recommend_model.get_name( ) + '_min_loss' save_loss_acc(hist, model_name, if_multi_epoch=True) epoch_evaluate_result = evalute_by_epoch(recommend_model, model, model_name, test_data) return model
def train_model_gen(self, model, train_images, train_labels, val_images, val_labels): es = EarlyStopping(monitor='loss', mode='min', verbose=1, patience=cfg.patience) # modelcheckpoint mc = ModelCheckpoint(super().get_path_to_save(), monitor='acc', mode='max', save_best_only=True, verbose=1) # tensorborad logdir = os.path.join(cfg.pfad_zu_logs, cfg.keras_model_name) tb = TensorBoard(log_dir=logdir, histogram_freq=0, write_graph=True, write_images=False) callbak = [es, mc, tb] self.compile_model(model) # generate images for training train_datagen, val_datagen = keras_data_gen() train_generator = train_datagen.flow(train_images, train_labels, batch_size=self.__batch_size) # rescale image validation val_generator = val_datagen.flow(val_images, val_labels, batch_size=self.__batch_size) history = model.fit_generator(train_generator, epochs=self.__Num_epochs, steps_per_epoch=len(train_images)//self.__batch_size, validation_data=val_generator, validation_steps=len(val_images)//self.__batch_size, callbacks=callbak) return history
def train_baseline_cnn(emb_layer, x_train, y_train, x_val, y_val, opt): model = CNN(embedding_layer=emb_layer, num_words=opt.transfer_n_words, embedding_dim=opt.baseline_embed_dim, filter_sizes=opt.cnn_filter_shapes, feature_maps=opt.filter_sizes, max_seq_length=opt.baseline_sent_len, dropout_rate=opt.baseline_drop_out_ratio, hidden_units=200, nb_classes=2).build_model() model.compile(loss='categorical_crossentropy', optimizer=optimizers.Adam(), metrics=['accuracy']) # y_train = y_train.reshape(-1, 1) # model = build_model(emb_layer, opt) print(model.summary()) tb_call_back = TensorBoard(log_dir=f'{opt.tbpath}/baseline_cnn_{time()}', histogram_freq=1, write_graph=True, write_images=True) checkpoint = ModelCheckpoint("baseline_cnn.h5", monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) early_stopping = EarlyStopping(monitor='val_loss', patience=2) history = model.fit(x_train, y_train, epochs=opt.baseline_epochs, batch_size=opt.baseline_batchsize, verbose=1, validation_data=(x_val, y_val), callbacks=[early_stopping, tb_call_back, checkpoint]) with open("CNN_train_baseline_history.txt", "w") as f: print(history.history, file=f) return model
def train(model: Sequential, epochs, train_x, train_y, test_x, test_y): model.compile(optimizer=RMSProp(), loss=losses.mean_squared_error, metrics=['accuracy']) print('running for %d epoches.' % epochs) save_model = ModelCheckpoint(MODEL_NAME) stop_model = EarlyStopping(min_delta=0.0002, patience=10) print("start training") model.fit(x=train_x, y=train_y, shuffle=True, batch_size=32, epochs=epochs, validation_data=(test_x, test_y), callbacks=[save_model, stop_model]) print("Done training, Now evaluating.") loss, acc = model.evaluate(x=test_x, y=test_y) print("Final loss: %3.2f Final accuracy: %3.2f" % (loss, acc))
def train(model: Sequential, train_x, train_y, epoches, test_x, test_y, model_file): model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) print('running for %d epoches.' % epoches) save_model = ModelCheckpoint(model_file) stop_model = EarlyStopping(min_delta=0.001, patience=10) model.fit(x=train_x, y=train_y, shuffle=True, batch_size=60, epochs=epoches, validation_data=(test_x, test_y), callbacks=[save_model, stop_model]) print("Done training, Now evaluating.") loss, acc = model.evaluate(x=test_x, y=test_y) print("Final loss: %3.2f Final accuracy: %3.2f" % (loss, acc))
def train(self, train_gen, val_gen, saved_model_path, epochs=100, steps=100, train_split=0.8, verbose=1, min_delta=.0005, patience=5, use_early_stop=True): """ train_gen: generator that yields an array of images an array of """ # checkpoint to save model after each epoch save_best = ModelCheckpoint(saved_model_path, monitor='val_loss', verbose=verbose, save_best_only=True, mode='min') # stop training if the validation error stops improving. early_stop = EarlyStopping(monitor='val_loss', min_delta=min_delta, patience=patience, verbose=verbose, mode='auto') reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=2, min_lr=0.001) callbacks_list = [save_best] callbacks_list.append(reduce_lr) if use_early_stop: callbacks_list.append(early_stop) start = datetime.datetime.now() hist = self.model.fit_generator( train_gen, steps_per_epoch=steps, epochs=epochs, verbose=1, validation_data=val_gen, callbacks=callbacks_list, validation_steps=int(steps * (1.0 - train_split) / train_split)) end = datetime.datetime.now() print('TRAIN TIME:',end-start) return hist
def train(self): #下面使用高阶语句构建模型 model = self.build_model() model.compile(loss='categorical_crossentropy', # optimizer=RMSprop(lr=0.001), optimizer = Adam(lr=self.learn_rate), # optimizer=tf.train.AdamOptimizer(learning_rate=self.learn_rate), metrics=['accuracy']) callbacks = [EarlyStopping( monitor='val_loss', patience=2)] # All images will be rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1./255) test_datagen = ImageDataGenerator(rescale=1./255) # Flow training images in batches of 20 using train_datagen generator train_generator = train_datagen.flow_from_directory( self.train_path, # This is the source directory for training images target_size=(DIVIDE_IMAGE_HEIGHT,DIVIDE_IMAGE_WEIGHT), color_mode='grayscale', batch_size=BATCH_SIZE, # Since we use binary_crossentropy loss, we need binary labels class_mode='categorical') # Flow validation images in batches of 20 using test_datagen generator validation_generator = test_datagen.flow_from_directory( self.valid_path, target_size=(DIVIDE_IMAGE_HEIGHT,DIVIDE_IMAGE_WEIGHT), color_mode='grayscale', batch_size=BATCH_SIZE, class_mode='categorical') history = model.fit_generator( train_generator, epochs=1000, callbacks=callbacks, validation_data=validation_generator, verbose=2) self.model = model model.save(self.model_path)
def get_call_back(lr, batch_size): """ 定义call back :return: """ text = '{}-{}-{}'.format(cfg.base_model_name, batch_size, lr) checkpoint = ModelCheckpoint(filepath='/tmp/ssd-' + text + '.{epoch:03d}.h5', monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=True, save_freq='epoch' ) reduce = ReduceLROnPlateau(monitor='val_loss', factor=0.2, min_delta=2e-3, patience=10, min_lr=1e-5) stop = EarlyStopping(monitor='val_loss', patience=20) # scheduler = LearningRateScheduler(lr_schedule(epochs, lr)) log = TensorBoard(log_dir='log-{}-{}'.format(text, time.strftime("%Y%m%d", time.localtime()))) return [checkpoint, reduce, stop, log]
def partial_training(model, train_data, val_data, epochs): for i in range(len(model.layers)): model.layers[i].trainable = True l_r = 0.00005 model.compile(optimizer=Adam(lr=l_r), loss=dual_loss_weighted, metrics=[BinaryAccuracy()]) hist_1 = model.fit(x=train_data, validation_data=val_data, epochs=epochs, callbacks=[ EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True), ReduceLROnPlateau(patience=4) ]) return model
def train_autoencoder(self, epochs): """Function to train autoencoder :param epochs: Number of epochs :type epochs: int """ self.logger.info("Training autoencoder") callbacks = [ EarlyStopping(monitor='loss', patience=10), ModelCheckpoint('autoencoder_weights.hdf5', monitor='loss', save_best_only=True, verbose=1) ] generator = self._get_generator(self.dataset_dir, self.batch_size, data_type=1) self.autoencoder.fit( generator, epochs=epochs, callbacks=callbacks) # TODO: Add callback to save logs
def retrainModel(): loadDataset() shuffleAndSplitDataset() dataAugmentation() convert2NPArray() cb = EarlyStopping(monitor='acc', min_delta=0.005, patience=0) model = load_model('classifier/model.keras') # model.fit(images_train, labels_train, batch_size=5, epochs=15, verbose=1, validation_split=0.1, callbacks=[cb]) model.fit(images_train, labels_train, batch_size=5, epochs=15, verbose=1, validation_split=0.1) model.save('classifier/model.keras') # Evaluación del modelo result = model.evaluate(images_test, labels_test, verbose=0) print('Testing set accuracy:', result[1]) testModel()
def train(self): start = time.time() early_stop = EarlyStopping(monitor='val_loss', patience=self.early_stop_patience, restore_best_weights=True) tensorboard = TensorBoard(log_dir=f"{os.environ['WORKSPACE']}/logs/{self.seq_info}__{self.get_model_info_str()}__{datetime.now().timestamp()}") # Train model self.training_history = self.model.fit( self.train_x, self.train_y, batch_size=self.batch_size, epochs=self.max_epochs, validation_data=(self.validation_x, self.validation_y), callbacks=[tensorboard, early_stop], shuffle=True ) # Score model self.score = self.model.evaluate(self.validation_x, self.validation_y, verbose=0) self.score = {out: self.score[i] for i, out in enumerate(self.model.metrics_names)} print('Scores:', self.score) end = time.time() self.train_time = end - start
def train(self, x_train, y_train, learning_rate, epochs, batch_size, tb_logs_dir=None, verbose=False): early_stopping_callback = EarlyStopping(monitor="val_loss", patience=25) callbacks = [early_stopping_callback] if bool(tb_logs_dir): date_time = datetime.now().strftime('%Y-%m-%d-%H%M%S') log_name = os.path.join(tb_logs_dir, "{}_{}".format("transfer_net", date_time)) # defining callbacks for training tensorboard_callback = TensorBoard(log_dir=log_name, write_graph=True, write_images=True) callbacks += [tensorboard_callback] x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, train_size=0.8, random_state=1) y_train = tf.keras.utils.to_categorical(y_train, self.num_output_classes) y_val = tf.keras.utils.to_categorical(y_val, self.num_output_classes) self.model.compile(loss="categorical_crossentropy", optimizer=keras.optimizers.Adam(lr=learning_rate), metrics=['accuracy', f1_score]) self.hist = self.model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=verbose, callbacks=callbacks, validation_data=(x_val, y_val))
def fit(self, train_data, train_label, validation_data, validation_label, batch_size, nb_epochs): # TODO exploit 'sample_weight' # TODO implement resumed training with 'initial_epoch' # TODO add documentation callbacks = [] # define checkpoints if self.logdir is not None: # create checkpoint callback checkpoint_path = os.path.join(self.logdir, "cp-{epoch}.ckpt") cp_callback = ModelCheckpoint(filepath=checkpoint_path, verbose=1) callbacks.append(cp_callback) # TODO debug early stopping # define early stopping early_stop = EarlyStopping(monitor="val_categorical_accuracy", min_delta=0, patience=5, verbose=2) callbacks.append(early_stop) # fit model self.history = self.model.fit(x=train_data, y=train_label, batch_size=batch_size, epochs=nb_epochs, verbose=2, callbacks=callbacks, validation_data=(validation_data, validation_label), shuffle=True, sample_weight=None, initial_epoch=0) # update model attribute self.trained = True return
def __init__(self, epochs=5, batch_size=16, lr=1e-5, optimizer='sgd', callbacks=EarlyStopping(patience=3), metrics=['accuracy'], input_shape=(128, 128, 3), n_output=3, loss='mean_squared_error'): self.epochs = epochs self.batch_size = batch_size self.lr = lr self.callbacks = callbacks self.metrics = metrics self.input_shape = input_shape self.n_output = n_output self.otpimizer = optimizer self.loss = loss self.instantiate_model()
def train(self, model_path: str, train_data: 'BatchSequence', train_steps: int, batch_size: int, validation_data: 'BatchSequence', validation_steps: int, epochs: int, verbose: int = 1, min_delta: float = .0005, patience: int = 5) -> tf.keras.callbacks.History: """ trains the model """ model = self._get_train_model() self.compile() callbacks = [ EarlyStopping(monitor='val_loss', patience=patience, min_delta=min_delta), ModelCheckpoint(monitor='val_loss', filepath=model_path, save_best_only=True, verbose=verbose)] history: Dict[str, Any] = model.fit( x=train_data, steps_per_epoch=train_steps, batch_size=batch_size, callbacks=callbacks, validation_data=validation_data, validation_steps=validation_steps, epochs=epochs, verbose=verbose, workers=1, use_multiprocessing=False ) return history
def train(model, train_x, train_y, epochs, test_x, test_y, model_file): model.compile(loss='categorical_crossentropy', optimizer='Adadelta', metrics=['accuracy']) print("Running for {0} epochs.".format(epochs)) savemodel = ModelCheckpoint(model_file) stopmodel = EarlyStopping(min_delta=0.001, patience=10) model.fit(x=train_x, y=train_y, shuffle=True, batch_size=256, epochs=epochs, validation_data=(test_x, test_y), callbacks=[savemodel, stopmodel]) print("Done training. Now evaluating.") loss, acc = model.evaluate(x=test_x, y=test_y) print("Final loss:{0} Final accuracy:{1}".format(loss, acc))
def __setup_callbacks(self) -> List: """ Sets up the callbacks for training :return: the early stopping schedule, tensorboard data and the checkpointer """ # Create a folder for the model log of the current experiment weights_log_path = os.path.join(self.__current_experiment_path, 'weights') # Set up the callback to save the best weights after each epoch checkpointer = ModelCheckpoint(filepath=os.path.join( weights_log_path, 'weights.{epoch:02d}-{val_loss:.2f}.hdf5'), verbose=0, save_best_only=True, save_weights_only=True, monitor='val_loss', mode='min') # Set up Tensorboard tensorboard = TensorBoard(log_dir=os.path.join( self.__current_experiment_path, 'tensorboard'), write_graph=True, histogram_freq=0, write_grads=True, write_images=False, batch_size=self._params.batch_size, update_freq=self._params.batch_size) # Set up early stopping to interrupt the training if val_loss is not increasing after n epochs early_stopping = EarlyStopping(monitor='val_loss', patience=25, mode='min') csv_logger = CSVLogger(os.path.join(self.__current_experiment_path, "training.csv"), append=True) return [early_stopping, tensorboard, checkpointer, csv_logger]
def usingCnnModel(training_data, training_labels, val_data, val_labels): """ This is using the CNN model and setting it up. Args: training_data(numpy arrays): This is the numpy array of the training data. training_labels(numpy arrays): This is the numpy array of the training labels. val_data(numpy arrays): This is the numpy array of the validation data. val_labels(numpy arrays): This is the numpy array of the validation labels. Returns: history(history): This is the history of the classifier. classifier(sequential): This is the cnn model classifier fitted to the training data and labels. """ model_checkpoint = ModelCheckpoint( filepath=os.path.abspath('best_weights.h5'), monitor=monitor_model_checkpoint, save_best_only=True) early_stopping = EarlyStopping( monitor=monitor_early_stopping, patience=patience_num) # original patience =3 classifier = buildClassifier() callbacks_array = [] if use_early_stopping: callbacks_array.append(early_stopping) if use_model_checkpoint: callbacks_array.append(model_checkpoint) print(len(training_data)) history = classifier.fit( training_data, training_labels, epochs=epochs, validation_data=(val_data, val_labels), callbacks=callbacks_array, batch_size=batch_size # steps_per_epoch=int(len(training_data) / batch_size), ) return history, classifier
def run_loss(args): data = args['data'] # For each run we want to get a new random balance data.process() # split, train, test dense_out = len(data.labels[0]) # split for all models X_train_, X_test_, Y_train, Y_test = train_test_split(data.text, data.labels, test_size=0.20, random_state=42) print(args) # Prep data for the LSTM model # This currently will train the tokenizer on all text (unbalanced and train/test) # It would be nice to replace this with a pretrained embedding on larger text tokenizer = Tokenizer(num_words=int(args['max_features']), split=' ') tokenizer.fit_on_texts(data.all_text) X_train = tokenizer.texts_to_sequences(X_train_) X_train = pad_sequences(X_train, maxlen=max_len) X_test = tokenizer.texts_to_sequences(X_test_) X_test = pad_sequences(X_test, maxlen=max_len) # Train the LSTM model lstm_model = simple_lstm(int(args['max_features']), dense_out, X_train.shape[1], int(args['embed_dim']), int(args['lstm_out']), args['dropout']) if args['epochs'] == 0: args['epochs'] = 1 es = EarlyStopping(monitor='val_acc', min_delta=0, patience=6, verbose=0, mode='max') model_hist = lstm_model.fit(X_train, Y_train, epochs=args['epochs'], batch_size=batch_size, verbose=1, validation_data=(X_test, Y_test), callbacks=[es]) lstm_acc = model_hist.history['val_acc'][-1] print("LSTM model accuracy ", lstm_acc) # This minimizes, so the maximize we have to take the inverse :) return 1 - lstm_acc
def train_keras_model(model, input_data, labels, dev_input_data, dev_labels, batch_size, epochs, steps_per_epochs, validation_steps, weights_filename): ''' Method used to train the singletask model implemented and compiled. :param model: the singletask model implemented and compiled :param input_data: arrays of arrays of id tokens :param labels: array of arrays of id tokens :param dev_input_data: array of array of id tokens containing data from dev set :param dev_labels: array of array of id tokens containing data from dev set :param batch_size: integer that indicates the size of batch :param epochs: integer that indicates how much epochs to use to train the model :param steps_per_epochs: integer that indicates how much step per epochs to use to train the model :param validation_steps: integer that indicates how much validation steps per epoch to yse to validate the model :param weights_filename: filepath where save the weights of the model :return: the statistics of the model after that the training is completed. ''' early_stopping = EarlyStopping(monitor="val_loss", patience=2) checkpointer = ModelCheckpoint(filepath="drive/My Drive/" + weights_filename + ".hdf5", monitor='val_loss', verbose=1, save_best_only=True, mode='min') cbk = [early_stopping, checkpointer] print("\nStarting training...") stats = model.fit_generator(batch_generator(input_data, labels, batch_size), steps_per_epoch=steps_per_epochs, epochs=epochs, callbacks=cbk, verbose=1, validation_data=batch_generator( dev_input_data, dev_labels, batch_size), validation_steps=validation_steps) print("Training complete.\n") return stats
def get_agent(name_of_model="model-3_200-50-3"): if False: # is exist return keras.models.load_model('./saved_model.pb') else: x_train = np.asarray(pickle.load(open("X.p", "rb"))) print(x_train.shape) y_train = np.asarray(pickle.load(open("Y.p", "rb"))) nb_class = 3 y_train = keras.utils.to_categorical(y_train, nb_class) model = keras.Sequential() model.add(layers.Dense(200, input_dim=68 * 40, activation='sigmoid')) model.add(layers.Dense(50, activation='sigmoid')) model.add(layers.Dense(3, activation='softmax')) model.summary() model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) from tensorflow.python.keras.callbacks import EarlyStopping # need to understand the f**k ourCallback = EarlyStopping(monitor='val_accuracy', min_delta=0.0001, patience=20, verbose=0, mode='auto', baseline=None, restore_best_weights=False) model.fit(x_train, y_train, epochs=100, batch_size=128, validation_split=0.2, callbacks=[ourCallback]) # model.fit(x_train, y_train, epochs=100, validation_split=0.33) #model.fit(x_train, y_train, epochs=100) model.save(".") return model