Какая разница между tf.placeholder и tf.Variable?

Ответ 1

Короче говоря, вы используете tf.Variable для обучаемых переменных, таких как весы (W) и предубеждения (B) для вашей модели.

weights = tf.Variable(
    tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                    stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))), name='weights')

biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')

tf.placeholder используется для подачи фактических примеров обучения.

images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_PIXELS))
labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))

Вот как вы кормите примеры обучения во время обучения:

for step in xrange(FLAGS.max_steps):
    feed_dict = {
       images_placeholder: images_feed,
       labels_placeholder: labels_feed,
     }
    _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)

Ваш tf.variables будет обучен (изменен) в результате этого обучения.

Подробнее см. https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html. (Примеры взяты с веб-страницы.)

Ответ 2

Разница в том, что при tf.Variable вы должны указать начальное значение, когда объявляете его. С tf.placeholder вам не нужно указывать начальное значение, и вы можете указать его во время выполнения с аргументом feed_dict внутри Session.run

Ответ 3

Так как вычисления Tensor состоят из графов, то лучше интерпретировать их в терминах графов.

Возьмем, к примеру, простую линейную регрессию WX + B = Y (где W и B обозначают веса и смещения, а X - входы наблюдений, а Y - выходы наблюдений). Очевидно, X и Y имеют одинаковую природу (явные переменные), которые отличаются от W и B (скрытые переменные). X и Y являются значениями выборок (наблюдений) и, следовательно, нуждаются в месте для заполнения, в то время как W и B являются весами и смещением, переменные (предыдущее значение влияет на последующие) на графике, который должен обучаться, используя разные пары X и Y. Мы помещаем различные образцы в заполнители для обучения переменных.

Нам можно и нужно только сохранить или восстановить переменные (в контрольных точках), чтобы сохранить или перестроить график с помощью кода. Заполнители в основном являются держателями для различных наборов данных (например, данных обучения или тестовых данных), но переменные обучаются в процессе обучения и остаются неизменными (для прогнозирования результатов ввода или сопоставления входов и выходов [меток] выборок) позже, пока вы не переподготовите или не отрегулируете модель (используя разные или одни и те же образцы для частичного заполнения заполнителей через диктовку, например session.run(a_graph, dict={a_placeholder_name: sample_values}), заполнители также передаются в качестве параметров для установки моделей).

Если вы меняете заполнители (добавляете, удаляете или меняете форму и т.д.) Модели в середине обучения, вы все равно можете перезагрузить контрольную точку без каких-либо других модификаций. Но если переменные сохраненной модели изменены, вам следует соответствующим образом настроить контрольную точку, чтобы перезагрузить ее и продолжить обучение (все переменные, определенные на графике, должны быть доступны в контрольной точке).

Подводя итог, если значения взяты из выборок (наблюдения, которые у вас уже есть), вы можете безопасно заполнить их, а если вам нужен параметр для обучения, используйте переменную (проще говоря, установите переменные для значений, которые вы хотите использовать TF автоматически).

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

Для получения дополнительной информации, пожалуйста, ознакомьтесь с этим простым и иллюстрирующим документом.

Ответ 4

TL; DR

Переменные

• Для получения параметров для изучения
• Значения могут быть получены из обучения
• Требуются начальные значения (часто случайные)

заполнителей

• Выделенное хранилище данных (например, для данных пикселя изображения во время подачи)
• Исходные значения не требуются (но могут быть установлены, см. tf.placeholder_with_default)

Ответ 5

Наиболее очевидная разница между tf.Variable и tf.placeholder заключается в том, что

Вы используете переменные для хранения и обновления параметров. Переменные - это буферы в памяти, содержащие тензоры. Они должны быть явно инициализированы и могут быть сохранены на диск во время и после тренировки. Позже вы можете восстановить сохраненные значения для тренировки или анализа модели.

Инициализация переменных выполняется с помощью sess.run(tf.global_variables_initializer()). Также при создании переменной вам нужно передать Tensor в качестве ее начального значения в конструктор Variable() и когда вы создаете переменную, вы всегда знаете ее форму.

С другой стороны, вы не можете обновить заполнитель. Их также не следует инициализировать, но, поскольку они обещают иметь тензор, вам необходимо sess.run(<op>, {a: <some_val>}) значение в них sess.run(<op>, {a: <some_val>}). И, наконец, по сравнению с переменной, заполнитель может не знать форму. Вы можете предоставить части размеров или вообще ничего не указывать.

