Von den Daten bis zur Bereitstellung

DataWhisper: Den DL-Projektlebenszyklus meistern

Autor: Abdellah Hallou (LinkedIn, Twitter)

Willkommen beim Deep Learning Project Starter Guide! Dieses Tutorial dient als umfassende Ressource für alle, die in die aufregende Welt des Deep Learning eintauchen möchten. Egal, ob Sie Anfänger oder erfahrener Entwickler sind, dieser Leitfaden führt Sie von Anfang bis Ende durch den Prozess der Erstellung eines Deep-Learning-Projekts.

Inhaltsverzeichnis

• Was Sie lernen werden
• Wer sollte diesem Tutorial folgen
• Benötigen Sie Hilfe oder haben Sie Fragen?
• Lasst uns anfangen!
• Importiert und lädt den Datensatz
• Datensatzstruktur
• Explorative Datenanalyse (EDA)
• Verarbeiten Sie die Daten vor
• Bauen Sie das Modell
• Bewerten Sie die Genauigkeit
• Speichern und exportieren Sie das Modell
• Machen Sie Vorhersagen
• Einsatz
  • Erstellen Sie ein neues Flatterprojekt
  • Konfigurieren der Kamera
  • Erstellen des Kamerabildschirms
  • Bild-Upload integrieren
  • Objekterkennung mit TensorFlow Lite
  • Ausführen des Modells auf Bildern
  • Ergebnisse in einem Dialog anzeigen
  • Erstellen der Benutzeroberfläche

Was Sie lernen werden

In diesem Tutorial lernen Sie die wesentlichen Schritte kennen, die zum Erstellen und Bereitstellen eines Deep-Learning-Modells in einer mobilen App erforderlich sind. Wir werden die folgenden Themen behandeln:

1. Vorbereitung der Daten: Wir werden verschiedene Methoden zur Datenvorverarbeitung untersuchen, um einen robusten und zuverlässigen Datensatz für das Training sicherzustellen.

2. Modellerstellung: Sie erfahren, wie Sie Ihr CNN-Modell entwerfen und erstellen.

3. Training des Modells: Wir befassen uns mit dem Prozess des Trainings Ihres Deep-Learning-Modells mit TensorFlow.

4. Bereitstellung in einer mobilen App: Sobald Ihr Modell trainiert ist, führen wir Sie durch die Schritte zur Integration in eine mobile App mit TensorFlow Lite. Sie werden verstehen, wie Sie unterwegs Vorhersagen treffen können!

Wer sollte diesem Tutorial folgen?

Dieses Tutorial eignet sich für Anfänger und fortgeschrittene Entwickler mit einem grundlegenden Verständnis von Deep-Learning-Konzepten und Python-Programmierung. Egal, ob Sie Datenwissenschaftler, Machine-Learning-Enthusiast oder Entwickler mobiler Apps sind, dieser Leitfaden vermittelt Ihnen das nötige Wissen, um Ihr Deep-Learning-Projekt in Gang zu bringen.

Benötigen Sie Hilfe oder haben Sie Fragen?

Wenn Sie beim Durcharbeiten dieses Tutorials auf Probleme stoßen, Fragen haben oder weitere Erläuterungen benötigen, zögern Sie nicht, in diesem Repository „From-Data-to-Deployment“ ein GitHub-Issue zu erstellen. Ich helfe Ihnen gerne weiter und gebe Ihnen die nötige Anleitung.

Um ein Problem zu erstellen, klicken Sie oben auf der Seite dieses Repositorys auf die Registerkarte "Probleme" und dann auf die Schaltfläche "Neues Problem". Bitte geben Sie so viel Kontext und Details wie möglich zu Ihrem Problem oder Ihrer Frage an. Dies wird mir helfen, Ihr Anliegen besser zu verstehen und Ihnen eine schnelle und genaue Antwort zu geben.

Ihr Feedback ist wertvoll und kann dazu beitragen, dieses Tutorial auch für andere Benutzer zu verbessern. Zögern Sie also nicht, sich an uns zu wenden, wenn Sie Hilfe benötigen. Lasst uns gemeinsam lernen und wachsen!

Fangen wir an!

Stellen Sie zunächst sicher, dass Sie die erforderlichen Abhängigkeiten und Bibliotheken installiert haben. Das Tutorial ist in leicht verständliche Abschnitte unterteilt, die jeweils einen bestimmten Aspekt des Deep-Learning-Projektworkflows abdecken. Springen Sie gerne zu den Abschnitten, die Sie am meisten interessieren, oder folgen Sie den Abschnitten von Anfang bis Ende.

