Apprenez les données distribuées avec TensorFlow Y = 2X

Il y avait une personne qui a présenté un exemple de Janken dans TensorFlow, et quand j'ai lu le code, j'ai pensé que je pouvais faire n'importe quoi si je pouvais convertir la valeur numérique en bits. Alors je l'ai fait. C'est un modèle pour apprendre et résoudre les données distribuées en y = 2x par la méthode de descente de gradient introduite dans le tutoriel. Si vous pensez à doubler le fonctionnement des bits, ce n'est qu'un changement.

résultat

Une convergence de précision peut être observée en raison d'un surajustement. Dans ce graphique, il s'agit de tf.train.GradientDescentOptimizer (0.001) .minimize (_loss). La valeur convergée est 0,434, ce qui est proche du log e.

■ Résultats d'apprentissage

■ Finalement convergé

code

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

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

for p in range(1, 100):
    point = p
    # Y=2X est représenté par des bits
    _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')])


#Préparer des variables qui représentent des poids et des seuils(La valeur initiale est zéro)
W = tf.Variable(tf.zeros([32, 64]))
b = tf.Variable(tf.zeros([64]))

#Variables pour insérer des vecteurs de caractéristiques pendant l'entraînement
x = tf.placeholder("float", [None, 32])

#Définir la fonction Softmax
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Variable pour saisir la vraie valeur d'étiquette pendant l'entraînement
supervisor_labels_placeholder = tf.placeholder("float", [None, 64])


#Erreur de la valeur cible. Valeur que vous souhaitez optimiser
def get_loss(_output, _supervisor_labels_placeholder):
    cross_entropy = -tf.reduce_sum(_supervisor_labels_placeholder * tf.log(_output))
    return cross_entropy


#Algorithme d'optimisation
def get_training(_loss):
    train_step = tf.train.GradientDescentOptimizer(0.001).minimize(_loss)
    return train_step


#Définir une fonction qui détermine la précision de l'apprentissage
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"))


#Préparez une session
with tf.Session() as sess:
    summary_writer = tf.train.SummaryWriter('data', graph_def=sess.graph_def)

    #Processus d'initialisation variable
    init = tf.initialize_all_variables()
    sess.run(init)
    loss = get_loss(y, supervisor_labels_placeholder)
    training_op = get_training(loss)

    #Paramètres des données de l'enseignant
    feed_dict = {x: _input, supervisor_labels_placeholder: _result}
    t_feed_dict = {x: _t_input, supervisor_labels_placeholder: _t_result}

    #Apprentissage
    for i in range(1000000):
        sess.run(training_op, feed_dict=feed_dict)
        # if i % 100 == 0:
        #     #Sortir l'erreur de la valeur cible
        #     # 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)

        #Sortie du résultat pour chaque apprentissage
        print sess.run(get_accuracy(y, supervisor_labels_placeholder), feed_dict=t_feed_dict)

    #Définir une fonction qui détermine la précision de l'apprentissage
    accuracy = get_accuracy(y, supervisor_labels_placeholder)

    #Sortie de résultat
    print "~~~~~~~~~~result~~~~~~~~~~"
    print sess.run(accuracy, feed_dict=t_feed_dict)

référence

Concept de division de code TensorFlow Tutoriel MNIST TensorFlow pour les débutants en ML