Jak zaimplementować wielowymiarowy algorytm liniowego gradientu stochastycznego w tensorflow?

Question

Zacząłem od prostej implementacji pojedynczego, zmiennego gradientu liniowego, ale nie wiem, jak rozszerzyć to na wielowymiarowy algorytm gradientu stochastycznego?

pojedyncze regresja liniowa zmienna

import tensorflow as tf 
import numpy as np 

# create random data 
x_data = np.random.rand(100).astype(np.float32) 
y_data = x_data * 0.5 

# Find values for W that compute y_data = W * x_data 
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0)) 
y = W * x_data 

# Minimize the mean squared errors. 
loss = tf.reduce_mean(tf.square(y - y_data)) 
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. 
for step in xrange(2001): 
    sess.run(train) 
    if step % 200 == 0: 
     print(step, sess.run(W)) 

Answer 1

masz dwie części w swoim pytaniu:

• jak zmienić ten problem na wyższy wymiar przestrzeni.
• Jak zmienić pochylenie gradientowe na stochastyczne pochylenie gradientowe.

Aby uzyskać większe ustawienie wymiarów, można zdefiniować liniowy problem y = <x, w>. Następnie wystarczy zmienić wymiar zmiennej W, aby pasował do w i zastąpić mnożenie W*x_data przez skalarny produkt tf.matmul(x_data, W), a kod powinien działać poprawnie.

Aby zmienić metodę uczenia na stochastyczne pochodzenie gradientowe, należy wykreślić dane wejściowe funkcji kosztu za pomocą tf.placeholder.
Po zdefiniowaniu X i y_, aby zachować dane wejściowe w każdym kroku, można skonstruować tę samą funkcję kosztów. Następnie musisz wywołać swój krok, dostarczając odpowiednią mini-partię danych.

Oto przykład, w jaki sposób można wdrożyć takie zachowanie i powinien on pokazać, że W szybko konwerguje do 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)) 

Dwie boczne Uwagi:

• Realizacja poniżej nazywana jest mini-partia gradientu zejście na każdym etapie, jest obliczana za pomocą gradientu podzbiór naszych danych wielkości mini_batch_size. Jest to wariant ze stochastycznego gradientu, który jest zwykle stosowany do stabilizacji oceny gradientu na każdym etapie. Stochastyczne nachylenie gradientu można uzyskać ustawiając mini_batch_size = 1.

• Zestaw danych można przetasować w każdej epoce, aby uzyskać implementację bliższą rozważaniom teoretycznym. Niektóre najnowsze prace uwzględniają również tylko jedno przejście przez zestaw danych, ponieważ zapobiega to nadmiernemu dopasowaniu. Aby uzyskać bardziej matematyczny i szczegółowy opis, można zobaczyć Bottou12. Można to łatwo zmienić w zależności od konfiguracji problemu i właściwości statystycznej, której szukasz.