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

Je suis un débutant à TensorFlow. Je suis confus quant à 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 leurs différences? En particulier, quand utiliser tf.Variable et quand utiliser tf.placeholder ?

    En bref, vous utilisez tf.Variable pour les 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 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 cet entraînement.

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

    La différence est que avec tf.Variable vous devez fournir une valeur initiale lorsque vous la 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 Session.run dans Session.run

    Comme les calculs de Tensor sont composés de graphes, il est 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 les entrées des observations et Y les sorties des observations). Evidemment, X et Y sont de même nature et diffèrent de ceux de W et B. X et Y sont des valeurs des échantillons (observations) et nécessitent donc une place à remplir , tandis que W et B sont les poids et les biais, Variables ( la valeur précédente affecte le dernier) dans le graphique qui devrait être formé en utilisant différentes paires X et Y. Nous plaçons des échantillons différents aux acteurs pour former les variables .

    Nous pouvons et devons seulement enregistrer ou restaurer les variables pour enregistrer ou reconstruire le graphique. Les espaces réservés sont principalement des détenteurs pour les différents jeux de données (par exemple, données de formation ou données de test), mais les variables sont formées au processus de formation et restnt les mêmes (pour prédire le résultat de l’entrée ou cartographier les entrées plus tard, jusqu’à ce que vous reformiez le modèle (en utilisant des échantillons différents ou identiques pour remplir les session.run(a_graph, dict={a_placeholder_name: sample_values}) souvent via le dict, par exemple session.run(a_graph, dict={a_placeholder_name: sample_values}) , les session.run(a_graph, dict={a_placeholder_name: sample_values}) sont également transmis en tant que parameters pour définir les modèles) .

    Si vous modifiez les espaces réservés (ajout ou suppression ou modification de la forme, etc.) d’un modèle en cours de formation, vous pouvez toujours recharger le sharepoint contrôle sans aucune autre modification. Mais si les variables d’un modèle enregistré sont modifiées, vous devez ajuster le sharepoint contrôle en conséquence pour le recharger et continuer la formation.

    En résumé, si les valeurs proviennent des échantillons (observations que vous avez déjà), vous faites un espace réservé pour les conserver, alors que si vous avez besoin d’un paramètre pour vous entraîner, utilisez une variable (mettez simplement les variables pour les valeurs souhaitées) pour utiliser TF automatiquement).

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

    TL; DR

    Les variables

    • Pour les parameters à apprendre
    • Les valeurs peuvent être dérivées de l’entraînement
    • Les valeurs initiales sont requirejses (souvent aléatoires)

    Placeholders

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

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


    vous utilisez des variables pour contenir et mettre à jour les parameters. Les variables sont des tampons en mémoire contenant des tenseurs. Ils doivent être explicitement initialisés et peuvent être sauvegardés sur le disque pendant et après la formation. Vous pourrez ensuite restaurer les valeurs enregistrées pour vous exercer ou parsingr 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 Tensor comme valeur initiale au constructeur Variable() et 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 parce qu’ils sont une promesse d’avoir un tenseur, vous devez leur donner la valeur sess.run(, {a: }) . Enfin, par rapport à une variable, l’espace réservé peut ne pas connaître la forme. Vous pouvez fournir des parties des dimensions ou ne rien fournir du tout.


    Il y a d’autres différences:

    • les valeurs dans la variable peuvent être mises à jour lors des optimisations
    • les variables peuvent être partagées et ne peuvent pas être entraînées
    • les valeurs à l’intérieur de la variable peuvent être stockées après l’entraînement
    • Lorsque la variable est créée, 3 opérations sont ajoutées à un graphique (variable op, initialiseur op, ops pour la valeur initiale)
    • placeholder est une fonction, Variable est une classe (donc une majuscule)
    • Lorsque vous utilisez TF dans un environnement dissortingbué, les variables sont stockées dans un emplacement spécial ( serveur de parameters ) et sont partagées entre les utilisateurs.

    Un aspect intéressant est que non seulement les espaces réservés peuvent être nourris. Vous pouvez transmettre la valeur à une variable et même à une constante.

    Ajoutant aux autres réponses, ils l’expliquent également 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 saisir lorsque nous demandons à TensorFlow d’exécuter un calcul. Nous voulons pouvoir saisir un nombre quelconque d’images MNIST, chacune aplatie en un vecteur de 784 dimensions. Nous représentons ceci comme un tenseur 2D de nombres à virgule flottante, avec une forme [Aucun, 784]. (Ici aucun signifie qu’une dimension peut avoir n’importe quelle longueur.)

    Nous avons également besoin des poids et des biais pour notre modèle. Nous pourrions imaginer de les traiter comme des intrants supplémentaires, mais TensorFlow a un moyen encore plus efficace de le gérer: la Variable . Une Variable est un tenseur modifiable qui réside dans le graphique des opérations interactives de TensorFlow. Il peut être utilisé et même modifié par le calcul. Pour les applications d’apprentissage automatique, les parameters du modèle sont généralement Variable .

    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 la Variable : dans ce cas, nous initialisons à la fois W et b tant que tenseurs pleins de zéros. Puisque nous allons apprendre le W et le b , peu importe ce qu’ils sont initialement.

    Variables(tf.varibales(SomeValue)):

    Les variables sont des nœuds avec état qui génèrent leur valeur actuelle (quelle que soit la valeur que nous leur atsortingbuons). Nous devons atsortingbuer des valeurs à une variable dans TensorFlow.

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

    Les espaces réservés sont des nœuds dont la valeur est injectée au moment de l’exécution. Par exemple, entrées, étiquettes, etc.

    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 plus tard, par exemple

    Les variables sont simplement les parameters d’entraînement ( W (masortingce), b (biais) identiques aux variables normales que vous utilisez dans votre programmation quotidienne, que le formateur met à jour / modifie à chaque cycle / étape.

    Alors que l’ espace réservé ne nécessite aucune valeur initiale, que lorsque vous avez créé x et y TF ne lui alloue aucune mémoire, TensorFlow allouera la mémoire de taille appropriée à la place lorsque vous alimenterez les espaces réservés dans sess.run() aide de feed_dict . eux ( x et y ) – cette absence de contrainte nous permet d’alimenter n’importe quelle taille et forme de données.


    En bref :

    Variable – est un paramètre que vous voulez que le formateur (GradientDescentOptimizer) mette à jour après chaque étape.

    Placeholder demo –

     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 respectivement transmis à a et b , puis à adder_node ouputting 7. Dans le second cas, il y aura une liste de stream, les premières étapes 1 et 2 seront ajoutées, puis 3 et 4 ( a et b ).


    Lectures pertinentes:

    • tf.placeholder doc.
    • tf.Variable doc.
    • Variable VS placeholder .

    Placeholder:

    1. Un espace réservé est simplement une variable à laquelle nous atsortingbuerons des données ultérieurement. 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 de TensorFlow, nous transmettons ensuite des données au 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 partagé et persistant 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!!!")

    Pensez à Variable dans tensorflow comme une variable normale que nous utilisons dans les langages de programmation. Nous initialisons les variables, nous pouvons également les modifier ultérieurement. Alors que l’ placeholder ne nécessite pas de valeur initiale. Placeholder atsortingbue simplement un bloc de mémoire pour une utilisation future. Plus tard, nous pouvons utiliser feed_dict pour alimenter les données en placeholder . Par défaut, l’ placeholder a une forme sans contrainte, ce qui vous permet d’alimenter des tenseurs de différentes formes dans une session. Vous pouvez créer une forme contrainte en passant un 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})) 

    Lors de la tâche d’apprentissage automatique, nous ignorons la plupart du temps le nombre de lignes, mais supposons que nous connaissons le nombre d’entités ou de colonnes. Dans ce cas, nous pouvons utiliser None.

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

    Maintenant, à l’exécution, nous pouvons alimenter n’importe quelle masortingce 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 (il s’agit de types de variables que nous utilisons pour alimenter notre modèle), où les variables sont des parameters tels que les poids que nous formons au fil du temps.

    Pensez à un graphique de calcul . Dans un tel graphique, 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 un espace réservé dans 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 par Variables, mais pour les graphes de calcul dans tensorflow, pour alimenter vos données sur le graphique, vous devez définir ces signes comme des espaces réservés.

    Les variables

    Une variable TensorFlow est le meilleur moyen de représenter un état partagé et persistant 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 sessions tf.Source, de sorte que plusieurs utilisateurs peuvent 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 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 

    Placeholders

    Un espace réservé est un noeud (identique à une variable) dont la valeur peut être initialisée dans le futur. Ces nœuds génèrent essentiellement la valeur qui leur est atsortingbué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.]] 

    Les 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 avec Scikit-Learn & Tensorflow

    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 / tests seront transmises au graphique.