Dlaczego ta implementacja TensorFlow jest mniej skuteczna niż NN Matlaba?

Question

Jako przykład zabawki próbuję dopasować funkcję f(x) = 1/x ze 100 punktów danych bez szumów. Domyślna implementacja programu Matlab jest fenomenalnie skuteczna ze średnią różnicą kwadratów ~ 10^-10 i idealnie interpoluje.

Implementuję sieć neuronową z jedną ukrytą warstwą 10 sigmoidalnych neuronów. Jestem początkującym w sieciach neuronowych, więc miej się na baczności przed głupim kodem.

import tensorflow as tf 
import numpy as np 

def weight_variable(shape): 
    initial = tf.truncated_normal(shape, stddev=0.1) 
    return tf.Variable(initial) 

def bias_variable(shape): 
    initial = tf.constant(0.1, shape=shape) 
    return tf.Variable(initial) 

#Can't make tensorflow consume ordinary lists unless they're parsed to ndarray 
def toNd(lst): 
    lgt = len(lst) 
    x = np.zeros((1, lgt), dtype='float32') 
    for i in range(0, lgt): 
     x[0,i] = lst[i] 
    return x 

xBasic = np.linspace(0.2, 0.8, 101) 
xTrain = toNd(xBasic) 
yTrain = toNd(map(lambda x: 1/x, xBasic)) 

x = tf.placeholder("float", [1,None]) 
hiddenDim = 10 

b = bias_variable([hiddenDim,1]) 
W = weight_variable([hiddenDim, 1]) 

b2 = bias_variable([1]) 
W2 = weight_variable([1, hiddenDim]) 

hidden = tf.nn.sigmoid(tf.matmul(W, x) + b) 
y = tf.matmul(W2, hidden) + b2 

# Minimize the squared errors. 
loss = tf.reduce_mean(tf.square(y - yTrain)) 
optimizer = tf.train.GradientDescentOptimizer(0.5) 
train = optimizer.minimize(loss) 

# For initializing the variables. 
init = tf.initialize_all_variables() 

# Launch the graph 
sess = tf.Session() 
sess.run(init) 

for step in xrange(0, 4001): 
    train.run({x: xTrain}, sess) 
    if step % 500 == 0: 
     print loss.eval({x: xTrain}, sess) 

Średnia różnica kwadratów kończy się na ~ 2 * 10^-3, czyli około 7 rzędów wielkości gorszych niż matlab. Wizualizacja z

xTest = np.linspace(0.2, 0.8, 1001) 
yTest = y.eval({x:toNd(xTest)}, sess) 
import matplotlib.pyplot as plt 
plt.plot(xTest,yTest.transpose().tolist()) 
plt.plot(xTest,map(lambda x: 1/x, xTest)) 
plt.show() 

widzimy dopasowanie jest systematycznie niedoskonały: natomiast Matlab wygląda idealny gołym okiem z różnicami równomiernie < 10^-5: starałem się replikować z TensorFlow schemat sieci Matlab:

Nawiasem mówiąc, schemat wydaje się sugerować tanh zamiast esicy activa funkcja. Nie mogę znaleźć nigdzie w dokumentacji, aby być pewnym. Jednak gdy próbuję użyć neuronu tanha w TensorFlow, dopasowanie szybko zawiedzie z nan dla zmiennych. Nie wiem dlaczego.

Matlab używa algorytmu szkolenia Levenberga-Marquardta. Bayesowska regularyzacja jest jeszcze bardziej skuteczna ze średnimi kwadratami przy 10^-12 (prawdopodobnie znajdujemy się w obszarze oparów arytmetyki pływaków).

Dlaczego wdrożenie TensorFlow jest znacznie gorsze i co mogę zrobić, aby było lepiej?

Answer 1

Próbowałem szkolenia dla 50000 iteracji, które dostałem do błędu 0.00012. Tesla K40 trwa około 180 sekund.

Wydaje się, że dla tego rodzaju problemu, pierwsze zamówienie gradientu zejście nie jest dobrym rozwiązaniem (gra słów nie przeznaczonych), i trzeba Levenberg-Marquardt lub L-BFGS. Nie sądzę, by ktokolwiek jeszcze je zaimplementował w TensorFlow.

Edytuj Użyj tego tf.train.AdamOptimizer(0.1). Po 4000 iteracjach przechodzi do 3.13729e-05. Ponadto GPU z domyślną strategią również wydaje się złym pomysłem na ten problem. Istnieje wiele małych operacji, a narzut powoduje, że wersja GPU działa 3 razy wolniej niż CPU na moim komputerze.

Answer 2

Przy okazji, oto nieco oczyszczona wersja powyższego, która czyści niektóre problemy z kształtem i niepotrzebnie odbija się między tf i np. Osiąga 3e-08 po 40k kroków, czyli około 1,5-e-5 po 4000:

import tensorflow as tf 
import numpy as np 

def weight_variable(shape): 
    initial = tf.truncated_normal(shape, stddev=0.1) 
    return tf.Variable(initial) 

def bias_variable(shape): 
    initial = tf.constant(0.1, shape=shape) 
    return tf.Variable(initial) 

xTrain = np.linspace(0.2, 0.8, 101).reshape([1, -1]) 
yTrain = (1/xTrain) 

x = tf.placeholder(tf.float32, [1,None]) 
hiddenDim = 10 

b = bias_variable([hiddenDim,1]) 
W = weight_variable([hiddenDim, 1]) 

b2 = bias_variable([1]) 
W2 = weight_variable([1, hiddenDim]) 

hidden = tf.nn.sigmoid(tf.matmul(W, x) + b) 
y = tf.matmul(W2, hidden) + b2 

# Minimize the squared errors.                 
loss = tf.reduce_mean(tf.square(y - yTrain)) 
step = tf.Variable(0, trainable=False) 
rate = tf.train.exponential_decay(0.15, step, 1, 0.9999) 
optimizer = tf.train.AdamOptimizer(rate) 
train = optimizer.minimize(loss, global_step=step) 
init = tf.initialize_all_variables() 

# Launch the graph                    
sess = tf.Session() 
sess.run(init) 

for step in xrange(0, 40001): 
    train.run({x: xTrain}, sess) 
    if step % 500 == 0: 
     print loss.eval({x: xTrain}, sess) 

Wszystko, co powiedział, to prawdopodobnie nie jest zbyt zaskakujące, że LMA robi lepiej niż bardziej ogólnym DNN stylu optymalizator do zamocowania Krzywa 2D. Adam i reszta są nastawieni na problemy z bardzo dużą przestrzennością, i LMA starts to get glacially slow for very large networks (patrz 12-15).