В приведенном ниже коде l2 неожиданно возвращает то же значение, что и l1, но поскольку оптимизатор запрашивается в списке перед l2, я ожидал, что потеря будет новой потерей после обучения. Могу ли я одновременно запросить несколько значений из графика и ожидать согласованного вывода?

import tensorflow as tf
import numpy as np

x = tf.placeholder(tf.float32, shape=[None, 10])
y = tf.placeholder(tf.float32, shape=[None, 2])

weight = tf.Variable(tf.random_uniform((10, 2), dtype=tf.float32))

loss = tf.nn.sigmoid_cross_entropy_with_logits(tf.matmul(x, weight), y)

optimizer = tf.train.AdamOptimizer(0.1).minimize(loss)

with tf.Session() as sess:
    tf.initialize_all_variables().run()

    X = np.random.rand(1, 10)
    Y = np.array([[0, 1]])

    # Evaluate loss before running training step
    l1 = sess.run([loss], feed_dict={x: X, y: Y})[0][0][0]
    print(l1) # 3.32393

    # Running the training step
    _, l2 = sess.run([optimizer, loss], feed_dict={x: X, y: Y})
    print(l2[0][0]) # 3.32393 -- didn't change?

    # Evaluate loss again after training step as sanity check
    l3 = sess.run([loss], feed_dict={x: X, y: Y})[0][0][0]
    print(l3) # 2.71041
6
jstaker7 19 Фев 2016 в 21:12

3 ответа

Лучший ответ

Нет - порядок, в котором вы запрашиваете их в списке, не влияет на порядок оценки. Для операций с побочными эффектами, таких как оптимизатор, если вы хотите гарантировать определенный порядок, вам необходимо принудительно применить его с помощью with_dependencies или аналогичных конструкций потока управления. В общем, игнорируя побочные эффекты, TensorFlow возвращает вам результаты, захватывая узел с графика, как только он вычисляется - и, очевидно, потери вычисляются перед оптимизатором, поскольку оптимизатор требует потеря как один из его входов. (Помните, что «потеря» - это не переменная, это тензор, поэтому шаг оптимизатора на самом деле не влияет на нее.)

sess.run([loss, optimizer], ...)

А также

sess.run([optimizer, loss], ...)

Эквивалентны.

12
dga 19 Фев 2016 в 19:10

Как указывает Дейв , порядок аргументов Session.run() не влияет на порядок оценки, а тензор loss в вашем примере не зависит от операции optimizer. Чтобы добавить зависимость, вы можете использовать {{X3} }, чтобы добавить явную зависимость от оптимизатора, работающего перед получением потери:

with tf.control_dependencies([optimizer]):
    loss_after_optimizer = tf.identity(loss)

_, l2 = sess.run([optimizer, loss_after_optimizer], feed_dict={x: X, y: Y})
3
Community 23 Май 2017 в 11:59

Я протестировал логистическую регрессию, реализованную в tensorflow, с тремя способами session.run:

  1. все вместе

    res1, res2, res3 = sessions.run ([op1, op2, op3])

  2. по отдельности

    res1 = sessions.run (op1)

    res2 = sessions.run (op2)

    res3 = sessions.run (op3)

  3. с зависимостями

    с tf.control_dependencies ([op1]):

    op2_after = tf.identity (op1)

    op3_after = tf.identity (op1)

    res1, res2, res3 = session.run ([op1, op2_after, op3_after])

Установите размер пакета как 10000, результат будет:

1: 0.05+ secs < 2: 0.11+ secs < 3: 0.25+ secs

Основное различие между 1 и 3 - всего одна мини-партия. Возможно, не стоит использовать 3 вместо 1.

Вот тестовый код (это пример LR, написанный кем-то другим ...).

Вот данные

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Fri Jun  2 13:38:14 2017

