Alai

Einführung

„Ein Deep-Learning-Modell in ein paar Minuten erstellen? Es wird Stunden dauern, es zu trainieren! Ich habe nicht einmal eine ausreichend gute Maschine.“ Das habe ich unzählige Male von angehenden Datenwissenschaftlern gehört, die davor zurückschrecken, Deep-Learning-Modelle auf ihren eigenen Maschinen zu erstellen.

Sie müssen nicht für Google oder andere große Technologieunternehmen arbeiten, um an Deep-Learning-Datensätzen zu arbeiten! Es ist durchaus möglich, innerhalb weniger Minuten ein eigenes neuronales Netzwerk aufzubauen, ohne die Server von Google mieten zu müssen. Die Studenten von Fast.ai haben ein Modell für den Imagenet-Datensatz in 18 Minuten erstellt – und ich werde in diesem Artikel etwas Ähnliches vorstellen.

Deep Learning ist ein weites Feld, also werden wir unseren Fokus etwas eingrenzen und uns der Herausforderung stellen, ein Projekt zur Bildklassifizierung zu lösen. Außerdem werden wir eine sehr einfache Deep-Learning-Architektur verwenden, um eine ziemlich beeindruckende Genauigkeit zu erzielen.

Sie können den Python-Code, den wir in diesem Artikel sehen, als Benchmark für die Erstellung von Bildklassifizierungsmodellen betrachten. Wenn Sie das Konzept erst einmal verstanden haben, können Sie mit dem Code herumspielen, an Wettbewerben teilnehmen und in der Rangliste nach oben klettern.

Wenn Sie neu im Bereich Deep Learning sind und sich für das Gebiet der Computer Vision interessieren (wer tut das nicht?!), sollten Sie sich den Kurs „Computer Vision using Deep Learning“ ansehen. Er bietet eine umfassende Einführung in dieses wunderbare Gebiet und bereitet Sie auf den riesigen Arbeitsmarkt der nahen Zukunft vor.

Projekt zur Anwendung der Bildklassifizierung

Mehr als 25 % des gesamten Umsatzes im E-Commerce entfallen auf &Bekleidungszubehör. Ein großes Problem besteht darin, diese Kleidungsstücke nur anhand der Bilder zu kategorisieren, insbesondere wenn die von den Marken angegebenen Kategorien uneinheitlich sind. Dies stellt ein interessantes Computer-Vision-Problem dar, das die Aufmerksamkeit mehrerer Deep-Learning-Forscher auf sich gezogen hat.

Fashion MNIST ist ein Drop-in-Ersatz für den sehr bekannten MNIST-Datensatz (Machine Learning Hello World), der unter dem Übungsproblem „Identify the Digits“ eingesehen werden kann. Anstelle von Ziffern zeigen die Bilder eine Art von Kleidung, z. B. ein T-Shirt, eine Hose, eine Tasche, usw. Der für dieses Problem verwendete Datensatz wurde von Zalando Research erstellt.

Jetzt üben

Inhaltsverzeichnis

1. Was ist Bildklassifikation und ihre Anwendungsfälle
2. Aufbau der Struktur unserer Bilddaten
3. Aufschlüsselung des Modellbildungs Prozess
4. Einrichten der Problemstellung und Verstehen der Daten
5. Schritte zum Aufbau des Bildklassifizierungsmodells
6. Eine weitere Herausforderung

Was ist Bildklassifizierung?

Betrachten Sie das folgende Bild:

Sie werden es sofort erkannt haben – es ist ein (protziges) Auto. Gehen Sie einen Schritt zurück und analysieren Sie, wie Sie zu dieser Schlussfolgerung gekommen sind – Ihnen wurde ein Bild gezeigt und Sie haben die Klasse klassifiziert, zu der es gehört (in diesem Fall ein Auto). Und genau darum geht es bei der Bildklassifizierung.

Es gibt potenziell n Kategorien, in die ein bestimmtes Bild eingeordnet werden kann. Die manuelle Überprüfung und Klassifizierung von Bildern ist ein sehr mühsamer Prozess. Die Aufgabe wird fast unmöglich, wenn wir es mit einer riesigen Anzahl von Bildern zu tun haben, sagen wir 10.000 oder sogar 100.000. Wie nützlich wäre es, wenn wir diesen gesamten Prozess automatisieren und Bilder schnell der entsprechenden Klasse zuordnen könnten?

