[PYTHON] L'apprentissage en profondeur! L'histoire des données elles-mêmes qui sont lues lorsqu'elles ne suivent pas après la reconnaissance des nombres manuscrits

L'apprentissage en profondeur! C'est l'intelligence artificielle! Apprentissage automatique!

Enthousiasme en tant qu'ingénieur Je pense que je peux faire quelque chose d'extraordinaire! Avec le soutien de mon patron Parcourez des livres d'étude approfondis et des articles sur Qiita, Présentation de TensorFlow et Chainer, Accumuler la vertu avec la copie du tutoriel Le GPU utilisé pour le jeu était également pleinement opérationnel sous la cause de l'apprentissage ...

Accuracy 99.23%

Cette fois, un ingénieur satisfait de l'implémentation d'un moteur qui identifie MNIST et IRIS à plus de 99% ** Une histoire à connaître MNIST pour sortir de MNIST **

Familier, quel type de données est "MNIST"?

Image 28 lignes et 28 colonnes → Correct, mais pas là maintenant. En tant qu'ensemble de données, 70 000 lignes et 784 colonnes, 70000 est le nombre d'échantillons, 784 est le nombre de dimensions lorsque 28 * 28 est converti en vecteur. Si vous pensez que le nombre total de données que vous souhaitez analyser dans une ligne et chaque donnée que vous souhaitez analyser dans une colonne, il n'y a pas de problème jusqu'à l'étape suivante (RNN ou quelque chose?), Et SupportVectorMachine et K-means peuvent être utilisés de la même manière.

Observation complémentaire du MNIST ...

Les numéros manuscrits semblent être disposés au hasard.

Ceci est également important et lors de la collecte de données sur les enseignants dans la pratique, il est facile de préparer une grande quantité de 1 et une grande quantité de 2. Vous devez le mélanger correctement avant de commencer à apprendre. Essayez de n'apprendre que les nombres de 0 à 8 pour voir si vous pouvez identifier 9. Je suis sûr qu'il y aura beaucoup de 0 et de 4.

Il n'y a que des chiffres.

Quel idéal. Lorsque vous essayez de collecter des données dans la pratique, il y a des moments où «A» ou «-» est inclus même s'il s'agit d'un ensemble de données numériques en raison de problèmes. Les données qui peuvent être correctement triées et étiquetées à l'avance sont extrêmement précieuses.

Vous pouvez également les faire étiqueter par financement cloud, alors utilisez-les au besoin. La collection de personnages à l'aide de Captcha a également été un sujet pendant un certain temps. Luis von Arn "Collaboration à grande échelle utilisant le net" https://www.youtube.com/watch?v=-Ht4qiDRZE8

Quantité de données de 70000

Environ 200 Mo. Si vous souhaitez le déployer dans la mémoire d'un PC moderne, c'est parfait. Même si vous l'implémentez en regardant Qiita dans Firefox et que vous l'exécutez soudainement, vous pouvez vérifier le comportement avec une utilisation réaliste de la mémoire. De plus, les performances d'identification qui sont plus que suffisantes pour être étonnantes peuvent être obtenues même avec un perceptron à trois couches ordinaire.

Noir et blanc 255 couches

Ce n'est pas une procession énorme et clairsemée comme la zone de traitement du langage naturel, ce n'est pas que sa longueur soit différente et que vous ne pouvez pas avoir une vue à vol d'oiseau comme la voix, et il n'est pas nécessaire de bien gérer les couleurs et les trois couleurs. C'est merveilleux que vous puissiez juger en regardant le putt même si vous organisez plusieurs résultats. Vous pouvez comprendre ce que les fonctionnalités qui apparaissent dans la couche intermédiaire sont excellentes.

Quel type de données souhaitez-vous générer?

Maintenant que vous avez fait l'éloge du MNIST, que voulez-vous faire avec MNIST? penser à. Cette fois, le but est de comprendre la forme des données de sortie et la forme de l'étiquette attachée aux données de l'enseignant.

Dans l'exemple MNIST

1,2,3,4,5,6,7,8,9,0

Mettez-en un. Quel genre d'expression seriez-vous heureux de voir? Exemple 1. Sortie en 1 dimension: 6 => 5,5 ou plus et 6,4 ou moins 7 => 6,5 ou plus et 7,4 ou moins

Exemple 2. Sortie en 10 dimensions: 6 => [0,0,0,0,0,1,0,0,0,0] 7 => [0,0,0,0,0,0,1,0,0,0] 8 => [0,0,0,0,0,0,0,1,0,0] Dans MNIST, qui est une classification multi-classes, il existe de nombreux tutoriels dans l'exemple 2, ce qui est approprié. Si vous faites une erreur ici, vous risquez de sélectionner la mauvaise fonction d'erreur. Il y a une fonction d'erreur qui fait du bon travail, mais si ce n'est pas courant, vous devrez peut-être modifier l'étiquette des données du professeur ... Si vous ne clarifiez pas la sortie de cette zone, vous pouvez être confondu avec la classification et la régression à deux classes, etc.

