Example #1
0
    def create(self):
        # 1st Layer: Conv (w ReLu) -> Pool -> Lrn
        conv1 = conv(self.tensor,
                     11,
                     11,
                     96,
                     4,
                     4,
                     padding='VALID',
                     name='conv1',
                     trainable=self.is_layer_trainable('conv1'))
        norm1 = tf.nn.local_response_normalization(conv1,
                                                   depth_radius=2,
                                                   alpha=2e-05,
                                                   beta=0.75,
                                                   bias=1.0,
                                                   name='norm1')
        pool1 = tf.nn.max_pool(norm1,
                               ksize=[1, 3, 3, 1],
                               strides=[1, 2, 2, 1],
                               padding='VALID',
                               name='pool1')

        # 2nd Layer: Conv (w ReLu) -> Pool -> Lrn with 2 groups
        conv2 = conv(pool1,
                     5,
                     5,
                     256,
                     1,
                     1,
                     groups=2,
                     name='conv2',
                     trainable=self.is_layer_trainable('conv2'))
        norm2 = tf.nn.local_response_normalization(conv2,
                                                   depth_radius=2,
                                                   alpha=2e-05,
                                                   beta=0.75,
                                                   bias=1.0,
                                                   name='norm2')
        pool2 = tf.nn.max_pool(norm2,
                               ksize=[1, 3, 3, 1],
                               strides=[1, 2, 2, 1],
                               padding='VALID',
                               name='pool2')

        # 3rd Layer: Conv (w ReLu)
        conv3 = conv(pool2,
                     3,
                     3,
                     384,
                     1,
                     1,
                     name='conv3',
                     trainable=self.is_layer_trainable('conv3'))

        # 4th Layer: Conv (w ReLu) splitted into two groups
        conv4 = conv(conv3,
                     3,
                     3,
                     384,
                     1,
                     1,
                     groups=2,
                     name='conv4',
                     trainable=self.is_layer_trainable('conv4'))

        # 5th Layer: Conv (w ReLu) -> Pool splitted into two groups
        conv5 = conv(conv4,
                     3,
                     3,
                     256,
                     1,
                     1,
                     groups=2,
                     name='conv5',
                     trainable=self.is_layer_trainable('conv5'))
        pool5 = tf.nn.max_pool(conv5,
                               ksize=[1, 3, 3, 1],
                               strides=[1, 2, 2, 1],
                               padding='VALID',
                               name='pool5')

        # 6th Layer: Flatten -> FC (w ReLu) -> Dropout
        pool5_out = int(np.prod(pool5.get_shape()[1:]))  # 6 * 6 * 256 = 9216
        pool5_flat = tf.reshape(
            pool5,
            [-1, pool5_out
             ])  # shape=(image count, 6, 6, 256) -> shape=(image count, 9216)
        fc6 = fc(pool5_flat,
                 4096,
                 name='fc6',
                 trainable=self.is_layer_trainable('fc6'))
        dropout6 = tf.nn.dropout(fc6, self.keep_prob)

        # 7th Layer: FC (w ReLu) -> Dropout
        fc7 = fc(dropout6,
                 4096,
                 name='fc7',
                 trainable=self.is_layer_trainable('fc7'))
        dropout7 = tf.nn.dropout(fc7, self.keep_prob)

        # 8th Layer: FC and return unscaled activations (for tf.nn.softmax_cross_entropy_with_logits)
        fc8 = fc(dropout7,
                 self.num_classes,
                 relu=False,
                 name='fc8',
                 trainable=self.is_layer_trainable('fc8'))

        # add layers to the endpoints dict
        endpoints = OrderedDict()
        endpoints['conv1'] = conv1
        endpoints['pool1'] = pool1
        endpoints['conv2'] = conv2
        endpoints['pool2'] = pool2
        endpoints['conv3'] = conv3
        endpoints['conv4'] = conv4
        endpoints['conv5'] = conv5
        endpoints['pool5'] = pool5
        endpoints['pool5/flat'] = pool5_flat  # 9216
        endpoints['fc6'] = fc6  # 4096
        endpoints['fc7'] = fc7  # 4096
        endpoints['fc8'] = fc8  # number of classes

        return fc8, endpoints
