PyTorch-Tensor

Ein Tensor ist ein mehrdimensionales Array, das ein Skalar, ein Vektor, eine Matrix oder eine höherdimensionale Datenstruktur sein kann.

In PyTorch ist ein Tensor die zentrale Darstellung von Daten, ähnlich den mehrdimensionalen Arrays von NumPy, aber mit leistungsfähigeren Funktionen wie Unterstützung für GPU-Beschleunigung und automatische Gradientenberechnung.

Tensoren unterstützen mehrere Datentypen (Ganzzahl, Gleitkommazahl, boolesch usw.).

Tensoren können auf CPU oder GPU gespeichert werden; GPU-Tensoren können die Berechnung erheblich beschleunigen.

Die folgende Abbildung zeigt, wie Tensoren unterschiedlicher Dimensionen in PyTorch dargestellt werden:

Erklärung:

1D-Tensor / Vektor (eindimensionaler Tensor/Vektor):Die grundlegendste Tensorform, kann als Array betrachtet werden. Das Beispiel in der Abbildung ist ein Vektor mit 10 Elementen.
2D-Tensor / Matrix (zweidimensionaler Tensor/Matrix):Ein zweidimensionales Array, das normalerweise verwendet wird, um eine Matrix darzustellen. Das Beispiel in der Abbildung ist eine 4x5-Matrix mit 20 Elementen.
3D-Tensor / Würfel (dreidimensionaler Tensor/Würfel):Ein dreidimensionales Array, das als ein Würfel betrachtet werden kann, der durch Stapeln mehrerer Matrizen entsteht. Das Beispiel in der Abbildung zeigt einen 3x4x5-Würfel, wobei jede 5x5-Matrix eine "Schicht" des Würfels darstellt.
4D-Tensor / Vektor von Würfeln (vierdimensionaler Tensor/Vektor von Würfeln):Ein vierdimensionales Array, das als ein Vektor betrachtet werden kann, der aus mehreren Würfeln besteht. Das Beispiel in der Abbildung hat keine konkreten Werte, kann aber als eine Sammlung verstanden werden, die mehrere 3D-Tensoren enthält.
5D-Tensor / Matrix von Würfeln (fünfdimensionaler Tensor/Matrix von Würfeln):Ein fünfdimensionales Array, das als eine Matrix betrachtet werden kann, die aus mehreren 4D-Tensoren besteht. Das Beispiel in der Abbildung hat ebenfalls keine konkreten Werte, kann aber als eine Sammlung verstanden werden, die mehrere 4D-Tensoren enthält.

Tensoren erstellen

Es gibt mehrere Möglichkeiten, Tensoren zu erstellen:

Methode	Beschreibung	Beispielcode
`torch.tensor(data)`	Erstellen Sie einen Tensor aus einem Python- oder NumPy-Array.	`x = torch.tensor([[1, 2], [3, 4]])`
`torch.zeros(size)`	Erstellen Sie einen Tensor, der nur aus Nullen besteht.	`x = torch.zeros((2, 3))`
`torch.ones(size)`	Erstellen Sie einen Tensor, der nur aus Einsen besteht.	`x = torch.ones((2, 3))`
`torch.empty(size)`	Erstellen Sie einen nicht initialisierten Tensor.	`x = torch.empty((2, 3))`
`torch.rand(size)`	Erstellen Sie einen Zufallstensor nach einer Gleichverteilung, mit Werten in`[0, 1)`。	`x = torch.rand((2, 3))`
`torch.randn(size)`	Erstellen Sie einen Zufallstensor nach einer Normalverteilung mit Mittelwert 0 und Standardabweichung 1.	`x = torch.randn((2, 3))`
`torch.arange(start, end, step)`	Erstellen Sie einen eindimensionalen Sequenztensor, ähnlich wie der von Python`range`。	`x = torch.arange(0, 10, 2)`
`torch.linspace(start, end, steps)`	Erstellen Sie einen Sequenztensor mit gleichen Abständen innerhalb eines angegebenen Bereichs.	`x = torch.linspace(0, 1, 5)`
`torch.eye(size)`	Erstellen Sie eine Identitätsmatrix (Diagonale ist 1, andere sind 0).	`x = torch.eye(3)`
`torch.from_numpy(ndarray)`	Konvertieren Sie ein NumPy-Array in einen Tensor.	`x = torch.from_numpy(np.array([1, 2, 3]))`

