了解作为类的 TensorFlow 模型和 TensorFlow Session 如何交互

Question

我已经使用 TensorFlow 一段时间了。并相信我对 TensorFlow 图在会话中的工作和执行方式有透彻的了解。但是，我已经以类似脚本的方式编写了我所有的 TensorFlow 模型：

import tensorflow as tf
import DataWorker
import Constants

x = tf.placeholder(tf.float32, [None, Constants.sequenceLength, DataWorker.numFeatures])
y = tf.placeholder(tf.float32, [None, 1])
xTensors = tf.unstack(x, axis=1)   # [seqLength tensors of shape (batchSize, numFeatures)]

W = tf.Variable(tf.random_normal([Constants.numHidden, 1]))     # Weighted matrix
b = tf.Variable(tf.random_normal([1]))                          # Bias

cell = tf.contrib.rnn.BasicLSTMCell(Constants.numHidden, forget_bias=Constants.forgetBias)
outputs, finalState = tf.nn.static_rnn(cell, xTensors, dtype=tf.float32)
# predictions = [tf.add(tf.matmul(output, W), b) for output in outputs]             # List of predictions after each time step
prediction = tf.add(tf.matmul(outputs[-1], W), b)                                   # Prediction after final time step
prediction = tf.tanh(prediction)                                                    # Activation
mse = tf.losses.mean_squared_error(predictions=prediction, labels=y)                # Mean loss over entire batch
accuracy = tf.reduce_mean(1 - (tf.abs(y - prediction) / DataWorker.labelRange))     # Accuracy over entire batch
optimiser = tf.train.AdamOptimizer(Constants.learningRate).minimize(mse)            # Backpropagation

with tf.Session() as session:
    session.run(tf.global_variables_initializer())
    # #############################################
    # TRAINING
    # #############################################
    for epoch in range(Constants.numEpochs):
        print("***** EPOCH:", epoch + 1, "*****\n")
        IDPointer, TSPointer = 0, 0         # Pointers to current ID and timestamp
        epochComplete = False
        batchNum = 0
        while not epochComplete:
            batchNum += 1
            batchX, batchY, IDPointer, TSPointer, epochComplete = DataWorker.generateBatch(IDPointer, TSPointer, isTraining=True)
            dict = {x: batchX, y: batchY}
            session.run(optimiser, dict)
            if batchNum % 1000 == 0 or epochComplete:
                batchLoss = session.run(mse, dict)
                batchAccuracy = session.run(accuracy, dict)
                print("Iteration:", batchNum)
                print(batchLoss)
                print(str("%.2f" % (batchAccuracy * 100) + "%\n"))

    # #############################################
    # TESTING
    # #############################################
    testX, testY, _, _, _ = DataWorker.generateBatch(0, 0, isTraining=False)
    testAccuracy = session.run(accuracy, {x: testX, y: testY})
    print("Testing Accuracy:", str("%.2f" % (testAccuracy * 100) + "%"))

但是现在，为了实用性和可读性，我想将我的模型实现为一个类，但是在初始化我的变量等方面遇到了很多问题。

这是我使用我自己的 LSTM 类实现上述示例的最接近的方法

Model.py

import tensorflow as tf
import Constants
import DataWorker       # Remove this dependency


