J'ai commencé à apprendre le machine learning, mais c'était un peu difficile à vivre. La reconnaissance de caractères est la première chose qui est introduite dans TensorFlow Tutorial, qui crée une atmosphère novice. C'était grand que j'étais là. Tout à coup "Créons une fonction qui distribue les données d'entrée de 784 éléments (nombre de pixels) aux données de sortie de 10 éléments (nombres). Nous avons une énorme quantité de données entrées manuellement (55 000). C'est Hello pour l'apprentissage automatique. C'est le monde. " C'était difficile.

Cependant, je n'ai pas pu m'en empêcher, alors je l'ai essayé, et d'une manière ou d'une autre, j'ai trouvé comment le faire, alors j'ai créé un tutoriel que j'ai emprunté moi-même, donc je vais l'écrire sous forme de mémorandum. J'ai utilisé 3.5.1 comme version Python.

Quoi faire

--Distributeur qui classe les types de corps en «mince», «normal» et «potelé» en fonction de la taille et du poids.

Situation présumée

Demandez à un grand nombre de personnes la «taille» et le «poids»
Notez l'impression de «forme corporelle» de la personne (subjectivité individuelle) en trois catégories: «mince», «normale» et «potelée».

172 cm 62 kg normal 181cm 55kg d'épaisseur ... ```

Lorsqu'une quantité considérable de données de mémo est accumulée, laissez la machine apprendre la corrélation entre «taille», «poids» et «forme du corps» afin que vous puissiez juger de la forme du corps sans vous fier à l'intuition si vous connaissez la «taille» et le «poids». À.

Flux d'apprentissage automatique par TensorFlow

Préparez les données des enseignants et les données des tests
Concevoir la structure de données de la valeur d'entrée et de la valeur de sortie à partir des données de l'enseignant
En supposant un modèle de corrélation entre les valeurs d'entrée et de sortie
Transmettez les données de l'enseignant au modèle et formez-le
Vérifiez l'état d'apprentissage du modèle
Si peu importe ce que vous apprenez, vous n'obtiendrez pas le résultat correct. → Revenir à 3.

1. Préparez les données des enseignants et les données des tests

Préparez suffisamment de données et de données sur les enseignants pour analyser la corrélation des données. Plus le nombre de données est grand, plus l'apprentissage peut être effectué avec précision.

Y = f(X)

L'ensemble de $ X $ et $ Y $ est les données de l'enseignant. Je ne sais pas comment trouver $ Y $, mais je veux connaître les informations. $ X $ et $ Y $ sont des vecteurs, mais ne réfléchissez pas trop, l'image ci-dessous.

\left(
  \begin{array}{ccc}
d'habitude\\
Maigre\\
      \vdots
  \end{array}
\right)
 = f\left(
  \begin{array}{ccc}
      172 & 62  \\
      181 & 55  \\
      \vdots & \vdots
  \end{array}
\right)

Pour les données des enseignants, cette fois, le format des données était CSV. Je n'ai pas eu le temps de faire un sondage de rue, alors je l'ai fait à la main.