Selbstfahrende Autos sind ein gutes Beispiel dafür, wo die Bildklassifizierung in der Praxis eingesetzt wird. Um autonomes Fahren zu ermöglichen, können wir ein Bildklassifizierungsmodell erstellen, das verschiedene Objekte wie Fahrzeuge, Personen, sich bewegende Objekte usw. auf der Straße erkennt. Wir werden später in diesem Artikel noch einige weitere Anwendungsfälle sehen, aber es gibt noch viele weitere Anwendungen um uns herum. Nutzen Sie den Kommentarbereich unter dem Artikel, um mir mitzuteilen, welche potenziellen Anwendungsfälle Ihnen einfallen!

Nun, da wir unser Thema im Griff haben, wollen wir uns damit befassen, wie ein Bildklassifizierungsmodell aufgebaut ist, was die Voraussetzungen dafür sind und wie es in Python implementiert werden kann.

Einrichten der Struktur unserer Bilddaten

Unsere Daten müssen in einem bestimmten Format vorliegen, um ein Bildklassifizierungsproblem zu lösen. Wir werden das in einigen Abschnitten in Aktion sehen, aber bis dahin sollten Sie diese Hinweise im Hinterkopf behalten.

Sie sollten zwei Ordner haben, einen für den Trainingssatz und den anderen für den Testsatz. Im Trainingsset haben Sie eine .csv-Datei und einen Bildordner:

• Die .csv-Datei enthält die Namen aller Trainingsbilder und die zugehörigen wahren Bezeichnungen
• Der Bildordner enthält alle Trainingsbilder.

Die .csv-Datei in unserem Testset unterscheidet sich von der im Trainingsset. Diese .csv-Datei des Testsatzes enthält die Namen aller Testbilder, aber sie haben keine entsprechenden Bezeichnungen. Können Sie erraten, warum? Unser Modell wird auf den Bildern des Trainingssatzes trainiert, und die Vorhersage der Bezeichnungen erfolgt auf den Bildern des Testsatzes

Wenn Ihre Daten nicht das oben beschriebene Format haben, müssen Sie sie entsprechend konvertieren (andernfalls werden die Vorhersagen falsch und ziemlich nutzlos sein).

Der Prozess der Modellbildung

Bevor wir in den Python-Code eintauchen, sollten wir uns einen Moment Zeit nehmen, um zu verstehen, wie ein Bildklassifizierungsmodell typischerweise aufgebaut ist. Wir können diesen Prozess grob in 4 Phasen unterteilen. Jede Phase erfordert einen bestimmten Zeitaufwand:

1. Laden und Vorverarbeitung der Daten – 30 % der Zeit
2. Definieren der Modellarchitektur – 10 % der Zeit
3. Trainieren des Modells – 50 % der Zeit
4. Schätzung der Leistung – 10 % der Zeit

Lassen Sie mich jeden der oben genannten Schritte etwas genauer erklären. Dieser Abschnitt ist sehr wichtig, da nicht jedes Modell auf Anhieb gebaut wird. Sie müssen nach jeder Iteration zurückgehen, Ihre Schritte verfeinern und das Modell erneut ausführen. Ein solides Verständnis der zugrunde liegenden Konzepte wird den gesamten Prozess erheblich beschleunigen.

Phase 1: Laden und Vorverarbeiten der Daten

Daten sind Gold wert, wenn es um Deep-Learning-Modelle geht. Ihr Bildklassifizierungsmodell hat eine viel bessere Chance, gut abzuschneiden, wenn Sie eine große Anzahl von Bildern im Trainingssatz haben. Außerdem variiert die Form der Daten je nach Architektur/Framework, das wir verwenden.

Daher der entscheidende Schritt der Datenvorverarbeitung (der ewig wichtige Schritt in jedem Projekt). Ich empfehle dringend, die „Grundlagen der Bildverarbeitung in Python“ zu lesen, um mehr darüber zu erfahren, wie die Vorverarbeitung von Bilddaten funktioniert.

Aber wir sind noch nicht ganz am Ziel. Um zu sehen, wie unser Modell bei ungesehenen Daten abschneidet (und bevor wir es dem Testsatz aussetzen), müssen wir einen Validierungssatz erstellen. Dazu werden die Daten des Trainingssatzes aufgeteilt.

