Qual è la differenza tra tf.placeholder e tf.Variable?

Sono un novizio di TensorFlow. Sono confuso sulla differenza tra tf.placeholdere tf.Variable. A mio avviso, tf.placeholderviene utilizzato per i dati di input e tf.Variableviene utilizzato per memorizzare lo stato dei dati. Questo è tutto quello che so.

Qualcuno potrebbe spiegarmi più in dettaglio sulle loro differenze? In particolare, quando usare tf.Variablee quando usare tf.placeholder?

In breve, si utilizzano tf.Variablevariabili allenabili come pesi (W) e distorsioni (B) per il proprio modello.

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 viene utilizzato per alimentare esempi di formazione reali.

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

Ecco come alimentare gli esempi di allenamento durante l'allenamento:

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)

Il tuo tf.variables sarà addestrato (modificato) come risultato di questo addestramento.

Scopri di più su https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html . (Gli esempi sono tratti dalla pagina Web.)

La differenza è che tf.Variabledevi fornire un valore iniziale quando lo dichiari. Con tf.placeholderte non devi fornire un valore iniziale e puoi specificarlo in fase di esecuzione con l' feed_dictargomento all'internoSession.run

Poiché i calcoli Tensor compongono dei grafici , è meglio interpretarli in termini di grafici.

Prendiamo ad esempio la semplice regressione lineare

WX+B=Y

dove We Brappresentano i pesi e la distorsione e Xgli input Ydelle osservazioni e i risultati delle osservazioni.

