Künstliche Intelligenz (KI) hat in den letzten Jahren stark an Popularität gewonnen.
Wenn Sie ein Software-Ingenieur, Informatiker oder Data-Science-Enthusiast im Allgemeinen sind, dann sind Sie wahrscheinlich fasziniert von den erstaunlichen Anwendungen der Bildverarbeitung, Mustererkennung und Objekterkennung, die dieser Bereich bietet.
Das wichtigste Teilgebiet der KI, von dem Sie wahrscheinlich gehört haben, ist Deep Learning. Dieses Feld konzentriert sich auf leistungsstarke Algorithmen (Computerprogrammanweisungen), die der menschlichen Gehirnfunktion nachempfunden sind, die als bekannt ist Neuronale Netze.
In diesem Artikel gehen wir auf das Konzept der neuronalen Netze ein und erläutern, wie diese Modelle erstellt, kompiliert, angepasst und ausgewertet werden Python.
Neuronale Netze
Neuronale Netze oder NNs sind eine Reihe von Algorithmen, die der biologischen Aktivität des menschlichen Gehirns nachempfunden sind. Neuronale Netze bestehen aus Knoten, auch Neuronen genannt.
Eine Sammlung vertikaler Knoten wird als Schichten bezeichnet. Das Modell besteht aus einem Eingang, einem Ausgang und einer Reihe verborgener Schichten. Jede Schicht besteht aus Knoten, auch Neuronen genannt, in denen die Berechnungen stattfinden.
Im folgenden Diagramm stellen die Kreise die Knoten und die vertikale Sammlung von Knoten die Ebenen dar. Es gibt drei Schichten in diesem Modell.
Die Knoten einer Schicht sind mit der nächsten Schicht durch Übertragungsleitungen verbunden, wie unten zu sehen ist.
Unser Datensatz besteht aus beschrifteten Daten. Dies bedeutet, dass jeder Datenentität ein bestimmter Namenswert zugewiesen wurde.
Für einen Tierklassifikationsdatensatz haben wir also Bilder von Katzen und Hunden als unsere Daten, mit „Katze“ und „Hund“ als unseren Bezeichnungen.
Es ist wichtig zu beachten, dass Beschriftungen in numerische Werte umgewandelt werden müssen, damit unser Modell sie sinnvoll interpretiert, sodass unsere Tierbeschriftungen „0“ für Katze und „1“ für Hund werden. Sowohl die Daten als auch die Labels werden durch das Modell geleitet.
Lernen
Die Daten werden dem Modell einzeln zugeführt. Diese Daten werden in Chunks zerlegt und durch jeden Knoten des Modells geleitet. Knoten führen mathematische Operationen auf diesen Chunks aus.
Sie müssen die mathematischen Funktionen oder Berechnungen für dieses Tutorial nicht kennen, aber es ist wichtig, eine allgemeine Vorstellung davon zu haben, wie diese Modelle funktionieren. Nach einer Reihe von Berechnungen in einer Schicht werden Daten an die nächste Schicht weitergegeben und so weiter.
Sobald es fertig ist, sagt unser Modell die Datenbeschriftung auf der Ausgabeebene voraus (z. B. erhalten wir bei einem Tierklassifikationsproblem eine Vorhersage „0“ für eine Katze).
Das Modell vergleicht dann diesen vorhergesagten Wert mit dem tatsächlichen Etikettenwert.
Wenn die Werte übereinstimmen, nimmt unser Modell die nächste Eingabe, aber wenn sich die Werte unterscheiden, berechnet das Modell die Differenz zwischen beiden Werten, die als Verlust bezeichnet wird, und passt die Knotenberechnungen an, um beim nächsten Mal übereinstimmende Beschriftungen zu erzeugen.
Deep-Learning-Frameworks
Um neuronale Netzwerke im Code zu erstellen, müssen wir importieren Deep-Learning-Frameworks bekannt als Bibliotheken, die unsere integrierte Entwicklungsumgebung (IDE) verwenden.
Diese Frameworks sind eine Sammlung vorgefertigter Funktionen, die uns in diesem Tutorial helfen werden. Wir werden das Keras-Framework verwenden, um unser Modell zu erstellen.
Keras ist eine Python-Bibliothek, die ein Backend für Deep Learning und künstliche Intelligenz namens Tensorflow NNs in Form von einfachen sequentiellen Modellen mit Leichtigkeit zu erstellen.
Keras bringt auch seine eigenen bereits vorhandenen Modelle mit, die ebenfalls verwendet werden könnten. Für dieses Tutorial erstellen wir unser eigenes Modell mit Keras.
Weitere Informationen zu diesem Deep-Learning-Framework finden Sie unter Keras-Website.
Aufbau eines neuronalen Netzwerks (Tutorial)
Fahren wir mit dem Aufbau eines neuronalen Netzwerks mit Python fort.
Problem Statement
Neuronale Netze sind eine Art Lösung für KI-basierte Probleme. Für dieses Tutorial werden wir die verfügbaren Diabetesdaten von Pima Indians durchgehen hier.
UCI Machine Learning hat diesen Datensatz zusammengestellt und enthält eine Krankenakte indischer Patienten. Unser Modell muss vorhersagen, ob der Patient innerhalb von 5 Jahren an Diabetes erkrankt oder nicht.
Datensatz laden
Unser Datensatz ist eine einzelne CSV-Datei mit dem Namen „diabetes.csv“, die einfach mit Microsoft Excel bearbeitet werden kann.
Bevor wir unser Modell erstellen, müssen wir unseren Datensatz importieren. Mit dem folgenden Code können Sie dies tun:
Pandas als pd importieren
data = pd.read_csv('diabetes.csv')
x = data.drop("Ergebnis")
y = data["Ergebnis"]
Hier verwenden wir die Pandas Bibliothek, um unsere CSV-Dateidaten bearbeiten zu können, ist read_csv() eine eingebaute Funktion von Pandas, die es uns ermöglicht, die Werte in unserer Datei in einer Variablen namens „data“ zu speichern.
Die Variable x enthält unseren Datensatz ohne die Ergebnisdaten (Labels). Wir erreichen dies mit der Funktion data.drop(), die die Labels für x entfernt, während y nur die Ergebnisdaten (Label) enthält.
Aufbau eines sequentiellen Modells
Schritt 1: Bibliotheken importieren
Zunächst müssen wir TensorFlow und Keras zusammen mit bestimmten Parametern importieren, die für unser Modell erforderlich sind. Der folgende Code ermöglicht uns dies:
Tensorflow als tf importieren
von tensorflow import keras
aus tensorflow.keras.models import Sequential
aus tensorflow.keras.layers import Aktivierung, Dichte
aus tensorflow.keras.optimizers import Adam
aus tensorflow.keras.metrics import categorycal_crossentropy
Für unser Modell importieren wir dichte Schichten. Dies sind vollständig verbundene Schichten; dh jeder Knoten in einer Schicht ist vollständig mit einem anderen Knoten in der nächsten Schicht verbunden.
Wir importieren auch eine Aktivierung Funktion zum Skalieren von Daten, die an Knoten gesendet werden. Optimierer wurden ebenfalls importiert, um Verluste zu minimieren.
Adam ist ein bekannter Optimierer, der unsere Modellaktualisierungsknotenberechnungen effizienter macht, zusammen mit kategorische_crossentropy was ist die Art der Verlustfunktion (berechnet die Differenz zwischen tatsächlichen und vorhergesagten Labelwerten), die wir verwenden werden.
Schritt 2: Entwerfen unseres Modells
Das Modell, das ich erstelle, hat eine Eingangs- (mit 16 Einheiten), eine verborgene (mit 32 Einheiten) und eine Ausgangsschicht (mit 2 Einheiten). Diese Zahlen sind nicht festgelegt und hängen vollständig von dem jeweiligen Problem ab.
Das Einstellen der richtigen Anzahl von Einheiten und Schichten ist ein Prozess, der mit der Zeit durch Übung verbessert werden kann. Die Aktivierung entspricht der Art der Skalierung, die wir an unseren Daten durchführen, bevor wir sie durch einen Knoten leiten.
Relu und Softmax sind bekannte Aktivierungsfunktionen für diese Aufgabe.
Modell = Sequentiell ([
Dense(units = 16, input_shape = (1,), activation = 'relu'),
Dichte (Einheiten = 32, Aktivierung = 'relu'),
Dichte (Einheiten = 2, Aktivierung = 'softmax')
])
So sollte die Zusammenfassung des Modells aussehen:
Das Modell trainieren
Unser Modell wird in zwei Schritten trainiert, wobei der erste das Kompilieren des Modells (Zusammensetzen des Modells) und der nächste das Anpassen des Modells an einen bestimmten Datensatz ist.
Dies kann mit der Funktion model.compile() gefolgt von der Funktion model.fit() erfolgen.
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['accuracy'])
model.fit(x, y, Epochen = 30, Batch_Size = 10)
Durch die Angabe der „Genauigkeits“-Metrik können wir die Genauigkeit unseres Modells während des Trainings beobachten.
Da unsere Beschriftungen die Form von Einsen und Nullen haben, verwenden wir eine binäre Verlustfunktion, um die Differenz zwischen tatsächlichen und vorhergesagten Beschriftungen zu berechnen.
Der Datensatz wird außerdem in 10er-Batches (batch_size) aufgeteilt und 30 Mal (Epochen) durch das Modell geleitet. Für einen gegebenen Datensatz wären x die Daten und y die Labels, die den Daten entsprechen.
Testmodell anhand von Vorhersagen
Um unser Modell zu evaluieren, machen wir Vorhersagen zu den Testdaten mit der Funktion „predict()“.
Vorhersagen = model.predict(x)
Und das ist es!
Sie sollten jetzt ein gutes Verständnis dafür haben Tiefes Lernen Anwendung, Neuronale Netze, wie sie im Allgemeinen funktionieren und wie man ein Modell in Python-Code erstellt, trainiert und testet.
Ich hoffe, dieses Tutorial gibt Ihnen den Kickstart, um Ihre eigenen Deep-Learning-Modelle zu erstellen und bereitzustellen.
Lassen Sie uns in den Kommentaren wissen, ob der Artikel hilfreich war.
Hinterlassen Sie uns einen Kommentar