Pythons Open-Source-Bibliothek für maschinelles Lernen.
PyTorch definiert eine Klasse namens ** Tensor ** (torch.Tensor), die zum Speichern und Berechnen mehrdimensionaler Arrays verwendet wird. Es ähnelt dem Array-Array von Numpy, ermöglicht jedoch auch CUDA-fähige Nvidia-Operationen auf GPUs.
[Quelle] -> PyTorch - Wikipedia
Bibliotheken für maschinelles Lernen werden grob in zwei Typen unterteilt: ** Definieren durch Ausführen ** und ** Definieren und Ausführen **.
Define by Run Definieren Sie das Netzwerk während der Ausführung. Da das Netzwerk dynamisch geändert werden kann, ist ein flexibles Design möglich. Beispielsweise ist es möglich, Netzwerke entsprechend der Datengröße zu wechseln und das Design für jede Iteration zu ändern. Bekannte Bibliotheken sind PyTorch und Chainer.
Define and Run Definieren Sie zuerst das Netzwerk und führen Sie es dann aus. Sie können ein Netzwerk einfach konfigurieren, indem Sie Teile wie einen Legoblock kombinieren. Prägnant und leicht verständlich. Bekannte Bibliotheken sind Keras und Tensorflow.
PyTorch gehört zur Bibliothek Define by Run für maschinelles Lernen, die während der Ausführung ein Netzwerk aufbaut. Aufgrund dieser Unterschiede scheint es am besten, diese Bibliotheken am richtigen Ort zu verwenden. Ist Keras of Define and Run in der normalen Datenanalyse einfach und PyTorch of Define by Run in Forschung und schwierigen Aufgaben, die ein detailliertes Design erfordern, überlegen?
[Referenzquelle] -> "Einführung in PyTorch" Verwendung und was ist der Unterschied zu Tensorflow, Keras usw.? --Proclassist
Der größte Unterschied zwischen PyTorch und Chainer besteht darin, dass PyTorch in überseeischen Gemeinden weit verbreitet ist, während Chainer hauptsächlich in Japan eingesetzt wird. Dies liegt daran, dass Chainer von einer Firma namens Preferred Networks (PFN) aus Japan entwickelt wurde. Im Dezember 2019 kündigte PFN jedoch an, das Hauptupdate von Chainer zu beenden und sich der Forschung und Entwicklung von PyTorch zuzuwenden, was die Beziehung zwischen den beiden Bibliotheken veränderte. Weitere Informationen finden Sie unter hier. Wenn Sie in Zukunft die Bibliothek Define by Run Machine Learning verwenden möchten, können Sie PyTorch sicher auswählen.
Überprüfen Sie die Spezifikationen von PyTorch, während Sie das offizielle Tutorial von PyTorch zitieren.
What is PyTorch? -- PyTorch Tutorials 1.4.0 documentation
Der in PyTorch verwendete "Tensor" ähnelt dem "ndarray" von Numpy, aber der "Tensor" kann zur schnelleren Berechnung mit der GPU berechnet werden.
Das Folgende ist eine Zusammenfassung der Verwendung von PyTorchs Tensor im Vergleich zu Numpy.
import torch
import numpy as np
Ein Array mit allen Nullen.
# Tensor
x_t = torch.zeros(2, 3)
# Numpy
x_n = np.zeros((2,3))
print('Tensor:\n',x_t,'\n')
print('Numpy:\n',x_n)
# ---Output---
#Tensor:
# tensor([[0., 0., 0.],
# [0., 0., 0.]])
#Numpy:
# [[0. 0. 0.]
# [0. 0. 0.]]
Ein Array mit allen Elementen 1.
# Tensor
x_t = torch.ones(2,3)
# Numpy
x_n = np.ones((2,3))
print('Tensor:\n',x_t,'\n')
print('Numpy:\n',x_n)
# ---Output---
#Tensor:
# tensor([[1., 1., 1.],
# [1., 1., 1.]])
#Numpy:
# [[1. 1. 1.]
# [1. 1. 1.]]
Ein Array, das die Werte der Elemente angibt.
# Tensor
x_t = torch.tensor([[5,3],[10,6]])
# Numpy
x_n = np.array([[5,3],[10,6]])
print('Tensor:\n',x_t,'\n')
print('Numpy:\n',x_n)
# ---Output---
#Tensor:
# tensor([[ 5, 3],
# [10, 6]])
#Numpy:
# [[ 5 3]
# [10 6]]
Ein Array, in dem Elementwerte durch Zufallszahlen angegeben werden.
# Tensor
x_t = torch.rand(2,3)
# Numpy
x_n = np.random.rand(2,3)
print('Tensor:\n',x_t,'\n',x12_t,'\n')
print('Numpy:\n',x_n,'\n',x12_n)
# ---Output---
#Tensor:
# tensor([[0.5266, 0.1276, 0.6704],
# [0.0412, 0.5800, 0.0312]])
# tensor(0.3370)
#Numpy:
# [[0.08877971 0.51718009 0.99738679]
# [0.35288525 0.68630145 0.73313903]]
# 0.1799177580940461
Der Zugriff auf jedes Element des Arrays kann wie "x [0,1]" erfolgen (dadurch werden die Elemente in der 1. Zeile und 2. Spalte des Arrays "x" abgerufen).
# Tensor
x12_t = x_t[0,1]
# Numpy
x12_n = x_n[0,1]
print('Tensor:\n',x12_t,'\n')
print('Numpy:\n',x12_n)
# ---Output---
#Tensor:
# tensor(0.1276)
#Numpy:
# 0.5171800941956144
Hierbei ist zu beachten, dass Numpy beim Abrufen eines Elements eines Arrays einen numerischen Wert erhält, PyTorch jedoch einen Tensor anstelle eines numerischen Werts. Daher kann PyTorch die auf diese Weise extrahierten Elemente des Arrays nicht als skalare Größe behandeln. Wenn Sie einen numerischen Wert wie Numpy abrufen möchten, müssen Sie Tensor.item () ausführen.
x12_value = x12_t.item()
print(x12_t)
print(x12_value)
# ---Output---
# tensor(0.1276)
# 0.12760692834854126
Mit PyTorch können Sie Operationen mit vier Regeln mit dem gleichen Gefühl wie Numpy ausführen.
# Tensor
x_t = torch.Tensor([1,2,3])
y_t = torch.Tensor([2,2,2])
add_t = x_t + y_t
sub_t = x_t - y_t
mul_t = x_t * y_t
div_t = x_t / y_t
print('Tensor:\nAddition:\n',add_t,'\nSubtraction:\n',sub_t,
'\nMultiplication:\n',mul_t,'\nDivision:\n',div_t,'\n')
# Numpy
x_n = np.array([1,2,3])
y_n = np.array([2,2,2])
add_n = x_n + y_n
sub_n = x_n - y_n
mul_n = x_n * y_n
div_n = x_n / y_n
print('Numpy:\nAddition:\n',add_n,'\nSubtraction:\n',sub_n,
'\nMultiplication:\n',mul_n,'\nDivision:\n',div_n)
# ---Output---
#Tensor:
#Addition:
# tensor([3., 4., 5.])
#Subtraction:
# tensor([-1., 0., 1.])
#Multiplication:
# tensor([2., 4., 6.])
#Division:
# tensor([0.5000, 1.0000, 1.5000])
#
#Numpy:
#Addition:
# [3 4 5]
#Subtraction:
# [-1 0 1]
#Multiplication:
# [2 4 6]
#Division:
# [0.5 1. 1.5]
Autograd: Automatic Differentiation -- PyTorch Tutorials 1.4.0 documentation
Die Forminformationen (Anzahl der Zeilen, Anzahl der Spalten) des Arrays können durch das "Form" -Verfahren erhalten werden. Es verhält sich wie Numpy.
# Tensor
x_t = torch.rand(4,3)
row_t = x_t.shape[0]
column_t = x_t.shape[1]
print('Tensor:\n','row: ',row_t,'column: ',column_t)
# Numpy
x_n = np.random.rand(4,3)
row_n = x_n.shape[0]
column_n = x_n.shape[1]
print('Numpy:\n','row: ',row_n,'column: ',column_n)
# ---Output---
#Tensor:
# row: 4 column: 3
#Numpy:
# row: 4 column: 3
Wenn Sie die Form des Arrays ändern möchten, verwenden Sie häufig ".view ()" in PyTorch und ".reshape ()" in Numpy. Sie können jedoch .reshape () sowohl für PyTorch's Tensor als auch für Numpy verwenden.
# Tensor
x_t = torch.rand(4,3)
y_t = x_t.view(12)
z_t = x_t.view(2,-1)
print('Tensor:\n',x_t,'\n',y_t,'\n',z_t,'\n')
# Numpy
x_n = np.random.rand(4,3)
y_n = x_n.reshape(12)
z_n = x_n.reshape([2,-1])
print('Numpy:\n',x_n,'\n',y_n,'\n',z_n)
# ---Output---
#Tensor:
# tensor([[0.5357, 0.2716, 0.2651],
# [0.6570, 0.0844, 0.9729],
# [0.4436, 0.9271, 0.4013],
# [0.8725, 0.2952, 0.1330]])
# tensor([0.5357, 0.2716, 0.2651, 0.6570, 0.0844, 0.9729, 0.4436, 0.9271, 0.4013,
# 0.8725, 0.2952, 0.1330])
# tensor([[0.5357, 0.2716, 0.2651, 0.6570, 0.0844, 0.9729],
# [0.4436, 0.9271, 0.4013, 0.8725, 0.2952, 0.1330]])
#
#Numpy:
# [[0.02711389 0.24172801 0.01202486]
# [0.59552453 0.49906154 0.81377212]
# [0.24744639 0.58570244 0.26464142]
# [0.14519645 0.03607043 0.46616757]]
# [0.02711389 0.24172801 0.01202486 0.59552453 0.49906154 0.81377212
# 0.24744639 0.58570244 0.26464142 0.14519645 0.03607043 0.46616757]
# [[0.02711389 0.24172801 0.01202486 0.59552453 0.49906154 0.81377212]
# [0.24744639 0.58570244 0.26464142 0.14519645 0.03607043 0.46616757]]
Bei Verwendung von .reshape ().
# Tensor
x_t = torch.rand(4,3)
y_t = x_t.reshape(2,-1)
#y_t = torch.reshape(x_t,[2,-1]) <-- Also works
print('Tensor:\n',y_t,'\n')
# Numpy
x_n = np.random.rand(4,3)
y_n = x_n.reshape(2,-1)
#y_n = np.reshape(x_n,[2,-1]) <-- Also works
print('Numpy:\n',y_n)
# ---Output---
#Tensor:
#tensor([[0.0617, 0.4898, 0.4745, 0.8218, 0.3760, 0.1556],
# [0.3192, 0.5886, 0.8385, 0.5321, 0.9758, 0.8254]])
#
#Numpy:
#[[0.60080911 0.55132561 0.75930606 0.03275005 0.83148483 0.48780054]
# [0.10971541 0.02317271 0.22571149 0.95286975 0.93045979 0.82358474]]
Die Array-Translokation erfolgt mit ".transpose ()" oder ".t ()" in PyTorch und mit ".transpose ()" oder ".T" in Numpy.
# Tensor
x_t = torch.rand(3,2)
xt_t = x_t.transpose(0,1)
#xt_t = torch.transpose(x_t,0,1)
#xt_t = x_t.t()
print('Tensor:\n',x_t,'\n',xt_t)
# Numpy
x_n = np.random.rand(3,2)
xt_n = x_n.transpose()
#xt_n = np.transpose(x_n)
#xt_n = x_n.T
print('Numpy:\n',x_n,'\n',xt_n)
# ---Output---
#Tensor:
# tensor([[0.8743, 0.8418],
# [0.6551, 0.2240],
# [0.9447, 0.2824]])
# tensor([[0.8743, 0.6551, 0.9447],
# [0.8418, 0.2240, 0.2824]])
#Numpy:
# [[0.80380702 0.81511741]
# [0.29398279 0.78025418]
# [0.19421487 0.43054298]]
# [[0.80380702 0.29398279 0.19421487]
# [0.81511741 0.78025418 0.43054298]]
Tensor --> ndarrayVerwenden Sie Tensor.numpy (), um von Tensor zu ndarray zu konvertieren.
Das konvertierte "ndarray" ist von der Änderung der Referenzquelle "Tensor" nicht betroffen. (ndarrya ist eine Kopie von Tensor.) Wenn Sie eine Verknüpfung herstellen möchten, müssen Sie die In-Place-Operation verwenden (fügen Sie am Ende jeder Funktion _ hinzu. Beispiel: add_ ().) Gibt es.
a = torch.ones(5)
b = a.numpy()
a = a + 1
print('a = ',a)
print('b = ',b)
# ---Output---
# a = tensor([2., 2., 2., 2., 2.])
# b = [1. 1. 1. 1. 1.]
a = torch.ones(5)
b = a.numpy()
a.add_(1)
#torch.add(a,1,out=a) <-- Same operation
print('a = ',a)
print('b = ',b)
# ---Output---
# a = tensor([2., 2., 2., 2., 2.])
# b = [2. 2. 2. 2. 2.]
Tensor <-- ndarrayVerwenden Sie beim Konvertieren von "ndarray" zu "Tensor" "torch.from_numpy (ndarray)".
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print('a = ',a)
print('b = ',b)
# ---Output---
# a = [2. 2. 2. 2. 2.]
# b = tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
CUDA Tensor
Tensor kann den Berechnungsbereich mit der Methode .to () verschieben.
Auf diese Weise können Sie den Tensor vom CPU-Speicher in den GPU-Speicher verschieben und Berechnungen durchführen.
x = torch.rand(2,3)
if torch.cuda.is_available():
device = torch.device("cuda") # a CUDA device object
y = torch.ones_like(x, device=device) # directly create a tensor on GPU
x = x.to(device) # or just use strings ``.to("cuda")``
z = x + y
print(z)
print(z.to("cpu", torch.double)) # ``.to`` can also change dtype together!
# ---Output---
#tensor([[1.1181, 1.1125, 1.3122],
# [1.1282, 1.5595, 1.4443]], device='cuda:0')
#tensor([[1.1181, 1.1125, 1.3122],
# [1.1282, 1.5595, 1.4443]], dtype=torch.float64)
Durch Setzen des Attributs require_grad von torch.Tensor auf True kann der gesamte Berechnungsverlauf verfolgt werden. Durch Aufrufen der Methode "backward ()" nach Abschluss der Berechnung wird die gesamte Differenzierung automatisch ausgeführt. Der Differentialkoeffizient wird im Attribut "grad" gespeichert.
Wenn Sie die Nachverfolgung des Berechnungsverlaufs beenden möchten, können Sie die Methode "attach ()" aufrufen, um sie von der Nachverfolgung des Berechnungsverlaufs zu trennen.
Jeder Tensor hat ein grad_fn Attribut. Dieses Attribut bezieht sich auf die Klasse "Function", die den "Tensor" erstellt. (Genau genommen hat der benutzerdefinierte "Tensor" nicht das "grad_fn" -Attribut, und der "Tensor" im Berechnungsergebnis erhält das "grad_fn" -Attribut.)
x = torch.ones(2, 2, requires_grad=True)
print(x)
# ---Output---
#tensor([[1., 1.],
# [1., 1.]], requires_grad=True)
y = x + 2
print(y)
# ---Output---
#tensor([[3., 3.],
# [3., 3.]], grad_fn=<AddBackward0>)
print(x.grad_fn)
print(y.grad_fn)
# ---Output---
# None
# <AddBackward0 object at 0x7f2285d93940>]
z = y * y * 3
out = z.mean()
print(z)
print(out)
# ---Output---
#tensor([[27., 27.],
# [27., 27.]], grad_fn=<MulBackward0>)
#tensor(27., grad_fn=<MeanBackward0>)
print(z.grad_fn)
# ---Output---
#<MulBackward0 object at 0x7f2285d93ac8>
out.backward()
print(x.grad)
# ---Output---
#tensor([[4.5000, 4.5000],
# [4.5000, 4.5000]])
Als ich das Endergebnis tatsächlich berechnet habe,
out = \frac{1}{4} \sum_{i} z_i \\
z_i = y_i \cdot y_i \cdot 3 = 3 \cdot (x_i+2)^2
Deshalb,
\frac{\partial out}{\partial x_i} = \frac{1}{4} \cdot 3 \cdot 2 \cdot (x_i+2) = 4.5
Es wird bestätigt, dass
Die Hauptpunkte dieses Artikels sind unten zusammengefasst.
--PyTorch ist eine Bibliothek zum maschinellen Lernen. --Verwenden Sie ein Array namens "torch.Tensor", das eine schnelle Berechnung und automatische Differenzierung ermöglicht. Dies kann fast genauso wie Numpys "numpy.ndaray" verwendet (definiert / berechnet) werden und kann leicht ineinander konvertiert werden.
Recommended Posts