web-dev-qa-db-fra.com

Quelle est la différence entre tf.placeholder et tf.Variable?

Je suis un débutant à TensorFlow. Je suis confus au sujet de la différence entre tf.placeholder et tf.Variable. À mon avis, tf.placeholder est utilisé pour les données d'entrée et tf.Variable pour stocker l'état des données. C'est tout ce que je sais.

Quelqu'un pourrait-il m'expliquer plus en détail sur leurs différences? En particulier, quand utiliser tf.Variable et quand utiliser tf.placeholder?

tensorflow
256
J.Doe

En bref, vous utilisez tf.Variable pour les variables pouvant être entraînées, telles que les poids (W) et les biais (B) de votre modèle.

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 est utilisé pour alimenter des exemples d'apprentissage réels.

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

Voici comment vous alimentez les exemples de formation au cours de la formation:

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)

Votre tf.variables sera formé (modifié) à la suite de cette formation.

Voir plus sur https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html . (Les exemples sont tirés de la page Web.)

161
Sung Kim

La différence est qu'avec tf.Variable vous devez fournir une valeur initiale lorsque vous le déclarez. Avec tf.placeholder vous n'avez pas à fournir de valeur initiale et vous pouvez le spécifier lors de l'exécution avec l'argument feed_dict à l'intérieur de Session.run.

64
fabrizioM

Puisque les calculs de tenseurs composent graphes , il est donc préférable d'interpréter les deux en termes de graphes.

Prenons par exemple la régression linéaire simple WX + B = Y (où W et B représentent les poids et les biais et X pour les entrées des observations et Y pour les sorties des observations). Il est évident que X et Y sont de même nature (variables manifestes) et diffèrent de ceux de W et B (variables latentes). X et Y sont les valeurs des échantillons (observations) et nécessitent donc un emplacement à renseigner , tandis que W et B sont les poids et biais, Variables (la valeur précédente affecte la dernière) dans le graphique qui doit être formé à l'aide de paires X et Y différentes. Nous plaçons différents échantillons sur le Placeholders pour former le Variables .

Nous pouvons et n'avons besoin que de enregistrer ou de restaurer le Variables pour enregistrer ou reconstruire le graphique. Placeholders sont principalement les détenteurs des différents jeux de données (par exemple, des données de formation ou des données de test), mais Variables sont formés au processus de formation et restez le même (pour prédire le résultat de l'entrée ou mapper les entrées et les sorties [étiquettes] des échantillons) jusqu'à ce que vous reformiez le modèle (en utilisant des échantillons différents ou identiques pour remplir Placeholders souvent à travers le dict, par exemple session.run(a_graph, dict={a_placeholder_name: sample_values}), Placeholders sont également passés en tant que paramètres pour définir des modèles).

Si vous modifiez des espaces réservés (ajout, suppression, modification de la forme, etc.) d'un modèle en cours de formation, vous pouvez toujours recharger le point de contrôle sans autre modification. Toutefois, si les variables d'un modèle enregistré sont modifiées, vous devez ajuster le point de contrôle en conséquence pour le recharger et poursuivre la formation (toutes les variables définies dans le graphique doivent être disponibles dans le point de contrôle).

Pour résumer, si les valeurs proviennent des échantillons (observations que vous avez déjà), vous créez en toute sécurité un espace réservé pour les conserver, tandis que si vous avez besoin d'un paramètre à former, utilisez un Variable (En termes simples, définissez Variables pour les valeurs que vous souhaitez obtenir en utilisant TF automatiquement).

Pour plus d'informations, veuillez en déduire ceci doc simple et illustrant .

53
Lerner Zhang

TL; DR

Variables

  • Pour les paramètres à apprendre
  • Les valeurs peuvent être dérivées de la formation
  • Les valeurs initiales sont obligatoires (souvent aléatoires)