Mit dertorch.tensor()-Funktion können Sie eine Liste oder ein Array in einen Tensor umwandeln:

Beispiel

import torch

tensor = torch.tensor([1, 2, 3])
print(tensor)

Die Ausgabe sieht wie folgt aus:

tensor([1, 2, 3])

Wenn Sie ein NumPy-Array haben, können Sie torch.from_numpy() verwenden, um es in einen Tensor umzuwandeln:

Beispiel

import numpy as np

np_array = np.array([1, 2, 3])
tensor = torch.from_numpy(np_array)
print(tensor)

Die Ausgabe sieht wie folgt aus:

tensor([1, 2, 3])

Erstellen eines 2D-Tensors (Matrix):

Beispiel

import torch

tensor_2d = torch.tensor([
[-9, 4, 2, 5, 7],
[3, 0, 12, 8, 6],
[1, 23, -6, 45, 2],
[22, 3, -1, 72, 6]
])
print("2D Tensor (Matrix):\n", tensor_2d)
print("Shape:", tensor_2d.shape) # shape

Die Ausgabe sieht wie folgt aus:

2D Tensor (Matrix):
 tensor([[-9,  4,  2,  5,  7],
        [ 3,  0, 12,  8,  6],
        [ 1, 23, -6, 45,  2],
        [22,  3, -1, 72,  6]])
Shape: torch.Size([4, 5])

Erstellen weiterer Dimensionen:

# 创建 3D 张量（立方体）
tensor_3d = torch.stack([tensor_2d, tensor_2d + 10, tensor_2d - 5])  # 堆叠 3 个 2D 张量
print("3D Tensor (Cube):\n", tensor_3d)
print("Shape:", tensor_3d.shape)  # 形状

# 创建 4D 张量（向量的立方体）
tensor_4d = torch.stack([tensor_3d, tensor_3d + 100])  # 堆叠 2 个 3D 张量
print("4D Tensor (Vector of Cubes):\n", tensor_4d)
print("Shape:", tensor_4d.shape)  # 形状

# 创建 5D 张量（矩阵的立方体）
tensor_5d = torch.stack([tensor_4d, tensor_4d + 1000])  # 堆叠 2 个 4D 张量
print("5D Tensor (Matrix of Cubes):\n", tensor_5d)
print("Shape:", tensor_5d.shape)  # 形状

Tensor-Attribute

Die Attribute eines Tensors sind wie folgt:

Attribute	Beschreibung	Beispiel
`.shape`	Die Form eines Tensors abrufen	`tensor.shape`
`.size()`	Die Form eines Tensors abrufen	`tensor.size()`
`.dtype`	Den Datentyp eines Tensors abrufen	`tensor.dtype`
`.device`	Das Gerät (CPU/GPU) anzeigen, auf dem sich der Tensor befindet	`tensor.device`
`.dim()`	Die Anzahl der Dimensionen eines Tensors abrufen	`tensor.dim()`
`.requires_grad`	Ob die Gradientenberechnung aktiviert ist	`tensor.requires_grad`
`.numel()`	Die Gesamtzahl der Elemente in einem Tensor abrufen	`tensor.numel()`
`.is_cuda`	Prüfen, ob sich der Tensor auf der GPU befindet	`tensor.is_cuda`
`.T`	Die Transponierte eines Tensors abrufen (anwendbar auf 2D-Tensoren)	`tensor.T`
`.item()`	Den Wert eines Tensors mit einem einzigen Element abrufen	`tensor.item()`
`.is_contiguous()`	Prüfen, ob der Tensor zusammenhängend gespeichert ist	`tensor.is_contiguous()`