import numpy as np
import csv
def gen_data(n):
    h = 160 + (np.random.randn(n) * 10)
    w = (h/100) ** 2 * 22 + (np.random.randn(n) * 10)
    bmi = w / (h/100) ** 2
    f = np.vectorize(lambda b: 'Joufflu' if b > 25 else 'd'habitude' if b > 18.5 else 'Maigre')
    return np.c_[h, w, f(bmi)]
fp = open('train.csv', 'w')
writer = csv.writer(fp)
writer.writerows(gen_data(100))
fp.close()

`train.csv`


172,62,d'habitude
181,55,Maigre
...

Facile à charger.

 fp = open('train.csv', 'r')
 train_data = np.array([r for r in csv.reader(fp)])

C'est la distribution des données dans le graphique

train_plot = [train_data[train_data[:,2] == 'Maigre'],
              train_data[train_data[:,2] == 'd'habitude'],
              train_data[train_data[:,2] == 'Joufflu']]
plt.plot(train_plot[0][:,0], train_plot[0][:,1], 'o', label = 'skinny')
plt.plot(train_plot[1][:,0], train_plot[1][:,1], 'o', label = 'normal')
plt.plot(train_plot[2][:,0], train_plot[2][:,1], 'o', label = 'fat')

En plus des données de l'enseignant, des données de test pour juger du résultat d'apprentissage de l'apprentissage automatique sont également préparées.

Ces données de test sont $ Une fonction entraînée par machine pour se rapprocher le plus possible de Y = f (X dans les données de l'enseignant) $ dans les données de l'enseignant $ Données de l'enseignant Y \ pointseq descendant g (données de l'enseignant X) $ Il est utilisé pour vérifier les performances de ce $ g $. Passez $ X $, qui est différent des données de l'enseignant, à $ g $ et voyez si le résultat attendu est renvoyé.

Vérifier le contenu: $ g (X des données de test) $ est-il égal à Y $ de $ données de test?

Cette fois, nous avons préparé 100 données d'enseignants et 50 données de tests.

2. Concevoir la structure de données de la valeur d'entrée et de la valeur de sortie à partir des données de l'enseignant

Même si cela dit design, il suffit de déterminer le nombre d'éléments de la valeur d'entrée et le nombre d'éléments de la valeur de sortie et de décider du type. Cette fois, il y a deux éléments d'entrée

[la taille: float,poids: float]

3 éléments de sortie

[Probabilité d'être mince:float,Probabilité d'être normal:float,Probabilité d'être potelé:float ]

Et dit. La probabilité est de 0 $ à 1 $.

Convertissez les données lues à partir du CSV comme suit.

train_x = np.array([[float(r[0]), float(r[1])] for r in train_data])
train_y = np.array([ [1,0,0] if r[2] =='Maigre' else [0,1,0] if r[2] == 'd'habitude' else [0,0,1] for r in train_data])

$ Y = f (X) $ ressemble à ceci.

\left(
  \begin{array}{ccc}
     0 & 1 & 0 \\
     1 & 0 & 0 \\
     \vdots & \vdots & \vdots 
  \end{array}
\right)
 = f\left(
  \begin{array}{ccc}
      172 & 62  \\
      181 & 55  \\
      \vdots & \vdots
  \end{array}
\right)

3. En supposant un modèle de corrélation entre les valeurs d'entrée et de sortie

C'est le foie.

Supposons que la fonction $ g (X) $ soit apprise automatiquement comme suit.

Y = {\rm softmax}(WX+b)

La formule est sortie soudainement, mais Régression linéaire Est possible avec cela. Si vous ne pouvez pas le résoudre [voir ci-dessous](#% E6% 9C% 9F% E5% BE% 85% E3% 81% 97% E3% 81% 9F% E7% B5% 90% E6% 9E% 9C% E3% 81 % AB% E8% BF% 91% E3% 81% A5% E3% 81% 8B% E3% 81% AA% E3% 81% 84).

Ceci est montré dans la figure,

$ X_ {i} $ Multipliez tout par le poids $ W_ {i, j} $, ajoutez le biais $ b_ {j} $ et ajoutez $ {\ rm softmax} $ pour obtenir $ y_ {j} $ Préparer. En changeant peu à peu $ W $ et $ b $ pour se rapprocher de la relation entre $ X $ et $ Y $ dans les données des enseignants, je pense que cela deviendra éventuellement un classificateur performant. y a-t-il.

\left(
  \begin{array}{ccc}
      y_{1,1} & y_{1,2} & y_{1,2}\\
      y_{2,1} & y_{2,2} & y_{1,3}\\
      \vdots & \vdots & \vdots
  \end{array}
\right)
 = {\rm softmax}(
\left(
  \begin{array}{ccc}
      W_{1,1} & W_{1,2} & W_{1,3}  \\
      W_{2,1} & W_{2,2} & W_{2,3} 
  \end{array}
\right) 
\cdot
\left(
  \begin{array}{ccc}
      x_{1,1} & x_{1,2}  \\
      x_{2,1} & x_{2,2}  \\
      \vdots & \vdots
  \end{array}
\right) + 
\left(
  \begin{array}{ccc}
      b_{1} &
      b_{2} &
      b_{3}
  \end{array}
\right))

Si vous démêlez une ligne,

$ \ left (\ begin {array} {ccc} Probabilité d'être mince y_ {, 1} & Probabilité d'être normal y_ {, 2} & Probabilité d'être potelé y_ {, 3} \ end {array} \ right) $

= 
{\rm softmax}
\left(
  \begin{array}{ccc}
    (W_{1.1} x_{,1} + W_{2.1} x_{,2} + b_{1}),\ (W_{1.2} x_{,1} + W_{2.2} x_{,2} + b_{2}),\ (W_{1.3} x_{,1} + W_{2.3} x_{,2} + b_{3}
  \end{array}
\right))

$ x_ {, 1} $: Hauteur, $ x_ {, 2} $: Poids

Voilà ce que c'est.

$ {\ rm softmax} $ est resté.

La fonction $ {\ rm softmax} $ est une fonction pratique lors de la classification en plusieurs valeurs de probabilité par un réseau neuronal comme cette fois. Dans la formule, $ A = \ left [\ begin {array} {ccc} a_ {1} \ ldots a_n \ end {array} \ right] $ {\ rm softmax} (A) = \ quand il y avait $ gauche [\ frac {e ^ {a_ {1}}} {\ sum_ {j = 1} ^ ne ^ {a_j}} \ ldots \ frac {e ^ {a_n}} {\ sum_ {j = 1} ^ ne ^ {a_j}} \ right] C'est une fonction qui devient $, mais pour le moment, veuillez l'ignorer.

En termes simples, les valeurs relativement plus élevées sont normalisées à $ 1 $ et les valeurs plus petites sont normalisées à $ 0 $ de sorte que la somme du tableau $ A $ est de 1 $. C'est un substitut pour moi. Cette fois, il y a trois catégories $ [Probabilité d'être mince, \ Probabilité d'être normal, \ Probabilité d'être potelé] $ Je veux en trouver une paire. Par exemple, si vous avez 80% de chances de perdre du poids et 20% de chances d'avoir une taille et un poids normaux, la réponse est [0.8,\ 0.2,\ 0.0] Je veux. De plus, chaque somme de tous les enregistrements de données sur les enseignants est de 1 $. [1,\ 0,\ 0]\ {\rm or}\ [0,\ 1,\ 0]\ {\rm or}\ [0,\ 0,\ 1] Par conséquent, je n'ai pas l'impression qu'il va converger même si j'obtiens un résultat comme $ [1, \ 2, \ 3] $. Je ne dis pas. $ [1, \ 2, \ 3] $ est $ {\ rm softmax} $ pour obtenir $ [0.09, \ 0.245, \ 0.665] $. Je sens que je peux faire ça.

En passant, dans l'apprentissage automatique, la fonction qui normalise la valeur comme ceci $ {\ rm softmax} $ est [Fonction d'activation](https://ja.wikipedia.org/wiki/%E6%B4%BB%E6 Il est appelé% 80% A7% E5% 8C% 96% E9% 96% A2% E6% 95% B0).

La définition du modèle dans TensorFlow est

import tensorflow as tf

#Définition de la valeur d'entrée
x = tf.placeholder('float', [None, 2])

#Définition de la valeur de sortie
w = tf.Variable(tf.ones([2, 3]))
b = tf.Variable(tf.zeros([3]))
y = tf.nn.softmax(tf.matmul(x, w) + b)

Ce sera comme ça. Depuis l'apparition de l'API tensorflow, je vais l'expliquer brièvement

api	La description
`tf.placeholder`	Définition de la valeur d'entrée. Les données des enseignants et les données de test se trouvent ici. Vous devez le donner au moment de l'exécution. Les arguments sont le type et le nombre de dimensions.
`tf.Variable`	Définition des valeurs à changer par l'apprentissage. Chaque fois que vous effectuez un apprentissage, celui-ci fluctue de sorte que l'erreur diminue. L'argument est la valeur initiale.
`tf.ones`	1 Renvoie une matrice remplie
`tf.zeros`	0 Renvoie une matrice remplie
`tf.matmul`	Renvoie le résultat de la multiplication matricielle

4. Transmettez les données de l'enseignant au modèle et formez-le

Dans le paramètre précédent, la valeur initiale était définie de manière appropriée, donc même si vous transmettez $ X $, seul un résultat approprié sera renvoyé. La direction vers le résultat correct doit être définie à l'avance.

Calculez en remplaçant $ W $, $ b $ pour la valeur initiale et $ X $ pour les données de l'enseignant pour $ g (X) $ et $ Y = {\ rm softmax} (WX + b) $ supposé dans la section précédente. ,

\left(
  \begin{array}{ccc}
     0.333 & 0.333 & 0.333 \\
     0.333 & 0.333 & 0.333 \\
     \vdots & \vdots & \vdots 
  \end{array}
\right)
 = g\left(
  \begin{array}{ccc}
      172 & 62  \\
      181 & 55  \\
      \vdots & \vdots
  \end{array}
\right)

Voilà le résultat. En conséquence, la valeur d'erreur de $ Y $ et le vrai résultat des données de l'enseignant (défini comme $ Y '$) sont calculés, et si cette valeur d'erreur peut être minimisée, l'apprentissage est terminé. La valeur d'erreur de la distribution de probabilité est calculée à l'aide d'une formule appelée entropie croisée.

loss = -\sum Y' {\rm log}(Y)

Cette entropie croisée est définie comme la méthode de mesure de la valeur d'erreur, car si la correspondance est exacte, $ 0 $ peut être obtenu, et si elle est différente, une valeur plus grande peut être obtenue.

Ensuite, il est nécessaire de réduire la valeur d'erreur mesurée tout en ajustant $ W $ et $ b $ définis comme tf.Variable (valeur qui fluctue par apprentissage) dans le modèle.

La fonction qui obtient cette valeur d'erreur (dans ce cas, l'entropie croisée de $ loss $: $ Y $ et $ Y '$) est appelée la fonction objectif.

Il existe différents algorithmes pour optimiser la fonction objectif.

Un algorithme qui converge rapidement mais qui risque de ne pas trouver la solution optimale
Un algorithme qui permet de trouver facilement la solution optimale mais qui met beaucoup de temps à converger --Un algorithme qui ne peut pas trouver de solution à un certain problème --Un algorithme qui est gênant pour définir les paramètres
Tel

Cependant, TensorFlow a une implémentation de de nombreux algorithmes d'optimisation, alors changez et essayez Est facile.

Cette fois, méthode de descente de gradient (tf.train.GradientDescentOptimizer) et Adam % A2% BA% E7% 8E% 87% E7% 9A% 84% E5% 8B% BE% E9% 85% 8D% E9% 99% 8D% E4% B8% 8B% E6% B3% 95 # Adam) ( J'ai essayé deux d'entre eux (tf.train.AdamOptimizer), mais les deux m'ont donné une solution. Adam a finalement choisi cela parce qu'il a convergé plus rapidement.

L'algorithme d'optimisation de TensorFlow modifie peu à peu les valeurs de fluctuation $ W $ et le biais $ b $ de sorte que le résultat (= valeur d'erreur) de la fonction objectif devienne petit.

Même si vous changez tout cela en même temps, vous ne trouverez pas la réponse, vous devez donc la changer petit à petit, mais cette quantité de changement peut être ajustée avec des paramètres. S'il est trop grand, la réponse ne peut être trouvée, et s'il est trop petit, il faut du temps pour trouver la réponse. Cette fois, la valeur de réglage pour ʻAdam Optimizer` était de 0,05.

La définition de l'apprentissage dans TensorFlow est la suivante.

#Zone de saisie de réponse pour les données de l'enseignant(Y')
y_ = tf.placeholder('float', [None, 3])
#Fonction objective-sum(Y'log(Y))
#log(0)Ajustement du montant minimum pour indiquer nan(tf.clip_by_value)
loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.clip_by_value(y, 1e-10, 1.0))))
#Optimiser progressivement les valeurs de variation afin que le résultat de la fonction objectif soit minimisé
train_step = tf.train.AdamOptimizer(0.05).minimize(loss)

#Initialisation variable
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

train_feed_dict={x: train_x, y_: train_y}
for i in range(100001):
    #Apprentissage
    sess.run(train_step, feed_dict=train_feed_dict)

L'exécution de sess.run évalue le contenu du premier paramètre. À ce moment-là, les données mappées vers le «espace réservé», qui est nécessaire pour calculer le paramètre, sont passées au paramètre «feed_dict». Puisque train_step nécessite $ X $ et $ Y '$ de données d'enseignant, définissez comme ci-dessus.

L'apprentissage a été effectué 100 000 fois.

5. Vérifiez l'état d'apprentissage du modèle

L'apprentissage prend du temps. Ce sera triste si le résultat n'est pas obtenu après avoir attendu, donc je veux vérifier lors de l'exécution si le modèle d'ensemble fonctionne correctement, c'est-à-dire si la valeur d'erreur se dirige vers la convergence.

TensorBoard est fourni en tant qu'outil de visualisation dans TensorFlow, mais je n'y toucherai pas cette fois.

Visualisé sur une console boueuse.

test_feed_dict={x: test_x}
for i in range(100001):
    sess.run(train_step, feed_dict=train_feed_dict)
    if(i % 10000 == 0 or (i % 1000 == 0 and i < 10000) or (i % 100 == 0 and i < 1000) or (i % 10 == 0 and i < 100)):
        #Sortie d'erreur
        test_y = ['Maigre' if max(a) == a[0] else 'd'habitude' if max(a) == a[1] else 'Joufflu' for a in sess.run(y, feed_dict=test_feed_dict)]
        bools = train_data[:,2] == test_y
        print (i, sess.run(loss, feed_dict=train_feed_dict), str(sum(bools) / len(bools) * 100) + '%')

Le nombre de fois d'apprentissage, la valeur d'erreur des données de l'enseignant et le taux de réponse correct lorsque $ X $ des données de test est utilisé ($ Y '$ n'est pas requis pour feed_dict) sont affichés. Corrigez la synchronisation de sortie comme il convient.

10 89.8509 64.0%
20 80.4948 64.0%
30 73.6655 64.0%
40 68.4465 65.0%
50 64.4532 69.0%
60 61.0676 73.0%
70 58.317 73.0%
80 56.0346 74.0%
90 54.1317 74.0%
100 52.5213 74.0%
200 44.4377 79.0%
300 41.6028 79.0%
400 40.2241 80.0%
...

Il est affiché comme ceci. D'une manière ou d'une autre, l'apprentissage semble réussir.

Je voulais le rendre un peu plus facile à comprendre, alors j'ai essayé de le visualiser avec pyplot.

import matplotlib.pyplot as plt

# height: 130～190, weight:Faire toutes les combinaisons de 20-100 et extraire y de la fonction apprise
px, py = np.meshgrid(np.arange(130, 190+1, 1), np.arange(20, 100+1, 1))
graph_x = np.c_[px.ravel() ,py.ravel()]
graph_y = sess.run(y, feed_dict={x: graph_x})
#y est la gradation des couleurs (-Convertir en 1 en 1)
pz = np.hsplit(np.array([sum(e * [-1, 0, 1]) for e in graph_y]), len(px))
plt.pcolor(px, py, pz)
plt.cool()

La plage de données de l'enseignant cette fois a été fixée à X $ pour tous les modèles de combinaison qui peuvent être pris par incréments de 1 cm de hauteur et 1 kg de poids, et le modèle a été évalué et tracé.

Je pense que c'est plus facile à appréhender en tant que situation d'apprentissage.

6. Si peu importe ce que vous apprenez, vous n'obtiendrez pas le résultat correct.

Passez en revue la conception du modèle. Selon le problème, un modèle simple comme celui-ci ne peut pas le gérer, il faudra donc faire des ajustements petit à petit.

Je n'ai pas saisi les détails, donc si vous donnez un exemple simple

L'apprentissage est lent ou s'arrête au milieu

Découpez un mini lot --Ajuster les paramètres de l'algorithme d'optimisation
Essayez de passer à un autre algorithme

Restez à l'écart des résultats attendus

Essayez d'ajouter une couche intermédiaire (couche masquée)

L'exemple de TensorFlow Playground est facile à comprendre.

Puisque $ WX + b $ est une expression linéaire, il ne peut pas traiter de problèmes non linéaires. Cependant, en préparant une couche intermédiaire omise dans ce modèle entre la couche d'entrée et la couche de sortie, il devient possible de former un modèle non linéaire compliqué en combinant des modèles linéaires. Il est moins efficace en temps, mais il a le potentiel de réduire la valeur d'erreur finale.

Exemple d'ajout de couche intermédiaire

#Couche intermédiaire
with tf.name_scope('hidden'):
    w0 = tf.Variable(tf.ones([2, 4])) #Reçoit 2 x de la couche d'entrée et se convertit en 4 sorties
    b0 = tf.Variable(tf.zeros([4]))   #Biais sur chaque sortie
    h0 = tf.nn.relu(tf.matmul(x, w0) + b0)

#Couche de sortie
with tf.name_scope('output'):
    w = tf.Variable(tf.ones([4, 3])) #Reçoit 4 sorties de la couche intermédiaire et les convertit en 3 sorties
    b = tf.Variable(tf.zeros([3]))   #Biais sur chaque sortie
    y = tf.nn.softmax(tf.matmul(h0, w) + b)

Essayez de traiter les données d'entrée

Cela peut valoir la peine d'essayer de traiter les données d'entrée, par exemple linéaires en ajoutant $ {x_ {1}} ^ 2, \ {\ rm sin} (x_ {2}) $ comme nouveau $ x_i $. Convertissez en un problème récurrent.

Exemple de traitement des données d'entrée

#Couche d'entrée
with tf.name_scope('input'):
    x = tf.placeholder('float', [None, 2])
    #Pré-traitement de la valeur d'entrée
    x1, x2 = tf.split(1, 2, x)
    x_ = tf.concat(1, [x, x1 ** 2, tf.sin(x2)])
#Couche de sortie
with tf.name_scope('output'):
    w = tf.Variable(tf.ones([4, 3])) #[[x1, x2, x1**2, sin(x2)],[skinny, normal, fat]] 
    b = tf.Variable(tf.zeros([3]))
    y = tf.nn.softmax(tf.matmul(h0, w) + b)

Ajouter des données d'entrée

Je soupçonne que les informations d'entrée peuvent être insuffisantes. Dans cet exemple, l'ajout du sexe, de l'âge, etc. aux données peut encore améliorer l'exactitude. Cependant, il est nécessaire de recommencer à partir de la collecte des données.

Résultat d'apprentissage

Dans ce modèle, 100 cas étaient 100 000 fois et le temps de calcul était d'environ 2 minutes. (Core i5 1,8 GHz)

...
70000 3.63972 99.0%
80000 3.27686 100.0%
90000 3.02285 100.0%
100000 2.80263 100.0%

Le taux de réponse correcte a atteint 100% vers la 80 000e fois.

Le graphique est également sympa

Voir aussi les valeurs de $ W $ et $ b $

print ('w:',sess.run(w))
print ('b:',sess.run(b))

`console`


w: [[ 3.11868572  1.0388186  -0.9223755 ]
 [-2.45032024  0.99802458  3.3779633 ]]
b: [-172.08648682   -3.14501309  158.91401672]

Fonction de distribution $ (Probabilité d'être mince, Probabilité d'être normal, Probabilité d'être potelé) $ $ = {\ rm softmax} ((3,12 Hauteur -2,45 Poids -172,96), (1,04 Hauteur + Poids -3,15), (-0,92 Hauteur + 3,38 Poids + 158,91)) $ Est terminé.

Vérifié avec ipython au cas où

import numpy as np
#Depuis softmax n'était pas dans le numpy, j'ai fait ma propre définition
def softmax(a):
    e = np.exp(np.array(a))
    return e / np.sum(e)
def taikei(h, w):
    return softmax([(3.12*h - 2.45*w - 172.96), (1.04*h + w - 3.15), (-0.92*h + 3.38*w + 158.91)])
print(np.round(taikei(172,60),2))

↓ [ 0. 1. 0.]

Si vous mesurez 172 cm et pesez 60 kg 100% normal.

Une ligne délicate, hauteur 172 cm, poids 74 kg

print(np.round(taikei(172,74),2))

↓ [ 0. 0.26 0.74] 74% joufflu.

Tout le code source

import numpy as np
import tensorflow as tf
import csv
import matplotlib.pyplot as plt
import math

def read(path):
    fp = open(path, 'r')
    data = np.array([r for r in csv.reader(fp)])
    fp.close()
    return data

def convert(data):
    return [np.array([[float(r[0]), float(r[1])] for r in data]),
            np.array([ [1,0,0] if r[2] =='Maigre' else [0,1,0] if r[2] == 'd'habitude' else [0,0,1]  for r in data])]

train_data = read('train.csv')
test_data = read('test.csv')

#Affichage des données de l'enseignant
plt.xlabel('height')
plt.ylabel('weight')
plt.xlim(130, 190)
plt.ylim(20, 100)
train_plot = [train_data[train_data[:,2] == 'Maigre'],
              train_data[train_data[:,2] == 'd'habitude'],
              train_data[train_data[:,2] == 'Joufflu']]
plt.plot(train_plot[0][:,0], train_plot[0][:,1], 'o', label = 'skinny')
plt.plot(train_plot[1][:,0], train_plot[1][:,1], 'o', label = 'normal')
plt.plot(train_plot[2][:,0], train_plot[2][:,1], 'o', label = 'fat')
plt.legend()

train_x, train_y = convert(train_data)
test_x, test_y = convert(test_data)

#Couche d'entrée
with tf.name_scope('input'):
    x = tf.placeholder('float', [None, 2])

#Couche de sortie
with tf.name_scope('output'):
    w = tf.Variable(tf.ones([2, 3]))
    b = tf.Variable(tf.zeros([3]))
    y = tf.nn.softmax(tf.matmul(x, w) + b)

with tf.name_scope('train'):
    #Zone de saisie de réponse pour les données de l'enseignant(Y')
    y_ = tf.placeholder('float', [None, 3])
    #Fonction objective-sum(Y'log(Y))
    #log(0)Ajustement du montant minimum pour indiquer nan(tf.clip_by_value)
    loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.clip_by_value(y, 1e-10,1.0))))
    #Optimiser progressivement les valeurs de variation afin que le résultat de la fonction objectif soit minimisé
    train_step = tf.train.AdamOptimizer(0.05).minimize(loss)

#Initialisation variable
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

train_feed_dict={x: train_x, y_: train_y}
test_feed_dict={x: test_x}
for i in range(100001):
    sess.run(train_step, feed_dict=train_feed_dict)
    if(i % 10000 == 0 or (i % 1000 == 0 and i < 10000) or (i % 100 == 0 and i < 1000) or (i % 10 == 0 and i < 100)):
        #Sortie d'erreur
        test_y = ['Maigre' if max(a) == a[0] else 'd'habitude' if max(a) == a[1] else 'Joufflu' for a in sess.run(y, feed_dict=test_feed_dict)]
        bools = train_data[:,2] == test_y
        print (i, sess.run(loss, feed_dict=train_feed_dict), str(sum(bools) / len(bools) * 100) + '%')
        #Affichage de l'état de la classification
        # height: 130～190, weight:Faire toutes les combinaisons de 20-100 et extraire y de la fonction apprise
        px, py = np.meshgrid(np.arange(130, 190+1, 1), np.arange(20, 100+1, 1))
        graph_x = np.c_[px.ravel() ,py.ravel()]
        graph_y = sess.run(y, feed_dict={x: graph_x})
        #y est la gradation des couleurs (-Convertir en 1 en 1)
        pz = np.hsplit(np.array([sum(e * [-1, 0, 1]) for e in graph_y]), len(px))
        plt.pcolor(px, py, pz)
        plt.cool()
        plt.pause(.01)
print ('w:',sess.run(w))
print ('b:',sess.run(b))

Impressions

Je n'ai pas l'impression que je n'allais pas rendre les choses faciles. C'était la première fois que je touchais sérieusement à Python, mais j'ai été impressionné par la facilité avec laquelle il était possible d'effectuer des opérations matricielles. Je veux trouver un matériel d'apprentissage automatique pratique, mais je ne le trouve pas facilement.

[PYTHON] Tutoriel du didacticiel TensorFlow