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)