Tensor en PyTorch

Un tensor es un arreglo multidimensional que puede ser un escalar, un vector, una matriz o una estructura de datos de dimensiones superiores.

En PyTorch, el tensor es la representación central de los datos, similar a los arreglos multidimensionales de NumPy, pero con capacidades más potentes, como soporte para aceleración por GPU y cálculo automático de gradientes.

Los tensores admiten múltiples tipos de datos (enteros, flotantes, booleanos, etc.).

Los tensores pueden almacenarse en la CPU o en la GPU; los tensores en GPU pueden acelerar significativamente el cálculo.

La siguiente figura muestra cómo se representan los tensores de diferentes dimensiones en PyTorch:

Notas:

  • 1D Tensor / Vector (tensor/vector unidimensional):La forma más básica de tensor, puede considerarse como un arreglo. El ejemplo en la figura es un vector que contiene 10 elementos.
  • 2D Tensor / Matrix (tensor/matriz bidimensional):Arreglo bidimensional, normalmente usado para representar matrices. El ejemplo en la figura es una matriz de 4x5 que contiene 20 elementos.
  • 3D Tensor / Cube (tensor/cubo tridimensional):Arreglo tridimensional, puede considerarse como un cubo formado por varias matrices apiladas. El ejemplo en la figura muestra un cubo de 3x4x5, donde cada matriz de 5x5 representa una "capa" del cubo.
  • 4D Tensor / Vector of Cubes (tensor/vector de cubos de cuatro dimensiones):Arreglo de cuatro dimensiones, puede considerarse como un vector compuesto por varios cubos. El ejemplo en la figura no tiene valores específicos, pero puede entenderse como una colección que contiene varios tensores 3D.
  • 5D Tensor / Matrix of Cubes (tensor/matriz de cubos de cinco dimensiones):Arreglo de cinco dimensiones, puede considerarse como una matriz compuesta por varios tensores 4D. El ejemplo en la figura tampoco tiene valores específicos, pero puede entenderse como una colección que contiene varios tensores 4D.

Crear tensores

Las formas de crear tensores son:

MétodoDescripciónCódigo de ejemplo
torch.tensor(data)Crea un tensor a partir de una lista de Python o un array de NumPy.x = torch.tensor([[1, 2], [3, 4]])
torch.zeros(size)Crea un tensor de ceros.x = torch.zeros((2, 3))
torch.ones(size)Crea un tensor de unos.x = torch.ones((2, 3))
torch.empty(size)Crea un tensor no inicializado.x = torch.empty((2, 3))
torch.rand(size)Crea un tensor aleatorio con distribución uniforme, con valores en[0, 1)。x = torch.rand((2, 3))
torch.randn(size)Crea un tensor aleatorio con distribución normal, con media 0 y desviación estándar 1.x = torch.randn((2, 3))
torch.arange(start, end, step)Crea un tensor de secuencia unidimensional, similar a `range` de Python.range。x = torch.arange(0, 10, 2)
torch.linspace(start, end, steps)Crea un tensor de secuencia con intervalos iguales dentro de un rango especificado.x = torch.linspace(0, 1, 5)
torch.eye(size)Crea una matriz identidad (diagonal en 1 y el resto en 0).x = torch.eye(3)
torch.from_numpy(ndarray)Convierte un array de NumPy a un tensor.x = torch.from_numpy(np.array([1, 2, 3]))

Usandotorch.tensor()la función, puedes convertir una lista o un array en un tensor:

Ejemplo

import torch

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

La salida es la siguiente:

tensor([1, 2, 3])

Si tienes un array de NumPy, puedes usar `torch.from_numpy()` para convertirlo en un tensor:

Ejemplo

import numpy as np

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

La salida es la siguiente:

tensor([1, 2, 3])

Crear un tensor 2D (matriz):

Ejemplo

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)  # Forma

La salida es la siguiente:

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

Creación de otras dimensiones:

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

Atributos del tensor

Los atributos de los tensores se muestran en la siguiente tabla:

