使用 tensorflow 实现旋转不变卷积层

Question

我正在尝试使用 tensorflow 实现旋转不变卷积层，作为 udacity 深度学习课程的一部分。

我尝试了下面的方法，但它没有因为我收到以下错误：

grad_ys, name, colocate_gradients_with_ops, gate_gradients, aggregation_method)
    424             raise LookupError(
    425                 "No gradient defined for operation '%s' (op type: %s)" %
--> 426                 (op.name, op.type))
    427         if grad_fn and any(out_grads):
    428           # NOTE: If _AggregatedGrads didn't compute a value for the i'th

LookupError: No gradient defined for operation 'Reverse_1' (op type: Reverse)

在这里，我尝试通过将原始的 90 度旋转图像馈送到同一个卷积核来实现最简单的方法。在此之后，我将相应卷积层的输出旋转回来。

您对如何解决这种方法有任何想法，或者您是否知道实现至少 90 度旋转不变卷积层的更好方法？

我的代码：

batch_size = 16
patch_size_1 = 3
patch_size_2 = 3
patch_size_3 = 2
depth = 32
num_hidden = 32
mx_pool_size_1 = 3
mx_pool_size_2 = 3
mx_pool_size_3 = 2
stride = 1
starter_learning_rate = 0.05
num_steps = 1001

graph = tf.Graph()

with graph.as_default():

  # Input data.
  tf_train_dataset = tf.placeholder(tf.float32, shape=(batch_size, image_size, image_size, num_channels))
  tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
  tf_valid_dataset = tf.constant(valid_dataset)
  tf_test_dataset = tf.constant(test_dataset)
  global_step = tf.Variable(0, trainable=False)

  # Variables.
  layer1_weights = tf.Variable(tf.truncated_normal([patch_size_1, patch_size_1, num_channels, depth], stddev=0.1))
  layer1_biases = tf.Variable(tf.zeros([depth]))

  layer12_weights = tf.Variable(tf.truncated_normal([patch_size_1, patch_size_1, num_channels, depth], stddev=0.1))
  layer12_biases = tf.Variable(tf.zeros([depth]))


  layer2_weights = tf.Variable(tf.truncated_normal([patch_size_2, patch_size_2, depth, depth], stddev=0.1))
  layer2_biases = tf.Variable(tf.constant(1.0, shape=[depth]))

  layer3_weights = tf.Variable(tf.truncated_normal([patch_size_3, patch_size_3, depth, depth], stddev=0.1))
  layer3_biases = tf.Variable(tf.constant(1.0, shape=[depth]))

  layer4_weights = tf.Variable(tf.truncated_normal(
            #[image_size * image_size * depth / (mx_pool_size_1 ** 2 * mx_pool_size_2 ** 2 * stride ** 4) , num_hidden],
            [512 , num_hidden], 
            stddev=0.1))
  layer4_biases = tf.Variable(tf.constant(1.0, shape=[num_hidden]))

  layer5_weights = tf.Variable(tf.truncated_normal([num_hidden, num_labels], stddev=0.1))
  layer5_biases = tf.Variable(tf.constant(1.0, shape=[num_labels]))

  # Model.
  def model(data, train = False):        
    conv1 = tf.nn.conv2d(data, layer1_weights, [1, stride, stride, 1], padding='SAME')
    conv1 = tf.nn.max_pool(conv1, 
                          [1, mx_pool_size_1, mx_pool_size_1, 1], 
                          [1, mx_pool_size_1, mx_pool_size_1, 1], 
                          padding='SAME')
    hidden1 = tf.nn.relu(conv1 + layer1_biases)
    hidden1 = tf.reshape(hidden1, [-1, 100, 1, depth])

    data1 = tf.reverse(tf.transpose(data, [0, 2, 1, 3]), [False, True, False, False])

    conv2 = tf.nn.conv2d(data, layer12_weights, [1, stride, stride, 1], padding='SAME')
    conv2 = tf.nn.max_pool(conv2, 
                          [1, mx_pool_size_1, mx_pool_size_1, 1], 
                          [1, mx_pool_size_1, mx_pool_size_1, 1], 
                          padding='SAME')
    hidden2 = tf.nn.relu(conv2 + layer12_biases)

    hidden2 = tf.reverse(tf.transpose(hidden2, [0, 2, 1, 3]), [False, True, False, False])

    hidden2 = tf.reshape(hidden2, [-1, 100, 1, depth])

    hidden = tf.concat(2, [hidden1, hidden2])
    hidden = tf.nn.max_pool(hidden,[1, 1, 2, 1], [1, 1, 2, 1], padding='SAME')
    hidden = tf.reshape(hidden, [-1, 10, 10, depth])

    conv = tf.nn.conv2d(hidden, 
                          layer2_weights, 
                          [1, stride, stride, 1], 
                          padding='SAME')
    conv = tf.nn.max_pool(conv, 
                          [1, mx_pool_size_2, mx_pool_size_2, 1], 
                          [1, mx_pool_size_2, mx_pool_size_2, 1], 
                          padding='SAME')
    hidden = tf.nn.relu(conv + layer2_biases)

    shape = hidden.get_shape().as_list()
    reshape = tf.reshape(hidden, [shape[0], shape[1] * shape[2] * shape[3]])
    hidden = tf.nn.relu(tf.matmul(reshape, layer4_weights) + layer4_biases)
    return tf.matmul(hidden, layer5_weights) + layer5_biases

  # Training computation.
  logits = model(tf_train_dataset, True)
  loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))

  learning_rate = starter_learning_rate #tf.train.exponential_decay(starter_learning_rate, global_step, batch_size , 0.999, staircase=True)

  # Optimizer.
  optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)


  # Predictions for the training, validation, and test data.
  train_prediction = tf.nn.softmax(logits)
  valid_prediction = tf.nn.softmax(model(tf_valid_dataset))
  test_prediction = tf.nn.softmax(model(tf_test_dataset))

Answer 1

最新版本的 TensorFlow (0.6.0) 缺少 tf.reverse() 的渐变定义。它是在后续的commit 中添加的，您可以将以下代码添加到程序的顶层以使用它而无需升级：

@tf.RegisterGradient("Reverse")
def _ReverseGrad(op, grad):
  reverse_dims = op.inputs[1]
  return tf.reverse(grad, reverse_dims), None