Exemple #1
0
    def testInvalidStrides(self):
        height, width = 7, 9
        images = random_ops.random_uniform((5, height, width, 3), seed=1)
        with self.assertRaisesRegexp(ValueError, 'strides'):
            pooling_layers.max_pooling2d(images, 3, strides=(1, 2, 3))

        with self.assertRaisesRegexp(ValueError, 'strides'):
            pooling_layers.max_pooling2d(images, 3, strides=None)
Exemple #2
0
    def testInvalidPoolSize(self):
        height, width = 7, 9
        images = random_ops.random_uniform((5, height, width, 3), seed=1)
        with self.assertRaisesRegexp(ValueError, 'pool_size'):
            pooling_layers.max_pooling2d(images, (1, 2, 3), strides=2)

        with self.assertRaisesRegexp(ValueError, 'pool_size'):
            pooling_layers.max_pooling2d(images, None, strides=2)
  def testInvalidPoolSize(self):
    height, width = 7, 9
    images = random_ops.random_uniform((5, height, width, 3), seed=1)
    with self.assertRaisesRegexp(ValueError, 'pool_size'):
      pooling_layers.max_pooling2d(images, (1, 2, 3), strides=2)

    with self.assertRaisesRegexp(ValueError, 'pool_size'):
      pooling_layers.max_pooling2d(images, None, strides=2)
Exemple #4
0
 def testInvalidDataFormat(self):
     height, width = 7, 9
     images = random_ops.random_uniform((5, height, width, 3), seed=1)
     with self.assertRaisesRegexp(ValueError, 'data_format'):
         pooling_layers.max_pooling2d(images,
                                      3,
                                      strides=2,
                                      data_format='invalid')
  def testInvalidStrides(self):
    height, width = 7, 9
    images = random_ops.random_uniform((5, height, width, 3), seed=1)
    with self.assertRaisesRegexp(ValueError, 'strides'):
      pooling_layers.max_pooling2d(images, 3, strides=(1, 2, 3))

    with self.assertRaisesRegexp(ValueError, 'strides'):
      pooling_layers.max_pooling2d(images, 3, strides=None)
Exemple #6
0
def cnn_2d(images, is_training):
    """
    Build the model for 2D-CNN.

    Inputs:
    -- images: Images placeholder
    -- is_training: bool placeholder, training or not

    Output:
    -- Logits: Return the output of the model

    """
    # Build the CNN model
    l_conv1 = conv2d(images,
                     CONV1_FILTERS,
                     KERNEL_SIZE1,
                     strides=STRIDE_CONV1,
                     activation=relu,
                     name='Conv1')

    l_maxpool1 = max_pooling2d(l_conv1,
                               POOL_SIZE1,
                               POOL_SIZE1,
                               padding='same',
                               name='Maxpool1')

    l_conv2 = conv2d(l_maxpool1,
                     CONV2_FILTERS,
                     KERNEL_SIZE2,
                     strides=STRIDE_CONV2,
                     activation=relu,
                     name='Conv2')

    l_maxpool2 = max_pooling2d(l_conv2,
                               POOL_SIZE2,
                               POOL_SIZE2,
                               padding='same',
                               name='Maxpool2')

    l_flatten = flatten(l_maxpool2, scope='Flatten')

    l_fc1 = dense(l_flatten, FC1, activation=relu, name='Fc1')

    l_drop = dropout(l_fc1, DROP_RATE, training=is_training, name='Dropout')

    l_fc2 = dense(l_drop, FC2, activation=relu, name='Fc2')

    logits = dense(l_fc2, NUM_CLASSES, name='Output')

    return logits
 def _make_conv_layers(self):
     self.image_input = tf.placeholder(
         dtype=tf.float32,
         shape=[None, self.HEIGHT, self.WIDTH, 3],
         name="image_input")
     layer = self.image_input
     for p, pooling_config in enumerate(self.config.poolings, 1):
         for c, conv_config in enumerate(pooling_config.convolutions, 1):
             layer = conv2d(
                 inputs=layer,
                 filters=conv_config.n_filters,
                 kernel_size=conv_config.kernel_size,
                 activation=relu,
                 padding="SAME",
                 name=f"conv_{p}_{c}",
             )
         layer = max_pooling2d(inputs=layer,
                               pool_size=2,
                               strides=pooling_config.strides,
                               name=f"pool_{p}")
     self.last_pool_layer = layer
