def instantiate_network(self): if self.nn == 'VGG16': self.model = applications.VGG16(weights='imagenet', include_top=True, input_shape=(self.img_size[0], self.img_size[0], 3))
batch_size=batch_size) # We now reuse a pretrained network. Here we'll use the # [VGG16](https://keras.io/applications/#vgg16) network architecture # with weights learned using Imagenet. We remove the top layers and # freeze the pre-trained weights. # # ### Initialization model = Sequential() model.add(InputLayer(input_shape=input_image_size + (3, ))) # possibly needed due to a bug in Keras vgg_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=input_image_size + (3, )) for layer in vgg_model.layers: model.add(layer) for layer in model.layers: layer.trainable = False print(model.summary()) # We then stack our own, randomly initialized layers on top of the # VGG16 network. model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dense(43, activation='softmax'))
# input_shape in_s = 64 img_width, img_height = in_s, in_s top_model_weights_path = 'bottleneck_fc_model_93.h5' train_data_dir = 'dataset/training_set' validation_data_dir = 'dataset/test_set' # number of epochs to train top model #epochs = 40 # batch size used by flow_from_directory and predict_generator batch_size = 32 # ------------------------------------------------------------------------------ # create the VGG16 model - # without the final fully-connected layers (by specifying include_top=False) # - and load the ImageNet weights model = applications.VGG16(include_top=False, weights='imagenet') # ------------------------------------------------------------------------------ # create the data generator for training images, # and run them on the VGG16 model to save the bottleneck features for training #train_datagen = ImageDataGenerator(rescale= 1./255, # shear_range = 0.2, # zoom_range = 0.2, # #rotation_range=30, # #width_shift_range=0.2, # #height_shift_range=0.2, # horizontal_flip = False) #generator = train_datagen.flow_from_directory( # train_data_dir, # target_size=(img_width, img_height), # batch_size=batch_size,
def TransferLearning(args): """ Performs training. """ train_dir = args.train_folder val_dir = args.validation_folder nb_train_samples = utils.get_nb_files(args.train_folder) nb_val_samples = utils.get_nb_files(args.validation_folder) nb_classes = utils.get_labels(args.train_folder, args.validation_folder) nb_epochs = int(args.nb_epoch) batch_size = int(args.batch_size) base_architecture = args.base_architecture model_load = args.model_load # Define base layer if base_architecture == 'VGG16': base_model = applications.VGG16(weights='imagenet', include_top=False) layers_to_freeze = 10 elif base_architecture == 'VGG19': base_model = applications.VGG19(weights='imagenet', include_top=False) layers_to_freeze = 11 elif base_architecture == 'InceptionV3': base_model = applications.InceptionV3(weights='imagenet', include_top=False) layers_to_freeze = 172 # TODO: understand how many levels! elif base_architecture == 'ResNet50': base_model = applications.ResNet50(weights='imagenet', include_top=False) elif base_architecture == 'Xception': base_model = applications.Xception(weights='imagenet', include_top=False) model = replace_classification_layer(base_model, nb_classes, 1024) train_datagen = ImageDataGenerator( rescale = 1./255, fill_mode='nearest') test_datagen = ImageDataGenerator( rescale = 1./255, fill_mode='nearest') train_generator = train_datagen.flow_from_directory( train_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='categorical') validation_generator = test_datagen.flow_from_directory( val_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='categorical') transfer_learning(base_model, model, model_load) history_tl = model.fit_generator( train_generator, nb_epoch=nb_epochs, samples_per_epoch=nb_train_samples, validation_data=validation_generator, nb_val_samples=nb_val_samples, class_weight='auto', callbacks=args.callbacks) utils.plot_training(history_tl) setup_fine_tuning(model, layers_to_freeze, model_load) history_ft = model.fit_generator( train_generator, samples_per_epoch=nb_train_samples, nb_epoch=nb_epochs, validation_data=validation_generator, nb_val_samples=nb_val_samples, class_weight='auto', callbacks=args.callbacks) # NOTE model.save(os.path.join(os.getcwd(), 'models', args.output_model_file)) utils.plot_training(history_ft)
TEST_DATA_PATH = '/Users/aboga/repos/car-damage-dataset/data1a/validation' train_generator, validation_generator = create_data_generator( TRAIN_DATA_PATH, TEST_DATA_PATH) # train_data = np.load('bottleneck_features_train.npy') # # the features were saved in order, so recreating the labels is easy # train_labels = np.array([0] * 920 + [1] * 920) # validation_data = np.load('bottleneck_features_validation.npy') # validation_labels = np.array([0] * 230 + [1] * 230) BATCH_SIZE = 16 vgg = applications.VGG16(include_top=False, weights='imagenet', input_shape=(150, 150, 3)) vgg.trainable = False model = Sequential() model.add(vgg) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) model.summary()
def test_vgg16_notop(): model = applications.VGG16(weights=None, include_top=False) assert model.output_shape == (None, None, None, 512)
intra_op_parallelism_threads=NUM_PARALLEL_EXEC_UNITS, inter_op_parallelism_threads=1 ) session = tf.Session(config=config) K.set_session(session) #MKL and OpenMP os.environ["OMP_NUM_THREADS"] = str(NUM_PARALLEL_EXEC_UNITS) os.environ["KMP_BLOCKTIME"] = "1" os.environ["KMP_SETTINGS"] = "1" os.environ["KMP_AFFINITY"]= "granularity=fine,verbose,compact,1,0" # Initialize VGG16 with transfer learning base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(WIDTH, HEIGHT,3)) # add a global spatial average pooling layer x = base_model.output x = GlobalAveragePooling2D()(x) # and a dense layer x = Dense(1024, activation='relu')(x) predictions = Dense(len(train_flow.class_indices), activation='softmax')(x) # this is the model we will train model = Model(inputs=base_model.input, outputs=predictions) # first: train only the top layers (which were randomly initialized) # i.e. freeze all convolutional VGG16 layers
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(image_train, labels_train, validation_data=(image_valid, labels_valid), batch_size=100, epochs=10) # --------------------------transfer learning from keras import applications from keras.models import Model from keras.callbacks import ModelCheckpoint, EarlyStopping model = applications.VGG16(weights="imagenet", include_top=False, input_shape=(100, 100, 3)) for layer in model.layers[:]: layer.trainable = False x = model.output x = Flatten()(x) x = Dense(1024, activation='relu')(x) # or 512 x = Dropout(0.2)(x) x = Dense(22, activation='softmax')(x) transfered_model = Model(inputs=model.input, output=x) transfered_model.summary() transfered_model.compile(optimizer='rmsprop', loss='categorical_crossentropy',
def train_top_model(train_targets, valid_targets, test_targets, test_tensors): input_tensor = Input(shape=(150, 150, 3)) base_model = applications.VGG16(weights='imagenet', include_top=False, input_tensor=input_tensor) print('Model loaded.') top_model = Sequential() top_model.add(BatchNormalization(input_shape=base_model.output_shape[1:])) top_model.add(GlobalAveragePooling2D()) top_model.add(Dense(32, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(10, activation='softmax')) top_model.load_weights(top_model_weights_path) model = Model(input=base_model.input, output=top_model(base_model.output)) for layer in model.layers[:25]: layer.trainable = False #opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6) model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) model.summary() checkpointer = ModelCheckpoint(filepath=top_model_fine_weights_path, verbose=1, save_best_only=True) train_datagen = ImageDataGenerator( rotation_range= 25, # randomly rotate images in the range (degrees, 0 to 180) # randomly shift images horizontally (fraction of total width) width_shift_range=0.2, # randomly shift images vertically (fraction of total height) height_shift_range=0.2, shear_range=0.15, # set range for random shear zoom_range=0.15, # set range for random zoom channel_shift_range=0.0, # set range for random channel shifts # set mode for filling points outside the input boundaries fill_mode='nearest', cval=0., # value used for fill_mode = "constant" horizontal_flip=True, rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_height, img_width), batch_size=batch_size, ) validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_height, img_width), batch_size=batch_size, ) history = model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=5, validation_data=validation_generator, verbose=1, shuffle=True, callbacks=[checkpointer], validation_steps=nb_validation_samples // batch_size) # history = model.fit(train_data, train_targets, # #steps_per_epoch = 100, # epochs=200, #300 # batch_size=32, # shuffle = True, # verbose=1, # validation_data=(valid_data, valid_targets), # callbacks=[checkpointer]) #model.save_weights(top_model_fine_weights_path) model.load_weights(top_model_fine_weights_path) pred_values = [(model.predict(np.expand_dims(tensor, axis=0))) for tensor in test_tensors] mushroom_predictions = [ np.argmax(model.predict(np.expand_dims(tensor, axis=0))) for tensor in test_tensors ] true_predictions = np.argmax(test_targets, axis=1) test_accuracy = 100 * np.sum( np.array(mushroom_predictions) == np.argmax( test_targets, axis=1)) / len(mushroom_predictions) print('Test accuracy: %.4f%%' % test_accuracy) print(history.history.keys()) # summarize history for accuracy plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'valid'], loc='upper left') plt.show() # summarize history for loss plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'valid'], loc='upper left') plt.show() cm = confusion_matrix(y_true=true_predictions, y_pred=mushroom_predictions) labels = [ '001', '002', '003', '004', '005', '006', '007', '008', '009', '010' ] plt.figure() plot_confusion_matrix(cm, classes=labels, title='Confusion matrix, without normalization') plt.show() report = classification_report(true_predictions, mushroom_predictions) print(report)
from keras import applications from keras.models import Sequential from keras.layers.core import Flatten, Dense, Dropout from keras.layers.convolutional import Conv2D, MaxPooling2D, ZeroPadding2D from keras.optimizers import SGD import numpy as np from keras.preprocessing.image import ImageDataGenerator model = applications.VGG16(include_top=False,weights='imagenet',input_shape=(60,60,3)) inps = np.load('/home/wangxiaopeng/NUS_dataset/218838_conv_pics.npy') trans = model.predict(inps) print 'trans shape:',trans.shape np.save(open('/home/wangxiaopeng/NUS_dataset/218838_vgg16_pics.npy', 'w'),trans)
def main(args): print("Loading Pretrained model VGG16") model = applications.VGG16(include_top=False, weights='imagenet') model_pre = Model(model.inputs, model.layers[-2].output) print("Got Weights") data_dir = args.data_dir #datagen_top = ImageDataGenerator(rescale=1. / 255,rotation_range=9,horizontal_flip=True) datagen_top = ImageDataGenerator() generator_top = datagen_top.flow_from_directory( data_dir, target_size=(args.image_size, args.image_size), batch_size=args.batch_size, class_mode='categorical', shuffle=False) nb_samples = len(generator_top.filenames) num_classes = len(generator_top.class_indices) labels = generator_top.classes print(labels.shape) predict_size_data = int(math.ceil(nb_samples / args.batch_size)) print("Extracting features...") bottleneck_features = model_pre.predict_generator(generator_top, predict_size_data, verbose=1) #Covariance Calculation print("Getting covariance matrix ") covarianceDimension = bottleneck_features.shape[3] longVectorDimension = ((covarianceDimension * (covarianceDimension + 1)) / 2) longVector = np.zeros( (bottleneck_features.shape[0], int(longVectorDimension))) for i in tqdm(range(0, bottleneck_features.shape[0])): X = bottleneck_features[i] y = X.reshape(X.shape[0] * X.shape[1], X.shape[2]) #Shape (14*14, 512) yt = np.transpose(y) #print(y.shape) #covarianceMatrix = np.cov(y) covarianceMatrix = yt.dot(y) #Matrix Logarithm identityMatrix = np.identity(covarianceDimension) lambdaValue = 1.e-3 covarianceMatrixNew = ((identityMatrix * lambdaValue) + covarianceMatrix) matrixLogarithm = logm(covarianceMatrixNew) flattenVector = list( matrixLogarithm[np.triu_indices(bottleneck_features.shape[3])] ) #If matrix logarithm is applied change covariance matrix to matrixLogarithm longVector[i] = flattenVector print('Long Vector Dimension ', longVector.shape) print("Scaling Features") bottleneck_features = longVector #bottleneck_features = scale(longVector) classifier_filename_exp = os.path.expanduser(args.classifier_filename) ##After long Vector if (args.mode == 'TRAIN'): print('Training classifier') start = time.time() modelSVC = SVC(kernel='linear', probability=True, verbose=True) modelSVC.fit(bottleneck_features, labels) end = time.time() print("Time taken", (end - start)) with open(classifier_filename_exp, 'wb') as outfile: joblib.dump(modelSVC, outfile) print('Saved classifier model to file "%s"' % classifier_filename_exp) elif (args.mode == 'CLASSIFY'): print('Testing classifier') with open(classifier_filename_exp, 'rb') as infile: modelSVC = joblib.load(infile) print('Loaded classifier model from file "%s"' % classifier_filename_exp) print("Predicting Images") predictions = modelSVC.predict_proba(bottleneck_features) best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[ np.arange(len(best_class_indices)), best_class_indices] arr = [] for i in range(len(best_class_indices)): arr.append((predictions[i], best_class_indices[i], labels[i])) print(arr) # pickle.dump(arr, open('classification_data.p','wb')) accuracy = 100 * np.mean(np.equal(best_class_indices, labels)) print('Total Accuracy: %.3f' % accuracy) '''
ValIDs = readIDfile(ValIdFile) ValIDs = ValIDs[0:ValSize] TestIDs = readIDfile(TestIdFile) numTestSam = len(TestIDs) #====================================# #============= Train and test data generators ========================# #[X_F_batch_test, X_R_batch_test, X_L_batch_test], [y_Elev_test, y_Azim_test] = MydataGeneratorTest(TrainIDs, MyBatchSize, samples_per_epoch) train_datagen = MydataGenerator(TrainIDs, MyBatchSize, samples_per_epoch) Val_generator = MydataGenerator(ValIDs, MyBatchSize, ValSize) #x, y = next(train_datagen) ## for testing purposes #============== Create the face Network ==============================# model_F = applications.VGG16(weights="imagenet", include_top=False, input_shape=(FaceResize, FaceResize, 3)) ##VGG network for face model_L = applications.VGG16(weights="imagenet", include_top=False, input_shape=(EyeResize, EyeResize, 3)) ##VGG network for left Eye model_R = applications.VGG16(weights="imagenet", include_top=False, input_shape=(EyeResize, EyeResize, 3)) ##VGG network for right Eye # change the layers' names in left and right eyes network for i, layer in enumerate(model_L.layers): layer.name = layer.name + '_l' for i, layer in enumerate(model_R.layers): layer.name = layer.name + '_r'
X = np.array([i for i in np.array(df["imgData"]) ]).reshape(-1, IMG_SIZE, IMG_SIZE, 3) y = df["totPurchaseAmt"] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # In[7]: vggModel = Sequential() vggModel.add( applications.VGG16(weights="imagenet", input_shape=(IMG_SIZE, IMG_SIZE, 3), include_top=False)) numLayers = len(vggModel.layers) for layer in vggModel.layers[:numLayers - 2]: layer.trainable = False vggModel.add(Flatten(input_shape=vggModel.output_shape[1:])) vggModel.add(Dropout(.1)) vggModel.add(Dense(1, activation="linear")) vggModel.summary() # In[8]:
from PIL import Image, ImageOps import uuid # path to the model weights files. top_model_weights_path = '../bottleneck_fc_model.h5' # dimensions of our images. This is set according to the input dimension of the model img_width, img_height = 150, 150 # this is set in accordance with model output num_classes = 3 #initialize and load trained model input_tensor = Input(shape=(img_height, img_width, 3)) # build the VGG16 network base_model = applications.VGG16(weights='imagenet', include_top=False, input_tensor=input_tensor) print('Base Model loaded.') # build a classifier model to put on top of the convolutional model top_model = Sequential() top_model.add(Flatten(input_shape=base_model.output_shape[1:])) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(num_classes, activation='softmax')) # load the weights of top model top_model.load_weights(top_model_weights_path) print('Top Model loaded') # Compile the full model by adding topmodel to base model
def test_vgg19_pooling(): model = applications.VGG16(weights=None, include_top=False, pooling='avg') assert model.output_shape == (None, 512)
# path to the model weights files. weights_path = '../keras/examples/vgg16_weights.h5' top_model_weights_path = 'fc_model.h5' # dimensions of our images. img_width, img_height = 150, 150 train_data_dir = 'cats_and_dogs_small/train' validation_data_dir = 'cats_and_dogs_small/validation' nb_train_samples = 2000 nb_validation_samples = 800 epochs = 50 batch_size = 16 # build the VGG16 network base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(200, 200, 3)) print("befor loading>>>") base_model.summary() print('Model loaded.') # build a classifier model to put on top of the convolutional model print("model.output_shape:\n", base_model.output_shape) print("model.output_shape[1:]") print(base_model.output_shape[1:]) ''' model.output_shape: (None, 6, 6, 512) model.output_shape[1:] (6, 6, 512) ''' top_model = Sequential()
def test_vgg16(): model = applications.VGG16(weights=None) assert model.output_shape == (None, 1000)
def main(): image_size = Configure.vgg_image_size # all train data train_x_image_path, train_y = data_util.load_train_data( image_size=image_size) # split train/validate train_X, validate_X, train_y, validate_y = train_test_split( train_x_image_path, train_y, test_size=0.1, random_state=0) train_data_wapper = data_util.DataWapper(x=train_X, y=train_y, target_size_x=image_size, target_size_y=image_size, istrain=True) validate_data_wapper = data_util.DataWapper(x=validate_X, y=validate_y, target_size_x=image_size, target_size_y=image_size, istrain=True) if K.image_data_format() == 'channels_first': # theano input_shape = (3, image_size, image_size) else: # tensorflow input_shape = (image_size, image_size, 3) print 'built vgg16 model' # build the VGG16 network image_input = Input(shape=input_shape) model = applications.VGG16(weights='imagenet', include_top=False, input_tensor=image_input) print('Model loaded.') for layer in model.layers[0:3]: print 'frozen layer', layer layer.trainable = False # build a classifier model to put on top of the convolutional model top_model = Flatten(name='flatten')(model.output) top_model = Dense(256, activation='relu', name='fc1', kernel_regularizer=regularizers.l2(5e-4))(top_model) top_model = Dropout(0.5)(top_model) top_model = Dense(256, activation='relu', name='fc2', kernel_regularizer=regularizers.l2(5e-4))(top_model) top_model = Dropout(0.5)(top_model) top_model = Dense(1, activation='sigmoid', name='predictions')(top_model) model = Model(input=image_input, output=top_model, name='vgg16') # compile the model with a SGD/momentum optimizer # and a very slow learning rate. model.compile(loss='binary_crossentropy', optimizer=optimizers.Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0), metrics=['accuracy']) print(model.summary()) plot_model(model, to_file='vgg16_model.png') print '========== start training ==========' print 'training data size: ', train_X.shape[0] print 'validate data size: ', validate_X.shape[0] epochs = 100 batch_size = 50 validate_X, validate_y = validate_data_wapper.load_all_data() def data_generator(gen_batch_size): while 1: batch_x, batch_y = train_data_wapper.next_batch(gen_batch_size) yield batch_x, batch_y weights_file = Configure.vgg16_best_model_weights earlystop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, verbose=0, mode='auto') checkpoint_lr_decay = ModelCheckpointAndLearningRateDecay( weights_file, lr_decay=0.9, monitor='val_loss', verbose=0, save_best_only=True, mode='min', patience=3) if os.path.exists(weights_file): model.load_weights(weights_file) print("Model loaded.") model.fit_generator(data_generator(gen_batch_size=batch_size), steps_per_epoch=train_X.shape[0] // batch_size, epochs=epochs, verbose=1, validation_data=(validate_X, validate_y), callbacks=[earlystop, checkpoint_lr_decay]) print '============ load weights ============' model.load_weights(weights_file) print '========== start validating ==========' predict = model.predict(validate_X, batch_size=100, verbose=1) val_roc = roc_auc_score(validate_y, predict) print 'validate roc_auc_score =', val_roc print '========== start predicting ==========' # load all all test data print 'load all all test data...' test_image_name, test_x = data_util.load_test_data(image_size) test_data_wapper = data_util.DataWapper(test_x, target_size_x=image_size, target_size_y=image_size, istrain=False) test_x, _ = test_data_wapper.load_all_data() print 'predict...' predict = model.predict(test_x, batch_size=100, verbose=1) predict = predict[:, 0] predict_df = pd.DataFrame({'name': test_image_name, 'invasive': predict}) print 'result:', predict_df.shape[0] print 'average...' predict_df['name'] = predict_df['name'].map(lambda n: n.split('_')[-1]) predict_df = predict_df.groupby('name').agg('mean').reset_index() predict_df = predict_df[['name', 'invasive']] print 'submit test size:', predict_df.shape[0] predict_df.to_csv(Configure.submission_path.format('vgg16'), index=False) print 'done.'
def model_app(arch, weights): """Loads the appropriate convolutional neural network (CNN) model Args: arch: String key for model to be loaded. weights: one of 'imagenet' or None Returns: model: The specified Keras Model instance with ImageNet weights loaded and without the top classification layer. """ # function that loads the appropriate model if arch == 'Xception': model = applications.Xception(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('Xception loaded') elif arch == 'VGG16': model = applications.VGG16(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('VGG16 loaded') elif arch == 'VGG19': model = applications.VGG19(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('VGG19 loaded') elif arch == 'ResNet50': model = applications.ResNet50(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('ResNet50 loaded') elif arch == 'InceptionV3': model = applications.InceptionV3(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('InceptionV3 loaded') elif arch == 'InceptionResNetV2': model = applications.InceptionResNetV2(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('InceptionResNetV2 loaded') elif arch == 'MobileNet': model = applications.MobileNet(input_shape=(224, 224, 3), include_top=False, weights=weights) print('MobileNet loaded') elif arch == 'DenseNet121': model = applications.DenseNet121(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('DenseNet121 loaded') elif arch == 'NASNetLarge': model = applications.NASNetLarge(include_top=False, weights=weights, input_shape=(299, 299, 3)) print('NASNetLarge loaded') elif arch == 'MobileNetV2': model = applications.MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights=weights) print('MobileNetV2 loaded') else: print('Invalid model selected') model = False return model
def get_model(num, print_model=False, reg=False, reg_type=None, num_classes=2): """ reg_type is only in accesssed if reg is True reg_type is a dictionary with keys dropout: [<rate>, ...] l2: [<rate>, ...] """ model = Sequential() if num == 1: if reg: model.add( Conv2D( 16, kernel_size=(3, 3), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][0]), )) model.add(Dropout(reg_type['dropout'][0])) model.add( Conv2D( 4, (5, 5), activation='relu', activity_regularizer=regularizers.l2(reg_type['l2'][1]), )) model.add(Dropout(reg_type['dropout'][1])) else: model.add( Conv2D(16, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(4, (5, 5), activation='relu'), ) model.add(MaxPooling2D(pool_size=(7, 7))) model.add(Flatten()) model.add(Dense(num_classes, activation='softmax')) elif num == 2: if reg: model.add( Conv2D( 4, kernel_size=(3, 3), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][0]), )) model.add(MaxPooling2D(pool_size=(5, 5))) model.add(Dropout(reg_type['dropout'][0])) model.add( Conv2D( 16, kernel_size=(3, 3), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][1]), )) model.add(MaxPooling2D(pool_size=(5, 5))) model.add(Dropout(reg_type['dropout'][1])) model.add( Conv2D( 1, kernel_size=(3, 3), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][2]), )) model.add(Dropout(reg_type['dropout'][2])) else: model.add( Conv2D(4, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(5, 5))) model.add( Conv2D(16, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(5, 5))) model.add( Conv2D(1, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Flatten()) model.add(Dense(num_classes, activation='softmax')) elif num == 3: if reg: model.add( Conv2D( 4, kernel_size=(3, 3), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][0]), )) model.add(MaxPooling2D(pool_size=(3, 3))) model.add(Dropout(reg_type['dropout'][0])) model.add( Conv2D( 16, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][1]), )) model.add(MaxPooling2D(pool_size=(3, 3))) model.add(Dropout(reg_type['dropout'][1])) model.add( Conv2D( 1, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=input_shape, activity_regularizer=regularizers.l2(reg_type['l2'][2]), )) model.add(Dropout(reg_type['dropout'][2])) else: model.add( Conv2D(4, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(3, 3))) model.add( Conv2D(16, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(3, 3))) model.add( Conv2D(1, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=input_shape)) model.add(Flatten()) model.add(Dense(num_classes, activation='softmax')) elif num == 4: # VGG Model base_model = applications.VGG16(weights='imagenet', include_top=False, input_tensor=input_tensor) layer_dict = dict([(layer.name, layer) for layer in base_model.layers]) num = 6 x = layer_dict['block2_pool'].output x = Conv2D(filters=4, kernel_size=(1, 1), activation='relu')(x) x = MaxPooling2D(pool_size=(5, 5))(x) x = Flatten()(x) x = Dense(32, activation='relu')(x) if reg: num += 1 x = Dropout(reg_type['dropout'][0])(x) x = Dense(num_classes, activation='softmax')(x) model = Model(base_model.input, x) for layer in model.layers[:-num]: layer.trainable = False elif num == 5: # Resnet 50 v2 base_model = applications.ResNet50V2(weights='imagenet', include_top=False, input_tensor=input_tensor) layer_dict = dict([(layer.name, layer) for layer in base_model.layers]) num = 5 x = layer_dict['post_relu'].output x = Conv2D(filters=8, kernel_size=(1, 1), activation='relu')(x) x = MaxPooling2D(pool_size=(5, 5))(x) if reg: num += 1 x = Dropout(reg_type['dropout'][0])(x) x = Flatten()(x) x = Dense(num_classes, activation='softmax')(x) model = Model(base_model.input, x) for layer in model.layers[:-num]: layer.trainable = False elif num == 6: # MobileNet v2 base_model = applications.MobileNetV2(weights='imagenet', include_top=False, input_tensor=input_tensor) layer_dict = dict([(layer.name, layer) for layer in base_model.layers]) num = 5 x = layer_dict['out_relu'].output x = Conv2D(filters=16, kernel_size=(1, 1), activation='relu')(x) x = MaxPooling2D(pool_size=(5, 5))(x) if reg: num += 1 x = Dropout(reg_type['dropout'][0])(x) x = Flatten()(x) x = Dense(num_classes, activation='softmax')(x) model = Model(base_model.input, x) for layer in model.layers[:-num]: layer.trainable = False model.compile( loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(), metrics=['accuracy'], ) if print_model: print(model.summary()) return model
# dimensions of our images. img_width, img_height = 150, 150 train_data_dir = 'data/train' validation_data_dir = 'data/validation' nb_train_samples = 2000 nb_validation_samples = 800 epochs = 50 batch_size = 16 # build the VGG16 network # build a classifier model to put on top of the convolutional model model = Sequential( applications.VGG16(weights='imagenet', input_shape=(150, 150, 3), include_top=False).layers) # print(model.get_layer('block5_pool').get_output_at(0).shape) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) # set the first 25 layers (up to the last conv block) # to non-trainable (weights will not be updated) for layer in model.layers[:25]: layer.trainable = False # compile the model with a SGD/momentum optimizer # and a very slow learning rate. model.compile(loss='binary_crossentropy',
def post(self): postedData = request.get_json() image_path = postedData["image_path"] K.clear_session() postedData3 = request.get_json( 'http://182.18.157.124/ImgVerification/ProjectService.asmx') print("posted data", postedData3) postedData2 = requests.get( 'http://182.18.157.124/ImgVerification/ProjectService.asmx') print(postedData2.json) # load the class_indices saved in the earlier step class_dictionary = np.load('./data1/model/class_indices.npy', allow_pickle=True).item() num_classes = len(class_dictionary) # add the path to your test image below #image_path = './test_images/bin1.jpg' orig = cv2.imread(image_path) print("[INFO] loading and preprocessing image...") image = load_img(image_path, target_size=(224, 224)) image = img_to_array(image) # important! otherwise the predictions will be '0' image = image / 255 image = np.expand_dims(image, axis=0) # build the VGG16 network model = applications.VGG16(include_top=False, weights='imagenet') # get the bottleneck prediction from the pre-trained VGG16 model bottleneck_prediction = model.predict(image) # build top model model = Sequential() model.add(Flatten(input_shape=bottleneck_prediction.shape[1:])) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) model.load_weights(top_model_weights_path) # use the bottleneck prediction on the top model to get the final # classification class_predicted = model.predict_classes(bottleneck_prediction) probabilities = model.predict_proba(bottleneck_prediction) inID = class_predicted[0] inv_map = {v: k for k, v in class_dictionary.items()} label = inv_map[inID] # get the prediction label print("Image ID: {}, Label: {}".format(inID, label)) response = requests.post( "http://182.18.157.124/ImgVerification/ProjectService.asmx", json={ "status": "200", "image id": inID, "msg": label }) response.json() """retJson = {
def learnModelMulti(): if(MODEL_NAME == 'RESNET'): K.set_learning_phase(0) # set model to inference / test mode manually (required for BN layers) base_model = applications.ResNet50(include_top=False, weights='imagenet', input_shape=(IMG_SIZE, IMG_SIZE, 3)) x = base_model.output x = layers.GlobalAveragePooling2D()(x) #x = layers.Dropout(0.5)(x) elif(MODEL_NAME == 'Xception'): K.set_learning_phase(0) # set model to inference / test mode manually (required for BN layers) base_model = applications.Xception(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3)) x = base_model.output x = layers.GlobalAveragePooling2D()(x) #ox = layers.Dropout(0.7)(x) else: base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3)) x = base_model.output x = layers.Flatten()(x) # flatten 3D output to 1D print('***** Base model {} loaded:'.format(MODEL_NAME)) #n_layers_base = len(base_model.layers) if(MODEL_NAME == 'Xception' or MODEL_NAME == 'RESNET'): K.set_learning_phase(1) # set model to training mode manually (required for BN layers) MLT_shared_repr = layers.Dense(NUM_HIDDEN_UNITS, activation='relu', name='shared_repr')(x) drop_out_layer = layers.Dropout(DROPOUT)(MLT_shared_repr) artist_prediction = layers.Dense(nClassesArtist, kernel_regularizer=regularizers.l2(0.001), activation='softmax', name='artist')(drop_out_layer) year_prediction = layers.Dense(1, name='year')(drop_out_layer) # regression hence no activation function type_prediction = layers.Dense(nClassesType, activation='sigmoid', name='type')(drop_out_layer) mat_prediction = layers.Dense(nClassesMat, activation='sigmoid', name='mat')(drop_out_layer) # MLT_shared_repr = layers.Dense(NUM_HIDDEN_UNITS, activation='relu', name='shared_repr')(x) # MLT_shared_repr = layers.Dropout(0.5)(MLT_shared_repr) # # artist_prediction = layers.Dense(300, activation='relu', name='artist_h')(MLT_shared_repr) # artist_prediction = layers.Dropout(0.5)(artist_prediction) # artist_prediction = layers.Dense(nClassesArtist, activation='softmax', name='artist')(artist_prediction) # # year_prediction = layers.Dense(300, activation='relu', name='year_h')(MLT_shared_repr) # regression hence no activation function # year_prediction = layers.Dropout(0.5)(year_prediction) # year_prediction = layers.Dense(1, name='year')(year_prediction) # regression hence no activation function # # type_prediction = layers.Dense(300, activation='relu', name='type_h')(MLT_shared_repr) # type_prediction = layers.Dropout(0.5)(type_prediction) # type_prediction = layers.Dense(nClassesType, activation='sigmoid', name='type')(type_prediction) # # mat_prediction = layers.Dense(300, activation='relu', name='mat_h')(MLT_shared_repr) # mat_prediction = layers.Dropout(0.5)(mat_prediction) # mat_prediction = layers.Dense(nClassesMat, activation='sigmoid', name='mat')(mat_prediction) global custom_model custom_model = Model(base_model.input,[artist_prediction, year_prediction, type_prediction, mat_prediction]) #print("***** Full model") #custom_model.summary() print('# trainable weights ' 'before freezing the conv base:', len(custom_model.trainable_weights)) for layer in base_model.layers: layer.trainable = False print('# trainable weights ' 'after freezing the conv base:', len(custom_model.trainable_weights)) artist_loss_weight = 2 year_loss_weight = 0 #0.1 #0.05 type_loss_weight = 1 mat_loss_weight = 1 f = open(LOGS_FOLDER + MODEL_NAME + '_info.txt', 'a') msg = '\nartist_loss_weight = {:.2f}\n'.format(artist_loss_weight) msg += 'year_loss_weight = {:.2f}\n'.format(year_loss_weight) msg += 'type_loss_weight = {:.2f}\n'.format(type_loss_weight) msg += 'mat_loss_weight = {:.2f}\n'.format(mat_loss_weight) print(msg) f.write(msg) f.close() #optimizer = tf.train.RMSPropOptimizer(learning_rate=2e-3, decay=0.9) #custom_model.compile(optimizer='rmsprop', #sgd = SGD(lr=1e-2, decay=1e-6, momentum=0.9, nesterov=True) loss_mae_tol = cm.mae_tol_param(50) custom_model.compile(optimizer='adam', loss = {'artist': 'categorical_crossentropy', 'year': 'mae', 'type': 'binary_crossentropy', 'mat': 'binary_crossentropy'}, loss_weights = {'artist': artist_loss_weight, 'year': year_loss_weight, 'type': type_loss_weight, 'mat': mat_loss_weight}, metrics = {'artist': 'accuracy' , 'year': ['mae', loss_mae_tol] , 'type': cm.precision, 'mat': cm.precision}, weighted_metrics = {'artist': 'categorical_accuracy', 'year': 'mae'}, sample_weight_mode ={'artist': None, 'year': None , 'type': None, 'mat': None}) train_gen = data_generator(train_set, Train=True) valid_gen = data_generator(valid_set, Train=False) #callbacks = [keras.callbacks.TensorBoard(log_dir='../logs',histogram_freq=1] callbacks_list = [callbacks.CSVLogger(LOGS_FOLDER + MODEL_NAME +'.log'), callbacks.EarlyStopping(monitor='val_artist_weighted_categorical_accuracy',patience=4), callbacks.ModelCheckpoint(filepath='artistsRD_W.h5',monitor='val_loss',save_best_only=True)] #csv_logger = callbacks.CSVLogger(LOGS_FOLDER + MODEL_NAME +'.log') history = custom_model.fit_generator(train_gen, validation_data = valid_gen, validation_steps = ceil(valid_set.shape[0] / BATCH_SIZE), steps_per_epoch = ceil(2 * train_set.shape[0] / BATCH_SIZE), epochs = NUM_EPOCHS, verbose = 1, #class_weight = {'artist': dic_artist_weights}, callbacks=callbacks_list) print('***** Training logs saved as ' + LOGS_FOLDER + MODEL_NAME +'.log') custom_model.save(MODEL_FOLDER + 'artistsRD_W.h5') print('***** Model saved as artistsRD.h5')
class WeightsSaver(Callback): def __init__(self, model, N=1): self.model = model self.N = N self.epoch = 1 def on_epoch_end(self, epoch, logs={}): if self.epoch % self.N == 0: name = 'script1model6_50try02%05d.h5' % self.epoch self.model.save_weights(src + name) self.epoch += 1 #We remove the last 8 layers of the convolutional network oldModel = applications.VGG16(include_top=False, weights='imagenet', input_shape=(img_size, img_size, 3)) for i in range(8): oldModel.layers.pop() #we add the fully connected layer model = Sequential() for layer in oldModel.layers: model.add(layer) model.add(Flatten()) model.add( Dense(300, kernel_initializer=initializers.RandomNormal(mean=0, stddev=0.01), bias_initializer='zeros')) model.add( Dense(300,
def __init__(self,w_path,model): self.model = model self.model.load_weights(w_path) self.b_model = applications.VGG16(include_top=False, weights='imagenet') self.graph = tf.get_default_graph()
def finetune_vgg16(train_folder_path, weights_dir, image_shape, num_epochs): ## #from glob import glob class_names = glob.glob(train_folder_path+"/*") # Reads all the folders in which images are present print(class_names) class_names = sorted(class_names) # Sorting them class_labels_dict = dict(zip(class_names, range(len(class_names)))) num_classes = len(class_names) print(num_classes) ## ## define input of model #image_shape = (None, None, 3) ##inp=keras.layers.Input(shape =image_shape) ## ## build the VGG16 network for variable image sizes base_model = applications.VGG16(include_top=False, weights='imagenet', input_shape=image_shape) ## add layers specific to our task x=base_model.output print(x.shape) x = keras.layers.GlobalAveragePooling2D()(x) print(x.shape) x = keras.layers.Dense(4096, activation='relu', name='fc1')(x) print(x.shape) x = keras.layers.Dense(4096, activation='relu', name='fc2')(x) print(x.shape) predictions = keras.layers.Dense(num_classes, activation='softmax', name='predictions')(x) print(predictions.shape) ## custom_model = keras.Model(inputs=base_model.input,outputs=predictions) # Make sure that the pre-trained bottom layers are not trainable for layer in custom_model.layers[:7]: layer.trainable = False adam_opt = keras.optimizers.Adam(lr=1e-5) custom_model.compile(optimizer=adam_opt,loss='categorical_crossentropy',metrics=['accuracy']) ## get list of all training data #all_data = glob.glob('{}/*/*'.format(train_folder_path)) all_data = glob.glob('{}/*'.format(train_folder_path)) #with open('/data_file.txt','w') as f: # f.write('\n'.join(all_data)) # #train_data = all_data[10:] #test_data = all_data[:10] #num_iters = len(train_data)//batch_size #iter_counter = 0 # ## set up dataset generatpr train_datagen=ImageDataGenerator(preprocessing_function=preprocess_input) #included in our dependencies train_generator=train_datagen.flow_from_directory(train_folder_path, target_size=(image_shape[0], image_shape[1]), color_mode='rgb', batch_size=3, class_mode='categorical', shuffle=True) # generate_arrays_from_file(all_data, batch_size, class_labels_dict) # ## train the network STEP_SIZE_TRAIN=train_generator.n//train_generator.batch_size custom_model.fit_generator(train_generator, steps_per_epoch=STEP_SIZE_TRAIN, epochs=num_epochs, verbose=1) ## save as tf model #tf.keras.models.save_model(custom_model, os.path.join(weights_dir,'vgg16_custom_model_tf'), save_format='tf') #custom_model.save(os.path.join(weights_dir,'vgg16_custom_model_tf'), save_format='tf') ## save the network weights custom_model.save_weights(os.path.join(weights_dir,'vgg16_custom_model_weights.h5')) ## Save the model architecture with open(os.path.join(weights_dir, 'model_architecture.json'), 'w') as f: f.write(custom_model.to_json()) ## save the dataset class dictionary label_map = train_generator.class_indices # with open(os.path.join(weights_dir, 'classes.txt'), 'w') as f: f.write(str(label_map))
# train_data_dir, # target_size=(img_height, img_width), # batch_size=batch_size, # class_mode='binary') # validation_generator = test_datagen.flow_from_directory( # validation_data_dir, # target_size=(img_height, img_width), # batch_size=batch_size, # class_mode='binary') # In[3]: # build the VGG16 network base_model = applications.VGG16(weights=None, include_top=False, input_shape=(150, 150, 3)) print('Model loaded.') # In[4]: # build a classifier model to put on top of the convolutional model top_model = Sequential() top_model.add(Flatten(input_shape=base_model.output_shape[1:])) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(1, activation='sigmoid')) # note that it is necessary to start with a fully-trained # classifier, including the top classifier, # in order to successfully do fine-tuning
elif path[0].split('/')[-2] == 'mucca': name_animal.append('cow') elif path[0].split('/')[-2] == 'gatto': name_animal.append('cat') elif path[0].split('/')[-2] == 'pecora': name_animal.append('sheep') elif path[0].split('/')[-2] == 'gallina': name_animal.append('chicken') elif path[0].split('/')[-2] == 'elefante': name_animal.append('elephant') elif path[0].split('/')[-2] == 'ragno': name_animal.append('spider') elif path[0].split('/')[-2] == 'cane': name_animal.append('dog') base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(img_rows, img_cols, img_channel)) add_model = Sequential() add_model.add(Flatten(input_shape=base_model.output_shape[1:])) add_model.add(Dense(256, activation='relu')) add_model.add(Dense(10, activation='softmax')) model = Model(inputs=base_model.input, outputs=add_model(base_model.output)) model.compile(loss='binary_crossentropy', optimizer=optimizers.SGD(lr=1e-4, momentum=0.9), metrics=['accuracy']) model.summary() batch_size = 32 epochs = 15
def save_bottlebeck_features(): np.random.seed(2929) vgg_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(150, 150, 3)) print('Model loaded.') #initialise top model top_model = Sequential() top_model.add(Flatten(input_shape=vgg_model.output_shape[1:])) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(1, activation='sigmoid')) model = Model(inputs=vgg_model.input, outputs=top_model(vgg_model.output)) model.trainable = True model.summary() #Total of 20 layers. The classification is considered as one layer #Therefore, intermediate is 19 layers #0, 4[:4], 3[:7], 4[:11], 4[:15], 4[:19] (Group 0, 1, 2, 3, 4, 5) #0 -> All trainable #5 -> All non-trainable except classification layer #Always keep layer 20 trainable because it is classification layer #layer_count = 1 for layer in model.layers[:15]: layer.trainable = False #print("NO-Top: Layer is %d trainable" %layer_count) #layer_count = layer_count + 1 model.summary() train_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='binary') sgd = optimizers.Adam( lr=1e-6 ) #optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss="binary_crossentropy", optimizer=sgd, metrics=['accuracy']) # model.compile(optimizer='rmsprop', # loss='binary_crossentropy', metrics=['accuracy']) history = model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size, verbose=1) history_dict = history.history #Plotting the training and validation loss history_dict = history.history loss_values = history_dict['loss'] val_loss_values = history_dict['val_loss'] epochs_0 = range(1, len(history_dict['acc']) + 1) plt.plot(epochs_0, loss_values, 'bo', label='Training loss') plt.plot(epochs_0, val_loss_values, 'b', label='Validation loss') plt.title( 'MCvsNM_64_VGG16_Freeze_data2_group4 - Training and validation loss') plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() #plt.show() plt.savefig('MCvsNM_64_VGG16_Freeze_data2_group4_loss.png') plt.close() #Plotting the training and validation accuracy acc_values = history_dict['acc'] val_acc_values = history_dict['val_acc'] plt.plot(epochs_0, acc_values, 'bo', label='Training acc') plt.plot(epochs_0, val_acc_values, 'b', label='Validation acc') plt.title( 'MCvsNM_64_VGG16_Freeze_data2_group4 - Training and validation accuracy' ) plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() #plt.show() plt.savefig('MCvsNM_64_VGG16_Freeze_data2_group4_acc.png') plt.close()
# expected image size img_width, img_height = 256, 256 # how many images to be considered for training train_samples = 1840 # how many images to be used for validation validation_samples = 460 num_epochs = 20 top_model_weights_path = location + '/model_weights.h5' fine_tuned_model_path = location + '/trained_model.h5' #Transfer learning with VGG16 base_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(img_width, img_height, 3)) ## set model architecture add_model = Sequential() add_model.add(Flatten(input_shape=base_model.output_shape[1:])) add_model.add(Dense(256, activation='relu', W_regularizer=l2(0.01))) add_model.add(Dropout(0.5)) #use activation softmax for multiple categories add_model.add(Dense(1, activation='sigmoid')) model = Model(inputs=base_model.input, outputs=add_model(base_model.output)) #can use categorical_crossentropy depending on the output classes model.compile(loss='binary_crossentropy', optimizer=optimizers.SGD(lr=1e-4, momentum=0.9), metrics=['accuracy'])