Je ne suis ni programmeur ni data scientist, mais j'ai touché Tensorflow pendant un mois, donc c'est super facile à comprendre.

Le simple fait d'écrire cela m'a écrasé pendant deux jours samedi et dimanche. Cela correspond à ce que vous avez appris, donc en le lisant, vous commencerez à parler de code. Je veux toucher / essayer Tensorflow, mais je ne comprends toujours pas diverses choses! Je l'ai écrit pour ceux qui l'ont dit.

** * Ajouté le 4 octobre 2018 ** Puisqu'il s'agit d'un article très ancien, il y a de fortes chances que le lien soit rompu ou que le document officiel ait été modifié. Je pense que Tensorflow dans cet article concernait ver0.4 ~ 0.7, il semble donc que ce sera ver2.0 ~ Maintenant, vous ne savez peut-être pas à quoi la plupart des phrases font référence.

1: Que fait le Deep Learning en premier lieu?

Il semble que les experts le soulignent, mais le fait est que c'est une boîte noire qui effectue une analyse de régression. Seul le mot «retour» fera apparaître «?». Demandez à la machine de calculer la «valeur» que vous voulez trouver et la valeur qui s'en rapproche le plus possible. Alors, n'est-ce pas? par exemple, je veux connaître une fonction appropriée Non-Linear-Regression.gif Par exemple, je souhaite connaître le cluster approprié K-Means-Clustering-Gif.gif Par exemple, je souhaite connaître un "visage" approprié à partir d'un ensemble de pixels Screen Shot 2016-03-06 at 4.44.13 PM.png Ensuite, il y a beaucoup de choses que j'aimerais savoir! Je pense qu'il y a beaucoup de gens qui disent cela. Je ne veux capturer que lorsque la vidéo de l'idole a un visage vraiment fou (valeur)! Ou, Qiita: --Essayez de déterminer s'il s'agit de gros seins à partir de la photo du visage par apprentissage en profondeur (cela fonctionne ou subtile). Il semble qu'il y ait toujours de grands ancêtres. Alors commençons avec le Deep Learning! est devenu.

2: Choisissez un framework - les bonnes choses à propos de Tensorflow

Tout d'abord, la quantité d'informations ** Au début, je ne savais pas ce qu'était Tensorflow et ce que faisaient les fonctions, j'ai donc pensé à passer à Theano plusieurs fois, mais pour l'instant, la plupart des questions sont déjà dans Stackoverflow (en anglais) ou Github. Il y a plusieurs choses écrites dans le numéro, donc après tout, la puissance du nom de Google est incroyable. Le code du corps principal de Tensorflow peut également être trouvé en recherchant sur google avec le nom de la fonction, afin que vous puissiez approfondir votre compréhension du corps principal lorsque vous l'utilisez. Avant de commencer à toucher ** Que pouvez-vous faire et que ne pouvez-vous pas faire? Je ne le savais pas encore **, j'ai donc lu les blogs de personnes qui font diverses expériences avec le framework Deep Learning. S'agit-il de Tensorflow> Theano> Chainer pour la clarté du document? Autre:

Liste des blogs que j'ai lus

-Tensorflow journal d'activité kivantium: - Identifiez la société de production de l'anime Yuruyuri avec TensorFlow Sugyan Memo: - Identifiez le visage d'une idole en apprenant en profondeur avec TensorFlow -Theano Une percée sur l'intelligence artificielle: - Mise en œuvre du réseau de neurones convolutifs par Theano (1) StatsFragments: --Apprentissage profond avec Theano <3>: Réseau neuronal convolutif -Chainer Sekairabo: -J'ai fait un bot qui peut répondre naturellement avec LSTM Oriental Robotics: --Apprendre avec RNN pour produire du texte littéraire (alias DeepDazai) Recherche préférée: - Contrôle robotique avec apprentissage par renforcement profond distribué

3: Hello, World! MNIST édition débutant

t = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] est le rang2 Le point est le nombre de dimensions de Tensor lui-même.

