Quelle est la différence entre les tf.espace réservé et tf.Variable?

En bref, vous utilisez tf.Variable pour éducables variables telles que le poids (W) et de 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 est utilisé pour nourrir les exemples d'entraînement.

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

C'est une façon de nourrir les exemples de formation lors 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 seront formés (modifié) à la suite de cette formation.

Voir plus à https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html. (Les exemples sont pris à partir de la page web.)

Depuis Tenseur des calculs composer de graphiques puis c'est mieux pour interpréter les deux en termes de graphes.

Prendre l'exemple de la régression linéaire simple WX+B=Y(où W et B pour les poids et les biais et X pour les observations", les entrées et Y pour les observations de la production). Évidemment, X et Y sont de même nature(manifeste des variables), qui diffèrent de celle de W et B(variables latentes). X et Y sont les valeurs des échantillons(observations) et donc besoin d'un lieu d'être rempli, tandis que W et B sont les poids et les biais, Variables(la valeur précédente affecte le plus tard) dans le graphique qui devraient être formés à l'aide de différents X et Y des paires. On place les différents échantillons à l' Espaces réservés pour former le Variables.

Nous peut et ne doit enregistrer ou restaurer la Variables à enregistrer ou à la reconstruction du graphe. Espaces réservés sont pour la plupart titulaires pour les différents ensembles de données (par exemple la formation de données ou des données de test) mais Variables sont formés dans le processus de formation et de rester le même(à prédire le résultat de l'entrée ou de la carte les entrées et les sorties[étiquettes] des échantillons) plus tard, jusqu'à ce que vous recycler le modèle(en utilisant différents ou les mêmes échantillons à remplir dans le Espaces réservés souvent par le biais de la dict, par exemple session.run(a_graph, dict={a_placeholder_name: sample_values}), Espaces réservés sont également passés en paramètres à définir des modèles).

Si vous modifiez des espaces réservés(ajouter ou de supprimer ou de modifier la forme et etc) d'un modèle dans le milieu de la formation, vous pouvez toujours 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(toutes les variables définies dans le graphique devrait être disponible dans le point de contrôle).

Pour résumer, si les valeurs sont à partir des échantillons(observations que vous avez déjà) que vous en faire un espace réservé pour les tenir, alors que si vous avez besoin d'un paramètre d'être formés à tirer parti d'un Variable(il suffit de mettre, ensemble la Variables pour les valeurs que vous souhaitez obtenir de l'aide TF automatiquement).

Pour plus d'informations, veuillez déduire de cette simple et illustrant doc.

La différence la plus évidente entre les tf.Variable et la tf.espace réservé est que

---

vous utiliser des variables pour stocker et mettre à jour les paramètres. Les Variables sont
en mémoire tampon contenant les tenseurs. Ils doivent être explicitement
initialisé et peuvent être enregistrées sur le disque pendant et après la formation. Vous
pouvez les restaurer plus tard valeurs enregistrées à l'exercice ou à l'analyse du modèle.

L'initialisation de ces variables est fait avec sess.run(tf.global_variables_initializer()). Aussi, tout en créant une variable, vous devez passer un Tenseur de sa valeur initiale à la Variable() constructeur et lorsque vous créez une variable que vous savez toujours à sa forme.

---

D'autre part, vous ne pouvez pas mettre à jour l'espace réservé. 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, espace réservé pourriez ne pas savoir la forme. Vous pouvez soit fournir des pièces de dimensions ou de fournir de rien du tout.

---

Il y a d'autres différences:

• les valeurs à l'intérieur de la variable peut être mis à jour lors des optimisations
• les variables peuvent être partagé, et peut être non-recyclable
• les valeurs à l'intérieur de la variable peut être conservée après la formation
• lorsque la variable est créée, 3 ops sont ajoutés à un graphique (variable op, initialiseur de l'op, de la fpo pour la valeur initiale)
• espace réservé est une fonction, une Variable est une classe (d'où une majuscule)
• lorsque vous utilisez le TF dans un environnement distribué, les variables sont stockées dans un endroit spécial (paramètre de serveur) et sont partagés entre les travailleurs.

Qui est intéressant, c'est que non seulement les espaces réservés peuvent être nourris. Vous pouvez nourrir la valeur d'une Variable, et même à une constante.

Exemple:

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

Que de dire au nom de l'espace réservé est une promesse de fournir une valeur plus tard, c'est à dire

Variable sont tout simplement les paramètres de la formation (W(la matrice), b(biais) de même que les variables que vous utilisez dans votre journée à jour de la programmation, à laquelle l'entraîneur des mises à jour/modifier à chaque exécution d'une étape ou d'.

Tout espace réservé ne nécessite pas de valeur initiale, que lorsque vous avez créé 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 de feed_dict, TensorFlow va allouer de la taille appropriée de la mémoire pour eux (x et y) - cette 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 (c'est à dire GradientDescentOptimizer) pour 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 de la sortie

7.5
[ 3.  7.]

Dans le premier cas 3 et 4,5 sera transmis à a et b respectivement, puis à adder_node ouputting 7. Dans le second cas il y a une liste de flux, d'abord les étapes 1 et 2 seront ajoutés, 3 et 4 (a et b).

---

Pertinente se lit comme suit:

• tf.espace réservé doc.
• tf.Variable doc.
• Variable VS à l'espace réservé.

Pense Variable dans tensorflow normal variables que nous utilisons dans les langages de programmation. Nous initialiser des variables, nous pouvons la modifier plus tard. Alors que placeholder ne nécessite pas de valeur initiale. Espace réservé simplement alloue un bloc de mémoire pour une utilisation ultérieure. Plus tard, nous pouvons utiliser feed_dict nourrir les données dans placeholder. Par défaut, placeholder a une contrainte de forme, qui permet de nourrir les tenseurs de formes différentes dans une session. Vous pouvez faire de contrainte de forme en passant 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}))

Tout en faisant l'Apprentissage de la Machine de la tâche, la plupart du temps nous ignorons le nombre de lignes, mais (supposons) nous savons que le nombre de fonctions 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 nourrir une matrice avec 4 colonnes et un nombre quelconque de lignes.

Également, les Espaces réservés sont utilisés pour l'entrée de données ( ils sont en quelque sorte des variables que nous utilisons pour nourrir notre modèle), où les Variables sont des paramètres tels que poids que nous formons au fil du temps.

Espace réservé :

1. Un espace réservé est simplement une variable que nous allons affecter des données à une date ultérieure. Il nous permet de créer nos opérations et de construire notre graphe, sans avoir besoin de les données. Dans TensorFlow de la terminologie, nous avons ensuite alimenter les données dans le graphique par le biais de ces espaces réservés.

2. Valeurs initiales ne sont pas nécessaires, mais peuvent avoir des valeurs par défaut avec tf.placeholder_with_default)

3. Nous avons à offrir de la valeur au moment de 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. Variables sont manipulées par le tf.Variable de classe. Une tf.Variable
   représente un tenseur dont la valeur peut être modifiée en cours d'exécution de la fpo sur elle.

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