[PYTHON] Lernen Sie mit TensorFlow Y = 2X verteilte Daten

In TensorFlow gab es eine Person, die ein Beispiel für Janken vorstellte, und als ich den Code las, dachte ich, ich könnte alles tun, wenn ich den numerischen Wert in Bits umwandeln könnte. Also habe ich es geschafft. Es ist ein Modell zum Lernen und Lösen der bei y = 2x verteilten Daten mit der im Lernprogramm vorgestellten Gradientenabstiegsmethode. Wenn Sie daran denken, die Bit-Arithmetik zu verdoppeln, ist dies nur eine Verschiebung.

Ergebnis

Eine Konvergenz der Genauigkeit konnte aufgrund einer Überanpassung beobachtet werden. In diesem Diagramm ist es "tf.train.GradientDescentOptimizer (0.001) .minimize (_loss)". Der konvergierte Wert beträgt 0,434, was nahe an log e liegt.

■ Lernergebnisse

■ Endlich konvergiert

Code

# -*- coding: utf-8 -*-
import tensorflow as tf

_input = []
_result = []
_t_input = []
_t_result = []

for p in range(1, 100):
    point = p
    # Y=2X wird als Bits dargestellt
    _input.append([int(x) for x in format(point, '032b')])
    _result.append([int(x) for x in format(point * 2, '064b')])

for p in range(1, 100):
    _t_input.append([int(x) for x in format(p, '032b')])
    _t_result.append([int(x) for x in format(p * 2, '064b')])


#Bereiten Sie Variablen vor, die Gewichte und Schwellenwerte darstellen(Der Anfangswert ist Null)
W = tf.Variable(tf.zeros([32, 64]))
b = tf.Variable(tf.zeros([64]))

#Variablen zum Einfügen von Merkmalsvektoren während des Trainings
x = tf.placeholder("float", [None, 32])

#Softmax-Funktion definieren
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Variable zur Eingabe des wahren Etikettenwerts während des Trainings
supervisor_labels_placeholder = tf.placeholder("float", [None, 64])


#Fehler vom Zielwert. Wert, den Sie optimieren möchten
def get_loss(_output, _supervisor_labels_placeholder):
    cross_entropy = -tf.reduce_sum(_supervisor_labels_placeholder * tf.log(_output))
    return cross_entropy


#Optimierungsalgorithmus
def get_training(_loss):
    train_step = tf.train.GradientDescentOptimizer(0.001).minimize(_loss)
    return train_step


#Definieren Sie eine Funktion, die die Genauigkeit des Lernens bestimmt
def get_accuracy(_y, _supervisor_labels_placeholder):
    correct_prediction = tf.equal(tf.argmax(_y, 1), tf.argmax(_supervisor_labels_placeholder, 1))
    return tf.reduce_mean(tf.cast(correct_prediction, "float"))


#Bereiten Sie eine Sitzung vor
with tf.Session() as sess:
    summary_writer = tf.train.SummaryWriter('data', graph_def=sess.graph_def)

    #Variabler Initialisierungsprozess
    init = tf.initialize_all_variables()
    sess.run(init)
    loss = get_loss(y, supervisor_labels_placeholder)
    training_op = get_training(loss)

    #Lehrerdateneinstellungen
    feed_dict = {x: _input, supervisor_labels_placeholder: _result}
    t_feed_dict = {x: _t_input, supervisor_labels_placeholder: _t_result}

    #Lernen
    for i in range(1000000):
        sess.run(training_op, feed_dict=feed_dict)
        # if i % 100 == 0:
        #     #Geben Sie den Fehler aus dem Zielwert aus
        #     # print sess.run(loss, feed_dict=feed_dict)
        #     pass
        # if i % 1000 == 0:
        #     print sess.run(get_accuracy(y, supervisor_labels_placeholder), feed_dict=t_feed_dict)
        #     summary_writer = tf.train.SummaryWriter('data', graph_def=sess.graph_def)

        #Geben Sie das Ergebnis für jedes Lernen aus
        print sess.run(get_accuracy(y, supervisor_labels_placeholder), feed_dict=t_feed_dict)

    #Definieren Sie eine Funktion, die die Genauigkeit des Lernens bestimmt
    accuracy = get_accuracy(y, supervisor_labels_placeholder)

    #Ergebnisausgabe
    print "~~~~~~~~~~result~~~~~~~~~~"
    print sess.run(accuracy, feed_dict=t_feed_dict)

Referenz

TensorFlow-Code-Divisionskonzept TensorFlow Tutorial MNIST für ML-Anfänger