Après tout, ce qui compte pour vous lorsque vous traitez des données

Lorsqu'il est appliqué à MNIST

Assurez-vous que vous vous en souciez vraiment.

WhatMnist.py


import pandas as pd
import numpy as np
# Chainer
import chainer
import chainer.functions as F
import chainer.links as L
from chainer import optimizers
from chainer import serializers, Variable
#Visualisation(Hypothèse de Jupyter)
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.cm as cm

Pour PKL

WhatMnist.py


# http://deeplearning.net/data/mnist/mnist.pkl.gz
#Avec tapple(train, valid, test)
# train -> (data, label)
# valid -> (data, label)C'est trop gentil et même les données de validation sont séparées
# test -> (data, label)
#Lire des données à l'aide de Pandas
mnist = pd.read_pickle('mnist.pkl')

http://deeplearning.net/tutorial/gettingstarted.html Cliquez ici pour le jeu de données.

Pour CSV

WhatMnist.py


if(0):
    # Pandas +Pour csv
    mnist = pd.read_csv('mnist.csv') 
    # Numpy +Pour csv
    mnist = np.loadtxt('mnist.csv')
    #Séparation des colonnes d'étiquettes(En supposant que la première ligne est l'étiquette)
    mnist_data, mnist_label = np.split(mnist, [1], axis=1)
    #Répartition entre les lignes d'étude et de test
    x_train,x_test = np.split(mnist_data, [50000])
    y_train,y_test = np.split(mnist_label, [50000])

Vérifier le format des données

WhatMnist.py


print('##Dimension et quantité')
print("train.data:{0}, train.label:{1}".format(mnist[0][0].shape, mnist[0][1].shape))
print("valid.data:{0}, valid.label:{1}".format(mnist[1][0].shape, mnist[1][1].shape))
print("test.data:{0}, test.label:{1}".format(mnist[2][0].shape, mnist[2][1].shape))

print('##Plage de valeurs et unité')
print("train.data.max:{0}, train.data.min:{1}".format(np.max(mnist[0][0]), np.min(mnist[0][0])))
print("train.label.max:{0}, train.label.min:{1}".format(np.max(mnist[0][1]), np.min(mnist[0][1])))

print('##Arrangement et méthode de sortie')
print("head -n 30 label: {0}".format(mnist[0][1][:30]))