Exemple #8
0
 def mpool(self,
           k_height,
           k_width,
           d_height=2,
           d_width=2,
           mode='VALID',
           input_layer=None,
           num_channels_in=None):
   """Construct a max pooling layer."""
   if input_layer is None:
     input_layer = self.top_layer
   else:
     self.top_size = num_channels_in
   name = 'mpool' + str(self.counts['mpool'])
   self.counts['mpool'] += 1
   pool = pooling_layers.max_pooling2d(
       input_layer, [k_height, k_width], [d_height, d_width],
       padding=mode,
       data_format=self.channel_pos,
       name=name)
   self.top_layer = pool
   return pool
 def testInvalidDataFormat(self):
   height, width = 7, 9
   images = tf.random_uniform((5, height, width, 3), seed=1)
   with self.assertRaisesRegexp(
       ValueError, 'data_format'):
     pooling_layers.max_pooling2d(images, 3, strides=2, data_format='invalid')
 def _maxpool(self, bottom, stride):
     return max_pooling2d(bottom, [stride,stride], [stride,stride])
def MNIST_model(features, labels, mode):
    #input features
    input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

    if mode == tf.estimator.ModeKeys.EVAL:
        #input_data = tf.constant(1.0) - input_layer
        input_data = input_layer
    else:
        input_data = input_layer

#convolution 1
    conv1 = conv2d(inputs=input_data,
                   filters=32,
                   kernel_size=[5, 5],
                   padding="same",
                   activation=relu,
                   use_bias=True)

    #max pooling 1
    pool1 = max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

    #convolution 2
    conv2 = conv2d(inputs=pool1,
                   filters=64,
                   kernel_size=[5, 5],
                   padding="same",
                   activation=relu,
                   use_bias=True)

    #max pooling 2
    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

    #Fully connected
    pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
    dense_out = dense(inputs=pool2_flat, units=hidden_size, activation=relu)
    dropout_out = dropout(inputs=dense_out,
                          rate=drop_rate,
                          training=mode == tf.estimator.ModeKeys.TRAIN)

    #Generate a [28 * 28, 10] matrix as context
    #initialize
    w_a_1 = weight_variable(name="w_a_1", shape=[hidden_size, 28 * 28 * 10])
    b_a_1 = bias_variable(name="b_a_1", shape=[28 * 28 * 10])

    context = tf.add(tf.matmul(dropout_out, w_a_1), b_a_1)
    context_matrix = tf.reshape(context, [-1, 28 * 28, 10])

    #dot product layer
    input_data_flat = tf.reshape(input_data, [-1, 28 * 28, 1])
    input_data_tiled = tf.tile(input=input_data_flat, multiples=[1, 1, 10])
    weighted_context = tf.multiply(input_data_tiled, context_matrix)

    #Generate softmax result
    logits = tf.reduce_sum(weighted_context, axis=[1])

    #a dictionary of prediction operators
    predictions = {
        "logits": tf.multiply(logits, tf.constant(1.0), name="logit_out"),
        #class prediction
        "classes": tf.argmax(input=logits, axis=1),
        #probability prediction
        "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
    }

    #prediction mode
    if mode == tf.estimator.ModeKeys.PREDICT:
        return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