Есть и другие отличия:

• значения внутри переменной могут быть обновлены во время оптимизации
• переменные могут быть общими, и могут быть необучаемыми
• значения внутри переменной могут быть сохранены после тренировки
• при создании переменной на график добавляются 3 операции (переменная операция, операция инициализации, операция для начального значения)
• заполнитель - это функция, переменная - это класс (отсюда и верхний регистр)
• когда вы используете TF в распределенной среде, переменные хранятся в специальном месте (сервер параметров) и совместно используются рабочими.

Интересно, что кормить можно не только заполнителей. Вы можете передать значение переменной и даже константе.

Ответ 6

Помимо других ответов, они также очень хорошо объясняют это в этом учебнике MNIST на веб-сайте Tensoflow:

Мы описываем эти взаимодействующие операции, манипулируя символическими переменные. Давайте создадим один:

x = tf.placeholder(tf.float32, [None, 784]),

x не является конкретным значением. Это заполнитель, значение, которое мы введем, когда попросим TensorFlow запустить вычисление. Мы хотим иметь возможность вводить любое количество MNIST изображения, каждое из которых сплющено в 784-мерный вектор. Были представлены это как двумерный тензор чисел с плавающей точкой, с формой [Нет, 784]. (Здесь "Нет" означает, что измерение может иметь любую длину.)

Нам также нужны веса и уклоны для нашей модели. Мы могли бы представить рассматривая их как дополнительные входы, но TensorFlow имеет четный лучший способ справиться с этим: Variable. Variable - модифицируемый тензор который живет в графе взаимодействующих операций TensorFlow. Может быть используется и даже модифицируется вычислением. Для машинного обучения В приложениях параметры модели обычно равны Variable с.

W = tf.Variable(tf.zeros([784, 10]))

b = tf.Variable(tf.zeros([10]))

Мы создаем эти Variable, давая tf.Variable начальное значение Variable: в этом случае мы инициализируем как W, так и b как заполненные тензоры нулей. Поскольку мы собираемся изучать W и b, это не имеет большого значения много, что они изначально.

Ответ 7

Variables(tf.varibales(SomeValue)):

Переменные - это узлы с состоянием, которые выводят свое текущее значение (какое бы значение мы ему ни присвоили) Мы должны присвоить значения переменной в TensorFlow.

Placeholders(tf.placeholders(dtype, shape)):

Заполнитель - это узлы, значения которых вводятся во время выполнения. Например, входы, метки и т.д.

Ответ 8

Пример фрагмента:

import numpy as np
import tensorflow as tf

### Model parameters ###
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)

### Model input and output ###
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)

### loss ###
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares

### optimizer ###
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

### training data ###
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]

### training loop ###
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x:x_train, y:y_train})

Как следует из названия, заполнитель является обещанием предоставить значение позже, т.е.

Переменные - это просто параметры обучения (W (матрица), b (смещение), такие же, как обычные переменные, которые вы используете в повседневном программировании, которые тренер обновляет/модифицирует при каждом запуске/шаге.

Хотя местозаполнитель не требует какого-либо начального значения, при создании x и y TF не выделяется память, но позже, когда вы sess.run() заполнители в sess.run() с помощью feed_dict, feed_dict выделит память соответствующего размера для они (x и y) - эта неограниченная возможность позволяет нам передавать данные любого размера и формы.

В двух словах:

Переменная - это параметр, который вы хотите, чтобы тренер (то есть GradientDescentOptimizer) обновлял после каждого шага.

Демо- заполнитель -

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)

Исполнение:

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

в результате на выходе

7.5
[ 3.  7.]

В первом случае 3 и 4.5 будут переданы a и b соответственно, а затем в adder_node outputting 7. Во втором случае будет добавлен список каналов, первые шаги 1 и 2, следующие 3 и 4 (a и b).

Актуальные читает:

• tf.placeholder документ
• tf.Variable doc.
• Переменная VS заполнитель.

Ответ 9

Переменные

Переменная TensorFlow - лучший способ представления общего постоянного состояния, которым манипулирует ваша программа. Переменные обрабатываются с помощью класса tf.Variable. Внутренне переменная tf.Variable хранит постоянный тензор. Конкретные операции позволяют читать и изменять значения этого тензора. Эти изменения видны в нескольких сеансах tf.Session, поэтому несколько рабочих могут видеть одинаковые значения для переменной tf.Variable. Переменные должны быть инициализированы перед использованием.

Пример:

x = tf.Variable(3, name="x")
y = tf.Variable(4, name="y")
f = x*x*y + y + 2

Это создает график вычислений. Переменные (x и y) могут быть инициализированы, а функция (f) оценена в сеансе тензорного потока следующим образом:

with tf.Session() as sess:
     x.initializer.run()
     y.initializer.run()
     result = f.eval()
print(result)
42

заполнителей

Заполнитель - это узел (такой же, как переменная), значение которого может быть инициализировано в будущем. Эти узлы в основном выводят значение, назначенное им во время выполнения. Узел-заполнитель можно назначить с помощью класса tf.placeholder(), которому вы можете предоставить аргументы, такие как тип переменной и/или ее форма. Заполнители широко используются для представления набора данных обучения в модели машинного обучения, так как набор данных обучения постоянно меняется.

Пример:

A = tf.placeholder(tf.float32, shape=(None, 3))
B = A + 5

Примечание. "Нет" для измерения означает "любой размер".

with tf.Session as sess:
    B_val_1 = B.eval(feed_dict={A: [[1, 2, 3]]})
    B_val_2 = B.eval(feed_dict={A: [[4, 5, 6], [7, 8, 9]]})

print(B_val_1)
[[6. 7. 8.]]
print(B_val_2)
[[9. 10. 11.]
 [12. 13. 14.]]

Ссылки:

1. https://www.tensorflow.org/guide/variables
2. https://www.tensorflow.org/api_docs/python/tf/placeholder
3. O'Reilly: практическое машинное обучение с Scikit-Learn & Tensorflow

Ответ 10

Tensorflow использует три типа контейнеров для хранения/выполнения процесса

1. Константы: Константы содержат типичные данные.

2. переменные: значения данных будут изменены с соответствующими функциями, такими как cost_function.

3. заполнители: данные обучения/тестирования будут переданы на график.

Ответ 11

Думайте о Variable в тензорном потоке как о обычных переменных, которые мы используем в языках программирования. Мы инициализируем переменные, мы можем изменить это позже. В то время как placeholder не требует начальной стоимости. Заполнитель просто выделяет блок памяти для будущего использования. Позже мы можем использовать feed_dict для подачи данных в placeholder. По умолчанию placeholder имеет неограниченную форму, что позволяет подавать тензоры разных форм в течение сеанса. Вы можете сделать ограниченную форму, передав необязательный аргумент -shape, как я сделал ниже.

x = tf.placeholder(tf.float32,(3,4))
y =  x + 2

sess = tf.Session()
print(sess.run(y)) # will cause an error

s = np.random.rand(3,4)
print(sess.run(y, feed_dict={x:s}))

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

x = tf.placeholder(tf.float32, shape=(None,4))

Теперь во время выполнения мы можем кормить любую матрицу четырьмя столбцами и любым количеством строк.

Кроме того, заполнители используются для входных данных (они являются своего рода переменными, которые мы используем для подачи в нашу модель), где в качестве переменных используются такие параметры, как веса, которые мы тренируем с течением времени.

Ответ 12

Заполнитель:

• Заполнитель - это просто переменная, которую мы назначим позже. Это позволяет нам создавать наши операции и строить наш график вычислений, не требуя данных. В терминологии TensorFlow мы затем передаем данные в график через эти заполнители.

• Начальные значения не требуются, но могут иметь значения по умолчанию с tf.placeholder_with_default)

• Мы должны предоставить значение во время выполнения, например:

  a = tf.placeholder(tf.int16) // initialize placeholder value
  b = tf.placeholder(tf.int16) // initialize placeholder value
  
  use it using session like :
  
  sess.run(add, feed_dict={a: 2, b: 3}) // this value we have to assign at runtime
  

Переменная:

• Переменная TensorFlow - лучший способ представления общих, постоянное состояние, управляемое вашей программой.
• Переменные обрабатываются через класс tf.Variable. A tf.Variable представляет собой тензор, значение которого можно изменить, выполнив на нем ops.

Пример: tf.Variable("Welcome to tensorflow!!!")

Ответ 13

Подумайте о графике вычислений. В таком графе нам нужен входной узел для передачи наших данных в граф, эти узлы должны быть определены как Placeholder в тензорном потоке.

Не думайте, что это обычная программа на Python. Вы можете написать программу на Python и делать все те вещи, которые ребята объяснили в других ответах только с помощью переменных, но для графов вычислений в тензорном потоке, чтобы подать ваши данные в граф, вам нужно определить эти узлы как заполнители.