Beispiel

import torch

# Einen 2D-Tensor erstellen
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)

# Tensor-Attribute
print("Tensor:\n", tensor)
print("Form:", tensor.shape) # Form abrufen
print("Größe:", tensor.size()) # Form abrufen (andere Methode)
print("Datentyp:", tensor.dtype) # Datentyp
print("Gerät:", tensor.device) # Gerät
print("Dimensionen:", tensor.dim()) # Anzahl der Dimensionen
print("Elemente insgesamt:", tensor.numel()) # Gesamtzahl der Elemente
print("Benötigt Gradient:", tensor.requires_grad) # Ob Gradient aktiviert ist
print("Ist CUDA:", tensor.is_cuda) # Ob auf GPU
print("Ist zusammenhängend:", tensor.is_contiguous()) # Ob zusammenhängender Speicher

# Einzelelementwert abrufen
single_value = torch.tensor(42)
print("Einzelelementwert:", single_value.item())

# Tensor transponieren
tensor_T = tensor.T
print("Transponierter Tensor:\n", tensor_T)

Ausgabeergebnis:

Tensor:
 tensor([[1., 2., 3.],
         [4., 5., 6.]])
Shape: torch.Size([2, 3])
Size: torch.Size([2, 3])
Data Type: torch.float32
Device: cpu
Dimensions: 2
Total Elements: 6
Requires Grad: False
Is CUDA: False
Is Contiguous: True
Single Element Value: 42
Transposed Tensor:
 tensor([[1., 4.],
         [2., 5.],
         [3., 6.]])

Tensoroperationen

Die Methoden für Tensoroperationen werden unten beschrieben.

Grundlegende Operationen:

Aktion	Beschreibung	Beispielcode
`+`, `-`, `*`, `/`	Elementweise Addition, Subtraktion, Multiplikation und Division.	`z = x + y`
`torch.matmul(x, y)`	Matrixmultiplikation.	`z = torch.matmul(x, y)`
`torch.dot(x, y)`	Vektor-Skalarprodukt (nur auf 1D-Tensoren anwendbar).	`z = torch.dot(x, y)`
`torch.sum(x)`	Summe.	`z = torch.sum(x)`
`torch.mean(x)`	Mittelwert.	`z = torch.mean(x)`
`torch.max(x)`	Maximum.	`z = torch.max(x)`
`torch.min(x)`	Minimum.	`z = torch.min(x)`
`torch.argmax(x, dim)`	Gib den Index des Maximalwerts zurück (entlang einer angegebenen Dimension).	`z = torch.argmax(x, dim=1)`
`torch.softmax(x, dim)`	Berechne Softmax (entlang einer angegebenen Dimension).	`z = torch.softmax(x, dim=1)`

Formoperationen

Aktion	Beschreibung	Beispielcode
`x.view(shape)`	Ändere die Form eines Tensors (ohne die Daten zu ändern).	`z = x.view(3, 4)`
`x.reshape(shape)`	Ähnlich wie`view`, aber flexibler.	`z = x.reshape(3, 4)`
`x.t()`	Transponiere die Matrix.	`z = x.t()`
`x.unsqueeze(dim)`	Füge an der angegebenen Dimension eine Dimension hinzu.	`z = x.unsqueeze(0)`
`x.squeeze(dim)`	Entferne die Dimension mit Größe 1 an der angegebenen Dimension.	`z = x.squeeze(0)`
`torch.cat((x, y), dim)`	Konkateniere mehrere Tensoren entlang einer angegebenen Dimension.	`z = torch.cat((x, y), dim=1)`

Beispiel

import torch

# Einen 2D-Tensor erstellen
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)
print("Originaler Tensor:\n", tensor)