#regularization
    l1_regularizer = tf.contrib.layers.l1_regularizer(scale=reg_scale)
    regularization_cost = tf.contrib.layers.apply_regularization(
        l1_regularizer, [context_matrix])

    #Calculate Loss (for both TRAIN and EVAL modes)
    onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=10)
    error_cost = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels,
                                                 logits=logits)

    #total lost
    loss = regularization_cost + error_cost

    #train mode
    if mode == tf.estimator.ModeKeys.TRAIN:
        optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)
        train_op = optimizer.minimize(loss=loss,
                                      global_step=tf.train.get_global_step())
        return tf.estimator.EstimatorSpec(mode=mode,
                                          loss=loss,
                                          train_op=train_op)

#evaluation metrics (for EVAL mode)
    eval_metric_ops = {
        "accuracy":
        tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])
    }
    return tf.estimator.EstimatorSpec(mode=mode,
                                      loss=loss,
                                      eval_metric_ops=eval_metric_ops)
def MNIST_model(features, labels, mode):
    #input features
    input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

    if mode == tf.estimator.ModeKeys.EVAL:
        input_data = tf.constant(1.0) - input_layer
    else:
        input_data = input_layer

#convolution 1
    conv1 = conv2d(inputs=input_data,
                   filters=32,
                   kernel_size=[5, 5],
                   padding="same",
                   activation=relu,
                   use_bias=True)

    #max pooling 1
    pool1 = max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

    #convolution 2
    conv2 = conv2d(inputs=pool1,
                   filters=64,
                   kernel_size=[5, 5],
                   padding="same",
                   activation=relu,
                   use_bias=True)

    #max pooling 2
    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

    #Fully connected
    pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
    dense_out = dense(inputs=pool2_flat, units=hidden_size, activation=relu)
    dropout_out = dropout(inputs=dense_out,
                          rate=drop_rate,
                          training=mode == tf.estimator.ModeKeys.TRAIN)

    logits = dense(inputs=dropout_out, units=10)

    #a dictionary of prediction operators
    predictions = {
        "logits": tf.multiply(logits, tf.constant(1.0), name="logit_out"),
        #class prediction
        "classes": tf.argmax(input=logits, axis=1),
        #probability prediction
        "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
    }

    #prediction mode
    if mode == tf.estimator.ModeKeys.PREDICT:
        return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

#Calculate Loss (for both TRAIN and EVAL modes)
    onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=10)
    loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels,
                                           logits=logits)

    #train mode
    if mode == tf.estimator.ModeKeys.TRAIN:
        optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
        train_op = optimizer.minimize(loss=loss,
                                      global_step=tf.train.get_global_step())
        return tf.estimator.EstimatorSpec(mode=mode,
                                          loss=loss,
                                          train_op=train_op)

#evaluation metrics (for EVAL mode)
    eval_metric_ops = {
        "accuracy":
        tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])
    }
    return tf.estimator.EstimatorSpec(mode=mode,
                                      loss=loss,
                                      eval_metric_ops=eval_metric_ops)
