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

Question

Je suis novice en 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 est utilisé pour stocker l'état des données. C'est tout ce que je sais.

Est-ce que quelqu'un pourrait m'expliquer plus en détail les différences? En particulier, quand utiliser tf.Variable et quand utiliser tf.placeholder?

Answer 1

En bref, vous utilisez tf.Variable pour des variables entraînables telles que les poids (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 est utilisé pour alimenter des exemples d'entraînement 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 d'entraînement pendant l'entraînement :

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)

Vos tf.variables seront entraînées (modifiées) à la suite de cet entraînement.

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

Answer 2

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 besoin de fournir une valeur initiale et vous pouvez la spécifier au moment de l'exécution avec l'argument feed_dict à l'intérieur de Session.run

Answer 3

Étant donné que les calculs de tenseurs se composent de graphiques, il est donc préférable d'interpréter les deux en termes de graphiques.

Prenons par exemple la régression linéaire simple

WX+B=Y

où W et B représentent les poids et le biais, X les entrées des observations et Y les sorties des observations.

De toute évidence, X et Y sont de même nature (variables manifestes) qui diffèrent de celle de W et B (variables latentes). X et Y sont des valeurs des échantillons (observations) et ont donc besoin d'un endroit à remplir, tandis que W et B sont les poids et le biais, Variables (les valeurs précédentes affectent les dernières) dans le graphique qui doivent être entraînés en utilisant différentes paires de X et Y. Nous plaçons différents échantillons dans les Placeholders pour entraîner les Variables.

Nous devons seulement enregistrer ou restaurer les Variables (aux points de contrôle) pour enregistrer ou reconstruire le graphique avec le code.

Les Placeholders sont principalement des conteneurs pour les différents ensembles de données (par exemple les données d'entraînement ou de test). Cependant, les Variables sont entraînées dans le processus d'entraînement pour les tâches spécifiques, c'est-à-dire pour prédire le résultat de l'entrée ou mapper les entrées aux étiquettes souhaitées. Elles restent les mêmes jusqu'à ce que vous retrainez ou affinez le modèle en utilisant des échantillons différents ou les mêmes pour remplir les Placeholders souvent à travers le dict. Par exemple:

 session.run(a_graph, dict = {a_placeholder_name : sample_values}) 

Les Placeholders sont également passés en paramètres pour définir les modèles.

Si vous modifiez les placeholders (ajoutez, supprimez, changez la forme, etc.) d'un modèle en cours d'entraînement, vous pouvez toujours recharger le point de contrôle sans autres modifications. Mais 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 continuer l'entraînement (toutes les variables définies dans le graphique doivent être disponibles dans le point de contrôle).

En résumé, si les valeurs proviennent des échantillons (observations que vous avez déjà), vous pouvez en toute sécurité créer un placeholder pour les contenir, tandis que si vous avez besoin qu'un paramètre soit entraîné, utilisez une Variable (autrement dit, définissez les Variables pour les valeurs que vous souhaitez obtenir automatiquement à l'aide de TF).

Dans certains modèles intéressants, comme un modèle de transfert de style, les pixels d'entrée vont être optimisés et les variables du modèle habituellement appelées sont fixes, alors nous devrions faire de l'entrée (généralement initialisée de manière aléatoire) une variable comme implémenté dans ce lien.

Pour plus d'informations, veuillez vous référer à ce document simple et illustratif.

Answer 4

Résumé

Variables

• Pour les paramètres à apprendre
• Les valeurs peuvent être dérivées de l'entraînement
• Des valeurs initiales sont nécessaires (souvent aléatoires)

Emplacements réservés

• Stockage alloué pour les données (comme pour les données de pixels d'image pendant une alimentation)
• Les valeurs initiales ne sont pas nécessaires (mais peuvent être définies, voir tf.placeholder_with_default)

Answer 5

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

---

vous utilisez des variables pour stocker et mettre à jour les paramètres. Les variables sont des buffers en mémoire contenant des tenseurs. Ils doivent être explicitement initialisés et peuvent être sauvegardés sur disque pendant et après l'entraînement. Vous pouvez ensuite restaurer les valeurs sauvegardées pour tester ou analyser le modèle.

L'initialisation des variables se fait avec sess.run(tf.global_variables_initializer()). De plus, lors de la création d'une variable, vous devez passer un tenseur comme valeur initiale à la méthode Variable() et lorsque vous créez une variable, vous connaissez toujours sa forme.

---

En revanche, vous ne pouvez pas mettre à jour le placeholder. Ils ne doivent pas non plus être initialisés, mais parce qu'ils sont une promesse d'avoir un tenseur, vous devez leur fournir une valeur avec sess.run(, {a: }). Et enfin, contrairement à une variable, un placeholder pourrait ne pas connaître sa forme. Vous pouvez soit fournir certaines dimensions, soit ne rien fournir du tout.

---

Voici d'autres différences:

• les valeurs à l'intérieur de la variable peuvent être mises à jour pendant les optimisations
• les variables peuvent être partagées, et peuvent être non entraînables
• les valeurs à l'intérieur de la variable peuvent être stockées après l'entraînement
• lorsque la variable est créée, 3 ops sont ajoutées à un graphe (opération de variable, opération d'initialisation, opérations pour la valeur initiale)
• placeholder est une fonction, Variable est une classe (d'où une majuscule)
• lorsque vous utilisez TF dans un environnement distribué, les variables sont stockées dans un endroit spécial (serveur de paramètres) et sont partagées entre les travailleurs.

La partie intéressante est que non seulement les placeholders peuvent être alimentés. Vous pouvez fournir une valeur à une Variable et même à une constante.