Kurz gesagt, wir trainieren das Modell mit den Trainingsdaten und validieren es mit den Validierungsdaten. Sobald wir mit der Leistung des Modells auf dem Validierungssatz zufrieden sind, können wir es für Vorhersagen auf den Testdaten verwenden.

Die für diesen Schritt benötigte Zeit: Wir benötigen etwa 2-3 Minuten für diese Aufgabe.

Phase 2: Definieren der Modellarchitektur

Dies ist ein weiterer wichtiger Schritt in unserem Deep-Learning-Modellbildungsprozess. Wir müssen definieren, wie unser Modell aussehen soll, und das erfordert die Beantwortung von Fragen wie:

• Wie viele Faltungsschichten wollen wir?
• Wie soll die Aktivierungsfunktion für jede Schicht aussehen?
• Wie viele versteckte Einheiten soll jede Schicht haben?

Und viele mehr. Dies sind im Wesentlichen die Hyperparameter des Modells, die eine RIESIGE Rolle dabei spielen, wie gut die Vorhersagen sein werden.

Wie entscheiden wir diese Werte? Ausgezeichnete Frage! Eine gute Idee ist, diese Werte auf der Grundlage bestehender Forschungen/Studien auszuwählen. Eine andere Idee ist, so lange mit den Werten zu experimentieren, bis man die beste Übereinstimmung gefunden hat, aber das kann ein ziemlich zeitaufwändiger Prozess sein.

Zeitaufwand für diesen Schritt: Es sollte etwa 1 Minute dauern, um die Architektur des Modells zu definieren.

Phase 3: Training des Modells

Für das Training des Modells benötigen wir:

• Trainingsbilder und die dazugehörigen wahren Bezeichnungen
• Validierungsbilder und die dazugehörigen wahren Bezeichnungen (wir verwenden diese Bezeichnungen nur zur Validierung des Modells und nicht während der Trainingsphase)

In diesem Schritt legen wir auch die Anzahl der Epochen fest. Für den Anfang lassen wir das Modell für 10 Epochen laufen (Sie können die Anzahl der Epochen später ändern).

Die für diesen Schritt benötigte Zeit: Da das Modell für das Training Strukturen erlernen muss, benötigen wir für diesen Schritt etwa 5 Minuten.

Und nun ist es an der Zeit, Vorhersagen zu treffen!

Phase 4: Schätzen der Leistung des Modells

Abschließend laden wir die Testdaten (Bilder) und führen auch hier den Vorverarbeitungsschritt durch. Anschließend sagen wir die Klassen für diese Bilder mit Hilfe des trainierten Modells voraus.

Zeitbedarf für diesen Schritt: ~ 1 Minute.

Problemstellung und Datenverständnis

Wir werden eine wirklich coole Herausforderung annehmen, um die Bildklassifizierung zu verstehen. Wir müssen ein Modell erstellen, das einen gegebenen Satz von Bildern nach der Art der Kleidung (Hemd, Hose, Schuhe, Socken usw.) klassifizieren kann. Es handelt sich dabei um ein Problem, mit dem viele E-Commerce-Händler konfrontiert sind, was es zu einem noch interessanteren Computer-Vision-Problem macht.

Diese Aufgabe heißt „Identify the Apparels“ und ist eines der Übungsprobleme, die wir auf unserer DataHack-Plattform anbieten. Sie müssen sich registrieren und den Datensatz über den obigen Link herunterladen.

Wir haben insgesamt 70.000 Bilder (Dimension 28 x 28), von denen 60.000 aus dem Trainingssatz und 10.000 aus dem Testsatz stammen. Die Trainingsbilder sind entsprechend der Bekleidungsart mit insgesamt 10 Klassen voretikettiert. Die Testbilder sind natürlich nicht beschriftet. Die Herausforderung besteht darin, die Art der Kleidung zu identifizieren, die in allen Testbildern vorhanden ist.

Wir werden unser Modell auf Google Colab aufbauen, da es eine kostenlose GPU zum Trainieren unserer Modelle bereitstellt.

Schritte zum Aufbau unseres Modells

Zeit, Ihre Python-Kenntnisse aufzufrischen und sich die Hände schmutzig zu machen. Wir sind endlich bei der Implementierung unseres Lernprozesses angelangt!

