0, # randomly shift images horizontally (fraction of total width) height_shift_range= 0, # randomly shift images vertically (fraction of total height) horizontal_flip=False, # randomly flip images vertical_flip=False) # randomly flip images # Compute quantities required for feature-wise normalization # (std, mean, and principal components if ZCA whitening is applied). datagen.fit(x_train) total_samples_train = getNumSamples(variants[num_variant][0][0:4] + '.h5') model.fit_generator(generate_arrays(TRAIN_SET, batch_size=BATCH_SIZE, max_sample=total_samples_train, new_size=INPUT_FRAME_SIZE), BATCH_SIZE, EPOCHS, verbose=2, callbacks=[best_model], validation_data=(x_test, y_test)) print("Finished fitting model") score = model.evaluate(x_test, y_test, verbose=1) print('Test loss:', score[0]) print('Test accuracy:', score[1]) print('All metrics', score) x_train = HDF5Matrix(TRAIN_SET, 'data') y_train = HDF5Matrix(TRAIN_SET, 'labels') res = model.predict(x_test) res_label = np.argmax(res, 1)
def main(): # Parameters if len(sys.argv) == 4: superclass = sys.argv[1] imgmove = sys.argv[2] if imgmove == 'False': imgmove = False else: imgmove = True lr = float(sys.argv[3]) else: print('Parameters error') exit() # The constants classNum = {'A': 40, 'F': 40, 'V': 40, 'E': 40, 'H': 24} testName = {'A': 'a', 'F': 'a', 'V': 'b', 'E': 'b', 'H': 'b'} date = '20180321' trainpath = 'trainval_' + superclass + '/train' valpath = 'trainval_' + superclass + '/val' if not os.path.exists('model'): os.mkdir('model') # Train/validation data preparation if imgmove: os.mkdir('trainval_' + superclass) os.mkdir(trainpath) os.mkdir(valpath) sourcepath = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_'+date+'_crop'\ +'/zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_images_'+date categories = os.listdir(sourcepath) for eachclass in categories: if eachclass[0] == superclass[0]: print(eachclass) os.mkdir(trainpath + '/' + eachclass) os.mkdir(valpath + '/' + eachclass) imgs = os.listdir(sourcepath + '/' + eachclass) idx = 0 for im in imgs: if idx % 8 == 0: shutil.copyfile( sourcepath + '/' + eachclass + '/' + im, valpath + '/' + eachclass + '/' + im) else: shutil.copyfile( sourcepath + '/' + eachclass + '/' + im, trainpath + '/' + eachclass + '/' + im) idx += 1 # Train and validation ImageDataGenerator batchsize = 32 train_datagen = ImageDataGenerator(rescale=1. / 255, rotation_range=15, width_shift_range=5, height_shift_range=5, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory(trainpath, target_size=(72, 72), batch_size=batchsize) valid_generator = test_datagen.flow_from_directory(valpath, target_size=(72, 72), batch_size=batchsize) # Train MobileNet model = Xception(include_top=True, weights=None, input_tensor=None, input_shape=(72, 72, 3), pooling=None, classes=classNum[superclass[0]]) model.summary() model.compile(optimizer=SGD(lr=lr, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy']) steps_per_epoch = int(train_generator.n / batchsize) validation_steps = int(valid_generator.n / batchsize) weightname = 'model/mobile_' + superclass + '_wgt.h5' if os.path.exists(weightname): model.load_weights(weightname) checkpointer = ModelCheckpoint(weightname, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True, mode='auto', period=1) model.fit_generator(train_generator, steps_per_epoch=steps_per_epoch, epochs=100, validation_data=valid_generator, validation_steps=validation_steps, callbacks=[checkpointer])
save_weights_only=False, mode='auto' ) early_stopping = EarlyStopping(monitor='val_loss', mode='auto',patience=7) #history = model.fit( # X_train,Y_train, # epochs=5, # batch_size=BATCH_SIZE, # validation_data=(X_val, Y_val), # callbacks=[checkpoint,kappa_metrics,early_stopping] #) history = model.fit_generator( data_generator, steps_per_epoch=X_train.shape[0] / BATCH_SIZE, epochs=50, validation_data=(X_val, Y_val), callbacks=[checkpoint,early_stopping] ) # In[ ]: with open(historyfilename, 'w') as f: json.dump(history.history, f) history_df = pd.DataFrame(history.history) history_df.to_csv('history.csv') history_df[['loss', 'val_loss']].plot() history_df[['acc', 'val_acc']].plot()
model = Model(base_model.input, x) model.summary() for layer in base_model.layers: layer.trainable = False model.summary() model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=['accuracy']) model.fit_generator(train_gen, validation_data=test_gen, steps_per_epoch=947 // 64, validation_steps=406 // 64, epochs=2) ################################################################### from matplotlib.image import imread train_arr = [] label_arr = [] for path, subdirs, files in os.walk(root): for name in files: full_path = os.path.join(path, name) train_arr.append(full_path)
lrate = initial_lrate * (drop ** np.floor(epoch/epochs_drop)) else: lrate = initial_lrate * (drop ** np.floor((epoch-1)/epochs_drop)) print(lrate) return lrate lrate = LearningRateScheduler(step_decay) Adam(lr=0.005, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0, amsgrad=False) model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy']) csv_logger = CSVLogger('./training_Xception.log', append=True) checkpointer = ModelCheckpoint(filepath='./weights_Xception.hdf5', verbose=1, save_best_only=True, monitor = 'val_acc') callbacks_list = [checkpointer,csv_logger,lrate] model.fit_generator(traning_set, epochs=100, steps_per_epoch=len(x_train) / 50, validation_steps=len(x_valid) / 50, verbose=1, validation_data=validation_set,callbacks=callbacks_list) score = model.evaluate(x_valid, y_valid, verbose=0) print(score)
def top_5(y_true, y_pred): return top_k_categorical_accuracy(y_true, y_pred, k=5) if __name__ == '__main__': batch_size = 16 train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) train_generator = train_datagen.flow_from_directory( 'data', target_size=(224, 224), batch_size=batch_size, class_mode='categorical', shuffle=True) model = Xception(include_top=True, weights=None, classes=10) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy', top_5]) model.fit_generator(train_generator, steps_per_epoch=125 // batch_size, epochs=10) model.save('xception10.h5')
factor=0.1, patience=5, verbose=1, epsilon=0.0001, mode='min'), ModelCheckpoint(monitor='val_loss', filepath=root_dir + 'weights/' + weight_name, save_best_only=True, save_weights_only=True, mode='min') , TQDMCallback()] history = model.fit_generator(generator=train_generator(batch_size), steps_per_epoch=1,#int(np.ceil(train_df.shape[0]/batch_size)/300),#344, epochs=60, verbose=2, callbacks=callbacks, validation_data=valid_generator(batch_size), validation_steps=1)#int(np.ceil(valid_df.shape[0]/batch_size))*20) model.load_weights(root_dir + 'weights/'+ weight_name) test_paths = glob(os.path.join(root_dir , 'test/audio/*wav')) def test_generator(test_batch_size): while True: for start in range(0, len(test_paths), test_batch_size): x_batch = [] end = min(start + test_batch_size, len(test_paths))
model_name = os.path.join(args.model_dir, "doc_detect.{epoch:02d}-{val_loss:.2f}.hdf5") checkpointer = ModelCheckpoint(model_name, monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) train_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory(args.train_dir, target_size=(img_w, img_w), batch_size=args.batch_size) validation_generator = test_datagen.flow_from_directory( args.test_dir, target_size=(img_w, img_w), batch_size=args.batch_size) print train_generator.class_indices model.fit_generator(train_generator, steps_per_epoch=train_size // args.batch_size, epochs=args.epochs, validation_data=validation_generator, validation_steps=test_size // args.batch_size, workers=7, callbacks=[checkpointer])
def train_with_sift_features(batch_size, input_shape, x_train, y_train, x_valid, y_valid, sift_features_train, sift_features_valid, model_name, num_workers, resume): print('Found {} images belonging to {} classes'.format(len(x_train), 128)) print('Found {} images belonging to {} classes'.format(len(x_valid), 128)) train_generator = AugmentedDatasetWithSiftFeatures(x_train, y_train, sift_features_train, batch_size=batch_size, input_shape=input_shape) valid_generator = DatasetWithSiftFeatures(x_valid, y_valid, sift_features_valid, batch_size=batch_size, input_shape=input_shape) class_weight = compute_class_weight('balanced', np.unique(y_train), y_train) class_weight_dict = dict.fromkeys(np.unique(y_train)) for key in class_weight_dict.keys(): class_weight_dict.update({key: class_weight[key]}) filepath = 'checkpoint/{}/sift_iter1.hdf5'.format(model_name) save_best = ModelCheckpoint(filepath=filepath, verbose=1, monitor='val_acc', save_best_only=True, mode='max') save_on_train_end = ModelCheckpoint(filepath=filepath, verbose=1, monitor='val_acc', period=args.epochs) reduce_lr = ReduceLROnPlateau(monitor='val_acc', factor=0.2, patience=2, verbose=1) callbacks = [save_best, save_on_train_end, reduce_lr] if resume == 'True': print('\nResume training from the last checkpoint') model = load_model(filepath) trainable_count = int( np.sum([K.count_params(p) for p in set(model.trainable_weights)])) print('Trainable params: {:,}'.format(trainable_count)) model.fit_generator(generator=train_generator, epochs=args.epochs, callbacks=callbacks, validation_data=valid_generator, class_weight=class_weight_dict, workers=num_workers) else: model = Xception(include_top=False, pooling='max') sift_features = Input(shape=(512, )) x = Concatenate()([model.layers[-1].output, sift_features]) x = Dense(units=128, activation='linear', name='predictions', kernel_regularizer=regularizers.l2(0.0001))(x) model = Model([model.layers[0].input, sift_features], x) for layer in model.layers[:-1]: layer.trainable = False model.compile(optimizer=Adam(lr=0.001), loss='categorical_hinge', metrics=['acc']) model.fit_generator(generator=train_generator, epochs=5, callbacks=callbacks, validation_data=valid_generator, class_weight=class_weight_dict, workers=num_workers) K.clear_session() print("\nFine-tune the network") model = load_model(filepath) for layer in model.layers: layer.trainable = True trainable_count = int( np.sum([K.count_params(p) for p in set(model.trainable_weights)])) print('Trainable params: {:,}'.format(trainable_count)) model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_hinge', metrics=['acc']) model.fit_generator(generator=train_generator, epochs=30, callbacks=callbacks, validation_data=valid_generator, class_weight=class_weight_dict, workers=num_workers) K.clear_session()
dtype='float32') datagen.fit(x_train) """ Training loop """ t0 = time.time() best_acc = 1e-10 for epoch in range(nb_epoch): t1 = time.time() print("### Model Fitting.. ###") print('epoch = {} / {}'.format(epoch + 1, nb_epoch)) print('check point = {}'.format(epoch)) hist = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=x_train.shape[0] // batch_size, validation_data=(x_val, y_val)) t2 = time.time() print(hist.history) print('Training time for one epoch : %.1f' % ((t2 - t1))) train_acc = hist.history['categorical_accuracy'][0] train_loss = hist.history['loss'][0] val_acc = hist.history['val_categorical_accuracy'][0] val_loss = hist.history['val_loss'][0] # must?? best_model = (val_acc > best_acc) if best_model: nsml.save('best')
def fine_tune(name, name_ext, lr=1e-4, reduce_lr_factor=0.1, reduce_lr_patience=3, epochs=10, batch_size=32, l2_reg=0, dropout_p=0.5, num_freeze_layers=0, save_best_only=True, loss_stop_val=0.00001): data_info = load_organized_data_info(imgs_dim=HEIGHT, name=name) tr_datagen = ImageDataGenerator( preprocessing_function=preprocess_input, rotation_range=180, vertical_flip=True, horizontal_flip=True, # width_shift_range=0.1, # height_shift_range=0.1, # zoom_range=0.1, # shear_range=0.3, # fill_mode='reflect' ) val_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) batch_size = 32 def dir_datagen(dir_, gen): return gen.flow_from_directory(directory=dir_, target_size=(HEIGHT, WIDTH), class_mode='categorical', batch_size=batch_size, shuffle=True) dir_tr, num_tr = data_info['dir_tr'], data_info['num_tr'] dir_val, num_val = data_info['dir_val'], data_info['num_val'] top_classifier_file = join(MODELS_DIR, TOP_CLASSIFIER_FILE.format(name)) model_file = join(MODELS_DIR, MODEL_FILE.format(name, name_ext)) model = Xception(weights='imagenet', include_top=False, pooling='avg') top_classifier = _top_classifier(l2_reg=l2_reg, dropout_p=dropout_p, input_shape=(2048, )) top_classifier.load_weights(top_classifier_file) model = Model(inputs=model.input, outputs=top_classifier(model.output)) model.compile(Adam(lr=lr), loss='categorical_crossentropy') # model has 134 layers for layer in model.layers[:num_freeze_layers]: layer.trainable = False log_dir = join(EXPERIMENTS_DIR, 'xception_fine_tuned_{:s}'.format(name)) callbacks = [ EarlyStoppingByLoss(monitor='loss', value=loss_stop_val), ReduceLROnPlateau(factor=reduce_lr_factor, patience=reduce_lr_patience), ModelCheckpoint(model_file, save_best_only=save_best_only), TensorBoard(log_dir=log_dir, write_graph=False) ] model.fit_generator(generator=dir_datagen(dir_tr, tr_datagen), steps_per_epoch=ceil(num_tr / batch_size), epochs=epochs, validation_data=dir_datagen(dir_val, val_datagen), validation_steps=ceil(num_val / batch_size), callbacks=callbacks)
class FaceEmotion: """Class for recognizing emotion using default Deep Learning Xception model""" def __init__(self, input_shape=(200, 200, 3)): # TODO: Check input_shape """Initialize main parameters of FaceEmotion class :param input_shape: Input images shape """ self.input_shape = input_shape self.model = Xception(include_top=False, input_shape=input_shape) self.model = self.add_classificator(self.model) @staticmethod def add_classificator(base_model): """Add a classificator to a model :param base_model: Keras model object """ layer = base_model.output layer = GlobalAveragePooling2D(name="classificator_block_pool")(layer) layer = Dense(512, activation='relu', name='classificator_block_dense_1')(layer) layer = Dense(64, activation='relu', name='classificator_block_dense_2')(layer) layer = Dense(6, activation='relu', name='classificator_block_dense_3')(layer) model = Model(inputs=base_model.input, outputs=layer) # freeze early layers for l in base_model.layers: l.trainable = False model.compile(optimizer='sgd', loss='mean_squared_error', metrics=['accuracy']) return model def model_architecture(self, filename=None): """Show model architecture and save it to file :param filename: Path to the model architecture image file """ list_summary = [] self.model.summary(print_fn=lambda x: list_summary.append(x)) summary = "\n".join(list_summary) if filename: with open(filename + '.txt', 'w') as f: f.write(summary) from keras.utils import plot_model plot_model(self.model, filename + '.jpg') return summary # noinspection PyShadowingNames def train(self, generator, epochs, steps_per_epoch): """Train model :param generator: Data generator compatible with Keras model :param epochs: Number of epochs to train model :param steps_per_epoch: Number of faces used in one step """ stopper = EarlyStopping(patience=100) # , restore_best_weights=True) save_dir = "training/e{epoch:02d}-a{acc:.2f}.ckpt" saver = ModelCheckpoint(save_dir) # , save_best_only=True) self.model.fit_generator(generator, steps_per_epoch, epochs, callbacks=[stopper, saver]) def get_emotion(self, image): emotions = [] for top, right, bottom, left in face_locations(image): emotion = self.model.predict(image[top:bottom, left:right]) emotions.append(emotion) return emotions