def get_model(self):
input = Input(self.maxlen)
# Embedding part can try multichannel as same as origin paper
embedding = self.embedding_layer(input)
convs = []
for kernel_size in self.kernel_size_list:
c = Conv1D(128, kernel_size, activation='relu')(embedding) # 卷积
# c = Dropout(0.5)(c)
p = GlobalMaxPool1D()(c) # 池化
# p = GlobalAvgPool1D()(c)
convs.append(p)
x = Concatenate()(convs)
output = Dense(self.num_class, activation=self.last_activation)(x)
model = Model(inputs=input, outputs=output)
return model
def create_resnet(block,
layer_sizes,
input_shape=(None, None, 3),
width_per_group=64,
replace_stride_with_dilation=None):
img_input = layers.Input(shape=input_shape, name='input')
resnet = ResNet(block, layer_sizes, width_per_group,
replace_stride_with_dilation)
x = resnet.layer0(img_input)
x = resnet.layer1(x)
x = resnet.layer2(x)
x = resnet.layer3(x)
x = resnet.layer4(x)
return Model(inputs=img_input, outputs=x)
def cgan_discriminator():
inp = layers.Input(shape=[2], name='cl_cd')
tar = layers.Input(shape=[99], name='cp')
x = layers.concatenate([inp, tar])
x = layers.Dense(512)(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dense(1024)(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dense(512)(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dense(1)(x)
return Model(inputs=[inp, tar], outputs=x)
def test_loss_on_layer(self):
class MyLayer(layers.Layer):
def call(self, inputs):
self.add_loss(math_ops.reduce_sum(inputs))
return inputs
inputs = Input((3, ))
layer = MyLayer()
outputs = layer(inputs)
model = Model(inputs, outputs)
self.assertEqual(len(model.losses), 1)
model.compile('sgd',
'mse',
run_eagerly=testing_utils.should_run_eagerly())
loss = model.train_on_batch(np.ones((2, 3)), np.ones((2, 3)))
self.assertEqual(loss, 2 * 3)
def build_c_discriminator(self, name, hidden_dim=2048):
def d_layer(layer_input, hidden_dim, normalization=True, dropout=True, dropout_percentage=0.3):
"""Discriminator layer"""
d = Dense(hidden_dim, activation="relu")(layer_input)
if normalization:
d = BatchNormalization()(d)
if dropout:
d = Dropout(dropout_percentage)(d)
return d
inpt = Input(shape=600)
d1 = d_layer(inpt, hidden_dim, normalization=False, dropout=True, dropout_percentage=0.3)
d1 = d_layer(d1, hidden_dim, normalization=True, dropout=True, dropout_percentage=0.3)
validity = Dense(1, activation="sigmoid", dtype='float32')(d1)
return Model(inpt, validity, name=name)
def _embedding_model(input_shape, embedding_size):
inputs = Input(shape=input_shape, name="img_input")
x = Conv2D(16, (4, 4), activation="relu")(inputs)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Conv2D(32, (3, 3), activation="relu")(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Conv2D(64, (2, 2), activation="relu")(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Flatten()(x)
x = Dense(16)(x)
x = Dense(embedding_size)(x)
output = Lambda(lambda tensor: K.l2_normalize(tensor, axis=1),
name='normalized_embedding')(x)
model = Model(inputs=[inputs], outputs=[output])
return model
def _define_model(output_layer=-1):
'''Define a pre-trained MobileNet model.
Args:
output_layer: the number of layer that output.
Returns:
Class of keras model with weights.
'''
base_model = MobileNet(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
output = base_model.layers[output_layer].output
output = GlobalAveragePooling2D()(output)
model = Model(inputs=base_model.input, outputs=output)
return model
def bfnn_model(): # construct the BFNN proposed in this letter
input_tensor = Input(
shape=(2 * Nt +
1, )) # consists of the estimated CSI and the SNR value
temp = dense_unit_dropout(input_tensor, 2048,
0) # the first dense unit with 2048 neurons
temp = dense_unit_dropout(temp, 1024,
0) # the second dense unit with 1024 neurons
temp = dense_unit_dropout(temp, 256,
0) # the third dense unit with 256 neurons
out_phases = dense_unit_dropout(temp, Nt,
0) # to output the phases of v_RF
model = Model(input_tensor, out_phases)
model.compile(optimizer=tf.train.AdamOptimizer(), loss=loss_function_rate)
print(model.summary())
return model
def _text_recognition_vertical_model(input_shape, n_vocab):
roi = Input(shape=input_shape, name="roi_vertical")
x = roi
for c in [64, 128, 256]:
x = SeparableConv2D(c, 3, padding="same")(x)
# TODO(agatan): if input_shape contains 0, GroupNormalization can generate nan weights.
# x = GroupNormalization()(x)
x = ReLU(6.)(x)
x = SeparableConv2D(c, 3, padding="same")(x)
# x = GroupNormalization()(x)
x = ReLU(6.)(x)
x = MaxPooling2D((1, 2))(x)
x = Lambda(lambda v: tf.squeeze(v, 2))(x)
x = Dropout(0.2)(x)
output = Dense(n_vocab, activation="softmax")(x)
return Model(roi, output, name="vertical_model")
def original_p300_model(seed=0):
"""
Function to create the model from P300 dataset
:return: Tensorflow model
"""
inp = Input(shape=(14, 360, 1), name='input_layer')
conv2d = Conv2D(filters=6, kernel_size=(3, 3), activation=tf.nn.relu)(inp)
dropout1 = Dropout(0.5, seed=seed)(conv2d)
avg_pooling = AveragePooling2D(pool_size=(1, 8), padding='same')(dropout1)
flatten = Flatten()(avg_pooling)
dense1 = Dense(100, activation=tf.nn.relu)(flatten)
batch_norm = BatchNormalization()(dense1)
dropout2 = Dropout(0.5, seed=seed)(batch_norm)
output = Dense(2, activation=tf.nn.softmax, name='output_layer')(dropout2)
return Model(inputs=inp, outputs=output)
def build_critic(self):
input_image = Input(shape=(84, 84, self.frames))
x = Conv2D(32, (8, 8), (2, 2), 'same', activation=relu)(input_image)
x = Conv2D(64, (4, 4), (2, 2), 'same', activation=relu)(x)
x = Conv2D(128, (2, 2), (2, 2), 'same', activation=relu)(x)
x = Conv2D(256, (1, 1), (2, 2), 'same', activation=relu)(x)
x = Flatten()(x)
x = Dense(512, activation=relu)(x)
out_value = Dense(1, activation=linear)(x)
model = Model(inputs=[input_image], outputs=[out_value])
model.compile(optimizer=Adam(lr=10e-4), loss='mse')
model.summary()
return model
def pix2pix_generator(c_dim, z_dim=None):
down_stack = [
downsample(units=1024,
input_shape=c_dim + z_dim,
apply_batchnorm=False),
downsample(units=512, input_shape=1024),
downsample(units=256, input_shape=512),
downsample(units=128, input_shape=256),
downsample(units=64, input_shape=128),
downsample(units=64, input_shape=64),
]
up_stack = [
upsample(units=64, input_shape=64, apply_dropout=False),
upsample(units=128, input_shape=128, apply_dropout=False),
upsample(units=256, input_shape=256),
upsample(units=512, input_shape=512),
upsample(units=1024, input_shape=1024),
]
initializer = random_normal_initializer(0., 0.02)
last = layers.Dense(OUTPUT_SIZE,
kernel_initializer=initializer,
activation='tanh')
inputs = layers.Input(shape=[c_dim])
if z_dim:
z = layers.Input(shape=[z_dim])
x = layers.concatenate([inputs, z])
inp = [inputs, z]
else:
x = inputs
inp = inputs
skips = []
for down in down_stack:
x = down(x)
skips.append(x)
skips = reversed(skips[:-1])
for up, skip in zip(up_stack, skips):
x = up(x)
x = layers.concatenate([x, skip])
x = last(x)
return Model(inputs=inp, outputs=x)
def cnn_model(
input_shape, # input list shape (word index list)
num_classes, # output shape
num_features, # number of word + empty
embedding_matrix,
filters,
kernel_sizes,
dropout_rate,
embedding_trainable,
l2_lambda):
embedding_layer = Embedding(
input_dim=num_features,
output_dim=300, # hard code
embeddings_initializer=Constant(embedding_matrix),
input_length=input_shape,
trainable=embedding_trainable)
# word index list, not map to embedding yet
sequence_input = Input(shape=(input_shape, ), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
nn_layers = list()
for kernel_size in kernel_sizes:
conv_layer_0 = Convolution1D(filters, kernel_size,
padding='valid')(embedded_sequences)
conv_layer_1 = BatchNormalization(axis=1)(conv_layer_0)
conv_layer_2 = Activation('relu')(conv_layer_1)
pool_layer_0 = MaxPooling1D(input_shape - kernel_size +
1)(conv_layer_2)
pool_layer_1 = Dropout(dropout_rate)(pool_layer_0)
nn_layers.append(pool_layer_1)
# merge diff kernal size generated output
line_merge_layer = concatenate(nn_layers)
line_flat_layer = Flatten()(line_merge_layer)
norm_layer = BatchNormalization(axis=1)(line_flat_layer)
drop_layer = Dropout(dropout_rate)(norm_layer)
preds = Dense(num_classes,
kernel_regularizer=regularizers.l2(l2_lambda),
activation='softmax')(drop_layer)
cnn_model = Model(inputs=sequence_input, outputs=preds)
return cnn_model
def build_fully_conv(obs_spec,
act_spec,
data_format='channels_first',
broadcast_non_spatial=False,
fc_dim=256):
print('obs_spec', obs_spec)
print('act_spec', act_spec)
screen, screen_input = spatial_block('screen', obs_spec.spaces[0],
conv_cfg(data_format, 'relu'))
minimap, minimap_input = spatial_block('minimap', obs_spec.spaces[1],
conv_cfg(data_format, 'relu'))
non_spatial_inputs = [Input(s.shape) for s in obs_spec.spaces[2:]]
if broadcast_non_spatial:
non_spatial, spatial_dim = non_spatial_inputs[1], obs_spec.spaces[
0].shape[1]
non_spatial = Log()(non_spatial)
broadcasted_non_spatial = Broadcast2D(spatial_dim)(non_spatial)
state = Concatenate(axis=1, name="state_block")(
[screen, minimap, broadcasted_non_spatial])
else:
state = Concatenate(axis=1, name="state_block")([screen, minimap])
fc = Flatten(name="state_flat")(state)
fc = Dense(fc_dim, **dense_cfg('relu'))(fc)
value = Dense(1, name="value_out", **dense_cfg(scale=0.1))(fc)
value = Squeeze(axis=-1)(value)
logits = []
for space in act_spec:
if space.is_spatial():
logits.append(
Conv2D(1, 1, **conv_cfg(data_format, scale=0.1))(state))
logits[-1] = Flatten()(logits[-1])
else:
logits.append(Dense(space.size(), **dense_cfg(scale=0.1))(fc))
mask_actions = Lambda(lambda x: tf.where(non_spatial_inputs[0] > 0, x,
-1000 * tf.ones_like(x)),
name="mask_unavailable_action_ids")
logits[0] = mask_actions(logits[0])
return Model(inputs=[screen_input, minimap_input] + non_spatial_inputs,
outputs=logits + [value])
def build_anchor_model(inp_shape, anchor_counts):
inp = Input(shape=inp_shape)
headModel = Conv2D(32, (3, 3), activation="relu", padding='same')(inp)
headModel = Conv2D(32, (3, 3), activation="relu",
padding='same')(headModel)
headModel = MaxPooling2D((2, 2))(headModel)
headModel = Conv2D(64, (3, 3), activation="relu",
padding='same')(headModel)
headModel = Conv2D(64, (3, 3), activation="relu",
padding='same')(headModel)
headModel = MaxPooling2D((2, 2))(headModel)
headModel = Conv2D(128, (3, 3), activation="relu",
padding='same')(headModel)
headModel = Conv2D(128, (3, 3), activation="relu",
padding='same')(headModel)
headModel = MaxPooling2D((2, 2))(headModel)
headModel = Conv2D(256, (3, 3), activation="relu",
padding='same')(headModel)
headModel = Conv2D(256, (3, 3), activation="relu",
padding='same')(headModel)
headModel = MaxPooling2D((2, 2))(headModel)
headModel = Conv2D(512, (3, 3), activation="relu",
padding='same')(headModel)
headModel = Conv2D(512, (3, 3), activation="relu",
padding='same')(headModel)
headModel = MaxPooling2D((2, 2))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dropout(0.2)(headModel)
headModel = Dense(4 * 1024, activation="relu")(headModel)
headModel = Dropout(0.2)(headModel)
headModel = Dense(anchor_counts[0] * anchor_counts[1],
activation="sigmoid")(headModel)
headModel = Reshape((anchor_counts[0], anchor_counts[1]))(headModel)
model = Model(inputs=inp, outputs=headModel)
model.compile(
# loss="binary_crossentropy",
loss=BinaryFocalLoss(gamma=3), # , # "mean_absolute_error",
optimizer=Adam(lr=0.001),
metrics=["accuracy"],
)
return model
def build_model(dim, max_seq, n_input_voca, n_output_voca):
#W2 = tf.keras.layers.Dense(n_output_voca, use_bias=False)
#W2 = K.random_normal_variable(shape=(n_output_voca, dim), mean=0, scale=1)
np_val = np.reshape(np.random.normal(size=n_output_voca * dim),
[n_output_voca, dim])
W2 = K.constant(np_val)
code_id = Input(shape=[1], name=str_code_id)
token_ids = Input(shape=(max_seq, ), dtype=tf.int32, name=str_desc_tokens)
W1 = tf.keras.layers.Embedding(n_input_voca, dim)
h0 = W1(code_id)
#logits = W2(h)
#logits = MyLayer(n_output_voca, dim, max_seq)(h)
h = tf.reshape(h0, [-1, dim])
h = tf.nn.l2_normalize(h, -1)
W2 = tf.nn.l2_normalize(W2, -1)
logits = tf.matmul(h, W2, transpose_b=True)
#logits = tf.reshape(logits, [-1, max_seq, n_output_voca])
log_probs = tf.nn.log_softmax(logits, axis=-1)
y = tf.one_hot(token_ids,
depth=n_output_voca) #[batch, max_seq, n_output_voca]
pos_val = logits * y # [ batch, max_seq, voca]
neg_val = logits - tf.reduce_sum(pos_val, axis=1) #[ batch, voca]
t = tf.reduce_sum(pos_val, axis=2) # [batch, max_seq]
correct_map = tf.expand_dims(t, 2) # [batch, max_seq, 1]
print(correct_map.shape)
#logits_correct = tf.expand_dims(tf.reduce_sum(logits * y, axis=-1), -1)
wrong_map = tf.expand_dims(neg_val, 1) # [batch, 1, voca]
print(wrong_map.shape)
t = wrong_map - correct_map + 1
print(t.shape)
loss = tf.reduce_mean(tf.math.maximum(t, 0), axis=-1)
mask = tf.cast(tf.not_equal(token_ids, 0), tf.float32) # batch, seq_len
print(mask.shape)
# loss = -tf.reduce_sum(input_tensor=log_probs * y, axis=[-1])
loss = mask * loss
loss = tf.reduce_sum(loss, axis=1) # over the sequence
loss = tf.reduce_mean(loss)
print(loss.shape)
model = Model(inputs=[code_id, token_ids], outputs=h0)
return loss, model
def get_model(self):
input = Input((self.maxlen, )) # 表示输入是maxlen维的向量
# input_dim: 词汇表大小 output_dim：词向量的维度 input_length: 输入序列的长度
embedding = Embedding(self.max_features,
self.embedding_dims,
input_length=self.maxlen)(input)
convs = []
for kernel_size in [3, 4, 5]:
c = Conv1D(128, kernel_size, activation='relu')(embedding)
c = GlobalMaxPooling1D()(c)
convs.append(c)
x = Concatenate()(convs)
x = Dropout(0.3)(x)
output = Dense(self.class_num, activation=self.last_activation)(x)
model = Model(inputs=input, outputs=output)
return model
def yolo_v3(input_shape=(416, 416, 3), obj_c=3 * (4 + 5)):
inputs = Input(shape=input_shape, name='img_input')
x = Lambda(padding)(inputs)
x = Conv2D(filters=32, kernel_size=3, padding='VALID', use_bias=False)(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.1)(x)
x = resdual_net(x, 64, 1)
x = resdual_net(x, 128, 2)
x_8 = resdual_net(x, 128, 4, name='shortcut_8')
x_16 = resdual_net(x_8, 256, 4, name='shortcut_16')
x_32 = resdual_net(x_16, 512, 2, name='shortcut_32')
x = DarknetConv2D_BN_Leaky(x_32, filters=512, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=512 * 2, kernel=3)
x = DarknetConv2D_BN_Leaky(x, filters=512, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=512 * 2, kernel=3)
x1 = DarknetConv2D_BN_Leaky(x, filters=512, kernel=1)
x = DarknetConv2D_BN_Leaky(x1, filters=512 * 2, kernel=3)
y1 = Conv2D(filters=obj_c, kernel_size=1)(x)
x = DarknetConv2D_BN_Leaky(x1, filters=256, kernel=1)
x = UpSampling2D(2)(x)
x = tf.keras.layers.concatenate([x, x_16])
x = DarknetConv2D_BN_Leaky(x, filters=256, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=256 * 2, kernel=3)
x = DarknetConv2D_BN_Leaky(x, filters=256, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=256 * 2, kernel=3)
x2 = DarknetConv2D_BN_Leaky(x, filters=256, kernel=1)
x = DarknetConv2D_BN_Leaky(x2, filters=256 * 2, kernel=3)
y2 = Conv2D(filters=obj_c, kernel_size=1)(x)
x = DarknetConv2D_BN_Leaky(x2, filters=128, kernel=1)
x = UpSampling2D(2)(x)
x = tf.keras.layers.concatenate([x, x_8])
x = DarknetConv2D_BN_Leaky(x, filters=128, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=128 * 2, kernel=3)
x = DarknetConv2D_BN_Leaky(x, filters=128, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=128 * 2, kernel=3)
x = DarknetConv2D_BN_Leaky(x, filters=128, kernel=1)
x = DarknetConv2D_BN_Leaky(x, filters=128 * 2, kernel=3)
y3 = Conv2D(filters=obj_c, kernel_size=1)(x)
model = Model(inputs, [y3, y2, y1])
model.summary()
return model
def augment_model(self, model: Model):
x = model.input
self.model_input = model.input
for layer in model.layers[:-1]:
if re.match(self.regex, layer.name):
original_output = layer(x)
perturbation_input = Input(shape=tuple(
d for d in original_output.shape if d is not None),
name=layer.name + '_perturbation')
x = self.perturb(original_output, perturbation_input)
self.perturbation_inputs.append(perturbation_input)
else:
x = layer(x)
x = model.layers[-1](x)
return Model(inputs=[model.inputs] + self.perturbation_inputs,
outputs=x,
name=model.name)
def _build_gen_model(self):
with self.get_scope():
token_lens = Input(shape=(), dtype=tf.int32, name='token_len')
inputs = self.nn_model.inputs + [token_lens]
prob_vec = self.nn_model.output
extract_last_token_layer = ExtractLastTokenLayer(
name="extract_last_token_layer")
last_prob = extract_last_token_layer([prob_vec, token_lens])
self.gen_model = Model(inputs=inputs,
outputs=last_prob,
name="last_token_model")
logger.info("gen model's summary:")
self.gen_model.summary(print_fn=logger.info)
self._update_model_dict("gen", self.gen_model)
return self.gen_model
def build_cnn():
cnn_inputs = Input(shape=(IMAGE_ROWS, IMAGE_COLS, IMAGE_CHANNELS), )
t = cnn_inputs
t = Conv2D(filters=64,
kernel_size=[4, 4],
strides=2,
input_shape=(IMAGE_ROWS, IMAGE_COLS, IMAGE_CHANNELS),
padding="same",
activation=my_leaky_relu)(t)
t = Conv2D(filters=128,
kernel_size=[4, 4],
strides=2,
padding="same",
activation=my_leaky_relu)(t)
t = BatchNormalization()(t)
t = Conv2D(filters=256,
kernel_size=[4, 4],
strides=2,
activation=my_leaky_relu)(t)
t = BatchNormalization()(t)
t = Conv2D(filters=512,
kernel_size=[4, 4],
strides=2,
activation=my_leaky_relu)(t)
t = BatchNormalization()(t)
t = Flatten()(t)
t = Dense(
units=128,
activation=None # linear activation
)(t)
cnn_out = t
m = Model(inputs=cnn_inputs, outputs=cnn_out)
m.summary()
return m
def build_train_model(self):
shared_model = self.base_network_build_fn()
# shared_model = build_multi_attention_model(self.input_steps)
# shared_model = build_stacked_rnn_model(self)
t_status = shared_model.output
p = layers.Dense(self.action_num, activation='softmax',
name='p')(t_status)
r = Input(shape=(self.action_num, ), name='r')
q = Input(shape=(self.action_num, ), name='q')
loss = PPO_Loss()([r, q, p])
train_input = shared_model.input + [r, q]
model = Model(train_input, loss, name=self.model_type)
# 减小学习率，避免策略改变的太快
model.compile(optimizer=Adam(lr=self.lr), loss=None)
return model
def define_model(self):
input_img = Input(shape=(self.model_parameters.img_height,
self.model_parameters.img_width,
self.model_parameters.num_channels))
x = layers.Conv2D(filters=64,
kernel_size=(4, 4),
strides=(2, 2),
padding='same')(input_img)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(filters=128,
kernel_size=(4, 4),
strides=(2, 2),
padding='same')(x)
x = tfa.layers.InstanceNormalization(axis=-1)(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(
filters=256,
kernel_size=(4, 4),
strides=(2, 2),
padding='same',
)(x)
x = tfa.layers.InstanceNormalization(axis=-1)(x)
x = layers.LeakyReLU()(x)
x = layers.ZeroPadding2D()(x)
x = layers.Conv2D(filters=512,
kernel_size=(4, 4),
strides=(1, 1),
padding='valid')(x)
x = tfa.layers.InstanceNormalization(axis=-1)(x)
x = layers.LeakyReLU()(x)
x = layers.ZeroPadding2D()(x)
x = layers.Conv2D(filters=1,
kernel_size=(4, 4),
strides=(1, 1),
padding='valid')(x)
model = Model(name=self.model_name, inputs=input_img, outputs=x)
return model
def create(self):
""" Creates MoE model.
Returns
-------
model: Model
A Mixture of Experts model
"""
inputs = Input(shape=self.input_shape)
if self.units is not None:
gate_activations = Dense(
self.units, kernel_regularizer=self.kernel_regularizer)(inputs)
gate_activations = Dense(
self.num_classes * (self.num_experts + 1),
kernel_regularizer=self.kernel_regularizer)(gate_activations)
else:
gate_activations = Dense(
self.num_classes * (self.num_experts + 1),
kernel_regularizer=self.kernel_regularizer)(inputs)
expert_activations = Dense(
self.num_classes * self.num_experts,
kernel_regularizer=self.kernel_regularizer)(inputs)
# (Batch * #Labels) x (num_experts + 1)
gate_reshaped = Reshape(
(self.num_classes, self.num_experts + 1))(gate_activations)
gating_distribution = Activation('softmax')(gate_reshaped)
# (Batch * #Labels) x num_experts
expert_reshaped = Reshape(
(self.num_classes, self.num_experts))(expert_activations)
expert_distribution = Activation('sigmoid')(expert_reshaped)
slice_gating = Lambda(lambda x: x[:, :, :self.num_experts])(
gating_distribution)
probs = Multiply()([slice_gating, expert_distribution])
outputs = Lambda(lambda x: sum(x, axis=2))(probs)
model = Model(inputs, outputs)
if self.summary:
model.summary()
return model
def structureModel(self):
Inputs = layers.Input(shape=self._inputShape, batch_size=self._iBatchSize)
Con1 = layers.Conv2D(64, (3, 3), name='Con1', activation='relu', padding='SAME', input_shape=self._inputShape, strides=1)(Inputs)
Con2 = layers.Conv2D(64, (3, 3), name='Con2', activation='relu', padding='SAME', strides=1)(Con1)
Side1 = sideBranch(Con2, 1)
MaxPooling1 = layers.MaxPooling2D((2, 2), name='MaxPooling1', strides=2, padding='SAME')(Con2)
# outputs1
Con3 = layers.Conv2D(128, (3, 3), name='Con3', activation='relu', padding='SAME', strides=1)(MaxPooling1)
Con4 = layers.Conv2D(128, (3, 3), name='Con4', activation='relu', padding='SAME', strides=1)(Con3)
Side2 = sideBranch(Con4, 2)
MaxPooling2 = layers.MaxPooling2D((2, 2), name='MaxPooling2', strides=2, padding='SAME')(Con4)
# outputs2
Con5 = layers.Conv2D(256, (3, 3), name='Con5', activation='relu', padding='SAME', strides=1)(MaxPooling2)
Con6 = layers.Conv2D(256, (3, 3), name='Con6', activation='relu', padding='SAME', strides=1)(Con5)
Con7 = layers.Conv2D(256, (3, 3), name='Con7', activation='relu', padding='SAME', strides=1)(Con6)
Side3 = sideBranch(Con7, 4)
MaxPooling3 = layers.MaxPooling2D((2, 2), name='MaxPooling3', strides=2, padding='SAME')(Con7)
# outputs3
Con8 = layers.Conv2D(512, (3, 3), name='Con8', activation='relu', padding='SAME', strides=1)(MaxPooling3)
Con9 = layers.Conv2D(512, (3, 3), name='Con9', activation='relu', padding='SAME', strides=1)(Con8)
Con10 = layers.Conv2D(512, (3, 3), name='Con10', activation='relu', padding='SAME', strides=1)(Con9)
Side4 = sideBranch(Con10, 8)
MaxPooling4 = layers.MaxPooling2D((2, 2), name='MaxPooling4', strides=2, padding='SAME')(Con10)
# outputs4
Con11 = layers.Conv2D(512, (3, 3), name='Con11', activation='relu', padding='SAME', strides=1)(MaxPooling4)
Con12 = layers.Conv2D(512, (3, 3), name='Con12', activation='relu', padding='SAME', strides=1)(Con11)
Con13 = layers.Conv2D(512, (3, 3), name='Con13', activation='relu', padding='SAME', strides=1)(Con12)
Side5 = sideBranch(Con13, 16)
Fuse = layers.Concatenate(axis=-1)([Side1, Side2, Side3, Side4, Side5])
# learn fusion weight
Fuse = layers.Conv2D(1, (1, 1), name='Fuse', padding='SAME', use_bias=False, activation=None)(Fuse)
output1 = layers.Activation('sigmoid', name='output1')(Side1)
output2 = layers.Activation('sigmoid', name='output2')(Side2)
output3 = layers.Activation('sigmoid', name='output3')(Side3)
output4 = layers.Activation('sigmoid', name='output4')(Side4)
output5 = layers.Activation('sigmoid', name='output5')(Side5)
output6 = layers.Activation('sigmoid', name='output6')(Fuse)
outputs = [output1, output2, output3, output4, output5, output6]
self._pModel = Model(inputs=Inputs, outputs=outputs)
pAdam = optimizers.adam(lr=0.0001)
self._pModel.compile(loss={
'output6': classBalancedSigmoidCrossEntropy
}, optimizer=pAdam)
def perf_test_RASTAweights():
"""
Test the performance of the RASTA weights provide by Lecoultre et al.
"""
dataset = 'RASTA'
sess = tf.Session()
set_session(sess)
tf.keras.backend.set_image_data_format('channels_last')
base_model = resnet_trained(20)
predictions = Dense(25, activation='softmax')(base_model.output)
net_finetuned = Model(inputs=base_model.input, outputs=predictions)
#net_finetuned = custom_resnet() # Ce model a 87 layers
path_to_model = os.path.join(os.sep,'media','gonthier','HDD2','output_exp','rasta_models','resnet_2017_7_31-19_9_45','model.h5')
#ce model a 107 layers
constrNet = 'LResNet50' # For Lecoutre ResNet50 version
model_name = 'Lecoutre2017'
input_name_lucid = 'input_1'
net_finetuned.load_weights(path_to_model) # ,by_name=True
net_finetuned.build((224,224,3))
print(net_finetuned.summary())
print(net_finetuned.predict(np.random.rand(1,224,224,3)))
item_name,path_to_img,default_path_imdb,classes,ext,num_classes,str_val,df_label,\
path_data,Not_on_NicolasPC = get_database(dataset)
sLength = len(df_label[item_name])
classes_vectors = df_label[classes].values
df_label_test = df_label[df_label['set']=='test']
y_test = classes_vectors[df_label['set']=='test',:]
cropCenter = False
randomCrop = False
imSize = 224
predictions = predictionFT_net(net_finetuned,df_test=df_label_test,x_col=item_name,\
y_col=classes,path_im=path_to_img,Net=constrNet,\
cropCenter=cropCenter,randomCrop=randomCrop,\
imSize=imSize)
with sess.as_default():
metrics = evaluationScoreRASTA(y_test,predictions)
top_k_accs,AP_per_class,P_per_class,R_per_class,P20_per_class,F1_per_class,acc_per_class= metrics
for k,top_k_acc in zip([1,3,5],top_k_accs):
print('Top-{0} accuracy : {1:.2f}%'.format(k,top_k_acc*100))
def _build_model(self):
input_image = Input(shape=(84, 84, self.frames))
x = Conv2D(32, (8, 8), (2, 2), 'same', activation=relu)(input_image)
x = Conv2D(64, (4, 4), (2, 2), 'same', activation=relu)(x)
x = Conv2D(128, (2, 2), (2, 2), 'same', activation=relu)(x)
x = Conv2D(256, (1, 1), (2, 2), 'same', activation=relu)(x)
x = Flatten()(x)
x = Dense(512, activation=relu)(x)
out_mouse = Dense(2, activation=softmax)(x)
out_action = Dense(4, activation=linear)(x)
model = Model(inputs=[input_image], outputs=[out_mouse, out_action])
model.summary()
def build(input_shape, num_outputs, block_fn, repetitions):
"""Builds a custom ResNet like architecture.
Args:
input_shape: The input shape in the form (nb_channels, nb_rows, nb_cols)
num_outputs: The number of outputs at final softmax layer
block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
The original paper used basic_block for layers < 50
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size is halved
Returns:
The keras `Model`.
"""
_handle_dim_ordering()
if len(input_shape) != 3:
raise Exception("Input shape should be a tuple (nb_channels, nb_rows, nb_cols)")
# Permute dimension order if necessary
if K.image_dim_ordering() == 'tf':
input_shape = (input_shape[1], input_shape[2], input_shape[0])
# Load function from str if needed.
block_fn = _get_block(block_fn)
input = Input(shape=input_shape)
conv1 = _conv_bn_relu(filters=64, kernel_size=(7, 7), strides=(2, 2))(input)
pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(conv1)
block = pool1
filters = 64
for i, r in enumerate(repetitions):
block = _residual_block(block_fn, filters=filters, repetitions=r, is_first_layer=(i == 0))(block)
filters *= 2
# Last activation
block = _bn_relu(block)
# Classifier block
block_shape = K.int_shape(block)
pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS], block_shape[COL_AXIS]),
strides=(1, 1))(block)
flatten1 = Flatten()(pool2)
dense = Dense(units=num_outputs, kernel_initializer="he_normal",
activation="softmax")(flatten1)
model = Model(inputs=input, outputs=dense)
return model
def caltech_student_weak(n_classes: int,
input_shape=None,
input_tensor=None,
weights_path: Union[None, str] = None) -> Model:
"""
Defines a caltech strong student network.
:param n_classes: the number of classes.
:param input_shape: the input shape of the network. Can be omitted if input_tensor is used.
:param input_tensor: the input tensor of the network. Can be omitted if input_shape is used.
:param weights_path: a path to a trained caltech tiny network's weights.
:return: Keras functional Model.
"""
inputs = create_inputs(input_shape, input_tensor)
# Define a weight decay for the regularisation.
weight_decay = 1e-4
x = Conv2D(64, (3, 3),
padding='same',
activation='relu',
input_shape=input_shape,
kernel_regularizer=l2(weight_decay))(inputs)
x = BatchNormalization()(x)
x = Dropout(0.3, seed=0)(x)
x = Conv2D(128, (3, 3),
padding='same',
activation='relu',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization()(x)
x = Dropout(0.4, seed=0)(x)
x = Flatten()(x)
x = Dense(512, kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization()(x)
x = Dropout(0.5, seed=0)(x)
outputs = Dense(n_classes, activation='softmax', name='softmax_outputs')(x)
# Create model.
model = Model(inputs, outputs, name='caltech_student_weak')
# Load weights, if they exist.
load_weights(weights_path, model)
return model
def set_model(self):
input_layer = Input(shape=(
self.seq_len,
self.items_len,
))
lstm1 = LSTM(units=64,
activation='relu',
return_sequences=True,
input_shape=(self.seq_len, self.items_len))(input_layer)
lstm2 = LSTM(units=64, activation='relu', return_sequences=True)(lstm1)
lstm3 = LSTM(units=64, activation='relu', return_sequences=True)(lstm2)
layer1_1 = TimeDistributed(Dense(units=64, activation='relu'))(lstm3)
layer1_2 = TimeDistributed(Dense(units=64,
activation='sigmoid'))(layer1_1)
y1_output = TimeDistributed(Dense(units=1, activation='sigmoid'),
name='y1_output')(layer1_2)
layer2_1 = TimeDistributed(Dense(units=64, activation='relu'))(lstm3)
dropout_1 = Dropout(0.2)(layer2_1)
layer2_2 = TimeDistributed(Dense(units=64,
activation='relu'))(dropout_1)
layer2_3 = TimeDistributed(Dense(units=64,
activation='relu'))(layer2_2)
y2_output = TimeDistributed(Dense(units=self.features_range,
activation='softmax'),
name='y2_output')(layer2_3)
# Define the model with the input layer and a list of output layers
model = Model(inputs=input_layer, outputs=[y1_output, y2_output])
# optimizer = tf.keras.optimizers.SGD(lr=0.001)
optimizer = tf.keras.optimizers.Adam(clipvalue=0.5)
model.compile(optimizer=optimizer,
loss={
'y1_output': 'binary_crossentropy',
'y2_output': self.missed_value_loss
},
metrics={
'y1_output': 'accuracy',
'y2_output': self.missed_value_acc
})
print(model.summary())
return model
