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

je suis nouveau à TensorFlow. Je ne comprends pas 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 est utilisé 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 ?

194
demandé sur nbro 2016-04-18 15:16:23

13 réponses

en bref, vous utilisez tf.Variable pour les variables pouvant faire l'objet d'une formation telles que les pondérations (W) et les biais (B) pour 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 sert à alimenter des exemples de formation.

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

c'est ainsi que vous alimentez les exemples de formation pendant 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 à https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html . (Des exemples sont tirés de la page web.)

129
répondu Sung Kim 2017-01-06 13:46:18

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

50
répondu fabrizioM 2016-04-18 20:19:17

puisque les calculs de tenseurs composent de graphiques alors il est préférable d'interpréter les deux en termes de graphiques.

prendre par exemple la régression linéaire simple WX+B=Y(où W et b représentent les poids et le 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 que W et B. X et Y sont des valeurs des échantillons (observations) et ont donc besoin d'un ." place à remplir , alors que W et B sont les poids et le biais, Variables (la valeur précédente affecte la dernière) dans le graphique qui doit être formé en utilisant des paires différentes de X et Y. Nous plaçons différents échantillons dans les cases 151990920 "pour former les Variables .

nous pouvons et devons seulement sauvegarder ou restaurer les Variables pour sauver ou reconstruire le graphique. les paramètres sont la plupart du temps des détenteurs pour les différents ensembles de données (par exemple, Données de formation ou données d'essai) mais Variables sont formés dans le processus de formation et restent les mêmes (pour prédire le résultat de l'entrée ou de la carte des entrées et sorties[étiquettes] des échantillons) plus tard jusqu'à ce que vous retrainez le modèle (en utilisant différents ou les mêmes échantillons pour remplir le paramètres souvent par le biais de la dict, par exemple session.run(a_graph, dict={a_placeholder_name: sample_values}) , "Placeholders sont également passés comme paramètres pour définir les modèles).

si vous changez les paramètres(ajouter ou supprimer ou changer la forme et etc) d'un modèle au milieu de la formation, vous pouvez tout de même recharger le point de contrôle sans aucune autre modification. Mais si les variables d'un modèle enregistré est changé, vous devez ajuster le point de contrôle en conséquence pour le recharger et continuer la formation.

pour résumer, si les valeurs sont samples (observations que vous avez déjà) vous faites en toute sécurité une place pour les tenir, tandis que si vous avez besoin d'un paramètre pour être formé harnacher une Variable (simplement mis, le Variables pour les valeurs que vous voulez obtenir en utilisant TF automatiquement).

pour plus d'information, veuillez inférer de ce simple et illustrant le doc .

42
répondu lerner 2017-11-17 11:36:47

TL; DR

Variables

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

Espaces réservés

  • aliments pour animaux)
  • les valeurs initiales ne sont pas nécessaires (mais peuvent être réglées, voir tf.placeholder_with_default )
26
répondu James 2017-04-26 11:56:48

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


vous utilisez des variables pour maintenir et mettre à jour les paramètres. Les Variables sont tampons mémoire contenant des tenseurs. Ils doivent être explicitement initialisé et peut être sauvegardé sur disque pendant et après la formation. Vous peut plus tard restaurer les valeurs sauvegardées pour exercer ou analyser le modèle.

L'initialisation des variables se fait avec sess.run(tf.global_variables_initializer()) . En outre, lors de la création d'une variable, vous devez passer un tenseur comme valeur initiale au constructeur Variable() et quand vous créez une variable, vous savez toujours sa forme.


d'un autre côté, vous ne pouvez pas mettre à jour le paramètre. Ils ne devraient pas être initialisé, mais parce qu'ils sont une promesse d'avoir un tenseur, vous avez besoin de nourrir la valeur en eux sess.run(<op>, {a: <some_val>}) . Et enfin, par rapport à une variable, placeholder pourrait ne pas connaître la forme. Vous pouvez fournir des parties des dimensions ou rien du tout.


