def get_input_config(model):
'''
returns a tuple (inputDimensions, numChannels)
'''
return (
model.get_input_shape_at(0)[2:4],
model.get_input_shape_at(0)[1]) if K.image_data_format() == 'th' else (
#tf ordering
model.get_input_shape_at(0)[1:3],
model.get_input_shape_at(0)[3])
# Input image dimensions
img_rows, img_cols = 28, 28
# The data, shuffled and split between train and test sets
x_train = np.load(os.path.join(args.train, 'train.npz'))['data']
y_train = np.load(os.path.join(args.train, 'train.npz'))['labels']
print("Train dataset loaded from: {}".format(os.path.join(args.train, 'train.npz')))
x_test = np.load(os.path.join(args.test, 'test.npz'))['data']
y_test = np.load(os.path.join(args.test, 'test.npz'))['labels']
print("Test dataset loaded from: {}".format(os.path.join(args.test, 'test.npz')))
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
def call(self, x, mask=None):
'''
Return an anchor box tensor based on the shape of the input tensor.
The logic implemented here is identical to the logic in the module `ssd_box_encode_decode_utils.py`.
Note that this tensor does not participate in any graph computations at runtime. It is being created
as a constant once during graph creation and is just being output along with the rest of the model output
during runtime. Because of this, all logic is implemented as Numpy array operations and it is sufficient
to convert the resulting Numpy array into a Keras tensor at the very end before outputting it.
Arguments:
x (tensor): 4D tensor of shape `(batch, channels, height, width)` if `dim_ordering = 'th'`
or `(batch, height, width, channels)` if `dim_ordering = 'tf'`. The input for this
layer must be the output of the localization predictor layer.
'''
# Compute box width and height for each aspect ratio
# The shorter side of the image will be used to compute `w` and `h` using `scale` and `aspect_ratios`.
size = min(self.img_height, self.img_width)
# Compute the box widths and and heights for all aspect ratios
wh_list = []
for ar in self.aspect_ratios:
if (ar == 1):
# Compute the regular anchor box for aspect ratio 1.
box_height = box_width = self.this_scale * size
wh_list.append((box_width, box_height))
if self.two_boxes_for_ar1:
# Compute one slightly larger version using the geometric mean of this scale value and the next.
box_height = box_width = np.sqrt(
self.this_scale * self.next_scale) * size
wh_list.append((box_width, box_height))
else:
box_height = self.this_scale * size / np.sqrt(ar)
box_width = self.this_scale * size * np.sqrt(ar)
wh_list.append((box_width, box_height))
wh_list = np.array(wh_list)
# We need the shape of the input tensor
if K.image_data_format() == 'tf':
batch_size, feature_map_height, feature_map_width, feature_map_channels = x.shape
else: # Not yet relevant since TensorFlow is the only supported backend right now, but it can't harm to have this in here for the future
batch_size, feature_map_channels, feature_map_height, feature_map_width = x.shape
# Compute the grid of box center points. They are identical for all aspect ratios.
# Compute the step sizes, i.e. how far apart the anchor box center points will be vertically and horizontally.
if (self.this_steps is None):
step_height = self.img_height / feature_map_height
step_width = self.img_width / feature_map_width
else:
if isinstance(self.this_steps,
(list, tuple)) and (len(self.this_steps) == 2):
step_height = self.this_steps[0]
step_width = self.this_steps[1]
elif isinstance(self.this_steps, (int, float)):
step_height = self.this_steps
step_width = self.this_steps
# Compute the offsets, i.e. at what pixel values the first anchor box center point will be from the top and from the left of the image.
if (self.this_offsets is None):
offset_height = 0.5
offset_width = 0.5
else:
if isinstance(self.this_offsets,
(list, tuple)) and (len(self.this_offsets) == 2):
offset_height = self.this_offsets[0]
offset_width = self.this_offsets[1]
elif isinstance(self.this_offsets, (int, float)):
offset_height = self.this_offsets
offset_width = self.this_offsets
# Now that we have the offsets and step sizes, compute the grid of anchor box center points.
cy = np.linspace(offset_height * step_height,
(offset_height + feature_map_height - 1) *
step_height, feature_map_height)
cx = np.linspace(offset_width * step_width,
(offset_width + feature_map_width - 1) * step_width,
feature_map_width)
cx_grid, cy_grid = np.meshgrid(cx, cy)
cx_grid = np.expand_dims(
cx_grid, -1
) # This is necessary for np.tile() to do what we want further down
cy_grid = np.expand_dims(
cy_grid, -1
) # This is necessary for np.tile() to do what we want further down
# Create a 4D tensor template of shape `(feature_map_height, feature_map_width, n_boxes, 4)`
# where the last dimension will contain `(cx, cy, w, h)`
boxes_tensor = np.zeros(
(feature_map_height, feature_map_width, self.n_boxes, 4))
boxes_tensor[:, :, :, 0] = np.tile(cx_grid,
(1, 1, self.n_boxes)) # Set cx
boxes_tensor[:, :, :, 1] = np.tile(cy_grid,
(1, 1, self.n_boxes)) # Set cy
boxes_tensor[:, :, :, 2] = wh_list[:, 0] # Set w
boxes_tensor[:, :, :, 3] = wh_list[:, 1] # Set h
# Convert `(cx, cy, w, h)` to `(xmin, xmax, ymin, ymax)`
boxes_tensor = convert_coordinates(boxes_tensor,
start_index=0,
conversion='centroids2corners')
# If `limit_boxes` is enabled, clip the coordinates to lie within the image boundaries
if self.limit_boxes:
x_coords = boxes_tensor[:, :, :, [0, 2]]
x_coords[x_coords >= self.img_width] = self.img_width - 1
x_coords[x_coords < 0] = 0
boxes_tensor[:, :, :, [0, 2]] = x_coords
y_coords = boxes_tensor[:, :, :, [1, 3]]
y_coords[y_coords >= self.img_height] = self.img_height - 1
y_coords[y_coords < 0] = 0
boxes_tensor[:, :, :, [1, 3]] = y_coords
# If `normalize_coords` is enabled, normalize the coordinates to be within [0,1]
if self.normalize_coords:
boxes_tensor[:, :, :, [0, 2]] /= self.img_width
boxes_tensor[:, :, :, [1, 3]] /= self.img_height
# TODO: Implement box limiting directly for `(cx, cy, w, h)` so that we don't have to unnecessarily convert back and forth.
if self.coords == 'centroids':
# Convert `(xmin, ymin, xmax, ymax)` back to `(cx, cy, w, h)`.
boxes_tensor = convert_coordinates(boxes_tensor,
start_index=0,
conversion='corners2centroids')
elif self.coords == 'minmax':
# Convert `(xmin, ymin, xmax, ymax)` to `(xmin, xmax, ymin, ymax).
boxes_tensor = convert_coordinates(boxes_tensor,
start_index=0,
conversion='corners2minmax')
# Create a tensor to contain the variances and append it to `boxes_tensor`. This tensor has the same shape
# as `boxes_tensor` and simply contains the same 4 variance values for every position in the last axis.
variances_tensor = np.zeros_like(
boxes_tensor
) # Has shape `(feature_map_height, feature_map_width, n_boxes, 4)`
variances_tensor += self.variances # Long live broadcasting
# Now `boxes_tensor` becomes a tensor of shape `(feature_map_height, feature_map_width, n_boxes, 8)`
boxes_tensor = np.concatenate((boxes_tensor, variances_tensor),
axis=-1)
# Now prepend one dimension to `boxes_tensor` to account for the batch size and tile it along
# The result will be a 5D tensor of shape `(batch_size, feature_map_height, feature_map_width, n_boxes, 8)`
boxes_tensor = np.expand_dims(boxes_tensor, axis=0)
boxes_tensor = K.tile(K.constant(boxes_tensor, dtype='float32'),
(K.shape(x)[0], 1, 1, 1, 1))
return boxes_tensor
def _inception_resnet_block(x,
scale,
block_type,
block_idx,
activation='relu'):
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
if block_idx is None:
prefix = None
else:
prefix = '_'.join((block_type, str(block_idx)))
name_fmt = partial(_generate_layer_name, prefix=prefix)
if block_type == 'Block35':
branch_0 = conv2d_bn(x, 32, 1, name=name_fmt('Conv2d_1x1', 0))
branch_1 = conv2d_bn(x, 32, 1, name=name_fmt('Conv2d_0a_1x1', 1))
branch_1 = conv2d_bn(branch_1,
32,
3,
name=name_fmt('Conv2d_0b_3x3', 1))
branch_2 = conv2d_bn(x, 32, 1, name=name_fmt('Conv2d_0a_1x1', 2))
branch_2 = conv2d_bn(branch_2,
32,
3,
name=name_fmt('Conv2d_0b_3x3', 2))
branch_2 = conv2d_bn(branch_2,
32,
3,
name=name_fmt('Conv2d_0c_3x3', 2))
branches = [branch_0, branch_1, branch_2]
elif block_type == 'Block17':
branch_0 = conv2d_bn(x, 128, 1, name=name_fmt('Conv2d_1x1', 0))
branch_1 = conv2d_bn(x, 128, 1, name=name_fmt('Conv2d_0a_1x1', 1))
branch_1 = conv2d_bn(branch_1,
128, [1, 7],
name=name_fmt('Conv2d_0b_1x7', 1))
branch_1 = conv2d_bn(branch_1,
128, [7, 1],
name=name_fmt('Conv2d_0c_7x1', 1))
branches = [branch_0, branch_1]
elif block_type == 'Block8':
branch_0 = conv2d_bn(x, 192, 1, name=name_fmt('Conv2d_1x1', 0))
branch_1 = conv2d_bn(x, 192, 1, name=name_fmt('Conv2d_0a_1x1', 1))
branch_1 = conv2d_bn(branch_1,
192, [1, 3],
name=name_fmt('Conv2d_0b_1x3', 1))
branch_1 = conv2d_bn(branch_1,
192, [3, 1],
name=name_fmt('Conv2d_0c_3x1', 1))
branches = [branch_0, branch_1]
else:
raise ValueError('Unknown Inception-ResNet block type. '
'Expects "Block35", "Block17" or "Block8", '
'but got: ' + str(block_type))
mixed = Concatenate(axis=channel_axis,
name=name_fmt('Concatenate'))(branches)
up = conv2d_bn(mixed,
K.int_shape(x)[channel_axis],
1,
activation=None,
use_bias=True,
name=name_fmt('Conv2d_1x1'))
up = Lambda(scaling,
output_shape=K.int_shape(up)[1:],
arguments={'scale': scale})(up)
x = add([x, up])
if activation is not None:
x = Activation(activation, name=name_fmt('Activation'))(x)
return x
from tensorflow.keras.layers import Input, Conv3D, BatchNormalization, Activation, Flatten, Concatenate
from tensorflow.keras import Model, backend
from tensorflow.keras.losses import mean_squared_error, categorical_crossentropy
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.optimizers.schedules import PiecewiseConstantDecay
IMAGE_FORMAT = backend.image_data_format()
def conv_block(input_,
n_filters=32,
kernel_size=(3, 3, 3),
dilation_rate=1,
idx=0):
"""
create a conv_block with the following structure:
Conv3D -- BatchNormalization -- ReLU
:param input_: input to the conv_block
:param n_filters: number of filters in Conv3D
:param kernel_size: kernel size of Conv3D
:param dilation_rate: dilation rate of Conv3D
:param idx: index of conv_block for naming
:return: x (output of relu)
"""
idx = str(idx)
x = Conv3D(n_filters,
kernel_size,
dilation_rate=dilation_rate,
name="conv" + idx)(input_)
def Xception(include_top=True, weights='imagenet',
input_tensor=None, input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the Xception architecture.
Optionally loads weights pre-trained
on ImageNet. This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
data format `(width, height, channels)`.
You should set `image_data_format='channels_last'` in your Keras config
located at ~/.keras/keras.json.
Note that the default input image size for this model is 299x299.
# Arguments
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 `(299, 299, 3)`.
It should have exactly 3 inputs channels,
and width and height should be no smaller than 71.
E.g. `(150, 150, 3)` would be one valid value.
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.
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
"""
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')
if K.backend() != 'tensorflow':
raise RuntimeError('The Xception model is only available with '
'the TensorFlow backend.')
if K.image_data_format() != 'channels_last':
warnings.warn('The Xception model 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.')
K.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=71,
data_format=K.image_data_format(),
require_flatten=False,
weights=weights)
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
x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False, name='block1_conv1', padding="same")(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2', padding='same')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, (1, 1), strides=(2, 2),
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block2_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(256, (1, 1), strides=(2, 2),
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block3_pool')(x)
x = layers.add([x, residual])
residual = Conv2D(728, (1, 1), strides=(2, 2),
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
residual = Conv2D(1024, (1, 1), strides=(2, 2),
padding='same', use_bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x)
x = layers.add([x, residual])
x = SeparableConv2D(1536, (3, 3), padding='same', use_bias=False, name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='xception')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file('xception_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models',
file_hash='0a58e3b7378bc2990ea3b43d5981f1f6')
else:
weights_path = get_file('xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='b0042744bf5b25fce3cb969f33bebb97')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
if old_data_format:
K.set_image_data_format(old_data_format)
return model
from tensorflow.keras import backend as K
import tensorflowjs as tfjs
batch_size = 128
num_classes = 10
epochs = 10
# input image dimensions
img_rows, img_cols = 28, 28
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
def ResNet(input_shape=None,
classes=10,
block='bottleneck',
residual_unit='v2',
repetitions=None,
initial_filters=64,
activation='softmax',
include_top=True,
input_tensor=None,
dropout=None,
transition_dilation_rate=(1, 1),
initial_strides=(2, 2),
initial_kernel_size=(7, 7),
initial_pooling='max',
final_pooling=None,
top='classification'):
"""Builds a custom ResNet like architecture. Defaults to ResNet50 v2.
Args:
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` dim ordering)
or `(3, 224, 224)` (with `channels_first` dim ordering).
It should have exactly 3 dimensions,
and width and height should be no smaller than 8.
E.g. `(224, 224, 3)` would be one valid value.
classes: The number of outputs at final softmax layer
block: The block function to use. This is either `'basic'` or `'bottleneck'`.
The original paper used `basic` for layers < 50.
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size
is halved. Default of None implies the ResNet50v2 values of [3, 4, 6, 3].
residual_unit: the basic residual unit, 'v1' for conv bn relu, 'v2' for bn relu
conv. See [Identity Mappings in
Deep Residual Networks](https://arxiv.org/abs/1603.05027)
for details.
dropout: None for no dropout, otherwise rate of dropout from 0 to 1.
Based on [Wide Residual Networks.(https://arxiv.org/pdf/1605.07146) paper.
transition_dilation_rate: Dilation rate for transition layers. For semantic
segmentation of images use a dilation rate of (2, 2).
initial_strides: Stride of the very first residual unit and MaxPooling2D call,
with default (2, 2), set to (1, 1) for small images like cifar.
initial_kernel_size: kernel size of the very first convolution, (7, 7) for
imagenet and (3, 3) for small image datasets like tiny imagenet and cifar.
See [ResNeXt](https://arxiv.org/abs/1611.05431) paper for details.
initial_pooling: Determine if there will be an initial pooling layer,
'max' for imagenet and None for small image datasets.
See [ResNeXt](https://arxiv.org/abs/1611.05431) paper for details.
final_pooling: Optional pooling mode for feature extraction at the final
model layer 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.
top: Defines final layers to evaluate based on a specific problem type. Options
are 'classification' for ImageNet style problems, 'segmentation' for
problems like the Pascal VOC dataset, and None to exclude these layers
entirely.
Returns:
The keras `Model`.
"""
if activation not in ['softmax', 'sigmoid', None]:
raise ValueError(
'activation must be one of "softmax", "sigmoid", or None')
if activation == 'sigmoid' and classes != 1:
raise ValueError(
'sigmoid activation can only be used when classes = 1')
if repetitions is None:
repetitions = [3, 4, 6, 3]
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=32,
min_size=8,
data_format=K.image_data_format(),
require_flatten=include_top)
_handle_dim_ordering()
if len(input_shape) != 3:
raise Exception(
"Input shape should be a tuple (nb_channels, nb_rows, nb_cols)")
if block == 'basic':
block_fn = basic_block
elif block == 'bottleneck':
block_fn = bottleneck
elif isinstance(block, six.string_types):
block_fn = _string_to_function(block)
else:
block_fn = block
if residual_unit == 'v2':
residual_unit = _bn_relu_conv
elif residual_unit == 'v1':
residual_unit = _conv_bn_relu
elif isinstance(residual_unit, six.string_types):
residual_unit = _string_to_function(residual_unit)
else:
residual_unit = residual_unit
# Permute dimension order if necessary
if K.image_data_format() == 'channels_first':
input_shape = (input_shape[1], input_shape[2], input_shape[0])
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=32,
min_size=8,
data_format=K.image_data_format(),
require_flatten=include_top)
img_input = Input(shape=input_shape, tensor=input_tensor)
x = _conv_bn_relu(filters=initial_filters,
kernel_size=initial_kernel_size,
strides=initial_strides)(img_input)
if initial_pooling == 'max':
x = MaxPooling2D(pool_size=(3, 3),
strides=initial_strides,
padding="same")(x)
block = x
filters = initial_filters
for i, r in enumerate(repetitions):
transition_dilation_rates = [transition_dilation_rate] * r
transition_strides = [(1, 1)] * r
if transition_dilation_rate == (1, 1):
transition_strides[0] = (2, 2)
block = _residual_block(
block_fn,
filters=filters,
stage=i,
blocks=r,
is_first_layer=(i == 0),
dropout=dropout,
transition_dilation_rates=transition_dilation_rates,
transition_strides=transition_strides,
residual_unit=residual_unit)(block)
filters *= 2
# Last activation
x = _bn_relu(block)
# Classifier block
if include_top and top is 'classification':
x = GlobalAveragePooling2D()(x)
x = Dense(units=classes,
activation=activation,
kernel_initializer="he_normal")(x)
elif include_top and top is 'segmentation':
x = Conv2D(classes, (1, 1), activation='linear', padding='same')(x)
if K.image_data_format() == 'channels_first':
channel, row, col = input_shape
else:
row, col, channel = input_shape
x = Reshape((row * col, classes))(x)
x = Activation(activation)(x)
x = Reshape((row, col, classes))(x)
elif final_pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif final_pooling == 'max':
x = GlobalMaxPooling2D()(x)
model = Model(inputs=img_input, outputs=x)
return model
def build(width, height, depth, classes, reg=0.0002):
# initialize the model along with the input shape to be
# "channels last" and the channels dimension itself
model = Sequential()
inputShape = (height, width, depth)
chanDim = -1
# if we are using "channels first", update the input shape
# and channels dimension
if K.image_data_format() == "channels_first":
inputShape = (depth, height, width)
chanDim = 1
# Block #1: first CONV => RELU => POOL layer set
model.add(
Conv2D(96, (11, 11),
strides=(4, 4),
input_shape=inputShape,
padding="same",
kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
# Block #2: second CONV => RELU => POOL layer set
model.add(
Conv2D(256, (5, 5), padding="same", kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
# Block #3: CONV => RELU => CONV => RELU => CONV => RELU
model.add(
Conv2D(384, (3, 3), padding="same", kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization(axis=chanDim))
model.add(
Conv2D(384, (3, 3), padding="same", kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization(axis=chanDim))
model.add(
Conv2D(256, (3, 3), padding="same", kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
# Block #4: first set of FC => RELU layers
model.add(Flatten())
model.add(Dense(4096, kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization())
model.add(Dropout(0.5))
# Block #5: second set of FC => RELU layers
model.add(Dense(4096, kernel_regularizer=l2(reg)))
model.add(Activation("relu"))
model.add(BatchNormalization())
model.add(Dropout(0.5))
# softmax classifier
model.add(Dense(classes, kernel_regularizer=l2(reg)))
model.add(Activation("softmax"))
# return the constructed network architecture
return model
def resnet(weights=None, input_shape=(8, 8, 13), classes=2):
"""Instantiates an adapted ResNet architecture.
Note that when using TensorFlow,
for best performance you should set
`image_data_format="channels_last"` in your Keras config
at ~/.keras/keras.json.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or "imagenet" (pre-training on ImageNet).
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, 244)` (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.
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.
"""
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
img_input = Input(shape=input_shape)
if k.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
x = ZeroPadding2D((3, 3))(img_input)
x = Conv2D(64, (3, 3), strides=(1, 1), name='conv1')(x)
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(1, 1))(x)
x = conv_block(x, 3, [64, 64, 128], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 128], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 128], stage=2, block='c')
x = conv_block(x, 3, [128, 128, 256], stage=3, block='a', strides=(1, 1))
x = identity_block(x, 3, [128, 128, 256], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 256], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 256], stage=3, block='d')
x = conv_block(x, 3, [256, 256, 512], stage=4, block='a', strides=(1, 1))
x = identity_block(x, 3, [256, 256, 512], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 512], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 512], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 512], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 512], stage=4, block='f')
x = conv_block(x, 3, [512, 512, 1024], stage=5, block='a', strides=(1, 1))
x = identity_block(x, 3, [512, 512, 1024], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 1024], stage=5, block='c')
x = AveragePooling2D((7, 7), name='avg_pool')(x)
x = Flatten()(x)
x = Dense(classes, activation='softmax', name='fc1000')(x)
# Create model.
model = Model(img_input, x, name='resnet')
return model
def EfficientNet(width_coefficient,
depth_coefficient,
default_resolution,
dropout_rate=0.2,
drop_connect_rate=0.2,
depth_divisor=8,
blocks_args=DEFAULT_BLOCKS_ARGS,
model_name='EfficientNet',
include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the EfficientNet architecture using given scaling coefficients.
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
width_coefficient: float, scaling coefficient for network width.
depth_coefficient: float, scaling coefficient for network depth.
default_resolution: int, default input image size.
dropout_rate: float, dropout rate before final classifier layer.
drop_connect_rate: float, dropout rate at skip connections.
depth_divisor: int.
blocks_args: A list of BlockArgs to construct block modules.
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.
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.
"""
if not (weights in {'imagenet', 'noisy-student', 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
input_shape = _obtain_input_shape(input_shape,
default_size=default_resolution,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if backend.backend() == 'tensorflow':
from tensorflow.python.keras.backend import is_keras_tensor
else:
is_keras_tensor = backend.is_keras_tensor
if not 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
activation = get_swish()
# Build stem
x = img_input
x = layers.Conv2D(round_filters(32, width_coefficient, depth_divisor),
3,
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='stem_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name='stem_bn')(x)
x = layers.Activation(activation, name='stem_activation')(x)
# Build blocks
num_blocks_total = sum(block_args.num_repeat for block_args in blocks_args)
block_num = 0
for idx, block_args in enumerate(blocks_args):
assert block_args.num_repeat > 0
# Update block input and output filters based on depth multiplier.
block_args = block_args._replace(
input_filters=round_filters(block_args.input_filters,
width_coefficient, depth_divisor),
output_filters=round_filters(block_args.output_filters,
width_coefficient, depth_divisor),
num_repeat=round_repeats(block_args.num_repeat, depth_coefficient))
# The first block needs to take care of stride and filter size increase.
drop_rate = drop_connect_rate * float(block_num) / num_blocks_total
x = mb_conv_block(x,
block_args,
activation=activation,
drop_rate=drop_rate,
prefix='block{}a_'.format(idx + 1))
block_num += 1
if block_args.num_repeat > 1:
block_args = block_args._replace(
input_filters=block_args.output_filters, strides=[1, 1])
for bidx in xrange(block_args.num_repeat - 1):
drop_rate = drop_connect_rate * float(
block_num) / num_blocks_total
block_prefix = 'block{}{}_'.format(
idx + 1, string.ascii_lowercase[bidx + 1])
x = mb_conv_block(x,
block_args,
activation=activation,
drop_rate=drop_rate,
prefix=block_prefix)
block_num += 1
# Build top
x = layers.Conv2D(round_filters(1280, width_coefficient, depth_divisor),
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='top_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name='top_bn')(x)
x = layers.Activation(activation, name='top_activation')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
if dropout_rate and 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)
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 = utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name=model_name)
# Load weights.
if weights == 'imagenet':
if include_top:
file_name = model_name + '_AutoAugment.h5'
else:
file_name = model_name + '_AutoAugment_NoTop.h5'
model.load_weights(os.path.join(os.path.dirname(__file__), file_name))
elif weights == 'noisy-student':
if include_top:
file_name = "{}_{}.h5".format(model_name, 'NoisyStudent')
else:
file_name = "{}_{}_NoTop.h5".format(model_name, 'NoisyStudent')
model.load_weights(os.path.join(os.path.dirname(__file__), file_name))
elif weights is not None:
model.load_weights(weights)
return model
def DualPathNetwork(input_shape=None,
initial_conv_filters=64,
depth=[3, 4, 20, 3],
filter_increment=[16, 32, 24, 128],
cardinality=32,
width=3,
weight_decay=0,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000):
""" Instantiate the Dual Path Network architecture for the ImageNet dataset. Note that ,
when using TensorFlow for best performance you should set
`image_data_format="channels_last"` in your Keras config
at ~/.keras/keras.json.
The model are compatible with both
TensorFlow and Theano. The dimension ordering
convention used by the model is the one
specified in your Keras config file.
# Arguments
initial_conv_filters: number of features for the initial convolution
depth: number or layers in the each block, defined as a list.
DPN-92 = [3, 4, 20, 3]
DPN-98 = [3, 6, 20, 3]
DPN-131 = [4, 8, 28, 3]
DPN-107 = [4, 8, 20, 3]
filter_increment: number of filters incremented per block, defined as a list.
DPN-92 = [16, 32, 24, 128]
DON-98 = [16, 32, 32, 128]
DPN-131 = [16, 32, 32, 128]
DPN-107 = [20, 64, 64, 128]
cardinality: the size of the set of transformations
width: width multiplier for the network
weight_decay: weight decay (l2 norm)
include_top: whether to include the fully-connected
layer at the top of the network.
weights: `None` (random initialization) or `imagenet` (trained
on ImageNet)
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 `tf` dim ordering)
or `(3, 224, 224)` (with `th` dim ordering).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 8.
E.g. `(200, 200, 3)` would be one valid value.
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.
- `max-avg` means that both global average and global max
pooling will be applied to the output of the last
convolution layer
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.
"""
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
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')
assert len(depth) == len(filter_increment), "The length of filter increment list must match the length " \
"of the depth list."
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=112,
data_format=K.image_data_format(),
require_flatten=include_top)
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
x = _create_dpn(classes, img_input, include_top, initial_conv_filters,
filter_increment, depth, cardinality, width, weight_decay,
pooling)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='resnext')
# load weights
return model
def _create_dpn(nb_classes,
img_input,
include_top,
initial_conv_filters,
filter_increment,
depth,
cardinality=32,
width=3,
weight_decay=5e-4,
pooling=None):
''' Creates a ResNeXt model with specified parameters
Args:
initial_conv_filters: number of features for the initial convolution
include_top: Flag to include the last dense layer
initial_conv_filters: number of features for the initial convolution
filter_increment: number of filters incremented per block, defined as a list.
DPN-92 = [16, 32, 24, 128]
DON-98 = [16, 32, 32, 128]
DPN-131 = [16, 32, 32, 128]
DPN-107 = [20, 64, 64, 128]
depth: number or layers in the each block, defined as a list.
DPN-92 = [3, 4, 20, 3]
DPN-98 = [3, 6, 20, 3]
DPN-131 = [4, 8, 28, 3]
DPN-107 = [4, 8, 20, 3]
width: width multiplier for network
weight_decay: weight_decay (l2 norm)
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.
- `max-avg` means that both global average and global max
pooling will be applied to the output of the last
convolution layer
Returns: a Keras Model
'''
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
N = list(depth)
base_filters = 256
# block 1 (initial conv block)
x = _initial_conv_block_inception(img_input, initial_conv_filters,
weight_decay)
# block 2 (projection block)
filter_inc = filter_increment[0]
filters = int(cardinality * width)
x = _dual_path_block(x,
pointwise_filters_a=filters,
grouped_conv_filters_b=filters,
pointwise_filters_c=base_filters,
filter_increment=filter_inc,
cardinality=cardinality,
block_type='projection')
for i in range(N[0] - 1):
x = _dual_path_block(x,
pointwise_filters_a=filters,
grouped_conv_filters_b=filters,
pointwise_filters_c=base_filters,
filter_increment=filter_inc,
cardinality=cardinality,
block_type='normal')
# remaining blocks
for k in range(1, len(N)):
print("BLOCK %d" % (k + 1))
filter_inc = filter_increment[k]
filters *= 2
base_filters *= 2
x = _dual_path_block(x,
pointwise_filters_a=filters,
grouped_conv_filters_b=filters,
pointwise_filters_c=base_filters,
filter_increment=filter_inc,
cardinality=cardinality,
block_type='downsample')
for i in range(N[k] - 1):
x = _dual_path_block(x,
pointwise_filters_a=filters,
grouped_conv_filters_b=filters,
pointwise_filters_c=base_filters,
filter_increment=filter_inc,
cardinality=cardinality,
block_type='normal')
x = concatenate(x, axis=channel_axis)
if include_top:
avg = GlobalAveragePooling2D()(x)
max = GlobalMaxPooling2D()(x)
x = add([avg, max])
x = Lambda(lambda z: 0.5 * z)(x)
x = Dense(nb_classes,
use_bias=False,
kernel_regularizer=l2(weight_decay),
kernel_initializer='he_normal',
activation='softmax')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
elif pooling == 'max-avg':
a = GlobalMaxPooling2D()(x)
b = GlobalAveragePooling2D()(x)
x = add([a, b])
x = Lambda(lambda z: 0.5 * z)(x)
return x
def _dual_path_block(input,
pointwise_filters_a,
grouped_conv_filters_b,
pointwise_filters_c,
filter_increment,
cardinality,
block_type='normal'):
'''
Creates a Dual Path Block. The first path is a ResNeXt type
grouped convolution block. The second is a DenseNet type dense
convolution block.
Args:
input: input tensor
pointwise_filters_a: number of filters for the bottleneck
pointwise convolution
grouped_conv_filters_b: number of filters for the grouped
convolution block
pointwise_filters_c: number of filters for the bottleneck
convolution block
filter_increment: number of filters that will be added
cardinality: cardinality factor
block_type: determines what action the block will perform
- `projection`: adds a projection connection
- `downsample`: downsamples the spatial resolution
- `normal` : simple adds a dual path connection
Returns: a list of two output tensors - one path of ResNeXt
and another path for DenseNet
'''
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
grouped_channels = int(grouped_conv_filters_b / cardinality)
init = concatenate(input, axis=channel_axis) if isinstance(input,
list) else input
if block_type == 'projection':
stride = (1, 1)
projection = True
elif block_type == 'downsample':
stride = (2, 2)
projection = True
elif block_type == 'normal':
stride = (1, 1)
projection = False
else:
raise ValueError(
'`block_type` must be one of ["projection", "downsample", "normal"]. Given %s'
% block_type)
if projection:
projection_path = _bn_relu_conv_block(init,
filters=pointwise_filters_c +
2 * filter_increment,
kernel=(1, 1),
stride=stride)
input_residual_path = Lambda(
lambda z: z[:, :, :, :pointwise_filters_c] if K.image_data_format(
) == 'channels_last' else z[:, :pointwise_filters_c, :, :])(
projection_path)
input_dense_path = Lambda(
lambda z: z[:, :, :, pointwise_filters_c:] if K.image_data_format(
) == 'channels_last' else z[:, pointwise_filters_c:, :, :])(
projection_path)
else:
input_residual_path = input[0]
input_dense_path = input[1]
x = _bn_relu_conv_block(init, filters=pointwise_filters_a, kernel=(1, 1))
x = _grouped_convolution_block(x,
grouped_channels=grouped_channels,
cardinality=cardinality,
strides=stride)
x = _bn_relu_conv_block(x,
filters=pointwise_filters_c + filter_increment,
kernel=(1, 1))
output_residual_path = Lambda(lambda z: z[:, :, :, :pointwise_filters_c]
if K.image_data_format() == 'channels_last'
else z[:, :pointwise_filters_c, :, :])(x)
output_dense_path = Lambda(lambda z: z[:, :, :, pointwise_filters_c:]
if K.image_data_format() == 'channels_last' else
z[:, pointwise_filters_c:, :, :])(x)
residual_path = add([input_residual_path, output_residual_path])
dense_path = concatenate([input_dense_path, output_dense_path],
axis=channel_axis)
return [residual_path, dense_path]
def train(params_names, train_path, valid_path):
HEIGHT = 178
WIDTH = 87
BATCH_SIZE = 256
EPOCHS_NUM = 1000
train_df, valid_df, train_min_max, valid_min_max = create_train_valid_dataframe(
train_path, valid_path)
print("Min & Max value from train_min_max:")
for t in train_min_max:
t.print_min_max()
print("Min & Max value from valid_min_max:")
for v in valid_min_max:
v.print_min_max()
# create generator
datagen = ImageDataGenerator(rescale=1. / 255, zoom_range=0.1)
train_it = datagen.flow_from_dataframe(dataframe=train_df,
x_col='path',
y_col=params_names,
batch_size=BATCH_SIZE,
shuffle=True,
class_mode="raw",
target_size=(178, 87),
color_mode='grayscale')
valid_it = datagen.flow_from_dataframe(dataframe=valid_df,
x_col='path',
y_col=params_names,
batch_size=BATCH_SIZE,
shuffle=True,
class_mode="raw",
target_size=(178, 87),
color_mode='grayscale')
if K.image_data_format() == 'channels_first':
input_shape = (1, HEIGHT, WIDTH)
else:
input_shape = (HEIGHT, WIDTH, 1)
model = conv_predict(input_shape, out_num=len(params_names))
tbCallBack = TensorBoard(log_dir='./Graph/{}'.format(time()),
histogram_freq=0,
write_graph=True,
write_images=True)
history = model.fit_generator(train_it,
epochs=EPOCHS_NUM,
validation_data=valid_it,
validation_steps=8,
steps_per_epoch=16,
callbacks=[tbCallBack],
use_multiprocessing=True)
model.save(FLAGS.model_name + ".h5")
# Write the net summary
with open(FLAGS.model_name + '_summary.txt', 'w') as fh:
# Pass the file handle in as a lambda function to make it callable
model.summary(print_fn=lambda x: fh.write(x + '\n'))
print("Saved model to disk")
plot_training(history)
return model, train_min_max
def test_keras_cnn(self):
if is_tf2:
import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras import backend as K
from tensorflow.keras.utils import to_categorical
else:
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
from keras.utils import to_categorical
from tensorflow.python.util import deprecation
deprecation._PRINT_DEPRECATION_WARNINGS = False
from datetime import datetime
begin = datetime.now()
batch_size = 128
num_classes = 10
epochs = 5
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
# convert class vectors to binary class matrices
y_train = to_categorical(y_train, num_classes)
y_test = to_categorical(y_test, num_classes)
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=0,
validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
self.assertLessEqual(score[0], 0.06)
self.assertGreaterEqual(score[1], 0.97)
end = datetime.now()
secs = (end - begin).total_seconds()
print('Took {} seconds'.format(secs))
self.assertLessEqual(secs, 80)
def __init__(self,
image_size,
channels,
conv_layers,
feature_maps,
filter_shapes,
strides,
dense_layers,
dense_neurons,
dense_dropouts,
latent_dim,
activation='relu',
eps_mean=0.0,
eps_std=1.0):
self.history = LossHistory()
# check that arguments are proper length;
if len(filter_shapes) != conv_layers:
raise Exception(
"number of convolutional layers must equal length of filter_shapes list"
)
if len(strides) != conv_layers:
raise Exception(
"number of convolutional layers must equal length of strides list"
)
if len(feature_maps) != conv_layers:
raise Exception(
"number of convolutional layers must equal length of feature_maps list"
)
if len(dense_neurons) != dense_layers:
raise Exception(
"number of dense layers must equal length of dense_neurons list"
)
if len(dense_dropouts) != dense_layers:
raise Exception(
"number of dense layers must equal length of dense_dropouts list"
)
# even shaped filters may cause problems in theano backend;
even_filters = [
f for pair in filter_shapes for f in pair if f % 2 == 0
]
if K.image_data_format() == 'th' and len(even_filters) > 0:
warnings.warn(
'Even shaped filters may cause problems in Theano backend')
if K.image_data_format() == 'channels_first' and len(even_filters) > 0:
warnings.warn(
'Even shaped filters may cause problems in Theano backend')
self.eps_mean = eps_mean
self.eps_std = eps_std
self.image_size = image_size
# define input layer;
if K.image_data_format() == 'th' or K.image_data_format(
) == 'channels_first':
self.input = Input(shape=(channels, image_size[0], image_size[1]))
else:
self.input = Input(shape=(image_size[0], image_size[1], channels))
# define convolutional encoding layers;
self.encode_conv = []
layer = Convolution2D(feature_maps[0],
filter_shapes[0],
padding='same',
activation=activation,
strides=strides[0])(self.input)
self.encode_conv.append(layer)
for i in range(1, conv_layers):
layer = Convolution2D(feature_maps[i],
filter_shapes[i],
padding='same',
activation=activation,
strides=strides[i])(self.encode_conv[i - 1])
self.encode_conv.append(layer)
# define dense encoding layers;
self.flat = Flatten()(self.encode_conv[-1])
self.encode_dense = []
layer = Dense(dense_neurons[0], activation=activation)(Dropout(
dense_dropouts[0])(self.flat))
self.encode_dense.append(layer)
for i in range(1, dense_layers):
layer = Dense(dense_neurons[i], activation=activation)(Dropout(
dense_dropouts[i])(self.encode_dense[i - 1]))
self.encode_dense.append(layer)
# define embedding layer;
self.z_mean = Dense(latent_dim,
dtype=tf.float32)(self.encode_dense[-1])
self.z_log_var = Dense(latent_dim,
dtype=tf.float32)(self.encode_dense[-1])
self.z = Lambda(self._sampling, output_shape=(latent_dim, ))(
[self.z_mean, self.z_log_var])
# save all decoding layers for generation model;
self.all_decoding = []
# define dense decoding layers;
self.decode_dense = []
layer = Dense(dense_neurons[-1], activation=activation)
self.all_decoding.append(layer)
self.decode_dense.append(layer(self.z))
for i in range(1, dense_layers):
layer = Dense(dense_neurons[-i - 1], activation=activation)
self.all_decoding.append(layer)
self.decode_dense.append(layer(self.decode_dense[i - 1]))
# dummy model to get image size after encoding convolutions;
self.decode_conv = []
if K.image_data_format() == 'th' or K.image_data_format(
) == 'channels_first':
dummy_input = np.ones((1, channels, image_size[0], image_size[1]))
else:
dummy_input = np.ones((1, image_size[0], image_size[1], channels))
dummy = Model(self.input, self.encode_conv[-1])
conv_size = dummy.predict(dummy_input).shape
layer = Dense(conv_size[1] * conv_size[2] * conv_size[3],
activation=activation)
self.all_decoding.append(layer)
self.decode_dense.append(layer(self.decode_dense[-1]))
reshape = Reshape(conv_size[1:])
self.all_decoding.append(reshape)
self.decode_conv.append(reshape(self.decode_dense[-1]))
# define deconvolutional decoding layers;
for i in range(1, conv_layers):
if K.image_data_format() == 'th' or K.image_data_format(
) == 'channels_first':
dummy_input = np.ones(
(1, channels, image_size[0], image_size[1]))
else:
dummy_input = np.ones(
(1, image_size[0], image_size[1], channels))
dummy = Model(self.input, self.encode_conv[-i - 1])
conv_size = list(dummy.predict(dummy_input).shape)
if K.image_data_format() == 'th' or K.image_data_format(
) == 'channels_first':
conv_size[1] = feature_maps[-i]
else:
conv_size[3] = feature_maps[-i]
layer = Conv2DTranspose(feature_maps[-i - 1],
filter_shapes[-i],
padding='same',
activation=activation,
strides=strides[-i])
self.all_decoding.append(layer)
self.decode_conv.append(layer(self.decode_conv[i - 1]))
layer = Conv2DTranspose(channels,
filter_shapes[0],
padding='same',
activation='sigmoid',
strides=strides[0])
self.all_decoding.append(layer)
layer = Conv2DTranspose(channels,
filter_shapes[0],
padding='same',
activation='sigmoid',
strides=strides[0],
dtype='float32')
self.output = layer(self.decode_conv[-1])
# build model;
self.model = Model(self.input, self.output)
print(self.model.predict(dummy_input).shape)
#Adam
lr_scaler = hvd.size()
self.optimizer = Adam(lr=0.001 * lr_scaler,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-07,
amsgrad=True)
#SGD optimizer
#self.optimizer = SGD(lr=0.001, nesterov=True)
#RMSProp optimizer
#self.optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
# Add Horovod Distributed Optimize
self.optimizer = hvd.DistributedOptimizer(self.optimizer,
op=hvd.Average)
# tf.train.experimental.enable_mixed_precision_graph_rewrite(
# self.optimizer, loss_scale='dynamic' )
self.model.compile(
optimizer=self.optimizer,
loss=self._vae_loss,
experimental_run_tf_function=False) #, metrics=[kl_loss])
print("model summary:")
self.model.summary()
# model for embeddings;
self.embedder = Model(self.input, self.z_mean)
# model for generation;
self.decoder_input = Input(shape=(latent_dim, ))
self.generation = []
self.generation.append(self.all_decoding[0](self.decoder_input))
for i in range(1, len(self.all_decoding)):
self.generation.append(self.all_decoding[i](self.generation[i -
1]))
self.generator = Model(self.decoder_input, self.generation[-1])
def simple_transfer_learning_cnn_mnist_example():
batch_size = 128
num_classes = 5
epochs = 5
# Input image dimensions.
img_rows, img_cols = 28, 28
# Number of convolutional filters to use.
filters = 32
# Size of pooling area for max pooling.
pool_size = 2
# Convolution kernel size.
kernel_size = 3
if K.image_data_format() == 'channels_first':
input_shape = (1, img_rows, img_cols)
else:
input_shape = (img_rows, img_cols, 1)
#--------------------
# The data, split between train and test sets.
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Create two datasets one with digits below 5 and one with 5 and above.
x_train_lt5 = x_train[y_train < 5]
y_train_lt5 = y_train[y_train < 5]
x_test_lt5 = x_test[y_test < 5]
y_test_lt5 = y_test[y_test < 5]
x_train_gte5 = x_train[y_train >= 5]
y_train_gte5 = y_train[y_train >= 5] - 5
x_test_gte5 = x_test[y_test >= 5]
y_test_gte5 = y_test[y_test >= 5] - 5
#--------------------
# Define two groups of layers: feature (convolutions) and classification (dense).
feature_layers = [
Conv2D(filters, kernel_size, padding='valid', input_shape=input_shape),
Activation('relu'),
Conv2D(filters, kernel_size),
Activation('relu'),
MaxPooling2D(pool_size=pool_size),
Dropout(0.25),
Flatten(),
]
classification_layers = [
Dense(128),
Activation('relu'),
Dropout(0.5),
Dense(num_classes),
Activation('softmax')
]
# Create complete model.
model = Sequential(feature_layers + classification_layers)
#--------------------
# Train model for 5-digit classification [0..4].
train_model(model, (x_train_lt5, y_train_lt5), (x_test_lt5, y_test_lt5),
num_classes, input_shape, batch_size, epochs)
# Freeze feature layers and rebuild model.
for layer in feature_layers:
layer.trainable = False
#--------------------
# Transfer: train dense layers for new classification task [5..9].
train_model(model, (x_train_gte5, y_train_gte5),
(x_test_gte5, y_test_gte5), num_classes, input_shape,
batch_size, epochs)
def main(args):
# Horovod: initialize Horovod.
hvd.init()
if not args.use_only_cpu:
# Horovod: pin GPU to be used to process local rank (one GPU per process)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.gpu_options.visible_device_list = str(hvd.local_rank())
else:
config = None
K.set_session(tf.Session(config=config))
batch_size = 128
num_classes = 10
# Horovod: adjust number of epochs based on number of GPUs.
epochs = int(math.ceil(args.num_epochs / hvd.size()))
# Input image dimensions
img_rows, img_cols = 28, 28
# The data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == "channels_first":
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype("float32")
x_test = x_test.astype("float32")
x_train /= 255
x_test /= 255
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")
# Convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation="relu",
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation="softmax"))
# Horovod: adjust learning rate based on number of GPUs.
opt = keras.optimizers.Adadelta(1.0 * hvd.size())
# Horovod: add Horovod Distributed Optimizer.
opt = hvd.DistributedOptimizer(opt)
##### Enabling SageMaker Debugger ###########
# Create hook from the configuration provided through sagemaker python sdk
smd_hook = smd.KerasHook.create_from_json_file()
##### Enabling SageMaker Debugger ###########
# wrap the optimizer so the hook can identify the gradients
opt = smd_hook.wrap_optimizer(opt)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=["accuracy"])
callbacks = [
# Horovod: broadcast initial variable states from rank 0 to all other processes.
# This is necessary to ensure consistent initialization of all workers when
# training is started with random weights or restored from a checkpoint.
hvd.callbacks.BroadcastGlobalVariablesCallback(0),
##### Enabling SageMaker Debugger ###########
# pass smd_hook as a callback
smd_hook,
]
# Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them.
if hvd.rank() == 0:
callbacks.append(
keras.callbacks.ModelCheckpoint(
os.path.join(args.model_dir, "checkpoint-{epoch}.h5")))
model.fit(
x_train,
y_train,
batch_size=batch_size,
callbacks=callbacks,
epochs=epochs,
verbose=1 if hvd.rank() == 0 else 0,
validation_data=(x_test, y_test),
)
score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])
def get_layer_neuronwise_io(layer,
node_index=0,
Xs=None,
Ys=None,
return_i=True,
return_o=True):
"""Returns the input and output for each neuron in a layer
Returns the symbolic input and output for each neuron in a layer.
For a dense layer this is the input output itself.
For convolutional layers this method extracts for each neuron
the input output mapping.
At the moment this function is designed
to work with dense and conv2d layers.
:param layer: The targeted layer.
:param node_index: Index of the layer node to use.
:param Xs: Ignore the layer's input but use Xs instead.
:param Ys: Ignore the layer's output but use Ys instead.
:param return_i: Return the inputs.
:param return_o: Return the outputs.
:return: Inputs and outputs, if specified, for each individual neuron.
"""
if not kchecks.contains_kernel(layer):
raise NotImplementedError()
if Xs is None:
Xs = iutils.to_list(layer.get_input_at(node_index))
if Ys is None:
Ys = iutils.to_list(layer.get_output_at(node_index))
if isinstance(layer, tensorflow.keras.layers.Dense):
# Xs and Ys are already in shape.
ret_Xs = Xs
ret_Ys = Ys
elif isinstance(layer, tensorflow.keras.layers.Conv2D):
kernel = get_kernel(layer)
# Expect filter dimension to be last.
n_channels = kernel.shape[-1]
if return_i:
extract_patches = ilayers.ExtractConv2DPatches(kernel.shape[:2],
kernel.shape[2],
layer.strides,
layer.dilation_rate,
layer.padding)
# shape [samples, out_row, out_col, weight_size]
reshape = ilayers.Reshape((-1, np.product(kernel.shape[:3])))
ret_Xs = [reshape(extract_patches(x)) for x in Xs]
if return_o:
# Get Ys into shape (samples, channels)
if K.image_data_format() == "channels_first":
# Ys shape is [samples, channels, out_row, out_col]
def reshape(x):
x = ilayers.Transpose((0, 2, 3, 1))(x)
x = ilayers.Reshape((-1, n_channels))(x)
return x
else:
# Ys shape is [samples, out_row, out_col, channels]
def reshape(x):
x = ilayers.Reshape((-1, n_channels))(x)
return x
ret_Ys = [reshape(x) for x in Ys]
else:
raise NotImplementedError()
# Xs is (n, d) and Ys is (d, channels)
if return_i and return_o:
return ret_Xs, ret_Ys
elif return_i:
return ret_Xs
elif return_o:
return ret_Ys
else:
raise Exception()
print(type(self.output_shape_))
print(type(self.output_shape_[0]))
return self.output_shape_
batch_size = 128
num_classes = 10
epochs = 2
# input image dimensions
img_rows, img_cols = 28, 28
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
def get_mobilenet_encoder(input_height=224,
input_width=224,
pretrained='imagenet'):
# todo add more alpha and stuff
assert (K.image_data_format() == 'channels_last'
), "Currently only channels last mode is supported"
assert (IMAGE_ORDERING == 'channels_last'
), "Currently only channels last mode is supported"
assert (input_height == 224), \
"For mobilenet , 224 input_height is supported "
assert (input_width == 224), "For mobilenet , 224 width is supported "
assert input_height % 32 == 0
assert input_width % 32 == 0
alpha = 1.0
depth_multiplier = 1
dropout = 1e-3
img_input = Input(shape=(input_height, input_width, 3))
x = _conv_block(img_input, 32, alpha, strides=(2, 2))
x = _depthwise_conv_block(x, 64, alpha, depth_multiplier, block_id=1)
f1 = x
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)
f2 = x
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)
f3 = x
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)
f4 = x
x = _depthwise_conv_block(x,
1024,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=12)
x = _depthwise_conv_block(x, 1024, alpha, depth_multiplier, block_id=13)
f5 = x
if pretrained == 'imagenet':
model_name = 'mobilenet_%s_%d_tf_no_top.h5' % ('1_0', 224)
weight_path = BASE_WEIGHT_PATH + model_name
weights_path = keras.utils.get_file(model_name, weight_path)
Model(img_input, x).load_weights(weights_path)
return img_input, [f1, f2, f3, f4, f5]
from tensorflow.keras import utils, backend, datasets
from FinalPractice.AutoML.model import AutoML
# Load and transform data for model
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
img_rows, img_cols = 28, 28
num_classes = 10
if backend.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
y_train = utils.to_categorical(y_train, num_classes)
y_test = utils.to_categorical(y_test, num_classes)
model = AutoML()
model.fit(x_train,
y_train,
x_test,
y_test,
train_epochs=10,
search_epochs=500,
input_shape=input_shape,
num_classes=num_classes,
batch_size=10000,
def mb_conv_block(inputs,
block_args,
activation,
drop_rate=None,
prefix='',
freeze_bn=False):
"""Mobile Inverted Residual Bottleneck."""
has_se = (block_args.se_ratio
is not None) and (0 < block_args.se_ratio <= 1)
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
# Expansion phase
filters = block_args.input_filters * block_args.expand_ratio
if block_args.expand_ratio != 1:
x = layers.Conv2D(filters,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'expand_conv')(inputs)
x = layers.BatchNormalization(axis=bn_axis,
name=prefix + 'expand_bn')(x)
x = layers.Activation(activation, name=prefix + 'expand_activation')(x)
else:
x = inputs
# Depthwise Convolution
x = layers.DepthwiseConv2D(block_args.kernel_size,
strides=block_args.strides,
padding='same',
use_bias=False,
depthwise_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'dwconv')(x)
x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'bn')(x)
x = layers.Activation(activation, name=prefix + 'activation')(x)
# Squeeze and Excitation phase
if has_se:
num_reduced_filters = max(
1, int(block_args.input_filters * block_args.se_ratio))
se_tensor = layers.GlobalAveragePooling2D(name=prefix +
'se_squeeze')(x)
target_shape = (
1, 1,
filters) if backend.image_data_format() == 'channels_last' else (
filters, 1, 1)
se_tensor = layers.Reshape(target_shape,
name=prefix + 'se_reshape')(se_tensor)
se_tensor = layers.Conv2D(num_reduced_filters,
1,
activation=activation,
padding='same',
use_bias=True,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'se_reduce')(se_tensor)
se_tensor = layers.Conv2D(filters,
1,
activation='sigmoid',
padding='same',
use_bias=True,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'se_expand')(se_tensor)
x = layers.multiply([x, se_tensor], name=prefix + 'se_excite')
# Output phase
x = layers.Conv2D(block_args.output_filters,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'project_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'project_bn')(x)
if block_args.id_skip and all(
s == 1 for s in block_args.strides
) and block_args.input_filters == block_args.output_filters:
if drop_rate and (drop_rate > 0):
x = FixedDropout(drop_rate,
noise_shape=(None, 1, 1, 1),
name=prefix + 'drop')(x)
x = layers.add([x, inputs], name=prefix + 'add')
return x
def InceptionResNetV1(input_shape=(160, 160, 3)):
inputs = Input(shape=input_shape)
x = conv2d_bn(inputs,
32,
3,
strides=2,
padding='valid',
name='Conv2d_1a_3x3')
x = conv2d_bn(x, 32, 3, padding='valid', name='Conv2d_2a_3x3')
x = conv2d_bn(x, 64, 3, name='Conv2d_2b_3x3')
x = MaxPooling2D(3, strides=2, name='MaxPool_3a_3x3')(x)
x = conv2d_bn(x, 80, 1, padding='valid', name='Conv2d_3b_1x1')
x = conv2d_bn(x, 192, 3, padding='valid', name='Conv2d_4a_3x3')
x = conv2d_bn(x, 256, 3, strides=2, padding='valid', name='Conv2d_4b_3x3')
# 5x Block35 (Inception-ResNet-A block):
for block_idx in range(1, 6):
x = _inception_resnet_block(x,
scale=0.17,
block_type='Block35',
block_idx=block_idx)
# Mixed 6a (Reduction-A block):
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
name_fmt = partial(_generate_layer_name, prefix='Mixed_6a')
branch_0 = conv2d_bn(x,
384,
3,
strides=2,
padding='valid',
name=name_fmt('Conv2d_1a_3x3', 0))
branch_1 = conv2d_bn(x, 192, 1, name=name_fmt('Conv2d_0a_1x1', 1))
branch_1 = conv2d_bn(branch_1, 192, 3, name=name_fmt('Conv2d_0b_3x3', 1))
branch_1 = conv2d_bn(branch_1,
256,
3,
strides=2,
padding='valid',
name=name_fmt('Conv2d_1a_3x3', 1))
branch_pool = MaxPooling2D(3,
strides=2,
padding='valid',
name=name_fmt('MaxPool_1a_3x3', 2))(x)
branches = [branch_0, branch_1, branch_pool]
x = Concatenate(axis=channel_axis, name='Mixed_6a')(branches)
# 10x Block17 (Inception-ResNet-B block):
for block_idx in range(1, 11):
x = _inception_resnet_block(x,
scale=0.1,
block_type='Block17',
block_idx=block_idx)
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
name_fmt = partial(_generate_layer_name, prefix='Mixed_7a')
branch_0 = conv2d_bn(x, 256, 1, name=name_fmt('Conv2d_0a_1x1', 0))
branch_0 = conv2d_bn(branch_0,
384,
3,
strides=2,
padding='valid',
name=name_fmt('Conv2d_1a_3x3', 0))
branch_1 = conv2d_bn(x, 256, 1, name=name_fmt('Conv2d_0a_1x1', 1))
branch_1 = conv2d_bn(branch_1,
256,
3,
strides=2,
padding='valid',
name=name_fmt('Conv2d_1a_3x3', 1))
branch_2 = conv2d_bn(x, 256, 1, name=name_fmt('Conv2d_0a_1x1', 2))
branch_2 = conv2d_bn(branch_2, 256, 3, name=name_fmt('Conv2d_0b_3x3', 2))
branch_2 = conv2d_bn(branch_2,
256,
3,
strides=2,
padding='valid',
name=name_fmt('Conv2d_1a_3x3', 2))
branch_pool = MaxPooling2D(3,
strides=2,
padding='valid',
name=name_fmt('MaxPool_1a_3x3', 3))(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = Concatenate(axis=channel_axis, name='Mixed_7a')(branches)
# 5x Block8 (Inception-ResNet-C block):
for block_idx in range(1, 6):
x = _inception_resnet_block(x,
scale=0.2,
block_type='Block8',
block_idx=block_idx)
x = _inception_resnet_block(x,
scale=1.,
activation=None,
block_type='Block8',
block_idx=6)
# Create model
model = Model(inputs, x, name='inception_resnet_v1')
return model
def EfficientNet(width_coefficient,
depth_coefficient,
default_resolution,
dropout_rate=0.2,
drop_connect_rate=0.2,
depth_divisor=8,
blocks_args=DEFAULT_BLOCKS_ARGS,
model_name='efficientnet',
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
freeze_bn=False,
**kwargs):
"""Instantiates the EfficientNet architecture using given scaling coefficients.
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
width_coefficient: float, scaling coefficient for network width.
depth_coefficient: float, scaling coefficient for network depth.
default_resolution: int, default input image size.
dropout_rate: float, dropout rate before final classifier layer.
drop_connect_rate: float, dropout rate at skip connections.
depth_divisor: int.
blocks_args: A list of BlockArgs to construct block modules.
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.
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.
"""
features = []
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
input_shape = _obtain_input_shape(input_shape,
default_size=default_resolution,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if backend.backend() == 'tensorflow':
from tensorflow.python.keras.backend import is_keras_tensor
else:
is_keras_tensor = backend.is_keras_tensor
if not 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
# Build stem
x = img_input
x = layers.Conv2D(round_filters(32, width_coefficient, depth_divisor),
3,
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='stem_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name='stem_bn')(x)
x = layers.Activation(swish, name='stem_activation')(x)
# Build blocks
num_blocks_total = sum(block_args.num_repeat for block_args in blocks_args)
block_num = 0
for idx, block_args in enumerate(blocks_args):
assert block_args.num_repeat > 0
# Update block input and output filters based on depth multiplier.
block_args = block_args._replace(
input_filters=round_filters(block_args.input_filters,
width_coefficient, depth_divisor),
output_filters=round_filters(block_args.output_filters,
width_coefficient, depth_divisor),
num_repeat=round_repeats(block_args.num_repeat, depth_coefficient))
# The first block needs to take care of stride and filter size increase.
drop_rate = drop_connect_rate * float(block_num) / num_blocks_total
x = mb_conv_block(x,
block_args,
activation=swish,
drop_rate=drop_rate,
prefix='block{}a_'.format(idx + 1),
freeze_bn=freeze_bn)
block_num += 1
if block_args.num_repeat > 1:
# pylint: disable=protected-access
block_args = block_args._replace(
input_filters=block_args.output_filters, strides=[1, 1])
# pylint: enable=protected-access
for bidx in xrange(block_args.num_repeat - 1):
drop_rate = drop_connect_rate * float(
block_num) / num_blocks_total
block_prefix = 'block{}{}_'.format(
idx + 1, string.ascii_lowercase[bidx + 1])
x = mb_conv_block(x,
block_args,
activation=swish,
drop_rate=drop_rate,
prefix=block_prefix,
freeze_bn=freeze_bn)
block_num += 1
if idx < len(blocks_args) - 1 and blocks_args[idx + 1].strides[0] == 2:
features.append(x)
elif idx == len(blocks_args) - 1:
features.append(x)
return features
def get_inception_resnet_v2_unet_softmax(input_shape, weights='imagenet'):
n_channel = 3
n_class = 2
img_input = Input(input_shape + (n_channel,))
# Stem block: 35 x 35 x 192
x = conv2d_bn(img_input, 32, 3, strides=2, padding='same')
x = conv2d_bn(x, 32, 3, padding='same')
x = conv2d_bn(x, 64, 3)
conv1 = x
x = MaxPooling2D(3, strides=2, padding='same')(x)
x = conv2d_bn(x, 80, 1, padding='same')
x = conv2d_bn(x, 192, 3, padding='same')
conv2 = x
x = MaxPooling2D(3, strides=2, padding='same')(x)
# Mixed 5b (Inception-A block): 35 x 35 x 320
branch_0 = conv2d_bn(x, 96, 1)
branch_1 = conv2d_bn(x, 48, 1)
branch_1 = conv2d_bn(branch_1, 64, 5)
branch_2 = conv2d_bn(x, 64, 1)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_pool = AveragePooling2D(3, strides=1, padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1)
branches = [branch_0, branch_1, branch_2, branch_pool]
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
x = Concatenate(axis=channel_axis, name='mixed_5b')(branches)
# 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
for block_idx in range(1, 11):
x = inception_resnet_block(x,
scale=0.17,
block_type='block35',
block_idx=block_idx)
conv3 = x
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='same')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 256, 3)
branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='same')
branch_pool = MaxPooling2D(3, strides=2, padding='same')(x)
branches = [branch_0, branch_1, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
for block_idx in range(1, 21):
x = inception_resnet_block(x,
scale=0.1,
block_type='block17',
block_idx=block_idx)
conv4 = x
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
branch_0 = conv2d_bn(x, 256, 1)
branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='same')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='same')
branch_2 = conv2d_bn(x, 256, 1)
branch_2 = conv2d_bn(branch_2, 288, 3)
branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='same')
branch_pool = MaxPooling2D(3, strides=2, padding='same')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
for block_idx in range(1, 10):
x = inception_resnet_block(x,
scale=0.2,
block_type='block8',
block_idx=block_idx)
x = inception_resnet_block(x,
scale=1.,
activation=None,
block_type='block8',
block_idx=10)
# Final convolution block: 8 x 8 x 1536
x = conv2d_bn(x, 1536, 1, name='conv_7b')
conv5 = x
conv6 = conv_block(UpSampling2D()(conv5), 320)
conv6 = concatenate([conv6, conv4], axis=-1)
conv6 = conv_block(conv6, 320)
conv7 = conv_block(UpSampling2D()(conv6), 256)
conv7 = concatenate([conv7, conv3], axis=-1)
conv7 = conv_block(conv7, 256)
conv8 = conv_block(UpSampling2D()(conv7), 128)
conv8 = concatenate([conv8, conv2], axis=-1)
conv8 = conv_block(conv8, 128)
conv9 = conv_block(UpSampling2D()(conv8), 96)
conv9 = concatenate([conv9, conv1], axis=-1)
conv9 = conv_block(conv9, 96)
conv10 = conv_block(UpSampling2D()(conv9), 64)
conv10 = conv_block(conv10, 64)
res = Conv2D(n_class, (1, 1), activation='softmax')(conv10)
model = Model(img_input, res)
if weights == 'imagenet':
inception_resnet_v2 = InceptionResNetV2(weights=weights, include_top=False, input_shape=input_shape + (3,))
for i in range(2, len(inception_resnet_v2.layers)-1):
model.layers[i].set_weights(inception_resnet_v2.layers[i].get_weights())
model.layers[i].trainable = False
return model
"""WideResNet architecture."""
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import Activation, BatchNormalization, Add
from tensorflow.keras.layers import GlobalAveragePooling2D, Dropout, Dense
from tensorflow.keras.initializers import RandomNormal, HeNormal
from tensorflow.keras import Input, Model
from tensorflow.keras import backend as K
from functools import partial
CHANNEL_AXIS = 1 if K.image_data_format() == 'channels_first' else -1
_batch_norm = partial(BatchNormalization,
axis=CHANNEL_AXIS,
momentum=0.1,
epsilon=1e-5,
gamma_initializer=RandomNormal(0., 1.))
_relu = partial(Activation, 'relu')
def _residual_block(input,
num_filters=16,
k=1,
stride=1,
dropout=0.0,
name='res_block'):
"""Pre-activated residual block."""
num_filters = num_filters * k
init = branch = input
def NanoNet(input_shape=None,
input_tensor=None,
include_top=True,
weights='imagenet',
pooling=None,
classes=1000,
**kwargs):
"""Generate nano net model for Imagenet classification."""
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
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=28,
data_format=K.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
img_input = input_tensor
x = nano_net_body(img_input)
if include_top:
model_name = 'nano_net'
x = DarknetConv2D(classes, (1, 1))(x)
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Softmax()(x)
else:
model_name = 'nano_net_headless'
if pooling == 'avg':
x = GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = 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 = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name=model_name)
# Load weights.
if weights == 'imagenet':
if include_top:
file_name = 'nanonet_weights_tf_dim_ordering_tf_kernels_224.h5'
weight_path = BASE_WEIGHT_PATH + file_name
else:
file_name = 'nanonet_weights_tf_dim_ordering_tf_kernels_224_no_top.h5'
weight_path = BASE_WEIGHT_PATH + file_name
weights_path = get_file(file_name, weight_path, cache_subdir='models')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def MobileNetV3_small(input_shape=None,
alpha=1.0,
include_top=True,
weights='imagenet',
input_tensor=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the MobileNetV2 architecture.
# Arguments
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.
alpha: controls the width of the network. This is known as the
width multiplier in the MobileNetV2 paper, but the name is kept for
consistency with MobileNetV1 in Keras.
- 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.
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.
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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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 or invalid 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 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]:
rows = 224
warnings.warn('`input_shape` is undefined or non-square, '
'or `rows` is not in [96, 128, 160, 192, 224].'
' Weights for input shape (224, 224) will be'
' loaded as the default.')
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
channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1
first_block_filters = _make_divisible(16 * 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(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name='bn_Conv1')(x)
x = layers.Activation(HardSwish, name='Conv_1_hs')(x)
x = _bneck_block(x,
kernel=3,
filters=16,
alpha=alpha,
stride=2,
activation="relu",
se=True,
expansion=16,
block_id=0)
x = _bneck_block(x,
kernel=3,
filters=24,
alpha=alpha,
stride=2,
activation="relu",
se=False,
expansion=72,
block_id=1)
x = _bneck_block(x,
kernel=5,
filters=24,
alpha=alpha,
stride=1,
activation="relu",
se=False,
expansion=88,
block_id=2)
x = _bneck_block(x,
kernel=5,
filters=40,
alpha=alpha,
stride=2,
activation="hswish",
se=True,
expansion=96,
block_id=3)
x = _bneck_block(x,
kernel=3,
filters=40,
alpha=alpha,
stride=1,
activation="hswish",
se=True,
expansion=240,
block_id=4)
x = _bneck_block(x,
kernel=3,
filters=40,
alpha=alpha,
stride=1,
activation="hswish",
se=True,
expansion=240,
block_id=5)
x = _bneck_block(x,
kernel=3,
filters=48,
alpha=alpha,
stride=1,
activation="hswish",
se=True,
expansion=120,
block_id=6)
x = _bneck_block(x,
kernel=3,
filters=48,
alpha=alpha,
stride=1,
activation="hswish",
se=True,
expansion=144,
block_id=7)
x = _bneck_block(x,
kernel=3,
filters=96,
alpha=alpha,
stride=2,
activation="hswish",
se=True,
expansion=288,
block_id=8)
x = _bneck_block(x,
kernel=3,
filters=96,
alpha=alpha,
stride=1,
activation="hswish",
se=True,
expansion=576,
block_id=9)
x = _bneck_block(x,
kernel=5,
filters=96,
alpha=alpha,
stride=1,
activation="hswish",
se=True,
expansion=576,
block_id=10)
if alpha > 1.0:
filters = _make_divisible(576 * alpha, 8)
last_block_filters = _make_divisible(1280 * alpha, 8)
else:
filters = 576
last_block_filters = 1280
x = layers.Conv2D(filters, kernel_size=1, use_bias=False, name="Conv_2")(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name='Conv_2_bn')(x)
x = layers.Activation(HardSwish, name='Conv_2_hs')(x)
x = layers.AveragePooling2D(pool_size=(7, 7))(x)
x = layers.Conv2D(last_block_filters,
kernel_size=1,
use_bias=False,
name='Conv_3')(x)
x = layers.Activation(HardSwish, name='Conv_3_hs')(x)
if include_top:
x = layers.Conv2D(1001, kernel_size=1, use_bias=False,
name='out_conv')(x)
x = backend.squeeze(x, 1)
x = backend.squeeze(x, 1)
# 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='mobilenetv3_%0.2f_%s' % (alpha, rows))
# Load weights.
if weights == 'imagenet':
if include_top:
model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' +
str(alpha) + '_' + str(rows) + '.h5')
weight_path = BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weight_path,
cache_subdir='models')
else:
model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' +
str(alpha) + '_' + str(rows) + '_no_top' + '.h5')
weight_path = BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weight_path,
cache_subdir='models')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def _bneck_block(inputs, kernel, expansion, stride, alpha, filters, se,
activation, block_id):
channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1
in_channels = backend.int_shape(inputs)[channel_axis]
pointwise_conv_filters = int(filters * alpha)
pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
x = inputs
prefix = 'block_{}_'.format(block_id)
# Expand
if block_id:
x = layers.Conv2D(expansion,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + 'expand')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'expand_BN')(x)
if activation == "relu":
x = layers.ReLU(6., name=prefix + 'expand_relu')(x)
else:
x = layers.Activation(HardSwish, name=prefix + 'expand_hs')(x)
else:
prefix = 'expanded_conv_'
# Depthwise
if stride == 2:
x = layers.ZeroPadding2D(padding=correct_pad(backend, x, kernel),
name=prefix + 'pad')(x)
x = layers.DepthwiseConv2D(kernel_size=kernel,
strides=stride,
activation=None,
use_bias=False,
padding='same' if stride == 1 else 'valid',
name=prefix + 'depthwise')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'depthwise_BN')(x)
if se:
x = squeeze_excite_block(x, prefix)
if activation == "relu":
x = layers.ReLU(6., name=prefix + 'depthwise_relu')(x)
else:
x = layers.Activation(HardSwish, name=prefix + 'depthwise_hs')(x)
# Project
x = layers.Conv2D(pointwise_filters,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + 'project')(x)
x = layers.BatchNormalization(axis=channel_axis,
epsilon=1e-3,
momentum=0.999,
name=prefix + 'project_BN')(x)
if in_channels == pointwise_filters and stride == 1:
return layers.Add(name=prefix + 'add')([inputs, x])
return x
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
# model imports
import cv2
#import numpy as np
import matplotlib.pyplot as plt
#%matplotlib inline
import random
from tensorflow.keras import layers
from tensorflow.keras import Model
from tensorflow.keras import backend as tf_keras_backend
tf_keras_backend.set_image_data_format('channels_last')
tf_keras_backend.image_data_format()
import time
from tensorflow.keras.callbacks import Callback
from datetime import datetime
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from tensorflow import keras
def get_items(image):
with open("images/save_image", "w+") as fp:
fp.write(image)
print("IMAGE OBTAINED")
