コード例 #1
0
    def encoder_v2(self, x, is_training=True, reuse=False):
        with tf.variable_scope("encoder_v2", reuse=reuse):
            if self.verbose: print(x.shape)

            # Layer 1
            net = layers.conv2d(x, self.conv_dim >> 1, name='en_conv1')
            net = tf.nn.leaky_relu(net)
            if self.verbose: print(net.shape)

            # Layer 2
            net = layers.conv2d(net, self.conv_dim, name='en_conv2')
            net = layers.batch_norm(net,
                                    is_training=is_training,
                                    scope='en_bn2')
            net = tf.nn.leaky_relu(net)
            if self.verbose: print(net.shape)

            # Layer 3
            net = layers.flatten(net)
            if self.verbose: print(net.shape)

            # Layer 4
            net = layers.linear(net, self.linear_dim, scope='en_fc3')
            net = layers.batch_norm(net,
                                    is_training=is_training,
                                    scope='en_bn3')
            net = tf.nn.leaky_relu(net)
            if self.verbose: print(net.shape)

            # Layer 5
            out_logit = layers.linear(net, self.latent_dim, scope='en_fc4')
            out = tf.nn.sigmoid(out_logit, name="main_out")
            if self.verbose: print(out.shape)

            return out
コード例 #2
0
def _depthwise_conv_block(x, weights, strides=1, block_id=0):
    '''
    depthwise convolution and pointwise convolution
    '''
    # depthwise convolution
    bn_beta = 'conv_dw_' + str(block_id) + '_bn/beta:0'
    bn_gamma = 'conv_dw_' + str(block_id) + '_bn/gamma:0'
    bn_mean = 'conv_dw_' + str(block_id) + '_bn/moving_mean:0'
    bn_var = 'conv_dw_' + str(block_id) + '_bn/moving_variance:0'
    conv_name = 'conv_dw_' + str(block_id) + '/depthwise_kernel:0'
    bias_name = 'conv_dw_' + str(block_id) + '/depthwise_bias:0'

    w, b, s = get_weights(weights, conv_name, bias_name, quant=False)
    x = depthwise_conv2d(x, w, b, strides=strides, padding='SAME')
    mean, std, beta, gamma = get_bn_param(weights, bn_mean, bn_var, bn_beta,
                                          bn_gamma)
    x = batch_norm(x, mean, std, beta, gamma)
    x = tf.nn.relu6(x)

    # pointwise convolution
    bn_beta = 'conv_pw_' + str(block_id) + '_bn/beta:0'
    bn_gamma = 'conv_pw_' + str(block_id) + '_bn/gamma:0'
    bn_mean = 'conv_pw_' + str(block_id) + '_bn/moving_mean:0'
    bn_var = 'conv_pw_' + str(block_id) + '_bn/moving_variance:0'
    conv_name = 'conv_pw_' + str(block_id) + '/kernel:0'
    bias_name = 'conv_pw_' + str(block_id) + '/bias:0'

    w, b, s = get_weights(weights, conv_name, bias_name)
    x = conv_2d(x, w, b, s, strides=1, padding='SAME')
    mean, std, beta, gamma = get_bn_param(weights, bn_mean, bn_var, bn_beta,
                                          bn_gamma)
    x = batch_norm(x, mean, std, beta, gamma)
    return tf.nn.relu6(x)
