def build_model(config): """ Returns: a model with specified weights """ input_size = config['input_size'] input_shape = (input_size, input_size, 3) if ('pretrain' in config) and config['pretrain']: assert config['input_size'] == 224 weights = 'imagenet' else: weights = None assert config['image_model'] in ['densenet', 'resnet', 'linear'] if config['image_model'] == 'densenet': print("Using Densenet.") base_model = DenseNet121(input_shape=input_shape, weights=weights, include_top=False, pooling='avg') image_input = base_model.input layer = base_model.output elif config['image_model'] == 'resnet': print("Using Resnet.") base_model = ResNet50(input_shape=input_shape, weights=weights, include_top=False, pooling='avg') image_input = base_model.input layer = base_model.output elif config['image_model'] == 'linear': print("Using linear model.") image_input = Input(shape=input_shape) layer = Flatten()(image_input) if ('freeze' in config) and config['freeze']: for layer in base_model.layers: try: layer.trainable = False print("Freezing {}".format(layer)) except Exception: print("Not trainable {}".format(layer)) predictions = Dense(14, activation='sigmoid')(layer) model = Model(inputs=image_input, outputs=predictions) return model
def fine_tune(data, labels, best_top_model, type_top, layers_fine_tune): folds = list(StratifiedKFold(n_splits=5, shuffle=True).split(data, labels)) for j, (train_idx, val_idx) in enumerate(folds): print('\nFold ', j) x_train = data[train_idx] y_train = labels[train_idx] x_valid = data[val_idx] y_valid = labels[val_idx] num_classes = len(np.unique(labels)) model = VGG16() top_model = Sequential() if type_top == enum_models.typeA: layer = Flatten(name='flatten', input_shape=model.output_shape[1:]) top_model.add(layer) layer = Dense(4096, activation='relu', name='fc1') top_model.add(layer) layer = Dense(4096, activation='relu', name='fc2') top_model.add(layer) layer = Dense(num_classes, activation='softmax', name='predictions') top_model.add(layer) elif type_top == enum_models.typeB: layer = Flatten(name='flatten', input_shape=model.output_shape[1:]) top_model.add(layer) layer = Dense(256, activation='relu', name='fc1') top_model.add(layer) layer = Dropout(0.5, name='dropout') top_model.add(layer) layer = Dense(num_classes, activation='softmax', name='predictions') top_model.add(layer) elif type_top == enum_models.typeC: layer = Flatten(name='flatten', input_shape=model.output_shape[1:]) top_model.add(layer) layer = Dense(4096, activation='relu', name='fc1') top_model.add(layer) layer = Dense(4096, activation='relu', name='fc2') top_model.add(layer) layer = Dropout(0.5, name='dropout') top_model.add(layer) layer = Dense(num_classes, activation='softmax', name='predictions') top_model.add(layer) top_model.load_weights(best_top_model) # build the final model for layer in top_model.layers: model.add(layer) for layer in model.layers[:layers_fine_tune]: layer.trainable = False model.compile(loss='categorical_crossentropy', optimizer=optimizers.SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) train_labels = y_train train_labels = to_categorical(train_labels, num_classes=num_classes) validation_labels = y_valid validation_labels = to_categorical(validation_labels, num_classes=num_classes) # prepare data augmentation configuration train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) train_generator = train_datagen.flow(x_train, train_labels, shuffle=False, batch_size=batch_size) #constantes nb_train_samples = len(train_idx) num_classes = len(np.unique(labels)) predict_size_train = int(math.ceil(nb_train_samples / batch_size)) test_datagen = ImageDataGenerator(rescale=1. / 255) validation_generator = test_datagen.flow(x_valid, validation_labels, shuffle=False, batch_size=batch_size) nb_validation_samples = len(val_idx) predict_size_validation = int( math.ceil(nb_validation_samples / batch_size)) import time t = time.process_time() historyGenerated = model.fit_generator( train_generator, steps_per_epoch=predict_size_train, epochs=epochs, validation_data=validation_generator, validation_steps=predict_size_validation) training_time = time.process_time() - t #este si porq el fine tune es el que usaremos model.save('fine_tune/final_model_exported_fold_' + str(j) + '.h5') import json contentJson = json.dumps(historyGenerated.history, indent=4, sort_keys=True) f = open('fine_tune/fine_tune_history_fold_' + str(j) + '.json', "w") f.write(contentJson) f.close() ########################################test############################################## test_datagen = ImageDataGenerator(rescale=1. / 255) generator_test = test_datagen.flow(x_valid, validation_labels, shuffle=False, batch_size=batch_size) nb_test_samples = nb_validation_samples test_loss, test_accuracy = model.evaluate_generator( generator_test, steps=nb_test_samples / batch_size) print("[INFO] TEST accuracy: {:.2f}%".format(test_accuracy * 100)) print("[INFO] Test loss: {}".format(test_loss)) import json contentJson = json.dumps({ 'test_accuracy': test_accuracy, 'test_loss': test_loss, 'training_time': training_time, 'model': 'fine_tune/fine_tune_exported_fold_' + str(j) + '.h5' }) f = open('fine_tune/fine_tune_test_fold_' + str(j) + '.json', "w") f.write(contentJson) f.close() #liberar memoria del model del top_model del x_train del y_train del x_valid del y_valid K.clear_session() gc.collect()