Operaciones con tensores y conversión NumPy-PyTorch
Contenido del curso
Jeison Wu Mitre
Roilhi Frajo Ibarra Hernández
Joel Orellana
Miguel Rodríguez
Juan Acevedo
IVAN CARAPIA BARAJAS
Daniel Abraján
Juan Acevedo
Mario Alexander Vargas Celis
Alejandro Giraldo Londoño
Hace mucho vi como un video con respecto a esto y quiero compartirselos, habla de las operaciones de tensores y las reglas que es tiene y lo explica de una manera muy directa y sencilla.
VIDEO
Hola, Quiero compartirles 2 cosas. La primera que los tensores también se pueden multiplicar por medio del comando @. Por ejemplo: matriz1@matriz2 nos da el mismo resultado que torch.matmul(matriz1,matriz2). También me gustaría compartirles un sitio web donde se desarrolla paso a paso la multiplicación de matrices. Puedes ingresar los valores que desees y paso a paso observarás el resultado: matrixmultiplication.xyz (la plataforma no me deja ingresar el link porque no contiene el cerficado https pero pueden copiar y pegar).
Hola :) solo para completar, me gustaría mencionar que torch. mm(mx1, mx2) también se puede utilizar. Es una abreviatura en PyTorch.
Para quienes tengan problemas con los temas vistos en esta clase les recomiendo este par de cursos donde se profundiza mas en el tema:
La multiplicación de matrices , es el famoso producto punto o producto interno , que es lo que viene siendo una operación que se hace entre vectores que devuelve un escalar que a la final vienen siendo combinaciones lineales , que nos sirven a nosotros para poder representar la información en diferentes espacios y encontrar información muy especifica
El broadcasting de tensores es una técnica en PyTorch que permite realizar operaciones element-wise entre tensores de diferentes formas, adaptando automáticamente sus dimensiones. Por ejemplo, si tienes un tensor de 3x4 y otro de 1x4, PyTorch expandirá el tensor de 1x4 a 3x4 para realizar operaciones como suma o multiplicación. Esta funcionalidad es crucial para simplificar cálculos sin necesidad de reestructurar manualmente los datos. Sin embargo, el broadcasting solo se aplica si las dimensiones son compatibles.
El broadcasting no es exclusivo de PyTorch, es una técnica que viene del álgebra lineal computacional. Permite operar entre arreglos (vectores, matrices, tensores) de diferentes tamaños expandiendo automáticamente las dimensiones más pequeñas para que coincidan
La **conversión** y **operación** de tensores en PyTorch es esencial para manipular y procesar datos de manera eficiente. A continuación, te explico los conceptos clave y cómo realizar estas tareas.
### 1. **Creación de Tensores**
En PyTorch, los tensores son similares a los arrays de NumPy, pero con la ventaja de que pueden ser utilizados en GPU para realizar cálculos más rápidos.
import torch \# Crear un tensor vacío tensor\_vacio = torch.empty(3, 4) # Crea un tensor vacío de 3x4 \# Crear un tensor con ceros tensor\_ceros = torch.zeros(3, 4) # Tensor de 3x4 lleno de ceros \# Crear un tensor con unos tensor\_unos = torch.ones(3, 4) # Tensor de 3x4 lleno de unos \# Crear un tensor con valores aleatorios tensor\_aleatorio = torch.rand(3, 4) # Valores aleatorios en \[0, 1)
### 2. **Conversiones entre Tensores y NumPy**
Los tensores de PyTorch pueden convertirse fácilmente en arrays de NumPy y viceversa. Esto es útil cuando ya tienes código que utiliza NumPy y quieres aprovechar PyTorch.
- **De Tensor a NumPy:**
```python
tensor = torch.rand(3, 3)
array_numpy = tensor.numpy()
print(array_numpy) # Conversión de tensor a array NumPy
```
- **De NumPy a Tensor:**
```python
import numpy as np
array_numpy = np.array([[1, 2], [3, 4]])
tensor = torch.from_numpy(array_numpy)
print(tensor) # Conversión de array NumPy a tensor PyTorch
```
### 3. **Operaciones con Tensores**
PyTorch permite realizar operaciones matemáticas con tensores, similares a las que se pueden hacer con arrays de NumPy.
- **Suma de Tensores:**
```python
x = torch.rand(2, 3)
y = torch.rand(2, 3)
suma = x + y # Suma elemento por elemento
print(suma)
```
- **Multiplicación Elemento por Elemento (Hadamard):**
```python
mult_elemento = x * y
print(mult_elemento)
```
- **Producto Matricial (Producto Punto):**
```python
x = torch.rand(3, 2)
y = torch.rand(2, 4)
producto_matriz = torch.matmul(x, y) # Producto matricial
print(producto_matriz)
```
### 4. **Modificación del Tipo de Datos (dtype)**
Los tensores en PyTorch pueden ser de varios tipos, como float32, int64, etc. Puedes convertir el tipo de un tensor usando el método to() o cambiando el dtype directamente.
- **Especificar el Tipo de Dato al Crear el Tensor:**
```python
tensor_flotante = torch.ones(3, 3, dtype=torch.float32)
```
- **Convertir el Tipo de Dato Después de Crear el Tensor:**
```python
tensor = torch.rand(3, 3)
tensor_entero = tensor.to(torch.int32) # Convertir a enteros
```
### 5. **Mover Tensores entre CPU y GPU**
PyTorch soporta operaciones en GPU, lo cual acelera significativamente los cálculos. Puedes mover tensores entre CPU y GPU con .to().
- **Mover un Tensor a la GPU:**
```python
if torch.cuda.is_available():
tensor_gpu = tensor.to('cuda')
print(tensor_gpu.device) # Verifica que el tensor esté en la GPU
```
- **Mover un Tensor de la GPU a la CPU:**
```python
tensor_cpu = tensor_gpu.to('cpu')
```
### 6. **Operaciones de Redimensionado y Transposición**
A veces necesitas cambiar la forma de un tensor o reordenar sus dimensiones. Estas operaciones son muy comunes en procesamiento de datos.
- **Cambiar la Forma (view):**
```python
tensor = torch.rand(4, 4)
tensor_reshaped = tensor.view(2, 8) # Redimensionar a 2x8
print(tensor_reshaped.shape) # Verifica la nueva forma
```
- **Transponer un Tensor (transpose):**
```python
tensor = torch.rand(2, 3)
tensor_transpose = torch.transpose(tensor, 0, 1) # Intercambia las dimensiones 0 y 1
print(tensor_transpose.shape) # Verifica la forma después de transponer
```
### 7. **Operaciones de Agregación**
Puedes calcular estadísticas como sumas, medias, mínimos y máximos a lo largo de un eje del tensor.
- **Suma de Todos los Elementos:**
```python
tensor = torch.rand(3, 3)
suma_total = tensor.sum()
print(suma_total) # Imprime la suma de todos los elementos del tensor
```
- **Media por Ejes Específicos:**
```python
media_filas = tensor.mean(dim=1) # Media a lo largo de las filas (dimensión 1)
print(media_filas)
```
### 8. **Operaciones de Corte e Indexado**
Al igual que con los arrays de NumPy, puedes acceder a subconjuntos de un tensor o modificar partes específicas de él.
- **Acceder a un Elemento:**
```python
tensor = torch.rand(4, 4)
print(tensor[1, 2]) # Acceder al elemento en la fila 1, columna 2
```
- **Modificar un Elemento:**
```python
tensor[1, 2] = 10 # Asignar un valor al elemento en la fila 1, columna 2
```
- **Cortar Tensores:**
```python
tensor_slice = tensor[:, 1] # Seleccionar la segunda columna de todas las filas
```
### 9. **Operaciones de Concatenación**
Puedes unir varios tensores a lo largo de un eje específico.
- **Concatenar Tensores:**
```python
tensor_a = torch.rand(2, 3)
tensor_b = torch.rand(2, 3)
tensor_concat = torch.cat((tensor_a, tensor_b), dim=0) # Concatenar a lo largo de las filas
print(tensor_concat)
```
### 10. **Operaciones de Comparación**
Puedes comparar tensores para obtener un tensor booleano (True/False) en cada posición.
- **Comparar Elementos:**
```python
tensor = torch.rand(2, 3)
comparacion = tensor > 0.5 # Comparar si los elementos son mayores que 0.5
print(comparacion)
```
### Conclusión
PyTorch ofrece una gran flexibilidad para trabajar con tensores y realizar operaciones numéricas de manera eficiente. Las operaciones de conversión entre NumPy y PyTorch, junto con la posibilidad de mover tensores entre CPU y GPU, permiten un flujo de trabajo robusto y acelerado para el desarrollo de modelos de aprendizaje profundo y otras tareas.
■ Resumen:
C = A + B sumará cada elemento de A con el elemento correspondiente en B.torch.from\_numpy(array) convierte un array de NumPy a un tensor de PyTorch, manteniendo los datos subyacentes sin copiarlos. Esto es especialmente útil cuando se trabaja con datasets en NumPy y se necesita usar las capacidades de PyTorch para entrenamiento y modelado.