Rank Unités mathématiques Python example
0 Scalaire (quantité réelle uniquement) s = 483
1 Vecteur (quantité et direction) v = [1.1, 2.2, 3.3]
2 Matrice (table commune) m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
3 3-Tensor (tridimensionnel) t = [[[2], [4], [6]], [[8], [10], [12]], [[14], [16], [18]]]
n n-Tensor (n-dimensionnel) ....

Shape Le précédent t = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] La forme est 3D x 3D, donc [3, 3]

Rank Shape Dimension number Example
0 [] 0-D A 0-D tensor. A scalar.
1 [D0] 1-D A 1-D tensor with shape [5].
2 [D0, D1] 2-D A 2-D tensor with shape [3, 4].
3 [D0, D1, D2] 3-D A 3-D tensor with shape [1, 4, 3].
n [D0, D1, ... Dn-1] n-D A tensor with shape [D0, D1, ... Dn-1].

Type C'est un int ou un float, donc je n'ai pas besoin de beaucoup d'explications.

Voir ces tenseurs dans MNIST

Dans l'exemple de MNIST, 55 000 données d'image (images) Tensor et réponse d'image (étiquettes) Tensor sont affichées. Images Tensor est Shape [55000, 784], Rank2, dtype = tf.float32 Labels Tensor est Shape [55000, 10], Rank2, dtype = tf.float32 Dans le tutoriel, il est d'abord inséré avec tf.placeholder. (Cela peut être plus facile à comprendre si vous dites Tensor sécurisé)

input_Tenseurs


x = tf.placeholder(tf.float32, [None, 784]) #images
y_ = tf.placeholder(tf.float32, [None, 10]) #labels
#La partie Aucun contient le nombre de lots

Notez que tf.placeholder () doit recevoir des données avec l'argument feed_dict pour chaque exécution d'entraînement. Dans le cas du didacticiel, l'exécution de l'apprentissage commence vers la fin:

Dernier code de démarrage de l'exécution d'apprentissage


for i in range(1000):
 batch_xs, batch_ys = mnist.train.next_batch(100)
 sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

Donc, en réalité, les Tensors traitent toutes les 100 images de x: Shape [100, 784] y_: Shape [100, 10].

** À part: À propos du nombre de dimensions de l'image **

Les données d'image sont à l'origine 28x28 pixels en échelle de gris = 1 canal, mais dans le didacticiel pour débutants, elles sont converties à plat en un vecteur de 784 dimensions pour un examen facile (ou plutôt, cela a déjà été fait) 28281 = 784-Dimension ** - Vous pouvez le voir sur la figure - ** C'est comme mettre tous les nombres alignés verticalement et horizontalement horizontalement. mnist.jpg 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000.6.7.7.50000000000.81111111.9.30000000.4.4.4.7111000000000000.1.10000000000000000000000000000000000000000000000000000000000 mnist1.jpg Il semble être "1" pour ceux qui peuvent le voir. Par ailleurs, dans le cas de «[55000, 28, 28, 1]» qui n'aplatit pas l'image, Rank4 Même dans le cas d'une image couleur, elle ne passe qu'à 3 canaux, donc [55000, 28, 28, 3] Rank4

4: Traitement Tensorflow: - Ce que vous faites dans le didacticiel pour débutants

Maintenant, une fois que Tensor l'a compris, le processus d'apprentissage automatique de Tensorflow peut être suivi. J'ai préparé Image Tensorx: [batch_num, 784] , mais comment dériver la bonne réponse à partir des 10 bonnes réponses du vecteur de 784 dimensions? Ici, nous comprenons l'existence de ** opérations matricielles et de "pondérations", de "biais" et de régression Softmax **.

Fonctionnement de la matrice

Les opérations matricielles sont une question simple. Si vous effectuez une opération matricielle de [784, 10] sur x: [batch_num, 784], une matrice de [batch_num, 10] sera créée, il y a donc 10 réponses possibles. Si vous vous référez à l'image sur wikipedia; ʻA: [4,2] et B: [2,3] sont maintenant [4,3] `. Matrix_multiplication_diagram_2.png Dans Tensorflow

Matrice d'opération matmul