Espaces réservés

  • Stockage alloué pour les données (comme pour les données de pixels d'image pendant un flux)
  • Les valeurs initiales ne sont pas obligatoires (mais peuvent être définies, voir tf.placeholder_with_default)
33
James

La différence la plus évidente entre le tf.Variable et le tf.placeholder est que

vous utilisez des variables pour conserver et mettre à jour les paramètres. Les variables sont des mémoires tampons en mémoire contenant des tenseurs. Ils doivent être explicitement initialisés et peuvent être sauvegardés sur disque pendant et après la formation. Vous pouvez restaurer ultérieurement les valeurs enregistrées pour exercer ou analyser le modèle.

L'initialisation des variables se fait avec sess.run(tf.global_variables_initializer()). De même, lors de la création d'une variable, vous devez transmettre un tenseur en tant que valeur initiale au constructeur Variable(). Lorsque vous créez une variable, vous en connaissez toujours la forme.

D'autre part, vous ne pouvez pas mettre à jour l'espace réservé. Ils ne doivent pas non plus être initialisés, mais comme ils sont une promesse d'avoir un tenseur, vous devez leur fournir la valeur sess.run(<op>, {a: <some_val>}). Et enfin, par rapport à une variable, un espace réservé peut ne pas connaître la forme. Vous pouvez fournir des parties des dimensions ou ne rien fournir du tout.

Il existe d'autres différences:

Une partie intéressante est que non seulement les espaces réservés peuvent être nourris. Vous pouvez attribuer la valeur à une variable et même à une constante.

32
Salvador Dali

En ajoutant aux réponses des autres, ils l'expliquent aussi très bien dans ce tutoriel MNIST sur le site web de Tensoflow:

Nous décrivons ces opérations en interaction en manipulant des variables symboliques. Créons-en un:

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

x n'est pas une valeur spécifique. C'est un espace réservé, une valeur que nous allons entrer lorsque nous demanderons à TensorFlow d'exécuter un calcul. Nous voulons pouvoir saisir un nombre illimité d'images MNIST, chacune étant aplatie en un vecteur à 784 dimensions. Nous représentons ceci comme un tenseur 2D de nombres à virgule flottante, de forme [Aucun, 784]. (Ici, aucun ne signifie qu'une dimension peut être de n'importe quelle longueur.)

Nous avons également besoin des poids et des biais pour notre modèle. On pourrait imaginer les traiter comme des entrées supplémentaires, mais TensorFlow a un moyen encore meilleur de le gérer: Variable. Un Variable est un tenseur modifiable qui figure dans le graphique des opérations en interaction de TensorFlow. Il peut être utilisé et même modifié par le calcul. Pour les applications d’apprentissage automatique, les paramètres du modèle sont généralement Variables.

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

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

Nous créons ces Variables en donnant à tf.Variable la valeur initiale de Variable: dans ce cas, nous initialisons à la fois W et b en tant que tenseurs pleins de zéros. Puisque nous allons apprendre W et b, peu importe ce qu’ils sont au départ.

14
tagoma

Exemple d'extrait:

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})

Comme son nom l'indique, un espace réservé est une promesse de fournir une valeur ultérieurement, c'est-à-dire.

Les variables sont simplement les paramètres d'apprentissage (W (matrice), b (biais) identiques aux variables normales que vous utilisez dans votre programmation quotidienne, que le formateur met à jour/modifie à chaque course/étape.

Bien que , un espace réservé ne nécessite aucune valeur initiale, mais lorsque vous avez créé x et y TF n'a pas alloué de mémoire. , au lieu de cela plus tard, lorsque vous alimenterez les espaces réservés dans la sess.run() avec feed_dict, TensorFlow allouera la mémoire de taille appropriée pour eux (x et y) - ce qui est sans contrainte nous pour nourrir n'importe quelle taille et forme de données.

En bref :

La variable - est un paramètre que vous souhaitez que le formateur (par exemple, GradientDescentOptimizer) mette à jour après chaque étape.

Placeholder démo -

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

Exécution:

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

résultant dans la sortie

7.5
[ 3.  7.]

Dans le premier cas, 3 et 4.5 seront passés à a et b, puis à adder_node ouputting 7. Dans le second cas, il existe une liste de flux, les étapes 1 et 2 seront ajoutées, les 3 prochaines et 4 (a et b).

Lectures pertinentes:

8
Nabeel Ahmed

Variables

Une variable TensorFlow est le meilleur moyen de représenter un état persistant partagé manipulé par votre programme. Les variables sont manipulées via la classe tf.Variable. En interne, une variable tf.Variable stocke un tenseur persistant. Des opérations spécifiques vous permettent de lire et de modifier les valeurs de ce tenseur. Ces modifications sont visibles sur plusieurs tf.Sessions, ce qui permet à plusieurs travailleurs de voir les mêmes valeurs pour une variable tf.Variable. Les variables doivent être initialisées avant utilisation.