Bist du bereit?

Importiert und lädt den Datensatz

Lassen Sie uns mit den notwendigen Importen für unseren Code beginnen. In diesem Tutorial verwenden wir den Fashion Mnist-Datensatz.

# Import the necessary libraries
from __future__ import print_function
import keras
from google.colab import drive
import os
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, BatchNormalization
from keras.layers import Conv2D, MaxPooling2D
from keras.wrappers.scikit_learn import KerasClassifier
from keras import backend as K
from sklearn.model_selection import GridSearchCV
import tensorflow as tf
from keras.utils.vis_utils import plot_model
import matplotlib.pyplot as plt

Datensatzstruktur

In jedem Deep-Learning-Projekt ist das Verständnis der Daten von entscheidender Bedeutung. Bevor wir uns mit der Modellerstellung und dem Training befassen, beginnen wir damit, die Daten zu laden und Einblicke in ihre Struktur, Variablen und Gesamteigenschaften zu gewinnen.

# Load the Fashion MNIST dataset
fashion_mnist = tf.keras.datasets.fashion_mnist
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()

Explorative Datenanalyse (EDA)

Da die Daten nun geladen sind, führen wir eine explorative Datenanalyse durch, um ein besseres Verständnis ihrer Eigenschaften zu erlangen.

print("Shape of the training data : ",x_train.shape)
print("Shape of the testing data : ",x_test.shape)

Shape of the training data :  (60000, 28, 28)
Shape of the testing data :  (10000, 28, 28)

Der Fashion MNIST-Datensatz enthält 70.000 Graustufenbilder in 10 Kategorien. Die Bilder zeigen einzelne Kleidungsstücke in niedriger Auflösung (28 x 28 Pixel), wie hier zu sehen:

60.000 Bilder werden verwendet, um das Netzwerk zu trainieren, und 10.000 Bilder, um zu bewerten, wie genau das Netzwerk gelernt hat, Bilder zu klassifizieren.

# Printing unique values in training data
unique_labels = np.unique(y_train, axis=0)
print("Unique labels in training data:", unique_labels)

Unique labels in training data: [0 1 2 3 4 5 6 7 8 9]

Die Beschriftungen sind eine Reihe von Ganzzahlen im Bereich von 0 bis 9. Diese entsprechen der Kleidungsklasse, die das Bild darstellt:
| Etikett | RKlasse |
| - |-|
| 0 | T-Shirt/Top|
| 1 | Hose|
| 2 |Pullover|
| 3 |Kleid|
| 4 |Mantel|
| 5 |Sandale|
| 6 |Shirt|
| 7 |Sneaker |
| 8 |Tasche|
| 9 | Stiefeletten |

Da die Klassennamen nicht im Datensatz enthalten sind, speichern Sie sie hier, um sie später beim Plotten der Bilder zu verwenden:

# Numeric labels
numeric_labels = np.sort(np.unique(y_train, axis=0))
# String labels
string_labels = np.array(['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat','Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'])
# Mapping numeric labels to string labels
numeric_to_string = dict(zip(numeric_labels, string_labels))
print("Numeric to String Label Mapping:")
print(numeric_to_string)

Numeric to String Label Mapping:
{0: 'T-shirt/top', 1: 'Trouser', 2: 'Pullover', 3: 'Dress', 4: 'Coat', 5: 'Sandal', 6: 'Shirt', 7: 'Sneaker', 8: 'Bag', 9: 'Ankle boot'}

Verarbeiten Sie die Daten vor

Die Daten müssen vorverarbeitet werden, bevor das Netzwerk trainiert wird.
Wir beginnen damit, die Anzahl der Klassen in unserem Datensatz (in diesem Fall 10) und die Abmessungen der Eingabebilder (28 x 28 Pixel) zu definieren.

# Import the necessary libraries
from __future__ import print_function
import keras
from google.colab import drive
import os
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, BatchNormalization
from keras.layers import Conv2D, MaxPooling2D
from keras.wrappers.scikit_learn import KerasClassifier
from keras import backend as K
from sklearn.model_selection import GridSearchCV
import tensorflow as tf
from keras.utils.vis_utils import plot_model
import matplotlib.pyplot as plt

Dieser Teil ist für die Umformung der Eingabebilddaten verantwortlich, damit sie dem erwarteten Format für das neuronale Netzwerkmodell entsprechen. Das Format hängt vom verwendeten Backend ab (z. B. TensorFlow oder Theano). In diesem Snippet überprüfen wir das Bilddatenformat mit K.image_data_format() und wenden die entsprechende Umformung basierend auf dem Ergebnis an.

