Fundamentos de PyTorch

1

Clasificación de Texto con PyTorch y TorchText

2

Creación de modelos con PyTorch para IA moderna

3

Clasificación de Texto con PyTorch y Redes Neuronales Recurrentes

4

Manipulación de Tensores en PyTorch: Escalares a Multidimensionales

5

Debugging de Tensores en PyTorch: Tipos, Formas y Dispositivos

6

Operaciones entre Arrays NumPy y Tensores PyTorch

Quiz: Fundamentos de PyTorch

Estructura de modelo de deep learning en PyTorch

7

Regresión Lineal con PyTorch: Creación y Entrenamiento de Modelos

8

Regresión Lineal en PyTorch: Creación y Primeras Predicciones

9

Regresión Lineal con PyTorch: Pérdidas y Optimizadores

10

Visualización de pérdidas en entrenamiento con PyTorch

11

Predicciones con PyTorch usando CPU y graficación de resultados

Quiz: Estructura de modelo de deep learning en PyTorch

Redes neuronales con PyTorch

12

Clasificación de Texto con PyTorch y TorchText

13

Tokenización y Creación de Vocabulario con Torch Text

14

Creación de Data Loaders en PyTorch: Procesa Grandes Datasets Eficazmente

15

Modelo de Clasificación de Texto en PyTorch: Creación y Entrenamiento

16

Optimización de Modelos de Clasificación en Python

17

Creación y uso de funciones de evaluación en modelos de aprendizaje

18

Optimización y Funciones de Pérdida en Deep Learning

19

Entrenamiento de Modelos con PyTorch: Optimización y Validación

20

Inferencia de Modelos con PyTorch 2.0 y Torch Compile

21

Guardar y cargar modelos en PyTorch con checkpoints

22

Subir Modelos a JoggingFace: Repositorios y Comunidad Platzi

23

Optimización de modelos en PyTorch: carga y gestión de checkpoints

Quiz: Redes neuronales con PyTorch

Cierre del curso

24

Manejo de Tensores y Modelos con PyTorch

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Operaciones entre Arrays NumPy y Tensores PyTorch

6/24
Recursos

¿Cómo interactuar entre arrays de NumPy y tensores de PyTorch?

En este fascinante mundo de la inteligencia artificial y el aprendizaje automático, es común encontrarse con la necesidad de usar datos en diferentes formatos. Entre los más utilizados se encuentran los arrays de NumPy y los tensores de PyTorch. Aprender a convertir y operar entre estos formatos es clave para llevar a cabo desarrollos eficientes y flexibles. Te mostraremos cómo realizar estas conversiones y operaciones esenciales.

¿Cómo convertir arrays de NumPy a tensores de PyTorch y viceversa?

La conexión entre NumPy y PyTorch es sumamente poderosa. NumPy es una herramienta fundamental para el manejo de matrices y grandes cantidades de datos por su eficiencia y simplicidad, mientras que PyTorch es crucial en el procesamiento de datos para tareas más avanzadas de inteligencia artificial.

  • De NumPy a PyTorch: Si ya tienes un array de NumPy y deseas convertirlo en un tensor de PyTorch, puedes usar torch.from_numpy(). Aquí un ejemplo sencillo:

    import numpy as np
    import torch
    
    # Creación de un vector de NumPy con unos
    vector = np.ones(4, dtype=np.float32)
    
    # Conversión de NumPy a PyTorch
    tensor = torch.from_numpy(vector)
    
  • De PyTorch a NumPy: Si trabajas con tensores y necesitas revertirlos a un formato de NumPy, simplemente utiliza .numpy() en el tensor:

    # Conversión de PyTorch a NumPy
    array = tensor.numpy()
    

¿Cómo realizar operaciones básicas con tensores en PyTorch?

Realizar operaciones elementales como suma, resta, multiplicación, y división es crucial en cualquier pipeline de procesamiento de datos. Estas operaciones son básicas pero fundamentales para entender el flujo de datos:

  • Operaciones Element-wise: PyTorch permite realizar operaciones de forma elemento por elemento, siempre que los tensores tengan la misma forma.

    # Definición de tensores
    zeros_tensor = torch.zeros((3, 4))
    ones_tensor = torch.ones((3, 4))
    
    # Suma de tensores
    sum_tensor = zeros_tensor + ones_tensor
    
    # Multiplicación elemento por elemento
    mul_tensor = zeros_tensor * ones_tensor
    
  • División y Broadcasting: PyTorch también es capaz de manejar divisiones y aplicar el concepto de broadcasting para adaptar las formas de los tensores cuando sea posible.

    random_tensor = torch.rand(4)
    
    # Podemos dividirlo por el tensor de unos
    div_tensor = random_tensor / ones_tensor
    

¿Cómo realizar multiplicaciones de matrices?

La multiplicación de matrices es una piedra angular en cualquier tarea de inteligencia artificial. Aunque se trate de una operación más compleja, es esencial para llevar a cabo tareas avanzadas de machine learning.

  • Multiplicación de matrices usando PyTorch:

    matrix1 = torch.rand((2, 3))
    matrix2 = torch.rand((3, 2))
    
    # Multiplicación de matrices
    result_tensor = torch.matmul(matrix1, matrix2)
    

Este tipo de multiplicaciones sigue la lógica matemática tradicional y es una de las operaciones más comunes en el desarrollo de modelos de machine learning.

¡Más allá: Empezando tu aventura con PyTorch!

Hemos explorado cómo manipular y operar con tensores, aprender a convertirlos entre formatos NumPy y PyTorch, realizar operaciones elementales y no tan elementales como la multiplicación de matrices. Ahora estás preparado para embarcarte en el entrenamiento de modelos con PyTorch. La clave es seguir practicando y mejorando tus habilidades. ¡Prepárate para el próximo módulo! Y recuerda, la práctica hace al maestro. Te animamos a dejar tus comentarios y a unirte a la próxima etapa de este apasionante viaje.

¡Sigue adelante y nunca dejes de aprender!

Aportes 6

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

Para quienes tengan problemas con los temas vistos en esta clase les recomiendo este par de cursos donde se profundiza mas en el tema:

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.
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. ```python 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: * **Operaciones Elemento a Elemento**: Operaciones como suma, resta, multiplicación y división entre tensores se realizan de forma "element-wise", es decir, se aplican a cada par de elementos correspondientes de los tensores involucrados. Por ejemplo, si A y B son tensores, entonces `C = A + B` sumará cada elemento de A con el elemento correspondiente en B. * **Compatibilidad de Dimensiones y Broadcasting**: Para que las operaciones elemento a elemento funcionen, las dimensiones de los tensores deben ser iguales o compatibles a través de broadcasting. Broadcasting extiende las dimensiones de uno o ambos tensores para que sus formas sean compatibles sin copiar datos innecesarios. Por ejemplo, sumar un tensor de forma (3, 1) con uno de forma (3, 4) aplicará broadcasting al primer tensor para que se comporte como si tuviera la forma (3, 4). * **Conversión de NumPy a PyTorch**: La función `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.