Exemple:

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

Cela crée un graphe de calcul. Les variables (x et y) peuvent être initialisées et la fonction (f) évaluée dans une session tensorflow comme suit:

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

Espaces réservés

Un espace réservé est un nœud (identique à une variable) dont la valeur peut être initialisée ultérieurement. Ces noeuds génèrent essentiellement la valeur qui leur est assignée pendant l'exécution. Un nœud d'espace réservé peut être affecté à l'aide de la classe tf.placeholder () à laquelle vous pouvez fournir des arguments tels que le type de la variable et/ou sa forme. Les espaces réservés sont largement utilisés pour représenter le jeu de données de formation dans un modèle d'apprentissage automatique, au fur et à mesure de l'évolution du jeu de données de formation.

Exemple:

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

Remarque: "Aucune" pour une dimension signifie "toute taille".

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.]]

Références:

  1. https://www.tensorflow.org/guide/variables
  2. https://www.tensorflow.org/api_docs/python/tf/placeholder
  3. O'Reilly: Apprentissage automatique pratique avec Scikit-Learn et Tensorflow
6
Ankita Mishra

Pensez à Variable dans tensorflow comme une variable normale que nous utilisons dans les langages de programmation. Nous initialisons les variables, nous pouvons aussi le modifier plus tard. Considérant que placeholder ne nécessite pas de valeur initiale. Placeholder alloue simplement un bloc de mémoire pour une utilisation future. Plus tard, nous pouvons utiliser feed_dict pour introduire les données dans placeholder. Par défaut, placeholder a une forme non contrainte, ce qui vous permet de charger des tenseurs de formes différentes dans une session. Vous pouvez créer une forme contrainte en passant l'argument optionnel -shape, comme je l'ai fait ci-dessous.

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}))

Lorsque vous effectuez une tâche d’apprentissage automatique, nous ne connaissons généralement pas le nombre de lignes, mais supposons que nous connaissons le nombre d’entités ou de colonnes. Dans ce cas, nous pouvons utiliser Aucun.

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

Au moment de l'exécution, nous pouvons alimenter n'importe quelle matrice avec 4 colonnes et un nombre quelconque de lignes.

De plus, les espaces réservés sont utilisés pour les données d'entrée (ce sont des types de variables que nous utilisons pour alimenter notre modèle), où les variables sont des paramètres tels que les poids que nous entraînons au fil du temps.

5
Muhammad Usman

Tensorflow utilise trois types de conteneurs pour stocker/exécuter le processus

  1. Constantes: Les constantes contiennent les données typiques.

  2. variables: les valeurs de données seront modifiées, avec les fonctions respectives telles que cost_function.

  3. espaces réservés: les données de formation/test seront transférées dans le graphique.

4
Karnakar Reddy

Placeholder:

  1. Un espace réservé est simplement une variable à laquelle nous allons affecter des données à une date ultérieure. Cela nous permet de créer nos opérations et de construire notre graphe de calcul sans avoir besoin des données. Dans la terminologie TensorFlow, nous insérons ensuite des données dans le graphique via ces espaces réservés.

  2. Les valeurs initiales ne sont pas obligatoires mais peuvent avoir des valeurs par défaut avec tf.placeholder_with_default)

  3. Nous devons fournir une valeur à l'exécution comme:

    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

Variable:

  1. Une variable TensorFlow est le meilleur moyen de représenter un état persistant partagé manipulé par votre programme.
  2. Les variables sont manipulées via la classe tf.Variable. Une variable tf.Variable représente un tenseur dont la valeur peut être modifiée en exécutant des opérations dessus.

Exemple: tf.Variable("Welcome to tensorflow!!!")

3
jitsm555

Pensez à un graphe de calcul. Dans un tel graphe, nous avons besoin d’un nœud d’entrée pour transmettre nos données au graphe. Ces nœuds doivent être définis comme Placeholder in tensorflow.

Ne pensez pas comme un programme général en Python. Vous pouvez écrire un programme Python et faire tout ce que les gars ont expliqué dans d'autres réponses simplement par Variables, mais pour les graphiques de calcul dans tensorflow, pour alimenter vos données dans le graphique, vous devez définir ces nœuds en tant qu'espaces réservés. .

1
Ali Salehi