def discriminator(self, inputs, reuse=False):
if self.arch:
arch = self.arch
dim_c = arch['dim_c_D']
if arch['activation_D'] == 'relu':
activation_fn = tf.nn.relu
elif arch['activation_D'] == 'leakyRelu':
activation_fn = tf.nn.leaky_relu
else:
activation_fn = tf.nn.tanh
batchnorm = arch['batchnorm_D']
else:
dim_c = self.config.dim_c
activation_fn = tf.nn.leaky_relu
batchnorm = False
with tf.variable_scope('Discriminator') as scope:
if reuse:
scope.reuse_variables()
output = tf.reshape(inputs, [-1, 28, 28, 1])
output = layers.conv2d(output, dim_c, name='Conv1')
output = activation_fn(output)
output = layers.conv2d(output, 2*dim_c, name='Conv2')
if batchnorm:
output = layers.batchnorm(output, is_training=self.is_training,
name='BN2')
output = activation_fn(output)
output = tf.reshape(output, [-1, 7*7*2*dim_c])
output = layers.linear(output, 1, name='LN3')
return tf.reshape(output, [-1])
def __init__(self, w_in, w_out, stride, params):
super(BottleneckTransform, self).__init__()
w_b = int(round(w_out * params['bot_mul']))
w_se = int(round(w_in * params['se_r']))
groups = w_b // params['group_w']
self.a = Conv_Bn_Act(w_in,
w_b,
1,
eps=1e-5,
momentum=0.1,
act_layer=nn.ReLU,
mode=None,
bias=False)
self.b = Conv_Bn_Act(w_b,
w_b,
3,
stride=stride,
groups=groups,
eps=1e-5,
momentum=0.1,
act_layer=nn.ReLU,
mode=None,
bias=False)
self.se = SEModule(w_b, w_se, act_layer=nn.ReLU) if w_se else None
self.c = conv2d(w_b, w_out, 1)
self.c_bn = nn.BatchNorm2d(w_out)
def __init__(self, w_in, w_out, stride, params):
super(ResBottleneckBlock, self).__init__()
self.proj, self.bn = None, None
if (w_in != w_out) or stride != 1:
self.proj = conv2d(w_in, w_out, 1, stride=stride)
self.bn = nn.BatchNorm2d(w_out)
self.f = BottleneckTransform(w_in, w_out, stride, params)
self.af = nn.ReLU(inplace=True)
def define_model(self):
input_layer = Input(shape=self.config.input_shape)
shared_conv = conv_blocks(
channels=self.config.deform_conv_channels[:3],
kernel_size=self.config.kernel_size,
strides=self.config.strides,
activation=self.config.activation,
use_sn=False,
norm='bn',
name='shared',
name_offset=0)(input_layer)
shared_conv = deform_conv_block(
channels=self.config.deform_conv_channels[3:-1],
deform_channels=self.config.deform_conv_offset_channels,
kernel_size=self.config.kernel_size,
strides=self.config.strides,
activation=self.config.activation,
name='shared',
name_offset=2)(shared_conv)
shared_conv = conv2d(
shared_conv,
filters=self.config.deform_conv_channels[-1],
kernel_size=3,
strides=2,
use_sn=False,
norm='bn',
activation='lrelu',
name=f'shared_conv_{len(self.config.deform_conv_channels)-1}')
conv_flatten = Flatten()(shared_conv)
out = dense_branches(units=self.config.dense_branch_units,
output_num=self.config.num_classes,
activation=self.config.activation,
use_dropout=True,
dropout_rate=0.25,
name='class')(conv_flatten)
return Model(input_layer, out, name='defromable_classifier')
def __init__(self,
in_,
out_,
expand,
kernel_size,
stride,
skip,
se_ratio,
dc_ratio=0.2):
super().__init__()
mid_ = in_ * expand
self.expand_conv = Conv_Bn_Act(
in_, mid_, kernel_size=1, eps=1e-3, momentum=0.01,
bias=False) if expand != 1 else nn.Identity()
self.depth_wise_conv = Conv_Bn_Act(mid_,
mid_,
kernel_size=kernel_size,
stride=stride,
eps=1e-3,
momentum=0.01,
groups=mid_,
bias=False)
self.se = SEModule(mid_, int(
in_ * se_ratio)) if se_ratio > 0 else nn.Identity()
self.project_conv = nn.Sequential(
conv2d(mid_, out_, kernel_size=1, stride=1, bias=False),
nn.BatchNorm2d(out_, 1e-3, 0.01))
# if _block_args.id_skip:
# and all(s == 1 for s in self._block_args.strides)
# and self._block_args.input_filters == self._block_args.output_filters:
self.skip = skip and (stride == 1) and (in_ == out_)
# DropConnect
self.dropconnect = DropConnect(
dc_ratio) if dc_ratio > 0 else nn.Identity()
def conv2d_fixed_padding(inputs,
filters,
kernel_size,
strides,
mixed_precision=False,
data_format='channels_first'):
"""Strided 2-D convolution with explicit padding."""
# The padding is consistent and is based only on `kernel_size`, not on the
# dimensions of `inputs` (as opposed to using `tf.layers.conv2d` alone).
if strides > 1:
inputs = fixed_padding(inputs, kernel_size, data_format)
padding = 'SAME' if strides == 1 else 'VALID'
return layers.conv2d(inputs,
filters,
kernel_size,
strides,
padding,
mixed_precision,
data_format,
variable_name='kernel_weights')
def pointnet_sa_module(xyz,
points,
npoint,
radius,
nsample,
mlp,
mlp2,
mlp3,
is_training,
scope,
bn=True,
bn_decay=None,
tnet_spec=None,
knn=False,
use_xyz=True,
keypoints=None,
orientations=None,
normalize_radius=True,
final_relu=True):
""" PointNet Set Abstraction (SA) Module. Modified to remove unneeded components (e.g. pooling),
normalize points based on radius, and for a third layer of MLP
Args:
xyz (tf.Tensor): (batch_size, ndataset, 3) TF tensor
points (tf.Tensor): (batch_size, ndataset, num_channel)
npoint (int32): #points sampled in farthest point sampling
radius (float): search radius in local region
nsample (int): Maximum points in each local region
mlp: list of int32 -- output size for MLP on each point
mlp2: list of int32 -- output size for MLP after max pooling concat
mlp3: list of int32 -- output size for MLP after second max pooling
is_training (tf.placeholder): Indicate training/validation
scope (str): name scope
bn (bool): Whether to perform batch normalizaton
bn_decay: Decay schedule for batch normalization
tnet_spec: Unused in Feat3D-Net. Set to None
knn: Unused in Feat3D-Net. Set to False
use_xyz: Unused in Feat3D-Net. Set to True
keypoints: If provided, cluster centers will be fixed to these points (npoint will be ignored)
orientations (tf.Tensor): Containing orientations from the detector
normalize_radius (bool): Whether to normalize coordinates [True] based on cluster radius.
final_relu: Whether to use relu as the final activation function
Returns:
new_xyz: (batch_size, npoint, 3) TF tensor
new_points: (batch_size, npoint, mlp[-1] or mlp2[-1]) TF tensor
idx: (batch_size, npoint, nsample) int32 -- indices for local regions
"""
with tf.variable_scope(scope) as sc:
if npoint is None:
nsample = xyz.get_shape()[1].value
new_xyz, new_points, idx, grouped_xyz = sample_and_group_all(
xyz, points, use_xyz)
else:
new_xyz, new_points, idx, grouped_xyz, end_points = sample_and_group(
npoint,
radius,
nsample,
xyz,
points,
tnet_spec,
knn,
use_xyz,
keypoints=keypoints,
orientations=orientations,
normalize_radius=normalize_radius)
for i, num_out_channel in enumerate(mlp):
new_points = conv2d(
new_points,
num_out_channel,
kernel_size=[1, 1],
stride=[1, 1],
padding='VALID',
bn=bn,
is_training=is_training,
scope='conv%d' % (i),
reuse=False,
)
# Max pool
pooled = tf.reduce_max(new_points, axis=[2], keep_dims=True)
pooled_expand = tf.tile(pooled, [1, 1, new_points.shape[2], 1])
# Concatenate
new_points = tf.concat((new_points, pooled_expand), axis=3)
if mlp2 is None: mlp2 = []
for i, num_out_channel in enumerate(mlp2):
new_points = conv2d(new_points,
num_out_channel, [1, 1],
padding='VALID',
stride=[1, 1],
bn=bn,
is_training=is_training,
scope='conv_mid_%d' % (i),
bn_decay=bn_decay,
activation=tf.nn.relu if
(final_relu or i < len(mlp2) - 1) else None)
# Max pool again
new_points = tf.reduce_max(new_points, axis=[2], keep_dims=True)
if mlp3 is None:
mlp3 = []
for i, num_out_channel in enumerate(mlp3):
new_points = conv2d(new_points,
num_out_channel, [1, 1],
padding='VALID',
stride=[1, 1],
bn=bn,
is_training=is_training,
scope='conv_post_%d' % (i),
bn_decay=bn_decay,
activation=tf.nn.relu if
(final_relu or i < len(mlp3) - 1) else None)
new_points = tf.squeeze(new_points,
[2]) # (batch_size, npoints, mlp2[-1])
return new_xyz, new_points, idx, end_points
def feature_detection_module(xyz,
points,
num_clusters,
radius,
is_training,
mlp,
mlp2,
num_samples=64,
use_bn=True):
""" Detect features in point cloud
Args:
xyz (tf.Tensor): Input point cloud of size (batch_size, ndataset, 3)
points (tf.Tensor): Point features. Unused in 3DFeat-Net
num_clusters (int): Number of clusters to extract. Set to -1 to use all points
radius (float): Radius to consider for feature detection
is_training (tf.placeholder): Set to True if training, False during evaluation
mlp: list of int32 -- output size for MLP on each point
mlp2: list of int32 -- output size for MLP on each region. Set to None or [] to ignore
num_samples: Maximum number of points to consider per cluster
use_bn: bool -- Whether to perform batch normalization
Returns:
new_xyz: Cluster centers
idx: Indices of points sampled for the clusters
attention: Output attention weights
orientation: Output orientation (radians)
end_points: Unused
"""
end_points = {}
new_xyz = sample_points(xyz, num_clusters) # Sample point centers
new_points, idx = query_and_group_points(
xyz,
points,
new_xyz,
num_samples,
radius,
knn=False,
use_xyz=True,
normalize_radius=True,
orientations=None) # Extract clusters
# Pre pooling MLP
for i, num_out_channel in enumerate(mlp):
new_points = conv2d(
new_points,
num_out_channel,
kernel_size=[1, 1],
stride=[1, 1],
padding='VALID',
bn=use_bn,
is_training=is_training,
scope='conv%d' % (i),
reuse=False,
)
# Max Pool
new_points = tf.reduce_max(new_points, axis=[2], keep_dims=True)
# Max pooling MLP
if mlp2 is None: mlp2 = []
for i, num_out_channel in enumerate(mlp2):
new_points = conv2d(new_points,
num_out_channel, [1, 1],
padding='VALID',
stride=[1, 1],
bn=use_bn,
is_training=is_training,
scope='conv_post_%d' % (i))
# Attention and orientation regression
attention = conv2d(new_points,
1, [1, 1],
stride=[1, 1],
padding='VALID',
activation=tf.nn.softplus,
bn=False,
scope='attention',
reuse=False)
attention = tf.squeeze(attention, axis=[2, 3])
orientation_xy = conv2d(new_points,
2, [1, 1],
stride=[1, 1],
padding='VALID',
activation=None,
bn=False,
scope='orientation',
reuse=False)
orientation_xy = tf.squeeze(orientation_xy, axis=2)
orientation_xy = tf.nn.l2_normalize(orientation_xy, dim=2, epsilon=1e-8)
orientation = tf.atan2(orientation_xy[:, :, 1], orientation_xy[:, :, 0])
return new_xyz, idx, attention, orientation, end_points
def define_model(self):
input_layer = Input(shape=self.config.input_shape)
x = conv2d(input_layer,
filters=64,
kernel_size=7,
strides=2,
pad_type='zero',
pad_size=3,
norm='in',
activation='lrelu')
x = ZeroPadding2D(padding=(1, 1))(x)
x = MaxPooling2D((3, 3), 2)(x)
shortcut = conv2d(x,
filters=256,
kernel_size=1,
strides=1,
pad_type='valid',
norm='in')
for i in range(3):
x = conv2d(x,
filters=64,
kernel_size=1,
strides=1,
pad_type='valid',
norm='in',
activation='lrelu')
x = conv2d(x,
filters=64,
kernel_size=3,
strides=1,
pad_type='same',
norm='in',
activation='lrelu')
x = conv2d(x,
filters=256,
kernel_size=1,
strides=1,
pad_type='valid',
norm='in')
x = Add()([x, shortcut])
x = get_activation('lrelu')(x)
shortcut = x
shortcut = conv2d(x,
filters=512,
kernel_size=1,
strides=2,
pad_type='valid',
norm='in')
for i in range(4):
x = conv2d(x, filters=128, kernel_size=1, strides=2, pad_type='valid', norm='in', activation='lrelu') if i == 0 \
else conv2d(x, filters=128, kernel_size=1, strides=1, pad_type='valid', norm='in', activation='lrelu')
x = conv2d(x,
filters=128,
kernel_size=3,
strides=1,
pad_type='same',
norm='in',
activation='lrelu')
x = conv2d(x,
filters=512,
kernel_size=1,
strides=1,
pad_type='valid',
norm='in')
x = Add()([x, shortcut])
x = get_activation('lrelu')(x)
shortcut = x
shortcut = conv2d(x,
filters=1024,
kernel_size=1,
strides=2,
pad_type='valid',
norm='in')
for i in range(6):
x = conv2d(x, filters=256, kernel_size=1, strides=2, pad_type='valid', norm='in', activation='lrelu') if i == 0 \
else conv2d(x, filters=256, kernel_size=1, strides=1, pad_type='valid', norm='in', activation='lrelu')
x = conv2d(x,
filters=256,
kernel_size=3,
strides=1,
pad_type='same',
norm='in',
activation='lrelu')
x = conv2d(x,
filters=1024,
kernel_size=1,
strides=1,
pad_type='valid',
norm='in')
x = Add()([x, shortcut])
x = get_activation('lrelu')(x)
shortcut = x
shortcut = conv2d(x,
filters=2048,
kernel_size=1,
strides=2,
pad_type='valid',
norm='in')
for i in range(3):
x = conv2d(x, filters=512, kernel_size=1, strides=2, pad_type='valid', norm='in', activation='lrelu') if i == 0 \
else conv2d(x, filters=512, kernel_size=1, strides=1, pad_type='valid', norm='in', activation='lrelu')
x = conv2d(x,
filters=512,
kernel_size=3,
strides=1,
pad_type='same',
norm='in',
activation='lrelu')
x = conv2d(x,
filters=2048,
kernel_size=1,
strides=1,
pad_type='valid',
norm='in')
x = Add()([x, shortcut])
x = get_activation('lrelu')(x)
shortcut = x
x = GlobalAveragePooling2D()(x)
out = Dense(self.config.num_classes,
activation='softmax',
name=f'class_output')(x)
return Model(inputs=input_layer, outputs=out, name='resnet50')
def _prepare_module(self):
d = OrderedDict()
#conv1 - batch_norm1 - leaky_relu1 - pool1
d['conv1'] = ConvBnAct(3, 32, 3, stride=1, padding=1)
d['pool1'] = max_pool(2, 2)
#conv2 - batch_norm2 - leaky_relu2 - pool2
d['conv2'] = ConvBnAct(32, 64, 3, stride=1, padding=1)
d['pool2'] = max_pool(2, 2)
#conv3 - batch_norm3 - leaky_relu3
d['conv3'] = ConvBnAct(64, 128, 3, stride=1, padding=1)
#conv4 - batch_norm4 - leaky_relu4
d['conv4'] = ConvBnAct(128, 64, 1, stride=1, padding=0)
#conv5 - batch_norm5 - leaky_relu5 - pool5
d['conv5'] = ConvBnAct(64, 128, 3, stride=1, padding=1)
d['pool5'] = max_pool(2, 2)
#conv6 - batch_norm6 - leaky_relu6
d['conv6'] = ConvBnAct(128, 256, 3, stride=1, padding=1)
#conv7 - batch_norm7 - leaky_relu7
d['conv7'] = ConvBnAct(256, 128, 1, stride=1, padding=0)
#conv8 - batch_norm8 - leaky_relu8 - pool8
d['conv8'] = ConvBnAct(128, 256, 3, stride=1, padding=1)
d['pool8'] = max_pool(2, 2)
#conv9 - batch_norm9 - leaky_relu9
d['conv9'] = ConvBnAct(256, 512, 3, stride=1, padding=1)
#conv10 - batch_norm10 - leaky_relu10
d['conv10'] = ConvBnAct(512, 256, 1, stride=1, padding=0)
#conv11 - batch_norm11 - leaky_relu11
d['conv11'] = ConvBnAct(256, 512, 3, stride=1, padding=1)
#conv12 - batch_norm12 - leaky_relu12
d['conv12'] = ConvBnAct(512, 256, 1, stride=1, padding=0)
#conv13 - batch_norm13 - leaky_relu13 - pool13
d['conv13'] = ConvBnAct(256, 512, 3, stride=1, padding=1)
d['pool13'] = max_pool(2, 2)
#conv14 - batch_norm14 - leaky_relu14
d['conv14'] = ConvBnAct(512, 1024, 3, stride=1, padding=1)
#conv15 - batch_norm15 - leaky_relu15
d['conv15'] = ConvBnAct(1024, 512, 1, stride=1, padding=0)
#conv16 - batch_norm16 - leaky_relu16
d['conv16'] = ConvBnAct(512, 1024, 3, stride=1, padding=1)
#conv17 - batch_norm16 - leaky_relu17
d['conv17'] = ConvBnAct(1024, 512, 1, stride=1, padding=0)
#conv18 - batch_norm18 - leaky_relu18
d['conv18'] = ConvBnAct(512, 1024, 3, stride=1, padding=1)
#conv19 - batch_norm19 - leaky_relu19
d['conv19'] = ConvBnAct(1024, 1024, 3, stride=1, padding=1)
# Detection Layer
#conv20 - batch_norm20 - leaky_relu20
d['conv20'] = ConvBnAct(1024, 1024, 3, stride=1, padding=1)
# concatenate layer20 and layer 13 using space to depth
d['skip_connection'] = nn.Sequential(
ConvBnAct(512, 64, 1, stride=1, padding=0), SpaceToDepth(2))
d['conv21'] = ConvBnAct(1024, 1024, 3, stride=1, padding=1)
#conv22 - batch_norm22 - leaky_relu22
d['conv22'] = ConvBnAct(1280, 1024, 3, stride=1, padding=1)
output_channel = self.num_anchors * (5 + self.num_classes)
d['logits'] = conv2d(1024,
output_channel,
1,
stride=1,
padding=0,
bias=True)
self.module = nn.ModuleList()
for i in d.values():
self.module.append(i)
return d
def _build_model(self, **kwargs):
"""Build the graph of the AlexNet for image classification.
NOTE: We initialized the neuron biases in the conv2, conv4, conv5, fc6, fc7, and fc8 with the constant 0.1
instead of 1.0.
"""
num_classes = int(self.Y.get_shape()[-1])
input_mean = kwargs.pop('image_mean', 0.0)
dropout_rate = kwargs.pop('dropout_rate', 0.5)
dropout_rate = tf.cond(self.is_training, lambda: dropout_rate,
lambda: 0.0)
net = dict()
# input layer
net['input'] = self.X - input_mean
# conv1-pool1
with tf.variable_scope('conv1'):
net['conv1'] = conv2d(
net['input'],
96,
11,
4,
padding='VALID',
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.0))
net['conv1'] = tf.nn.relu(net['conv1'])
net['conv1'] = lrn(net['conv1'],
depth_radius=5,
bias=2,
alpha=1e-4,
beta=0.75)
net['pool1'] = max_pool2d(net['conv1'], 3, 2, padding='VALID')
# conv2-pool2
with tf.variable_scope('conv2'):
net['conv2'] = conv2d(
net['pool1'],
256,
5,
1,
padding='SAME',
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.1))
net['conv2'] = tf.nn.relu(net['conv2'])
net['conv2'] = lrn(net['conv2'],
depth_radius=5,
bias=2,
alpha=1e-4,
beta=0.75)
net['pool2'] = max_pool2d(net['conv2'], 3, 2, padding='VALID')
# conv3
with tf.variable_scope('conv3'):
net['conv3'] = conv2d(
net['pool2'],
384,
3,
1,
padding='SAME',
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.0))
net['conv3'] = tf.nn.relu(net['conv3'])
# conv4
with tf.variable_scope('conv4'):
net['conv4'] = conv2d(
net['conv3'],
384,
3,
1,
padding='SAME',
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.1))
net['conv4'] = tf.nn.relu(net['conv4'])
# conv5-pool5-flat5
with tf.variable_scope('conv5'):
net['conv5'] = conv2d(
net['conv4'],
256,
3,
1,
padding='SAME',
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.1))
net['conv5'] = tf.nn.relu(net['conv5'])
net['pool5'] = max_pool2d(net['conv5'], 3, 2, padding='VALID')
net['flat5'] = flatten(net['pool5'])
# fc6
with tf.variable_scope('fc6'):
net['fc6'] = fully_connected(
net['flat5'],
4096,
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.1))
net['fc6'] = tf.nn.relu(net['fc6'])
net['fc6'] = tf.nn.dropout(net['fc6'], rate=dropout_rate)
# fc7
with tf.variable_scope('fc7'):
net['fc7'] = fully_connected(
net['fc6'],
4096,
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.1))
net['fc7'] = tf.nn.relu(net['fc7'])
net['fc7'] = tf.nn.dropout(net['fc7'], rate=dropout_rate)
# fc8
with tf.variable_scope('fc8'):
net['logits'] = fully_connected(
net['fc7'],
num_outputs=num_classes,
weight_initializer=tf.random_normal_initializer(mean=0.0,
stddev=0.01),
bias_initializer=tf.constant_initializer(value=0.1))
# softmax
net['pred'] = tf.nn.softmax(net['logits'])
print('layer\tout_shape')
for i, key in enumerate(net.keys()):
print('{}\t{}'.format(key, net[key].shape.as_list()[1:]))
print('\nvariable\tshape')
var_list = tf.trainable_variables()
for var in var_list:
print('{}\t{}'.format(var.name, var.shape.as_list()))
return net
def _build_model(self, **kwargs):
"""Build the graph of the Darknet19 for image classification.
"""
num_classes = int(self.Y.get_shape()[-1])
input_mean = kwargs.pop('image_mean', 0.0)
weight_initializer = tf.random_uniform_initializer(-1.0, 1.0)
bias_initializer = None
net = dict()
# input layer
net['input'] = self.X - input_mean
# conv1
with tf.variable_scope('conv1'):
net['conv1'] = conv2d(net['input'],
32,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv1'] = batch_norm(net['conv1'],
is_training=self.is_training)
net['conv1'] = tf.nn.leaky_relu(net['conv1'], 0.1)
# pool1
net['pool1'] = max_pool2d(net['conv1'], 2, 2, padding='SAME')
# conv2
with tf.variable_scope('conv2'):
net['conv2'] = conv2d(net['pool1'],
64,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv2'] = batch_norm(net['conv2'],
is_training=self.is_training)
net['conv2'] = tf.nn.leaky_relu(net['conv2'], 0.1)
# pool2
net['pool2'] = max_pool2d(net['conv2'], 2, 2, padding='SAME')
# conv3
with tf.variable_scope('conv3'):
net['conv3'] = conv2d(net['pool2'],
128,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv3'] = batch_norm(net['conv3'],
is_training=self.is_training)
net['conv3'] = tf.nn.leaky_relu(net['conv3'], 0.1)
# conv4
with tf.variable_scope('conv4'):
net['conv4'] = conv2d(net['conv3'],
64,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv4'] = batch_norm(net['conv4'],
is_training=self.is_training)
net['conv4'] = tf.nn.leaky_relu(net['conv4'], 0.1)
# conv5
with tf.variable_scope('conv5'):
net['conv5'] = conv2d(net['conv4'],
128,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv5'] = batch_norm(net['conv5'],
is_training=self.is_training)
net['conv5'] = tf.nn.leaky_relu(net['conv5'], 0.1)
# pool3
net['pool3'] = max_pool2d(net['conv5'], 2, 2, padding='SAME')
# conv6
with tf.variable_scope('conv6'):
net['conv6'] = conv2d(net['pool3'],
256,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv6'] = batch_norm(net['conv6'],
is_training=self.is_training)
net['conv6'] = tf.nn.leaky_relu(net['conv6'], 0.1)
# conv7
with tf.variable_scope('conv7'):
net['conv7'] = conv2d(net['conv6'],
128,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv7'] = batch_norm(net['conv7'],
is_training=self.is_training)
net['conv7'] = tf.nn.leaky_relu(net['conv7'], 0.1)
# conv8
with tf.variable_scope('conv8'):
net['conv8'] = conv2d(net['conv7'],
256,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv8'] = batch_norm(net['conv8'],
is_training=self.is_training)
net['conv8'] = tf.nn.leaky_relu(net['conv8'], 0.1)
# pool4
net['pool4'] = max_pool2d(net['conv8'], 2, 2, padding='SAME')
# conv9
with tf.variable_scope('conv9'):
net['conv9'] = conv2d(net['pool4'],
512,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv9'] = batch_norm(net['conv9'],
is_training=self.is_training)
net['conv9'] = tf.nn.leaky_relu(net['conv9'], 0.1)
# conv10
with tf.variable_scope('conv10'):
net['conv10'] = conv2d(net['conv9'],
256,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv10'] = batch_norm(net['conv10'],
is_training=self.is_training)
net['conv10'] = tf.nn.leaky_relu(net['conv10'], 0.1)
# conv11
with tf.variable_scope('conv11'):
net['conv11'] = conv2d(net['conv10'],
512,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv11'] = batch_norm(net['conv11'],
is_training=self.is_training)
net['conv11'] = tf.nn.leaky_relu(net['conv11'], 0.1)
# conv12
with tf.variable_scope('conv12'):
net['conv12'] = conv2d(net['conv11'],
256,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv12'] = batch_norm(net['conv12'],
is_training=self.is_training)
net['conv12'] = tf.nn.leaky_relu(net['conv12'], 0.1)
# conv13
with tf.variable_scope('conv13'):
net['conv13'] = conv2d(net['conv12'],
512,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv13'] = batch_norm(net['conv13'],
is_training=self.is_training)
net['conv13'] = tf.nn.leaky_relu(net['conv13'], 0.1)
# pool5
net['pool5'] = max_pool2d(net['conv13'], 2, 2, padding='SAME')
# conv14
with tf.variable_scope('conv14'):
net['conv14'] = conv2d(net['pool5'],
1024,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv14'] = batch_norm(net['conv14'],
is_training=self.is_training)
net['conv14'] = tf.nn.leaky_relu(net['conv14'], 0.1)
# conv15
with tf.variable_scope('conv15'):
net['conv15'] = conv2d(net['conv14'],
512,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv15'] = batch_norm(net['conv15'],
is_training=self.is_training)
net['conv15'] = tf.nn.leaky_relu(net['conv15'], 0.1)
# conv16
with tf.variable_scope('conv16'):
net['conv16'] = conv2d(net['conv15'],
1024,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv16'] = batch_norm(net['conv16'],
is_training=self.is_training)
net['conv16'] = tf.nn.leaky_relu(net['conv16'], 0.1)
# conv17
with tf.variable_scope('conv17'):
net['conv17'] = conv2d(net['conv16'],
512,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv17'] = batch_norm(net['conv17'],
is_training=self.is_training)
net['conv17'] = tf.nn.leaky_relu(net['conv17'], 0.1)
# conv18
with tf.variable_scope('conv18'):
net['conv18'] = conv2d(net['conv17'],
1024,
3,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv18'] = batch_norm(net['conv18'],
is_training=self.is_training)
net['conv18'] = tf.nn.leaky_relu(net['conv18'], 0.1)
# conv19
with tf.variable_scope('conv19'):
net['conv19'] = conv2d(net['conv18'],
num_classes,
1,
1,
padding='SAME',
weight_initializer=weight_initializer,
bias_initializer=bias_initializer)
net['conv19'] = batch_norm(net['conv19'],
is_training=self.is_training)
net['conv19'] = tf.nn.leaky_relu(net['conv19'], 0.1)
# avg_pool
net['logits'] = global_avg_pool(net['conv19'])
# softmax
net['pred'] = tf.nn.softmax(net['logits'])
print('layer\tout_shape')
for i, key in enumerate(net.keys()):
print('{}\t{}'.format(key, net[key].shape.as_list()[1:]))
print('\nvariable\tshape')
var_list = tf.trainable_variables()
for var in var_list:
print('{}\t{}'.format(var.name, var.shape.as_list()))
return net
def __init__(self, w_in, w_out):
super(SimpleStem, self).__init__()
self.conv = conv2d(w_in, w_out, 3, stride=2)
self.bn = nn.BatchNorm2d(w_out)
self.af = nn.ReLU(inplace=True)