Warum ist diese TensorFlow-Implementierung wesentlich weniger erfolgreich als Matlabs NN?

Question

Als ein Spielzeugbeispiel versuche ich eine Funktion f(x) = 1/x von 100 No-Noise-Datenpunkten anzupassen. Die Matlab-Standardimplementierung ist phänomenal erfolgreich mit einer mittleren quadratischen Differenz von ~ 10^-10 und interpoliert perfekt.

Ich implementiere ein neuronales Netzwerk mit einer versteckten Schicht von 10 sigmoiden Neuronen. Ich bin ein Anfänger in neuronalen Netzen, also seien Sie auf der Hut vor dummem Code.

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) 

Die mittlere quadratische Differenz endet bei ~ 2 * 10^-3, also etwa 7 Größenordnungen schlechter als Matlab. Visualisieren mit

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

wir das für richtig halten kann, ist systematisch unvollkommen: gleichmäßig < 10^-5 während die Matlab eine mit dem bloßen Auge mit den Unterschieden perfekt aussieht: Ich habe versucht, mit zu replizieren TensorFlow das Diagramm des Matlab-Netzwerk:

Übrigens scheint das Diagramm, das eine tanh zu implizieren, statt sigmoid activa Funktion. Ich kann es nirgends in der Dokumentation finden, um sicher zu sein. Wenn ich jedoch versuche, in TensorFlow ein tanh-Neuron zu verwenden, scheitert die Anpassung schnell an nan für Variablen. Keine Ahnung warum.

Matlab verwendet den Levenberg-Marquardt-Trainingsalgorithmus. Bayessche Regularisierung ist mit mittleren Quadraten bei 10^-12 noch erfolgreicher (wir sind wahrscheinlich im Bereich der Dämpfe der Float-Arithmetik).

Warum ist die TensorFlow-Implementierung so viel schlimmer, und was kann ich tun, um es besser zu machen?

Answer 1

Ich versuchte Training für 50000 Iterationen es 0,00012 Fehler wurde. Es dauert etwa 180 Sekunden auf Tesla K40.

Es scheint, dass für diese Art von Problem, erste Ordnung Gradientenabfallsaktualisierung ist nicht eine gute Passform (Wortspiel beabsichtigt), und Sie müssen Levenberg-Marquardt oder l-BFGS. Ich glaube nicht, dass irgendjemand sie in TensorFlow implementiert hat.

Bearbeiten Verwenden Sie tf.train.AdamOptimizer(0.1) für dieses Problem. Es kommt nach 4000 Iterationen zu 3.13729e-05. Auch GPU mit Standardstrategie scheint für dieses Problem eine schlechte Idee zu sein. Es gibt viele kleine Operationen und der Overhead bewirkt, dass die GPU-Version 3x langsamer läuft als die CPU auf meinem Rechner.

Answer 2

übrigens, hier ist eine leicht bereinigte Version der oben genannten, die einige der Formprobleme und unnötiges Springen zwischen TF und NP bereinigt. Er erreicht 3e-08 nach 40k Schritten oder etwa 1.5E-5 nach 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) 

Alles, was gesagt, es ist wahrscheinlich nicht allzu überraschend, dass LMA tut besser als ein allgemeinere DNN-style-Optimierer für ein Einpassen 2D-Kurve. Adam und der Rest zielen auf sehr hohe Dimensionalitätsprobleme und LMA starts to get glacially slow for very large networks (siehe 12-15).