def format_img_inceptionresnet(file):
pic=load_img(file,target_size=(299,299))
pic_array=img_to_array(pic)
# pic_array.shape
expanded=np.expand_dims(pic_array,axis=0)
# expanded.shape
print(expanded)
return preprocess_input(expanded)
data=format_img_inceptionresnet(FILE_2)
prediction=inception_model.predict(data)
decode_predictions(prediction)
"""#Testing the VGG model"""
def format_img_VGG19(file):
pic=load_img(file,target_size=(224,224))
display(pic)
pic_array=img_to_array(pic)
# pic_array.shape
expanded=np.expand_dims(pic_array,axis=0)
# expanded.shape
return preprocess_input_vgg19(expanded)
VGG19model=VGG19('imagenet')
VGG19model.graph=tf.compat.v1.get_default_graph()
print(data.shape)
data=format_img_VGG19(FILE_3)
prediction=VGG19model.predict(data)
decode_predictions(prediction)
def vgg_norm():
img_input = Input(shape=(256, 256, 3))
x1 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv1')(img_input)
x2 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv2')(x1)
x3 = AveragePooling2D((2, 2), strides=(2, 2), name='block1_pool')(x2)
x4 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv1')(x3)
x5 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv2')(x4)
x6 = AveragePooling2D((2, 2), strides=(2, 2), name='block2_pool')(x5)
x7 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv1')(x6)
x8 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv2')(x7)
x9 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv3')(x8)
x10 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv4')(x9)
x11 = AveragePooling2D((2, 2), strides=(2, 2), name='block3_pool')(x10)
x12 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv1')(x11)
x13 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv2')(x12)
x14 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv3')(x13)
x15 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv4')(x14)
x16 = AveragePooling2D((2, 2), strides=(2, 2), name='block4_pool')(x15)
x17 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv1')(x16)
x18 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv2')(x17)
x19 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv3')(x18)
x20 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv4')(x19)
x21 = AveragePooling2D((2, 2), strides=(2, 2), name='block5_pool')(x20)
model = Model(
inputs=[img_input],
outputs=[x1, x2, x4, x5, x7, x8, x9, x10, x12, x13, x14, x15])
model_orig = VGG19(weights='imagenet',
input_shape=(256, 256, 3),
include_top=False)
for i in range(len(model.layers)):
weights = model_orig.layers[i].get_weights()
model.layers[i].set_weights(weights)
return model
if args.resume:
print('resume from checkpoint')
model = keras.models.load_model(save_file)
else:
print('train from start')
model = models.Sequential()
if '16' in args_model:
base_model = VGG16(weights=None,
include_top=False,
input_shape=(32, 32, 3),
pooling=None)
elif '19' in args_model:
base_model = VGG19(weights=None,
include_top=False,
input_shape=(32, 32, 3),
pooling=None)
#base_model.summary()
#pdb.set_trace()
model.add(base_model)
model.add(layers.Flatten())
model.add(layers.BatchNormalization())
model.add(layers.Dense(
128, activation='relu')) #, kernel_initializer='he_uniform'))
#model.add(layers.Dropout(0.2))
model.add(layers.BatchNormalization())
model.add(layers.Dense(
64, activation='relu')) #, kernel_initializer='he_uniform'))
len(IMAGE_TYPES) * len(IMAGE_IDX))[[0, 5, 10]]
print(avg_original_pred)
if __name__ == "__main__":
trials = []
if len(sys.argv) < 2 or '-s' not in sys.argv:
K.set_learning_phase(0)
if MODEL == 'VGG19':
model = VGG19(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000)
elif MODEL == 'Xception':
model = Xception(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000)
else:
print('Error unrecognised model!')
exit(-1)
# for network_file_path in glob.iglob('test_networks/' + FILENAME_PATTERN + '*.h5'):
network_file_path = 'test_networks/imagenet.pdf'
def transferLearning(image_dir, imgs_rows, imgs_cols, batch_size, epochs,
modelT):
channel = 3
classes = next(os.walk(image_dir + '/entrenamiento'))[1]
if modelT == 'vgg16':
datagen = ImageDataGenerator(preprocessing_function=preprocess_input16)
datagen_test = ImageDataGenerator(
preprocessing_function=preprocess_input16)
else:
datagen = ImageDataGenerator(preprocessing_function=preprocess_input19)
datagen_test = ImageDataGenerator(
preprocessing_function=preprocess_input19)
train_generator = datagen.flow_from_directory(
image_dir + '/entrenamiento', #train
target_size=(imgs_cols, imgs_rows),
batch_size=batch_size,
class_mode='categorical',
shuffle=False)
test_generator = datagen_test.flow_from_directory(
image_dir + '/validacion',
target_size=(imgs_cols, imgs_rows),
batch_size=batch_size,
class_mode='categorical',
shuffle=False)
# Load our model
if modelT == 'vgg16':
model = VGG16(include_top=False, weights='imagenet', pooling='max')
else:
model = VGG19(weights='imagenet', include_top=False, pooling='max')
for layer in model.layers[:15]: #15
layer.trainable = False
features = model.predict_generator(train_generator, steps=10)
train_labels = np_utils.to_categorical(train_generator.classes,
len(classes))
test_features = model.predict_generator(test_generator, steps=10)
test_labels = np_utils.to_categorical(test_generator.classes, len(classes))
# Creamos un nuevo modelo, de forma que entrenemos sólo la última capa
new_model = Sequential()
#new_model.add(Flatten()) # O bien no se usa Flatten y se usa el arguemnto 'pooling = 'max'' al llamar a VGG o bien no se usa y se usa Flatten aquí
new_model.add(
Dense(512, activation='relu', input_shape=features.shape[1:])
) # Si se usa Flatten hay que quitar el argumento input_shape aquí
new_model.add(Dense(len(classes), activation='softmax'))
opt = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
new_model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
new_model.fit(features, train_labels, epochs=epochs, batch_size=batch_size)
# Make predictions
predictions = new_model.predict(test_features,
batch_size=batch_size,
verbose=1)
# Calculate accuracy
test_labels = np.argmax(test_labels, axis=1)
predictions = np.argmax(predictions, axis=1)
acc = sum(test_labels == predictions) / len(test_labels)
return acc
import time
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(42)
os.chdir("/Users/ashutosh/Documents/analytics/DeepLearning/VGG19")
from keras.applications.vgg19 import VGG19
from keras.applications.vgg19 import preprocess_input, decode_predictions
from keras.preprocessing import image
from keras.models import Model
import cv2
# load pre-trained model
model = VGG19(weights='imagenet', include_top=True)
# display model layers
model.summary()
# display the image
img_disp = plt.imread('./peacock.jpg')
#img_disp = cv2.cvtColor(img_disp, cv2.COLOR_BGR2RGB)
plt.imshow(img_disp)
plt.axis("off")
plt.show()
# pre-process the image
img = image.load_img('./peacock.jpg', target_size=(224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
import os
import nltk
import scipy
import json
import cPickle
from sklearn.feature_extraction.text import CountVectorizer
from nltk.tokenize import TreebankWordTokenizer
import pdb
from keras.applications.vgg19 import VGG19
from keras.preprocessing import image
from keras.applications.vgg19 import preprocess_input
from keras.models import Model
import numpy as np
base_model = VGG19(weights='imagenet')
model = Model(input=base_model.input,
output=base_model.get_layer('block5_conv4').output)
TRAIN_SIZE = 16
TEST_SIZE = 2
annotation_path = '/local/wangxin/Data/Flickr8k_Dataset/Flickr8k_text/Flickr8k.token.txt'
flickr_image_path = '/local/wangxin/Data/Flickr8k_Dataset/Flicker8k_Dataset'
feat_path = 'feat/flickr8k'
def my_tokenizer(s):
return s.split()
def generate_base_model(model_name, lam, dropout_rate, import_weights):
if model_name in ['VGG16', 'VGG19']:
if model_name == 'VGG16':
from keras.applications.vgg16 import VGG16
base_model = VGG16(include_top=False,
weights=import_weights,
input_shape=(224, 224, 3))
elif model_name == 'VGG19':
from keras.applications.vgg19 import VGG19
base_model = VGG19(include_top=False,
weights=import_weights,
input_shape=(224, 224, 3))
x = base_model.output
x = Flatten()(x)
x = Dense(4096,
activation='relu',
kernel_regularizer=regularizers.l2(lam))(x)
x = Dropout(dropout_rate)(x)
x = Dense(4096,
activation='relu',
kernel_regularizer=regularizers.l2(lam))(x)
x = Dropout(dropout_rate)(x)
elif model_name in ['MobileNet', 'MobileNetV2']:
if model_name == 'MobileNet':
from keras.applications.mobilenet import MobileNet
base_model = MobileNet(include_top=False,
weights=import_weights,
input_shape=(224, 224, 3))
elif model_name == 'MobileNetV2':
from keras.applications.mobilenet_v2 import MobileNetV2
base_model = MobileNetV2(include_top=False,
weights=import_weights,
input_shape=(224, 224, 3))
x = base_model.output
x = GlobalAveragePooling2D()(x)
elif model_name in ['DenseNet121', 'DenseNet169', 'DenseNet201']:
if model_name == 'DenseNet121':
from keras.applications.densenet import DenseNet121
base_model = DenseNet121(include_top=True,
weights=import_weights,
input_shape=(224, 224, 3))
elif model_name == 'DenseNet169':
from keras.applications.densenet import DenseNet169
base_model = DenseNet169(include_top=True,
weights=import_weights,
input_shape=(224, 224, 3))
elif model_name == 'DenseNet201':
from keras.applications.densenet import DenseNet201
base_model = DenseNet201(include_top=True,
weights=import_weights,
input_shape=(224, 224, 3))
base_model = Model(base_model.inputs, base_model.layers[-2].output)
x = base_model.output
elif model_name in ['NASNetMobile', 'NASNetLarge']:
if model_name == 'NASNetMobile':
from keras.applications.nasnet import NASNetMobile
base_model = NASNetMobile(include_top=True,
weights=import_weights,
input_shape=(224, 224, 3))
elif model_name == 'NASNetLarge':
from keras.applications.nasnet import NASNetLarge
base_model = NASNetLarge(include_top=True,
weights=import_weights,
input_shape=(331, 331, 3))
base_model = Model(base_model.inputs, base_model.layers[-2].output)
x = base_model.output
elif model_name == 'Xception':
from keras.applications.xception import Xception
base_model = Xception(include_top=False,
weights=import_weights,
input_shape=(299, 299, 3))
x = base_model.output
x = GlobalAveragePooling2D()(x)
elif model_name == 'InceptionV3':
from keras.applications.inception_v3 import InceptionV3
base_model = InceptionV3(include_top=False,
weights=import_weights,
input_shape=(299, 299, 3))
x = base_model.output
x = GlobalAveragePooling2D()(x)
elif model_name == 'InceptionResNetV2':
from keras.applications.inception_resnet_v2 import InceptionResNetV2
base_model = InceptionResNetV2(include_top=False,
weights=import_weights,
input_shape=(299, 299, 3))
x = base_model.output
x = GlobalAveragePooling2D()(x)
return x, base_model.input
exp = args.exp # name of the experiment
bbox = args.bbox # whether use the heatmap loss
per = args.per # use percentage of the training data
year = args.year # the year of the coco dataset, can be 2017 or 2014
batch_size = 16
target_size = (224, 224)
COI = ['cat']
epochs = 20
r_blk = 1 # number of blocks to learn
model_name = "vgg19" # only support vgg19 and resnet50
if model_name == "vgg19":
blk_layers = [4,3,5,5,6] # number of layers at each block
base_model = VGG19(weights="imagenet", input_shape=target_size + (3,), include_top=False,pooling="avg")
last_conv = "block5_pool" # for vgg19
if model_name == "resnet50"::
blk_layers = [5, 12, 10, 10, 12, 10, 10, 10, 12, 10, 10, 10, 10, 10, 12, 10, 12] # number of layers at each block
base_model = ResNet50(weights="imagenet", input_shape=target_size + (3,), include_top=False,pooling="avg")
last_conv = "activation_49" # for resnet50
num_classes = 1
conv_features = base_model.get_layer(name=last_conv).output # get the output of last conv, shape (batch_size, 7, 7, 2048)
x = base_model.output # the results after global avg, shape(batch_size, 2048)
# x = keras.layers.Dense(512, activation='relu')(x)
# x = keras.layers.Dense(256, activation='relu')(x)
fc_layer = FC_layer(num_classes, name="last_fc") # custom fully connected layer, it is shared between "x" and "conv_feature"
x = fc_layer(x)
labels = layers.Activation("sigmoid", name="label")(x)
def train(args, arch):
"""Use transfer learning and fine-tuning to train a network on a new dataset"""
nb_train_samples = get_nb_files(args.train_dir)
nb_classes = len(glob.glob(args.train_dir + "/*"))
#nb_val_samples = get_nb_files(args.val_dir)
nb_epoch = int(args.nb_epoch)
#batch_size = int(args.batch_size)
if arch == 'vgg19':
from keras.applications.vgg19 import VGG19
# setup model
base_model = VGG19(
weights='imagenet',
include_top=False) #include_top=False excludes final FC layer
model = add_new_last_layer(base_model, nb_classes)
filepath = "_{acc:.4f}_{loss:.4f}_{epoch:02d}_"
checkpoint = ModelCheckpoint("D:/CODE/New folder/{}vgg19.model".format(
filepath,
monitor=['acc', 'loss'],
verbose=1,
save_best_only=True,
mode='max'))
elif arch == 'vgg16':
from keras.applications.vgg16 import VGG16
# setup model
base_model = VGG16(
weights='imagenet',
include_top=False) #include_top=False excludes final FC layer
model = add_new_last_layer(base_model, nb_classes)
filepath = "_{acc:.4f}_{loss:.4f}_{epoch:02d}_"
checkpoint = ModelCheckpoint("D:/CODE/New folder/{}vgg16.model".format(
filepath,
monitor=['acc', 'loss'],
verbose=1,
save_best_only=True,
mode='max'))
elif arch == 'xception':
from keras.applications.xception import Xception
# setup model
base_model = Xception(
weights='imagenet',
include_top=False) #include_top=False excludes final FC layer
model = add_new_last_layer(base_model, nb_classes)
filepath = "_{acc:.4f}_{loss:.4f}_{epoch:02d}_"
checkpoint = ModelCheckpoint(
"D:/CODE/New folder/{}xception.model".format(
filepath,
monitor=['acc', 'loss'],
verbose=1,
save_best_only=True,
mode='max'))
elif arch == 'res50':
from keras.applications.resnet50 import ResNet50
# setup model
base_model = ResNet50(
weights='imagenet',
include_top=False) #include_top=False excludes final FC layer
model = add_new_last_layer(base_model, nb_classes)
filepath = "_{acc:.4f}_{loss:.4f}_{epoch:02d}_"
checkpoint = ModelCheckpoint("D:/CODE/New folder/{}res50.model".format(
filepath,
monitor=['acc', 'loss'],
verbose=1,
save_best_only=True,
mode='max'))
elif arch == 'inv3':
from keras.applications.inception_v3 import InceptionV3
# setup model
base_model = InceptionV3(
weights='imagenet',
include_top=False) #include_top=False excludes final FC layer
model = add_new_last_layer(base_model, nb_classes)
filepath = "_{acc:.4f}_{loss:.4f}_{epoch:02d}_"
checkpoint = ModelCheckpoint("models/{}inv3.model".format(
filepath,
monitor=['acc', 'loss'],
verbose=1,
save_best_only=True,
mode='max'))
# elif arch == 'dense201':
# from keras.applications.densenet import DenseNet201
# # setup model
# base_model = DenseNet201(weights='imagenet', include_top=False) #include_top=False excludes final FC layer
# model = add_new_last_layer(base_model, nb_classes)
#
# filepath = "{acc:.4f}_{loss:.4f}_{epoch:02d}"
# checkpoint = ModelCheckpoint("D:/CODE/New folder/{}dense.model".format(filepath, monitor=['acc', 'loss'], verbose=1, save_best_only=True, mode='max'))
# data prep
train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,
rotation_range=40,
width_shift_range=0.3,
height_shift_range=0.3,
shear_range=0.3,
zoom_range=0.3,
horizontal_flip=True)
# test_datagen = ImageDataGenerator(
# preprocessing_function=preprocess_input,
# rotation_range=45,
# width_shift_range=0.4,
# height_shift_range=0.4,
# shear_range=0.4,
# zoom_range=0.4,
# horizontal_flip=True
# )
train_generator = train_datagen.flow_from_directory(
args.train_dir,
target_size=(IM_WIDTH, IM_HEIGHT),
batch_size=BAT_SIZE,
)
# validation_generator = test_datagen.flow_from_directory(
# args.val_dir,
# target_size=(IM_WIDTH, IM_HEIGHT),
# batch_size=batch_size,
# )
# transfer learning
setup_to_transfer_learn(model, base_model)
history_tl = model.fit_generator(
train_generator,
nb_epoch=nb_epoch,
samples_per_epoch=nb_train_samples,
#validation_data=validation_generator,
#nb_val_samples=nb_val_samples,
callbacks=[checkpoint],
class_weight='auto')
# fine-tuning
setup_to_finetune(model)
history_ft = model.fit_generator(
train_generator,
samples_per_epoch=nb_train_samples,
nb_epoch=nb_epoch,
#validation_data=validation_generator,
#nb_val_samples=nb_val_samples,
callbacks=[checkpoint],
class_weight='auto')
model.save(args.output_model_file)
if args.plot:
plot_training(history_ft)
from_vgg['conv3_4'] = 'block3_conv4'
from_vgg['conv4_1'] = 'block4_conv1'
from_vgg['conv4_2'] = 'block4_conv2'
# load previous weights or vgg19 if this is the first run
last_epoch, wfile = get_last_epoch_and_weights_file()
if wfile is not None:
print("Loading %s ..." % wfile)
model.load_weights(wfile)
last_epoch = last_epoch + 1
else:
print("Loading vgg19 weights...")
vgg_model = VGG19(include_top=False, weights='imagenet')
for layer in model.layers:
if layer.name in from_vgg:
vgg_layer_name = from_vgg[layer.name]
layer.set_weights(
vgg_model.get_layer(vgg_layer_name).get_weights())
print("Loaded VGG19 layer: " + vgg_layer_name)
last_epoch = 0
# setup lr multipliers for conv layers
lr_mult = dict()
for layer in model.layers:
if isinstance(layer, Conv2D):
def get_model():
# input = Input(shape=(256,256,3),name = 'image_input')
model_vgg19_conv = VGG19(weights='imagenet', include_top=False, input_shape=(256,256,3))
# output_vgg19_conv = model_vgg19_conv(input)
# concat = Input(shape=(256,256,3), name = 'concat')
# conv2_3_16_zeropadding = ZeroPadding2D(padding=(1,1), name= "conv2_3_16_zeropadding", data_format="channels_last")(model_vgg19_conv.layers[-17].output)
# conv3_3_16_zeropadding = ZeroPadding2D(padding=(1,1), name= "conv3_3_16_zeropadding", data_format="channels_last")(model_vgg19_conv.layers[-12].output)
# conv4_3_16_zeropadding = ZeroPadding2D(padding=(1,1), name= "conv4_3_16_zeropadding", data_format="channels_last")(model_vgg19_conv.layers[-7].output)
# conv5_3_16_zeropadding = ZeroPadding2D(padding=(1,1), name= "conv5_3_16_zeropadding", data_format="channels_last")(model_vgg19_conv.layers[-2].output)
# conv2_3_16 = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), dilation_rate=(1,1), activation='linear', name= "conv2_3_16", data_format="channels_last")(conv2_3_16_zeropadding)
# conv3_3_16 = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), dilation_rate=(1,1), activation='linear', name= "conv3_3_16", data_format="channels_last")(conv3_3_16_zeropadding)
# conv4_3_16 = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), dilation_rate=(1,1), activation='linear', name= "conv4_3_16", data_format="channels_last")(conv4_3_16_zeropadding)
# conv5_3_16 = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), dilation_rate=(1,1), activation='linear', name= "conv5_3_16", data_format="channels_last")(conv5_3_16_zeropadding)
conv2_3_16 = Conv2D(filters=16, kernel_size=(3, 3), padding = "same", activation='linear', name= "conv2_3_16", data_format="channels_last")(model_vgg19_conv.layers[-17].output)
conv3_3_16 = Conv2D(filters=16, kernel_size=(3, 3), padding = "same", activation='linear', name= "conv3_3_16", data_format="channels_last")(model_vgg19_conv.layers[-12].output)
conv4_3_16 = Conv2D(filters=16, kernel_size=(3, 3), padding = "same", activation='linear', name= "conv4_3_16", data_format="channels_last")(model_vgg19_conv.layers[-7].output)
conv5_3_16 = Conv2D(filters=16, kernel_size=(3, 3), padding = "same", activation='linear', name= "conv5_3_16", data_format="channels_last")(model_vgg19_conv.layers[-2].output)
# upsample2_zeropadding = ZeroPadding2D(padding=(1,1), name= "upsample2_zeropadding", data_format="channels_last")(conv2_3_16)
# new_score_weighting = Conv2D(filters=1, kernel_size=(1, 1), strides=(1, 1), dilation_rate=(1,1), activation='linear', name= "new_score_weighting", data_format="channels_last")(concat)
# upsample2_ = Conv2DTranspose(filters=16, kernel_size=(4, 4), strides=(2, 2), activation='linear', name= "upsample2_", data_format="channels_last"dat)(upsample2_zeropadding)
upsample2_ = Conv2DTranspose(filters=16, kernel_size=(4, 4), strides=(2, 2), padding = "same", activation='linear', name= "upsample2_", data_format="channels_last")(conv2_3_16)
upsample4_ = Conv2DTranspose(filters=16, kernel_size=(8, 8), strides=(4, 4), padding = "same", activation='linear', name= "upsample4_", data_format="channels_last")(conv3_3_16)
upsample8_ = Conv2DTranspose(filters=16, kernel_size=(16, 16), strides=(8, 8), padding = "same", activation='linear', name= "upsample8_", data_format="channels_last")(conv4_3_16)
upsample16_ = Conv2DTranspose(filters=16, kernel_size=(32, 32), strides=(16, 16), padding = "same", activation='linear', name= "upsample16_", data_format="channels_last")(conv5_3_16)
#sigmoid_fuse = Activation(activation="sigmoid")(new_score_weighting)
concat_upscore = concatenate([upsample2_, upsample4_, upsample8_, upsample16_], axis=-1)
# upscore_fuse = Activation(activation="sigmoid")(concat_upscore)
new_score_weighting = Conv2D(filters=1, kernel_size=(1,1), activation='sigmoid', name= "new_score_weighting", data_format="channels_last")(concat_upscore)
my_model = Model(input=model_vgg19_conv.input , output=new_score_weighting)
return my_model
def getFeatureData(fileNm, dataFold):
featData = np.load(os.path.join(dataFold, fileNm))
outVec = np.zeros((1, numConcatFeats))
outVec[0, 0:numGivenFeat] = np.mean(featData, axis=0)
outVec[0, numGivenFeat:numGivenFeat * 2] = np.max(
featData, axis=0) # this causes potential overfit. should remove
outVec[0, numGivenFeat * 2:numGivenFeat * 3] = np.min(
featData, axis=0) # this causes potential overfit. should remove
return outVec
matFiles = os.listdir(curDir)
origNet = VGG19(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None)
#net2 = Model(input=origNet.input,output=origNet.get_layer('flatten').output)
net3 = Model(input=origNet.input, output=origNet.get_layer('fc2').output)
def getResNetData(curData):
curImg = curData
#curImg[curImg==-2000]=0
batch = []
#for i in range(0, curData.shape[0] - 3, 3):
for i in range(curData.shape[2]):
tmp = []
for j in range(3):
img = curImg[i]
def main():
parser = argparse.ArgumentParser(description=DESCRIPTION)
parser.add_argument('--dataset_dir',
type=str,
default=config.DEFAULT_DATASET_DIR)
parser.add_argument('--batch_size', type=int, default=20)
parser.add_argument('--inv_model_file',
type=str,
help='a saved model (.h5) file')
args = parser.parse_args()
config_keras_backend()
if not args.inv_model_file.endswith('.h5'):
sys.exit('model_file is not a .h5')
inv_model = tf.keras.models.load_model(args.inv_model_file,
compile=False,
custom_objects={'AdamW': AdamW})
inv_model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
ds_validation = get_dataset(args.dataset_dir, 'validation',
args.batch_size)
## VGG
vgg_model = VGG19(include_top=True, weights='imagenet', classes=1000)
vgg_model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# InceptionV3
inception_model = InceptionV3(include_top=True,
weights='imagenet',
classes=1000)
inception_model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
## ResNet
resnet_model = ResNet50(include_top=True, weights='imagenet', classes=1000)
resnet_model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Process batches
iteration = 0
sum1 = 0
sum2 = 0
for images, labels in tfds.as_numpy(ds_validation):
if iteration < 199:
print('continuing')
iteration += 1
continue
if iteration == 500:
exit()
labels = np.argmax(labels, axis=1)
#adv_imgs = run_attack(True, 'CarliniL2Method', inception_model, images, labels, batch_size=args.batch_size, dataset='cifar', fgsm_epsilon=0.3, cwl2_confidence=0)
#adv_imgs = run_attack(False, 'DeepFool', inception_model, images, labels, batch_size=args.batch_size, dataset='cifar', fgsm_epsilon=0.3, cwl2_confidence=0)
adv_imgs = run_attack(False,
'FastGradientMethod',
inception_model,
images,
labels,
batch_size=args.batch_size,
dataset='cifar',
fgsm_epsilon=0.3,
cwl2_confidence=0)
#adv_imgs = run_attack(False, 'ProjectedGradientDescent', inception_model, images, labels, batch_size=10, dataset='cifar', fgsm_epsilon=0.1, cwl2_confidence=0)
## VGG ################################################
#img *= (2.0/255) # normalize to: 0.0~2.0
#img -= 1.0 # subtract mean to make it: -1.0~1.0
#img = np.expand_dims(img, axis=0)
vgg_imgs = []
resnet_imgs = []
inc_imgs = []
flip_imgs = []
inv_imgs = []
adv_vgg_imgs = []
adv_resnet_imgs = []
adv_inc_imgs = []
adv_flip_imgs = []
adv_inv_imgs = []
for ii in range(images.shape[0]):
img = copy.deepcopy(images[ii, :, :, :])
img += 1.0
#img /= (2.0/255)
img *= (255.0 / 2.0)
## VGG
vgg_img = copy.deepcopy(img)
vgg_img = cv2.resize(vgg_img, (224, 224))
vgg_img = vgg_preprocess_input(vgg_img)
vgg_imgs.append(vgg_img)
## Resnet
resnet_img = copy.deepcopy(img)
resnet_img = cv2.resize(resnet_img, (224, 224))
resnet_img = resnet_preprocess_input(resnet_img)
resnet_imgs.append(resnet_img)
## InceptionV3
inc_img = copy.deepcopy(img)
inc_img = cv2.resize(inc_img, (299, 299))
inc_img = inception_preprocess_input(inc_img)
inc_imgs.append(inc_img)
## Flipped
#flip_img = copy.deepcopy(img)
#flip_img = cv2.resize(flip_img, (299, 299))
#flip_img = cv2.flip(flip_img, 1)
#flip_img = inception_preprocess_input(flip_img)
#flip_imgs.append(flip_img)
flip_img = copy.deepcopy(images[ii, :, :, :])
flip_img = cv2.flip(flip_img, 1)
flip_imgs.append(flip_img)
## Inverse
inv_img = copy.deepcopy(images[ii, :, :, :]) #########
inv_img += 1.0
inv_img /= 2.0
inv_img = 1 - inv_img
inv_img *= 255.0
inv_img = cv2.resize(inv_img, (299, 299))
inv_img = inception_preprocess_input(inv_img)
inv_imgs.append(inv_img)
#==========================================
# ADVERSARIAL ---------------
adv_img = copy.deepcopy(adv_imgs[ii, :, :, :])
adv_img += 1.0
#adv_img /= (2.0/255)
adv_img *= (255.0 / 2.0)
# VGG
adv_vgg_img = copy.deepcopy(adv_img)
adv_vgg_img = cv2.resize(adv_vgg_img, (224, 224))
adv_vgg_img = vgg_preprocess_input(adv_vgg_img)
adv_vgg_imgs.append(adv_vgg_img)
# Resnet
adv_resnet_img = copy.deepcopy(adv_img)
adv_resnet_img = cv2.resize(adv_resnet_img, (224, 224))
adv_resnet_img = resnet_preprocess_input(adv_resnet_img)
adv_resnet_imgs.append(adv_resnet_img)
# InceptionV3
adv_inc_img = copy.deepcopy(adv_img)
adv_inc_img = cv2.resize(adv_inc_img, (299, 299))
adv_inc_img = inception_preprocess_input(adv_inc_img)
adv_inc_imgs.append(adv_inc_img)
## Flipped
#adv_flip_img = copy.deepcopy(img)
#adv_flip_img = cv2.resize(adv_flip_img, (299, 299))
#adv_flip_img = cv2.flip(adv_flip_img, 1)
#adv_flip_img = inception_preprocess_input(adv_flip_img)
#adv_flip_imgs.append(adv_flip_img)
adv_flip_img = copy.deepcopy(adv_imgs[ii, :, :, :])
adv_flip_img = cv2.flip(adv_flip_img, 1)
adv_flip_imgs.append(adv_flip_img)
## Inverse
##test on inverse Inceptionv3
adv_inv_img = copy.deepcopy(adv_imgs[ii, :, :, :]) #########
adv_inv_img += 1.0
adv_inv_img /= 2.0
adv_inv_img = 1 - adv_inv_img
adv_inv_img *= 255.0
adv_inv_img = cv2.resize(adv_inv_img, (299, 299))
adv_inv_img = inception_preprocess_input(adv_inv_img)
adv_inv_imgs.append(adv_inv_img)
# Horizontal Flipping
# test on Resnet
vgg_imgs = np.asarray(vgg_imgs)
resnet_imgs = np.asarray(resnet_imgs)
inc_imgs = np.asarray(inc_imgs)
flip_imgs = np.asarray(flip_imgs)
inv_imgs = np.asarray(inv_imgs)
adv_vgg_imgs = np.asarray(adv_vgg_imgs)
adv_resnet_imgs = np.asarray(adv_resnet_imgs)
adv_inc_imgs = np.asarray(adv_inc_imgs)
adv_flip_imgs = np.asarray(adv_flip_imgs)
adv_inv_imgs = np.asarray(adv_inv_imgs)
# Default ResNet accuracy
_, results1 = resnet_model.evaluate(x=resnet_imgs, y=labels, verbose=0)
_, results2 = vgg_model.evaluate(x=vgg_imgs, y=labels, verbose=0)
_, results3 = inception_model.evaluate(x=inc_imgs, y=labels, verbose=0)
_, results4 = inception_model.evaluate(x=flip_imgs,
y=labels,
verbose=0)
_, results5 = inv_model.evaluate(x=inv_imgs, y=labels, verbose=0)
# print('-----------------------------------------------------')
_, results6 = resnet_model.evaluate(x=adv_resnet_imgs,
y=labels,
verbose=0)
_, results7 = vgg_model.evaluate(x=adv_vgg_imgs, y=labels, verbose=0)
_, results8 = inception_model.evaluate(x=adv_inc_imgs,
y=labels,
verbose=0)
_, results9 = inception_model.evaluate(x=adv_flip_imgs,
y=labels,
verbose=0)
_, results10 = inv_model.evaluate(x=adv_inv_imgs, y=labels, verbose=0)
print(iteration)
print(results1, results6)
print(results2, results7)
print(results3, results8)
print(results4, results9)
print(results5, results10)
with open("kot_fgsm_untarg.txt", "a") as myfile:
myfile.write(
str(results1) + ' ' + str(results2) + ' ' + str(results3) +
' ' + str(results4) + ' ' + str(results5) + ' ' +
str(results6) + ' ' + str(results7) + ' ' + str(results8) +
' ' + str(results9) + ' ' + str(results10) + '\n')
iteration += 1
#exit()
#results = resnet_model.evaluate(x=adv_imgs, y=to_categorical(labels, 1000))
#print('RESNET test loss, test acc:', results)
#results = vgg_model.evaluate(x=adv_imgs, y=to_categorical(labels, 1000))
#print('VGG test loss, test acc:', results)
# labels = np.argmax(labels, axis=1)
#
# #results = model.evaluate(
# # x=images, y=to_categorical(labels, 1000))
# #print('test loss, test acc:', results)
# total = total + images.shape[0]
# print(total)
exit()
results = resnet_model.evaluate(x=ds_validation,
steps=50000 // args.batch_size)
print('test loss, test acc:', results)
clear_keras_session()
def compute_perceptual_loss(x_ref, decoded_ref2ref, decoded_art2ref, patchSize,
pl_network):
if K.ndim(x_ref) == 5 and K.ndim(decoded_ref2ref) == 5 and K.ndim(
decoded_art2ref) == 5:
x_ref = reshape(x_ref, patchSize)
decoded_ref2ref = reshape(decoded_ref2ref, patchSize)
decoded_art2ref = reshape(decoded_art2ref, patchSize)
if pl_network == 'vgg19':
x_ref = concatenate([x_ref, x_ref, x_ref], axis=1)
decoded_ref2ref = concatenate(
[decoded_ref2ref, decoded_ref2ref, decoded_ref2ref], axis=1)
decoded_art2ref = concatenate(
[decoded_art2ref, decoded_art2ref, decoded_art2ref], axis=1)
x_ref = Lambda(preprocessing,
output_shape=(3, patchSize[0], patchSize[1]))(x_ref)
decoded_ref2ref = Lambda(preprocessing,
output_shape=(3, patchSize[0],
patchSize[1]))(decoded_ref2ref)
decoded_art2ref = Lambda(preprocessing,
output_shape=(3, patchSize[0],
patchSize[1]))(decoded_art2ref)
input = Input(shape=(3, patchSize[0], patchSize[1]))
model = VGG19(include_top=False,
weights='imagenet',
input_tensor=input)
else:
sys.exit("loss network is not supported.")
l1 = model.layers[1].output
l2 = model.layers[4].output
l3 = model.layers[7].output
l1_model = Model(input, l1)
l2_model = Model(input, l2)
l3_model = Model(input, l3)
f_l1_ref = l1_model(x_ref)
f_l2_ref = l2_model(x_ref)
f_l3_ref = l3_model(x_ref)
f_l1_decoded_ref = l1_model(decoded_ref2ref)
f_l2_decoded_ref = l2_model(decoded_ref2ref)
f_l3_decoded_ref = l3_model(decoded_ref2ref)
f_l1_decoded_art = l1_model(decoded_art2ref)
f_l2_decoded_art = l2_model(decoded_art2ref)
f_l3_decoded_art = l3_model(decoded_art2ref)
p1_loss_ref = Lambda(
lambda x: K.mean(K.sum(K.square(x[0] - x[1]), [1, 2, 3])),
output_shape=(None, ))([f_l1_ref, f_l1_decoded_ref])
p2_loss_ref = Lambda(
lambda x: K.mean(K.sum(K.square(x[0] - x[1]), [1, 2, 3])),
output_shape=(None, ))([f_l2_ref, f_l2_decoded_ref])
p3_loss_ref = Lambda(
lambda x: K.mean(K.sum(K.square(x[0] - x[1]), [1, 2, 3])),
output_shape=(None, ))([f_l3_ref, f_l3_decoded_ref])
p1_loss_art = Lambda(
lambda x: K.mean(K.sum(K.square(x[0] - x[1]), [1, 2, 3])),
output_shape=(None, ))([f_l1_ref, f_l1_decoded_art])
p2_loss_art = Lambda(
lambda x: K.mean(K.sum(K.square(x[0] - x[1]), [1, 2, 3])),
output_shape=(None, ))([f_l2_ref, f_l2_decoded_art])
p3_loss_art = Lambda(
lambda x: K.mean(K.sum(K.square(x[0] - x[1]), [1, 2, 3])),
output_shape=(None, ))([f_l3_ref, f_l3_decoded_art])
perceptual_loss_ref2ref = p1_loss_ref + p2_loss_ref + p3_loss_ref
perceptual_loss_art2ref = p1_loss_art + p2_loss_art + p3_loss_art
return perceptual_loss_ref2ref, perceptual_loss_art2ref
VALIDATION_STEPS = TEST_COUNT // BATCH_SIZE
WIDTH = 299
HEIGHT = 299
LEARNING_RATE = 0.0001
# Define directories
TRAIN_DIR = 'E:\Attempt 6\Original'
TEST_DIR = 'E:\Attempt 6\Test'
Attempt = "Attempt-1"
filepath_epoch = R"E:\Attempt 6/InceptionFineTuneProper-" + Attempt + "-NoBatchNormalization-" + str(
BATCH_SIZE) + "-{epoch:02d}-.model"
# Model used is vgg16 with imagenet weights by default
# Remove output layer as we are replacing it with out own
base_model = VGG19(weights='imagenet',
include_top=False,
input_shape=(HEIGHT, WIDTH, 3))
print(len(base_model.layers))
# Declare checkpoints
now = datetime.now()
date_time = now.strftime("%m-%d-%Y")
model_checkpoint = k.callbacks.callbacks.ModelCheckpoint(filepath_epoch,
monitor='val_acc',
verbose=1,
save_best_only=False,
mode='max')
csv_logger = CSVLogger('finetuning_model_history - ' + date_time + '.csv',
append=True)
member_dir = member_base_dir + '/' + member + '/'
for filename in os.listdir(member_dir):
if not re.match('.+.jpg', filename): continue
filepath = member_dir + filename
img = img_to_array(load_img(filepath, target_size=(64,64)))
X_train.append(img)
y_train.append(i)
X_train = np.asarray(X_train).astype('float32') / 255.0
y_train = to_categorical(y_train, n_category)
X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.2, random_state=1)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)
# モデルの定義: VGG19モデル
input_tensor = Input(shape=(64,64,3))
vgg19_model = VGG19(include_top=False, weights='imagenet', input_tensor=input_tensor)
top_model = Sequential()
top_model.add(Flatten(input_shape=vgg19_model.output_shape[1:]))
top_model.add(Dense(256))
top_model.add(Activation("sigmoid"))
top_model.add(Dropout(0.5))
top_model.add(Dense(128))
top_model.add(Activation('sigmoid'))
top_model.add(Dense(n_category))
top_model.add(Activation("softmax"))
model = Model(input=vgg19_model.input, output=top_model(vgg19_model.output))
for layer in model.layers[:17]:
layer.trainable = False
def feature_extraction(pre_trained_model='VGG16',
pooling_mode='avg',
classes=9,
data_augm_enabled=False):
"""ConvNet as fixed feature extractor, consist of taking the convolutional base of a previously-trained network,
running the new data through it, and training a new classifier on top of the output.
(i.e. train only the randomly initialized top layers while freezing all convolutional layers of the original model).
# Arguments
pre_trained_model: one of `VGG16`, `VGG19`, `ResNet50`, `VGG16_Places365`
pooling_mode: Optional pooling_mode mode for feature extraction
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling_mode
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling_mode will
be applied.
classes: optional number of classes to classify images into,
only to be specified if `weights` argument is `None`.
data_augm_enabled: whether to augment the samples during training
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `pre_trained_model`, `pooling_mode` or invalid input shape.
"""
if not (pre_trained_model
in {'VGG16', 'VGG19', 'ResNet50', 'VGG16_Places365'}):
raise ValueError(
'The `pre_trained_model` argument should be either '
'`VGG16`, `VGG19`, `ResNet50`, '
'or `VGG16_Places365`. Other models will be supported in future releases. '
)
if not (pooling_mode in {'avg', 'max', 'flatten'}):
raise ValueError('The `pooling_mode` argument should be either '
'`avg` (GlobalAveragePooling2D), `max` '
'(GlobalMaxPooling2D), '
'or `flatten` (Flatten).')
# Define the name of the model and its weights
weights_name = 'cost_sensitive_feature_extraction_' + pre_trained_model + '_' + pooling_mode + '_pool_weights_tf_dim_ordering_tf_kernels.h5'
augm_samples_weights_name = 'cost_sensitive_augm_feature_extraction_' + pre_trained_model + '_' + pooling_mode + '_pool_weights_tf_dim_ordering_tf_kernels.h5'
model_log = logs_dir + 'cost_sensitive_feature_extraction_' + pre_trained_model + '_' + pooling_mode + '_pool_log.csv'
csv_logger = CSVLogger(model_log, append=True, separator=',')
input_tensor = Input(shape=(224, 224, 3))
# create the base pre-trained model for warm-up
if pre_trained_model == 'VGG16':
base_model = VGG16(weights='imagenet',
include_top=False,
input_tensor=input_tensor)
elif pre_trained_model == 'VGG19':
base_model = VGG19(weights='imagenet',
include_top=False,
input_tensor=input_tensor)
elif pre_trained_model == 'ResNet50':
base_model = ResNet50(weights='imagenet',
include_top=False,
input_tensor=input_tensor)
elif pre_trained_model == 'VGG16_Places365':
base_model = VGG16_Places365(weights='places',
include_top=False,
input_tensor=input_tensor)
print('\n \n')
print('The plain `' + pre_trained_model +
'` pre-trained convnet was successfully initialised.\n')
x = base_model.output
# Now we set-up transfer learning process - freeze all but the penultimate layer
# and re-train the last Dense layer with 9 final outputs representing probabilities for HRA classes.
# Build a randomly initialised classifier model to put on top of the convolutional model
# both `avg`and `max`result in the same size of the Dense layer afterwards
# Both Flatten and GlobalAveragePooling2D are valid options. So is GlobalMaxPooling2D.
# Flatten will result in a larger Dense layer afterwards, which is more expensive
# and may result in worse overfitting. But if you have lots of data, it might also perform better.
# https://github.com/keras-team/keras/issues/8470
if pooling_mode == 'avg':
x = GlobalAveragePooling2D(name='GAP')(x)
elif pooling_mode == 'max':
x = GlobalMaxPooling2D(name='GMP')(x)
elif pooling_mode == 'flatten':
x = Flatten(name='FLATTEN')(x)
x = Dense(256, activation='relu',
name='FC1')(x) # let's add a fully-connected layer
# When random init is enabled, we want to include Dropout,
# otherwise when loading a pre-trained HRA model we want to omit
# Dropout layer so the visualisations are done properly (there is an issue if it is included)
x = Dropout(0.5, name='DROPOUT')(x)
# and a logistic layer with the number of classes defined by the `classes` argument
predictions = Dense(classes, activation='softmax',
name='PREDICTIONS')(x) # new softmax layer
# this is the transfer learning model we will train
model = Model(inputs=base_model.input, outputs=predictions)
print(
'Randomly initialised classifier was successfully added on top of the original pre-trained conv. base. \n'
)
print(
'Number of trainable weights before freezing the conv. base of the original pre-trained convnet: '
'' + str(len(model.trainable_weights)))
# first: train only the top layers (which were randomly initialized)
# i.e. freeze all convolutional layers of the preliminary base model
for layer in base_model.layers:
layer.trainable = False
print(
'Number of trainable weights after freezing the conv. base of the pre-trained convnet: '
'' + str(len(model.trainable_weights)))
print('\n')
# compile the warm_up_model (should be done *after* setting layers to non-trainable)
model.compile(optimizer=SGD(lr=0.0001, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
# # The attribute model.metrics_names will give you the display labels for the scalar outputs.
# print warm_up_model.metrics_names
if data_augm_enabled:
print(
'Using augmented samples for training. This may take a while ! \n')
t = now()
history = model.fit_generator(augmented_train_generator,
steps_per_epoch=nb_train_samples //
batch_size,
epochs=feature_extraction_epochs,
callbacks=[csv_logger],
class_weight=class_weight)
print(
'Training time for re-training the last Dense layer using augmented samples: %s'
% (now() - t))
model.save_weights(feature_extraction_dir + augm_samples_weights_name)
print('Model weights using augmented samples were saved as `' +
augm_samples_weights_name + '`')
print('\n')
else:
t = now()
history = model.fit_generator(train_generator,
steps_per_epoch=nb_train_samples //
batch_size,
epochs=feature_extraction_epochs,
callbacks=[csv_logger],
class_weight=class_weight)
print('Training time for re-training the last Dense layer: %s' %
(now() - t))
model.save_weights(feature_extraction_dir + weights_name)
print('Model weights were saved as `' + weights_name + '`')
print('\n')
return model
def init(args):
"""Init dataset and model."""
# initialize dataset
if args.estimated_3DBB is None:
dataset = BoxCarsDataset(load_split="hard", load_atlas=True)
else:
dataset = BoxCarsDataset(load_split="hard", load_atlas=True,
use_estimated_3DBB=True,
estimated_3DBB_path=args.estimated_3DBB)
# get optional path to load model
model = None
for path in [args.eval, args.resume]:
if path is not None:
print("Loading model from %s" % path)
model = load_model(path)
break
# construct the model as it was not passed as an argument
if model is None:
print("Initializing new %s model ..." % args.train_net)
if args.train_net in ("ResNet50", ):
base_model = ResNet50(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
x = Flatten()(base_model.output)
if args.train_net in ("VGG16", "VGG19"):
if args.train_net == "VGG16":
base_model = VGG16(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
elif args.train_net == "VGG19":
base_model = VGG19(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
x = Flatten()(base_model.output)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dropout(0.5)(x)
x = Dense(4096, activation='relu', name='fc2')(x)
x = Dropout(0.5)(x)
if args.train_net in ("InceptionV3", ):
base_model = InceptionV3(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
output_dim = int(base_model.outputs[0].get_shape()[1])
x = AveragePooling2D((output_dim, output_dim), strides=(
output_dim, output_dim), name='avg_pool')(base_model.output)
x = Flatten()(x)
predictions = Dense(dataset.get_number_of_classes(),
activation='softmax')(x)
model = Model(input=base_model.input,
output=predictions,
name="%s%s" % (
args.train_net,
{True: "_estimated3DBB",
False: ""}[args.estimated_3DBB is not None]))
optimizer = SGD(lr=args.lr, decay=1e-4, nesterov=True)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy', metrics=["accuracy"])
print("Model name: %s" % (model.name))
if args.estimated_3DBB is not None and "estimated3DBB" not in model.name:
print("ERROR: using estimated 3DBBs "
"with model trained on original 3DBBs")
sys.exit(1)
if args.estimated_3DBB is None and "estimated3DBB" in model.name:
print("ERROR: using model trained on estimated 3DBBs "
"and running on original 3DBBs")
sys.exit(1)
args.output_final_model_path = os.path.join(
args.cache, model.name, "final_model.h5")
args.snapshots_dir = os.path.join(args.cache, model.name, "snapshots")
args.tensorboard_dir = os.path.join(args.cache, model.name, "tensorboard")
dataset.initialize_data("test")
return model, dataset
def TrainedVGG19():
return VGG19(include_top=True, weights='imagenet', input_tensor=None)
results = config["results"]
model_path = config["model_path"]
# start time
print ("[STATUS] start time - {}".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M")))
start = time.time()
# create the pretrained models
# check for pretrained weight usage or not
# check for top layers to be included or not
if model_name == "vgg16":
base_model = VGG16(weights=weights)
model = Model(input=base_model.input, output=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "vgg19":
base_model = VGG19(weights=weights)
model = Model(input=base_model.input, output=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "resnet50":
base_model = ResNet50(weights=weights)
model = Model(input=base_model.input, output=base_model.get_layer('flatten').output)
image_size = (224, 224)
elif model_name == "inception_v3":
base_model = InceptionV3(include_top=include_top, weights=weights, input_tensor=Input(shape=(299,299,3)))
model = Model(input=base_model.input, output=base_model.get_layer('custom').output)
image_size = (299, 299)
elif model_name == "inceptionresnetv2":
base_model = InceptionResNetV2(include_top=include_top, weights=weights, input_tensor=Input(shape=(299,299,3)))
model = Model(input=base_model.input, output=base_model.get_layer('custom').output)
image_size = (299, 299)
elif model_name == "mobilenet":
validation_dir = os.path.join(base_dir, 'validation')
# Directory with our training cat pictures
train_cats_dir = os.path.join(train_dir, 'cats')
# Directory with our training dog pictures
train_dogs_dir = os.path.join(train_dir, 'dogs')
# Directory with our validation cat pictures
validation_cats_dir = os.path.join(validation_dir, 'cats')
# Directory with our validation dog pictures
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
conv_base = VGG19(weights='imagenet',
include_top=False,
input_shape=(150, 150, 3))
conv_base.summary()
conv_base.trainable = False
model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
# no dropout
model.add(layers.Dense(1, activation='sigmoid'))
model.summary()
# data augmentation
delete_old_model=True)
# for monitoring the training curves
lh_cb = LearningHistoryCallback(prefix=prefix,
style='ggplot',
save_logs=args.save_logs,
plot_steps=args.plot_steps)
callbacks = [mc_cb, lh_cb]
# -------------------------------------------------------
# Build model based on VGG19 pretrained on ImageNet
# -------------------------------------------------------
## base model: VGG19 with weights
input_tensor = Input(shape=(IMG_HEIGHT, IMG_WIDTH, 3)) # input tensor
base_model = VGG19(weights='imagenet',
include_top=False,
input_tensor=input_tensor) # load VGG19 model
# classifier (Output layers)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(1, activation='sigmoid')(
x) # Outputs are between 0 to 1. 0 means cat, 1 means dog.
model = Model(inputs=base_model.input, outputs=predictions)
# freeze base model parameters
for layer in base_model.layers[:15]:
layer.trainable = False
# configure the model
import keras
from keras.applications.vgg19 import VGG19
from keras.applications.resnet50 import ResNet50
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.imagenet_utils import decode_predictions
from keras.metrics import top_k_categorical_accuracy
from loader import imagenetData
import os
data_dir = "/data/imagenet"
batch_size = 16
vgg = VGG19(weights='imagenet')
resnet = ResNet50(weights='imagenet')
vgg.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=[top_k_categorical_accuracy])
resnet.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=[top_k_categorical_accuracy])
data = imagenetData(img_set='train', batch_size=batch_size)
i = 0
# while i < data.num_images//batch_size:
while i < 3:
x, y = data._get_next_minibatch()
preds = resnet.predict_on_batch(x)
score = resnet.test_on_batch(x, y)
activation='relu',
padding='same',
name='block5_conv3')(x18)
x20 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv4')(x19)
x21 = AveragePooling2D((2, 2), strides=(2, 2), name='block5_pool')(x20)
model = Model(
inputs=[img_input],
outputs=[x1, x2, x4, x5, x7, x8, x9, x10, x12, x13, x14, x15])
model_orig = VGG19(weights='imagenet',
input_shape=(256, 256, 3),
include_top=False)
for i in range(len(model.layers)):
weights = model_orig.layers[i].get_weights()
model.layers[i].set_weights(weights)
return model
if __name__ == '__main__':
model = vgg_norm()
model.summary()
print("#####################################################")
model_orig = VGG19(weights='imagenet',
input_shape=(256, 256, 3),
include_top=False)
model_orig.summary()
# the data, shuffled and split between train and test sets
# (X_train, y_train), (X_test, y_test) = cifar10.load_data()
(X_train, y_train), (X_vali, y_vali) = load_data()
print('X_train shape:', X_train.shape)
print('X_vali shape:', X_vali.shape)
print(X_train.shape[0], 'train samples')
print(X_vali.shape[0], 'test samples')
# convert class vectors to binary class matrices
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_vali = np_utils.to_categorical(y_vali, nb_classes)
# create the base pre-trained model
K.set_image_dim_ordering("tf")
base_model = VGG19(weights='imagenet', include_top=False)
# add a global spatial average pooling layer
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dropout(0.5, name="drp1")(x)
# x = Flatten(name='flatten', input_shape=(img_rows, img_cols, img_channels))(x)
x = Dense(120, activation='relu', name='fc1', W_regularizer=l2(0.01))(x)
x = Dropout(0.5, name="drp2")(x)
x = Dense(120, activation='relu', name='fc2', W_regularizer=l2(0.01))(x)
predictions = Dense(nb_classes, activation='softmax', name='predictions')(x)
# x = GlobalAveragePooling2D()(x)
# let's add a fully-connected layer
# x = Dense(100, activation='relu')(x)
# and a logistic layer -- let's say we have 200 classes
# predictions = Dense(2, activation='softmax')(x)
model.fit_generator(generator,
validation_data=val_generator,
epochs=20,
verbose=1,
callbacks=[csv_logger, checkpointer])
# serialize weights to HDF5
model.save_weights(filename + "_modelweights.h5")
print("Saved model to disk")
########### VGG
K.clear_session()
# base_model = InceptionV3(weights='imagenet', include_top=False, input_tensor=Input(shape=(299, 299, 3)))
# base_model = ResNet50(weights='imagenet', include_top=False, input_tensor=Input(shape=(299, 299, 3)))
base_model = VGG19(weights='imagenet',
include_top=False,
input_tensor=Input(shape=(299, 299, 3)))
# base_model = Xception(weights='imagenet', include_top=False, input_tensor=Input(shape=(299, 299, 3)))
x = base_model.output
x = GlobalAveragePooling2D()(x)
# # x = Flatten()(x)
x = Dense(4096)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Dropout(.5)(x)
predictions = Dense(101, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
for layer in base_model.layers:
"densenet201": "https://www.flyai.com/m/v0.8|densenet201_weights_tf_dim_ordering_tf_kernels_notop.h5"
}
# 必须使用该方法下载模型，然后加载
from flyai.utils import remote_helper
path = remote_helper.get_remote_date(MODEL_URL[model_name])
for rt, dirs, files in os.walk('./'):
for f in files:
if model_name in f:
weight_path = os.path.join(rt, f)
print(weight_path)
if model_name=="vgg16":
base_model=VGG16(include_top=False, weights=weight_path, input_shape=(size, size, 3))
elif model_name=="vgg19":
base_model=VGG19(include_top=False, weights=weight_path, input_shape=(size, size, 3))
elif model_name=="xception":
base_model=Xception(include_top=False, weights=weight_path, input_shape=(size, size, 3))
elif model_name=="resnet50":
base_model=ResNet50(include_top=False, weights=weight_path, input_shape=(size, size, 3))
elif model_name=="densenet121":
base_model=DenseNet121(include_top=False, weights=weight_path, input_shape=(size, size, 3))
elif model_name=="densenet201":
base_model=DenseNet201(include_top=False, weights=weight_path, input_shape=(size, size, 3))
else:
base_model=VGG16(include_top=False, weights=weight_path, input_shape=(size, size, 3))
def get_model():
model = Sequential()
feature=base_model
model.add(feature)
By default, the model loads weights pre-trained on [ImageNet.](http://www.image-net.org/about-overview)
The default input size for this model is 224x224.
#[For more information](https://keras.io/api/applications/vgg/#vgg16-function)
"""
# re-size all the images to this
IMAGE_SIZE = [224, 224]
#put directories to the training and validation data
train_path = '/content/drive/My Drive/Study/INTRODUCTION TO DATA SCIENCE/Other/Deep-Learning-in-Medical-Science-master/chest_xray/train'
valid_path = '/content/drive/My Drive/Study/INTRODUCTION TO DATA SCIENCE/Other/Deep-Learning-in-Medical-Science-master/chest_xray/val'
# add preprocessing layer to the front of VGG
data = VGG19(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False)
# don't train existing weights
for layer in data.layers:
layer.trainable = False
# useful for getting number of classes in the given data set
folders = glob('/content/drive/My Drive/Study/INTRODUCTION TO DATA SCIENCE/Other/Deep-Learning-in-Medical-Science-master/chest_xray/train/*')
#add more layers if you want
x = Flatten()(data.output)
prediction = Dense(len(folders), activation='softmax')(x)
"""#Visualizing the model
[VGG19](https://miro.medium.com/max/2408/1*6U9FJ_se7SIuFKJRyPMHuA.png)
import cv2
import numpy as np
import tensorflow as tf
from keras.models import load_model
from keras.preprocessing import image
from keras.applications.resnet50 import ResNet50
from keras.applications.vgg19 import VGG19, preprocess_input
from model.define_model import dog_names, convert_to_label
#Loading pre-built model for prediction
breed_predictor = load_model('../model/Breed_Predictor.hdf5')
#Loading VGG19 and resnet models to extract features and detect dogs
model_VGG19_features = VGG19(weights='imagenet', include_top=False)
ResNet50_model = ResNet50(weights='imagenet')
#Introducing default tensforflow graph for flask compatibility
graph = tf.get_default_graph()
def path_to_tensor(img_path):
"""Takes a file path of an image, loads it and then extracts information into a fixed shape numpy
array, ready to be used for VGG19 feature extracrion.
Parameters:
img_path (String): Path to a file containing the image.
Returns:
(np.array): A numpy array with fixed dimensions and information from an image