Exemple #13
0
 def _maxpool(self, bottom):
     return max_pooling2d(bottom, [2, 2], [2, 2])
    def _create_model(self):

        self.input_image = tf.placeholder(tf.float32, shape=(None, None, None, self.img_input_channels), name='input_image_placeholder')
        self.gt_image = tf.placeholder(tf.int32, shape=(None, None, None, self.num_classes), name='gt_image_placeholder')
        self.gt_contours = tf.placeholder(tf.int32, shape=(None, None, None, self.num_classes), name='gt_contours_placeholder')
        self.dropout_prob = tf.placeholder(dtype=tf.float32, shape=None, name='dropout_prob_placeholder')

        self.lr = tf.placeholder(dtype=tf.float32, shape=None, name='learning_rate_placeholder')

        scale_nc = self.hps.get('scale_nc')

        with tf.variable_scope("encoder"):
            with tf.variable_scope("block_1"):
                conv1 = self._add_common_layers(conv2d(self.input_image, filters=32*scale_nc, kernel_size=3, padding='same'))
                conv2 = self._add_common_layers(conv2d(conv1, filters=32*scale_nc, kernel_size=3, padding='same'))

            with tf.variable_scope("block_2"):
                mp2 = max_pooling2d(conv2, pool_size=2, strides=2, padding='same')
                bn1 = self._add_common_layers(self._bottleneck(mp2, size=64*scale_nc))
                bn2 = self._add_common_layers(self._bottleneck(bn1, size=64*scale_nc))

            with tf.variable_scope("block_3"):
                mp3 = max_pooling2d(bn2, pool_size=2, strides=2, padding='same')
                bn3 = self._add_common_layers(self._bottleneck(mp3, size=128*scale_nc))
                bn4 = self._add_common_layers(self._bottleneck(bn3, size=128*scale_nc))

            with tf.variable_scope("block_4"):
                mp4 = max_pooling2d(bn4, pool_size=2, strides=2, padding='same')
                bn5 = self._add_common_layers(self._bottleneck(mp4, size=256*scale_nc))
                bn6 = self._add_common_layers(self._bottleneck(bn5, size=256*scale_nc))
                d1 = dropout(bn6, rate=self.dropout_prob)

            with tf.variable_scope("block_5"):
                mp5 = max_pooling2d(d1, pool_size=2, strides=2, padding='same')
                bn7 = self._add_common_layers(self._bottleneck(mp5, size=256*scale_nc))
                bn8 = self._add_common_layers(self._bottleneck(bn7, size=256*scale_nc))
                d2 = dropout(bn8, rate=self.dropout_prob)

            with tf.variable_scope("block_6"):
                mp6 = max_pooling2d(d2, pool_size=2, strides=2, padding='same')
                bn9 = self._add_common_layers(self._bottleneck(mp6, size=256*scale_nc))
                bn10 = self._add_common_layers(self._bottleneck(bn9, size=256*scale_nc))
                d3 = dropout(bn10, rate=self.dropout_prob)

        self.img_descriptor = tf.reduce_mean(d3, axis=(1, 2))

        with tf.variable_scope("decoder_seg"):
            deconvs = []
            deconvs.append(conv2d(conv2, filters=self.num_classes, kernel_size=3,
                                  padding='same'))
            deconvs.append(self._upsample(bn2, k=1))
            deconvs.append(self._upsample(bn4, k=2))
            deconvs.append(self._upsample(d1, k=3))
            deconvs.append(self._upsample(d2, k=4))
            deconvs.append(self._upsample(d3, k=5))

            concat = tf.concat(deconvs, axis=3)

            conv3 = conv2d(concat, filters=self.num_classes, kernel_size=3, padding='same')
            ac1 = self._add_common_layers(conv3)

            conv4 = conv2d(ac1, filters=self.num_classes, kernel_size=1, padding='same')
            ac2 = self._add_common_layers(conv4)

            self.preds_seg = softmax(ac2)

        with tf.variable_scope("decoder_cont"):
            deconvs = []
            deconvs.append(conv2d(conv2, filters=self.num_classes, kernel_size=3,
                                  padding='same'))
            deconvs.append(self._upsample(bn2, k=1))
            deconvs.append(self._upsample(bn4, k=2))
            deconvs.append(self._upsample(d1, k=3))
            deconvs.append(self._upsample(d2, k=4))
            deconvs.append(self._upsample(d3, k=5))

            concat = tf.concat(deconvs, axis=3)

            conv3 = conv2d(concat, filters=self.num_classes, kernel_size=3, padding='same')
            ac1 = self._add_common_layers(conv3)

            conv4 = conv2d(ac1, filters=self.num_classes, kernel_size=1, padding='same')
            ac2 = self._add_common_layers(conv4)

            self.preds_cont = softmax(ac2)

        cond1 = tf.greater_equal(self.preds_seg, self.threshold)
        cond2 = tf.less(self.preds_cont, self.threshold)

        conditions = tf.logical_and(cond1, cond2)

        self.preds = tf.where(conditions, tf.ones_like(conditions), tf.zeros_like(conditions))

        self._add_train_op()

        self.summaries = tf.summary.merge_all()