# 1. **Indexierungs- und Slicing-Operationen**
print("\n[Indizierung und Slicing]")
print("Erste Zeile abrufen:", tensor[0]) # Erste Zeile abrufen
print("Das Element in der ersten Zeile und ersten Spalte abrufen:", tensor[0, 0]) # Ein bestimmtes Element abrufen
print("Alle Elemente in der zweiten Spalte abrufen:", tensor[:, 1]) # Alle Elemente in der zweiten Spalte abrufen

# 2. **Operationen zur Formtransformation**
print("\n[Formtransformation]")
reshaped = tensor.view(3, 2) # Tensorform auf 3x2 ändern
print("Tensor nach der Umformung:\n", reshaped)
flattened = tensor.flatten() # Tensor auf eine Dimension abflachen
print("Abgeflachter Tensor:\n", flattened)

# 3. **Mathematische Operationen**
print("\n[Mathematische Operationen]")
tensor_add = tensor + 10 # Tensor-Addition
print("Tensor plus 10:\n", tensor_add)
tensor_mul = tensor * 2 # Tensor-Multiplikation
print("Tensor multipliziert mit 2:\n", tensor_mul)
tensor_sum = tensor.sum() # Summe aller Elemente berechnen
print("Summe der Tensorelemente:", tensor_sum.item())

# 4. **Operationen mit anderen Tensoren**
print("\n[Operationen mit anderen Tensoren]")
tensor2 = torch.tensor([[1, 1, 1], [1, 1, 1]], dtype=torch.float32)
print("Ein weiterer Tensor:\n", tensor2)
tensor_dot = torch.matmul(tensor, tensor2.T) # Tensor-Matrixmultiplikation
print("Ergebnis der Matrixmultiplikation:\n", tensor_dot)

# 5. **Bedingte Prüfung und Filterung**
print("\n[Bedingte Prüfung und Filterung]")
mask = tensor > 3 # Eine boolesche Maske erstellen
print("Boolesche Maske der Elemente größer als 3:\n", mask)
filtered_tensor = tensor[tensor > 3] # Elemente filtern, die die Bedingung erfüllen
print("Elemente größer als 3:\n", filtered_tensor)

Ausgabeergebnis:

原始张量:
 tensor([[1., 2., 3.],
         [4., 5., 6.]])

【索引和切片】
获取第一行: tensor([1., 2., 3.])
获取第一行第一列的元素: tensor(1.)
获取第二列的所有元素: tensor([2., 5.])

【形状变换】
改变形状后的张量:
 tensor([[1., 2.],
         [3., 4.],
         [5., 6.]])
展平后的张量:
 tensor([1., 2., 3., 4., 5., 6.])

【数学运算】
张量加 10:
 tensor([[11., 12., 13.],
         [14., 15., 16.]])
张量乘 2:
 tensor([[ 2.,  4.,  6.],
         [ 8., 10., 12.]])
张量元素的和: 21.0

【与其他张量操作】
另一个张量:
 tensor([[1., 1., 1.],
         [1., 1., 1.]])
矩阵乘法结果:
 tensor([[ 6.,  6.],
         [15., 15.]])

【条件判断和筛选】
大于 3 的元素的布尔掩码:
 tensor([[False, False, False],
         [ True,  True,  True]])
大于 3 的元素:
 tensor([4., 5., 6.])

GPU-Beschleunigung von Tensoren

Den Tensor auf die GPU übertragen:

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
x = torch.tensor([1.0, 2.0, 3.0], device=device)

Prüfen, ob die GPU verfügbar ist:

torch.cuda.is_available()  # 返回 True oder  False

Interoperabilität zwischen Tensoren und NumPy

Die Interoperabilität zwischen Tensoren und NumPy ist in der folgenden Tabelle dargestellt:

Aktion	Beschreibung	Beispielcode
`torch.from_numpy(ndarray)`	Konvertieren Sie ein NumPy-Array in einen Tensor.	`x = torch.from_numpy(np_array)`
`x.numpy()`	Konvertieren Sie einen Tensor in ein NumPy-Array (nur CPU-Tensoren).	`np_array = x.numpy()`

