PyTorch y la programación orientada a objetos

Aprendizaje profundo intermedio con PyTorch

Michal Oleszak

Machine Learning Engineer

Lo que aprenderemos

Cómo entrenar modelos robustos de aprendizaje profundo:

Mejorar la formación con optimizadores
Mitigación de gradientes desaparecidos y explosivos
Redes neuronales convolucionales (CNN)
Redes neuronales recurrentes (RNN)
Modelos de múltiples entradas y múltiples salidas

Logotipo de PyTorch

Requisitos previos

El curso da por sentado que estás familiarizado con los siguientes temas:

Entrenamiento de redes neuronales:
- Pase hacia delante
- Cálculo de pérdidas
- Paso hacia atrás (retropropagación)
Modelos de entrenamiento con PyTorch:
- Conjuntos de datos y DataLoaders
- Bucle de entrenamiento del modelo
- Evaluación del modelo
Curso previo: Introducción al aprendizaje profundo con PyTorch

Programación orientada a objetos (OOP)

Usaremos la POO para definir:
- Conjunto de datos PyTorch
- Modelo PyTorch
En la POO, creamos objetos con:
- Habilidades (métodos)
- Datos (atributos)

Programación orientada a objetos (OOP)

class BankAccount:
    def __init__(self, balance):
        self.balance = balance

__init__ Se llama cuando se crea un objeto BankAccount.
balance es el atributo del objeto BankAccount

account = BankAccount(100)
print(account.balance)

Programación orientada a objetos (OOP)

Métodos Funciones de Python para realizar tareas
deposit el método aumenta el equilibrio

class BankAccount:
    def __init__(self, balance):
        self.balance = balance


    def deposit(self, amount):
        self.balance += amount

account = BankAccount(100)
account.deposit(50)
print(account.balance)

Conjunto de datos sobre la potabilidad del agua

Pandas DataFrame mostrando un par de primeras y últimas filas de los datos sobre la potabilidad del agua.

Conjunto de datos PyTorch

from torch.utils.data import Dataset

class WaterDataset(Dataset):

    def __init__(self, csv_path):
        super().__init__()
        df = pd.read_csv(csv_path)
        self.data = df.to_numpy()


    def __len__(self):
        return self.data.shape[0]


    def __getitem__(self, idx):
        features = self.data[idx, :-1]
        label = self.data[idx, -1]
        return features, label

init: cargar datos, almacenar como arreglo numpy
- super().__init__() asegura que WaterDataset se comporte como torch Dataset
len: devuelve el tamaño del conjunto de datos
getitem:
- toma un argumento llamado idx
- devuelve las características y la etiqueta de una sola muestra en el índice idx

DataLoader PyTorch

dataset_train = WaterDataset(
    "water_train.csv"
)

from torch.utils.data import DataLoader

dataloader_train = DataLoader(
    dataset_train,
    batch_size=2,
    shuffle=True,
)

features, labels = next(iter(dataloader_train))
print(f"Features: {features},
Labels: {labels}")


Features: tensor([
  [0.4899, 0.4180, 0.6299, 0.3496, 0.4575,
   0.3615, 0.3259, 0.5011, 0.7545],
  [0.7953, 0.6305, 0.4480, 0.6549, 0.7813,
   0.6566, 0.6340, 0.5493, 0.5789]
]),
Labels: tensor([1., 0.])

Modelo PyTorch

Definición del modelo secuencial:

net = nn.Sequential(
  nn.Linear(9, 16),
  nn.ReLU(),
  nn.Linear(16, 8),
  nn.ReLU(),
  nn.Linear(8, 1),
  nn.Sigmoid(),
)

Definición del modelo basado en clases:

class Net(nn.Module):

    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(9, 16)
        self.fc2 = nn.Linear(16, 8)
        self.fc3 = nn.Linear(8, 1)


    def forward(self, x):
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = nn.functional.sigmoid(self.fc3(x))
        return x

net = Net()

¡Vamos a practicar!

Aprendizaje profundo intermedio con PyTorch