Résumons les fonctions de base de TensorFlow en créant un réseau neuronal qui apprend les portes XOR.

Je n'ai pas bien compris la fonction TensorFlow, donc [ce livre](https://www.amazon.co.jp/gp/product/4839962510/ref=s9u_simh_gw_i1?ie=UTF8&pd_rd_i=4839962510&pd_rd_r=43PPPAM7DTS0 & pf_rd_r = 4J4CEBWSM45D5K2A5SGW & pf_rd_t = 36701 & pf_rd_p = d4802771-73ad-49b1-a154-90aaec384d3e & pf_rd_i = bureau).

Réalisez la porte xor à l'aide de TensorFlow. Dans le tableau de vérité ci-dessous, la dimension de la couche d'entrée est 2 et la dimension de la couche de sortie est 1.

x1	x2	y
0	0	0
0	1	1
1	0	1
1	1	0

Flux de programme

① Bibliothèque d'importation

import numpy as np
import tensorflow as tf

② Préparation des données XOR

X = np.array([[0,0],[0,1],[1,0],[1,1]])
Y = np.array([[0],[1],[1],[0]])

③ Saisissez et préparez un contenant pour l'étiquette de réponse correcte

x = tf.placeholder(tf.float32, shape=[None,2])
t = tf.placeholder(tf.float32, shape=[None,1])

tf.placeholder() Être comme un conteneur pour stocker des données. Lors de la définition d'un modèle, seules les dimensions sont décidées, et il est possible d'évaluer la formule réelle en entrant des valeurs au moment où les données sont réellement nécessaires, comme l'apprentissage du modèle. «shape = [None, 2]» indique que la dimension du vecteur d'entrée est 2, et «None» est un conteneur qui peut être utilisé même si le nombre de données est variable. Partie «Aucune» ← En bref, au moment de la porte xor, il y a 4 données de «00», «01», «10», «11», mais comme le nombre de données peut ne pas être connu, il devient «Aucun».

④ Définition du modèle (couche d'entrée masquée)

x: Entrée h: Sortie de couche cachée W: Poids b: Biais

h = Wx + b

W = tf.Variable(tf.truncated_normal([2,2]))
b = tf.Variable(tf.zeros([2]))
h = tf.nn.sigmoid(tf.matmul(x,W) + b)

tf.Variable() Requis pour générer des variables. Gérez les données avec le type unique de TensorFlow Le content tf.zeros () correspond au np.zeros () dans Numpy. tf.truncated_normal () est une méthode qui génère des données qui suivent une distribution normale de coupe. Si vous initialisez avec «0», l'erreur peut ne pas être reflétée correctement.

⑤ Définition du modèle (couche de sortie cachée)

h: couche d'entrée vers la sortie (sortie de couche cachée) y: sortie V: poids c: biais

y = Vh + c

V = tf.Variable(tf.truncated_normal([2,1]))
c = tf.Variable(tf.zeros([1]))
y = tf.nn.sigmoid(tf.matmul(h,V) + c)

L'explication est la même que ④

⑥ Fonction d'erreur

cross_entropy = -tf.reduce_sum(t * tf.log(y) + (1-t) * tf.log(1-y))

Comme il s'agit cette fois d'une classification binaire, nous utiliserons la fonction d'entropie croisée

-tf.reduce_sum(t * tf.log(y) + (1-t) * tf.log(1-y)) Le calcul de la fonction d'erreur d'entropie croisée peut être écrit selon la formule. tf.reduce_sum () correspond à np.sum ()

⑦ Méthode de descente de gradient probabiliste

train_step = tf.train.GradientDescentOptimizer(0.1).minimize(cross_entropy)

Application de la méthode de descente de gradient probabiliste L'argument «0,1» de «GradientDescentOptimizer ()» est le taux d'apprentissage

⑧ Confirmation des résultats après apprentissage

correct_prediction = tf.equal(tf.to_float(tf.greater(y, 0.5)), t)

Mise en œuvre pour vérifier si le résultat après l'entraînement est correct Le neurone se déclenche à «y> = 0,5». Comparez-le avec l'étiquette correcte t et renvoyez True ou False

⑨ Préparation de session

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

Dans TensorFlow, les calculs sont toujours effectués dans le flux d'échange de données appelé session. Pour la première fois, l'expression de la variable déclarée dans la définition du modèle est initialisée.

⑩ Apprentissage

for epoch in range(4000):
    sess.run(train_step, feed_dict={
        x:X,
        t:Y
    })

    if epoch % 1000 == 0:
        print('epoch:', epoch)

sess.run (train_step) C'est l'apprentissage par la méthode de descente de gradient Attribution de valeurs à «x», «t», qui sont des «espaces réservés» dans «feed_dict» Donner exactement la valeur à l'espace réservé

⑪ Confirmation du résultat d'apprentissage (comparaison avec l'étiquette de réponse correcte)

classified = correct_prediction.eval(session=sess, feed_dict={
    x:X,
    t:Y
})

eval() Utilisé pour vérifier si les neurones peuvent correctement classer s'ils se déclenchent ou non En bref, nous l'utilisons ici pour vérifier la valeur de correct_prediction

⑫ Confirmation du résultat d'apprentissage (probabilité de sortie)

prob = y.eval(session=sess, feed_dict={
    x:X,
    t:Y
})

Vous pouvez obtenir la probabilité de sortie pour chaque entrée En bref, vous pouvez vérifier la valeur de y

⑫ Affichage

print('classified:')
print(classified)
print()
print('output probability:')
print(prob)

résultat

`production`


epoch: 0
epoch: 1000
epoch: 2000
epoch: 3000
classified:
[[ True]
 [ True]
 [ True]
 [ True]]

output probability:
[[ 0.00661706]
 [ 0.99109781]
 [ 0.99389231]
 [ 0.00563505]]

référence

[Explication détaillée Apprentissage en profondeur ~ Traitement des données de séries temporelles par TensorFlow / Keras](https://www.amazon.co.jp/gp/product/4839962510/ref=s9u_simh_gw_i1?ie=UTF8&pd_rd_i=4839962510&pd_rd_TS40Prd_i1?ie=UTF8&pd_rd_i=4839962510&pd_rd_TS40_Prd_P8p8&pd_rd_TS40_Prd_p8p8&pd_rd_TS40_Prd_p8p8 = & pf_rd_r = 4J4CEBWSM45D5K2A5SGW & pf_rd_t = 36701 & pf_rd_p = d4802771-73ad-49b1-a154-90aaec384d3e & pf_rd_i = bureau)