1. Einrichten von Google Colab
2. Importieren von Bibliotheken
3. Laden und Vorverarbeiten von Daten – (3 Min.)
4. Erstellen eines Validierungssatzes
5. Definieren der Modellstruktur – (1 Min.)
6. Trainieren des Modells – (5 Min.)
7. Vorhersagen treffen – (1 Min.)

Schauen wir uns jeden Schritt im Detail an.

Schritt 1: Einrichten von Google Colab

Da wir unsere Daten aus einem Google Drive-Link importieren, müssen wir ein paar Codezeilen in unser Google Colab-Notizbuch einfügen. Erstellen Sie ein neues Python 3-Notizbuch und schreiben Sie die folgenden Codeblöcke:

!pip install PyDrive

Damit wird PyDrive installiert. Nun importieren wir einige erforderliche Bibliotheken:

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

Als Nächstes erstellen wir eine Laufwerksvariable, um auf Google Drive zuzugreifen:

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

Um den Datensatz herunterzuladen, verwenden wir die ID der auf Google Drive hochgeladenen Datei:

download = drive.CreateFile({'id': '1BZOv422XJvxFUnGh-0xVeSvgFgqVY45q'})

Ersetzen Sie die „id“ im obigen Code durch die ID Ihrer Datei. Jetzt laden wir diese Datei herunter und entpacken sie:

download.GetContentFile('train_LbELtWX.zip')!unzip train_LbELtWX.zip

Sie müssen diese Codeblöcke jedes Mal ausführen, wenn Sie Ihr Notebook starten.

Schritt 2: Importieren Sie die Bibliotheken, die wir in der Phase der Modellerstellung benötigen.

import kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

Schritt 3: Erinnern Sie sich an die vorbereitenden Schritte, die wir bereits besprochen haben. Wir verwenden sie hier nach dem Laden der Daten.

train = pd.read_csv('train.csv')

Als Nächstes lesen wir alle Trainingsbilder, speichern sie in einer Liste und konvertieren diese Liste schließlich in ein Numpy-Array.

# We have grayscale images, so while loading the images we will keep grayscale=True, if you have RGB images, you should set grayscale as Falsetrain_image = for i in tqdm(range(train.shape)): img = image.load_img('train/'+train.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

Da es sich um ein Mehrklassen-Klassifizierungsproblem (10 Klassen) handelt, werden wir die Zielvariable in einem Schritt kodieren.

y=train.valuesy = to_categorical(y)

Schritt 4: Erstellen einer Validierungsmenge aus den Trainingsdaten.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

Schritt 5: Definieren der Modellstruktur.

Wir werden eine einfache Architektur mit 2 Faltungsschichten, einer dichten versteckten Schicht und einer Ausgabeschicht erstellen.

model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

Als Nächstes werden wir das erstellte Modell kompilieren.

model.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

Schritt 6: Training des Modells.

In diesem Schritt trainieren wir das Modell auf den Bildern des Trainingssatzes und validieren es anhand des Validierungssatzes.

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

Schritt 7: Vorhersagen treffen!

Wir folgen zunächst den Schritten, die wir bei der Bearbeitung der Trainingsdaten durchgeführt haben. Laden Sie die Testbilder und sagen Sie ihre Klassen mit der Funktion model.predict_classes() voraus.

download = drive.CreateFile({'id': '1KuyWGFEpj7Fr2DgBsW8qsWvjqEzfoJBY'})download.GetContentFile('test_ScVgIM0.zip')!unzip test_ScVgIM0.zip

Lesen Sie die Testdatei ein:

test = pd.read_csv('test.csv')

Nun werden wir alle Testbilder einlesen und speichern:

