def dynamic_embeddings(num_layers,
filter_lengths,
nb_filters,
n_classes,
hidden_size=250):
# some constants
max_len_char = 140
dropout_rate = 0.5
# dynamic embeddings and more n-grams
input_layer = (Input(name='input', shape=(max_len_char, )))
# Dynamic embeddings: TensorShape([Dimension(None), Dimension(246), Dimension(140)])
embed = Embedding(input_dim=246, output_dim=140)(input_layer)
convs = []
for i in range(num_layers):
for ksize in filter_lengths:
conv = (Convolution1D(filters=nb_filters, kernel_size=ksize, padding="valid", activation="relu",\
strides=1, name ='conv%d_%d' % (i, ksize))(embed))
pool = MaxPooling1D(pool_size=max_len_char - ksize + 1,
name='pool%d_%d' % (i, ksize))(conv)
convs.append(pool)
concat = Concatenate()(convs)
flatten = Flatten()(concat)
flatten.get_shape()
hidden = Dense(hidden_size, activation="relu")(flatten)
dropout = Dropout(rate=dropout_rate)(hidden)
output = Dense(n_classes, activation='softmax')(dropout)
model = Model(inputs=input_layer, outputs=output)
return model
def static_embeddings(num_layers,
filter_lengths,
nb_filters,
n_classes,
hidden_size=250):
# some constants
max_len_char = 140
dropout_rate = 0.5
input_layer = (Input(name='input',
shape=(max_len_char, 246))) #len(small_chars_set))))
convs = []
for i in range(num_layers):
for j in filter_lengths:
conv = (Convolution1D(filters=nb_filters, kernel_size=j, padding="valid", activation="relu",\
strides=1, name ='conv%d_%d' % (i, j))(input_layer))
pool = MaxPooling1D(pool_size=max_len_char - j + 1,
name='pool%d_%d' % (i, j))(conv)
convs.append(pool)
concat = Concatenate()(convs)
flatten = Flatten()(concat)
flatten.get_shape()
hidden = Dense(hidden_size, activation="relu")(flatten)
dropout = Dropout(rate=dropout_rate)(hidden)
output = Dense(10, activation='softmax')(dropout)
model = Model(inputs=input_layer, outputs=output)
def build_discriminator(img_shape,
df,
num_classes,
num_layers=4,
act_multi_label='softmax'):
def d_layer(layer_input, filters, f_size=4, normalization=True):
"""Discriminator layer"""
d = Conv2D(filters, kernel_size=f_size, strides=2,
padding='valid')(layer_input)
d = LeakyReLU(alpha=0.2)(d)
if normalization:
d = InstanceNormalization()(d)
return d
img = Input(shape=img_shape)
#label = Input(shape=(1,), dtype='int32')
#label_embedding = Flatten()(Embedding(self.num_classes, np.prod(self.img_shape))(label))
#flat_img = Flatten()(img)
#model_input = multiply([flat_img, label_embedding])
#d0 = Reshape(self.img_shape)(model_input)
d = img
for i in range(num_layers):
_norm = False if i == 0 else True
d = d_layer(d, df * 2**i, normalization=_norm)
flat_repr = Flatten()(d)
#validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4)
print("flat_repr.get_shape().as_list():", flat_repr.get_shape().as_list())
print("flat_repr.get_shape().as_list()[1:]:",
flat_repr.get_shape().as_list()[1:])
gan_logit = Dense(df * 2**(num_layers - 1))(flat_repr)
gan_logit = LeakyReLU(alpha=0.2)(gan_logit)
gan_prob = Dense(1, activation='sigmoid')(gan_logit)
class_logit = Dense(df * 2**(num_layers - 1))(flat_repr)
class_logit = LeakyReLU(alpha=0.2)(class_logit)
class_prob = Dense(num_classes, activation=act_multi_label)(class_logit)
####
#label = Input(shape=(1,), dtype='int32')
#label_embedding = Flatten()(Embedding(self.num_classes, 9)(label))
#flat_img = Flatten()(validity)
#d44 = multiply([flat_img, label_embedding])
#d444 = Reshape(validity.get_shape().as_list()[1:])(d44)
####
return Model(img, [gan_prob, class_prob])
def cnn_ascad(classes=256):
# From VGG16 design
input_shape = (700, 1)
img_input = Input(shape=input_shape)
# Block 1
x = Conv1D(64, 11, activation='relu', padding='same',
name='block1_conv1')(img_input)
print x.get_shape()
x = AveragePooling1D(2, strides=2, name='block1_pool')(x)
print x.get_shape()
# Block 2
x = Conv1D(128, 11, activation='relu', padding='same',
name='block2_conv1')(x)
print x.get_shape()
x = AveragePooling1D(2, strides=2, name='block2_pool')(x)
print x.get_shape()
# Block 3
x = Conv1D(256, 11, activation='relu', padding='same',
name='block3_conv1')(x)
print x.get_shape()
x = AveragePooling1D(2, strides=2, name='block3_pool')(x)
print x.get_shape()
# Block 4
x = Conv1D(512, 11, activation='relu', padding='same',
name='block4_conv1')(x)
print x.get_shape()
x = AveragePooling1D(2, strides=2, name='block4_pool')(x)
print x.get_shape()
# Block 5
x = Conv1D(512, 11, activation='relu', padding='same',
name='block5_conv1')(x)
print x.get_shape()
x = AveragePooling1D(2, strides=2, name='block5_pool')(x)
print x.get_shape()
# Classification block
x = Flatten(name='flatten')(x)
print x.get_shape()
x = Dense(4096, activation='relu', name='fc1')(x)
print x.get_shape()
x = Dense(4096, activation='relu', name='fc2')(x)
print x.get_shape()
x = Dense(classes, activation='softmax', name='predictions')(x)
print x.get_shape()
inputs = img_input
# Create model.
model = Model(inputs, x, name='cnn_best')
optimizer = RMSprop(lr=0.00001)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
return model
class ConvOutputNode(Node):
"""Input node of feature extraction graph."""
__vertex_type = "ConvOutputNode"
def __init__(self):
super().__init__()
def build(self, model):
""" Builds and stoers Keras model. """
self._model = Flatten()(model)
@property
def output_dimension(self):
return self._model.get_shape()[1]
def build_VGG16(self):
data_input = Input(batch_shape=self.data_size) # ,dtype=np.float32)
net = Conv2D(64, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding='same', activation="relu",
name="conv1_1")(data_input) # 可以
net = Conv2D(64, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding='same', activation="relu",
name="conv1_2")(net)
net = MaxPool2D((2, 2), strides=(2, 2), name="maxpool_1")(net)
net = Conv2D(128, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv2_1")(net)
net = Conv2D(128, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv2_2")(net)
net = MaxPool2D((2, 2), strides=(2, 2), name="maxpool_2")(net)
net = Conv2D(256, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv3_1")(net)
net = Conv2D(256, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv3_2")(net)
net = Conv2D(256, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv3_3")(net)
net = MaxPool2D((2, 2), strides=(2, 2), name="maxpool3")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv4_1")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv4_2")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv4_3")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv4_4")(net)
net = MaxPool2D((2, 2), strides=(2, 2), name="maxpool4")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv5_1")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv5_2")(net)
net = Conv2D(512, (3, 3), strides=(1, 1),
kernel_regularizer=regularizers.l2(decay_weight), padding="same", activation="relu",
name="conv5_3")(net)
net = MaxPool2D((2, 2), strides=(2, 2), name="maxpool5")(net)
# net = Flatten()(net) # 全局池化不可以的
if self.flags==1:
# 普通的fc
net = Flatten()(net)
net = Dense(4096, name="fc1")(net)
net = Activation("relu")(net)
net = Dense(4096, name="fc2")(net)
net = Activation("relu")(net)
net = Dense(self.n_classes, name="fc3")(net)
net = Activation("softmax")(net)
model = Model(inputs=data_input, outputs=net)
from keras.utils import plot_model
import os
plot_model(model, to_file=os.path.join('./imgs', "003_vgg.png"), show_shapes=True)
model.summary()
print("output data shape : ", net.get_shape())
return net
elif self.flags== 2:
# 全局平均池化
net = AvgPool2D((7, 7), (1, 1), padding="valid", name="pool_fc")(net)
net = GlobalAveragePooling2D(name="GAP")(net)
net = Dense(self.n_classes, name="fc1")(net)
net = Activation("softmax")(net)
model = Model(inputs=data_input, outputs=net)
model.summary()
print("output data shape : ", net.get_shape())
return net
elif self.flags== 3:
# 卷积代替fc
fks = net.get_shape().as_list()[1:3]
net = Conv2D(4096, fks, strides=(1, 1), padding="valid",
activation="relu", name="cnn_fc1")(net)
net = Conv2D(self.n_classes, (1, 1), strides=(1, 1), padding="valid",
activation="relu", name="cnn_fc3")(net)
net = Activation("softmax")(net)
model = Model(inputs=data_input, outputs=net)
print("output data shape : ", net.get_shape())
model.summary()
return net
else:
raise ValueError
def build_nets(flags=1):
data_input = Input(batch_shape=(32, 224, 224, 3))
# -----1
net = Conv2D(64, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv1_1")(data_input)
net = Conv2D(64, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv1_2")(net)
# -----2
net = MaxPool2D((2, 2), strides=(2, 2), padding="Valid",
name="maxpool1")(net)
net = Conv2D(128, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv2_1")(net)
net = Conv2D(128, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv2_2")(net)
# -----3
net = MaxPool2D((2, 2), strides=(2, 2), padding="Valid",
name="maxpool2")(net)
net = Conv2D(256, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv3_1")(net)
net = Conv2D(256, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv3_2")(net)
net = Conv2D(256, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv3_3")(net)
# -----4
net = MaxPool2D((2, 2), strides=(2, 2), padding="Valid",
name="maxpool3")(net)
net = Conv2D(512, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv4_1")(net)
net = Conv2D(512, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv4_2")(net)
net = Conv2D(512, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv4_3")(net)
# -----5
net = MaxPool2D((2, 2), strides=(2, 2), padding="Valid",
name="maxpool4")(net)
net = Conv2D(512, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv5_1")(net)
net = Conv2D(512, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv5_2")(net)
net = Conv2D(512, (3, 3),
strides=(1, 1),
padding="same",
activation="relu",
name="conv5_3")(net)
# ------6
# conv2d 代替 fc
net = MaxPool2D((2, 2), strides=(2, 2), padding="Valid",
name="maxpool5")(net)
if flags == 1:
# 普通的fc
net = Flatten()(net)
net = Dense(4096, name="fc1")(net)
net = Activation("relu")(net)
net = Dense(4096, name="fc2")(net)
net = Activation("relu")(net)
net = Dense(1000, name="fc3")(net)
net = Activation("softmax")(net)
a = net.get_layer("fc2").get_weights()
print('a ---> ', a)
model = Model(inputs=data_input, outputs=net)
print("output data shape : ", net.get_shape())
return model
elif flags == 2:
# 全局平均池化
net = AvgPool2D((7, 7), (1, 1), padding="valid", name="pool_fc")(net)
net = GlobalAveragePooling2D(name="GAP")(net)
net = Dense(1000, name="fc1")(net)
net = Activation("softmax")(net)
model = Model(inputs=data_input, outputs=net)
print("output data shape : ", net.get_shape())
return model
elif flags == 3:
# 卷积代替fc
net = Conv2D(4096, (7, 7),
strides=(1, 1),
padding="valid",
activation="relu",
name="cnn_fc1")(net)
net = Conv2D(4096, (1, 1),
strides=(1, 1),
padding="valid",
activation="relu",
name="cnn_fc2")(net)
net = Conv2D(1000, (1, 1),
strides=(1, 1),
padding="valid",
activation="relu",
name="cnn_fc3")(net)
net = Flatten()(net)
net = Activation("softmax")(net)
model = Model(inputs=data_input, outputs=net)
print("output data shape : ", net.get_shape())
return model
else:
raise ValueError
def draw_cnn_model(hyper_param, embedding_matrix=None, verbose=True):
"""
Input: hyper_parameters dictionary
Construct:
input layers : x , x_pos(o), x_captialization(o)
embedding matrix : use_glove or randomly initialize
conv1 : first convolution layer
conv2 : second convolution layer
conv3 : third convolution layer
max pooling
flatten : concant maxpooled univariate vectors into one long vector
ff1, ff2: two feed forward layers
out_pred: softmax over all ner classes
Returns: keras.models.Model object
"""
# input layer(s)
x = Input(shape=(hyper_param['maxlen'], ), name='x')
if hyper_param['use_pos_tags']:
x_pos = Input(shape=(hyper_param['maxlen'], hyper_param['poslen']),
name='x_pos')
if hyper_param['use_capitalization_info']:
x_capital = Input(shape=(hyper_param['maxlen'],
hyper_param['capitallen']),
name='x_capital')
# embedding matrix
if hyper_param['use_glove']:
embed = Embedding(hyper_param['max_features'], hyper_param['embed_dim'], weights=[embedding_matrix],\
input_length=hyper_param['maxlen'], trainable=hyper_param['allow_glove_retrain'])(x)
else:
embed = Embedding(hyper_param['max_features'], hyper_param['embed_dim'], input_length=hyper_param['maxlen'],\
embeddings_initializer="random_uniform" )(x)
# concat embeddings with additional features
if hyper_param['use_pos_tags'] and hyper_param['use_capitalization_info']:
embed = Concatenate(axis=-1)([embed, x_pos, x_capital])
elif hyper_param['use_pos_tags'] and (
not hyper_param['use_capitalization_info']):
embed = Concatenate(axis=-1)([embed, x_pos])
elif (not hyper_param['use_pos_tags']
) and hyper_param['use_capitalization_info']:
embed = Concatenate(axis=-1)([embed, x_capital])
else:
embed = embed
# feed embeddings into conv1
conv1 = Conv1D( filters=hyper_param['conv1_filters'], \
kernel_size=hyper_param['conv1_kernel_size'],\
strides=hyper_param['conv1_strides'], \
padding=hyper_param['conv1_padding'],\
activation='relu', name='conv1')(embed)
# update this
# make primary capsules
conv2 = Conv1D( filters=hyper_param['conv2_filters'], \
kernel_size=hyper_param['conv2_kernel_size'],\
strides=hyper_param['conv2_strides'], \
padding=hyper_param['conv2_padding'],\
activation='relu', name='conv2')(conv1)
# update this
# make primary capsules
conv3 = Conv1D( filters=hyper_param['conv3_filters'], \
kernel_size=hyper_param['conv3_kernel_size'],\
strides=hyper_param['conv3_strides'], \
padding=hyper_param['conv3_padding'],\
activation='relu', name='conv3')(conv2)
# max pooling layer
max_pooled = MaxPooling1D(pool_size=hyper_param['max_pooling_size'], \
strides=hyper_param['max_pooling_strides'], \
padding=hyper_param['max_pooling_padding'])(conv3)
# dropout
maxpooled_dropout = Dropout(hyper_param['maxpool_dropout'])(max_pooled)
# flatten many univariate vectos into 1 long vector
flattened = Flatten()(maxpooled_dropout)
# to feed-forward layers
ff1 = Dense(hyper_param['feed_forward_1'], activation='relu')(flattened)
ff1_dropout = Dropout(hyper_param['ff1_dropout'])(ff1)
ff2 = Dense(hyper_param['feed_forward_2'], activation='relu')(ff1_dropout)
ff2_dropout = Dropout(hyper_param['ff2_dropout'])(ff2)
out_pred = Dense(hyper_param['ner_classes'],
activation='softmax',
name='out_pred')(ff2) #!
if verbose:
print("x", x.get_shape())
if hyper_param['use_pos_tags']: print("x_pos", x_pos.get_shape())
if hyper_param['use_capitalization_info']:
print("x_capital", x_capital.get_shape())
print("embed", embed.get_shape())
print("embed", embed.get_shape())
print("conv1", conv1.get_shape())
print("conv2", conv2.get_shape())
print("conv3", conv3.get_shape())
print("max_pooled", max_pooled.get_shape())
print("flattened", flattened.get_shape())
print("ff1", ff1.get_shape())
print("ff2", ff2.get_shape())
print("out_pred", out_pred.get_shape())
# return final model
if hyper_param['use_pos_tags'] and hyper_param['use_capitalization_info']:
cnnmodel = Model(inputs=[x, x_pos, x_capital], outputs=[out_pred])
elif hyper_param['use_pos_tags'] and (
not hyper_param['use_capitalization_info']):
cnnmodel = Model(inputs=[x, x_pos], outputs=[out_pred])
elif (not hyper_param['use_pos_tags']
) and hyper_param['use_capitalization_info']:
cnnmodel = Model(inputs=[x, x_capital], outputs=[out_pred])
else:
cnnmodel = Model(inputs=[x], outputs=[out_pred])
return cnnmodel
def build(self, img_shape):
if self.model is not None:
print("PosNet has been constructed")
else:
img_input = Input(shape=(img_shape[0], img_shape[1], img_shape[2]),
name='inputImg')
x_conv = Conv2D(24, (8, 8),
padding="valid",
strides=(2, 2),
name="conv1")(img_input)
x_conv = BatchNormalization()(x_conv)
x_conv = Activation('elu')(x_conv)
print(x_conv.get_shape())
x_conv = Conv2D(36, (5, 5),
padding="valid",
strides=(2, 2),
name="conv2")(x_conv)
x_conv = BatchNormalization()(x_conv)
x_conv = Activation('elu')(x_conv)
print(x_conv.get_shape())
x_conv = Conv2D(48, (5, 5),
padding="valid",
strides=(2, 2),
name="conv3")(x_conv)
x_conv = BatchNormalization()(x_conv)
x_conv = Activation('elu')(x_conv)
print(x_conv.get_shape())
x_conv = Conv2D(64, (5, 5), padding="valid", name="conv4")(x_conv)
x_conv = BatchNormalization()(x_conv)
x_conv = Activation('elu')(x_conv)
print(x_conv.get_shape())
x_conv = Conv2D(64, (5, 5), padding="valid", name="conv5")(x_conv)
x_conv = BatchNormalization()(x_conv)
x_conv = Activation('elu')(x_conv)
print(x_conv.get_shape())
x_out = Flatten()(x_conv)
print(x_out.get_shape())
# Cut for transfer learning is here:
speed_input = Input(shape=(1, ), name='inputSpeed')
x_out = Lambda(lambda x: K.concatenate(x, axis=1))(
[x_out, speed_input])
x_out = Dense(200)(x_out)
x_out = BatchNormalization()(x_out)
x_out = Activation('elu')(x_out)
x_out = Dense(200)(x_out)
x_out = BatchNormalization()(x_out)
x_end = Activation('elu')(x_out)
# Branching from X_END to three branches (steer, throttle, position)
steer = Dense(100)(x_end)
steer = BatchNormalization()(steer)
steer = Activation('elu')(steer)
steer = Dropout(.2)(steer)
steer = Dense(30)(steer)
steer = BatchNormalization()(steer)
steer = Activation('elu')(steer)
steer = Dense(1, activation='sigmoid')(steer)
steer = Lambda(lambda x: x * 10 - 5, name='outputSteer')(steer)
throttle = Dense(100, name='thr1')(x_end)
throttle = BatchNormalization(name='thr2')(throttle)
throttle = Activation('elu')(throttle)
throttle = Dropout(.2)(throttle)
throttle = Dense(30, name='thr3')(throttle)
throttle = BatchNormalization(name='thr4')(throttle)
throttle = Activation('elu')(throttle)
throttle = Dense(1, activation='sigmoid', name='thr5')(throttle)
throttle = Lambda(lambda x: x * 2 - 1, name='outputThr')(throttle)
position = Dropout(.3)(x_end)
position = Dense(1, activation='sigmoid', name='pos5')(position)
position = Lambda(lambda x: x * 2 - 1, name='outputPos')(position)
self.model = Model((img_input, speed_input),
(steer, throttle, position))
def gan_1(
input_img,
hidden_num=128,
no_of_pairs=5,
min_fea_map_H=8,
activation_fn=tf.nn.elu,
noise_dim=0,
z_num=64,
input_channel=3
): #x, hidden_num=3, no_of_pairs=4, min_fea_map_H=8, activation_fn=tf.nn.elu, noise_dim=0):
# Encoder
encoder_layer_list = []
x = Conv2D(hidden_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(input_img)
for idx in range(no_of_pairs):
# to increase number of filter by (filters)*(index+1) ex: 16, 32, 48 ...
channel_num = hidden_num * (idx + 1)
res = x
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = add([x, res])
encoder_layer_list.append(x)
if idx < no_of_pairs - 1:
x = Conv2D(hidden_num * (idx + 2),
kernel_size=3,
strides=2,
activation=activation_fn,
padding='same')(x)
# for flattening the layer
x = Flatten()(x)
# 20480
reshape_dim = int(np.prod([min_fea_map_H, min_fea_map_H / 2, channel_num]))
x = Reshape((1, reshape_dim))(x)
x = Dense(z_num, activation=None)(x)
# Decoder
reshape_dim = int(np.prod([min_fea_map_H, min_fea_map_H / 2, hidden_num]))
x = Dense(reshape_dim, activation=None)(x)
x = Reshape((min_fea_map_H, min_fea_map_H // 2, hidden_num))(x)
for idx in range(no_of_pairs):
x = Concatenate(axis=-1)(
[x, encoder_layer_list[no_of_pairs - 1 - idx]])
res = x
channel_num = x.get_shape().as_list()[-1]
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = Conv2D(channel_num,
kernel_size=3,
strides=1,
activation=activation_fn,
padding='same')(x)
x = add([x, res])
if idx < no_of_pairs - 1:
x = UpSampling2D(2)(x)
x = Conv2D(hidden_num * (no_of_pairs - idx - 1),
kernel_size=1,
strides=1,
activation=activation_fn,
padding='same')(x)
out = Conv2D(input_channel,
name='output_g1',
kernel_size=3,
strides=1,
activation=None,
padding='same')(x)
return out
class My_Model:
def __init__(self, input_shape, dimention):
self.ip1 = Input(shape=(input_shape, 1))
self.ip2 = Input(shape=(input_shape, 1))
self.sim = Input(shape=(1, ))
print(self.ip1.shape)
##---projection layer-----##
## assume each argument is of size 4 and 5 argument per event. hence ip1 is 20x1. so is ip2self.
## after conv each argument will have 5 channles(dimention)
self.projection1 = Conv1D(
5, 4, strides=4, padding='valid',
activation='tanh') #(Dropout(0.5)(Dense(1500, activation='relu')))
self.sh_projection1_op1 = self.projection1(self.ip1)
self.sh_projection1_op2 = self.projection1(self.ip2)
print(self.sh_projection1_op1.shape)
self.f_v1 = Flatten()(self.sh_projection1_op1)
self.f_v2 = Flatten()(self.sh_projection1_op2)
print('after flatten {}'.format(self.f_v1.get_shape().as_list()))
self.projection2 = Conv1D(1,
5,
strides=5,
padding='valid',
activation='tanh')
self.allignment = list()
x0 = self.f_v2
x1 = Lambda(myfunc,
output_shape=self.f_v2.get_shape().as_list()[1])(x0)
x2 = Lambda(myfunc,
output_shape=self.f_v2.get_shape().as_list()[1])(x1)
x3 = Lambda(myfunc,
output_shape=self.f_v2.get_shape().as_list()[1])(x2)
x4 = Lambda(myfunc,
output_shape=self.f_v2.get_shape().as_list()[1])(x3)
print('*****@@@@@+++++{} and {} and {} and {} and{}'.format(
x0.shape, x1.shape, x2.shape, x3.shape, x4.shape))
self.merged_layer = merge([self.f_v1, x0], mode='concat')
self.merged_layer = Reshape((-1, 2))(self.merged_layer)
allgn = self.projection2(self.merged_layer)
self.allignment.append(allgn)
self.merged_layer = merge([self.f_v1, x1], mode='concat')
self.merged_layer = Reshape((-1, 2))(self.merged_layer)
allgn = self.projection2(self.merged_layer)
self.allignment.append(allgn)
self.merged_layer = merge([self.f_v1, x2], mode='concat')
self.merged_layer = Reshape((-1, 2))(self.merged_layer)
allgn = self.projection2(self.merged_layer)
self.allignment.append(allgn)
self.merged_layer = merge([self.f_v1, x3], mode='concat')
self.merged_layer = Reshape((-1, 2))(self.merged_layer)
allgn = self.projection2(self.merged_layer)
self.allignment.append(allgn)
self.merged_layer = merge([self.f_v1, x4], mode='concat')
self.merged_layer = Reshape((-1, 2))(self.merged_layer)
allgn = self.projection2(self.merged_layer)
self.allignment.append(allgn)
'''
for i in range(5):
self.merged_layer = merge([self.f_v1, self.f_v2], mode = 'concat')
self.merged_layer = Reshape((-1,2))(self.merged_layer)
allgn = self.projection2(self.merged_layer)
#print('{} dim merged layer{} dim of conv allgn{}'.format(i,self.merged_layer.shape,allgn.shape ))
self.allignment.append(allgn)
temp1 = self.f_v2[0:4]
temp2 = self.f_v2[5:]
self.f_v2 = merge([temp2, temp1], mode = 'concat')
#print(self.f_v2.type)
'''
#print(self.allignment[0].shape)
for i in range(len(self.allignment)):
self.allignment[i] = Reshape((5, 1))(self.allignment[i])
#print('{} dim allgnlayer{}'.format(i,self.allignment[i] ))
self.allignment_all = merge(self.allignment, mode='concat')
self.prediction = Dense(1, activation='sigmoid')(Flatten()(
self.allignment_all))
self.model = Model(input=[self.ip1, self.ip2, self.sim],
output=self.prediction)
sgd = SGD(lr=0.1, momentum=0.9, decay=0, nesterov=False)
self.model.compile(loss='mean_squared_error',
optimizer=sgd,
metrics=['accuracy'])
#seed(2017)
#self.model.fit([X1, X2], Y.values, batch_size = 2000, nb_epoch = 100, verbose = 1)
def train_model(self,
train_X1,
train_X2,
train_S,
train_y,
batch_size_=50,
epch=15):
self.model.fit([train_X1, train_X2, train_S],
train_y,
batch_size=batch_size_,
nb_epoch=epch,
verbose=1,
shuffle=True)
self.epch = epch
def predict(self, test_x1, test_x2, train_S):
return self.model.predict([test_x1, test_x2, train_S])
def evaluate(self, X1, X2, S, y):
return self.model.evaluate([X1, X2, S], y)
def save_Model_separately(self, path):
weights_file = os.path.join(path, 'weight.h5')
model_file = os.path.join(path, 'model_archi.json')
# Save the weights
self.model.save_weights(weights_file)
with open(model_file, 'w') as f:
f.write(self.model.to_json())
def save_model(self, path):
model_file = os.path.join(path, 'model_FM' + str(self.epch) + '.h5')
self.model.save(model_file)
return str(model_file)
def load_model(self, path):
self.model = load_model(path)
print(x.shape)
x = MaxPooling2D((2,2))(x)
print(x.shape)
x = Conv2D(35, (5, 5), padding='same', activation='relu')(x)
print(x.shape)
x = MaxPooling2D((2,2))(x)
print(x.shape)
x = Conv2D(40, (5, 5), padding='same', activation='relu')(x)
print(x.shape)
x = MaxPooling2D((2,2))(x)
print(x.shape)
print('pre flatten shape')
shape = K.int_shape(x)
print(shape)
x = Flatten()(x)
print(x.get_shape())
# time.sleep(20)
# z_mean = Dense(latentDim, name='z_mean')(x)
# z_log_var = Dense(latentDim, name='z_log_var')(x)
# print(z_mean.shape)
# print(z_log_var.shape)
# z = Lambda(sampling, output_shape=(latentDim,), name='z')([z_mean, z_log_var])
encoder_model = Model(encoder_in, x)
#This ensures the model will be shared, including weights
encoded1 = encoder_model(image1)
encoded2 = encoder_model(image2)
encoded3 = encoder_model(image3)
