Python im algorithmischen Handel - Seite 22
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Datenvisualisierung mit matplotlib in 1 Stunde
Datenvisualisierung mit matplotlib in 1 Stunde
In diesem Video stellt der Dozent die Bedeutung der Datenvisualisierung beim maschinellen Lernen vor und erklärt, wie sie dabei helfen kann, große Mengen gesammelter Daten zu verstehen. Die beiden wichtigsten Python-Bibliotheken für die Datenvisualisierung, Matplotlib und Seaborn, werden im Kurs behandelt.
Der Kursleiter gibt an, dass der Kurs in erster Linie für Ingenieure des maschinellen Lernens, Dateningenieure und Datenwissenschaftler gedacht ist, die Python lernen möchten. Um die Verwendung von Matplotlib zu veranschaulichen, wird ein einfaches Beispiel für das Zeichnen einer Kurve bereitgestellt. Die Philosophie von Matplotlib basiert auf der Nutzung der vorhandenen Sprache Python, die zum Standard für die Erstellung von Modellen für maschinelles Lernen und den Umgang mit Daten geworden ist. Durch die Kombination von Matplotlib mit anderen Python-Paketen können Benutzer die zahlreichen verfügbaren Pakete für verschiedene Aufgaben nutzen.
Das Video betont die Bedeutung der Verwendung des NumPy-Pakets zusammen mit Matplotlib für wissenschaftliches Rechnen. Während Matplotlib ohne NumPy funktionieren kann, kann die Verwendung von NumPy erheblich Zeit und Aufwand sparen. NumPy bietet ein leistungsstarkes mehrdimensionales Array-Objekt und Funktionen zu dessen Bearbeitung. Im Video wird ein Beispiel gezeigt, in dem mit NumPy eine Kurve mit 100 Punkten generiert wird, um die x- und y-Koordinaten zu berechnen. Dieser Ansatz erweist sich als viel schneller als die Durchführung der Operation mit reinem Python. Darüber hinaus behandelt das Video das Zeichnen zweier Kurven in demselben Diagramm zum Vergleich, das Zeichnen von Daten aus einer Datei durch Extrahieren und Organisieren der Daten mithilfe von Python-Code sowie das lineare Zeichnen von Punkten anstelle von Elementen.
Das Tutorial befasst sich mit der Erstellung verschiedener Arten von Balkendiagrammen mithilfe der Matplotlib-Bibliothek. Die spezielle Funktion zum Erstellen von Balkendiagrammen, „bar“, wird eingeführt, die die x-Koordinate für jeden Balken und die Höhe jedes Balkens als Eingabeparameter verwendet. Durch Anpassen optionaler Parameter können Benutzer verschiedene Effekte erzeugen und mithilfe der „barh“-Funktion sogar horizontale Balken erzeugen. Das Tutorial behandelt auch das Zeichnen mehrerer Balkendiagramme im selben Diagramm und das Erstellen gestapelter Balken mithilfe eines speziellen Parameters in der Funktion „bar“. Darüber hinaus wird im Video kurz auf die Erstellung von Tortendiagrammen mit der „Pie“-Funktion eingegangen.
Im Tutorial werden verschiedene Funktionen erläutert, die bei der Datenvisualisierung mit Matplotlib verwendet werden. Die erste abgedeckte Funktion sind Histogramme, bei denen es sich um grafische Darstellungen von Wahrscheinlichkeitsverteilungen handelt. Die Funktion „hist“ und ihre Parameter werden besprochen, sodass Benutzer Daten einfach als Histogramme darstellen können. Die zweite abgedeckte Funktion sind Boxplots, die den Vergleich von Werteverteilungen erleichtern. Das Video erklärt die Komponenten eines Boxplots, einschließlich Quartile, Median, Mittelwert und statistische Größen eines Datensatzes, und zeigt, wie diese mithilfe der „Boxplot“-Funktion generiert werden. Abschließend behandelt das Tutorial das Ändern von Diagrammen durch die Verwendung verschiedener Farben und Stile, z. B. das Definieren von Farben mithilfe von Tripletts, Quadruplets oder HTML-Farbnamen sowie das Festlegen der Farbe eines Kurvendiagramms.
Im Video wird weiterhin erläutert, wie Sie mithilfe des Parameters „Farbe“ Farbe zu Streudiagrammen, Balkendiagrammen und Kreisdiagrammen hinzufügen. Mit diesem Parameter können Benutzer einzelne Punktfarben steuern oder die gemeinsame Farbe für alle Punkte ändern. Das Video geht außerdem auf den Import von Bibliotheken als Module, die Verwendung von Aliasen zur einfacheren Codierung und die Erläuterung der Darstellung von Variablen ein. Es wird betont, dass fast alles in Matplotlib und Python Funktionen beinhaltet, wie zum Beispiel die Funktion „pi“ und die Funktion „show“.
Als nächstes behandelt das Tutorial benutzerdefinierte Farbschemata und Linienmuster beim Erstellen von Boxplots, Markierungen und Linienformen. Es zeigt das Erstellen benutzerdefinierter Markierungen mithilfe vordefinierter Formen und das Definieren benutzerdefinierter Markierungen mithilfe mathematischer Textsymbole. Darüber hinaus wird erläutert, wie die Standardeinstellungen von Matplotlib mithilfe des zentralisierten Konfigurationsobjekts einfach geändert werden können, sodass Benutzer den visuellen Stil, z. B. einen schwarzen Hintergrund und weiße Anmerkungen, an verschiedene Nutzungskontexte anpassen können.
Der Moderator erklärt, wie man ein Diagramm mithilfe der Funktion „savefig“ in Matplotlib in einer Datei speichert. Sie behandeln auch das Hinzufügen von Anmerkungen zu einem Diagramm, einschließlich eines Titels, Beschriftungen für die x- und y-Achse, eines begrenzten Rahmens und Pfeilen. Das Video zeigt den Prozess des Hinzufügens dieser Anmerkungen, um die visuelle Klarheit und das Verständnis des Diagramms zu verbessern. Darüber hinaus wird gezeigt, wie Sie den Tick-Abstand in Matplotlib manuell steuern können, um präzise Anpassungen vorzunehmen. Das Video beleuchtet die verschiedenen Funktionen von Matplotlib, um Diagramme mit Anmerkungen zu versehen und sie für den Leser selbsterklärender zu machen.
Anschließend bespricht der Kursleiter die Datenvisualisierung mit Matplotlib und stellt Seaborn vor, eine High-Level-Schnittstelle zu Matplotlib. Seaborn bietet im Vergleich zu Matplotlib andere Parameter und Funktionalitäten. Der Kursleiter zeigt, wie man mithilfe des integrierten Datensatzes und der Farbkarten von Seaborn Visualisierungen erstellt. Das Video schließt mit der Präsentation von Beispielen für die Erstellung eines Faktordiagramms und die Verwendung von Farbkarten zur Darstellung von Daten. Anhand dieser Beispiele erhalten Zuschauer Einblicke in die Verwendung verschiedener Funktionen und Tools in Matplotlib und Seaborn, um ihre Datenvisualisierungsfähigkeiten zu verbessern.
Das Video erklärt, wie Diagramme mit der Funktion „set_context“ von Seaborn skaliert werden. Mit dieser Funktion können Benutzer Plotelemente, wie z. B. die Größe, basierend auf dem Kontext steuern, in dem der Plot angezeigt wird. Anschließend wird die Unterscheidung zwischen den beiden Funktionstypen von Seaborn verdeutlicht: Funktionen auf Achsenebene und Funktionen auf Figurenebene. Funktionen auf Achsenebene arbeiten auf der Achsenebene und geben das Achsenobjekt zurück, während Funktionen auf Figurenebene Diagramme erstellen, die auf sinnvolle Weise organisierte Achsen enthalten. Abschließend bietet das Video Anleitungen zum Festlegen von Achsen für einen Boxplot mithilfe des Matplotlib-Achsen-Subplots-Objekts.
Dieses umfassende Video-Tutorial deckt ein breites Themenspektrum im Zusammenhang mit der Datenvisualisierung mit Matplotlib und Seaborn ab. Zunächst wird die Bedeutung der Datenvisualisierung beim maschinellen Lernen und die Verwendung von Matplotlib als leistungsstarke Bibliothek vorgestellt. Es zeigt, wie Sie Kurven zeichnen, Balkendiagramme erstellen, Histogramme und Boxplots erstellen und Farben, Markierungen und Linienstile anpassen. Das Tutorial behandelt außerdem das Speichern von Diagrammen, das Hinzufügen von Anmerkungen und das Bearbeiten des Teilstrichabstands. Darüber hinaus wird Seaborn als alternatives Visualisierungstool mit eigenen Features und Funktionalitäten vorgestellt. Durch das Befolgen dieses Tutorials können Betrachter ihre Datenvisualisierungsfähigkeiten verbessern und ihre Ergebnisse mithilfe dieser leistungsstarken Python-Bibliotheken effektiv kommunizieren.
Tutorial zu Deep Learning mit Python, TensorFlow und Keras
Tutorial zu Deep Learning mit Python, TensorFlow und Keras
Grüße an alle und willkommen zu einem mit Spannung erwarteten Update zu Deep Learning und Python mit TensorFlow sowie einem neuen Chaos-Tutorial. Es ist über zwei Jahre her, seit ich mich das letzte Mal mit grundlegendem Deep Learning in Python befasst habe, und in dieser Zeit gab es bedeutende Fortschritte. Der Einstieg in Deep Learning und die Arbeit mit Deep-Learning-Modellen ist viel einfacher und zugänglicher geworden.
Wenn Sie daran interessiert sind, sich mit dem TensorFlow-Code auf niedrigerer Ebene und den komplizierten Details zu befassen, können Sie sich immer noch das ältere Video ansehen. Wenn Sie jedoch mit Deep Learning beginnen möchten, müssen Sie das nicht mehr tun, da wir jetzt über benutzerfreundliche High-Level-APIs wie Chaos verfügen, die auf TensorFlow basieren. Diese APIs machen Deep Learning unglaublich einfach und ermöglichen es jedem, auch ohne Vorkenntnisse in Deep Learning, mitzumachen.
In diesem Tutorial werden wir einen kurzen Überblick über neuronale Netze geben. Lassen Sie uns zunächst die Kernkomponenten eines neuronalen Netzwerks verstehen. Das Hauptziel jedes maschinellen Lernmodells, einschließlich neuronaler Netze, besteht darin, Eingaben Ausgaben zuzuordnen. Beispielsweise möchten wir anhand der Eingaben X1, X2 und X3 bestimmen, ob die Ausgabe einem Hund oder einer Katze entspricht. In diesem Fall besteht die Ausgabeschicht aus zwei Neuronen, die die Möglichkeit darstellen, ein Hund oder eine Katze zu sein.
Um diese Zuordnung zu erreichen, können wir eine einzelne verborgene Schicht verwenden, wobei jeder Eingang, X1, X2 und X3, mit den Neuronen in der verborgenen Schicht verbunden ist. Jeder dieser Verbindungen ist ein einzigartiges Gewicht zugeordnet. Wenn wir uns jedoch auf eine einzige verborgene Ebene beschränken, wären die Beziehungen zwischen den Eingaben und der Ausgabe linear. Um nichtlineare Beziehungen zu erfassen, die bei komplexen Problemen häufig vorkommen, benötigen wir zwei oder mehr verborgene Schichten. Ein neuronales Netzwerk mit zwei oder mehr verborgenen Schichten wird oft als tiefes neuronales Netzwerk bezeichnet.
Fügen wir eine weitere verborgene Ebene hinzu und verbinden sie vollständig mit der vorherigen Ebene. Jede Verbindung zwischen den Schichten hat ihr eigenes einzigartiges Gewicht. Letztendlich wird die Ausgabe von der letzten Schicht abgeleitet, wobei jede Verbindung zur Ausgabeschicht ein eindeutiges Gewicht besitzt. Auf der Ebene eines einzelnen Neurons empfängt das Neuron Eingaben, bei denen es sich entweder um die Eingabeschichtwerte (X1, X2, X3) oder um Eingaben von anderen Neuronen handeln kann. Diese Eingaben werden unter Berücksichtigung der zugehörigen Gewichtungen summiert. Zusätzlich wird eine Aktivierungsfunktion angewendet, um zu simulieren, ob das Neuron feuert oder nicht. Zu den gängigen Aktivierungsfunktionen gehören die Schrittfunktion oder die Sigmoidfunktion, die Werte zwischen 0 und 1 zurückgibt. In unserem neuronalen Netzwerk verwendet die Ausgabeschicht eine Sigmoidaktivierungsfunktion, die jeder Klasse (Hund oder Katze) Wahrscheinlichkeiten zuweist. Die Arg max-Funktion wird dann verwendet, um die vorhergesagte Klasse basierend auf der höchsten Wahrscheinlichkeit zu bestimmen.
Nachdem wir nun ein grundlegendes Verständnis neuronaler Netze haben, beginnen wir mit der Erstellung eines solchen Netzes mithilfe von TensorFlow. Stellen Sie zunächst sicher, dass TensorFlow installiert ist, indem Sie den Befehl „pip install --upgrade tensorflow“ ausführen. Sie können TensorFlow als „tf“ importieren und die aktuelle Version mit „tf.version“ überprüfen. Für dieses Tutorial wird Python 3.6 oder höher empfohlen, obwohl TensorFlow voraussichtlich in Zukunft Python 3.7 und spätere Versionen unterstützen wird.
Als Nächstes importieren wir einen Datensatz, mit dem wir arbeiten möchten. Wir verwenden den MNIST-Datensatz, der aus 28x28 Bildern handgeschriebener Ziffern im Bereich von 0 bis 9 besteht. Diese Bilder werden in das neuronale Netzwerk eingespeist und das Netzwerk wird die entsprechende Ziffer vorhersagen. Wir teilen den Datensatz in Trainings- und Testvariablen auf: X_train, Y_train, X_test und Y_test.
Um eine bessere Leistung zu gewährleisten, normalisieren wir die Daten. Die Pixelwerte der Bilder liegen derzeit zwischen 0 und 255, daher skalieren wir sie mit der Funktion TF.keras.utils.normalize zwischen 0 und 1.
Um das Modell zu erstellen, verwenden wir die High-Level-API Chaos, die den Prozess der Erstellung und des Trainings neuronaler Netze in TensorFlow vereinfacht. Chaos bietet ein sequentielles Modell namens Sequential, das es uns ermöglicht, Schichten nacheinander zu stapeln.
Hier ist ein Beispiel dafür, wie Sie mit Chaos ein neuronales Netzwerkmodell erstellen können:
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
Im obigen Code importieren wir die notwendigen Module von TensorFlow und Chaos. Wir erstellen ein sequentielles Modell und fügen ihm mithilfe der Add-Methode Ebenen hinzu. Die erste Ebene ist eine Flatten-Ebene, die die 2D-Eingabe (28 x 28 Bilder) in ein 1D-Array umwandelt. Anschließend fügen wir eine dichte Schicht mit 128 Neuronen und ReLU-Aktivierung hinzu. Schließlich fügen wir eine Ausgabeschicht mit 10 Neuronen (entsprechend den 10 Ziffern) und Softmax-Aktivierung hinzu.
Nachdem wir das Modell definiert haben, kompilieren wir es mit der Kompilierungsmethode. Wir geben den Optimierer (in diesem Fall „adam“), die Verlustfunktion („sparse_categorical_crossentropy“ für die Klassifizierung mehrerer Klassen) und die während des Trainings auszuwertenden Metriken an.
Nachdem wir nun unser Modell definiert und kompiliert haben, können wir es auf dem MNIST-Datensatz trainieren. Wir verwenden die Anpassungsmethode, um das Modell zu trainieren.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
Im obigen Code übergeben wir die Trainingsdaten (X_train und Y_train) zusammen mit der Anzahl der Epochen, für die trainiert werden soll, an die Fit-Methode. Wir stellen auch die Validierungsdaten (X_test und Y_test) bereit, um die Leistung des Modells anhand unsichtbarer Daten während des Trainings zu bewerten.
Nach dem Training des Modells können wir mithilfe der Vorhersagemethode Vorhersagen treffen:
# Make predictions predictions = model.predict(X_test)
Im obigen Code übergeben wir die Testdaten (X_test) an die Vorhersagemethode und sie gibt die vorhergesagten Wahrscheinlichkeiten für jede Klasse zurück.
Dies ist ein kurzer Überblick über den Aufbau und das Training eines neuronalen Netzwerks mithilfe von Chaos in TensorFlow. Sie können verschiedene Ebenen, Aktivierungsfunktionen, Optimierer und andere Parameter weiter erkunden, um Ihr Modell anzupassen.
zusätzliche Techniken und Konzepte im Zusammenhang mit dem Aufbau und Training neuronaler Netze.
Regularisierungstechniken:
Dropout: Dropout ist eine Regularisierungstechnik, die verwendet wird, um eine Überanpassung zu verhindern. Bei jeder Aktualisierung während des Trainings wird ein Teil der Eingabeeinheiten nach dem Zufallsprinzip auf 0 gesetzt, wodurch verhindert wird, dass sich das Modell zu stark auf einen bestimmten Funktionssatz verlässt.
L1- und L2-Regularisierung: L1- und L2-Regularisierung sind Techniken, mit denen der Verlustfunktion eine Strafe hinzugefügt wird, um große Gewichte im Netzwerk zu verhindern. Die L1-Regularisierung fügt den absoluten Wert der Gewichte zur Verlustfunktion hinzu und fördert so die Sparsität, während die L2-Regularisierung die quadrierten Gewichte zur Verlustfunktion hinzufügt und so kleine Gewichte fördert.
Erweiterte Aktivierungsfunktionen:
Leaky ReLU: Leaky ReLU ist eine Aktivierungsfunktion, die das Problem des „sterbenden ReLU“ löst, indem sie eine kleine Steigung für negative Eingaben zulässt. Es führt eine kleine negative Steigung ein, wenn die Eingabe negativ ist, was dazu beiträgt, das Absterben von Neuronen während des Trainings zu verhindern.
Exponentielle Lineareinheit (ELU): ELU ist eine Aktivierungsfunktion, die die Ausgabe für negative Eingaben glättet, sodass die Aktivierung negative Werte annehmen kann. Es hat sich gezeigt, dass es dazu beiträgt, das Lernen neuronaler Netze zu verbessern und die Tendenz zu positiven Werten zu verringern.
Swish: Swish ist eine Aktivierungsfunktion, die eine sanfte Interpolation zwischen der linearen und der Sigmoidfunktion durchführt. Es hat sich gezeigt, dass es in bestimmten Fällen bessere Ergebnisse im Vergleich zu anderen Aktivierungsfunktionen wie ReLU und Sigmoid liefert.
Transferlernen: Transferlernen ist eine Technik, die vorab trainierte Modelle nutzt, um neue Aufgaben zu lösen oder die Leistung eines Modells bei einer verwandten Aufgabe zu verbessern. Anstatt ein Modell von Grund auf zu trainieren, können Sie ein vorab trainiertes Modell als Ausgangspunkt verwenden und es an Ihre spezifische Aufgabe oder Ihren Datensatz anpassen. Dies ist besonders nützlich, wenn Sie nur über begrenzte Daten für Ihre spezifische Aufgabe verfügen.
Hyperparameter-Tuning: Hyperparameter sind Parameter, die vom Modell nicht gelernt werden, sich aber auf den Lernprozess auswirken, wie z. B. Lernrate, Stapelgröße, Anzahl der Schichten usw. Die Optimierung dieser Hyperparameter kann sich erheblich auf die Leistung des Modells auswirken. Techniken wie Rastersuche, Zufallssuche und Bayes'sche Optimierung können verwendet werden, um den Hyperparameterraum systematisch zu durchsuchen und die beste Kombination zu finden.
Modellbewertung: Die Bewertung der Leistung eines Modells ist entscheidend für die Beurteilung seiner Wirksamkeit. Zu den gängigen Bewertungsmetriken für Klassifizierungsaufgaben gehören Genauigkeit, Präzision, Rückruf, F1-Score und Fläche unter der Receiver Operating Characteristic Curve (ROC AUC). Es ist wichtig, die geeigneten Metriken basierend auf dem vorliegenden Problem und der Art der Daten auszuwählen.
Umgang mit unausgeglichenen Datensätzen: Unausgeglichene Datensätze treten auf, wenn die Verteilung der Klassen nicht gleich ist, was zu verzerrten Modellen führen kann. Techniken wie die Überabtastung der Minderheitsklasse, die Unterabtastung der Mehrheitsklasse oder die Verwendung einer Kombination aus beidem können zur Lösung dieses Problems beitragen. Darüber hinaus kann die Verwendung von Bewertungsmetriken wie Präzision, Rückruf und F1-Score ein besseres Verständnis der Leistung des Modells bei unausgeglichenen Datensätzen liefern.
Denken Sie daran, dass der Aufbau und das Training neuronaler Netze ein iterativer Prozess ist. Es erfordert Experimente, Feinabstimmung und kontinuierliche Verbesserung, um die gewünschten Ergebnisse zu erzielen.
Laden Ihrer eigenen Daten – Deep-Learning-Grundlagen mit Python, TensorFlow und Keras S.2
Laden Ihrer eigenen Daten – Deep-Learning-Grundlagen mit Python, TensorFlow und Keras S.2
Willkommen alle zu Teil 2 unseres Deep-Learning-Tutorials zu Python TensorFlow in Karros. In diesem Tutorial konzentrieren wir uns auf das Laden eines externen Datensatzes. Konkret werden wir den Katzen- und Hundedatensatz von Microsoft verwenden, ursprünglich eine Kaggle-Herausforderung. Ziel ist es, ein neuronales Netzwerk darauf zu trainieren, zu erkennen, ob ein Bild eine Katze oder einen Hund enthält.
Laden Sie zunächst den Katzen- und Hundedatensatz von Microsoft herunter. Nachdem Sie den Datensatz heruntergeladen und extrahiert haben, sollten Sie zwei Verzeichnisse sehen: „cat“ und „dog“. Diese Verzeichnisse enthalten Bilder von Katzen bzw. Hunden. Jedes Verzeichnis sollte eine beträchtliche Anzahl von Beispielen enthalten, etwa 12.500, die ausreichend Beispiele für das Training unseres Modells bieten.
Kommen wir nun zum Codierungsteil. Wir müssen mehrere Bibliotheken importieren: numpy als np, matplotlib.pyplot als plt und OpenCV als cv2. Wenn Sie diese Bibliotheken nicht installiert haben, können Sie sie mit pip installieren.
Als nächstes definieren wir das Datenverzeichnis, in dem sich unser Datensatz befindet. Sie können den Pfad zu Ihrem Datensatz entsprechend angeben. Wir werden auch die Kategorien „Hund“ und „Katze“ definieren, um sie an die Verzeichnisse in unserem Datensatz anzupassen.
Wir werden jede Kategorie und die entsprechenden Bilder mithilfe der Betriebssystembibliothek durchlaufen. Für jedes Bild konvertieren wir es mithilfe der cv2-Bibliothek in Graustufen. Wir haben uns für Graustufen entschieden, weil wir glauben, dass die Farbe für die Unterscheidung zwischen Katzen und Hunden bei dieser speziellen Aufgabe nicht ausschlaggebend ist.
Zur Visualisierung der Bilder verwenden wir matplotlib.pyplot. Wir zeigen ein Beispielbild mit plt.imshow und der Graustufen-Farbkarte an. Mit diesem Schritt können wir bestätigen, dass die Bilder korrekt geladen wurden.
Nachdem wir die Bilder überprüft haben, werden wir sie auf eine einheitliche Form anpassen. Wir müssen uns für eine Zielgröße entscheiden, beispielsweise 50 x 50 Pixel, um die Konsistenz sicherzustellen. Wir ändern die Größe der Bilder mit der Funktion cv2.resize und speichern die in der Größe geänderten Bildarrays.
Jetzt erstellen wir den Trainingsdatensatz. Wir initialisieren eine leere Liste namens „training_data“ und definieren eine Funktion namens „create_training_data“. Innerhalb dieser Funktion durchlaufen wir die Bilder und weisen numerische Beschriftungen zu (0 für Hunde, 1 für Katzen), indem wir den Index der Kategorie in der Liste „Kategorien“ verwenden.
Für jedes Bild ändern wir die Größe auf die gewählte Zielgröße. Wir hängen das in der Größe geänderte Bildarray und die entsprechende Beschriftung an die Liste „training_data“ an. Wir kümmern uns auch um alle potenziellen Ausnahmen im Zusammenhang mit fehlerhaften Bildern im Datensatz.
Sobald wir den Trainingsdatensatz erstellt haben, sollten wir die Ausgewogenheit der Daten überprüfen. Bei einer binären Klassifizierungsaufgabe wie dieser ist es wichtig, für jede Klasse die gleiche Anzahl von Stichproben zu haben (50 % Hunde und 50 % Katzen). Unausgeglichene Daten können zu verzerrten Modellvorhersagen führen. Wenn Ihre Daten unausgeglichen sind, können Sie während des Trainings Klassengewichtungen verwenden, um dieses Problem zu entschärfen.
Um die Zufälligkeit sicherzustellen und zu verhindern, dass das Modell die Reihenfolge der Bilder lernt, mischen wir die Trainingsdaten mithilfe der Funktion „random.shuffle“.
Nachdem unsere Daten nun gemischt sind, können wir sie in Variablen für Features (X) und Beschriftungen (Y) packen. Wir initialisieren leere Listen für X und Y, durchlaufen die Trainingsdaten und hängen die Features und Beschriftungen an die jeweiligen Listen an. Schließlich konvertieren wir X in ein NumPy-Array und formen es mithilfe von np.array und der Form jedes Features um.
Zu diesem Zeitpunkt haben wir unsere Daten für das Training des neuronalen Netzwerks vorbereitet. Wir sind nun bereit, mit weiteren Schritten fortzufahren, wie der Aufteilung der Daten in Trainings- und Validierungssätze, dem Aufbau des Modells und dem Training mit TensorFlow.
Negativ 1 ist ein Platzhalter, der die Größe automatisch basierend auf der Länge des Arrays und der Form jedes Elements berechnet. In diesem Fall formen wir das X-Array so um, dass es die Form (-1, Bildgröße, Bildgröße) hat. Dadurch wird sichergestellt, dass die Daten im richtigen Format vorliegen, um in das neuronale Netzwerk eingespeist zu werden.
Als nächstes müssen wir die Pixelwerte der Bilder normalisieren. Derzeit liegen die Pixelwerte zwischen 0 und 255 und stellen die Intensität der Graustufen dar. Neuronale Netze erbringen im Allgemeinen eine bessere Leistung, wenn die Eingabedaten normalisiert werden, d. h. die Werte werden auf einen kleineren Bereich skaliert. Dies erreichen wir, indem wir die Pixelwerte durch 255,0 dividieren, wodurch sie auf einen Wert zwischen 0 und 1,0 skaliert werden. Dies kann mit dem folgenden Code erfolgen:
x = x / 255.0
Faltungs-Neuronale Netze – Grundlagen des Deep Learning mit Python, TensorFlow und Keras S.3
Faltungs-Neuronale Netze – Grundlagen des Deep Learning mit Python, TensorFlow und Keras S.3
Hallo zusammen und willkommen zum dritten Teil unserer Tutorialreihe „Deep Learning mit Python, TensorFlow und Keras“. In diesem Video konzentrieren wir uns auf Faltungs-Neuronale Netze (CNNs) und wie man sie mithilfe des Datensatzes, den wir im vorherigen Video erstellt haben, zur Klassifizierung von Hunden und Katzen anwenden kann.
Bevor wir uns mit CNNs befassen, wollen wir kurz erläutern, wie sie funktionieren und warum sie für Bilddaten nützlich sind. CNNs umfassen mehrere Schritte: Faltung, Pooling und dann noch mehr Faltung und Pooling. Die Hauptidee der Faltung besteht darin, nützliche Merkmale aus einem Bild zu extrahieren. Wir verwenden ein Faltungsfenster, das normalerweise als Matrix (z. B. 3x3) dargestellt wird, um das Bild zu scannen und die Informationen im Fenster auf einen einzigen Wert zu vereinfachen. Das Fenster verschiebt sich dann und wiederholt diesen Vorgang mehrmals. Der Schritt, der bestimmt, wie weit sich das Fenster bewegt, kann ebenfalls angepasst werden.
Mit Keras können wir die Fenstergröße festlegen und die meisten anderen Details werden automatisch erledigt. Wenn Sie tiefer in die Feinheiten des Deep Learning eintauchen möchten, empfehle ich Ihnen, sich die Tutorialreihe „Praktisches maschinelles Lernen“ anzusehen, in der das Innenleben ausführlicher erklärt wird, insbesondere für rohen TensorFlow-Code.
Die Ausgabe der Faltungsschicht ist eine Reihe von Merkmalen, die aus dem Bild extrahiert werden. Diese Features werden dann typischerweise durch eine Pooling-Schicht geleitet, wobei der häufigste Typ das Max-Pooling ist. Max-Pooling wählt den Maximalwert innerhalb eines Fensters aus und verschiebt ihn wiederholt, wodurch die Daten effektiv heruntergerechnet werden.
Die übergeordnete Idee hinter CNNs besteht darin, dass sie nach und nach komplexere Merkmale aus dem Bild extrahieren, je tiefer man in das Netzwerk vordringt. Die ersten Ebenen identifizieren möglicherweise Kanten und Linien, während tiefere Ebenen möglicherweise komplexere Formen wie Kreise oder Quadrate erkennen. Schließlich kann das Netzwerk lernen, bestimmte Objekte oder Muster zu identifizieren.
Um ein CNN zu implementieren, müssen wir die notwendigen Bibliotheken importieren. Wir importieren TensorFlow und die Keras-Module, die wir verwenden werden, wie z. B. Sequential, Dense, Dropout, Activation, Conv2D und MaxPooling2D. Wir importieren auch Pickle, um unseren Datensatz zu laden.
Bevor wir die Daten in das neuronale Netzwerk einspeisen, sollten wir über eine Normalisierung nachdenken. In unserem Fall können wir die Pixeldaten skalieren, indem wir sie durch 255 teilen, da die Pixelwerte zwischen 0 und 255 liegen. Alternativ können wir für komplexere Normalisierungsszenarien die Normalisierungsfunktion von chaos.utils verwenden.
Als Nächstes beginnen wir mit der Erstellung unseres Modells mithilfe der Sequential API. Wir fügen eine Conv2D-Ebene mit 64 Einheiten und einer Fenstergröße von 3x3 hinzu. Der input_shape wird dynamisch mithilfe von X.shape festgelegt. Anschließend fügen wir eine Aktivierungsschicht mithilfe der gleichgerichteten linearen Aktivierungsfunktion (ReLU) hinzu. Anschließend fügen wir eine maximale Pooling-Ebene mit einer Fenstergröße von 2x2 hinzu.
Wir wiederholen diesen Vorgang, indem wir eine weitere Conv2D-Ebene und eine entsprechende Max-Pooling-Ebene hinzufügen. Zu diesem Zeitpunkt haben wir ein 2D-Faltungs-Neuronales Netzwerk.
Um die extrahierten Features an eine vollständig verbundene Ebene zu übergeben, müssen wir die Daten reduzieren. Wir fügen eine Flatten-Ebene hinzu, bevor wir eine letzte Dense-Ebene mit 64 Knoten hinzufügen. Schließlich fügen wir eine Ausgabeebene mit einem einzelnen Knoten hinzu und geben die Aktivierungsfunktion an, die entweder kategorisch oder binär sein kann.
Wir kompilieren das Modell, indem wir die Verlustfunktion (kategoriale oder binäre Kreuzentropie), den Optimierer (z. B. Adam) und die Metriken zur Bewertung der Leistung des Modells (z. B. Genauigkeit) angeben.
Um das Modell zu trainieren, verwenden wir die Fit-Methode und übergeben unsere Eingabedaten X und Beschriftungen Y. Wir können auch die Batch-Größe angeben (z. B. 32).
Wir verwenden den folgenden Code, um das Modell zu trainieren:
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Dieser Code trainiert das Modell mithilfe der Eingabedaten X und der entsprechenden Beschriftungen Y. Wir legen die Stapelgröße auf 32 fest, was bedeutet, dass das Modell während des Trainings jeweils 32 Proben verarbeitet. Der Parameter validation_split ist auf 0,1 gesetzt, was bedeutet, dass 10 % der Daten für die Validierung beim Training des Modells verwendet werden.
Sobald das Modell trainiert ist, können wir seine Leistung anhand der Testdaten bewerten. Wir können den folgenden Code verwenden, um das Modell auszuwerten:
model.evaluate(X_test, Y_test)
Hier repräsentieren X_test und Y_test die Testdaten bzw. Beschriftungen. Dieser Code gibt den Verlustwert und die Genauigkeit des Modells anhand der Testdaten zurück.
Nachdem wir das Modell ausgewertet haben, können wir damit Vorhersagen zu neuen, noch nie gesehenen Daten treffen. Wir können die Funktion „predict()“ verwenden, um die vorhergesagten Beschriftungen für die neuen Daten zu erhalten. Hier ist ein Beispiel:
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
Das ist es! Sie haben nun ein Faltungsmodell eines neuronalen Netzwerks trainiert, um Hunde und Katzen zu klassifizieren, und es verwendet, um Vorhersagen auf der Grundlage neuer Daten zu treffen. Denken Sie daran, das trainierte Modell bei Bedarf für die zukünftige Verwendung zu speichern.
Modelle mit TensorBoard analysieren – Deep Learning mit Python, TensorFlow und Keras S.4
Modelle mit TensorBoard analysieren – Deep Learning mit Python, TensorFlow und Keras S.4
Willkommen an alle, zu Teil 4 der Tutorialreihe „Deep Learning mit Python: TensorFlow und Keras“. In diesem und dem nächsten Video besprechen wir, wie wir unsere Modelle mit TensorBoard analysieren und optimieren. TensorBoard ist ein leistungsstarkes Tool, mit dem wir das Training unserer Modelle im Zeitverlauf visualisieren können. Sein Hauptzweck besteht darin, uns dabei zu helfen, verschiedene Aspekte der Leistung unseres Modells zu verstehen, wie z. B. Genauigkeit, Validierungsgenauigkeit, Verlust und Validierungsverlust. Darüber hinaus gibt es in TensorBoard erweiterte Funktionen, die wir möglicherweise in zukünftigen Tutorials untersuchen.
Bevor wir uns mit TensorBoard befassen, wollen wir uns mit einem kleinen Detail befassen. Obwohl dies für dieses Tutorial nicht entscheidend ist, möchte ich darauf hinweisen, dass selbst kleine Modelle dazu neigen, eine erhebliche Menge an GPU-Speicher zu verbrauchen. Wenn Sie mehrere Modelle gleichzeitig ausführen möchten, können Sie einen Bruchteil des GPU-Speichers angeben, den jedes Modell verwenden soll. Auf diese Weise können Sie potenzielle Probleme vermeiden, wenn Sie mehrere Modelle ausführen oder auf Speicherbeschränkungen stoßen. Normalerweise stelle ich das Modell beispielsweise so ein, dass es ein Drittel des GPU-Speichers nutzt. Dieser Ansatz hat sich als hilfreich erwiesen, wenn mehrere Modelle gleichzeitig ausgeführt werden, beispielsweise in der „Python Plays GTA“-Reihe, bei der es um Objekterkennung und autonomes Fahren geht. Es ist nur ein praktischer Tipp, der Ihnen Zeit und Kopfschmerzen ersparen kann.
Kommen wir nun zum Hauptthema. Das erste, was ich ansprechen möchte, ist das Hinzufügen einer Aktivierungsfunktion nach der dichten Ebene. Es war ein Versehen meinerseits, es zunächst nicht aufzunehmen. Das Hinzufügen einer Aktivierungsfunktion ist unerlässlich, da die dichte Schicht ohne sie zu einer linearen Aktivierungsfunktion wird, die für unsere Zwecke nicht geeignet ist. Wir möchten eine Regression vermeiden und sicherstellen, dass unser Modell optimal funktioniert. Lassen Sie uns das also schnell beheben, indem wir die Aktivierungsfunktion vor der dichten Ebene einfügen.
Mit dieser Korrektur sollten wir eine deutliche Verbesserung der Genauigkeit feststellen. Während das Modell trainiert, nehmen wir uns einen Moment Zeit, um die TensorFlow-Dokumentation zu erkunden und mehr über die verschiedenen verfügbaren Keras-Rückrufe zu erfahren. In unserem Fall verwenden wir den TensorBoard-Rückruf als Schnittstelle zu TensorBoard. Es ist jedoch anzumerken, dass es noch andere nützliche Rückrufe gibt, wie z. B. das frühzeitige Anhalten auf der Grundlage bestimmter Parameter, die Planung der Lernrate und die Erstellung von Modellprüfpunkten. Das Modell-Checkpointing ist besonders wertvoll, wenn Sie das Modell in bestimmten Intervallen speichern möchten, beispielsweise zum besten Verlust oder zur besten Validierungsgenauigkeit. Konzentrieren wir uns vorerst auf den TensorBoard-Rückruf, aber ich werde vielleicht in einem zukünftigen Video kurz auf andere Rückrufe eingehen.
Um den TensorBoard-Rückruf zu verwenden, müssen wir ihn aus dem Keras-Rückrufmodul von TensorFlow importieren. Fügen Sie die folgende Codezeile hinzu, um TensorBoard zu importieren:
from tensorflow.keras.callbacks import TensorBoard
Nachdem wir nun das erforderliche Modul importiert haben, beginnen wir mit der Reinigung. Es empfiehlt sich immer, Ihrem Modell einen aussagekräftigen Namen zu geben, insbesondere wenn Sie mit mehreren Modellen arbeiten. In diesem Fall können wir unser Modell etwa „cats_vs_dogs_CNN_64x2“ nennen. Fügen wir dem Namen außerdem einen Zeitstempel hinzu, um die Eindeutigkeit sicherzustellen. Das Einbeziehen des Zeitstempels ist nützlich, wenn Sie ein Modell erneut trainieren oder Verwechslungen mit Modellversionen vermeiden möchten. Definieren wir also zu Beginn unseres Codes den Modellnamen und den Zeitstempel wie folgt:
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
Darüber hinaus ermöglicht uns das Tensorboard die Analyse und Optimierung unserer Modelle durch die Bereitstellung von Visualisierungen des Trainingsprozesses. Es konzentriert sich hauptsächlich auf Metriken wie Genauigkeit, Validierungsgenauigkeit, Verlust und Validierungsverlust. Mithilfe dieser Kennzahlen können wir verstehen, wie sich unser Modell im Laufe der Zeit entwickelt, und Bereiche mit Verbesserungspotenzial identifizieren. Während Genauigkeit und Verlust üblicherweise überwacht werden, bietet das Tensorboard erweiterte Funktionen, die wir möglicherweise in Zukunft erkunden werden.
Um mit der Verwendung des Tensorboards beginnen zu können, müssen wir zunächst eine kleine Ergänzung zu unserem Code vornehmen. Obwohl es für dieses Tutorial nicht entscheidend ist, ist es dennoch erwähnenswert. Durch das Hinzufügen einiger Codezeilen können wir unserem Modell einen bestimmten Teil des GPU-Speichers zuweisen. Dies ist von Vorteil, wenn mehrere Modelle gleichzeitig ausgeführt werden oder Probleme mit dem VRAM auftreten. Dadurch können wir die GPU-Zuweisung steuern und mögliche Abstürze oder Speicherüberläufe vermeiden. In unserem Fall weisen wir dem Modell ein Drittel der GPU zu. Dies gewährleistet eine reibungslose Ausführung und verhindert Konflikte bei der Arbeit mit anderen Modellen oder Projekten.
Konzentrieren wir uns nun auf die Implementierung des Tensorboards. Zunächst müssen wir die notwendigen Abhängigkeiten importieren. Wir importieren das Modul „tensorboard“ aus dem Paket „tensorflow.keras.callbacks“. Dieses Modul bietet die Callback-Funktionalität für das Tensor-Board.
Als nächstes wollen wir unserem Modell einen aussagekräftigen Namen geben. Wenn Sie mit mehreren Modellen arbeiten, ist es wichtig, jedem Modell einen eindeutigen Namen zu geben. Es hilft uns, den Überblick über die Experimente zu behalten und Verwirrung zu vermeiden. In diesem Fall nennen wir unser Modell „cat's_first_dog_CNN_64x2_good_enough“. Zusätzlich fügen wir dem Namen einen Zeitstempel hinzu, der den aktuellen Zeitwert verwendet. Dies stellt die Einzigartigkeit sicher und verhindert ein versehentliches Überschreiben von Modellen.
Nachdem wir unserem Modell einen Namen gegeben haben, können wir das Tensor-Board-Callback-Objekt definieren. Wir erstellen eine Instanz der Klasse „TensorBoard“ und weisen diese der Variablen „tensorboard“ zu. Wir übergeben den Protokollverzeichnispfad an den Konstruktor. Im Protokollverzeichnis speichert das Tensor-Board die Protokolle und Daten zu unserem Modell. Wir verwenden eine Zeichenfolgenformatierung, um den Modellnamen in den Protokollverzeichnispfad aufzunehmen.
Sobald wir das Callback-Objekt bereit haben, können wir es in unseren Modelltrainingsprozess integrieren. In der „fit“-Methode unseres Modells übergeben wir das Callback-Objekt als Liste an den „callbacks“-Parameter. In diesem Fall haben wir nur einen Rückruf, nämlich den Tensor-Board-Rückruf. Beachten Sie jedoch, dass Sie bei Bedarf mehrere Rückrufe in die Liste aufnehmen können.
Mit dem integrierten Callback können wir nun unser Modell trainieren. Für dieses Beispiel legen wir die Anzahl der Epochen auf 10 fest. Sie können die Anzahl der Epochen jedoch jederzeit an Ihre Anforderungen anpassen. Während das Modell trainiert, beginnt das Tensor-Board mit der Generierung von Protokollen und Visualisierungen basierend auf den angegebenen Metriken.
Um das Tensor-Board in Aktion zu sehen, müssen wir das Befehlsfenster oder Terminal öffnen und zu dem Verzeichnis navigieren, das die Protokolldateien enthält. Sobald wir im richtigen Verzeichnis sind, führen wir den Tensor-Board-Befehl aus, indem wir „tensorboard --logdir logs“ in die Eingabeaufforderung eingeben. Dieser Befehl initiiert den Tensor-Board-Server und stellt eine lokale URL bereit, über die wir auf die Tensor-Board-Schnittstelle zugreifen können.
Nachdem wir Tensor Board gestartet haben, können wir einen Webbrowser öffnen und die von der Eingabeaufforderung bereitgestellte URL eingeben. Dadurch wird die Tensor-Board-Schnittstelle angezeigt, auf der wir den Trainingsfortschritt unseres Modells visualisieren können. Die Schnittstelle zeigt verschiedene Diagramme an, darunter In-Sample-Genauigkeit, In-Sample-Verlust, Out-of-Sample-Genauigkeit und Out-of-Sample-Verlust. Wir analysieren diese Metriken, um die Leistung des Modells zu überwachen und fundierte Entscheidungen hinsichtlich seiner Optimierung zu treffen.
Durch die Betrachtung der Diagramme können wir Muster und Trends im Verhalten des Modells erkennen. Wenn beispielsweise der Validierungsverlust zunimmt, während die Validierungsgenauigkeit gleich bleibt oder abnimmt, deutet dies auf eine Überanpassung hin. Wenn sich andererseits sowohl die Validierungsgenauigkeit als auch der Verlust mit der Zeit verbessern, deutet dies darauf hin, dass das Modell effektiv lernt.
Das Tensor-Board bietet eine leistungsstarke Plattform zur Analyse und Optimierung von Modellen. Seine Visualisierungen bieten wertvolle Einblicke in den Trainingsprozess und erleichtern die Entscheidungsfindung. Durch den Einsatz von Tensorboards können wir den Modellentwicklungsprozess rationalisieren und bessere Ergebnisse erzielen.
Im nächsten Teil dieser Tutorialreihe werden wir uns eingehender mit den erweiterten Funktionen des Tensorboards befassen, einschließlich Histogrammen, Verteilungen und Einbettungen. Diese Funktionen sorgen für eine weitere Granularität und ermöglichen uns ein umfassenderes Verständnis unserer Modelle. Seien Sie gespannt auf das nächste Video, in dem wir diese aufregenden Funktionen erkunden.
Das war’s für dieses Tutorial. Vielen Dank fürs Zuschauen, wir sehen uns im nächsten Video!
Optimierung mit TensorBoard – Deep Learning mit Python, TensorFlow und Keras S.5
Optimierung mit TensorBoard – Deep Learning mit Python, TensorFlow und Keras S.5
Hallo zusammen und willkommen zum fünften Teil der Tutorialreihe „Deep Learning mit Python TensorBoard und Keras“. In diesem Tutorial konzentrieren wir uns auf TensorBoard und wie wir es zur Optimierung von Modellen verwenden können, indem wir verschiedene Modellversuche visualisieren. Lasst uns eintauchen!
Lassen Sie uns zunächst das Modell analysieren und die Aspekte identifizieren, die wir optimieren können, um seine Leistung zu verbessern. Obwohl unser aktuelles Modell eine Genauigkeit von etwa 79 % erreichte, glauben wir, dass wir es noch besser machen können. Einige potenzielle Optimierungsbereiche umfassen den Optimierer, die Lernrate, die Anzahl dichter Schichten, Einheiten pro Schicht, Aktivierungseinheiten, Kernelgröße, Schrittweite, Abklingrate und mehr. Da es zahlreiche Optionen zu erkunden gilt, können wir am Ende Tausende von Modellen testen. Also, wo fangen wir an?
Der Einfachheit halber beginnen wir mit den einfachsten Änderungen. Wir konzentrieren uns auf die Anpassung der Anzahl der Ebenen, der Knoten pro Ebene und darauf, ob am Ende eine dichte Ebene eingefügt werden soll oder nicht. Als Anzahl der dichten Schichten gehen wir von null, eins oder zwei aus. Bezüglich der Ebenengrößen verwenden wir die Werte 32, 64 und 128. Bei diesen Werten handelt es sich lediglich um Konventionen, und Sie können je nach Ihren Vorlieben unterschiedliche Werte auswählen.
Lassen Sie uns nun diese Änderungen in unserem Code implementieren. Wir definieren einige Variablen für die Auswahl, die wir treffen möchten, beispielsweise die Anzahl der dichten Schichten und Schichtgrößen. Wir werden diese Variablen durchlaufen, um verschiedene Modellkombinationen zu erstellen. Darüber hinaus erstellen wir für jedes Modell einen Namen, der seine Konfiguration widerspiegelt.
Sobald wir die Modellkonfigurationen haben, können wir sie in unserem Code anwenden. Wir aktualisieren die Modellstruktur entsprechend und berücksichtigen dabei die Eingabeform, die Faltungsschichten, die dichten Schichten und die Ausgabeschicht. Wir sorgen auch dafür, dass die Ebenengrößen entsprechend angepasst werden.
Nachdem alle Änderungen vorgenommen wurden, ist es an der Zeit, den Code auszuführen. Da das Training zahlreicher Modelle jedoch zeitaufwändig sein kann, habe ich den Code bereits ausgeführt und die Ergebnisse gespeichert. Lassen Sie uns mit der Analyse der Ergebnisse mit TensorBoard fortfahren.
Wir laden die TensorBoard-Protokolle und beobachten die verschiedenen Modellkombinationen. Die Modelle sind nach ihrer Leistung organisiert, insbesondere nach dem Validierungsverlust. Wir konzentrieren uns auf die leistungsstärksten Modelle und notieren deren Konfigurationen.
Aus den Ergebnissen geht hervor, dass Modelle mit drei Faltungsschichten und null dichten Schichten durchweg eine gute Leistung erbringen. Die spezifische Anzahl der Knoten pro Schicht scheint weniger bedeutsam zu sein. Es ist jedoch zu beachten, dass größere dichte Schichten, z. B. 512 oder 256 Knoten, möglicherweise noch bessere Ergebnisse liefern. Um dies zu überprüfen, können Sie verschiedene dichte Schichtgrößen testen.
Zusammenfassend haben wir zunächst verschiedene Modellkonfigurationen mit TensorBoard untersucht. Wir haben festgestellt, dass Modelle mit drei Faltungsschichten und ohne dichte Schichten durchweg eine gute Leistung erbringen. Wir haben auch festgestellt, dass die Anzahl der Knoten pro Schicht weiter optimiert werden könnte. Durch das Testen verschiedener dichter Schichtgrößen können wir die Genauigkeit des Modells möglicherweise noch weiter verbessern.
Bedenken Sie, dass dies nur ein Ausgangspunkt ist und es viele andere Aspekte gibt, die Sie optimieren können, um Ihre Modelle zu optimieren. TensorBoard bietet ein wertvolles Tool zur Visualisierung und Analyse dieser Modellvariationen und hilft Ihnen, fundierte Entscheidungen zur Modellverbesserung zu treffen.
So verwenden Sie Ihr trainiertes Modell – Deep Learning-Grundlagen mit Python, TensorFlow und Keras S.6
So verwenden Sie Ihr trainiertes Modell – Deep Learning-Grundlagen mit Python, TensorFlow und Keras S.6
Hallo zusammen und willkommen zu Teil 6 der Tutorialreihe „Deep Learning in Python mit TensorFlow und Keras“!
In diesem Video besprechen wir, wie wir unser trainiertes Modell verwenden können, um Vorhersagen für neue Bilder zu treffen. Viele Leute haben danach gefragt, da sie ihre Datensätze erfolgreich trainiert und getestet haben, sich aber nicht sicher sind, wie sie das Modell für Vorhersagen auf externen Bildern verwenden sollen. Also, lasst uns eintauchen!
Zuerst müssen wir die notwendigen Bibliotheken importieren. Wir importieren cv2 für die Bildverarbeitung und Tensorflow als TF für die Arbeit mit unserem Modell. Wir benötigen außerdem die Kategorienliste, die die Klassenbezeichnungen „Hund“ und „Katze“ enthält, die wir während des Trainings verwendet haben.
Als Nächstes definieren wir eine Funktion namens „prepare“, die einen Dateipfad als Parameter verwendet. Diese Funktion übernimmt die für das Eingabebild erforderlichen Vorverarbeitungsschritte. Wir ändern die Größe des Bildes auf eine bestimmte Größe und konvertieren es in Graustufen. Das Bild wird dann als umgeformtes Numpy-Array zurückgegeben.
Danach laden wir unser trainiertes Modell mit der Funktion TF.keras.models.load_model(). Zuvor haben wir unser Modell als „64 x 3 CNN-Modell“ gespeichert, daher laden wir es unter demselben Namen.
Jetzt sind wir bereit, Vorhersagen zu treffen. Wir definieren eine Variable namens „prediction“ und weisen ihr das Ergebnis des Aufrufs von „model.predict()“ für unser vorbereitetes Bild zu. Es ist wichtig zu beachten, dass die Methode „predict()“ eine Liste als Eingabe erwartet, auch wenn wir eine Vorhersage für ein einzelnes Bild treffen. Wir müssen also das vorbereitete Bild als Liste übergeben.
Sobald wir das Vorhersageergebnis haben, können wir es ausdrucken. Allerdings liegt die Vorhersage derzeit in Form einer verschachtelten Liste vor. Um die Lesbarkeit zu verbessern, können wir den Vorhersagewert in eine Ganzzahl umwandeln und ihn als Index verwenden, um die entsprechende Klassenbezeichnung aus der Kategorienliste abzurufen.
Schließlich können wir die vorhergesagte Klassenbezeichnung ausdrucken, die angibt, ob das Bild als Hund oder Katze klassifiziert ist.
In diesem Tutorial haben wir zwei externe Bilder zum Testen unseres Modells verwendet: eines von einem Hund mit einem Schamkegel und ein anderes von einer unbekannten Kreatur. Diese Bilder waren nicht Teil unseres Trainingsdatensatzes, wodurch sichergestellt wird, dass wir Vorhersagen auf der Grundlage unsichtbarer Daten treffen.
Um es mit Ihren eigenen Hunde- und Katzenbildern auszuprobieren, befolgen Sie die im Code beschriebenen Schritte. Beachten Sie, dass die Genauigkeit variieren kann, im Durchschnitt jedoch bei etwa 80 % liegen sollte.
Das ist alles für jetzt! Ich möchte unseren jüngsten Sponsoren danken: Michael, Nick, Rodrigo und Papasan E. Wir wissen Ihre Unterstützung sehr zu schätzen. Wenn Sie Fragen, Kommentare oder Vorschläge für zukünftige Tutorials haben, hinterlassen Sie diese bitte unten. Ich bin auch offen für Ideen zur Verwendung wiederkehrender neuronaler Netze. Wenn Sie also einen einfachen Datensatz im Sinn haben, lassen Sie es mich wissen.
Wir sehen uns im nächsten Tutorial, in dem wir uns mit wiederkehrenden neuronalen Netzen befassen. Bis dahin viel Spaß beim Codieren!
Rekurrente neuronale Netze (RNN) – Deep Learning mit Python, TensorFlow und Keras S.7
Rekurrente neuronale Netze (RNN) – Deep Learning mit Python, TensorFlow und Keras S.7
Hallo zusammen und willkommen zu Teil 7 der Tutorialreihe „Deep Learning mit Python TensorFlow in Chaos“. In diesem Teil konzentrieren wir uns auf das rekurrente neuronale Netzwerk (RNN). Der Zweck eines RNN besteht darin, die Bedeutung und Wichtigkeit der Datenreihenfolge zu erfassen. Dies ist besonders relevant bei Zeitreihendaten, bei denen Daten zeitlich organisiert sind, und bei der Verarbeitung natürlicher Sprache, bei der die Reihenfolge der Wörter in einem Satz eine Bedeutung hat.
Um das Konzept zu veranschaulichen, betrachten wir das Beispiel eines Satzes: „Einige Leute haben ein neuronales Netzwerk geschaffen.“ Wenn dieser Satz von einem tiefen neuronalen Netzwerk verarbeitet wird, das die Daten normalerweise durch Aufteilen in einzelne Wörter tokenisiert, kann es sein, dass das Netzwerk die korrekte Bedeutung nicht erfasst. Beispielsweise hat der Satz „Ein neuronales Netzwerk hat einige Menschen geschaffen“ eine ganz andere Bedeutung. Dies unterstreicht die Bedeutung der Reihenfolge der Wörter für die Bedeutung eines Satzes.
Lassen Sie uns nun in die Funktionsweise eines rekurrenten neuronalen Netzwerks eintauchen. Der Grundbaustein eines RNN ist die wiederkehrende Zelle, die häufig mithilfe einer LSTM-Zelle (Long Short-Term Memory) implementiert wird. Obwohl andere Optionen wie die Gated Recurrent Unit (GRU) existieren, wird häufig die LSTM-Zelle verwendet. In einem RNN nimmt jede Zelle sequentielle Daten als Eingabe und gibt sie an die nächste Schicht oder die nächste Zelle in der wiederkehrenden Schicht aus.
Die Ausgabe einer Zelle kann auf unterschiedliche Weise erfolgen. Es kann unidirektional oder bidirektional zur nächsten Schicht oder zur nächsten Zelle gelangen. In diesem Tutorial konzentrieren wir uns auf ein einfaches unidirektionales RNN. Um dies zu veranschaulichen, stellen Sie sich ein grünes Kästchen vor, das eine wiederkehrende Zelle darstellt. Daten aus der vorherigen Zelle gelangen in die aktuelle Zelle, die Vorgänge wie das Vergessen irrelevanter Informationen vom vorherigen Knoten, das Einbeziehen neuer Eingabedaten und die Entscheidung, welche Informationen an die nächste Ebene oder den nächsten Knoten ausgegeben werden sollen, ausführt.
Um diesen Prozess besser zu veranschaulichen, betrachten wir eine bestimmte Zelle in der Ebene. Das grüne Kästchen stellt die aktuelle Zelle dar. Daten fließen aus der vorherigen Zelle ein, werden umbrochen und gelangen in die LSTM-Zelle. Innerhalb der Zelle gibt es Operationen zum Vergessen von Informationen vom vorherigen Knoten, zum Einbeziehen neuer Eingabedaten und zum Bestimmen der Ausgabe, die an die nächste Schicht oder den nächsten Knoten weitergeleitet werden soll. Diese Vorgänge ermöglichen es der LSTM-Zelle gemeinsam, wichtige Informationen zu behalten und an nachfolgende Schichten oder Knoten weiterzugeben.
Die Implementierung eines RNN kann komplex sein, insbesondere wenn es um Skalarwerte geht. Wenn Sie an einer detaillierten Erklärung der Funktionsweise von LSTM-Zellen interessiert sind, empfehle ich Ihnen, einen umfassenden Leitfaden zu lesen, der sie ausführlich erklärt. Als Referenz habe ich einen Link zu diesem Leitfaden in die Textversion des Tutorials eingefügt.
Kommen wir nun zum Aufbau eines grundlegenden rekurrenten neuronalen Netzwerks. In diesem Tutorial beginnen wir mit einem einfachen Beispiel unter Verwendung des M-NIST-Datensatzes. Im nächsten Tutorial werden wir mit realistischeren Zeitreihendaten arbeiten und uns dabei insbesondere auf die Preise von Kryptowährungen konzentrieren.
Zunächst importieren wir die erforderlichen Bibliotheken. Wir importieren TensorFlow als tf, das sequentielle Modell aus tensorflow.keras.models, die dichte Ebene aus tensorflow.keras.layers sowie Dropout- und LSTM-Zellen. Beachten Sie, dass es bei Verwendung der GPU-Version von TensorFlow auch eine optimierte LSTM-Zelle namens KU DNN LSTM-Zelle gibt. Für dieses Tutorial bleiben wir jedoch bei der regulären LSTM-Zelle. Wenn Sie die CPU-Version von TensorFlow verwenden, kann die Berechnung viel Zeit in Anspruch nehmen.
Als nächstes müssen wir den Datensatz laden. Für dieses Beispiel verwenden wir den M-NIST-Datensatz. Wir können es einfach mit der Funktion tf.keras.datasets.mnist.load_data() laden, die die Trainings- und Testdaten zurückgibt. Entpacken wir die Daten in Variablen: X_train, Y_train, X_test und Y_test.
Lassen Sie uns zunächst die Eingabedaten normalisieren, indem wir jeden Pixelwert durch 255 dividieren. Dadurch werden die Pixelwerte auf einen Bereich zwischen 0 und 1 skaliert, der für das Training neuronaler Netzwerke geeignet ist. Dies können wir erreichen, indem wir sowohl die Trainings- als auch die Testdaten durch 255 dividieren.
X_train = X_train / 255.0 X_test = X_test / 255.0
Als nächstes müssen wir die Zieletiketten in One-Hot-codierte Vektoren konvertieren. Im M-NIST-Datensatz sind die Bezeichnungen Ganzzahlen im Bereich von 0 bis 9, die die Ziffern darstellen. One-Hot-Codierung wandelt jedes Etikett in einen binären Vektor der Länge 10 um, wobei der der Ziffer entsprechende Index auf 1 und alle anderen Indizes auf 0 gesetzt werden. Wir können die Funktion to_categorical von tensorflow.keras.utils verwenden, um eine solche auszuführen -Hot-Kodierung.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Definieren wir nun die Architektur unseres wiederkehrenden neuronalen Netzwerks. Wir werden das Sequential-Modell von tensorflow.keras.models verwenden und ihm Ebenen hinzufügen.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Kompilieren wir nun das Modell, indem wir die Verlustfunktion, den Optimierer und die Bewertungsmetrik angeben.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Abschließend trainieren wir das Modell mithilfe der Trainingsdaten und werten es anhand der Testdaten aus.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
Das ist es! Sie haben jetzt ein rekurrentes neuronales Netzwerk mit LSTM-Zellen für den M-NIST-Datensatz erstellt. Sie können mit verschiedenen Architekturen, Hyperparametern und Datensätzen experimentieren, um die Fähigkeiten von RNNs weiter zu erkunden.
Kryptowährungsvorhersage-RNN-Einführung – Deep Learning mit Python, TensorFlow und Keras S.8
Kryptowährungsvorhersage-RNN-Einführung – Deep Learning mit Python, TensorFlow und Keras S.8
Hallo zusammen und willkommen zu einem weiteren Deep Learning mit Python-Tutorial-Video. In diesem und den kommenden Videos werden wir diskutieren, wie man ein wiederkehrendes neuronales Netzwerk (RNN) auf ein realistischeres Beispiel für die Arbeit mit sequentiellen Daten anwenden kann. Konkret werden wir mit einem Zeitreihendatensatz arbeiten, der aus Preisen und Volumina für Kryptowährungen besteht.
Bevor wir auf die Details eingehen, möchte ich klarstellen, dass Sie dieselben Konzepte auf andere Arten von sequentiellen Daten anwenden können, beispielsweise Aktienkurse oder Sensordaten. Auch wenn Sie sich nicht für Finanzen interessieren, können Sie die Konzepte dennoch nachvollziehen und verstehen.
Das Ziel dieses Tutorials besteht darin, ein wiederkehrendes neuronales Netzwerk zu verwenden, um den zukünftigen Preis einer Kryptowährung basierend auf ihrem vergangenen Preis und Volumen vorherzusagen. Wir werden uns auf vier große Kryptowährungen konzentrieren: Bitcoin, Litecoin, Ethereum und Bitcoin Cash. Die Idee besteht darin, die Preis- und Volumendaten der letzten 60 Minuten für jede dieser Kryptowährungen zu nehmen und sie als Eingabe zu verwenden, um beispielsweise den Preis von Litecoin drei Minuten in der Zukunft vorherzusagen.
Diese Art von Vorhersageproblem kann auch auf andere Domänen angewendet werden, beispielsweise auf die Vorhersage von Serverausfällen oder Website-Verkehr auf der Grundlage von Zeit- und Nutzungsdaten. Das ultimative Ziel besteht darin, entweder eine Klassifizierung vorherzusagen (z. B. ob der Preis steigen oder fallen wird) oder eine Regression durchzuführen (z. B. den tatsächlichen Preis oder die prozentuale Änderung vorherzusagen).
Die Arbeit mit sequentiellen Daten stellt einzigartige Herausforderungen dar. Zunächst müssen wir die Daten vorverarbeiten und in Sequenzen umwandeln, die das rekurrente neuronale Netzwerk verarbeiten kann. Darüber hinaus müssen wir die Daten ausgleichen und normalisieren, da die Preise und Volumina verschiedener Kryptowährungen unterschiedliche Maßstäbe haben können. Die Skalierung der Daten ist komplexer als in anderen Bereichen, beispielsweise bei Bilddaten, wo wir einfach durch 255 dividieren.
Darüber hinaus stellt die Bewertung der Leistung des Modells mithilfe von Out-of-Sample-Daten eine andere Herausforderung dar, wenn mit sequentiellen Daten gearbeitet wird. Wir müssen mehrere Aspekte abdecken, darunter Datenvorbereitung, Normalisierung und Auswertung.
Um zu beginnen, habe ich einen Datensatz zum Herunterladen für Sie bereitgestellt. Den Download-Link finden Sie in der Beschreibung des Tutorials. Sobald Sie die heruntergeladene ZIP-Datei entpacken, finden Sie vier Dateien, die jeweils den Preis- und Volumendaten einer Kryptowährung entsprechen.
Wir werden die Pandas-Bibliothek in Python verwenden, um den Datensatz zu lesen und zu bearbeiten. Wenn Sie Pandas nicht installiert haben, können Sie dies tun, indem Sie den Befehl pip install pandas in Ihrem Terminal oder Ihrer Eingabeaufforderung ausführen.
Als nächstes lesen wir den Datensatz mithilfe von Pandas ein und untersuchen die Daten. Wir konzentrieren uns auf die Spalten „Schlusspreis“ und „Volumen“ für jede Kryptowährung. Um die Daten aus verschiedenen Dateien zusammenzuführen, legen wir die Spalte „Zeit“ als Index für jeden Datenrahmen fest. Anschließend verknüpfen wir die Datenrahmen anhand ihres gemeinsamen Index.
Sobald wir den zusammengeführten Datenrahmen haben, müssen wir einige Parameter definieren. Dazu gehören die Sequenzlänge (die Anzahl der zu berücksichtigenden vergangenen Perioden), die zukünftige Periode (die Anzahl der vorherzusagenden Perioden in der Zukunft) und das vorherzusagende Verhältnis (die Kryptowährung, die wir vorhersagen möchten).
In unserem Fall konzentrieren wir uns auf die Vorhersage des zukünftigen Preises von Litecoin (LTC) auf der Grundlage der Daten der letzten 60 Minuten und werden drei Minuten in die Zukunft vorhersagen. Wir werden auch eine Klassifizierungsregel definieren, bei der wir die Vorhersage basierend auf den aktuellen und zukünftigen Preisen als Preiserhöhung oder -senkung klassifizieren.
Nachdem diese ersten Schritte abgeschlossen sind, sind wir nun bereit, die Daten vorzuverarbeiten, Sequenzen zu erstellen und das rekurrente neuronale Netzwerk zu trainieren. Wir werden diese Themen in den kommenden Videos behandeln, also bleiben Sie dran.
Wenn Sie mitmachen möchten, laden Sie unbedingt den Datensatz herunter und richten Sie die erforderlichen Bibliotheken ein. Den vollständigen Code und die Anleitung finden Sie in der textbasierten Version des Tutorials, die in der Beschreibung verfügbar ist.
Da wir noch viel zu tun haben, klassifizieren wir es als 1, was auf einen Preisanstieg hindeutet. Andernfalls, wenn der zukünftige Preis niedriger als der aktuelle Preis ist, klassifizieren wir ihn als 0, was auf einen Preisrückgang hinweist. Dies ist eine einfache Regel, die wir zur Klassifizierung verwenden. Sie können jedoch mit anderen Regeln experimentieren oder sogar die Regression verwenden, um die tatsächliche Preisänderung vorherzusagen.
Erstellen wir nun die Zielspalte in unserem Haupt-DataFrame. Wir verwenden die Verschiebungsfunktion von Pandas, um die Werte der Spalte „LTCUSD_close“ um den zukünftigen Zeitraum zu verschieben. Dadurch erhalten wir die zukünftigen Preise, die wir mit den aktuellen Preisen vergleichen, um die Klassifizierung festzulegen. Das Ergebnis weisen wir einer neuen Spalte namens „Ziel“ zu.
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
Als nächstes erstellen wir die Eingabesequenzen. Wir durchlaufen den DataFrame und erstellen Sequenzen der Länge sequence_length, die aus den vorherigen Preisen und Volumina von Bitcoin, Litecoin, Ethereum und Bitcoin Cash bestehen. Wir speichern diese Sequenzen in einer Liste namens „Sequenzen“.
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Zum Schluss konvertieren wir die Sequenzen und Ziele in Numpy-Arrays, um die Handhabung und das Training zu erleichtern.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Bitte beachten Sie, dass der hier bereitgestellte Code eine Teilimplementierung ist und sich auf die Datenvorverarbeitungsschritte konzentriert. Sie müssen die Modellarchitektur weiterentwickeln, das Modell trainieren und seine Leistung bewerten. Darüber hinaus müssen Sie möglicherweise die Hyperparameter anpassen und mit verschiedenen Techniken experimentieren, um die Genauigkeit des Modells zu verbessern.
Denken Sie daran, die erforderlichen Bibliotheken zu importieren, fehlende Daten zu verarbeiten, die Funktionen vorzuverarbeiten (Normalisierung, Skalierung usw.) und die Daten vor dem Training des Modells in Trainings- und Testsätze aufzuteilen.
Ich hoffe, dies hilft Ihnen, den Prozess der Arbeit mit sequentiellen Daten und der Anwendung wiederkehrender neuronaler Netze zur Vorhersage zukünftiger Preise zu verstehen. Viel Glück mit Ihrem Deep-Learning-Projekt!
Normalisierung und Erstellung von Sequenzen Crypto RNN – Deep Learning mit Python, TensorFlow und Keras S.9
Normalisierung und Erstellung von Sequenzen Crypto RNN – Deep Learning mit Python, TensorFlow und Keras S.9
Hallo zusammen und willkommen zurück zu einer weiteren Episode der Tutorialreihe „Deep Learning mit Python, TensorFlow und Chaos“. In diesem Video werden wir weiter an unserem Miniprojekt zur Implementierung eines wiederkehrenden neuronalen Netzwerks (RNN) arbeiten, um die zukünftigen Preisbewegungen einer Kryptowährung vorherzusagen. Wir werden die Sequenzen der Preise und Volumina der Währung zusammen mit drei anderen Preisen und Volumina für Kryptowährungen verwenden.
Bisher haben wir die Daten erhalten, zusammengeführt und die Ziele erstellt. Kommen wir nun zu den nächsten Schritten. Wir müssen Sequenzen aus den Daten erstellen und Aufgaben wie Ausgleich, Normalisierung und Skalierung durchführen. Bevor man sich jedoch mit diesen Aufgaben beschäftigt, ist es wichtig, sich mit dem Problem der Out-of-Sample-Tests zu befassen.
Beim Umgang mit Zeit- und Zeitreihendaten kann das Mischen und zufällige Auswählen eines Teils als Out-of-Sample-Daten zu einem verzerrten Modell führen. In unserem Fall mit Sequenzen von 60 Minuten und einem Vorhersagefenster von 3 Minuten könnte die zufällige Auswahl der Out-of-Sample-Daten dazu führen, dass ähnliche Beispiele sowohl in den In-Sample- als auch in den Out-of-Sample-Sätzen vorhanden sind. Dies würde eine Überanpassung des Modells und eine schlechte Leistung bei unsichtbaren Daten erleichtern.
Um dieses Problem anzugehen, müssen wir die Daten außerhalb der Stichprobe sorgfältig auswählen. Für Zeitreihendaten wird empfohlen, einen Datenblock aus der Zukunft als Out-of-Sample-Satz auszuwählen. In unserem Fall nehmen wir die letzten 5 % der historischen Daten als unsere Out-of-Sample-Daten. Bei diesem Ansatz wird die Erstellung des Modells vor 5 % der Zeit simuliert und es anschließend getestet.
Lassen Sie uns nun diese Trennung von Out-of-Sample-Daten implementieren. Wir sortieren die Daten nach dem Zeitstempel und ermitteln den Schwellenwert der letzten 5 % der Zeiten. Durch diese Trennung der Daten stellen wir sicher, dass der Out-of-Sample-Satz Daten aus der Zukunft enthält, wodurch Datenlecks und voreingenommene Tests verhindert werden. Nach der Trennung verfügen wir über die Validierungsdaten und die Trainingsdaten.
Bevor wir fortfahren, ist es wichtig zu beachten, dass wir sowohl die Validierungs- als auch die Trainingsdaten vorverarbeiten müssen. Wir werden Sequenzen erstellen, die Daten ausgleichen, normalisieren, skalieren und andere notwendige Aufgaben ausführen. Um diesen Prozess zu optimieren, erstellen wir eine Funktion namens preprocess_df, die einen DataFrame als Eingabe verwendet und alle diese Vorverarbeitungsschritte ausführt.
Zuerst importieren wir das Vorverarbeitungsmodul aus der sklearn-Bibliothek. Wenn Sie es nicht installiert haben, können Sie dies tun, indem Sie pip install sklearn ausführen. Dann definieren wir die Funktion preprocess_df, die einen DataFrame als Parameter akzeptiert.
Innerhalb der Funktion löschen wir zunächst die unnötige zukünftige Spalte aus dem DataFrame. Als Nächstes durchlaufen wir die Spalten des DataFrame und wenden die prozentuale Änderungstransformation an. Dieser Normalisierungsschritt hilft bei der Handhabung unterschiedlicher Preis- und Volumengrößen bei Kryptowährungen.
Nach der Normalisierung der Daten löschen wir alle Zeilen, die NaN-Werte enthalten, da diese beim Training Probleme verursachen können. Anschließend verwenden wir die Funktion preprocessing.scale, um die Werte zwischen 0 und 1 zu skalieren. Alternativ können Sie Ihre eigene Skalierungslogik implementieren.
Nachdem wir die Daten nun vorverarbeitet haben, fahren wir mit der Verarbeitung sequenzieller Daten fort. Wir erstellen eine leere Liste namens „sequential_data“ und initialisieren ein Deque-Objekt namens „prev_days“ mit einer maximalen Länge von 60. Das Deque-Objekt ermöglicht es uns, neue Elemente effizient anzuhängen und alte automatisch zu entfernen, wenn es die maximale Länge erreicht.
Als nächstes iterieren wir über die Werte des DataFrame, der nun die normalisierten und skalierten Daten enthält. Für jede Zeile hängen wir die Werte an die prev_days-Deque an. Sobald die Deque eine Länge von mindestens 60 erreicht, beginnen wir mit dem Auffüllen der Sequential_Data
# Create a deque object with a maximum length of max_len
if len(prev_days) < max_len:
prev_days.append([n for n in i[:-1]])
else:
# Append the current values to prev_days
prev_days.append([n for n in i[:-1]])
# Add the sequence to the sequential_data list
sequential_data.append([np.array(prev_days), i[-1]])
# Remove the oldest sequence from prev_days
prev_days.popleft()
Nachdem wir nun die Sequenzen generiert haben, können wir mit dem Abgleich der Daten fortfahren. Das Ausbalancieren ist wichtig, um eine Tendenz zu einer bestimmten Klasse in unseren Trainingsdaten zu verhindern. In diesem Fall sind unsere Klassen die unterschiedlichen Preisbewegungen (nach oben oder unten). Um die Daten auszugleichen, zählen wir die Anzahl der Vorkommen für jede Klasse und begrenzen die Anzahl der Sequenzen für die Mehrheitsklasse, um sie mit der Minderheitsklasse abzugleichen.
sells = []
for seq, target in sequential_data:
if target == 0:
sells.append([seq, target])
elif target == 1:
buys.append([seq, target])
# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))
# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]
# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells
# Shuffle the balanced_data
random.shuffle(balanced_data)
Nachdem wir die Daten ausgeglichen haben, können wir sie in Arrays mit Eingabemerkmalen (X) und Zielbeschriftungen (y) aufteilen.
y = []
for seq, target in balanced_data:
X.append(seq)
y.append(target)
# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)
Nachdem wir nun X als Eingabemerkmale und y als Zielbezeichnungen haben, können wir mit der Aufteilung der Daten in Trainings- und Validierungssätze fortfahren.
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)
Im obigen Code verwenden wir die Funktion train_test_split von scikit-learn, um die Daten in Trainings- und Validierungssätze aufzuteilen. Wir weisen 80 % der Daten dem Trainingssatz (train_x und train_y) und 20 % zu
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
Mit den vorbereiteten Daten können wir nun das LSTM-Modell erstellen und trainieren:
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=2, activation='softmax'))
# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
Wir definieren den Optimierer als Adam mit einer Lernrate von 0,001 und kompilieren das Modell mit spärlicher kategorialer Kreuzentropie als Verlustfunktion und Genauigkeit als Metrik.
Das frühe Stoppen wird mithilfe des EarlyStopping-Rückrufs definiert, um den Validierungsverlust zu überwachen und das Training zu stoppen, wenn es nach drei Epochen keine Verbesserung zeigt.
Das Modell wird mithilfe der Fit-Funktion trainiert, wobei die Trainingsdaten (train_x und train_y), Validierungsdaten (val_x und val_y) und die definierten Rückrufe übergeben werden. Das Training wird über 20 Epochen durchgeführt.
Sie können die Modellarchitektur, die Hyperparameter und die Trainingskonfiguration entsprechend Ihren spezifischen Anforderungen anpassen.
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)
loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')
Anschließend verwenden wir die Bewertungsmethode des Modells, um den Verlust und die Genauigkeit der Testdaten zu berechnen. Die Evaluierungsmethode verwendet die Testeingabedaten (test_x) und die entsprechenden Ground-Truth-Labels (test_y). Der berechnete Verlust und die Genauigkeit werden auf der Konsole ausgegeben.
Denken Sie daran, die erforderlichen Module zu Beginn Ihres Skripts zu importieren:
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
Mit diesem Code können Sie ein LSTM-Modell für Ihre Kauf-/Verkaufsklassifizierungsaufgabe trainieren, die Daten normalisieren und die Leistung des Modells im Testsatz bewerten. Nehmen Sie jederzeit Anpassungen oder Modifikationen gemäß Ihren spezifischen Anforderungen vor.