il y a d'autres différences:

ce qui est intéressant, c'est que non seulement les placeholders peuvent être alimentés. Vous pouvez nourrir la valeur d'une Variable, et même à une constante.

26
répondu Salvador Dali 2018-01-03 15:01:53

ajoutant à d'autres réponses, ils l'expliquent aussi très bien dans ce MNIST tutorial sur le site Tensoflow:

nous décrivons ces opérations en interaction en manipulant des symboles variable. Créons-en un:

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

x n'est pas une valeur spécifique. C'est un paramètre, une valeur que nous entrerons quand nous demanderons à TensorFlow exécuter un calcul. Nous voulons être en mesure d'entrer n'importe quel nombre de MNIST des images, chacune aplatie en un vecteur 784-dimensionnel. Nous représentons il s'agit d'un tenseur 2-D de nombres à virgule flottante, avec une forme [aucun, 784]. (Ici Aucun signifie qu'une dimension peut être de n'importe quelle longueur.)

nous avons également besoin des poids et des biais pour notre modèle. Nous pourrions imaginer traiter ces entrées comme des entrées supplémentaires, mais TensorFlow a un pair meilleure façon de le gérer: Variable . Un Variable est un tenseur modifiable qui vit dans le graphique de TensorFlow des opérations en interaction. Il peut être utilisé et même modifié par le calcul. Pour l'apprentissage à la machine applications, on a généralement les paramètres du modèle être Variable s.

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

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

nous créons ces Variable s en donnant tf.Variable la valeur initiale de le Variable : dans ce cas, nous initialisons à la fois W et b comme tenseurs pleins de zéros. Puisque nous allons apprendre W et b , cela n'a pas d'importance beaucoup de ce qu'ils étaient au départ.

13
répondu tagoma 2018-01-03 15:09:55

Variables(tf.varibales(SomeValue)):

Les Variables

sont des noeuds stateful qui produisent leur valeur courante (quelle que soit la valeur que nous lui assignons). Nous devons attribuer des valeurs à une variable dans TensorFlow.

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

Placeholder sont des noeuds dont la valeur est entrée au moment de l'exécution. Par exemple, entrées, étiquettes, etc.

9
répondu Parvez Khan 2018-01-03 15:06:58

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 le nom disent placeholder est une promesse de fournir une valeur plus tard i.e.

la Variable sont simplement les paramètres de formation ( W (matrice), b (biais) les mêmes que les variables normales que vous utilisez dans votre programmation quotidienne, que le formateur met à jour/modifie à chaque exécution/étape.

alors que placeholder ne exiger de toute valeur initiale, que lors de la création de x et y TF n'a pas alloué de la mémoire, au lieu de cela plus tard, quand vous nourrissez les espaces réservés dans les sess.run() à l'aide feed_dict , TensorFlow va allouer de la taille appropriée de la mémoire ( x et y ) - sans contrainte-ness nous permet de nous nourrir de n'importe quelle taille et la forme des données.


en bref :

Variable - est un paramètre que vous voulez formateur (i.e. GradientDescentOptimizer) à mettre à jour après chaque étape.

espace Réservé 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 en la sortie

7.5
[ 3.  7.]

dans le premier cas 3 et 4.5 seront passés à a et b respectivement, puis à adder_node ouputting 7. Dans le second cas, il y a une liste de flux, les première et deuxième étapes seront ajoutées, les 3 et 4 suivantes ( a et b ).


pertinent se lit:

6
répondu Nabeel Ahmed 2017-03-10 12:36:04

espace Réservé :

  1. un paramètre est simplement une variable à laquelle nous assignerons des données à une date ultérieure. Il nous permet de créer nos opérations et construire notre graphique de calcul, sans avoir besoin des données. Dans la terminologie TensorFlow, nous alimentons ensuite les données dans le graphe à travers ces espaces réservés.

  2. les valeurs initiales ne sont pas requises 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. Un TensorFlow variable est le meilleur moyen de représenter partagé, l'état persistant manipulé par votre programme.
  2. Les Variables
  3. sont manipulées via le tf.Variable de classe. A tf.Variable représente un tenseur dont la valeur peut être modifié par l'exécution de la fpo.

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

3
répondu jitesh mohite 2017-09-23 06:30:14

pensez à Variable dans tensorflow comme une variable normale que nous utilisons dans les langages de programmation. On initialise les variables, on peut les modifier plus tard aussi. Alors que placeholder ne nécessite pas de valeur initiale. Placeholder attribue simplement bloc de mémoire pour une utilisation future. Plus tard, nous pouvons utiliser feed_dict pour alimenter les données dans placeholder . Par défaut, placeholder a une forme libre, qui vous permet d'alimenter des tenseurs de différentes formes dans une session. Vous pouvez faire des contraintes forme par le passage d'argument optionnel -forme, 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}))

