Hai due parte nella tua domanda:
- come cambiare questo problema in uno spazio dimensione superiore.
- Come passare dalla discesa del gradiente batch a una discesa con gradiente stocastico.
Per ottenere un'impostazione dimensionale superiore, è possibile definire il problema lineare y = <x, w>
. Quindi, è sufficiente modificare la dimensione della variabile W
per corrispondere a quella di w
e sostituire la moltiplicazione W*x_data
con un prodotto scalare tf.matmul(x_data, W)
e il codice dovrebbe essere eseguito correttamente.
Per modificare il metodo di apprendimento su una discesa con gradiente stocastico, è necessario astrarre l'input della funzione di costo utilizzando tf.placeholder
.
Dopo aver definito X
e y_
per mantenere l'input in ogni passaggio, è possibile creare la stessa funzione di costo. Quindi, devi chiamare il tuo passo inserendo il mini-batch corretto dei tuoi dati.
Ecco un esempio di come è possibile implementare tale comportamento e dovrebbe mostrare che W
converge rapidamente in w
.
import tensorflow as tf
import numpy as np
# Define dimensions
d = 10 # Size of the parameter space
N = 1000 # Number of data sample
# create random data
w = .5*np.ones(d)
x_data = np.random.random((N, d)).astype(np.float32)
y_data = x_data.dot(w).reshape((-1, 1))
# Define placeholders to feed mini_batches
X = tf.placeholder(tf.float32, shape=[None, d], name='X')
y_ = tf.placeholder(tf.float32, shape=[None, 1], name='y')
# Find values for W that compute y_data = <x, W>
W = tf.Variable(tf.random_uniform([d, 1], -1.0, 1.0))
y = tf.matmul(X, W, name='y_pred')
# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y_ - y))
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# Before starting, initialize the variables
init = tf.initialize_all_variables()
# Launch the graph.
sess = tf.Session()
sess.run(init)
# Fit the line.
mini_batch_size = 100
n_batch = N // mini_batch_size + (N % mini_batch_size != 0)
for step in range(2001):
i_batch = (step % n_batch)*mini_batch_size
batch = x_data[i_batch:i_batch+mini_batch_size], y_data[i_batch:i_batch+mini_batch_size]
sess.run(train, feed_dict={X: batch[0], y_: batch[1]})
if step % 200 == 0:
print(step, sess.run(W))
Due note laterali:
L'implementazione di seguito viene chiamato un mini-batch discesa del gradiente come ad ogni passo, il gradiente è calcolato utilizzando un sottoinsieme dei nostri dati di dimensioni mini_batch_size
. Questa è una variante della discesa del gradiente stocastico che viene solitamente utilizzata per stabilizzare la stima del gradiente ad ogni passaggio. La discesa del gradiente stocastico può essere ottenuta impostando mini_batch_size = 1
.
Il set di dati può essere rimescolato in ogni epoca per ottenere un'implementazione più vicina alla considerazione teorica. Alcuni lavori recenti considerano anche l'utilizzo di un solo passaggio attraverso il set di dati in quanto previene il sovra-adattamento. Per una spiegazione più matematica e dettagliata, è possibile vedere Bottou12. Questo può essere facilmente modificato in base all'impostazione del problema e alla proprietà statistica che stai cercando.
fonte
2016-03-16 20:01:25
Non dovevamo mescolare casualmente i dati in ogni fase? –
Secondo l'articolo di wikipedia, per la versione iterativa dobbiamo eseguire in ogni iterazione la formazione in ogni punto, anche se la formazione richiede solo una o più serie di punti di dati per l'aggiornamento –
Non riesco a ottenere quello che hai fatto in linea n_batch = N // 100 + (N% 100! = 0) –