def resnet18_2d(image_rows=256,
image_cols=256,
input_channels=3,
train_encoder=True):
# Block 1
# get parameters for model layers
no_scale_bn_params = get_bn_params(train_encoder, scale=False)
bn_params = get_bn_params(train_encoder)
conv_params = get_conv_params(train_encoder)
init_filters = 64
# INPUT
inputs = layers.Input((image_rows, image_cols, input_channels))
# resnet bottom
x = layers.BatchNormalization(name='bn_data', **no_scale_bn_params)(inputs)
x = layers.ZeroPadding2D(padding=(3, 3))(x)
x = layers.Conv2D(init_filters, (7, 7),
strides=(2, 2),
name='conv0',
**conv_params)(x)
x = layers.BatchNormalization(name='bn0', **bn_params)(x)
x = layers.Activation('relu', name='relu0')(x)
skip_connection_1 = x
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.MaxPooling2D((3, 3),
strides=(2, 2),
padding='valid',
name='pooling0')(x)
# Stage 1, Unit 1 - Settings
stage = 0
block = 0
strides = (1, 1)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 1 - Layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
# defining shortcut connection
shortcut = layers.Conv2D(filters, (1, 1),
name=sc_name,
strides=strides,
**conv_params)(x)
# continue with convolution layers
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 1, Unit 2 - Settings
stage = 0
block = 1
strides = (1, 1)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 2 - Layers
# defining shortcut connection
shortcut = x
# continue with convolution layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 2, Unit 1 - Settings
stage = 1
block = 0
strides = (2, 2)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 1 - Layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
skip_connection_2 = x
# defining shortcut connection
shortcut = layers.Conv2D(filters, (1, 1),
name=sc_name,
strides=strides,
**conv_params)(x)
# continue with convolution layers
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1_convpool',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 2, Unit 2 - Settings
stage = 1
block = 1
strides = (1, 1)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 2 - Layers
# defining shortcut connection
shortcut = x
# continue with convolution layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 3, Unit 1 - Settings
stage = 2
block = 0
strides = (2, 2)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 1 - Layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
skip_connection_3 = x
# defining shortcut connection
shortcut = layers.Conv2D(filters, (1, 1),
name=sc_name,
strides=strides,
**conv_params)(x)
# continue with convolution layers
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1_convpool',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 3, Unit 2 - Settings
stage = 2
block = 1
strides = (1, 1)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 2 - Layers
# defining shortcut connection
shortcut = x
# continue with convolution layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 4, Unit 1 - Settings
stage = 3
block = 0
strides = (2, 2)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 1 - Layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
skip_connection_4 = x
# defining shortcut connection
shortcut = layers.Conv2D(filters, (1, 1),
name=sc_name,
strides=strides,
**conv_params)(x)
# continue with convolution layers
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1_convpool',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Stage 4, Unit 2 - Settings
stage = 3
block = 1
strides = (1, 1)
filters = init_filters * (2**stage)
conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
# Stage 1, Block 2 - Layers
# defining shortcut connection
shortcut = x
# continue with convolution layers
x = layers.BatchNormalization(name=bn_name + '1', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '1')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3),
strides=strides,
name=conv_name + '1',
**conv_params)(x)
x = layers.BatchNormalization(name=bn_name + '2', **bn_params)(x)
x = layers.Activation('relu', name=relu_name + '2')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.Conv2D(filters, (3, 3), name=conv_name + '2', **conv_params)(x)
x = layers.Add()([x, shortcut])
# Resnet OUTPUT
x = layers.BatchNormalization(name='bn1', **bn_params)(x)
x = layers.Activation('relu', name='relu1')(x)
model = Model(inputs=[inputs], outputs=[x], name='resnet18')
model.summary()
plot_model(model, to_file='model.png')
weights_path = utils.get_file('resnet18_imagenet_1000_no_top.h5.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model.load_weights(weights_path)
return model
'''for x in range(0,len(itenes)):
itenes[x] = Image.open(itenes[x])
itenes[x] = itenes[x].resize(size=input_size)
itenes[x] = np.asarray(itenes[x])
itenes = np.asarray(itenes)
y = itenes.shape
if(len(y)==3):
itenes = np.reshape(itenes, (y[0],y[1],y[2],1))
generator.fit(itenes)'''
traingen = generator.flow_from_directory(path,
target_size=input_size,
batch_size=batch_size,
shuffle=True)
#seção do modelo da arquitetura
model = models.Sequential()
model.add(layers.ZeroPadding2D(input_shape=input_shape, padding=1))
model.add(
layers.Conv2D(filters=64,
kernel_size=3,
strides=1,
dilation_rate=1,
activation='relu'))
model.add(layers.ZeroPadding2D(1))
model.add(
layers.Conv2D(filters=64,
kernel_size=3,
strides=1,
dilation_rate=1,
activation='relu'))
model.add(layers.MaxPooling2D(pool_size=2, strides=2))
def MobileNetV2(input_shape=None,
alpha=1.0,
depth_multiplier=1,
include_top=True,
weights='imagenet',
input_tensor=None,
pooling=None,
classes=1000,
leaky_relu=None,
**kwargs):
"""Instantiates the MobileNetV2 architecture.
This is a simple modification of MobileNetV2 in keras_applications. I add
just one parameter: leaky_relu. If None, the original activation function
is used. Otherwise, Leaky_ReLU with alpha value just specified by leaky_relu
is used to substitute all activate functions.
:param input_shape: Optional shape tuple, to be specified if you would
like to use a model with an input img resolution that is not
(224, 224, 3).
It should have exactly 3 inputs channels (224, 224, 3).
You can also omit this option if you would like
to infer input_shape from an input_tensor.
If you choose to include both input_tensor and input_shape then
input_shape will be used if they match, if the shapes
do not match then we will throw an error.
E.g. `(160, 160, 3)` would be one valid value.
:param alpha: Controls the width of the network. This is known as the
width multiplier in the MobileNetV2 paper.
- If `alpha` < 1.0, proportionally decreases the number
of filters in each layer.
- If `alpha` > 1.0, proportionally increases the number
of filters in each layer.
- If `alpha` = 1, default number of filters from the paper
are used at each layer.
:param depth_multiplier: Depth multiplier for depthwise convolution
(also called the resolution multiplier)
:param include_top: Whether to include the fully-connected
layer at the top of the network.
:param weights: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model
will be the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a
2D tensor.
- `max` means that global max pooling will be applied.
:param input_tensor: Optional Keras tensor (i.e. output of
`layers.Input()`)
to use as image input for the model.
:param pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model
will be the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a
2D tensor.
- `max` means that global max pooling will
be applied.
:param classes: Optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
:param leaky_relu:
:param kwargs:
:return: A Keras model instance.
:raises:
ValueError: in case of invalid argument for `weights`,
or invalid input shape or invalid depth_multiplier, alpha,
rows when weights='imagenet'
"""
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError(
'If using `weights` as `"imagenet"` with `include_top`'
'as true, `classes` should be 1000')
# Determine proper input shape and default size.
# If both input_shape and input_tensor are used, they should match
if input_shape is not None and input_tensor is not None:
try:
is_input_t_tensor = backend.is_keras_tensor(input_tensor)
except ValueError:
try:
is_input_t_tensor = backend.is_keras_tensor(
keras_utils.get_source_inputs(input_tensor))
except ValueError:
raise ValueError('input_tensor: ', input_tensor,
'is not type input_tensor')
if is_input_t_tensor:
if backend.image_data_format == 'channels_first':
if backend.int_shape(input_tensor)[1] != input_shape[1]:
raise ValueError(
'input_shape: ', input_shape, 'and input_tensor: ',
input_tensor,
'do not meet the same shape requirements')
else:
if backend.int_shape(input_tensor)[2] != input_shape[1]:
raise ValueError(
'input_shape: ', input_shape, 'and input_tensor: ',
input_tensor,
'do not meet the same shape requirements')
else:
raise ValueError('input_tensor specified: ', input_tensor,
'is not a keras tensor')
# If input_shape is None, infer shape from input_tensor
if input_shape is None and input_tensor is not None:
try:
backend.is_keras_tensor(input_tensor)
except ValueError:
raise ValueError('input_tensor: ', input_tensor, 'is type: ',
type(input_tensor), 'which is not a valid type')
if input_shape is None and not backend.is_keras_tensor(input_tensor):
default_size = 224
elif input_shape is None and backend.is_keras_tensor(input_tensor):
if backend.image_data_format() == 'channels_first':
rows = backend.int_shape(input_tensor)[2]
cols = backend.int_shape(input_tensor)[3]
else:
rows = backend.int_shape(input_tensor)[1]
cols = backend.int_shape(input_tensor)[2]
if rows == cols and rows in [96, 128, 160, 192, 224]:
default_size = rows
else:
default_size = 224
# If input_shape is None and no input_tensor
elif input_shape is None:
default_size = 224
# If input_shape is not None, assume default size
else:
if backend.image_data_format() == 'channels_first':
rows = input_shape[1]
cols = input_shape[2]
else:
rows = input_shape[0]
cols = input_shape[1]
if rows == cols and rows in [96, 128, 160, 192, 224]:
default_size = rows
else:
default_size = 224
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if backend.image_data_format() == 'channels_last':
row_axis, col_axis = (0, 1)
else:
row_axis, col_axis = (1, 2)
rows = input_shape[row_axis]
cols = input_shape[col_axis]
if weights == 'imagenet':
if depth_multiplier != 1:
raise ValueError('If imagenet weights are being loaded, '
'depth multiplier must be 1')
if alpha not in [0.35, 0.50, 0.75, 1.0, 1.3, 1.4]:
raise ValueError('If imagenet weights are being loaded, '
'alpha can be one of `0.35`, `0.50`, `0.75`, '
'`1.0`, `1.3` or `1.4` only.')
if rows != cols or rows not in [96, 128, 160, 192, 224]:
if rows is None:
rows = 224
warnings.warn('MobileNet shape is undefined.'
' Weights for input shape'
'(224, 224) will be loaded.')
else:
raise ValueError('If imagenet weights are being loaded, '
'input must have a static square shape'
'(one of (96, 96), (128, 128), (160, 160),'
'(192, 192), or (224, 224)).'
'Input shape provided = %s' % (input_shape, ))
if backend.image_data_format() != 'channels_last':
warnings.warn('The MobileNet family of models is only available '
'for the input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height).'
' You should set `image_data_format="channels_last"` '
'in your Keras config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
backend.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
first_block_filters = _make_divisible(32 * alpha, 8)
x = layers.ZeroPadding2D(padding=correct_pad(backend, img_input, 3),
name='Conv1_pad')(img_input)
x = layers.Conv2D(first_block_filters,
kernel_size=3,
strides=(2, 2),
padding='valid',
use_bias=False,
name='Conv1')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name='bn_Conv1')(x)
x = _mobilenetv2_relu_activate(name='Conv1_relu', leaky_relu=leaky_relu)(x)
x = _inverted_res_block(x,
filters=16,
alpha=alpha,
stride=1,
expansion=1,
block_id=0,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=24,
alpha=alpha,
stride=2,
expansion=6,
block_id=1,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=24,
alpha=alpha,
stride=1,
expansion=6,
block_id=2,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=2,
expansion=6,
block_id=3,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=1,
expansion=6,
block_id=4,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=1,
expansion=6,
block_id=5,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=2,
expansion=6,
block_id=6,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
expansion=6,
block_id=7,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
expansion=6,
block_id=8,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
expansion=6,
block_id=9,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
expansion=6,
block_id=10,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
expansion=6,
block_id=11,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
expansion=6,
block_id=12,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=2,
expansion=6,
block_id=13,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=1,
expansion=6,
block_id=14,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=1,
expansion=6,
block_id=15,
leaky_relu=leaky_relu)
x = _inverted_res_block(x,
filters=320,
alpha=alpha,
stride=1,
expansion=6,
block_id=16,
leaky_relu=leaky_relu)
# no alpha applied to last conv as stated in the paper:
# if the width multiplier is greater than 1 we
# increase the number of output channels
if alpha > 1.0:
last_block_filters = _make_divisible(1280 * alpha, 8)
else:
last_block_filters = 1280
x = layers.Conv2D(last_block_filters,
kernel_size=1,
use_bias=False,
name='Conv_1')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name='Conv_1_bn')(x)
x = _mobilenetv2_relu_activate(name='out_relu', leaky_relu=leaky_relu)(x)
if include_top:
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(classes,
activation='softmax',
use_bias=True,
name='Logits')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs,
x,
name='mobilenetv2_%0.2f_%s' % (alpha, rows))
# Load weights.
if weights == 'imagenet':
if backend.image_data_format() == 'channels_first':
raise ValueError('Weights for "channels_first" format '
'are not available.')
if include_top:
model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' +
str(alpha) + '_' + str(rows) + '.h5')
weigh_path = MOBILENETV2_BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weigh_path,
cache_subdir='models')
else:
model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' +
str(alpha) + '_' + str(rows) + '_no_top' + '.h5')
weigh_path = MOBILENETV2_BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weigh_path,
cache_subdir='models')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
if old_data_format:
backend.set_image_data_format(old_data_format)
return model
def _reduction_a_cell(ip, p, filters, block_id=None):
'''Adds a Reduction cell for NASNet-A (Fig. 4 in the paper).
# Arguments
ip: Input tensor `x`
p: Input tensor `p`
filters: Number of output filters
block_id: String block_id
# Returns
A Keras tensor
'''
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
with backend.name_scope('reduction_A_block_%s' % block_id):
p = _adjust_block(p, ip, filters, block_id)
h = layers.Activation('relu')(ip)
h = layers.Conv2D(filters, (1, 1),
strides=(1, 1),
padding='same',
name='reduction_conv_1_%s' % block_id,
use_bias=False,
kernel_initializer='he_normal')(h)
h = layers.BatchNormalization(axis=channel_dim,
momentum=0.9997,
epsilon=1e-3,
name='reduction_bn_1_%s' % block_id)(h)
h3 = layers.ZeroPadding2D(padding=correct_pad(backend, h, 3),
name='reduction_pad_1_%s' % block_id)(h)
with backend.name_scope('block_1'):
x1_1 = _separable_conv_block(h,
filters, (5, 5),
strides=(2, 2),
block_id='reduction_left1_%s' %
block_id)
x1_2 = _separable_conv_block(p,
filters, (7, 7),
strides=(2, 2),
block_id='reduction_right1_%s' %
block_id)
x1 = layers.add([x1_1, x1_2], name='reduction_add_1_%s' % block_id)
with backend.name_scope('block_2'):
x2_1 = layers.MaxPooling2D(
(3, 3),
strides=(2, 2),
padding='valid',
name='reduction_left2_%s' % block_id)(h3)
x2_2 = _separable_conv_block(p,
filters, (7, 7),
strides=(2, 2),
block_id='reduction_right2_%s' %
block_id)
x2 = layers.add([x2_1, x2_2], name='reduction_add_2_%s' % block_id)
with backend.name_scope('block_3'):
x3_1 = layers.AveragePooling2D(
(3, 3),
strides=(2, 2),
padding='valid',
name='reduction_left3_%s' % block_id)(h3)
x3_2 = _separable_conv_block(p,
filters, (5, 5),
strides=(2, 2),
block_id='reduction_right3_%s' %
block_id)
x3 = layers.add([x3_1, x3_2], name='reduction_add3_%s' % block_id)
with backend.name_scope('block_4'):
x4 = layers.AveragePooling2D(
(3, 3),
strides=(1, 1),
padding='same',
name='reduction_left4_%s' % block_id)(x1)
x4 = layers.add([x2, x4])
with backend.name_scope('block_5'):
x5_1 = _separable_conv_block(x1,
filters, (3, 3),
block_id='reduction_left4_%s' %
block_id)
x5_2 = layers.MaxPooling2D(
(3, 3),
strides=(2, 2),
padding='valid',
name='reduction_right5_%s' % block_id)(h3)
x5 = layers.add([x5_1, x5_2], name='reduction_add4_%s' % block_id)
x = layers.concatenate([x2, x3, x4, x5],
axis=channel_dim,
name='reduction_concat_%s' % block_id)
return x, ip
def ResNet(stack_fn,
preact,
use_bias,
model_name='resnet',
include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
nclass=1000,
**kwargs):
"""Instantiates the ResNet, ResNetV2, and ResNeXt architecture.
Optionally loads weights pre-trained on ImageNet.
Note that the data format convention used by the model is
the one specified in your Keras config at `~/.keras/keras.json`.
# Arguments
stack_fn: a function that returns output tensor for the
stacked residual blocks.
preact: whether to use pre-activation or not
(True for ResNetV2, False for ResNet and ResNeXt).
use_bias: whether to use biases for convolutional layers or not
(True for ResNet and ResNetV2, False for ResNeXt).
model_name: string, model name.
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor
(i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels.
pooling: optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
# Determine proper input shape
# input_shape = input_shape
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(img_input)
x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv')(x)
if preact is False:
x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5,
name='conv1_bn')(x)
x = layers.Activation('relu', name='conv1_relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = stack_fn(x)
if preact is True:
x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5,
name='post_bn')(x)
x = layers.Activation('relu', name='post_relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(nclass, activation='softmax', name='probs')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name=model_name)
# Load weights.
if weights is not None:
model.load_weights(weights)
model.compile(loss='categorical_crossentropy',
optimizer='adam', metrics=['accuracy'])
return model
def resnet50(num_classes, size, compiled=True):
img_input = layers.Input(shape=(size[1], size[0], 3))
if backend.image_data_format() == 'channels_first':
x = layers.Lambda(
lambda x: backend.permute_dimensions(x, (0, 3, 1, 2)),
name='transpose')(img_input)
bn_axis = 1
else: # channels_last
x = img_input
bn_axis = 3
# Conv1 (7x7,64,stride=2)
x = layers.ZeroPadding2D(padding=(3, 3))(x)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY))(x)
x = layers.BatchNormalization(axis=bn_axis,
momentum=BATCH_NORM_DECAY,
epsilon=BATCH_NORM_EPSILON)(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
# 3x3 max pool,stride=2
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
# Conv2_x
# 1x1, 64
# 3x3, 64
# 1x1, 256
x = conv_block(x, 3, [64, 64, 256], strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256])
x = identity_block(x, 3, [64, 64, 256])
# Conv3_x
#
# 1x1, 128
# 3x3, 128
# 1x1, 512
x = conv_block(x, 3, [128, 128, 512])
x = identity_block(x, 3, [128, 128, 512])
x = identity_block(x, 3, [128, 128, 512])
x = identity_block(x, 3, [128, 128, 512])
# Conv4_x
# 1x1, 256
# 3x3, 256
# 1x1, 1024
x = conv_block(x, 3, [256, 256, 1024])
x = identity_block(x, 3, [256, 256, 1024])
x = identity_block(x, 3, [256, 256, 1024])
x = identity_block(x, 3, [256, 256, 1024])
x = identity_block(x, 3, [256, 256, 1024])
x = identity_block(x, 3, [256, 256, 1024])
# 1x1, 512
# 3x3, 512
# 1x1, 2048
x = conv_block(x, 3, [512, 512, 2048])
x = identity_block(x, 3, [512, 512, 2048])
x = identity_block(x, 3, [512, 512, 2048])
# average pool, 1000-d fc, sigmoid
x = layers.GlobalAveragePooling2D()(x)
if (compiled):
x = layers.Dense(num_classes,
activation='sigmoid',
kernel_regularizer=regularizers.l2(L2_WEIGHT_DECAY),
bias_regularizer=regularizers.l2(L2_WEIGHT_DECAY))(x)
else:
x = layers.BatchNormalization()(x)
model = models.Model(img_input, x, name='resnet50')
if (compiled):
top3_acc = functools.partial(metric.top_categorical_accuracy,
num_classes=num_classes)
top3_acc.__name__ = 'top3_accuracy'
opt = Adam(lr=0.001)
model.compile(optimizer=opt,
loss=keras.losses.binary_crossentropy,
metrics=[
top3_acc, metrics.categorical_accuracy,
metrics.binary_accuracy
])
return model
def conv2d(x,
in_channels,
out_channels,
kernel_size,
strides=1,
padding=0,
dilation=1,
groups=1,
use_bias=True,
name="conv2d"):
"""
Convolution 2D layer wrapper.
Parameters:
----------
x : keras.backend tensor/variable/symbol
Input tensor/variable/symbol.
in_channels : int
Number of input channels.
out_channels : int
Number of output channels.
kernel_size : int or tuple/list of 2 int
Convolution window size.
strides : int or tuple/list of 2 int
Strides of the convolution.
padding : int or tuple/list of 2 int
Padding value for convolution layer.
dilation : int or tuple/list of 2 int, default 1
Dilation value for convolution layer.
groups : int, default 1
Number of groups.
use_bias : bool, default False
Whether the layer uses a bias vector.
name : str, default 'conv2d'
Layer name.
Returns
-------
keras.backend tensor/variable/symbol
Resulted tensor/variable/symbol.
"""
if isinstance(kernel_size, int):
kernel_size = (kernel_size, kernel_size)
if isinstance(strides, int):
strides = (strides, strides)
if isinstance(padding, int):
padding = (padding, padding)
if isinstance(dilation, int):
dilation = (dilation, dilation)
extra_pad = False
if K.backend() == "tensorflow":
if (padding[0] > 0) or (padding[1] > 0):
import tensorflow as tf
x = nn.Lambda(
(lambda z: tf.pad(z, [[0, 0], [0, 0], list(padding), list(padding)]))
if is_channels_first() else
(lambda z: tf.pad(z, [[0, 0], list(padding), list(padding), [0, 0]])))(x)
if not ((padding[0] == padding[1]) and (kernel_size[0] == kernel_size[1]) and
(kernel_size[0] // 2 == padding[0])):
extra_pad = True
padding_ke = "valid"
else:
if (padding[0] == padding[1]) and (padding[0] == 0):
padding_ke = "valid"
elif (padding[0] == padding[1]) and (kernel_size[0] == kernel_size[1]) and (kernel_size[0] // 2 == padding[0]):
padding_ke = "same"
else:
x = nn.ZeroPadding2D(
padding=padding,
name=name + "/pad")(x)
padding_ke = "valid"
extra_pad = True
if groups == 1:
if extra_pad:
name = name + "/conv"
x = nn.Conv2D(
filters=out_channels,
kernel_size=kernel_size,
strides=strides,
padding=padding_ke,
dilation_rate=dilation,
use_bias=use_bias,
name=name)(x)
elif (groups == out_channels) and (out_channels == in_channels):
assert (dilation[0] == 1) and (dilation[1] == 1)
if extra_pad:
name = name + "/conv"
x = nn.DepthwiseConv2D(
kernel_size=kernel_size,
strides=strides,
padding=padding_ke,
use_bias=use_bias,
name=name)(x)
else:
assert (in_channels % groups == 0)
assert (out_channels % groups == 0)
none_batch = (x._keras_shape[0] is None)
in_group_channels = in_channels // groups
out_group_channels = out_channels // groups
group_list = []
for gi in range(groups):
xi = nn.Lambda(
(lambda z: z[:, gi * in_group_channels:(gi + 1) * in_group_channels, :, :])
if is_channels_first() else
(lambda z: z[:, :, :, gi * in_group_channels:(gi + 1) * in_group_channels]))(x)
xi = nn.Conv2D(
filters=out_group_channels,
kernel_size=kernel_size,
strides=strides,
padding=padding_ke,
dilation_rate=dilation,
use_bias=use_bias,
name=name + "/convgroup{}".format(gi + 1))(xi)
group_list.append(xi)
x = nn.concatenate(group_list, axis=get_channel_axis(), name=name + "/concat")
if none_batch and (x._keras_shape[0] is not None):
x._keras_shape = (None, ) + x._keras_shape[1:]
return x
def YOLOv4(inputs,
num_classes,
num_anchors,
initial_filters=32,
fast=False,
anchors=None,
conf_thresh=0.05,
nms_thresh=0.45,
keep_top_k=100,
nms_top_k=100):
i32 = initial_filters
i64 = i32 * 2
i128 = i32 * 4
i256 = i32 * 8
i512 = i32 * 16
i1024 = i32 * 32
if fast:
# x = PreLayer()(inputs)
x = inputs
else:
x = inputs
# cspdarknet53部分
x = conv2d_unit(x, i32, 3, strides=1, padding='same')
# ============================= s2 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i64, 3, strides=2)
s2 = conv2d_unit(x, i64, 1, strides=1)
x = conv2d_unit(x, i64, 1, strides=1)
x = stack_residual_block(x, i32, i64, n=1)
x = conv2d_unit(x, i64, 1, strides=1)
x = layers.Concatenate()([x, s2])
s2 = conv2d_unit(x, i64, 1, strides=1)
# ============================= s4 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(s2)
x = conv2d_unit(x, i128, 3, strides=2)
s4 = conv2d_unit(x, i64, 1, strides=1)
x = conv2d_unit(x, i64, 1, strides=1)
x = stack_residual_block(x, i64, i64, n=2)
x = conv2d_unit(x, i64, 1, strides=1)
x = layers.Concatenate()([x, s4])
s4 = conv2d_unit(x, i128, 1, strides=1)
# ============================= s8 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(s4)
x = conv2d_unit(x, i256, 3, strides=2)
s8 = conv2d_unit(x, i128, 1, strides=1)
x = conv2d_unit(x, i128, 1, strides=1)
x = stack_residual_block(x, i128, i128, n=8)
x = conv2d_unit(x, i128, 1, strides=1)
x = layers.Concatenate()([x, s8])
s8 = conv2d_unit(x, i256, 1, strides=1)
# ============================= s16 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(s8)
x = conv2d_unit(x, i512, 3, strides=2)
s16 = conv2d_unit(x, i256, 1, strides=1)
x = conv2d_unit(x, i256, 1, strides=1)
x = stack_residual_block(x, i256, i256, n=8)
x = conv2d_unit(x, i256, 1, strides=1)
x = layers.Concatenate()([x, s16])
s16 = conv2d_unit(x, i512, 1, strides=1)
# ============================= s32 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(s16)
x = conv2d_unit(x, i1024, 3, strides=2)
s32 = conv2d_unit(x, i512, 1, strides=1)
x = conv2d_unit(x, i512, 1, strides=1)
x = stack_residual_block(x, i512, i512, n=4)
x = conv2d_unit(x, i512, 1, strides=1)
x = layers.Concatenate()([x, s32])
s32 = conv2d_unit(x, i1024, 1, strides=1)
# cspdarknet53部分结束
# fpn部分
x = conv2d_unit(s32, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = spp(x)
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
fpn_s32 = conv2d_unit(x, i512, 1, strides=1, act='leaky')
# pan01
x = conv2d_unit(fpn_s32, i256, 1, strides=1, act='leaky')
x = layers.UpSampling2D(2)(x)
s16 = conv2d_unit(s16, i256, 1, strides=1, act='leaky')
x = layers.Concatenate()([s16, x])
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
fpn_s16 = conv2d_unit(x, i256, 1, strides=1, act='leaky')
# pan01结束
# pan02
x = conv2d_unit(fpn_s16, i128, 1, strides=1, act='leaky')
x = layers.UpSampling2D(2)(x)
s8 = conv2d_unit(s8, i128, 1, strides=1, act='leaky')
x = layers.Concatenate()([s8, x])
x = conv2d_unit(x, i128, 1, strides=1, act='leaky')
x = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i128, 1, strides=1, act='leaky')
x = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i128, 1, strides=1, act='leaky')
# pan02结束
# output_s, 不用concat()
output_s = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky')
output_s = conv2d_unit(output_s,
num_anchors * (num_classes + 5),
1,
strides=1,
bn=0,
act=None)
# output_m, 需要concat()
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i256, 3, strides=2, act='leaky')
x = layers.Concatenate()([x, fpn_s16])
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
output_m = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
output_m = conv2d_unit(output_m,
num_anchors * (num_classes + 5),
1,
strides=1,
bn=0,
act=None)
# output_l, 需要concat()
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i512, 3, strides=2, act='leaky')
x = layers.Concatenate()([x, fpn_s32])
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
output_l = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
output_l = conv2d_unit(output_l,
num_anchors * (num_classes + 5),
1,
strides=1,
bn=0,
act=None)
# 用张量操作实现后处理
if fast:
def output_layer(args):
output_s, output_m, output_l = args
# 先对坐标解码
pred_xywh_s, pred_conf_s, pred_prob_s = decode(
output_s, anchors[0], 8, num_classes)
pred_xywh_m, pred_conf_m, pred_prob_m = decode(
output_m, anchors[1], 16, num_classes)
pred_xywh_l, pred_conf_l, pred_prob_l = decode(
output_l, anchors[2], 32, num_classes)
# 获取分数
pred_score_s = pred_conf_s * pred_prob_s
pred_score_m = pred_conf_m * pred_prob_m
pred_score_l = pred_conf_l * pred_prob_l
# 所有输出层的预测框集合后再执行nms
all_pred_boxes = tf.concat([pred_xywh_s, pred_xywh_m, pred_xywh_l],
axis=1) # [batch_size, -1, 4]
all_pred_scores = tf.concat(
[pred_score_s, pred_score_m, pred_score_l],
axis=1) # [batch_size, -1, 80]
# 用fastnms
output = fastnms(all_pred_boxes, all_pred_scores, conf_thresh,
nms_thresh, keep_top_k, nms_top_k)
return output
output = layers.Lambda(output_layer)([output_s, output_m, output_l])
model_body = keras.models.Model(inputs=inputs, outputs=output)
else:
model_body = keras.models.Model(inputs=inputs,
outputs=[output_l, output_m, output_s])
return model_body
def ResNet(input_shape, **kwargs):
"""Instantiates the ResNet architecture.
# Arguments
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 197.
E.g. `(200, 200, 3)` would be one valid value.
# Returns
A Keras model instance.
# ResNet configuration space:
kernel_size: 3,5
stage2_block: [1,3]
stage3_block: [1,11]
stage4_block: [1,47]
stage5_block: [1,4]
"""
kwargs = {k: kwargs[k]
for k in kwargs if kwargs[k]} # Remove None value in args
kernel_size = kwargs['res_kernel_size']
stages = 4
img_input = layers.Input(shape=input_shape)
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
filters = 64
# stage 1
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(filters, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer='he_normal',
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
# stage 2-5
for stage in range(2, stages + 2):
if stage == 2:
x = conv_block(x,
kernel_size, [filters, filters, filters * 4],
stage=stage,
block='_0_',
strides=(1, 1))
else:
x = conv_block(x,
kernel_size, [filters, filters, filters * 4],
stage=stage,
block='_0_')
for i in range(kwargs['res_stage' + str(stage) + '_block']):
x = identity_block(x,
3, [filters, filters, filters * 4],
stage=stage,
block="_" + str(i + 1) + "_")
filters *= 2
x = layers.GlobalAveragePooling2D()(x)
# Create model.
model = Model(img_input, x, name='resnet')
return model
def create_CNN(window_shape):
K.set_image_dim_ordering('tf')
# sgd = optimizers.SGD()
adam = optimizers.Adam(lr=0.0000001) # , decay=0.000001)
cnn_model = Sequential()
print(window_shape)
cnn_model.add(
layers.ZeroPadding2D(padding=2,
input_shape=window_shape,
data_format='channels_last'))
cnn_model.add(layers.Conv2D(18, (5, 5), strides=(1, 1), activation='relu')
) #, kernel_regularizer=regularizers.l2())) # 'relu'))
cnn_model.add(layers.BatchNormalization())
cnn_model.add(layers.MaxPooling2D(pool_size=(2, 2), padding='valid'))
cnn_model.add(layers.ZeroPadding2D(padding=(1, 1), data_format=None))
cnn_model.add(
layers.Conv2D(36, (3, 3), strides=(1, 1), activation='relu')
) #,kernel_regularizer=regularizers.l2())) # 'relu')) #4 previously
cnn_model.add(layers.BatchNormalization())
cnn_model.add(layers.MaxPooling2D(pool_size=(2, 2), padding='valid'))
cnn_model.add(layers.Flatten())
cnn_model.add(
layers.Dense(20, activation='relu')
) #, kernel_regularizer=regularizers.l2())) # 'sigmoid')) # layers.Dropout(rate, noise_shape=None, seed=None)
cnn_model.add(layers.Dropout(0.5))
# cnn_model.add(layers.Flatten())
cnn_model.add(
layers.Dense(1, activation='sigmoid')
) #,kernel_regularizer=regularizers.l2())) # layers.Dropout(rate, noise_shape=None, seed=None)
# cnn_model.add(layers.Dropout(0.1))
# cnn_model.add(layers.Activation('softmax'))
cnn_model.summary()
# cnn_model.add(layers.Dense())
cnn_model.compile(optimizer=adam, loss='binary_crossentropy')
# K.set_image_dim_ordering('tf')
# # sgd = optimizers.SGD()
# adam = optimizers.Adam(lr=0.0001)
# cnn_model = Sequential()
# print(window_shape)
# cnn_model.add(layers.ZeroPadding2D(padding=2, input_shape=window_shape, data_format='channels_last'))
# cnn_model.add(
# layers.Conv2D(12, (5, 5), strides=(1, 1), activation=None, kernel_regularizer=regularizers.l2())) # 'relu'))
# cnn_model.add(layers.MaxPooling2D(pool_size=(2, 2), padding='valid'))
# cnn_model.add(layers.ZeroPadding2D(padding=(1, 1), data_format=None))
# cnn_model.add(layers.Conv2D(8, (3, 3), strides=(1, 1), activation=None,
# kernel_regularizer=regularizers.l2())) # 'relu')) #4 previously
# cnn_model.add(layers.MaxPooling2D(pool_size=(2, 2), padding='valid'))
# cnn_model.add(layers.Flatten())
# cnn_model.add(layers.Dense(20, activation=None,
# kernel_regularizer=regularizers.l2())) # 'sigmoid')) # layers.Dropout(rate, noise_shape=None, seed=None)
# # cnn_model.add(layers.Dropout(0.2))
# # cnn_model.add(layers.Flatten())
# cnn_model.add(layers.Dense(2, activation='softmax', kernel_regularizer=regularizers.l2()))
# cnn_model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])
# K.set_image_dim_ordering('tf')
# sgd = optimizers.SGD()
# cnn_model = Sequential()
# # sigmoid part may need to be of form, activation='tanh' activation = layers.sigmoid input_shape=window_shape,
# print(window_shape)
# cnn_model.add(layers.ZeroPadding2D(padding=2, input_shape=window_shape, data_format='channels_last'))
# # cnn_model.add(layers.ZeroPadding2D(padding=2, input_shape=(window_shape[2], window_shape[0], window_shape[1]), data_format='channels_first'))
# cnn_model.add(layers.Conv2D(12, (5, 5), strides=(1, 1), activation ='relu'))
# cnn_model.add(layers.MaxPooling2D(pool_size=(2, 2), padding='valid'))
# cnn_model.add(layers.ZeroPadding2D(padding=(1, 1), data_format=None))
# cnn_model.add(layers.Conv2D(4, (3, 3), strides=(1, 1), activation='relu'))
# cnn_model.add(layers.MaxPooling2D(pool_size=(2, 2), padding='valid'))
# cnn_model.add(layers.Flatten())
# cnn_model.add(layers.Dense(20, activation='sigmoid')) # layers.Dropout(rate, noise_shape=None, seed=None)
# # cnn_model.add(layers.Dropout(0.1))
# # cnn_model.add(layers.Flatten())
# cnn_model.add(layers.Dense(2, activation='softmax')) # layers.Dropout(rate, noise_shape=None, seed=None)
# # cnn_model.add(layers.Dropout(0.1))
# # cnn_model.add(layers.Activation('softmax'))
#
# ## Summary Line, Suppressed
# # cnn_model.summary()
#
#
# # cnn_model.add(layers.Dense())
# cnn_model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
cnn_model.load_weights('Keras_Models_Saved\Model_12')
# cnn_model.load_weights('Keras_Models_Saved\Model_112917_2220_binary')
# cnn_model.load_weights('Keras_Models_Saved\Model_112717_test7')
# utils.plot_model(cnn_model, to_file='model_1107.png', show_shapes=True, show_layer_names=True, rankdir='LR')
print(cnn_model.get_weights())
return cnn_model
def cnn_model(input_shape, num_classes=1284):
"""Generate CNN with backdoor."""
input = layers.Input(shape=input_shape)
# Border extraction
c_w1 = shift_kernel((2, 2), 3)
c_w2 = shift_kernel((-4, -4), 3)
c_w3 = shift_kernel((2, 2), 3)
c_wp = subtractive_pointwise_kernel(6, preserve_org=True)
# First method of extracting border, it is bit slower than next one
# l1 = layers.Conv2D(
# 3,
# c_w1.shape[:2],
# padding="same",
# use_bias=False,
# weights=[c_w1],
# trainable=False)(input)
# l2 = layers.Conv2D(
# 3,
# c_w1.shape[:2],
# padding="same",
# use_bias=False,
# weights=[c_w2],
# trainable=False)(input)
# l3 = layers.Conv2D(
# 3,
# c_w1.shape[:2],
# padding="same",
# use_bias=False,
# weights=[c_w3],
# trainable=False)(input)
# concat = layers.Concatenate()([intput, l3])
# border_plus_org_input = layers.Conv2D(
# 6,
# c_w1.shape[:2],
# padding="same",
# use_bias=False,
# weights=[c_wp],
# trainable=False)(input)
# Second method of extraction
c_weights_1 = shift_kernel((0, 0), 3, kernel_size=5) * -1
l1 = layers.Conv2D(3,
c_weights_1.shape[:2],
padding="valid",
use_bias=False,
weights=[c_weights_1],
trainable=False,
name="train")(input)
l1_pad = layers.ZeroPadding2D(padding=(2, 2))(l1)
border = layers.Add()([input, l1_pad])
concat = layers.Concatenate()([input, border])
# Rest of the CNN
c_layer1_5 = layers.Conv2D(12, (5, 5), padding="same",
activation="relu")(concat)
c_layer1_3 = layers.Conv2D(12, (3, 3), padding="same",
activation="relu")(concat)
c_layer1_1 = layers.Conv2D(12, (1, 1), padding="same",
activation="relu")(concat)
concat_1 = layers.Concatenate()(
[c_layer1_5, c_layer1_3, c_layer1_1, border])
max_pool1 = layers.Conv2D(36, (3, 3),
strides=2,
padding="same",
activation="relu")(concat_1)
c_layer2_5 = layers.Conv2D(64, (5, 5), padding="same",
activation="relu")(max_pool1)
max_pool2 = layers.MaxPooling2D(pool_size=2, strides=2)(c_layer2_5)
c_layer3_5 = layers.Conv2D(128, (5, 5),
strides=2,
padding="same",
activation="relu")(max_pool2)
flatten = layers.Flatten()(c_layer3_5)
dense = layers.Dense(2048, activation='relu')(flatten)
dropout_2 = layers.Dropout(0.5)(dense)
output = layers.Dense(num_classes, activation='softmax')(dropout_2)
model = Model(inputs=input, outputs=output)
return model
def EfficientNet(width_coefficient,
depth_coefficient,
default_size,
dropout_rate=0.2,
drop_connect_rate=0.2,
depth_divisor=8,
activation_fn=tf.nn.swish,
blocks_args=DEFAULT_BLOCKS_ARGS,
model_name='efficientnet',
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
#-------------------------------------------------#
# 该函数的目的是保证filter的大小可以被8整除
#-------------------------------------------------#
def round_filters(filters, divisor=depth_divisor):
"""Round number of filters based on depth multiplier."""
filters *= width_coefficient
new_filters = max(divisor,
int(filters + divisor / 2) // divisor * divisor)
# Make sure that round down does not go down by more than 10%.
if new_filters < 0.9 * filters:
new_filters += divisor
return int(new_filters)
#-------------------------------------------------#
# 计算模块的重复次数
#-------------------------------------------------#
def round_repeats(repeats):
return int(math.ceil(depth_coefficient * repeats))
#-------------------------------------------------#
# 创建stem部分
#-------------------------------------------------#
x = img_input
x = layers.ZeroPadding2D(padding=correct_pad(x, 3),
name='stem_conv_pad')(x)
x = layers.Conv2D(round_filters(32),
3,
strides=2,
padding='valid',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='stem_conv')(x)
x = layers.BatchNormalization(name='stem_bn')(x)
x = layers.Activation(activation_fn, name='stem_activation')(x)
blocks_args = deepcopy(blocks_args)
#-------------------------------------------------#
# 计算总的efficient_block的数量
#-------------------------------------------------#
b = 0
blocks = float(sum(args['repeats'] for args in blocks_args))
#------------------------------------------------------------------------------#
# 对结构块参数进行循环、一共进行7个大的结构块。
# 每个大结构块下会重复小的efficient_block
#------------------------------------------------------------------------------#
for (i, args) in enumerate(blocks_args):
assert args['repeats'] > 0
#-------------------------------------------------#
# 对使用到的参数进行更新
#-------------------------------------------------#
args['filters_in'] = round_filters(args['filters_in'])
args['filters_out'] = round_filters(args['filters_out'])
for j in range(round_repeats(args.pop('repeats'))):
if j > 0:
args['strides'] = 1
args['filters_in'] = args['filters_out']
x = block(x,
activation_fn,
drop_connect_rate * b / blocks,
name='block{}{}_'.format(i + 1, chr(j + 97)),
**args)
b += 1
#-------------------------------------------------#
# 1x1卷积调整通道数
#-------------------------------------------------#
x = layers.Conv2D(round_filters(1280),
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='top_conv')(x)
x = layers.BatchNormalization(name='top_bn')(x)
x = layers.Activation(activation_fn, name='top_activation')(x)
#-------------------------------------------------#
# 利用GlobalAveragePooling2D代替全连接层
#-------------------------------------------------#
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
if dropout_rate > 0:
x = layers.Dropout(dropout_rate, name='top_dropout')(x)
x = layers.Dense(classes,
activation='softmax',
kernel_initializer=DENSE_KERNEL_INITIALIZER,
name='probs')(x)
inputs = img_input
model = Model(inputs, x, name=model_name)
#-------------------------------------------------#
# 载入权值
#-------------------------------------------------#
if weights == 'imagenet':
file_suff = '_weights_tf_dim_ordering_tf_kernels_autoaugment.h5'
file_hash = WEIGHTS_HASHES[model_name[-2:]][0]
file_name = model_name + file_suff
weights_path = get_file(file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir='models',
file_hash=file_hash)
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def block(inputs,
activation_fn=get_swish,
drop_rate=0.,
name='',
filters_in=32,
filters_out=16,
kernel_size=3,
strides=1,
expand_ratio=1,
se_ratio=0.,
id_skip=True):
filters = filters_in * expand_ratio
#-------------------------------------------------#
# 利用Inverted residuals
# part1 利用1x1卷积进行通道数上升
#-------------------------------------------------#
if expand_ratio != 1:
x = layers.Conv2D(filters,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'expand_conv')(inputs)
x = layers.BatchNormalization(name=name + 'expand_bn')(x)
x = layers.Activation(activation_fn,
name=name + 'expand_activation')(x)
else:
x = inputs
#------------------------------------------------------#
# 如果步长为2x2的话，利用深度可分离卷积进行高宽压缩
# part2 利用3x3卷积对每一个channel进行卷积
#------------------------------------------------------#
if strides == 2:
x = layers.ZeroPadding2D(padding=correct_pad(x, kernel_size),
name=name + 'dwconv_pad')(x)
conv_pad = 'valid'
else:
conv_pad = 'same'
x = layers.DepthwiseConv2D(kernel_size,
strides=strides,
padding=conv_pad,
use_bias=False,
depthwise_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'dwconv')(x)
x = layers.BatchNormalization(name=name + 'bn')(x)
x = layers.Activation(activation_fn, name=name + 'activation')(x)
#------------------------------------------------------#
# 完成深度可分离卷积后
# 对深度可分离卷积的结果施加注意力机制
#------------------------------------------------------#
if 0 < se_ratio <= 1:
filters_se = max(1, int(filters_in * se_ratio))
se = layers.GlobalAveragePooling2D(name=name + 'se_squeeze')(x)
se = layers.Reshape((1, 1, filters), name=name + 'se_reshape')(se)
#------------------------------------------------------#
# 通道先压缩后上升，最后利用sigmoid将值固定到0-1之间
#------------------------------------------------------#
se = layers.Conv2D(filters_se,
1,
padding='same',
activation=activation_fn,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'se_reduce')(se)
se = layers.Conv2D(filters,
1,
padding='same',
activation='sigmoid',
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'se_expand')(se)
x = layers.multiply([x, se], name=name + 'se_excite')
#------------------------------------------------------#
# part3 利用1x1卷积进行通道下降
#------------------------------------------------------#
x = layers.Conv2D(filters_out,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=name + 'project_conv')(x)
x = layers.BatchNormalization(name=name + 'project_bn')(x)
#------------------------------------------------------#
# part4 如果满足残差条件，那么就增加残差边
#------------------------------------------------------#
if (id_skip is True and strides == 1 and filters_in == filters_out):
if drop_rate > 0:
x = layers.Dropout(drop_rate,
noise_shape=(None, 1, 1, 1),
name=name + 'drop')(x)
x = layers.add([x, inputs], name=name + 'add')
return x
c7 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(u7)
c7 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(c7)
u8 = upsample(16, (2, 2), strides=(2, 2), padding='same')(c7)
u8 = layers.concatenate([u8, c2])
c8 = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(u8)
c8 = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(c8)
u9 = upsample(8, (2, 2), strides=(2, 2), padding='same')(c8)
u9 = layers.concatenate([u9, c1], axis=3)
c9 = layers.Conv2D(8, (3, 3), activation='relu', padding='same')(u9)
c9 = layers.Conv2D(8, (3, 3), activation='relu', padding='same')(c9)
d = layers.Conv2D(1, (1, 1), activation='sigmoid')(c9)
d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d)
d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d)
if NET_SCALING is not None:
d = layers.UpSampling2D(NET_SCALING)(d)
seg_model = models.Model(inputs=[input_img], outputs=[d])
seg_model.summary()
# In[ ]:
import keras.backend as K
from keras.optimizers import Adam
from keras.losses import binary_crossentropy
def dice_coef(y_true, y_pred, smooth=1):
intersection = K.sum(y_true * y_pred, axis=[1, 2, 3])
def mobilenet_v2_ssdlite(input_image, sub):
alpha = 1.0
first_block_filters = _make_divisible(32 * alpha, 8)
# stage subtraction feature map extraction
# 300*300*3 -> 150*150*16
sub = KL.ZeroPadding2D(padding=correct_pad(K, sub, 3),
name='sub_stage1_block1_pad')(sub)
sub = KL.Conv2D(first_block_filters,
kernel_size=3, strides=(2, 2),
padding='valid', use_bias=False,
name='sub_stage1_block1_conv')(sub)
sub = KL.BatchNormalization(
epsilon=1e-3, momentum=0.999, name='sub_stage1_block1_bn')(sub)
sub = KL.ReLU(6., name='sub_stage1_block1_relu')(sub)
sub = dw_sub_block(sub, filters=24, alpha=alpha, stride=2, stage=2, block_id=1)
# 150*150*16 -> 75*75*24
# 75*75*24 -> 38*38*32
#sub = dw_sub_block(sub, filters=32, alpha=alpha, stride=2, stage=3, block_id=1)
#38*38*32 -> 19*19*32
#sub = dw_sub_block(sub, filters=32, alpha=alpha, stride=2, stage=4, block_id=1)
# stage1
x = KL.ZeroPadding2D(padding=correct_pad(K, input_image, 3),
name='bbn_stage1_block1_pad')(input_image)
x = KL.Conv2D(first_block_filters,
kernel_size=3, strides=(2, 2),
padding='valid', use_bias=False,
name='bbn_stage1_block1_conv')(x)
x = KL.BatchNormalization(
epsilon=1e-3, momentum=0.999, name='bbn_stage1_block1_bn')(x)
x = KL.ReLU(6., name='bbn_stage1_block1_relu')(x)
x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1,
expansion=1, stage=1, block_id=2, expand=False)
# stage2
x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2,
expansion=6, stage=2, block_id=1)
x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1,
expansion=6, stage=2, block_id=2)
# stage3
x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2,
expansion=6, stage=3, block_id=1)
# concatenate sub here
sub = dw_sub_block(sub, filters=32, alpha=alpha, stride=2, stage=3, block_id=1)
x = KL.Add(name='38_38_32stage3_add')([x, sub])#KL.Add(name=name + '_add')([inputs, x])
x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
expansion=6, stage=3, block_id=2)
x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
expansion=6, stage=3, block_id=3)
# stage4
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=2,
expansion=6, stage=4, block_id=1)
# concatenate sub here
sub = dw_sub_block(sub, filters=64, alpha=alpha, stride=2, stage=4, block_id=1)
x = KL.Add(name='19_19_64stage4_add')([x, sub])
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1,
expansion=6, stage=4, block_id=2)
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1,
expansion=6, stage=4, block_id=3)
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1,
expansion=6, stage=4, block_id=4)
x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1,
expansion=6, stage=4, block_id=5)
x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1,
expansion=6, stage=4, block_id=6)
x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1,
expansion=6, stage=4, block_id=7)
# stage5
x, link1 = _inverted_res_block(x, filters=160, alpha=alpha, stride=2,
expansion=6, stage=5, block_id=1, output2=True)
# concatenate sub here
sub = dw_sub_b lock(sub, filters=160, alpha=alpha, stride=2, stage=5, block_id=1)
x = KL.Add(name='10_10_160stage5_add')([x, sub])
x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1,
expansion=6, stage=5, block_id=2)
x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1,
expansion=6, stage=5, block_id=3)
x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1,
expansion=6, stage=5, block_id=4)
x = KL.Conv2D(1280, kernel_size=1, padding='same', use_bias=False, activation=None, name='ssd_2_conv')(x)
x = KL.BatchNormalization(epsilon=1e-3, momentum=0.999, name='ssd_2_conv_bn')(x)
link2 = x = KL.ReLU(6., name='ssd_2_conv_relu')(x)
link3 = x = _followed_down_sample_block(x, 256, 512, 3)
link4 = x = _followed_down_sample_block(x, 128, 256, 4)
link5 = x = _followed_down_sample_block(x, 128, 256, 5)
link6 = x = _followed_down_sample_block(x, 64, 128, 6)
links = [link1, link2, link3, link4, link5, link6]# return 6 feature maps with different scales
return links
def extend_resnet(input_image, architecture="resnet101", train_bn=True):
assert architecture in ["resnet50", "resnet101"]
# Stage 1
x = KL.ZeroPadding2D((3, 3))(input_image)
x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=True)(x)
x = BatchNorm(name='bn_conv1')(x, training=train_bn)
x = KL.Activation('relu')(x)
x = KL.MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)
# Stage 2
x = conv_block(x,
3, [64, 64, 256],
stage=2,
block='a',
strides=(1, 1),
train_bn=train_bn)
x = identity_block(x,
3, [64, 64, 256],
stage=2,
block='b',
train_bn=train_bn)
conv3_3 = x = identity_block(x,
3, [64, 64, 256],
stage=2,
block='c',
train_bn=train_bn)
# Stage 3
x = conv_block(x,
3, [128, 128, 512],
stage=3,
block='a',
train_bn=train_bn)
x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='b',
train_bn=train_bn)
x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='c',
train_bn=train_bn)
conv4_3 = x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='d',
train_bn=train_bn)
# Stage 4
x = conv_block(x,
3, [256, 256, 1024],
stage=4,
block='a',
train_bn=train_bn)
block_count = {"resnet50": 5, "resnet101": 22}[architecture]
for i in range(block_count):
x = identity_block(x,
3, [256, 256, 1024],
stage=4,
block=chr(98 + i),
train_bn=train_bn)
conv5_3 = x
# Stage 5
x = conv_block(x,
3, [512, 512, 2048],
stage=5,
block='a',
train_bn=train_bn)
x = identity_block(x,
3, [512, 512, 2048],
stage=5,
block='b',
train_bn=train_bn)
conv_fc7 = x = identity_block(x,
3, [512, 512, 2048],
stage=5,
block='c',
train_bn=train_bn)
# Stage 6(Extended)
x = KL.Conv2D(512, (1, 1), name='stage6_conv1', padding='same',
strides=1)(x)
x = BatchNorm(name='stage6_bn1', )(x, training=train_bn)
x = KL.Activation('relu')(x)
x = KL.Conv2D(512, (3, 3), name='stage6_conv2', padding='same',
strides=2)(x)
x = BatchNorm(name='stage6_bn2', )(x, training=train_bn)
conv6_2 = x = KL.Activation('relu')(x)
# Stage 7(Extended)
x = KL.Conv2D(128, (1, 1), name='stage7_conv1', padding='same',
strides=1)(x)
x = BatchNorm(name='stage7_bn1', )(x, training=train_bn)
x = KL.Activation('relu')(x)
x = KL.Conv2D(256, (3, 3), name='stage7_conv2', padding='same',
strides=2)(x)
x = BatchNorm(name='stage7_bn2', )(x, training=train_bn)
conv7_2 = x = KL.Activation('relu')(x)
return conv3_3, conv4_3, conv5_3, conv_fc7, conv6_2, conv7_2
def ResNet50(classes: int = 1000, input_shape: Tuple[int] = (224, 224)):
""" Instantiates the ResNet50 architecture.
# Arguments
- classes: The number of classes to predict.
- input_shape: The size of the inputs (x, y).
# Returns:
A Keras model instance.
"""
img_input = layers.Input(shape=(*input_shape, 3))
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
# 1
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer='he_normal',
kernel_regularizer=l2(0.00005),
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis,
momentum=0.9,
epsilon=1e-5,
name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
# 2
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
# 3
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
# 4
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
# 5
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes,
activation='softmax',
kernel_regularizer=l2(0.00005),
name='fc1000')(x)
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='resnet50')
return model
def create_model(self, img_shape, num_class):
concat_axis = 3
shape = img_shape + [1] if len(img_shape) == 1 else img_shape
inputs = layers.Input(shape=shape)
conv1 = layers.Conv2D(32, (3, 3),
activation='relu',
padding='same',
name='conv1_1')(inputs)
conv1 = layers.Conv2D(32, (3, 3), activation='relu',
padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu',
padding='same')(pool4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu',
padding='same')(conv5)
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = self.get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch, cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(up6)
conv6 = layers.Conv2D(256, (3, 3), activation='relu',
padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = self.get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch, cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu',
padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = self.get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch, cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu',
padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = self.get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch, cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu',
padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu',
padding='same')(conv9)
ch, cw = self.get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0],
cw[1])))(conv9)
# conv10 = layers.Conv2D(num_class, (1, 1))(conv9)
conv10 = layers.Conv2D(1, (1, 1), activation='sigmoid')(conv9)
model = models.Model(inputs=inputs, outputs=conv10)
return model
def _depthwise_conv_block(inputs,
pointwise_conv_filters,
alpha,
depth_multiplier=1,
strides=(1, 1),
block_id=1):
"""Adds a depthwise convolution block.
A depthwise convolution block consists of a depthwise conv,
batch normalization, relu6, pointwise convolution,
batch normalization and relu6 activation.
# Arguments
inputs: Input tensor of shape `(rows, cols, channels)`
(with `channels_last` data format) or
(channels, rows, cols) (with `channels_first` data format).
pointwise_conv_filters: Integer, the dimensionality of the output space
(i.e. the number of output filters in the pointwise convolution).
alpha: controls the width of the network.
- If `alpha` < 1.0, proportionally decreases the number
of filters in each layer.
- If `alpha` > 1.0, proportionally increases the number
of filters in each layer.
- If `alpha` = 1, default number of filters from the paper
are used at each layer.
depth_multiplier: The number of depthwise convolution output channels
for each input channel.
The total number of depthwise convolution output
channels will be equal to `filters_in * depth_multiplier`.
strides: An integer or tuple/list of 2 integers,
specifying the strides of the convolution
along the width and height.
Can be a single integer to specify the same value for
all spatial dimensions.
Specifying any stride value != 1 is incompatible with specifying
any `dilation_rate` value != 1.
block_id: Integer, a unique identification designating
the block number.
# Input shape
4D tensor with shape:
`(batch, channels, rows, cols)` if data_format='channels_first'
or 4D tensor with shape:
`(batch, rows, cols, channels)` if data_format='channels_last'.
# Output shape
4D tensor with shape:
`(batch, filters, new_rows, new_cols)`
if data_format='channels_first'
or 4D tensor with shape:
`(batch, new_rows, new_cols, filters)`
if data_format='channels_last'.
`rows` and `cols` values might have changed due to stride.
# Returns
Output tensor of block.
"""
channel_axis = 3
pointwise_conv_filters = int(pointwise_conv_filters * alpha)
if strides == (1, 1):
x = inputs
else:
x = layers.ZeroPadding2D(((0, 1), (0, 1)),
name='conv_pad_%d' % block_id)(inputs)
x = layers.DepthwiseConv2D(
(3, 3),
padding='same' if strides == (1, 1) else 'valid',
depth_multiplier=depth_multiplier,
strides=strides,
use_bias=False,
name='conv_dw_%d' % block_id)(x)
x = layers.BatchNormalization(axis=channel_axis,
name='conv_dw_%d_bn' % block_id)(x)
x = layers.ReLU(6., name='conv_dw_%d_relu' % block_id)(x)
x = layers.Conv2D(pointwise_conv_filters, (1, 1),
padding='same',
use_bias=False,
strides=(1, 1),
name='conv_pw_%d' % block_id)(x)
x = layers.BatchNormalization(axis=channel_axis,
name='conv_pw_%d_bn' % block_id)(x)
return layers.ReLU(6., name='conv_pw_%d_relu' % block_id)(x)
def build(self,
input_shape=None,
data_format='channels_last',
pooling=None,
repetitions=None,
bottleneck=True,
model_name='resnet50'):
assert len(repetitions) == 4
img_input = layers.Input(shape=input_shape)
if data_format == 'channels_first':
bn_axis = 1
else:
bn_axis = 3
# stage1
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(
64, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer='he_normal',
name='conv1_4' if input_shape[2] == 4 else 'conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
block_names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
base_num1 = 64
base_num2 = 256
# loop for stages from stage2 to ...
for i, num in enumerate(repetitions):
stage = i + 2
# fisrt block in i-th stage
x = conv_block(x,
3, [base_num1, base_num1, base_num2],
stage=stage,
block='a',
bn_axis=bn_axis,
strides=(1, 1) if i == 0 else (2, 2),
bottleneck=bottleneck)
# loop for rest block in i-th stage
for ii in range(1, num):
#block_name = block_names[ii+1]
x = identity_block(
x,
3,
[base_num1, base_num1, base_num2],
stage=stage,
block='b' + str(ii) if
(repetitions[2] > 6 and stage in [3, 4]) else block_names[
ii], #res50（包括50）以下按照keras内置的命名格式，res50以上则按照权值文件的命名格式，参考：https://github.com/GKalliatakis/Keras-Application-Zoo/blob/master/resnet101.py
bn_axis=bn_axis,
bottleneck=bottleneck)
base_num1 = 2 * base_num1
base_num2 = 2 * base_num2
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
elif pooling:
raise ('no such pooling type!!')
# create model
model = models.Model(img_input, x, name=model_name)
return model
def nn_base(input_tensor=None, trainable=False):
#Determine proper input shape
if K.image_dim_ordering() == 'th':
input_shape = (3, None, None)
else:
input_shape = (None, None, 3)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if K.image_dim_ordering() == 'tf':
bn_axis = 3
else:
bn_axis = 1
# for testing..
alpha = 1
depth_multiplier = 1
# need this layer to pass the input image size
x = layers.ZeroPadding2D((3, 3))(img_input)
#Input: 320x320
#Block 1, Output = 160x160
x = _conv_block(img_input, 32, alpha, strides=(2, 2))
#Block 2, Output 160x160 (Stride 1)
x = _depthwise_conv_block(x, 64, alpha, depth_multiplier, block_id=1)
#Block 3, Output = 80x80
x = _depthwise_conv_block(x,
128,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=2)
x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, block_id=3)
#Block 4, Output = 40x40
x = _depthwise_conv_block(x,
256,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=4)
x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, block_id=5)
#Block 5 is a 5x stride1 dw-separable, Output = 20x20
x = _depthwise_conv_block(x,
512,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=6)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=7)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=8)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=9)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=10)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=11)
return x
def unet(self, img_shape, num_class=2):
'''Create non-compiled UNet model
# arguments
img_shape: shape of input image
num_class: default value is 2 as we classify pixel in two classes
'''
concat_axis = -1
inputs = layers.Input(shape = img_shape)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='conv1_1')(inputs)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch,cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch,cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch,cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch,cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
ch, cw = get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9)
conv10 = layers.Conv2D(num_class, (1, 1))(conv9)
model = Model(inputs=inputs, outputs=conv10)
return model
def YnetResNet(netpram,include_top=True, weights=None, input_tensor=None, input_shape=None,pooling=None, classes=1000):
include_top=False
pooling='max'
classes=1000
if netpram.task=='all':
num_classes=11
elif netpram.task=='binary':
num_classes=1
elif netpram.task=='parts':
num_classes=3
elif netpram.task=='instrument':
num_classes=7
#img_input=Input((224, 224, 3))
inputs_L = Input((224, 224, 3))
inputs_R = Input((224, 224, 3))
inputs=[inputs_L,inputs_R]
bn_axis = 3
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(inputs_L)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x_a = layers.Activation('relu')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x_a)
x_b = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x_b, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
x_c = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x_c, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
x_d = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x_d, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
x_e = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x_e, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
if include_top:
x = layers.AveragePooling2D((7, 7), name='avg_pool')(x)
x = layers.Flatten()(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
else:
warnings.warn('The output shape of `ResNet50(include_top=False)` '
'has been changed since Keras 2.2.0.')
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
inputs = inputs_L
# Create model.
modelen1 = Model(inputs, x, name='resnet50')
# Load weights.
weights_path = utils.get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
modelen1.load_weights(weights_path)
# for layer in modelen1.layers:
# layer.trainable=False
# Loaded enoder one- untrainable
x = layers.ZeroPadding2D(padding=(3, 3), name='enc2_conv1_pad')(inputs_R)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
name='enc2_conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='enc2_bn_conv1')(x)
x_a_e2 = layers.Activation('relu')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x_a_e2)
x_b_e2 = conv_block(x, 3, [64, 64, 256], stage=2, block='a_enc2', strides=(1, 1))
x = identity_block(x_b_e2, 3, [64, 64, 256], stage=2, block='b_enc2')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c_enc2')
x_c_e2 = conv_block(x, 3, [128, 128, 512], stage=3, block='a_enc2')
x = identity_block(x_c_e2, 3, [128, 128, 512], stage=3, block='b_enc2')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c_enc2')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d_enc2')
x_d_e2 = conv_block(x, 3, [256, 256, 1024], stage=4, block='a_enc2')
x = identity_block(x_d_e2, 3, [256, 256, 1024], stage=4, block='b_enc2')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c_enc2')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d_enc2')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e_enc2')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f_enc2')
x_e_e2 = conv_block(x, 3, [512, 512, 2048], stage=5, block='a_enc2')
x = identity_block(x_e_e2, 3, [512, 512, 2048], stage=5, block='b_enc2_enc2')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c_enc2')
if include_top:
x = layers.AveragePooling2D((7, 7), name='avg_pool_enc2')(x)
x = layers.Flatten()(x)
x = layers.Dense(classes, activation='softmax', name='fc1000_enc2')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
else:
warnings.warn('The output shape of `ResNet50(include_top=False)` '
'has been changed since Keras 2.2.0.')
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
inputs = inputs_R
# Create model.
modelen2 = Model(inputs, x, name='resnet50')
# Load weights.
weights_path = utils.get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
modelen2.load_weights(weights_path)
#Loaded encoder 2-trainable
#center = add([xold, ynew])
#center = concatenate([xold, ynew], axis=3)
center=conv_block_decoder(add([x_e,x_e_e2]), 1024, 7, 'center', strides=(2, 2))
center=conv_block_decoder(center, 1024, 7, 'center_2', strides=(2, 2))
# 32
up4 = UpSampling2D((2, 2))(center)
#upc=concatenate([x_d,x_d_e2], axis=3)
up4 = concatenate([add([x_d,x_d_e2]), up4], axis=3)
up4=conv_block_decoder(up4, 512, 32, 'deconv1', strides=(2, 2))
# up4=conv_block_decoder(up4, 512, 32, 'deconv2', strides=(2, 2))
up4=conv_block_decoder(up4, 512, 32, 'deconv3', strides=(2, 2))
# 64
up3 = UpSampling2D((2, 2))(up4)
# upc=concatenate([down2T,down2B], axis=3)
#upc=concatenate([x_c,x_c_e2], axis=3)
up3 = concatenate([add([x_c,x_c_e2]), up3], axis=3)
up3=conv_block_decoder(up3, 512, 64, 'deconv1', strides=(2, 2))
up3=conv_block_decoder(up3, 512, 64, 'deconv2', strides=(2, 2))
up3=conv_block_decoder(up3, 512, 64, 'deconv3', strides=(2, 2))
# 128
up2 = UpSampling2D((2, 2))(up3)
#upc = concatenate([down1T,down1B], axis=3)
x_b = layers.ZeroPadding2D(padding=[1, 1], name='convdec_pad')(x_b)
x_b = layers.Cropping2D(cropping=((1, 0), (1, 0)), data_format=None)(x_b)
x_b_e2 = layers.ZeroPadding2D(padding=[1, 1], name='convdec_pad2')(x_b_e2)
x_b_e2 = layers.Cropping2D(cropping=((1, 0), (1, 0)), data_format=None)(x_b_e2)
up2 = concatenate([add([x_b,x_b_e2]), up2], axis=3)
up2=conv_block_decoder(up2, 256, 128, 'deconv1', strides=(2, 2))
# up2=conv_block_decoder(up2, 256, 128, 'deconv2', strides=(2, 2))
up2=conv_block_decoder(up2, 256, 128, 'deconv3', strides=(2, 2))
# 256
up1 = UpSampling2D((2, 2))(up2)
#upc=concatenate([down0T,down0B], axis=3)
up1 = concatenate([add([x_a,x_a_e2]), up1], axis=3)
up1=conv_block_decoder(up1, 128, 256, 'deconv1', strides=(2, 2))
up1=conv_block_decoder(up1, 128, 256, 'deconv2', strides=(2, 2))
up1=conv_block_decoder(up1, 128, 256, 'deconv3', strides=(2, 2))
# 512
up0a = UpSampling2D((2, 2))(up1)
#upc= concatenate([down0aT,down0aB],axis=3)
# up0a = concatenate([img_input, up0a], axis=3)
up0a=conv_block_decoder(up0a, 64, 512, 'deconv1', strides=(2, 2))
up0a=conv_block_decoder(up0a, 64, 512, 'deconv2', strides=(2, 2))
up0a=conv_block_decoder(up0a, 64, 512, 'deconv3', strides=(2, 2))
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up0a)
model = Model(inputs=[inputs_L,inputs_R], outputs=classify,name='RESNetU')
# optimizerc =CustomRMSprop(lr=0.00001,multipliers = LR_mult_dict)
#lr=0.00001, F1=79.8
model.compile(optimizer=RMSprop(lr=0.0001), loss=bce_dice_loss, metrics=[dice_coeff])
# '''
return model
def _adjust_block(p, ip, filters, block_id=None):
'''Adjusts the input `previous path` to match the shape of the `input`.
Used in situations where the output number of filters needs to be changed.
# Arguments
p: Input tensor which needs to be modified
ip: Input tensor whose shape needs to be matched
filters: Number of output filters to be matched
block_id: String block_id
# Returns
Adjusted Keras tensor
'''
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
img_dim = 2 if backend.image_data_format() == 'channels_first' else -2
ip_shape = backend.int_shape(ip)
if p is not None:
p_shape = backend.int_shape(p)
with backend.name_scope('adjust_block'):
if p is None:
p = ip
elif p_shape[img_dim] != ip_shape[img_dim]:
with backend.name_scope('adjust_reduction_block_%s' % block_id):
p = layers.Activation('relu',
name='adjust_relu_1_%s' % block_id)(p)
p1 = layers.AveragePooling2D(
(1, 1),
strides=(2, 2),
padding='valid',
name='adjust_avg_pool_1_%s' % block_id)(p)
p1 = layers.Conv2D(filters // 2, (1, 1),
padding='same',
use_bias=False,
name='adjust_conv_1_%s' % block_id,
kernel_initializer='he_normal')(p1)
p2 = layers.ZeroPadding2D(padding=((0, 1), (0, 1)))(p)
p2 = layers.Cropping2D(cropping=((1, 0), (1, 0)))(p2)
p2 = layers.AveragePooling2D(
(1, 1),
strides=(2, 2),
padding='valid',
name='adjust_avg_pool_2_%s' % block_id)(p2)
p2 = layers.Conv2D(filters // 2, (1, 1),
padding='same',
use_bias=False,
name='adjust_conv_2_%s' % block_id,
kernel_initializer='he_normal')(p2)
p = layers.concatenate([p1, p2], axis=channel_dim)
p = layers.BatchNormalization(axis=channel_dim,
momentum=0.9997,
epsilon=1e-3,
name='adjust_bn_%s' %
block_id)(p)
elif p_shape[channel_dim] != filters:
with backend.name_scope('adjust_projection_block_%s' % block_id):
p = layers.Activation('relu')(p)
p = layers.Conv2D(filters, (1, 1),
strides=(1, 1),
padding='same',
name='adjust_conv_projection_%s' % block_id,
use_bias=False,
kernel_initializer='he_normal')(p)
p = layers.BatchNormalization(axis=channel_dim,
momentum=0.9997,
epsilon=1e-3,
name='adjust_bn_%s' %
block_id)(p)
return p
# In[15]:
network = models.Sequential()
network.add(
layers.Conv2D(32, (3, 3),
activation='relu',
padding='same',
input_shape=input_shape))
network.add(layers.MaxPooling2D((2, 2), padding='same'))
network.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
network.add(layers.MaxPooling2D((2, 2), padding='valid'))
network.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
network.add(layers.UpSampling2D((2, 2)))
network.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same'))
network.add(layers.UpSampling2D((2, 2)))
network.add(layers.ZeroPadding2D(padding=(1, 0), data_format=None))
network.add(layers.Conv2D(1, (3, 3), activation='sigmoid', padding='same'))
# In[16]:
network.summary()
# In[17]:
network2 = keras.utils.multi_gpu_model(network, gpus=2) #model for 2 GPUs
# # Compiling Model
# In[18]:
network.compile(optimizer='adadelta', loss='binary_crossentropy')
initial_filters = 8
i32 = initial_filters
i64 = i32 * 2
i128 = i32 * 4
i256 = i32 * 8
i512 = i32 * 16
i1024 = i32 * 32
# 多尺度训练
inputs = layers.Input(shape=(None, None, 3))
''' darknet53部分，所有卷积层都没有偏移use_bias=False '''
x = conv2d_unit(inputs, i32, (3, 3))
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i64, (3, 3), strides=2, padding='valid')
x = stack_residual_block(x, i32, n=1)
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i128, (3, 3), strides=2, padding='valid')
x = stack_residual_block(x, i64, n=2)
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i256, (3, 3), strides=2, padding='valid')
act11 = stack_residual_block(x, i128, n=8)
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(act11)
x = conv2d_unit(x, i512, (3, 3), strides=2, padding='valid')
act19 = stack_residual_block(x, i256, n=8)
def resnet_graph(input_image, architecture, stage5=False, train_bn=True):
"""Build a ResNet graph.
architecture: Can be resnet50 or resnet101
stage5: Boolean. If False, stage5 of the network is not created
train_bn: Boolean. Train or freeze Batch Norm layers
"""
assert architecture in ["resnet50", "resnet101"]
# Stage 1
x = KL.ZeroPadding2D((3, 3))(input_image)
x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=True)(x)
x = BatchNorm(name='bn_conv1')(x, training=train_bn)
x = KL.Activation('relu')(x)
C1 = x = KL.MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)
# Stage 2
x = conv_block(x,
3, [64, 64, 256],
stage=2,
block='a',
strides=(1, 1),
train_bn=train_bn)
x = identity_block(x,
3, [64, 64, 256],
stage=2,
block='b',
train_bn=train_bn)
C2 = x = identity_block(x,
3, [64, 64, 256],
stage=2,
block='c',
train_bn=train_bn)
# Stage 3
x = conv_block(x,
3, [128, 128, 512],
stage=3,
block='a',
train_bn=train_bn)
x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='b',
train_bn=train_bn)
x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='c',
train_bn=train_bn)
C3 = x = identity_block(x,
3, [128, 128, 512],
stage=3,
block='d',
train_bn=train_bn)
# Stage 4
x = conv_block(x,
3, [256, 256, 1024],
stage=4,
block='a',
train_bn=train_bn)
block_count = {"resnet50": 5, "resnet101": 22}[architecture]
for i in range(block_count):
x = identity_block(x,
3, [256, 256, 1024],
stage=4,
block=chr(98 + i),
train_bn=train_bn)
C4 = x
# Stage 5
if stage5:
x = conv_block(x,
3, [512, 512, 2048],
stage=5,
block='a',
train_bn=train_bn)
x = identity_block(x,
3, [512, 512, 2048],
stage=5,
block='b',
train_bn=train_bn)
C5 = x = identity_block(x,
3, [512, 512, 2048],
stage=5,
block='c',
train_bn=train_bn)
else:
C5 = None
return [C1, C2, C3, C4, C5]
