def __init__(self):
super(Triplet_Net, self).__init__(self)
self.emb_layer = tf.keras.models.Sequential([
layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same'),
layers.LeakyReLU(),
layers.Dropout(0.3),
layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same'),
layers.LeakyReLU(),
layers.Dropout(0.3),
layers.Flatten(),
tf.keras.layers.Dense(200)
])
self.l2_norm = layers.Lambda(lambda x: tf.math.l2_normalize(x, axis=1))
def call(
self, inputs: Union[tf.Tensor, Tuple[tf.Tensor, ...],
List[tf.Tensor]], **kwargs
) -> Union[tf.Tensor, Tuple[tf.Tensor, ...], List[tf.Tensor]]:
"""
@credit: https://github.com/zzh8829/yolov3-tf2/blob/master/yolov3_tf2/models.py
"""
layer = self.conv1(inputs)
layer = self.conv2(layer)
layer = layers.Lambda(lambda layer: tf.reshape(
layer, (-1, tf.shape(layer)[1], tf.shape(layer)[2], self.
num_anchors, self.num_classes + 5)))(layer)
return layer
def yolo_v3(self, model_input, use_plot_model):
x_big_features, x_medium_features, x_small_features = darknet(
model_input, use_plot_model, self.figs_path)
n_anchors = self.masks.shape[1]
# Block for detecting big objects
y_big, y_big_features = last_layers(x_big_features, [512, 1024],
[1, 3], n_anchors, self.n_classes)
# Block for detecting medium objects
concat = concat_layers(256, y_big_features, x_medium_features)
y_medium, y_medium_features = last_layers(concat, [256, 512], [1, 3],
n_anchors, self.n_classes)
# Block for detecting small objects
concat = concat_layers(128, y_medium_features, x_small_features)
y_small, _ = last_layers(concat, [128, 256], [1, 3], len(self.masks),
self.n_classes)
train_model = tf.keras.Model(model_input, (y_big, y_medium, y_small),
name="YOLOv3_train")
boxes_big = layers.Lambda(
lambda predictions: self.extract_from_predictions(predictions, 0),
name='extractor_big')(y_big)
boxes_medium = layers.Lambda(
lambda predictions: self.extract_from_predictions(predictions, 1),
name='extractor_medium')(y_medium)
boxes_small = layers.Lambda(
lambda predictions: self.extract_from_predictions(predictions, 2),
name='extractor_small')(y_small)
outputs = layers.Lambda(
lambda predictions: self.non_max_suppression(predictions),
name='non_max_suppression')(
(boxes_big[:3], boxes_medium[:3], boxes_small[:3]))
inference_model = tf.keras.Model(model_input,
outputs,
name='YOLOv3_inference')
if use_plot_model:
self.save_plot_model(inference_model, train_model, 'yolov3')
return train_model, inference_model
def build_model(input_shape, target_size):
"""Construct the CosmoFlow 3D CNN model"""
# resnet = ResNet50(input_shape=input_shape, pooling='avg')
resnet = CosmoResNet(input_shape=input_shape, pooling='avg')
model = models.Sequential()
model.add(resnet)
model.add(layers.Flatten())
model.add(layers.Dense(target_size, activation='tanh'))
model.add(layers.Lambda(scale_1p2))
return model
def call(self, inputs):
identity = inputs
out = self.conv1(inputs)
out = self.bn1(out)
out = self.relu(out)
# group convs
if self.groups > 1:
outs = []
for i in range(self.groups):
# split output channels into groups
if self.data_format == 'channels_first':
g_out = layers.Lambda(
lambda x: x[:, self.per_group_c * i:self.per_group_c *
i + self.per_group_c, :, :])(out)
else:
g_out = layers.Lambda(
lambda x: x[:, :, :, self.per_group_c * i:self.
per_group_c * i + self.per_group_c])(out)
outs.append(self.group_convs[i](g_out))
out = layers.Concatenate(name='grouped')(outs)
else:
out = self.group_convs[0](out)
out = self.bn2(out)
out = self.relu(out)
# expansion
out = self.conv3(out)
out = self.bn3(out)
if self.downsample is not None:
identity = self.downsample(inputs)
out += identity
out = self.relu(out)
return out
def get_model_v5(input_shape, nb_classes):
model = get_base_v5(input_shape)
model.add(layers.Dense(1024, activation='relu'))
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(128, activation='relu', name="dense_128_relu"))
input_a = layers.Input(shape=input_shape)
input_b = layers.Input(shape=input_shape)
processed_a = model(input_a)
processed_b = model(input_b)
distance = layers.Lambda(euclidean_distance)([processed_a, processed_b])
model = Model(inputs=[input_a, input_b], outputs=distance)
return model
def multi_scale_like(image, disp_ms):
"""
:param image: [batch, height, width, 3]
:param disp_ms: list of [batch, height/scale, width/scale, 1]
:return: image_ms: list of [batch, height/scale, width/scale, 3]
"""
image_ms = []
for i, disp in enumerate(disp_ms):
batch, height_sc, width_sc, _ = disp.get_shape().as_list()
image_sc = layers.Lambda(lambda img: tf.image.resize(img, size=(height_sc, width_sc), method="bilinear"),
name=f"target_resize_{i}")(image)
image_ms.append(image_sc)
return image_ms
def __init_layers(self, base_model, dense_params):
self.base_model = base_model
self.dense_list = []
for param in dense_params[:-1]:
self.dense_list.append(
layers.Dense(param, activation="relu")
)
self.dense_list.append(
layers.Dense(dense_params[-1], activation="softmax")
)
self.cent_loss = layers.Lambda(
lambda x: K.mean(K.categorical_crossentropy(x[0], x[1]))
)
def combineModels(models, combiner):
shape = models[0].layers[0].input_shape[0][1:]
inputs = layers.Input(shape=shape)
actionsMask = layers.Input(shape=(4, ))
predictions = [
layers.Reshape((1, -1))(MaskedSoftmax()(x(inputs), actionsMask))
for x in models
]
res = layers.Lambda(combiner)(layers.Concatenate(axis=1)(predictions))
res = MaskedSoftmax()(res, actionsMask)
return keras.Model(inputs=[inputs, actionsMask], outputs=res)
def buildSiameseV2(self, shape, n_cls, distance='l2'):
"""
Which uses the function of contrastive. It is assumed that 0 for the same and 1 for different images.
[1] Hadsell R, Chopra S, LeCun Y.
Dimensionality reduction by learning an invariant mapping.
Innull 2006 Jun 17 (pp. 1735-1742). IEEE.
"""
model = self.build(shape)
model.add(layers.Dense(128, activation='sigmoid'))
self.extract_layer = 'dense_128_sigmoid'
self.input = model.input
self.output = model.output
input_1 = layers.Input(shape=shape)
input_2 = layers.Input(shape=shape)
embedded_1 = model(input_1)
embedded_2 = model(input_2)
def output_shape(input_shape):
return input_shape[0], 1
if distance == 'l1':
distance_layer = layers.Lambda(lambda tensors: K.sum(
K.abs(tensors[0] - tensors[1]), axis=-1, keepdims=True),
output_shape=output_shape)
distance = distance_layer([embedded_1, embedded_2])
elif distance == 'l2':
distance_layer = layers.Lambda(lambda tensors: K.sqrt(
K.sum(K.square(tensors[0] - tensors[1]),
axis=-1,
keepdims=True) + epsilon()),
output_shape=output_shape)
distance = distance_layer([embedded_1, embedded_2])
self.model = Model(inputs=[input_1, input_2], outputs=distance)
return self
def make_model(SIZE=28, LATENT_DIM=10, LR=1e-4, BETA=1.):
encoder_inputs = layers.Input(shape=(SIZE, SIZE, 1), name='encoder_input')
e = layers.Conv2D(filters=16,kernel_size=5,padding='SAME',activation='relu',strides=(2,2))(encoder_inputs)
e = layers.BatchNormalization()(e)
e = layers.Conv2D(filters=32,kernel_size=5,padding='SAME',activation='relu',strides=(2,2))(e)
e = layers.BatchNormalization()(e)
e = layers.Flatten()(e)
z_mean = layers.Dense(LATENT_DIM, name='z_mean')(e)
z_log_var = layers.Dense(LATENT_DIM, name='z_log_var')(e)
encoder = k.Model(inputs=encoder_inputs, outputs=[z_mean, z_log_var], name='encoder')
decoder_inputs = layers.Input(shape=(LATENT_DIM,), name='decoder_input')
d = layers.Dense(units=7*7*4,activation='relu')(decoder_inputs)
d = layers.Reshape((7,7,4))(d)
d = layers.Conv2DTranspose(filters=16,kernel_size=4,strides=(2, 2), padding="SAME", activation='relu')(d)
d = layers.Conv2DTranspose(filters=32,kernel_size=4,strides=(2, 2), padding="SAME", activation='relu')(d)
decoded = layers.Conv2DTranspose(filters=1, kernel_size=3,strides=(1, 1), padding="SAME")(d)
decoder = k.Model(inputs=decoder_inputs, outputs=decoded, name='decoder')
def sample(inputs):
z_mean, z_log_var = inputs
epsilon = tf.random.normal(shape=tf.shape(z_mean))
return z_mean + tf.exp(0.5 * z_log_var) * epsilon
sampler = layers.Lambda(sample)
z = sampler([z_mean, z_log_var])
vae = k.Model(inputs=encoder_inputs, outputs=decoder(z), name='vae')
def compute_kernel(x, y):
x_size = tf.shape(x)[0]
y_size = tf.shape(y)[0]
dim = tf.shape(x)[1]
tiled_x = tf.tile(tf.reshape(x, [x_size, 1, dim]), [1, y_size, 1])
tiled_y = tf.tile(tf.reshape(y, [1, y_size, dim]), [x_size, 1, 1])
return tf.exp(-tf.reduce_mean(tf.square(tiled_x - tiled_y), axis=2) / tf.cast(dim, tf.float32))
def compute_mmd(x, y):
x_kernel = compute_kernel(x, x)
y_kernel = compute_kernel(y, y)
xy_kernel = compute_kernel(x, y)
return tf.reduce_mean(x_kernel) + tf.reduce_mean(y_kernel) - 2 * tf.reduce_mean(xy_kernel)
true_samples = tf.random_normal(shape=tf.shape(z))
loss_mmd = compute_mmd(true_samples, z)
vae.add_loss(loss_mmd*BETA)
vae.compile(loss='mse', optimizer=k.optimizers.Adam(LR), metrics=['mse'])
return encoder, decoder , vae
def RNNSpeechModel(nCategories, samplingrate=16000, inputLength=16000):
# simple LSTM
sr = samplingrate
iLen = inputLength
inputs = L.Input((iLen, ))
x = L.Reshape((1, -1))(inputs)
x = Melspectrogram(n_dft=1024,
n_hop=128,
input_shape=(1, iLen),
padding='same',
sr=sr,
n_mels=80,
fmin=40.0,
fmax=sr / 2,
power_melgram=1.0,
return_decibel_melgram=True,
trainable_fb=False,
trainable_kernel=False,
name='mel_stft')(x)
x = Normalization2D(int_axis=0)(x)
# note that Melspectrogram puts the sequence in shape (batch_size, melDim, timeSteps, 1)
# we would rather have it the other way around for LSTMs
x = L.Permute((2, 1, 3))(x)
x = L.Conv2D(10, (5, 1), activation='relu', padding='same')(x)
x = L.BatchNormalization()(x)
x = L.Conv2D(1, (5, 1), activation='relu', padding='same')(x)
x = L.BatchNormalization()(x)
# x = Reshape((125, 80)) (x)
# keras.backend.squeeze(x, axis)
x = L.Lambda(lambda q: K.squeeze(q, -1), name='squeeze_last_dim')(x)
x = L.Bidirectional(L.LSTM(64, return_sequences=True))(
x) # [b_s, seq_len, vec_dim]
x = L.Bidirectional(L.LSTM(64))(x)
x = L.Dense(64, activation='relu')(x)
x = L.Dense(32, activation='relu')(x)
output = L.Dense(nCategories, activation='softmax')(x)
model = Model(inputs=[inputs], outputs=[output])
return model
def tiny_yolo_v3(self, model_input, use_plot_model):
x_big_features, x_small_features = tiny_darknet(
model_input, use_plot_model, self.figs_path)
n_anchors = self.masks.shape[1]
y_big_features = tiny_layer(x_big_features)
y_big = last_tiny_layers(y_big_features,
n_filters=512,
kernel_size=3,
n_anchors=n_anchors,
n_classes=self.n_classes)
concat = concat_layers(128, y_big_features, x_small_features)
y_small = last_tiny_layers(concat,
n_filters=256,
kernel_size=3,
n_anchors=n_anchors,
n_classes=self.n_classes)
train_model = tf.keras.Model(model_input, (y_big, y_small),
name="Tiny_YOLOv3_train")
boxes_big = layers.Lambda(
lambda predictions: self.extract_from_predictions(predictions, 0),
name='extractor_big')(y_big)
boxes_small = layers.Lambda(
lambda predictions: self.extract_from_predictions(predictions, 1),
name='extractor_small')(y_small)
outputs = layers.Lambda(
lambda predictions: self.non_max_suppression(predictions),
name='non_max_suppression')((boxes_big[:3], boxes_small[:3]))
inference_model = tf.keras.Model(model_input,
outputs,
name='Tiny_YOLOv3_inference')
if use_plot_model:
self.save_plot_model(inference_model, train_model, 'tiny-yolov3')
return train_model, inference_model
def get_model(self):
input_layer = layers.Input((self.n_inputs, ))
layer = input_layer
layer = layers.Dense(self.n_inputs * self.n_actions,
activation='relu',
kernel_initializer=keras.initializers.HeUniform(
seed=self.seed))(layer)
if self.dueling_dqn:
state_value = layers.Dense(
1,
kernel_initializer=keras.initializers.HeUniform(
seed=self.seed))(layer)
state_value = layers.Lambda(
lambda s: keras.backend.expand_dims(s[:, 0], -1),
output_shape=(self.n_actions, ))(state_value)
action_advantage = layers.Dense(
self.n_actions,
kernel_initializer=keras.initializers.HeUniform(
seed=self.seed))(layer)
action_advantage = layers.Lambda(
lambda a: a[:, :] - keras.backend.mean(a[:, :], keepdims=True),
output_shape=(self.n_actions, ))(action_advantage)
layer = layers.Add()([state_value, action_advantage])
else:
layer = layers.Dense(
self.n_actions,
kernel_initializer=keras.initializers.HeUniform(
seed=self.seed))(layer)
model = keras.Model(inputs=input_layer, outputs=layer)
model.compile(
optimizer=keras.optimizers.Adam(learning_rate=self.learning_rate),
loss='mean_squared_error')
return model
def resnet_block(x, dim, k_init, ks=3, s=1):
# e.g, x is (batch * 128 * 128 * 3)
p = (ks - 1) // 2
# For ks = 3, p = 1
y = layers.Lambda(padding,
arguments={'p': p},
name='PADDING_1')(x)
# After first padding, (batch * 130 * 130 * 3)
y = layers.Conv2D(filters=dim,
kernel_size=ks,
strides=s,
padding='valid',
kernel_initializer=k_init,
use_bias=False)(y)
y = layers.Lambda(instance_norm,
name='IN')(y)
y = layers.ReLU()(y)
# After first conv2d, (batch * 128 * 128 * 3)
y = layers.Lambda(padding,
arguments={'p': p},
name='PADDING_2')(y)
# After second padding, (batch * 130 * 130 * 3)
y = layers.Conv2D(filters=dim,
kernel_size=ks,
strides=s,
padding='valid',
kernel_initializer=k_init,
use_bias=False)(y)
y = layers.Lambda(instance_norm,
name='IN')(y)
y = layers.ReLU()(y + x)
# After second conv2d, (batch * 128 * 128 * 3)
return y
def add_resolution(self):
self.current_resolution += 1
inputs = layers.Input(
shape=(2.0**self.current_resolution, ) * self.dimensionality +
(self.num_channels, ),
name='image')
alpha = layers.Input(shape=[], name='d_alpha')
# Residual from input
from_rgb_1 = self.AveragePooling()(inputs)
from_rgb_1 = self.Conv(self._nf(self.current_resolution - 1),
kernel_size=1,
padding='same',
name='from_rgb_1')(from_rgb_1)
# Growing discriminator
d_block = self._make_discriminator_block(
self._nf(self.current_resolution - 1),
name='d_block_{}'.format(self.current_resolution))
from_rgb_2 = self.Conv(self._nf(self.current_resolution),
kernel_size=1,
padding='same',
name='from_rgb_2')(inputs)
from_rgb_2 = d_block(from_rgb_2)
lerp_input = self._weighted_sum()([from_rgb_1, from_rgb_2, alpha])
output = self.growing_discriminator(lerp_input)
score_output = layers.Lambda(lambda x: x[..., 0])(output)
label_output = layers.Lambda(lambda x: x[..., 1:])(output)
self.growing_discriminator = tf.keras.Sequential(
[d_block, self.growing_discriminator])
self.train_discriminator = tf.keras.models.Model(
inputs=[inputs, alpha], outputs=[score_output, label_output])
def make_model(nh):
z = L.Input((nh,), name="Patient")
x = L.Dense(100, activation="relu", name="d1")(z)
x = L.Dense(100, activation="relu", name="d2")(x)
#x = L.Dense(100, activation="relu", name="d3")(x)
p1 = L.Dense(3, activation="linear", name="p1")(x)
p2 = L.Dense(3, activation="relu", name="p2")(x)
preds = L.Lambda(lambda x: x[0] + tf.cumsum(x[1], axis=1),
name="preds")([p1, p2])
model = M.Model(z, preds, name="CNN")
#model.compile(loss=qloss, optimizer="adam", metrics=[score])
model.compile(loss=mloss(0.8), optimizer=tf.keras.optimizers.Adam(lr=0.1, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.01, amsgrad=False), metrics=[score])
return model
def build_model(input_shape,
target_size,
conv_size=32,
kernel_size=3,
n_conv_layers=5,
fc1_size=128,
fc2_size=64,
l2=0,
hidden_activation='LeakyReLU',
pooling_type='MaxPool3D',
dropout=0.5):
"""Construct the CosmoFlow 3D CNN model"""
if have_mlperf_logging:
mllogger = mllog.get_mllogger()
mllogger.event(key=mllog.constants.OPT_WEIGHT_DECAY, value=l2)
mllogger.event(key='dropout', value=dropout)
conv_args = dict(kernel_size=kernel_size, padding='same')
hidden_activation = getattr(layers, hidden_activation)
pooling_type = getattr(layers, pooling_type)
model = tf.keras.models.Sequential()
# First convolutional layer
model.add(layers.Conv3D(conv_size, input_shape=input_shape, **conv_args))
model.add(hidden_activation())
model.add(pooling_type(pool_size=2))
# Additional conv layers
for i in range(1, n_conv_layers):
# Double conv channels at every layer
model.add(layers.Conv3D(conv_size * 2**i, **conv_args))
model.add(hidden_activation())
model.add(pooling_type(pool_size=2))
model.add(layers.Flatten())
# Fully-connected layers
model.add(layers.Dense(fc1_size, kernel_regularizer=regularizers.l2(l2)))
model.add(hidden_activation())
model.add(layers.Dropout(dropout))
model.add(layers.Dense(fc2_size, kernel_regularizer=regularizers.l2(l2)))
model.add(hidden_activation())
model.add(layers.Dropout(dropout))
# Output layers
model.add(layers.Dense(target_size, activation='tanh'))
model.add(layers.Lambda(scale_1p2))
return model
def _branching(self, previous, before_unet):
real_branch = self._cc_layer(self.dataprovider.nK, previous)
real_branch = layers.concatenate([real_branch, before_unet])
real_branch = layers.Conv2D(self.dataprovider.IF**2, (3, 3),
activation='relu',
padding='same')(real_branch)
imag_branch = self._cc_layer(self.dataprovider.nK, previous)
imag_branch = layers.concatenate([imag_branch, before_unet])
imag_branch = layers.Conv2D(self.dataprovider.IF**2, (3, 3),
activation=None,
padding='same')(imag_branch)
de_int_real = layers.Lambda(self._deinterleave,
name="De-interleave_real")(real_branch)
de_int_imag = layers.Lambda(self._deinterleave,
name="De-interleave_imag")(imag_branch)
slm_field = layers.Lambda(self._prop_to_slm,
name="SLM_phase")([de_int_real, de_int_imag])
return slm_field
def __init__(self,
filter_num=[64, 64],
kernel_size=[3, 3],
strides=[1, 1],
input_channels=64):
super(BasicResBlockUpdate, self).__init__()
# 初始化滤波器个数、滤波器大小、和步长
filter_num1, filter_num2 = filter_num
kernel_size1, kernel_size2 = kernel_size
strides1, strides2 = strides
# 定义卷积层
self.cnn1 = layers.Conv2D(filters=filter_num1,
kernel_size=kernel_size1,
strides=strides1,
padding='same',
activation='relu')
self.bn1 = layers.BatchNormalization()
self.cnn2 = layers.Conv2D(filters=filter_num2,
kernel_size=kernel_size2,
strides=strides2,
padding='same',
activation=None)
self.bn2 = layers.BatchNormalization()
if strides1 * strides2 == 1 and input_channels == filter_num2:
self.shortcut = layers.Lambda(lambda x: x)
else:
# 维度不一样
# 两种解决方法
# 方法1：先将输入补零增加维度，后利用池化降低维度
# self.shortcut = keras.Sequential([
# layers.Lambda(lambda x: tf.pad(x, [[0, 0], [0, 0], [0, 0], [0, filter_num2-x.shape[3]]],
# mode='CONSTANT', constant_values=0, name=None)),
# layers.MaxPool2D(pool_size=2, strides=strides1 * strides2, padding='same')
# ])
# 方法2：利用1*1卷积增加维度，再池化
self.shortcut = keras.Sequential([
layers.Conv2D(filter_num2,
kernel_size=1,
strides=1,
padding='same'),
layers.MaxPool2D(pool_size=2,
strides=strides1 * strides2,
padding='same'),
layers.BatchNormalization()
])
def make_parallel(inner_model, gpu_count):
"""Creates a new wrapper model that consists of multiple replicas of
the original model placed on different GPUs.
"""
# Slice inputs. Slice inputs on the CPU to avoid sending a copy
# of the full inputs to all GPUs. Saves on bandwidth and memory.
input_slices = {name: tf.split(x, gpu_count)
for name, x in zip(inner_model.input_names,
inner_model.inputs)}
output_names = inner_model.output_names
outputs_all = []
for i in range(len(inner_model.outputs)):
outputs_all.append([])
# Run the model call() on each GPU to place the ops there
for i in range(gpu_count):
with tf.device('/gpu:%d' % i):
with tf.name_scope('tower_%d' % i):
# Run a slice of inputs through this replica
zipped_inputs = zip(inner_model.input_names,
inner_model.inputs)
inputs = [
KL.Lambda(lambda s: input_slices[name][i],
output_shape=lambda s: (None,) + s[1:])(tensor)
for name, tensor in zipped_inputs]
# Create the model replica and get the outputs
outputs = inner_model(inputs)
if not isinstance(outputs, list):
outputs = [outputs]
# Save the outputs for merging back together later
for l, o in enumerate(outputs):
outputs_all[l].append(o)
# Merge outputs on CPU
with tf.device('/cpu:0'):
merged = []
for outputs, name in zip(outputs_all, output_names):
# If outputs are numbers without dimensions, add a batch dim.
def add_dim(tensor):
"""Add a dimension to tensors that don't have any."""
if K.int_shape(tensor) == ():
return KL.Lambda(lambda t: K.reshape(t, [1, 1]))(tensor)
return tensor
outputs = list(map(add_dim, outputs))
# Concatenate
merged.append(KL.Concatenate(axis=0, name=name)(outputs))
# return merged
return KM.Model(inputs=inner_model.inputs, outputs=merged)
def action_smear_layer(input_sequence_length, action_dim, h, w):
reshape = layers.Reshape(
target_shape=[input_sequence_length, 1, 1, action_dim],
name='smear_reshape')
smear = layers.Lambda(function=lambda action_reshaped: tf.tile(
action_reshaped, [1, 1, h, w, 1]),
name='spatial_tile')
def forward(action):
action_reshaped = reshape(action)
action_smear = smear(action_reshaped)
return action_smear
return forward
def bottleneck_block(x, filters_in, filters_out, cardinality=32):
""" Construct a ResNeXT block with identity link
x : input to block
filters_in : number of filters (channels) at the input convolution
filters_out: number of filters (channels) at the output convolution
cardinality: width of cardinality layer
"""
# Remember the input
shortcut = x
# Dimensionality Reduction
x = layers.Conv2D(filters_in,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
kernel_initializer='he_normal')(shortcut)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# Cardinality (Wide) Layer (split-transform)
filters_card = filters_in // cardinality
groups = []
for i in range(cardinality):
group = layers.Lambda(lambda z: z[:, :, :, i * filters_card:i *
filters_card + filters_card])(x)
groups.append(
layers.Conv2D(filters_card,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
kernel_initializer='he_normal')(group))
# Concatenate the outputs of the cardinality layer together (merge)
x = layers.concatenate(groups)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# Dimensionality restoration
x = layers.Conv2D(filters_out,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
kernel_initializer='he_normal')(x)
x = layers.BatchNormalization()(x)
# Identity Link: Add the shortcut (input) to the output of the block
x = layers.add([shortcut, x])
x = layers.ReLU()(x)
return x
def le_net_5(input_shape, dropout):
m = models.Sequential()
m.add(layers.Lambda(lambda x: x / 127.5 - 1., input_shape=input_shape))
m.add(layers.Convolution2D(64, 5, 5, activation='relu'))
m.add(layers.MaxPooling2D((2, 2)))
m.add(layers.Dropout(dropout))
m.add(layers.Convolution2D(36, 5, 5, activation='relu'))
m.add(layers.MaxPooling2D((2, 2)))
m.add(layers.Flatten())
m.add(layers.Dense(120))
m.add(layers.Dropout(dropout))
m.add(layers.Dense(84))
m.add(layers.Dense(1))
return m
def create(self):
units_output_size = 512
units_input = tf.keras.Input(shape=(None, self.units_features_size),
name="units_input")
layer_units = layers.Dense(1024, activation='elu',
name="units_layer1")(units_input)
layer_units = layers.Dense(512, activation='elu',
name="units_layer2")(layer_units)
layer_units = layers.Dense(512, activation='elu',
name="units_layer3")(layer_units)
units_output = layers.Dense(units_output_size,
activation='elu',
name="units_output")(layer_units)
units_output = layers.Lambda(
lambda x: tf.keras.backend.mean(x, axis=1),
name="average_units_output")(units_output)
extra_features_input = tf.keras.Input(
shape=(self.extra_features_size, ), name="extra_features_input")
concatenate_layer = layers.Concatenate()(
[units_output, extra_features_input])
layer = layers.Dense(2048, activation='elu',
name="state_layer1")(concatenate_layer)
layer = layers.Dense(1024, activation='elu',
name="state_layer2")(layer)
layer = layers.Dense(512, activation='elu', name="state_layer3")(layer)
layer = layers.Dense(512, activation='elu', name="state_layer4")(layer)
layer = layers.Dense(256, activation='elu', name="state_layer5")(layer)
layer = layers.Dense(256, activation='elu', name="state_layer6")(layer)
layer = layers.Dense(256, activation='elu', name="state_layer7")(layer)
layer = layers.Dense(128, activation='elu', name="state_layer8")(layer)
layer = layers.Dense(128, activation='elu', name="state_layer9")(layer)
layer = layers.Dense(128, activation='elu',
name="state_layer10")(layer)
value = layers.Dense(1, activation='relu', name="value")(layer)
self.model = tf.keras.Model(inputs=[units_input, extra_features_input],
outputs=value)
#self.lrs = tf.keras.callbacks.LearningRateScheduler(self.exponential_decay)
self.model.compile(optimizer=tf.keras.optimizers.Nadam(
self.learning_rate),
loss='mae',
metrics=['mae'])
def fpn_classifier_graph(rois,
feature_maps,
image_meta,
pool_size,
num_classes,
batch_size,
train_bn=True,
fc_layers_size=1024):
#ROIAlign层 Shape: [batch, num_boxes, pool_height, pool_width, channels]
x = PyramidROIAlign(batch_size, [pool_size, pool_size],
name="roi_align_classifier")([rois, image_meta] +
feature_maps)
#用卷积替代两个1024全连接网络
x = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (pool_size, pool_size),
padding="valid"),
name="mrcnn_class_conv1")(x)
x = KL.TimeDistributed(KL.BatchNormalization(),
name='mrcnn_class_bn1')(x, training=train_bn)
x = KL.Activation('relu')(x)
#1*1卷积，代替第二个全连接
x = KL.TimeDistributed(KL.Conv2D(fc_layers_size, (1, 1)),
name="mrcnn_class_conv2")(x)
x = KL.TimeDistributed(KL.BatchNormalization(),
name='mrcnn_class_bn2')(x, training=train_bn)
x = KL.Activation('relu')(x)
#共享特征，用于计算分类和边框
shared = KL.Lambda(lambda x: K.squeeze(K.squeeze(x, 3), 2),
name="pool_squeeze")(x)
#（1）计算分类
mrcnn_class_logits = KL.TimeDistributed(KL.Dense(num_classes),
name='mrcnn_class_logits')(shared)
mrcnn_probs = KL.TimeDistributed(KL.Activation("softmax"),
name="mrcnn_class")(mrcnn_class_logits)
#（2）计算边框坐标BBox（偏移和缩放量）
# [batch, boxes, num_classes * (dy, dx, log(dh), log(dw))]
x = KL.TimeDistributed(KL.Dense(num_classes * 4, activation='linear'),
name='mrcnn_bbox_fc')(shared)
# Reshape to [batch, boxes, num_classes, (dy, dx, log(dh), log(dw))]
s = K.int_shape(x)
print(s, num_classes, 4)
#mrcnn_bbox = KL.Reshape((s[1], num_classes, 4), name="mrcnn_bbox")(x)
mrcnn_bbox = KL.Reshape((-1, num_classes, 4), name="mrcnn_bbox")(x)
return mrcnn_class_logits, mrcnn_probs, mrcnn_bbox
def makeCaps(int numcaps):
# Building a Capsule Network as specified by Sara Sabour
# Start with a Convolution Layer with 256 9*9 filters
# output would be 20*20*256 images
#creating input layer
# ---
# -CryTech Size : 28, 28, 1
#-----
x = tf.keras.Input(shape=(28,28,1))
#creating conv layer as mentioned before
conv1 = layers.Conv2D(filters=256, kernel_size=9, strides=1, padding='valid', activation='relu')(x)
#primary capsule which involves
#we need 32 capsules each capsule has 8 dimensional array of size 6*6
#Conv layer is used with no of filters as 32*8 = 256
#reshape the array from 6*6*256 as (6*6*32)*8
output = layers.Conv2D(filters=256, kernel_size=9, strides=2, padding='valid')(conv1)
# ---
# -CryTech Primary Capsule Size : 6*6*32 capsules of 8Dimension
#-----
outputs = layers.Reshape(target_shape=[1152, 8], name='primarycap_reshape')(output)
#Apply Squash
outputs = layers.Lambda(squash, name='primarycap_squash')(outputs)
#Create a Capsule Layer
# ---
# -CryTech Primary Capsule Size : 13 capsules(representing 13 classes) of 10Dimension
# :param number of routings is set to 3
#-----
digitcaps = CapsuleLayer(num_capsule=numcaps, dim_capsule=16, routings=3,name='digitcaps')(outputs)
out_caps = Length(name='capsnet')(digitcaps)
y = layers.Input(shape=(numcaps,))
masked_by_y = Mask()([digitcaps, y]) # The true label is used to mask the output of capsule layer. For training
masked = Mask()(digitcaps) # Mask using the capsule with maximal length. For prediction
# Shared Decoder model in training and prediction
decoder = models.Sequential(name='decoder')
decoder.add(layers.Dense(512, activation='relu', input_dim=16*numcaps))
decoder.add(layers.Dense(1024, activation='relu'))
# ---
# -CryTech Input Shape = 28 * 28 = 784
#-----
decoder.add(layers.Dense(784, activation='sigmoid'))
decoder.add(layers.Reshape(target_shape=(28,28,1), name='out_recon'))
M = models.Model([x, y], [out_caps, decoder(masked_by_y)])
return M
def create_model(anchors,
num_classes,
model_struc="densenet",
load_pretrained=False,
weights_path="",
freeze_body=False):
backend.clear_session(
) # Useful to avoid clutter from old models and layers.
image_input = layers.Input(shape=(None, None, 1)) # 图片输入格式
num_anchors = len(anchors)
# YOLO3有三种尺度的特征图：size/32, size/16, size/8, 分别对应不同粒度的特征
# 特征图shape(batch, height, width, 当前尺度下的anchor数，类别数+边框4个+置信度1个)
y_true = [
layers.Input(shape=(None, None, num_anchors // 3, num_classes + 5))
for _ in range(3)
]
model_body = yolo_body(image_input, num_anchors // 3, num_classes,
model_struc)
print("Create YOLOv3 model with {} anchors and {} classes.".format(
num_anchors, num_classes))
# 加载预训练模型
if load_pretrained:
model_body.load_weights(weights_path, by_name=True,
skip_mismatch=True) # 加载参数，跳过错误
print('Load weights {}.'.format(weights_path))
if freeze_body:
num = len(model_body.layers) - 52
for i in range(num):
model_body.layers[i].trainable = False # 将模型层的训练关闭
print('Freeze the first {} layers of total {} layers.'.format(
num, len(model_body.layers)))
model_loss = layers.Lambda(yolo_loss,
output_shape=(1, ),
name='yolo_loss',
arguments={
'anchors': anchors,
'num_classes': num_classes,
'iou_thresh': 0.5
})(model_body.output + y_true)
model = models.Model(inputs=[model_body.input] + y_true,
outputs=model_loss) # 模型inputs和outputs
model.summary()
return model
def __new__(cls, shape: Tuple[int] = (32, 32),
units: int = 32, repeat: int = 3) \
-> KM.Model:
def _preprocess(image):
image = tf.reshape(
tf.tile(tf.squeeze(inputs, -1), [1, repeat, repeat]),
[-1, repeat, *shape])
image = tf.expand_dims(image, -1)
return image
def _postprocess(output):
return output[repeat - 1::repeat]
inputs = KL.Input(shape=[None, None, 1], name="input_image")
image = KL.Lambda(_preprocess)(inputs)
output = KL.RNN(RNN(units=units, shape=shape),
return_sequences=False,
name='rnn')(image)
output = KL.Lambda(_postprocess)(output)
return KM.Model([inputs], [output], name='SRN')
def rpn_header(feature, num_anchors):
""" the header of region proposal network
/ scores_branch
x -> resnet -> c2, c3, c4, c5 -> FPN -> p2, p3, p4, p5, p6 --> shared_layer -->
\ location_branch
Args:
feature: the outputs of FPN
num_anchors: the channels is 2 * num_anchors and 4 * num_anchors
Returns:
rpn_class_logits
rpn_class_probs
location
"""
shared_feature = layers.Conv2D(512,
3,
padding='same',
name='rpn_conv_shared')(feature)
shared_feature = layers.ReLU()(shared_feature)
# scores of positive negative
rpn_class_logits = layers.Conv2D(2 * num_anchors, 1,
name='rpn_class_raw')(shared_feature)
rpn_class_logits = layers.Lambda(
lambda t: tf.reshape(t, [tf.shape(t)[0], -1, 2]))(rpn_class_logits)
rpn_class_probs = layers.Softmax(name='rpn_class_xxx')(rpn_class_logits)
# the location
# [batch_size, none, none, 4 * num_anchors]
location = layers.Conv2D(4 * num_anchors, 1,
name='rpn_bbox_pred')(shared_feature)
location = layers.Lambda(lambda t: tf.reshape(t, [tf.shape(t)[0], -1, 4]))(
location) # [batch, num_anchors, 4]
return rpn_class_logits, rpn_class_probs, location