Beispiel

import torch
import numpy as np

# 1. NumPy-Array in PyTorch-Tensor umwandeln
print("1. NumPy in PyTorch-Tensor umwandeln")
numpy_array = np.array([[1, 2, 3], [4, 5, 6]])
print("NumPy-Array:\n", numpy_array)

# Verwenden Sie torch.from_numpy(), um ein NumPy-Array in einen Tensor umzuwandeln
tensor_from_numpy = torch.from_numpy(numpy_array)
print(Konvertierter PyTorch-Tensor:\n", tensor_from_numpy)

# Ändern Sie das NumPy-Array und beobachten Sie die Änderung im Tensor (gemeinsam genutzter Speicher)
numpy_array[0, 0] = 100
print(Geändertes NumPy-Array:\n", numpy_array)
print(Der PyTorch-Tensor ändert sich ebenfalls entsprechend:\n", tensor_from_numpy)

# 2. PyTorch-Tensor in NumPy-Array umwandeln
print("\n2. PyTorch-Tensor in NumPy-Array umwandeln)
tensor = torch.tensor([[7, 8, 9], [10, 11, 12]], dtype=torch.float32)
print(PyTorch-Tensor:\n", tensor)

# Verwende tensor.numpy(), um den Tensor in ein NumPy-Array umzuwandeln
numpy_from_tensor = tensor.numpy()
print(Konvertiertes NumPy-Array:\n", numpy_from_tensor)

# Ändere den Tensor und beobachte die Änderung im NumPy-Array (gemeinsam genutzter Speicher)
tensor[0, 0] = 77
print(Modifizierter PyTorch-Tensor:\n", tensor)
print(Das NumPy-Array ändert sich ebenfalls entsprechend:\n", numpy_from_tensor)

# 3. Hinweis: Fälle, in denen Speicher nicht gemeinsam genutzt wird (Daten müssen kopiert werden)
print("\n3. Verwende clone(), um unabhängige Daten sicherzustellen)
tensor_independent = torch.tensor([[13, 14, 15], [16, 17, 18]], dtype=torch.float32)
numpy_independent = tensor_independent.clone().numpy() # Verwende clone, um Daten zu kopieren
print(Original-Tensor:\n", tensor_independent)
tensor_independent[0, 0] = 0 # Tensordaten ändern
print(Geänderter Tensor:\n", tensor_independent)
print(NumPy-Array (wird sich nicht entsprechend ändern):\n", numpy_independent)

Ausgabe:

1. NumPy 转为 PyTorch 张量
NumPy 数组:
 [[1 2 3]
 [4 5 6]]
转换后的 PyTorch 张量:
 tensor([[1, 2, 3],
         [4, 5, 6]])

修改后的 NumPy 数组:
 [[100   2   3]
 [  4   5   6]]
PyTorch 张量也会同步变化:
 tensor([[100,   2,   3],
         [  4,   5,   6]])

2. PyTorch 张量转为 NumPy 数组
PyTorch 张量:
 tensor([[ 7.,  8.,  9.],
         [10., 11., 12.]])
转换后的 NumPy 数组:
 [[ 7.  8.  9.]
 [10. 11. 12.]]

修改后的 PyTorch 张量:
 tensor([[77.,  8.,  9.],
         [10., 11., 12.]])
NumPy 数组也会同步变化:
 [[77.  8.  9.]
 [10. 11. 12.]]

3. 使用 clone() 保证独立数据
原始张量:
 tensor([[13., 14., 15.],
         [16., 17., 18.]])
修改后的张量:
 tensor([[ 0., 14., 15.],
         [16., 17., 18.]])
NumPy 数组（不会同步变化）:
 [[13. 14. 15.]
 [16. 17. 18.]]

Weitere Erweiterungen