print('Y_train2 shape : ', Y_train2.shape)
print('Y_train3 shape : ', Y_train3.shape)
# print('Y_train4 shape : ',Y_train4.shape)
# print('Y_train5 shape : ',Y_train5.shape)
print('X_test shape : ', X_test.shape)
print('Y_test1 shape : ', Y_test1.shape)
print('Y_test2 shape : ', Y_test2.shape)
print('Y_test3 shape : ', Y_test3.shape)
# print('Y_test4 shape : ',Y_test4.shape)
# print('Y_test5 shape : ',Y_test5.shape)
#Resnet50
model1 = VGG16(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=(224, 224, 3),
pooling='avg',
classes=[4, 5, 3])
x1 = model1.output
#使用Droupout
x1 = Dropout(0.5)(x1)
#Multi tasking
Influ = Dense(4, activation='softmax', name='softmax1')(x1)
Para = Dense(5, activation='softmax', name='softmax2')(x1)
EV = Dense(3, activation='softmax', name='softmax3')(x1)
# RSV = Dense(3, activation='softmax', name='softmax4')(x1)
# ADV = Dense(3, activation='softmax', name='softmax5')(x1)
# model_final = keras.models.load_model('/home/pmcn/workspace/CPE_AI/Resnet50/checkpoint2/0120_all_Multi_model_1.h5')
validation_data_dir = DATA_ROOT + 'val'
nb_train_samples = (80 * 11)
nb_val_samples = (20 * 11 - 6 - 1)
nb_epoch = 50
result_dir = 'results'
if not os.path.exists(result_dir):
os.mkdir(result_dir)
if __name__ == '__main__':
# VGG16モデルと学習済み重みをロード
# Fully-connected層（FC）はいらないのでinclude_top=False）
input_tensor = Input(shape=(img_rows, img_cols, 3))
vgg16 = VGG16(include_top=False,
weights='imagenet',
input_tensor=input_tensor)
# vgg16.summary()
# FC層を構築
# Flattenへの入力指定はバッチ数を除く
top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(nb_classes, activation='softmax'))
# 学習済みのFC層の重みをロード
# top_model.load_weights(os.path.join(result_dir, 'bottleneck_fc_model.h5'))
# VGG16とFCを接続
def go(args):
drop_rate = args[0]
now = datetime.datetime.now()
current_time = '{:04d}_{:02d}_{:02d}_{:02d}{:02d}{:02d}'.format(
now.year, now.month, now.day, now.hour, now.minute, now.second)
DATASET_PATH = './dataset'
BATCH_SIZE = 20
NUM_CLASS = 13
NUM_EPOCHS = 20
SAVE_PATH = current_time
os.mkdir(SAVE_PATH)
train_datagen = ImageDataGenerator(
# rotation_range=rotation_range,
# width_shift_range=width_shift_range,
# height_shift_range=height_shift_range,
# shear_range=shear_range,
# zoom_range=zoom_range,
preprocessing_function=preprocess_input,
horizontal_flip=True,
fill_mode='reflect',
cval=0,
validation_split=0.1)
train_generator = train_datagen.flow_from_directory(
os.path.join(DATASET_PATH, 'train'),
target_size=(256, 256),
interpolation='bicubic',
class_mode='categorical',
shuffle=True,
batch_size=BATCH_SIZE,
subset='training')
validation_generator = train_datagen.flow_from_directory(
os.path.join(DATASET_PATH, 'train'),
target_size=(256, 256),
interpolation='bicubic',
class_mode='categorical',
batch_size=BATCH_SIZE,
subset='validation') # set as validation data
net = VGG16(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=(256, 256, 3))
x = net.output
x = Flatten()(x)
x = Dropout(drop_rate)(x)
x = Dense(1024, activation='relu', name='fc1')(x)
x = Dropout(drop_rate)(x)
x = Dense(512, activation='relu', name='fc2')(x)
output_layer = Dense(NUM_CLASS, activation='softmax', name='softmax')(x)
net_final = Model(inputs=net.input, outputs=output_layer)
for layer in net_final.layers[:-4]:
layer.trainable = False
for layer in net_final.layers[-4:]:
layer.trainable = True
net_final.compile(optimizer=Adam(lr=1e-4),
loss='categorical_crossentropy',
metrics=['accuracy'])
mcp_save = ModelCheckpoint(os.path.join(SAVE_PATH,
'model-vgg16-final_best.h5'),
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='min',
period=1)
print(net_final.summary())
history = net_final.fit_generator(
train_generator,
steps_per_epoch=train_generator.samples // BATCH_SIZE,
validation_data=validation_generator,
validation_steps=validation_generator.samples // BATCH_SIZE,
epochs=NUM_EPOCHS,
callbacks=[mcp_save],
verbose=1)
net_final.save(os.path.join(SAVE_PATH, 'model-vgg16-final.h5'))
with open(os.path.join(SAVE_PATH, 'min_val_loss.txt'), 'a') as out_file:
out_file.write(str(min(history.history['val_loss'])))
print('Loss:', min(history.history['val_loss']))
return min(history.history['val_loss'])
yield shuffle(X_train, Y_train)
train_generator = generator(train_data, batch_size=32)
valid_generator = generator(valid_data, batch_size=32)
from keras.applications.vgg16 import VGG16
from keras.layers import Input, Lambda, Flatten, Dense, Cropping2D, Dropout
from keras.models import Model
import math
# Use pre-trained VGG16 model as a start point.
input_height = 65
input_width = 320
vgg = VGG16(include_top=False,
weights='imagenet',
input_shape=(input_height, input_width, 3))
# freeze all layers weight
for layer in vgg.layers:
layer.trainable = False
#vgg.summary()
input_shape = Input(shape=(160, 320, 3))
normalize = Lambda(lambda x: x / 255.0 - 0.5)(input_shape) # Normalize inputs
crop_input = Cropping2D(cropping=((70, 25), (0, 0)))(normalize)
vgg16 = vgg(crop_input)
flatten = Flatten()(vgg16)
fc1 = Dense(2048, activation='relu')(flatten)
d1 = Dropout(0.5)(fc1) # dropout regularization
fc2 = Dense(2048, activation='relu')(d1)
def __init__(self,
model='resnet152',
input_shape=(224, 224, 3),
conv_output=True,
conv7_output=False):
"""The :class:`BaseNetE2E` object provides different implementations of CNN Classifiers used as Base Model to extract features from images.
If :paramref:`utils.base_net_e2e.BaseNetE2E.conv_output is set to True, the Classifier is slightly changed to have a 3D feature map as output.
:param str model: the name of the classifier
:param tuple input_shape: shape of the input
:param bool conv_output: whether to change the model to output a 3D feature map or a 1D flatten output
:param bool freeze_layers: whether to set the layers from the Classifier as not trainable or trainable
"""
self.input_shape = input_shape
self.conv_output = conv_output
self.added_layers = 9
weights = 'imagenet'
if conv7_output:
self.added_layers = 0
if model == 'vgg16':
self.model = VGG16(input_shape=input_shape, weights=weights)
self.conv_model = self.model.layers[-5].output
elif model == 'mobilenet':
self.model = MobileNetV2(input_shape=input_shape,
weights=weights)
self.conv_model = self.model.layers[-3].output
elif model == 'resnet50':
self.model = ResNet50(input_shape=input_shape, weights=weights)
self.conv_model = self.model.layers[-3].output
elif model == 'resnet152':
self.model = ResNet152(input_shape=input_shape,
weights=weights)
self.conv_model = self.model.layers[-4].output
elif model == 'inceptionresnet':
self.model = InceptionResNetV2(input_shape=input_shape,
weights=weights)
self.conv_model = Conv2D(1024, (2, 2),
padding='valid',
kernel_initializer='he_normal',
name='output1')(
self.model.layers[-4].output)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.added_layers = 3
elif conv_output:
if model == 'vgg16':
self.model = VGG16(input_shape=input_shape, weights=weights)
self.conv_model = Conv2D(1024, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='fc6')(
self.model.layers[-5].output)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(1024, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='fc7')(self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(256, (1, 1),
padding='same',
kernel_initializer='he_normal',
name='bottleneck_output')(
self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
elif model == 'mobilenet':
self.model = MobileNetV2(input_shape=input_shape,
weights=weights)
self.conv_model = Conv2D(512, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output1')(
self.model.layers[-3].output)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(512, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output2')(self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(256, (1, 1),
padding='same',
kernel_initializer='he_normal',
name='bottleneck_output')(
self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
elif model == 'resnet50':
self.model = ResNet50(input_shape=input_shape, weights=weights)
self.conv_model = Conv2D(512, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output1')(
self.model.layers[-3].output)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(512, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output2')(self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(256, (1, 1),
padding='same',
kernel_initializer='he_normal',
name='bottleneck_output')(
self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
elif model == 'resnet152':
self.model = ResNet152(input_shape=input_shape,
weights=weights)
self.conv_model = Conv2D(512, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output1')(
self.model.layers[-4].output)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(512, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output2')(self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(256, (1, 1),
padding='same',
kernel_initializer='he_normal',
name='bottleneck_output')(
self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
elif model == 'inceptionresnet':
self.model = InceptionResNetV2(input_shape=input_shape,
weights=weights)
self.conv_model = Conv2D(1024, (3, 3),
padding='valid',
kernel_initializer='he_normal',
name='output1')(
self.model.layers[-4].output)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.conv_model = Conv2D(256, (1, 1),
padding='same',
kernel_initializer='he_normal',
name='bottleneck_output')(
self.conv_model)
self.conv_model = BatchNormalization()(self.conv_model)
self.conv_model = ReLU()(self.conv_model)
self.added_layers = 6
else:
raise ValueError(
"The model you want to initialize as base is unknown.")
else:
if model == 'vgg16':
self.model = VGG16(input_shape=input_shape, weights=weights)
elif model == 'mobilenet':
self.model = MobileNetV2(input_shape=input_shape,
weights=weights)
elif model == 'resnet50':
self.model = ResNet50(input_shape=input_shape, weights=weights)
elif model == 'resnet152':
self.model = ResNet152(input_shape=input_shape,
weights=weights)
elif model == 'inceptionresnet':
self.model = InceptionResNetV2(input_shape=input_shape,
weights=weights)
else:
raise ValueError(
"The model you want to initialize as base is unknown.")
import tensorflow as tf
from keras.layers import Dense, Flatten
from keras.models import Model
from keras.applications.vgg16 import VGG16
from keras.preprocessing.image import ImageDataGenerator
from glob import glob
import matplotlib.pyplot as plt
IMAGE_SIZE = [224, 224]
train_path = 'Datasets/Train'
valid_path = 'Datasets/Validate'
vgg = VGG16(input_shape=IMAGE_SIZE + [3],
weights='imagenet',
include_top=False)
for layer in vgg.layers:
layer.trainable = False
folders = glob(train_path + '/*')
x = Flatten()(vgg.output)
prediction = Dense(len(folders), activation='sigmoid')(x)
model = Model(inputs=vgg.input, outputs=prediction)
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
from keras.models import Model
from keras.preprocessing import image
from keras.optimizers import SGD
from keras.applications.vgg16 import VGG16
import matplotlib.pyplot as plt
import numpy as np
import cv2
# imagenet에 대해 사전 학습된 가중치를 갖는 사전에 빌드된 모델
model = VGG16(weights='imagenet', include_top=True)
sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss='categorical_crossentropy')
# VGG16 학습된 이미지 포맷으로 리사이즈
im = cv2.resize(cv2.imread('./data/steam-locomotive.jpg'), (224, 224))
im = np.expand_dims(im, axis=0)
# 예측
out = model.predict(im)
plt.plot(out.ravel())
plt.show()
print(np.argmax(out))
# 증기 기관차를 뜻하는 820이 나와야 한다.
from imblearn.under_sampling import RandomUnderSampler
from keras.applications.vgg19 import VGG19
from keras.applications.resnet50 import ResNet50
from keras.applications.inception_resnet_v2 import InceptionResNetV2
from keras.applications import Xception
from keras.utils.np_utils import to_categorical
from keras.callbacks import Callback, EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
# %cd /content
wkdir = "./weights/"
pb_filename = "./drive/My Drive/Colab Notebooks/weights/retrained_graph.pb"
label_file = "./drive/My Drive/Colab Notebooks/weights/retrained_labels.txt"
weight_path1 = './drive/My Drive/Colab Notebooks/weights/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'
weight_path2 = './drive/My Drive/Colab Notebooks/weights/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'
pretrained_model_1 = VGG16(weights=weight_path1,
include_top=False,
input_shape=(299, 299, 3))
#pretrained_model_2 = InceptionV3(weights = weight_path2, include_top=False, input_shape=(299, 299, 3))
IMG_SIZE = 299
ARCHITECTURE = 1
device_name = tf.test.gpu_device_name()
if device_name != '/device:GPU:0':
raise SystemError('GPU device not found')
print('Found GPU at: {}'.format(device_name))
class MetricsCheckpoint(Callback):
"""Callback that saves metrics after each epoch"""
def __init__(self, savepath):
def main():
map_characters1 = {0: 'No COVID', 1: 'Yes COVID'}
dict_characters = map_characters1
df = pd.DataFrame()
print(dict_characters)
model_file = "weights/covid.pb"
weight_path1 = './drive/My Drive/Colab Notebooks/weights/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'
weight_path2 = './drive/My Drive/Colab Notebooks/weights/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'
train_dir = "./drive/My Drive/Colab Notebooks/covid_dataset/train/"
test_dir = "./drive/My Drive/Colab Notebooks/covid_dataset/test/"
with tf.device('/device:GPU:0'):
X_train, y_train = get_data(train_dir)
X_test, y_test = get_data(test_dir)
# Encode labels to hot vectors (ex : 2 -> [0,0,1,0,0,0,0,0,0,0])
y_trainHot = to_categorical(y_train, num_classes=2)
y_testHot = to_categorical(y_test, num_classes=2)
plotHistogram(X_train[1])
plt.show()
class_weight1 = class_weight.compute_class_weight(
'balanced', np.unique(y_train), y_train)
pretrained_model_1 = VGG16(weights=weight_path1,
include_top=False,
input_shape=(299, 299, 3))
#pretrained_model_2 = InceptionV3(weights = weight_path2, include_top=False, input_shape=(299, 299, 3))
optimizer1 = keras.optimizers.SGD(learning_rate=0.1)
optimizer2 = keras.optimizers.Adam(lr=0.01, epsilon=0.0001)
# Deal with imbalanced class sizes below
# Make Data 1D for compatability upsampling methods
X_trainShape = X_train.shape[1] * X_train.shape[2] * X_train.shape[3]
X_testShape = X_test.shape[1] * X_test.shape[2] * X_test.shape[3]
X_trainFlat = X_train.reshape(X_train.shape[0], X_trainShape)
X_testFlat = X_test.reshape(X_test.shape[0], X_testShape)
Y_train = y_train
Y_test = y_test
ros = RandomUnderSampler(sampling_strategy='auto')
X_trainRos, Y_trainRos = ros.fit_sample(X_trainFlat, Y_train)
X_testRos, Y_testRos = ros.fit_sample(X_testFlat, Y_test)
Y_trainRosHot = to_categorical(Y_trainRos, num_classes=2)
Y_testRosHot = to_categorical(Y_testRos, num_classes=2)
df["labels"] = y_train
lab = df['labels']
dist = lab.value_counts()
sns.countplot(lab)
# Make Data 2D again
for i in range(len(X_trainRos)):
height, width, channels = IMG_SIZE, IMG_SIZE, 3
X_trainRosReshaped = X_trainRos.reshape(len(X_trainRos), height,
width, channels)
for i in range(len(X_testRos)):
height, width, channels = IMG_SIZE, IMG_SIZE, 3
X_testRosReshaped = X_testRos.reshape(len(X_testRos), height,
width, channels)
# Plot Label Distribution
dfRos = pd.DataFrame()
dfRos["labels"] = Y_trainRos
labRos = dfRos['labels']
distRos = lab.value_counts()
sns.countplot(labRos)
class_weight2 = class_weight.compute_class_weight(
'balanced', np.unique(Y_trainRos), Y_trainRos)
print("New Class Weights: ", class_weight2)
pretrainedNetwork(X_trainRosReshaped, Y_trainRosHot, X_testRosReshaped,
Y_testRosHot, pretrained_model_1, weight_path1,
class_weight2, 2, 100, optimizer2, map_characters1)
return 1
style_array[:, :, :, 0] -= 103.939
style_array[:, :, :, 1] -= 116.779
style_array[:, :, :, 2] -= 123.68
style_array=style_array[:, :, :, ::-1]
style_array.shape
height=512
width=512
content_image=backend.variable(content_array)
style_image=backend.variable(style_array)
combination_image=backend.placeholder((1,height,width,3))
input_tensor = backend.concatenate([content_image,style_image,combination_image], axis=0)
model=VGG16(input_tensor=input_tensor,weights='imagenet', include_top=False)
content_weight = 0.05
style_weight = 5.0
total_variation_weight = 1.0
layers=dict([(layer.name, layer.output) for layer in model.layers])
loss = backend.variable(0.)
def content_loss(content, combination):
return backend.sum(backend.square(content-combination))
layer_features = layers['block2_conv2']
content_image_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]
conv_depth_2 = 64
conv_depth_3 = 128
conv_depth_4 = 256
conv_depth_5 = 512
drop_prob_1 = 0.5
drop_prob_2 = 0.25
hidden_size = 512
print("Training About to start")
print
########################################################################################################################################
input_shape = (224, 224, 3)
nClasses = 10
image_input = Input(shape=(224, 224, 3))
model = VGG16(input_tensor=image_input, include_top=True, weights='imagenet')
model.summary()
last_layer = model.get_layer('block5_pool').output
x = AveragePooling2D(pool_size=(4, 4), strides=2)(last_layer)
x = Flatten(name='flatten')(x)
x = Dense(128, activation='relu', name='fc1')(x)
x = Dense(128, activation='relu', name='fc2')(x)
out = Dense(num_classes, activation='softmax', name='output')(x)
custom_vgg_model2 = Model(image_input, out)
custom_vgg_model2.summary()
# freeze all the layers except the dense layers
for layer in custom_vgg_model2.layers[:-3]:
def nn_base(input, trainable):
base_model = VGG16(weights=None, include_top=False, input_shape=input)
return base_model.input, base_model.get_layer('block5_conv3').output
def __init__(self):
"""
Download VGG16 Model from Github
"""
self._model = VGG16(weights='imagenet')
def transform(content_img, style_img, height, width, iterations):
content_array = image_to_array(content_img)
style_array = image_to_array(style_img)
content_array = transform_color_and_flip_colorchannels(content_array)
style_array = transform_color_and_flip_colorchannels(style_array)
content_image = backend.variable(content_array)
style_image = backend.variable(style_array)
combination_image = backend.placeholder((1, height, width, 3))
input_tensor = backend.concatenate(
[content_image, style_image, combination_image], axis=0)
model = VGG16(input_tensor=input_tensor,
weights='imagenet',
include_top=False)
layers = dict([(layer.name, layer.output) for layer in model.layers])
content_weight = 0.025
style_weight = 5.0
total_variation_weight = 1.0
loss = backend.variable(0.)
layer_features = layers['block2_conv2']
content_image_features = layer_features[0, :, :, :]
combination_features = layer_features[2, :, :, :]
loss += content_weight * backend.sum(
backend.square(combination_features - content_image_features))
feature_layers = [
'block1_conv2', 'block2_conv2', 'block3_conv3', 'block4_conv3',
'block5_conv3'
]
for layer_name in feature_layers:
layer_features = layers[layer_name]
style_features = layer_features[1, :, :, :]
combination_features = layer_features[2, :, :, :]
sl = style_loss(style_features, combination_features, height, width)
loss += (style_weight / len(feature_layers)) * sl
loss += total_variation_weight * total_variation_loss(
combination_image, height, width)
grads = backend.gradients(loss, combination_image)
outputs = [loss]
outputs += grads
f_outputs = backend.function([combination_image], outputs)
evaluator = Evaluator(f_outputs, height, width)
x = np.random.uniform(0, 255, (1, height, width, 3)) - 128.
for i in range(iterations):
print('Start of iteration', i)
start_time = time.time()
x, min_val, info = fmin_l_bfgs_b(evaluator.loss,
x.flatten(),
fprime=evaluator.grads,
maxfun=20)
print('Current loss value:', min_val)
end_time = time.time()
print('Iteration %d completed in %ds' % (i, end_time - start_time))
x = x.reshape((height, width, 3))
x = x[:, :, ::-1]
x[:, :, 0] += 103.939
x[:, :, 1] += 116.779
x[:, :, 2] += 123.68
x = np.clip(x, 0, 255).astype('uint8')
img = Image.fromarray(x)
return img
x_train = x_train.reset_index(drop=True)
x_test = x_test.reset_index(drop=True)
y_train = y_train.reset_index(drop=True)
y_test = y_test.reset_index(drop=True)
train_steps = int(x_train.shape[0]/batch_size)
valid_steps = int(x_test.shape[0]/batch_size)
train_gen = KinImageReader(x_train,y_train,batch_size,height,width)
valid_gen = KinImageReader(x_test,y_test,batch_size,height,width)
# Define Pretrained VGG16 Application from Keras
model1 = VGG16(weights='imagenet', include_top=False,input_shape=(height,width, 3))
model2 = VGG16(weights='imagenet', include_top=False,input_shape=(height,width, 3))
# Append label for each head so merge layer doesnt get confused
for layer in model1.layers:
layer.name = layer.name + str("_1")
layer.trainable = False
for layer in model2.layers:
layer.name = layer.name + str("_2")
layer.trainable = False
# Flatten the layers before merging
a = Flatten()(model1.output)
b = Flatten()(model2.output)
def create_model(self):
input_tensor = Input(shape=self.input_shape)
h, w, c = self.input_shape
depth_tensor = Input(
shape=(h, w, 1)) # Already prepared depthmap with PyDNet
# VGG16 encodes with 5 successives blocks of Conv2D and 2x2 MaxPooling (s=2)
# So it divides input size by 2**5 = 32
# We zero pad image so that both sides are multiples of 32
# If we don't, information is lost at encoding step
# TODO: Investigate Mirror Padding instead of Zero Padding
modVGG16 = 32
hpad = (modVGG16 - w % modVGG16) % modVGG16
vpad = (modVGG16 - h % modVGG16) % modVGG16
ceil_hpad = int(np.ceil(hpad / 2))
floor_hpad = int(np.floor(hpad / 2))
ceil_vpad = int(np.ceil(vpad / 2))
floor_vpad = int(np.floor(vpad / 2))
encoder_input_tensor = ZeroPadding2D(
padding=((ceil_vpad, floor_vpad), (ceil_hpad,
floor_hpad)))(input_tensor)
concat_depth_tensor = ZeroPadding2D(
padding=((ceil_vpad, floor_vpad), (ceil_hpad,
floor_hpad)))(depth_tensor)
encoder = VGG16(include_top=False,
weights=self.pre_trained_encoder,
input_tensor=encoder_input_tensor,
input_shape=self.input_shape,
pooling="None") # type: tModel
L = [layer
for i, layer in enumerate(encoder.layers)] # type: List[Layer]
for layer in L:
layer.trainable = False # freeze VGG16
L.reverse()
x = encoder.output
x = Dropout(0.2)(x)
# Block 5
if self.dsegnet_indices:
x = DePool2D(L[0],
size=L[0].pool_size,
input_shape=encoder.output_shape[1:],
name='DePool5')(x)
else:
x = UpSampling2D(size=L[0].pool_size,
input_shape=encoder.output_shape[1:],
name='UpSampling5')(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[1].filters,
L[1].kernel_size,
padding=L[1].padding,
kernel_initializer=self.weights_init,
name='block5_deconv3')(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[2].filters,
L[2].kernel_size,
padding=L[2].padding,
kernel_initializer=self.weights_init,
name='block5_deconv5')(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[3].filters,
L[3].kernel_size,
padding=L[3].padding,
kernel_initializer=self.weights_init,
name='block5_deconv1')(x)))
x = Dropout(0.2)(x)
# Block 4
if self.dsegnet_indices:
x = DePool2D(L[4], size=L[4].pool_size, name='DePool4')(x)
else:
x = UpSampling2D(size=L[4].pool_size, name='UpSampling4')(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[5].filters,
L[5].kernel_size,
padding=L[5].padding,
kernel_initializer=self.weights_init,
name='block4_deconv3')(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[6].filters,
L[6].kernel_size,
padding=L[6].padding,
kernel_initializer=self.weights_init,
name='block4_deconv2')(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[7].filters,
L[7].kernel_size,
padding=L[7].padding,
kernel_initializer=self.weights_init,
name='block4_deconv1')(x)))
x = Dropout(0.3)(x)
# Block 3
if self.dsegnet_indices:
x = DePool2D(L[8], size=L[8].pool_size, name='DePool3')(x)
else:
x = UpSampling2D(size=L[8].pool_size, name='UpSampling3')(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[10].filters,
L[10].kernel_size,
padding=L[10].padding,
kernel_initializer=self.weights_init,
name='block3_deconv2')(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[11].filters,
L[11].kernel_size,
padding=L[11].padding,
kernel_initializer=self.weights_init,
name='block3_deconv1')(x)))
x = Dropout(0.3)(x)
# Block 2
if self.dsegnet_indices:
x = DePool2D(L[12], size=L[12].pool_size, name='DePool2')(x)
else:
x = UpSampling2D(size=L[12].pool_size, name='UpSampling2')(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[13].filters,
L[13].kernel_size,
padding=L[13].padding,
kernel_initializer=self.weights_init,
name='block2_deconv2')(x)))
# Next layer drops a filters to make sure we have a power of two filters after concatenation
x = Activation('relu')(BatchNormalization()(Conv2D(
L[14].filters - 1,
L[14].kernel_size,
padding=L[14].padding,
kernel_initializer=self.weights_init,
name='block2_deconv1')(x)))
# Block 1
if self.dsegnet_indices:
x = DePool2D(L[15], size=(L[15].pool_size), name='DePool1')(x)
else:
x = UpSampling2D(size=L[15].pool_size, name='UpSampling1')(x)
# Plugging in the depth
x = Concatenate()([x, concat_depth_tensor])
x = Activation('relu')(BatchNormalization()(Conv2D(
L[16].filters,
L[16].kernel_size,
padding=L[16].padding,
kernel_initializer=self.weights_init,
name='block1_deconv2')(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[17].filters,
L[17].kernel_size,
padding=L[17].padding,
kernel_initializer=self.weights_init,
name='block1_deconv1')(x)))
x = Conv2D(self.num_classes, (1, 1),
padding='valid',
kernel_initializer=self.weights_init,
name='block1_deconv_classes' + str(self.num_classes))(x)
x = Cropping2D(cropping=(vpad // 2, hpad // 2))(x)
x = Activation('softmax')(x)
predictions = x
segnet = Model(inputs=[encoder.inputs[0], depth_tensor],
outputs=predictions) # type: tModel
if self.pre_trained_weights is not None:
if os.path.exists(self.pre_trained_weights):
segnet.load_weights(self.pre_trained_weights,
by_name=self.load_weights_by_name)
else:
raise AssertionError(
'Not able to load weights. File does not exist')
return segnet
POOLING = 'avg'
x_train = np.zeros((len(labels), INPUT_SIZE, INPUT_SIZE, 3), dtype='float32')
for i, img_id in tqdm(enumerate(labels['id'])):
img = read_img(img_id, 'train', (INPUT_SIZE, INPUT_SIZE))
x = preprocess_input(np.expand_dims(img.copy(), axis=0))
x_train[i] = x
print('Train Images shape: {} size: {:,}'.format(x_train.shape, x_train.size))
# In[ ]:
Xtr = x_train[train_idx]
Xv = x_train[valid_idx]
print((Xtr.shape, Xv.shape, ytr.shape, yv.shape))
vgg_bottleneck = VGG16(weights='imagenet', include_top=False, pooling=POOLING)
train_vgg_bf = vgg_bottleneck.predict(Xtr, batch_size=32, verbose=1)
valid_vgg_bf = vgg_bottleneck.predict(Xv, batch_size=32, verbose=1)
print('VGG train bottleneck features shape: {} size: {:,}'.format(train_vgg_bf.shape, train_vgg_bf.size))
print('VGG valid bottleneck features shape: {} size: {:,}'.format(valid_vgg_bf.shape, valid_vgg_bf.size))
# # LogReg on VGG bottleneck features
# In[ ]:
logreg = LogisticRegression(multi_class='multinomial', solver='lbfgs', random_state=SEED)
logreg.fit(train_vgg_bf, (ytr * range(NUM_CLASSES)).sum(axis=1))
valid_probs = logreg.predict_proba(valid_vgg_bf)
valid_preds = logreg.predict(valid_vgg_bf)
nb_train_samples, img_rows, img_cols = x_train.shape
nb_val_samples = x_val.shape[0]
train_batchsize = 10
val_batchsize = 5
tst_batchsize = 5
epochs = 10
lr = 1e-4
image_size = 224
target_angles = [0, 180, 270, 90]
# Load the VGG model
vgg_conv = VGG16(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
# Freeze n number of layers from the last
for layer in vgg_conv.layers[:]:
layer.trainable = False
# Check the trainable status of the individual layers
for layer in vgg_conv.layers:
print(layer, layer.trainable)
# Create a sequential model
model = createModel()
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.RMSprop(lr=lr),
metrics=['acc'])
def __init__(self):
base_model = VGG16(weights='imagenet')
self.model = Model(inputs=base_model.input, outputs=base_model.get_layer('fc1').output) #FC1 as the output feature
self.graph = tf.get_default_graph()
y_true_cont = true_labels[:, 1]
reduced_pred = tf.reduce_sum(
predicted_labels * idx_tensor,
1) * 3 - 99 # reducing 1st axis of predicted labels
mse_loss = tf.keras.losses.mean_squared_error(y_true_cont, reduced_pred)
angle_loss = cls_loss + alpha * mse_loss
return angle_loss
inputs = Input(shape=(INPUT_SIZE, INPUT_SIZE, 3))
# # VGG16 backbone
net = VGG16(weights=None, include_top=False)
feature = net(inputs)
# feature = Conv2D(filters=64, kernel_size=(11, 11), strides=4, padding='same', activation=tf.nn.relu)(inputs)
# feature = MaxPool2D(pool_size=(3, 3), strides=2)(feature)
# feature = Conv2D(filters=192, kernel_size=(5, 5), padding='same', activation=tf.nn.relu)(feature)
# feature = MaxPool2D(pool_size=(3, 3), strides=2)(feature)
# feature = Conv2D(filters=384, kernel_size=(3, 3), padding='same', activation=tf.nn.relu)(feature)
# feature = Conv2D(filters=256, kernel_size=(3, 3), padding='same', activation=tf.nn.relu)(feature)
# feature = Conv2D(filters=256, kernel_size=(3, 3), padding='same', activation=tf.nn.relu)(feature)
# feature = MaxPool2D(pool_size=(3, 3), strides=2)(feature)
feature = Flatten()(feature)
feature = Dropout(0.5)(feature)
feature = Dense(units=4096, activation=tf.nn.relu)(feature)
# Output layers for pitch, roll and yaw
train_img = preprocess_input(np.array(train_img))
# applying the same procedure with the valid dataset
valid_img = []
valid_y = []
for i in range(len(valid)):
temp_img = image.load_img(valid_path + valid['filename'][i],
target_size=(224, 224))
temp_img = image.img_to_array(temp_img)
valid_img.append(temp_img)
valid_y.append(0 if 'negative' in valid['filename'][i] else 1)
valid_img = preprocess_input(np.array(valid_img))
# loading VGG16 model weights
model = VGG16(weights='imagenet', include_top=False)
# Extracting features from the train dataset using the VGG16 pre-trained model
features_train = model.predict(train_img)
# Extracting features from the train dataset using the VGG16 pre-trained model
features_valid = model.predict(valid_img)
train_x = features_train.reshape((len(train), 7 * 7 * 512))
train_y = np.asarray(train_y)
valid_x = features_valid.reshape((len(valid), 7 * 7 * 512))
valid_y = np.asarray(valid_y)
X_train, X_valid, Y_train, Y_valid = train_x, valid_x, train_y, valid_y
'''
Created on Jul 16, 2018
@author: User
'''
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16
import numpy as np
model = VGG16(include_top=False, weights='imagenet')
batch_size = 16
img_width, img_height = 150, 150
train_size = 19984
validation_size = 4992
test_size = 12500
train_data_dir = '../data/train/'
validation_data_dir = '../data/validation/'
test_data_dir = '../data/test/'
def extract_features():
datagen = ImageDataGenerator(rescale=1. / 255)
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, train_size // batch_size)
plt.plot(epochs, train_acc, 'g', label='Training accuracy')
plt.plot(epochs, test_acc, 'r', label='Test accuracy')
plt.plot(epochs, valid_acc, 'b', label='valid accuracy')
plt.title('Training, Validation and Test accuracy')
plt.xlabel('Epochs')
plt.title('Training, Validation and Test accuracy')
plt.ylabel('Loss')
plt.xlabel('Epochs')
plt.legend()
plt.show()
# cannot easily visualize filters lower down
from keras.applications.vgg16 import VGG16
from matplotlib import pyplot
# load the model
model = VGG16()
filters, biases = model.layers[4].get_weights()
# normalize filter values to 0-1 so we can visualize them
f_min, f_max = filters.min(), filters.max()
filters = (filters - f_min) / (f_max - f_min)
# plot first few filters
n_filters, ix = 8, 1
for i in range(n_filters):
# get the filter
f = filters[:, :, :, i]
# plot each channel separately
for j in range(1):
# specify subplot and turn of axis
ax = pyplot.subplot(n_filters, 4, ix)
ax.set_xticks([])
ax.set_yticks([])
def InitialiazeModel(head_only,weights,model_name,lr):
if model_name == 'VGG19':
from keras.applications.vgg19 import VGG19
base_model = VGG19(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'VGG16':
from keras.applications.vgg16 import VGG16
base_model = VGG16(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'MobileNet':
from keras.applications.mobilenet import MobileNet
base_model = MobileNet(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'ResNet50':
from keras.applications.resnet50 import ResNet50
base_model = ResNet50(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'Xception':
from keras.applications.xception import Xception
base_model = Xception(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'InceptionV3':
from keras.applications.inception_v3 import InceptionV3
base_model = InceptionV3(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'InceptionResNetV2':
from keras.applications.inception_resnet_v2 import InceptionResNetV2
base_model = InceptionResNetV2(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'NASNetLarge':
from keras.applications.nasnet import NASNetLarge
base_model = NASNetLarge(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
elif model_name == 'NASNetMobile':
from keras.applications.nasnet import NASNetMobile
base_model = NASNetMobile(include_top=False, weights='imagenet',
input_shape=(PICS_WIDTH, PICS_HEIGHT, 3), pooling = 'avg')
else:
raise ValueError('Network name is undefined')
if head_only:
for lay in base_model.layers:
lay.trainable = False
#manipulated = Input(shape=(1,))
x = base_model.output
#x = concatenate([x, manipulated])
x = Dense(NUM_CATEGS, activation='softmax', name='predictions')(x)
#model = Model([base_model.input,manipulated], x)
model = Model(base_model.input, x)
#print(model.summary())
if weights != '':
model.load_weights(weights)
MODEL_OPTIMIZER = optimizers.SGD(lr=lr, momentum=0.9, nesterov=True)
model.compile(loss=MODEL_LOSS, optimizer=MODEL_OPTIMIZER, metrics=[MODEL_METRIC])
return model
import numpy as np
import pandas as pd
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.vgg16 import preprocess_input
from keras.applications.vgg16 import decode_predictions
from keras.applications.vgg16 import VGG16
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
HEADERS = "author_id, tench, goldfish, great_white_shark, tiger_shark, hammerhead, electric_ray, stingray, c**k, hen, ostrich, brambling, goldfinch, house_finch, junco, indigo_bunting, robin, bulbul, jay, magpie, chickadee, water_ouzel, kite, bald_eagle, vulture, great_grey_owl, European_fire_salamander, common_newt, eft, spotted_salamander, axolotl, bullfrog, tree_frog, tailed_frog, loggerhead, leatherback_turtle, mud_turtle, terrapin, box_turtle, banded_gecko, common_iguana, American_chameleon, whiptail, agama, frilled_lizard, alligator_lizard, Gila_monster, green_lizard, African_chameleon, Komodo_dragon, African_crocodile, American_alligator, triceratops, thunder_snake, ringneck_snake, hognose_snake, green_snake, king_snake, garter_snake, water_snake, vine_snake, night_snake, boa_constrictor, rock_python, Indian_cobra, green_mamba, sea_snake, horned_viper, diamondback, sidewinder, trilobite, harvestman, scorpion, black_and_gold_garden_spider, barn_spider, garden_spider, black_widow, tarantula, wolf_spider, tick, centipede, black_grouse, ptarmigan, ruffed_grouse, prairie_chicken, peacock, quail, partridge, African_grey, macaw, sulphur-crested_cockatoo, lorikeet, coucal, bee_eater, hornbill, hummingbird, jacamar, toucan, drake, red-breasted_merganser, goose, black_swan, tusker, echidna, platypus, wallaby, koala, wombat, jellyfish, sea_anemone, brain_coral, flatworm, nematode, conch, snail, slug, sea_slug, chiton, chambered_nautilus, Dungeness_crab, rock_crab, fiddler_crab, king_crab, American_lobster, spiny_lobster, crayfish, hermit_crab, isopod, white_stork, black_stork, spoonbill, flamingo, little_blue_heron, American_egret, bittern, crane, limpkin, European_gallinule, American_coot, bustard, ruddy_turnstone, red-backed_sandpiper, redshank, dowitcher, oystercatcher, pelican, king_penguin, albatross, grey_whale, killer_whale, dugong, sea_lion, Chihuahua, Japanese_spaniel, Maltese_dog, Pekinese, Shih-Tzu, Blenheim_spaniel, papillon, toy_terrier, Rhodesian_ridgeback, Afghan_hound, basset, beagle, bloodhound, bluetick, black-and-tan_coonhound, Walker_hound, English_foxhound, redbone, borzoi, Irish_wolfhound, Italian_greyhound, whippet, Ibizan_hound, Norwegian_elkhound, otterhound, Saluki, Scottish_deerhound, Weimaraner, Staffordshire_bullterrier, American_Staffordshire_terrier, Bedlington_terrier, Border_terrier, Kerry_blue_terrier, Irish_terrier, Norfolk_terrier, Norwich_terrier, Yorkshire_terrier, wire-haired_fox_terrier, Lakeland_terrier, Sealyham_terrier, Airedale, cairn, Australian_terrier, Dandie_Dinmont, Boston_bull, miniature_schnauzer, giant_schnauzer, standard_schnauzer, Scotch_terrier, Tibetan_terrier, silky_terrier, soft-coated_wheaten_terrier, West_Highland_white_terrier, Lhasa, flat-coated_retriever, curly-coated_retriever, golden_retriever, Labrador_retriever, Chesapeake_Bay_retriever, German_short-haired_pointer, vizsla, English_setter, Irish_setter, Gordon_setter, Brittany_spaniel, clumber, English_springer, Welsh_springer_spaniel, cocker_spaniel, Sussex_spaniel, Irish_water_spaniel, kuvasz, schipperke, groenendael, malinois, briard, kelpie, komondor, Old_English_sheepdog, Shetland_sheepdog, collie, Border_collie, Bouvier_des_Flandres, Rottweiler, German_shepherd, Doberman, miniature_pinscher, Greater_Swiss_Mountain_dog, Bernese_mountain_dog, Appenzeller, EntleBucher, boxer, bull_mastiff, Tibetan_mastiff, French_bulldog, Great_Dane, Saint_Bernard, Eskimo_dog, malamute, Siberian_husky, dalmatian, affenpinscher, basenji, pug, Leonberg, Newfoundland, Great_Pyrenees, Samoyed, Pomeranian, chow, keeshond, Brabancon_griffon, Pembroke, Cardigan, toy_poodle, miniature_poodle, standard_poodle, Mexican_hairless, timber_wolf, white_wolf, red_wolf, coyote, dingo, dhole, African_hunting_dog, hyena, red_fox, kit_fox, Arctic_fox, grey_fox, tabby, tiger_cat, Persian_cat, Siamese_cat, Egyptian_cat, cougar, lynx, leopard, snow_leopard, jaguar, lion, tiger, cheetah, brown_bear, American_black_bear, ice_bear, sloth_bear, mongoose, meerkat, tiger_beetle, ladybug, ground_beetle, long-horned_beetle, leaf_beetle, dung_beetle, rhinoceros_beetle, weevil, fly, bee, ant, grasshopper, cricket, walking_stick, cockroach, mantis, cicada, leafhopper, lacewing, dragonfly, damselfly, admiral, ringlet, monarch, cabbage_butterfly, sulphur_butterfly, lycaenid, starfish, sea_urchin, sea_cucumber, wood_rabbit, hare, Angora, hamster, porcupine, fox_squirrel, marmot, beaver, guinea_pig, sorrel, zebra, hog, wild_boar, warthog, hippopotamus, ox, water_buffalo, bison, ram, bighorn, ibex, hartebeest, impala, gazelle, Arabian_camel, llama, weasel, mink, polecat, black-footed_ferret, otter, skunk, badger, armadillo, three-toed_sloth, orangutan, gorilla, chimpanzee, gibbon, siamang, guenon, patas, baboon, macaque, langur, colobus, proboscis_monkey, marmoset, capuchin, howler_monkey, titi, spider_monkey, squirrel_monkey, Madagascar_cat, indri, Indian_elephant, African_elephant, lesser_panda, giant_panda, barracouta, eel, coho, rock_beauty, anemone_fish, sturgeon, gar, lionfish, puffer, abacus, abaya, academic_gown, accordion, acoustic_guitar, aircraft_carrier, airliner, airship, altar, ambulance, amphibian, analog_clock, apiary, apron, ashcan, assault_rifle, backpack, bakery, balance_beam, balloon, ballpoint, Band_Aid, banjo, bannister, barbell, barber_chair, barbershop, barn, barometer, barrel, barrow, baseball, basketball, bassinet, bassoon, bathing_cap, bath_towel, bathtub, beach_wagon, beacon, beaker, bearskin, beer_bottle, beer_glass, bell_cote, bib, bicycle-built-for-two, bikini, binder, binoculars, birdhouse, boathouse, bobsled, bolo_tie, bonnet, bookcase, bookshop, bottlecap, bow, bow_tie, brass, brassiere, breakwater, breastplate, broom, bucket, buckle, bulletproof_vest, bullet_train, butcher_shop, cab, caldron, candle, cannon, canoe, can_opener, cardigan, car_mirror, carousel, carpenter's_kit, carton, car_wheel, cash_machine, cassette, cassette_player, castle, catamaran, CD_player, cello, cellular_telephone, chain, chainlink_fence, chain_mail, chain_saw, chest, chiffonier, chime, china_cabinet, Christmas_stocking, church, cinema, cleaver, cliff_dwelling, cloak, clog, cocktail_shaker, coffee_mug, coffeepot, coil, combination_lock, computer_keyboard, confectionery, container_ship, convertible, corkscrew, cornet, cowboy_boot, cowboy_hat, cradle, crane, crash_helmet, crate, crib, Crock_Pot, croquet_ball, crutch, cuirass, dam, desk, desktop_computer, dial_telephone, diaper, digital_clock, digital_watch, dining_table, dishrag, dishwasher, disk_brake, dock, dogsled, dome, doormat, drilling_platform, drum, drumstick, dumbbell, Dutch_oven, electric_fan, electric_guitar, electric_locomotive, entertainment_center, envelope, espresso_maker, face_powder, feather_boa, file, fireboat, fire_engine, fire_screen, flagpole, flute, folding_chair, football_helmet, forklift, fountain, fountain_pen, four-poster, freight_car, French_horn, frying_pan, fur_coat, garbage_truck, gasmask, gas_pump, goblet, go-kart, golf_ball, golfcart, gondola, gong, gown, grand_piano, greenhouse, grille, grocery_store, guillotine, hair_slide, hair_spray, half_track, hammer, hamper, hand_blower, hand-held_computer, handkerchief, hard_disc, harmonica, harp, harvester, hatchet, holster, home_theater, honeycomb, hook, hoopskirt, horizontal_bar, horse_cart, hourglass, iPod, iron, jack-o'-lantern, jean, jeep, jersey, jigsaw_puzzle, jinrikisha, joystick, kimono, knee_pad, knot, lab_coat, ladle, lampshade, laptop, lawn_mower, lens_cap, letter_opener, library, lifeboat, lighter, limousine, liner, lipstick, Loafer, lotion, loudspeaker, loupe, lumbermill, magnetic_compass, mailbag, mailbox, maillot, maillot, manhole_cover, maraca, marimba, mask, matchstick, maypole, maze, measuring_cup, medicine_chest, megalith, microphone, microwave, military_uniform, milk_can, minibus, miniskirt, minivan, missile, mitten, mixing_bowl, mobile_home, Model_T, modem, monastery, monitor, moped, mortar, mortarboard, mosque, mosquito_net, motor_scooter, mountain_bike, mountain_tent, mouse, mousetrap, moving_van, muzzle, nail, neck_brace, necklace, nipple, notebook, obelisk, oboe, ocarina, odometer, oil_filter, organ, oscilloscope, overskirt, oxcart, oxygen_mask, packet, paddle, paddlewheel, padlock, paintbrush, pajama, palace, panpipe, paper_towel, parachute, parallel_bars, park_bench, parking_meter, passenger_car, patio, pay-phone, pedestal, pencil_box, pencil_sharpener, perfume, Petri_dish, photocopier, pick, pickelhaube, picket_fence, pickup, pier, piggy_bank, pill_bottle, pillow, ping-pong_ball, pinwheel, pirate, pitcher, plane, planetarium, plastic_bag, plate_rack, plow, plunger, Polaroid_camera, pole, police_van, poncho, pool_table, pop_bottle, pot, potter's_wheel, power_drill, prayer_rug, printer, prison, projectile, projector, puck, punching_bag, purse, quill, quilt, racer, racket, radiator, radio, radio_telescope, rain_barrel, recreational_vehicle, reel, reflex_camera, refrigerator, remote_control, restaurant, revolver, rifle, rocking_chair, rotisserie, rubber_eraser, rugby_ball, rule, running_shoe, safe, safety_pin, saltshaker, sandal, sarong, sax, scabbard, scale, school_bus, schooner, scoreboard, screen, screw, screwdriver, seat_belt, sewing_machine, shield, shoe_shop, shoji, shopping_basket, shopping_cart, shovel, shower_cap, shower_curtain, ski, ski_mask, sleeping_bag, slide_rule, sliding_door, slot, snorkel, snowmobile, snowplow, soap_dispenser, soccer_ball, sock, solar_dish, sombrero, soup_bowl, space_bar, space_heater, space_shuttle, spatula, speedboat, spider_web, spindle, sports_car, spotlight, stage, steam_locomotive, steel_arch_bridge, steel_drum, stethoscope, stole, stone_wall, stopwatch, stove, strainer, streetcar, stretcher, studio_couch, stupa, submarine, suit, sundial, sunglass, sunglasses, sunscreen, suspension_bridge, swab, sweatshirt, swimming_trunks, swing, switch, syringe, table_lamp, tank, tape_player, teapot, teddy, television, tennis_ball, thatch, theater_curtain, thimble, thresher, throne, tile_roof, toaster, tobacco_shop, toilet_seat, torch, totem_pole, tow_truck, toyshop, tractor, trailer_truck, tray, trench_coat, tricycle, trimaran, tripod, triumphal_arch, trolleybus, trombone, tub, turnstile, typewriter_keyboard, umbrella, unicycle, upright, vacuum, vase, vault, velvet, vending_machine, vestment, viaduct, violin, volleyball, waffle_iron, wall_clock, wallet, wardrobe, warplane, washbasin, washer, water_bottle, water_jug, water_tower, whiskey_jug, whistle, wig, window_screen, window_shade, Windsor_tie, wine_bottle, wing, wok, wooden_spoon, wool, worm_fence, wreck, yawl, yurt, web_site, comic_book, crossword_puzzle, street_sign, traffic_light, book_jacket, menu, plate, guacamole, consomme, hot_pot, trifle, ice_cream, ice_lolly, French_loaf, bagel, pretzel, cheeseburger, hotdog, mashed_potato, head_cabbage, broccoli, cauliflower, zucchini, spaghetti_squash, acorn_squash, butternut_squash, cucumber, artichoke, bell_pepper, cardoon, mushroom, Granny_Smith, strawberry, orange, lemon, fig, pineapple, banana, jackfruit, custard_apple, pomegranate, hay, carbonara, chocolate_sauce, dough, meat_loaf, pizza, potpie, burrito, red_wine, espresso, cup, eggnog, alp, bubble, cliff, coral_reef, geyser, lakeside, promontory, sandbar, seashore, valley, volcano, ballplayer, groom, scuba_diver, rapeseed, daisy, yellow_lady's_slipper, corn, acorn, hip, buckeye, coral_fungus, agaric, gyromitra, stinkhorn, earthstar, hen-of-the-woods, bolete, ear, toilet_tissue, class\n"
# HEADERS = "author_id,"
# HEADERS += ", ".join([str(i) for i in range( 7 * 7 * 512)])
# HEADERS += ",class\n"
# MODEL = VGG16(weights='imagenet', include_top=False)
MODEL = VGG16(weights='imagenet')
BASE_DIR_PHOTOS = sys.argv[1]
OUTPUT_FILE = open('/media/ivan/DDE/datasets_proyecto_mt/notop/en_test_2.csv', "w")
OUTPUT_FILE.write(HEADERS)
LABELS_FILE = sys.argv[2]
IDX = 0
with open(LABELS_FILE) as json_file:
GENDER_LABELS = json.load(json_file)
def get_list_of_labels(image_path, include_top=True):
try:
image = load_img(image_path, target_size=(224, 224))
except Exception as e:
print(e)
return
def get_vgg_7conv(input_shape):
img_input = Input(input_shape)
vgg16_base = VGG16(input_tensor=img_input, include_top=False)
for l in vgg16_base.layers:
l.trainable = True
conv1 = vgg16_base.get_layer("block1_conv2").output
conv2 = vgg16_base.get_layer("block2_conv2").output
conv3 = vgg16_base.get_layer("block3_conv3").output
pool3 = vgg16_base.get_layer("block3_pool").output
conv4 = Conv2D(384, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block4_conv1")(pool3)
conv4 = Conv2D(384, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block4_conv2")(conv4)
pool4 = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(conv4)
conv5 = Conv2D(512, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block5_conv1")(pool4)
conv5 = Conv2D(512, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block5_conv2")(conv5)
pool5 = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(conv5)
conv6 = Conv2D(512, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block6_conv1")(pool5)
conv6 = Conv2D(512, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block6_conv2")(conv6)
pool6 = MaxPooling2D((2, 2), strides=(2, 2), name='block6_pool')(conv6)
conv7 = Conv2D(512, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block7_conv1")(pool6)
conv7 = Conv2D(512, (3, 3),
activation="relu",
padding='same',
kernel_initializer="he_normal",
name="block7_conv2")(conv7)
up8 = concatenate([
Conv2DTranspose(384, (3, 3),
activation="relu",
kernel_initializer="he_normal",
strides=(2, 2),
padding='same')(conv7), conv6
],
axis=3)
conv8 = Conv2D(384, (3, 3),
activation="relu",
kernel_initializer="he_normal",
padding='same')(up8)
up9 = concatenate([
Conv2DTranspose(256, (3, 3),
activation="relu",
kernel_initializer="he_normal",
strides=(2, 2),
padding='same')(conv8), conv5
],
axis=3)
conv9 = Conv2D(256, (3, 3),
activation="relu",
kernel_initializer="he_normal",
padding='same')(up9)
up10 = concatenate([
Conv2DTranspose(192, (3, 3),
activation="relu",
kernel_initializer="he_normal",
strides=(2, 2),
padding='same')(conv9), conv4
],
axis=3)
conv10 = Conv2D(192, (3, 3),
activation="relu",
kernel_initializer="he_normal",
padding='same')(up10)
up11 = concatenate([
Conv2DTranspose(128, (3, 3),
activation="relu",
kernel_initializer="he_normal",
strides=(2, 2),
padding='same')(conv10), conv3
],
axis=3)
conv11 = Conv2D(128, (3, 3),
activation="relu",
kernel_initializer="he_normal",
padding='same')(up11)
up12 = concatenate([
Conv2DTranspose(64, (3, 3),
activation="relu",
kernel_initializer="he_normal",
strides=(2, 2),
padding='same')(conv11), conv2
],
axis=3)
conv12 = Conv2D(64, (3, 3),
activation="relu",
kernel_initializer="he_normal",
padding='same')(up12)
up13 = concatenate([
Conv2DTranspose(32, (3, 3),
activation="relu",
kernel_initializer="he_normal",
strides=(2, 2),
padding='same')(conv12), conv1
],
axis=3)
conv13 = Conv2D(32, (3, 3),
activation="relu",
kernel_initializer="he_normal",
padding='same')(up13)
conv13 = Conv2D(1, (1, 1))(conv13)
conv13 = Activation("sigmoid")(conv13)
model = Model(img_input, conv13)
return model
from tensorflow.contrib import keras
from keras.applications.vgg16 import VGG16
import keras.preprocessing
from keras.applications.vgg16 import preprocess_input
from keras.models import Model
import numpy as np
import os
def features(img_path):
img = keras.preprocessing.image.load_img(img_path, target_size=(224, 224))
x = keras.preprocessing.image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
fc2_features = model.predict(x)
return fc2_features
if __name__ == "__main__":
directory = './data/test_images/'
base_model = VGG16(weights='imagenet')
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc2').output)
files = os.listdir(directory)
img_output = np.zeros((1, 4096))
for i in files:
img_output = np.vstack((img_output, features(directory + i)))
np.save('./data/test_features', img_output[1:])
#Create training dataset to feed into the training model
train_datagen = training_augmentation.flow_from_directory(
training_dataset,
target_size=(x_ray_width, x_ray_height),
batch_size=27,
class_mode="categorical")
#Create testing dataset to feed into the training model
test_datagen = testing_augmentation.flow_from_directory(
testing_dataset,
target_size=(x_ray_width, x_ray_height),
batch_size=27,
class_mode="categorical")
#Initialize VGG16 model
vgg_network = VGG16(input_shape=(x_ray_width, x_ray_height, 3),
weights="imagenet",
include_top=True)
vgg_network.summary()
#To not retrain the pre-trained layers
for layers in (vgg_network.layers)[:19]:
print(layers)
layers.trainable = False
#Customized last layers
X = vgg_network.layers[-2].output
prediction = Dense(len(training_folders), activation="softmax")(X)
#Declare an object model
vgg_network_final = Model(inputs=vgg_network.input, outputs=prediction)
y_test = keras.utils.to_categorical(y_test, num_classes)
if args.resume:
print('resume from checkpoint')
message = job_name + ' b_end'
send_signal.send(args.node, 10002, message)
model = keras.models.load_model(save_file)
message = job_name + ' c_end'
send_signal.send(args.node, 10002, message)
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(
def __init__(self):
vgg_model = VGG16(weights='imagenet', include_top=True)
self.model = Model(input=vgg_model.input,
output=vgg_model.get_layer('fc2').output)
