Letztes Mal implementierte ein mehrschichtiges Perzeptron mit vollem Kratzer und versuchte, CAPTCHA-Bilder zu erkennen. Dieses Mal werde ich dasselbe mit "Chainer" versuchen.

Sie können auch ein mehrschichtiges Perzeptron mit "scikit-neuralnetwork" implementieren. Diese Überprüfung ist jedoch eine weitere Möglichkeit.

Agenda

Implementierungscode
Probieren Sie es aus
Zusammenfassung
Referenzen

0. Implementierungscode

Verwenden Sie unten nur einen Python-Code. Die Codemenge ist im Vergleich zur vorherigen Zeit sehr gering.

`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

#Trainingsdaten laden
def train_data_read(file_path):
        #Trainingsdaten(MNIST handgeschriebene Zeichen)Straße
        f = gzip.open(file_path, 'rb')
        train, valid, test = pickle.load(f)
        f.close()

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

#neurales Netzwerk(Mehrschichtiges Perceptron)wird bearbeitet
def forward(x_data, y_data, train=True):
    x = Variable(x_data)
    t = Variable(y_data)

    #Normalisierte lineare Funktion zur Aktivierungsfunktion(ReLU)verwenden
    #Verwenden Sie Aussetzer, um die Generalisierungsleistung zu verbessern
    h1 = F.dropout(F.relu(model.l1(x)),  train=train)
    h2 = F.dropout(F.relu(model.l2(h1)), train=train)
    y = model.l3(h2)

    #Verwenden Sie die Kreuzentropie für die Fehlerfunktion
    return F.softmax_cross_entropy(y, t)

#Datenvorhersage
def predict(x_test):
    x = Variable(x_test)

    #Normalisierte lineare Funktion zur Aktivierungsfunktion(ReLU)verwenden
    #Verwenden Sie Aussetzer, um die Generalisierungsleistung zu verbessern
    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__":
    #Definieren Sie den Dateipfad, in dem das zu identifizierende CAPTCHA-Bild gespeichert ist
    captcha_path = 'C:\MNIST\captcha\captcha0'

    #Trainingsdaten(MNIST)Definieren Sie den Dateipfad von
    train_data_path = os.path.join('C:\\MNIST', 'mnist.pkl.gz')

    #Definition des richtigen Etiketts(Zur Ergebnisanzeige)
    answerLabel = [0, 1, 4, 6, 7, 9]

    #Voraussichtliche Daten(CAPTCHA Bild)Erhalten
    #Konvertieren Sie Bilddaten in einen 784-dimensionalen Vektor
    #Extrahieren Sie für jedes RGB nur R-Elemente aus dem Array(Dimensionsreduzierung)
    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)

    #Erfassung von Trainingsdaten
    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)

    #Aufbau eines neuronalen Netzwerks
    #Eingabeebene = 784(28*28), Zwischenschicht = 300, Ausgangsschicht = 10(0～9)
    model = FunctionSet(l1=F.Linear(784, 300),
                        l2=F.Linear(300, 300),
                        l3=F.Linear(300, 10))

    #Probabilistische Gradientenabstiegsmethode(SGD)Stapelgröße beim Lernen mit
    #Es wird oft auf ungefähr 10 bis 100 eingestellt, aber das beste Ergebnis wurde auf 100 eingestellt.
    batchsize = 100

    #Anzahl der Wiederholungen des Lernens
    #Die Genauigkeit beträgt 95 nach 5-maligem Lernen%Da es das Limit überschritten hat, wurde es auf das 5-fache eingestellt.
    learning_loop = 5

    #SGD-Einstellungen
    optimizer = optimizers.Adam()
    optimizer.setup(model.collect_parameters())

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

        #Randomisieren Sie die Reihenfolge der Trainingsdaten
        perm = np.random.permutation(N)

        #Lernen Sie Daten von 0 bis N, indem Sie sie in Stapelgrößen unterteilen
        for i in range(0, N, batchsize):
            x_batch = x_train[perm[i:i+batchsize]]
            y_batch = y_train[perm[i:i+batchsize]]

            #Gewichtsinitialisierung
            optimizer.zero_grads()

            #Feed forward und berechnen Sie den Fehler
            error = forward(x_batch, y_batch)

            #Berechnen Sie den Gradienten mit Rückausbreitung
            error.backward()

            #Gewicht aktualisieren
            optimizer.update()

    #CAPTCHA-Datenprognose
    ok = 0
    for i in range(len(analize_data)):
        #Lesen Sie die Erkennungszieldaten nacheinander
        x = analize_data[i].astype(np.float32)

        #Lesen Sie die richtigen Antwortdaten, um sie nacheinander zu erkennen
        y = answerLabel[i]

        #CAPTCHA-Datenprognose
        answer = predict(x)

        #Standardausgabe des vorhergesagten Werts und der korrekten Antwortdaten
        print("No.{0:d} : predict => {1:d} , answer = > {2:d}".format(i, answer, int(y)))

        #Wenn der vorhergesagte Wert und die richtigen Antwortdaten übereinstimmen, ist dies in Ordnung(Richtige Antwort)Wird um 1 erhöht
        if int(y) == answer:
            ok += 1

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

Techniken wie Vorwärtskopplung, Rückwärtsausbreitung, stochastischer Gradientenabstieg (SGD) und Ausfall können mit sehr einfachem Code erreicht werden.

Was für eine wundervolle Bibliothek!

1. Probieren Sie es aus

Verwenden wir dies, um CAPTCHA sofort zu erkennen.

Zunächst einmal von nun an.

`1. Vorhersageergebnis`


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%

Die richtige Antwortrate beträgt 100%. Dies ist das gleiche wie beim letzten Mal.

Als nächstes kommt der zweite.

`Zweites Vorhersageergebnis`


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%

Die richtige Antwortrate beträgt 50%. Das letzte Mal waren es 33,33%, also können Sie sehen, dass es sich verbessert hat.

2. Zusammenfassung

Ich habe versucht, ein numerisches Bild mit Chainer zu erkennen. Die richtige Antwortrate hat sich gegenüber dem vorherigen Mal verbessert.

Es scheint, dass die richtige Antwortrate weiter zunimmt, wenn die Anzahl der Lernvorgänge erhöht wird, aber wie ich letztes Mal geschrieben habe, wird dies keine grundlegende Lösung sein, wenn die Lerndaten nicht erstellt werden.

Vielmehr sollte bei dieser Überprüfung beachtet werden, dass das mehrschichtige Perceptron mit sehr einfachem Code implementiert und die Genauigkeitsrate verbessert werden könnte.

In Zukunft werden wir Neuroevolution mit Chainer und Deap implementieren und versuchen, einen automatischen Crawler für Webanwendungen zu entwickeln.

3. Referenzen

Deep Learning
Maschinelles Lernen Ich werde es erklären, während ich das Deep Learning Framework Chainer ausprobiere. ](Http://qiita.com/kenmatsu4/items/7b8d24d4c5144a686412)
Chainer Official Document

das ist alles

[PYTHON] Maschinelles Lernen x Webanwendungsdiagnose: Erkennen von CAPTCHA mit mehrschichtigem Perzeptron (Chainer Edition)