def binary_densenet(args,
input_shape,
num_classes,
input_tensor=None,
include_top=True):
input = utils.get_input_layer(input_shape, input_tensor)
if input_shape[0] and input_shape[0] < 50:
x = keras.layers.Conv2D(
args.initial_filters,
kernel_size=3,
padding="same",
kernel_initializer="he_normal",
use_bias=False,
)(input)
else:
x = keras.layers.Conv2D(
args.initial_filters,
kernel_size=7,
strides=2,
padding="same",
kernel_initializer="he_normal",
use_bias=False,
)(input)
x = keras.layers.BatchNormalization(momentum=0.9, epsilon=1e-5)(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D(3, strides=2, padding="same")(x)
for block, layers_per_block in enumerate(args.layers):
for _ in range(layers_per_block):
x = densely_connected_block(x, args, args.dilation_rate[block])
if block < len(args.layers) - 1:
x = keras.layers.BatchNormalization(momentum=0.9, epsilon=1e-5)(x)
if args.dilation_rate[block + 1] == 1:
x = keras.layers.MaxPooling2D(2, strides=2)(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.Conv2D(
round(x.shape.as_list()[-1] // args.reduction[block] / 32) *
32,
kernel_size=1,
kernel_initializer="he_normal",
use_bias=False,
)(x)
x = keras.layers.BatchNormalization(momentum=0.9, epsilon=1e-5)(x)
if include_top:
x = keras.layers.Activation("relu")(x)
x = keras.layers.GlobalAvgPool2D()(x)
x = keras.layers.Dense(num_classes,
activation="softmax",
kernel_initializer="he_normal")(x)
return keras.Model(inputs=input, outputs=x, name=args.name)
def resnet_e(args, input_shape, num_classes, input_tensor=None, include_top=True):
input = utils.get_input_layer(input_shape, input_tensor)
if input_shape[0] and input_shape[0] < 50:
x = keras.layers.Conv2D(
args.initial_filters,
kernel_size=3,
padding="same",
kernel_initializer="he_normal",
use_bias=False,
)(input)
else:
x = keras.layers.Conv2D(
args.initial_filters,
kernel_size=7,
strides=2,
padding="same",
kernel_initializer="he_normal",
use_bias=False,
)(input)
x = keras.layers.BatchNormalization(momentum=0.9, epsilon=1e-5)(x)
x = keras.layers.Activation("relu")(x)
x = keras.layers.MaxPool2D(3, strides=2, padding="same")(x)
x = keras.layers.BatchNormalization(momentum=0.9, epsilon=1e-5)(x)
for block, (layers, filters) in enumerate(zip(*args.spec)):
# this tricks adds shortcut connections between original resnet blocks
# we multiple number of blocks by 2, but add only one layer instead of two in each block
for layer in range(layers * 2):
strides = 1 if block == 0 or layer != 0 else 2
x = residual_block(x, args, filters, strides=strides)
if include_top:
x = keras.layers.Activation("relu")(x)
x = keras.layers.GlobalAvgPool2D()(x)
x = keras.layers.Dense(
num_classes, activation="softmax", kernel_initializer="glorot_normal"
)(x)
return keras.Model(inputs=input, outputs=x, name=args.name)
def binary_alexnet(hparams,
input_shape,
num_classes,
input_tensor=None,
include_top=True):
"""
Implementation of ["Binarized Neural Networks"](https://papers.nips.cc/paper/6573-binarized-neural-networks)
by Hubara et al., NIPS, 2016.
"""
kwhparams = dict(
input_quantizer="ste_sign",
kernel_quantizer="ste_sign",
kernel_constraint="weight_clip",
use_bias=False,
)
def conv_block(
x,
features,
kernel_size,
strides=1,
pool=False,
first_layer=False,
no_inflation=False,
):
x = lq.layers.QuantConv2D(
features * (1 if no_inflation else hparams.inflation_ratio),
kernel_size=kernel_size,
strides=strides,
padding="same",
input_quantizer=None if first_layer else "ste_sign",
kernel_quantizer="ste_sign",
kernel_constraint="weight_clip",
use_bias=False,
)(x)
if pool:
x = tf.keras.layers.MaxPool2D(pool_size=3, strides=2)(x)
x = tf.keras.layers.BatchNormalization(scale=False, momentum=0.9)(x)
return x
def dense_block(x, units):
x = lq.layers.QuantDense(units, **kwhparams)(x)
x = tf.keras.layers.BatchNormalization(scale=False, momentum=0.9)(x)
return x
# get input
img_input = utils.get_input_layer(input_shape, input_tensor)
# feature extractor
out = conv_block(img_input,
features=64,
kernel_size=11,
strides=4,
pool=True,
first_layer=True)
out = conv_block(out, features=192, kernel_size=5, pool=True)
out = conv_block(out, features=384, kernel_size=3)
out = conv_block(out, features=384, kernel_size=3)
out = conv_block(out,
features=256,
kernel_size=3,
pool=True,
no_inflation=True)
# classifier
if include_top:
out = tf.keras.layers.Flatten()(out)
out = dense_block(out, units=4096)
out = dense_block(out, units=4096)
out = dense_block(out, num_classes)
out = tf.keras.layers.Activation("softmax")(out)
return tf.keras.Model(inputs=img_input, outputs=out, name="binary_alexnet")
def dorefa_net(hparams,
input_shape,
num_classes,
input_tensor=None,
include_top=True):
def conv_block(x,
filters,
kernel_size,
strides=1,
pool=False,
pool_padding="same"):
x = lq.layers.QuantConv2D(
filters,
kernel_size=kernel_size,
strides=strides,
padding="same",
input_quantizer=hparams.input_quantizer,
kernel_quantizer=hparams.kernel_quantizer,
kernel_constraint=None,
use_bias=False,
)(x)
x = tf.keras.layers.BatchNormalization(scale=False,
momentum=0.9,
epsilon=1e-4)(x)
if pool:
x = tf.keras.layers.MaxPool2D(pool_size=3,
strides=2,
padding=pool_padding)(x)
return x
def fully_connected_block(x, units):
x = lq.layers.QuantDense(
units,
input_quantizer=hparams.input_quantizer,
kernel_quantizer=hparams.kernel_quantizer,
kernel_constraint=None,
use_bias=False,
)(x)
x = tf.keras.layers.BatchNormalization(scale=False,
momentum=0.9,
epsilon=1e-4)(x)
return x
# get input
img_input = utils.get_input_layer(input_shape, input_tensor)
# feature extractor
out = tf.keras.layers.Conv2D(96,
kernel_size=12,
strides=4,
padding="valid",
use_bias=True)(img_input)
out = conv_block(out, filters=256, kernel_size=5, pool=True)
out = conv_block(out, filters=384, kernel_size=3, pool=True)
out = conv_block(out, filters=384, kernel_size=3)
out = conv_block(out,
filters=256,
kernel_size=3,
pool_padding="valid",
pool=True)
# classifier
if include_top:
out = tf.keras.layers.Flatten()(out)
out = fully_connected_block(out, units=4096)
out = fully_connected_block(out, units=4096)
out = tf.keras.layers.Activation("clip_by_value_activation")(out)
out = tf.keras.layers.Dense(num_classes, use_bias=True)(out)
out = tf.keras.layers.Activation("softmax")(out)
return tf.keras.Model(inputs=img_input, outputs=out, name="dorefanet")
def birealnet(args, input_shape, num_classes, input_tensor=None, include_top=True):
def residual_block(x, double_filters=False, filters=None):
assert not (double_filters and filters)
# compute dimensions
in_filters = x.get_shape().as_list()[-1]
out_filters = filters or in_filters if not double_filters else 2 * in_filters
shortcut = x
if in_filters != out_filters:
shortcut = tf.keras.layers.AvgPool2D(2, strides=2, padding="same")(shortcut)
shortcut = tf.keras.layers.Conv2D(
out_filters,
1,
kernel_initializer=args.kernel_initializer,
use_bias=False,
)(shortcut)
shortcut = tf.keras.layers.BatchNormalization(momentum=0.8)(shortcut)
x = lq.layers.QuantConv2D(
out_filters,
3,
strides=1 if out_filters == in_filters else 2,
padding="same",
input_quantizer=args.input_quantizer,
kernel_quantizer=args.kernel_quantizer,
kernel_initializer=args.kernel_initializer,
kernel_constraint=args.kernel_constraint,
use_bias=False,
)(x)
x = tf.keras.layers.BatchNormalization(momentum=0.8)(x)
return tf.keras.layers.add([x, shortcut])
img_input = utils.get_input_layer(input_shape, input_tensor)
# layer 1
out = tf.keras.layers.Conv2D(
args.filters,
7,
strides=2,
kernel_initializer=args.kernel_initializer,
padding="same",
use_bias=False,
)(img_input)
out = tf.keras.layers.BatchNormalization(momentum=0.8)(out)
out = tf.keras.layers.MaxPool2D(3, strides=2, padding="same")(out)
# layer 2
out = residual_block(out, filters=args.filters)
# layer 3 - 5
for _ in range(3):
out = residual_block(out)
# layer 6 - 17
for _ in range(3):
out = residual_block(out, double_filters=True)
for _ in range(3):
out = residual_block(out)
# layer 18
if include_top:
out = tf.keras.layers.GlobalAvgPool2D()(out)
out = tf.keras.layers.Dense(num_classes, activation="softmax")(out)
return tf.keras.Model(inputs=img_input, outputs=out, name="birealnet18")
def xnornet(hparams,
input_shape,
num_classes,
input_tensor=None,
include_top=True):
kwargs = dict(
kernel_quantizer=hparams.kernel_quantizer,
input_quantizer=hparams.input_quantizer,
kernel_constraint=hparams.kernel_constraint,
use_bias=hparams.use_bias,
kernel_regularizer=hparams.kernel_regularizer,
)
img_input = utils.get_input_layer(input_shape, input_tensor)
x = tf.keras.layers.Conv2D(
96,
(11, 11),
strides=(4, 4),
padding="same",
use_bias=hparams.use_bias,
input_shape=input_shape,
kernel_regularizer=hparams.kernel_regularizer,
)(img_input)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-5)(x)
x = tf.keras.layers.Activation("relu")(x)
x = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2))(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-4)(x)
x = lq.layers.QuantConv2D(256, (5, 5), padding="same", **kwargs)(x)
x = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2))(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-4)(x)
x = lq.layers.QuantConv2D(384, (3, 3), padding="same", **kwargs)(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-4)(x)
x = lq.layers.QuantConv2D(384, (3, 3), padding="same", **kwargs)(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-4)(x)
x = lq.layers.QuantConv2D(256, (3, 3), padding="same", **kwargs)(x)
x = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2))(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-4)(x)
x = lq.layers.QuantConv2D(4096, (6, 6), padding="valid", **kwargs)(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-4)(x)
if include_top:
# Equivilent to a dense layer
x = lq.layers.QuantConv2D(4096, (1, 1),
strides=(1, 1),
padding="valid",
**kwargs)(x)
x = tf.keras.layers.BatchNormalization(momentum=hparams.bn_momentum,
scale=hparams.bn_scale,
epsilon=1e-3)(x)
x = tf.keras.layers.Activation("relu")(x)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(
num_classes,
use_bias=False,
kernel_regularizer=hparams.kernel_regularizer)(x)
x = tf.keras.layers.Activation("softmax")(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = tf.keras.utils.get_source_inputs(input_tensor)
else:
inputs = img_input
return tf.keras.models.Model(inputs, x, name="xnornet")