def identity_block(input_tensor, kernel_size, filters, stage, block):
filters1, filters2, filters3 = filters
conv_name_base = 'res' + str(stage) + block + '_branch'
bn_name_base = 'bn' + str(stage) + block + '_branch'
x = Conv2D(filters1, (1, 1),
kernel_initializer=RandomNormal(stddev=0.02),
name=conv_name_base + '2a')(input_tensor)
x = BatchNormalization(trainable=False, name=bn_name_base + '2a')(x)
x = Activation('relu')(x)
x = Conv2D(filters2,
kernel_size,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02),
name=conv_name_base + '2b')(x)
x = BatchNormalization(trainable=False, name=bn_name_base + '2b')(x)
x = Activation('relu')(x)
x = Conv2D(filters3, (1, 1),
kernel_initializer=RandomNormal(stddev=0.02),
name=conv_name_base + '2c')(x)
x = BatchNormalization(trainable=False, name=bn_name_base + '2c')(x)
x = layers.add([x, input_tensor])
x = Activation('relu')(x)
return x
def residual(x, out_dim, name, stride=1):
#-----------------------------------#
# 残差网络结构
# 两个形态
# 1、残差边有卷积，改变维度
# 2、残差边无卷积，加大深度
#-----------------------------------#
shortcut = x
num_channels = K.int_shape(shortcut)[-1]
x = ZeroPadding2D(padding=1, name=name + '.pad1')(x)
x = Conv2D(out_dim, 3, strides=stride, kernel_initializer=RandomNormal(stddev=0.02), use_bias=False, name=name + '.conv1')(x)
x = BatchNormalization(epsilon=1e-5, name=name + '.bn1')(x)
x = Activation('relu', name=name + '.relu1')(x)
x = Conv2D(out_dim, 3, padding='same', kernel_initializer=RandomNormal(stddev=0.02), use_bias=False, name=name + '.conv2')(x)
x = BatchNormalization(epsilon=1e-5, name=name + '.bn2')(x)
if num_channels != out_dim or stride != 1:
shortcut = Conv2D(out_dim, 1, strides=stride, kernel_initializer=RandomNormal(stddev=0.02), use_bias=False, name=name + '.shortcut.0')(
shortcut)
shortcut = BatchNormalization(epsilon=1e-5, name=name + '.shortcut.1')(shortcut)
x = Add(name=name + '.add')([x, shortcut])
x = Activation('relu', name=name + '.relu')(x)
return x
def call(self, layer_input):
# first convolutional layer
x = tf.keras.layers.Conv2D(
self.num_filters,
self.filter_shape,
strides=1,
padding='same',
kernel_initializer=RandomNormal(mean=0, stddev=0.02),
bias_initializer=RandomNormal(mean=0, stddev=0.02))(layer_input)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Activation(tf.keras.activations.relu)(x)
# second convolutional layer
x = tf.keras.layers.Conv2D(
self.num_filters,
self.filter_shape,
strides=1,
padding='same',
kernel_initializer=RandomNormal(mean=0, stddev=0.02),
bias_initializer=RandomNormal(mean=0, stddev=0.02))(x)
x = tf.keras.layers.BatchNormalization()(x)
# Return elementwise summation of resblock input and output
return tf.add(x, layer_input)
def generator(img_shape):
in_img = Input(shape=img_shape)
e1 = encoder(in_img, 64, batchnorm=False)
e2 = encoder(e1, 128)
e3 = encoder(e2, 256)
e4 = encoder(e3, 512)
e5 = encoder(e4, 512)
e6 = encoder(e5, 512)
e7 = encoder(e6, 512)
b = Conv2D(512, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=RandomNormal(stddev=0.02))(e7)
b = LeakyReLU()(b)
d1 = decoder(b, e7, 512)
d2 = decoder(d1, e6, 512)
d3 = decoder(d2, e5, 512)
d4 = decoder(d3, e4, 512, dropout=False)
d5 = decoder(d4, e3, 256, dropout=False)
d6 = decoder(d5, e2, 128, dropout=False)
d7 = decoder(d6, e1, 64, dropout=False)
out = Conv2DTranspose(3, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=RandomNormal(stddev=0.02))(d7)
out = Activation('tanh')(out)
model = Model(in_img, out)
return model
def get_generator_unet(n_block=3):
input = Input(shape=(image_size, image_size, input_channel))
# encoder
e0 = Conv2D(64, kernel_size=4, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(input) # use reflection padding instead
e0 = BatchNormalization()(e0)
e0 = Activation('relu')(e0)
e1 = conv_block(e0, 128, downsample=True, dropout=False) # 1/2
e2 = conv_block(e1, 256, downsample=True, dropout=False) # 1/4
e3 = conv_block(e2, 512, downsample=True, dropout=False) # 1/8
e4 = conv_block(e3, 512, downsample=True, dropout=False) # 1/16
e5 = conv_block(e4, 512, downsample=True, dropout=False) # 1/32
e6 = conv_block(e5, 512, downsample=True, dropout=False) # 1/64
e7 = conv_block(e6, 512, downsample=True, dropout=False) # 1/128
# decoder
d0 = conv_block(e7, 512, downsample=False, dropout=True) # 1/64
d1 = Concatenate(axis=-1)([d0, e6])
d1 = conv_block(d1, 512, downsample=False, dropout=True) # 1/32
d2 = Concatenate(axis=-1)([d1, e5])
d2 = conv_block(d2, 512, downsample=False, dropout=True) # 1/16
d3 = Concatenate(axis=-1)([d2, e4])
d3 = conv_block(d3, 512, downsample=False, dropout=True) # 1/8
d4 = Concatenate(axis=-1)([d3, e3])
d4 = conv_block(d4, 256, downsample=False, dropout=True) # 1/4
d5 = Concatenate(axis=-1)([d4, e2])
d5 = conv_block(d5, 128, downsample=False, dropout=True) # 1/2
d6 = Concatenate(axis=-1)([d5, e1])
d6 = conv_block(d6, 64, downsample=False, dropout=True) # 1
# out
x = Conv2D(output_channel, kernel_size=3, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(d6) # use reflection padding instead
x = BatchNormalization()(x)
x = Activation('tanh')(x)
generator = Model(inputs=input, outputs=x)
return generator
def get_rpn(base_layers, num_anchors):
#----------------------------------------------------#
# 利用一个512通道的3x3卷积进行特征整合
#----------------------------------------------------#
x = Conv2D(512, (3, 3),
padding='same',
activation='relu',
kernel_initializer=RandomNormal(stddev=0.02),
name='rpn_conv1')(base_layers)
#----------------------------------------------------#
# 利用一个1x1卷积调整通道数，获得预测结果
#----------------------------------------------------#
x_class = Conv2D(num_anchors, (1, 1),
activation='sigmoid',
kernel_initializer=RandomNormal(stddev=0.02),
name='rpn_out_class')(x)
x_regr = Conv2D(num_anchors * 4, (1, 1),
activation='linear',
kernel_initializer=RandomNormal(stddev=0.02),
name='rpn_out_regress')(x)
x_class = Reshape((-1, 1), name="classification")(x_class)
x_regr = Reshape((-1, 4), name="regression")(x_regr)
return [x_class, x_regr]
def get_generator(n_block=3):
input = Input(shape=(image_size, image_size, input_channel))
x = Conv2D(64, kernel_size=7, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(input) # use reflection padding instead
x = BatchNormalization()(x)
x = Activation('relu')(x)
# downsample
x = Conv2D(128, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# downsample
x = Conv2D(256, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
for i in range(n_block):
x = residual_block(x)
# upsample
x = Conv2DTranspose(128, kernel_size=3, strides=2, padding='same',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.02), bias_initializer=Zeros())(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# upsample
x = Conv2DTranspose(64, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# out
x = Conv2D(output_channel, kernel_size=7, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) # use reflection padding instead
x = BatchNormalization()(x)
x = Activation('tanh')(x)
generator = Model(inputs=input, outputs=x)
return generator
def build_discriminator(self):
with tf.name_scope('discriminator') as scope:
model = Sequential(name=scope)
model.add(
Conv2D(64, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01)))
model.add(LeakyReLU())
model.add(Dropout(0.3))
model.add(
Conv2D(128, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01)))
model.add(LeakyReLU())
model.add(Dropout(0.3))
model.add(Flatten())
model.add(
Dense(1,
activation='sigmoid',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01)))
return model
def Attention_CNN(input_shape=(20, 4, 1), filters=16, conv_1=7):
X_input = Input(input_shape)
# stage1
X = Conv2D(filters=filters,
kernel_size=(conv_1, 4),
strides=(1, 1),
name="conv1",
padding='valid',
activation='relu',
kernel_initializer=RandomNormal(stddev=0.05))(X_input)
#X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
y = se_block(X)
X = add([X, y])
X = MaxPooling2D(pool_size=(2, 1))(X)
# 输出层
X = Flatten()(X)
X = Dense(128,
activation='relu',
kernel_initializer=RandomNormal(stddev=0.05))(X)
X = Dropout(0.4)(X)
X = Dense(1,
name='fc',
activation='linear',
kernel_initializer=RandomNormal(stddev=0.05))(X)
model = Model(inputs=X_input, outputs=X, name='simplenet')
return model
def BuildInitialModel(input_dim):
"""
Builds a model with a single input layer and a binary sigmoid output layer.
# Arguments :
input_dim - the dimension of the 1D input vector
"""
l1init = RandomNormal(
mean=0.0, stddev=0.1,
seed=None) # original model parameters for initializing input layer
hiddeninit = RandomNormal(
mean=0.0, stddev=0.05,
seed=None) # original model parameters for initializing hidden layers
outputinit = RandomNormal(
mean=0.0, stddev=0.001,
seed=None) # original model parameters for initializing output layer
model = Sequential()
model.add(
Dense(300,
input_dim=input_dim,
activation='relu',
kernel_initializer=l1init))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid', kernel_initializer=outputinit))
return model
def _get_convolutional_network(kernel_regularizer_conv,
kernel_regularizer_dense):
convolutional_net = Sequential()
_add_convolutional_layer(convolutional_net, 64, (10, 10),
kernel_regularizer_conv, True)
# convolutional_net.add(SpatialDropout2D(0.2))
# convolutional_net.add(MaxPool2D(pool_size=(3, 3), strides=(3, 3)))
_add_convolutional_layer(convolutional_net, 128, (7, 7),
kernel_regularizer_conv, True)
# convolutional_net.add(SpatialDropout2D(0.5))
# convolutional_net.add(MaxPool2D(pool_size=(3, 3), strides=(3, 3)))
_add_convolutional_layer(convolutional_net, 128, (4, 4),
kernel_regularizer_conv, True)
# convolutional_net.add(SpatialDropout2D(0.5))
# convolutional_net.add(MaxPool2D())
_add_convolutional_layer(convolutional_net, 256, (4, 4),
kernel_regularizer_conv, False)
convolutional_net.add(Flatten())
convolutional_net.add(
Dense(units=4096,
activation='sigmoid',
kernel_initializer=RandomNormal(mean=0, stddev=0.01),
bias_initializer=RandomNormal(mean=0.5, stddev=0.01),
kernel_regularizer=l2(kernel_regularizer_dense)))
# convolutional_net.add(BatchNormalization())
return convolutional_net
def conv_2d(*args, **kwargs):
return Conv2D(
*args, **kwargs,
kernel_initializer=RandomNormal(0.0, 0.01),
bias_initializer=RandomNormal(0.5, 0.01),
kernel_regularizer=l2()
)
def construct_network2():
model = tf.keras.models.Sequential([
InputLayer(input_shape=(28, 28, 1)),
Conv2D(20,
3,
kernel_initializer=RandomNormal(0, 0.01),
padding="same",
activation="relu"),
BatchNormalization(),
MaxPool2D(pool_size=2, strides=2, padding="same"),
Conv2D(30,
3,
kernel_initializer=RandomNormal(0, 0.01),
padding="same",
activation="relu"),
BatchNormalization(),
MaxPool2D(pool_size=2, strides=2, padding="same"),
Conv2D(50,
3,
kernel_initializer=RandomNormal(0, 0.01),
padding="same",
activation="relu"),
BatchNormalization(),
MaxPool2D(pool_size=2, strides=2, padding="same"),
Flatten(),
Dense(10, kernel_initializer=RandomNormal(0, 0.01)),
])
model.compile(
optimizer=SGD(learning_rate=0.01, momentum=0.9),
loss=SparseCategoricalCrossentropy(from_logits=True),
metrics=["accuracy"],
)
model.summary()
return model
def __init__(self, filters, kernel_size):
super(ConvBlock, self).__init__()
self.filters = filters
self.kernel_size = kernel_size
self.stddev = _calc_initializer_stddev(filters, kernel_size)
self.conv1 = layers.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=1,
padding='same',
kernel_initializer=RandomNormal(stddev=self.stddev))
self.bn1 = layers.BatchNormalization()
self.relu1 = layers.ReLU()
self.conv2 = layers.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=1,
padding='same',
kernel_initializer=RandomNormal(stddev=self.stddev))
self.bn2 = layers.BatchNormalization()
self.relu2 = layers.ReLU()
self.dropout = layers.Dropout(0.2)
def __design_generator(self):
inputs = Input(shape=self.latent_features)
x = Dense(units=self.latent_features * 32,
kernel_initializer=RandomNormal(stddev=0.02))(inputs)
x = LeakyReLU(alpha=0.2)(x)
x = Reshape(target_shape=(self.latent_features, 32))(x)
x = Conv1DTranspose(filters=32,
kernel_size=4,
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02))(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv1DTranspose(filters=32,
kernel_size=4,
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02))(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv1DTranspose(filters=32,
kernel_size=4,
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=0.02))(x)
x = LeakyReLU(alpha=0.2)(x)
x = Flatten()(x)
outputs = Dense(units=self.features,
activation='tanh',
kernel_initializer=RandomNormal(stddev=0.02))(x)
model = Model(inputs=inputs, outputs=outputs)
return model
def KochNet(input_shape=(105, 105, 3)):
"""
The conv net used as backbone in
[Siamese Neural Networks for One-shot Image Recognition](https://www.cs.cmu.edu/~rsalakhu/papers/oneshot1.pdf)
"""
model = Sequential(name="koch_net")
model.add(Input(input_shape))
model.add(conv_2d(64, (10, 10)))
model.add(MaxPooling2D())
model.add(conv_2d(128, (7, 7), activation="relu"))
model.add(MaxPooling2D())
model.add(conv_2d(128, (4, 4), activation="relu"))
model.add(MaxPooling2D())
model.add(conv_2d(256, (4, 4), activation="relu"))
model.add(Flatten())
model.add(
Dense(
4096,
activation="sigmoid",
kernel_initializer=RandomNormal(0.0, 0.2),
bias_initializer=RandomNormal(0.5, 0.01),
))
return model
def create_generator():
size = 4
model = Sequential()
model.add(
Dense(units=size * size * 256,
kernel_initializer=RandomNormal(0, 0.02),
input_dim=noise_img_dim))
model.add(LeakyReLU(0.2))
model.add(Reshape(target_shape=(size, size, 256)))
model.add(
Conv2DTranspose(128, (4, 4),
strides=2,
padding="same",
kernel_initializer=RandomNormal(0, 0.02)))
model.add(LeakyReLU(0.2))
model.add(
Conv2DTranspose(128, (4, 4),
strides=2,
padding="same",
kernel_initializer=RandomNormal(0, 0.02)))
model.add(LeakyReLU(0.2))
model.add(
Conv2DTranspose(128, (4, 4),
strides=2,
padding="same",
kernel_initializer=RandomNormal(0, 0.02)))
model.add(LeakyReLU(0.2))
model.add(
Conv2D(channels, (3, 3),
padding="same",
kernel_initializer=RandomNormal(0, 0.02)))
model.add(Activation("tanh"))
model.compile(optimizer=optimizer, loss="binary_crossentropy")
return model
def _depthwise_conv_block(inputs,
pointwise_conv_filters,
alpha,
depth_multiplier=1,
strides=(1, 1),
block_id=1):
pointwise_conv_filters = int(pointwise_conv_filters * alpha)
# 深度可分离卷积
x = DepthwiseConv2D((3, 3),
padding='same',
depth_multiplier=depth_multiplier,
depthwise_initializer=RandomNormal(stddev=0.02),
strides=strides,
use_bias=False,
name='conv_dw_%d' % block_id)(inputs)
x = BatchNormalization(name='conv_dw_%d_bn' % block_id)(x)
x = Activation(relu6, name='conv_dw_%d_relu' % block_id)(x)
# 1x1卷积
x = Conv2D(pointwise_conv_filters, (1, 1),
kernel_initializer=RandomNormal(stddev=0.02),
padding='same',
use_bias=False,
strides=(1, 1),
name='conv_pw_%d' % block_id)(x)
x = BatchNormalization(name='conv_pw_%d_bn' % block_id)(x)
return Activation(relu6, name='conv_pw_%d_relu' % block_id)(x)
def create_embedding_dict(sparse_feature_columns,
varlen_sparse_feature_columns,
init_std,
seed,
l2_reg,
prefix='sparse_',
seq_mask_zero=True):
sparse_embedding = {
feat.embedding_name:
Embedding(feat.vocabulary_size,
feat.embedding_dim,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg),
name=prefix + '_emb_' + feat.embedding_name)
for feat in sparse_feature_columns
}
if varlen_sparse_feature_columns and len(
varlen_sparse_feature_columns) > 0:
for feat in varlen_sparse_feature_columns:
# if feat.name not in sparse_embedding:
sparse_embedding[feat.embedding_name] = Embedding(
feat.vocabulary_size,
feat.embedding_dim,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg),
name=prefix + '_seq_emb_' + feat.name,
mask_zero=seq_mask_zero)
return sparse_embedding
def create_model():
model = Sequential()
model.add(Conv2D(2, 3, activation = None,use_bias = False, \
input_shape = (28, 28, 1), padding = "valid", \
data_format='channels_last', dilation_rate = (1, 1), strides = (1, 1), \
kernel_initializer = RandomNormal(mean = 0.0, stddev = 0.05, seed = int(time()) ) \
))
model.add(ReLU(max_value=None, negative_slope=0, threshold=0))
model.add(Conv2D(4, 3, activation = None,use_bias = False, \
padding = "valid", \
data_format='channels_last', dilation_rate = (1, 1), strides = (1, 1), \
kernel_initializer = RandomNormal(mean = 0.0, stddev = 0.05, seed = int(time()) ) \
))
model.add(ReLU(max_value=None, negative_slope=0, threshold=0))
model.add(
MaxPooling2D((2, 2),
strides=(2, 2),
padding="valid",
data_format="channels_last"))
model.add(Conv2D(8, 3, activation = None,use_bias = False, \
input_shape = (28, 28, 1), padding = "valid", \
data_format='channels_last', dilation_rate = (1, 1), strides = (1, 1), \
kernel_initializer = RandomNormal(mean = 0.0, stddev = 0.05, seed = int(time()) ) \
))
model.add(ReLU(max_value=None, negative_slope=0, threshold=0))
model.add(Conv2D(16, 3, activation = None,use_bias = False, \
padding = "valid", \
data_format='channels_last', dilation_rate = (1, 1), strides = (1, 1), \
kernel_initializer = RandomNormal(mean = 0.0, stddev = 0.05, seed = int(time()) ) \
))
model.add(ReLU(max_value=None, negative_slope=0, threshold=0))
model.add(
MaxPooling2D((2, 2),
strides=(2, 2),
padding="valid",
data_format="channels_last"))
model.add(Flatten())
model.add(Dense(10, activation = None, use_bias = True, \
kernel_initializer = RandomNormal(mean = 0.0, stddev = 0.05, seed = int(time()) ) \
))
model.add(Softmax(axis=1))
optimizer = Adam(lr=0.0001)
model.compile(loss="categorical_crossentropy", \
optimizer=optimizer, metrics=["accuracy"])
return model
def generator_model():
"""
Create and return a discriminator model
:return: discriminator model
"""
Generator = Sequential(name='Generator')
# Fully Connected layer --> 512 activation maps of 2x2
Generator.add(
Dense(units=512 * 2 * 2,
input_shape=GENERATOR_INPUT,
kernel_initializer=RandomNormal(stddev=GAUSS_SD)))
Generator.add(Reshape((2, 2, 512)))
Generator.add(BatchNormalization(momentum=MOMENTUM))
Generator.add(LeakyReLU(ALPHA))
# Upsampling : 2x2x512 --> 4x4x256
Generator.add(
Conv2DTranspose(filters=256,
kernel_size=(5, 5),
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=GAUSS_SD)))
Generator.add(BatchNormalization(momentum=MOMENTUM))
Generator.add(LeakyReLU(ALPHA))
# Upsampling : 4x4x256 --> 8x8x128
Generator.add(
Conv2DTranspose(filters=256,
kernel_size=(5, 5),
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=GAUSS_SD)))
Generator.add(BatchNormalization(momentum=MOMENTUM))
Generator.add(LeakyReLU(ALPHA))
# Upsampling : 8x8x128 --> 16x16x64
Generator.add(
Conv2DTranspose(filters=128,
kernel_size=(5, 5),
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=GAUSS_SD)))
Generator.add(BatchNormalization(momentum=MOMENTUM))
Generator.add(LeakyReLU(ALPHA))
# Upsampling : 16x16x63 --> 32x32x3
Generator.add(
Conv2DTranspose(filters=3,
kernel_size=(5, 5),
strides=2,
padding='same',
kernel_initializer=RandomNormal(stddev=GAUSS_SD),
activation='tanh'))
return Generator
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id):
in_channels = backend.int_shape(inputs)[-1]
pointwise_conv_filters = int(filters * alpha)
pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
x = inputs
prefix = 'block_{}_'.format(block_id)
# part1 数据扩张
if block_id:
# Expand
x = Conv2D(expansion * in_channels,
kernel_initializer=RandomNormal(stddev=0.02),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + 'expand')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + 'expand_BN')(x)
x = Activation(relu6, name=prefix + 'expand_relu')(x)
else:
prefix = 'expanded_conv_'
if stride == 2:
x = ZeroPadding2D(padding=correct_pad(x, 3), name=prefix + 'pad')(x)
# part2 可分离卷积
x = DepthwiseConv2D(kernel_size=3,
depthwise_initializer=RandomNormal(stddev=0.02),
strides=stride,
activation=None,
use_bias=False,
padding='same' if stride == 1 else 'valid',
name=prefix + 'depthwise')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + 'depthwise_BN')(x)
x = Activation(relu6, name=prefix + 'depthwise_relu')(x)
# part3压缩特征，而且不使用relu函数，保证特征不被破坏
x = Conv2D(pointwise_filters,
kernel_initializer=RandomNormal(stddev=0.02),
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + 'project')(x)
x = BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + 'project_BN')(x)
if in_channels == pointwise_filters and stride == 1:
return Add(name=prefix + 'add')([inputs, x])
return x
def build(self, input_shape):
self.routing_logits = self.add_weight(shape=[1, self.k_max, self.max_len],
initializer=RandomNormal(stddev=self.init_std),
trainable=False, name="B", dtype=tf.float32)
self.bilinear_mapping_matrix = self.add_weight(shape=[self.input_units, self.out_units],
initializer=RandomNormal(stddev=self.init_std),
name="S", dtype=tf.float32)
super(CapsuleLayer, self).build(input_shape)
def __init__(self,
num_blocks,
num_classes,
num_depth=4,
num_features=256,
use_separable_conv=False,
expand_ratio=4.,
use_squeeze_excite=False,
squeeze_ratio=16.,
groups=16,
**kwargs):
self.num_blocks = num_blocks
self.num_classes = num_classes
self.num_depth = num_depth
self.num_features = num_features
self.use_separable_conv = use_separable_conv
self.expand_ratio = expand_ratio
self.use_squeeze_excite = use_squeeze_excite
self.squeeze_ratio = squeeze_ratio
self.groups = groups
super().__init__(**kwargs)
self.blocks = []
for idx in range(self.num_blocks):
block = []
for i in range(self.num_depth):
if self.use_squeeze_excite:
layer = SqueezeExcite(self.squeeze_ratio)
block.append(layer)
if self.use_separable_conv:
layer = MobileSeparableConv2D(num_features, (3, 3),
expand_ratio=expand_ratio)
else:
layer = Conv2D(
num_features, (3, 3),
activation='relu',
padding='same',
kernel_initializer=RandomNormal(stddev=0.01))
block.append(layer)
layer = GroupNormalization(self.groups)
block.append(layer)
layer = Conv2DTranspose(
num_features, (2, 2), (2, 2),
padding='same',
activation='relu',
kernel_initializer=RandomNormal(stddev=0.01))
block.append(layer)
layer = Conv2D(num_classes, (1, 1),
padding='same',
activation='sigmoid',
kernel_initializer=RandomNormal(stddev=0.01))
block.append(layer)
self.blocks.append(block)
def __init__(self,
C,
layers,
steps=4,
multiplier=4,
stem_multiplier=3,
drop_path=0,
num_classes=10):
super().__init__()
self._C = C
self._steps = steps
self._multiplier = multiplier
self._drop_path = drop_path
C_curr = stem_multiplier * C
self.stem = Sequential([
Conv2d(3, C_curr, 3, bias=False),
Norm(C_curr, 'def', affine=True),
])
C_prev_prev, C_prev, C_curr = C_curr, C_curr, C
self.cells = []
reduction_prev = False
for i in range(layers):
if i in [layers // 3, 2 * layers // 3]:
C_curr *= 2
reduction = True
else:
reduction = False
cell = Cell(steps, multiplier, C_prev_prev, C_prev, C_curr,
reduction, reduction_prev, drop_path)
reduction_prev = reduction
self.cells.append(cell)
C_prev_prev, C_prev = C_prev, multiplier * C_curr
self.avg_pool = GlobalAvgPool()
self.classifier = Linear(C_prev, num_classes)
k = sum(2 + i for i in range(self._steps))
num_ops = len(get_primitives())
self.alphas_normal = self.add_weight(
'alphas_normal', (k, num_ops),
initializer=RandomNormal(stddev=1e-2),
trainable=True,
experimental_autocast=False)
self.alphas_reduce = self.add_weight(
'alphas_reduce', (k, num_ops),
initializer=RandomNormal(stddev=1e-2),
trainable=True,
experimental_autocast=False)
self.tau = self.add_weight('tau', (),
initializer=Constant(1.0),
trainable=False,
experimental_autocast=False)
def create_embedding_dict(
feature_dim_dict,
embedding_size,
init_std,
seed,
l2_rev_V,
l2_reg_w,
):
sparse_embedding = {
j.name: {
feat.name:
Embedding(j.dimension,
embedding_size,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=0.0001,
seed=seed),
embeddings_regularizer=l2(l2_rev_V),
name='sparse_emb_' + str(j.name) + '_' + str(i) + '-' +
feat.name)
for i, feat in enumerate(feature_dim_dict["sparse"] +
feature_dim_dict['dense'])
}
for j in feature_dim_dict["sparse"]
}
dense_embedding = {
j.name: {
feat.name: Dense(embedding_size,
kernel_initializer=RandomNormal(mean=0.0,
stddev=0.0001,
seed=seed),
use_bias=False,
kernel_regularizer=l2(l2_rev_V),
name='sparse_emb_' + str(j.name) + '_' + str(i) +
'-' + feat.name)
for i, feat in enumerate(feature_dim_dict["sparse"] +
feature_dim_dict["dense"])
}
for j in feature_dim_dict["dense"]
}
linear_embedding = {
feat.name:
Embedding(feat.dimension,
1,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg_w),
name='linear_emb_' + str(i) + '-' + feat.name)
for i, feat in enumerate(feature_dim_dict["sparse"])
}
return sparse_embedding, dense_embedding, linear_embedding
def build_generator(input_shape=(256, 256, 3), num_blocks=9):
"""Generator network architecture"""
x0 = layers.Input(input_shape)
x = ReflectionPadding2D(padding=(3, 3))(x0)
x = layers.Conv2D(filters=64, kernel_size=7, strides=1, kernel_initializer=RandomNormal(mean=0, stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.ReLU()(x)
# downsample
x = layers.Conv2D(filters=128,
kernel_size=3,
strides=2,
padding='same',
kernel_initializer=RandomNormal(mean=0, stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(filters=256,
kernel_size=3,
strides=2,
padding='same',
kernel_initializer=RandomNormal(mean=0, stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.ReLU()(x)
# residual
for _ in range(num_blocks):
x = _resblock(x)
# upsample
x = layers.Conv2DTranspose(filters=128,
kernel_size=3,
strides=2,
padding='same',
kernel_initializer=RandomNormal(mean=0, stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2DTranspose(filters=64,
kernel_size=3,
strides=2,
padding='same',
kernel_initializer=RandomNormal(mean=0, stddev=0.02))(x)
x = InstanceNormalization()(x)
x = layers.ReLU()(x)
# final
x = ReflectionPadding2D(padding=(3, 3))(x)
x = layers.Conv2D(filters=3, kernel_size=7, activation='tanh', kernel_initializer=RandomNormal(mean=0,
stddev=0.02))(x)
return Model(inputs=x0, outputs=x)
def residual_block(feature, dropout=False):
x = Conv2D(256, kernel_size=3, strides=1, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(feature)
x = BatchNormalization()(x)
x = Activation('relu')(x)
if dropout:
x = Dropout(0.5)(x)
x = Conv2D(256, kernel_size=3, strides=1, padding='same', kernel_initializer=RandomNormal(
mean=0.0, stddev=0.02), bias_initializer=Zeros())(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
return Add()([feature, x])
def wcrn(band, ncla1):
input1 = Input(shape=(5, 5, band))
# define network
conv0x = Conv2D(64,
kernel_size=(1, 1),
padding='valid',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01))
conv0 = Conv2D(64,
kernel_size=(3, 3),
padding='valid',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01))
bn11 = BatchNormalization(axis=-1,
momentum=0.9,
epsilon=0.001,
center=True,
scale=True,
beta_initializer='zeros',
gamma_initializer='ones',
moving_mean_initializer='zeros',
moving_variance_initializer='ones')
conv11 = Conv2D(128,
kernel_size=(1, 1),
padding='same',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01))
conv12 = Conv2D(128,
kernel_size=(1, 1),
padding='same',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01))
#
fc1 = Dense(ncla1,
activation='softmax',
name='output1',
kernel_initializer=RandomNormal(mean=0.0, stddev=0.01))
# x1
x1 = conv0(input1)
x1x = conv0x(input1)
x1 = MaxPooling2D(pool_size=(3, 3))(x1)
x1x = MaxPooling2D(pool_size=(5, 5))(x1x)
x1 = concatenate([x1, x1x], axis=-1)
x11 = bn11(x1)
x11 = Activation('relu')(x11)
x11 = conv11(x11)
x11 = Activation('relu')(x11)
x11 = conv12(x11)
x1 = Add()([x1, x11])
x1 = Flatten()(x1)
pre1 = fc1(x1)
model1 = Model(inputs=input1, outputs=pre1)
return model1
def centernet_head(x, num_classes):
x = Dropout(rate=0.5)(x)
#-------------------------------#
# 解码器
#-------------------------------#
num_filters = 256
# 16, 16, 2048 -> 32, 32, 256 -> 64, 64, 128 -> 128, 128, 64
for i in range(3):
# 进行上采样
x = Conv2DTranspose(num_filters // pow(2, i), (4, 4),
strides=2,
use_bias=False,
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=l2(5e-4))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# 最终获得128,128,64的特征层
# hm header
y1 = Conv2D(64,
3,
padding='same',
use_bias=False,
kernel_initializer=RandomNormal(stddev=0.02))(x)
y1 = BatchNormalization()(y1)
y1 = Activation('relu')(y1)
y1 = Conv2D(num_classes,
1,
kernel_initializer=Constant(0),
bias_initializer=Constant(-2.19),
activation='sigmoid')(y1)
# wh header
y2 = Conv2D(64,
3,
padding='same',
use_bias=False,
kernel_initializer=RandomNormal(stddev=0.02))(x)
y2 = BatchNormalization()(y2)
y2 = Activation('relu')(y2)
y2 = Conv2D(2, 1, kernel_initializer=RandomNormal(stddev=0.02))(y2)
# reg header
y3 = Conv2D(64,
3,
padding='same',
use_bias=False,
kernel_initializer=RandomNormal(stddev=0.02))(x)
y3 = BatchNormalization()(y3)
y3 = Activation('relu')(y3)
y3 = Conv2D(2, 1, kernel_initializer=RandomNormal(stddev=0.02))(y3)
return y1, y2, y3
