[PYTHON] Ich habe versucht, die handschriftliche Zeichenerkennung von Runenzeichen mit CNN mithilfe von Keras zu erkennen

Wie oben erwähnt, in einer eindimensionalen Anordnung Die Pixelinformationen von links oben nach rechts unten im Bild sollten sich in der Ebene befinden. In diesem Fall gehen die vertikalen und horizontalen Informationen des Bildes verloren ...

Verwendung des Convolution Neural Network (CNN)

Auf der anderen Seite, wenn Sie ein sogenanntes Convolutional Neural Network (CNN) verwenden. Ich habe gelernt, dass Sie mit Daten lernen können, die vertikale und horizontale Informationen enthalten! Im Folgenden werde ich die von mir organisierte Gliederung und Implementierungsmethode beschreiben.

Überblick

Faltungs-Neuronales Netz (CNN) Ein neuronales Netzwerk, das im Bereich der Bildverarbeitung verwendet wird ** Das Bild kann unverändert für die Eingabe in zwei Dimensionen verwendet werden **.

Die Hauptidee von CNN lautet: "Imitieren wir die Bewegung von Nervenzellen im Gesichtsfeld des Menschen." Die Methode, die erstellt wurde.

CNN verwendet einen Filter (Kernel), um Features aus einem Bild zu extrahieren. Verwenden Sie einen Filter, der kleiner als das Originalbild ist. Überlagern Sie die Filter in der Reihenfolge oben links im Bild. Berechnen Sie die Summe aus dem Produkt des Bildes und dem Filterwert.

Die aus dem Bild erhaltenen Eigenschaften ändern sich je nachdem, was Sie mit den Filternummern tun. Sie erfahren, welchen Wert der Filter haben sollte.

[Referenz] Sie können den Prozess der Zeichenerkennung von CNN visuell auf der folgenden Site sehen! https://www.cs.ryerson.ca/~aharley/vis/conv/

Implementierungsmethode

Es scheint eine Möglichkeit zu geben, die folgenden zwei Muster zu implementieren!

1. Handmontiert mit Numpy

Dies ist eine Methode zum manuellen Implementieren des Filterberechnungsprozesses von CNN. Es wird in diesem Artikel geübt. https://qiita.com/ta-ka/items/1c588dd0559d1aad9921

2. Verwenden Sie die Keras-Bibliothek

Sie können CNN auch mit Keras implementieren, einer Bibliothek für Deep Learning.

https://keras.io/ja/

Keras ist eine in Python geschriebene übergeordnete neuronale Netzwerkbibliothek, die auf TensorFlow, CNTK oder Theano ausgeführt werden kann. Wenn Sie in den folgenden Fällen eine Deep-Learning-Bibliothek benötigen, verwenden Sie Keras:

• Unterstützt sowohl CNN als auch RNN und Kombinationen dieser beiden

Dieses Mal werde ich versuchen, die 2.Keras-Bibliothek zu verwenden.

Verwendung von Keras

Wenn Sie versuchen, Keras für diesen Zweck zu verwenden, gibt es wahrscheinlich die folgenden Optionen.

• Rufen Sie an und verwenden Sie die eigenständigen Keras direkt --Verwenden Sie Keras, die in TensorFlow enthalten sind

Ab Mai 2020 jedoch das offizielle Handbuch

"Keras wird mit TensorFlow 2.0 als tensorflow.keras geliefert. Um mit Keras zu beginnen, installieren Sie einfach TensorFlow 2.0. "

Es scheint ein Trend zu sein, sich zu "Keras of TensorFlow" zu vereinen. (Zitiert aus dem folgenden Artikel)

[Referenz] Das Ende von Multi-Backend-Keras, vereint in tf.keras https://www.atmarkit.co.jp/ait/articles/2005/13/news017.html

Nach Ablauf der Zeit werde ich dieses Mal Keras von Tensorflow verwenden.