AtributoDescripciónEjemplo
.shapeObtiene la forma del tensor.tensor.shape
.size()Obtiene la forma del tensor.tensor.size()
.dtypeObtiene el tipo de dato del tensor.tensor.dtype
.deviceMuestra el dispositivo en el que se encuentra el tensor (CPU/GPU).tensor.device
.dim()Obtiene el número de dimensiones del tensor.tensor.dim()
.requires_gradIndica si el cálculo de gradientes está habilitado.tensor.requires_grad
.numel()Obtiene el número total de elementos del tensor.tensor.numel()
.is_cudaComprueba si el tensor está en la GPU.tensor.is_cuda
.TObtiene la transpuesta del tensor (aplica a tensores 2D).tensor.T
.item()Obtiene el valor de un tensor de un solo elemento.tensor.item()
.is_contiguous()Comprueba si el tensor tiene almacenamiento contiguo.tensor.is_contiguous()

Ejemplo

import torch

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

# Atributos del tensor
print("Tensor:\n", tensor)
print("Shape:", tensor.shape)  # Obtener forma
print("Size:", tensor.size())  # Obtener la forma (otro método)
print("Data Type:", tensor.dtype)  # Tipo de datos
print("Device:", tensor.device)  # Dispositivo
print("Dimensions:", tensor.dim())  # Número de dimensiones
print("Total Elements:", tensor.numel())  # Número total de elementos
print("Requires Grad:", tensor.requires_grad)  # Si se habilita el gradiente
print("Is CUDA:", tensor.is_cuda)  # Si está en GPU
print("Is Contiguous:", tensor.is_contiguous())  # Si se almacena de forma contigua

# Obtener el valor de un único elemento
single_value = torch.tensor(42)
print("Single Element Value:", single_value.item())

# Transponer tensor
tensor_T = tensor.T
print("Transposed Tensor:\n", tensor_T)

Resultado:

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

Operaciones con tensores

Las operaciones con tensores se describen a continuación.

Operaciones básicas:

Operación Descripción Código de ejemplo
+, -, *, / Suma, resta, multiplicación y división a nivel de elementos. z = x + y
torch.matmul(x, y) Multiplicación de matrices. z = torch.matmul(x, y)
torch.dot(x, y) Producto punto de vectores (solo para tensores 1D). z = torch.dot(x, y)
torch.sum(x) Suma. z = torch.sum(x)
torch.mean(x) Media. z = torch.mean(x)
torch.max(x) Máximo. z = torch.max(x)
torch.min(x) Mínimo. z = torch.min(x)
torch.argmax(x, dim) Devuelve el índice del valor máximo (en la dimensión especificada). z = torch.argmax(x, dim=1)
torch.softmax(x, dim) Calcula el softmax (en la dimensión especificada). z = torch.softmax(x, dim=1)

Operaciones de forma

Operación Descripción Código de ejemplo
x.view(shape) Cambia la forma del tensor (sin cambiar los datos). z = x.view(3, 4)
x.reshape(shape) Similar aview, pero más flexible. z = x.reshape(3, 4)
x.t() Transpone la matriz. z = x.t()
x.unsqueeze(dim) Añade una dimensión en la posición especificada. z = x.unsqueeze(0)
x.squeeze(dim) Elimina las dimensiones cuyo tamaño es 1. z = x.squeeze(0)
torch.cat((x, y), dim) Concatena varios tensores a lo largo de una dimensión especificada. z = torch.cat((x, y), dim=1)

Ejemplo

import torch

# Crear un tensor 2D
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.float32)
print("Tensor original:\n", tensor)

# 1. **Operaciones de indexación y slicing**
print("\n【Indexación y segmentación】")
print("Obtener la primera fila:", tensor[0])  # Obtener la primera fila
print(Obtener el elemento de la primera fila y primera columna:, tensor[0, 0])  # Obtener elemento específico
print("Obtener todos los elementos de la segunda columna:", tensor[:, 1])  # Obtener todos los elementos de la segunda columna