tf.matmul(A,B) # A is [4,2] and B is [2,3]. output would be [4,3]

'''
x: [batch_num, 784]
W: [784, 10]
matmul: [batch_num, 10]
'''
matmul = tf.matmul(x,W)

Dans ce B[2,3], MNIST,` W: [784, 10] ʻest un poids ** important **.

poids

Les poids W: [784, 10] sont maintenant disponibles. La partie du code est

Poids W


W = tf.Variable(tf.zeros([784, 10]))

tf.Variable () est tampons en mémoire </ i> C'est une variable contenant Tensor qui conserve les paramètres que vous souhaitez utiliser pour l'apprentissage. tf.zeros () crée un Tensor avec tout son contenu rempli de 0. Remplir avec «0» n'est qu'un début de «0» car il est mis à jour de temps en temps pendant le processus d'apprentissage. Il y a aussi un tf.random_normal () qui met un nombre aléatoire.

Le rôle des poids

Le contenu de W: [784, 10] sont les valeurs numériques de l'image en unités de 1 pixel, la possibilité de 0 est 0.XXX, la possibilité de 1 est -0.0.XXX, la possibilité de 2 est de 0.0XX ... J'arrive à multiplier les nombres comme ça. Par exemple, dans le cas de l'image précédente "1", pour le tout premier pixel supérieur gauche, le poids réellement entraîné W [0] est [0.0.0.0.0.0.0.0. 0. 0. 0. 0.] ʻSouvent. La raison est claire: tous les nombres de 0 à 9 n'ont pas de sens dans le pixel supérieur gauche. En regardant le poids W [380]autour du milieu:[-0.23017341 0.03032022 0.02670325 -0.06415708 0.07344861 -0.05119878 0.03592584 -0.00460929 0.09520938 0.08853132]` Il est devenu. Le fait que le poids de 0 "-0,23017341" soit négatif signifie que ** il est peu probable qu'il soit "0" lorsque le pixel du milieu est noir. Je comprends que **. mnist.jpg Je pense qu'il s'agit davantage de la couche convolutive du tutoriel expert, mais ** personnellement, je pense que le filtre de mots est plus approprié que le poids. ** ** Lorsque ce poids est calculé par matrice dans Images Tensor

Après le calcul de la matrice


matmul = tf.matmul(x,W)
print "matmul:", matmul[0] #Première image(La réponse est 7)
matmul: [ 1.43326855 -10.14613152 2.10967159 6.07900429 -3.25419664
-1.93730605 -8.57098293 10.21759605 1.16319525 2.90590048]

Sera retourné. Eh bien, je ne suis toujours pas sûr.

biais

Le biais peut être inapproprié car il sonne bien, y = x(sin(2+(x^1+exp(0.01)+exp(0.5)))+x^(2+tan(10)))+x(x/2x+x^3x)+0.12 Est-ce quelque chose comme le dernier "0.12" quand il y a une fonction comme celle-ci? graph.jpg Plus simplement, b? Of y = xa + b? Oh, c'est pourquoi c'est un parti pris. Cependant, dans le cas du tutoriel, l'exactitude de la réponse n'a pas beaucoup changé, même sans biais. Si la valeur réelle du biais est «b = 1e-10», cela ne signifie pas grand-chose. Dans le code, nous le créerons de la même manière que le poids, mais comme l'image Tensor et le poids ont déjà été opérés par matrice, le biais à ajouter plus tard est «Shape [10]» de «Rank1».

biais


b = tf.Variable(tf.zeros([10]))
print "b:",b #Biais post-apprentissage
b: [-0.98651898 0.82111627 0.23709664 -0.55601585 0.00611385 2.46202803
-0.34819031 1.39600098 -2.53770232 -0.49392569]

Je ne sais pas s'il s'agit d'une seule unité.

Fonction Softmax - réponses correspondantes -

Le Tensor Images original x: [batch_num, 784] est Opération de matrice avec un poids «x» »W: [784, 10]« Après être devenu = matmul: [batch_num, 10] + Bias b: [10] sera ajouté. Cependant, je ne comprends toujours pas la signification de ces chiffres. Par conséquent, transmettez-les à tf.nn.softmax () afin qu'ils puissent être compris par les humains.

