def define_model(config, dset):
# Set session
configuration = tf.ConfigProto()
configuration.gpu_options.visible_device_list = config["train"]["gpus"]
configuration.gpu_options.allow_growth = True
sess = tf.Session(config=configuration)
K.set_session(sess)
# Load InceptionResnetV2 base architecture
if config['train']["pretrained"]:
weights = None
input_tensor = Input(
(
config['train']["sampling"]["box_size"], # height
config['train']["sampling"]["box_size"], # width
config['prepare']['images']["channel_repeats"] # channels
),
name='input')
base = inception_resnet_v2.InceptionResNetV2(include_top=True,
input_tensor=input_tensor)
base.get_layer(index=-2).name = "global_{}_pool".format(
config["train"]["model"]["params"]["pooling"])
# Define model
model = base
else:
weights = None
input_tensor = Input(
(
config["train"]["sampling"]["box_size"], # height
config["train"]["sampling"]["box_size"], # width
len(config['prepare']['images']["channels"]) # channels
),
name='input')
base = inception_resnet_v2.InceptionResNetV2(
include_top=False,
weights=weights,
input_tensor=input_tensor,
pooling=config["train"]["model"]["params"]["pooling"],
classes=dset.targets[0].shape[1])
base.get_layer(index=-1).name = "global_{}_pool".format(
config["train"]["model"]["params"]["pooling"])
# Create output embedding for each target
class_outputs = []
i = 0
for t in dset.targets:
y = Dense(t.shape[1], activation="softmax",
name=t.field_name)(base.output)
class_outputs.append(y)
i += 1
# Define model
model = Model(input_tensor, class_outputs)
# Define optimizer and loss
optimizer = Adam(lr=config['train']['model']['params']['learning_rate'])
loss = 'categorical_crossentropy'
return model, optimizer, loss
def build_bbx_model():
# cnn = resnet50.ResNet50(weights='imagenet', include_top=True)
# cnn = inception_v3.InceptionV3(weights='imagenet',
# input_shape = (img_h, img_w, 3),
# include_top=False,
# pooling='avg')
cnn = inception_resnet_v2.InceptionResNetV2(weights='imagenet',
input_shape=(img_h, img_w, 3),
include_top=False,
pooling='avg')
for layer in cnn.layers:
layer.trainable = True
cnn.trainable = True
x = cnn.output
x = Dropout(drop_out_ratio)(x)
x = Dense(1024, activation='relu')(x)
x = Dense(512, activation='relu')(x)
x = Dropout(drop_out_ratio)(x)
x = Dense(256, activation='relu')(x)
x = Dense(64, activation='relu')(x)
Output = Dense(8, activation='linear')(x)
model = Model(cnn.input, Output)
return model
def __init__(self, model, input_size):
input_shape = (input_size, input_size, 3)
if model == 'xception':
base_model = xception.Xception(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'vgg16':
base_model = vgg16.VGG16(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'vgg19':
base_model = vgg19.VGG19(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'inception_v3':
base_model = inception_v3.InceptionV3(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'mobilenet':
base_model = mobilenet.MobileNet(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'inception_resnet_v2':
base_model = inception_resnet_v2.InceptionResNetV2(
weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'resnet50':
base_model = resnet50.ResNet50(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
elif model == 'nasnetlarge':
base_model = nasnet.NASNetLarge(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
else:
base_model = nasnet.NASNetMobile(weights='imagenet',
include_top=False,
pooling='max',
input_shape=input_shape)
self.input_size = input_size
self.model = base_model
self.graph = tf.get_default_graph()
base_model.summary()
def get_extractor(layer='conv_7b'):
"""Returns pretrained InceptionResNetV2 model from bottom
to choosen layer (conv_7b by default).
Returns:
keras.Model
"""
base_model = inception_resnet_v2.InceptionResNetV2(include_top=False)
extractor = Model(inputs=base_model.inputs,
outputs=base_model.get_layer(layer).output)
return extractor
def define_model(config, dset):
# Load InceptionResnetV2 base architecture
if config["profile"]["use_pretrained_input_size"]:
input_tensor = Input((299, 299, 3), name="input")
model = inception_resnet_v2.InceptionResNetV2(
include_top=True,
input_tensor=input_tensor,
weights='imagenet',
pooling="avg")
model.summary()
else:
input_tensor = Input(
(
config["dataset"]["locations"]["box_size"], # height
config["dataset"]["locations"]["box_size"], # width
len(config["dataset"]["images"]["channels"]) # channels
),
name="input")
base = inception_resnet_v2.InceptionResNetV2(
include_top=False,
weights=None,
input_tensor=input_tensor,
pooling="avg",
classes=dset.targets[0].shape[1])
# Create output embedding for each target
class_outputs = []
i = 0
for t in dset.targets:
y = Dense(t.shape[1], activation="softmax",
name=t.field_name)(base.output)
class_outputs.append(y)
i += 1
# Define model
model = Model(input_tensor, class_outputs)
# Define optimizer and loss
optimizer = Adam(lr=config["train"]["model"]["params"]["learning_rate"])
loss = "categorical_crossentropy"
return model, optimizer, loss
def resnet_embedding(batch):
resnet = inception_resnet_v2.InceptionResNetV2(include_top=True,
weights='imagenet')
resnet.graph = tf.get_default_graph()
batch_resized = []
for i in batch:
i = resize(i, (299, 299, 3), mode='constant')
batch_resized.append(i)
batch_resized = np.array(batch_resized, dtype=np.float16)
batch_resized = inception_resnet_v2.preprocess_input(batch_resized)
with resnet.graph.as_default():
embed = resnet.predict(batch_resized)
return embed
def inception_resnet_v2_classificator(self, image_path):
inception_resnet_v2_model = inception_resnet_v2.InceptionResNetV2(
weights='imagenet')
filename = image_path
original = load_img(filename, target_size=(WIDTH, HEIGHT))
plt.imshow(original)
numpy_image = img_to_array(original)
plt.imshow(np.uint8(numpy_image))
image_batch = np.expand_dims(numpy_image, axis=0)
plt.imshow(np.uint8(image_batch[0]))
processed_image = inception_resnet_v2.preprocess_input(
image_batch.copy())
predictions = inception_resnet_v2_model.predict(processed_image)
label = decode_predictions(predictions)
return sorted(label[0], key=lambda x: x[2], reverse=True)
def incepres2(input_image, **kwargs):
from keras.applications import inception_resnet_v2
model = inception_resnet_v2.InceptionResNetV2(input_tensor=input_image,
include_top=False,
**kwargs)
print(model.summary())
return [
KL.ZeroPadding2D(p)(model.get_layer(name=n).output)
for p, n in [(((1, 1), (1, 1)),
'conv2d_1'), (((1, 2), (1, 2)), 'max_pooling2d_1'
), (((1, 2), (2, 1)), 'max_pooling2d_2'),
(((1, 1), (1, 1)),
'max_pooling2d_3'), (((1, 1), (1, 1)),
'max_pooling2d_4')]
]
def load_imagenet_model(self):
"""
Initialize the pre-trained model architecture and load the model weights.
The downloaded weights contains only the convolution base. It does not
contain the top two dense layers. We will have to manually define the top
two dense layers. The size_dict dictionary object will hold the input sizes
for various models, which will be further used to train the respective models
with the given input image dimensions.
Arguments:
-model_name : Name of the model, for example - vgg16, inception_v3, resnet50 etc
"""
if (self.input_params['model_name'] == "vgg16"):
base_model = vgg16.VGG16(weights=None, include_top=False)
base_model.load_weights(
self.path_dict["weights_path"] +
"vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5")
elif (self.input_params['model_name'] == "inceptionv3"):
base_model = inception_v3.InceptionV3(weights=None,
include_top=False)
base_model.load_weights(
self.path_dict["weights_path"] +
"inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5")
elif (self.input_params['model_name'] == "resnet50"):
base_model = resnet.ResNet50(weights=None, include_top=False)
base_model.load_weights(
self.path_dict["weights_path"] +
"resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5")
elif (self.input_params['model_name'] == "inception_resnet"):
base_model = inception_resnet_v2.InceptionResNetV2(
weights=None, include_top=False)
base_model.load_weights(
self.path_dict["weights_path"] +
"inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5"
)
elif (self.input_params['model_name'] == "nasnet"):
base_model = nasnet.NASNetLarge(weights=None, include_top=False)
base_model.load_weights(self.path_dict["weights_path"] +
"NASNet-large-no-top.h5")
elif (self.input_params['model_name'] == "xception"):
base_model = xception.Xception(weights=None, include_top=False)
base_model.load_weights(
self.path_dict["weights_path"] +
"xception_weights_tf_dim_ordering_tf_kernels.h5")
return base_model
def build_inceptionvresnetv2_model():
# get the model without the denses
base_model = inceptionresnetv2.InceptionResNetV2(weights='imagenet',
include_top='false')
new_dense = base_model.output
# add the new denses to classify the hate images
new_dense = Dense(1024, activation='relu')(new_dense)
predictions = Dense(2, activation='softmax')(new_dense)
model = Model(inputs=base_model.input, outputs=predictions)
# we will only train the new denses for the baseline
for layer in base_model.layers:
layer.trainable = False
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=["accuracy"])
return model
def create_model(img_size, model_type, base_name):
if model_type == 0:
print("Creating MobileNet model")
base = mobilenet.MobileNet(input_shape=img_size,
include_top=False,
weights='imagenet')
elif model_type == 1:
print("Creating InceptionV3 model")
base = inception_v3.InceptionV3(input_shape=img_size,
include_top=False,
weights='imagenet')
elif model_type == 2:
print("Creating Resnet50 model")
base = resnet50.ResNet50(input_shape=img_size,
include_top=False,
weights='imagenet')
elif model_type == 3:
print("Creating InceptionResNet-V2 model")
base = inception_resnet_v2.InceptionResNetV2(input_shape=img_size,
include_top=False,
weights='imagenet')
top = base.output
top = GlobalAveragePooling2D()(top)
top = Dense(units=2048,
activation='relu',
kernel_regularizer=None,
name='fc_1')(top)
predictions = Dense(units=n_classes,
activation='softmax',
kernel_regularizer=l2(l=wd),
name='softmax')(top)
model_combined = Model(inputs=base.input,
outputs=predictions,
name=base_name)
path_to_weights = 'weights/' + weights_filename
model_combined.load_weights(filepath=path_to_weights, by_name=True)
print('Loading weights from ' + path_to_weights)
return model_combined
def load_dcn_model(model_name = 'VGG16'):
"""
Returns a pretrained keras DCN model. For each model we return complete activation (last layer)
and intermediate activation (penultimate layer).
model_name can be:
- VGG16
- VGG19
- xception
- inception_resnet_v2
- resnet50
- inceptionV3
- densenet
"""
print "Loading model "+model_name
if(model_name == 'VGG16'):
model = vgg16.VGG16(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('fc2').output)
elif(model_name == 'VGG19'):
model = vgg19.VGG19(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('fc2').output)
elif(model_name == 'xception'):
model = xception.Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('avg_pool').output)
elif(model_name == 'inception_resnet_v2'):
model = inception_resnet_v2.InceptionResNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('avg_pool').output)
elif(model_name == 'resnet50'):
model = resnet50.ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('flatten_1').output)
elif(model_name == 'inceptionV3'):
model = inception_v3.InceptionV3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('avg_pool').output)
elif(model_name == 'densenet'):
model = densenet.DenseNet121(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
int_model = Model(inputs=model.input, outputs = model.get_layer('avg_pool').output)
else:
print "Model not found."
return None
print "Model loaded."
return (model, int_model)
def main(args):
file_trainval = 'Paintings_Classification_trainval.csv'
file_test = 'Paintings_Classification_test.csv'
demonet = 'inception_resnet_v2'
if demonet == 'inception_resnet_v2':
base_model = inception_resnet_v2.InceptionResNetV2(include_top=False, weights='imagenet', input_tensor=None, input_shape=None, pooling=None)
print('Model based loaded')
outputs = Dense(10, activation='sigmoid')(base_model.output)
model = Model(base_model.inputs, outputs)
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
batch_size= 16
print('Before compiling')
model.compile(loss='binary_crossentropy', optimizer=sgd,metrics=[metrics.categorical_accuracy, average_precision])
print('model compiled')
steps_per_epoch = 5000 / batch_size
model.fit_generator(imageLoader(file_trainval,batch_size),steps_per_epoch=steps_per_epoch, epochs=20,validation_data=imageLoader(file_test,batch_size))
print('End training')
return 0
def get_model_v2():
baseModel = inception_resnet_v2.InceptionResNetV2(
include_top=False,
weights='imagenet',
input_tensor=Input(shape=(SIZEINPUT, SIZEINPUT, 3)))
for layer in baseModel.layers:
layer.trainable = False
features = baseModel.output
x = GlobalAveragePooling2D(name="avg_pool")(features)
#x = Flatten()(x) #注意：使用GlobalAveragePooling2D时，输出即为2D Tensor，无需再用Flatten
x = Dense(12, activation='softmax')(x)
x = Dropout(0.5)(x)
model = Model(inputs=baseModel.inputs, outputs=x)
sgd = SGD(lr=LR, momentum=0.9)
model.compile(optimizer=sgd,
loss="categorical_crossentropy",
metrics=["accuracy"])
return model
def create_base_model(input_shape, base_id):
# Inception-v3
if base_id is 0:
base = inception_v3.InceptionV3(input_shape=input_shape,
weights='imagenet',
include_top=False)
base_name = 'Inception-V3'
# MobileNet
elif base_id is 1:
base = mobilenet.MobileNet(input_shape=input_shape,
weights='imagenet',
include_top=False)
base_name = 'MobileNet'
#Inception-ResNet-v2
elif base_id is 2:
base = inception_resnet_v2.InceptionResNetV2(input_shape=input_shape,
weights='imagenet',
include_top=False)
base_name = 'InceptionResNet-v2'
#ResNet50
elif base_id is 3:
base = resnet50.ResNet50(input_shape=input_shape,
weights='imagenet',
include_top=False)
base_name = 'ResNet50'
print("\nBase Network: %s" % base_name)
top = GlobalAveragePooling2D()(base.output)
# freeze all layers in the base network
for layers in base.layers:
layers.trainable = False
model = Model(inputs=base.input, outputs=top, name='base_model')
return model
def create_model(feature_extraction_method, num_classes, path_cnn_pre_trained,
input_size):
if (feature_extraction_method == 'fine_tuning_lenet'):
model = load_model(path_cnn_pre_trained)
input_image = input_size
if (feature_extraction_method == 'fine_tuning_vgg16'):
model = vgg16.VGG16(weights='imagenet', include_top=True)
#layer_name = 'fc2'
input_image = 224
elif (feature_extraction_method == 'fine_tuning_vgg19'):
model = vgg19.VGG19(weights='imagenet', include_top=True)
#layer_name = 'fc2'
input_image = 224
elif (feature_extraction_method == 'fine_tuning_xception'):
model = xception.Xception(weights='imagenet', include_top=True)
#layer_name = 'avg_pool'
input_image = 299
elif (feature_extraction_method == 'fine_tuning_resnet'):
model = resnet.ResNet50(weights='imagenet', include_top=True)
#layer_name = 'avg_pool'
input_image = 224
elif (feature_extraction_method == 'fine_tuning_inception_resnet'):
model = inception_resnet.InceptionResNetV2(weights='imagenet',
include_top=True)
#layer_name = 'avg_pool'
input_image = 299
elif (feature_extraction_method == 'fine_tuning_nasnet'):
model = nasnet.NASNetLarge(weights='imagenet', include_top=True)
#layer_name = 'global_average_pooling2d_1'
input_image = 331
#Removing the last layer
model.layers.pop()
new_layer = Dense(num_classes, activation='softmax', name='predictions')
model = Model(model.input, new_layer(model.layers[-1].output))
model.summary()
return model, input_image
def build_model_Inception_Resnet():
inception_resnet = inception_resnet_v2.InceptionResNetV2(
weights='imagenet',
include_top=False,
input_shape=(224,224,3)
)
model = Sequential()
model.add(inception_resnet)
model.add(layers.GlobalMaxPooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(2, activation='sigmoid'))
model.compile(
loss='categorical_crossentropy',
optimizer=Adam(lr=0.0005),
metrics=['accuracy']
)
return model
def create_model(feature_extraction_method, path_cnn_pre_trained, input_size):
if (feature_extraction_method == 'pretrained_lenet'):
model = load_model(path_cnn_pre_trained)
input_image = input_size
elif (feature_extraction_method == 'pretrained_vgg16'):
model = vgg16.VGG16(weights='imagenet', include_top=True)
#layer_name = 'fc2'
input_image = 224
elif (feature_extraction_method == 'pretrained_vgg19'):
model = vgg19.VGG19(weights='imagenet', include_top=True)
#layer_name = 'fc2'
input_image = 224
elif (feature_extraction_method == 'pretrained_xception'):
model = xception.Xception(weights='imagenet', include_top=True)
#layer_name = 'avg_pool'
input_image = 299
elif (feature_extraction_method == 'pretrained_resnet'):
model = resnet.ResNet50(weights='imagenet', include_top=True)
#layer_name = 'avg_pool'
input_image = 224
elif (feature_extraction_method == 'pretrained_inception_resnet'):
model = inception_resnet.InceptionResNetV2(weights='imagenet',
include_top=True)
#layer_name = 'avg_pool'
input_image = 299
elif (feature_extraction_method == 'pretrained_nasnet'):
model = nasnet.NASNetLarge(weights='imagenet', include_top=True)
#layer_name = 'global_average_pooling2d_1'
input_image = 331
intermediate_layer_model = Model(inputs=model.input,
outputs=model.layers[-2].output)
model.summary()
return intermediate_layer_model, input_image
def inception_res(input_shape=(224, 224, 3), freeze=0):
model = inception_resnet_v2.InceptionResNetV2(weights='imagenet',
input_shape=input_shape,
include_top=False)
return model
# classlabel.append(CLASS_INDEX[str(i)][1])
# classes = np.array(classlabel)
num_classes = len(classes)
##### Predict
# Load the retrained CNN model
# Model reconstruction from JSON file
# with open(model_json, 'r') as f:
# model_trained = model_from_json(f.read())
model_trained = inception_resnet_v2.InceptionResNetV2(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=(img_width,
img_height,
3))
x = model_trained.output
x = GlobalAveragePooling2D()(x) # before dense layer
x = Dense(1024, activation='relu')(x)
predictions_new = Dense(num_classes, activation='softmax', name='softmax')(x)
model_trained = Model(inputs=model_trained.input, outputs=predictions_new)
# Load weights into the new model
model_trained.load_weights(trainedweights_name)
# model_final = multi_gpu_model(model_final, gpus=2, cpu_merge=True, cpu_relocation=False)
# https://www.kaggle.com/giuseppemerendino/deep-mushroom-keras-t-sne
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
#Load the Inception_V3 model
# inception_v3_model = inception_v3.InceptionV3(weights='imagenet')
#Load the Inception_V4_resnetv2 model
inceptionResnet_v2_model = inception_resnet_v2.InceptionResNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
# inceptionResnet_v2_model = inception_resnet_v2.InceptionResNetV2( weights='imagenet')
# nasnet_model = nasnet.NASNetLarge(input_shape=None, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000)
# xception_model = xception.Xception(include_top=True, weights='imagenet')
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.imagenet_utils import decode_predictions
import matplotlib.pyplot as plt
%matplotlib osx
# or qt5.
# PyQt5 or similar required.. (https://stackoverflow.com/questions/52346254/importerror-failed-to-import-any-qt-binding-python-tensorflow)
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return
x_train, y_train = load_data(
'/media/tang/code/tianchi/data/trainset',
'/media/tang/code/tianchi/data/trainset/Annotations/label.csv')
width = 299
base_model = inception_resnet_v2.InceptionResNetV2(weights='imagenet',
input_shape=(width, width,
3),
include_top=False,
pooling='avg')
input_tensor = Input((width, width, 3))
x = input_tensor
x = Lambda(inception_resnet_v2.preprocess_input)(x)
x = base_model(x)
x = Dropout(0.5)(x)
x = [
Dense(count, activation='softmax', name=name)(x)
for name, count in label_count.items()
]
model = Model(input_tensor, x)
model.compile(optimizer='adam',
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("train_class", type=str, choices=classes.keys())
parser.add_argument("data_dir", type=str)
parser.add_argument('-e', "--epoch",
required=False,
type=int,
default=64,
dest="epoch")
parser.add_argument('-ef', "--epoch-fine-tune",
required=False,
type=int,
default=200,
dest="epoch_fine_tune")
parser.add_argument('-b', '--batch-size',
required=False,
default=1024,
type=int,
dest="batch")
parser.add_argument('-lr', '--learning-rate',
required=False,
default=1e-4,
type=float,
dest="lr")
parser.add_argument('-decay', '--learning-rate-decay',
required=False,
default=1e-6,
type=float,
dest="decay")
parser.add_argument('-ignore-npz', '--ignore-precomputed-learning-file',
required=False,
default=False,
type=bool,
dest="ignore_npz")
parser.add_argument('-ri', '--use-random-weight-initialisation',
required=False,
default=False,
type=bool,
dest="random_init")
parser.add_argument('-ua', '--unfroze-all-convolution-layer-directly',
required=False,
default=False,
type=bool,
dest="unfroze_all")
parser.add_argument('-m', '--model-name',
required=False,
default="MobileNetV2",
type=str,
dest="model_name")
parser.add_argument('-d', '--dense-layer-size',
required=False,
nargs="*",
default=[],
type=int,
dest="dense_size")
parser.add_argument('-is', '--input-size',
required=False,
default=96,
type=int,
dest="input_size")
parser.add_argument('-viz', '--data-visualisation',
required=False,
default=False,
type=bool,
dest="data_visualisation")
args = parser.parse_args()
batch_size = args.batch
class_name = args.train_class
out_classes = classes[class_name]["signs_classes"]
rotation_and_flips = classes[class_name]["rotation_and_flips"]
h_symmetry_classes = classes[class_name]["h_symmetry"]
try:
merge_sign_classes = classes[class_name]["merge_sign_classes"]
except KeyError:
merge_sign_classes = None
mapping = {c: i for i, c in enumerate(out_classes)}
mapping_id_to_name = {i: c for c, i in mapping.items()}
os.makedirs(class_name, exist_ok=True)
x_train, y_train, x_test, y_test = get_data_for_master_class(class_name=class_name,
mapping=mapping,
mapping_id_to_name=mapping_id_to_name,
rotation_and_flips=rotation_and_flips,
data_dir=args.data_dir,
merge_sign_classes=merge_sign_classes,
h_symmetry_classes=h_symmetry_classes,
image_size=(args.input_size, args.input_size),
ignore_npz=args.ignore_npz,
out_classes=out_classes)
if args.data_visualisation:
preprocess_input = lambda x: x
model = None
else:
if args.random_init:
weights = None
else:
weights = 'imagenet'
if args.model_name == "MobileNetV2":
preprocess_input = mobilenetv2.preprocess_input
base_model = mobilenetv2.MobileNetV2(weights=weights,
include_top=False,
input_shape=(args.input_size, args.input_size, 3),
pooling='avg')
elif args.model_name == "InceptionResNetV2":
preprocess_input = inception_resnet_v2.preprocess_input
base_model = inception_resnet_v2.InceptionResNetV2(weights=weights,
include_top=False,
input_shape=(args.input_size, args.input_size, 3),
pooling='avg')
elif args.model_name == "NASNetLarge":
preprocess_input = nasnet.preprocess_input
base_model = nasnet.NASNetLarge(weights=weights,
include_top=False,
input_shape=(args.input_size, args.input_size, 3),
pooling='avg')
else:
raise ValueError("unknown model name {}, should be one of {}".format(args.model_name,
["MobileNetV2", "InceptionResNetV2",
"NASNetLarge"]))
predictions = base_model.outputs[0]
for s in args.dense_size:
predictions = Dense(s, activation='relu')(predictions)
predictions = Dense(len(out_classes), activation='softmax')(predictions)
model = Model(inputs=base_model.input, outputs=predictions)
# model.summary()
# blocks = {}
# for i, layer in enumerate(base_model.layers):
# s = layer.name.split('_')
# if s[0] == "block":
# b = int(s[1])
# if b not in blocks:
# blocks[b] = [i]
# else:
# blocks[b].append(i)
# exit(0)
callbacks = [ModelCheckpoint(filepath="{}/checkpoint.h5".format(class_name),
monitor="val_loss",
mode='min',
verbose=0,
save_best_only="True",
save_weights_only=False,
period=1),
EarlyStopping(monitor='val_acc',
mode='max',
min_delta=0.001,
patience=40,
verbose=1,
restore_best_weights=True)
]
x_test = np.stack([preprocess_input(i) for i in x_test])
datagen = ImageDataGenerator(featurewise_center=False,
featurewise_std_normalization=False,
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
brightness_range=(0.5, 1.4),
shear_range=3.0,
zoom_range=(0.7, 1.1),
fill_mode='nearest',
horizontal_flip=False,
vertical_flip=False,
preprocessing_function=preprocess_input)
datagen.fit(x_train)
if args.data_visualisation:
for b in datagen.flow(x_train, y_train, batch_size=1):
im, im_class = b[0][0], b[1][0]
im_class = int(np.argmax(im_class))
plt.imshow(im.astype(np.int))
plt.title(out_classes[im_class])
plt.show()
return
if not args.random_init:
# if the network is not randomly initialized, we first fine tune the last layers
for layer in base_model.layers:
layer.trainable = False
model.compile(optimizer=rmsprop(lr=args.lr, decay=args.decay),
loss='categorical_crossentropy', metrics=["accuracy"])
history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=ceil(len(x_train) / batch_size),
epochs=args.epoch,
verbose=1,
validation_data=(x_test, y_test),
use_multiprocessing=True,
callbacks=callbacks)
plot_history(history, "{0}/{1}_{0}_dense_".format(class_name, args.model_name))
model.save("{0}/{1}_{0}_dense.h5".format(class_name, args.model_name), overwrite=True)
if not args.unfroze_all:
# unfroze the 3 last blocks of mobile net
for layer in model.layers[:113]:
layer.trainable = False
for layer in model.layers[113:]:
layer.trainable = True
model.compile(optimizer=SGD(lr=args.lr, momentum=0.9, decay=args.decay),
loss='categorical_crossentropy', metrics=["accuracy"])
history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=ceil(len(x_train) / batch_size),
epochs=args.epoch_fine_tune,
verbose=1,
validation_data=(x_test, y_test),
use_multiprocessing=True,
callbacks=callbacks)
plot_history(history, "{0}/{1}_{0}_fine_tuning_1_".format(class_name, args.model_name))
model.save("{0}/{1}_{0}_1.h5".format(class_name, args.model_name), overwrite=True)
# unfroze the 6 last blocks of mobile net
for layer in model.layers[:87]:
layer.trainable = False
for layer in model.layers[87:]:
layer.trainable = True
model.compile(optimizer=SGD(lr=args.lr, momentum=0.9, decay=args.decay),
loss='categorical_crossentropy', metrics=["accuracy"])
history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=ceil(len(x_train) / batch_size),
epochs=args.epoch_fine_tune,
verbose=1,
validation_data=(x_test, y_test),
use_multiprocessing=True,
callbacks=callbacks)
plot_history(history, "{0}/{1}_{0}_fine_tuning_2_".format(class_name, args.model_name))
model.save("{0}/{1}_{0}_2.h5".format(class_name, args.model_name), overwrite=True)
# unfroze all model
for layer in model.layers:
layer.trainable = True
model.compile(optimizer=SGD(lr=args.lr, momentum=0.9, decay=args.decay),
loss='categorical_crossentropy', metrics=["accuracy"])
history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=ceil(len(x_train) / batch_size),
epochs=args.epoch_fine_tune,
verbose=1,
validation_data=(x_test, y_test),
use_multiprocessing=True,
callbacks=callbacks)
plot_history(history, "{0}/{1}_{0}_fine_tuning_f_".format(class_name, args.model_name))
model.save("{0}/{1}_{0}_final.h5".format(class_name, args.model_name), overwrite=True)
def get_model():
num_classes = 10
input_shape = (MODELS[MODEL]['size'], MODELS[MODEL]['size'], 3)
#preprocess = imagenet_utils.preprocess_input
input_image = Input(shape=input_shape)
if MODEL == "densenet121":
base_model = densenet.DenseNet121(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "densenet169":
base_model = densenet.DenseNet169(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "densenet201":
base_model = densenet.DenseNet201(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "inceptionresnet":
base_model = inception_resnet_v2.InceptionResNetV2(
include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "inception":
base_model = inception_v3.InceptionV3(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "mobilenet":
base_model = mobilenet.MobileNet(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "resnet":
base_model = resnet50.ResNet50(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "vgg16":
base_model = vgg16.VGG16(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
elif MODEL == "vgg19":
base_model = vgg19.VGG19(include_top=False,
pooling=None,
weights='imagenet',
input_shape=input_shape)
else:
print("Bad model type:", MODEL)
sys.exit(-1)
x = input_image
x = base_model(x)
x = Reshape((-1, ))(x)
#x = Dropout(rate=?)(x)
x = Dense(512, activation='relu', name='fc1')(x)
x = Dropout(0.3, name='dropout_fc1')(x)
x = Dense(128, activation='relu', name='fc2')(x)
x = Dropout(0.3, name='dropout_fc2')(x)
prediction = Dense(nclass, activation="softmax", name="predictions")(x)
# this is the model we will train
my_model = Model(inputs=(input_image), outputs=prediction)
# compile the model (should be done *after* setting layers to non-trainable)
opt = optimizers.Adam(lr=1e-4)
my_model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['acc'])
my_model.summary()
return my_model
#modelo.summary()
if (Modelo == 1):
from keras.applications.inception_v3 import preprocess_input
imagen = preprocess_input(imagen)
modelo = inception_v3.InceptionV3(weights='imagenet',
include_top=True)
#modelo.summary()
if (Modelo == 2):
from keras.applications.resnet50 import preprocess_input
imagen = preprocess_input(imagen)
modelo = resnet50.ResNet50(weights='imagenet', include_top=True)
#modelo.summary()
if (Modelo == 3):
from keras.applications.inception_resnet_v2 import preprocess_input
imagen = preprocess_input(imagen)
modelo = inception_resnet_v2.InceptionResNetV2(weights='imagenet',
include_top=True)
#modelo.summary()
if (Modelo == 4):
from keras.applications.xception import preprocess_input
imagen = preprocess_input(imagen)
modelo = xception.Xception(weights='imagenet', include_top=True)
#modelo.summary()
prediccion = modelo.predict(imagen)
from keras.applications.imagenet_utils import decode_predictions
prediccion_decodificada = decode_predictions(prediccion)
#prediccion_decodificada=np.array(prediccion_decodificada)
print("La prediccion del modelo %s es %s con una probabilidad de %f" %
(modelos[Modelo], prediccion_decodificada[0][0][1],
y[12500:] = 1
from sklearn.model_selection import train_test_split
# 需要把集合打乱么？
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2)
# from keras.applications.resnet50 import ResNet50
# base_model = ResNet50(input_tensor=Input((img_height, img_width, 3)), weights='imagenet', include_top=False)
i_input_tensor = Input((img_height, img_width, 3))
# x_input_tensor = inception_resnet_v2.preprocess_input(i_input_tensor) # 错误的处理
x_input_tensor = Lambda(inception_resnet_v2.preprocess_input)(i_input_tensor)
base_model = inception_resnet_v2.InceptionResNetV2(input_tensor=x_input_tensor,
weights='imagenet',
include_top=False)
# 上面的 input_tensor 没有进行处理吧，参考里面的 ResNet50 是不用预处理的。
# 但是上面会找不到数据
# 下面的可以进行计算，但是结果。。。训练集还不错，loss：0.16；acc：0.93。但是验证集，loss：5.9197；acc：0.5622
# base_model = inception_resnet_v2.InceptionResNetV2(weights='imagenet', include_top=False)
for layers in base_model.layers:
layers.trainable = False
i_output = GlobalAveragePooling2D()(base_model.output)
i_output = Dropout(0.5)(i_output)
i_predictions = Dense(1, activation='sigmoid')(i_output)
model = Model(base_model.input, i_predictions)
model.compile(optimizer='adadelta',
non_trainable_count = np.sum([K.count_params(w) for w in model.non_trainable_weights])
return trainable_count, non_trainable_count
#print('Total params: {:,}'.format(trainable_count + non_trainable_count))
#print('Trainable params: {:,}'.format(trainable_count))
#print('Non-trainable params: {:,}'.format(non_trainable_count))
paramcount_list= []
for model_name in ["vgg16","nasnet","inception_resnet","inceptionv3","xception"]:
if(model_name=="vgg16"):
base_model = vgg16.VGG16(weights=None, include_top=False)
elif(model_name=="inceptionv3"):
base_model = inception_v3.InceptionV3(weights=None, include_top=False)
elif(model_name=="resnet50"):
base_model = resnet.ResNet50(weights=None, include_top=False)
elif(model_name=="inception_resnet"):
base_model = inception_resnet_v2.InceptionResNetV2(weights=None, include_top=False)
elif(model_name=="nasnet"):
base_model = nasnet.NASNetLarge(weights=None, include_top=False)
elif(model_name=="xception"):
base_model = xception.Xception(weights=None, include_top=False)
print("model name is:",model_name)
paramcount_list.append((model_name,"base",count_params(base_model)))
#Adding a global spatial average pooling layer
x = base_model.output
x = GlobalAveragePooling2D()(x)
customlayers= customlayer()
output_layer = customlayers(x)
model_stg1 = Model(inputs=base_model.input, outputs=output_layer)
model_json = model_stg1.to_json()
modelpath= liby+model_name+".json"
with open(modelpath, "w") as json_file:
from keras.models import Model
from keras.applications import inception_v3, inception_resnet_v2
from keras.layers import Dense, ELU, Dropout, BatchNormalization
filename = "finalEnsemble/inception_v4_difftop_832.h5"
model = inception_resnet_v2.InceptionResNetV2(include_top=False,
input_shape=(256, 256, 3),
pooling='avg')
x = model.output
x = Dense(512)(x)
x = BatchNormalization(name="lol")(x)
x = ELU()(x)
x = Dense(512, activation='relu')(x)
x = Dropout(0.5)(x)
pred = Dense(18, activation='softmax')(x)
new_model = Model(inputs=model.input, outputs=pred)
new_model.load_weights(filename)
new_model.save(filename)
def __init__(self):
self.extractor = inception_resnet_v2.InceptionResNetV2(
weights='imagenet', include_top=False, pooling="avg")
self.classifier = inception_resnet_v2.InceptionResNetV2(
weights='imagenet')
print('trainX.shape:', trainX.shape, ' valX.shape:', valX.shape)
# augmenting datset
aug = ImageDataGenerator(rotation_range=25,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode="nearest")
print("loading the model")
#set the model
model = ''
if model_name == 'inception':
model = inception_resnet_v2.InceptionResNetV2(include_top=False,
weights='imagenet',
input_shape=img_dims)
elif model_name in ['vgg16', 'VGG16']:
model = vgg16.VGG16(include_top=False,
weights='imagenet',
input_shape=img_dims)
elif model_name in ['vgg19', 'VGG19']:
model = vgg19.VGG19(include_top=False,
weights='imagenet',
input_shape=img_dims)
elif model_name in ['resnet50', 'ResNet50']:
model = ResNet50(include_top=False,
weights='imagenet',
input_shape=img_dims)
elif model_name in ['resnet101', 'ResNet101']:
model = resnet.ResNet101(include_top=False,