Tenseur PyTorch

Un tenseur est un tableau multidimensionnel, qui peut être un scalaire, un vecteur, une matrice ou une structure de données de dimension supérieure.

Dans PyTorch, un tenseur est la représentation centrale des données, similaire aux tableaux multidimensionnels de NumPy, mais avec des fonctionnalités plus puissantes, comme la prise en charge de l'accélération GPU et le calcul automatique des gradients.

Les tenseurs prennent en charge plusieurs types de données (entier, nombre à virgule flottante, booléen, etc.).

Les tenseurs peuvent être stockés sur CPU ou GPU ; les tenseurs GPU peuvent accélérer considérablement les calculs.

La figure suivante montre comment les tenseurs de différentes dimensions sont représentés dans PyTorch :

Explication :

Tenseur 1D / Vecteur (tenseur/vecteur à une dimension) :La forme de tenseur la plus élémentaire, pouvant être vue comme un tableau. L'exemple de la figure est un vecteur contenant 10 éléments.
Tenseur 2D / Matrice (tenseur/matrice à deux dimensions) :Un tableau bidimensionnel, généralement utilisé pour représenter une matrice. L'exemple de la figure est une matrice 4x5 contenant 20 éléments.
Tenseur 3D / Cube (tenseur/cube à trois dimensions) :Un tableau tridimensionnel, pouvant être vu comme un cube formé en empilant plusieurs matrices. L'exemple de la figure montre un cube 3x4x5, où chaque matrice 5x5 représente une « couche » du cube.
Tenseur 4D / Vecteur de cubes (tenseur/vecteur de cubes à quatre dimensions) :Un tableau quadridimensionnel, pouvant être vu comme un vecteur composé de plusieurs cubes. L'exemple de la figure n'a pas de valeurs spécifiques, mais il peut être compris comme une collection contenant plusieurs tenseurs 3D.
Tenseur 5D / Matrice de cubes (tenseur/matrice de cubes à cinq dimensions) :Un tableau à cinq dimensions, pouvant être vu comme une matrice composée de plusieurs tenseurs 4D. De même, l'exemple de la figure n'a pas de valeurs spécifiques, mais il peut être compris comme une collection contenant plusieurs tenseurs 4D.

Création de tenseurs

Il existe plusieurs façons de créer des tenseurs :

Méthode	Description	Exemple de code
`torch.tensor(data)`	Créer un tenseur à partir d'une liste Python ou d'un tableau NumPy.	`x = torch.tensor([[1, 2], [3, 4]])`
`torch.zeros(size)`	Créer un tenseur rempli de zéros.	`x = torch.zeros((2, 3))`
`torch.ones(size)`	Créer un tenseur rempli de uns.	`x = torch.ones((2, 3))`
`torch.empty(size)`	Créer un tenseur non initialisé.	`x = torch.empty((2, 3))`
`torch.rand(size)`	Créer un tenseur aléatoire suivant une distribution uniforme, avec des valeurs dans`[0, 1)`。	`x = torch.rand((2, 3))`
`torch.randn(size)`	Créer un tenseur aléatoire suivant une distribution normale, avec une moyenne de 0 et un écart-type de 1.	`x = torch.randn((2, 3))`
`torch.arange(start, end, step)`	Créer un tenseur de séquence unidimensionnel, similaire à celle de Python`range`。	`x = torch.arange(0, 10, 2)`
`torch.linspace(start, end, steps)`	Créer un tenseur de séquence avec des intervalles égaux dans une plage spécifiée.	`x = torch.linspace(0, 1, 5)`
`torch.eye(size)`	Créer une matrice identité (la diagonale vaut 1, les autres valent 0).	`x = torch.eye(3)`
`torch.from_numpy(ndarray)`	Convertir un tableau NumPy en tenseur.	`x = torch.from_numpy(np.array([1, 2, 3]))`

Utilisez la fonctiontorch.tensor(), vous pouvez convertir une liste ou un tableau en un tenseur :

Exemple

import torch

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

La sortie est la suivante :

tensor([1, 2, 3])

Si vous avez un tableau NumPy, vous pouvez utiliser torch.from_numpy() pour le convertir en un tenseur :

Exemple

import numpy as np

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

La sortie est la suivante :

tensor([1, 2, 3])

Création d'un tenseur 2D (matrice) :

Exemple

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("Tenseur 2D (Matrice) :\n", tensor_2d)
print("Forme :", tensor_2d.shape) # shape

La sortie est la suivante :

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])

Création d'autres dimensions :

# 创建 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)  # 形状

Attributs du tenseur

Les attributs d'un tenseur sont les suivants :