print('##Procédé d'entrée(Lire à la fois et np.Je suis coincé dans le tableau)')
fig = plt.figure()
ax1 = fig.add_subplot(2,1,1)
ax2 = fig.add_subplot(2,1,2)
print('##Méthode de confirmation')
print('J'ai essayé d'en afficher un qui convenait en tant que représentant.')
ax1.imshow(mnist[0][0][40].reshape((28,28)), cmap = cm.Greys_r)

print('##Gentil et nature')
print('Ici, j'ai essayé de visualiser la fréquence de chaque classe avec un histogramme.')
ax2.hist(mnist[0][1], bins=range(11), alpha=0.9, color='b', normed=True)

Dimension et quantité

train.data:(50000, 784), train.label:(50000,) valid.data:(10000, 784), valid.label:(10000,) test.data:(10000, 784), test.label:(10000,)

Plage de valeurs et unités

train.data.max:0.99609375, train.data.min:0.0 train.label.max:9, train.label.min:0

Méthode de tri et de sortie

head -n 30 label: [5 0 4 1 9 2 1 3 1 4 3 5 3 6 1 7 2 8 6 9 4 0 9 1 1 2 4 3 2 7]

Méthode de saisie (lecture immédiate et plongée dans np.array)

Comment vérifier

J'ai essayé d'en afficher un qui convenait en tant que représentant.

Type et nature

Ici, j'ai essayé de visualiser la fréquence de chaque cours avec un histogramme. (array([ 0.09864, 0.11356, 0.09936, 0.10202, 0.09718, 0.09012, 0.09902, 0.1035 , 0.09684, 0.09976]), array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), mnisthist.png

Donnez-lui un nom facile à appeler pour l'avenir

Dans chainer, les données sont gérées comme float32, int32 et traitées comme un tableau (sur le CPU)

WhatMnist.py


x_train = np.array(mnist[0][0], dtype=np.float32)
y_train = np.array(mnist[0][1], dtype=np.int32)
x_test = np.array(mnist[2][0], dtype=np.float32)
y_test = np.array(mnist[2][1], dtype=np.int32)
print('x_train:' + str(x_train.shape))
print('y_train:' + str(y_train.shape))
print('x_test:' + str(x_test.shape))
print('y_test:' + str(y_test.shape))

x_train:(50000, 784) y_train:(50000,) x_test:(10000, 784) y_test:(10000,)

Le reste est un tutoriel familier

WhatMnist.py


#Classe de prédicteur
class MLP(chainer.Chain):
    def __init__(self):
        super(MLP, self).__init__(
            l1=L.Linear(784, 100),
            l2=L.Linear(100, 100),
            l3=L.Linear(100, 10),
        )
    
    def __call__(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        y = self.l3(h2)
        return y
    
#Calculer la perte et la précision
class Classifier(chainer.Chain):
    def __init__(self, predictor):
        super(Classifier, self).__init__(predictor=predictor)
        
    def __call__(self, x, t):
        y = self.predictor(x)
        self.loss = F.softmax_cross_entropy(y, t)
        self.accuracy = F.accuracy(y, t)
        return self.loss

model = Classifier(MLP())
optimizer = optimizers.SGD()
optimizer.setup(model)

batchsize = 100
datasize = 50000
for epoch in range(20):
    print('epoch %d' % epoch)
    indexes = np.random.permutation(datasize)
    for i in range(0, datasize, batchsize):
        x = Variable(x_train[indexes[i : i + batchsize]])
        t = Variable(y_train[indexes[i : i + batchsize]])
        optimizer.update(model, x, t)

Utiliser les résultats d'apprentissage

(Personnellement, je pense que cet appareil est important.)

WhatMnist.py


n = 10
x = Variable(x_test[n:n+1])
v = model.predictor(x)
plt.imshow(x_test[n:n+1].reshape((28,28)), cmap = cm.Greys_r)
print(np.argmax(v.data))

0 show.png

en conclusion

Il y a longtemps, lorsque la vague du Deep Learning est arrivée. Lorsque je faisais de l'apprentissage automatique en détail, en tant qu'étudiant diplômé de petits poissons, j'avais tendance à me concentrer sur les algorithmes et le codage, et souvent perdu de vue la nature des données elles-mêmes. À mesure que la quantité augmente, il devient nécessaire d'observer des choses difficiles à observer et la compréhension des propriétés affecte grandement les performances. ** Si vous vous perdez, regardez les données. ** **

** Maintenant, au-delà du tutoriel **

Recommended Posts

L'apprentissage en profondeur! L'histoire des données elles-mêmes qui sont lues lorsqu'elles ne suivent pas après la reconnaissance des nombres manuscrits
Il semble que la version de pyflakes ne soit pas la dernière lorsque flake8 est installé
Une histoire qui vire au bleu lorsque les données lues par Pillow sont converties pour pouvoir être gérées par OpenCV
Lors de l'incrémentation de la valeur d'une clé qui n'existe pas
[Vérification] Ce n'est pas parce qu'il existe un apprentissage en profondeur que le taux de récupération peut facilement dépasser 100% dans les courses de chevaux.
L'histoire du travail de sortie de l'application que Google ne raconte pas
Juger si c'est mon enfant à partir de l'image du chien Shiba par apprentissage en profondeur (2) Augmentation des données / transfert d'apprentissage / réglage fin
L'histoire de l'apprentissage profond avec TPU
On dit que libmysqlclient.so.18 n'existe pas
C'est une histoire de ferroutage sur le service qui renvoie "Nyan" lorsque vous appuyez sur ping
[Python Data Frame] Lorsque la valeur est vide, remplissez-la avec la valeur d'une autre colonne.
Comptez le nombre de paramètres dans le modèle d'apprentissage en profondeur
À en juger par l'image du chien Shiba en apprenant en profondeur si c'est mon enfant (1)
À propos du problème que nosetests ne passe pas lorsque __init__.py est créé dans le répertoire du projet
L'histoire selon laquelle pyenv n'a pas passé la commande d'exécution python PATH
TensorFlow change-t-il l'image de l'apprentissage profond? Ce que j'ai pensé après avoir touché un peu
Grep pour que grep n'apparaisse pas au moment de grep
Une histoire qui a vérifié si le nombre de coronas augmente vraiment rapidement chez les jeunes
Pourquoi le nombre à virgule flottante de 0,1 est-il supérieur à 0,1, mais lorsqu'il est ajouté 10 fois, il est inférieur à 1,0 [Partie 1]
Pourquoi le nombre à virgule flottante de 0,1 est-il supérieur à 0,1, mais lorsqu'il est ajouté 10 fois, il est inférieur à 1,0 [Partie 2]