Wie man LLaMA2 schnell und einfach neu abstimmt

I. Einführung in das Feinabstimmen von LLaMA-2

A. Überblick über LLaMA-2 und seine Möglichkeiten

LLaMA-2 ist die zweite Iteration des Large Language Model for AI (LLaMA), das von Anthropic entwickelt wurde. Es handelt sich um ein leistungsstarkes und vielseitiges Sprachmodell, das für eine Vielzahl von natürlichen Sprachverarbeitungsaufgaben wie Textgenerierung, Fragebeantwortung und Sprachübersetzung verwendet werden kann.

LLaMA-2 basiert auf dem ursprünglichen LLaMA-Modell, das Anfang 2023 veröffentlicht wurde und aufgrund seiner beeindruckenden Leistung in verschiedenen Benchmarks schnell Aufmerksamkeit erregte. Das aktualisierte LLaMA-2-Modell enthält verschiedene Verbesserungen, darunter verbesserte Trainingsdaten, Modellarchitektur und Optimierungstechniken, was zu noch fortschrittlicheren Sprachverständnis- und Generierungsfähigkeiten führt.

Eine der wichtigsten Funktionen von LLaMA-2 ist die Möglichkeit, es an domänenspezifischen Datensätzen feinzutunen, um es an spezialisierte Aufgaben und Szenarien anzupassen. Dieser Feinabstimmungsprozess steht im Mittelpunkt dieses Tutorials, da er es den Benutzern ermöglicht, die Leistung des vortrainierten LLaMA-2-Modells zu nutzen und es an ihre spezifischen Bedürfnisse anzupassen.

B. Bedeutung des Feinabstimmens für domänenspezifische Aufgaben

Obwohl das vortrainierte LLaMA-2-Modell hochleistungsfähig ist, ist es als Allzweck-Sprachmodell konzipiert, das auf einem breiten Korpus von Daten trainiert wurde. Für viele realitätsnahe Anwendungen besteht jedoch die Notwendigkeit, das Modell an spezifische Domänen, Aufgaben oder Datensätze anzupassen.

Das Feinabstimmen des LLaMA-2-Modells auf domänenspezifische Daten kann mehrere Vorteile bieten:

Verbesserte Leistung: Durch das Training des Modells mit Daten, die für die Zielstellung oder Domäne relevanter sind, kann das feinabgestimmte Modell eine bessere Leistung erzielen und oft das allgemeine vortrainierte Modell übertreffen.
Spezialwissen: Der Feinabstimmungsprozess ermöglicht es dem Modell, spezialisiertes Wissen und Verständnis für die Ziel-Domäne zu erlangen, was es ihm ermöglicht, genauere, relevantere und kohärentere Ausgaben zu generieren.
Maßgeschneiderte Fähigkeiten: Das Feinabstimmen kann das Verhalten und die Fähigkeiten des Modells an die spezifischen Anforderungen der Aufgabe oder Anwendung anpassen und es so besser für die Bedürfnisse des Endbenutzers geeignet machen.
Effizienz: Das Feinabstimmen eines vortrainierten Modells ist im Allgemeinen effizienter und schneller als das Training eines Modells von Grund auf, da das vortrainierte Modell bereits wertvolle Repräsentationen und Muster aus den umfangreichen Trainingsdaten gelernt hat.

In den folgenden Abschnitten werden wir Sie durch den Prozess der Feinabstimmung des LLaMA-2-Modells für eine bestimmte Aufgabe führen und die notwendigen Schritte und bewährten Verfahren erläutern, um eine erfolgreiche und effektive Anpassung des Modells zu gewährleisten.

II. Vorbereitung der Umgebung

A. Systemanforderungen

Bevor wir mit dem Feinabstimmungsprozess beginnen, ist es wichtig sicherzustellen, dass Ihr System die erforderlichen Hardware- und Softwareanforderungen erfüllt.

1. Hardware

Die Feinabstimmung von LLaMA-2-Modellen ist eine rechenintensive Aufgabe, daher wird empfohlen, über eine leistungsstarke GPU zu verfügen, idealerweise mit mindestens 16 GB Videospeicher. Die genauen Hardwareanforderungen können je nach Größe Ihres Datensatzes und der Komplexität der Aufgabe variieren, aber eine Hochleistungs-GPU wird den Schulungsprozess erheblich beschleunigen.