class LSTM():
    """docstring."""

    def __init__(self,
                 inputDimensionList,
                 outputDimensionList,
                 numLayers=Constants.numLayers,
                 numHidden=Constants.numHidden,
                 learningRate=Constants.learningRate,
                 forgetBias=Constants.forgetBias
                 ):
        """docstring."""
        self.batchInputs = tf.placeholder(tf.float32, [None] + inputDimensionList)
        self.batchLabels = tf.placeholder(tf.float32, [None] + outputDimensionList)
        self.weightedMatrix = tf.Variable(tf.random_normal([numHidden] + outputDimensionList))
        self.biasMatrix = tf.Variable(tf.random_normal(outputDimensionList))
        self.cell = tf.contrib.rnn.BasicLSTMCell(numHidden, forget_bias=forgetBias)
        self.numLayers = numLayers
        self.numHidden = numHidden
        self.learningRate = learningRate
        self.forgetBias = forgetBias
        self.batchDict = {}
        self.batchInputTensors = None
        self.batchOutputs = None    # All needed as instance variables?
        self.batchFinalStates = None
        self.batchPredictions = None
        self.batchLoss = None
        self.batchAccuracy = None
        self.initialised = False
        self.session = tf.Session()
        # Take in activation, loss and optimiser FUNCTIONS as args

    def execute(self, command):
        """docstring."""
        return self.session.run(command, self.batchDict)

    def setBatchDict(self, inputs, labels):
        """docstring."""
        self.batchDict = {self.batchInputs: inputs, self.batchLabels: labels}
        self.batchInputTensors = tf.unstack(self.batchInputs, axis=1)

    def processBatch(self):
        """docstring."""
        self.batchOutputs, self.batchFinalState = tf.nn.static_rnn(self.cell, self.batchInputTensors, dtype=tf.float32)
        pred = tf.tanh(tf.add(tf.matmul(self.batchOutputs[-1], self.weightedMatrix), self.biasMatrix))
        mse = tf.losses.mean_squared_error(predictions=pred, labels=self.batchLabels)
        optimiser = tf.train.AdamOptimizer(self.learningRate).minimize(mse)

        if not self.initialised:
            self.session.run(tf.global_variables_initializer())
            self.initialised = True

        with tf.variable_scope("model") as scope:
            if self.initialised:
                scope.reuse_variables()
            self.execute(optimiser)
            self.batchPredictions = self.execute(pred)
            self.batchLoss = self.execute(tf.losses.mean_squared_error(predictions=self.batchPredictions, labels=self.batchLabels))
            self.batchAccuracy = self.execute(tf.reduce_mean(1 - (tf.abs(self.batchLabels - self.batchPredictions) / DataWorker.labelRange)))
            return self.batchPredictions, self.batchLabels, self.batchLoss, self.batchAccuracy

    def kill(self):
        """docstring."""
        self.session.close()

这个类相当混乱，尤其是processBatch()，因为我只是在改进它之前试图让它工作。

然后我在这里运行我的模型：

Main.py

import DataWorker
import Constants
from Model import LSTM

inputDim = [Constants.sequenceLength, DataWorker.numFeatures]
outputDim = [1]

lstm = LSTM(inputDimensionList=inputDim, outputDimensionList=outputDim)

# #############################################
# TRAINING
# #############################################
for epoch in range(Constants.numEpochs):
    print("***** EPOCH:", epoch + 1, "*****\n")
    IDPointer, TSPointer = 0, 0         # Pointers to current ID and timestamp
    epochComplete = False
    batchNum = 0
    while not epochComplete:
        batchNum += 1
        batchX, batchY, IDPointer, TSPointer, epochComplete = DataWorker.generateBatch(IDPointer, TSPointer, isTraining=True)
        lstm.setBatchDict(batchX, batchY)
        batchPredictions, batchLabels, batchLoss, batchAccuracy = lstm.runBatch()
        if batchNum % 1000 == 0 or epochComplete:
            print("Iteration:", batchNum)
            print("Pred:", batchPredictions[-1], "\tLabel:", batchLabels[-1])
            print("Loss:", batchLoss)
            print("Accuracy:", str("%.2f" % (batchAccuracy * 100) + "%\n"))

# #############################################
# TESTING
# #############################################
testX, testY, _, _, _ = DataWorker.generateBatch(0, 0, isTraining=False)
lstm.setBatchDict(testX, testY)
_, _, _, testAccuracy = lstm.runBatch()
print("Testing Accuracy:", str("%.2f" % (testAccuracy * 100) + "%"))

lstm.kill()

当所有变量都被初始化时，图形的单次传递可以正常执行，但是在第二次迭代中我得到了错误

ValueError: Variable rnn/basic_lstm_cell/kernel/Adam/ already exists, disallowed. Did you mean to set reuse=True in VarScope? Originally defined at:
optimiser = tf.train.AdamOptimizer(self.learningRate).minimize(mse)

我在 Google 上搜索了这个问题并了解到使用 scope.reuse_variables() 应该会阻止它再次尝试初始化 AdamOptimizer，但很明显，这在我实现它的方式上不起作用。我该如何解决这个问题？

附带说明一下，我在 LSTM 类中将 TensorFlow 会话创建为实例变量的方法是否可以接受，或者我应该在 Main 中创建会话，然后将其传递到 LSTM 实例中？

Answer 1

一般来说，在进行面向对象的模型构建时，我会使用 tf.make_template 将任何创建变量的东西包裹起来。

但是，您应该避免在训练循环中向图表添加操作，这看起来就像在这里发生的那样。它们会累积并导致问题，并可能给您错误的结果。相反，定义图（使用来自 tf.data、占位符或队列的输入）并仅循环 session.run 调用。更好的是，将您的代码构造为 Estimator，这将得到强制执行。