El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

¿Qué es PyTorch?

PyTorch es una biblioteca de aprendizaje automático de código abierto desarrollada por Facebook's AI Research lab (FAIR). Es ampliamente utilizada por investigadores y desarrolladores debido a su flexibilidad y facilidad de uso. PyTorch proporciona una interfaz intuitiva y dinámica para construir y entrenar modelos de redes neuronales.

Características Clave de PyTorch:

Tensors: Estructuras de datos similares a los arrays de NumPy, pero con la capacidad de ser utilizados en GPUs para acelerar el cálculo.
Autograd: Sistema de diferenciación automática que facilita la construcción y el entrenamiento de redes neuronales.
TorchScript: Permite la transición entre el modo de investigación y producción.
Biblioteca de Modelos Preentrenados: Acceso a modelos preentrenados y herramientas para transfer learning.

Instalación de PyTorch

Para instalar PyTorch, puedes usar pip o conda. A continuación se muestra cómo instalar PyTorch usando pip:

pip install torch torchvision torchaudio

Para instalar PyTorch con conda:

conda install pytorch torchvision torchaudio -c pytorch

Conceptos Básicos de PyTorch

3.1 Tensors

Los tensores son la estructura de datos fundamental en PyTorch. Son similares a los arrays de NumPy, pero con capacidades adicionales para ser utilizados en GPUs.

Creación de Tensors

import torch

# Crear un tensor vacío
tensor_vacio = torch.empty(3, 3)
print(tensor_vacio)

# Crear un tensor de ceros
tensor_ceros = torch.zeros(3, 3)
print(tensor_ceros)

# Crear un tensor de unos
tensor_unos = torch.ones(3, 3)
print(tensor_unos)

# Crear un tensor a partir de una lista
tensor_lista = torch.tensor([1, 2, 3, 4])
print(tensor_lista)

3.2 Operaciones con Tensors

PyTorch permite realizar una variedad de operaciones matemáticas con tensores.

# Suma de tensores
tensor_a = torch.tensor([1, 2, 3])
tensor_b = torch.tensor([4, 5, 6])
tensor_suma = tensor_a + tensor_b
print(tensor_suma)

# Multiplicación de tensores
tensor_mult = tensor_a * tensor_b
print(tensor_mult)

# Producto matricial
tensor_c = torch.tensor([[1, 2], [3, 4]])
tensor_d = torch.tensor([[5, 6], [7, 8]])
tensor_prod_mat = torch.matmul(tensor_c, tensor_d)
print(tensor_prod_mat)

3.3 Autograd: Diferenciación Automática

El módulo autograd de PyTorch permite la diferenciación automática de todas las operaciones en los tensores.

# Crear un tensor con gradiente
x = torch.tensor(2.0, requires_grad=True)

# Definir una función
y = x**2 + 3*x + 1

# Calcular la derivada
y.backward()

# Imprimir el gradiente
print(x.grad)

Construcción de una Red Neuronal Simple

4.1 Definición del Modelo

En PyTorch, las redes neuronales se definen utilizando la clase torch.nn.Module.

import torch.nn as nn
import torch.nn.functional as F

class RedNeuronalSimple(nn.Module):
    def __init__(self):
        super(RedNeuronalSimple, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 1)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

4.2 Entrenamiento del Modelo

Para entrenar el modelo, necesitamos definir una función de pérdida y un optimizador.

import torch.optim as optim

# Crear una instancia del modelo
modelo = RedNeuronalSimple()

# Definir la función de pérdida y el optimizador
criterio = nn.MSELoss()
optimizador = optim.SGD(modelo.parameters(), lr=0.01)

# Datos de ejemplo
datos_entrada = torch.randn(10)
etiqueta_real = torch.tensor([1.0])

# Proceso de entrenamiento
for epoch in range(100):
    # Forward pass
    salida = modelo(datos_entrada)
    perdida = criterio(salida, etiqueta_real)

    # Backward pass y optimización
    optimizador.zero_grad()
    perdida.backward()
    optimizador.step()

    if epoch % 10 == 0:
        print(f'Epoch [{epoch}/100], Pérdida: {perdida.item():.4f}')

