[PYTHON] Ich habe versucht, mit TensorFlow den Durchschnitt mehrerer Spalten zu ermitteln

Es gibt ein Missverständnis, dass Tensorflow eine Bibliothek für maschinelles Lernen ist, deshalb habe ich einen Code geschrieben, um den Durchschnitt zu finden, der mein Verständnis vertieft.

Generieren Sie 100 einheitliche Zufallszahlen von 0 bis 100. Der Durchschnitt liegt bei 50.
Einige Änderungen des Lernkoeffizienten

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) #Zu schätzende Variablen
x = tf.placeholder(tf.float32)      #Daten zu geben

loss = tf.reduce_sum(tf.square(x - m)) #Summe der quadratischen Fehler

for lr in [0.009, 0.001, 0.0001]:

    optimizer = tf.train.GradientDescentOptimizer(lr) #Feste Gradientenmethode
    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();

Es ist auf den wahren Durchschnitt konvergiert

Wenn der Lernkoeffizient groß ist, vibriert er.
Abweichung größer als 0,01
Je kleiner der Lernkoeffizient ist, desto langsamer ist die Konvergenz

RMS Prop

mit Optimierer Ich habe gerade den Bereich der Lernrate geändert.

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

Wenn die Lernrate zu groß ist, vibriert sie nach der Konvergenz.
Die Lernrate ist erheblich höher als die des Gradientenabstiegs

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

Die Vibration ist sanft. Erinnern Sie sich an den Schwingungsgraphen des transienten Phänomens.
Überschwingen, wenn die Lernrate hoch ist.

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

Exzellenz. Es ist gut, die Lernrate zu erhöhen. Selbst wenn es groß ist, divergiert es nicht und konvergiert schnell. (Es ist interessant, 100 zu versuchen)

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