Zusätzlich benötigen Sie ausreichend Systemspeicher (RAM), um das Modell und die Trainingsdaten zu speichern. Als allgemeine Richtlinie sollten Sie auf mindestens 32 GB RAM abzielen, aber die genauen Anforderungen können je nach Ihrem spezifischen Anwendungsfall variieren.

2. Software

Der Feinabstimmungsprozess wird mithilfe von Python durchgeführt, daher müssen Sie eine Python-Umgebung auf Ihrem System einrichten. Wir empfehlen die Verwendung von Python 3.7 oder höher.

Darüber hinaus müssen Sie die folgenden wichtigen Bibliotheken installieren:

PyTorch: Ein beliebtes Deep-Learning-Framework, das zum Laden und Manipulieren des LLaMA-2-Modells verwendet wird.
Hugging Face Transformers: Eine leistungsstarke Bibliothek, die benutzerfreundliche Schnittstellen zum Arbeiten mit vortrainierten Sprachmodellen, einschließlich LLaMA-2, bereitstellt.
NumPy: Eine grundlegende Bibliothek zur wissenschaftlichen Berechnung in Python, die für die Datenmanipulation und -vorverarbeitung verwendet wird.
Pandas: Eine Datenmanipulations- und -analysebibliothek, die bei der Arbeit mit tabellarischen Daten hilfreich sein kann.
Tensorboard: Ein Visualisierungstoolkit zur Überwachung und Visualisierung verschiedener Metriken während des Feinabstimmungsprozesses.

B. Installation der erforderlichen Bibliotheken

Sie können die erforderlichen Bibliotheken mit pip, dem Python-Paket-Installer, installieren. Öffnen Sie ein Terminal oder eine Befehlszeile und führen Sie die folgenden Befehle aus:

pip install torch transformers numpy pandas tensorboard

Alternativ können Sie eine virtuelle Umgebung erstellen und die Abhängigkeiten innerhalb dieser Umgebung installieren, um Konflikte mit anderen Python-Paketen auf Ihrem System zu vermeiden.

# Erstellen Sie eine virtuelle Umgebung
python -m venv finetuning-env
# Aktivieren Sie die virtuelle Umgebung
source finetuning-env/bin/activate
# Installieren Sie die erforderlichen Bibliotheken
pip install torch transformers numpy pandas tensorboard

Sobald Sie die erforderliche Hardware und Software eingerichtet haben, können Sie zum nächsten Schritt übergehen: dem Erhalten des LLaMA-2-Modells.

III. Erhalten des LLaMA-2-Modells

A. Herunterladen des vortrainierten LLaMA-2-Modells

Das LLaMA-2-Modell ist derzeit nicht öffentlich verfügbar, da es sich um ein proprietäres Modell handelt, das von Anthropic entwickelt wurde. Anthropic hat jedoch eine Reihe von vortrainierten LLaMA-Modellen veröffentlicht, die als Ausgangspunkt für das Feinabstimmen verwendet werden können.

Um das vortrainierte LLaMA-Modell zu erhalten, müssen Sie den Anweisungen von Anthropic folgen. Dies beinhaltet in der Regel die Registrierung für den Zugriff und die Zustimmung zu den Nutzungsbedingungen. Sobald Sie Zugang haben, können Sie die Modelldateien von der Anthropic-Website oder dem Repository herunterladen.

B. Überprüfen der Modellintegrität

Nach dem Herunterladen der LLaMA-Modelldateien ist es wichtig, deren Integrität zu überprüfen, um sicherzustellen, dass die Dateien korrekt heruntergeladen wurden und nicht manipuliert wurden.

Eine Möglichkeit, dies zu tun, besteht darin, die von Anthropic bereitgestellten Datei-Hashes zu überprüfen und sie mit den Hashes der heruntergeladenen Dateien zu vergleichen. Sie können entweder das sha256sum-Befehls (unter Linux oder macOS) oder ein Tool wie Get-FileHash (unter Windows PowerShell) verwenden, um den SHA-256-Hash der heruntergeladenen Dateien zu berechnen und sie mit den erwarteten Werten zu vergleichen.

