print(x_train_processed.shape)
print(x_test_processed.shape)
print(x_valid_processed.shape)
i = random.randint(1, len(x_train))
plt.imshow(x_train_processed[i].squeeze(), cmap='gray')
plt.figure()
plt.imshow(x_train[i].squeeze())
#Deep CNN model
model = Sequential()
model.add(Conv2D(32, (5, 5), activation='relu',
input_shape=(32, 32, 1))) #Add convolution layer 1
model.add(MaxPooling2D(pool_size=(2, 2))) #pooling layer
model.add(Dropout(0.25))
model.add(Conv2D(64, (5, 5), activation='relu')) #Add convolution layer 2
model.add(MaxPooling2D(pool_size=(2, 2))) #pooling layer
model.add(Flatten()) #Image flattener
model.add(Dense(256, activation='relu')) #Image density
model.add(Dropout(0.5)) #dropout rate layer
model.add(Dense(43, activation='softmax'))
offsetbox.OffsetImage(ims[i]),
X[i],pad=0)
ax.add_artist(imagebox)
plt.xticks([]), plt.yticks([])
if title is not None:
plt.title(title)
def PIL2array(img):
return np.array(img.getdata()).reshape(img.size[1], img.size[0], 3)
# initialize cae
cae = Sequential()
# convolution + pooling 1
cae.add(Convolution2D(8, filterSize, filterSize, input_shape=(3, sampSize, sampSize), border_mode='same'))
cae.add(MaxPooling2D(pool_size=(poolSize, poolSize)))
cae.add(Activation('relu'))
# convolution + pooling 2
cae.add(Convolution2D(16, filterSize, filterSize, border_mode='same'))
cae.add(MaxPooling2D(pool_size=(poolSize, poolSize)))
cae.add(Activation('relu'))
# convolution + pooling 3
cae.add(Convolution2D(32, filterSize, filterSize, border_mode='same'))
cae.add(MaxPooling2D(pool_size=(poolSize, poolSize)))
cae.add(Activation('relu'))
# convolution + pooling 4
cae.add(Convolution2D(64, filterSize, filterSize, border_mode='same'))
cae.add(MaxPooling2D(pool_size=(poolSize, poolSize)))
Pool_Valid_Acc = np.zeros(shape=(nb_epoch, 1))
Pool_Train_Acc = np.zeros(shape=(nb_epoch, 1))
x_pool_All = np.zeros(shape=(1))
Y_train = np_utils.to_categorical(y_train, nb_classes)
print('Training Model Without Acquisitions in Experiment', e)
model = Sequential()
model.add(Convolution2D(nb_filters, nb_conv, nb_conv, border_mode='valid', input_shape=(1, img_rows, img_cols)))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, nb_conv, nb_conv))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
model.add(Dropout(0.25))
model.add(Convolution2D(nb_filters*2, nb_conv, nb_conv, border_mode='valid', input_shape=(1, img_rows, img_cols)))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters*2, nb_conv, nb_conv))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
model.add(Dropout(0.25))
c = 10
Weight_Decay = c / float(X_train.shape[0])
model.add(Flatten())
model.add(Dense(128, W_regularizer=l2(Weight_Decay)))
model.add(Activation('relu'))
model.add(Dropout(0.5))
def build(width=224,
height=224,
depth=3,
classes=10,
l2_reg=0.,
weights=None):
img_shape = (height, width, depth)
# Initialize model
alexnet = Sequential()
# Layer 1
alexnet.add(
Conv2D(96, (11, 11),
input_shape=img_shape,
padding='same',
kernel_regularizer=l2(l2_reg)))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
alexnet.add(MaxPooling2D(pool_size=(2, 2)))
# Layer 2
alexnet.add(Conv2D(256, (5, 5), padding='same'))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
alexnet.add(MaxPooling2D(pool_size=(2, 2)))
# Layer 3
alexnet.add(ZeroPadding2D((1, 1)))
alexnet.add(Conv2D(512, (3, 3), padding='same'))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
alexnet.add(MaxPooling2D(pool_size=(2, 2)))
# Layer 4
alexnet.add(ZeroPadding2D((1, 1)))
alexnet.add(Conv2D(1024, (3, 3), padding='same'))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
# Layer 5
alexnet.add(ZeroPadding2D((1, 1)))
alexnet.add(Conv2D(1024, (3, 3), padding='same'))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
alexnet.add(MaxPooling2D(pool_size=(2, 2)))
# Layer 6
alexnet.add(Flatten())
alexnet.add(Dense(3072))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
alexnet.add(Dropout(0.5))
# Layer 7
alexnet.add(Dense(4096))
alexnet.add(BatchNormalization())
alexnet.add(Activation('relu'))
alexnet.add(Dropout(0.5))
# Layer 8
alexnet.add(Dense(classes))
alexnet.add(BatchNormalization())
alexnet.add(Activation('softmax'))
if weights is not None:
alexnet.load_weights(weights)
return alexnet
def vgg_16(weights_path=None, h=224, w=224):
model = DeepFaceHashSequential()
model.add(ZeroPadding2D((1, 1), input_shape=(3, h, w)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Flatten(name="flatten"))
# model.add(Dense(4096, activation='relu', name='dense_1'))
# model.add(Dropout(0.5))
# model.add(Dense(4096, activation='relu', name='dense_2'))
# model.add(Dropout(0.5))
# model.add(Dense(1000, name='dense_3'))
# model.add(Activation("softmax",name="softmax"))
if weights_path:
print("Trying to load weights...")
excluded = [
'dense_1', 'dense_2', 'dense_3', 'dropout_5', 'dropout_6'
'softmax'
]
model.load_weights(weights_path, excluded)
print("Weights loaded!!!")
return model
# combine the 3 images into a single Keras tensor
input_tensor = K.concatenate([base_image,
style_reference_image,
combination_image], axis=0)
# build the VGG16 network with our 3 images as input
first_layer = ZeroPadding2D((1, 1), input_shape=(3, img_width, img_height))
first_layer.input = input_tensor
model = Sequential()
model.add(first_layer)
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
def googlenet_block(x):
if gnet:
""" _______
(1, 1)-------------| |
(3, 3)-------------| con- |_____
(5, 5)-------------| cate |
(1, 1)-------------|______|
"""
# 1x1 conv
conv1 = Convolution2D(conv_2D[0], (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(x)
# 3x3 conv
conv3 = Convolution2D(conv_2D[1], (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(x)
# 5x5 conv
conv5 = Convolution2D(conv_2D[2], (5, 5),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(x)
# 3x3 max pooling
pool = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(x)
pool_conv = Convolution2D(conv_2D[0], (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(pool)
# concatenate filters, assumes filters/channels last
layer_out = concatenate([conv1, conv3, conv5, pool_conv])
layers = 6
conv_n = 4
return [layer_out, layers, conv_n]
else:
""" _______
(1, 1)-------------| |
(1, 1) -> (3, 3)---| con- |_____
(1, 1) -> (5, 5)---| cate |
pool() -> (1, 1)---|______|
"""
# 1x1 conv
conv1 = Convolution2D(conv_2D[0], (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(x)
# 3x3 conv
conv3_conv = Convolution2D(conv_2D[0], (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(x)
conv3 = Convolution2D(conv_2D[1], (3, 3),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(conv3_conv)
# 5x5 conv
conv5_conv = Convolution2D(conv_2D[0], (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(x)
conv5 = Convolution2D(conv_2D[2], (5, 5),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(conv5_conv)
# 3x3 max pooling
pool = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(x)
pool_conv = Convolution2D(conv_2D[0], (1, 1),
padding='same',
activation='relu',
kernel_initializer='he_normal',
use_bias=False)(pool)
# concatenate filters, assumes filters/channels last
layer_out = concatenate([conv1, conv3, conv5, pool_conv])
layers = 8
conv_n = 6
return [layer_out, layers, conv_n]
def build(width, height, depth, classes):
model = Sequential()
inputShape = (height, width, depth)
chanDim = -1
if K.image_data_format() == "channels_first":
inputShape = (depth, height, width)
chanDim = 1
# Block #1: first CONV => ELU => CONV => ELU => POOL
# layer set
model.add(
Conv2D(32, (3, 3),
padding="same",
kernel_initializer="he_normal",
input_shape=inputShape))
model.add(ELU())
model.add(BatchNormalization(axis=chanDim))
model.add(
Conv2D(32, (3, 3), kernel_initializer="he_normal", padding="same"))
model.add(ELU())
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# Block #2: second CONV => ELU => CONV => ELU => POOL
# layer set
model.add(
Conv2D(64, (3, 3), padding="same", kernel_initializer="he_normal"))
model.add(ELU())
model.add(BatchNormalization(axis=chanDim))
model.add(
Conv2D(64, (3, 3), padding="same", kernel_initializer="he_normal"))
model.add(ELU())
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# Block #3: third CONV => ELU => CONV => ELU => POOL
# layer set
model.add(
Conv2D(128, (3, 3), padding="same",
kernel_initializer="he_normal"))
model.add(ELU())
model.add(BatchNormalization(axis=chanDim))
model.add(
Conv2D(128, (3, 3), padding="same",
kernel_initializer="he_normal"))
model.add(ELU())
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# Block 4: set Full-Connected => Relu layers
# layer set
model.add(Flatten())
model.add(Dense(64, kernel_initializer="he_normal"))
model.add(ELU())
model.add(BatchNormalization())
model.add(Dropout(0.5))
# Block 5: second set Full-Connected => Relu layers
# layer set
model.add(Dense(64, kernel_initializer="he_normal"))
model.add(ELU())
model.add(BatchNormalization())
model.add(Dropout(0.5))
# Block 7: Softmax classifier
model.add(Dense(classes, kernel_initializer="he_normal"))
model.add(Activation("softmax"))
return model
def build(width,
height,
depth,
classes,
stages,
filters,
reg=0.0001,
bnEps=2e-5,
bnMom=0.9):
# Initialise inputShape and chanDim based on channels last or channels first
# initialise the input shape the be "channels last" and the channels dimension itself
inputShape = (height, width, depth)
chanDim = -1
# if using channels first update input shape and channels dimension
if K.image_data_format() == "channels_first":
inputShape = (depth, height, width)
chanDim = 1
# set input and apply BN
inputs = Input(shape=inputShape)
x = BatchNormalization(axis=chanDim, epsilon=bnEps,
momentum=bnMom)(inputs)
# ResNet uses BN as the first layer as an added level of normalisation to the input
# apply Conv => BN => Act => POOL to reduce spatial size
x = Conv2D(filters[0], (5, 5),
use_bias=False,
padding="same",
kernel_regularizer=l2(reg))(x)
x = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(x)
x = Activation("relu")(x)
x = ZeroPadding2D((1, 1))(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
# Stack residual layers on top of each other
# loop over number of stages
for i in range(0, len(stages)):
# initialise the stride and apply a residual module used to reduce spatial size of the input volume
# to reduce volume size without pooling layers change stride of convolution
# first entry in the stage has stride of (1,1) ie no downsampling
# every stage after stride is (2, 2) which decreases volume size
stride = (1, 1) if i == 0 else (2, 2)
x = ResNet.residual_module(x,
filters[i + 1],
stride,
chanDim,
red=True,
bnEps=bnEps,
bnMom=bnMom)
# loop over the number of layers in the stage
for j in range(0, stages[i] - 1):
# apply a ResNet module
x = ResNet.residual_module(x,
filters[i + 1], (1, 1),
chanDim,
bnEps=bnEps,
bnMom=bnMom)
# avoid dense fully connected layers by applying average pooling to reduce volume size to 1x1xclasses
# apply BN => Act => POOL
x = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(x)
x = Activation("relu")(x)
x = AveragePooling2D((8, 8))(x)
# create dense layer for total number of classes to learn then apply
# softmax activation to generate final output probs
# softmax classifier
x = Flatten()(x)
x = Dense(classes, kernel_regularizer=l2(reg))(x)
x = Activation("softmax")(x)
# create model
model = Model(inputs, x, name="resnet")
# return the constructed network architecture
return model
def train(run_name, start_epoch, stop_epoch, img_w):
# Input Parameters
img_h = 64
words_per_epoch = 16000
val_split = 0.2
val_words = int(words_per_epoch * (val_split))
# Network parameters
conv_num_filters = 16
filter_size = 3
pool_size = 2
time_dense_size = 32
rnn_size = 512
if K.image_dim_ordering() == 'th':
input_shape = (1, img_w, img_h)
else:
input_shape = (img_w, img_h, 1)
fdir = os.path.dirname(
get_file('wordlists.tgz',
origin='http://www.isosemi.com/datasets/wordlists.tgz',
untar=True))
img_gen = TextImageGenerator(
monogram_file=os.path.join(fdir, 'wordlist_mono_clean.txt'),
bigram_file=os.path.join(fdir, 'wordlist_bi_clean.txt'),
minibatch_size=32,
img_w=img_w,
img_h=img_h,
downsample_factor=(pool_size**2),
val_split=words_per_epoch - val_words)
act = 'relu'
input_data = Input(name='the_input', shape=input_shape, dtype='float32')
inner = Convolution2D(conv_num_filters,
filter_size,
filter_size,
border_mode='same',
activation=act,
init='he_normal',
name='conv1')(input_data)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner)
inner = Convolution2D(conv_num_filters,
filter_size,
filter_size,
border_mode='same',
activation=act,
init='he_normal',
name='conv2')(inner)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max2')(inner)
conv_to_rnn_dims = (img_w // (pool_size**2),
(img_h // (pool_size**2)) * conv_num_filters)
inner = Reshape(target_shape=conv_to_rnn_dims, name='reshape')(inner)
# cuts down input size going into RNN:
inner = Dense(time_dense_size, activation=act, name='dense1')(inner)
# Two layers of bidirecitonal GRUs
# GRU seems to work as well, if not better than LSTM:
gru_1 = GRU(rnn_size, return_sequences=True, init='he_normal',
name='gru1')(inner)
gru_1b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
init='he_normal',
name='gru1_b')(inner)
gru1_merged = merge([gru_1, gru_1b], mode='sum')
gru_2 = GRU(rnn_size, return_sequences=True, init='he_normal',
name='gru2')(gru1_merged)
gru_2b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
init='he_normal',
name='gru2_b')(gru1_merged)
# transforms RNN output to character activations:
inner = Dense(img_gen.get_output_size(), init='he_normal',
name='dense2')(merge([gru_2, gru_2b], mode='concat'))
y_pred = Activation('softmax', name='softmax')(inner)
Model(input=[input_data], output=y_pred).summary()
labels = Input(name='the_labels',
shape=[img_gen.absolute_max_string_len],
dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
loss_out = Lambda(ctc_lambda_func, output_shape=(1, ),
name='ctc')([y_pred, labels, input_length, label_length])
# clipnorm seems to speeds up convergence
sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
model = Model(input=[input_data, labels, input_length, label_length],
output=[loss_out])
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)
if start_epoch > 0:
weight_file = os.path.join(
OUTPUT_DIR,
os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1)))
model.load_weights(weight_file)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], [y_pred])
viz_cb = VizCallback(run_name, test_func, img_gen.next_val())
model.fit_generator(generator=img_gen.next_train(),
samples_per_epoch=(words_per_epoch - val_words),
nb_epoch=stop_epoch,
validation_data=img_gen.next_val(),
nb_val_samples=val_words,
callbacks=[viz_cb, img_gen],
initial_epoch=start_epoch)
def keras_own():
## Configure the network
#batch_size to train
batch_size = 32
# number of output classes
nb_classes = 135
# number of epochs to train
nb_epoch = 40
# number of convolutional filters to use
nb_filters = 20
# size of pooling area for max pooling
nb_pool = 2
# convolution kernel size
nb_conv = 5
model = Sequential()
model.add(
Convolution2D(nb_filters,
nb_conv,
nb_conv,
dim_ordering='th',
border_mode='valid',
input_shape=(1, 29, 29)))
convout1 = Activation('relu')
model.add(convout1)
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool), dim_ordering="th"))
#model.add(Dropout(0.5))
model.add(
Convolution2D(nb_filters,
nb_conv,
nb_conv,
dim_ordering='th',
border_mode='valid'))
convout2 = Activation('relu')
model.add(convout2)
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool), dim_ordering="th"))
#model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(4000, batch_input_shape=(None, 1, 29, 29)))
model.add(Activation('relu'))
#model.add(Dropout(0.25))
model.add(Dense(135))
model.add(Activation('softmax'))
adam1 = adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(loss='categorical_crossentropy',
optimizer=adam1,
metrics=['accuracy'])
# ## Train model - uncoment to perform the training yourself
#
# train = numpy.load('train.npz')
# x_train = train['x_train']
# y_train = train['y_train']
#
# for m in range(0,nb_epoch):
# for jj in range(0,x_train.shape[0]-256*20,256*20):
# print('Epoch number is', m)
# xx = x_train[jj:jj+256*20,:]
# yy = y_train[jj:jj+256*20,:]
# earlyStopping=EarlyStopping(monitor='val_loss', patience=0, verbose=0, mode='auto')
# model.fit(xx,yy,epochs=1,batch_size=1, callbacks=[earlyStopping], validation_split=0.20)
# print("saving weights")
# model.save_weights('data/keras-epoch-' + str(m) + '.h5')
# model.save_weights('keras.h5')
## Load the pretrained network
model.load_weights('./Week_7_export/keras.h5')
return model
def vgg16_model(img_rows, img_cols, color_type=1):
model = Sequential()
model.add(
ZeroPadding2D((1, 1), input_shape=(color_type, img_rows, img_cols)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1000, activation='softmax'))
model.load_weights('vgg16_weights.h5')
# Code above loads pre-trained data and
model.layers.pop()
model.outputs = [model.layers[-1].output]
model.layers[-1].outbound_nodes = []
model.add(Dense(10, activation='softmax'))
# Learning rate is changed to 0.001
sgd = SGD(lr=5e-4, decay=4e-3, momentum=0.9, nesterov=True)
# adam = Adam()
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def vgg16_256_model(img_rows, img_cols, color_type=1):
model = Sequential()
model.add(
ZeroPadding2D((1, 1), input_shape=(color_type, img_rows, img_cols)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
weight_path = 'vgg16_weights.h5'
f = h5py.File(weight_path)
for k in range(f.attrs['nb_layers']):
if k >= len(model.layers):
# we don't look at the last (fully-connected) layers in the savefile
break
g = f['layer_{}'.format(k)]
if k == 32:
weights = []
weight_small = g['param_0']
zero = np.zeros((7680, 4096))
weights.append(np.vstack((weight_small, zero)))
weights.append(g['param_1'])
else:
weights = [
g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])
]
model.layers[k].set_weights(weights)
f.close()
model.add(Dense(10, activation='softmax'))
# Learning rate is changed to 0.001
sgd = SGD(lr=5e-4, decay=4e-3, momentum=0.9, nesterov=True)
adam = Adam()
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def getModel1():
model = Sequential()
model.add(ZeroPadding2D((1, 1), input_shape=(3, 32, 32)))
model.add(Convolution2D(128, 3, 3, W_regularizer=l2(weightDecay)))
#model.add(Conv2D(128, (1, 1) ,kernel_regularizer=l2_reg))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
#model.add(MaxPooling2D((2,2)))
model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering="th"))
model.add(Dropout(0.5))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
#model.add(MaxPooling2D((2,2)))
model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering="th"))
model.add(Dropout(0.5))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
#model.add(MaxPooling2D((2,2)))
model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering="th"))
model.add(Dropout(0.5))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(1024, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(1024, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(1024, 3, 3, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
#model.add(MaxPooling2D((2,2)))
model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering="th"))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(outNeurons, W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(Dropout(0.5))
#model.add(Dense(outNeurons/2,W_regularizer=l2(weightDecay)))
model.add(Dense(int(outNeurons / 2), W_regularizer=l2(weightDecay)))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, W_regularizer=l2(weightDecay)))
model.add(Activation('softmax'))
return model
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dropout
from keras.layers.core import Dense
from keras import optimizers
from keras.preprocessing.image import ImageDataGenerator
original_dataset = '/media/lac/DATA/virtualenv/deep/train/'
base_dir = '/media/lac/DATA/virtualenv/deep/cats_dogs'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(150, 150, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(128, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dropout(0.5))
import json
img_w = 200
img_h = 200
n_labels = 2
kernel = 3
encoding_layers = [
Conv2D(64, kernel, padding='same', input_shape=(img_h, img_w, 14)),
BatchNormalization(),
Activation('relu'),
Conv2D(64, kernel, padding='same'),
BatchNormalization(),
Activation('relu'),
MaxPooling2D(),
Conv2D(128, kernel, padding='same'),
BatchNormalization(),
Activation('relu'),
Conv2D(128, kernel, padding='same'),
BatchNormalization(),
Activation('relu'),
MaxPooling2D(),
Conv2D(256, kernel, padding='same'),
BatchNormalization(),
Activation('relu'),
Conv2D(256, kernel, padding='same'),
BatchNormalization(),
Activation('relu'),
Conv2D(256, kernel, padding='same'),
BatchNormalization(),
def build(
numChannels,
imgRows,
imgCols,
numClasses, #parameters passed in the main script
activation="relu",
weightsPath=None
): #weightsPath is addictional parameter passed to the main script
# initialize the model
model = Sequential(
) #this put layers sequentially as they are defined layer-by-layer (contrary of functional)
inputShape = (imgRows, imgCols, numChannels)
# if we are using "channels first", update the input shape
# to verify the configuration go to $HOME/.keras/.keras.json
if K.image_data_format() == "channels_first":
inputShape = (numChannels, imgRows, imgCols)
# this is a zero padding layer to resize dataset mnist into 32x32 images
model.add(ZeroPadding2D(padding=(2, 2), input_shape=inputShape))
# ---C1
# define the first set of CONV => ACTIVATION => POOL layers
model.add(
Conv2D(filters=6,
kernel_size=(5, 5),
strides=(1, 1),
padding="valid"))
##model.add(Conv2D(filters=6, kernel_size=(5, 5), strides=(1, 1), padding="valid", input_shape=inputShape))
# padding "same" to have a classic zero padding
model.add(
Activation(activation)
) # we could write activation='relu' directly as argument of Conv2
# ---S2
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
##model.add(AveragePooling2D(pool_size=(2, 2), strides=(2, 2)))
# ---C3
# define the second set of CONV => ACTIVATION => POOL layers
model.add(
Conv2D(filters=16,
kernel_size=(5, 5),
strides=(1, 1),
padding="valid"))
#model.add(Conv2D(filters=16, kernel_size=(5, 5), padding="same"))
model.add(Activation(activation))
# ---S4
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# ---C5
# define the first FC => ACTIVATION layers
model.add(Flatten()) #vectorize the input matrixs
model.add(
Dense(units=120, activation=None,
use_bias=True)) #output=activation(dot(input,kernel) + bias)
# units --> dimensionality of the output space
model.add(Activation(activation))
# ---FC6
# define the second FC layer
model.add(Dense(units=84, activation=None, use_bias=True))
model.add(Activation(activation))
# ---FC7
# define the third FC layer
model.add(Dense(units=numClasses, use_bias=True))
# Output
# lastly, define the soft-max classifier
model.add(Activation("softmax"))
# if a weights path is supplied (indicating that the model was
# pre-trained), then load the weights
if weightsPath is not None:
model.load_weights(weightsPath)
# return the constructed network architecture
return model
def train(img_w, train_data, val_data):
# Input Parameters
img_h = 64
# Network parameters
conv_filters = 16
kernel_size = (3, 3)
pool_size = 2
time_dense_size = 32
rnn_size = 512
if K.image_data_format() == 'channels_first':
input_shape = (1, img_w, img_h)
else:
input_shape = (img_w, img_h, 1)
batch_size = 32
downsample_factor = pool_size**2
tiger_train = ImageGenerator(train_data, img_w, img_h, batch_size,
downsample_factor)
tiger_train.build_data()
tiger_val = ImageGenerator(val_data, img_w, img_h, batch_size,
downsample_factor)
tiger_val.build_data()
act = 'relu'
input_data = Input(name='the_input', shape=input_shape, dtype='float32')
inner = Conv2D(conv_filters,
kernel_size,
padding='same',
activation=act,
kernel_initializer='he_normal',
name='conv1')(input_data)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner)
inner = Conv2D(conv_filters,
kernel_size,
padding='same',
activation=act,
kernel_initializer='he_normal',
name='conv2')(inner)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max2')(inner)
conv_to_rnn_dims = (img_w // (pool_size**2),
(img_h // (pool_size**2)) * conv_filters)
inner = Reshape(target_shape=conv_to_rnn_dims, name='reshape')(inner)
# cuts down input size going into RNN:
inner = Dense(time_dense_size, activation=act, name='dense1')(inner)
# Two layers of bidirecitonal LSTMs
lstm_1 = LSTM(rnn_size,
return_sequences=True,
kernel_initializer='he_normal',
name='lstm1')(inner)
lstm_1b = LSTM(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='lstm1_b')(inner)
lstm1_merged = add([lstm_1, lstm_1b])
lstm_2 = LSTM(rnn_size,
return_sequences=True,
kernel_initializer='he_normal',
name='lstm2')(lstm1_merged)
lstm_2b = LSTM(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='lstm2_b')(lstm1_merged)
# transforms RNN output to character activations:
inner = Dense(tiger_train.get_output_size(),
kernel_initializer='he_normal',
name='dense2')(concatenate([lstm_2, lstm_2b]))
y_pred = Activation('softmax', name='softmax')(inner)
Model(inputs=input_data, outputs=y_pred).summary()
labels = Input(name='the_labels',
shape=[tiger_train.max_text_len],
dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
loss_out = Lambda(ctc_lambda_func, output_shape=(1, ),
name='ctc')([y_pred, labels, input_length, label_length])
# clipnorm seems to speeds up convergence
sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
model = Model(inputs=[input_data, labels, input_length, label_length],
outputs=loss_out)
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)
model.fit_generator(generator=tiger_train.next_batch(),
steps_per_epoch=tiger_train.n,
epochs=1,
validation_data=tiger_val.next_batch(),
validation_steps=tiger_val.n)
return model
def SimpleNet(yoloNet):
model = Sequential()
#Convolution Layer 2 & Max Pooling Layer 3
# model.add(ZeroPadding2D(padding=(1,1),input_shape=(3,448,448)))
l = yoloNet.layers[1]
if l.weights is None or l.biases is None:
model.add(
Convolution2D(64,
7,
7,
input_shape=(3, 448, 448),
init='he_uniform',
border_mode='same',
subsample=(2, 2)))
else:
model.add(
Convolution2D(
64,
7,
7,
input_shape=(3, 448, 448),
weights=[yoloNet.layers[1].weights, yoloNet.layers[1].biases],
border_mode='same',
subsample=(2, 2)))
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
layer_cnt = 3
#Use a for loop to replace all manually defined layers
for i in range(3, yoloNet.layer_number):
l = yoloNet.layers[i]
# print i, len(model.layers)
if (l.type == "CONVOLUTIONAL"):
# print l.size, l.n, l.c, l.h, l.w
sub = (1, 1)
if i == 26: # modify convolution stride
sub = (2, 2)
model.add(ZeroPadding2D(padding=(
l.size // 2,
l.size // 2,
)))
if l.weights is None or l.biases is None:
model.add(
Convolution2D(l.n,
l.size,
l.size,
init='he_uniform',
border_mode='valid',
subsample=sub))
else:
model.add(
Convolution2D(l.n,
l.size,
l.size,
weights=[l.weights, l.biases],
border_mode='valid',
subsample=sub))
model.add(LeakyReLU(alpha=0.1))
layer_cnt += 3
elif (l.type == "MAXPOOL"):
model.add(MaxPooling2D(pool_size=(2, 2), border_mode='valid'))
layer_cnt += 1
elif (l.type == "FLATTEN"):
model.add(Flatten())
layer_cnt += 1
elif (l.type == "CONNECTED"):
# print l.input_size, l.output_size, l.weights.shape, l.biases.shape
if l.weights is None or l.biases is None:
model.add(Dense(l.output_size, init='he_uniform'))
else:
model.add(Dense(l.output_size, weights=[l.weights, l.biases]))
layer_cnt += 1
elif (l.type == "LEAKY"):
model.add(LeakyReLU(alpha=0.1))
layer_cnt += 1
elif (l.type == "DROPOUT"):
model.add(Dropout(0.5))
layer_cnt += 1
else:
print "Error: Unknown Layer Type", l.type
return model
def VGG_16():
model = Sequential()
model.add(ZeroPadding2D((1, 1), input_shape=(3, 224, 224)))
model.add(Convolution2D(64, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(64, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), stride=(2,2)))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(128, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(128, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), stride=(2,2)))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(256, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), stride=(2,2)))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), stride=(2,2)))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(ZeroPadding2D((1,1)))
model.add(Convolution2D(512, 3, 3, activation='relu'))
model.add(MaxPooling2D((2,2), stride=(2,2)))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
f = h5py.File('weights/vgg16_weights.h5')
for k in range(f.attrs['nb_layers']):
if k >= len(model.layers):
# we don't look at the last (fully-connected) layers in the savefile
break
g = f['layer_{}'.format(k)]
weights = [g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])]
model.layers[k].set_weights(weights)
f.close()
print('Model loaded.')
model.add(Dense(10, activation='softmax'))
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss='categorical_crossentropy')
return model
def pooling_func(x):
if pooltype == 1:
return AveragePooling2D((2, 2), strides=(2, 2))(x)
else:
return MaxPooling2D((2, 2), strides=(2, 2))(x)
def build_cross(input_shape, num_outputs, block_fn, repetitions):
"""Builds a custom ResNet like architecture.
Args:
input_shape: The input shape in the form (nb_channels, nb_rows, nb_cols)
num_outputs: The number of outputs at final softmax layer
block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
The original paper used basic_block for layers < 50
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size is halved
Returns:
The keras `Model`.
"""
_handle_dim_ordering()
if len(input_shape) != 3:
raise Exception(
"Input shape should be a tuple (nb_channels, nb_rows, nb_cols)"
)
# Permute dimension order if necessary
if K.image_dim_ordering() == 'tf':
input_shape = (input_shape[1], input_shape[2], input_shape[0])
# Load function from str if needed.
block_fn = _get_block(block_fn)
input = Input(shape=input_shape)
conv1 = _conv_bn_relu(filters=64, kernel_size=(7, 7),
strides=(2, 2))(input)
pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2),
padding="same")(conv1)
init = pool1
#first branch
block = init
filters = 64
branch_list_1 = []
for i, r in enumerate(repetitions):
block = _residual_block(block_fn,
filters=filters,
repetitions=r,
is_first_layer=(i == 0))(block)
filters *= 2
branch_list_1.append(block)
block_branch_1 = block
#second branch
block = init
filters = 64
branch_list_2 = []
for i, r in enumerate(repetitions):
#print(i)
if (i == 0):
block = _shortcut(branch_list_1[3], block)
#block = block
elif (i == 1):
block = _shortcut(branch_list_1[0], block)
elif (i == 2):
block = _shortcut(branch_list_1[1], block)
elif (i == 3):
block = _shortcut(branch_list_1[2], block)
block = _residual_block(block_fn,
filters=filters,
repetitions=r,
is_first_layer=(i == 0))(block)
filters *= 2
branch_list_2.append(block)
block_branch_2 = block
#third branch
block = init
filters = 64
branch_list_3 = []
for i, r in enumerate(repetitions):
if (i == 0):
block = _shortcut(branch_list_2[3], block)
#block =block
elif (i == 1):
block = _shortcut(branch_list_2[0], block)
elif (i == 2):
block = _shortcut(branch_list_2[1], block)
elif (i == 3):
block = _shortcut(branch_list_2[2], block)
block = _residual_block(block_fn,
filters=filters,
repetitions=r,
is_first_layer=(i == 0))(block)
filters *= 2
branch_list_3.append(block)
block_branch_3 = block
print("init block size", block_branch_3)
#merge
block = AddWeight(weight_size=3, name="add_weight")(
[block_branch_1, block_branch_2, block_branch_3])
#block = block_branch_3
#print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",block.shape)
# Last activation
block = _bn_relu(block)
# Classifier block
block_shape = K.int_shape(block)
pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS],
block_shape[COL_AXIS]),
strides=(1, 1))(block)
flatten1 = Flatten()(pool2)
dense = Dense(units=num_outputs,
kernel_initializer="he_normal",
activation="softmax")(flatten1)
model = Model(inputs=input, outputs=dense)
return model
def build(width=224, height=224, depth=3, classes=1000, weightsPath=None):
input_shape = (height, width, depth)
model = Sequential()
model.add(Conv2D(32, (3, 3), padding="same", input_shape=input_shape))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(64, (3, 3), padding="same", input_shape=input_shape))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(128, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(64, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(128, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(256, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(128, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(256, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(512, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(256, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(512, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(256, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(512, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(1024, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(512, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(1024, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(512, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(1024, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
'''model.add(Conv2D(classes, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=0.1))'''
model.add(GlobalAveragePooling2D(data_format="channels_last"))
model.add(Dense(classes))
model.add(BatchNormalization())
model.add(Activation("sigmoid"))
# model.add(Dropout(0.5)) #Não há dropout no paper original
# model.add(Dense(classes))
'''if classes == 1:
model.add(Activation("sigmoid"))
else:
model.add(Activation("softmax"))'''
if weightsPath is not None:
model.load_weights(weightsPath)
return model
def init_model(preload=None,
declare=False,
use_inception=True,
use_resnet=False):
print 'Compiling model...'
if use_multiscale and use_inception and use_resnet:
raise ValueError('Incorrect params')
if not declare and preload: return load_model(preload)
if use_multiscale: return multiscale_model(preload)
if use_multicrop: return multicrop_model(preload)
if use_resnet:
if not preload:
weights_path = ROOT + '/resnet50_tf_notop.h5'
body = ResNet50(input_shape=(img_width, img_width, channels),
weights_path=weights_path)
for layer in body.layers:
layer.trainable = False
head = body.output
batchnormed = BatchNormalization(axis=3)(head)
avgpooled = GlobalAveragePooling2D()(batchnormed)
# dropout = Dropout(0.3) (avgpooled)
dense = Dense(128)(avgpooled)
batchnormed = BatchNormalization()(dense)
relu = PReLU()(batchnormed)
dropout = Dropout(0.2)(relu)
output = Dense(1, activation="sigmoid")(dropout)
model = Model(body.input, output)
if preload: model.load_weights(preload)
return model
if use_inception:
if preload: return load_model(preload)
return inception_v4()
else:
model = Sequential()
model.add(
ZeroPadding2D((1, 1),
input_shape=(img_width, img_height, channels)))
model.add(Convolution2D(16, 3, 3, activation="linear"))
model.add(ELU())
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(16, 3, 3, activation="linear"))
model.add(ELU())
model.add(MaxPooling2D(pool_size=(5, 5)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(32, 3, 3, activation="linear"))
model.add(ELU())
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(32, 3, 3, activation="linear"))
model.add(ELU())
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(32, 3, 3, activation="linear"))
model.add(ELU())
model.add(MaxPooling2D(pool_size=(3, 3)))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation="linear"))
model.add(ELU())
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation="linear"))
model.add(ELU())
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation="linear"))
model.add(ELU())
model.add(MaxPooling2D(pool_size=(3, 3)))
model.add(Flatten())
model.add(Dense(64, activation='linear'))
model.add(ELU())
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
if preload: model.load_weights(preload)
return model
def train_model(X_train,
y_train,
X_validation,
y_validation,
batch_size=128): #64
'''
Trains 2D convolutional neural network
:param X_train: Numpy array of mfccs
:param y_train: Binary matrix based on labels
:return: Trained model
'''
# Get row, column, and class sizes
rows = X_train[0].shape[0]
cols = X_train[0].shape[1]
val_rows = X_validation[0].shape[0]
val_cols = X_validation[0].shape[1]
num_classes = len(y_train[0])
# input image dimensions to feed into 2D ConvNet Input layer
input_shape = (rows, cols, 1)
X_train = X_train.reshape(X_train.shape[0], rows, cols, 1)
X_validation = X_validation.reshape(X_validation.shape[0], val_rows,
val_cols, 1)
print('X_train shape:', X_train.shape)
print(X_train.shape[0], 'training samples')
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
data_format="channels_last",
input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
# Stops training if accuracy does not change at least 0.005 over 10 epochs
es = EarlyStopping(monitor='acc',
min_delta=.005,
patience=10,
verbose=1,
mode='auto')
# Creates log file for graphical interpretation using TensorBoard
tb = TensorBoard(log_dir='../logs',
histogram_freq=0,
batch_size=32,
write_graph=True,
write_grads=True,
write_images=True,
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None)
# Image shifting
datagen = ImageDataGenerator(width_shift_range=0.05)
# Fit model using ImageDataGenerator
model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size),
steps_per_epoch=len(X_train) / 32,
epochs=EPOCHS,
callbacks=[es, tb],
validation_data=(X_validation, y_validation))
return (model)
def multiscale_model(preload=None):
shared_conv_1 = Convolution2D(num_filters, 3, 3, activation="linear")
shared_conv_2 = Convolution2D(num_filters, 3, 3, activation="linear")
input_1 = Input(shape=(channels, w1, h1))
zero_pad_1 = ZeroPadding2D((1, 1))(input_1)
conved_1 = shared_conv_1(zero_pad_1)
elu_1 = ELU()(conved_1)
zero_pad_2 = ZeroPadding2D((1, 1))(elu_1)
conved_2 = shared_conv_2(zero_pad_2)
elu_2 = ELU()(conved_2)
pool_1 = MaxPooling2D(pool_size=(4, 4), strides=(4, 4))(elu_2)
input_2 = Input(shape=(channels, w2, h2))
zero_pad_1 = ZeroPadding2D((1, 1))(input_2)
conved_1 = shared_conv_1(zero_pad_1)
elu_1 = ELU()(conved_1)
zero_pad_2 = ZeroPadding2D((1, 1))(elu_1)
conved_2 = shared_conv_2(zero_pad_2)
elu_2 = ELU()(conved_2)
pool_2 = MaxPooling2D(pool_size=(3, 3), strides=(3, 3))(elu_2)
input_3 = Input(shape=(channels, w3, h3))
zero_pad_1 = ZeroPadding2D((1, 1))(input_3)
conved_1 = shared_conv_1(zero_pad_1)
elu_1 = ELU()(conved_1)
zero_pad_2 = ZeroPadding2D((1, 1))(elu_1)
conved_2 = shared_conv_2(zero_pad_2)
elu_2 = ELU()(conved_2)
pool_3 = MaxPooling2D(pool_size=(5, 5), strides=(5, 5))(elu_2)
multiscaleInputBlock = merge([pool_1, pool_2, pool_3],
mode='concat',
concat_axis=1)
zero_pad_1 = ZeroPadding2D((1, 1))(multiscaleInputBlock)
conved_1 = Convolution2D(64, 3, 3, activation='linear')(zero_pad_1)
elu_1 = ELU()(conved_1)
zero_pad_2 = ZeroPadding2D((1, 1))(elu_1)
conved_2 = Convolution2D(64, 3, 3, activation='linear')(zero_pad_2)
elu_2 = ELU()(conved_2)
zero_pad_3 = ZeroPadding2D((1, 1))(elu_2)
conved_3 = Convolution2D(64, 3, 3, activation='linear')(zero_pad_3)
elu_3 = ELU()(conved_3)
dropout = Dropout(0.5)(elu_3)
pool = MaxPooling2D(pool_size=(5, 5))(dropout)
zero_pad_1 = ZeroPadding2D((1, 1))(pool)
conved_1 = Convolution2D(128, 3, 3, activation='linear')(zero_pad_1)
elu_1 = ELU()(conved_1)
zero_pad_2 = ZeroPadding2D((1, 1))(elu_1)
conved_2 = Convolution2D(128, 3, 3, activation='linear')(zero_pad_2)
elu_2 = ELU()(conved_2)
zero_pad_3 = ZeroPadding2D((1, 1))(elu_2)
conved_3 = Convolution2D(128, 3, 3, activation='linear')(zero_pad_3)
elu_3 = ELU()(conved_3)
dropout = Dropout(0.5)(elu_3)
pool = MaxPooling2D(pool_size=(3, 3))(dropout)
flat = Flatten()(pool)
dense_1 = Dense(1024, activation="linear")(flat)
elu_1 = ELU()(dense_1)
dropout_1 = Dropout(0.5)(elu_1)
output = Dense(1, activation="sigmoid")(dropout_1)
model = Model(input=[input_1, input_2, input_3], output=output)
if preload:
model.load_weights(preload)
return model
print(" <Setting> root location: %s"%(root))
print(" <Setting> relative image location: %s"%(images_path))
print(" <Setting> relative pairs.txt location: %s\n"%(pair_txt_path))
raw_images, flipped_raw_images, raw_labels = read_dataset(path=root+images_path, size=32)
trainData1, trainData2, train_labels, testData1, testData2, test_labels = lfw_train_test(root, pair_txt_path, raw_images, flipped_raw_images, raw_labels, foldnum, includeflipped=True)
train_data = np.concatenate((trainData1, trainData2), axis=-1) / 255.0
test_data = np.concatenate((testData1, testData2), axis=-1) /255.0
train_labels = np_utils.to_categorical(train_labels, 2)
test_labels = np_utils.to_categorical(test_labels, 2)
model = Sequential()
model.add(Convolution2D(filters = 20, kernel_size = (5, 5), padding = "same", input_shape = (32, 32, 2)))
model.add(Activation(activation = "relu"))
model.add(MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))
model.add(Convolution2D(filters = 50, kernel_size = (5, 5), padding = "same"))
model.add(Activation(activation = "relu"))
model.add(MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))
model.add(Flatten())
model.add(Dense(150))
model.add(Activation(activation = "relu"))
model.add(Dense(50))
model.add(Activation(activation = "relu"))
model.add(Dense(2))
model.add(Activation("softmax"))
model.compile(loss = "categorical_crossentropy", optimizer = keras.optimizers.RMSprop(), metrics = ["accuracy"])
history = model.fit(train_data, train_labels, batch_size = 128, nb_epoch = 100, verbose = 1, validation_data=(test_data, test_labels),shuffle=True)
def ConvBlock(self, layers, filters):
model = self.model
for i in range(layers):
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(filters, 3, 3, activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
# 모델 구성(Input -> CONV(ReLU) -> CONV(ReLU) -> Pool(2) -> FC(relu) -> FC(softmax))
model = Sequential()
#필터가 10개이고, 필터 사이즈가 (3,3), Stride가 1인 Conv Layer를 추가합니다.
model.add(
Convolution2D(input_shape=(28, 28, 1),
filters=10,
kernel_size=(3, 3),
strides=1,
padding='same'))
#Activation Function 으로 Relu를 사용하였습니다.
model.add(Activation('relu'))
#필터가 20개이고, 필터 사이즈가 (3,3), Stride가 1인 Conv Layer를 추가합니다.
model.add(Convolution2D(filters=20, kernel_size=(3, 3), strides=1))
model.add(Activation('relu'))
#이미지의 차원을 줄이기 위해서 Pooling Layer를 넣었습니다.
model.add(MaxPooling2D(pool_size=(2, 2)))
#0.25의 확률의 Dropout 시행
model.add(Dropout(0.25))
#FC Layer에 넣기 위해서 2차원 배열로 되어 있는 이미지 인풋을 Flattern 해 줍니다.
model.add(Flatten())
#Output Node 가 128개인 FC Layer
model.add(Dense(128))
model.add(Activation('relu'))
#Output Node 가 10개인 FC Layer
model.add(Dense(10))
#Output 벡터의 합을 1로 만들어주기 위해서 softmax 함수를 사용했습니다.
model.add(Activation('softmax'))
# #Keras Documentation 을 참고하여 Adam Optimizer 를 이용하였습니다.
model.compile(loss='mean_squared_error',
optimizer='sgd',
metrics=['accuracy'])
def maintrainnet():
tupledata=processwav()
for i in np.arange( len(tupledata) ):
tupledata[i][0]=tupledata[i][0][0:40]
sessionTrain, sessionTest = train_test_split(tupledata, test_size=0.1)
start = time.time()
window=2
allUt = []
allLabels = []
utteranceByFeat = []
labelsByFeat = []
portionSelection=1.0
for utterance in (sessionTrain):
allUt.append([utterance[0]])
allLabels.append(encodeLabels(utterance[1]))
print '----SHAPE--- ',np.array(allUt).shape
testUtterance = []
X_test = []
Y_test = []
#X_train=np.array()
for utterance in (sessionTest):
X_test.append([utterance[0]])
Y_test.append(encodeLabels(utterance[1]))
end = time.time()
print 'segment level feature extraction total time: ' +str(end - start)
print 'building middle layer'
#nb_filters = 100
# size of pooling area for max pooling
nb_pool = 2
# convolution kernel size
nb_conv = 2
voice_rows=240
voice_cols=100
nb_filters = 32
# size of pooling area for max pooling
nb_pool = 2
# convolution kernel size
nb_conv = 3
model=Sequential()
model.add(
Convolution2D( 20, 3, 3, border_mode='same',input_shape=(1, 40, 40) )
)
model.add(Activation('relu'))
#model.add(MaxPooling2D(poolsize=(2, 2)))
model.add(MaxPooling2D(pool_size=(2, 2)))
#model.add(Convolution2D(10,5,5))
model.add(Dropout(0.25))
model.add(Convolution2D( 40, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
#model.add(Convolution2D(20, 5, 5))
model.add(Convolution2D(60, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Convolution2D(80, 2, 2))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(80*2*2))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(6))
model.add(Activation('softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=["accuracy"])
#print 'allUt shape is ',np.array(allUt).shape
X_train=np.array(allUt)
X_test=np.array(X_test)
print 'shape is ',X_test.shape
X_train = X_train.reshape(X_train.shape[0], 1, 40, 40)
X_train = X_train.astype('float32')
#X_test = X_test.reshape(X_test.shape[0], 1, 40, 40)
X_test = X_test.astype('float32')
print 'X_train.shape IS ',X_train.shape
print 'X_test.shape IS ',X_test.shape
model.fit(X_train, np.array(allLabels),
validation_data=(X_test, np.array(Y_test)), nb_epoch=50, batch_size=40,show_accuracy=True, shuffle=True)
print 'estimating emotion state prob. distribution'
stateEmotions = []
#score = model.evaluate(X_test, np.array(Y_test), show_accuracy=False, verbose=0)
score = model.evaluate(X_test, np.array(Y_test), show_accuracy=True, verbose=0)
print 'Test scores is ',score