def squeeze_and_excitation(inputs, reduction_ratio=4):
"""
paper：Squeeze-and-Excitation Networks
在特征信息中，通道之间存在依赖关系，通过senet可以显示地去表示
这些通道之间的依赖关系。采用神经网络学习每个通道的weights，
重要的通道给予大的weights，不重要的通道给予小的weights。
Args:
inputs: features
reduction_ratio: the reduction ratio
Returns: y: scale (1, 1, C)
"""
channels = inputs.shape[-1]
c_reduce = (channels // reduction_ratio)
# (batch, c)
y = layers.GlobalMaxPool2D()(inputs)
# (batch, c/r)
y = layers.Dense(c_reduce)(y)
y = layers.ReLU()(y)
# (batch, c)
y = layers.Dense(channels)(y)
y = keras.activations.sigmoid(y)
y = layers.Reshape(target_shape=(1, 1, -1))(y)
return y
def encoder_simple_res(observation_space):
inputs = keras.Input(observation_space['obs'].shape, name='obs')
x = layers.Conv2D(32,
3,
padding='same',
activation='relu',
name='encoder_conv1')(inputs)
x = res_block(x, 2, name='encoder_resblock1')
x = layers.Conv2D(64,
3,
padding='same',
strides=2,
activation='relu',
name='encoder_bottleneck1')(x)
x = res_block(x, 2, name='encoder_resblock2')
x = layers.Conv2D(128,
3,
padding='same',
strides=2,
activation='relu',
name='encoder_bottleneck2')(x)
x = res_block(x, 2, name='encoder_resblock3')
x = layers.Conv2D(256,
3,
padding='same',
strides=2,
name='encoder_bottleneck3')(x)
outputs = layers.GlobalMaxPool2D(name='encoder_pool', dtype='float32')(x)
return outputs, [inputs]
def __init__(self, num_classes, initial_filters=16, **kwargs):
super(ResNet, self).__init__(**kwargs)
self.stem = layers.Conv2D(initial_filters,
3,
strides=3,
padding='valid')
# 一共包含8个ResnetBlock模块,16+ 根连接的1层 + 输出的1层。
# 就是分成了4组，每组的第一个完成了高和宽的降维；第二个Strides=1就是维度保持不变。
self.blocks = keras.models.Sequential([
ResnetBlock(initial_filters * 2, strides=3),
ResnetBlock(initial_filters * 2, strides=1),
# layers.Dropout(rate=0.5),
ResnetBlock(initial_filters * 4, strides=3),
ResnetBlock(initial_filters * 4, strides=1),
ResnetBlock(initial_filters * 8, strides=2),
ResnetBlock(initial_filters * 8, strides=1),
ResnetBlock(initial_filters * 16, strides=2),
ResnetBlock(initial_filters * 16, strides=1),
])
self.final_bn = layers.BatchNormalization()
self.avg_pool = layers.GlobalMaxPool2D()
self.fc = layers.Dense(num_classes) # 全连接层
def small_resnet():
'''
小型残差网络
'''
inputs = keras.Input(shape=(28,28,1), name='img')
h1 = layers.Conv2D(32, 3, activation='relu')(inputs)
h1 = layers.Conv2D(64, 3, activation='relu')(h1)
block1_out = layers.MaxPooling2D(3)(h1)
h2 = layers.Conv2D(64, 3, activation='relu', padding='same')(block1_out)
h2 = layers.Conv2D(64, 3, activation='relu', padding='same')(h2)
block2_out = layers.add([h2, block1_out])
h3 = layers.Conv2D(64, 3, activation='relu', padding='same')(block2_out)
h3 = layers.Conv2D(64, 3, activation='relu', padding='same')(h3)
block3_out = layers.add([h3, block2_out])
h4 = layers.Conv2D(64, 3, activation='relu')(block3_out)
h4 = layers.GlobalMaxPool2D()(h4)
h4 = layers.Dense(256, activation='relu')(h4)
h4 = layers.Dropout(0.5)(h4)
outputs = layers.Dense(10, activation='softmax')(h4)
model = keras.Model(inputs, outputs, name='small resnet')
model.summary()
keras.utils.plot_model(model, 'small_resnet_model.png', show_shapes=True)
return model
def build_res_net():
inputs = keras.Input(shape=(32,32,3), name='img')
h1 = layers.Conv2D(32, 3, activation='relu')(inputs)
h1 = layers.Conv2D(64, 3, activation='relu')(h1)
block1_out = layers.MaxPooling2D(3)(h1)
h2 = layers.Conv2D(64, 3, activation='relu', padding='same')(block1_out)
h2 = layers.Conv2D(64, 3, activation='relu', padding='same')(h2)
block2_out = layers.add([h2, block1_out])
h3 = layers.Conv2D(64, 3, activation='relu', padding='same')(block2_out)
h3 = layers.Conv2D(64, 3, activation='relu', padding='same')(h3)
block3_out = layers.add([h3, block2_out])
h4 = layers.Conv2D(64, 3, activation='relu')(block3_out)
h4 = layers.GlobalMaxPool2D()(h4)
h4 = layers.Dense(256, activation='relu')(h4)
h4 = layers.Dropout(0.5)(h4)
outputs = layers.Dense(10, activation='softmax')(h4)
model = keras.Model(inputs, outputs, name='small resnet')
model.summary()
keras.utils.plot_model(model, 'small_resnet_model.png', show_shapes=True)
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
x_train = x_train.astype('float32') / 255
x_test = y_train.astype('float32') / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
model.compile(optimizer=keras.optimizers.RMSprop(1e-3), loss='categorical_crossentropy', metrics=['acc'])
model.fit(x_train, y_train, batch_size=64, epochs=1, validation_split=0.2)
def build_tensorflow_cnn_classifier(input_shape=(None, None, 3),
n_class=3,
classifier_activation='softmax'):
inputs = tf.keras.Input(shape=input_shape)
x = cnn_block(inputs,
8,
kernel_size=3,
stride=3,
name='block1',
conv_shortcut=True)
x = cnn_block(x,
16,
kernel_size=3,
stride=2,
name='block2',
conv_shortcut=True)
x = cnn_block(x,
32,
kernel_size=3,
stride=2,
name='block3',
conv_shortcut=True)
x = layers.GlobalMaxPool2D()(x)
outputs = layers.Dense(n_class,
activation=classifier_activation,
name='predictions')(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs, name="test_model")
return model
def make_model(self):
if self.mode == 'train':
dataset = imitation_dataset()
obs_input, action_gt = dataset.get_next()
obs_input = Input(tensor=obs_input)
elif self.mode == 'eval':
obs_input = Input(shape=[84, 84, 4])
obs_feature = layers.Conv2D(32, 8, 4, padding='same', activation='relu')(obs_input) # 21
obs_feature = layers.Conv2D(64, 4, 2, padding='same', activation='relu')(obs_feature) # 11
obs_feature = layers.Conv2D(128, 3, 2, padding='same', activation='relu')(obs_feature) # 6
obs_feature = layers.Conv2D(256, 3, 2, padding='same', activation='relu')(obs_feature) # 3
obs_feature = layers.GlobalMaxPool2D()(obs_feature)
obs_feature = layers.Flatten()(obs_feature)
obs_feature = layers.Dense(128, activation='relu')(obs_feature)
action_out = layers.Dense(action_space, activation='softmax')(obs_feature)
model = tf.keras.Model(inputs=[obs_input], outputs=[action_out])
if self.mode == 'train':
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'],
target_tensors=[action_gt]
)
else:
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
return model
def __init__(self):
super().__init__()
self.conv1 = layers.Conv2D(32, 3, padding='same', activation='relu')
self.conv2 = layers.Conv2D(64, 3, padding='same', activation='relu')
self.conv3 = layers.Conv2D(128, 3, padding='same', activation='relu')
self.maxpool = layers.MaxPool2D(strides=2)
self.globalpool = layers.GlobalMaxPool2D()
def tensorboard_test():
# 定义自适应学习率函数(自定义参数)
def lr_sche(epoch):
learning_rate=0.2
if epoch>5:
learning_rate=0.02
if epoch>10:
learning_rate = 0.01
if epoch>20:
learning_rate = 0.005
# 记录自定义变量
tf.summary.scalar('learning_rate',data=learning_rate,step=epoch)
return learning_rate
# 加载数据集
(train_image, train_labels), (test_image, test_labels) = tf.keras.datasets.mnist.load_data()
# 扩充维度，转换数据类型，归一化
train_image = tf.expand_dims(train_image, -1)
# train_labels=tf.expand_dims(train_labels, -1) #标签项无需修改
train_image = tf.cast(train_image / 255, tf.float32)
train_labels = tf.cast(train_labels, tf.int64)
# 将数据转化为 tensor
ds = tf.data.Dataset.from_tensor_slices((train_image, train_labels))
ds = ds.repeat().shuffle(1000).batch(128)
# 测试数据
# 扩充维度，转换数据类型，归一化
test_image = tf.expand_dims(test_image, -1)
# train_labels=tf.expand_dims(train_labels, -1) #标签项无需修改
test_image = tf.cast(test_image / 255, tf.float32)
test_labels = tf.cast(test_labels, tf.int64)
# 将数据转化为 tensor
test_ds = tf.data.Dataset.from_tensor_slices((test_image, test_labels))
# 数据乱序 分batch
test_ds = test_ds.batch(128)
# 构建模型
model=tf.keras.Sequential()
model.add(layers.Conv2D(16,[3,3],activation='relu',input_shape=(28,28,1)))
model.add(layers.Conv2D(32,[3,3],activation='relu'))
model.add(layers.GlobalMaxPool2D())
model.add(layers.Dense(10,activation='softmax'))
model.compile(optimizer=tf.optimizers.Adam(),loss=tf.losses.SparseCategoricalCrossentropy(),metrics=['accuracy'])
log_dir_str = 'log/'+datetime.datetime.now().strftime('%y%m%d-%H%M%S')
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir_str,histogram_freq=1)
lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_sche)
file_writer = tf.summary.create_file_writer(log_dir_str+'/lr') #实例化文件编写器
file_writer.set_as_default() # 设置为默认文件编写器
model.fit(ds,validation_data=test_ds,
epochs=10,steps_per_epoch=len(train_image)//128,
validation_steps=len(test_image)//128,
callbacks=[tensorboard_callback,lr_callback])
def _buildCameraModel(self): imgInput = keras.Input(shape=(self._imgReshapeWithDepth), name='img_input') x = layers.BatchNormalization()(imgInput) x = layers.Conv2D(16, (3,3),activation="relu", name="input_Conv")(x) x = layers.BatchNormalization()(x) x = layers.GlobalMaxPool2D(name="camera_maxPool_output")(x) x = layers.BatchNormalization()(x) return (imgInput,x)
def __init__(self, dim):
super(_MP, self).__init__()
if dim == 1:
self.pool = layers.GlobalMaxPool1D()
elif dim == 2:
self.pool = layers.GlobalMaxPool2D()
elif dim == 3:
self.pool = layers.GlobalMaxPool3D()
def __init__(self):
super().__init__()
self.conv = layers.Conv2D(128,1)
self.bn1 = layers.BatchNormalization()
self.flatten = layers.Flatten()
self.globalmaxpool = layers.GlobalMaxPool2D()
self.globalavgpool = layers.GlobalAveragePooling2D()
self.fc = layers.Dense(128)
def ConvLSTM(in_shape, name):
inputs = layers.Input(in_shape)
x = layers.ConvLSTM2D(filters=8, kernel_size=4, strides=4)(inputs)
x = layers.BatchNormalization()(x)
x = layers.GlobalMaxPool2D(name='global_average_pooling')(
x
) # Global Average Pooling act as dropout; so no need to add a dropout layers after
return tf.keras.Model(inputs, x, name=name)
def __init__(self, data_format="channels_last", **kwargs):
super(GlobalAvgMaxPool2D, self).__init__(**kwargs)
self.axis = get_channel_axis(data_format)
self.avg_pool = nn.GlobalAvgPool2D(data_format=data_format,
name="avg_pool")
self.max_pool = nn.GlobalMaxPool2D(data_format=data_format,
name="max_pool")
def ResNetHead():
channels = None # Do not pad input with channels
input_shape = (8, 9, 2048)
model = keras.models.Sequential([
layers.GlobalMaxPool2D(input_shape=input_shape),
layers.Dense(1024),
layers.Dense(len(birdcodes.bird_code), activation="sigmoid"),
])
return model, input_shape, channels
def ResUnet50(input_shape=(512, 512, 3), num_classes=200):
"""Network Architecture"""
inputs = layers.Input(shape=input_shape)
resnet50 = tf.keras.applications.ResNet50(weights='imagenet',
include_top=False,
pooling=None,
input_tensor=inputs)
assert resnet50.layers[4].name == "conv1_relu"
C1 = resnet50.layers[4].output # 256 x 256 x 64
assert resnet50.layers[38].name == "conv2_block3_out"
C2 = resnet50.layers[38].output # 128 x 128 x 256
assert resnet50.layers[80].name == "conv3_block4_out"
C3 = resnet50.layers[80].output # 64 x 64 x 512
assert resnet50.layers[142].name == "conv4_block6_out"
C4 = resnet50.layers[142].output # 32 x 32 x 1024
assert resnet50.layers[-1].name == "conv5_block3_out"
C5 = resnet50.layers[-1].output # 16 x 16 x 2048
# classification subnet
label = layers.GlobalMaxPool2D()(C5)
label = layers.Flatten()(label)
label = layers.Dense(num_classes, activation='softmax')(label)
# segmentation subnet
conv_config = {
'activation': 'relu',
'padding': 'same',
'kernel_initializer': 'he_normal'
}
up6 = layers.Conv2D(512, 3, **conv_config)(
layers.UpSampling2D(size=(2, 2))(C5)) # 32 x 32 x 512
merge6 = layers.concatenate([C4, up6], axis=3) # 32 x 32 x 1536
conv6 = layers.Conv2D(512, 3, **conv_config)(merge6) # 32 x 32 x 512
conv6 = layers.Conv2D(512, 3, **conv_config)(conv6) # 32 x 32 x 512
up7 = layers.Conv2D(256, 3, **conv_config)(
layers.UpSampling2D(size=(2, 2))(conv6)) # 64 x 64 x 256
merge7 = layers.concatenate([C3, up7], axis=3) # 64 x 64 x 768
conv7 = layers.Conv2D(256, 3, **conv_config)(merge7) # 64 x 64 x 256
conv7 = layers.Conv2D(256, 3, **conv_config)(conv7) # 64 x 64 x 256
up8 = layers.Conv2D(128, 3, **conv_config)(
layers.UpSampling2D(size=(2, 2))(conv7)) # 128 x 128 x 128
merge8 = layers.concatenate([C2, up8], axis=3) # 128 x 128 x 384
conv8 = layers.Conv2D(128, 3, **conv_config)(merge8) # 128 x 128 x 128
conv8 = layers.Conv2D(128, 3, **conv_config)(conv8) # 128 x 128 x 128
up9 = layers.Conv2D(64, 3, **conv_config)(
layers.UpSampling2D(size=(2, 2))(conv8)) # 256 x 256 x 64
merge9 = layers.concatenate([C1, up9], axis=3) # 256 x 256 x 128
conv9 = layers.Conv2D(64, 3, **conv_config)(merge9) # 256 x 256 x 64
conv9 = layers.Conv2D(64, 3, **conv_config)(conv9) # 256 x 256 x 64
up10 = layers.Conv2D(2, 3, **conv_config)(
layers.UpSampling2D(size=(2, 2))(conv9)) # 512 x 512 x 2
mask = layers.Conv2D(1, 1, activation='sigmoid')(up10)
model = tf.keras.Model(inputs=inputs, outputs=[label, mask])
return model
def build(self, input_shape):
# Build MLP layer
for mlp_setting in self.mlp:
self.mlp_list.append(MLP(**mlp_setting))
# Build pooling layer
if self.pooling == 'max':
self.pooling_layer = layers.GlobalMaxPool2D(
data_format=self.data_format)
else:
self.pooling_layer = layers.GlobalAveragePooling2D(
data_format=self.data_format)
# Build dense layer
for dense_setting, batch_norm_setting in zip(self.dense,
self.batch_norm):
self.dense_list.append(layers.Dense(**dense_setting))
if batch_norm_setting is not None:
self.batch_norm_list.append(
layers.BatchNormalization(**batch_norm_setting))
else:
self.batch_norm_list.append(None)
# Add weights
if self.dense:
shape = (self.dense[-1]['units'],
input_shape[self.chan_axis] * input_shape[self.chan_axis])
elif self.mlp:
shape = (self.mlp[-1]['filters'],
input_shape[self.chan_axis] * input_shape[self.chan_axis])
else:
shape = (input_shape[self.chan_axis],
input_shape[self.chan_axis] * input_shape[self.chan_axis])
self.w = self.add_weight(name='w',
shape=shape,
initializer='zeros',
trainable=True)
self.b = self.add_weight(name='b',
shape=(input_shape[self.chan_axis],
input_shape[self.chan_axis]),
initializer='identity',
trainable=True)
# Build reshape layer
self.reshape = layers.Reshape(
target_shape=(input_shape[self.chan_axis],
input_shape[self.chan_axis]))
# Call build function of the keras base layer
super(FeatureTransformNet, self).build(input_shape)
def ResNet9(input_size=(32, 32, 3), head_len=128, classes=10):
"""A small 9-layer ResNet Tensorflow model for cifar10 image classification.
The model architecture is from https://github.com/davidcpage/cifar10-fast
Args:
input_size: The size of the input tensor (height, width, channels).
classes: The number of outputs the model should generate.
Raises:
ValueError: Length of `input_size` is not 3.
ValueError: `input_size`[0] or `input_size`[1] is not a multiple of 16.
Returns:
A TensorFlow ResNet9 model.
"""
# prep layers
inp = layers.Input(shape=input_size)
x = layers.Conv2D(64, 3, padding='same')(inp)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer1
x = layers.Conv2D(128, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 128)])
# layer2
x = layers.Conv2D(256, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer3
x = layers.Conv2D(512, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 512)])
# layers4
x = layers.GlobalMaxPool2D()(x)
code = layers.Flatten()(x)
p_head = layers.Dense(head_len)(code)
model_con = tf.keras.Model(inputs=inp, outputs=p_head)
s_head = layers.Dense(classes)(code)
s_head = layers.Activation('softmax', dtype='float32')(s_head)
model_finetune = tf.keras.Model(inputs=inp, outputs=s_head)
return model_con, model_finetune
def ResNet(weights="imagenet"):
"""
Resnet model
:param weights: None or "imagenet" pretraining
:return:
"""
channels = 3
input_shape = spectrogram_dim + (3, )
model = keras.models.Sequential([
ResNet50(input_shape=input_shape, include_top=False, weights=weights),
layers.GlobalMaxPool2D(input_shape=(8, 9, 2048)),
layers.Dense(1024, activation="relu"),
layers.Dense(len(birdcodes.bird_code), activation="sigmoid"),
])
return model, input_shape, channels
def build(self, input_shape):
# Build split layer (split input in point coordinates and point features)
if self.data_format == 'channels_last':
self.lambda1 = layers.Lambda(lambda x: x[:, :, 0:3])
self.lambda2 = layers.Lambda(lambda x: x[:, :, 3:])
elif self.data_format == 'channels_first':
self.lambda1 = layers.Lambda(lambda x: x[:, 0:3, :])
self.lambda2 = layers.Lambda(lambda x: x[:, 3:, :])
# Build permutation (transponation) layer
if self.data_format == 'channels_first':
self.permut = layers.Permute(dims=(2, 1))
# Build input transformation layer
self.input_trans_net = InputTransformNet(**self.input_trans)
# Build concatenation layer
self.concat = layers.Concatenate(axis=self.chan_axis)
# Set kernel size of the first mlp layer
if self.data_format == 'channels_last':
self.mlp[0].update(
{'kernel_size': [1, input_shape[self.chan_axis]]})
else:
self.mlp[0].update(
{'kernel_size': [input_shape[self.chan_axis], 1]})
# Build first MLP layer
for mlp_setting in self.mlp:
self.mlp_list.append(MLP(**mlp_setting))
# Build feature transformation layer
self.feat_trans_net = FeatureTransformNet(**self.feature_trans)
# Build second MLP layer
for mlp_setting in self.mlp2:
self.mlp2_list.append(MLP(**mlp_setting))
# Build pooling layer
if self.pooling == 'max':
self.pooling_layer = layers.GlobalMaxPool2D(
data_format=self.data_format)
else:
self.pooling_layer = layers.GlobalAveragePooling2D(
data_format=self.data_format)
# Call build function of the keras base layer
super(Encoder, self).build(input_shape)
def __init__(self, in_height):
super(Embedder, self).__init__()
self.relu = layers.LeakyReLU()
# in 6*224*224
# self.pad = Padding(in_height) # out 256*256*6
self.resDown1 = ResBlockDown(6, 64) # out 128*128*64
self.resDown2 = ResBlockDown(64, 128) # out 64*64*128
self.resDown3 = ResBlockDown(128, 256) # out 32*32*256
self.self_att = SelfAttention(256) # out 32*32*256
self.resDown4 = ResBlockDown(256, 512) # out 16*16*512
self.resDown5 = ResBlockDown(512, 512) # out 8*8*512
self.resDown6 = ResBlockDown(512, 512) # out 4*4*512
# self.sum_pooling = nn.AdaptiveMaxPool2d((1, 1)) # out 1*1*512
self.sum_pooling = layers.GlobalMaxPool2D()
def __init__(self,
channels,
reduction_ratio=16,
data_format="channels_last",
**kwargs):
super(ChannelGate, self).__init__(**kwargs)
self.data_format = data_format
self.avg_pool = nn.GlobalAvgPool2D(data_format=data_format,
name="avg_pool")
self.max_pool = nn.GlobalMaxPool2D(data_format=data_format,
name="max_pool")
self.mlp = MLP(channels=channels,
reduction_ratio=reduction_ratio,
data_format=data_format,
name="mlp")
self.sigmoid = tf.nn.sigmoid
def __init__(self,
vocab_size: int,
embed_dim: int,
hidden_size: int = 128,
training: bool = False):
super(MyAdvancedModel, self).__init__()
### TODO(Students) START
# ...
self.num_classes = len(ID_TO_CLASS)
self.decoder = layers.Dense(units=self.num_classes,
activation="softmax")
self.omegas = tf.Variable(tf.random.normal((hidden_size * 2, 1)))
self.embeddings = tf.Variable(tf.random.normal(
(vocab_size, embed_dim)))
### TODO(Students) START
# ...
self.vocab_size = vocab_size
self.embed_dim = embed_dim
self.hidden_size = hidden_size
self.conv_layer = layers.Conv1D(filters=128,
kernel_size=3,
padding="same",
strides=1,
activation="relu",
data_format="channels_last",
input_shape=(None, None, 1))
self.conv2d_layer = layers.Conv2D(filters=64,
kernel_size=3,
padding="same",
activation="relu",
data_format="channels_last",
input_shape=(None, None, 1))
self.maxpool_layer = layers.GlobalMaxPool1D()
self.maxpool2d_layer = layers.GlobalMaxPool2D()
self.flatten_layer = layers.Flatten()
self.training = training
self.dropout = layers.Dropout(0.4)
def plotModel():
encode_input = keras.Input(shape=(28, 28, 1), name='src_img')
h1 = layers.Conv2D(16, 3, activation='relu')(encode_input)
h1 = layers.Conv2D(32, 3, activation='relu')(h1)
h1 = layers.MaxPool2D(3)(h1)
h1 = layers.Conv2D(32, 3, activation='relu')(h1)
h1 = layers.Conv2D(16, 3, activation='relu')(h1)
encode_output = layers.GlobalMaxPool2D()(h1)
encode_model = keras.Model(inputs=encode_input,
outputs=encode_output,
name='encoder')
encode_model.summary()
decode_input = keras.Input(shape=(16, ), name='encoded_img')
h2 = layers.Reshape((4, 4, 1))(decode_input)
h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2)
h2 = layers.Conv2DTranspose(32, 3, activation='relu')(h2)
h2 = layers.UpSampling2D(3)(h2)
h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2)
decode_output = layers.Conv2DTranspose(1, 3, activation='relu')(h2)
decode_model = keras.Model(inputs=decode_input,
outputs=decode_output,
name='decoder')
decode_model.summary()
autoencoder_input = keras.Input(shape=(28, 28, 1), name='img')
h3 = encode_model(autoencoder_input)
autoencoder_output = decode_model(h3)
autoencoder = keras.Model(inputs=autoencoder_input,
outputs=autoencoder_output,
name='autoencoder')
autoencoder.summary()
keras.utils.plot_model(
autoencoder,
r'C:\\Users\\mih\\Desktop\\NN_Graph\\autoencoder_model.png')
keras.utils.plot_model(
autoencoder,
r'C:\\Users\\mih\\Desktop\\NN_Graph\\autoencoder_info.png',
show_shapes=True)
autoencoder.fit()
def build_shared_net():
encode_input = keras.Input(shape=(28,28,1), name='img')
h1 = layers.Conv2D(16, 3, activation='relu')(encode_input)
h1 = layers.Conv2D(32, 3, activation='relu')(h1)
h1 = layers.MaxPool2D(3)(h1)
h1 = layers.Conv2D(32, 3, activation='relu')(h1)
h1 = layers.Conv2D(16, 3, activation='relu')(h1)
encode_output = layers.GlobalMaxPool2D()(h1)
encode_model = keras.Model(inputs=encode_input, outputs=encode_output, name='encoder')
encode_model.summary()
h2 = layers.Reshape((4, 4, 1))(encode_output)
h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2)
h2 = layers.Conv2DTranspose(32, 3, activation='relu')(h2)
h2 = layers.UpSampling2D(3)(h2)
h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2)
decode_output = layers.Conv2DTranspose(1, 3, activation='relu')(h2)
autoencoder = keras.Model(inputs=encode_input, outputs=decode_output, name='autoencoder')
autoencoder.summary()
def MolMapResNet(input_shape,
num_resnet_blocks=8,
n_outputs=1,
dense_layers=[128, 32],
dense_avf='relu',
last_avf=None):
"""
parameters
----------------------
molmap_shape: w, h, c
num_resnet_blocks: int
n_outputs: output units
dense_layers: list, how many dense layers and units
dense_avf: activation function for dense layers
last_avf: activation function for last layer
"""
tf.keras.backend.clear_session()
inputs = tf.keras.Input(input_shape) #input_shape = (24, 24, 3)
# x = layers.Conv2D(32, 11, activation='relu')(inputs)
# x = layers.Conv2D(64, 3, activation='relu')(x)
# x = layers.MaxPooling2D(3)(x)
x = Conv2D(64, 13, padding='same', activation='relu', strides=1)(inputs)
x = MaxPool2D(pool_size=3, strides=2, padding='same')(x) #p1
## renet block
for i in range(num_resnet_blocks):
x = resnet_block(x, 64, 3)
x = layers.Conv2D(256, 3, activation='relu')(x)
x = layers.GlobalMaxPool2D()(x)
## dense layer
for units in dense_layers:
x = layers.Dense(units, activation=dense_avf)(x)
#last layer
outputs = Dense(n_outputs, activation=last_avf)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
return model
def __init__(self, num_classes, initial_filters=16, **kwargs):
super(ResNet, self).__init__(**kwargs)
self.stem = layers.Conv2D(initial_filters,
3,
strides=3,
padding='valid')
self.blocks = keras.models.Sequential([
ResnetBlock(initial_filters * 2, strides=3),
ResnetBlock(initial_filters * 2, strides=1),
# layers.Dropout(rate=0.5),
ResnetBlock(initial_filters * 4, strides=3),
ResnetBlock(initial_filters * 4, strides=1),
ResnetBlock(initial_filters * 8, strides=2),
ResnetBlock(initial_filters * 8, strides=1),
ResnetBlock(initial_filters * 16, strides=2),
ResnetBlock(initial_filters * 16, strides=1),
])
self.final_bn = layers.BatchNormalization()
self.avg_pool = layers.GlobalMaxPool2D()
self.fc = layers.Dense(num_classes)
def get_vgg19(classes=9,
input_shape=(224, 224, 3),
base_layer_trainable=False):
from tensorflow.keras.applications.vgg19 import VGG19
base_model = VGG19(include_top=False, input_shape=input_shape)
for layer in base_model.layers:
layer.trainable = base_layer_trainable
head_model = KL.GlobalMaxPool2D()(base_model.output)
head_model = KL.Dense(1024,
activation='relu',
name='00',
kernel_initializer='he_uniform')(head_model)
head_model = KL.Dropout(0.5)(head_model)
head_model = KL.Dense(1024,
activation='relu',
name='01',
kernel_initializer='he_uniform')(head_model)
head_model = KL.Dropout(0.5)(head_model)
head_model = KL.Dense(classes, activation='softmax', name='11')(head_model)
model = KM.Model(inputs=base_model.input, outputs=head_model)
return model
def get_mobilenetv2(classes=9,
input_shape=(224, 224, 3),
base_layer_trainable=False):
from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2
base_model = MobileNetV2(include_top=False, input_shape=input_shape)
for layer in base_model.layers:
layer.trainable = base_layer_trainable
head_model = KL.GlobalMaxPool2D()(base_model.output)
head_model = KL.Dense(1024,
activation='relu',
name='0000',
kernel_initializer='he_uniform')(head_model)
head_model = KL.Dropout(0.5)(head_model)
# head_model = KL.Dense(1024, activation='relu', name='1111', kernel_initializer='he_uniform')(head_model)
# head_model = KL.Dropout(0.5)(head_model)
if classes == 2:
head_model = KL.Dense(classes, activation='sigmoid',
name='3333')(head_model)
else:
head_model = KL.Dense(classes, activation='softmax',
name='3333')(head_model)
model = KM.Model(inputs=base_model.input, outputs=head_model)
return model
def __init__(self, filters=12, conv_count=4, alpha=0.2):
"""
Init the layers of the model.
Args:
filters (int): Base number of filters, scaled by conv_count
conv_count (int): Number of leaky conv layers to use
alpha (float): LeakyReLU alpha param
"""
super().__init__()
self.conv_in = ConvBlock(filters, 5, 2, override_activation=True)
# Interpolate kernel size from 5 to 2 over all the layers
kernels = np.interp(
x=[index / (conv_count - 1) for index in range(conv_count)],
xp=[0.0, 1.0],
fp=[5.0, 2.0],
)
kernels = np.round(kernels).astype(int)
# Stack the con layers into conv_layers
self.conv_layers = []
for index, kernel in zip(range(2, conv_count + 2), kernels):
self.conv_layers.append(
LeakyConvBlock(
filters=index * filters,
kernel_size=(kernel, kernel),
strides=2,
alpha=alpha,
),
)
self.conv_out = layers.Conv2D((conv_count + 1) * filters, 2, 2, padding='same')
self.global_pool = layers.GlobalMaxPool2D()
self.dense = layers.Dense(1, activation='sigmoid')