# Load the Fashion MNIST dataset
fashion_mnist = tf.keras.datasets.fashion_mnist
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()

Die Pixelwerte der Bilder in den Daten liegen im Bereich von 0 bis 255.
Skalieren Sie diese Werte auf einen Bereich von 0 bis 1, bevor Sie sie dem CNN-Modell zuführen.

print("Shape of the training data : ",x_train.shape)
print("Shape of the testing data : ",x_test.shape)

Konvertieren Sie die Klassenbezeichnungen (dargestellt als ganze Zahlen) in ein binäres Klassenmatrixformat, das für Klassifizierungsprobleme mit mehreren Klassen erforderlich ist.

Shape of the training data :  (60000, 28, 28)
Shape of the testing data :  (10000, 28, 28)

Bauen Sie das Modell

In diesem Schritt definieren und erstellen wir ein Convolutional Neural Network (CNN)-Modell für die Bildklassifizierung. Die Modellarchitektur besteht aus mehreren Schichten wie Faltungs-, Pooling-, Dropout- und dichten Schichten. Die Funktion build_model verwendet die Anzahl der Klassen sowie Trainings- und Testdaten als Eingabe und gibt den Trainingsverlauf und das erstellte Modell zurück.

# Printing unique values in training data
unique_labels = np.unique(y_train, axis=0)
print("Unique labels in training data:", unique_labels)

Unique labels in training data: [0 1 2 3 4 5 6 7 8 9]

# Numeric labels
numeric_labels = np.sort(np.unique(y_train, axis=0))
# String labels
string_labels = np.array(['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat','Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'])
# Mapping numeric labels to string labels
numeric_to_string = dict(zip(numeric_labels, string_labels))
print("Numeric to String Label Mapping:")
print(numeric_to_string)

Bewerten Sie die Genauigkeit

Um die Leistung des trainierten Modells zu beurteilen, bewerten wir es anhand der Testdaten. Die Bewertungsmethode wird zur Berechnung des Testverlusts und der Testgenauigkeit verwendet. Diese Metriken werden dann auf der Konsole gedruckt.

Numeric to String Label Mapping:
{0: 'T-shirt/top', 1: 'Trouser', 2: 'Pullover', 3: 'Dress', 4: 'Coat', 5: 'Sandal', 6: 'Shirt', 7: 'Sneaker', 8: 'Bag', 9: 'Ankle boot'}

num_classes = 10
# input image dimensions
img_rows, img_cols = 28, 28

if K.image_data_format() == 'channels_first':
    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)

Speichern und exportieren Sie das Modell

Nachdem wir das Modell trainiert haben, speichern wir es mit der Methode Speichern im Dateiformat Hierarchical Data Format (HDF5). Das Modell wird dann durch Aufruf der Funktion move_to_drive nach Google Drive exportiert. Zusätzlich wird das Modell mit der Funktion h52tflite in das TensorFlow Lite-Format konvertiert und das resultierende TFLite-Modell auch in Google Drive gespeichert. Die Pfade des gespeicherten Modells und des TFLite-Modells werden zurückgegeben.

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

Machen Sie Vorhersagen

Um die Vorhersagen des Modells zu visualisieren, wählen wir einen zufälligen Satz von Testbildern aus. Das Modell sagt die Klassenbezeichnungen für diese Bilder mithilfe der Vorhersagemethode voraus. Die vorhergesagten Beschriftungen werden dann mit den Ground-Truth-Beschriftungen verglichen, um die Bilder zusammen mit ihren entsprechenden vorhergesagten Beschriftungen mithilfe von matplotlib anzuzeigen.

# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

Weitere Informationen zum Modell finden Sie in diesen Ressourcen:

1. https://www.tensorflow.org/tutorials/keras/classification
2. https://github.com/cmasch/zalando-fashion-mnist/tree/master

Einsatz

Erstellen Sie ein neues Flutter-Projekt

Bevor Sie ein neues Flutter-Projekt erstellen, stellen Sie sicher, dass das Flutter SDK und andere Anforderungen im Zusammenhang mit der Flutter-App-Entwicklung ordnungsgemäß installiert sind: https://docs.flutter.dev/get-started/install/windows

Nachdem das Projekt eingerichtet wurde, implementieren wir die Benutzeroberfläche, damit Benutzer Bilder aufnehmen oder Bilder aus der Galerie hochladen und eine Objekterkennung mithilfe des exportierten TensorFlow Lite-Modells durchführen können.
Zuerst müssen wir diese Pakete installieren:

