Como un juguete ejemplo, estoy tratando de adaptarse a una función f(x) = 1/x de 100 no-ruido de puntos de datos. El matlab implementación predeterminada es un éxito rotundo, con una media de cuadrados de la diferencia de ~10^-10, y se interpola a la perfección.

Puedo implementar una red neuronal con una capa oculta de 10 sigmoide las neuronas. Soy un principiante en redes neuronales para estar en guardia contra tonto código.

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)

Cuadrada de la media aritmética de la diferencia de los extremos a ~2*10^-3, por lo que alrededor de 7 órdenes de magnitud peor que la de matlab. Visualizando con

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

podemos ver que el ajuste es sistemáticamente imperfecto:
¿Por qué es esto TensorFlow implementación considerablemente menos exitosas que las de Matlab NN?
mientras que el matlab uno ve perfecto a simple vista con las diferencias de manera uniforme < 10^-5:
¿Por qué es esto TensorFlow implementación considerablemente menos exitosas que las de Matlab NN?
He tratado de reproducir con TensorFlow el diagrama de Matlab de la red:

¿Por qué es esto TensorFlow implementación considerablemente menos exitosas que las de Matlab NN?

Por cierto, en el diagrama se parece implicar un tanh lugar de la función de activación sigmoide. No puedo encontrar en cualquier lugar en la documentación para estar seguro. Sin embargo, cuando trato de usar un tanh neurona en TensorFlow el ajuste rápidamente falla con nan para las variables. No sé por qué.

Matlab utiliza de Levenberg–Marquardt algoritmo de entrenamiento. Bayesiano de regularización es aún más exitoso, con una media de plazas en 10^-12 (probablemente estamos en la zona de vapor de flotador de la aritmética).

¿Por qué es TensorFlow aplicación mucho peor, y lo que puedo hacer para hacerlo mejor?

  • No he mirado en el tensor de flujo todavía, así que lo siento, pero usted está haciendo algunas cosas bizarras con numpy hay con que toNd función. np.linspace ya de regreso de un ndarray, no una lista, si desea convertir una lista a una ndarray, todo lo que necesitas hacer es np.array(my_list), y si usted simplemente necesita el eje adicional, usted puede hacer new_array = my_array[np.newaxis, :]. Que sólo podría ser llegar a cero error porque se supone que para hacer eso. La mayoría de los datos de ruido y no necesariamente quiere formación cero error en ella. A juzgar por ‘reduce_mean,’ puede ser mediante la validación cruzada.
  • toNd es definitivamente un stop-gap por mi falta de experiencia. Traté de np.array antes y el problema parece ser que np.array([5,7]).shape es (2,) y no (2,1). my_array[np.newaxis, :] parece corregir esto, gracias! Yo no uso python, pero en lugar F# día-a-día.
  • No creo que reduce_mean hace la validación cruzada. A partir de la documentación: Computes the mean of elements across dimensions of a tensor. Matlab realiza la validación cruzada que a mi parecer debería reducir el ajuste en la formación de la muestra en comparación con la ausencia de validación cruzada, ¿es eso cierto?
  • Sí, validación cruzada, normalmente, de evitar un ajuste perfecto. Lo siento por la falta de una respuesta real. Conocimiento del tensor de flujo es todavía muy escasa. He visto un montón de preguntas acerca de ella últimamente y no demasiadas respuestas. Udacity es el desarrollo de un curso en él como parte de su nueva máquina de aprendizaje ingeniero nanodegree. Juro que yo no trabajo para Udacity, pero podría ser vale la pena mirar en!
InformationsquelleAutor Arbil | 2015-11-15

2 Comentarios

  1. 25

    Traté de formación para 50000 iteraciones se puso a 0.00012 de error. Se tarda alrededor de 180 segundos en Tesla K40.

    ¿Por qué es esto TensorFlow implementación considerablemente menos exitosas que las de Matlab NN?

    Parece que para este tipo de problema de primer orden de gradiente de la pendiente no es un buen ajuste (juego de palabras), y que necesita de Levenberg–Marquardt o l-BFGS. No creo que nadie implementado en TensorFlow todavía.

    Editar
    Uso tf.train.AdamOptimizer(0.1) para este problema. Se pone a 3.13729e-05 después de 4000 iteraciones. Además, la GPU con defecto estrategia también parece una mala idea para este problema. Hay muchas pequeñas operaciones y la sobrecarga de las causas de la GPU versión para ejecutar 3 veces más lento que el de la CPU en mi máquina.

    • Gracias por la comprobación de esto. ¿Te refieres a 5000 de mis bucles, así 20M de formación básica se ejecuta? Puede usted confirmar que se produce cuando se cambia la capa oculta a tanh las neuronas, y si es así, ¿sabes por qué sucede?
    • Me acaba de cambiar su xrange(4001) a xrange(5000). Para tanh, parece que el entrenamiento sea incompatible con el aprendizaje de la tasa de 0.5. En general, para la gradiente de la pendiente se necesita optimizar su tasa de aprendizaje para cada problema, parece que funciona si hago tf.de tren.GradientDescentOptimizer(0.1)
    • Veo sobre el gradiente de parámetro. Es muy extraño xrange(0, 5000) le da un orden de magnitud mayor precisión que 4k de gama y toma 180s en una GPU. Puedo ejecutar el mismo rango en la CPU con exactitud sin cambios y se tarda menos de 10 segundos.
    • ups, error tipográfico, 50000, no 5000
    • así que sólo traté de algo diferente, el optimizador = tf.de tren.AdamOptimizer(0.1) parece hacer mucho mejor, 3.13729 e-05 después de 4000 iteraciones
    • Gracias. Pensé que me registré a este pero probablemente lo intentó con un parámetro incorrecto. A continuación en mi pipeline es la lectura acerca de la optimización de los algoritmos.
    • También – cambiando su tipo de datos de float32 a float64, el ajuste de adamoptimizer utilizar un exponencialmente descomposición de la tasa de aprendizaje paso a paso hacia abajo de 0.2 con exp caries 0.9999 obtiene 1.44 e-05 después de 4000 pasos de entrenamiento. paso = tf.Variable(0, entrenable=False) = tasa de tf.de tren.exponential_decay(0.2, de paso, 1, 0.9999) optimizador = tf.de tren.AdamOptimizer(tasa) tren = optimizador.minimizar(pérdida, global_step=paso)
    • Ahora usted puede utilizar scipy de TensorFlow: tensorflow.org/api_docs/python/tf/contrib/opt/…

  2. 16

    por cierto, aquí un poco limpiado versión de la anterior que limpia algunos de los problemas de forma innecesaria y rebotando entre el tf y np. Logra 3e-08 después de 40k pasos, o alrededor de 1,5 e-5 después de 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)

    Todo lo que dijo, probablemente no es demasiado sorprendente que la LMA está haciendo mejor que la más general de la DNN-estilo optimizador para el ajuste de una curva 2D. Adán y el resto son de la orientación de muy alta dimensionalidad de los problemas, y LMA empieza a ser glacial y lento para redes muy grandes (ver 12-15).

Dejar respuesta

Please enter your comment!
Please enter your name here