PyTorch: Leistungsstarkes Deep Learning Framework | 20.03.2023
Heute möchte ich euch PyTorch vorstellen, ein Open-Source-Deep-Learning-Framework, das bei der Erstellung einiger der bekanntesten künstlichen Intelligenz-Produkte verwendet wird.
PyTorch wurde 2016 im Meta AI-Forschungslabor entwickelt und stammt eigentlich von der auf Lua basierenden Torch-Bibliothek ab, die bis ins Jahr 2002 zurückreicht. Im Kern handelt es sich um eine Bibliothek zur Programmierung mit Tensoren, die genau genommen mehrdimensionale Arrays sind und Daten und Parameter in tiefen neuronalen Netzen repräsentieren.
Tensoren sind grundlegende Datenstrukturen in der Künstlichen Intelligenz (KI), insbesondere in Deep Learning und maschinellem Lernen. In einfachen Worten sind Tensoren n-dimensionale Arrays oder Matrizen, die Daten und Parameter in neuronalen Netzen und maschinellen Lernmodellen repräsentieren.
Tensoren können unterschiedliche Dimensionen haben:
In Deep Learning- und KI-Anwendungen werden Tensoren verwendet, um verschiedene Informationen darzustellen, wie z. B.:
Deep Learning-Frameworks wie PyTorch, TensorFlow und Keras bieten spezielle Tensor-Implementierungen, die für effiziente Berechnungen und GPU-Unterstützung optimiert sind. Diese Implementierungen ermöglichen es, komplexe KI-Modelle mit hoher Leistung zu erstellen und zu trainieren.
Ich hatte ja schon zu Beginn geschrieben, dass einige der bekanntesten KI-Produkte auf PyTorch aufbauen. Um hier etwas konkreter zu werden, anbei eine nicht abgeschlossene Liste mit Firmen, die PyTorch nachweislich nutzen.
PyTorch legt großen Wert auf Benutzerfreundlichkeit und ermöglicht es dir, mit nur wenigen Zeilen Python maschinelle Lernmodelle zu trainieren. Außerdem erleichtert es die Hochleistungsparallelberechnung auf einer GPU dank der CUDA-Plattform von Nvidia. Entwickler lieben es, mit PyTorch zu arbeiten, da es einen dynamischen Berechnungsgraphen unterstützt, der es ermöglicht, Modelle zur Laufzeit zu optimieren.
Ein dynamischer Berechnungsgraph (Dynamic Computational Graph, DCG) ist eine Technik in der Programmierung von Deep Learning-Systemen, bei der die Struktur des Berechnungsgraphen zur Laufzeit erstellt und modifiziert werden kann. Ein Berechnungsgraph ist eine Darstellung der mathematischen Berechnungen und Operationen, die in einem neuronalen Netzwerk stattfinden. In diesem Graphen sind die Knoten die mathematischen Operationen, und die Kanten repräsentieren die Daten (meistens Tensoren) zwischen den Operationen.
Im Gegensatz zu statischen Berechnungsgraphen, bei denen die Struktur des Graphen vor der Laufzeit festgelegt wird, erlaubt der dynamische Berechnungsgraph das Hinzufügen oder Entfernen von Knoten und Kanten während der Ausführung des Programms. Diese Flexibilität ist nützlich, wenn die Struktur des neuronalen Netzwerks von den Eingabedaten abhängt oder wenn sich die Struktur im Laufe des Trainings ändern muss.
PyTorch wurde zum Trainieren von Modellen für Computer Vision KI wie Tesla Autopilot, Bildgeneratoren wie Stable Diffusion und Spracherkennungsmodelle wie OpenAI Whisper verwendet, um nur einige zu nennen.
Zuerst installiere PyTorch und CUDA (falls du es verwenden möchtest) mit dem folgenden Befehl. Du kannst diesen Befehl in deinem Terminal oder in einer Anaconda-Umgebung ausführen:
pip install torch torchvision -f https://download.pytorch.org/whl/cu101/torch_stable.html
Importiere PyTorch in deine Python-Datei oder in ein Jupyter-Notebook:
import torch
Erstelle ein 2D-Array oder eine Matrix mit Python und wandle es dann in einen Tensor um:
import numpy as np
# Erstelle ein 2D-Array (Matrix) mit NumPy
matrix = np.array([[1, 2], [3, 4]])
# Konvertiere das 2D-Array in einen Tensor
tensor = torch.from_numpy(matrix)
Definiere eine neue Klasse, die von der Neural-Network-Module-Klasse erbt, und erstelle ein einfaches neuronales Netzwerk:
import torch.nn as nn
class MeinNetzwerk(nn.Module):
def __init__(self):
super(MeinNetzwerk, self).__init__()
self.flatten = nn.Flatten()
self.sequential = nn.Sequential(
nn.Linear(28 * 28, 512),
nn.ReLU(),
nn.Linear(512, 10),
)
def forward(self, x):
x = self.flatten(x)
x = self.sequential(x)
return x
# Instanziiere das Modell
modell = MeinNetzwerk()
Jetzt, da das Modell erstellt ist, kannst du es auf einer GPU instanziieren und ihm Eingabedaten übergeben. Du musst dafür jedoch zuerst Trainingsdaten und -labels erstellen und die richtigen Verlustfunktionen und Optimierer auswählen. Das vollständige Trainingsverfahren erfordert jedoch mehr Code und ist in diesem kurzen Beispiel nicht enthalten. Du kannst jedoch ein Dummy-Beispiel für die Vorhersage erstellen, um zu zeigen, wie das Modell verwendet wird:
# Dummy-Eingabedaten erstellen
dummy_eingabe = torch.randn(1, 28, 28)
# Übergebe die Eingabedaten an das Modell
vorhersage = modell(dummy_eingabe)
Um das Beispiel konkreter zu machen, so könnte ein einfaches Beispiel für die Verwendung von PyTorch aussehen, um eine Wettervorhersage auf der Grundlage von Wetterdaten zu erstellen. In diesem Beispiel verwenden wir ein einfaches Feedforward-Neuronales Netzwerk, um die Temperatur für den nächsten Tag basierend auf historischen Temperaturdaten vorherzusagen:
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
# Daten laden (Beispiel: 'weather_data.csv' enthält zwei Spalten: 'date' und 'temperature')
data = pd.read_csv('weather_data.csv')
temperatures = data['temperature'].values
# Daten vorbereiten
look_back = 5 # Anzahl der Tage in der Vergangenheit, die für die Vorhersage verwendet werden
scaler = MinMaxScaler()
temperatures = scaler.fit_transform(temperatures.reshape(-1, 1)).flatten()
X = []
y = []
for i in range(len(temperatures) - look_back - 1):
X.append(temperatures[i:i + look_back])
y.append(temperatures[i + look_back])
X = np.array(X)
y = np.array(y)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train = torch.tensor(X_train).float()
y_train = torch.tensor(y_train).float()
X_test = torch.tensor(X_test).float()
y_test = torch.tensor(y_test).float()
# Neuronales Netzwerk definieren
class WeatherPredictor(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(WeatherPredictor, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
# Hyperparameter
input_size = look_back
hidden_size = 32
output_size = 1
num_epochs = 100
learning_rate = 0.01
# Modell erstellen
model = WeatherPredictor(input_size, hidden_size, output_size)
# Loss-Funktion und Optimierer
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
# Modell trainieren
for epoch in range(num_epochs):
output = model(X_train)
loss = criterion(output, y_train)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 10 == 0:
print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')
# Modell testen
model.eval()
with torch.no_grad():
predictions = model(X_test)
test_loss = criterion(predictions, y_test)
print(f'Test Loss: {test_loss.item():.4f}')
# Beispielvorhersage
example_input = torch.tensor([0.5, 0.55, 0.6, 0.65, 0.7]).float()
predicted_temp = model(example_input).item()
predicted_temp = scaler.inverse_transform([[predicted_temp]])[0][0]
print(f'Vorhersage für den nächsten Tag: {predicted_temp:.2f}°C')
Dieses Beispiel soll dir einen Einstiegspunkt bieten, um mit PyTorch loszulegen. Um vollständige Tutorials und Beispiele zu finden, besuche die offizielle PyTorch-Website und ihre Dokumentation: https://pytorch.org/