Hier ist ein Beispiel, wie Sie die Dateiintegrität unter Linux oder macOS überprüfen können:

# Berechnen Sie den SHA-256-Hash der heruntergeladenen Modelldatei
sha256sum llama.7b.pth

# Vergleichen Sie den berechneten Hash mit dem von Anthropic bereitgestellten erwarteten Hash

Wenn die Hashes übereinstimmen, können Sie sicher sein, dass die heruntergeladenen Dateien authentisch sind und während des Downloadvorgangs nicht beschädigt wurden.

Mit den LLaMA-2-Modelldateien in der Hand und der überprüften Integrität sind Sie nun bereit, den Feinabstimmungsprozess zu starten.

IV. Feinabstimmung von LLaMA-2 für eine bestimmte Aufgabe

A. Definition der Aufgabe und des Datensatzes

Der erste Schritt im Feinabstimmungsprozess besteht darin, die Aufgabe, die Sie erreichen möchten, und den Datensatz, den Sie für die Feinabstimmung verwenden möchten, klar zu definieren.

1. Identifizieren der Aufgabe

Die Art der Aufgabe, die Sie wählen, hängt von Ihrem spezifischen Anwendungsfall und Ihren Anforderungen ab. Einige häufige Aufgaben, die durch Feinabstimmung von LLaMA-2 angegangen werden können, sind:

Textgenerierung: Generieren Sie kohärenten und inhaltlich relevanten Text wie Geschichten, Artikel oder Produktbeschreibungen.
Fragebeantwortung: Trainieren Sie das Modell, Fragen zu verstehen und genaue und informative Antworten zu geben.
Sprachübersetzung: Stimmen Sie das Modell auf die Übersetzung von Text zwischen verschiedenen Sprachen ab.
Sentimentanalyse: Passen Sie das Modell an, um die Stimmung (positiv, negativ oder neutral) des Eingabetextes zu klassifizieren.
Zusammenfassung: Trainieren Sie das Modell, prägnante und informative Zusammenfassungen von längeren Texten zu generieren.

2. Vorbereiten des Datensatzes

Sobald Sie die Aufgabe identifiziert haben, müssen Sie den Datensatz vorbereiten, der für die Feinabstimmung verwendet wird. Dies umfasst die folgenden Schritte:

a. Daten sammeln: Sammeln Sie einen relevanten Datensatz für Ihre Aufgabe, entweder aus öffentlich verfügbaren Quellen oder indem Sie Ihren eigenen erstellen. b. Daten vorverarbeiten: Bereinigen und verarbeiten Sie die Daten, um sicherzustellen, dass sie im Format vorliegen, das vom Modell leicht verarbeitet werden kann. Dies kann Aufgaben wie Tokenisierung, Textnormalisierung und Handhabung von Sonderzeichen umfassen. c. Aufteilung in Trainings-, Validierungs- und Testsets: Teilen Sie den Datensatz in Trainings-, Validierungs- und Testsets auf. Das Trainingsset wird zur Feinabstimmung des Modells verwendet, das Validierungsset wird zur Überwachung der Leistung des Modells während des Trainings verwendet und das Testset wird zur abschließenden Evaluation verwendet.

Durch eine klare Definition der Aufgabe und die Vorbereitung eines hochwertigen Datensatzes legen Sie den Grundstein für einen erfolgreichen Feinabstimmungsprozess.

B. Vorbereitung der Feinabstimmungspipeline

Mit der Aufgabe und dem Datensatz können Sie nun die Feinabstimmungspipeline einrichten. Dies umfasst die folgenden Schritte:

1. Einrichtung des Tokenizers

Der erste Schritt besteht darin, den Tokenizer einzurichten, der für die Umwandlung des Eingabetexts in eine Sequenz von Tokens zuständig ist, die vom Modell verarbeitet werden können. Die Hugging Face Transformers-Bibliothek bietet vortrainierte Tokenizer für verschiedene Modelle, einschließlich LLaMA-2.

from transformers import LlamaTokenizer
 
tokenizer = LlamaTokenizer.from_pretrained('path/to/llama-2-model')

2. Laden und Vorverarbeiten des Datensatzes