コード例 #3
0
    def decoder_v2(self, x, is_training=True, reuse=False):
        with tf.variable_scope("decoder", reuse=reuse):
            if self.verbose: print(x.shape)

            # Layer 1
            net = layers.linear(x, self.linear_dim, scope='de_fc1')
            net = layers.batch_norm(net,
                                    is_training=is_training,
                                    scope='de_bn1')
            net = tf.nn.relu(net)
            if self.verbose: print(net.shape)

            # Layer 2
            shape = self.conv_dim * ((self.image_size >> 2)**2)
            net = layers.linear(net, shape, scope='de_fc2')
            net = layers.batch_norm(net,
                                    is_training=is_training,
                                    scope='de_bn2')
            net = tf.nn.relu(net)
            if self.verbose: print(net.shape)

            # Layer 3
            shape = [
                self.batch_size, self.image_size >> 2, self.image_size >> 2,
                self.conv_dim
            ]
            net = tf.reshape(net, shape)
            if self.verbose: print(net.shape)

            # Layer 4
            shape = [
                self.batch_size, self.image_size >> 1, self.image_size >> 1,
                self.conv_dim >> 1
            ]
            net = layers.deconv2d(net, shape, name='de_dc3')
            net = layers.batch_norm(net,
                                    is_training=is_training,
                                    scope='de_bn3')
            net = tf.nn.relu(net)
            if self.verbose: print(net.shape)

            # Layer 5
            shape = [
                self.batch_size, self.image_size, self.image_size,
                self.channels
            ]
            net = layers.deconv2d(net, shape, name='de_dc4')
            out = tf.nn.sigmoid(net, name="main_out")
            if self.verbose: print(out.shape)

            return out
コード例 #4
0
def conv2dbn(l, name, **kwargs):
    l = nn.layers.dnn.Conv2DDNNLayer(
        l, name=name,
        **kwargs
    )
    l = batch_norm(l, name='%sbn' % name)
    return l
コード例 #5
0
 def __call__(self, x):
     fc1 = dense(x, 600, activation_fn=leaky_relu)
     fc2 = dense(fc1, 100, activation_fn=tf.identity)
     z = batch_norm(fc2)
     z = z + 0.05 * tf.random_normal(tf.shape(fc2), mean=0.0, stddev=1)
     fc1_ = dense(z, 600, activation_fn=relu_bn)
     x_ = dense(fc1_, 784, activation_fn=tf.sigmoid)
     return x_
コード例 #6
0
def conv2dbn(l, name, **kwargs):
    """ Batch normalized DNN Conv2D Layer """
    l = nn.layers.dnn.Conv2DDNNLayer(
        l, name=name,
        **kwargs
    )
    l = batch_norm(l, name='%sbn' % name)
    return l
コード例 #7
0
def residual_block3_localbn(layer, name, num_layers, num_filters,
                            bottleneck=False, bottleneck_factor=4,
                            filter_size=(3, 3), stride=1, pad='same',
                            W=nn.init.GlorotUniform(),
                            nonlinearity=nn.nonlinearities.rectify):
    conv = layer

    # Insert shortcut when changing filter size or feature map size
    if (num_filters != layer.output_shape[1]) or (stride != 1):
        # Projection shortcut, aka option B
        layer = nn.layers.dnn.Conv2DDNNLayer(
            layer, name='%s_shortcut' % name, num_filters=num_filters,
            filter_size=1, stride=stride, pad=0, nonlinearity=None, b=None
        )

    if bottleneck and num_layers < 3:
        raise ValueError('At least 3 layers is required for bottleneck configuration')

    for i in range(num_layers):
        if bottleneck:
            # Force then first and last layer to use 1x1 convolution
            if i == 0 or (i == (num_layers - 1)):
                actual_filter_size = (1, 1)
            else:
                actual_filter_size = filter_size

            # Only increase the filter size to the target size for
            # the last layer
            if i == (num_layers - 1):
                actual_num_filters = num_filters
            else:
                actual_num_filters = num_filters / bottleneck_factor
        else:
            actual_num_filters = num_filters
            actual_filter_size = filter_size

        # TODO the last layer should probably not be bn-ed..
        conv = conv2dbn(
            conv, name='%s_%s' % (name, i), num_filters=actual_num_filters,
            filter_size=actual_filter_size, pad=pad, W=W,
            # Remove nonlinearity for the last conv layer
            nonlinearity=nonlinearity if (i < num_layers - 1) else None,
            # Only apply stride for the first conv layer
            stride=stride if i == 0 else 1
        )

    l = nn.layers.merge.ElemwiseSumLayer([conv, layer], name='%s_elemsum' % name)
    l = batch_norm(l)
    l = nn.layers.NonlinearityLayer(l, nonlinearity=nonlinearity, name='%s_elemsum_nl' % name)
    return l
