def __init__(self, *args, **kws): KerasModelCheckpoint.__init__(self, *args, **kws) if self.filepath.startswith("gs://"): self.on_epoch_end = self._gcp_on_epoch_end self._original_filepath = self.filepath self._temp_file = tempfile.NamedTemporaryFile() self.filepath = self._temp_file.name
def __init__(self, filepath, save_best_only=True, training_set=(None, None), testing_set=(None, None), folder=None, cost_string="log_loss", save_training_dataset=False, verbose=1): ModelCheckpoint.__init__(self, filepath=filepath, save_best_only=save_best_only, verbose=1) self.training_x, self.training_y = training_set self.testing_x, self.testing_id, = testing_set self.folder = folder self.save_training_dataset = save_training_dataset if cost_string == "log_loss": self.cost_function = cost_string elif cost_string == "auc": self.cost_function = roc_auc_score else: log("Found undefined cost function - {}".format(cost_string), ERROR) raise NotImplementError
def _gcp_on_epoch_end(self, epoch, logs=None): # Call original checkpoint to temporary file KerasModelCheckpoint.on_epoch_end(self, epoch, logs=logs) logs = logs or {} # Check if file exists and not empty if not os.path.exists(self.filepath): log.warning("Checkpoint file does not seem to exists. Ignoring") return if os.path.getsize(self.filepath) == 0: log.warning("File empty, no checkpoint has been saved") return final_path = self._original_filepath.format(epoch=epoch + 1, **logs) with file_io.FileIO(self.filepath, mode='rb') as input_f: with file_io.FileIO(final_path, mode='w+b') as output_f: output_f.write(input_f.read()) # Remove local model os.remove(self.filepath)
model.summary() #only last two layers with 30735 and 64 parameters are trainable # In[15]: from keras.callbacks import EarlyStopping, ModelCheckpoint model_path = 'transfer_model.h5' callbacks = [ EarlyStopping( monitor='val_categorical_crossentropy', patience=3, # stop training at 3 verbose=0), ModelCheckpoint( model_path , monitor='val_categorical_crossentropy', save_best_only=True, verbose=0) ] # In[16]: X_tr ,y_tr = X[0::2,], y[0::2,] X_val , y_val = X[1::2,],y[1::2,] del X ,y # In[17]: import gc
model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=lr_schedule(0)), metrics=['accuracy']) model.summary() print(model_type) # Prepare model model saving directory. save_dir = os.path.join(os.getcwd(), 'saved_models') model_name = 'cifar10_%s_model.{epoch:03d}.h5' % model_type if not os.path.isdir(save_dir): os.makedirs(save_dir) filepath = os.path.join(save_dir, model_name) # Prepare callbacks for model saving and for learning rate adjustment. checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_acc', verbose=1, save_best_only=True) lr_scheduler = LearningRateScheduler(lr_schedule) lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.1), cooldown=0, patience=5, min_lr=0.5e-6) from keras.callbacks import TensorBoard callbacks = [ checkpoint, lr_reducer, lr_scheduler, TensorBoard(log_dir='./TB_logdir/BetterTrain_BS=256', write_images=False) ] # # Train
model = Sequential() model.add(Dense(input_dim=input_size, output_dim=2048, activation='relu')) model.add(Dropout(0.6)) model.add(Dense(input_dim=2048, output_dim=1024, activation='relu')) model.add(Dropout(0.4)) model.add(Dense(input_dim=1024, output_dim=512, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(input_dim=512, output_dim=512, activation='relu')) model.add(Dropout(0.2)) # model.add(Dense(input_dim=4096, output_dim=output_size, activation='sigmoid')) model.add(Dense(input_dim=512, output_dim=output_size, activation='linear')) # model.compile(optimizer=Adam(), loss=weighted_binary_crossentropy) model.compile(optimizer=Adam(), loss='mse') model_checkpoint = ModelCheckpoint('./models/' + 'weights_12_5_epoch_{epoch:02d}.h5', monitor='val_loss', save_best_only=True) # model.fit(xt, yt, batch_size=64, nb_epoch=500, validation_data=(xs, ys), class_weight=W, verbose=0) print "Start Training..." #set early stopping monitor so the model stops training when it won't improve anymore early_stopping_monitor = EarlyStopping(patience=5) model.fit(train_pool5_img, description_train_vecs, batch_size=64, nb_epoch=300, verbose=1, shuffle=True, validation_split=0.1, callbacks=[model_checkpoint, early_stopping_monitor]) preds = model.predict(test_pool5_img) output_name = "./models/nn_pool5_to_word2vec_300.pkl" pickle.dump(preds, open(output_name, 'wb'), protocol=2)
initial_lrate=1e-1 def time_decay(EPOCHS, initial_lrate): decay_rate = 0.1 new_lrate = initial_lrate/(1+decay_rate*EPOCHS) return new_lrate from keras.callbacks import LearningRateScheduler lrate = LearningRateScheduler(time_decay,verbose=1) # hyperparameter tuning filepath=" DEC weights-improvement-{epoch:02d}-{val_accuracy:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_accuracy', verbose=1, save_best_only=True, mode='max') #early = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10) reduce1 = keras.callbacks.ReduceLROnPlateau(monitor='val_accuracy', verbose=1,factor=0.9, patience=2,min_lr=1e-5 ) callbacks_list = [checkpoint,reduce1] #callbacks_list = [checkpoint,reduce1, lrate] #callbacks_list = [checkpoint, reduce1,clr] #callbacks_list = [checkpoint,clr] #callbacks_list = [checkpoint,sched] #callbacks_list = [checkpoint,lrate]
def train(self, model): datagen = ImageDataGenerator(rescale=(1. / 255)) val_datagen = ImageDataGenerator(rescale=(1. / 255)) os.system('gsutil -m cp -r ' + self.image_path + '/Train .') os.system('gsutil -m cp -r ' + self.image_path + '/Validation .') batch_size = 32 def batch_generator(batch_size): for batch in datagen.flow_from_directory("Train", target_size=(image_size, image_size), class_mode="input", batch_size=batch_size): lab = color.rgb2lab(batch[0]) X = preprocess(lab) Y = lab[:, :, :, 1:] / 128 yield ([X, Y]) def val_batch_generator(batch_size): for batch in val_datagen.flow_from_directory( "Validation", target_size=(image_size, image_size), class_mode="input", batch_size=batch_size): lab = color.rgb2lab(batch[0]) X = preprocess(lab) Y = lab[:, :, :, 1:] / 128 yield ([X, Y]) model.summary() class WeightsSaver(Callback): def __init__(self, N, output_path): self.N = N self.output_path = output_path self.batch = 0 def on_batch_end(self, batch, logs={}): if self.batch % self.N == 0: name = 'currentWeights.h5' self.model.save_weights(name) try: os.system('gsutil cp ' + name + ' ' + self.output_path) except: print("Could not upload current weights") self.batch += 1 checkpoint = ModelCheckpoint("best.hdf5", monitor="accuracy", verbose=1, save_best_only=True, mode="max") every_20_batches = WeightsSaver(20, self.output_path) every_10 = ModelCheckpoint("latest.hdf5", monitor="accuracy", verbose=1, save_best_only=False, mode='auto', period=1) tensorboard = TensorBoard(log_dir=".") callbacks = [tensorboard, checkpoint, every_10, every_20_batches] model.compile(loss='mean_squared_error', optimizer="adam", metrics=['accuracy']) model.fit_generator(batch_generator(batch_size), callbacks=callbacks, epochs=3, steps_per_epoch=4040, validation_data=val_batch_generator(batch_size), validation_steps=157) #5132 steps per epoch # outputDate = now.strftime("%Y-%m-%d %Hh%Mm") # os.chdir("output") # os.mkdir(outputDate) # os.chdir(outputDate) try: model.save_weights("model_weights.h5") model.save("model.h5") # else: # model.load_weights("/floyd/input/model/my_model_weights.h5") except: print("Could not save") os.system('gsutil cp model_weights.h5 ' + self.output_path) os.system('gsutil cp model.h5 ' + self.output_path) os.system('gsutil cp best.hdf5 ' + self.output_path) os.system('gsutil cp latest.h5 ' + self.output_path)
output_mode='error', return_sequences=True) inputs = Input(shape=(nt,) + input_shape) print (nt,) + input_shape errors = prednet(inputs) # errors will be (batch_size, nt, nb_layers) errors_by_time = TimeDistributed(Dense(1, weights=[layer_loss_weights, np.zeros(1)], trainable=False), trainable=False)( errors) # calculate weighted error by layer errors_by_time = Flatten()(errors_by_time) # will be (batch_size, nt) final_errors = Dense(1, weights=[time_loss_weights, np.zeros(1)], trainable=False)( errors_by_time) # weight errors by time model = Model(input=inputs, output=final_errors) model.compile(loss='mean_absolute_error', optimizer='adam') train_generator = RadarGenerator(train_file, nt, batch_size=batch_size, shuffle=True) val_generator = RadarGenerator(val_file, nt, batch_size=batch_size, N_seq=N_seq_val) lr_schedule = lambda \ epoch: 0.001 if epoch < 75 else 0.0001 # start with lr of 0.001 and then drop to 0.0001 after 75 epochs callbacks = [LearningRateScheduler(lr_schedule)] if save_model: if not os.path.exists(WEIGHTS_DIR): os.mkdir(WEIGHTS_DIR) callbacks.append(ModelCheckpoint(filepath=weights_file, monitor='val_loss', save_best_only=True)) history = model.fit_generator(train_generator, samples_per_epoch, nb_epoch, callbacks=callbacks, validation_data=val_generator, nb_val_samples=N_seq_val) if save_model: json_string = model.to_json() with open(json_file, "w") as f: f.write(json_string)
up9 = Conv3DTranspose(32, (2, 2, 2), strides=(2, 2, 2), padding='same')(conv8) conv9 = Conv3D(32, (3, 3, 3), activation='relu', padding='same')(up9) conv9 = Conv3D(32, (3, 3, 3), activation='relu', padding='same')(conv9) conv10 = Conv3D(1, (1, 1, 1), activation='sigmoid')(conv9) model = Model(inputs=[I1], outputs=[conv10, fc3]) # Training model.compile(optimizer=Adam(lr=1e-4), loss=[dice_loss, ent_loss], loss_weights=[1, 0.3], metrics=[dice, 'accuracy']) filepath = "/home/shas/projects/rrg-hamarneh/sponsored/shas/model11/weights-improvement-{epoch:02d}.hdf5" my_checkpoint = ModelCheckpoint(filepath, monitor='val_dice', save_weights_only=True, period=10, verbose=1) tbCallBack = TensorBoard(log_dir='./logs', histogram_freq=0, write_graph=True, write_images=True) # generating training and validation data training_generator = generator10(h5path='/dev/shm/shas/SFU_scaled', indices=index_tr, batchSize=15, imagesize=64, channel=4, number_class=2)
def make_checkpoint(filepath, monitor='val_mean_squared_error'): ckp = ModelCheckpoint(filepath, monitor=monitor, save_best_only=True) return ckp
validation_datas = validation_datas.reshape(nb_validation_samples, input_step_size,1) # print validation_datas.shape, training_datas.shape, validation_labels.shape # In[17]: model = Sequential() model.add(LSTM(10, input_shape=(input_step_size,1),return_sequences=False)) model.add(Dropout(0.2)) model.add(Dense(output_size)) model.add(Activation('sigmoid')) model.summary() # Adam = optimizers.Adam(lr=0.0001) model.compile(loss='mse', optimizer='adam') model.fit(training_datas, training_labels, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger('1layer.csv', append=True), ModelCheckpoint('weights/weights-improvement-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')]) model.save('1layer.h5') # In[ ]: # In[ ]:
train_samples, validation_samples = train_test_split(samples, test_size=0.2) print('Train samples: {}'.format(len(train_samples))) print('Validation samples: {}'.format(len(validation_samples))) train_generator = BatchGenerator(train_samples, batch_size=256) validation_generator = BatchGenerator(validation_samples, batch_size=256) batch_size = 256 epochs = 5 verbose = 1 # Model creation model = nVidiaModel() checkpoint = ModelCheckpoint('TrainingCheckpoints/model-{epoch:03d}.h5', monitor='val_loss', verbose=0, save_best_only=True, mode='auto') # Compiling and training the model print('Compiling model...') model.compile(loss='mean_squared_error', optimizer=Adam(lr=0.0001)) print('Training model...') history_object = model.fit_generator(train_generator, steps_per_epoch=len(train_samples)/batch_size, validation_data=validation_generator, validation_steps=len(validation_samples)/batch_size, callbacks=[checkpoint], epochs=epochs,
model.add(Activation('relu')) model.add(Convolution2D(32,3,3, init='he_normal')) model.add(BatchNormalization(mode=0, axis=1)) model.add(Activation('relu')) model.add(Flatten()) model.add(BatchNormalization()) model.add(Dense(1,init='glorot_normal')) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='rmsprop', class_mode='binary') model.summary() file_name = 'network_B_1' saveWeigts = ModelCheckpoint(file_name+'_best_weights.h5', monitor='val_acc', verbose=1, save_best_only=True) cllbcks= [saveWeigts] for mini_epoch in range(1000): print "Epoch ", mini_epoch X_train, Y_train = train_batches.next() model.fit(X_train, Y_train, batch_size=64, nb_epoch=1, callbacks = cllbcks, validation_data=(X_valid,Y_valid),show_accuracy=True, verbose=1)
print('Descriptions: test=%d' % len(test_descriptions)) # photo features test_features = LoadPhotoFeatures( '/project/ProjectData/Imagefeatures_backup.pkl', test) print('Photos: test=%d' % len(test_features)) # prepare sequences X1test, X2test, ytest = CreateSequence(tokenizer, maxLength, test_descriptions, test_features, vocabSize) # define the model model = DefineModel(vocabSize, maxLength) # define checkpoint callback filename = 'model-ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5' checkpoint = ModelCheckpoint(filename, monitor='val_loss', verbose=1, save_best_only=True, mode='min') # fit model start = time.time() hist = model.fit([X1train, X2train], ytrain, epochs=10, verbose=2, callbacks=[checkpoint], validation_data=([X1test, X2test], ytest)) end = time.time() print("TIME TOOK {:3.2f}MIN".format((end - start) / 60)) #Plot Graph
def train(model_name, fold_count, train_full_set=False, load_weights_path=None, ndsb3_holdout=0, manual_labels=True, local_patient_set=False): batch_size = 16 train_files, holdout_files = get_train_holdout_files( train_percentage=80, ndsb3_holdout=ndsb3_holdout, manual_labels=manual_labels, full_luna_set=train_full_set, fold_count=fold_count, local_patient_set=local_patient_set) # train_files = train_files[:100] # holdout_files = train_files[:10] train_gen = data_generator(batch_size, train_files, True) holdout_gen = data_generator(batch_size, holdout_files, False) for i in range(0, 10): tmp = next(holdout_gen) cube_img = tmp[0][0].reshape(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE, 1) cube_img = cube_img[:, :, :, 0] cube_img *= 255. cube_img += MEAN_PIXEL_VALUE # helpers.save_cube_img("c:/tmp/img_" + str(i) + ".png", cube_img, 4, 8) # logger.info(tmp) #input("Enter any key to continue...") history = LossHistory() logcallback = LoggingCallback(logger.info) learnrate_scheduler = LearningRateScheduler(step_decay) model = get_net(load_weight_path=load_weights_path) # Tensorboard setting if not os.path.exists(TENSORBOARD_LOG_DIR): os.makedirs(TENSORBOARD_LOG_DIR) tensorboard_callback = TensorBoard( log_dir=TENSORBOARD_LOG_DIR, histogram_freq=2, # write_images=True, # Enabling this line would require more than 5 GB at each `histogram_freq` epoch. write_graph=True # embeddings_freq=3, # embeddings_layer_names=list(embeddings_metadata.keys()), # embeddings_metadata=embeddings_metadata ) tensorboard_callback.set_model(model) holdout_txt = "_h" + str(ndsb3_holdout) if manual_labels else "" if train_full_set: holdout_txt = "_fs" + holdout_txt checkpoint = ModelCheckpoint(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "_e" + "{epoch:02d}-{val_loss:.4f}.hd5", monitor='val_loss', verbose=1, save_best_only=not train_full_set, save_weights_only=False, mode='auto', period=1) checkpoint_fixed_name = ModelCheckpoint( settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "_best.hd5", monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) # train_history = model.fit_generator(train_gen, len(train_files) / 1, 12, validation_data=holdout_gen, nb_val_samples=len(holdout_files) / 1, callbacks=[checkpoint, checkpoint_fixed_name, learnrate_scheduler]) train_history = model.fit_generator( train_gen, len(train_files) / batch_size, 1, validation_data=holdout_gen, validation_steps=len(holdout_files) / batch_size, callbacks=[ logcallback, tensorboard_callback, checkpoint_fixed_name, learnrate_scheduler ]) logger.info("Model fit_generator finished.") model.save(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "_end.hd5") logger.info("history keys: {0}".format(train_history.history.keys())) # numpy_loss_history = numpy.array(history.history) # numpy.savetxt("workdir/model_" + model_name + "_" + holdout_txt + "_loss_history.txt", numpy_loss_history, delimiter=",") pandas.DataFrame( train_history.history).to_csv(settings.WORKING_DIR + "workdir/model_" + model_name + "_" + holdout_txt + "history.csv")
activation3 = 'softmax' activation4 ='elu' # model.add(Dense(1024, activation=activation, input_shape=(n_cols,))) model.add(Dense(256, activation=activation4, input_shape=(n_cols,))) # best so far # model.add(Dense(128, activation=activation)) # model.add(Dense(32, activation=activation)) # model.add(Dense(64, activation=activation)) model.add(Dense(16, activation=activation4)) # model.add(Dense(4, activation=activation3)) # # 'adam' 'sgd' optimizer model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) filepath = "keras_model_weights\\weights_best_classification.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_accuracy', # 'accuracy' verbose=1, save_best_only=True, mode='max') # min for loss functions, max for optimizations early_stopping_monitor = EarlyStopping(patience=500) # runs without improvement before stopping callbacks_list = [checkpoint, early_stopping_monitor] # list of tasks to do before next run history = model.fit(features, target, validation_split=.3, # split data into .7 train, .3 test each run epochs=2500, # do this many runs unless stop early callbacks=callbacks_list) # after each run do this list of things, defined above # ############################## Predictions vs Actual ####################################### best = pd.Series(history.history['val_accuracy']).idxmax() print(np.array(history.history['val_accuracy']).max())
def before_train(self): logger.info(f"args: {self.args}") logger.info(f"config:\n{self.config}") # compile model model = self.config.create_model(weight=self.args.weights) model_sum = [] model.summary(print_fn=lambda l: model_sum.append(l)) logger.info("Model summary:\n {}".format("\n".join(model_sum))) optimizer = self.config.get_optimizer() loss = self.config.get_loss() metrics = self.config.get_metrics() model.compile(optimizer, loss, metrics) lr_scheduler = self.config.get_lr_scheduler() if lr_scheduler is not None: self.callbacks.append(lr_scheduler) # save weights acc_name = [acc for acc in model.metrics_names if "acc" in acc] if len(acc_name): acc_name = acc_name[0] val_acc_name = "val_" + acc_name weight_path = os.path.join(self.record_dir, "Epoch_{epoch:04d}_{%s:.3f}_{%s:.3f}.h5" % (acc_name, val_acc_name)) monitor = val_acc_name monitor_mode = "max" else: weight_path = os.path.join(self.record_dir, "Epoch_{epoch:04d}_{loss:.3f}_{val_loss:.3f}.h5") monitor = "val_loss" monitor_mode = "min" logger.info(f"Weight monitor: {monitor} Monitor mode: {monitor_mode}") best_weight_path = os.path.join(self.record_dir, "best_ckpt.h5") cb_save_each_weight = ModelCheckpoint(weight_path, monitor, save_weights_only=True) cb_save_best_weight = ModelCheckpoint(best_weight_path, monitor, save_best_only=True, mode=monitor_mode, save_weights_only=True) self.callbacks += [ cb_save_each_weight, cb_save_best_weight ] # monitor training log_path = os.path.join(self.record_dir, "train_log.csv") cb_csv_log = CSVLogger(log_path, append=bool(self.ini_epoch)) cb_tensorboard = TensorBoard(self.record_dir, write_graph=False) self.callbacks += [ cb_csv_log, cb_tensorboard ] if self.ini_epoch != 0: logger.info(f"resume train from {self.ini_epoch}") # dataset init self.train_loader = self.config.get_train_loader() self.train_loader.batch_size = self.batch_size self.val_loader = self.config.get_validate_loader() self.val_loader.batch_size = self.batch_size self.model = model logger.info("Start training...")
# define loss if __name__ == '__main__': # model selection AF_model = AFNN(filters=64, image_channels=1, use_bnorm=True) AF_model.summary() # load the last model in matconvnet style initial_epoch = find_LastCheckpoint(model_dir=save_dir) if initial_epoch > 0: print('resuming by loading epoch %03d' % initial_epoch) AF_model = load_model(os.path.join( save_dir, 'model_%03d.hdf5' % initial_epoch), compile=False) # compile the model AF_model.compile(optimizer=Adam(0.001), loss=losses.mean_squared_error) # use call back functions check_pointer = ModelCheckpoint(os.path.join(save_dir, 'model_{epoch:03d}.hdf5'), verbose=1, save_weights_only=False, period=args.save_step) csv_logger = CSVLogger(os.path.join( save_dir, 'log.csv'), append=True, separator=',') lr_scheduler = LearningRateScheduler(lr_schedule) history = AF_model.fit_generator(train_datagen(batch_size=args.batch_size), steps_per_epoch=200, epochs=args.epoch, verbose=1, initial_epoch=initial_epoch, callbacks=[check_pointer, csv_logger, lr_scheduler])
################################# # print ('vocabulary', vocabulary, 'hidden_size', hidden_size, 'num_steps', num_steps) optimizer = Adam() model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['categorical_accuracy']) outputs = [layer.output for layer in model.layers] for out in outputs: print(out) print(model.summary()) assert (False) checkpointer = ModelCheckpoint(filepath=data_path + '/model-{epoch:02d}.hdf5', verbose=1) num_epochs = 50 if args.run_opt == 1: model.fit_generator(train_data_generator.generate(), len(train_data) // (batch_size * num_steps), num_epochs, validation_data=valid_data_generator.generate(), validation_steps=len(valid_data) // (batch_size * num_steps), callbacks=[checkpointer]) # model.fit_generator(train_data_generator.generate(), 2000, num_epochs, # validation_data=valid_data_generator.generate(), # validation_steps=10) model.save(data_path + "final_model.hdf5") elif args.run_opt == 2: model = load_model(data_path + "\model-40.hdf5")
name='dense_final')(dropout_4) dropout_5 = Dropout(drop)(dense_final) softmax_final = Dense(units=len(categories), activation='softmax', name='softmax_final')(dropout_5) # Compile model model = Model(inputs=inputs, outputs=softmax_final) model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) # Save checkpoints? if save_checkpoints: filepath = path_to_dir + "weights-improvement-{epoch:02d}-{val_acc:.4f}.hdf5" # https://machinelearningmastery.com/check-point-deep-learning-models-keras/ checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=verbose, save_best_only=True, mode='auto') print("Training Model...") if save_checkpoints: history = model.fit(Xtrain_encoded, Ytrain_encoded, batch_size=batch_size, epochs=epochs, verbose=verbose, callbacks=[checkpoint], validation_data=(Xtest_encoded, Ytest_encoded)) # starts training else: history = model.fit(Xtrain_encoded, Ytrain_encoded,
dense_output2 = dense(dense_output1) logistic_regression_output = Dense(1, activation='sigmoid', name='main_output')(dense_output2) model = Model(inputs=[main_input_1, main_input_2], outputs=[logistic_regression_output]) model.compile(optimizer='RMSprop', loss={'main_output': 'mean_squared_error'}, metrics=['mse', 'mae', 'mape', 'cosine']) tensorboard = TensorBoard(log_dir="logs/".format(time())) checkpoint = ModelCheckpoint("checkpoint", monitor='val_acc', verbose=1, mode='max') model.fit({ 'main_input_1': input1, 'main_input_2': input2 }, {'main_output': main_output}, epochs=epochs, verbose=1, batch_size=batch_size, callbacks=[tensorboard, checkpoint], validation_split=0.2) print("-----Training Completed-----\n") model_json = model.to_json()
def train(): print('-' * 30) print('Loading and preprocessing train data...') print('-' * 30) # mean = np.mean(imgs_train) # mean for data centering # std = np.std(imgs_train) # std for data normalization # # imgs_train -= mean # imgs_train /= std # imgs_train = imgs_train.astype(np.uint8) imgs_train, imgs_mask_train = load_train_data() imgs_mask_train = imgs_mask_train.astype('float32') imgs_train = imgs_train.astype('float32') imgs_mask_train /= 255. # scale masks to [0, 1] imgs_train /= 255. # scale masks to [0, 1] #print(imgs_mask_train[10, 11, 100, :, 0]) #print(imgs_train[10, 11, 100, :, 0]) # imgs_mask_train = imgs_mask_train.astype(np.uint8) # np.set_printoptions(threshold=np.nan) # print('-'*30) # print(imgs_train[0][30]) print('-' * 30) print('Creating and compiling model...') print('-' * 30) model = get_unet() weight_dir = 'weights' if not os.path.exists(weight_dir): os.mkdir(weight_dir) model_checkpoint = ModelCheckpoint(os.path.join(weight_dir, project_name + '.h5'), monitor='val_loss', save_best_only=True) log_dir = 'logs' if not os.path.exists(log_dir): os.mkdir(log_dir) csv_logger = CSVLogger(os.path.join(log_dir, project_name + '.txt'), separator=',', append=False) print('-' * 30) print('Fitting model...') print('-' * 30) # model.fit(imgs_train, imgs_mask_train, batch_size=32, epochs=20, verbose=1, shuffle=True, # validation_split=0.15, # callbacks=[model_checkpoint]) model.fit(imgs_train, imgs_mask_train, batch_size=1, epochs=50, verbose=1, shuffle=True, validation_split=0.10, callbacks=[model_checkpoint, csv_logger]) print('-' * 30) print('Training finished') print('-' * 30)
batch_size = 32 epochs = 16 X_tra, X_val, y_tra, y_val = train_test_split( x_train, y_train, train_size=0.95, random_state=233) RocAuc = RocAucEvaluation(validation_data=(X_val, y_val), interval=1) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=2, verbose=0, mode='auto') bst_model_path = OUTPUT_DIR + MODEL_STAMP + '.h5' model_checkpoint = ModelCheckpoint( bst_model_path, save_best_only=True, save_weights_only=True) hist = model.fit(X_tra, y_tra, batch_size=batch_size, epochs=epochs, validation_data=(X_val, y_val), callbacks=[early_stopping, model_checkpoint, RocAuc], verbose=2) bst_val_score = min(hist.history['val_loss']) model.load_weights(bst_model_path) y_pred = model.predict(x_test, batch_size=1024) submission[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]] = y_pred submission.to_csv(OUTPUT_DIR+'submission_%.4f_gru_glove.csv' % (bst_val_score), index=False)
def train(data_type, seq_length, model, saved_model=None, concat=False, class_limit=None, image_shape=None, load_to_memory=False): # Set variables. nb_epoch = 1000 batch_size = 32 # Helper: Save the model. checkpointer = ModelCheckpoint( filepath='./data/checkpoints/' + model + '-' + data_type + \ '.{epoch:03d}-{val_loss:.3f}.hdf5', verbose=1, save_best_only=True) # Helper: TensorBoard tb = TensorBoard(log_dir='./data/logs') # Helper: Stop when we stop learning. early_stopper = EarlyStopping(patience=10) # Helper: Save results. timestamp = time.time() csv_logger = CSVLogger('./data/logs/' + model + '-' + 'training-' + \ str(timestamp) + '.log') # Get the data and process it. if image_shape is None: data = DataSet( seq_length=seq_length, class_limit=class_limit ) else: data = DataSet( seq_length=seq_length, class_limit=class_limit, image_shape=image_shape ) # Get samples per epoch. # Multiply by 0.7 to attempt to guess how much of data.data is the train set. samples_per_epoch = ((len(data.data) * 0.7) // batch_size) * batch_size if load_to_memory: # Get data. X, y = data.get_all_sequences_in_memory(batch_size, 'train', data_type, concat) X_test, y_test = data.get_all_sequences_in_memory(batch_size, 'test', data_type, concat) else: # Get generators. generator = data.frame_generator(batch_size, 'train', data_type, concat) val_generator = data.frame_generator(batch_size, 'test', data_type, concat) # Get the model. rm = ResearchModels(len(data.classes), model, seq_length, saved_model) # Fit! if load_to_memory: # Use standard fit. rm.model.fit( X, y, batch_size=batch_size, validation_data=(X_test, y_test), verbose=1, callbacks=[checkpointer, tb, early_stopper, csv_logger], nb_epoch=nb_epoch, samples_per_epoch=samples_per_epoch) else: # Use fit generator. rm.model.fit_generator( generator=generator, samples_per_epoch=samples_per_epoch, nb_epoch=nb_epoch, verbose=1, callbacks=[checkpointer, tb, early_stopper, csv_logger], validation_data=val_generator, nb_val_samples=256)
def train_generator(self, epochs, batch_size, workers=1, dataname='doctor', datapath_train='./images/train_dir', datapath_validation='./images/val_dir', datapath_test='./images/val_dir', steps_per_epoch=1000, steps_per_validation=1000, crops_per_image=2, log_weight_path='./data/weights/', log_tensorboard_path='./data/logs/', log_tensorboard_name='SR-RRDB-D', log_tensorboard_update_freq=1, log_test_path="./images/samples-d/" ): """Trains the generator part of the network with MSE loss""" # Create data loaders train_loader = DataLoader( datapath_train, batch_size, self.height_hr, self.width_hr, self.upscaling_factor, crops_per_image ) test_loader = None if datapath_validation is not None: test_loader = DataLoader( datapath_validation, batch_size, self.height_hr, self.width_hr, self.upscaling_factor, crops_per_image ) self.gen_lr = 3.2e-5 for step in range(epochs // 10): self.compile_generator(self.generator) # Callback: tensorboard callbacks = [] if log_tensorboard_path: tensorboard = TensorBoard( log_dir=os.path.join(log_tensorboard_path, log_tensorboard_name), histogram_freq=0, batch_size=batch_size, write_graph=False, write_grads=False, update_freq=log_tensorboard_update_freq ) callbacks.append(tensorboard) else: print(">> Not logging to tensorboard since no log_tensorboard_path is set") # Callback: save weights after each epoch modelcheckpoint = ModelCheckpoint( os.path.join(log_weight_path, dataname + '_{}X.h5'.format(self.upscaling_factor)), monitor='PSNR', save_best_only=True, save_weights_only=True ) callbacks.append(modelcheckpoint) # Callback: test images plotting if datapath_test is not None: testplotting = LambdaCallback( on_epoch_end=lambda epoch, logs: plot_test_images( self, test_loader, datapath_test, log_test_path, epoch + step * 10, name='RRDB-D' ) ) callbacks.append(testplotting) # Fit the model self.generator.fit_generator( train_loader, steps_per_epoch=steps_per_epoch, epochs=10, validation_data=test_loader, validation_steps=steps_per_validation, callbacks=callbacks, use_multiprocessing=workers > 1, workers=workers ) self.generator.save('./data/weights/Doctor_gan(Step %dK).h5' % (step * 10 + 10)) self.gen_lr /= 1.149 print(step, self.gen_lr)
y_train = label[:-nb_validation_samples] x_test = data[-nb_validation_samples:] y_test = label[-nb_validation_samples:] """ 文本数据表示完成时间 """ mid_time = time.time() print("初始时间=:", mid_time - start_time) """ 模型的建立 """ print('Build model...') earlyStopping = EarlyStopping(monitor='val_loss', patience=1, verbose=0) saveBestModel = ModelCheckpoint(save_best_model_file, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True) embeddings_layer = Embedding(len(word_index) + 1, embedding_dim, input_length=max_sequence_length, trainable=True) inputs = Input(shape=(max_sequence_length, ), dtype='int32', name='input') embeddings_sequences = embeddings_layer(inputs) output = LSTM(lstm_output_size, dropout=0.65, recurrent_dropout=0.0)(embeddings_sequences) # output=Dense(64,activation='relu',name='dense1')(output) print(output)
self.current_idx = 0 inn, out, _ = self.inn[self.current_idx] self.current_idx += 1 tmp_x = np.swapaxes(np.array([n_str_to_int_list(inn, max_length)], dtype=int),1,2) tmp_y = np.array([str_to_int_list(out, max_length)], dtype=int).reshape((1, -1)) #print(tmp_x.shape, tmp_y.shape) yield tmp_x, to_categorical(tmp_y, num_classes=max_output) train_data_generator = KerasBatchGenerator(args.train_data_num, vocab) valid_data_generator = KerasBatchGenerator(0, vocab) print("starting") checkpointer = ModelCheckpoint(filepath='checkpoints/model-{epoch:02d}.hdf5', verbose=1) num_epochs = args.epochs history = model.fit_generator(train_data_generator.generate(), args.epoch_size, num_epochs, validation_data=valid_data_generator.generate(), validation_steps=args.epoch_size / 10, callbacks=[checkpointer]) model.save(args.final_name+'.hdf5') print(history.history.keys()) def list_to_string(prediction): s="" for i in range(prediction.shape[0]): s += vocab_rev[np.argmax(prediction[i])] return s
x_test = test_data.astype('float32') / 255. y_test = test_label.astype('float32') / 255. x_test = np.reshape(x_test, (len(x_test), 512, 512, 3)) # adapt this if using `channels_first` image data format y_test = np.reshape(y_test, (len(y_test), 512, 512, 1)) # adapt this if using `channels_first` im from SD_Unet import * model=SD_UNet(input_size=(512,512,3),start_neurons=16,keep_prob=1,block_size=1) weight="Model/Luna/SD_UNet.h5" if os.path.isfile(weight): model.load_weights(weight) model_checkpoint = ModelCheckpoint(weight, monitor='val_acc', verbose=1, save_best_only=True) y_pred = model.predict(x_test) y_pred_threshold = [] i=0 for y in y_pred: _, temp = cv2.threshold(y, 0.5, 1, cv2.THRESH_BINARY) y_pred_threshold.append(temp) y = y * 255 cv2.imwrite('./Luna/test/result/%d.png' % i, y) i+=1 y_test = list(np.ravel(y_test)) y_pred_threshold = list(np.ravel(y_pred_threshold)) tn, fp, fn, tp = confusion_matrix(y_test, y_pred_threshold).ravel()
def _main(): annotation_path = 'dataset/chanelset/train.txt' # Update to your feeding list file log_dir = 'logs/001/' classes_path = 'model_data/yolo_classes.txt' anchors_path = 'model_data/yolo_anchors.txt' class_names = get_classes(classes_path) num_classes = len(class_names) anchors = get_anchors(anchors_path) input_shape = (608, 608) # multiple of 32, hw is_tiny_version = len(anchors) == 6 # default setting if is_tiny_version: model = create_tiny_model( input_shape, anchors, num_classes, freeze_body=2, weights_path='model_data/tiny_yolo_weights.h5') else: model = create_model(input_shape, anchors, num_classes, freeze_body=2, weights_path='model_data/yolo_weights.h5' ) # make sure you know what you freeze logging = TensorBoard(log_dir=log_dir) checkpoint = ModelCheckpoint( log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5', monitor='val_loss', save_weights_only=True, save_best_only=True, period=3) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1) val_split = 0.1 with open(annotation_path) as f: lines = f.readlines() np.random.seed(10101) np.random.shuffle(lines) np.random.seed(None) num_val = int(len(lines) * val_split) num_train = len(lines) - num_val # Train with frozen layers first, to get a stable loss. # Adjust num epochs to your dataset. This step is enough to obtain a not bad model. if True: model.compile( optimizer=Adam(lr=1e-3), loss={ # use custom yolo_loss Lambda layer. 'yolo_loss': lambda y_true, y_pred: y_pred }) batch_size = 32 print('Train on {} samples, val on {} samples, with batch size {}.'. format(num_train, num_val, batch_size)) model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes), steps_per_epoch=max(1, num_train // batch_size), validation_data=data_generator_wrapper( lines[num_train:], batch_size, input_shape, anchors, num_classes), validation_steps=max(1, num_val // batch_size), epochs=50, initial_epoch=0, callbacks=[logging, checkpoint]) model.save_weights(log_dir + 'trained_weights_stage_1.h5') # Unfreeze and continue training, to fine-tune. # Train longer if the result is not good. if True: for i in range(len(model.layers)): model.layers[i].trainable = True model.compile(optimizer=Adam(lr=1e-4), loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # recompile to apply the change print('Unfreeze all of the layers.') batch_size = 32 # note that more GPU memory is required after unfreezing the body print('Train on {} samples, val on {} samples, with batch size {}.'. format(num_train, num_val, batch_size)) model.fit_generator( data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes), steps_per_epoch=max(1, num_train // batch_size), validation_data=data_generator_wrapper(lines[num_train:], batch_size, input_shape, anchors, num_classes), validation_steps=max(1, num_val // batch_size), epochs=50, initial_epoch=30, callbacks=[logging, checkpoint, reduce_lr, early_stopping]) model.save_weights(log_dir + 'trained_weights_final.h5')
def fit(self, model, data, new_data): import time import keras import numpy from keras.callbacks import ModelCheckpoint, EarlyStopping from sklearn.model_selection import StratifiedKFold params = self.get_params() X = data['X'] Y = data['Y'] if model.get_name().lower() == 'vgg16': X = self.prepare_data(X, True) elif model.get_name().lower() == 'mobile_net' or model.get_name( ).lower() == 'resnet' or model.get_name().lower() == 'unet': X = self.prepare_data(X, False) if params['use_new_data']: new_X = new_data['X'] new_Y = new_data['Y'] if model.get_name().lower() == 'vgg16': new_X = self.prepare_data(new_X, True) elif model.get_name().lower() == 'mobile_net' or model.get_name( ).lower() == 'resnet' or model.get_name().lower() == 'unet': new_X = self.prepare_data(new_X, False) if (self.get_params()['problem_type'] == 'classification'): new_Y = keras.utils.to_categorical(new_Y, num_classes=len( numpy.unique(Y))) title = model.get_name() + '_' + time.strftime("%Y_%m_%d_%H_%M_%S") repetitions_scores = [] repetitions_scores_new_data = [] matrix_orig = [] matrix_predicted = [] for i in range(params['repetitions']): test_results = [] test_orig = [] test_results_new_data = [] test_orig_new_data = [] import random seed = random.randint(1, 1000) kfold = StratifiedKFold(n_splits=params['folds'], shuffle=True, random_state=seed) if self.get_params()['verbose']: print('Repetition: ' + str(i + 1) + '\n') count = 1 cvscores = [] cvscores_new_data = [] for train, test in kfold.split(X, Y): architecture = model.get_model() if self.get_params()['verbose']: print('Fold: ' + str(count)) X_train, X_test = X[train], X[test] Y_train, Y_test = Y[train], Y[test] validation_percentage = params['validation_split'] # Class weight if there are unbalanced classes from sklearn.utils import class_weight # class_weight = class_weight.compute_class_weight('balanced',numpy.unique(Y), Y) sample_weight = class_weight.compute_sample_weight( class_weight='balanced', y=Y_train) if ( self.get_params()['problem_type'] == 'classification' ): # and not(params['use_distillery'] and model.get_name().lower() != 'distillery_network'): Y_train = keras.utils.to_categorical(Y_train, num_classes=len( numpy.unique(Y))) Y_test = keras.utils.to_categorical(Y_test, num_classes=len( numpy.unique(Y))) callbacks_list = [] callbacks_list.append( ModelCheckpoint(title + "_kfold_weights_improvement.hdf5", monitor='val_loss', verbose=params['verbose'], save_best_only=True, mode='min')) callbacks_list.append( EarlyStopping(monitor='val_loss', min_delta=params['min_delta'], patience=params['patience'], verbose=params['verbose'], mode='min')) history = LossHistory((X_train, Y_train)) callbacks_list.append(history) # Fit the architecture architecture.fit(X_train, Y_train, epochs=params['epochs'], batch_size=params['batch'], validation_split=validation_percentage, callbacks=callbacks_list, verbose=params['verbose'], sample_weight=sample_weight) import matplotlib.pyplot as plt plt.plot(history.losses[:]) plt.plot(history.accuracies[:]) plt.title('model loss and acc') plt.ylabel('value') plt.xlabel('batch') plt.legend(['loss', 'acc'], loc='upper left') plt.show() # Data Augmentation if params['augmentation']: from keras.preprocessing.image import ImageDataGenerator # Initialize Generator datagen = ImageDataGenerator(vertical_flip=True) # Fit parameters from data datagen.fit(X_train) # Fit new data architecture.fit_generator( datagen.flow(X_train, Y_train, batch_size=params['batch'])) model_json = architecture.to_json() if count == 1: with open(title + '_model.json', "w") as json_file: json_file.write(model_json) architecture.save_weights( title + '_weights.h5') # TODO: Check what weights save file = open(title + '_seed.txt', 'a+') file.write('Repetition: ' + str(i + 1) + ' , seed: ' + str(seed) + '\n') file.close() # Evaluate the architecture print('Evaluation metrics\n') scores = architecture.evaluate(X_test, Y_test, verbose=params['verbose']) Y_predicted = numpy.argmax(architecture.predict( X_test, batch_size=params['batch']), axis=1) test_results += Y_predicted.tolist() test_orig += numpy.argmax(Y_test, axis=1).tolist() cvscores.append(scores) if params['use_new_data']: scores_new_data = architecture.evaluate( new_X, new_Y, verbose=params['verbose']) new_Y_predicted = numpy.argmax(architecture.predict( new_X, batch_size=params['batch']), axis=1) test_results_new_data += new_Y_predicted.tolist() test_orig_new_data += numpy.argmax(new_Y, axis=1).tolist() cvscores_new_data.append(scores_new_data) matrix_orig.extend(test_orig) matrix_predicted.extend(Y_predicted) count += 1 if params['problem_type'].lower() == 'classification': scores2 = self.classification_metrics( numpy.array(test_results), test_orig, numpy.unique(Y)) else: scores2 = self.regression_metrics(numpy.array(test_results), test_orig) import csv with open(title + '_test_output.csv', 'w+') as file: wr = csv.writer(file) wr.writerow(test_results) file.close() repetitions_scores.append( numpy.mean(cvscores, axis=0).tolist() + scores2) if params['use_new_data']: if params['problem_type'].lower() == 'classification': scores2_new_data = self.classification_metrics( numpy.array(test_results_new_data), test_orig_new_data, numpy.unique(Y)) else: scores2_new_data = self.regression_metrics( numpy.array(test_results_new_data), test_orig_new_data) repetitions_scores_new_data.append( numpy.mean(cvscores_new_data, axis=0).tolist() + scores2_new_data) global_score_mean = numpy.mean(repetitions_scores, axis=0) global_score_std = numpy.std(repetitions_scores, axis=0) if params['problem_type'].lower() == 'classification': architecture.metrics_names += [ "sklearn_acc", "tn", "fp", "fn", "tp", "precision", "recall", "specificity", "f1", "auc_roc", "k" ] else: architecture.metrics_names += ["mae", "r2"] file = open(title + '_results.txt', 'w') for count in range(len(architecture.metrics_names)): file.write( str(architecture.metrics_names[count]) + ": " + str(numpy.around(global_score_mean[count], decimals=4)) + chr(177) + str(numpy.around(global_score_std[count], decimals=4)) + '\n') file.close() matrix = self.compute_confusion_matrix(matrix_orig, matrix_predicted) numpy.savetxt(title + '_total_confusion_matrix.txt', matrix, fmt='% 4d') if params['problem_type'].lower() == 'classification': total_metrics_names = [ "acc", "tn", "fp", "fn", "tp", "recall", "specificity", "precision", "f1", "Negative predictive value", "False positive rate", "False negative rate", "False discovery rate" ] total_metrics_scores = self.compute_total_classification_metrics( matrix) file = open(title + '_total_results.txt', 'w') for i in range(len(total_metrics_names)): file.write( str(total_metrics_names[i]) + ": " + str(numpy.around(total_metrics_scores[i], decimals=4)) + '\n') file.close() if params['use_new_data']: global_score_mean_new_data = numpy.mean( repetitions_scores_new_data, axis=0) global_score_std_new_data = numpy.std(repetitions_scores_new_data, axis=0) file = open(title + '_results_new_data.txt', 'w') for count in range(len(architecture.metrics_names)): file.write( str(architecture.metrics_names[count]) + ": " + str( numpy.around(global_score_mean_new_data[count], decimals=4)) + chr(177) + str( numpy.around(global_score_std_new_data[count], decimals=4)) + '\n') file.close()
seg_model.summary() import keras.backend as K from keras.optimizers import Adam from keras.losses import binary_crossentropy ## intersection over union def IoU(y_true, y_pred, eps=1e-6): if np.max(y_true) == 0.0: return IoU(1-y_true, 1-y_pred) ## empty image; calc IoU of zeros intersection = K.sum(y_true * y_pred, axis=[1,2,3]) union = K.sum(y_true, axis=[1,2,3]) + K.sum(y_pred, axis=[1,2,3]) - intersection return -K.mean( (intersection + eps) / (union + eps), axis=0) from keras.callbacks import ModelCheckpoint, LearningRateScheduler, EarlyStopping, ReduceLROnPlateau weight_path="{}_weights.best.hdf5".format('seg_model') checkpoint = ModelCheckpoint(weight_path, monitor='val_loss', verbose=1, save_best_only=True, mode='min', save_weights_only=True) reduceLROnPlat = ReduceLROnPlateau(monitor='val_loss', factor=0.33, patience=1, verbose=1, mode='min', min_delta=0.0001, cooldown=0, min_lr=1e-8) early = EarlyStopping(monitor="val_loss", mode="min", verbose=2, patience=20) # probably needs to be more patient, but kaggle time is limited callbacks_list = [checkpoint, early, reduceLROnPlat] def fit(): seg_model.compile(optimizer=Adam(1e-3, decay=1e-6), loss=IoU, metrics=['binary_accuracy']) step_count = min(MAX_TRAIN_STEPS, train_df.shape[0]//BATCH_SIZE) aug_gen = create_aug_gen(make_image_gen(train_df)) loss_history = [seg_model.fit_generator(aug_gen,
p.add_argument('--history') p.add_argument('--batch_size', default=4, type=int) p.add_argument('--epochs', default=64, type=int) p.add_argument('--cont', action='store_true') args = p.parse_args() train_generator, val_generator, train_batches, val_batches = \ create_generators(args.data_directory, \ args.density_scale, args.sigma, args.batch_size) # Setup callbacks early_stopping = EarlyStopping(patience=5, verbose=2) model_checkpoint = ModelCheckpoint(args.model, save_best_only=True, verbose=2) callbacks = [early_stopping, model_checkpoint] if args.history is not None: csv_logger = CSVLogger(args.history, append=True) callbacks.append(csv_logger) # Load model custom_objects = dict(inspect.getmembers(losses, inspect.isfunction)) model = models.load_model(args.model, custom_objects=custom_objects) model.summary() # Get score if args.cont: losses = model.evaluate_generator(val_generator, val_batches) val_loss_idx = model.metrics_names.index('loss') print('Loaded model with: %s' % ' - '.join( \
def on_epoch_end(self, batch, logs={}): self.losses.append(logs.get('loss')) self.lr.append(step_decay(len(self.losses))) print('lr:', step_decay(len(self.losses))) def step_decay(epoch): initial_lrate = LR drop = DROP epochs_drop = EPOCHS_DROP lrate = initial_lrate * math.pow(drop, math.floor((epoch)/epochs_drop)) return lrate checkpointer = ModelCheckpoint( filepath='./best_weights.hdf5', monitor="val_categorical_accuracy", save_best_only=True, save_weights_only=False, verbose=2) earlyStoper = EarlyStopping( monitor='val_loss', mode='min', restore_best_weights=True, min_delta =0.75, # patience = 5, verbose=2) # learning schedule callback loss_history = LossHistory() lrate = LearningRateScheduler(step_decay) callbacks_list = [loss_history, lrate, checkpointer]