Convolution2D(
batch_input_shape=(None, 1, 28, 28),
filters=32,
kernel_size=5,
strides=1,
padding='same',
data_format='channels_first',
))
model.add(Activation('relu'))
# MaxPool2D, 二维最大池化层
# output shape = (32, 14, 14)
model.add(
MaxPool2D(
pool_size=2,
strides=2,
padding='same',
data_format='channels_first',
))
# output shape = (64, 14, 14)
model.add(
Convolution2D(
filters=64,
kernel_size=5,
strides=1,
padding='same',
data_format='channels_first',
))
model.add(Activation('relu'))
# output shape = (64, 7, 7)
#example:
print(y_train[0])
model = Sequential()
model.add(
Conv2D(filters=16,
kernel_size=(3, 3),
activation='relu',
input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
model.add(BatchNormalization())
#model.add(Conv2D(filters = 16, kernel_size = (3, 3), activation='relu'))
#model.add(BatchNormalization())
model.add(MaxPool2D(strides=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))
model.add(BatchNormalization())
#model.add(Conv2D(filters = 32, kernel_size = (3, 3), activation='relu'))
#model.add(BatchNormalization())
model.add(MaxPool2D(strides=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
def ResNet152(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the ResNet152 architecture.
Optionally loads weights pre-trained
on ImageNet. Note that when using TensorFlow,
for best performance you should set
`image_data_format='channels_last'` in your Keras config
at ~/.keras/keras.json.
The model and the weights are compatible with both
TensorFlow and Theano. The data format
convention used by the model is the one
specified in your Keras config file.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 197.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
WEIGHTS_PATH = None
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=197,
data_format=K.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if K.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
x = Conv2D(64, (7, 7), strides=(2, 2), padding='same',
name='conv1')(img_input)
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPool2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
x = AvgPool2D((7, 7), name='avg_pool')(x)
if include_top:
x = Flatten()(x)
x = Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = GlobalAvgPool2D()(x)
elif pooling == 'max':
x = GlobalMaxPool2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='resnet152')
# load weights
if weights == 'imagenet':
weights_path = get_file('resnet152_weights_tf.h5',
WEIGHTS_PATH,
cache_subdir='models')
if include_top:
model.load_weights(weights_path)
else:
f = h5py.File(weights_path)
layer_names = [name for name in f.attrs['layer_names']]
for i, layer in enumerate(model.layers):
g = f[layer_names[i]]
weights = [g[name] for name in g.attrs['weight_names']]
layer.set_weights(weights)
if K.backend() == 'theano':
layer_utils.convert_all_kernels_in_model(model)
if include_top:
maxpool = model.get_layer(name='avg_pool')
shape = maxpool.output_shape[1:]
dense = model.get_layer(name='fc1000')
layer_utils.convert_dense_weights_data_format(
dense, shape, 'channels_first')
if K.image_data_format() == 'channels_first' and K.backend(
) == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
elif weights is not None:
model.load_weights(weights)
return model
padding='valid',
kernel_initializer='normal',
activation='relu')(reshape)
conv_1 = Conv2D(num_filters,
kernel_size=(filter_sizes[1], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu')(reshape)
conv_2 = Conv2D(num_filters,
kernel_size=(filter_sizes[2], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu')(reshape)
maxpool_0 = MaxPool2D(pool_size=(sequence_length - filter_sizes[0] + 1, 1),
strides=(1, 1),
padding='valid')(conv_0)
maxpool_1 = MaxPool2D(pool_size=(sequence_length - filter_sizes[1] + 1, 1),
strides=(1, 1),
padding='valid')(conv_1)
maxpool_2 = MaxPool2D(pool_size=(sequence_length - filter_sizes[2] + 1, 1),
strides=(1, 1),
padding='valid')(conv_2)
concatenated_tensor = Concatenate(axis=1)([maxpool_0, maxpool_1, maxpool_2])
flatten = Flatten()(concatenated_tensor)
dropout = Dropout(drop)(flatten)
output = Dense(5, activation='softmax')(dropout)
# this creates a model that includes
model = Model(inputs=inputs, outputs=output)
# 2. 모델
# model = Sequential()
# model.add(Con))
# model.add(Flatten())
# model.add(Dense(1))
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Conv2D(
32,
(3, 3),
padding='same',
))
model.add(MaxPool2D(
pool_size=2)) # MaxPool 자원소모 x Conv2D + MaxPool2D 한 layer라고 생각하는게 편함
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
model.summary()
# model.save('./model/model_test01.h5')
# 3. 훈련
from keras.callbacks import EarlyStopping
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['acc']) # metrics = ['acc']
earlystopping = EarlyStopping(monitor='loss', patience=3, mode='min')
hist = model.fit(x_train,
training_img.append(img)
training_txt.append(encode_to_labels(txt))
if i == 150000:
flag = 1
break
i+=1
if flag == 1:
break
train_padded_txt = pad_sequences(training_txt, maxlen=max_label_len, padding='post', value = len(char_list))
valid_padded_txt = pad_sequences(valid_txt, maxlen=max_label_len, padding='post', value = len(char_list))
inputs = Input(shape=(32,128,1))
conv_1 = Conv2D(64, (3,3), activation = 'relu', padding='same')(inputs)
pool_1 = MaxPool2D(pool_size=(2, 2), strides=2)(conv_1)
conv_2 = Conv2D(128, (3,3), activation = 'relu', padding='same')(pool_1)
pool_2 = MaxPool2D(pool_size=(2, 2), strides=2)(conv_2)
conv_3 = Conv2D(256, (3,3), activation = 'relu', padding='same')(pool_2)
conv_4 = Conv2D(256, (3,3), activation = 'relu', padding='same')(conv_3)
pool_4 = MaxPool2D(pool_size=(2, 1))(conv_4)
conv_5 = Conv2D(512, (3,3), activation = 'relu', padding='same')(pool_4)
batch_norm_5 = BatchNormalization()(conv_5)
conv_6 = Conv2D(512, (3,3), activation = 'relu', padding='same')(batch_norm_5)
batch_norm_6 = BatchNormalization()(conv_6)
pool_6 = MaxPool2D(pool_size=(2, 1))(batch_norm_6)
# setup model
model = Sequential()
# 1st Conv2D layer
model.add(
Convolution2D(filters=32,
kernel_size=[5, 5],
padding='same',
input_shape=(28, 28, 1)))
model.add(Activation('relu'))
model.add(MaxPool2D(
pool_size=(2, 2),
strides=(2, 2),
padding="same",
))
# 2nd Conv2D layer
model.add(Convolution2D(
filters=64,
kernel_size=(5, 5),
padding='same',
))
model.add(Activation('relu'))
model.add(MaxPool2D(
pool_size=(2, 2),
strides=(2, 2),
padding="same",
def make_model(in_shape, layers, initial_depth, prefix=''):
# type: (Tuple[int, int, int], int, int, str) -> keras.models.Model
"""
A simple, crop-free UNET for quick experimentation and baseline references
:param in_shape:
:param layers:
:param initial_depth:
:param prefix:
:return:
>>> simple_model = make_model((32, 32, 1), 2, 8, prefix='HI')
>>> len(simple_model.layers)
20
>>> simple_model.summary()
__________________________________________________________________________________________________
Layer (type) Output Shape Param # Connected to
==================================================================================================
UNET_HI_Input (InputLayer) (None, 32, 32, 1) 0
__________________________________________________________________________________________________
CONV_HI_0 (Conv2D) (None, 32, 32, 8) 80 UNET_HI_Input[0][0]
__________________________________________________________________________________________________
BN_HI_0 (BatchNormalization) (None, 32, 32, 8) 32 CONV_HI_0[0][0]
__________________________________________________________________________________________________
RELU_HI_0 (Activation) (None, 32, 32, 8) 0 BN_HI_0[0][0]
__________________________________________________________________________________________________
MP_HI_0 (MaxPooling2D) (None, 16, 16, 8) 0 RELU_HI_0[0][0]
__________________________________________________________________________________________________
CONV_HI_1 (Conv2D) (None, 16, 16, 16) 1168 MP_HI_0[0][0]
__________________________________________________________________________________________________
BN_HI_1 (BatchNormalization) (None, 16, 16, 16) 64 CONV_HI_1[0][0]
__________________________________________________________________________________________________
RELU_HI_1 (Activation) (None, 16, 16, 16) 0 BN_HI_1[0][0]
__________________________________________________________________________________________________
MP_HI_1 (MaxPooling2D) (None, 8, 8, 16) 0 RELU_HI_1[0][0]
__________________________________________________________________________________________________
DECONV_HI_1 (Conv2DTranspose) (None, 16, 16, 16) 2320 MP_HI_1[0][0]
__________________________________________________________________________________________________
SKIP_HI_1 (Concatenate) (None, 16, 16, 24) 0 DECONV_HI_1[0][0]
MP_HI_0[0][0]
__________________________________________________________________________________________________
BN_HI_U1 (BatchNormalization) (None, 16, 16, 24) 96 SKIP_HI_1[0][0]
__________________________________________________________________________________________________
RELU_HI_U1 (Activation) (None, 16, 16, 24) 0 BN_HI_U1[0][0]
__________________________________________________________________________________________________
DECONV_HI_0 (Conv2DTranspose) (None, 32, 32, 8) 1736 RELU_HI_U1[0][0]
__________________________________________________________________________________________________
SKIP_HI_0 (Concatenate) (None, 32, 32, 9) 0 DECONV_HI_0[0][0]
UNET_HI_Input[0][0]
__________________________________________________________________________________________________
BN_HI_U0 (BatchNormalization) (None, 32, 32, 9) 36 SKIP_HI_0[0][0]
__________________________________________________________________________________________________
RELU_HI_U0 (Activation) (None, 32, 32, 9) 0 BN_HI_U0[0][0]
==================================================================================================
Total params: 5,532
Trainable params: 5,418
Non-trainable params: 114
__________________________________________________________________________________________________
"""
in_layer = Input(in_shape, name='UNET_{}_Input'.format(prefix))
start_x = in_layer
skip_layers = []
for c_layer in range(layers + 1):
skip_layers += [start_x]
x = Conv2D(filters=initial_depth * 2 ** c_layer,
kernel_size=(3, 3),
activation='linear',
padding='same',
name='CONV_{}_{}'.format(prefix, c_layer))(start_x)
x = BatchNormalization(name='BN_{}_{}'.format(prefix, c_layer))(x)
x = Activation('relu', name='RELU_{}_{}'.format(prefix, c_layer))(x)
start_x = MaxPool2D((2, 2), name='MP_{}_{}'.format(prefix, c_layer))(x)
start_x = x
for c_layer, c_skip in reversed(list(zip(range(layers), skip_layers))):
x = Deconv2D(filters=initial_depth * 2 ** c_layer,
kernel_size=(3, 3),
strides=(2, 2),
activation='linear',
padding='same',
name='DECONV_{}_{}'.format(prefix, c_layer)
)(start_x)
x = concatenate([x, c_skip], name='SKIP_{}_{}'.format(prefix, c_layer))
x = BatchNormalization(name='BN_{}_U{}'.format(prefix, c_layer))(x)
x = Activation('relu', name='RELU_{}_U{}'.format(prefix, c_layer))(x)
start_x = x
return Model(inputs=[in_layer], outputs=[x], name='UNET_{}'.format(prefix))
def get_model(img_shape, classes_num, last_activation):
block0_input = Input(shape=(img_shape, img_shape, 3))
block1_conv1 = Conv2D(64, (3, 3), padding="same",
activation="relu")(block0_input)
block1_conv2 = Conv2D(64, (3, 3), padding="same",
activation="relu")(block1_conv1)
block1_conv3 = Conv2D(64, (3, 3), padding="same",
activation="relu")(block1_conv2)
block1_pool1 = MaxPool2D(2)(block1_conv3)
block2_conv1 = Conv2D(128, (3, 3), padding="same",
activation="relu")(block1_pool1)
block2_conv2 = Conv2D(128, (3, 3), padding="same",
activation="relu")(block2_conv1)
block2_conv3 = Conv2D(128, (3, 3), padding="same",
activation="relu")(block2_conv2)
block2_pool1 = MaxPool2D(2)(block2_conv3)
block3_conv1 = Conv2D(256, (3, 3), padding="same",
activation="relu")(block2_pool1)
block3_conv2 = Conv2D(256, (3, 3), padding="same",
activation="relu")(block3_conv1)
block3_conv3 = Conv2D(256, (3, 3), padding="same",
activation="relu")(block3_conv2)
block3_pool1 = MaxPool2D(2)(block3_conv3)
block4_conv1 = Conv2D(512, (3, 3), padding="same",
activation="relu")(block3_pool1)
block4_conv2 = Conv2D(512, (3, 3), padding="same",
activation="relu")(block4_conv1)
block4_conv3 = Conv2D(512, (3, 3), padding="same",
activation="relu")(block4_conv2)
block4_upsa1 = UpSampling2D(2, interpolation="bilinear")(block4_conv3)
block5_conc1 = Concatenate()([block3_conv3, block4_upsa1])
block5_conv1 = Conv2D(256, (3, 3), padding="same",
activation="relu")(block5_conc1)
block5_conv2 = Conv2D(256, (3, 3), padding="same",
activation="relu")(block5_conv1)
block5_conv3 = Conv2D(256, (3, 3), padding="same",
activation="relu")(block5_conv2)
block5_upsa1 = UpSampling2D(2, interpolation="bilinear")(block5_conv3)
block6_conc1 = Concatenate()([block2_conv3, block5_upsa1])
block6_conv1 = Conv2D(128, (3, 3), padding="same",
activation="relu")(block6_conc1)
block6_conv2 = Conv2D(128, (3, 3), padding="same",
activation="relu")(block6_conv1)
block6_conv3 = Conv2D(128, (3, 3), padding="same",
activation="relu")(block6_conv2)
block6_upsa1 = UpSampling2D(2, interpolation="bilinear")(block6_conv3)
block7_conc1 = Concatenate()([block1_conv3, block6_upsa1])
block7_conv1 = Conv2D(64, (3, 3), padding="same",
activation="relu")(block7_conc1)
block7_conv2 = Conv2D(64, (3, 3), padding="same",
activation="relu")(block7_conv1)
block7_conv3 = Conv2D(64, (3, 3), padding="same",
activation="relu")(block7_conv2)
block8_output = Conv2D(classes_num, (1, 1),
padding="same",
activation=last_activation)(block7_conv3)
return Model(inputs=block0_input, outputs=block8_output)
epochs = 30
batch_size = 128
# this returns a tensor
print("Creating Model...")
model = Sequential()
model.add(
Embedding(input_dim=len(embeddings_matrix),
output_dim=embedding_dim,
weights=[embeddings_matrix],
input_length=sequence_length,
trainable=False))
model.add(Bidirectional(LSTM(300, dropout=0.3)))
model.add(MaxPool2D(pool_size=(1, 10), strides=(1, 1), padding='valid'))
model.add(Bidirectional(LSTM(300, dropout=0.3)))
model.add(MaxPool2D(pool_size=(1, 10), strides=(1, 1), padding='valid'))
model.add(Dense(units=2, activation='softmax'))
model.summary()
checkpoint = ModelCheckpoint(
'./lstm/lstm_word_pianpang_weights.{epoch:03d}-{val_acc:.4f}.hdf5',
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='auto')
adam = Adam(lr=1e-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(optimizer=adam, loss='binary_crossentropy', metrics=['accuracy'])
# TensorBoard
@author: omprakash """ from keras.models import Sequential # initialise neural network from keras.layers import Convolution2D # convolutional layer add from keras.layers import MaxPool2D from keras.layers import Flatten from keras.layers import Dense # to add fully connected layer in a cnn se = Sequential() # Convolution step - 32 filter with dimension 3*3, se.add(Convolution2D(32, 3, 3, input_shape=(64, 64, 3), activation='relu')) #pooling se.add(MaxPool2D(pool_size=(2, 2))) #u can add more convilution layer or fully connected layer to increase accuracy se.add(Convolution2D(32, 3, 3, activation='relu')) se.add(MaxPool2D(pool_size=(2, 2))) #flattening se.add(Flatten()) #Fully connected se.add(Dense(output_dim=128, activation='relu')) #when outcome more than 2 category then use softmax activation function se.add(Dense(1, activation='sigmoid')) #compiling the CNN #more 2 outcome use categorical_crossentropy
## 정규화
#from sklearn.preprocessing import MinMaxScaler
x_train = x_train.reshape(60000,28,28,1).astype('float32') / 255 ## float 안해줘도 되지 않나?
x_test = x_test.reshape(10000,28,28,1).astype('float32') / 255
from keras.models import Model
from keras.layers import Conv2D, Dense, Flatten, MaxPool2D, Dropout, Input
input1 = Input(shape = (28,28,1))
Conv1 = Conv2D(32, (3,3),activation='elu', padding = 'same', input_shape=(28,28,1))(input1)
Conv1 = Dropout(0.2)(Conv1)
Conv1 = Conv2D(32, (3,3),padding = 'same',activation='elu')(Conv1)
Conv1 = Dropout(0.2)(Conv1)
Conv1 = MaxPool2D((2,2))(Conv1)
Conv1 = Conv2D(64, (3,3),padding = 'same',activation='elu')(Conv1)
Conv1 = Dropout(0.2)(Conv1)
Conv1 = Conv2D(64, (3,3),padding = 'same',activation='elu')(Conv1)
Conv1 = Dropout(0.2)(Conv1)
Conv1 = MaxPool2D((2,2))(Conv1)
Conv1 = Conv2D(128, (3,3),padding = 'same',activation='elu')(Conv1)
Conv1 = Dropout(0.2)(Conv1)
Conv1 = Conv2D(128, (3,3),padding = 'same',activation='elu')(Conv1)
Conv1 = Dropout(0.2)(Conv1)
Conv1 = Flatten()(Conv1)
Dense1 = Dense(200, activation='elu')(Conv1)
def mlp(X, Y): #training an validation generator
model = Sequential() #initalise model
model.add(
Conv2D(64,
kernel_size=3,
activation='relu',
strides=(2, 2),
input_shape=(240, 240, 3))) # input layer
model.add(MaxPool2D(pool_size=(2, 2), padding='same')) #padding added
model.add(
Conv2D(128,
kernel_size=3,
activation='relu',
strides=(2, 2),
activity_regularizer=regularizers.l2(0.001))
) #regulization added to convolutional layer with lamda parameter 0.001
model.add(MaxPool2D(pool_size=(2, 2), padding='same'))
model.add(Flatten()) #allow connection to fukky connect layer
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.7))
model.add(Dense(1, activation='sigmoid'))
adam = optimizers.Adam(lr=0.1,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False) # optimzer created
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy']) #back propogation
callbacks = [
EarlyStopping(monitor='val_loss', patience=100),
ModelCheckpoint(filepath='best_model_glasses.h5',
monitor='val_loss',
save_best_only=True)
] #conditon for early stop when model stops improving
history = model.fit_generator(
X,
steps_per_epoch=X.n / X.batch_size,
epochs=100, # Maximum number of forward + back props
validation_data=Y,
validation_steps=Y.n / Y.batch_size,
callbacks=callbacks)
model.save_weights('first_try.h5')
model.summary()
#plots training graphs after trianing (accuracy and loss achieved)
print(history.history.keys())
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
plt.show()
def Network(height, width, depth, weights=None):
# Height: Image Height
# Width: Image Width
# Depth: Image Depth
# Weights: learned weights
# we will create this network with 3 classes
classes = 3
# Let's create the network
model = Sequential()
# Add 2 Convolution layers with 'relu' activations
# We will add one max pooling layer
model.add(
Conv2D(64,
kernel_size=(3, 3),
activation='relu',
padding='same',
input_shape=(depth, height, width)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu',
padding='same'))
model.add(MaxPool2D(pool_size=(2, 2)))
# Add 4 more Convolution layers with one max pool
model.add(
Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(
Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(
Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(
Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(MaxPool2D(2, 2))
# Add 4 More Convolution layers with another max pool
model.add(
Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(
Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(
Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(
Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(MaxPool2D(2, 2))
# Here we will convert 2D feature maps to 1D
model.add(Flatten())
# Add a Fully connected Layer with 50% drop-out
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.50))
# One more Fully connected layer here
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.50))
# Final layer with 3 outputs
model.add(Dense(classes, activation='softmax'))
# If learned weights provide load them into the network
if weights is not None:
model.load_weights(weights)
return model
def build_model(do_batch_norm, dropout, weight_decay, initial_learning_rate):
model = Sequential()
model.add(
Conv2D(
16,
(3, 3),
padding='same',
activation='relu',
input_shape=(32, 32, 3),
kernel_regularizer=regularizers.l2(weight_decay)
)
)
if do_batch_norm:
model.add(BatchNormalization())
model.add(
Conv2D(
16,
(3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l2(weight_decay)
)
)
if do_batch_norm:
model.add(BatchNormalization())
model.add(MaxPool2D())
model.add(
Conv2D(
16,
(3, 3),
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(weight_decay)
)
)
if do_batch_norm:
model.add(BatchNormalization())
model.add(
Conv2D(
32,
(3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l2(weight_decay)
)
)
if do_batch_norm:
model.add(BatchNormalization())
model.add(MaxPool2D())
model.add(
Conv2D(
32,
(3, 3),
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(weight_decay)
)
)
if do_batch_norm:
model.add(BatchNormalization())
model.add(
Conv2D(
64,
(3, 3),
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(weight_decay)
)
)
model.add(MaxPool2D())
model.add(Flatten())
if do_batch_norm:
model.add(BatchNormalization())
model.add(Dropout(dropout))
model.add(Dense(10, activation='softmax', kernel_regularizer=regularizers.l2(weight_decay)))
sgd = keras.optimizers.SGD(lr=initial_learning_rate, momentum=0.9, nesterov=True)
model.compile(
loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy']
)
model.summary()
return model
def get_test_model(params_transform,params_train,chaneels):
# params set
batch_size = int(params_train['batch_size'])
crop_size_x = int(params_transform['crop_size_x'])
crop_size_y = int(params_transform['crop_size_y'])
stride = int(params_transform['stride'])
stage_num = 6
# input output
image = Input(shape=(crop_size_y,crop_size_x,chaneels),
batch_shape=(batch_size,crop_size_y,crop_size_x,chaneels),
name='image')
net_input = [image]
image_padded = ZeroPadding2D()(image)
conv1_1 = Conv2D(filters=64,kernel_size=(3,3),activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(),name='conv1_1')(image_padded)
conv1_1_padded = ZeroPadding2D()(conv1_1)
conv1_2 = Conv2D(filters=64,kernel_size=(3,3),activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(),name='conv1_2')(conv1_1_padded)
pool1_stage1 = MaxPool2D(pool_size=(2,2),strides=2,name='pool1_stage1')(conv1_2)
pool1_stage1_padded = ZeroPadding2D()(pool1_stage1)
conv2_1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv2_1')(pool1_stage1_padded)
conv2_1_padded = ZeroPadding2D()(conv2_1)
conv2_2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv2_2')(conv2_1_padded)
# conv2_2 = ZeroPadding2D()(conv2_2)
pool2_stage1 = MaxPool2D(pool_size=(2,2),strides=2,name='pool2_stage1')(conv2_2)
pool2_stage1_padded = ZeroPadding2D()(pool2_stage1)
conv3_1 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_1')(pool2_stage1_padded)
conv3_1_padded = ZeroPadding2D()(conv3_1)
conv3_2 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_2')(conv3_1_padded)
conv3_2_padded = ZeroPadding2D()(conv3_2)
conv3_3 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_3')(conv3_2_padded)
conv3_3_padded = ZeroPadding2D()(conv3_3)
conv3_4 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_4')(conv3_3_padded)
pool3_stage1 = MaxPool2D(pool_size=(2, 2), strides=2, name='pool3_stage1')(conv3_4)
pool3_stage1_padded = ZeroPadding2D()(pool3_stage1)
conv4_1 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_1')(pool3_stage1_padded)
conv4_1_padded = ZeroPadding2D()(conv4_1)
conv4_2 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_2')(conv4_1_padded)
conv4_2_padded = ZeroPadding2D()(conv4_2)
conv4_3_CPM = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_3_CPM')(conv4_2_padded)
conv4_3_CPM_padded = ZeroPadding2D()(conv4_3_CPM)
conv4_4_CPM = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_4_CPM')(conv4_3_CPM_padded)
# stage 1
# L2 confidence maps
conv4_4_CPM_padded = ZeroPadding2D()(conv4_4_CPM)
conv5_1_CPM_L2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_1_CPM_L2')(conv4_4_CPM_padded)
conv5_1_CPM_L2_padded = ZeroPadding2D()(conv5_1_CPM_L2)
conv5_2_CPM_L2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_2_CPM_L2')(conv5_1_CPM_L2_padded)
conv5_2_CPM_L2_padded = ZeroPadding2D()(conv5_2_CPM_L2)
conv5_3_CPM_L2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_3_CPM_L2')(conv5_2_CPM_L2_padded)
conv5_3_CPM_L2_padded = ZeroPadding2D(padding=(0,0))(conv5_3_CPM_L2)
conv5_4_CPM_L2 = Conv2D(filters=512, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_4_CPM_L2')(conv5_3_CPM_L2_padded)
conv5_4_CPM_L2_padded = ZeroPadding2D(padding=(0,0))(conv5_4_CPM_L2)
conv5_5_CPM_L2 = Conv2D(filters=19, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_5_CPM_L2')(conv5_4_CPM_L2_padded)
# L1 PAFs
# conv4_4_CPM_padded = ZeroPadding2D()(conv4_4_CPM)
conv5_1_CPM_L1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_1_CPM_L1')(conv4_4_CPM_padded)
conv5_1_CPM_L1_padded = ZeroPadding2D()(conv5_1_CPM_L1)
conv5_2_CPM_L1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_2_CPM_L1')(conv5_1_CPM_L1_padded)
conv5_2_CPM_L1_padded = ZeroPadding2D()(conv5_2_CPM_L1)
conv5_3_CPM_L1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_3_CPM_L1')(conv5_2_CPM_L1_padded)
conv5_3_CPM_L1_padded = ZeroPadding2D(padding=(0, 0))(conv5_3_CPM_L1)
conv5_4_CPM_L1 = Conv2D(filters=512, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_4_CPM_L1')(conv5_3_CPM_L1_padded)
conv5_4_CPM_L1_padded = ZeroPadding2D(padding=(0, 0))(conv5_4_CPM_L1)
conv5_5_CPM_L1 = Conv2D(filters=38, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_5_CPM_L1')(conv5_4_CPM_L1_padded)
temp_L1 = conv5_5_CPM_L1
temp_L2 = conv5_5_CPM_L2
for i in range(2,stage_num+1):
concat_stagei = concatenate([temp_L1,temp_L2,conv4_4_CPM],axis=3)
# L1
concat_stage_padded = ZeroPadding2D(padding=(3,3))(concat_stagei)
Mconv1_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv1_stage%s_L1'%(str(i)))(concat_stage_padded)
Mconv1_stagei_L1_padded = ZeroPadding2D(padding=(3,3))(Mconv1_stagei_L1)
Mconv2_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv2_stage%s_L1'%(str(i)))(Mconv1_stagei_L1_padded)
Mconv2_stagei_L1_padded = ZeroPadding2D(padding=(3, 3))(Mconv2_stagei_L1)
Mconv3_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv3_stage%s_L1'%(str(i)))(Mconv2_stagei_L1_padded)
Mconv3_stagei_L1_padded = ZeroPadding2D(padding=(3, 3))(Mconv3_stagei_L1)
Mconv4_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv4_stage%s_L1'%(str(i)))(Mconv3_stagei_L1_padded)
Mconv4_stagei_L1_padded = ZeroPadding2D(padding=(3, 3))(Mconv4_stagei_L1)
Mconv5_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv5_stage%s_L1'%(str(i)))(Mconv4_stagei_L1_padded)
Mconv5_stagei_L1_padded = ZeroPadding2D(padding=(0, 0))(Mconv5_stagei_L1)
Mconv6_stagei_L1 = Conv2D(filters=128, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv6_stage%s_L1'%(str(i)))(Mconv5_stagei_L1_padded)
Mconv6_stagei_L1_padded = ZeroPadding2D(padding=(0, 0))(Mconv6_stagei_L1)
Mconv7_stagei_L1 = Conv2D(filters=38, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv7_stage%s_L1'%(str(i)))(Mconv6_stagei_L1_padded)
# L2
Mconv1_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv1_stage%s_L2'%(str(i)))(concat_stage_padded)
Mconv1_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv1_stagei_L2)
Mconv2_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv2_stage%s_L2'%(str(i)))(Mconv1_stagei_L2_padded)
Mconv2_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv2_stagei_L2)
Mconv3_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv3_stage%s_L2'%(str(i)))(Mconv2_stagei_L2_padded)
Mconv3_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv3_stagei_L2)
Mconv4_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv4_stage%s_L2'%(str(i)))(Mconv3_stagei_L2_padded)
Mconv4_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv4_stagei_L2)
Mconv5_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv5_stage%s_L2'%(str(i)))(Mconv4_stagei_L2_padded)
Mconv5_stagei_L2_padded = ZeroPadding2D(padding=(0, 0))(Mconv5_stagei_L2)
Mconv6_stagei_L2 = Conv2D(filters=128, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv6_stage%s_L2'%(str(i)))(Mconv5_stagei_L2_padded)
Mconv6_stagei_L2_padded = ZeroPadding2D(padding=(0, 0))(Mconv6_stagei_L2)
Mconv7_stagei_L2 = Conv2D(filters=19, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv7_stage%s_L2'%(str(i)))(Mconv6_stagei_L2_padded)
temp_L1 = Mconv7_stagei_L1
temp_L2 = Mconv7_stagei_L2
# net_output.append(lossi)
# net_output.append((Mconv7_stagei_L1,Mconv7_stagei_L2))
net_output = [Mconv7_stagei_L1,Mconv7_stagei_L2]
model = Model(inputs=net_input,outputs=net_output)
#model.compile(optimizer=SGD(lr=0.000040,momentum=0.9,decay=0.0005),
# loss='mean_absolute_error')
return model
for x_start, x_end in zip(x[:-1], x[1:]):
for y_start, y_end in zip(y[:-1], y[1:]):
patch_list.append(im_rgb[x_start:x_end, y_start:y_end, :])
# 把此patch的mask的mean值作为对应的分类结果
lbl_list.append(masks[x_start:x_end, y_start:y_end].mean())
patches = np.array(patch_list)
lbls = np.array(lbl_list)
# print(patches.shape,lbls.shape)
x_train, x_test, y_train, y_test = train_test_split(patches, lbls, train_size=0.8, test_size=0.2)
model = Sequential()
model.add(Conv2D(64, (1, 1), input_shape=(16, 16, 8), padding="same"))
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(64, (1, 1), padding="same"))
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(Conv2D(128, (3, 3), padding="same"))
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(MaxPool2D((2, 2)))
model.add(Flatten())
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=32, epochs=10)
def get_model(params_transform,params_train):
# params set
batch_size = int(params_train['batch_size'])
crop_size_x = int(params_transform['crop_size_x'])
crop_size_y = int(params_transform['crop_size_y'])
stride = int(params_transform['stride'])
num_parts = int(params_transform['np'])
grid_x = crop_size_x / stride
grid_y = crop_size_y / stride
stage_num = 6
# input output
image = Input(shape=(crop_size_y,crop_size_x,3),
batch_shape=(batch_size,crop_size_y,crop_size_x,3),
name='image')
label = Input(shape=(grid_y,grid_x,(num_parts + 1)*2),
batch_shape=(batch_size,grid_y,grid_x,(num_parts+1)*2),
name='label')
net_input = [image,label]
net_output = []
# ground-truth
paf_weight = Lambda(lambda x: x[:, :, :, :38])(label)# mask
confid_weight = Lambda(lambda x: x[:,:, :, 38:57])(label)# mask
paf_temp = Lambda(lambda x: x[:,:, :, 57:95])(label)# gt
confid_temp = Lambda(lambda x: x[:,:, :, 95:114])(label)#gt
gt = concatenate([paf_temp, confid_temp], axis=3,name='ground-truth')
# temp = concatenate([paf_weight,confid_weight],axis=3)
# print(temp.shape)
# common op
image_padded = ZeroPadding2D()(image)
conv1_1 = Conv2D(filters=64,kernel_size=(3,3),activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(),name='conv1_1')(image_padded)
conv1_1_padded = ZeroPadding2D()(conv1_1)
conv1_2 = Conv2D(filters=64,kernel_size=(3,3),activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(),name='conv1_2')(conv1_1_padded)
pool1_stage1 = MaxPool2D(pool_size=(2,2),strides=2,name='pool1_stage1')(conv1_2)
pool1_stage1_padded = ZeroPadding2D()(pool1_stage1)
conv2_1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv2_1')(pool1_stage1_padded)
conv2_1_padded = ZeroPadding2D()(conv2_1)
conv2_2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv2_2')(conv2_1_padded)
# conv2_2 = ZeroPadding2D()(conv2_2)
pool2_stage1 = MaxPool2D(pool_size=(2,2),strides=2,name='pool2_stage1')(conv2_2)
pool2_stage1_padded = ZeroPadding2D()(pool2_stage1)
conv3_1 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_1')(pool2_stage1_padded)
conv3_1_padded = ZeroPadding2D()(conv3_1)
conv3_2 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_2')(conv3_1_padded)
conv3_2_padded = ZeroPadding2D()(conv3_2)
conv3_3 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_3')(conv3_2_padded)
conv3_3_padded = ZeroPadding2D()(conv3_3)
conv3_4 = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv3_4')(conv3_3_padded)
pool3_stage1 = MaxPool2D(pool_size=(2, 2), strides=2, name='pool3_stage1')(conv3_4)
pool3_stage1_padded = ZeroPadding2D()(pool3_stage1)
conv4_1 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_1')(pool3_stage1_padded)
conv4_1_padded = ZeroPadding2D()(conv4_1)
conv4_2 = Conv2D(filters=512, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_2')(conv4_1_padded)
conv4_2_padded = ZeroPadding2D()(conv4_2)
conv4_3_CPM = Conv2D(filters=256, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_3_CPM')(conv4_2_padded)
conv4_3_CPM_padded = ZeroPadding2D()(conv4_3_CPM)
conv4_4_CPM = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv4_4_CPM')(conv4_3_CPM_padded)
# stage 1
# L2 confidence maps
conv4_4_CPM_padded = ZeroPadding2D()(conv4_4_CPM)
conv5_1_CPM_L2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_1_CPM_L2')(conv4_4_CPM_padded)
conv5_1_CPM_L2_padded = ZeroPadding2D()(conv5_1_CPM_L2)
conv5_2_CPM_L2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_2_CPM_L2')(conv5_1_CPM_L2_padded)
conv5_2_CPM_L2_padded = ZeroPadding2D()(conv5_2_CPM_L2)
conv5_3_CPM_L2 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_3_CPM_L2')(conv5_2_CPM_L2_padded)
conv5_3_CPM_L2_padded = ZeroPadding2D(padding=(0,0))(conv5_3_CPM_L2)
conv5_4_CPM_L2 = Conv2D(filters=512, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_4_CPM_L2')(conv5_3_CPM_L2_padded)
conv5_4_CPM_L2_padded = ZeroPadding2D(padding=(0,0))(conv5_4_CPM_L2)
conv5_5_CPM_L2 = Conv2D(filters=19, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_5_CPM_L2')(conv5_4_CPM_L2_padded)
# L1 PAFs
# conv4_4_CPM_padded = ZeroPadding2D()(conv4_4_CPM)
conv5_1_CPM_L1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_1_CPM_L1')(conv4_4_CPM_padded)
conv5_1_CPM_L1_padded = ZeroPadding2D()(conv5_1_CPM_L1)
conv5_2_CPM_L1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_2_CPM_L1')(conv5_1_CPM_L1_padded)
conv5_2_CPM_L1_padded = ZeroPadding2D()(conv5_2_CPM_L1)
conv5_3_CPM_L1 = Conv2D(filters=128, kernel_size=(3, 3), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_3_CPM_L1')(conv5_2_CPM_L1_padded)
conv5_3_CPM_L1_padded = ZeroPadding2D(padding=(0, 0))(conv5_3_CPM_L1)
conv5_4_CPM_L1 = Conv2D(filters=512, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_4_CPM_L1')(conv5_3_CPM_L1_padded)
conv5_4_CPM_L1_padded = ZeroPadding2D(padding=(0, 0))(conv5_4_CPM_L1)
conv5_5_CPM_L1 = Conv2D(filters=38, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='conv5_5_CPM_L1')(conv5_4_CPM_L1_padded)
paf_masked_stage1_L1 = multiply([conv5_5_CPM_L1,paf_weight],name='paf_masked_stage1_L1')
confid_masked_stage1_L2 = multiply([conv5_5_CPM_L2,confid_weight],name='confid_masked_stage1_L2')
pred_label_stage1 = concatenate([paf_masked_stage1_L1,confid_masked_stage1_L2],axis=3,name='s1')
pred_label_stage1 = Lambda(lambda x:tf.multiply(x,-1.0))(pred_label_stage1)
pred_label_stage1 = add([pred_label_stage1,gt])
pred_label_stage1 = Lambda(lambda x:tf.square(x))(pred_label_stage1)
loss1 = Lambda(lambda x:tf.reduce_sum(x,axis=[1,2,3],keep_dims=True),name="scalar_s1")(pred_label_stage1)
loss1 = Reshape((1,),name='final_s1')(loss1)
# net_output.append(paf_masked_stage1_L1)
# net_output.append(confid_masked_stage1_L2)
net_output.append(loss1)
temp_L1 = conv5_5_CPM_L1
temp_L2 = conv5_5_CPM_L2
# model = Model(inputs=image,outputs=[temp_L2,temp_L1])
# return model
for i in range(2,stage_num+1):
concat_stagei = concatenate([temp_L1,temp_L2,conv4_4_CPM],axis=3)
# L1
concat_stage_padded = ZeroPadding2D(padding=(3,3))(concat_stagei)
Mconv1_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv1_stage%s_L1'%(str(i)))(concat_stage_padded)
Mconv1_stagei_L1_padded = ZeroPadding2D(padding=(3,3))(Mconv1_stagei_L1)
Mconv2_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv2_stage%s_L1'%(str(i)))(Mconv1_stagei_L1_padded)
Mconv2_stagei_L1_padded = ZeroPadding2D(padding=(3, 3))(Mconv2_stagei_L1)
Mconv3_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv3_stage%s_L1'%(str(i)))(Mconv2_stagei_L1_padded)
Mconv3_stagei_L1_padded = ZeroPadding2D(padding=(3, 3))(Mconv3_stagei_L1)
Mconv4_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv4_stage%s_L1'%(str(i)))(Mconv3_stagei_L1_padded)
Mconv4_stagei_L1_padded = ZeroPadding2D(padding=(3, 3))(Mconv4_stagei_L1)
Mconv5_stagei_L1 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv5_stage%s_L1'%(str(i)))(Mconv4_stagei_L1_padded)
Mconv5_stagei_L1_padded = ZeroPadding2D(padding=(0, 0))(Mconv5_stagei_L1)
Mconv6_stagei_L1 = Conv2D(filters=128, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv6_stage%s_L1'%(str(i)))(Mconv5_stagei_L1_padded)
Mconv6_stagei_L1_padded = ZeroPadding2D(padding=(0, 0))(Mconv6_stagei_L1)
Mconv7_stagei_L1 = Conv2D(filters=38, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv7_stage%s_L1'%(str(i)))(Mconv6_stagei_L1_padded)
# L2
Mconv1_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv1_stage%s_L2'%(str(i)))(concat_stage_padded)
Mconv1_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv1_stagei_L2)
Mconv2_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv2_stage%s_L2'%(str(i)))(Mconv1_stagei_L2_padded)
Mconv2_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv2_stagei_L2)
Mconv3_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv3_stage%s_L2'%(str(i)))(Mconv2_stagei_L2_padded)
Mconv3_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv3_stagei_L2)
Mconv4_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv4_stage%s_L2'%(str(i)))(Mconv3_stagei_L2_padded)
Mconv4_stagei_L2_padded = ZeroPadding2D(padding=(3, 3))(Mconv4_stagei_L2)
Mconv5_stagei_L2 = Conv2D(filters=128, kernel_size=(7, 7), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv5_stage%s_L2'%(str(i)))(Mconv4_stagei_L2_padded)
Mconv5_stagei_L2_padded = ZeroPadding2D(padding=(0, 0))(Mconv5_stagei_L2)
Mconv6_stagei_L2 = Conv2D(filters=128, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv6_stage%s_L2'%(str(i)))(Mconv5_stagei_L2_padded)
Mconv6_stagei_L2_padded = ZeroPadding2D(padding=(0, 0))(Mconv6_stagei_L2)
Mconv7_stagei_L2 = Conv2D(filters=19, kernel_size=(1, 1), activation='relu',
kernel_initializer=RandomNormal(stddev=0.00999999977648),
bias_initializer=Constant(), name='Mconv7_stage%s_L2'%(str(i)))(Mconv6_stagei_L2_padded)
temp_L1 = Mconv7_stagei_L1
temp_L2 = Mconv7_stagei_L2
paf_masked_stagei_L1 = multiply([temp_L1, paf_weight],name='paf_masked_stage%s_L1'%(str(i)))
confid_masked_stagei_L2 = multiply([temp_L2, confid_weight],name='confid_masked_stage%s_L2'%(str(i)))
pred_label_stagei = concatenate([paf_masked_stagei_L1, confid_masked_stagei_L2], axis=3,
name='s%s'%(str(i)))
pred_label_stagei = Lambda(lambda x:tf.multiply(x,-1.0))(pred_label_stagei)
pred_label_stagei = add([pred_label_stagei,gt])
pred_label_stagei = Lambda(lambda x:tf.square(x))(pred_label_stagei)
# pred_label_stagei = Lambda(lambda x:tf.reduce_sum(x))(pred_label_stagei)
lossi = Lambda(lambda x:tf.reduce_sum(x,axis=[1,2,3],keep_dims=True),name="scalar_s%s"%(str(i)))(pred_label_stagei)
lossi = Reshape((1,), name='final_s%s'%(str(i)))(lossi)
# net_output.append(paf_masked_stagei_L1)
# net_output.append(confid_masked_stagei_L2)
net_output.append(lossi)
model = Model(inputs=net_input,outputs=net_output)
model.compile(optimizer=SGD(lr=0.000040,momentum=0.9,decay=0.0005),
loss='mean_absolute_error')
return model
print("Shape before one-hot encoding: ", y_train.shape)
Y_train = np_utils.to_categorical(y_train, n_classes)
Y_test = np_utils.to_categorical(y_test, n_classes)
print("Shape after one-hot encoding: ", Y_train.shape)
# building a linear stack of layers with the sequential model
model = Sequential()
# convolutional layer
model.add(
Conv2D(25,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid',
activation='relu',
input_shape=(28, 28, 1)))
model.add(MaxPool2D(pool_size=(1, 1)))
# flatten output of conv
model.add(Flatten())
# hidden layer
model.add(Dense(100, activation='relu'))
# output layer
model.add(Dense(10, activation='softmax'))
# compiling the sequential model
model.compile(loss='categorical_crossentropy',
metrics=['accuracy'],
optimizer='adam')
# training the model for 10 epochs
model.fit(X_train,
Y_train,
def get_text_model(self):
# Modality specific hyperparameters
self.epochs = 100
self.batch_size = 50
# Modality specific parameters
self.embedding_dim = self.data.W.shape[1]
# For text model
self.vocabulary_size = self.data.W.shape[0]
self.filter_sizes = [3, 4, 5]
self.num_filters = 512
print("Creating Model...")
sentence_length = self.train_x.shape[2]
# Initializing sentence representation layers
embedding = Embedding(input_dim=self.vocabulary_size,
output_dim=self.embedding_dim,
weights=[self.data.W],
input_length=sentence_length,
trainable=False)
conv_0 = Conv2D(self.num_filters,
kernel_size=(self.filter_sizes[0], self.embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu')
conv_1 = Conv2D(self.num_filters,
kernel_size=(self.filter_sizes[1], self.embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu')
conv_2 = Conv2D(self.num_filters,
kernel_size=(self.filter_sizes[2], self.embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu')
maxpool_0 = MaxPool2D(pool_size=(sentence_length -
self.filter_sizes[0] + 1, 1),
strides=(1, 1),
padding='valid')
maxpool_1 = MaxPool2D(pool_size=(sentence_length -
self.filter_sizes[1] + 1, 1),
strides=(1, 1),
padding='valid')
maxpool_2 = MaxPool2D(pool_size=(sentence_length -
self.filter_sizes[2] + 1, 1),
strides=(1, 1),
padding='valid')
dense_func = Dense(100, activation='tanh', name="dense")
dense_final = Dense(units=self.classes, activation='softmax')
reshape_func = Reshape((sentence_length, self.embedding_dim, 1))
def slicer(x, index):
return x[:, K.constant(index, dtype='int32'), :]
def slicer_output_shape(input_shape):
shape = list(input_shape)
assert len(shape) == 3 # batch, seq_len, sent_len
new_shape = (shape[0], shape[2])
return new_shape
def reshaper(x):
return K.expand_dims(x, axis=3)
def flattener(x):
x = K.reshape(x, [-1, x.shape[1] * x.shape[3]])
return x
def flattener_output_shape(input_shape):
shape = list(input_shape)
new_shape = (shape[0], 3 * shape[3])
return new_shape
inputs = Input(shape=(self.sequence_length, sentence_length),
dtype='int32')
cnn_output = []
for ind in range(self.sequence_length):
local_input = Lambda(slicer,
output_shape=slicer_output_shape,
arguments={"index": ind
})(inputs) # Batch, word_indices
#cnn-sent
emb_output = embedding(local_input)
reshape = Lambda(reshaper)(emb_output)
concatenated_tensor = Concatenate(axis=1)([
maxpool_0(conv_0(reshape)),
maxpool_1(conv_1(reshape)),
maxpool_2(conv_2(reshape))
])
flatten = Lambda(
flattener,
output_shape=flattener_output_shape,
)(concatenated_tensor)
dense_output = dense_func(flatten)
dropout = Dropout(0.5)(dense_output)
cnn_output.append(dropout)
def stack(x):
return K.stack(x, axis=1)
cnn_outputs = Lambda(stack)(cnn_output)
masked = Masking(mask_value=0)(cnn_outputs)
lstm = Bidirectional(
LSTM(300, activation='relu', return_sequences=True,
dropout=0.3))(masked)
lstm = Bidirectional(LSTM(300,
activation='relu',
return_sequences=True,
dropout=0.3),
name="utter")(lstm)
output = TimeDistributed(Dense(self.classes,
activation='softmax'))(lstm)
model = Model(inputs, output)
return model
print("Test data shapes : ", X_test.shape, y_test.shape)
# To build a first neural network we need to turn the target variable into a
# vector "one-hot-encoding" representation. Keras provides a utility function
# to convert integer-encoded categorical variables as one-hot encoded values:
Y_train = to_categorical(y_train)
N = X_train.shape[1] # input size
H = 100 # hidden layer size or 'width'
K = 10 # output layer size, i.e number of classes
# --- Keras sequential model
model = Sequential()
model.add(Conv2D(4, 5, activation='relu', input_shape=(8, 8, 1)))
model.add(MaxPool2D(2, strides=2))
model.add(Flatten())
model.add(Dense(H, input_dim=N))
model.add(Activation("tanh"))
model.add(Dense(K))
model.add(Activation("softmax"))
# --- Compile and fit the model using SGD
model.compile(optimizer=optimizers.SGD(lr=0.1),
loss='categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(X_train, Y_train, epochs=15, batch_size=32)
# --- Display the report for model training
# summarize history for loss
model += GInftlyLayer(
'dcnn0',
w_regularizer=(c_l2, w_reg),
f_regularizer=(c_l2, f_reg),
reweight_regularizer=False,
f_layer=[
lambda reg: Convolution2D(init_cnn_count, (3, 3), padding='same'),
lambda reg: Dropout(0.25),
lambda reg: GammaRegularizedBatchNorm(reg, max_free_gamma=0.),
],
h_step=[
lambda reg: Activation('relu'),
],
w_step=w_step,
)
model += MaxPool2D()
model += Convolution2D(init_cnn_count * 2, (3, 3),
trainable=False,
padding='same')
model += GInftlyLayer(
'dcnn1',
w_regularizer=(c_l2, w_reg),
f_regularizer=(c_l2, f_reg),
reweight_regularizer=False,
f_layer=[
lambda reg: Convolution2D(init_cnn_count * 2, (3, 3), padding='same'),
lambda reg: Dropout(0.25),
lambda reg: GammaRegularizedBatchNorm(reg, max_free_gamma=0.),
],
h_step=[
lambda reg: Activation('relu'),
yield sklearn.utils.shuffle(X_train, y_train) ## Creating training and validation generator train_generator = generator(training_data, batch_size=64) validation_generator = generator(validation_data, batch_size=64) ## Define architecture model = Sequential() model.add(Cropping2D(cropping=((50, 20), (0, 0)), input_shape=(160, 320, 3))) model.add(Lambda(lambda x: (x / 255.0) - 0.5)) model.add(Conv2D(24, (5, 5), strides=(2, 2), activation="relu")) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Dropout(0.3)) model.add(Conv2D(36, (5, 5), strides=(2, 2), activation="relu")) model.add(Dropout(0.3)) model.add(Conv2D(48, (5, 5), strides=(2, 2), activation="relu")) model.add(Dropout(0.3)) model.add(Flatten()) model.add(Dense(100)) model.add(Dense(50)) model.add(Dense(10)) model.add(Dense(1)) model_image = './images/architecture.png'
def train_CNN(X_train, y_train, X_test, y_test, qstn=None, outputDF=False):
# Create a vocab (word to index)
vocab_dict = build_vocab(X_train)
pickle_object(vocab_dict, 'vocab_dict_comb_test')
vocabulary_size = len(vocab_dict)+1
# Create one-hot-vector encodings
# These are not really one-hot-vectors in this file
# Its just a vector of the word indices for each word in the question
# Need to try one-hot-vecs also
X_train_embedding = retrieve_one_hot_embeddings(X_train,vocab_dict)
X_test_embedding = retrieve_one_hot_embeddings(X_test,vocab_dict)
# Number of labels would be just 4: +,-,*,/
num_of_labels = len(set(y_train))
labels = list(set(y_train))
# Create dict for labels to index
label_to_index = {o:i for i,o in enumerate(labels)}
index_to_label = {i:o for i,o in enumerate(labels)}
# Convert labels in the training and test datset to numeric format
y_train_label_numeric_rep = [label_to_index[label] for label in y_train]
y_test_label_numeric_rep = [label_to_index[label] for label in y_test]
# Just creates the actual one hot encoded vectors
# e.g. 0 : [0 0 0 0]
# 1: [0 1 0 0]
y_train_distribution = np_utils.to_categorical(y_train_label_numeric_rep, num_of_labels)
y_test_distribution = np_utils.to_categorical(y_test_label_numeric_rep, num_of_labels)
# pad (post) questions to max length
max_length = 100
X_train_embedding_padded = pad_sequences(X_train_embedding, maxlen=max_length, padding='post')
X_test_embedding_padded = pad_sequences(X_test_embedding, maxlen=max_length, padding='post')
X_shuffled, y_shuffled = X_train_embedding_padded, y_train_distribution
length = len(X_shuffled)
# Split the training dataset into train (80%) + dev (20%)
X_train_onehot = np.array(X_shuffled[:int(0.8*length)])
X_dev_onehot = np.array(X_shuffled[int(0.8*length):])
y_train_distribution = np.array(y_shuffled[:int(0.8*length)])
y_dev_distribution = np.array(y_shuffled[int(0.8*length):])
embedding_dim = 256
filter_sizes = [3, 4, 5]
num_filters = 128
std_drop = 0.5
epochs = 15
# batch_size = 128
batch_size = 256
print("Creating CNN Model...")
inputs = Input(shape=(max_length,), dtype='int32')
embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim, input_length=max_length)(inputs)
reshape = Reshape((max_length, embedding_dim, 1))(embedding)
# Kernel size specifies the size of the 2-D conv window
# looking at 3 words at a time in the 1st layer, 4 in the 2nd ...
# set padding to valid to ensure no padding
conv_0 = Conv2D(num_filters, kernel_size=(filter_sizes[0], embedding_dim), padding='valid', kernel_initializer='normal',
activation='relu')(reshape)
conv_1 = Conv2D(num_filters, kernel_size=(filter_sizes[1], embedding_dim), padding='valid', kernel_initializer='normal',
activation='relu')(reshape)
conv_2 = Conv2D(num_filters, kernel_size=(filter_sizes[2], embedding_dim), padding='valid', kernel_initializer='normal',
activation='relu')(reshape)
# Pool size is the downscaling factor
maxpool_0 = MaxPool2D(pool_size=(max_length-filter_sizes[0]+1, 1), strides=(2,2), padding='valid')(conv_0)
maxpool_1 = MaxPool2D(pool_size=(max_length-filter_sizes[1]+1, 1), strides=(2,2), padding='valid')(conv_1)
maxpool_2 = MaxPool2D(pool_size=(max_length-filter_sizes[2]+1, 1), strides=(2,2), padding='valid')(conv_2)
concatenated_tensor = Concatenate(axis=1)([maxpool_0, maxpool_1, maxpool_2])
flatten = Flatten()(concatenated_tensor)
dropout = Dropout(std_drop)(flatten)
output = Dense(units=num_of_labels, activation='softmax')(dropout)
model = Model(inputs=inputs, outputs=output)
checkpoint = ModelCheckpoint('trained_CNN_model.hdf5', monitor='val_loss', verbose=0, save_best_only=True, mode='auto')
# adam = Adam(lr=2e-3, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
#print(model.summary())
print("Training CNN Model...")
# model.fit(X_train_onehot, y_train_distribution, batch_size=batch_size, epochs=epochs, verbose=0, callbacks=[checkpoint],
# validation_data=(X_dev_onehot, y_dev_distribution))
model.fit(X_train_onehot, y_train_distribution, batch_size=batch_size, epochs=epochs, verbose=0, callbacks=[checkpoint],
validation_data=(X_dev_onehot, y_dev_distribution))
#Building CNN
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import Dense
from keras.layers import MaxPool2D
from keras.layers import Flatten
from keras.layers import Dropout
classifier = Sequential()
classifier.add(Conv2D(64, (3, 3), input_shape=(256, 256, 3),
activation="relu"))
classifier.add(MaxPool2D(pool_size=(2, 2)))
classifier.add(Conv2D(32, (3, 3), activation="relu"))
classifier.add(MaxPool2D(pool_size=(2, 2)))
classifier.add(Conv2D(32, (3, 3), activation="relu"))
classifier.add(MaxPool2D(pool_size=(2, 2)))
classifier.add(Flatten())
classifier.add(Dense(units=128, activation='relu'))
classifier.add(Dropout(rate=0.4))
classifier.add(Dense(units=64, activation='relu'))
classifier.add(Dropout(rate=0.2))
classifier.add(Dense(units=32, activation='relu'))
classifier.add(Dropout(rate=0.2))
classifier.add(Dense(units=1, activation='sigmoid'))
classifier.compile(optimizer="adam",
loss="binary_crossentropy",
metrics=['accuracy'])
from keras.preprocessing.image import ImageDataGenerator
traindata = trdata.flow_from_directory(directory="data",
target_size=(224, 224))
valdata = ImageDataGenerator()
valdata = valdata.flow_from_directory(directory="validation",
target_size=(224, 224))
model = Sequential()
model.add(
Conv2D(input_shape=(224, 224, 3),
filters=64,
kernel_size=(3, 3),
padding="same",
activation="relu"))
model.add(
Conv2D(filters=64, kernel_size=(3, 3), padding="same", activation="relu"))
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Conv2D(filters=128, kernel_size=(3, 3), padding="same", activation="relu"))
model.add(
Conv2D(filters=128, kernel_size=(3, 3), padding="same", activation="relu"))
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Conv2D(filters=256, kernel_size=(3, 3), padding="same", activation="relu"))
model.add(
Conv2D(filters=256, kernel_size=(3, 3), padding="same", activation="relu"))
model.add(
Conv2D(filters=256, kernel_size=(3, 3), padding="same", activation="relu"))
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
def cnn_model():
input_img1 = Input(shape=(256, 256, 1)) # channel first
input_img2 = Input(shape=(256, 256, 1))
input_img3 = Input(shape=(256, 256, 1))
X1 = Convolution2D(filters=32,
kernel_size=(7, 7),
padding='same',
activation='relu')(input_img1)
X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X1)
X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X1)
X1 = Convolution2D(filters=64,
kernel_size=(7, 7),
padding='same',
activation='relu')(X1)
X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X1)
# X1 = Convolution2D(filters=128, kernel_size=(7, 7), padding='same', activation='relu')(X1)
# X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X1)
# X1 = Convolution2D(filters=256, kernel_size=(7, 7), padding='same', activation='relu')(X1)
# X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X1)
# X1 = Convolution2D(filters=512, kernel_size=(7, 7), padding='same', activation='relu')(X1)
# X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X1)
# X1 = Convolution2D(filters=1024, kernel_size=(7, 7), padding='same', activation='relu')(X1)
# X1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X1)
X2 = Convolution2D(filters=32,
kernel_size=(7, 7),
padding='same',
activation='relu')(input_img2)
X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X2)
X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X2)
X2 = Convolution2D(filters=64,
kernel_size=(7, 7),
padding='same',
activation='relu')(X2)
X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X2)
# X2 = Convolution2D(filters=128, kernel_size=(7, 7), padding='same', activation='relu')(X2)
# X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X2)
# X2 = Convolution2D(filters=256, kernel_size=(7, 7), padding='same', activation='relu')(X2)
# X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X2)
# X2 = Convolution2D(filters=512, kernel_size=(7, 7), padding='same', activation='relu')(X2)
# X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X2)
# X2 = Convolution2D(filters=1024, kernel_size=(7, 7), padding='same', activation='relu')(X2)
# X2 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X2)
X3 = Convolution2D(filters=32,
kernel_size=(7, 7),
padding='same',
activation='relu')(input_img3)
X3 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X3)
X3 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X3)
X3 = Convolution2D(filters=64,
kernel_size=(7, 7),
padding='same',
activation='relu')(X3)
X3 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X3)
# X3 = Convolution2D(filters=128, kernel_size=(7, 7), padding='same', activation='relu')(X3)
# X3 = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X3)
# X3 = Convolution2D(filters=512, kernel_size=(7, 7), padding='same', activation='relu')(X3)
# X3 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X3)
# X3 = Convolution2D(filters=1024, kernel_size=(7, 7), padding='same', activation='relu')(X3)
# X3 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X3)
concat = Concatenate()([X1, X2, X3])
X = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(concat)
X = Convolution2D(filters=128,
kernel_size=(7, 7),
padding='same',
activation='relu')(X)
# X = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X)
# X = Convolution2D(filters=64, kernel_size=(7, 7), padding='same', activation='relu')(X)
# X = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(X)
# X = Convolution2D(filters=256, kernel_size=(7, 7), padding='same', activation='relu')(X)
X = Flatten()(X)
X = Dense(128, activation='relu')(X)
X = Dense(64, activation='relu')(X)
# X = Dense(128, activation='relu')(X)
# X = Dense(64, activation='relu')(X)
# print('before ' +str(X.shape))
X = Dense(2, activation='sigmoid')(X)
# print('after ' + str(X.shape))
model = Model(inputs=[input_img1, input_img2, input_img3], outputs=X)
return model
from keras.layers import Dense, Activation, Conv2D, MaxPool2D, Reshape
import numpy as np
train_X = []
for i in range(10000):
img = Image.open("train/cat.%d.jpg" % i).resize((64, 64))
train_X.append(np.array(img))
img = Image.open("train/dog.%d.jpg" % i).resize((64, 64))
train_X.append(np.array(img))
train_X = np.float32(train_X) / 255
train_y = [0, 1] * 10000
train_Y = np.eye(2)[train_y]
model = Sequential()
model.add(
Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
activation="relu",
input_shape=(64, 64, 3)))
model.add(MaxPool2D())
model.add(
Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation="relu"))
model.add(MaxPool2D())
model.add(Reshape((-1, )))
model.add(Dense(units=1024, activation="relu"))
model.add(Dense(units=2, activation="softmax"))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(train_X, train_Y, validation_split=0.1, batch_size=64, epochs=20)
def model_creation():
model = Sequential()
model.add(
Conv2D(2,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
input_shape=(48, 48, 1),
activation='relu')) ##Input Layers
model.add(
Conv2D(2,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(BatchNormalization(axis=-1))
model.add(MaxPool2D(pool_size=(2, 2), strides=(1, 1),
padding='SAME')) #Max Pool1
model.add(Dropout(0.5))
model.add(ZeroPadding2D(padding=(2, 2)))
model.add(
Conv2D(3,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(
Conv2D(3,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2), strides=(1, 1),
padding='SAME')) #MaxPool2
model.add(Dropout(0.5))
model.add(ZeroPadding2D(padding=(2, 2)))
model.add(
Conv2D(7,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(
Conv2D(7,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(BatchNormalization(axis=-1))
model.add(MaxPool2D(pool_size=(2, 2), strides=(1, 1),
padding='SAME')) #MaxPool3
model.add(Dropout(0.5))
model.add(ZeroPadding2D(padding=(2, 2)))
model.add(
Conv2D(10,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(
Conv2D(10,
kernel_size=(3, 3),
strides=(1, 1),
padding='SAME',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2), strides=(1, 1),
padding='SAME')) #MaxPool4
model.add(Dropout(0.5))
"""model.add(ZeroPadding2D(padding = (2, 2)))
model.add(Conv2D(15, kernel_size=(3, 3), strides=(1, 1), padding='SAME',
activation = 'relu'))
model.add(Conv2D(15, kernel_size=(3, 3), strides=(1, 1), padding='SAME',
activation = 'relu'))
model.add(BatchNormalization(axis = -1))
model.add(MaxPool2D(pool_size=(2, 2), strides=(1, 1), padding = 'SAME')) #MaxPool5
model.add(Dropout(0.5))
"""
model.add(Flatten())
#Dense1
model.add(Dense(200, activation='relu'))
model.add(BatchNormalization(axis=-1))
model.add(Dropout(0.5))
#Dense2
model.add(Dense(140, activation='relu'))
model.add(BatchNormalization(axis=-1))
model.add(Dropout(0.5))
#Dense3
model.add(Dense(100, activation='relu'))
model.add(BatchNormalization(axis=-1))
model.add(Dropout(0.5))
#Dense4
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
model.summary()
return model
def fit_cnn():
X_train = train_embed
y_train = np.array(train_labels)
X_test = test_embed
y_test = test_labels
X_train = X_train.reshape(
(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1))
X_test = X_test.reshape(
(X_test.shape[0], X_test.shape[1], X_test.shape[2], 1))
y_train, y_test = convert_one_hot(y_train, y_test)
sequence_length = train_embed.shape[1] # 60
embedding_dim = train_embed.shape[2]
filter_sizes = [2, 3, 4, 5]
num_filters = 64
drop = 0.6
input_shape = train_embed[0].shape
epochs = 1000
batch_size = 64
inputs = Input(shape=(sequence_length, embedding_dim, 1), dtype='float32')
batch_norm = BatchNormalization(input_shape=input_shape)(inputs)
conv_0 = Conv2D(num_filters,
kernel_size=(filter_sizes[0], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
conv_1 = Conv2D(num_filters,
kernel_size=(filter_sizes[1], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
conv_2 = Conv2D(num_filters,
kernel_size=(filter_sizes[2], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
conv_3 = Conv2D(num_filters,
kernel_size=(filter_sizes[3], embedding_dim),
padding='valid',
kernel_initializer='normal',
activation='relu',
input_shape=input_shape,
kernel_regularizer=regularizers.l2(0.01))(batch_norm)
maxpool_0 = MaxPool2D(pool_size=(sequence_length - filter_sizes[0] + 1, 1),
strides=(1, 1),
padding='valid')(conv_0)
maxpool_1 = MaxPool2D(pool_size=(sequence_length - filter_sizes[1] + 1, 1),
strides=(1, 1),
padding='valid')(conv_1)
maxpool_2 = MaxPool2D(pool_size=(sequence_length - filter_sizes[2] + 1, 1),
strides=(1, 1),
padding='valid')(conv_2)
maxpool_3 = MaxPool2D(pool_size=(sequence_length - filter_sizes[3] + 1, 1),
strides=(1, 1),
padding='valid')(conv_3)
concatenated_tensor = Concatenate(axis=1)(
[maxpool_0, maxpool_1, maxpool_2, maxpool_3])
flatten = Flatten()(concatenated_tensor)
dropout = Dropout(drop)(flatten)
output = Dense(units=3,
activation='softmax',
kernel_regularizer=regularizers.l2(0.1))(dropout)
# this creates a model that includes
model = Model(inputs=inputs, outputs=output)
adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(optimizer=adam,
loss='categorical_crossentropy',
metrics=['accuracy'])
print("Traning Model...")
model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_test, y_test))
model.save("model/cnn.h5")
return model
