[PYTHON] Fordern Sie die Bildklassifizierung mit TensorFlow2 + Keras 2 heraus ~ Schauen wir uns die Eingabedaten genauer an ~

Einführung

Versuchen wir, ** die Klassifizierung handgeschriebener numerischer Bilder (MNIST) ** mit ** TensorFlow2 + Keras ** in der Google Colaboratory-Umgebung (+ vertiefendes Verständnis von Python und tiefes Lernen). Letztes Mal enthält Beispielcode aus TensorFlows Offiziellem HP Tutorial Ich kam zu dem Punkt, an dem ich es tatsächlich versuchte.

• Herausforderung der Bildklassifizierung nach TensorFlow2 + Keras-Serien
• 1. Vorerst verschieben
• 2. Sehen Sie sich die Eingabedaten genauer an
• 3. MNIST-Daten visualisieren
• 4. Sagen wir mit dem trainierten Modell voraus
• 5. Bilder beobachten, die nicht klassifiziert werden können
• 6. Versuchen Sie, von Ihnen selbst erstellte Bilder vorzuverarbeiten und zu klassifizieren
• 7. Layertypen und Aktivierungsfunktionen verstehen
• 8. Optimierungsalgorithmus und Verlustfunktion auswählen
• 9. Versuchen Sie, das Modell zu lernen, zu speichern und zu laden

Laut "Illustrated Rapid Learning DEEP LEARNING (Autor: Tomoaki Masuda)" hat ** MNIST ** die folgenden Ursprünge. Obwohl hier nicht direkt verwandt, sind die Rohdaten unter http://yann.lecun.com/exdb/mnist/ verfügbar.

Einer der NISTs (Datenbank des National Institute of Standards and Technology) verfügte über einen Datensatz mit handgeschriebenen Nummern von Mitarbeitern des US Census Bureau und Schülern. "M" NIST ist eine modifizierte Version davon, die beim maschinellen Lernen einfacher zu verwenden ist.

Dieses Mal werden wir den Inhalt von ** Trainingsdaten ** (x_train, y_train) und ** Testdaten ** (x_test, y_test) in dem zuletzt gezeigten Beispielcode erläutern. Schauen Sie genauer hin oder verwenden Sie matplotlib, um es zu visualisieren.

Zunächst werde ich "** Klassifizierungsproblem für mehrere Klassen " und " Deep Learning **" organisieren (Bestätigung der Positionierung von Trainingsdaten und Testdaten).

Problem der Klassifizierung mehrerer Klassen

Das Erkennen handgeschriebener Zahlen gehört zum ** Mehrklassenklassifizierungsproblem **. Das Mehrklassenklassifizierungsproblem ist das Problem der Vorhersage der ** Kategorie (Klasse) der Eingabedaten **. Die Kategorien werden im Voraus wie "Hund", "Katze", "Vogel" in der Problemeinstellung ** angegeben, und für die Eingabedaten (z. B. Bild) ist dies "Hund", "Katze", "Vogel". Von diesen besteht das Problem darin, herauszufinden, zu welcher Kategorie es gehört.

Für das Klassifizierungsproblem mehrerer Klassen wurden verschiedene Ansätze vorgeschlagen, aber hier werden wir es mit ** Deep Learning ** (Deep Learning) lösen.

Tiefes Lernen

Deep Learning gehört zu einer Technik namens ** überwachtes maschinelles Lernen **. Überwachtes maschinelles Lernen besteht grob aus ** 2 Stufen **, die als "Lernphase" und "Vorhersagephase (Inferenzphase, Anwendungsphase)" bezeichnet werden.

Zunächst wird in der ** Lernphase ** eine große Anzahl von Paaren von ** Eingabedaten ** und ** korrekten Antwortdaten ** (= Lehrerdaten, korrekte Antwortdaten, korrekter Antwortwert, korrektes Antwortetikett) an das Modell übergeben. Lassen Sie sie ihre Beziehungen lernen. Der Paarsatz dieser Eingabedaten und korrekten Antwortdaten wird als ** Trainingsdaten ** (= Trainingsdaten) bezeichnet. Das anhand der Trainingsdaten trainierte Modell heißt "** trainiertes Modell **".

In der nachfolgenden ** Vorhersagephase ** werden dem trainierten Modell ** unbekannte Eingabedaten ** zur ** Vorhersage der Ausgabe ** (Vorhersage) gegeben. Bei Problemen mit mehreren Klassen ist die Kategorie (z. B. "Hund") die prädiktive Ausgabe.

Der Prozess von ** Evaluieren ** besteht dann darin, zu messen, "wie viel Leistung das trainierte Modell hat". Bei der Auswertung werden zunächst ** Eingabedaten und korrekte Antwortdaten, die sich von den für das Training verwendeten unterscheiden, vorbereitet, und von diesen werden nur die Eingabedaten ** an das trainierte Modell übergeben, um Vorhersagedaten zu erhalten. Beantworten Sie dann die erhaltenen Vorhersagedaten mit den richtigen Antwortdaten, bewerten Sie sie und verwenden Sie sie als Bewertungswert. Als spezifische Bewertungsindizes stehen zusätzlich zu der ** korrekten Antwortrate ** (Genauigkeit) und dem ** Verlustfunktionswert ** (Verlust), die beim letzten Mal aufgetreten sind, verschiedene Dinge wie die Präzisionsrate und die Rückrufrate nach Bedarf zur Verfügung. Wird angenommen.