コード例 #8
0
ファイル: resnet50.py プロジェクト: chatterboy/fracture
def block(name, input, filters, ksz, stride, padding):
    """
    :param name: a string
    :param input: a tensor
    :param filters: an integer, # filters
    :param ksz: an integer, the size of filters
    :param stride: an integer
    :param padding: a string, all string need to be uppercase
    :return:
    """
    with tf.variable_scope(name):
        conv = conv2d('conv', input, filters, ksz, stride, padding)
        bn = batch_norm('bn', conv)
        return relu('relu', bn)
コード例 #9
0
def MobileNet(img_input, weights, alpha):
    x = tf.reshape(img_input, shape=[-1, 224, 224, 3])

    # init convolution
    w, b, s = get_weights(weights, 'conv1/kernel:0', 'conv1/bias:0')
    x = conv_2d(x, w, b, s, strides=2, padding='SAME')
    mean, std, beta, gamma = get_bn_param(weights, 'conv1_bn/moving_mean:0',
                                          'conv1_bn/moving_variance:0',
                                          'conv1_bn/beta:0',
                                          'conv1_bn/gamma:0')
    x = batch_norm(x, mean, std, beta, gamma)
    x = tf.nn.relu6(x)

    x = _depthwise_conv_block(x, weights, block_id=1)

    x = _depthwise_conv_block(x, weights, strides=2, block_id=2)
    x = _depthwise_conv_block(x, weights, block_id=3)

    x = _depthwise_conv_block(x, weights, strides=2, block_id=4)
    x = _depthwise_conv_block(x, weights, block_id=5)

    x = _depthwise_conv_block(x, weights, strides=2, block_id=6)
    x = _depthwise_conv_block(x, weights, block_id=7)
    x = _depthwise_conv_block(x, weights, block_id=8)
    x = _depthwise_conv_block(x, weights, block_id=9)
    x = _depthwise_conv_block(x, weights, block_id=10)
    x = _depthwise_conv_block(x, weights, block_id=11)

    x = _depthwise_conv_block(x, weights, strides=2, block_id=12)
    x = _depthwise_conv_block(x, weights, block_id=13)

    x = avgpool_2d(x, k=7)

    x = tf.reshape(x, shape=[-1, 1, 1, int(1024 * alpha)])
    w, b, s = get_weights(weights, 'conv_preds/kernel:0', 'conv_preds/bias:0')
    x = conv_2d(x, w, b, s, strides=1, padding='SAME')
    x = tf.reshape(x, shape=[-1, 1000])
    return x
コード例 #10
0
ファイル: model.py プロジェクト: princeton-vl/think_visually
                predicted_img = tf.where(img_new < 0, x=zeros_img, y=ones_img)
                correct_prediction = tf.cast(tf.equal(predicted_img, img),
                                             tf.float32) * mask_modi
                accuracy_img = tf.cond(
                    tf.equal((tf.reduce_sum(mask_modi) * img_size * img_size),
                             0), lambda: tf.zeros([]),
                    lambda: tf.reduce_sum(correct_prediction) /
                    (tf.reduce_sum(mask_modi) * img_size * img_size))

            # adding batch normalization
            # For FloorPlanQA we observe that DSMN* performs better without this
            if reg == 1:
                img_new = tf.reshape(
                    img_new,
                    shape=[batch_size * img_size * img_size * max_num_sen, -1])
                img_new = layers.batch_norm(img_new, is_training)
                img_new = tf.reshape(
                    img_new,
                    shape=[batch_size, img_size, img_size, max_num_sen])

            # the special softmax layer
            img_new_sig = tf.sigmoid(img_new)
            mask_modi = tf.expand_dims(tf.expand_dims(mask, 1), 1)
            img_new_sig_rel = img_new_sig * mask_modi
        else:
            with tf.variable_scope('loss_image'):
                img_created_reshape = tf.reshape(img_new, [-1, 12])
                img_reshape = tf.reshape(img, [-1, 12])
                loss_mask_temp = loss_mask * tf.expand_dims(
                    tf.expand_dims(tf.expand_dims(img_loss_mask, 1), 1), 1)
                loss_mask_reshape = tf.reshape(loss_mask_temp, [-1, 12])