Ejercicio Práctico

Ejercicio: Construir y Entrenar una Red Neuronal para Clasificación de Dígitos MNIST

Paso 1: Cargar el Dataset MNIST

import torchvision
import torchvision.transforms as transforms

# Transformaciones para normalizar los datos
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# Descargar y cargar el dataset de entrenamiento
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# Descargar y cargar el dataset de prueba
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

Paso 2: Definir el Modelo

class RedNeuronalMNIST(nn.Module):
    def __init__(self):
        super(RedNeuronalMNIST, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)  # Aplanar la imagen
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

Paso 3: Entrenar el Modelo

# Crear una instancia del modelo
modelo_mnist = RedNeuronalMNIST()

# Definir la función de pérdida y el optimizador
criterio = nn.CrossEntropyLoss()
optimizador = optim.SGD(modelo_mnist.parameters(), lr=0.01)

# Proceso de entrenamiento
for epoch in range(5):  # Entrenar por 5 épocas
    for i, (imagenes, etiquetas) in enumerate(trainloader):
        # Forward pass
        salidas = modelo_mnist(imagenes)
        perdida = criterio(salidas, etiquetas)

        # Backward pass y optimización
        optimizador.zero_grad()
        perdida.backward()
        optimizador.step()

        if (i+1) % 100 == 0:
            print(f'Epoch [{epoch+1}/5], Paso [{i+1}/{len(trainloader)}], Pérdida: {perdida.item():.4f}')

Paso 4: Evaluar el Modelo

# Evaluar el modelo en el dataset de prueba
modelo_mnist.eval()  # Modo evaluación
correctos = 0
total = 0

with torch.no_grad():
    for imagenes, etiquetas in testloader:
        salidas = modelo_mnist(imagenes)
        _, predicciones = torch.max(salidas.data, 1)
        total += etiquetas.size(0)
        correctos += (predicciones == etiquetas).sum().item()

print(f'Precisión del modelo en el dataset de prueba: {100 * correctos / total:.2f}%')

Conclusión

En esta sección, hemos introducido PyTorch, una poderosa biblioteca para el aprendizaje profundo. Hemos cubierto los conceptos básicos, incluyendo la creación y manipulación de tensores, la diferenciación automática con autograd, y la construcción y entrenamiento de una red neuronal simple. Además, hemos realizado un ejercicio práctico para construir y entrenar una red neuronal para la clasificación de dígitos MNIST. Con estos conocimientos, estás preparado para explorar más a fondo las capacidades de PyTorch y aplicarlo a problemas más complejos en el campo del Deep Learning.

Introducción a PyTorch

¿Qué es PyTorch?

Características Clave de PyTorch:

Instalación de PyTorch

Conceptos Básicos de PyTorch

3.1 Tensors

Creación de Tensors

3.2 Operaciones con Tensors

3.3 Autograd: Diferenciación Automática

Construcción de una Red Neuronal Simple

4.1 Definición del Modelo

4.2 Entrenamiento del Modelo

Ejercicio Práctico

Ejercicio: Construir y Entrenar una Red Neuronal para Clasificación de Dígitos MNIST

Paso 1: Cargar el Dataset MNIST

Paso 2: Definir el Modelo

Paso 3: Entrenar el Modelo

Paso 4: Evaluar el Modelo

Conclusión

Curso de Deep Learning

Módulo 1: Introducción a Deep Learning

Módulo 2: Fundamentos de Redes Neuronales

Módulo 3: Redes Neuronales Convolucionales (CNN)

Módulo 4: Redes Neuronales Recurrentes (RNN)

Módulo 5: Técnicas Avanzadas en Deep Learning

Módulo 6: Herramientas y Frameworks

Módulo 7: Proyectos Prácticos

Módulo 8: Consideraciones Éticas y Futuro del Deep Learning