Ovviamente X e Ysono della stessa natura (variabili manifest) che differiscono da quelle di We B(variabili latenti). Xe Ysono valori dei campioni (osservazioni) e quindi necessitano di un posto da riempire , mentre We Bsono i pesi e la distorsione, le variabili (i valori precedenti influiscono su quest'ultimo) nel grafico che dovrebbero essere allenati usando differenti Xe Ycoppie. Mettiamo diversi campioni ai segnaposto per addestrare le variabili .

Abbiamo solo bisogno di salvare o ripristinare le variabili (ai punti di controllo) per salvare o ricostruire il grafico con il codice.

I segnaposto sono principalmente titolari di diversi set di dati (ad esempio dati di formazione o dati di test). Tuttavia, le variabili sono addestrate nel processo di formazione per le attività specifiche, vale a dire, per prevedere il risultato dell'input o mappare gli input alle etichette desiderate. Rimangono gli stessi fino a quando non si riqualifica o si perfeziona il modello utilizzando campioni diversi o uguali per riempire i segnaposto spesso attraverso il dict. Per esempio:

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

I segnaposto vengono inoltre passati come parametri per impostare i modelli.

Se si cambiano segnaposto (aggiungi, elimina, modifica la forma, ecc.) Di un modello durante l'allenamento, è comunque possibile ricaricare il checkpoint senza altre modifiche. Ma se le variabili di un modello salvato vengono modificate, è necessario regolare il checkpoint di conseguenza per ricaricarlo e continuare l'addestramento (tutte le variabili definite nel grafico dovrebbero essere disponibili nel checkpoint).

Per riassumere, se i valori provengono dai campioni (osservazioni che hai già), fai in modo sicuro un segnaposto per tenerli, mentre se hai bisogno di un parametro da addestrare imbriglia una variabile (in poche parole, imposta le variabili per i valori che desideri per utilizzare automaticamente TF).

In alcuni modelli interessanti, come un modello di trasferimento di stile , i pixel di input verranno ottimizzati e le variabili del modello normalmente definite verranno fissate, quindi dovremmo rendere l'input (di solito inizializzato in modo casuale) come variabile implementata in quel collegamento.

Per ulteriori informazioni si prega di dedurre questo doc semplice e illustrativo .

TL; DR

variabili

• Per i parametri da imparare
• I valori possono essere derivati ​​dall'allenamento
• Sono richiesti valori iniziali (spesso casuali)

segnaposto

• Memoria allocata per i dati (ad esempio per i dati pixel dell'immagine durante un feed)
• I valori iniziali non sono richiesti (ma possono essere impostati, vedi tf.placeholder_with_default)

La differenza più evidente tra il tf.Variable e il tf.placeholder è quella

usi le variabili per conservare e aggiornare i parametri. Le variabili sono buffer in memoria contenenti tensori. Devono essere esplicitamente inizializzati e possono essere salvati su disco durante e dopo l'allenamento. Successivamente è possibile ripristinare i valori salvati per esercitare o analizzare il modello.

L'inizializzazione delle variabili viene eseguita con sess.run(tf.global_variables_initializer()). Inoltre, durante la creazione di una variabile, è necessario passare un Tensore come valore iniziale al Variable()costruttore e quando si crea una variabile si conosce sempre la sua forma.

D'altra parte, non è possibile aggiornare il segnaposto. Inoltre, non devono essere inizializzati, ma poiché promettono di avere un tensore, è necessario inserire il valore in essi sess.run(<op>, {a: <some_val>}). E infine, rispetto a una variabile, il segnaposto potrebbe non conoscere la forma. Puoi fornire parti delle dimensioni o non fornire nulla.

Ci sono altre differenze:

• i valori all'interno della variabile possono essere aggiornati durante le ottimizzazioni
• le variabili possono essere condivise e non possono essere addestrate
• i valori all'interno della variabile possono essere memorizzati dopo l'allenamento
• quando viene creata la variabile, 3 operazioni vengono aggiunte a un grafico (operazione variabile, operazione di inizializzazione, operazioni per il valore iniziale)
• il segnaposto è una funzione, la variabile è una classe (quindi una maiuscola)
• quando si utilizza TF in un ambiente distribuito, le variabili vengono archiviate in un posto speciale ( parametro server ) e condivise tra i lavoratori.

La parte interessante è che non solo i segnaposto possono essere alimentati. È possibile alimentare il valore in una variabile e persino in una costante.

Aggiungendo alle risposte degli altri, lo spiegano anche molto bene in questo tutorial MNIST sul sito Web di Tensoflow:

Descriviamo queste operazioni interagenti manipolando le variabili simboliche. Creiamo uno:

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

xnon è un valore specifico. È un segnaposto, un valore che inseriremo quando chiederemo a TensorFlow di eseguire un calcolo. Vogliamo essere in grado di inserire un numero qualsiasi di immagini MNIST, ciascuna appiattita in un vettore di 784 dimensioni. Rappresentiamo questo come un tensore 2D di numeri in virgola mobile, con una forma [Nessuno, 784]. (Qui Nessuno significa che una dimensione può essere di qualsiasi lunghezza.)

Abbiamo anche bisogno dei pesi e delle inclinazioni per il nostro modello. Potremmo immaginare il trattamento di questi come ulteriori ingressi, ma tensorflow ha un modo migliore per gestire la cosa: Variable. A Variableè un tensore modificabile che vive nel grafico delle operazioni interagenti di TensorFlow. Può essere utilizzato e persino modificato dal calcolo. Per le applicazioni di apprendimento automatico, in genere si hanno i parametri del modello Variables.

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

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

Creiamo questi messaggi Variablefornendo tf.Variableil valore iniziale di Variable: in questo caso, inizializziamo entrambi We bcome tensori pieni di zeri. Dal momento che impareremoW e bnon importa molto cosa siano inizialmente.

Tensorflow utilizza tre tipi di contenitori per archiviare / eseguire il processo

1. Costanti: Costanti contiene i dati tipici.

2. variabili: i valori dei dati verranno modificati, con rispettive funzioni come cost_function ..

3. segnaposto: i dati di addestramento / test verranno passati al grafico.

Snippet di esempio:

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

Come dice il nome, il segnaposto è una promessa di fornire un valore in seguito, ad es

Le variabili sono semplicemente i parametri di allenamento ( W(matrice), b(bias) uguali alle normali variabili utilizzate nella programmazione quotidiana, che il trainer aggiorna / modifica ad ogni corsa / passo.

Mentre il segnaposto non richiede alcun valore iniziale, che quando hai creato xe yTF non ha allocato alcuna memoria, invece in seguito quando dai da mangiare ai segnaposto durante l' sess.run()utilizzo feed_dict, TensorFlow alloca la memoria di dimensioni appropriate per loro ( xe y) - questo non vincolato- ness ci consente di alimentare qualsiasi dimensione e forma dei dati.

In poche parole :

Variabile - è un parametro che si desidera aggiornare con il trainer (ad es. GradientDescentOptimizer) dopo ogni passaggio.

Demo segnaposto -

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

Esecuzione:

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

con conseguente output

7.5
[ 3.  7.]

Nel primo caso 3 e 4.5 verranno passati a ae b, rispettivamente, e poi a adder_node all'uscita 7. Nel secondo caso c'è una lista di feed, verranno aggiunti i primi passi 1 e 2, i successivi 3 e 4 ( ae b).

Letture rilevanti:

• tf.placeholder doc.
• tf.Variabile doc.
• Segnaposto VS variabile .

variabili

Una variabile TensorFlow è il modo migliore per rappresentare lo stato condiviso e persistente manipolato dal programma. Le variabili vengono manipolate tramite la classe tf.Variable. Internamente, una variabile tf memorizza un tensore persistente. Operazioni specifiche consentono di leggere e modificare i valori di questo tensore. Queste modifiche sono visibili su più sessioni tf. In questo modo più lavoratori possono vedere gli stessi valori per una variabile tf. Le variabili devono essere inizializzate prima dell'uso.

Esempio:

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

Questo crea un grafico di calcolo. Le variabili (xey) possono essere inizializzate e la funzione (f) valutata in una sessione tensorflow come segue:

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

segnaposto

Un segnaposto è un nodo (uguale a una variabile) il cui valore può essere inizializzato in futuro. Questi nodi generano sostanzialmente il valore assegnato loro durante il runtime. Un nodo segnaposto può essere assegnato utilizzando la classe tf.placeholder () alla quale è possibile fornire argomenti come il tipo della variabile e / o la sua forma. I segnaposto vengono ampiamente utilizzati per rappresentare il set di dati di training in un modello di apprendimento automatico man mano che il set di dati di training continua a cambiare.

Esempio:

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

Nota: "Nessuno" per una dimensione significa "qualsiasi dimensione".

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

Riferimenti:

1. https://www.tensorflow.org/guide/variables
2. https://www.tensorflow.org/api_docs/python/tf/placeholder
3. O'Reilly: Apprendimento automatico pratico con Scikit-Learn e Tensorflow

Pensa Variablea tensorflow come a normali variabili che usiamo nei linguaggi di programmazione. Inizializziamo le variabili, possiamo modificarle anche in seguito. Considerando placeholderche non richiede il valore iniziale. Il segnaposto alloca semplicemente il blocco di memoria per un utilizzo futuro. Successivamente, possiamo utilizzare feed_dictper alimentare i dati placeholder. Per impostazione predefinita, placeholderha una forma non vincolata, che consente di alimentare tensori di forme diverse in una sessione. Puoi creare una forma vincolata passando l'argomento -shape opzionale, come ho fatto di seguito.

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

Durante l'attività di Machine Learning, il più delle volte non siamo a conoscenza del numero di righe ma (supponiamo) conosciamo il numero di funzionalità o colonne. In tal caso, possiamo usare Nessuno.

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

Ora, in fase di esecuzione, possiamo alimentare qualsiasi matrice con 4 colonne e un numero qualsiasi di righe.

Inoltre, i segnaposto vengono utilizzati per i dati di input (sono tipi di variabili che utilizziamo per alimentare il nostro modello), dove le variabili sono parametri come i pesi che alleniamo nel tempo.

Segnaposto:

1. Un segnaposto è semplicemente una variabile a cui assegneremo i dati in un secondo momento. Ci consente di creare le nostre operazioni e costruire il nostro grafico di calcolo, senza bisogno dei dati. Nella terminologia TensorFlow, inseriamo quindi i dati nel grafico attraverso questi segnaposto.

2. I valori iniziali non sono richiesti ma possono avere valori predefiniti con tf.placeholder_with_default)

3. Dobbiamo fornire valore in fase di esecuzione come:

   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

Variabile:

1. Una variabile TensorFlow è il modo migliore per rappresentare lo stato condiviso e persistente manipolato dal programma.
2. Le variabili vengono manipolate tramite la classe tf.Variable. Una variabile tf. rappresenta un tensore il cui valore può essere modificato eseguendo operazioni su di esso.

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

Risposta compatibile Tensorflow 2.0 : il concetto di segnaposto tf.placeholdernon sarà disponibile Tensorflow 2.x (>= 2.0)per impostazione predefinita, poiché la modalità di esecuzione predefinita è Esecuzione desiderosa.

Tuttavia, possiamo usarli se usati in Graph Mode( Disable Eager Execution).

Il comando equivalente per segnaposto TF nella versione 2.x è tf.compat.v1.placeholder.

Comando equivalente per la variabile TF nella versione 2.x è tf.Variablee se si desidera migrare il codice da 1.xa 2.x, il comando equivalente è

tf.compat.v2.Variable.

Fare riferimento a questa pagina Tensorflow per ulteriori informazioni su Tensorflow versione 2.0.

Per ulteriori informazioni sulla migrazione dalle versioni 1.x alla 2.x, consultare la Guida alla migrazione.

Pensa a un grafico di calcolo . In tale grafico, abbiamo bisogno di un nodo di input per passare i nostri dati al grafico, quei nodi dovrebbero essere definiti come segnaposto in tensorflow .

Non pensare come un programma generale in Python. Puoi scrivere un programma Python e fare tutte quelle cose che i ragazzi hanno spiegato in altre risposte solo da Variabili, ma per i grafici di calcolo in tensorflow, per fornire i tuoi dati al grafico, devi definire quei riferimenti come segnaposto.