コード例 #1
0
    def generator_AB(self, inputs, is_training, reuse=False):
        with tf.variable_scope('Generator_AB', reuse=reuse):
            with tf.variable_scope('g_ab_hidden1'):
                layer1_1 = lrelu(
                    bn(
                        conv2d(inputs,
                               64, [3, 3],
                               initializer='random',
                               name='conv_1'), is_training))

            with tf.variable_scope('g_ab_hidden2'):
                layer2_1 = max_pool(layer1_1, name='pool1')
                layer2_2 = lrelu(
                    bn(
                        conv2d(layer2_1,
                               128, [3, 3],
                               initializer='random',
                               name='conv_2'), is_training))

            with tf.variable_scope('g_ab_hidden3'):
                layer3_1 = max_pool(layer2_2, name='pool2')
                layer3_2 = lrelu(
                    bn(
                        conv2d(layer3_1,
                               256, [3, 3],
                               initializer='random',
                               name='conv_3'), is_training))

            with tf.variable_scope('g_ab_hidden4'):
                layer4_1 = conv2d_t(layer3_2, [None, 14, 14, 128], [2, 2],
                                    initializer='random',
                                    name='convT_4')
                layer4_2 = tf.concat([layer4_1, layer2_2], axis=3)
                layer4_3 = lrelu(
                    bn(
                        conv2d(layer4_2,
                               128, [3, 3],
                               initializer='random',
                               name='conv_4'), is_training))

            with tf.variable_scope('g_ab_hidden5'):
                layer5_1 = conv2d_t(layer4_3, [None, 28, 28, 64], [2, 2],
                                    initializer='random',
                                    name='convT5')
                layer5_2 = tf.concat([layer1_1, layer5_1], axis=3)
                layer5_3 = conv2d(layer5_2,
                                  1, [3, 3],
                                  initializer='random',
                                  name='conv5')
                layer5_4 = conv2d(layer5_3,
                                  1, [1, 1],
                                  initializer='random',
                                  name='conv6')
                gen_ab = tf.nn.sigmoid(layer5_4)

            return gen_ab, layer5_4
コード例 #2
0
ファイル: dcgan.py プロジェクト: brianjang/reddit_challenge
    def generator(self, inputs, is_training, reuse=False):
        with tf.variable_scope('generator', reuse=reuse):
            g_hidden1 = fully_connect(inputs, 1024, name='g_hidden1')
            g_hidden2 = lrelu(bn(fully_connect(g_hidden1, 7*7*128), is_training))
            g_reshape = tf.reshape(g_hidden2, [-1, 7, 7, 128])
            g_hidden3 = lrelu(bn(conv2d_t(g_reshape, [None, 14, 14, 64], [4, 4], name='g_hidden3'), is_training))
            g_hidden4 = conv2d_t(g_hidden3, [None, 28, 28, 1], [4, 4], name='g_hidden4')
            g_logtis = sigmoid(g_hidden4)

            return g_hidden4, g_logtis
コード例 #3
0
ファイル: dcgan.py プロジェクト: brianjang/reddit_challenge
 def discriminator(self, inputs, is_training, reuse=False):
     with tf.variable_scope('discriminator', reuse=reuse):
         d_hidden1 = conv2d(inputs, 64, [4, 4], strides=[1, 2, 2, 1], name='d_hidden1')
         d_hidden2 = lrelu(bn(conv2d(d_hidden1, 128, [4, 4], strides=[1, 2, 2, 1], name='d_hidden2'), is_training))
         d_flatten = tf.reshape(d_hidden2, [-1, 7*7*128])
         d_hidden3 = lrelu(bn(fully_connect(d_flatten, 1024, name='d_hidden3'), is_training))
         d_hidden4 = fully_connect(d_hidden3, 1, name='d_hidden4')
         d_logits = sigmoid(d_hidden4)
         
         return d_hidden4, d_logits