test_image = for i in tqdm(range(test.shape)): img = image.load_img('test/'+test.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

# making predictionsprediction = model.predict_classes(test)

Wir werden auch eine Einreichungsdatei erstellen, um sie auf der DataHack-Plattformseite hochzuladen (um zu sehen, wie unsere Ergebnisse in der Rangliste aussehen).

download = drive.CreateFile({'id': '1z4QXy7WravpSj-S4Cs9Fk8ZNaX-qh5HF'})download.GetContentFile('sample_submission_I5njJSF.csv')

# creating submission filesample = pd.read_csv('sample_submission_I5njJSF.csv')sample = predictionsample.to_csv('sample_cnn.csv', header=True, index=False)

Laden Sie diese sample_cnn.csv-Datei herunter und laden Sie sie auf die Wettbewerbsseite hoch, um Ihre Ergebnisse zu generieren und Ihre Platzierung auf der Bestenliste zu überprüfen. Auf diese Weise erhalten Sie eine Benchmark-Lösung, die Ihnen den Einstieg in ein beliebiges Bildklassifizierungsproblem ermöglicht!

Sie können Hyperparameter-Tuning und Regularisierungstechniken ausprobieren, um die Leistung Ihres Modells weiter zu verbessern. Ich empfehle Ihnen, sich diesen Artikel anzusehen, um diesen Schritt der Feinabstimmung im Detail zu verstehen – ‚A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch‘.

Eine andere Herausforderung

Lassen Sie uns unser Lernen an einem anderen Datensatz testen. In diesem Abschnitt werden wir das Übungsproblem „Identifiziere die Ziffern“ knacken. Laden Sie sich den Datensatz herunter. Bevor Sie weitermachen, versuchen Sie, die Aufgabe selbst zu lösen. Sie haben bereits die Werkzeuge, um die Aufgabe zu lösen – Sie müssen sie nur noch anwenden! Kommen Sie hierher zurück, um Ihre Ergebnisse zu überprüfen oder wenn Sie einmal nicht weiterkommen.

In dieser Aufgabe müssen wir die Ziffern in einem vorgegebenen Bild identifizieren. Wir haben insgesamt 70.000 Bilder – 49.000 beschriftete Bilder in der Trainingsmenge und die restlichen 21.000 in der Testmenge (die Testbilder sind unbeschriftet). Wir müssen die Klasse dieser unmarkierten Bilder identifizieren/vorhersagen.

Bereit zu beginnen? Prima! Erstellen Sie ein neues Python 3-Notizbuch und führen Sie den folgenden Code aus:

# Setting up Colab!pip install PyDrive

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

# Replace the id and filename in the below codesdownload = drive.CreateFile({'id': '1ZCzHDAfwgLdQke_GNnHp_4OheRRtNPs-'})download.GetContentFile('Train_UQcUa52.zip')!unzip Train_UQcUa52.zip

# Importing librariesimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

train = pd.read_csv('train.csv')

# Reading the training imagestrain_image = for i in tqdm(range(train.shape)): img = image.load_img('Images/train/'+train, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

# Creating the target variabley=train.valuesy = to_categorical(y)

# Creating validation setX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Define the model structuremodel = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

# Compile the modelmodel.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

# Training the modelmodel.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

download = drive.CreateFile({'id': '1zHJR6yiI06ao-UAh_LXZQRIOzBO3sNDq'})download.GetContentFile('Test_fCbTej3.csv')

test_file = pd.read_csv('Test_fCbTej3.csv')

test_image = for i in tqdm(range(test_file.shape)): img = image.load_img('Images/test/'+test_file, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

prediction = model.predict_classes(test)

download = drive.CreateFile({'id': '1nRz5bD7ReGrdinpdFcHVIEyjqtPGPyHx'})download.GetContentFile('Sample_Submission_lxuyBuB.csv')

sample = pd.read_csv('Sample_Submission_lxuyBuB.csv')sample = test_filesample = predictionsample.to_csv('sample.csv', header=True, index=False)

Senden Sie diese Datei auf der Seite mit den Übungsproblemen ein, um eine recht ordentliche Genauigkeitszahl zu erhalten. Es ist ein guter Anfang, aber es gibt immer Raum für Verbesserungen. Spielen Sie weiter mit den Hyperparametern und sehen Sie, ob Sie unser Basismodell verbessern können.

Endenotizen

Wer sagt denn, dass Deep-Learning-Modelle Stunden oder Tage zum Trainieren benötigen. Mein Ziel war es, zu zeigen, dass man ein ziemlich gutes Deep-Learning-Modell in doppelt so kurzer Zeit erstellen kann. Sie sollten ähnliche Herausforderungen annehmen und versuchen, sie auch bei sich selbst zu programmieren. Es geht nichts über Learning by doing!

Die besten Datenwissenschaftler und -analysten haben diese Codes schon vor Beginn eines Hackathons parat. Sie verwenden diese Codes, um erste Vorschläge zu machen, bevor sie sich in eine detaillierte Analyse stürzen. Sobald sie eine Benchmark-Lösung haben, beginnen sie, ihr Modell mit verschiedenen Techniken zu verbessern.