在TensorFlow中使用make_template（）

Question

我试图使用make_template（）来避免在整个模型中传递重用标志。但make_template（）在python类中使用时似乎无法正常工作。我粘贴了]我的模型代码和下面出现的错误。这是一个在MNIST数据集上进行训练的简单MLP。

由于代码有点长，这里的主要部分是_weights（）函数。我尝试使用make_template（）包装它，然后在其中使用get_variables（）在整个模型中创建和重用权重_权重（）由_create_densite_layer（）使用，而_create_model（）则使用权重（）创建图形。函数的作用是：接受从数据读取器获取的张量。

模型

class MLP(object):
    def __init__(self, hidden=[], biases=False, activation=tf.nn.relu):
        self.graph = tf.get_default_graph()
        self.hidden = hidden
        self.activation = activation
        self.biases = biases
        self.n_features = 784
        self.n_classes = 10
        self.bsize = 100
        self.l2 = 0.1

    def _real_weights(self, shape):
        initializer=tf.truncated_normal_initializer(stddev=0.1)
        weights = tf.get_variable('weights', shape, initializer=initializer)
        return weights
    # use make_template to make variable reuse transparent
    _weights = tf.make_template('_weights', _real_weights)

    def _real_biases(self, shape):
        initializer=tf.constant_initializer(0.0)
        return tf.get_variable('biases', shape, initializer=initializer)
    # use make_template to make variable reuse transparent
    _biases = tf.make_template('_biases', _real_biases)

    def _create_dense_layer(self, name, inputs, n_in, n_out, activation=True):
        with tf.variable_scope(name):
            weights = self._weights([n_in, n_out])
            layer = tf.matmul(inputs, weights)
            if self.biases:
                biases = self._biases([n_out])
                layer = layer + biases
            if activation:
                layer = self.activation(layer)
            return layer

    def _create_model(self, inputs):
        n_in = self.n_features
        for i in range(len(self.hidden)):
            n_out = self.hidden[i]
            name = 'hidden%d' % (i)
            inputs = self._create_dense_layer(name, inputs, n_in, n_out)
            n_in = n_out
        output = self._create_dense_layer('output', inputs, n_in, self.n_classes, activation=False)    
        return output

    def _create_loss_op(self, logits, labels):
        cent = tf.nn.softmax_cross_entropy_with_logits(logits, labels)
        weights = self.graph.get_collection('weights')
        l2 = (self.l2 / self.bsize) * tf.reduce_sum([tf.reduce_sum(tf.square(w)) for w in weights])
        return tf.reduce_mean(cent, name='loss') + l2

    def _create_train_op(self, loss):
        optimizer = tf.train.AdamOptimizer()
        return optimizer.minimize(loss)

    def _create_accuracy_op(self, logits, labels):
        predictions = tf.nn.softmax(logits)
        errors = tf.equal(tf.argmax(predictions, 1), tf.argmax(labels, 1))
        return tf.reduce_mean(tf.cast(errors, tf.float32))

    def train(self, images, labels):
        logits = model._create_model(images)
        loss = model._create_loss_op(logits, labels)
        return model._create_train_op(loss)       

    def accuracy(self, images, labels):
        logits = model._create_model(images)
        return model._create_accuracy_op(logits, labels)

    def predict(self, images):
        return model._create_model(images)

错误：

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
     25     model = MLP(hidden=[128])
     26     # define ops
---> 27     train = model.train(images, labels)
     28     accuracy = model.accuracy(eval_images, eval_labels)
     29     # load test data and create a prediction op

 in train(self, images, labels)
     60 
     61     def train(self, images, labels):
---> 62         logits = model._create_model(images)
     63         loss = model._create_loss_op(logits, labels)
     64         return model._create_train_op(loss)

 in _create_model(self, inputs)
     39             n_out = self.hidden[i]
     40             name = 'hidden%d' % (i)
---> 41             inputs = self._create_dense_layer(name, inputs, n_in, n_out)
     42             n_in = n_out
     43         output = self._create_dense_layer('output', inputs, n_in, self.n_classes, activation=False)

 in _create_dense_layer(self, name, inputs, n_in, n_out, activation)
     25     def _create_dense_layer(self, name, inputs, n_in, n_out, activation=True):
     26         with tf.variable_scope(name):
---> 27             weights = self._weights([n_in, n_out])
     28             layer = tf.matmul(inputs, weights)
     29             if self.biases:

/usr/local/lib/python3.5/site-packages/tensorflow/python/ops/template.py in __call__(self, *args, **kwargs)
    265           self._unique_name, self._name) as vs:
    266         self._var_scope = vs
--> 267         return self._call_func(args, kwargs, check_for_new_variables=False)
    268 
    269   @property

/usr/local/lib/python3.5/site-packages/tensorflow/python/ops/template.py in _call_func(self, args, kwargs, check_for_new_variables)
    206           ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES))
    207 
--> 208       result = self._func(*args, **kwargs)
    209       if check_for_new_variables:
    210         trainable_variables = ops.get_collection(

TypeError: _real_weights() missing 1 required positional argument: 'shape'

originally defined at:
  File "", line 1, in 
    class MLP(object):
  File "", line 17, in MLP
    _weights = tf.make_template('_weights', _real_weights)

Answer 1

此代码存在多个问题，例如列车中的模型参考，准确性和预测方法。我认为这是因为从它的自然栖息地中删除了代码。

您提到的TypeError的原因，

TypeError: _real_weights() missing 1 required positional argument: 'shape'

最可能的原因是\u real\u weights本身是MLP类的实例方法，而不是常规函数或静态方法。因此，函数的第一个参数始终是调用时指向类实例的self引用（类C语言中this指针的显式版本），如函数声明中所示：

def _real_weights(self, shape):
    initializer=tf.truncated_normal_initializer(stddev=0.1)
    weights = tf.get_variable('weights', shape, initializer=initializer)
    return weights

请注意，即使不使用参数，在本例中仍然需要它。因此，在使用创建函数模板时

tf.make_template('_weights', self._real_weights)

您基本上声明您创建的_weights模板应该包含两个位置参数：自己和权重（就像_real_weights方法一样）。因此，当您将从模板创建的函数调用为

weights = self._weights([n_in, n_out])

您将数组传递给自己参数，而不指定（必需的）形状参数。

看起来你有两个选择：你可以让_real_weights成为MLP类之外的常规函数，这样

def _real_weights(shape):
    initializer=tf.truncated_normal_initializer(stddev=0.1)
    weights = tf.get_variable('weights', shape, initializer=initializer)
    return weights

class MLP():
    # etc.

这可能不是你想要的，因为你已经为模型创建了一个类——或者你可以显式地把它变成MLP类的静态方法，这样

class MLP():
    @staticmethod
    def _real_weights(shape):
        initializer=tf.truncated_normal_initializer(stddev=0.1)
        weights = tf.get_variable('weights', shape, initializer=initializer)
        return weights

由于静态方法按定义不在类实例上操作，因此您可以（并且必须）省略self引用。

然后，您将创建模板

tf.make_template('_weights', _real_weights)

在第一种情况下和

tf.make_template('_weights', MLP._real_weights)

在第二种情况下，显式指定类MLP作为静态方法的名称范围。无论哪种方式，\u real\u weights函数/方法和\u weights模板现在都只有一个参数，即要创建的变量的形状。