@author: inse7en
"""

from __future__ import print_function
import numpy as np
import tensorflow as tf
from six.moves import cPickle as pickle
import time

pickle_file = '/Users/inse7en/Downloads/notMNIST.pickle'
with open(pickle_file, 'rb') as f:
  save = pickle.load(f)
  train_dataset = save['train_dataset']
  train_labels = save['train_labels']
  valid_dataset = save['valid_dataset']
  valid_labels = save['valid_labels']
  test_dataset = save['test_dataset']
  test_labels = save['test_labels']
  del save  # hint to help gc free up memory
  print('Training set', train_dataset.shape, train_labels.shape)
  print('Validation set', valid_dataset.shape, valid_labels.shape)
  print('Test set', test_dataset.shape, test_labels.shape)


image_size = 28
num_labels = 10

def reformat(dataset, labels):
  dataset = dataset.reshape((-1, image_size * image_size)).astype(np.float32)
  # Map 2 to [0.0, 1.0, 0.0 ...], 3 to [0.0, 0.0, 1.0 ...]
  labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)
  return dataset, labels
train_dataset, train_labels = reformat(train_dataset, train_labels)
valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)
test_dataset, test_labels = reformat(test_dataset, test_labels)
print('Training set', train_dataset.shape, train_labels.shape)
print('Validation set', valid_dataset.shape, valid_labels.shape)
print('Test set', test_dataset.shape, test_labels.shape)

# This is to expedite the process
train_subset = 10000
# This is a good beta value to start with
beta = 0.01

graph = tf.Graph()
with graph.as_default():
    # Input data.
    # They're all constants.
    tf_train_dataset = tf.constant(train_dataset[:train_subset, :])
    tf_train_labels = tf.constant(train_labels[:train_subset])
    tf_valid_dataset = tf.constant(valid_dataset)
    tf_test_dataset = tf.constant(test_dataset)

    # Variables
    # They are variables we want to update and optimize.
    weights = tf.Variable(tf.truncated_normal([image_size * image_size, num_labels]))
    biases = tf.Variable(tf.zeros([num_labels]))

    # Training computation.
    logits = tf.matmul(tf_train_dataset, weights) + biases
    # Original loss function
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))
    # Loss function using L2 Regularization
    regularizer = tf.nn.l2_loss(weights)
    loss = tf.reduce_mean(loss + beta * regularizer)

    # Optimizer.
    optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

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

    num_steps = 50


    def accuracy(predictions, labels):
        return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))
                / predictions.shape[0])


    with tf.Session(graph=graph) as session:
        # This is a one-time operation which ensures the parameters get initialized as
        # we described in the graph: random weights for the matrix, zeros for the
        # biases.
        tf.initialize_all_variables().run()
        print('Initialized')
        for step in range(num_steps):
            # Run the computations. We tell .run() that we want to run the optimizer,
            # and get the loss value and the training predictions returned as numpy
            # arrays.
            #_, l, predictions = session.run([optimizer, loss, train_prediction])

            start_time = time.time()
            with tf.control_dependencies([optimizer]):
                loss_after_optimizer = tf.identity(loss)
                predictions_after = tf.identity(train_prediction)
                regularizers_after = tf.identity(regularizer)


            _, l, predictions,regularizers = session.run([optimizer, loss_after_optimizer, predictions_after, regularizers_after])

            print("--- with dependencies: %s seconds ---" % (time.time() - start_time))
            #start_time = time.time()
            #opt = session.run(optimizer)
            #l = session.run(loss)
            #predictions = session.run(train_prediction)
            #regularizers = session.run(regularizer)

            #print("--- run separately: %s seconds ---" % (time.time() - start_time))

            #start_time = time.time()
            #_, l, predictions,regularizers = session.run([optimizer, loss, train_prediction, regularizer])

            #print("--- all together: %s seconds ---" % (time.time() - start_time))

            #if (step % 100 == 0):
                #print('Loss at step {}: {}'.format(step, l))
                #print('Training accuracy: {:.1f}'.format(accuracy(predictions,
                                                                  #train_labels[:train_subset, :])))
                # Calling .eval() on valid_prediction is basically like calling run(), but
                # just to get that one numpy array. Note that it recomputes all its graph
                # dependencies.

                # You don't have to do .eval above because we already ran the session for the
                # train_prediction
                #print('Validation accuracy: {:.1f}'.format(accuracy(valid_prediction.eval(),
                                                                    #valid_labels)))
        #print('Test accuracy: {:.1f}'.format(accuracy(test_prediction.eval(), test_labels)))
        #print(regularizer)
4
Chen Chu 4 Июл 2017 в 03:33