Als nächstes müssen Sie den Datensatz laden und die Daten so vorverarbeiten, dass sie dem erwarteten Format des Modells entsprechen. Dies kann Aufgaben wie die Umwandlung des Texts in Token-IDs, das Auffüllen der Sequenzen auf eine feste Länge und das Erstellen der erforderlichen Eingabe-Ausgabe-Paare für die Feinabstimmungsaufgabe umfassen.

from torch.utils.data import Dataset, DataLoader
 
class MeinDatensatz(Dataset):
    def __init__(self, daten, tokenizer):
        self.daten = daten
        self.tokenizer = tokenizer
 
    def __len__(self):
        return len(self.daten)
 
    def __getitem__(self, idx):
        # Daten vorverarbeiten und Eingabe-Ausgabe-Paare zurückgeben

input_ids = self.tokenizer.encode(self.data[idx][0], return_tensors='pt') output_ids = self.tokenizer.encode(self.data[idx][1], return_tensors='pt') return input_ids, output_ids

Erstelle das Dataset und den Dataloader

dataset = MyDataset(train_data, tokenizer) dataloader = DataLoader(dataset, batch_size=8, shuffle=True)


### 3. Initialisierung und Konfiguration des Modells

Schließlich müssen Sie das LLaMA-2-Modell initialisieren und für die Feinabstimmung konfigurieren. Dies beinhaltet das Laden der vortrainierten Modellgewichte und das Einrichten der erforderlichen Modellkomponenten.