Example #2
0
    def create(self):
        # 1st Layer: Conv -> Conv -> Pool
        # conv(tensor, filter_height, filter_width, num_filters, stride_y, stride_x, name, padding)
        conv1_1 = conv(self.tensor,
                       3,
                       3,
                       64,
                       1,
                       1,
                       padding='SAME',
                       name='conv1_1',
                       trainable=self.is_layer_trainable('conv1_1'))
        conv1_2 = conv(conv1_1,
                       3,
                       3,
                       64,
                       1,
                       1,
                       padding='SAME',
                       name='conv1_2',
                       trainable=self.is_layer_trainable('conv1_2'))
        pool1 = tf.nn.max_pool(conv1_2,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool1')

        # 2nd Layer: Conv -> Conv -> Pool
        conv2_1 = conv(pool1,
                       3,
                       3,
                       128,
                       1,
                       1,
                       padding='SAME',
                       name='conv2_1',
                       trainable=self.is_layer_trainable('conv2_1'))
        conv2_2 = conv(conv2_1,
                       3,
                       3,
                       128,
                       1,
                       1,
                       padding='SAME',
                       name='conv2_2',
                       trainable=self.is_layer_trainable('conv2_2'))
        pool2 = tf.nn.max_pool(conv2_2,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool2')

        # 3rd Layer: Conv -> Conv -> Conv -> Pool
        conv3_1 = conv(pool2,
                       3,
                       3,
                       256,
                       1,
                       1,
                       padding='SAME',
                       name='conv3_1',
                       trainable=self.is_layer_trainable('conv3_1'))
        conv3_2 = conv(conv3_1,
                       3,
                       3,
                       256,
                       1,
                       1,
                       padding='SAME',
                       name='conv3_2',
                       trainable=self.is_layer_trainable('conv3_2'))
        conv3_3 = conv(conv3_2,
                       3,
                       3,
                       256,
                       1,
                       1,
                       padding='SAME',
                       name='conv3_3',
                       trainable=self.is_layer_trainable('conv3_3'))
        pool3 = tf.nn.max_pool(conv3_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool3')

        # 4th Layer: Conv -> Conv -> Conv -> Pool
        conv4_1 = conv(pool3,
                       3,
                       3,
                       512,
                       1,
                       1,
                       padding='SAME',
                       name='conv4_1',
                       trainable=self.is_layer_trainable('conv4_1'))
        conv4_2 = conv(conv4_1,
                       3,
                       3,
                       512,
                       1,
                       1,
                       padding='SAME',
                       name='conv4_2',
                       trainable=self.is_layer_trainable('conv4_2'))
        conv4_3 = conv(conv4_2,
                       3,
                       3,
                       512,
                       1,
                       1,
                       padding='SAME',
                       name='conv4_3',
                       trainable=self.is_layer_trainable('conv4_3'))
        pool4 = tf.nn.max_pool(conv4_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool4')

        # 5th Layer: Conv -> Conv -> Conv -> Pool
        conv5_1 = conv(pool4,
                       3,
                       3,
                       512,
                       1,
                       1,
                       padding='SAME',
                       name='conv5_1',
                       trainable=self.is_layer_trainable('conv5_1'))
        conv5_2 = conv(conv5_1,
                       3,
                       3,
                       512,
                       1,
                       1,
                       padding='SAME',
                       name='conv5_2',
                       trainable=self.is_layer_trainable('conv5_2'))
        conv5_3 = conv(conv5_2,
                       3,
                       3,
                       512,
                       1,
                       1,
                       padding='SAME',
                       name='conv5_3',
                       trainable=self.is_layer_trainable('conv5_3'))
        pool5 = tf.nn.max_pool(conv5_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool5')

        # 6th Layer: FC -> DropOut
        # [1:] cuts away the first element
        pool5_out = int(np.prod(pool5.get_shape()[1:]))  # 7 * 7 * 512 = 25088
        pool5_flat = tf.reshape(
            pool5,
            [-1, pool5_out
             ])  # shape=(image count, 7, 7, 512) -> shape=(image count, 25088)
        fc6 = fc(pool5_flat,
                 num_out=4096,
                 name='fc6',
                 relu=True,
                 trainable=self.is_layer_trainable('fc6'))
        dropout1 = tf.nn.dropout(fc6, self.keep_prob)

        # 7th Layer: FC
        fc7 = fc(dropout1,
                 num_out=4096,
                 name='fc7',
                 relu=True,
                 trainable=self.is_layer_trainable('fc7'))
        dropout2 = tf.nn.dropout(fc7, self.keep_prob)

        # 8th Layer: FC
        fc8 = fc(dropout2,
                 num_out=self.num_classes,
                 name='fc8',
                 relu=False,
                 trainable=self.is_layer_trainable('fc8'))

        # add layers to the endpoints dict
        endpoints = OrderedDict()
        endpoints['conv1/conv1_1'] = conv1_1
        endpoints['conv1/conv1_2'] = conv1_2
        endpoints['pool1'] = pool1
        endpoints['conv2/conv2_1'] = conv2_1
        endpoints['conv2/conv2_2'] = conv2_2
        endpoints['pool2'] = pool2
        endpoints['conv3/conv3_1'] = conv3_1
        endpoints['conv3/conv3_2'] = conv3_2
        endpoints['conv3/conv3_3'] = conv3_3
        endpoints['pool3'] = pool3
        endpoints['conv4/conv4_1'] = conv4_1
        endpoints['conv4/conv4_2'] = conv4_2
        endpoints['conv4/conv4_3'] = conv4_3
        endpoints['pool4'] = pool4
        endpoints['conv5/conv5_1'] = conv5_1
        endpoints['conv5/conv5_2'] = conv5_2
        endpoints['conv5/conv5_3'] = conv5_3
        endpoints['pool5'] = pool5
        endpoints['pool5/flat'] = pool5_flat  # 25088
        endpoints['fc6'] = fc6  # 4096
        endpoints['fc7'] = fc7  # 4096
        endpoints['fc8'] = fc8  # number of output classes

        return fc8, endpoints