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 スクリーンショット 2015-11-13 22.53.30.png

■ Finalement convergé スクリーンショット 2015-11-13 22.58.58.png

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

Recommended Posts

Apprenez les données distribuées avec TensorFlow Y = 2X
Essayez les données en parallèle avec TensorFlow distribué
Lecture de données avec TensorFlow
Apprenez de nouvelles données avec PaintsChainer
[TensorFlow 2] Apprendre RNN avec perte CTC
Essayez Distributed Tensor Flow
Apprenez la science des données
Zundokokiyoshi avec TensorFlow
Casser des blocs avec Tensorflow
Conv en direction x et déconv en direction y avec chainer
Challenge classification des images par TensorFlow2 + Keras 3 ~ Visualiser les données MNIST ~
Découvrez Wasserstein GAN avec le modèle Keras et l'optimisation TensorFlow
Ce que vous pouvez et ne pouvez pas faire avec Tensorflow 2.x
[Comment!] Apprenez et jouez à Super Mario avec Tensorflow !!
Analyse de données avec python 2
Apprenez Python avec ChemTHEATER
Apprenez Zundokokiyoshi en utilisant LSTM
Pandas apprenant avec la chimioinfomatique
Prévisions de courses de bateaux avec TensorFlow
Apprentissage Scikit-Learn avec la chimioinfomatique
Visualisation des données avec les pandas
Apprenez avec Chemo Informatics Matplotlib
Manipulation des données avec les Pandas!
Mélangez les données avec les pandas
Augmentation des données avec openCV
Apprenez avec Chemo Informatics NumPy
Normariser les données avec Scipy
DCGAN avec TF Learn
Essayez la régression avec TensorFlow
Analyse de données avec Python
CHARGER DES DONNÉES avec PyMysql
Apprenez Pendulum-v0 avec DDPG
Ne pas apprendre avec la séquence TensorFlow ~ Fibonacci de la bibliothèque d'apprentissage automatique
Utilisez «% tensorflow_version 2.x» lorsque vous utilisez TPU avec Tensorflow 2.1.0 dans Colaboratory
Apprenez «l'architecture x86 apprise avec votre propre émulateur» avec Manjaro (Linux)