[PYTHON] Introduction au Deep Learning pour la première fois (Chainer) Reconnaissance de caractères japonais Chapitre 2 [Génération de modèles par apprentissage automatique]

Bonjour Licht. Suivant ici, Tutoriel Deep Learning Chapitre 2 Décrit la génération d'un modèle de prédiction Deep Learning par machine learning. J'expliquerai comment le réseau neuronal effectue spécifiquement l'apprentissage automatique dans un chapitre ultérieur. Ici, nous allons introduire une utilisation pratique.

Préparation

Tout d'abord, téléchargez le code source de ce Github et placez le tout sous hiraganaNN.py dans le même répertoire que l'ensemble de données d'image précédent. Le chapitre 2 utilise hiraganaNN.py, dataArgs.py, hiragana_unicode.csv.

Courir

Après avoir déplacé vers le répertoire HIRAGANA_NN dans le terminal (invite de commande)

python hiraganaNN.py

Commencer avec.

Cela va démarrer l'apprentissage automatique avec Deep Learning, mais cela prendra du temps à apprendre, donc je vais vous expliquer un peu en attendant. Dans le répertoire HIRAGANA_NN, des images (110 * 110 pixels) divisées en répertoires sont stockées pour chaque plat et pseudonyme. Par exemple, dans le répertoire 305e, les images du pseudonyme plat "Zo" sont enregistrées dans diverses polices et manuscrites comme suit.

Quel est le but de l'apprentissage automatique en général, à partir de diverses images «zo»? C'est une tentative pour apprendre cela. En d'autres termes, ce sont "zo" (apprentissage)

C'est "Zo", n'est-ce pas? Je veux faire quelque chose (appelé identification / prédiction / reconnaissance).

Cela semble facile, mais comme la machine est simple, nous faisons des erreurs auxquelles les humains ne s'attendraient pas. Par exemple, j'ai appris "Zo" ci-dessus. Donc le fond n'est pas "Zo"! Kippari

(Parce qu'il est un peu incliné) Les erreurs (détérioration de la polyvalence) dues à un tel apprentissage excessif (autres que les «zo» ci-dessus ne sont pas reconnus comme «zo») sont appelées «surapprentissage». De plus, la détérioration de l'efficacité d'apprentissage, qui rend l'apprentissage difficile dans des endroits qui ne sont pas liés à l'origine à la reconnaissance de la couleur et de la densité des caractères, est également une cause de détérioration des performances.

Effectue un "prétraitement" pour éviter une dégradation des performances telle qu'un surapprentissage et une détérioration de l'efficacité de l'apprentissage. Il existe différents prétraitements, mais l'expansion des données (rotation, mouvement, distorsion élastique, bruit, etc.) (quoi qu'il arrive si vous apprenez différents "zo"!),

Un exemple est la normalisation des données (échelle de gris, blanchiment, normalisation par lots, etc.) qui simplifie le problème et améliore l'efficacité de l'apprentissage.

Aperçu du code source

Dès la première ligne

unicode2number = {}
import csv
train_f = open('./hiragana_unicode.csv', 'rb')
train_reader = csv.reader(train_f)
train_row = train_reader
hiragana_unicode_list = []
counter = 0
for row in train_reader:
    for e in row:
        unicode2number[e] = counter
        counter = counter + 1

Ici, chaque pseudonyme plat est numéroté. Celui avec unicode 304a (o) est le numéro 0, celui avec 304b (ou) est le numéro 1, et ainsi de suite. prochain

files = os.listdir('./')
for file in files:
    if len(file) == 4:
        #Répertoire de pseudonymes plat
        _unicode = file
        imgs = os.listdir('./' + _unicode + '/')
        counter = 0
        for img in imgs:
            if img.find('.png') > -1:
                if len(imgs) - counter != 1:
                ...

Ici, l'image en tant que données d'entrée (données d'apprentissage) est lue. Chargez uniquement la dernière image de chaque répertoire à des fins de test. Lors de la lecture

x_train.append(src)
y_train.append(unicode2number[_unicode])

Les données d'image sont stockées dans x_train (x_test), et l'étiquette de réponse correcte (0-83) est stockée dans y_train (y_test). La partie suivante consiste à agrandir les données pour une image de données d'entrée

for x in xrange(1, 10):
    dst = dargs.argumentation([2, 3])
    ret, dst = cv2.threshold(
        dst, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    x_train.append(dst)
    y_train.append(unicode2number[_unicode])

Ici, il est déplacé et tourné au hasard pour l'étendre à 10 feuilles. Quelques arguments d'arguments ([2, 3]) sont terriblement difficiles à comprendre, mais dans l'ordre 2: rotation (rotation avec une profondeur tridimensionnelle) et 3: mouvement, le processus de mouvement est effectué après le processus de rotation. C'est donné. De chaque annuaire

prochain

x_train = np.array(x_train).astype(np.float32).reshape(
    (len(x_train), 1, IMGSIZE, IMGSIZE)) / 255
y_train = np.array(y_train).astype(np.int32)

L'image en échelle de gris a une valeur de pixel de 0 à 255, mais elle est normalisée à une valeur de 0 à 1 en la divisant par 255. Ce processus améliore l'efficacité de l'apprentissage.

Ce qui précède est la préparation des données d'entraînement (x_train, y_train), mais la préparation du test (x_test, y_test) se fait également de la même manière. Ici, nous allons lire le dernier de chaque répertoire pour le tester et vérifier l'exactitude du modèle entraîné par machine. L'image de test est également agrandie et lue, mais la raison en est écrite autour du chapitre 7.

Ce qui suit est une structure concrète du Deep Learning, donc je résumerai l'explication dans un chapitre ultérieur.

Résultat d'apprentissage

Ce faisant, les progrès de l'apprentissage automatique sont apparus dans le terminal.

('epoch', 1)
COMPUTING...
train mean loss=3.53368299341, accuracy=0.161205981514
test mean loss=1.92266467359, accuracy=0.506097565337
('epoch', 2)
COMPUTING...
train mean loss=1.66657279936, accuracy=0.518463188454
test mean loss=1.0855880198, accuracy=0.701219529277
.
.(Un avertissement apparaîtra, mais vous pouvez l'ignorer pour le moment.)
('epoch', 16)
COMPUTING...
train mean loss=0.198548029516, accuracy=0.932177149753
test mean loss=0.526535278777, accuracy=0.844512195849
.
.
('epoch', 23)
COMPUTING...
train mean loss=0.135178960405, accuracy=0.954375654268
test mean loss=0.686121761981, accuracy=0.814024389154

Considérez la perte comme l'erreur entre la sortie prédite par Deep Learning et la bonne réponse. la précision est le pourcentage de bonnes réponses En apprentissage automatique, l'objectif est de réduire la perte de données de test.

Au fur et à mesure que l'apprentissage progresse, la perte de train et de test diminuera, mais la perte de train diminuera après l'époque 16. Le surapprentissage a tendance à augmenter la perte de test. Lorsque cela se produit, l'apprentissage se termine car c'est la limite. Pour le moment, la perte de test = 0,526 de l'époque 16 donne le meilleur résultat dans ce modèle. (Les efforts pour améliorer cette précision seront discutés dans un chapitre ultérieur)

Étant donné que le résultat d'apprentissage du Deep Learning de chaque époque est enregistré dans le même répertoire que le code source, Enregistrez un fichier appelé «modèle 16» qui a donné les meilleurs résultats. (Vous pouvez supprimer d'autres fichiers de modèle)

Dans le prochain chapitre 3, nous ferons des prédictions réelles en utilisant ce modèle.