Проблема с инициализацией тензорного потока, когда он инкапсулируется

Question

Я инкапсулирую калькуляцию стоимости авто-кодера, чтобы можно было использовать с алгоритмами роя.Цель состоит в том, чтобы получить сводку стоимости автоэнкодера, отправляющего несколько параметров, поэтому метод создает модель, обучает ее и возвращает ее тензор стоимости

def getAECost(dfnormalized, adamParam, iterations):
    N_VISIBLE = 31
    N_HIDDEN = 20
    DEVICE = '/gpu:0' #Or '/cpu:0'

    ITERATIONS = 1 + iterations

    with tf.device(DEVICE):
        # create node for input data(entiendo none columns and N_VISIBLE rows)
        X = tf.placeholder("float", [None, N_VISIBLE], name='X')

        # create nodes for hidden variables
        W_init_max = 4 * np.sqrt(6. / (N_VISIBLE + N_HIDDEN))
        W_init = tf.random_uniform(shape=[N_VISIBLE, N_HIDDEN])#,
        #                            minval=-W_init_max,
        #                            maxval=W_init_max)
        #Inicialite our weight and bias
        #W [784,500]
        W = tf.Variable(W_init, name='W')
        #Inicializate only bias of hidden layer
        b = tf.Variable(tf.zeros([N_HIDDEN]), name='b')
        #W_prime[500,784]
        W_prime = tf.transpose(W)  # tied weights between encoder and decoder
        b_prime = tf.Variable(tf.zeros([N_VISIBLE]), name='b_prime')

        #model that take our variables parameters 
        #Comportamiento de la red neuronal
        def model(X, W, b, W_prime, b_prime):
            tilde_X = X
            #To decode ?
            Y = tf.nn.sigmoid(tf.matmul(tilde_X, W) + b)  # hidden state
            #to reconstructed the input
            Z = tf.nn.sigmoid(tf.matmul(Y, W_prime) + b_prime)  # reconstructed input 
            return Z

        # build model graph
        pred = model(X, W, b, W_prime, b_prime)

        # create cost function
        #Sum of squared error
        cost = tf.reduce_sum(tf.pow(X - pred, 2))  # minimize squared error
        #Tensor to parameter learning rate
        learning = tf.placeholder("float", name='learning')
        train_op = tf.train.AdamOptimizer(learning).minimize(cost) # construct an optimizer

    with tf.Session() as sess:
        # you need to initialize all variables
        tf.global_variables_initializer()
        RATIO = adamParam

        for i in range(ITERATIONS):
            #Prepare input(minibach) from feed autoencoder 
            input_ = dfnormalized
            # train autoencoder
            sess.run(train_op, feed_dict={X: input_, learning: RATIO})
            #Save last epoch and test
            if(i == ITERATIONS-1):
                #Get output as dataframe after training(Z is a array, we cast to list to append with a dataframe)
                costAE = sess.run(cost, feed_dict={X: input_})
        return costAE

Это сработало несколько дней назад (возможно, у меня был другойсеанс в фоновом режиме), возвращая метод с плавающей точкой, но в настоящее время не работает, получая ошибку инициализации

FailedPreconditionError: Attempting to use uninitialized value W
     [[{{node W/read}}]]

на этапе обучения

sess.run(train_op, feed_dict={X: input_, learning: RATIO})

Любой совет о том, как эта инициализацияпроблема может быть решена, или как я могу инкапсулировать модель тензорного потока и сеанс?

Спасибо

Answer 1

Я попробовал то, что сказал @Addy, и реструктурировал код, чтобы сделать его более разборчивым, и теперь отлично работает

class Model:
    N_VISIBLE = 31
    N_HIDDEN = 20
    DEVICE = '/gpu:0' #Or '/cpu:0'

    with tf.device(DEVICE):
        # create node for input data(entiendo none columns and N_VISIBLE rows)
        X = tf.placeholder("float", [None, N_VISIBLE], name='X')

        # create nodes for hidden variables
        W_init_max = 4 * np.sqrt(6. / (N_VISIBLE + N_HIDDEN))
        W_init = tf.random_uniform(shape=[N_VISIBLE, N_HIDDEN])#,
        #                            minval=-W_init_max,
        #                            maxval=W_init_max)
        #Inicialite our weight and bias
        #W [784,500]
        W = tf.Variable(W_init, name='W')
        #Inicializate only bias of hidden layer
        b = tf.Variable(tf.zeros([N_HIDDEN]), name='b')
        #W_prime[500,784]
        W_prime = tf.transpose(W)  # tied weights between encoder and decoder
        b_prime = tf.Variable(tf.zeros([N_VISIBLE]), name='b_prime')

        #model that take our variables parameters 
        #Comportamiento de la red neuronal
        def model(X, W, b, W_prime, b_prime):
            tilde_X = X
            #To decode ?
            Y = tf.nn.sigmoid(tf.matmul(tilde_X, W) + b)  # hidden state
            #to reconstructed the input
            Z = tf.nn.sigmoid(tf.matmul(Y, W_prime) + b_prime)  # reconstructed input 
            return Z

        # build model graph
        pred = model(X, W, b, W_prime, b_prime)

        # create cost function
        #Sum of squared error
        cost = tf.reduce_sum(tf.pow(X - pred, 2))  # minimize squared error
        #Tensor to parameter learning rate
        learning = tf.placeholder("float", name='learning')
        train_op = tf.train.AdamOptimizer(learning).minimize(cost) # construct an optimizer
        sess = tf.InteractiveSession()
        sess.run(tf.global_variables_initializer())


    def train (self, data, adamParam, iterations):
        input_ = data
        RATIO = adamParam
        for i in range(iterations):
            # train autoencoder
            _= self.sess.run(self.train_op, feed_dict={self.X: input_, self.learning: RATIO})
        #print ("Model trained")


    def getAECost(self, data):
        input_ = data
        return self.sess.run(self.cost, {self.X: data})

    def trainAndGetCost (self, dataTrain, dataCost, adamParam, iterations):
        self.train(dataTrain, adamParam, iterations)
        return self.getAECost(dataCost)

Answer 2

Вы фактически должны запустить инициализатор переменных, tf.global_variables_initializer() возвращает op для выполнения, он не запускает инициализацию для вас.Таким образом, решением вашей проблемы должна быть замена строки

tf.global_variables_initializer()

на

sess.run(tf.global_variables_initializer())