en faisant la tâche D'apprentissage Machine, la plupart du temps nous ne sommes pas au courant du nombre de lignes mais (supposons) nous savons le nombre de traits ou de colonnes. Dans ce cas, on peut utiliser Aucun.

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

maintenant, au moment de l'exécution nous pouvons alimenter n'importe quelle matrice avec 4 colonnes et n'importe quel nombre de lignes.

aussi, les espaces réservés sont utilisés pour les données d'entrée ( ils sont en quelque sorte variables que nous utilisons pour alimenter notre modèle), où comme Variables sont des paramètres tels que les poids que nous formons au fil du temps.

3
répondu Muhammad Usman 2018-06-02 13:22:29

pensez à un calcul graphe . Dans un tel graphe, nous avons besoin d'un noeud d'entrée pour passer nos données au graphe, ces noeuds devraient être définis comme un Placeholder dans tensorflow .

ne pensez pas comme un programme général en Python. Vous pouvez écrire un programme Python et faire tous ces trucs que les gars expliqués dans d'autres réponses juste par des Variables, mais pour les graphiques de calcul dans tensorflow, pour alimenter vos données au graphique, vous devez définir ces têtes sont des Placeholders.

1
répondu Ali Salehi 2018-06-25 00:29:27

Variables

une variable TensorFlow est la meilleure façon de représenter un état partagé et persistant manipulé par votre programme. Les Variables sont manipulées via le tf.Variable de classe. Intérieurement, un tf.La 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 dans plusieurs tf.Sessions, de sorte que plusieurs travailleurs peuvent voir les mêmes valeurs pour un tf.Variable. Les Variables doivent être initialisées avant d'être utilisées.

exemple:

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

cela crée un graphique 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 placeholder est un noeud (identique à une variable) dont la valeur peut être initialisée dans le futur. Ces noeuds produisent essentiellement la valeur qui leur est attribuée pendant l'exécution. Un noeud placeholder peut être assigné en utilisant le TF.la classe placeholder () à laquelle vous pouvez fournir des arguments tels que le type de la variable et/ou sa forme. Les Placeholders sont largement utilisés pour représenter l'ensemble de données sur la formation dans un modèle d'apprentissage automatique à mesure que l'ensemble de données sur la formation continue d'évoluer.

exemple:

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

Remarque: "None" pour une dimension, '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.]]

, les Références:

  1. https://www.tensorflow.org/guide/variables
  2. https://www.tensorflow.org/api_docs/python/tf/placeholder
  3. O'Reilly: les Mains Sur l'Apprentissage de la Machine avec Scikit-Learn & Tensorflow
1
répondu Ankita Mishra 2018-07-25 13:03:29

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 des données seront modifiées, avec les fonctions respectives telles que cost_function..

  3. espaces réservés: Formation/Analyse de données dans le graphique.

1
répondu Karnakar Reddy 2018-07-28 12:23:39