Was wurde verwendet

Also habe ich folgendes verwendet. TensorFlow musste Version 2.0.0 mit erweiterter Integration in Keras verwenden.

--Anaconda: (Ein Paket, das Python selbst und häufig verwendete Bibliotheken enthält)

• TensorFlow : 2.0.0

Verwendete Daten

Lassen Sie uns einmal [vorher] mit den erstellten Bilddaten (24 (Zeichen) x 18 (Blätter)) lernen (https://qiita.com/kondo-a/items/02943c926bc584c40103).

Implementierung

Importieren Sie das zu verwendende Paket

#Paket für die Arbeit mit Arrays
import numpy as np
#Paket zur Verarbeitung von Bilddaten und Dateien
from PIL import Image
import os, glob
# tensorflow
import tensorflow as tf
#Ein praktisches Paket von Keras, das Daten vorverarbeitet
from tensorflow.keras.preprocessing.image import array_to_img, img_to_array, load_img
from keras.utils import np_utils
#Dient zum Trennen von Trainingsdaten und Testdaten
from sklearn.model_selection import train_test_split
#Wird zur Bildanzeige von Trainingsdaten verwendet
import matplotlib.pyplot as plt
#Wird verwendet, um eine Zusammenfassung der Lernergebnisse anzuzeigen
import pandas as pd

Datei lesen

Bereiten Sie eine Reihe von Bildern und Beschriftungen vor, die Sie zum Lernen verwenden möchten. Dieses Mal müssen wir die Bezeichnung jeder Daten numerisch an das Modell von Keras CNN übergeben. Ich habe im Voraus eine Korrespondenztabelle für jedes Runenzeichen und jede Bezeichnung (numerischer Wert) im Wörterbuch erstellt.

runeCharDict = { 0 : 'ᚠ',
               1 : 'ᚢ',
               2 : 'ᚦ',
               3 : 'ᚫ',
               4 : 'ᚱ',
               5 : 'ᚲ',
               6 : 'ᚷ',
               7 : 'ᚹ',
               8 : 'ᚺ',
               9 : 'ᚾ',
               10 : 'ᛁ',
               11 : 'ᛃ',
               12 : 'ᛇ',
               13 : 'ᛈ',
               14 : 'ᛉ',
               15 : 'ᛋ',
               16 : 'ᛏ',
               17 : 'ᛒ',
               18 : 'ᛖ',
               19 : 'ᛗ',
               20 : 'ᛚ',
               21 : 'ᛜ',
               22 : 'ᛞ',
               23 : 'ᛟ',
              }

Laden Sie das Bild.

#Datei lesen
#Array zum Speichern von Bilddaten
X = []
#Zeichen, die Bilddaten entsprechen(Antworten)Array zum Speichern
Y = []

#Trainingsdatenverzeichnisdatei
dir = '[Verzeichnis, in dem Bilddaten handgeschriebener Zeichen gespeichert sind]'
files = glob.glob(dir + "\\*.png ")

#Vertikale und horizontale Größe des Bildes(Pixel)
image_size = 50

#Lesen Sie die Dateien im Verzeichnis und fügen Sie sie der Liste der Trainingsdaten hinzu
for i, file in enumerate(files):
    
    temp_img = load_img(file, target_size=(image_size, image_size))
    temp_img_array  = img_to_array(temp_img)
    X.append(temp_img_array)
    
    moji = file.split("\\")[-1].split("_")[0]
    label = list(runeCharDict.keys())[list(runeCharDict.values()).index(moji)]
    Y.append(label)

X = np.asarray(X)
Y = np.asarray(Y)

#Konvertieren Sie Pixelwerte von 0 in 1
X = X.astype('float32')
X = X / 255.0

#Klassenformat konvertieren
Y = np_utils.to_categorical(Y, 24)

Erstellen Sie ein Modell

Erstellen Sie ein Modell zum Trainieren. Stellen Sie hier die "Faltungsschichteinstellungen (Eingabedatenform, Filtereinstellungen)" und "zu verwendende Aktivierungsfunktion" ein.

Eine ausführliche Erläuterung der einzelnen Elemente wird in diesem Artikel ausführlich beschrieben. Siehe ...!

https://qiita.com/mako0715/items/b6605a77467ac439955b

#Erstellen Sie ein Modell für CNN
model = tf.keras.models.Sequential([
  tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(50, 50, 3)),
  tf.keras.layers.MaxPooling2D(2,2),
  tf.keras.layers.Conv2D(32, (3,3), activation='relu'),
  tf.keras.layers.MaxPooling2D(2,2),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(24, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Lernen

Das Lernen selbst kann einfach durch Aufrufen der Funktion fit () erfolgen.

#Trainingsdaten und Testdaten trennen
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=111)
#Lernen
model.fit(x_train, y_train, epochs=5)

Bei der Ausführung wird eine Zusammenfassung jedes Lernens angezeigt.

Epoch 1/5
246/246 [==============================] - 2s 9ms/sample - loss: 3.1595 - acc: 0.0935
Epoch 2/5
246/246 [==============================] - 2s 9ms/sample - loss: 2.8289 - acc: 0.2317
Epoch 3/5
246/246 [==============================] - 2s 8ms/sample - loss: 2.0306 - acc: 0.4593
Epoch 4/5
246/246 [==============================] - 2s 8ms/sample - loss: 1.0820 - acc: 0.7642
Epoch 5/5
246/246 [==============================] - 2s 9ms/sample - loss: 0.6330 - acc: 0.8333

Wenn Sie sich die Elemente rechts ansehen, sehen Sie den Prozentsatz der richtigen Antworten für das Modell im Training.

--loss: Der Bewertungswert der Verlustfunktion (je niedriger der Wert, desto höher die Genauigkeit der Vorhersage). --acc: Die Genauigkeit der Vorhersage.

Beim ersten Lernen betrug die Genauigkeitsrate etwa 9%, beim fünften Lernen beträgt die Genauigkeit 83%!

Modelltest / Ergebnisanzeige

Lassen Sie das Modell die Validierungsdaten vorhersagen.

#Auf Testdaten anwenden
predict_classes = model.predict_classes(x_test)

mg_df = pd.DataFrame({'predict': predict_classes, 'class': np.argmax(y_test, axis=1)})

#Ausgabe der aktuellen maximalen Anzahl von Anzeigespalten
pd.get_option("display.max_columns")

#Geben Sie die maximale Anzahl von Anzeigespalten an (hier werden 50 Spalten angegeben).
pd.set_option('display.max_columns', 50)

# confusion matrix
pd.crosstab(mg_df['class'], mg_df['predict'])

Erstellen Sie eine Verwirrungsmatrix, indem Sie die Richtigkeit der Vorhersage der Testdaten berücksichtigen.

Die gemischte Matrix ist eine Kombinationstabelle aus "Istwert \ Vorhersagewert des Modells". Die Anzahl der richtigen Antworten ist der Schnittpunkt von Zeilen und Spalten derselben Anzahl.

Ergebnis

Die richtige Antwort ist die Mehrheit! Danach können Sie sehen, dass es viele falsche Antworten mit dem Buchstaben "ᛒ" gibt, der Nummer 17 in der Ergebnistabelle ist. Wenn Sie den Prozentsatz der richtigen Antworten wirklich erhöhen möchten, können Sie die "ᛒ" -Daten überprüfen oder erhöhen.

Aufgeblasene Daten

Ich habe das Gefühl, dass es nur wenige Trainingsdaten gibt, daher werde ich das handschriftliche Zeichenbild verarbeiten, um die Trainingsdaten zu erhöhen. Dieses Mal konnte ich die Zeichendaten mit einem Vorverarbeitungspaket namens keras_preprocessing problemlos drehen. Das wird auch zu den Daten hinzugefügt.

#Keras hinter den Kulissen von Keras verwendet_preprocessing
from keras_preprocessing.image import apply_affine_transform

#Datei lesen
#Array zum Speichern von Bilddaten
X = []
#Zeichen, die Bilddaten entsprechen(Antworten)Array zum Speichern
Y = []

#Datei lesen(Wie oben erwähnt)

#Lesen Sie die Dateien im Verzeichnis und fügen Sie sie der Liste der Trainingsdaten hinzu
for i, file in enumerate(files):
    
    #Registrieren Sie die Originaldaten(Wie oben erwähnt)
    
    #Aufgeblasene Daten
    image  = img_to_array(temp_img)
        
    #1. 1. 10 Grad im Uhrzeigersinn drehen "Theta"=Geben Sie die Frequenz an, mit der gedreht werden soll
    image1 = apply_affine_transform(image, channel_axis=2, theta=10, fill_mode="nearest", cval=0.)
    X.append(image1)
    Y.append(label)

    #2. 10 Grad gegen den Uhrzeigersinn drehen
    image2 = apply_affine_transform(image, channel_axis=2, theta=-10, fill_mode="nearest", cval=0.)
    X.append(image2)
    Y.append(label)
    
    # #3. 3. 20 Grad im Uhrzeigersinn drehen
    image3 = apply_affine_transform(image, channel_axis=2, theta=20, fill_mode="nearest", cval=0.)
    X.append(image3)
    Y.append(label)
    
    #4. 20 Grad gegen den Uhrzeigersinn drehen
    image4 = apply_affine_transform(image, channel_axis=2, theta=-20, fill_mode="nearest", cval=0.)
    X.append(image4)
    Y.append(label)

Es war so einfach! !! Insbesondere da die durch Rotation erzeugten Ränder ergänzt werden, Der Hintergrund wird nicht schwarz. Ist es nicht wirklich praktisch ...?

Lernergebnis

Lassen Sie uns noch einmal lernen, indem Sie die Daten hinzufügen, die durch Drehen des Originalbilds vergrößert wurden.

Epoch 1/5
1232/1232 [==============================] - 7s 6ms/sample - loss: 23.2898 - accuracy: 0.1144
Epoch 2/5
1232/1232 [==============================] - 7s 6ms/sample - loss: 1.1991 - accuracy: 0.6396
Epoch 3/5
1232/1232 [==============================] - 7s 5ms/sample - loss: 0.3489 - accuracy: 0.8847
Epoch 4/5
1232/1232 [==============================] - 7s 5ms/sample - loss: 0.1527 - accuracy: 0.9456
Epoch 5/5
1232/1232 [==============================] - 6s 5ms/sample - loss: 0.0839 - accuracy: 0.9740

Das Modell kann jetzt genauer sein als bei einer geringen Datenmenge! (97%)

Am Ende

Bisher haben wir den Ablauf der Verwendung eines Faltungsnetzwerks mit Keras in Python beschrieben.

Was ich dachte

――Wir konnten nicht genau dieselben Daten vergleichen, aber wir haben festgestellt, dass die Verwendung von CNN eine höhere Genauigkeit bietet als das vorherige grundlegende neuronale Netzwerk. ―― Insgesamt gab es bei Verwendung der Tensorflow- und Keras-Bibliotheken viele Stellen, an denen Sie bei der Vorverarbeitung und Anzeige von Lern- / Vorhersageergebnissen klarer als beim letzten Mal Code schreiben konnten! ――Ich möchte den Montageort noch einmal mit einem flauschigen Verständnis untersuchen und verstehen.

Ich hoffe, dieser Artikel ist hilfreich für Sie.

Endlich tut es mir leid, dass ich völlig spät dran war! Ich bin froh, dass ich an der Sommer-Anzeigenpflege teilnehmen konnte, danke.