1. Kamera: 0,10,4
2. image_picker:
3. tflite: ^1.1.2

Kopieren Sie dazu den folgenden Codeausschnitt und fügen Sie ihn in die Datei pubspec.yaml des Projekts ein:

# Import the necessary libraries
from __future__ import print_function
import keras
from google.colab import drive
import os
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, BatchNormalization
from keras.layers import Conv2D, MaxPooling2D
from keras.wrappers.scikit_learn import KerasClassifier
from keras import backend as K
from sklearn.model_selection import GridSearchCV
import tensorflow as tf
from keras.utils.vis_utils import plot_model
import matplotlib.pyplot as plt

Importieren Sie die erforderlichen Pakete in die Datei main.dart des Projekts

# Load the Fashion MNIST dataset
fashion_mnist = tf.keras.datasets.fashion_mnist
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()

Konfigurieren der Kamera

Um die Kamerafunktionalität zu aktivieren, verwenden wir das Paket Kamera. Importieren Sie zunächst die erforderlichen Pakete und instanziieren Sie den Kameracontroller. Verwenden Sie die Funktion availableCameras(), um eine Liste der verfügbaren Kameras abzurufen. In diesem Tutorial verwenden wir die erste Kamera in der Liste.

print("Shape of the training data : ",x_train.shape)
print("Shape of the testing data : ",x_test.shape)

Erstellen des Kamerabildschirms

Erstellen Sie ein neues StatefulWidget mit dem Namen CameraScreen, das die Kameravorschau- und Bilderfassungsfunktionen übernimmt. Initialisieren Sie in der Methode initState() den Kameracontroller und legen Sie die Auflösungsvoreinstellung fest. Implementieren Sie außerdem die Methode _takePicture(), die ein Bild mithilfe des Kamera-Controllers aufnimmt.

Shape of the training data :  (60000, 28, 28)
Shape of the testing data :  (10000, 28, 28)

Bild-Upload integrieren

Damit Benutzer Bilder aus der Galerie hochladen können, importieren Sie das Paket image_picker. Implementieren Sie die Methode _pickImage(), die die Klasse ImagePicker verwendet, um ein Bild aus der Galerie auszuwählen. Sobald ein Bild ausgewählt ist, kann es mit der Methode _processImage() verarbeitet werden.

# Printing unique values in training data
unique_labels = np.unique(y_train, axis=0)
print("Unique labels in training data:", unique_labels)

Objekterkennung mit TensorFlow Lite

Um die Objekterkennung durchzuführen, verwenden wir TensorFlow Lite. Beginnen Sie mit dem Import des tflite-Pakets. Laden Sie in der Methode _initTensorFlow() das TensorFlow Lite-Modell und die Beschriftungen aus den Assets. Sie können die Modell- und Etikettendateipfade angeben und Einstellungen wie die Anzahl der Threads und die GPU-Delegatennutzung anpassen.

# Import the necessary libraries
from __future__ import print_function
import keras
from google.colab import drive
import os
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, BatchNormalization
from keras.layers import Conv2D, MaxPooling2D
from keras.wrappers.scikit_learn import KerasClassifier
from keras import backend as K
from sklearn.model_selection import GridSearchCV
import tensorflow as tf
from keras.utils.vis_utils import plot_model
import matplotlib.pyplot as plt

Ausführen des Modells auf Bildern

Implementieren Sie die Methode _objectRecognition(), die einen Bilddateipfad als Eingabe verwendet und das TensorFlow Lite-Modell auf dem Bild ausführt. Die Methode gibt die Bezeichnung des erkannten Objekts zurück.

# Load the Fashion MNIST dataset
fashion_mnist = tf.keras.datasets.fashion_mnist
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()

Ergebnisse in einem Dialog anzeigen

Wenn ein Bild verarbeitet wird, zeigen Sie das Ergebnis in einem Dialogfeld mit der Methode showDialog() an. Passen Sie das Dialogfeld an, um die Bezeichnung des erkannten Objekts anzuzeigen und eine Option zum Abbrechen bereitzustellen.

print("Shape of the training data : ",x_train.shape)
print("Shape of the testing data : ",x_test.shape)

Erstellen der Benutzeroberfläche

Shape of the training data :  (60000, 28, 28)
Shape of the testing data :  (10000, 28, 28)

Das obige ist der detaillierte Inhalt vonVon den Daten bis zur Bereitstellung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!