[PYTHON] J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow

Il y a un malentendu sur le fait que Tensorflow est une bibliothèque d'apprentissage automatique, j'ai donc écrit un code pour trouver la moyenne pour approfondir ma compréhension.

--Générer 100 nombres aléatoires uniformes de 0 à 100. La moyenne est de 50.

• Quelques modifications du coefficient d'apprentissage

Gradient decent

python

import matplotlib.pylab as plt
%matplotlib inline
import numpy as np
import tensorflow as tf

x_train = np.random.randint(0,100, size=100)

n_itr = 100

m = tf.Variable([30.0], tf.float32) #Variables à estimer
x = tf.placeholder(tf.float32)      #Données à donner

loss = tf.reduce_sum(tf.square(x - m)) #Somme des erreurs au carré

for lr in [0.009, 0.001, 0.0001]:

    optimizer = tf.train.GradientDescentOptimizer(lr) #Méthode du gradient solide
    train = optimizer.minimize(loss)

    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)

    est = []
    for i in range(n_itr):
        _, est_m = sess.run([train, m], {x:x_train})
        est.append(est_m)

    est = np.array(est)
    plt.plot(est.reshape(n_itr), label="lr={}".format(lr))

plt.title("batch gradient decent")
plt.legend()
plt.show();

Il a convergé vers la vraie moyenne

--Si le coefficient d'apprentissage est élevé, il vibre. --Divergence lorsque supérieure à 0,01

• Plus le coefficient d'apprentissage est petit, plus la convergence est lente

RMS Prop

avec optimiseur Je viens de changer la fourchette de taux d'apprentissage.

python

for lr in [5, 1, 0.1, 0.01]:

    optimizer = tf.train.RMSPropOptimizer(lr)
    train = optimizer.minimize(loss)

    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)

    est = []
    for i in range(n_itr):
        _, est_m = sess.run([train, m], {x:x_train})
        est.append(est_m)

    est = np.array(est)
    plt.plot(est.reshape(n_itr), label="lr={}".format(lr))

plt.title("batch RMS Prop")
plt.legend()
plt.show();

--Si le taux d'apprentissage est trop élevé, il vibrera après la convergence.

• Le taux d'apprentissage est considérablement plus élevé que celui de la descente de gradient

Adam

python

for lr in [5, 1, 0.1, 0.01]:

    optimizer = tf.train.AdamOptimizer(lr)
    train = optimizer.minimize(loss)

    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)

    est = []
    for i in range(n_itr):
        _, est_m = sess.run([train, m], {x:x_train})
        est.append(est_m)

    est = np.array(est)
    plt.plot(est.reshape(n_itr), label="lr={}".format(lr))

plt.title("batch Adam")
plt.legend()
plt.show();

• La vibration est douce. Rappelez-vous le graphique de vibration du phénomène transitoire.
• Dépassement lorsque le taux d'apprentissage est élevé.

AdaGrad

python

for lr in [20, 10, 5, 1, 0.1, 0.01]:

    optimizer = tf.train.AdagradOptimizer(lr)
    train = optimizer.minimize(loss)

    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)

    est = []
    for i in range(n_itr):
        _, est_m = sess.run([train, m], {x:x_train})
        est.append(est_m)

    est = np.array(est)
    plt.plot(est.reshape(n_itr), label="lr={}".format(lr))

plt.title("batch AdaGrad")
plt.legend()
plt.show();

• l'excellence. Il est bon d'augmenter le taux d'apprentissage. Même s'il est grand, il ne diverge pas et converge rapidement. (C'est intéressant d'essayer 100)

AdaDelta

python

for lr in [20000, 10000, 1000, 100, 10]:

    optimizer = tf.train.AdadeltaOptimizer(lr)
    train = optimizer.minimize(loss)

    init = tf.global_variables_initializer()
    sess = tf.Session()
    sess.run(init)

    est = []
    for i in range(n_itr):
        _, est_m = sess.run([train, m], {x:x_train})
        est.append(est_m)

    est = np.array(est)
    plt.plot(est.reshape(n_itr), label="lr={}".format(lr))

plt.title("batch AdaDelta")
plt.legend()
plt.show();

• Le comportement est presque le même que celui d'AdaGrad.
• Le taux d'apprentissage est assez élevé.