PyTorch für Deep Learning. Ian Pointer
die wir in einigen nachfolgenden Kapiteln verwenden, um Deep-Learning-Architekturen zu erstellen, die mit Bildern arbeiten. Mit der Anaconda-Distribution wird automatisch auch Jupyter Notebook für uns installiert. Wir können also sofort loslegen:
jupyter notebook
Geben Sie http://YOUR-IP-ADDRESS:8888 in Ihren Browser ein (eigentlich sollten Sie direkt darauf umgeleitet werden), erstellen Sie ein neues Notebook und geben Sie Folgendes ein:
import torch
print(torch.cuda.is_available())
print(torch.rand(2,2))
Dies sollte zu einer ähnlichen Ausgabe wie der folgenden führen:
True
0.6040 0.6647
0.9286 0.4210
[torch.FloatTensor of size 2x2]
Falls der Befehl cuda.is_available() als Ausgabe False zurückgibt, müssen Sie Ihre CUDA-Installation debuggen, damit PyTorch Ihre Grafikkarte erkennen kann. Die Werte des Tensors werden auf Ihrer Instanz etwas anders sein.
Aber was ist eigentlich dieser Tensor? Tensoren sind das Herzstück von fast allem in PyTorch. Deshalb sollten Sie wissen, was ein Tensor ist und was er für Sie leisten kann.
Tensoren
Ein Tensor ist sowohl ein Container für Zahlen als auch ein Regelsatz, der Transformationen zwischen Tensoren definiert, die neue Tensoren erzeugen. Es ist wahrscheinlich am einfachsten für uns, Tensoren als mehrdimensionale Arrays aufzufassen. Jeder Tensor hat einen Rang, der seinem Dimensionsraum entspricht. Ein einfacher Skalar (z.B. 1) kann als Tensor mit dem Rang 0 dargestellt werden, ein Vektor besitzt den Rang 1, eine n × n-Matrix den Rang 2 und so weiter. Im vorigen Beispiel haben wir einen Tensor mit Zufallswerten vom Rang 2 durch die Verwendung von torch.rand() erstellt. Wir können sie auch aus Listen erzeugen:
x = torch.Tensor([[0,0,1],[1,1,1],[0,0,0]])
x
>tensor([[0, 0, 1],
[1, 1, 1],
[0, 0, 0]])
Wir können ein Element in einem Tensor ändern, indem wir die gewöhnliche Python-Indizierung verwenden:
x[0][0] = 5
>tensor([[5, 0, 1],
[1, 1, 1],
[0, 0, 0]])
Sie können spezielle vordefinierte Funktionen einsetzen, um bestimmte Arten von Tensoren zu erzeugen. Insbesondere die Funktionen ones() und zeroes() erzeugen Tensoren, die mit Einsen bzw. mit Nullen gefüllt sind:
torch.zeros(2,2)
> tensor([[0., 0.],
[0., 0.]])
Auch mathematische Standardoperationen können mit Tensoren durchgeführt werden (z.B. können zwei Tensoren addiert werden):
torch.ones(1,2) + torch.ones(1,2)
> tensor([[2., 2.]])
Und wenn Sie einen Tensor vom Rang 0 haben, können Sie sich den Wert des Elements mit der Funktion item() ausgeben lassen:
torch.rand(1).item()
> 0.34106671810150146
Tensoren können sowohl auf der CPU als auch auf der GPU eingesetzt und mit der Funktion to() zwischen den Komponenten kopiert werden:
cpu_tensor = tensor.rand(2)
cpu_tensor.device
> device(type='cpu')
gpu_tensor = cpu_tensor.to("cuda")
gpu_tensor.device
> device(type='cuda', index=0)
Tensoroperationen
Wenn Sie sich die PyTorch-Dokumentation (https://oreil.ly/1Ev0-) anschauen, werden Sie feststellen, dass es eine Vielzahl an Funktionen gibt, die Sie auf Tensoren anwenden können – alles vom Finden des Maximalwerts bis zur Anwendung einer Fourier-Transformation. Im vorliegenden Buch müssen Sie nicht alle Funktionen kennen, um die Bilder, Texte und Töne in Tensoren zu verwandeln und sie für unsere Zwecke zu manipulieren. Sie werden dennoch einige benötigen. Ich empfehle Ihnen auf jeden Fall, spätestens aber nach dem Lesen dieses Buchs, einen Blick in die Dokumentation zu werfen. Gehen wir nun alle Funktionen durch, die in den kommenden Kapiteln verwendet werden.
Zum einen müssen wir häufig das Element mit dem Maximalwert in einem Tensor sowie den korrespondierenden Index des Elements finden (da dieses oft der Kategorie angehört, für die sich das neuronale Netz in seiner endgültigen Vorhersage entschieden hat). Dies können wir mit den Funktionen max() und argmax() vornehmen. Ebenso können wir die Funktion item() verwenden, um einen Wert aus einem eindimensionalen Tensor zu extrahieren.
torch.rand(2,2).max()
> tensor(0.4726)
torch.rand(2,2).max().item()
> 0.8649941086769104
In manchen Situationen möchten wir den Typ eines Tensors ändern, zum Beispiel von einem LongTensor in einen FloatTensor. Dies können wir mit der Funktion to() erreichen:
long_tensor = torch.tensor([[0,0,1],[1,1,1],[0,0,0]])
long_tensor.type()
> 'torch.LongTensor'
float_tensor = torch.tensor([[0,0,1],[1,1,1],[0,0,0]]).to(dtype=torch.float32)
float_tensor.type()
> 'torch.FloatTensor'
Die meisten Funktionen, die auf einem Tensor operieren und einen Tensor zurückgeben, erzeugen gleichzeitig einen neuen Tensor, um das Ergebnis zu speichern. Wenn Sie jedoch Arbeitsspeicher sparen wollen, vergewissern Sie sich, ob eine In-Place-Funktion definiert ist. Diese besitzt den gleichen Namen wie die ursprüngliche Funktion, lediglich mit einem angehängten Unterstrich (_).
random_tensor = torch.rand(2,2)
random_tensor.log2()
>tensor([[-1.9001, -1.5013],
[-1.8836, -0.5320]])
random_tensor.log2_()
> tensor([[-1.9001, -1.5013],
[-1.8836, -0.5320]])
Eine weitere gängige Operation ist die Umformung eines Tensors. Dies kann oft vonnöten sein, weil Ihre neuronale Netzwerkschicht eine etwas andere Form der Eingabe erfordert als die, die Sie gerade einspeisen. Zum Beispiel ist der Datensatz des Modified National Institute of Standards and Technology (MNIST) mit handgeschriebenen Ziffern eine Sammlung von 28 × 28 Pixel großen Bildern. Er besteht jedoch aus Arrays der Länge 784. Um die Netzwerke, die wir aufbauen, zu verwenden, müssen wir diese wieder in 1 × 28 × 28-Tensoren umwandeln (die führende 1 entspricht der Anzahl der Farbkanäle – für gewöhnlich Rot, Grün und Blau –, da die MNIST-Ziffern aber nur in Graustufen gehalten sind, haben wir lediglich einen Kanal). Die Umformung können wir entweder mit der Funktion view() oder mit reshape() durchführen:
flat_tensor = torch.rand(784)
viewed_tensor = flat_tensor.view(1,28,28)
viewed_tensor.shape
> torch.Size([1, 28, 28])
reshaped_tensor = flat_tensor.reshape(1,28,28)