def run_test_harness(): # define model model = define_model() # create data generator datagen = ImageDataGenerator(featurewise_center=True) # specify imagenet mean values for centering datagen.mean = [123.68, 116.779, 103.939] # prepare iterator train_it = datagen.flow_from_directory('../dataset/train/', class_mode='binary', batch_size=64, target_size=(224, 224)) test_it = datagen.flow_from_directory('../dataset/test/', class_mode='binary', batch_size=64, target_size=(224, 224)) # fit model history = model.fit_generator(train_it, steps_per_epoch=len(train_it), validation_data=test_it, validation_steps=len(test_it), epochs=1, verbose=1) # evaluate model _, acc = model.evaluate_generator(test_it, steps=len(test_it), verbose=0) print('> %.3f' % (acc * 100.0)) # learning curves summarize_diagnostics(history) model.save('model.h5')
def run_test_harness_3(): ################################# TRANSFERR LEARNING ############ ########################################################################## model = vgg16_pretrained() # create data generator datagen = ImageDataGenerator(featurewise_center=True) # specify imagenet mean values for centering datagen.mean = [123.68, 116.779, 103.939] # prepare iterator train_it = datagen.flow_from_directory('q7_img_224/train/', class_mode='binary', batch_size=10, target_size=(224, 224)) test_it = datagen.flow_from_directory('q7_img_224/test/', class_mode='binary', batch_size=10, target_size=(224, 224)) # fit model history = model.fit_generator(train_it, steps_per_epoch=len(train_it), validation_data=test_it, validation_steps=len(test_it), epochs=10, verbose=1) # evaluate model _, acc = model.evaluate_generator(test_it, steps=len(test_it), verbose=1) print('> %.3f' % (acc * 100.0)) # learning curves summarize_diagnostics(history)
def get_test_generator(df, grab_mean_std, labels, img_dir, H, W, img_col='Image', is_tv_col='Is_tv', batch_size=8, seed=1): image_test_gen = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True) image_test_gen.mean, image_test_gen.std = grab_mean_std test_gen = image_test_gen.flow_from_dataframe( dataframe=df[df[is_tv_col] == False], directory=img_dir, x_col=img_col, y_col=labels, class_mode='raw', batch_size=batch_size, shuffle=False, seed=seed, target_size=(W, H)) return test_gen
def run_test_harness(): model = define_model() # define model datagen = ImageDataGenerator( featurewise_center=True) # create data generator datagen.mean = [123.68, 116.779, 103.939] # specify imagenet mean values for centering # prepare iterator print("start allocate") train_it = datagen.flow_from_directory('/PATH_TO_TRAIN_DIR/', class_mode='binary', batch_size=64, target_size=(240, 320)) test_it = datagen.flow_from_directory('/PATH_TO_TEST_DIR/', class_mode='binary', batch_size=64, target_size=(240, 320)) # fit model print("start train") history = model.fit(train_it, steps_per_epoch=len(train_it), validation_data=test_it, validation_steps=len(test_it), epochs=20, verbose=1) model.save('/PATH_TO_MODEL_.h5_FILE') # evaluate model _, acc = model.evaluate(test_it, steps=len(test_it), verbose=0) print('> %.3f' % (acc * 100.0)) # learning curves summarize_diagnostics(history)
def get_tv_generator(df, fold_train, fold_val, grab_mean_std, labels, img_dir, H, W, img_col='Image', shuffle=True, batch_size=8, seed=1): image_train_gen = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True, rotation_range=7, zoom_range=0.1, horizontal_flip=True, validation_split=0.) image_train_gen.mean, image_train_gen.std = grab_mean_std train_gen = image_train_gen.flow_from_dataframe( dataframe=df[df['Image'].isin(fold_train)], directory=img_dir, x_col=img_col, y_col=labels, class_mode='raw', batch_size=batch_size, shuffle=shuffle, seed=seed, target_size=(W, H)) image_val_gen = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True) image_val_gen.mean, image_val_gen.std = grab_mean_std val_gen = image_val_gen.flow_from_dataframe( dataframe=df[df['Image'].isin(fold_val)], directory=img_dir, x_col=img_col, y_col=labels, class_mode='raw', batch_size=batch_size, shuffle=False, seed=seed, target_size=(W, H)) return train_gen, val_gen
def main(): model_path = "./model.h5" checkpoint = ModelCheckpoint(model_path, monitor='val_loss', mode='min', save_best_only='True', verbose=1) model = VGG16(include_top=False, input_shape=(224, 224, 3)) for layer in model.layers: layer.trainable = False flat1 = Flatten()(model.layers[-1].output) class1 = Dense(128, activation='relu', kernel_initializer='he_uniform')(flat1) output = Dense(1, activation='sigmoid')(class1) model = Model(inputs=model.inputs, outputs=output) opt = SGD(lr=0.001, momentum=0.9) model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy']) datagen = ImageDataGenerator(featurewise_center=True) datagen.mean = [123.68, 116.779, 103.939] train_it = datagen.flow_from_directory('dataset_dogs_vs_cats/train/', class_mode='binary', batch_size=16, target_size=(224, 224)) test_it = datagen.flow_from_directory('dataset_dogs_vs_cats/test/', class_mode='binary', batch_size=16, target_size=(224, 224)) model.fit_generator(train_it, steps_per_epoch=len(train_it), validation_data=test_it, validation_steps=len(test_it), epochs=10, callbacks=[checkpoint], verbose=1) user_input = input("Do you want to evaluate the model on the test set?\ (y/n)") if user_input == 'y': score = model.evaluate_generator(test_it, steps=len(test_it), verbose=1) print("loss: ", score[0]) print('accuracy: ', score[1])
def create_prediction_model(npz_filename, model_name): # load dataset X, y = load_dataset(npz_filename) # create data generator datagen = ImageDataGenerator(featurewise_center=True, horizontal_flip=True, vertical_flip=True, rotation_range=90) # specify imagenet mean values for centering datagen.mean = [123.68, 116.779, 103.939] # prepare iterator train_it = datagen.flow(X, y, batch_size=128) # define model model = define_model() # fit model model.fit(train_it, steps_per_epoch=len(train_it), epochs=50, verbose=0) # save model model.save(model_name)
def run_test_harness(): modelName = 'nasnetMobile_5species75train25' # define model model = define_model() # create data generator datagen = ImageDataGenerator(featurewise_center=True) # specify imagenet mean values for centering datagen.mean = [123.68, 116.779, 103.939] # prepare iterators train_it = datagen.flow_from_directory('5species75train25test/train', class_mode='categorical', batch_size=32, target_size=(224, 224)) test_it = datagen.flow_from_directory('5species75train25test/test', class_mode='categorical', batch_size=32, target_size=(224, 224)) # fit model history = model.fit(train_it, steps_per_epoch=len(train_it), validation_data=test_it, validation_steps=len(test_it), epochs=20, verbose=1) # save model (.h5 format) model.save(modelName + '.h5') # save model (.pb format) model.save(modelName) # evaluate model _, acc = model.evaluate(test_it, steps=len(test_it), verbose=1) print('> %.3f' % (acc * 100.0)) # plot model plot_model(model, to_file=modelName + '.png') # learning curves summarize_diagnostics(history)
#optimizer = RMSprop(lr=0.0008, decay=1e-6) model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) # this is the augmentation we will use for training train_datagen = ImageDataGenerator( rescale=1. / 255, featurewise_center=True, featurewise_std_normalization=True, horizontal_flip=True, vertical_flip=True, rotation_range=15, width_shift_range=0.1, height_shift_range=0.1) train_datagen.mean = GetCifar10Mean() train_datagen.std = GetCifar10STD() test_datagen = ImageDataGenerator(rescale=1. / 255, featurewise_center=True, featurewise_std_normalization=True) test_datagen.mean = GetCifar10Mean() test_datagen.std = GetCifar10STD() train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), color_mode='rgb', batch_size=batch_size, class_mode='categorical')
def train_and_evaluate(args): # load the filenames of all room_scenes as classes for classification classes = util.load_classes(args) # load data labels df_labels = util.make_labels_df(args) df_train, df_test = train_test_split(df_labels, test_size=0.1) # create data generator train_datagen = ImageDataGenerator(featurewise_center=True, horizontal_flip=True, vertical_flip=True, rotation_range=90) test_datagen = ImageDataGenerator(featurewise_center=True) # specify imagenet mean values for centering train_datagen.mean = [123.68, 116.779, 103.939] test_datagen.mean = [123.68, 116.779, 103.939] # prepare iterators train_it = train_datagen.flow_from_dataframe(dataframe=df_train, directory=os.path.join( args.data_dir, 'images'), x_col="file_name", y_col="room_name", batch_size=args.batch_size, seed=42, shuffle=True, classes=classes, class_mode="categorical", target_size=(128, 128)) test_it = test_datagen.flow_from_dataframe(dataframe=df_test, directory=os.path.join( args.data_dir, 'images'), x_col="file_name", y_col="room_name", batch_size=args.batch_size, seed=42, shuffle=True, classes=classes, class_mode="categorical", target_size=(128, 128)) # define model print('> Define model') keras_model = model.create_model() # fit model print('> Begin training') print('> len(train_it) = {}'.format(len(train_it))) print('> len(test_it) = {}'.format(len(test_it))) history = keras_model.fit_generator(train_it, steps_per_epoch=len(train_it), validation_data=test_it, validation_steps=len(test_it), epochs=args.num_epochs, verbose=1) # evaluate model print('> Begin evaluating') loss, fbeta = keras_model.evaluate_generator(test_it, steps=len(test_it), verbose=1) print('> loss=%.3f, fbeta=%.3f' % (loss, fbeta)) # save model if not os.path.exists(args.out_dir): os.makedirs(args.out_dir) keras_model.save(os.path.join(args.out_dir, 'final_model.h5')) # learning curves util.summarize_diagnostics(history, os.path.join(args.out_dir, 'diagnostics.png'))
def generate_predictions(self, model, data): self.test_image_augmentations = {} if 'zca_whitening' in self.image_augmentations.keys(): if self.image_augmentations['zca_whitening']: self.test_image_augmentations['zca_whitening'] = True if self.img_norm == 'mean_and_std': self.test_image_augmentations['featurewise_center'] = True self.test_image_augmentations[ 'featurewise_std_normalization'] = True test_datagen = ImageDataGenerator( preprocessing_function=self.preprocess_input, **self.test_image_augmentations) if self.img_norm == 'mean_and_std': if self.greyscale: test_datagen.mean = np.array(self.img_mean_pt, dtype=np.float32) test_datagen.std = np.array(self.img_std_pt, dtype=np.float32) else: test_datagen.mean = np.array(self.img_mean_pt, dtype=np.float32).reshape( (1, 1, 3)) # ordering: [R, G, B] test_datagen.std = np.array(self.img_std_pt, dtype=np.float32).reshape( (1, 1, 3)) # ordering: [R, G, B] # Create Data Generators if self.greyscale: valid_generator = test_datagen.flow_from_dataframe( dataframe=data, directory=None, x_col=self.x_name, y_col=self.y_name, batch_size=self.batch_size, seed=self.random_state, shuffle=False, class_mode="other", target_size=(self.model_img_width, self.model_img_height), color_mode='grayscale') else: valid_generator = test_datagen.flow_from_dataframe( dataframe=data, directory=None, x_col=self.x_name, y_col=self.y_name, batch_size=self.batch_size, seed=self.random_state, shuffle=False, class_mode="other", target_size=(self.model_img_width, self.model_img_height)) # Predict if self.norm_labels: print(f"mean: {self.mean_pt} std: {self.std_pt}") return model.predict_generator( valid_generator, steps=np.ceil(len(data) / self.batch_size), verbose=1) * self.std_pt + self.mean_pt else: return model.predict_generator(valid_generator, steps=np.ceil( len(data) / self.batch_size), verbose=1)
shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest', featurewise_center=True # this is to use the mean substraction of ImageNet ) datagen_validation = ImageDataGenerator( rescale=1/255, featurewise_center=True # this is to use the mean substraction of ImageNet ) # define the ImageNet mean subtraction (in RGB order) and set the # the mean subtraction value for the data augmentation object imagenet_mean = np.array([123.68, 116.779, 103.939], dtype="float32") datagen_train.mean = imagenet_mean datagen_validation.mean = imagenet_mean train_generator = datagen_train.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical', interpolation='lanczos') validation_generator = datagen_validation.flow_from_directory( validation_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical', interpolation='lanczos')
lbl, test_size=0.25, stratify=lbl, random_state=331) trDatGen = ImageDataGenerator(rotation_range=30, width_shift_range=0.2, height_shift_range=0.2, zoom_range=0.15, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") tsDatGen = ImageDataGenerator() trDatGen.mean = imgMean tsDatGen.mean = imgMean # ........................................................................... optmz = SGD(lr=1e-4, momentum=0.9, decay=1e-4 / 25) base = ResNet50(weights="imagenet", include_top=False, input_tensor=Input(shape=(224, 224, 3))) def createModel(): h = base.output h = AveragePooling2D(pool_size=(7, 7))(h) h = Flatten(name="flatten")(h)
from tensorflow.keras.preprocessing.image import load_img, img_to_array from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.models import load_model from tensorflow.compat.v1 import ConfigProto from tensorflow.compat.v1 import InteractiveSession import pandas as pd import numpy as np config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) datagen = ImageDataGenerator(featurewise_center=True) datagen.mean = [123.68, 116.779, 103.939] batch_size = 10 iterator = datagen.flow_from_directory('test', class_mode=None, batch_size=batch_size, target_size=(224, 224), shuffle=False) model = load_model('model.h5') results = model.predict_generator(iterator, steps=1, verbose=1) results_string = list() for result in results: if result == 0.: results_string.append('cat') else: results_string.append('dog')
testPath = os.path.sep.join(['..', BASE_PATH, BASE_PATH + TEST]) # nbr total des image dans chacun des repo train test totalTrain = len(list(paths.list_images(trainPath))) totalTest = len(list(paths.list_images(testPath))) # instancier un objet ImageDataGenerator pour l'augmentation des donnees train # 1. Appliquer une augmentation des données de train, avec un flip horizontal. trainAug = ImageDataGenerator(horizontal_flip=True) # instancier un objet ImageDataGenerator pour l'augmentation des donnees test testAug = ImageDataGenerator() # 2. Les images en entrée vont être normalisées par rapport à la moyenne des plans RGB des images de ImageNet. # definir la moyenne des images ImageNet par plan RGB pour normaliser les images de la base Food-11 mean = np.array([123.68, 116.779, 103.939], dtype="float32") trainAug.mean = mean testAug.mean = mean #3. Charger un model pré-appris sur ImageNet sans la dernière couche FC. #print("[INFO] Chargement de NASNetMobile...") #baseModel = NASNetMobile(weights="imagenet", include_top=False, input_tensor=Input(shape=(224, 224, 3))) #print("[INFO] Chargement fini...") # FCmodel = NASNetMobile(weights="imagenet", include_top=True, input_tensor=Input(shape=(224, 224, 3))) #4. Faire un model.summary() avec et sans la dernière couche afin de voir la couche à #redéfinir (un globalaveragepooling, un dropout, un flatten, etc) ceci diffère d’un modèle #à l’autre. #print(baseModel.summary()) #print('############################################################################################################') #print(FCmodel.summary())
# initialize the training data augmentation object trainAug = ImageDataGenerator(rotation_range=30, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode='nearest') # validation/testing data augmentation object valAug = ImageDataGenerator() # TODO - Look into these values mean = np.array([123.68, 116.779, 103.939], dtype='float32') trainAug.mean = mean valAug.mean = mean # load the ResNet50 baseModel = ResNet50(weights='imagenet', include_top=False, input_tensor=Input(shape=(224, 224, 3))) # head of model that will go on top of baseModel headModel = baseModel.output headModel = AveragePooling2D(pool_size=(7, 7))(headModel) headModel = Flatten(name='flatten')(headModel) headModel = Dense(512, activation='relu')(headModel) headModel = Dropout(0.5)(headModel) headModel = Dense(len(lb.classes_), activation='softmax')(headModel)
test_size=0.2, shuffle=True) #%% data_generator = ImageDataGenerator(rescale=1. / 255, rotation_range=30, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") mean = np.array([123.68, 116.779, 103.939], dtype="float32") data_generator.mean = mean #%% base_model = ResNet50(weights="imagenet", include_top=False, input_tensor=Input(shape=(*IMAGE_SIZE, 3))) head_model = base_model.output head_model = AveragePooling2D(pool_size=(7, 7))(head_model) head_model = Flatten(name="flatten")(head_model) head_model = Dense(512, activation="relu")(head_model) head_model = Dropout(0.5)(head_model) head_model = Dense(len(lb.classes_), activation="softmax")(head_model) model = Model(inputs=base_model.input, outputs=head_model)
if hvd.rank() == 0: callbacks.append( ModelCheckpoint(os.path.join(CHECKPOINTS_DIR, "checkpoint-{epoch}.h5"))) # Set up ImageDataGenerators to do data augmentation for the training images. train_datagen = ImageDataGenerator( rotation_range=15, rescale=1.0 / 255, shear_range=0.1, zoom_range=0.2, horizontal_flip=True, width_shift_range=0.1, height_shift_range=0.1, ) train_datagen.mean = [123.68, 116.779, 103.939] train_generator = train_datagen.flow_from_dataframe( train_df, DATA_PATH, x_col="filename", y_col="category", target_size=IMAGE_SIZE, class_mode="binary", batch_size=BATCH_SIZE, ) if hvd.rank() == 0: mlctx.logger.info("classes:", train_generator.class_indices) validation_datagen = ImageDataGenerator(rescale=1.0 / 255)
def train_model(self, model, train_data, test_data): # If normalized labels are needed, extract it if self.norm_labels: train_data[self.y_name] = (train_data[self.y_name] - self.mean_pt) / self.std_pt test_data[self.y_name] = (test_data[self.y_name] - self.mean_pt) / self.std_pt if self.lf_setting == 'weighted_mape': self.weight = train_data[self.y_name].max() # Create Data Generators self.test_image_augmentations = {} if 'zca_whitening' in self.image_augmentations.keys(): if self.image_augmentations['zca_whitening']: self.test_image_augmentations['zca_whitening'] = True if self.img_norm == 'mean_and_std': self.image_augmentations['featurewise_center'] = True self.image_augmentations['featurewise_std_normalization'] = True self.test_image_augmentations['featurewise_center'] = True self.test_image_augmentations[ 'featurewise_std_normalization'] = True datagen = ImageDataGenerator( preprocessing_function=self.preprocess_input, **self.image_augmentations) test_datagen = ImageDataGenerator( preprocessing_function=self.preprocess_input, **self.test_image_augmentations) if self.img_norm == 'mean_and_std': if self.greyscale: datagen.mean = np.array(self.img_mean_pt, dtype=np.float32) datagen.std = np.array(self.img_std_pt, dtype=np.float32) test_datagen.mean = np.array(self.img_mean_pt, dtype=np.float32) test_datagen.std = np.array(self.img_std_pt, dtype=np.float32) else: datagen.mean = np.array(self.img_mean_pt, dtype=np.float32).reshape( (1, 1, 3)) # ordering: [R, G, B] datagen.std = np.array(self.img_std_pt, dtype=np.float32).reshape( (1, 1, 3)) # ordering: [R, G, B] test_datagen.mean = np.array(self.img_mean_pt, dtype=np.float32).reshape( (1, 1, 3)) # ordering: [R, G, B] test_datagen.std = np.array(self.img_std_pt, dtype=np.float32).reshape( (1, 1, 3)) # ordering: [R, G, B] # Set-up callback callbacks_list = [ ModelCheckpoint(self.model_pth, verbose=1, period=5), ModelCheckpoint(self.model_best_pth, verbose=1, save_best_only=True), CSVLogger(os.path.join(self.output_pth, 'hist.csv')) ] # Create Data Generators if self.greyscale: train_generator = datagen.flow_from_dataframe( dataframe=train_data, directory=None, x_col=self.x_name, y_col=self.y_name, batch_size=self.batch_size, seed=self.random_state, shuffle=True, class_mode="raw", target_size=(self.model_img_width, self.model_img_height), color_mode='grayscale') valid_generator = test_datagen.flow_from_dataframe( dataframe=test_data, directory=None, x_col=self.x_name, y_col=self.y_name, batch_size=self.batch_size, seed=self.random_state, shuffle=False, class_mode="raw", target_size=(self.model_img_width, self.model_img_height), color_mode='grayscale') else: train_generator = datagen.flow_from_dataframe( dataframe=train_data, directory=None, x_col=self.x_name, y_col=self.y_name, batch_size=self.batch_size, seed=self.random_state, shuffle=True, class_mode="raw", target_size=(self.model_img_width, self.model_img_height)) valid_generator = test_datagen.flow_from_dataframe( dataframe=test_data, directory=None, x_col=self.x_name, y_col=self.y_name, batch_size=self.batch_size, seed=self.random_state, shuffle=False, class_mode="raw", target_size=(self.model_img_width, self.model_img_height)) H = model.fit_generator( generator=train_generator, steps_per_epoch=len(train_data) // self.batch_size, validation_data=valid_generator, validation_steps=len(test_data) // self.batch_size, epochs=self.epochs, verbose=1, callbacks=callbacks_list, workers=12) return H, model