```python
from transformers import LlamaForCausalLM

model = LlamaForCausalLM.from_pretrained('path/to/llama-2-model')
model.config.pad_token_id = tokenizer.pad_token_id

Mit dem Tokenizer, dem Dataset und dem Modell eingerichtet, können Sie nun den Feinabstimmungsprozess implementieren.

C. Implementierung des Feinabstimmungsprozesses

Der Feinabstimmungsprozess umfasst das Training des LLaMA-2-Modells auf dem aufgabenspezifischen Dataset und die Aktualisierung der Modellparameter, um die Leistung auf der Ziel-Aufgabe zu verbessern.

1. Definition der Trainingsschleife

Die Trainingsschleife ist der Kern des Feinabstimmungsprozesses, bei dem die Modellparameter anhand der Trainingsdaten aktualisiert werden. Hier ein einfaches Beispiel:

import torch.optim as optim
import torch.nn.functional as F
 
# Set up the optimizer and loss function
optimizer = optim.AdamW(model.parameters(), lr=1e-5)
loss_fn = F.cross_entropy
 
# Training loop
for epoch in range(num_epochs):
    for inputs, outputs in dataloader:
        optimizer.zero_grad()
        logits = model(inputs, labels=outputs).logits
        loss = loss_fn(logits.view(-1, logits.size(-1)), outputs.view(-1))
        loss.backward()
        optimizer.step()
 
    # Evaluate the model on the validation set
    # and implement early stopping if desired

In diesem Beispiel verwenden wir den AdamW-Optimizer und die Kreuzentropie-Verlustfunktion, um das Modell zu trainieren. Sie können mit verschiedenen Optimierungsalgorithmen, Verlustfunktionen und Hyperparametern experimentieren, um die beste Konfiguration für Ihre spezifische Aufgabe zu finden.

2. Überwachung und Auswertung der Feinabstimmung

Während des Feinabstimmungsprozesses ist es wichtig, die Leistung des Modells zu überwachen und den Fortschritt zu bewerten. Dies kann durch regelmäßige Auswertung des Modells auf dem Validierungsset und die Verfolgung verschiedener Metriken wie:

Perplexität: Ein Maß dafür, wie gut das Modell das nächste Token in der Sequenz vorhersagt.
BLEU-Score: Eine Metrik zur Bewertung der Qualität von maschineller Übersetzung oder Textgenerierung.
**F1-Score

Convolutional Neural Networks (CNNs)

Convolutional Neural Networks (CNNs) sind eine spezialisierte Art von neuronalen Netzwerken, die besonders gut geeignet sind, Daten mit einer rasterartigen Topologie, wie z.B. Bilder, zu verarbeiten. CNNs bestehen aus mehreren Schichten, von denen jede eine bestimmte Aufgabe erfüllt, wie z.B. Merkmalsextraktion oder Klassifizierung.

Die Schlüsselkomponenten eines CNNs sind:

Faltungs-Schichten: Diese Schichten wenden einen Satz erlernbarer Filter auf das Eingangsbild an und extrahieren Merkmale wie Kanten, Formen und Texturen.
Pooling-Schichten: Diese Schichten reduzieren die räumlichen Dimensionen der Merkmalskarten und tragen dazu bei, Overfitting zu kontrollieren und das Modell gegen kleine Verschiebungen und Verzerrungen robuster zu machen.
Vollständig verbundene Schichten: Diese Schichten nehmen die Ausgabe der Faltungs- und Pooling-Schichten und verwenden sie, um die endgültige Klassifizierung oder Regression durchzuführen.

Hier ein Beispiel für eine einfache CNN-Architektur zur Bildklassifizierung:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
 
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))

Dieses Modell nimmt 28x28-Grauwertbilder auf, führt sie durch drei Faltungsschichten mit Max-Pooling und verwendet dann zwei vollständig verbundene Schichten, um die Bilder in eine von 10 Klassen zu klassifizieren.

Recurrent Neural Networks (RNNs)

Recurrent Neural Networks (RNNs) sind eine Art von neuronalen Netzwerken, die für die Verarbeitung sequenzieller Daten wie Text, Sprache oder Zeitreihen entwickelt wurden. Im Gegensatz zu neuronalen Netzwerken mit Vorwärtsverbindung, die Daten unabhängig voneinander verarbeiten, behalten RNNs einen "Gedächtnis"-Zustand früherer Eingaben bei, der es ihnen ermöglicht, die zeitlichen Abhängigkeiten in den Daten zu erfassen.

Die Schlüsselkomponenten eines RNNs sind:

Recurrent-Schichten: Diese Schichten verarbeiten die Eingangssequenz Schritte für Schritt und behalten einen versteckten Zustand bei, der von einem Zeitschritt zum nächsten weitergegeben wird.
Vollständig verbundene Schichten: Diese Schichten nehmen die Ausgabe der Rekurrent-Schichten und verwenden sie, um die endgültige Klassifizierung oder Regression durchzuführen.

Hier ein Beispiel für ein einfaches RNN zur Textklassifizierung:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
 
# Angenommen, Sie haben ein tokenisiertes Text-Dataset
num_words = 10000
max_length = 100
 
model = Sequential()
model.add(Embedding(num_words, 128, input_length=max_length))
model.add(LSTM(64))
model.add(Dense(1, activation='sigmoid'))

Dieses Modell nimmt eine Sequenz von 100 Wortindizes auf, führt sie durch eine Embedding-Schicht, um sie in dichte Vektoren umzuwandeln, und verwendet dann eine LSTM-Schicht, um die Sequenz zu verarbeiten. Die endgültige vollständig verbundene Schicht erzeugt eine einzelne Ausgabe, die für binäre Klassifizierungsaufgaben verwendet werden kann.

Long Short-Term Memory (LSTMs)

Long Short-Term Memory (LSTMs) sind eine spezielle Art von RNNs, die entwickelt wurden, um das Problem des Verschwindens von Gradienten zu lösen, das es herkömmlichen RNNs schwer macht, langfristige Abhängigkeiten in den Daten zu erlernen.

LSTMs führen ein neues Konzept namens "Zustand der Zelle" ein, der als Speicher fungiert und selektiv aktualisiert und von einem Zeitschritt zum nächsten weitergegeben werden kann. Dadurch können LSTMs langfristige Abhängigkeiten in den Daten besser erfassen.

Hier ein Beispiel für eine LSTM zur Vorhersage von Zeitreihen:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
 
# Angenommen, Sie haben ein Zeitreihen-Dataset
n_features = 5
n_steps = 10
 
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(n_steps, n_features)))
model.add(Dense(1))

Dieses Modell nimmt eine Sequenz von 10 Zeitschritten mit jeweils 5 Merkmalen auf und verwendet eine LSTM-Schicht mit 50 Einheiten, um die Sequenz zu verarbeiten. Die endgültige vollständig verbundene Schicht erzeugt eine einzelne Ausgabe, die für Zeitreihenprognoseaufgaben verwendet werden kann.

Generative Adversarial Networks (GANs)

Generative Adversarial Networks (GANs) sind eine Art von Deep-Learning-Modell, das aus zwei neuronalen Netzwerken besteht: einem Generator und einem Diskriminator. Das Generator-Netzwerk wird darauf trainiert, neue Daten zu generieren, die dem Trainingsdatensatz ähneln, während das Diskriminator-Netzwerk darauf trainiert wird, zwischen echten und generierten Daten zu unterscheiden.

Die Schlüsselkomponenten eines GANs sind:

Generator-Netzwerk: Dieses Netzwerk nimmt einen zufälligen Rauschvektor auf und generiert neue Daten, die dem Trainingsdatensatz ähneln.
Diskriminator-Netzwerk: Dieses Netzwerk nimmt echte oder generierte Daten auf und gibt eine Wahrscheinlichkeit aus, dass die Daten echt sind.

Die beiden Netzwerke werden auf eine antagonistische Weise trainiert, wobei der Generator versucht, den Diskriminator zu täuschen, und der Diskriminator versucht, echte und generierte Daten korrekt zu identifizieren.

Hier ein Beispiel für ein einfaches GAN zur Generierung von handgeschriebenen Ziffern:

import tensorflow as tf
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, Reshape, Flatten, Conv2D, LeakyReLU, BatchNormalization
from tensorflow.keras.optimizers import Adam
 
# Generator-Netzwerk
generator = Sequential()
generator.add(Dense(7*7*256, input_shape=(100,), activation=LeakyReLU()))
generator.add(Reshape((7, 7, 256)))
generator.add(Conv2D(128, (5, 5), padding='same', activation=LeakyReLU()))
generator.add(BatchNormalization())
generator.add(Conv2D(64, (5, 5), padding='same', activation=LeakyReLU()))
generator.add(BatchNormalization())
generator.add(Conv2D(1, (5, 5), padding='same', activation='tanh'))
 
# Diskriminator-Netzwerk
discriminator = Sequential()
discriminator.add(Conv2D(64, (5, 5), padding='same', input_shape=(28, 28, 1), activation=LeakyReLU()))
discriminator.add(BatchNormalization())
discriminator.add(Conv2D(128, (5, 5), padding='same', activation=LeakyReLU()))
discriminator.add(BatchNormalization())
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))
 
# Kombinieren Sie den Generator und den Diskriminator in ein GAN-Modell
gan = Model(generator.input, discriminator(generator.output))

Dieses Modell verwendet einen konvolutionalen Generator und einen konvolutionalen Diskriminator, um handgeschriebene Ziffern zu generieren. Der Generator nimmt einen 100-dimensionalen Rauschvektor auf und generiert 28x28-Graustufenbilder, während der Diskriminator echte oder generierte Bilder aufnimmt und eine Wahrscheinlichkeit ausgibt, dass das Bild echt ist.

Fazit

In diesem Tutorial haben wir mehrere wichtige Deep-Learning-Architekturen wie Convolutional Neural Networks (CNNs), Recurrent Neural Networks (RNNs), Long Short-Term Memory (LSTMs) und Generative Adversarial Networks (GANs) behandelt. Wir haben Beispiele und Code-Snippets bereitgestellt, um zu veranschaulichen, wie diese Modelle mit der TensorFlow/Keras-Bibliothek implementiert werden können.

Diese Deep-Learning-Modelle haben ein breites Anwendungsspektrum, von Computer Vision und Natural Language Processing bis hin zur Zeitreihenanalyse und generativen Modellierung. Da das Gebiet des Deep Learning weiterhin fortschreitet, ist es wichtig, mit den neuesten Entwicklungen und bewährten Verfahren Schritt zu halten.Wir hoffen, dass dieses Tutorial Ihnen eine solide Grundlage für Deep Learning bietet und Sie dazu inspiriert, diese leistungsstarken Techniken weiter zu erforschen. Viel Spaß beim Lernen!

Wie man einfach eine Deep Learning Workstation einrichtet Wie man GAN in PyTorch für Anfänger leicht versteht