def FC(dnn_feature_columns,
history_feature_list,
embedding_size=8,
hist_len_max=16,
dnn_use_bn=False,
dnn_hidden_units=(200, 80),
dnn_activation='relu',
l2_reg_dnn=0,
dnn_dropout=0,
init_std=0.0001,
seed=1024,
task='binary'):
"""Instantiates the Deep Interest Network architecture.
:param dnn_feature_columns: An iterable containing all the features used by deep part of the model.
:param history_feature_list: list,to indicate sequence sparse field
:param embedding_size: positive integer,sparse feature embedding_size.
:param hist_len_max: positive int, to indicate the max length of seq input
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of deep net
:param dnn_activation: Activation function to use in deep net
:param att_hidden_size: list,list of positive integer , the layer number and units in each layer of attention net
:param att_activation: Activation function to use in attention net
:param att_weight_normalization: bool.Whether normalize the attention score of local activation unit.
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
features = build_input_features(dnn_feature_columns)
sparse_feature_columns = list(
filter(lambda x: isinstance(x, SparseFeat),
dnn_feature_columns)) if dnn_feature_columns else []
dense_feature_columns = list(
filter(lambda x: isinstance(x, DenseFeat),
dnn_feature_columns)) if dnn_feature_columns else []
inputs_list = list(features.values())
embedding_dict = create_embedding_matrix(sparse_feature_columns)
dnn_input_emb_list = embedding_lookup(embedding_dict, features,
sparse_feature_columns)
dense_value_list = get_dense_input(features, dense_feature_columns)
print(dense_value_list)
deep_input_emb = concat_fun(dnn_input_emb_list)
deep_input_emb = deep_input_emb
print(deep_input_emb)
deep_input_emb = Flatten()(deep_input_emb)
print(deep_input_emb)
dnn_input = combined_dnn_input([deep_input_emb], dense_value_list)
print(dnn_input)
# output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn,
# dnn_dropout, dnn_use_bn, seed)(dnn_input)
output = Dense(200, activation='relu')(dnn_input)
output = Dense(80, activation='relu')(output)
output = Dense(1, activation='sigmoid')(output)
# output = PredictionLayer(task)(final_logit)
model = Model(inputs=inputs_list, outputs=output)
return model
tamano_filtro1,
padding="same",
input_shape=(longitud, altura, 3),
activation='relu'))
# Agrega capa 2 un Maxpooling
cnn.add(MaxPooling2D(pool_size=tamano_pool))
# Agrega capa 3 otra capa convolucional (Input_shape solo se usa en la primera capa)
cnn.add(Convolution2D(filtrosConv2, tamano_filtro2, padding="same"))
# Agrega capa 4 Maxpooling
cnn.add(MaxPooling2D(pool_size=tamano_pool))
# Agrega capa 5 Aplana la imagen a una sola dimesion
cnn.add(Flatten())
# Agrega capa 6 agrega 256 neuronas con activacion relu
cnn.add(Dense(256, activation="relu"))
# Agrega capa 7 y activa aleatoriamente solo la mitad de las neuronas
cnn.add(Dropout(0.5))
# Agrega capa 8 con solo 3 neuronas para clasificar y su activacion es softmax
cnn.add(Dense(clases, activation="softmax"))
# Compila la cnn con la finalidad de mejorar la accuracy
cnn.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=lr),
metrics=['accuracy'])
dummy_env = create_env()
initializer = VarianceScaling()
model = Sequential([
Conv2D(8,
4,
activation='elu',
padding='same',
input_shape=dummy_env.observation_space.shape,
kernel_initializer=initializer),
Conv2D(16,
2,
activation='elu',
padding='valid',
input_shape=dummy_env.observation_space.shape,
kernel_initializer=initializer),
Flatten(),
Dropout(0.5),
Dense(512, activation='elu', kernel_initializer=initializer)
])
# Optimizer with sheduled learning rate decay
optimizer = Adam(lr=3e-3, decay=1e-5)
# Run multiple instances
instances = 8
# Exploration and learning rate decay after each epoch
eps_max = 0.2
eps_decay = 0.9
learning_rate = 3e-3
learning_decay = 0.9
# Create Advantage Actor-Critic agent
agent = A2C(model,
actions=dummy_env.action_space.n,
def add(self, data_format=None, **kwargs):
return self._add_layer(Flatten(data_format=data_format, **kwargs))
def build(input_shape, num_outputs, block_fn, hp_lambda, repetitions):
"""Builds a custom ResNet like architecture.
Args:
input_shape: The input shape in the form (nb_channels, nb_rows, nb_cols)
num_outputs: The number of outputs at final softmax layer
block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
The original paper used basic_block for layers < 50
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size is halved
Returns:
The keras `Model`.
"""
_handle_dim_ordering()
if len(input_shape) != 3:
raise Exception(
"Input shape should be a tuple (nb_channels, nb_rows, nb_cols)"
)
# Permute dimension order if necessary
if K.image_data_format() == 'channels_last':
input_shape = (input_shape[1], input_shape[2], input_shape[0])
# Load function from str if needed.
block_fn = _get_block(block_fn)
input = Input(shape=input_shape)
conv1 = _conv_bn_relu(filters=16, kernel_size=(7, 7),
strides=(2, 2))(input)
pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2),
padding="same")(conv1)
block = pool1
filters = 16
for i, r in enumerate(repetitions):
#block = SpatialDropout2D(rate=0.5)(block)
block = _residual_block(block_fn,
filters=filters,
repetitions=r,
is_first_layer=(i == 0))(block)
filters *= 2
# Last activation
block_output_split = _bn_relu(block)
#block = SpatialDropout2D(rate=0.5)(block)
# Classifier block class label
block_shape = K.int_shape(block_output_split)
pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS],
block_shape[COL_AXIS]),
strides=(1, 1))(block_output_split)
flatten1 = Flatten()(pool2)
dense_class = Dense(units=num_outputs,
kernel_initializer="he_normal",
activation="sigmoid")(flatten1)
# Classifier block domain label
hp_lambda = 0.01
Flip = flipGradient.GradientReversal(hp_lambda)
block = Flip(block_output_split)
block_shape = K.int_shape(block)
pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS],
block_shape[COL_AXIS]),
strides=(1, 1))(block)
flatten1 = Flatten()(pool2)
# flatten1 = Dense(units=256, kernel_initializer="he_normal", activation="relu")(flatten1)
# flatten1 = Dense(units=256, kernel_initializer="he_normal", activation="relu")(flatten1)
dense_domain = Dense(units=num_outputs,
kernel_initializer="he_normal",
activation="sigmoid")(flatten1)
model_combined = Model(inputs=input,
outputs=[dense_class, dense_domain])
model_class = Model(inputs=input, outputs=dense_class)
model_domain = Model(inputs=input, outputs=dense_domain)
return (model_combined, model_class)
def EEGNet(nb_classes, Chans = 64, Samples = 128,
dropoutRate = 0.5, kernLength = 64, F1 = 8,
D = 2, F2 = 16, norm_rate = 0.25, dropoutType = 'Dropout'):
""" Keras Implementation of EEGNet
http://iopscience.iop.org/article/10.1088/1741-2552/aace8c/meta
Note that this implements the newest version of EEGNet and NOT the earlier
version (version v1 and v2 on arxiv). We strongly recommend using this
architecture as it performs much better and has nicer properties than
our earlier version. For example:
1. Depthwise Convolutions to learn spatial filters within a
temporal convolution. The use of the depth_multiplier option maps
exactly to the number of spatial filters learned within a temporal
filter. This matches the setup of algorithms like FBCSP which learn
spatial filters within each filter in a filter-bank. This also limits
the number of free parameters to fit when compared to a fully-connected
convolution.
2. Separable Convolutions to learn how to optimally combine spatial
filters across temporal bands. Separable Convolutions are Depthwise
Convolutions followed by (1x1) Pointwise Convolutions.
While the original paper used Dropout, we found that SpatialDropout2D
sometimes produced slightly better results for classification of ERP
signals. However, SpatialDropout2D significantly reduced performance
on the Oscillatory dataset (SMR, BCI-IV Dataset 2A). We recommend using
the default Dropout in most cases.
Assumes the input signal is sampled at 128Hz. If you want to use this model
for any other sampling rate you will need to modify the lengths of temporal
kernels and average pooling size in blocks 1 and 2 as needed (double the
kernel lengths for double the sampling rate, etc). Note that we haven't
tested the model performance with this rule so this may not work well.
The model with default parameters gives the EEGNet-8,2 model as discussed
in the paper. This model should do pretty well in general, although it is
advised to do some model searching to get optimal performance on your
particular dataset.
We set F2 = F1 * D (number of input filters = number of output filters) for
the SeparableConv2D layer. We haven't extensively tested other values of this
parameter (say, F2 < F1 * D for compressed learning, and F2 > F1 * D for
overcomplete). We believe the main parameters to focus on are F1 and D.
Inputs:
nb_classes : int, number of classes to classify
Chans, Samples : number of channels and time points in the EEG data
dropoutRate : dropout fraction
kernLength : length of temporal convolution in first layer. We found
that setting this to be half the sampling rate worked
well in practice. For the SMR dataset in particular
since the data was high-passed at 4Hz we used a kernel
length of 32.
F1, F2 : number of temporal filters (F1) and number of pointwise
filters (F2) to learn. Default: F1 = 8, F2 = F1 * D.
D : number of spatial filters to learn within each temporal
convolution. Default: D = 2
dropoutType : Either SpatialDropout2D or Dropout, passed as a string.
"""
if dropoutType == 'SpatialDropout2D':
dropoutType = SpatialDropout2D
elif dropoutType == 'Dropout':
dropoutType = Dropout
else:
raise ValueError('dropoutType must be one of SpatialDropout2D '
'or Dropout, passed as a string.')
input1 = Input(shape = (1, Chans, Samples))
##################################################################
block1 = Conv2D(F1, (1, kernLength), padding = 'same',
input_shape = (1, Chans, Samples),
use_bias = False)(input1)
block1 = BatchNormalization(axis = 1)(block1)
block1 = DepthwiseConv2D((Chans, 1), use_bias = False,
depth_multiplier = D,
depthwise_constraint = max_norm(1.))(block1)
block1 = BatchNormalization(axis = 1)(block1)
block1 = Activation('elu')(block1)
block1 = AveragePooling2D((1, 4))(block1)
block1 = dropoutType(dropoutRate)(block1)
block2 = SeparableConv2D(F2, (1, 16),
use_bias = False, padding = 'same')(block1)
block2 = BatchNormalization(axis = 1)(block2)
block2 = Activation('elu')(block2)
block2 = AveragePooling2D((1, 8))(block2)
block2 = dropoutType(dropoutRate)(block2)
flatten = Flatten(name = 'flatten')(block2)
dense = Dense(nb_classes, name = 'dense',
kernel_constraint = max_norm(norm_rate))(flatten)
softmax = Activation('softmax', name = 'softmax')(dense)
return Model(inputs=input1, outputs=softmax)
def build_model_ex(self, pos_mode=0, use_mask=False, active_layers=999):
#define embedding layer
uid_embedding = Embedding(750000, 16, name='uid_embedding') # for uid
itemid_embedding = Embedding(7500000, 32,
name='itemid_embedding') # for icf1
f1_embedding = Embedding(8, 2, name='f1_embedding') # for ucf1
f2_embedding = Embedding(4, 2, name='f2_embedding') # for ucf2 & icf3
f3_embedding = Embedding(8, 2, name='f3_embedding') # for ucf3 & icf4
f4_embedding = Embedding(4, 2, name='f4_embedding') # for icf5
f5_embedding = Embedding(256, 4, name='f5_embedding') # icf2
#define user input
uid_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='uid_input')
ucf1_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='ucf1_input')
ucf2_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='ucf2_input')
ucf3_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='ucf3_input')
#define item input
icf1_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='icf1_input')
icf2_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='icf2_input')
icf3_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='icf3_input')
icf4_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='icf4_input')
icf5_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='icf5_input')
#define dense input
v_input = Input(shape=(self.seq_len, self.d_feature), name='v_input')
#define user embedding
u0 = uid_embedding(uid_input)
u1 = f1_embedding(ucf1_input)
u2 = f2_embedding(ucf2_input)
u3 = f3_embedding(ucf3_input)
#define item embedding
i1 = itemid_embedding(icf1_input)
i2 = f5_embedding(icf2_input)
i3 = f2_embedding(icf3_input)
i4 = f3_embedding(icf4_input)
i5 = f4_embedding(icf5_input)
#define page embedding: 16+2+2+2+32+4+2+2+2=64
page_embedding = concatenate(
[v_input, u0, u1, u2, u3, i1, i2, i3, i4, i5],
axis=-1,
name='page_embedding')
d0 = TimeDistributed(Dense(self.d_model))(page_embedding)
pos_input = Input(shape=(self.seq_len, ),
dtype='int32',
name='pos_input')
if pos_mode == 0: # use fix pos embedding
pos_embedding = Embedding(self.seq_len, self.d_model, trainable=False,\
weights=[GetPosEncodingMatrix(self.seq_len, self.d_model)])
p0 = pos_embedding(pos_input)
elif pos_mode == 1: # use trainable ebmedding
pos_embedding = Embedding(self.seq_len, self.d_model)
p0 = pos_embedding(pos_input)
else: # not use pos embedding
p0 = None
if p0 != None:
combine_input = Add()([d0, p0])
else:
combine_input = d0 # no pos
sub_mask = None
if use_mask:
sub_mask = Lambda(GetSubMask)(pos_input)
enc_output = self.encoder(combine_input,
mask=sub_mask,
active_layers=active_layers)
# score
time_score_dense1 = TimeDistributed(
Dense(self.d_model, activation='tanh'))(enc_output)
time_score_dense2 = TimeDistributed(Dense(1))(time_score_dense1)
flat = Flatten()(time_score_dense2)
score_output = Activation(activation='softmax')(flat)
base_input = [
pos_input, uid_input, ucf1_input, ucf2_input, ucf3_input,
icf1_input, icf2_input, icf3_input, icf4_input, icf5_input, v_input
]
self.model = Model(base_input, score_output)
return self.model
def DIN(dnn_feature_columns,
history_feature_list,
embedding_size=8,
hist_len_max=16,
dnn_use_bn=False,
dnn_hidden_units=(200, 80),
dnn_activation='relu',
att_hidden_size=(80, 40),
att_activation="dice",
att_weight_normalization=False,
l2_reg_dnn=0,
l2_reg_embedding=1e-6,
dnn_dropout=0,
init_std=0.0001,
seed=1024,
task='binary'):
"""Instantiates the Deep Interest Network architecture.
:param dnn_feature_columns: An iterable containing all the features used by deep part of the model.
:param history_feature_list: list,to indicate sequence sparse field
:param embedding_size: positive integer,sparse feature embedding_size.
:param hist_len_max: positive int, to indicate the max length of seq input
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of deep net
:param dnn_activation: Activation function to use in deep net
:param att_hidden_size: list,list of positive integer , the layer number and units in each layer of attention net
:param att_activation: Activation function to use in attention net
:param att_weight_normalization: bool.Whether normalize the attention score of local activation unit.
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
features = build_input_features(dnn_feature_columns)
sparse_feature_columns = list(
filter(lambda x: isinstance(x, SparseFeat),
dnn_feature_columns)) if dnn_feature_columns else []
dense_feature_columns = list(
filter(lambda x: isinstance(x, DenseFeat),
dnn_feature_columns)) if dnn_feature_columns else []
varlen_sparse_feature_columns = list(
filter(lambda x: isinstance(x, VarLenSparseFeat),
dnn_feature_columns)) if dnn_feature_columns else []
history_feature_columns = []
sparse_varlen_feature_columns = []
history_fc_names = list(map(lambda x: "hist_" + x, history_feature_list))
for fc in varlen_sparse_feature_columns:
feature_name = fc.name
if feature_name in history_fc_names:
history_feature_columns.append(fc)
else:
sparse_varlen_feature_columns.append(fc)
inputs_list = list(features.values())
embedding_dict = create_embedding_matrix(dnn_feature_columns,
l2_reg_embedding,
init_std,
seed,
embedding_size,
prefix="")
query_emb_list = embedding_lookup(embedding_dict, features,
sparse_feature_columns,
history_feature_list,
history_feature_list) #query是单独的
keys_emb_list = embedding_lookup(embedding_dict, features,
history_feature_columns, history_fc_names,
history_fc_names)
dnn_input_emb_list = embedding_lookup(embedding_dict,
features,
sparse_feature_columns,
mask_feat_list=history_feature_list)
dense_value_list = get_dense_input(features, dense_feature_columns)
sequence_embed_dict = varlen_embedding_lookup(
embedding_dict, features, sparse_varlen_feature_columns)
sequence_embed_list = get_varlen_pooling_list(
sequence_embed_dict, features, sparse_varlen_feature_columns)
dnn_input_emb_list += sequence_embed_list
keys_emb = concat_fun(keys_emb_list, mask=True)
deep_input_emb = concat_fun(dnn_input_emb_list)
query_emb = concat_fun(query_emb_list, mask=True)
hist = AttentionSequencePoolingLayer(
att_hidden_size,
att_activation,
weight_normalization=att_weight_normalization,
supports_masking=True)([query_emb, keys_emb])
deep_input_emb = Concatenate()([NoMask()(deep_input_emb), hist])
deep_input_emb = Flatten()(deep_input_emb)
dnn_input = combined_dnn_input([deep_input_emb], dense_value_list)
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
dnn_use_bn, seed)(dnn_input)
final_logit = Dense(1, use_bias=False)(output)
output = PredictionLayer(task)(final_logit)
model = Model(inputs=inputs_list, outputs=output)
return model
def build_explanation_model(self,
input_dim,
output_dim,
loss,
downsample_factors=(1, )):
num_indices, num_channels, steps, downsampling_factor =\
MaskingUtil.get_input_constants(input_dim, downsample_factors)
if downsampling_factor != 1 and num_indices is None:
raise ValueError(
"Attribution downsampling is not supported for variable length inputs. "
"Please pad your data samples to the same size to use downsampling."
)
input_shape = (input_dim, ) if not isinstance(
input_dim, collections.Sequence) else input_dim
input_layer = Input(shape=input_shape)
last_layer = self.build(input_layer)
if num_indices is None:
last_layer = Dense(1, activation="linear")(last_layer)
last_layer = Flatten()(last_layer) # None * None outputs
last_layer = Lambda(
K.softmax, output_shape=K.int_shape(last_layer))(last_layer)
else:
last_layer = Flatten()(last_layer)
last_layer = Dense(num_indices, activation="softmax")(last_layer)
# Prepare extra inputs for causal loss.
all_auxiliary_outputs = Input(shape=(output_dim, ), name="all")
all_but_one_auxiliary_outputs_input = Input(shape=(num_indices,
output_dim),
name="all_but_one")
if num_indices is not None:
all_but_one_auxiliary_outputs = Lambda(lambda x: tf.unstack(
x, axis=1))(all_but_one_auxiliary_outputs_input)
if K.int_shape(all_but_one_auxiliary_outputs_input)[1] == 1:
all_but_one_auxiliary_outputs = [all_but_one_auxiliary_outputs]
else:
all_but_one_auxiliary_outputs = all_but_one_auxiliary_outputs_input
causal_loss_fun = partial(
causal_loss,
attention_weights=last_layer,
auxiliary_outputs=all_auxiliary_outputs,
all_but_one_auxiliary_outputs=all_but_one_auxiliary_outputs,
loss_function=loss)
causal_loss_fun.__name__ = "causal_loss"
if downsampling_factor != 1:
last_layer = Reshape(tuple(steps) + (1, ))(last_layer)
if len(steps) == 1:
# Add a dummy dimension to enable usage of __resize_images__.
last_layer = Reshape(tuple(steps) + (1, 1))(last_layer)
last_layer = Lambda(lambda x: resize_images(
x,
height_factor=downsample_factors[0],
width_factor=1,
data_format="channels_last"))(last_layer)
elif len(steps) == 2:
last_layer = Lambda(lambda x: resize_images(
x,
height_factor=downsample_factors[0],
width_factor=downsample_factors[1],
data_format="channels_last"))(last_layer)
elif len(steps) == 3:
last_layer = Lambda(lambda x: resize_volumes(
x,
depth_factor=downsample_factors[0],
height_factor=downsample_factors[1],
width_factor=downsample_factors[2],
data_format="channels_last"))(last_layer)
else:
raise ValueError(
"Attribution maps of larger dimensionality than 3D data are not currently supported. "
"Requested output dim was: {}.".format(len(steps)))
attribution_shape = Validation.get_attribution_shape_from_input_shape(
num_samples=1, input_dim=input_dim)[1:]
collapsed_attribution_shape = (int(np.prod(attribution_shape)), )
last_layer = Reshape(collapsed_attribution_shape)(last_layer)
# Re-normalise to sum = 1 after resizing (sum = __downsampling_factor__ after resizing).
last_layer = Lambda(lambda x: x / float(downsampling_factor))(
last_layer)
# We must connect all inputs to the output to bypass a bug in model saving in tf < 1.15.0rc0.
# For easier handling when calling .fit(), we transform all outputs to be the same shape.
# See https://github.com/tensorflow/tensorflow/pull/30244
all_but_one_same_shape_output_layer = Lambda(lambda x: x[:, 0, :])(
all_but_one_auxiliary_outputs_input)
model = Model(inputs=[
input_layer, all_auxiliary_outputs,
all_but_one_auxiliary_outputs_input
],
outputs=[
last_layer, all_auxiliary_outputs,
all_but_one_same_shape_output_layer
])
model = self.compile_model(model,
main_losses=[causal_loss_fun, "mse", "mse"],
loss_weights=[1.0] * 3,
learning_rate=self.learning_rate,
optimizer=self.optimizer)
prediction_model = Model(input_layer, last_layer)
return model, prediction_model
def resnet_v2(input_shape, depth, num_classes=10, fused_batch_norm=False):
"""ResNet Version 2 Model builder [b]
Stacks of (1 x 1)-(3 x 3)-(1 x 1) BN-ReLU-Conv2D or also known as
bottleneck layer
First shortcut connection per layer is 1 x 1 Conv2D.
Second and onwards shortcut connection is identity.
At the beginning of each stage, the feature map size is halved (downsampled)
by a convolutional layer with strides=2, while the number of filter maps is
doubled. Within each stage, the layers have the same number filters and the
same filter map sizes.
Features maps sizes:
conv1 : 32x32, 16
stage 0: 32x32, 64
stage 1: 16x16, 128
stage 2: 8x8, 256
# Arguments
input_shape (tensor): shape of input image tensor
depth (int): number of core convolutional layers
num_classes (int): number of classes (CIFAR10 has 10)
# Returns
model (Model): Keras model instance
"""
if (depth - 2) % 9 != 0:
raise ValueError('depth should be 9n+2 (eg 56 or 110 in [b])')
# Start model definition.
num_filters_in = 16
num_res_blocks = int((depth - 2) / 9)
inputs = Input(shape=input_shape)
# v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths
x = resnet_layer(inputs=inputs,
num_filters=num_filters_in,
conv_first=True,
fused_batch_norm=fused_batch_norm)
# Instantiate the stack of residual units
for stage in range(3):
for res_block in range(num_res_blocks):
activation = 'relu'
batch_normalization = True
strides = 1
if stage == 0:
num_filters_out = num_filters_in * 4
if res_block == 0: # first layer and first stage
activation = None
batch_normalization = False
else:
num_filters_out = num_filters_in * 2
if res_block == 0: # first layer but not first stage
strides = 2 # downsample
# bottleneck residual unit
y = resnet_layer(inputs=x,
num_filters=num_filters_in,
kernel_size=1,
strides=strides,
activation=activation,
batch_normalization=batch_normalization,
conv_first=False)
y = resnet_layer(inputs=y,
num_filters=num_filters_in,
conv_first=False)
y = resnet_layer(inputs=y,
num_filters=num_filters_out,
kernel_size=1,
conv_first=False)
if res_block == 0:
# linear projection residual shortcut connection to match
# changed dims
x = resnet_layer(inputs=x,
num_filters=num_filters_out,
kernel_size=1,
strides=strides,
activation=None,
batch_normalization=False)
x = keras.layers.add([x, y])
num_filters_in = num_filters_out
# Add classifier on top.
# v2 has BN-ReLU before Pooling
x = BatchNormalization(fused=fused_batch_norm)(x)
x = Activation('relu')(x)
x = AveragePooling2D(pool_size=8)(x)
y = Flatten()(x)
outputs = Dense(num_classes,
activation='softmax',
kernel_initializer='he_normal')(y)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
def ResNet50(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the ResNet50 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.
"""
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 = ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), padding='valid', name='conv1')(x)
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((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')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
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 = AveragePooling2D((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 = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(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='resnet50')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
md5_hash='a7b3fe01876f51b976af0dea6bc144eb')
else:
weights_path = get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
model.load_weights(weights_path)
if K.backend() == 'theano':
layer_utils.convert_all_kernels_in_model(model)
elif weights is not None:
model.load_weights(weights)
return model
def classification_small_convnet_model(args, input_shape, num_classes):
"""Convnet classification"""
model = keras.models.Sequential()
model.add(keras.layers.InputLayer(input_shape=input_shape))
model.add(
_conv2d_layer(args, 32, (3, 3), padding='same'))
# if args.batch_norm:
# The default Conv2D data format is 'channels_last' and the
# default BatchNormalization axes is -1.
#
# In batch norm fix a channel and average over the samples
# and the spatial location. axis = the axis we keep fixed
# (averaging over the rest), so for 'channels_last' this is
# the last axis, -1.
# model.add(BatchNormalization())
# model.add(Activation(args.activation))
## Aitor
model.add(Activation(args.activation))
if args.batch_norm:
if args.mean_to_zero:
bconstraint=keras.constraints.MaxNorm(max_value=0)
else:
bconstraint=None
model.add(BatchNormalization(beta_constraint=bconstraint))
## Aitor
model.add(_conv2d_layer(args, 32, (3, 3)))
# if args.batch_norm:
# model.add(BatchNormalization())
# model.add(Activation(args.activation))
## Aitor
model.add(Activation(args.activation))
if args.batch_norm:
if args.mean_to_zero:
bconstraint=keras.constraints.MaxNorm(max_value=0)
else:
bconstraint=None
model.add(BatchNormalization(beta_constraint=bconstraint))
## Aitor
model.add(MaxPooling2D(pool_size=(2, 2)))
if args.dropout:
model.add(Dropout(0.25))
model.add(_conv2d_layer(args, 64, (3, 3), padding='same'))
# if args.batch_norm:
# model.add(BatchNormalization())
# model.add(Activation(args.activation))
## Aitor
model.add(Activation(args.activation))
if args.batch_norm:
if args.mean_to_zero:
bconstraint=keras.constraints.MaxNorm(max_value=0)
else:
bconstraint=None
model.add(BatchNormalization(beta_constraint=bconstraint))
## Aitor
model.add(_conv2d_layer(args, 64, (3, 3)))
# if args.batch_norm:
# model.add(BatchNormalization())
# model.add(Activation(args.activation))
## Aitor
model.add(Activation(args.activation))
if args.batch_norm:
if args.mean_to_zero:
bconstraint=keras.constraints.MaxNorm(max_value=0)
else:
bconstraint=None
model.add(BatchNormalization(beta_constraint=bconstraint))
## Aitor
model.add(MaxPooling2D(pool_size=(2, 2)))
if args.dropout:
model.add(Dropout(0.25))
model.add(Flatten())
# if args.dense:
# model.add(Dense(args.cnn_last_layer, name='dense'))
# if args.overparam > 0:
# for i in range(args.overparam):
# model.add(Dense(args.cnn_last_layer,
# name='dense-overparam{}'.format(i + 1)))
# if args.batch_norm:
# model.add(BatchNormalization())
# model.add(Activation(args.activation))
# if args.dropout:
# model.add(Dropout(0.5))
if args.overparam > 0:
for i in range(args.overparam):
model.add(
_dense_layer(
args, num_classes, name='output-overparam{}'.format(i + 1)))
logits = _dense_layer(args, num_classes, name='logits')
model.add(logits)
model.add(Activation('softmax'))
return model
def InceptionResNetV2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the Inception-ResNet v2 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 TensorFlow, Theano and
CNTK backends. The data format convention used by the model is
the one specified in your Keras config file.
Note that the default input image size for this model is 299x299, instead
of 224x224 as in the VGG16 and ResNet models. Also, the input preprocessing
function is different (i.e., do not use `imagenet_utils.preprocess_input()`
with this model. Use `preprocess_input()` defined in this module instead).
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 `(299, 299, 3)` (with `'channels_last'` data format)
or `(3, 299, 299)` (with `'channels_first'` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 139.
E.g. `(150, 150, 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.
"""
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=299,
min_size=139,
data_format=K.image_data_format(),
require_flatten=False,
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
# Stem block: 35 x 35 x 192
x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid')
x = conv2d_bn(x, 32, 3, padding='valid')
x = conv2d_bn(x, 64, 3)
x = MaxPooling2D(3, strides=2)(x)
x = conv2d_bn(x, 80, 1, padding='valid')
x = conv2d_bn(x, 192, 3, padding='valid')
x = MaxPooling2D(3, strides=2)(x)
# Mixed 5b (Inception-A block): 35 x 35 x 320
branch_0 = conv2d_bn(x, 96, 1)
branch_1 = conv2d_bn(x, 48, 1)
branch_1 = conv2d_bn(branch_1, 64, 5)
branch_2 = conv2d_bn(x, 64, 1)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_pool = AveragePooling2D(3, strides=1, padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1)
branches = [branch_0, branch_1, branch_2, branch_pool]
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
x = Concatenate(axis=channel_axis, name='mixed_5b')(branches)
# 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
for block_idx in range(1, 11):
x = inception_resnet_block(
x, scale=0.17, block_type='block35', block_idx=block_idx)
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 256, 3)
branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='valid')
branch_pool = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
for block_idx in range(1, 21):
x = inception_resnet_block(
x, scale=0.1, block_type='block17', block_idx=block_idx)
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
branch_0 = conv2d_bn(x, 256, 1)
branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='valid')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='valid')
branch_2 = conv2d_bn(x, 256, 1)
branch_2 = conv2d_bn(branch_2, 288, 3)
branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='valid')
branch_pool = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
for block_idx in range(1, 10):
x = inception_resnet_block(
x, scale=0.2, block_type='block8', block_idx=block_idx)
x = inception_resnet_block(
x, scale=1., activation=None, block_type='block8', block_idx=10)
# Final convolution block: 8 x 8 x 1536
x = conv2d_bn(x, 1536, 1, name='conv_7b')
if include_top:
# Classification block
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
x = Flatten(name='custom')(x) ##DB
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`
if input_tensor is not None:
inputs = layer_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model
model = Model(inputs, x, name='inception_resnet_v2')
# Load weights
if weights == 'imagenet':
if include_top:
fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5'
weights_path = get_file(
fname,
BASE_WEIGHT_URL + fname,
cache_subdir='models',
file_hash='e693bd0210a403b3192acc6073ad2e96')
else:
fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5'
weights_path = get_file(
fname,
BASE_WEIGHT_URL + fname,
cache_subdir='models',
file_hash='d19885ff4a710c122648d3b5c3b684e4')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def VGG16(save_dir):
VGG16 = Sequential()
VGG16.add(
Conv2D(64, (3, 3),
strides=(1, 1),
input_shape=(224, 224, 3),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(64, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(128, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(128, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(Flatten())
VGG16.add(Dense(4096, activation='relu'))
VGG16.add(Dropout(0.5))
VGG16.add(Dense(4096, activation='relu'))
VGG16.add(Dropout(0.5))
VGG16.add(Dense(1000, activation='softmax'))
VGG16.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
VGG16.summary()
save_dir += 'VGG16.h5'
return VGG16
cnn.add(
Convolution2D(filtrosConv1,
tamano_filtro1,
padding="same",
input_shape=(altura, longitud, 3),
activation='relu'))
cnn.add(MaxPooling2D(pool_size=tamano_pool))
cnn.add(
Convolution2D(filtrosConv2,
tamano_filtro2,
padding="same",
activation='relu'))
cnn.add(MaxPooling2D(pool_size=tamano_pool))
cnn.add(Flatten()) #imagen profunda y pequeña queda plana
cnn.add(Dense(256, activation='relu')
) #despues de aplanar la imformacion es enviada a una capa nueva
cnn.add(Dropout(
0.5)) #a esta capa densa se le apaga el 50% de 256 neuronas a cada paso.
cnn.add(Dense(
clases, activation='softmax')) #esta activacion es la que ayuda a predecir
cnn.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=lr),
metrics=['accuracy'])
cnn.fit_generator(imagen_entrenamiento,
steps_per_epoch=pasos,
epochs=epocas,
validation_data=imagen_validacion,
def DIN(feature_dim_dict,
seq_feature_list,
embedding_size=8,
hist_len_max=16,
dnn_use_bn=False,
dnn_hidden_units=(200, 80),
dnn_activation='relu',
att_hidden_size=(80, 40),
att_activation="dice",
att_weight_normalization=False,
l2_reg_dnn=0,
l2_reg_embedding=1e-6,
dnn_dropout=0,
init_std=0.0001,
seed=1024,
task='binary'):
"""Instantiates the Deep Interest Network architecture.
:param feature_dim_dict: dict,to indicate sparse field (**now only support sparse feature**)like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':[]}
:param seq_feature_list: list,to indicate sequence sparse field (**now only support sparse feature**),must be a subset of ``feature_dim_dict["sparse"]``
:param embedding_size: positive integer,sparse feature embedding_size.
:param hist_len_max: positive int, to indicate the max length of seq input
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of deep net
:param dnn_activation: Activation function to use in deep net
:param att_hidden_size: list,list of positive integer , the layer number and units in each layer of attention net
:param att_activation: Activation function to use in attention net
:param att_weight_normalization: bool.Whether normalize the attention score of local activation unit.
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
sparse_input, dense_input, user_behavior_input = get_input(
feature_dim_dict, seq_feature_list, hist_len_max)
sparse_embedding_dict = {
feat.name:
Embedding(feat.dimension,
embedding_size,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg_embedding),
name='sparse_emb_' + str(i) + '-' + feat.name,
mask_zero=(feat.name in seq_feature_list))
for i, feat in enumerate(feature_dim_dict["sparse"])
}
query_emb_list = get_embedding_vec_list(sparse_embedding_dict,
sparse_input,
feature_dim_dict['sparse'],
seq_feature_list, seq_feature_list)
keys_emb_list = get_embedding_vec_list(sparse_embedding_dict,
user_behavior_input,
feature_dim_dict['sparse'],
seq_feature_list, seq_feature_list)
deep_input_emb_list = get_embedding_vec_list(
sparse_embedding_dict,
sparse_input,
feature_dim_dict['sparse'],
mask_feat_list=seq_feature_list)
keys_emb = concat_fun(keys_emb_list)
deep_input_emb = concat_fun(deep_input_emb_list)
query_emb = concat_fun(query_emb_list)
hist = AttentionSequencePoolingLayer(
att_hidden_size,
att_activation,
weight_normalization=att_weight_normalization,
supports_masking=True)([query_emb, keys_emb])
deep_input_emb = Concatenate()([NoMask()(deep_input_emb), hist])
deep_input_emb = Flatten()(deep_input_emb)
if len(dense_input) > 0:
deep_input_emb = Concatenate()([deep_input_emb] +
list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
dnn_use_bn, seed)(deep_input_emb)
final_logit = Dense(1, use_bias=False)(output)
output = PredictionLayer(task)(final_logit)
model_input_list = get_inputs_list(
[sparse_input, dense_input, user_behavior_input])
model = Model(inputs=model_input_list, outputs=output)
return model
def DeepConvNet(nb_classes, Chans = 64, Samples = 256,
dropoutRate = 0.5):
""" Keras implementation of the Deep Convolutional Network as described in
Schirrmeister et. al. (2017), Human Brain Mapping.
This implementation assumes the input is a 2-second EEG signal sampled at
128Hz, as opposed to signals sampled at 250Hz as described in the original
paper. We also perform temporal convolutions of length (1, 5) as opposed
to (1, 10) due to this sampling rate difference.
Note that we use the max_norm constraint on all convolutional layers, as
well as the classification layer. We also change the defaults for the
BatchNormalization layer. We used this based on a personal communication
with the original authors.
ours original paper
pool_size 1, 2 1, 3
strides 1, 2 1, 3
conv filters 1, 5 1, 10
Note that this implementation has not been verified by the original
authors.
"""
# start the model
input_main = Input((1, Chans, Samples))
block1 = Conv2D(25, (1, 5),
input_shape=(1, Chans, Samples),
kernel_constraint = max_norm(2., axis=(0,1,2)))(input_main)
block1 = Conv2D(25, (Chans, 1),
kernel_constraint = max_norm(2., axis=(0,1,2)))(block1)
block1 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block1)
block1 = Activation('elu')(block1)
block1 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block1)
block1 = Dropout(dropoutRate)(block1)
block2 = Conv2D(50, (1, 5),
kernel_constraint = max_norm(2., axis=(0,1,2)))(block1)
block2 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block2)
block2 = Activation('elu')(block2)
block2 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block2)
block2 = Dropout(dropoutRate)(block2)
block3 = Conv2D(100, (1, 5),
kernel_constraint = max_norm(2., axis=(0,1,2)))(block2)
block3 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block3)
block3 = Activation('elu')(block3)
block3 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block3)
block3 = Dropout(dropoutRate)(block3)
block4 = Conv2D(200, (1, 5),
kernel_constraint = max_norm(2., axis=(0,1,2)))(block3)
block4 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block4)
block4 = Activation('elu')(block4)
block4 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block4)
block4 = Dropout(dropoutRate)(block4)
flatten = Flatten()(block4)
dense = Dense(nb_classes, kernel_constraint = max_norm(0.5))(flatten)
softmax = Activation('softmax')(dense)
return Model(inputs=input_main, outputs=softmax)
def onBeginTraining(self):
ue.log("starting mnist keras cnn opt training")
model_file_name = "mnistKerasCNNOpt"
model_directory = ue.get_content_dir() + "/Scripts/"
model_sess_path = model_directory + model_file_name + ".tfsess"
model_json_path = model_directory + model_file_name + ".json"
my_file = Path(model_json_path)
#reset the session each time we get training calls
K.clear_session()
#let's train
batch_size = 2000
self.batch_size = batch_size
num_classes = 10
epochs = 20
round_values = True
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
#so we train to sets closer to ue4 types
if(round_values):
x_train = x_train.round()
x_test = x_test.round()
ue.log('x_train shape:' + str(x_train.shape))
ue.log(str(x_train.shape[0]) + 'train samples')
ue.log(str(x_test.shape[0]) + 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
# create model
model = Sequential()
model.add(Conv2D(30, (5, 5), input_shape=input_shape, activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(15, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(50, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#pre-fill our callEvent data to minimize setting
jsonPixels = {}
size = {'x':28, 'y':28}
jsonPixels['size'] = size
self.jsonPixels = jsonPixels
self.x_train = x_train
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[self.stopcallback])
score = model.evaluate(x_test, y_test, verbose=0)
ue.log("mnist keras cnn training complete.")
ue.log('Test loss:' + str(score[0]))
ue.log('Test accuracy:' + str(score[1]))
self.session = K.get_session()
self.model = model
stored = {'model':model, 'session': self.session}
#run a test evaluation
ue.log(x_test.shape)
result_test = model.predict(np.reshape(x_test[500],(1,28,28,1)))
ue.log(result_test)
#flush the architecture model data to disk
#with open(model_json_path, "w") as json_file:
# json_file.write(model.to_json())
#flush the whole model and weights to disk
#saver = tf.train.Saver()
#save_path = saver.save(K.get_session(), model_sess_path)
#model.save(model_path)
return stored
def loadModel():
myInput = Input(shape=(96, 96, 3))
x = ZeroPadding2D(padding=(3, 3), input_shape=(96, 96, 3))(myInput)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x)
x = BatchNormalization(axis=3, epsilon=0.00001, name='bn1')(x)
x = Activation('relu')(x)
x = ZeroPadding2D(padding=(1, 1))(x)
x = MaxPooling2D(pool_size=3, strides=2)(x)
x = Lambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name='lrn_1')(x)
x = Conv2D(64, (1, 1), name='conv2')(x)
x = BatchNormalization(axis=3, epsilon=0.00001, name='bn2')(x)
x = Activation('relu')(x)
x = ZeroPadding2D(padding=(1, 1))(x)
x = Conv2D(192, (3, 3), name='conv3')(x)
x = BatchNormalization(axis=3, epsilon=0.00001, name='bn3')(x)
x = Activation('relu')(x)
x = Lambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name='lrn_2')(x)
x = ZeroPadding2D(padding=(1, 1))(x)
x = MaxPooling2D(pool_size=3, strides=2)(x)
# Inception3a
inception_3a_3x3 = Conv2D(96, (1, 1), name='inception_3a_3x3_conv1')(x)
inception_3a_3x3 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3a_3x3_bn1')(inception_3a_3x3)
inception_3a_3x3 = Activation('relu')(inception_3a_3x3)
inception_3a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3a_3x3)
inception_3a_3x3 = Conv2D(128, (3, 3),
name='inception_3a_3x3_conv2')(inception_3a_3x3)
inception_3a_3x3 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3a_3x3_bn2')(inception_3a_3x3)
inception_3a_3x3 = Activation('relu')(inception_3a_3x3)
inception_3a_5x5 = Conv2D(16, (1, 1), name='inception_3a_5x5_conv1')(x)
inception_3a_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3a_5x5_bn1')(inception_3a_5x5)
inception_3a_5x5 = Activation('relu')(inception_3a_5x5)
inception_3a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3a_5x5)
inception_3a_5x5 = Conv2D(32, (5, 5),
name='inception_3a_5x5_conv2')(inception_3a_5x5)
inception_3a_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3a_5x5_bn2')(inception_3a_5x5)
inception_3a_5x5 = Activation('relu')(inception_3a_5x5)
inception_3a_pool = MaxPooling2D(pool_size=3, strides=2)(x)
inception_3a_pool = Conv2D(
32, (1, 1), name='inception_3a_pool_conv')(inception_3a_pool)
inception_3a_pool = BatchNormalization(
axis=3, epsilon=0.00001,
name='inception_3a_pool_bn')(inception_3a_pool)
inception_3a_pool = Activation('relu')(inception_3a_pool)
inception_3a_pool = ZeroPadding2D(padding=((3, 4), (3,
4)))(inception_3a_pool)
inception_3a_1x1 = Conv2D(64, (1, 1), name='inception_3a_1x1_conv')(x)
inception_3a_1x1 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3a_1x1_bn')(inception_3a_1x1)
inception_3a_1x1 = Activation('relu')(inception_3a_1x1)
inception_3a = concatenate([
inception_3a_3x3, inception_3a_5x5, inception_3a_pool, inception_3a_1x1
],
axis=3)
# Inception3b
inception_3b_3x3 = Conv2D(96, (1, 1),
name='inception_3b_3x3_conv1')(inception_3a)
inception_3b_3x3 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3b_3x3_bn1')(inception_3b_3x3)
inception_3b_3x3 = Activation('relu')(inception_3b_3x3)
inception_3b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3b_3x3)
inception_3b_3x3 = Conv2D(128, (3, 3),
name='inception_3b_3x3_conv2')(inception_3b_3x3)
inception_3b_3x3 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3b_3x3_bn2')(inception_3b_3x3)
inception_3b_3x3 = Activation('relu')(inception_3b_3x3)
inception_3b_5x5 = Conv2D(32, (1, 1),
name='inception_3b_5x5_conv1')(inception_3a)
inception_3b_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3b_5x5_bn1')(inception_3b_5x5)
inception_3b_5x5 = Activation('relu')(inception_3b_5x5)
inception_3b_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3b_5x5)
inception_3b_5x5 = Conv2D(64, (5, 5),
name='inception_3b_5x5_conv2')(inception_3b_5x5)
inception_3b_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3b_5x5_bn2')(inception_3b_5x5)
inception_3b_5x5 = Activation('relu')(inception_3b_5x5)
inception_3b_pool = Lambda(lambda x: x**2, name='power2_3b')(inception_3a)
inception_3b_pool = AveragePooling2D(pool_size=(3, 3),
strides=(3, 3))(inception_3b_pool)
inception_3b_pool = Lambda(lambda x: x * 9,
name='mult9_3b')(inception_3b_pool)
inception_3b_pool = Lambda(lambda x: K.sqrt(x),
name='sqrt_3b')(inception_3b_pool)
inception_3b_pool = Conv2D(
64, (1, 1), name='inception_3b_pool_conv')(inception_3b_pool)
inception_3b_pool = BatchNormalization(
axis=3, epsilon=0.00001,
name='inception_3b_pool_bn')(inception_3b_pool)
inception_3b_pool = Activation('relu')(inception_3b_pool)
inception_3b_pool = ZeroPadding2D(padding=(4, 4))(inception_3b_pool)
inception_3b_1x1 = Conv2D(64, (1, 1),
name='inception_3b_1x1_conv')(inception_3a)
inception_3b_1x1 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3b_1x1_bn')(inception_3b_1x1)
inception_3b_1x1 = Activation('relu')(inception_3b_1x1)
inception_3b = concatenate([
inception_3b_3x3, inception_3b_5x5, inception_3b_pool, inception_3b_1x1
],
axis=3)
# Inception3c
inception_3c_3x3 = Conv2D(128, (1, 1),
strides=(1, 1),
name='inception_3c_3x3_conv1')(inception_3b)
inception_3c_3x3 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3c_3x3_bn1')(inception_3c_3x3)
inception_3c_3x3 = Activation('relu')(inception_3c_3x3)
inception_3c_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3c_3x3)
inception_3c_3x3 = Conv2D(256, (3, 3),
strides=(2, 2),
name='inception_3c_3x3_conv' +
'2')(inception_3c_3x3)
inception_3c_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_3c_3x3_bn' +
'2')(inception_3c_3x3)
inception_3c_3x3 = Activation('relu')(inception_3c_3x3)
inception_3c_5x5 = Conv2D(32, (1, 1),
strides=(1, 1),
name='inception_3c_5x5_conv1')(inception_3b)
inception_3c_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3c_5x5_bn1')(inception_3c_5x5)
inception_3c_5x5 = Activation('relu')(inception_3c_5x5)
inception_3c_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3c_5x5)
inception_3c_5x5 = Conv2D(64, (5, 5),
strides=(2, 2),
name='inception_3c_5x5_conv' +
'2')(inception_3c_5x5)
inception_3c_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_3c_5x5_bn' +
'2')(inception_3c_5x5)
inception_3c_5x5 = Activation('relu')(inception_3c_5x5)
inception_3c_pool = MaxPooling2D(pool_size=3, strides=2)(inception_3b)
inception_3c_pool = ZeroPadding2D(padding=((0, 1), (0,
1)))(inception_3c_pool)
inception_3c = concatenate(
[inception_3c_3x3, inception_3c_5x5, inception_3c_pool], axis=3)
# inception 4a
inception_4a_3x3 = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_4a_3x3_conv' + '1')(inception_3c)
inception_4a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_3x3_bn' +
'1')(inception_4a_3x3)
inception_4a_3x3 = Activation('relu')(inception_4a_3x3)
inception_4a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4a_3x3)
inception_4a_3x3 = Conv2D(192, (3, 3),
strides=(1, 1),
name='inception_4a_3x3_conv' +
'2')(inception_4a_3x3)
inception_4a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_3x3_bn' +
'2')(inception_4a_3x3)
inception_4a_3x3 = Activation('relu')(inception_4a_3x3)
inception_4a_5x5 = Conv2D(32, (1, 1),
strides=(1, 1),
name='inception_4a_5x5_conv1')(inception_3c)
inception_4a_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_4a_5x5_bn1')(inception_4a_5x5)
inception_4a_5x5 = Activation('relu')(inception_4a_5x5)
inception_4a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4a_5x5)
inception_4a_5x5 = Conv2D(64, (5, 5),
strides=(1, 1),
name='inception_4a_5x5_conv' +
'2')(inception_4a_5x5)
inception_4a_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_5x5_bn' +
'2')(inception_4a_5x5)
inception_4a_5x5 = Activation('relu')(inception_4a_5x5)
inception_4a_pool = Lambda(lambda x: x**2, name='power2_4a')(inception_3c)
inception_4a_pool = AveragePooling2D(pool_size=(3, 3),
strides=(3, 3))(inception_4a_pool)
inception_4a_pool = Lambda(lambda x: x * 9,
name='mult9_4a')(inception_4a_pool)
inception_4a_pool = Lambda(lambda x: K.sqrt(x),
name='sqrt_4a')(inception_4a_pool)
inception_4a_pool = Conv2D(128, (1, 1),
strides=(1, 1),
name='inception_4a_pool_conv' +
'')(inception_4a_pool)
inception_4a_pool = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_pool_bn' +
'')(inception_4a_pool)
inception_4a_pool = Activation('relu')(inception_4a_pool)
inception_4a_pool = ZeroPadding2D(padding=(2, 2))(inception_4a_pool)
inception_4a_1x1 = Conv2D(256, (1, 1),
strides=(1, 1),
name='inception_4a_1x1_conv' + '')(inception_3c)
inception_4a_1x1 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_1x1_bn' +
'')(inception_4a_1x1)
inception_4a_1x1 = Activation('relu')(inception_4a_1x1)
inception_4a = concatenate([
inception_4a_3x3, inception_4a_5x5, inception_4a_pool, inception_4a_1x1
],
axis=3)
# inception4e
inception_4e_3x3 = Conv2D(160, (1, 1),
strides=(1, 1),
name='inception_4e_3x3_conv' + '1')(inception_4a)
inception_4e_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_3x3_bn' +
'1')(inception_4e_3x3)
inception_4e_3x3 = Activation('relu')(inception_4e_3x3)
inception_4e_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4e_3x3)
inception_4e_3x3 = Conv2D(256, (3, 3),
strides=(2, 2),
name='inception_4e_3x3_conv' +
'2')(inception_4e_3x3)
inception_4e_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_3x3_bn' +
'2')(inception_4e_3x3)
inception_4e_3x3 = Activation('relu')(inception_4e_3x3)
inception_4e_5x5 = Conv2D(64, (1, 1),
strides=(1, 1),
name='inception_4e_5x5_conv' + '1')(inception_4a)
inception_4e_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_5x5_bn' +
'1')(inception_4e_5x5)
inception_4e_5x5 = Activation('relu')(inception_4e_5x5)
inception_4e_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4e_5x5)
inception_4e_5x5 = Conv2D(128, (5, 5),
strides=(2, 2),
name='inception_4e_5x5_conv' +
'2')(inception_4e_5x5)
inception_4e_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_5x5_bn' +
'2')(inception_4e_5x5)
inception_4e_5x5 = Activation('relu')(inception_4e_5x5)
inception_4e_pool = MaxPooling2D(pool_size=3, strides=2)(inception_4a)
inception_4e_pool = ZeroPadding2D(padding=((0, 1), (0,
1)))(inception_4e_pool)
inception_4e = concatenate(
[inception_4e_3x3, inception_4e_5x5, inception_4e_pool], axis=3)
# inception5a
inception_5a_3x3 = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5a_3x3_conv' + '1')(inception_4e)
inception_5a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_3x3_bn' +
'1')(inception_5a_3x3)
inception_5a_3x3 = Activation('relu')(inception_5a_3x3)
inception_5a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5a_3x3)
inception_5a_3x3 = Conv2D(384, (3, 3),
strides=(1, 1),
name='inception_5a_3x3_conv' +
'2')(inception_5a_3x3)
inception_5a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_3x3_bn' +
'2')(inception_5a_3x3)
inception_5a_3x3 = Activation('relu')(inception_5a_3x3)
inception_5a_pool = Lambda(lambda x: x**2, name='power2_5a')(inception_4e)
inception_5a_pool = AveragePooling2D(pool_size=(3, 3),
strides=(3, 3))(inception_5a_pool)
inception_5a_pool = Lambda(lambda x: x * 9,
name='mult9_5a')(inception_5a_pool)
inception_5a_pool = Lambda(lambda x: K.sqrt(x),
name='sqrt_5a')(inception_5a_pool)
inception_5a_pool = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5a_pool_conv' +
'')(inception_5a_pool)
inception_5a_pool = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_pool_bn' +
'')(inception_5a_pool)
inception_5a_pool = Activation('relu')(inception_5a_pool)
inception_5a_pool = ZeroPadding2D(padding=(1, 1))(inception_5a_pool)
inception_5a_1x1 = Conv2D(256, (1, 1),
strides=(1, 1),
name='inception_5a_1x1_conv' + '')(inception_4e)
inception_5a_1x1 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_1x1_bn' +
'')(inception_5a_1x1)
inception_5a_1x1 = Activation('relu')(inception_5a_1x1)
inception_5a = concatenate(
[inception_5a_3x3, inception_5a_pool, inception_5a_1x1], axis=3)
# inception_5b
inception_5b_3x3 = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5b_3x3_conv' + '1')(inception_5a)
inception_5b_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_3x3_bn' +
'1')(inception_5b_3x3)
inception_5b_3x3 = Activation('relu')(inception_5b_3x3)
inception_5b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5b_3x3)
inception_5b_3x3 = Conv2D(384, (3, 3),
strides=(1, 1),
name='inception_5b_3x3_conv' +
'2')(inception_5b_3x3)
inception_5b_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_3x3_bn' +
'2')(inception_5b_3x3)
inception_5b_3x3 = Activation('relu')(inception_5b_3x3)
inception_5b_pool = MaxPooling2D(pool_size=3, strides=2)(inception_5a)
inception_5b_pool = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5b_pool_conv' +
'')(inception_5b_pool)
inception_5b_pool = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_pool_bn' +
'')(inception_5b_pool)
inception_5b_pool = Activation('relu')(inception_5b_pool)
inception_5b_pool = ZeroPadding2D(padding=(1, 1))(inception_5b_pool)
inception_5b_1x1 = Conv2D(256, (1, 1),
strides=(1, 1),
name='inception_5b_1x1_conv' + '')(inception_5a)
inception_5b_1x1 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_1x1_bn' +
'')(inception_5b_1x1)
inception_5b_1x1 = Activation('relu')(inception_5b_1x1)
inception_5b = concatenate(
[inception_5b_3x3, inception_5b_pool, inception_5b_1x1], axis=3)
av_pool = AveragePooling2D(pool_size=(3, 3), strides=(1, 1))(inception_5b)
reshape_layer = Flatten()(av_pool)
dense_layer = Dense(128, name='dense_layer')(reshape_layer)
norm_layer = Lambda(lambda x: tf.math.l2_normalize(x, axis=1),
name='norm_layer')(dense_layer)
# Final Model
model = Model(inputs=[myInput], outputs=norm_layer)
home = str(Path.home())
if not os.path.isfile(home + '/.deepface/weights/openface_weights.h5'):
print("openface_weights.h5 will be downloaded...")
url = 'https://drive.google.com/uc?id=1LSe1YCV1x-BfNnfb7DFZTNpv_Q9jITxn'
output = home + '/.deepface/weights/openface_weights.h5'
gdown.download(url, output, quiet=False)
model.load_weights(home + '/.deepface/weights/openface_weights.h5')
return model
def instance_network(shape):
input_img = Input(shape=(*shape, 1, MAX_INSTANCES), name='fg_input_img')
input_packed = Lambda(lambda x: pack_instance(x),
name='fg_pack_input')(input_img)
input_img_3 = Lambda(lambda x: tf.tile(x, [1, 1, 1, 3]),
name='fg_input_tile')(input_packed)
# VGG16 without top layers
VGG_model = applications.vgg16.VGG16(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
model_3 = Model(VGG_model.input,
VGG_model.layers[-6].output,
name='fg_model_3')(input_img_3)
# Global features
conv2d_6 = Conv2D(512, (3, 3),
padding='same',
strides=(2, 2),
activation='relu',
name='fg_conv2d_6')(model_3)
batch_normalization_1 = BatchNormalization(
name='fg_batch_normalization_1')(conv2d_6)
conv2d_7 = Conv2D(512, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_7')(batch_normalization_1)
batch_normalization_2 = BatchNormalization(
name='fg_batch_normalization_2')(conv2d_7)
conv2d_8 = Conv2D(512, (3, 3),
padding='same',
strides=(2, 2),
activation='relu',
name='fg_conv2d_8')(batch_normalization_2)
batch_normalization_3 = BatchNormalization(
name='fg_batch_normalization_3')(conv2d_8)
conv2d_9 = Conv2D(512, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_9')(batch_normalization_3)
batch_normalization_4 = BatchNormalization(
name='fg_batch_normalization_4')(conv2d_9)
# Global feature pass back to colorization + classification
flatten_1 = Flatten(name='fg_flatten_1')(batch_normalization_4)
dense_1 = Dense(1024, activation='relu', name='fg_dense_1')(flatten_1)
dense_2 = Dense(512, activation='relu', name='fg_dense_2')(dense_1)
dense_3 = Dense(256, activation='relu', name='fg_dense_3')(dense_2)
repeat_vector_1 = RepeatVector(28 * 28, name='fg_repeat_vector_1')(dense_3)
reshape_1 = Reshape((28, 28, 256), name='fg_reshape_1')(repeat_vector_1)
# Mid-level features
conv2d_10 = Conv2D(512, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_10')(model_3)
batch_normalization_5 = BatchNormalization(
name='fg_batch_normalization_5')(conv2d_10)
conv2d_11 = Conv2D(256, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_11')(batch_normalization_5)
batch_normalization_6 = BatchNormalization(
name='fg_batch_normalization_6')(conv2d_11)
# Fusion of (VGG16 -> Mid-level) + (VGG16 -> Global) + Colorization
concatenate_2 = concatenate([batch_normalization_6, reshape_1],
name='fg_concatenate_2')
conv2d_12 = Conv2D(256, (1, 1),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_12')(concatenate_2)
conv2d_13 = Conv2D(128, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_13')(conv2d_12)
up_sampling2d_1 = UpSampling2D(size=(2, 2),
name='fg_up_sampling2d_1',
interpolation='bilinear')(conv2d_13)
# conv2dt_1 = Conv2DTranspose(64, (4, 4), padding='same', strides=(2, 2), name='fg_conv2dt_1')(conv2d_13)
conv2d_14 = Conv2D(64, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_14')(up_sampling2d_1)
conv2d_15 = Conv2D(64, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_15')(conv2d_14)
up_sampling2d_2 = UpSampling2D(size=(2, 2),
name='fg_up_sampling2d_2',
interpolation='bilinear')(conv2d_15)
# conv2dt_2 = Conv2DTranspose(32, (4, 4), padding='same', strides=(2, 2), name='fg_conv2dt_2')(conv2d_15)
conv2d_16 = Conv2D(32, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='fg_conv2d_16')(up_sampling2d_2)
conv2d_17 = Conv2D(2, (3, 3),
padding='same',
strides=(1, 1),
activation='sigmoid',
name='fg_conv2d_17')(conv2d_16)
up_sampling2d_3 = UpSampling2D(size=(2, 2),
name='fg_up_sampling2d_3')(conv2d_17)
model_3_unpack = Lambda(lambda x: unpack_instance(x),
name='fg_model_3_unpack')(model_3)
conv2d_11_unpack = Lambda(lambda x: unpack_instance(x),
name='fg_conv2d_11_unpack')(conv2d_11)
conv2d_13_unpack = Lambda(lambda x: unpack_instance(x),
name='fg_conv2d_13_unpack')(conv2d_13)
conv2d_15_unpack = Lambda(lambda x: unpack_instance(x),
name='fg_conv2d_15_unpack')(conv2d_15)
conv2d_17_unpack = Lambda(lambda x: unpack_instance(x),
name='fg_conv2d_17_unpack')(conv2d_17)
up_sampling2d_3_unpack = Lambda(
lambda x: unpack_instance(x),
name='up_sampling2d_3_unpack')(up_sampling2d_3)
generated = Model(inputs=input_img,
outputs=[
model_3_unpack, conv2d_11_unpack, conv2d_13_unpack,
conv2d_15_unpack, conv2d_17_unpack,
up_sampling2d_3_unpack
])
return generated
interpolation='bicubic',
class_mode='categorical',
shuffle=False,
batch_size=BATCH_SIZE)
'''
# output the index number of each class
for cls, idx in train_batches_ref.class_indices.items():
print('Class #{} = {}'.format(idx, cls))
# use pretrained resnet50 and drop the last fully connected layer
net = ResNet50(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3))
x = net.output
x = Flatten()(x)
# add a dropout layer
x = Dropout(0.5)(x)
# add another Dense layer
#x = Dense(2048, activation='relu', name='readToOutput')(x)
#x = Dropout(0.5)(x)
# add a dense layer with softmax
output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(x)
# set the layers to be whether freezed or trained
net_final = Model(inputs=net.input, outputs=output_layer)
for layer in net_final.layers[:FREEZE_LAYERS]:
layer.trainable = False
def fusion_network(shape, batch_size):
input_img = Input(shape=(*shape, 1), name='input_img')
input_img_3 = Lambda(lambda x: tf.tile(x, [1, 1, 1, 3]),
name='input_tile')(input_img)
bbox = Input(shape=(4, MAX_INSTANCES), name='bbox')
mask = Input(shape=(*shape, MAX_INSTANCES), name='mask')
# VGG16 without top layers
VGG_model = applications.vgg16.VGG16(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
vgg_model_3_pre = Model(VGG_model.input,
VGG_model.layers[-6].output,
name='model_3')(input_img_3)
fg_model_3 = Input(shape=(*vgg_model_3_pre.get_shape().as_list()[1:],
MAX_INSTANCES),
name='fg_model_3') # <-
vgg_model_3 = WeightGenerator(64, batch_size, name='weight_generator_1')(
[fg_model_3, vgg_model_3_pre, bbox, mask]) # <-
# Global features
conv2d_6 = Conv2D(512, (3, 3),
padding='same',
strides=(2, 2),
activation='relu',
name='conv2d_6')(vgg_model_3)
batch_normalization_1 = BatchNormalization(
name='batch_normalization_1')(conv2d_6)
conv2d_7 = Conv2D(512, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_7')(batch_normalization_1)
batch_normalization_2 = BatchNormalization(
name='batch_normalization_2')(conv2d_7)
conv2d_8 = Conv2D(512, (3, 3),
padding='same',
strides=(2, 2),
activation='relu',
name='conv2d_8')(batch_normalization_2)
batch_normalization_3 = BatchNormalization(
name='batch_normalization_3')(conv2d_8)
conv2d_9 = Conv2D(512, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_9')(batch_normalization_3)
batch_normalization_4 = BatchNormalization(
name='batch_normalization_4')(conv2d_9)
# Classification
flatten_2 = Flatten(name='flatten_2')(batch_normalization_4)
dense_4 = Dense(4096, activation='relu', name='dense_4')(flatten_2)
dense_5 = Dense(4096, activation='relu', name='dense_5')(dense_4)
dense_6 = Dense(1000, activation='softmax', name='dense_6')(dense_5)
# Global feature pass back to colorization + classification
flatten_1 = Flatten(name='flatten_1')(batch_normalization_4)
dense_1 = Dense(1024, activation='relu', name='dense_1')(flatten_1)
dense_2 = Dense(512, activation='relu', name='dense_2')(dense_1)
dense_3 = Dense(256, activation='relu', name='dense_3')(dense_2)
repeat_vector_1 = RepeatVector(28 * 28, name='repeat_vector_1')(dense_3)
reshape_1 = Reshape((28, 28, 256), name='reshape_1')(repeat_vector_1)
# Mid-level features
conv2d_10 = Conv2D(512, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_10')(vgg_model_3)
batch_normalization_5 = BatchNormalization(
name='batch_normalization_5')(conv2d_10)
conv2d_11_pre = Conv2D(256, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_11')(batch_normalization_5)
fg_conv2d_11 = Input(shape=(*conv2d_11_pre.get_shape().as_list()[1:],
MAX_INSTANCES),
name='fg_conv2d_11') # <-
conv2d_11 = WeightGenerator(32, batch_size, name='weight_generator_2')(
[fg_conv2d_11, conv2d_11_pre, bbox, mask]) # <-
batch_normalization_6 = BatchNormalization(
name='batch_normalization_6')(conv2d_11)
# Fusion of (VGG16 -> Mid-level) + (VGG16 -> Global) + Colorization
concatenate_2 = concatenate([batch_normalization_6, reshape_1],
name='concatenate_2')
conv2d_12 = Conv2D(256, (1, 1),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_12')(concatenate_2)
conv2d_13_pre = Conv2D(128, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_13')(conv2d_12)
fg_conv2d_13 = Input(shape=(*conv2d_13_pre.get_shape().as_list()[1:],
MAX_INSTANCES),
name='fg_conv2d_13') # <-
conv2d_13 = WeightGenerator(16, batch_size, name='weight_generator_3')(
[fg_conv2d_13, conv2d_13_pre, bbox, mask]) # <-
# conv2dt_1 = Conv2DTranspose(64, (4, 4), padding='same', strides=(2, 2), name='conv2dt_1')(conv2d_13)
up_sampling2d_1 = UpSampling2D(size=(2, 2),
name='up_sampling2d_1',
interpolation='bilinear')(conv2d_13)
conv2d_14 = Conv2D(64, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_14')(up_sampling2d_1)
conv2d_15_pre = Conv2D(64, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_15')(conv2d_14)
fg_conv2d_15 = Input(shape=(*conv2d_15_pre.get_shape().as_list()[1:],
MAX_INSTANCES),
name='fg_conv2d_15') # <-
conv2d_15 = WeightGenerator(16, batch_size, name='weight_generator_4')(
[fg_conv2d_15, conv2d_15_pre, bbox, mask]) # <-
# conv2dt_2 = Conv2DTranspose(32, (4, 4), padding='same', strides=(2, 2), name='conv2dt_2')(conv2d_15)
up_sampling2d_2 = UpSampling2D(size=(2, 2),
name='up_sampling2d_2',
interpolation='bilinear')(conv2d_15)
conv2d_16 = Conv2D(32, (3, 3),
padding='same',
strides=(1, 1),
activation='relu',
name='conv2d_16')(up_sampling2d_2)
conv2d_17_pre = Conv2D(2, (3, 3),
padding='same',
strides=(1, 1),
activation='sigmoid',
name='conv2d_17')(conv2d_16)
fg_conv2d_17 = Input(shape=(*conv2d_17_pre.get_shape().as_list()[1:],
MAX_INSTANCES),
name='fg_conv2d_17') # <-
conv2d_17 = WeightGenerator(16, batch_size, name='weight_generator_5')(
[fg_conv2d_17, conv2d_17_pre, bbox, mask]) # <-
# conv2dt_3 = Conv2DTranspose(2, (4, 4), padding='same', strides=(2, 2), name='conv2dt_3')(conv2d_17)
up_sampling2d_3 = UpSampling2D(size=(2, 2),
name='up_sampling2d_3',
interpolation='bilinear')(conv2d_17)
return Model(inputs=[
input_img, fg_model_3, fg_conv2d_11, fg_conv2d_13, fg_conv2d_15,
fg_conv2d_17, bbox, mask
],
outputs=[up_sampling2d_3, dense_6])
def create_VGG_net(self, raw=height, column=width, channel=1):
print('create VGG model!!')
inputShape = (raw, column, channel)
init = 'he_normal'
# init = 'glorot_normal'
activation = 'relu'
keep_prob_conv = 0.25
keep_prob_dense = 0.5
chanDim = -1
classes = 3
model = Sequential()
# CONV => RELU => POOL
model.add(
Conv2D(32, (3, 3),
padding="same",
input_shape=inputShape,
kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(3, 3)))
model.add(Dropout(keep_prob_conv))
# (CONV => RELU) * 2 => POOL
model.add(Conv2D(64, (3, 3), padding="same", kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(Conv2D(64, (3, 3), padding="same", kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(keep_prob_conv))
# (CONV => RELU) * 2 => POOL
model.add(Conv2D(128, (3, 3), padding="same", kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(Conv2D(128, (3, 3), padding="same", kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(keep_prob_conv))
# (CONV => RELU) * 2 => POOL
model.add(Conv2D(128, (3, 3), padding="same", kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(Conv2D(128, (3, 3), padding="same", kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(keep_prob_conv))
# first (and only) set of FC => RELU layers
model.add(Flatten())
model.add(Dense(1024, kernel_initializer=init))
model.add(Activation(activation))
model.add(BatchNormalization())
model.add(Dropout(keep_prob_dense))
# softmax classifier
model.add(Dense(classes))
model.add(Activation("softmax"))
# return the constructed network architecture
self.model = model
def build_autoencoder(self, image_size = 64, max_pool_size = 2, conv_size = 3, channels = 1, code_size = 4):
autoencoder = None
# this is our input placeholder
input_img = Input(shape=(image_size, image_size, channels), name = 'input')
x = Conv2D(256, (conv_size, conv_size), activation='relu', padding='same')(input_img) # tanh?
x = MaxPooling2D((max_pool_size, max_pool_size), padding='same')(x)
x = Conv2D(128, (conv_size, conv_size), activation='relu', padding='same')(x)
x = MaxPooling2D((max_pool_size, max_pool_size), padding='same')(x)
x = Conv2D(128, (conv_size, conv_size), activation='relu', padding='same')(x)
x = MaxPooling2D((max_pool_size, max_pool_size), padding='same')(x)
#encoded = MaxPooling2D((max_pool_size, max_pool_size), padding='same', name = 'encoded')(x)
# x = Conv2D(16, (conv_size, conv_size), activation='relu', padding='same')(x)
# x = MaxPooling2D((max_pool_size, max_pool_size), padding='same')(x)
# x = Conv2D(8, (conv_size, conv_size), activation='relu', padding='same')(x)
# x = MaxPooling2D((max_pool_size, max_pool_size), padding='same')(x)
# x = Conv2D(1, (3, 3), activation='relu', padding='same')(x)
# x = MaxPooling2D((2, 2), padding='same')(x)
# print x.shape
x= Flatten()(x)
# x= Dense(code_size)(x)
# encoded = Reshape(target_shape=(4,), name='encoded')(x) # encoded shape should by 2*2*2
encoded = Dense(code_size, name='encoded')(x)
print ('encoded shape ', encoded.shape)
# x = Reshape(target_shape=(8,8,1))(encoded) #-12
# x = Dense(code_size, activation='relu')(encoded)
# x = Reshape(target_shape=(4, 4, 1))(x) #-12
# x = Conv2D(2, (conv_size, conv_size), activation='relu', padding='same')(x) #-13
# x = UpSampling2D((max_pool_size, max_pool_size))(x)
# x = Conv2D(8, (conv_size, conv_size), activation='relu', padding='same')(x)
# x = UpSampling2D((max_pool_size, max_pool_size))(x)
# x = Conv2D(8, (conv_size, conv_size), activation='relu', padding='same')(x)
# x = UpSampling2D((max_pool_size, max_pool_size))(x)
# x = Conv2D(8, (conv_size, conv_size), activation='relu', padding='same')(x)
# x = UpSampling2D((max_pool_size, max_pool_size))(x)
ims = 8
first = True
x = Dense(int(ims*ims), activation='relu')(encoded)
x = Reshape(target_shape=(ims, ims, 1))(x) #-12
while ims!=image_size:
x = Conv2D(int(ims*ims/2), (conv_size, conv_size), activation='relu', padding='same')(x)
x = UpSampling2D((max_pool_size, max_pool_size))(x)
ims = ims*max_pool_size
decoded = Conv2D(channels, (conv_size, conv_size), activation = 'sigmoid', padding='same', name= 'decoded')(x)
print ('decoded shape ', decoded.shape)
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adam', loss='mean_squared_error')
# autoencoder.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
#autoencoder.summary()
# Create a separate encoder model
encoder = Model(input_img, encoded)
encoder.compile(optimizer='adam', loss='mean_squared_error')
encoder.summary()
# Create a separate decoder model
decoder_inp = Input(shape=(code_size,))
# decoder_inp = Input(shape=encoded.output_shape)
enc_layer_idx = self.getLayerIndexByName(autoencoder, 'encoded')
print ('encoder layer idx ', enc_layer_idx)
decoder_layer = autoencoder.layers[enc_layer_idx+1](decoder_inp)
for i in range(enc_layer_idx+2, len(autoencoder.layers)):
decoder_layer = autoencoder.layers[i](decoder_layer)
decoder = Model(decoder_inp, decoder_layer)
decoder.compile(optimizer='adam', loss='mean_squared_error')
decoder.summary()
return autoencoder, encoder, decoder
def adversarial_autoencoder(z, x, dropout_rate, dropout, config):
outputs = {}
with tf.variable_scope('Encoder'):
encoder = build_unified_encoder(x.get_shape().as_list(),
config.intermediateResolutions)
temp_out = x
for layer in encoder:
temp_out = layer(temp_out)
with tf.variable_scope("Bottleneck"):
intermediate_conv = Conv2D(temp_out.get_shape().as_list()[3] // 8,
1,
padding='same')
intermediate_conv_reverse = Conv2D(temp_out.get_shape().as_list()[3],
1,
padding='same')
dropout_layer = Dropout(dropout_rate)
temp_out = intermediate_conv(temp_out)
reshape = temp_out.get_shape().as_list()[1:]
z_layer = Dense(config.zDim)
dec_dense = Dense(np.prod(reshape))
outputs['z_'] = z_ = dropout_layer(z_layer(Flatten()(temp_out)),
dropout)
reshaped = tf.reshape(dropout_layer(dec_dense(z_), dropout),
[-1, *reshape])
temp_out = intermediate_conv_reverse(reshaped)
with tf.variable_scope('Decoder'):
decoder = build_unified_decoder(config.outputWidth,
config.intermediateResolutions,
config.numChannels)
# Decode: z -> x_hat
for layer in decoder:
temp_out = layer(temp_out)
outputs['x_hat'] = temp_out
# Discriminator
with tf.variable_scope('Discriminator'):
discriminator = [
Dense(50, activation=leaky_relu),
Dense(50, activation=leaky_relu),
Dense(1)
]
# fake
temp_out = z_
for layer in discriminator:
temp_out = layer(temp_out)
outputs['d_'] = temp_out
# real
temp_out = z
for layer in discriminator:
temp_out = layer(temp_out)
outputs['d'] = temp_out
# adding noise
epsilon = tf.random_uniform([config.batchsize, 1],
minval=0.,
maxval=1.)
outputs['z_hat'] = z_hat = z + epsilon * (z - z_)
temp_out = z_hat
for layer in discriminator:
temp_out = layer(temp_out)
outputs['d_hat'] = temp_out
return outputs
def cnnlin(xtrain,
ytrain,
xtest,
ytest,
input_shape,
num_classes,
batch_size,
epochs,
callbacks,
ismodelsaved=False,
tl=False):
if ismodelsaved == False:
inputs = Input(shape=input_shape, name='main_input')
conv_1 = Conv2D(10, (1, 1), padding='same', activation='relu')(inputs)
conv_2 = Conv2D(10, (1, 2), padding='same', activation='relu')(inputs)
conv_3 = Conv2D(10, (1, 3), padding='same', activation='relu')(inputs)
conv_4 = Conv2D(10, (1, 5), padding='same', activation='relu')(inputs)
#
conv_output = concatenate([conv_1, conv_2, conv_3, conv_4])
bn_output = BatchNormalization()(conv_output)
pooling_output = MaxPool2D(pool_size=(1, 5),
strides=None,
padding='valid')(bn_output)
flatten_output = Flatten()(pooling_output)
#
x = Dense(100, activation='relu')(flatten_output)
x = Dense(23, activation='relu')(x)
x = Dropout(0.15)(x)
predictions = Dense(num_classes, name='main_output')(x)
#
cnnlin = Model(inputs, predictions)
adamopt = tf.keras.optimizers.Adam(lr=1e-4)
cnnlin.compile(loss='binary_crossentropy',
optimizer=adamopt,
metrics=['accuracy'])
#
history_cnnreplica = cnnlin.fit(xtrain,
ytrain,
batch_size=batch_size,
epochs=20,
verbose=1,
validation_data=(xtest, ytest))
#
if True:
plt.figure()
plt.plot(history_cnnreplica.history['loss'], label='train loss')
plt.plot(history_cnnreplica.history['val_loss'], label='test loss')
plt.title('Learning Curves')
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend()
plt.show()
else:
if np.cumprod(input_shape)[-1] == 92:
cnnlin = tf.keras.models.load_model(
flpath + '/saved_model_4x23/cnnlinn_4x23')
else:
if tl:
cnnlin = tf.keras.models.load_model(
flpath + '/saved_model_guideseq_8x23/cnnlinn_8x23')
else:
cnnlin = tf.keras.models.load_model(
flpath + '/saved_model_crispr_8x23/cnnlinncrispr_8x23')
p("CNN Lin: Done")
return cnnlin
def default_model(num_action, input_shape, actor_critic='actor'):
from tensorflow.python.keras.models import Model
from tensorflow.python.keras.layers import Input, Lambda, Concatenate
LR = 1e-4 # Lower lr stabilises training greatly
img_in = Input(shape=input_shape, name='img_in')
if actor_critic == "actor":
# Perception
x = Convolution2D(filters=24,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu')(img_in)
x = Convolution2D(filters=32,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu')(x)
x = Convolution2D(filters=64,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu')(x)
x = Convolution2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
activation='relu')(x)
x = Convolution2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu')(x)
x = Flatten(name='flattened')(x)
s_in = Input(shape=(1, ), name='speed')
adv_in = Input(shape=(1, ), name='adv')
old_prediction = Input(shape=(2 * num_action, ),
name='old_prediction_input')
# speed layer
s = Dense(64)(s_in)
s = Dropout(0.5)(s)
s = Activation('relu')(s)
s = Dense(64)(s)
s = Dropout(0.5)(s)
s = Activation('relu')(s)
# action layer
o = Concatenate(axis=1)([x, s])
o = Dense(64)(o)
o = Dropout(0.5)(o)
o = Activation('relu')(o)
mu = Dense(num_action, activation='tanh', name="actor_output_mu")(o)
sigma = Dense(num_action,
activation='softplus',
name="actor_output_sigma")(o)
mu_and_sigma = Concatenate(axis=-1)([mu, sigma])
model = Model(inputs=[img_in, s_in, adv_in, old_prediction],
outputs=mu_and_sigma)
model.compile(optimizer=Adam(lr=0.002),
loss=proximal_policy_optimization_loss_continuous(
advantage=adv_in, old_prediction=old_prediction))
# action, action_matrix, prediction from trial_run
# reward is a function( angle, throttle)
return model
if actor_critic == 'critic':
# Perception
x = Convolution2D(filters=24,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu')(img_in)
x = Convolution2D(filters=32,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu')(x)
x = Convolution2D(filters=64,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu')(x)
x = Convolution2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
activation='relu')(x)
x = Convolution2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu')(x)
x = Flatten(name='flattened')(x)
s_in = Input(shape=(1, ), name='speed')
# speed layer
s = Dense(64)(s_in)
s = Dropout(0.5)(s)
s = Activation('relu')(s)
s = Dense(64)(s)
s = Dropout(0.5)(s)
s = Activation('relu')(s)
o = Concatenate(axis=1)([x, s])
o = Dense(64)(o)
o = Dropout(0.5)(o)
o = Activation('relu')(o)
total_reward = Dense(units=1, activation='linear',
name='total_reward')(o)
model = Model(inputs=[img_in, s_in], outputs=total_reward)
return model
def cnnthree(xtrain,
ytrain,
xtest,
ytest,
input_shape,
num_classes,
batch_size,
epochs,
callbacks,
ismodelsaved=False,
tl=False):
if ismodelsaved == False:
cnn3 = Sequential()
cnn3.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
cnn3.add(MaxPooling2D(pool_size=(2, 2)))
cnn3.add(Dropout(0.25))
cnn3.add(Flatten())
cnn3.add(Dense(128, activation='relu'))
cnn3.add(Dropout(0.5))
cnn3.add(Dense(num_classes, activation='softmax'))
#
cnn3.compile(loss=tfkeras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.RMSprop(0.001, rho=0.9),
metrics=['accuracy'])
#
history_cnn3 = cnn3.fit(xtrain,
ytrain,
batch_size=batch_size,
epochs=epochs,
verbose=0,
validation_data=(xtest, ytest),
callbacks=callbacks)
score = cnn3.evaluate(xtest, ytest, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#
if True:
plt.figure()
plt.plot(history_cnn3.history['loss'], label='train loss')
plt.plot(history_cnn3.history['val_loss'], label='test loss')
plt.title('Learning Curves')
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend()
plt.show()
else:
if np.cumprod(input_shape)[-1] == 92:
cnn3 = tf.keras.models.load_model(flpath +
'/saved_model_4x23/cnn3_4x23')
else:
if tl:
cnn3 = tf.keras.models.load_model(
flpath + '/saved_model_guideseq_8x23/cnn3_8x23')
else:
cnn3 = tf.keras.models.load_model(
flpath + '/saved_model_crispr_8x23/cnn3crispr_8x23')
p("CNN3: Done")
return cnn3
1).astype('float32')
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], X_test.shape[2],
1).astype('float32')
X_train /= 255
X_test /= 255
num_of_classes = 10
y_train = np_utils.to_categorical(y_train, num_of_classes)
y_test = np_utils.to_categorical(y_test, num_of_classes)
model = Sequential()
model.add(
Conv2D(32, (5, 5),
input_shape=(X_train.shape[1], X_train.shape[2], 1),
activation='relu'))
model.add(MaxPooling2D())
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D())
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(num_of_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=Adam(),
metrics=['accuracy'])
model.fit(X_train, y_train, 200, 10, validation_data=(X_test, y_test))
model.save("../resources/mnist_model2")
metrics = model.evaluate(X_test, y_test, verbose=0)
input_img = Input(shape=x_train.shape[1:]) # (32, 32, 3)
def inception(input):
pool_1 = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(input)
conv_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(pool_1)
conv_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(input)
conv_3 = Conv2D(64, (3, 3), padding='same', activation='relu')(conv_2)
conv_4 = Conv2D(64, (3, 3), padding='same', activation='relu')(conv_3)
concat = concatenate([conv_1, conv_2, conv_3, conv_4], axis=3)
return concat
concat_1 = inception(input_img)
output = Flatten()(concat_1)
out = Dense(10, activation='softmax')(output)
from tensorflow.python.keras.models import Model
model = Model(inputs=input_img, outputs=out)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
from tensorflow.python.keras.models import load_model
from keras.callbacks import ModelCheckpoint
