Ich habe dieses Buch gekauft, weil ich etwas über PyTorch lernen wollte.
Nachdem ich einige davon verglichen hatte, wählte ich die für Anfänger, aber ... Ich weiß es nicht! !! !! Es wurde .
_ ** Ich habe die Ausgabe nicht geschrieben, daher weiß ich nicht, was ausgegeben wird und welche Art von Standpunkt ich überprüfen soll! !! ** _
Also habe ich eine ** Ergänzung ** zusammengestellt, die besagt, dass dies wahrscheinlich das ist, was ich versuche zu sagen. Die Ausführungsumgebung ist Google Colaboratory.
Installieren Sie PyTorch als vorläufige Vorbereitung.
IN
import torch
PyTorch verwendet eine GPU. Lassen Sie uns überprüfen, ob die GPU verfügbar ist.
IN
#Überprüfen Sie, ob eine GPU verfügbar ist
print(torch.cuda.is_available())
OUT
True
Nach dem Buch ist Tensor
Korrekt.
Kurz gesagt, es ist PyTorchs "mehrdimensionales Array". In dem Buch gab es Erklärungen und Beispielcode für Mess- und Datentypen, aber ich habe es nur definiert ** Ich habe den Inhalt überhaupt nicht bestätigt **. Also, ** ich werde die Daten überprüfen **.
IN
#Erstellen Sie durch Übergeben einer verschachtelten Liste
t = torch.tensor([[1, 2], [3, 4.]])
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.float32
device: cpu
tensor([[1., 2.],
[3., 4.]])
dtype ist der Datentyp und device gibt an, ob sich der Tensor auf der CPU oder der GPU befindet.
Lassen Sie uns einen Tensor auf der GPU erstellen.
IN
t = torch.tensor([[1, 2], [2, 4.]], device="cuda:0")
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.float32
device: cuda:0
tensor([[1., 2.],
[2., 4.]], device='cuda:0')
Es scheint, dass Sie mit torch.cuda.FloatTensor auch einen Tensor auf der GPU erstellen können.
IN
t = torch.cuda.FloatTensor([[1, 2], [2, 4.]])
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
dtype: torch.float32
device: cuda:0
tensor([[1., 2.],
[2., 4.]], device='cuda:0')
Cuda ist übrigens laut Wikipedia
CUDA (Compute Unified Device Architecture) ist eine universelle Parallel-Computing-Plattform (Parallel-Computing-Architektur) und ein Programmiermodell für GPUs, die von NVIDIA entwickelt und bereitgestellt werden.
Korrekt.
Jetzt ändern wir den Datentyp.
IN
#Geben Sie den 64-Bit-Datentyp an
t = torch.tensor([[1, 2], [2, 4.]], dtype=torch.float64)
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.float64
device: cpu
tensor([[1., 2.],
[2., 4.]], dtype=torch.float64)
Eine 64-Bit-Ganzzahl mit Vorzeichen kann auch mit "torch.LongTensor" definiert werden.
IN
t = torch.LongTensor([[1, 2], [2, 4.]])
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.int64
device: cpu
tensor([[1, 2],
[2, 4]])
Die Datentypen sind in diesem Dokument zusammengefasst. https://pytorch.org/docs/stable/tensors.html
Versuchen Sie, den auf der CPU erstellten Tensor auf die GPU zu übertragen.
IN
t = torch.zeros(100, 10).to("cuda:0")
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t[:2] #Scheiben sind auch in Tensor erhältlich
OUT
dtype: torch.float32
device: cuda:0
tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], device='cuda:0')
Wenn Sie die Form von Tensor überprüfen möchten, verwenden Sie die Größenfunktion anstelle der Formfunktion. Dies unterscheidet sich von NumPy.
IN
#Form wird durch Größe erhalten
# t.shape() #Kompilierungsfehler
t.size()
OUT
torch.Size([100, 10])
Verwenden Sie die Numpy-Funktion, um Tensor in Numpys Ndarray zu konvertieren.
IN
t = torch.tensor([[1, 2], [3, 4.]])
x = t.numpy()
print("type: {}".format(type(x)))
x
OUT
type: <class 'numpy.ndarray'>
array([[1., 2.],
[3., 4.]], dtype=float32)
Der Tensor auf der GPU muss in die CPU konvertiert werden.
IN
t = torch.cuda.FloatTensor([[1, 2], [3, 4.]])
x = t.to("cpu").numpy()
print("type: {}".format(type(x)))
x
OUT
type: <class 'numpy.ndarray'>
array([[1., 2.],
[3., 4.]], dtype=float32)
Versuchen wir einen verwirrenden Weg, um Tensor zu konvertieren.
Die Umformung in Numpy wird von der Ansichtsfunktion ausgeführt.
IN
# 2 *2 bis 4*Wechseln Sie zu 1
#Die Ansicht ähnelt der Umformung von Ndarray
x1 = torch.tensor([[1, 2], [3, 4.]])
x1.view(4, 1)
OUT
tensor([[1.],
[2.],
[3.],
[4.]])
Es gibt verschiedene Möglichkeiten, eine Translokation zu schreiben.
IN
x2 = torch.tensor([[10, 20, 30], [40, 50, 60.]])
x2.T
OUT
tensor([[10., 40.],
[20., 50.],
[30., 60.]])
IN
x2.t()
OUT
tensor([[10., 40.],
[20., 50.],
[30., 60.]])
Transponieren kann auch transponiert werden, aber zusätzlich zur Transposition kann auch das Bilddatenformat von HWC (vertikal, horizontal, Farbe) nach CHW (Farbe, horizontal, vertikal) sortiert werden.
IN
hwc_img_data = torch.rand(1, 5, 4, 3)
hwc_img_data
OUT
tensor([[[[0.9248, 0.7545, 0.5603],
[0.5339, 0.6627, 0.7652],
[0.7082, 0.5146, 0.9273],
[0.8437, 0.7064, 0.1053]],
[[0.2080, 0.8018, 0.6833],
[0.5892, 0.9264, 0.9315],
[0.0872, 0.1898, 0.5745],
[0.2192, 0.1187, 0.7537]],
[[0.9680, 0.9239, 0.8698],
[0.2339, 0.9918, 0.3446],
[0.6669, 0.4148, 0.2037],
[0.1055, 0.0353, 0.3679]],
[[0.7079, 0.4069, 0.1181],
[0.1983, 0.0452, 0.5788],
[0.6378, 0.7050, 0.1148],
[0.3960, 0.1924, 0.2714]],
[[0.3127, 0.1320, 0.7232],
[0.3484, 0.7617, 0.4725],
[0.4863, 0.9178, 0.3092],
[0.6279, 0.4259, 0.3828]]]])
Ich habe irgendwie verstanden, dass ich von 1 * 5 * 4 * 3 zu 1 * 4 * 5 * 3 wechseln würde (5 und 4 würden vertauscht).
IN
# 1 * 5 * 4 *3 zu 1* 4 * 5 *Wechseln Sie zu 3
hwc_img_data.transpose(1, 2)
OUT
tensor([[[[0.9248, 0.7545, 0.5603],
[0.2080, 0.8018, 0.6833],
[0.9680, 0.9239, 0.8698],
[0.7079, 0.4069, 0.1181],
[0.3127, 0.1320, 0.7232]],
[[0.5339, 0.6627, 0.7652],
[0.5892, 0.9264, 0.9315],
[0.2339, 0.9918, 0.3446],
[0.1983, 0.0452, 0.5788],
[0.3484, 0.7617, 0.4725]],
[[0.7082, 0.5146, 0.9273],
[0.0872, 0.1898, 0.5745],
[0.6669, 0.4148, 0.2037],
[0.6378, 0.7050, 0.1148],
[0.4863, 0.9178, 0.3092]],
[[0.8437, 0.7064, 0.1053],
[0.2192, 0.1187, 0.7537],
[0.1055, 0.0353, 0.3679],
[0.3960, 0.1924, 0.2714],
[0.6279, 0.4259, 0.3828]]]])
IN
#1 mehr* 4 * 5 *3 zu 1* 3 * 4 *Wechseln Sie zu 5
#Jetzt können Sie von hwc nach cwh konvertieren
hwc_img_data.transpose(1, 2).transpose(1, 3)
OUT
tensor([[[[0.9248, 0.5339, 0.7082, 0.8437],
[0.2080, 0.5892, 0.0872, 0.2192],
[0.9680, 0.2339, 0.6669, 0.1055],
[0.7079, 0.1983, 0.6378, 0.3960],
[0.3127, 0.3484, 0.4863, 0.6279]],
[[0.7545, 0.6627, 0.5146, 0.7064],
[0.8018, 0.9264, 0.1898, 0.1187],
[0.9239, 0.9918, 0.4148, 0.0353],
[0.4069, 0.0452, 0.7050, 0.1924],
[0.1320, 0.7617, 0.9178, 0.4259]],
[[0.5603, 0.7652, 0.9273, 0.1053],
[0.6833, 0.9315, 0.5745, 0.7537],
[0.8698, 0.3446, 0.2037, 0.3679],
[0.1181, 0.5788, 0.1148, 0.2714],
[0.7232, 0.4725, 0.3092, 0.3828]]]])
Wenn das Attribut require_grad auf True gesetzt ist, wird eine automatische Differenzierung durchgeführt. Das Buch beschreibt nicht im Detail, wo und was erscheinen wird, also werde ich es hinzufügen.
IN
x = torch.randn(100, 3)
a = torch.tensor([1, 2, 3.], requires_grad=True)
y = torch.mv(x, a)
print(y.grad_fn) #Stellen Sie sicher, dass das Berechnungsdiagramm zur Berechnung des Gradienten gespeichert ist
o = y.sum()
#Holen Sie sich einen Farbverlauf
#Variablen, die rückwärts arbeiten, müssen skalar sein
o.backward()
#Eine automatische Differenzierung wird durchgeführt, a.Gradient wird in grad erfasst
print(a.grad)
a.grad != x.sum(0)
OUT
<MvBackward object at 0x7f9c7998e3c8>
tensor([ 2.5016, 6.3925, -6.3674])
tensor([False, False, False])
Recommended Posts