MNIST-Trainingsdaten, Testdaten

Der folgende Code lädt die MNIST-Daten herunter und speichert sie in jeder Variablen ("x_train", "y_train", "x_test", "y_test") (das gesamte Programm war [vorher](https: // qiita). Siehe com / code0327 / items / 7d3c7bd3327ff049243a)).

python

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

Hier ist "* _train" die Eingabe- und korrekten Antwortdaten, die für das Training (zum Lernen) zugewiesen wurden, und "* _test" sind die Eingabe- und korrekten Antwortdaten, die für das Testen (für die Modellbewertung) zugewiesen wurden. Es gibt 60.000 für Schulungen und 10.000 für Tests.

Außerdem sind "x _ ***" die Eingabedaten (dh Daten, die ein handgeschriebenes Bild darstellen: Graustufen mit 256 Schritten von 28 x 28), und "y _ ***" sind die richtigen Antwortdaten (Kategorie von "0" bis "9"). Wird in einem Array gespeichert.

Lassen Sie uns zunächst mit len () prüfen, ob jeder von ihnen tatsächlich aus 60.000 und 10.000 Daten besteht.

python

#Trainingsdaten
print(len(x_train))  #Ausführungsergebnis-> 60000
print(len(y_train))  #Ausführungsergebnis-> 60000
#Testdaten
print(len(x_test))   #Ausführungsergebnis-> 10000
print(len(y_test))   #Ausführungsergebnis-> 10000

Als nächstes überprüfen wir den ** Typ ** jeder Daten.

python

print(type(x_train)) #Ausführungsergebnis-> <class 'numpy.ndarray'>
print(type(y_train)) #Ausführungsergebnis-> <class 'numpy.ndarray'>
print(type(x_test))  #Ausführungsergebnis-> <class 'numpy.ndarray'>
print(type(y_test))  #Ausführungsergebnis-> <class 'numpy.ndarray'>

Als nächstes überprüfen wir den Inhalt von y_train (= korrekte Antwortdaten für das Training).

python

print(y_train) #Ausführungsergebnis-> [5 0 4 ... 5 6 8]

Es wurde festgestellt, dass der korrekte Antwortwert der 0. Daten "5" ist, der korrekte Antwortwert der 1. Daten "0" ist und der korrekte Antwortwert der 59.999sten Daten "8" ist.

Als nächstes überprüfen wir den Inhalt von x_train (= repräsentiert ein handgeschriebenes Bild für das Training). Das Anzeigen aller Elemente wäre lächerlich, daher wird nur das erste "x_train [0]" als Ziel ausgewählt.

python

(x_train, y_train), (x_test, y_test) = mnist.load_data()
print(x_train[0].shape) #Ausführungsergebnis-> (28, 28)
print(x_train[0])       #Ausführungsergebnis->Siehe unten

Sie können die Größe der Daten in numpy.ndarray mit .shape überprüfen. (28, 28), was bedeutet, dass x_train [0] aus ** 28 Zeilen und 28 Spalten zweidimensionalem Array ** besteht. Außerdem sieht die Ausgabe von print (x_train [0]) folgendermaßen aus:

Wenn Sie es mit einem hellen Auge betrachten, können Sie die leicht verzerrte handschriftliche Zahl "5" sehen. Dies entspricht der in "y_train [0]" gespeicherten "5".

Sie können sehen, dass alle Pixeldaten aus ** Werten im Bereich ** 0 bis 255 bestehen, wobei 0 der Hintergrund (weiß) und 255 der dunkelste Text (schwarz) ist.

Ich möchte es auf alle 60.000 Daten überprüfen.

python

import numpy as np
print(x_train.min())  #Extrahieren Sie den Mindestwert#Ausführungsergebnis-> 0
print(x_train.max())  #Maximalwert extrahieren#Ausführungsergebnis-> 255

Sie können sehen, dass alle Daten aus dem Bereich 0-255 bestehen.

Wie viele Zahlen von "0" bis "9" sind übrigens in den 60.000 Trainingsdaten vorhanden? Grundsätzlich denke ich, dass 10 Muster von 0 bis 9 fast gleichmäßig existieren, aber lassen Sie uns das überprüfen. Verwenden Sie Pandas für die Aggregation.

Pandas Version

import pandas as pd

tmp = pd.DataFrame({'label':y_train})
tmp = tmp.groupby(by='label').size()
display(tmp)
print(f'Gesamtzahl={tmp.sum()}')

Ausführungsergebnis

label
0    5923
1    6742
2    5958
3    6131
4    5842
5    5421
6    5918
7    6265
8    5851
9    5949
dtype: int64
Gesamtzahl=60000

Es scheint einige Variationen zu geben, wie weniger "5" und mehr "1".

Sie können es ohne Pandas wie folgt finden.

numpy Version

import numpy as np
tmp = list([np.count_nonzero(y_train==p) for p in range(10)])
print(tmp)                #Ausführungsergebnis-> [5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]
print(f'Gesamtzahl={sum(tmp)}') #Ausführungsergebnis-> Gesamtzahl=60000

nächstes Mal

• Ich wollte so weit gehen, die Eingabedaten mit matplotlib grafisch darzustellen, aber der Artikel ist lang geworden, deshalb würde ich das gerne beim nächsten Mal tun.