def run_test_harness():
# load dataset
trainX, trainY, testX, testY = load_dataset()
# 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(trainX, trainY, batch_size=128)
test_it = test_datagen.flow(testX, testY, batch_size=128)
# define model
model = define_model()
# fit model
history = model.fit_generator(train_it,
steps_per_epoch=len(train_it),
validation_data=test_it,
validation_steps=len(test_it),
epochs=50,
verbose=0)
# evaluate model
loss, fbeta = model.evaluate_generator(test_it,
steps=len(test_it),
verbose=0)
print('> loss=%.3f, fbeta=%.3f' % (loss, fbeta))
# learning curves
summarize_diagnostics(history)
def create_generators(conf, _Xtrain, _ytrain, _Xvalid, _yvalid):
# Create Keras ImageDataGenerator
aug_datagen = ImageDataGenerator(
featurewise_center=conf['normalize'] == 'featurewise',
featurewise_std_normalization=conf['normalize'] == 'featurewise',
rotation_range=0,
width_shift_range=0.4,
height_shift_range=0.0,
horizontal_flip=True,
preprocessing_function=get_random_eraser(v_l=-1, v_h=1))
plain_datagen = ImageDataGenerator(
featurewise_center=aug_datagen.featurewise_center,
featurewise_std_normalization=aug_datagen.
featurewise_std_normalization,
)
# Set featurewise normalization mean/std
if aug_datagen.featurewise_center:
print(' normalize featurewise')
aug_datagen.mean, aug_datagen.std = np.mean(_Xtrain), np.std(_Xtrain)
plain_datagen.mean, plain_datagen.std = aug_datagen.mean, aug_datagen.std
# Create Generators
train_generator = MixupGenerator(_Xtrain,
_ytrain,
alpha=1.0,
batch_size=conf['batch_size'],
datagen=aug_datagen)()
valid_generator = plain_datagen.flow(_Xvalid,
_yvalid,
batch_size=conf['batch_size'],
shuffle=False)
return train_generator, valid_generator, plain_datagen
def DataGenerator(train_batch, val_batch, IMG_SIZE):
datagen = ImageDataGenerator(preprocessing_function=preprocess_input,
rescale=1.0/255.0,
rotation_range=10,
horizontal_flip=True,
vertical_flip=False)
datagen.mean=np.array([103.939, 116.779, 123.68],dtype=np.float32).reshape(1,1,3)
train_gen = datagen.flow_from_directory('E:\cov\covtrain',
target_size=(IMG_SIZE, IMG_SIZE),
color_mode='rgb',
class_mode='categorical',
batch_size=train_batch)
val_gen = datagen.flow_from_directory('E:\cov\covval',
target_size=(IMG_SIZE, IMG_SIZE),
color_mode='rgb',
class_mode='categorical',
batch_size=val_batch)
datagen = ImageDataGenerator(preprocessing_function=preprocess_input,
rescale=1.0/255.0)
datagen.mean=np.array([103.939, 116.779, 123.68],dtype=np.float32).reshape(1,1,3)
test_gen = datagen.flow_from_directory('E:\cov\covtest',
target_size=(IMG_SIZE, IMG_SIZE),
color_mode='rgb',
batch_size=1,
class_mode='categorical',
shuffle=False)
return train_gen, val_gen, test_gen
def create_image_gen(HEIGHT, WIDTH, CHANNEL):
# derive the paths to the training, validation, and testing directories
trainImagePath = os.path.sep.join([BASE_PATH, BASE_IMAGE_TYPE, TRAIN])
validImagePath = os.path.sep.join([BASE_PATH, BASE_IMAGE_TYPE, VAL])
testImagePath = os.path.sep.join([BASE_PATH, BASE_IMAGE_TYPE, TEST])
# determine the total number of image paths in training, validation and testing directories
totalTrain = len(list(paths.list_images(trainImagePath)))
totalVal = len(list(paths.list_images(validImagePath)))
totalTest = len(list(paths.list_images(testImagePath)))
# initialize the training data augmentation object
trainImageAug = 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")
# initialize the validation/testing data augmentation object (which we'll be adding mean subtraction to)
valImageAug = ImageDataGenerator()
# define the ImageNet mean subtraction (in RGB order) and set the
# the mean subtraction value for each of the data augmentation
# objects
mean = np.array([123.68, 116.779, 103.939], dtype="float32")
trainImageAug.mean = mean
valImageAug.mean = mean
TARGET_SIZE = (HEIGHT, WIDTH)
# initialize the training generator
trainImageGen = trainImageAug.flow_from_directory(
trainImagePath,
class_mode="categorical",
target_size=TARGET_SIZE,
color_mode="rgb",
shuffle=True,
batch_size=BATCH_SIZE)
# initialize the validation generator
valImageGen = valImageAug.flow_from_directory(
validImagePath,
class_mode="categorical",
target_size=TARGET_SIZE,
color_mode="rgb",
shuffle=False,
batch_size=BATCH_SIZE)
# initialize the testing generator
testImageGen = valImageAug.flow_from_directory(
testImagePath,
class_mode="categorical",
target_size=TARGET_SIZE,
color_mode="rgb",
shuffle=False,
batch_size=BATCH_SIZE)
return (trainImageGen, valImageGen, testImageGen), (totalTrain, totalVal, totalTest)
def get_generator():
datagen_args = dict(
data_format='channels_last',
# set input mean to 0 over the dataset
featurewise_center=True,
# set each sample mean to 0
samplewise_center=False,
# divide inputs by std of dataset
featurewise_std_normalization=True,
# divide each input by its std
samplewise_std_normalization=False,
# apply ZCA whitening
zca_whitening=False,
# randomly rotate images in the range (deg 0 to 180)
rotation_range=0,
# randomly shift images horizontally
width_shift_range=0,
# randomly shift images vertically
height_shift_range=0,
# randomly flip images
horizontal_flip=False,
# randomly flip images
vertical_flip=False,
rescale=1. / 255)
image_datagen = ImageDataGenerator(**datagen_args)
image_datagen.mean = np.array([[[0.36654497, 0.35386439, 0.30782658]]])
image_datagen.std = np.array([[[0.19212837, 0.19031791, 0.18903286]]])
return image_datagen
def run_test_harness():
model = define_model()
# create data generator
datagen = ImageDataGenerator(featurewise_center=True)
# specify imagenet mean values for centering
'''
The model also expects images to be centered.
That is, to have the mean pixel values from each channel (red, green, and blue) as calculated on the ImageNet training dataset subtracted from the input.
Keras provides a function to perform this preparation for individual photos via the preprocess_input() function.
Nevertheless, we can achieve the same effect with the ImageDataGenerator by setting the “featurewise_center” argument to “True”
and manually specifying the mean pixel values to use when centering as the mean values from the ImageNet training dataset: [123.68, 116.779, 103.939]
'''
datagen.mean = [123.68, 116.779, 103.939]
# prepare iterators
train_it = datagen.flow_from_directory('dataset_dogs_vs_cats/train/',
class_mode='binary',
batch_size=64,
target_size=(224, 224))
test_it = datagen.flow_from_directory('dataset_dogs_vs_cats/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=10,
verbose=1)
_, acc = model.evaluate_generator(test_it, steps=len(test_it), verbose=1)
print('> %.3f' % (acc * 100.0))
summarize_diagnostics(history)
def predict(model, path_img):
datagen = ImageDataGenerator(
rescale=1. / 255,
featurewise_center=True,
featurewise_std_normalization=True)
img_height, img_width = 224, 224
batch_size = 40
datagen.mean = np.array([0.485, 0.456, 0.406])
datagen.std = np.array([0.229, 0.224, 0.225])
datagen_generator = datagen.flow_from_directory(
path_img,
shuffle=False,
color_mode="rgb",
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical',
subset='training') # set as training data
Y_pred = model.predict(datagen_generator)
y_pred = np.argmax(Y_pred, axis=1)
TEST_DIR = Path(path_img)
test_files = sorted(list(TEST_DIR.rglob('*.*')))
data_file = pd.DataFrame(test_files)
data_file['class'] = y_pred
return data_file
def save_bottlebeck_features():
# This base_model is trained on fish detection, we assume that the convolutional features
# will be more relevant
base_model_1 = ResNet50(include_top=False, weights='imagenet', input_shape=(3, img_width, img_height))
base_model = Model(input=base_model_1.input, output=base_model_1.layers[-2].output)
#print(base_model.summary())
datagen = ImageDataGenerator(rescale=1., featurewise_center=True) # (
datagen.mean = np.array(resnet50_data_mean, dtype=np.float32).reshape(3, 1, 1)
# generate valid first
generator = datagen.flow_from_directory(
validation_data_dir,
target_size=(img_width, img_height),
batch_size=32,
class_mode='categorical',
shuffle=False)
bottleneck_features_validation = base_model.predict_generator(generator, nb_validation_samples)
np.save(open(os.path.join(exp_dir_path, 'bottleneck_features_validation_resnet50_no_enhancement.npy'), 'w'), bottleneck_features_validation)
# generate train
generator = datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=32,
class_mode='categorical',
shuffle=False)
bottleneck_features_train = base_model.predict_generator(generator, nb_train_samples)
np.save(open(os.path.join(exp_dir_path, 'bottleneck_features_train_resnet50_no_enhancement.npy'), 'w'), bottleneck_features_train)
def get_mnist_generator(batch_size=32,
zero_mean=False,
unit_variance=False,
horizontal_flip=True,
vertical_flip=False,
rotation_range=10,
height_shift_range=0,
width_shift_range=0.25):
(X_train, Y_train), (X_val, Y_val), (X_test, Y_test) = get_mnist()
train_gen = ImageDataGenerator(featurewise_center=zero_mean,
featurewise_std_normalization=unit_variance,
width_shift_range=width_shift_range,
height_shift_range=height_shift_range,
rotation_range=rotation_range,
horizontal_flip=horizontal_flip,
vertical_flip=vertical_flip)
train_gen.fit(X_train, seed=1234)
valtest_gen = ImageDataGenerator(
featurewise_center=zero_mean,
featurewise_std_normalization=unit_variance)
valtest_gen.mean = train_gen.mean
valtest_gen.std = train_gen.std
train_gen = train_gen.flow(X_train,
Y_train,
batch_size=batch_size,
seed=999)
val_gen = valtest_gen.flow(X_val, Y_val, batch_size=batch_size, seed=888)
test_gen = valtest_gen.flow(X_test,
Y_test,
batch_size=batch_size,
seed=777)
return train_gen, val_gen, test_gen, (valtest_gen.mean, valtest_gen.std)
def run_test_harness():
# define model
model = define_model()
# create data generator
datagen = ImageDataGenerator(
featurewise_center=True) # antes: ImageDataGenerator(rescale=1.0/255.0, -> primer modelo
# width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True)
# specify imagenet mean values for centering
datagen.mean = [123.68, 116.779, 103.939]
# specify imagenet mean values for centering
# datagen.mean = [123.68, 116.779, 103.939]
# prepare iterator
train_it = datagen.flow_from_directory('dataset_pearls_others/train/',
class_mode='binary', batch_size=62, target_size=(224, 224))
test_it = datagen.flow_from_directory('dataset_pearls_others/test/',
class_mode='binary', batch_size=31, target_size=(224, 224))
## bonito
earlyStopping = EarlyStopping(monitor='val_loss', patience=10, verbose=0, mode='min')
mcp_save = ModelCheckpoint('.mdl_wts.hdf5', save_best_only=True, monitor='val_loss', mode='min')
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=7, verbose=1, epsilon=1e-4, mode='min')
# fit model
history = model.fit_generator(train_it, steps_per_epoch=len(train_it),
validation_data=test_it, validation_steps=len(test_it), epochs=2, verbose=1, callbacks = [earlyStopping, mcp_save, reduce_lr_loss])
# save model
model.save('model_09_12_pearls_others.h5')
# evaluate model
_, acc = model.evaluate_generator(test_it, steps=len(test_it), verbose=0)
print('> %.3f' % (acc * 100.0))
# learning curves
summarize_diagnostics(history)
def run_test_Transfer(model_x, f_name):
# define model
model = model_x()
# 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('Images/Train/',
class_mode='binary',
target_size=(200, 200))
test_it = datagen.flow_from_directory('Images/Test/',
class_mode='binary',
target_size=(200, 200))
# fit model
history = model.fit_generator(train_it,
steps_per_epoch=len(train_it),
validation_data=test_it,
validation_steps=len(test_it),
epochs=5,
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, f_name)
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('D:\\UDAY\\ML_API\\dataset_dogs_vs_cats\\train\\',
# class_mode='binary', batch_size=64, target_size=(224, 224))
# test_it = datagen.flow_from_directory('D:\\UDAY\\ML_API\\dataset_dogs_vs_cats\\test\\',
# class_mode='binary', batch_size=64, target_size=(224, 224))
# print(train_it)
# # 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=0)
# print('> %.3f' % (acc * 100.0))
# # learning curves
# summarize_diagnostics(history)
#final_model
train_it = datagen.flow_from_directory(
'D:\\UDAY\\ML_API\\finalize_dogs_vs_cats\\',
class_mode='binary',
batch_size=64,
target_size=(224, 224))
model.fit_generator(train_it, steps_per_epoch=20, epochs=5, verbose=1)
model.save('D:\\UDAY\\ML_API\\final_model.h5')
def extract_bottleneck_feature():
datagen = ImageDataGenerator(
rescale=1.,
featurewise_center=True,
)
datagen.mean = np.array(resnet_mean, dtype=np.float32).reshape(3, 1, 1)
train_generator = datagen.flow_from_directory(train_root,
target_size=image_size,
batch_size=24,
class_mode='binary',
shuffle=False)
validate_generator = datagen.flow_from_directory(validate_root,
target_size=image_size,
batch_size=24,
class_mode='binary',
shuffle=False)
base_model = ResNet50(include_top=False, weights='imagenet')
feature_model = Model(input=base_model.input,
output=base_model.layers[-2].output)
bottleneck_train_feature = feature_model.predict_generator(
train_generator, train_samples)
np.save(open('bottleneck_train_feature.npy', 'w'),
bottleneck_train_feature)
bottleneck_validate_feature = feature_model.predict_generator(
validate_generator, validate_samples)
np.save(open('bottleneck_validate_feature.npy', 'w'),
bottleneck_validate_feature)
def run_test_harness_vgg16(model):
datagen = ImageDataGenerator(featurewise_center= True)
datagen.mean = [123.68, 116.779, 103.939]
print('\nInitializing Training Data Generator\n')
train_data_gen = datagen.flow_from_directory('train',
class_mode= 'binary',
batch_size= 64,
target_size= (224,224))
print('\nInitializing Testing Data Generator\n')
test_data_gen = datagen.flow_from_directory('test',
class_mode= 'binary',
batch_size= 64,
target_size= (224,224))
print('\nModel Fitting\n')
history = model.fit_generator(train_data_gen,
steps_per_epoch= len(train_data_gen),
validation_data = test_data_gen,
validation_steps= len(test_data_gen),
epochs= 10
)
print('\nEvaluating Model\n')
_, acc = model.evaluate_generator(test_data_gen,
steps= len(test_data_gen)
)
print('>%.3f'%(acc*100))
return history
def run_test_harness(epochs, fit_generator_verbose, evaluate_generator_verbose):
# define model
#fit_generator_verbose = 1
#evaluate_generator_verbose = 1
#model = define_model_vgg16_transfer()
model = transfer_learn_mbv1()
datagen = ImageDataGenerator(featurewise_center=True)
# specify imagenet mean values for centering
datagen.mean = [123.68, 116.779, 103.939]
batch_size = 64 # - original
#batch_size = 128
train_it = datagen.flow_from_directory(processed_dataset_home + 'train/',
class_mode='binary', batch_size=batch_size, target_size=(224, 224))
test_it = datagen.flow_from_directory(processed_dataset_home + 'test/',
class_mode='binary', batch_size=batch_size, target_size=(224, 224))
# original epochs = 1
history = model.fit_generator(train_it, steps_per_epoch=len(train_it),
validation_data=test_it, validation_steps=len(test_it), epochs=epochs, verbose=fit_generator_verbose) # epochs=10
#model.save(f"final_model.h5") # not yet, I guess
# evaluate model
_, acc = model.evaluate_generator(test_it, steps=len(test_it), verbose=evaluate_generator_verbose)
print('> %.3f' % (acc * 100.0))
# learning curves
summarize_diagnostics(history)
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_dogs_vs_cats/train/',
class_mode='binary',
batch_size=64,
target_size=(224, 224))
test_it = datagen.flow_from_directory('dataset_dogs_vs_cats/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=10,
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)
def save_bottlebeck_features():
#datagen = ImageDataGenerator(rescale=1. / 255)
datagen = ImageDataGenerator(rescale=1., featurewise_center=True) #(rescale=1./255)
datagen.mean=np.array([103.939, 116.779, 123.68],dtype=np.float32).reshape(1,1,3)
# build the ResNet50 network
model = applications.ResNet50(include_top=False, pooling = 'avg', weights='imagenet')
#model = applications.(include_top=False, weights='imagenet')
generator = datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode=None,
shuffle=False)
bottleneck_features_train = model.predict_generator(
generator, nb_train_samples // batch_size)
np.save(open('bottleneck_features_train.npy', 'wb'),
bottleneck_features_train)
generator = datagen.flow_from_directory(
validation_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode=None,
shuffle=False)
bottleneck_features_validation = model.predict_generator(
generator, nb_validation_samples // batch_size)
np.save(open('bottleneck_features_validation.npy', 'wb'),
bottleneck_features_validation)
#model.summary()
plot_model(model, show_shapes = True,to_file='Model_ResNet_notop.png')
def trainCNNAug():
model = buildModel()
json_string = model.to_json()
f = open('model2.json', 'w')
f.write(json_string)
f.close()
trainX = np.load('data\\trainX.npy')
trainY = np.load('data\\trainY.npy')
validX = np.load('data\\validX.npy')
validY = np.load('data\\validY.npy')
mu = np.mean(trainX, axis=0)
np.save('mu.npy', mu)
validX -= mu
print('loaded')
datagen = ImageDataGenerator(horizontal_flip=True, featurewise_center=True)
datagen.mean = mu
ckpoint = ModelCheckpoint('model2.{epoch:02d}.hdf5',
monitor='val_acc',
save_best_only=True,
verbose=1)
history = model.fit_generator(datagen.flow(trainX, trainY, batch_size=128),
samples_per_epoch=len(trainX),
nb_epoch=300,
validation_data=(validX, validY),
callbacks=[ckpoint])
np.save('acc2.npy', np.array(history.history['acc']))
np.save('val_acc2.npy', np.array(history.history['val_acc']))
def db_test_predict():
from applications_train import get_img_fit_flow
center = True
model_file = "/home/gcgic/Downloads/fine_tuning_resnet50_best_lrate0.001_bsize64_epochs1000_1536810325.2233403.h5"
dataset = "/home/gcgic/Documents/Hemerson/Datasets/UCF11/UCF11_sampled_from_101_VR_Gaussian_H_RGB_sz_99_sg_33_split1_augmented_1/valid"
model = load_model(model_file)
if center:
flow_dir = {'directory': os.path.join(os.path.split(dataset)[0], 'training'), 'target_size': (224, 224),
'batch_size': 25, 'class_mode': 'categorical'}
data_aug = {'featurewise_center': True, 'featurewise_std_normalization': True}
_, stdev, mean = get_img_fit_flow(data_aug, 1, flow_dir)
datagen = ImageDataGenerator(featurewise_center = True,
featurewise_std_normalization = True)
datagen.mean = mean
datagen.std = stdev
tta = TTA_Model(model, 1, mean = mean, std = stdev)
else:
datagen = ImageDataGenerator(rescale=1./255)
tta = TTA_Model(model, 1)
preds_tta = tta.predict(dataset)
print("Accuracy using TTA: {}".format(preds_tta))
generator = datagen.flow_from_directory(dataset, target_size = (224, 224), color_mode='rgb', batch_size = 16, class_mode = 'categorical', shuffle=False)
model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
samples = sum([len(files) for r, d, files in os.walk(dataset)])
score = model.evaluate_generator(generator, samples // 16 + 1)
print("Metrics names: {}".format(model.metrics_names))
print("Score from evaluate: {}".format(score))
def getDataGenerator(datadir, meanstddir, batchSize, shuffle):
dataGenerator = ImageDataGenerator(featurewise_center=True,
featurewise_std_normalization=True,
horizontal_flip=True)
mean = np.load(meanstddir + '/mean.npy')
std = np.load(meanstddir + '/std.npy')
nImages = 0
classes = []
for subdir in sorted(os.listdir(datadir)):
if os.path.isdir(os.path.join(datadir, subdir)):
classes.append(subdir)
nImages += len(os.listdir(os.path.join(datadir, subdir)))
# need to swap channel
mean[0, 0, :] = mean[0, 0, ::-1]
std[0, 0, :] = mean[0, 0, ::-1]
dataGenerator.mean = mean
dataGenerator.std = std
generator = dataGenerator.flow_from_directory(
datadir,
target_size=(55, 47),
batch_size=batchSize,
shuffle=shuffle,
class_mode='sparse',
classes=classes,
seed=np.random.randint(100000))
return generator, nImages
def run_test():
model = define_model()
datagen = ImageDataGenerator(featurewise_center=True)
datagen.mean = [123.68, 116.779, 103.939]
#iterators
train_it = datagen.flow_from_directory(dir + '\\Dataset\\train\\',
class_mode='binary',
batch_size=64,
target_size=(200, 200))
test_it = datagen.flow_from_directory(dir + '\\Dataset\\test\\',
class_mode='binary',
batch_size=64,
target_size=(200, 200))
#fit model
hist = model.fit(train_it,
steps_per_epoch=len(train_it),
validation_data=test_it,
validation_steps=len(test_it),
epochs=20,
verbose=0)
#evaluate model
_, acc = model.evaluate_generator(test_it, steps=len(test_it), verbose=0)
print('> %.3f' % (acc * 100.0))
plot_learning_curves(hist)
model.save('final_model.h5')
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(
'D:\\Documents\\Academics\\semester VI\\ES 654- ML\\assi 3\\assignment-3-alianas23\\dataset\\train\\train\\',
class_mode='binary',
batch_size=2,
target_size=(224, 224))
test_it = datagen.flow_from_directory(
'D:\\Documents\\Academics\\semester VI\\ES 654- ML\\assi 3\\assignment-3-alianas23\\dataset\\train\\test\\',
class_mode='binary',
batch_size=2,
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=0)
print('> %.3f' % (acc * 100.0))
# learning curves
summarize_diagnostics(history)
def save_bottlebeck_features_no_pooling():
# Ideally we want use original VGG image prepossessing mean and no scale
datagen = ImageDataGenerator(rescale=1., featurewise_center=True) # (rescale=1./255)
datagen.mean = np.array(resnet50_data_mean, dtype=np.float32).reshape(3, 1, 1)
base_model = ResNet50(include_top=False, weights='imagenet', input_shape=(3, img_width, img_height))
base_model_1 = Model(input=base_model.input, output=base_model.layers[-2].output)
# add the model on top of the convolutional base
extract_model = Sequential()
extract_model.add(base_model_1)
generator = datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=32,
class_mode='binary',
shuffle=False)
bottleneck_features_train = extract_model.predict_generator(generator, nb_train_samples)
np.save(open(os.path.join(exp_dir_path, 'training', 'bottleneck_features_train_resnet50_no_pooling_180.npy'), 'w'), bottleneck_features_train)
generator = datagen.flow_from_directory(
validation_data_dir,
target_size=(img_width, img_height),
batch_size=32,
class_mode='binary',
shuffle=False)
bottleneck_features_validation = extract_model.predict_generator(generator, nb_validation_samples)
np.save(open(os.path.join(exp_dir_path, 'training', 'bottleneck_features_validation_resnet50_no_pooling_180.npy'), 'w'), bottleneck_features_validation)
def train_top_model():
train_data = np.load(
open(
os.path.join(
exp_dir_path,
'bottleneck_features_train_resnet50_no_enhancement_avgpool.npy'
)))
validation_data = np.load(
open(
os.path.join(
exp_dir_path,
'bottleneck_features_validation_resnet50_no_enhancement_avgpool.npy'
)))
datagen = ImageDataGenerator(rescale=1., featurewise_center=True)
datagen.mean = np.array(resnet50_data_mean,
dtype=np.float32).reshape(3, 1, 1)
generator = datagen.flow_from_directory(train_data_dir,
target_size=(img_width,
img_height),
batch_size=32,
class_mode='categorical',
shuffle=False)
train_labels = np_utils.to_categorical(generator.classes, n_out)
generator = datagen.flow_from_directory(validation_data_dir,
target_size=(img_width,
img_height),
batch_size=32,
class_mode='categorical',
shuffle=False)
validation_labels = np_utils.to_categorical(generator.classes, n_out)
model = Sequential()
model.add(Flatten(input_shape=train_data.shape[1:]))
model.add(Dense(n_out, activation='softmax'))
# model.compile(optimizer='rmsprop',
# loss='categorical_crossentropy',
# metrics=['accuracy', 'categorical_crossentropy'])
lr_list = [0.001 * 0.1**(x) for x in range(3)]
for lr in lr_list:
print('lr: %.5f' % lr)
model.compile(optimizer=optimizers.SGD(lr=lr, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy', 'categorical_crossentropy'])
model.fit(train_data,
train_labels,
nb_epoch=nb_epoch * 10,
batch_size=64,
class_weight='auto',
validation_data=(validation_data, validation_labels))
# # it's better to save the model...
model.save_weights(
os.path.join(exp_dir_path,
'bottleneck_fc_model_no_enhancement_avgpool.h5'))
return model
def image_dataGen(self,
directory,
target_size,
batch_size,
data_augmentation=False):
'''
产生batch
:param directory: 'train','validate','test'文件夹路径
:param batch_size:
:param target_size: 图像大小
:return:
'''
if data_augmentation:
# use imgaug instead
datagen = ImageDataGenerator(
rescale=1.0 / 255,
# rotation_range=10,
# width_shift_range=0.2,
# height_shift_range=0.2,
# shear_range=0.1,
# zoom_range=0.1,
# horizontal_flip=True,
fill_mode='nearest',
preprocessing_function=augment_callback,
featurewise_std_normalization=True,
featurewise_center=True)
# rescaling is before normalization
datagen.mean = np.array([0.485, 0.456, 0.406])
datagen.std = np.array([0.229, 0.224, 0.225])
else:
datagen = ImageDataGenerator(rescale=1.0 / 255,
featurewise_std_normalization=True,
featurewise_center=True)
datagen.mean = np.array([0.485, 0.456, 0.406])
datagen.std = np.array([0.229, 0.224, 0.225])
data_generator = datagen.flow_from_directory(
directory,
classes=self.
labels, # in order to mark self.labels[i] as one-hot(i), instead of a random combination
target_size=target_size,
batch_size=batch_size,
class_mode=self.label_types)
return data_generator
def get_feature(model, queries, db):
img_size = (224, 224)
test_path = DATASET_PATH + '/test/test_data'
mean = np.array([144.62598745, 132.1989693, 119.10957842],
dtype=np.float32).reshape((1, 1, 3)) / 255.0
std = np.array([5.71350834, 7.67297079, 8.68071288],
dtype=np.float32).reshape((1, 1, 3)) / 255.0
intermediate_layer_model = Model(inputs=model.layers[0].input,
outputs=model.layers[-1].output)
test_datagen = ImageDataGenerator(rescale=1. / 255,
dtype='float32',
featurewise_std_normalization=True,
featurewise_center=True)
query_generator = test_datagen.flow_from_directory(directory=test_path,
target_size=(224, 224),
classes=['query'],
color_mode="rgb",
batch_size=64,
class_mode=None,
shuffle=False)
test_datagen.mean = mean
test_datagen.std = std
query_vecs = intermediate_layer_model.predict_generator(
query_generator, steps=len(query_generator), verbose=1)
reference_generator = test_datagen.flow_from_directory(
directory=test_path,
target_size=(224, 224),
classes=['reference'],
color_mode="rgb",
batch_size=64,
class_mode=None,
shuffle=False)
test_datagen.mean = mean
test_datagen.std = std
reference_vecs = intermediate_layer_model.predict_generator(
reference_generator, steps=len(reference_generator), verbose=1)
return queries, query_vecs, db, reference_vecs
def generate_data(train_path, valid_path):
# generate & augment training data
train_datagen = ImageDataGenerator(rotation_range=30.,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_datagen.mean = np.array([123.675, 116.28, 103.53],
dtype=np.float32).reshape((3, 1, 1))
train_data = train_datagen.flow_from_directory(train_path,
target_size=img_size,
classes=None)
# generate training data
valid_datagen = ImageDataGenerator()
valid_datagen.mean = np.array([123.675, 116.28, 103.53],
dtype=np.float32).reshape((3, 1, 1))
valid_data = train_datagen.flow_from_directory(valid_path,
target_size=img_size,
classes=None)
return train_data, valid_data
def run_finalize_harness(epochs, fit_generator_verbose): #model = define_model_vgg16_transfer() model = transfer_learn_mbv1() datagen = ImageDataGenerator(featurewise_center=True) datagen.mean = [123.68, 116.779, 103.939] finalize_it = datagen.flow_from_directory(processed_dataset_home + 'finalize/', class_mode='binary', batch_size=64, target_size=(224, 224)) # epochs = 10 model.fit_generator(finalize_it, steps_per_epoch=len(finalize_it), epochs=epochs, verbose=fit_generator_verbose) model.save(f"final_model.h5") # 82 mb
def save_bottlebeck_features():
# This base_model is trained on fish detection, we assume that the convolutional features
# will be more relevant
model = get_model_resnet50_fully_connected_no_pooling()
model.load_weights(
'./exp_dir/fish_localise/training/fine_tune_all_conv_resnet50.h5')
base_model_1 = Model(input=model.input, output=model.layers[-2].output)
# build a classifier model to put on top of the convolutional model
top_model = Sequential()
top_model.add(
AveragePooling2D((7, 7), name='avg_pool', input_shape=(2048, 7, 7)))
base_model = Sequential()
base_model.add(base_model_1)
base_model.add(top_model)
base_model.add(Flatten())
print(base_model.summary())
datagen = ImageDataGenerator(rescale=1., featurewise_center=True) # (
datagen.mean = np.array(resnet50_data_mean,
dtype=np.float32).reshape(3, 1, 1)
# rescale=1./255)
# generate valid first
generator = datagen.flow_from_directory(validation_data_dir,
target_size=(img_width,
img_height),
batch_size=32,
class_mode='categorical',
shuffle=False)
bottleneck_features_validation = base_model.predict_generator(
generator, nb_validation_samples)
np.save(
open(
os.path.join(exp_dir_path,
'bottleneck_features_validation_resnet50.npy'), 'w'),
bottleneck_features_validation)
# generate train
generator = datagen.flow_from_directory(train_data_dir,
target_size=(img_width,
img_height),
batch_size=32,
class_mode='categorical',
shuffle=False)
bottleneck_features_train = base_model.predict_generator(
generator, nb_train_samples)
np.save(
open(
os.path.join(exp_dir_path,
'bottleneck_features_train_resnet50.npy'), 'w'),
bottleneck_features_train)
def generate_dataflow(self, image_size=(224, 224)):
for it in config.configured_dirs:
idg = ImageDataGenerator()
#Remove the mean operation, just using original images
idg.mean = np.array([103.939, 116.779, 123.68],
dtype=np.float32).reshape((3, 1, 1))
self.__dataflow[it] = idg.flow_from_directory(
self.get_dir_path(it),
target_size=image_size,
classes=config.configured_classes)