x = small_basic_block(nr_filters=128)(x)
x = Reshape(
(x.shape[1], x.shape[2], x.shape[3],
1))(x) #add temporary dim to reduce nr of filters(dim before the added)
#don't know why (3,3,1) but it does some necessary dim reduction
x = MaxPooling3D(padding='valid', pool_size=(3, 3, 1),
strides=(2, 1, 2))(x) #we should reduce 128 to 64,div by 2
x = Reshape((x.shape[1], x.shape[2], x.shape[3]))(x) #delete added dim
x = small_basic_block(nr_filters=256)(x)
x = small_basic_block(nr_filters=256)(x)
x = Reshape(
(x.shape[1], x.shape[2], x.shape[3], 1))(x) #same procedure as before
x = MaxPooling3D(padding='valid', pool_size=(3, 3, 1),
strides=(2, 1, 4))(x) #now reduce 256 to 64, div by 4
x = Reshape((x.shape[1], x.shape[2], x.shape[3]))(x)
x = Dropout(rate=0.5)(x)
x = Conv2D(filters=256, kernel_size=(4, 1), kernel_initializer=hu,
strides=1)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Dropout(rate=0.5)(x)
x = Conv2D(filters=class_number,
kernel_size=(1, 13),
kernel_initializer=hu,
strides=1)(x)
y_pred = BatchNormalization()(x)
y_pred = Activation('relu')(y_pred)
y_pred = Reshape((y_pred.shape[2], y_pred.shape[3]))(y_pred)
dim_of_samples = y_pred.shape[1].value
vgg_model.trainable = True
set_trainable = False
for layer in vgg_model.layers:
if layer.name in ['block5_conv1', 'block4_conv1']:
set_trainable = True
if set_trainable:
layer.trainable = True
else:
layer.trainable = False
print("Model architecture")
model = Sequential()
model.add(vgg_model)
model.add(Dense(512, activation='relu', input_dim=input_shape))
model.add(Dropout(0.3))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer=optimizers.RMSprop(lr=1e-5),
metrics=['accuracy'])
datagen = ImageDataGenerator(
rotation_range=25,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.3,
def Network():
branch_one_dense_outputs = []
branch_two_dense_outputs = []
### Head-1:
input1 = Input(shape=X2[0].shape)
x = Conv1D(filters=25,
kernel_size=3,
padding='same',
activation='relu',
kernel_regularizer=l2(l=0.03))(input1)
temp_B = Dropout(rate=0.25)(x)
x = Dropout(rate=0.65)(x)
temp_A = x
#Type A feature connection
dense_output_from_branch_one_filters_combined_one = Dense(
units=20, activation=tf.nn.relu)(Flatten()(temp_A))
#Type B feature connection
#temp = MaxPooling1D(pool_size=2,strides=2)(temp)
for filter_index in range(temp_B.shape[-1]):
i = 0
branch_one_dense_outputs.append(
Dense(units=2, activation=tf.nn.relu)(temp_B[:, :, filter_index]))
x = Conv1D(filters=50,
kernel_size=3,
padding='same',
activation='relu',
kernel_regularizer=l2(l=0.03))(x)
temp_B = Dropout(rate=0.25)(x)
x = Dropout(rate=0.65)(x)
temp_A = x
#Type A feature connection
dense_output_from_branch_one_filters_combined_two = Dense(
units=20, activation=tf.nn.relu)(Flatten()(temp_A))
#Type B feature connection
#temp = MaxPooling1D(pool_size=2,strides=2)(temp)
for filter_index in range(temp_B.shape[-1]):
branch_one_dense_outputs.append(
Dense(units=2, activation=tf.nn.relu)(temp_B[:, :, filter_index]))
### Head-2:
input2 = Input(shape=X4[0].shape)
x = Conv1D(filters=25,
kernel_size=3,
padding='same',
activation='relu',
kernel_regularizer=l2(l=0.03))(input2)
temp_B = Dropout(rate=0.25)(x)
x = Dropout(rate=0.65)(x)
temp_A = x
#Type A feature connection
dense_output_from_branch_two_filters_combined_one = Dense(
units=20, activation=tf.nn.relu)(Flatten()(temp_A))
#Type B feature connection
#temp = MaxPooling1D(pool_size=2,strides=2)(temp)
for filter_index in range(temp_B.shape[-1]):
i = 0
branch_two_dense_outputs.append(
Dense(units=2, activation=tf.nn.relu)(temp_B[:, :, filter_index]))
x = Conv1D(filters=50,
kernel_size=3,
padding='same',
activation='relu',
kernel_regularizer=l2(l=0.03))(x)
temp_B = Dropout(rate=0.25)(x)
x = Dropout(rate=0.65)(x)
temp_A = x
#Type A feature connection
dense_output_from_branch_two_filters_combined_two = Dense(
units=20, activation=tf.nn.relu)(Flatten()(temp_A))
#Type B feature connection
#temp = MaxPooling1D(pool_size=2,strides=2)(temp)
for filter_index in range(temp_B.shape[-1]):
branch_two_dense_outputs.append(
Dense(units=2, activation=tf.nn.relu)(temp_B[:, :, filter_index]))
#Type B feature connection
branch_one_dense_outputs = Concatenate()(branch_one_dense_outputs)
# branch_one_dense_outputs = Dropout(rate=0.45)(branch_one_dense_outputs)
# branch_one_dense_outputs = Dense(units = 20, activation=tf.nn.relu)(branch_one_dense_outputs)
branch_two_dense_outputs = Concatenate()(branch_two_dense_outputs)
# branch_two_dense_outputs = Dropout(rate=0.45)(branch_two_dense_outputs)
# branch_two_dense_outputs = Dense(units = 20, activation=tf.nn.relu)(branch_two_dense_outputs)
merge = Concatenate()([branch_one_dense_outputs, branch_two_dense_outputs])
output = Dropout(rate=0.50)(merge)
output = Dense(units=1, activation='sigmoid')(output)
return Model(inputs=[input1, input2], outputs=output)
:param model_filepath: path to where model will be saved
"""
model.save_weights(weights_filepath)
model_json = model.to_json()
with open(model_filepath, "w") as json_file:
json_file.write(model_json)
# Using ResNet architecture initialized with ImageNet weights and default fully connected layer removed
base_model = ResNet50V2(include_top=False, weights='imagenet')
# Adding custom layers at the end of the network
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
x = Dropout(0.4)(x)
predictions = Dense(5, activation='softmax')(x) # star rating of 1 - 5
# Creating a trainable model
model = Model(inputs=base_model.input, outputs=predictions)
# Freezing the base_model's layers
# for layer in base_model.layers:
# layer.trainable = False
# Compiling the model
model.compile(optimizer=SGD(lr=0.0001, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy'])
# Return the training and testing data and labels from get_data
def generate_resnet_model(classes_len: int):
"""
Function to create a VGG19 model pre-trained with custom FC Layers.
If the "advanced" command line argument is selected, adds an extra convolutional layer with extra filters to support
larger images.
:param classes_len: The number of classes (labels).
:return: The VGG19 model.
"""
# Reconfigure single channel input into a greyscale 3 channel input
img_input = Input(shape=(config.VGG_IMG_SIZE['HEIGHT'],
config.VGG_IMG_SIZE['WIDTH'], 1))
img_conc = Concatenate()([img_input, img_input, img_input])
# Generate a ResNet50 model with pre-trained ImageNet weights, input as given above, excluded fully connected layers.
model_base = ResNet50(include_top=False,
weights='imagenet',
input_tensor=img_conc)
# Add fully connected layers
model = Sequential()
# Start with base model consisting of convolutional layers
model.add(model_base)
# Flatten layer to convert each input into a 1D array (no parameters in this layer, just simple pre-processing).
model.add(Flatten())
# Possible dropout for regularisation can be added later and experimented with:
if config.DROPOUT != 0:
model.add(Dropout(config.DROPOUT, name='Dropout_Regularization_1'))
# Add fully connected hidden layers.
model.add(
Dense(units=512,
activation='relu',
kernel_initializer='random_uniform',
name='Dense_Intermediate_1'))
model.add(
Dense(units=32,
activation='relu',
kernel_initializer='random_uniform',
name='Dense_Intermediate_2'))
# Final output layer that uses softmax activation function (because the classes are exclusive).
if classes_len == 2:
model.add(
Dense(1,
activation='sigmoid',
kernel_initializer='random_uniform',
name='Output'))
else:
model.add(
Dense(classes_len,
kernel_initializer='random_uniform',
activation='softmax',
name='Output'))
# Print model details if running in debug mode.
if config.verbose_mode:
print(model.summary())
return model
X_test = X_test.reshape(list(X_test.shape) + [1])
#Converting the labels into one hot encoding
y_train = to_categorical(y_train, classes)
y_test = to_categorical(y_test, classes)
#Building the model
model = Sequential()
model.add(
Conv2D(filters=32,
kernel_size=(5, 5),
activation='relu',
input_shape=X_train.shape[1:]))
model.add(Conv2D(filters=32, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(rate=0.25))
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(rate=0.25))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(rate=0.5))
model.add(Dense(classes, activation='softmax'))
#Compilation of the model
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
epochs = 10
history = model.fit(X_train,
def __init__(self):
super(VGGNet, self).__init__()
self.c1 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', input_shape=(32, 32, 3))
self.b1 = BatchNormalization()
self.a1 = Activation('relu')
self.c2 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', input_shape=(32, 32, 3))
self.b2 = BatchNormalization()
self.a2 = Activation('relu')
self.p1 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
self.d1 = Dropout(0.05)
self.c3 = Conv2D(filters=128, kernel_size=(3, 3), strides=1, padding='same')
self.b3 = BatchNormalization()
self.a3 = Activation('relu')
self.c4 = Conv2D(filters=128, kernel_size=(3, 3), strides=1, padding='same')
self.b4 = BatchNormalization()
self.a4 = Activation('relu')
self.p2 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
self.d2 = Dropout(0.05)
self.c5 = Conv2D(filters=256, kernel_size=(3, 3), strides=1, padding='same')
self.b5 = BatchNormalization()
self.a5 = Activation('relu')
self.c6 = Conv2D(filters=256, kernel_size=(3, 3), strides=1, padding='same')
self.b6 = BatchNormalization()
self.a6 = Activation('relu')
self.c7 = Conv2D(filters=256, kernel_size=(3, 3), strides=1, padding='same')
self.b7 = BatchNormalization()
self.a7 = Activation('relu')
self.p3 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
self.d3 = Dropout(0.05)
self.c8 = Conv2D(filters=512, kernel_size=(3, 3), strides=1, padding='same')
self.b8 = BatchNormalization()
self.a8 = Activation('relu')
self.c9 = Conv2D(filters=512, kernel_size=(3, 3), strides=1, padding='same')
self.b9 = BatchNormalization()
self.a9 = Activation('relu')
self.c10 = Conv2D(filters=512, kernel_size=(3, 3), strides=1, padding='same')
self.b10 = BatchNormalization()
self.a10 = Activation('relu')
self.p4 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
self.d4 = Dropout(0.05)
self.c11 = Conv2D(filters=512, kernel_size=(3, 3), strides=1, padding='same')
self.b11 = BatchNormalization()
self.a11 = Activation('relu')
self.c12 = Conv2D(filters=512, kernel_size=(3, 3), strides=1, padding='same')
self.b12 = BatchNormalization()
self.a12 = Activation('relu')
self.c13 = Conv2D(filters=512, kernel_size=(3, 3), strides=1, padding='same')
self.b13 = BatchNormalization()
self.a13 = Activation('relu')
self.p5 = MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
self.d5 = Dropout(0.05)
self.flatten = Flatten()
self.f1 = Dense(4096, activation='relu')
self.d6 = Dropout(0.05)
self.f2 = Dense(4096, activation='relu')
self.d7 = Dropout(0.05)
self.f3 = Dense(10, activation='softmax')
def classifier_model():
#Prepare Training Data
vgg_face=loadModel()
x_train=[]
y_train=[]
person_folders=os.listdir('./Images_crop/')
person_rep=dict()
for i,person in enumerate(person_folders):
person_rep[i]=person
image_names=os.listdir('./Images_crop/'+person+'/')
for image_name in image_names:
img=load_img('./Images_crop/'+person+'/'+image_name,target_size=(224,224))
img=img_to_array(img)
img=np.expand_dims(img,axis=0)
img=preprocess_input(img)
img_encode=vgg_face(img)
x_train.append(np.squeeze(K.eval(img_encode)).tolist())
y_train.append(i)
x_train=np.array(x_train)
y_train=np.array(y_train)
np.save('train_data',x_train)
np.save('train_labels',y_train)
#Prepare Test Data
x_test=[]
y_test=[]
person_folders=os.listdir('./Test_Images_crop/')
for i,person in enumerate(person_folders):
image_names=os.listdir('./Test_Images_crop/'+person+'/')
for image_name in image_names:
img=load_img('./Test_Images_crop/'+person+'/'+image_name,target_size=(224,224))
img=img_to_array(img)
img=np.expand_dims(img,axis=0)
img=preprocess_input(img)
img_encode=vgg_face(img)
x_test.append(np.squeeze(K.eval(img_encode)).tolist())
y_test.append(i)
print(x_train)
print(y_train)
x_test=np.array(x_test)
y_test=np.array(y_test)
np.save('test_data',x_test)
np.save('test_labels',y_test)
# x_train=np.load('train_data.npy')
# y_train=np.load('train_labels.npy')
# Softmax regressor to classify images based on encoding
classifier_model=Sequential()
classifier_model.add(Dense(units=100,input_dim=x_train.shape[1],kernel_initializer='glorot_uniform'))
classifier_model.add(BatchNormalization())
classifier_model.add(Activation('tanh'))
classifier_model.add(Dropout(0.3))
classifier_model.add(Dense(units=10,kernel_initializer='glorot_uniform'))
classifier_model.add(BatchNormalization())
classifier_model.add(Activation('tanh'))
classifier_model.add(Dropout(0.2))
classifier_model.add(Dense(units=7,kernel_initializer='he_uniform'))
classifier_model.add(Activation('softmax'))
classifier_model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(),optimizer='nadam',metrics=['accuracy'])
classifier_model.fit(x_train,y_train,epochs=100,validation_data=(x_test,y_test))
tf.keras.models.save_model(classifier_model,'face_classifier_model.h5')
# classifier_model()
#include_top = false will remove the last layer because i have 2 categories only, not 1000 as imagenet
vgg = VGG16(input_shape=Image_size, weights='imagenet', include_top=False)
#vgg.summary()
#to prevent training existing weights
for layer in vgg.layers:
layer.trainable = False
#build the model
x = vgg.input
y = vgg.output # a vector with a size of 2 for each image (2 probabilities)
y = Flatten(name='flatten')(y)
#normaliza the input to the neural network to speed up training
y = BatchNormalization()(y)
y = Dense(1024, activation='relu', name='FC1')(y)
y = Dropout(0.5)(y)
y = Dense(64, name='FC2')(y)
#the default for leaky relu in keras is 0.3
y = LeakyReLU()(y)
y = Dropout(0.2)(y)
y = Dense(2, activation='softmax', name='prediction')(y)
model = Model(inputs=x, outputs=y)
#model.summary()
#plot_model(model, to_file='/home/marmia/snic2020-6-41/Mariam/Mariam_Thesis/Notebooks_Master/train1/model1.png')
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#save results to a csv
csv_logger = tf.keras.callbacks.CSVLogger('train_log.csv',
append=True,
min_lr=1e-8,
verbose=1)
# Lets define different architecture (brains) for each head :)
# Let each hydra think differently.
# You can play with configurations - i just randomly created 4 nn architectures
# ANCHOR MODEL
h_model_1 = [
Dense(64,
input_dim=NUM_FEATURES,
activation='relu',
kernel_initializer='he_uniform'), # TODO 05281336 he_uniform, relu
Dropout(0.3),
Dense(32, activation='relu', kernel_initializer='he_uniform'),
Dropout(0.2),
Dense(128, activation='softmax', kernel_initializer='he_uniform'),
Dropout(0.2),
Dense(NUM_CLASS, activation='softmax', kernel_initializer='he_uniform')
]
h_model_1A = [
Dense(10,
input_dim=NUM_FEATURES,
activation='relu',
kernel_initializer='he_uniform'),
Dropout(0.3),
Dense(20, activation='relu', kernel_initializer='he_uniform'),
Dropout(0.2),
test_generator = test_datagen.flow_from_directory('Dataset\Test',
target_size = (224, 224),
batch_size = 32,
class_mode = 'categorical')
# In[9]:
bModel = VGG16(weights="imagenet", include_top=False,input_tensor=Input(shape=(224, 224,3 ))) #base_Model
hModel = bModel.output #head_Model
hModel = AveragePooling2D(pool_size=(4, 4))(hModel)
hModel = Flatten(name="flatten")(hModel)
hModel = Dense(64, activation="relu")(hModel)
hModel = Dropout(0.5)(hModel)
hModel = Dense(2, activation="softmax")(hModel)
model = Model(inputs=bModel.input, outputs=hModel)
for layer in bModel.layers:
layer.trainable = False
# In[10]:
from tensorflow.keras.callbacks import ModelCheckpoint,EarlyStopping
checkpoint = ModelCheckpoint(r"models\model2.h5",
monitor="val_loss",
mode="min",
save_best_only = True,
shear_range=0.15,
horizontal_flip=True,
fill_mode="nearest")
# loading the VGG16 network, ensuring the head FC layer sets are left
# off
baseModel = VGG16(weights="imagenet",
include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
# constructing the head of the model that will be placed on top of the
# the base model
headModel = baseModel.output
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(512, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(len(config.CLASSES), activation="softmax")(headModel)
# placing the head FC model on top of the base model - this will become
# the actual model we will train
model = Model(inputs=baseModel.input, outputs=headModel)
# looping over all layers in the base model and freeze them so they will
# NOT be updated during the first training process
for layer in baseModel.layers:
layer.trainable = False
# compiling our model (this needs to be done after our setting our
# layers to being non-trainable
print("[INFO] compiling model...")
opt = SGD(lr=config.MIN_LR, momentum=0.9)
input_shape=(IMG_ROWS, IMG_COLS, 1),
name='conv2d_1'))
model.add(BatchNormalization(name='batchnorm_1'))
model.add(
Conv2D(64, (3, 3),
activation='elu',
padding='same',
kernel_initializer='he_normal',
name='conv2d_2'))
model.add(BatchNormalization(name='batchnorm_2'))
model.add(MaxPooling2D(pool_size=(2, 2), name='maxpool2d_1'))
model.add(Dropout(0.3, name='dropout_1'))
model.add(
Conv2D(128, (3, 3),
activation='elu',
padding='same',
kernel_initializer='he_normal',
name='conv2d_3'))
model.add(BatchNormalization(name='batchnorm_3'))
model.add(
Conv2D(128, (3, 3),
activation='elu',
padding='same',
kernel_initializer='he_normal',
def create_model(input_shape, config, is_training=True):
weight_decay = 0.001
model = Sequential()
model.add(
Convolution2D(16,
7,
7,
W_regularizer=l2(weight_decay),
activation="relu",
input_shape=input_shape))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Convolution2D(32,
5,
5,
W_regularizer=l2(weight_decay),
activation="relu"))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Convolution2D(64,
3,
3,
W_regularizer=l2(weight_decay),
activation="relu"))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Convolution2D(128,
3,
3,
W_regularizer=l2(weight_decay),
activation="relu"))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Convolution2D(256,
3,
3,
W_regularizer=l2(weight_decay),
activation="relu"))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(512, W_regularizer=l2(weight_decay), activation="relu"))
model.add(Dense(config["num_classes"], activation="softmax"))
ref_model = load_model("logs/2016-12-08-15-14-06/weights.20.model")
for ref_layer in ref_model.layers[:-2]:
layer = model.get_layer(ref_layer.name)
if layer:
print(ref_layer.name)
layer.set_weights(ref_layer.get_weights())
layer.trainable = False
return model
def build_vgg16_like(self, data):
# data must have size nb_pictures x height x width x nb_channels
assert type(data) is tf.Tensor and len(data.shape) == 4
with tf.variable_scope(self.name):
(nb_pics, height, width, nb_channels) = data.get_shape().as_list()
# VGG-16 encoder
### conv3 - 64
self.input_layer = tf.cast(data, dtype=tf.float32)
self.conv1_1 = Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu',
input_shape=(height, width,
nb_channels))(self.input_layer)
self.conv1_1 = BatchNormalization()(self.conv1_1)
self.conv1_2 = Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv1_1)
self.conv1_2 = BatchNormalization()(self.conv1_2)
self.pool1 = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
padding='same')(self.conv1_2)
### conv3 - 128
self.conv2_1 = Conv2D(filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.pool1)
self.conv2_1 = BatchNormalization()(self.conv2_1)
self.conv2_2 = Conv2D(filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv2_1)
self.conv2_2 = BatchNormalization()(self.conv2_2)
self.pool2 = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
padding='same')(self.conv2_2)
### conv3 - 256
self.conv3_1 = Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.pool2)
self.conv3_1 = BatchNormalization()(self.conv3_1)
self.conv3_2 = Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv3_1)
self.conv3_2 = BatchNormalization()(self.conv3_2)
self.conv3_3 = Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv3_2)
self.conv3_3 = BatchNormalization()(self.conv3_3)
self.pool3 = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
padding='same')(self.conv3_3)
### conv3 - 512
self.conv4_1 = Conv2D(filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.pool3)
self.conv4_1 = BatchNormalization()(self.conv4_1)
self.conv4_2 = Conv2D(filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv4_1)
self.conv4_2 = BatchNormalization()(self.conv4_2)
self.conv4_3 = Conv2D(filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv4_2)
self.conv4_3 = BatchNormalization()(self.conv4_3)
self.pool4 = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
padding='same')(self.conv4_3)
### conv3 - 512
self.conv5_1 = Conv2D(filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.pool4)
self.conv5_1 = BatchNormalization()(self.conv5_1)
self.conv5_2 = Conv2D(filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv5_1)
self.conv5_2 = BatchNormalization()(self.conv5_2)
self.conv5_3 = Conv2D(filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(self.conv5_2)
self.conv5_3 = BatchNormalization()(self.conv5_3)
self.pool5 = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
padding='same')(self.conv5_3)
### SPP [4, 2, 1]
self.spp = self.spp_layer(self.pool5, [4, 2, 1],
'spp',
pooling='TV')
### FC-1024
self.dense1 = Dense(1024, activation='relu')(self.spp)
if (self.training_mode):
self.dense1 = Dropout(self.dropout_prob)(self.dense1)
### FC-1024
self.dense2 = Dense(1024)(self.dense1)
if (self.training_mode):
self.dense2 = Dropout(self.dropout_prob)(self.dense2)
### FC-32
self.dense3 = Dense(32, activation='relu')(self.dense2)
if (self.training_mode):
self.dense3 = Dropout(self.dropout_prob)(self.dense3)
### output
if (self.pb_kind == 'classification'):
self.output = Dense(self.nb_classes)(self.dense3)
elif (self.pb_kind == 'regression'):
self.output = Dense(1)(self.dense3)
else:
print('Illegal kind of problem for VGG-16 model: {}'.format(
self.pb_kind))
self.weights_summary(
tf.get_variable('conv1_1/kernel',
shape=[3, 3, nb_channels, 64]),
'first_conv_weights')
#self.weights_summary(tf.get_variable('conv5_3/kernel',shape=[3,3,512,512]), 'last_conv_weights')
#self.weights_summary(self.dense2, '1024_fc_layer')
self.weights_summary(self.output, 'last_fc_layer')
#self.prob_summary(nb_pics)
self.model_built = 'VGG_16'
return self.output
trainable=False)(model_input)
conv_blocks = []
for sz in filter_sizes:
conv = Conv1D(filters=num_filters,
kernel_size=sz,
padding="valid",
activation="relu",
strides=1)(z)
conv = GlobalMaxPooling1D()(conv)
conv = Flatten()(conv)
conv_blocks.append(conv)
z = Concatenate()(conv_blocks) if len(conv_blocks) > 1 else conv_blocks[0]
z = Dropout(drop)(z)
model_output = Dense(len(label_idx), activation='softmax')(z)
model = Model(model_input, model_output)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
print(model.summary())
history = model.fit(
X_train,
y_train,
batch_size=100, # 1회 학습시 주는 데이터 개수
epochs=20, # 전체 데이타 10번 학습
def sublayer_connection(inputs, sublayer, dropout=0.2):
outputs = layer_norm(inputs + Dropout(dropout)(sublayer))
return outputs
# Otra técnica para reducir el overfitting es la introducción de dropouts a la red
# Es una forma de regularización que fuerza a los pesos neuronales a tomar
# solo valores pequeños, lo que hace la distribución de los pesos más regulares
# y la red puede reducir el overfitting en entrenamientos con muestras pequeñas
# Crear una nueva red con Dropouts
# esto hace, de manera aleatoria, que el 20% de las neuronas se vayan a 0
model_new = Sequential([
Conv2D(16,
3,
padding='same',
activation='relu',
input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
MaxPooling2D(),
Dropout(0.2),
Conv2D(32, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(64, 3, padding='same', activation='relu'),
MaxPooling2D(),
Dropout(0.2),
Flatten(),
Dense(512, activation='relu'),
Dense(1, activation='sigmoid')
])
# Compilar el nuevo modelo
model_new.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import MaxPooling2D
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
mode = "display"
# Create the model
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(48,48,1)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
def emotion_recog(frame):
model.load_weights('model.h5')
# 학습 데이터와 시험데이터로 분리한다.
x_train, x_test, y_train, y_test = train_test_split(x_data,
y_data,
test_size=0.2)
y_train = np.array(y_train).reshape(-1, 1)
y_test = np.array(y_test).reshape(-1, 1)
x_train.shape, y_train.shape, x_test.shape, y_test.shape
# NPLM 모델을 생성한다.
EMB_SIZE = 32
VOCAB_SIZE = len(word2idx) + 1
x_input = Input(batch_shape=(None, x_train.shape[1]))
x_embed = Embedding(input_dim=VOCAB_SIZE, output_dim=EMB_SIZE)(
x_input) # weights 옵션으로 C행렬을 넣어줄 수 있다. - 사전학습
x_embed = Dropout(0.5)(x_embed)
x_lstm = LSTM(64, dropout=0.5)(x_embed)
y_output = Dense(n_topic, activation='softmax')(x_lstm)
model = Model(x_input, y_output) # 학습, 예측용 모델
model.compile(loss='sparse_categorical_crossentropy',
optimizer=optimizers.Adam(learning_rate=0.01))
model.summary()
# 모델을 학습한다.
hist = model.fit(x_train,
y_train,
validation_data=(x_test, y_test),
batch_size=512,
epochs=30) # 사전학습해서 Fine-tuning
def build(self,
word_length,
num_labels,
num_intent_labels,
word_vocab_size,
char_vocab_size,
word_emb_dims=100,
char_emb_dims=30,
char_lstm_dims=30,
tagger_lstm_dims=100,
dropout=0.2):
self.word_length = word_length
self.num_labels = num_labels
self.num_intent_labels = num_intent_labels
self.word_vocab_size = word_vocab_size
self.char_vocab_size = char_vocab_size
words_input = Input(shape=(None, ), name='words_input')
embedding_layer = Embedding(word_vocab_size,
word_emb_dims,
name='word_embedding')
word_embeddings = embedding_layer(words_input)
word_embeddings = Dropout(dropout)(word_embeddings)
word_chars_input = Input(shape=(None, word_length),
name='word_chars_input')
char_embedding_layer = Embedding(char_vocab_size,
char_emb_dims,
input_length=word_length,
name='char_embedding')
char_embeddings = char_embedding_layer(word_chars_input)
char_embeddings = TimeDistributed(Bidirectional(
LSTM(char_lstm_dims)))(char_embeddings)
char_embeddings = Dropout(dropout)(char_embeddings)
# first BiLSTM layer (used for intent classification)
first_bilstm_layer = Bidirectional(
LSTM(tagger_lstm_dims, return_sequences=True, return_state=True))
first_lstm_out = first_bilstm_layer(word_embeddings)
lstm_y_sequence = first_lstm_out[:1][
0] # save y states of the LSTM layer
states = first_lstm_out[1:]
hf, _, hb, _ = states # extract last hidden states
h_state = concatenate([hf, hb], axis=-1)
intents = Dense(num_intent_labels,
activation='softmax',
name='intent_classifier_output')(h_state)
# create the 2nd feature vectors
combined_features = concatenate([lstm_y_sequence, char_embeddings],
axis=-1)
# 2nd BiLSTM layer (used for entity/slots classification)
second_bilstm_layer = Bidirectional(
LSTM(tagger_lstm_dims, return_sequences=True))(combined_features)
second_bilstm_layer = Dropout(dropout)(second_bilstm_layer)
bilstm_out = Dense(num_labels)(second_bilstm_layer)
# feed BiLSTM vectors into CRF
crf = CRF(num_labels, name='intent_slot_crf')
entities = crf(bilstm_out)
model = Model(inputs=[words_input, word_chars_input],
outputs=[intents, entities])
loss_f = {
'intent_classifier_output': 'categorical_crossentropy',
'intent_slot_crf': crf.loss
}
metrics = {
'intent_classifier_output': 'categorical_accuracy',
'intent_slot_crf': crf.viterbi_accuracy
}
model.compile(loss=loss_f, optimizer=AdamOptimizer(), metrics=metrics)
self.model = model
def E4(self, x, y, trails=8, epochs=30):
# Fit params
print('shape features ---', x.shape)
print('shape labels -----', y.shape)
print('epochs -----------', epochs, end='\n\n')
# Trails
for trail in range(trails):
timestamp = str(int(time.time()))
model = Sequential()
D = trail * 0.1
NAME = f'E4 [32C5-P2-] - D{D} - [64C5-P2] - D{D}'
NAME = f'{NAME} - 128 - D{D} - 10 @{int(time.time())}'
# 1st conv
model.add(
Conv2D(32,
kernel_size=5,
activation=self.activation,
input_shape=self.input_shape))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Dropout(D))
# 2nd conv
model.add(Conv2D(64, kernel_size=5, activation=self.activation))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Dropout(D))
# Classification layer
model.add(Flatten())
model.add(Dense(128, activation=self.activation))
model.add(Dropout(D))
# Output layer
model.add(Dense(10, activation='softmax'))
model.compile(optimizer=self.optimizer,
loss=self.loss,
metrics=self.metrics)
# Tensor Board
self.printStart(NAME[:2], trail, trails, timestamp)
tensorboard = TensorBoard(log_dir=f'{self.path_logs}\\{NAME}',
profile_batch=0)
# Fitting
model.fit(x,
y,
epochs=epochs,
callbacks=[tensorboard],
validation_split=self.val_split,
verbose=self.verbose)
# Saving
model.save(f'{self.path_models}/{NAME}.model')
# Appending
date = datetime.datetime.fromtimestamp(int(timestamp))
date = date.strftime('%Y-%m-%d %H:%M:%S')
self.models['date'].append(date)
self.models['timestamp'].append(int(timestamp))
self.models['name'].append(NAME[:NAME.find(' @')])
self.models['model'].append(model)
conv1 = Conv2D(6, kernel_size=3, padding='same')
bn1 = BatchNormalization()
a1 = Activation('relu')
conv2 = Conv2D(12, kernel_size=3, padding='same')
bn2 = BatchNormalization()
a2 = Activation('relu')
mp1 = MaxPool2D()
conv3 = Conv2D(24, kernel_size=3, padding='same')
bn3 = BatchNormalization()
a3 = Activation('relu')
conv4 = Conv2D(48, kernel_size=3, padding='same')
bn4 = BatchNormalization()
a4 = Activation('relu')
mp2 = MaxPool2D()
drop1 = Dropout(0.25)
conv11 = Conv2D(6, kernel_size=3, padding='same')
bn11 = BatchNormalization()
a11 = Activation('relu')
conv22 = Conv2D(12, kernel_size=3, padding='same')
bn22 = BatchNormalization()
a22 = Activation('relu')
mp11 = MaxPool2D()
conv33 = Conv2D(24, kernel_size=3, padding='same')
bn33 = BatchNormalization()
a33 = Activation('relu')
conv44 = Conv2D(48, kernel_size=3, padding='same')
bn44 = BatchNormalization()
a44 = Activation('relu')
def modelArchitectureNew(self, x, y, val_set, epochs):
timestamp = str(int(time.time()))
model = Sequential()
# 1st conv replacement
model.add(
Conv2D(32,
kernel_size=3,
activation=self.activation,
input_shape=self.input_shape))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size=3, activation=self.activation))
model.add(BatchNormalization())
model.add(
Conv2D(32,
kernel_size=5,
strides=2,
padding='same',
activation=self.activation))
model.add(BatchNormalization())
model.add(Dropout(0.4))
# 2nd conv replaement
model.add(Conv2D(64, kernel_size=3, activation=self.activation))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size=3, activation=self.activation))
model.add(BatchNormalization())
model.add(
Conv2D(64,
kernel_size=5,
strides=2,
padding='same',
activation=self.activation))
model.add(BatchNormalization())
model.add(Dropout(0.4))
# Classification layer
model.add(Flatten())
model.add(Dense(128, activation=self.activation))
model.add(BatchNormalization())
model.add(Dropout(0.4))
# Output and compile
model.add(Dense(10, activation='softmax'))
model.compile(optimizer=self.optimizer,
loss=self.loss,
metrics=self.metrics)
# TensorBoard
NAME = 'E5 [32C3n-32C3n-32C5S2n] - D0.4 - [64C3n-64C3n-64C5S2n] - D0.4'
NAME = f'{NAME} - 128n - D0.4 - 10 @{timestamp}'
self.printStart(NAME[:2], 1, 2, timestamp)
tensorboard = TensorBoard(log_dir=f'{self.path_logs}\\{NAME}',
profile_batch=0)
# Learning rate scheduler
annealer = LearningRateScheduler(self.exponentialDecay)
# Fitting
model.fit(x,
y,
epochs=epochs,
callbacks=[tensorboard, annealer],
validation_data=val_set,
verbose=self.verbose)
model.save(f'{self.path_models}/{NAME}.model')
# Appending
date = datetime.datetime.fromtimestamp(int(timestamp))
date = date.strftime('%Y-%m-%d %H:%M:%S')
self.models['date'].append(date)
self.models['timestamp'].append(int(timestamp))
self.models['name'].append(NAME[:NAME.find(' @')])
self.models['model'].append(model)
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes, activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
# this script builds and trains a simple feed forward neural network using the Keras api of tensorflow
data = read_data('train')
y = data["Survived"].to_numpy()
X = data.drop(columns="Survived").to_numpy()
# Definition of the networks hyper-parameters
input_dim = len(X[0])
epochs = 100
hidden_sizes = [10, 20, 10]
# Definition of the model
input_placeholder = Input(shape=(input_dim, ))
layer = input_placeholder
while len(hidden_sizes) > 0:
dim = hidden_sizes.pop(0)
layer = Dense(dim, activation='sigmoid')(layer)
layer = Dropout(0.1)(layer)
output = Dense(1, activation='sigmoid')(layer)
model = Model(input_placeholder, output)
# Compile model
opt = Adam(lr=1e-2, decay=1e-2 / epochs)
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
# Training of the model
model.fit(X, y, epochs=epochs, batch_size=20, shuffle=True)
# save the model
model.save("Models/FeedForward.hdf5")
y_train = []
for i in range(3, trainingData.shape[0]):
X_train.append(trainingData[i - 3:i])
y_train.append(trainingData[i, 0])
X_train, y_train = np.array(X_train), np.array(y_train)
regressor = Sequential()
regressor.add(
LSTM(units=50,
activation="relu",
return_sequences=True,
input_shape=(X_train.shape[1], 2)))
regressor.add(Dropout(0.2))
regressor.add(LSTM(units=60, activation="relu", return_sequences=True))
regressor.add(Dropout(0.3))
regressor.add(LSTM(units=80, activation="relu", return_sequences=True))
regressor.add(Dropout(0.4))
regressor.add(LSTM(units=80, activation="relu"))
regressor.add(Dropout(0.5))
regressor.add(Dense(units=1))
#Adam is stochasitc gradient descent and I use mean squared error as the loss function
regressor.compile(optimizer="adam", loss=tensorflow.keras.losses.MSE)
regressor.fit(X_train, y_train, epochs=5, batch_size=16)
from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() scaler.fit(x_train) x_train = scaler.transform(x_train) x_test = scaler.transform(x_test) x_val = scaler.transform(x_val) print(np.max(x), np.min(x)) print(np.max(x[0])) #2 모델구성 input1 = Input(shape=(13, )) dense1 = Dense(120, activation='relu')(input1) dense1 = Dropout(0.4)(dense1) dense1 = Dense(85)(dense1) dense1 = Dropout(0.3)(dense1) dense1 = Dense(70)(dense1) dense1 = Dropout(0.3)(dense1) dense1 = Dense(60)(dense1) dense1 = Dropout(0.2)(dense1) dense1 = Dense(30)(dense1) dense1 = Dropout(0.2)(dense1) dense1 = Dense(20)(dense1) dense1 = Dropout(0.2)(dense1) dense1 = Dense(4)(dense1) output1 = Dense(1)(dense1) model = Model(inputs=input1, outputs=output1) #3 컴파일 훈련
#from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
# sort out some
y_train_known = y_train[np.squeeze(y_train) < 5]
y_train_novel = y_train[np.squeeze(y_train) >= 5]
x_train_known = x_train[np.squeeze(y_train) < 5] / 255
x_train_novel = x_train[np.squeeze(y_train) >= 5] / 255
y_train_known_cat = to_categorical(y_train_known)
y_test_cat = to_categorical(y_test)
img_inputs = keras.Input(shape=x_train[0].shape)
x = Conv2D(16, 3, activation="relu")(img_inputs)
x = Conv2D(32, 3, activation="relu")(x)
x = MaxPooling2D(3)(x)
x = Conv2D(32, 3, activation="relu")(x)
x = Conv2D(16, 3, activation="relu")(x)
x = Flatten()(x)
x = Dropout(0.5)(x)
x = Dense(2048)(x)
x = Dropout(0.5)(x)
x = Dense(5, activation="softmax")(x)
model = Model(img_inputs, x)
model.summary()
model.compile("adam", loss="categorical_crossentropy", metrics=["acc"])
model.fit(x_train_known, y_train_known_cat, epochs=20)
def create_model(seed, epochs, batch_size):
train_generator2 = train_datagen2.flow_from_directory(
'data/train',
target_size=img_size,
batch_size=batch_size,
class_mode='categorical',
seed=seed)
validation_generator2 = test_datagen.flow_from_directory(
'data/validation',
target_size=img_size,
batch_size=batch_size,
class_mode='categorical',
seed=seed)
reset_random_seeds(seed)
model = Sequential([
Conv2D(baseMapNum, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay),
input_shape=(32, 32, 3)),
Activation('relu'),
BatchNormalization(),
Conv2D(baseMapNum, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)),
Activation('relu'),
BatchNormalization(),
MaxPool2D(pool_size=(2, 2)),
Dropout(0.2),
Conv2D(2 * baseMapNum, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)),
Activation('relu'),
BatchNormalization(),
Conv2D(2 * baseMapNum, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)),
Activation('relu'),
BatchNormalization(),
MaxPool2D(pool_size=(2, 2)),
Dropout(0.3),
Conv2D(4 * baseMapNum, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)),
Activation('relu'),
BatchNormalization(),
Conv2D(4 * baseMapNum, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay)),
Activation('relu'),
BatchNormalization(),
MaxPool2D(pool_size=(2, 2)),
Dropout(0.4),
Flatten(),
Dense(128, activation='relu'),
BatchNormalization(),
Dropout(0.4),
Dense(num_classes, activation='softmax')
])
lrr = ReduceLROnPlateau(
monitor='val_accuracy',
factor=.5,
patience=8,
min_lr=1e-4,
verbose=1)
opt_adam = Adam(learning_rate=0.002, beta_1=0.9, beta_2=0.999)
model.compile(loss='categorical_crossentropy',
optimizer=opt_adam,
metrics=['accuracy'])
history = model.fit(train_generator2, epochs=epochs, validation_data=validation_generator2, callbacks=[lrr])
loss, acc = model.evaluate(validation_generator2)
return model, history, loss, acc
