La dernière fois a implémenté un perceptron multicouche avec un scratch complet et a essayé de reconnaître les images CAPTCHA. Cette fois, je vais essayer la même chose en utilisant "Chainer".

Vous pouvez également implémenter un perceptron multicouche avec "scikit-neuralnetwork", mais cette vérification sera une autre opportunité.

ordre du jour

Code de mise en œuvre
Essayez-le
Résumé
Références

0. Code de mise en œuvre

N'utilisez qu'un seul code Python ci-dessous. La quantité de code est très faible par rapport à la fois précédente.

`mlp.py`


#!/usr/bin/env python
#coding:utf-8
import os
import gzip, pickle
import pylab
import numpy as np
from chainer import Variable, FunctionSet, optimizers
import chainer.functions as F

#Chargement des données d'entraînement
def train_data_read(file_path):
        #Données d'entraînement(Caractères manuscrits MNIST)Route
        f = gzip.open(file_path, 'rb')
        train, valid, test = pickle.load(f)
        f.close()

        return (train[0], train[1], train[0].shape[0])

#réseau neuronal(Perceptron multicouche)En traitement
def forward(x_data, y_data, train=True):
    x = Variable(x_data)
    t = Variable(y_data)

    #Fonction linéaire normalisée en fonction d'activation(ReLU)utilisation
    #Utilisez les abandons pour améliorer les performances de généralisation
    h1 = F.dropout(F.relu(model.l1(x)),  train=train)
    h2 = F.dropout(F.relu(model.l2(h1)), train=train)
    y = model.l3(h2)

    #Utiliser l'entropie croisée pour la fonction d'erreur
    return F.softmax_cross_entropy(y, t)

#Prédiction de données
def predict(x_test):
    x = Variable(x_test)

    #Fonction linéaire normalisée en fonction d'activation(ReLU)utilisation
    #Utilisez les abandons pour améliorer les performances de généralisation
    h1 = F.dropout(F.relu(model.l1(x)))
    h2 = F.dropout(F.relu(model.l2(h1)))
    y = model.l3(h2)

    return np.argmax(y.data)

if __name__ == "__main__":
    #Définir le chemin du fichier où l'image CAPTCHA à identifier est stockée
    captcha_path = 'C:\MNIST\captcha\captcha0'

    #Données d'entraînement(MNIST)Définissez le chemin du fichier de
    train_data_path = os.path.join('C:\\MNIST', 'mnist.pkl.gz')

    #Définition de l'étiquette correcte(Pour l'affichage des résultats)
    answerLabel = [0, 1, 4, 6, 7, 9]

    #Données prédites(Image CAPTCHA)Avoir
    #Convertir les données d'image en vecteur de 784 dimensions
    #Extraire uniquement les éléments R du tableau pour chaque RVB(Réduction de dimension)
    img_captcha = []
    analize_data = []
    captcha_files = os.listdir(captcha_path)
    for file in captcha_files:
        img_captcha = pylab.imread(os.path.join(captcha_path,file))
        img_captcha_r = img_captcha[:, :, 0]
        #img_captcha_r = img_captcha[:, :]
        img_captcha_Array = np.asarray(img_captcha_r)
        d_captcha = img_captcha_Array.shape[0] * img_captcha_Array.shape[1]
        img_captcha_wide = img_captcha_Array.reshape(1, d_captcha)
        analize_data.append(img_captcha_wide)

    #Acquisition de données d'entraînement
    x_train, y_train, length = train_data_read(train_data_path)
    x_train = x_train.astype(np.float32)
    y_train = y_train.astype(np.int32)

    #Construire un réseau de neurones
    #Couche d'entrée = 784(28*28), Couche intermédiaire = 300, couche de sortie = 10(0～9)
    model = FunctionSet(l1=F.Linear(784, 300),
                        l2=F.Linear(300, 300),
                        l3=F.Linear(300, 10))

    #Méthode de descente de gradient probabiliste(SGD)Taille du lot lors de l'apprentissage avec
    #Il est souvent défini entre 10 et 100, mais le meilleur résultat a été défini sur 100.
    batchsize = 100

    #Nombre de répétitions d'apprentissage
    #La précision est de 95 après avoir appris 5 fois%Puisqu'il a dépassé la limite, il a été fixé à 5 fois.
    learning_loop = 5

    #Paramètres SGD
    optimizer = optimizers.Adam()
    optimizer.setup(model.collect_parameters())

    #Apprentissage
    N = 50000
    for epoch in range(1, learning_loop+1):

        #Randomiser l'ordre des données d'entraînement
        perm = np.random.permutation(N)

        #Apprenez les données de 0 à N en les divisant en tailles de lots
        for i in range(0, N, batchsize):
            x_batch = x_train[perm[i:i+batchsize]]
            y_batch = y_train[perm[i:i+batchsize]]

            #Initialisation du poids
            optimizer.zero_grads()

            #Avancez et calculez l'erreur
            error = forward(x_batch, y_batch)

            #Calculer le gradient avec propagation arrière
            error.backward()

            #Mettre à jour le poids
            optimizer.update()

    #Prévisions des données CAPTCHA
    ok = 0
    for i in range(len(analize_data)):
        #Lire les données de la cible de reconnaissance une par une
        x = analize_data[i].astype(np.float32)

        #Lisez les bonnes réponses pour être reconnues une par une
        y = answerLabel[i]

        #Prévisions des données CAPTCHA
        answer = predict(x)

        #Sortie standard de la valeur prédite et des données de réponse correctes
        print("No.{0:d} : predict => {1:d} , answer = > {2:d}".format(i, answer, int(y)))

        #Si la valeur prédite et les données de réponse correctes correspondent, ok(Bonne réponse)Est incrémenté de 1
        if int(y) == answer:
            ok += 1

    # ok(Bonne réponse)の数と認識対象データ数を基にBonne réponse率を標準出力する
    print("{0:05d} / {1:05d} = {2:3.2f}%".format(ok, len(analize_data), 100*ok/len(analize_data)))