コード例 #4
0
    def discriminator_B(self, inputs, is_training, reuse=False):
        with tf.variable_scope('discirminator_B', reuse=reuse):
            layer1 = lrelu(
                bn(
                    conv2d(inputs,
                           64, [4, 4],
                           strides=[1, 2, 2, 1],
                           initializer='random',
                           name='d_B_hiddne1'), is_training))
            layer2 = lrelu(
                bn(
                    conv2d(layer1,
                           128, [4, 4],
                           strides=[1, 2, 2, 1],
                           initializer='random',
                           name='d_B_hidden2'), is_training))
            flatten = tf.reshape(layer2, [-1, 7 * 7 * 128])
            layer3 = lrelu(
                bn(fully_connect(flatten, 1024, name='d_B_hidden3'),
                   is_training))
            layer4 = fully_connect(layer3, 1, name='d_B_hidden')
            logits = sigmoid(layer4)

            return logits, layer4
コード例 #5
0
ファイル: yolo2.py プロジェクト: brianjang/reddit_challenge
    def make_model(self, inputs, is_training):
        with tf.variable_scope('Darknet19'):
            net = lrelu(bn(conv2d(inputs, 32, [3, 3], name='conv1'), is_training))
            net = max_pool(net, name='pool1')

            net = lrelu(bn(conv2d(net, 64, [3, 3], name='conv2'), is_training))
            net = max_pool(net, name='pool2')

            net = lrelu(bn(conv2d(net, 128, [3, 3], name='conv3'), is_training))
            net = lrelu(bn(conv2d(net, 64, [1, 1], name='conv4'), is_training))
            net = lrelu(bn(conv2d(net, 128, [3, 3], name='conv5'), is_training))
            net = max_pool(net, name='pool3')

            net = lrelu(bn(conv2d(net, 256, [3, 3], name='conv6'), is_training))
            net = lrelu(bn(conv2d(net, 128, [1, 1], name='conv7'), is_training))
            net = lrelu(bn(conv2d(net, 256, [3, 3], name='conv8'), is_training))
            net = max_pool(net, name='pool4')

            net = lrelu(bn(conv2d(net, 512, [3, 3], name='conv9'), is_training))
            net = lrelu(bn(conv2d(net, 256, [1, 1], name='conv10'), is_training))
            net = lrelu(bn(conv2d(net, 512, [3, 3], name='conv11'), is_training))
            net = lrelu(bn(conv2d(net, 256, [3, 3], name='conv12'), is_training))
            skip = lrelu(bn(conv2d(net, 512, [3, 3], name='conv13'), is_training))
            net = max_pool(net, name='pool5')

            net = lrelu(bn(conv2d(net, 1024, [3, 3], name='conv14'), is_training))
            net = lrelu(bn(conv2d(net, 512, [1, 1], name='conv15'), is_training))
            net = lrelu(bn(conv2d(net, 1024, [3, 3], name='conv16'), is_training))
            net = lrelu(bn(conv2d(net, 512, [1, 1], name='conv17'), is_training))
            net = lrelu(bn(conv2d(net, 1024, [3, 3], name='conv18'), is_training))

        with tf.variable_scope('Detection'):
            net = lrelu(bn(conv2d(net, 1024, [3, 3], name='conv19'), is_training))
            net = lrelu(bn(conv2d(net, 1024, [3, 3], name='conv20'), is_training))

            passthrough = lrelu(bn(conv2d(skip, 64, [1, 1], name='conv21_passthrough'), is_training))
            passthrough = tf.space_to_depth(passthrough, block_size=2)

            concated = tf.concat([passthrough, net], axis=3)

            net = lrelu(bn(conv2d(concated, 1024, [3, 3], name='conv22'), is_training))

            out_depth = self.N_ANCHORS * (5 + self.N_CLASSES)
            net = conv2d(net, out_depth, [1, 1], name='conv23')
            
            return net