Attribut	Description	Exemple
`.shape`	Obtenir la forme d'un tenseur	`tensor.shape`
`.size()`	Obtenir la forme d'un tenseur	`tensor.size()`
`.dtype`	Obtenir le type de données d'un tenseur	`tensor.dtype`
`.device`	Afficher l'appareil (CPU/GPU) sur lequel se trouve le tenseur	`tensor.device`
`.dim()`	Obtenir le nombre de dimensions d'un tenseur	`tensor.dim()`
`.requires_grad`	Indique si le calcul du gradient est activé	`tensor.requires_grad`
`.numel()`	Obtenir le nombre total d'éléments dans un tenseur	`tensor.numel()`
`.is_cuda`	Vérifier si le tenseur se trouve sur le GPU	`tensor.is_cuda`
`.T`	Obtenir la transposée d'un tenseur (applicable aux tenseurs 2D)	`tensor.T`
`.item()`	Obtenir la valeur d'un tenseur à un seul élément	`tensor.item()`
`.is_contiguous()`	Vérifier si le tenseur est stocké de manière contiguë	`tensor.is_contiguous()`

Exemple

import torch

# Créer un tenseur 2D
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)

# Attributs du tenseur
print("Tenseur :\n", tensor)
print("Forme :", tensor.shape) # Obtenir la forme
print("Taille :", tensor.size()) # Obtenir la forme (autre méthode)
print("Type de données :", tensor.dtype) # Type de données
print("Périphérique :", tensor.device) # Périphérique
print("Dimensions :", tensor.dim()) # Nombre de dimensions
print("Nombre total d'éléments :", tensor.numel()) # Nombre total d'éléments
print("Gradient requis :", tensor.requires_grad) # Indique si le gradient est activé
print("Est CUDA :", tensor.is_cuda) # Indique si sur GPU
print("Est contigu :", tensor.is_contiguous()) # Indique si le stockage est contigu

# Obtenir la valeur d'un seul élément
single_value = torch.tensor(42)
print("Valeur de l'élément unique :", single_value.item())

# Transposer le tenseur
tensor_T = tensor.T
print("Tenseur transposé :\n", tensor_T)

Résultat de sortie :

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.]])

Opérations sur les tenseurs

Les méthodes d'opérations sur les tenseurs sont décrites ci-dessous.

Opérations de base :

Opération	Description	Exemple de code
`+`, `-`, `*`, `/`	Addition, soustraction, multiplication et division élément par élément.	`z = x + y`
`torch.matmul(x, y)`	Multiplication matricielle.	`z = torch.matmul(x, y)`
`torch.dot(x, y)`	Produit scalaire de vecteurs (applicable uniquement aux tenseurs 1D).	`z = torch.dot(x, y)`
`torch.sum(x)`	Somme.	`z = torch.sum(x)`
`torch.mean(x)`	Moyenne.	`z = torch.mean(x)`
`torch.max(x)`	Maximum.	`z = torch.max(x)`
`torch.min(x)`	Minimum.	`z = torch.min(x)`
`torch.argmax(x, dim)`	Renvoie l'indice de la valeur maximale (le long d'une dimension spécifiée).	`z = torch.argmax(x, dim=1)`
`torch.softmax(x, dim)`	Calcule le softmax (le long d'une dimension spécifiée).	`z = torch.softmax(x, dim=1)`

Opérations sur les formes

Opération	Description	Exemple de code
`x.view(shape)`	Change la forme d'un tenseur (sans modifier les données).	`z = x.view(3, 4)`
`x.reshape(shape)`	Similaire à`view`, mais plus flexible.	`z = x.reshape(3, 4)`
`x.t()`	Transpose la matrice.	`z = x.t()`
`x.unsqueeze(dim)`	Ajoute une dimension au niveau d'une dimension spécifiée.	`z = x.unsqueeze(0)`
`x.squeeze(dim)`	Supprime la dimension de taille 1 au niveau de la dimension spécifiée.	`z = x.squeeze(0)`
`torch.cat((x, y), dim)`	Concatène plusieurs tenseurs le long d'une dimension spécifiée.	`z = torch.cat((x, y), dim=1)`

Exemple

import torch

# Créer un tenseur 2D
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)
print("Tenseur original :\n", tensor)

# 1. **Opérations d'indexation et de découpage**
print("\n[Indexation et découpage]")
print("Obtenir la première ligne :", tensor[0]) # Obtenir la première ligne
print("Obtenir l'élément à la première ligne et à la première colonne :", tensor[0, 0]) # Obtenir un élément spécifique
print("Obtenir tous les éléments de la deuxième colonne :", tensor[:, 1]) # Obtenir tous les éléments de la deuxième colonne