Des techniques telles que la rétroaction, la propagation en arrière, la descente de gradient stochastique (SGD) et l'abandon peuvent être réalisées avec un code très simple.

Quelle merveilleuse bibliothèque!

1. Essayez-le

Utilisons ceci pour reconnaître immédiatement CAPTCHA.

Tout d'abord, à partir de maintenant.

`1er résultat de prédiction`


No.0 : predict => 0 , answer = > 0
No.1 : predict => 1 , answer = > 1
No.2 : predict => 4 , answer = > 4
No.3 : predict => 6 , answer = > 6
No.4 : predict => 7 , answer = > 7
No.5 : predict => 9 , answer = > 9
00006 / 00006 = 100.00%

Le taux de réponse correcte est de 100%. C'est la même chose que la dernière fois.

Vient ensuite le deuxième.

`Deuxième résultat de prédiction`


No.0 : predict => 0 , answer = > 0
No.1 : predict => 1 , answer = > 1
No.2 : predict => 6 , answer = > 4
No.3 : predict => 8 , answer = > 6
No.4 : predict => 8 , answer = > 7
No.5 : predict => 9 , answer = > 9
00003 / 00006 = 50.00%

Le taux de réponse correcte est de 50%. La dernière fois, il était de 33,33%, vous pouvez donc voir qu'il s'est amélioré.

2. Résumé

J'ai essayé de reconnaître une image numérique en utilisant Chainer. Le taux de réponse correcte s'est amélioré par rapport à la fois précédente.

Il semble que le taux de réponse correcte augmentera encore si le nombre d'apprentissage est augmenté, mais comme je l'ai écrit la dernière fois, ce ne sera pas une solution fondamentale à moins que les données d'apprentissage ne soient conçues.

Au contraire, ce qu'il convient de noter dans cette vérification est que le Perceptron multicouche pourrait être implémenté avec un code très simple, et le taux de précision pourrait être amélioré.

Dans le futur, nous allons implémenter Neuroevolution en utilisant Chainer et Deap et essayer de développer un robot d'exploration automatique pour les applications Web.

3. Références

c'est tout

Apprentissage automatique x diagnostic d'application Web: Reconnaître CAPTCHA avec perceptron multicouche (édition Chainer)