softmax


y = tf.nn.softmax(tf.matmul(x, W) + b)
print "y", y[0] #Première image(La réponse est 7)
y [ 2.04339485e-05 6.08732953e-10 5.19737077e-05 2.63350527e-03
2.94665284e-07 2.85405549e-05 2.29651920e-09 9.96997833e-01
1.14465665e-05 2.55984633e-04]

En y regardant, le 7ème chiffre est le plus élevé. Apparemment, la probabilité de «7» est élevée. Si vous voulez simplement faire correspondre les réponses plutôt que les probabilités dans le tableau

Veuillez me donner une réponse


x_answer = tf.argmax(y,1)
y_answer = tf.argmax(y_,1)
print "x",x_answer[0:10] #La réponse aux 10 premières images que pense Tensorflow
print "y",y_answer[0:10] #10 La vraie réponse de l'image
x [7 2 1 0 4 1 4 9 6 9]
y [7 2 1 0 4 1 4 9 5 9]

Je veux connaître l'exactitude


correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print "accuracy:", accuracy
accuracy: 0.9128
  • Ajouté le 19/05/2016 La fonction Softmax est une fonction qui écrase un ensemble de valeurs réelles arbitraires dans «range (0, 1)». Au début, je l'ai écrit sous le nom de régression Softmax, mais pour être précis, on l'appelle «régression logistique» parce qu'elle effectue une régression sur la probabilité. Softmax est une fonction qui renvoie la sortie lorsque vous la saisissez. Puisque MNIST est un problème de classification des images, comme une série de traitements, "Je veux connaître la probabilité de chaque étiquette pour cette image" → "Régression logistique (softmax)" → "La réponse est celle avec la probabilité la plus élevée (argmax)". Vous n'utiliserez donc probablement pas softmax pour l'analyse de régression où vous souhaitez trouver des nombres réels.

5: Quand apprenez-vous?

Vous comprenez maintenant comment Tensorflow vous donne la réponse pour MNIST. Mais comment se déroule l'apprentissage des pondérations «W» et du biais «b»? Ce sera. L'indice se trouve dans la partie où l'exécution d'apprentissage de Tensorflow est répétée.

Dernier code de démarrage de l'exécution d'apprentissage


for i in range(1000):
 batch_xs, batch_ys = mnist.train.next_batch(100)
 sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

Ce train_step semble être un entraînement. Le contenu est

Méthode d'apprentissage