# 2. **Opérations de transformation de forme**
print("\n[Transformation de forme]")
reshaped = tensor.view(3, 2) # Changer la forme du tenseur en 3x2
print("Tenseur après remodelage :\n", reshaped)
flattened = tensor.flatten() # Aplatir le tenseur en une dimension
print("Tenseur aplati :\n", flattened)

# 3. **Opérations mathématiques**
print("\n[Opérations mathématiques]")
tensor_add = tensor + 10 # Addition de tenseurs
print("Tenseur plus 10:\n", tensor_add)
tensor_mul = tensor * 2 # Multiplication de tenseurs
print("Tenseur multiplié par 2:\n", tensor_mul)
tensor_sum = tensor.sum() # Calculer la somme de tous les éléments
print("Somme des éléments du tenseur:", tensor_sum.item())

# 4. **Opérations avec d'autres tenseurs**
print("\n[Opérations avec d'autres tenseurs]")
tensor2 = torch.tensor([[1, 1, 1], [1, 1, 1]], dtype=torch.float32)
print("Un autre tenseur:\n", tensor2)
tensor_dot = torch.matmul(tensor, tensor2.T) # Multiplication matricielle de tenseurs
print("Résultat de la multiplication matricielle:\n", tensor_dot)

# 5. **Jugement conditionnel et filtrage**
print("\n[Jugement conditionnel et filtrage]")
mask = tensor > 3 # Créer un masque booléen
print("Masque booléen des éléments supérieurs à 3 :\n", mask)
filtered_tensor = tensor[tensor > 3] # Filtrer les éléments qui satisfont la condition
print("Éléments supérieurs à 3 :\n", filtered_tensor)

Résultat de sortie :

原始张量:
 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.])

Accélération GPU des tenseurs

Transférer le tenseur vers le GPU :

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

Vérifier si le GPU est disponible :

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

Interopérabilité entre les tenseurs et NumPy

L'interopérabilité entre les tenseurs et NumPy est présentée dans le tableau suivant :

Opération	Description	Exemple de code
`torch.from_numpy(ndarray)`	Convertir un tableau NumPy en tenseur.	`x = torch.from_numpy(np_array)`
`x.numpy()`	Convertir un tenseur en tableau NumPy (tenseurs CPU uniquement).	`np_array = x.numpy()`

Exemple

import torch
import numpy as np

# 1. Convertir un tableau NumPy en tenseur PyTorch
print("1. Convertir NumPy en tenseur PyTorch")
numpy_array = np.array([[1, 2, 3], [4, 5, 6]])
print("Tableau NumPy :\n", numpy_array)

# Utiliser torch.from_numpy() pour convertir un tableau NumPy en tenseur
tensor_from_numpy = torch.from_numpy(numpy_array)
print(Tenseur PyTorch converti :\n", tensor_from_numpy)

# Modifier le tableau NumPy et observer le changement dans le tenseur (mémoire partagée)
numpy_array[0, 0] = 100
print(Tableau NumPy modifié :\n", numpy_array)
print(Le tenseur PyTorch change également en conséquence :\n", tensor_from_numpy)

# 2. Convertir un tenseur PyTorch en tableau NumPy
print("\n2. Tenseur PyTorch en tableau NumPy)
tensor = torch.tensor([[7, 8, 9], [10, 11, 12]], dtype=torch.float32)
print(Tenseur PyTorch :\n", tensor)

# Utiliser tensor.numpy() pour convertir le tenseur en un tableau NumPy
numpy_from_tensor = tensor.numpy()
print(Tableau NumPy converti :\n", numpy_from_tensor)

# Modifier le tenseur et observer le changement dans le tableau NumPy (mémoire partagée)
tensor[0, 0] = 77
print(Tenseur PyTorch modifié :\n", tensor)
print(Le tableau NumPy change également en conséquence :\n", numpy_from_tensor)

# 3. Remarque : cas où la mémoire n'est pas partagée (il faut copier les données)
print("\n3. Utiliser clone() pour garantir des données indépendantes)
tensor_independent = torch.tensor([[13, 14, 15], [16, 17, 18]], dtype=torch.float32)
numpy_independent = tensor_independent.clone().numpy() # Utiliser clone pour copier les données
print(Tenseur d'origine :\n", tensor_independent)
tensor_independent[0, 0] = 0 # Modifier les données du tenseur
print(Tenseur modifié :\n", tensor_independent)
print(Tableau NumPy (ne changera pas en conséquence) :\n", numpy_independent)

Sortie :

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.]]

Autres extensions