[PYTHON] 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
Par exemple, je souhaite connaître le cluster approprié
Par exemple, je souhaite connaître un "visage" approprié à partir d'un ensemble de pixels
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:
- Caffe
- L'ancien Google Andy Rubin a investi Nervana
- Vous pouvez faire de l'apprentissage automatique avec le glisser-déposer basé sur l'interface graphique Microsoft Azure Machine Learning Etc. Cependant, rien ne peut être fait si vous ne comprenez pas le modèle d'évaluation du contenu. Donc au final, j'ai commencé avec Tensorflow, qui semble avoir le plus d'informations. Peut-être que la principale raison de son utilisation est qu'il existe de nombreuses fonctions de modèle d'évaluation lorsque vous vous habituez à ce champ. ** * Ajouté 2016/4/26 ** Quand je suis le contenu qui est engagé dans github tous les jours, je pense qu'il est normal d'attendre un moment, sauf pour Tensorflow.
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
- Il existe de nombreuses histoires de type installation, je vais donc les ignorer.
※※ Il est recommandé de lire le tutoriel pour débutants.
C'est le début d'un commentaire sérieux.
MNIST est une référence pour l'apprentissage automatique.
En tant que premier tutoriel de Tensorflow, nous donnerons de nombreuses images de nombres manuscrits de 0 à 9 pour vous aider à comprendre les nombres.
Débutant et Expert (/tutorials/mnist/pros/index.html) fonctionne également si vous copiez et collez ... Ce que vous devez apprendre ici n'est pas le code direct, mais Tensor, Rank, Scalar, Vector (tenseur, rang, scalaire, vecteur, C'était une reconfirmation des concepts et des processus de Tensorflow, tels que la forme) et de la compréhension mathématique.
Tout d'abord, à propos du Tensor le plus important.
Fiable pour la gestion des données d'entrée, etc. ** Tensor n'est qu'une structure de données, il n'est échangé qu'entre les processus d'apprentissage. Tensor semble être mieux considéré comme un tableau ou une liste à n dimensions en termes Python. ** **
C'est comme mettre des données dans Tensor pour chaque lot d'apprentissage.
Donc, même si j'essaie print hoge_Tensorà des moments autres que le processus d'apprentissage, le contenu n'est pas inclus. La valeur du processus d'apprentissage telle que "weight" est conservée dans la variable tf.Variable. ** Et Tensor a toujours Rang, Forme, Type. ** ** C'est souvent dit avec des erreurs, donc ça a été beaucoup plus facile une fois que j'ai compris. Rank
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.
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000.6.7.7.50000000000.81111111.9.30000000.4.4.4.7111000000000000.1.10000000000000000000000000000000000000000000000000000000000
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] `.
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 **.
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?
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.
- Ajouté le 08.12.2016 J'ai écrit une description de LSTM dans Advent Calender. Si vous pouvez comprendre cela, pouvez-vous faire du traitement du langage naturel? Commentaire en touchant RNN (LSTM) avec MNIST