cross_entropy = -tf.reduce_sum(y_*tf.log(y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
'''
 y: [batch_num, 10] y is a list of processed numbers of x(images)
y_: [batch_num, 10] y_ is labels
0.01 is a learning rate
'''

Mais mâchons un peu plus tf.log () calcule le journal d'une manière facile à comprendre. Il n'y a pas de changement dans Tensor lui-même, donc c'est log-y: [batch_num, 10]. Et je le multiplie par la réponse Tensory_, mais comme "y_" contient tous les 0 sauf la réponse, quand je le multiplie, la valeur de "index" autre que la réponse devient "0". Dans le Tensor multiplié, «Shape» est «[batch_num, 10]», mais il peut être plus facile de comprendre que la dimension réelle est «[batch_num, 1]» parce que c'est «0» sauf pour la partie réponse.

log-y = tf.log(y)
print log-y[0]
[ -1.06416254e+01 -2.04846172e+01 -8.92418385e+00 -5.71210337e+00
 -1.47629070e+01 -1.18935766e+01 -1.92577553e+01 -3.63449310e-03
 -1.08472376e+01 -8.88469982e+00]
y_times_log-y = y_*tf.log(y)
print y_times_log-y[0] #Seule la valeur de 7 reste.
[-0. -0. -0. -0. -0. -0.
-0. -0.00181153 -0. -0. ]

tf.reduce_sum () ajoute à toutes les dimensions et devient un TenseurRank0 (scalaire) sans le deuxième argument et l'option keep_dims = True. Dans le cas de MNIST, c'est la somme de toutes les valeurs détenues par [batch_num].

Exemple tf.reduce_sum()


# 'x' is [[1, 1, 1]
# [1, 1, 1]]
tf.reduce_sum(x) ==> 6
tf.reduce_sum(x, 0) ==> [2, 2, 2]
tf.reduce_sum(x, 1) ==> [3, 3]
tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]
tf.reduce_sum(x, [0, 1]) ==> 6
------
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
print "cross_entropy:", cross_entropy #y_*tf.log(y)Le nombre total de contenus
cross_entropy 23026.0 #Valeur numérique après le premier apprentissage
.
.
.
cross_entropy: 3089.6 #Valeur numérique après le dernier apprentissage

Cet article est très utile pour l'entropie croisée. Neural Network and Deep Learning: -Livres en ligne gratuits-Chapitre 3 http://nnadl-ja.github.io/nnadl_site_ja/chap3.html En bref, c'est un indicateur de ce que vous apprenez. Il semble que l'apprentissage réussisse si vous optimisez le ** poids ** et le ** biais ** en vous référant à cela. C'est tf.train.GradientDescentOptimizer () qui est en fait en train d'optimiser, mais il y a d'autres choix class tf.train.Optimizer, donc c'est amusant de jeter un œil. Tensorflow/api_docs - Optimizers: https://www.tensorflow.org/versions/r0.7/api_docs/python/train.html#optimizers Si vous appelez en plus .minimize (), le calcul du gradient et l'application à tf.Variables seront effectués ensemble. Inversement, en appelant .compute_gradients (), vous pouvez voir la valeur de mise à jour des ** poids ** W et ** biais ** b au moment de l'optimisation, c'est-à-dire la valeur d'erreur / valeur de correction. peut faire. En fait, il semble que cela commence par ± un grand nombre et converge en faisant des va-et-vient entre les lieux.

Gradient_values


#Apprentissage précoce
cross_entropy 23026.0
grad W[0] [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
grad W[380] [ 511.78765869 59.3368187 -34.74549103 -163.8828125 -103.32589722
 181.61528015 17.56824303 -60.38471603 -175.52197266 -232.44744873]
grad b [ 19.99900627 -135.00904846 -32.00152588 -9.99949074 18.00206184
 107.99274445 41.992836 -27.99754715 26.00336075 -8.99738121]
#Dernier apprentissage
cross_entropy 2870.42
grad W[0] [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
grad W[380] [ 6.80800724 1.27235568 -6.85943699 -22.70822525 -17.48428154
 13.11752224 19.7425499 -32.00106812 -41.48160553 79.59416199]
grad b [ 19.52701187 3.17797041 -20.07606125 -48.88145447 -28.05920601
 37.52313232 40.22808456 -34.04494858 -74.16973114 104.77211761]

Concernant le poids W, il semble que le premier pixel soit complètement ignoré ... lol Je pense qu'il vaut mieux laisser ces chiffres à la machine et boire lentement avec du thé.

6: La prochaine fois, j'expliquerai les experts en détail!

En fait, je n'ai pas encore réalisé ce que je voulais faire ... J'étais complètement fasciné par le fait que l'apprentissage automatique super-stimule «l'esprit de fabrication». Plus votre compréhension est profonde, plus vous trouverez d'idées, «Faisons ceci» et «Faisons-le». Cela ne fonctionne pas, mais c'est amusant. Je me demande ... ce sentiment nostalgique. Ensuite, je voudrais expliquer l'édition experte du MNIST du tutoriel. Je le recommande à ceux qui ne savent pas plier et regrouper. Les actions, les tweets, les likes, les haines, les commentaires, etc. sont tous encourageants, alors s'il vous plaît.

  • Ajouté 2016.3.29 J'ai écrit un commentaire pour l'édition experte.

Recommended Posts

Je ne suis ni programmeur ni data scientist, mais j'ai touché Tensorflow pendant un mois, donc c'est super facile à comprendre.
Je suis un utilisateur Windows mais je souhaite exécuter tensorflow