# 2. **Operaciones de transformación de forma**
print("\n【Transformación de forma】)
reshaped = tensor.view(3, 2)  # Cambiar la forma del tensor a 3x2
print("Tensor después de cambiar la forma:\n", reshaped)
flattened = tensor.flatten()  # Aplanar el tensor a una dimensión
print("Tensor aplanado:\n", flattened)

# 3. **Operaciones matemáticas**
print("\n【Operaciones matemáticas】)
tensor_add = tensor + 10  # Suma de tensores
print("Suma de tensores 10:\n", tensor_add)
tensor_mul = tensor * 2  # Multiplicación de tensores
print(Tensor multiplicado por 2:\n", tensor_mul)
tensor_sum = tensor.sum()  # Calcular la suma de todos los elementos
print(Suma de los elementos del tensor:, tensor_sum.item())

# 4. **Operaciones con otros tensores**
print("\n【Con otras operaciones de tensor】")
tensor2 = torch.tensor([[1, 1, 1], [1, 1, 1]], dtype=torch.float32)
print(Otro tensor:\n", tensor2)
tensor_dot = torch.matmul(tensor, tensor2.T)  # Multiplicación de matrices tensoriales
print("Resultado de la multiplicación de matrices:\n", tensor_dot)

# 5. **Condiciones y filtrado**
print("\n【Evaluación de condiciones y filtrado】")
mask = tensor > 3  # Crear una máscara booleana
print("Máscara booleana de los elementos mayores que 3:\n", mask)
filtered_tensor = tensor[tensor > 3]  # Filtrar los elementos que cumplen las condiciones
print("Elementos mayores que 3:\n", filtered_tensor)

Resultado:

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

Aceleración de tensores con GPU

Transfiere el tensor a la GPU:

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

Comprueba si la GPU está disponible:

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

Interoperabilidad entre tensores y NumPy

La interoperabilidad entre tensores y NumPy se muestra en la siguiente tabla:

Operación Descripción Código de ejemplo
torch.from_numpy(ndarray) Convierte un array de NumPy a un tensor. x = torch.from_numpy(np_array)
x.numpy() Convierte un tensor a un array de NumPy (solo tensores en CPU). np_array = x.numpy()

Ejemplo

import torch
import numpy as np

# 1. Convertir array de NumPy a tensor de PyTorch
print("1. Convertir NumPy a tensor de PyTorch")
numpy_array = np.array([[1, 2, 3], [4, 5, 6]])
print(Arreglo de NumPy:\n", numpy_array)

# Usa torch.from_numpy() para convertir arrays de NumPy a tensores
tensor_from_numpy = torch.from_numpy(numpy_array)
print("Tensor de PyTorch convertido:"\n", tensor_from_numpy)

"# Modificar el array NumPy y observar el cambio del tensor (memoria compartida)"
numpy_array[0, 0] = 100
print("Array NumPy modificado:"\n", numpy_array)
print("El tensor de PyTorch también cambia sincronizadamente:"\n", tensor_from_numpy)

"# 2. Convertir tensor de PyTorch a array NumPy"
print("\n"2. Conversión de tensor de PyTorch a array NumPy")
tensor = torch.tensor([[7, 8, 9], [10, 11, 12]], dtype=torch.float32)
print("Tensor de PyTorch:"\n", tensor)

"# Usar tensor.numpy() para convertir el tensor a array NumPy"
numpy_from_tensor = tensor.numpy()
print("Array NumPy convertido:"\n", numpy_from_tensor)

"# Modificar el tensor y observar el cambio del array NumPy (memoria compartida)"
tensor[0, 0] = 77
print("Tensor de PyTorch modificado:"\n", tensor)
print("El array NumPy también cambia sincronizadamente:"\n", numpy_from_tensor)

"# 3. Nota: caso sin memoria compartida (se necesita copiar datos)"
print("\n"3. Usar clone() para garantizar datos independientes")
tensor_independent = torch.tensor([[13, 14, 15], [16, 17, 18]], dtype=torch.float32)
numpy_independent = tensor_independent.clone().numpy()  "# Usar clone para copiar datos"
print("Tensor original:"\n", tensor_independent)
tensor_independent[0, 0] = 0  "# Modificar los datos del tensor"
print("Tensor modificado:"\n", tensor_independent)
print("Array NumPy (no cambiará sincronizadamente):"\n", numpy_independent)

"Resultado de salida:"

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.]]
"Otras extensiones"