Escribir nuestro primer bucle de entrenamiento

Introducción al aprendizaje profundo con PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Entrenar una red neuronal

Crear un modelo
Elige una función de pérdida
Definir un conjunto de datos
Establecer un optimizador
Ejecuta un bucle de entrenamiento:
- Calcula la pérdida (pase hacia adelante)
- Calcula los gradientes (retropropagación)
- Actualizar los parámetros del modelo

Presentación del conjunto de datos sobre Salarios en Ciencia de Datos

 experience_level  employment_type  remote_ratio  company_size  salary_in_usd  
        0                0               0.5             1            0.036 
        1                0               1.0             2            0.133     
        2                0               0.0             1            0.234  
        1                0               1.0             0            0.076  
        2                0               1.0             1            0.170

()

Características: categórico, objetivo: salario (USD)
Resultado final: capa lineal
Pérdida: específica por regresión

Pérdida del error cuadrático medio

La pérdida MSE es la media de la diferencia al cuadrado entre las predicciones y la verdad sobre el terreno

def mean_squared_loss(prediction, target):
  return np.mean((prediction - target)**2)

en PyTorch:

criterion = nn.MSELoss()
# Prediction and target are float tensors
loss = criterion(prediction, target)

Antes del bucle de entrenamiento

# Create the dataset and the dataloader
dataset = TensorDataset(torch.tensor(features).float(),
                        torch.tensor(target).float())


dataloader = DataLoader(dataset, batch_size=4, shuffle=True)


# Create the model
model = nn.Sequential(nn.Linear(4, 2), 
                      nn.Linear(2, 1))


# Create the loss and optimizer
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.001)

El bucle de entrenamiento

for epoch in range(num_epochs):

    for data in dataloader:

        # Set the gradients to zero
        optimizer.zero_grad()

        # Get feature and target from the data loader
        feature, target = data

        # Run a forward pass
        pred = model(feature)
        # Compute loss and gradients
        loss = criterion(pred, target)
        loss.backward()

        # Update the parameters
        optimizer.step()

¡Vamos a practicar!

Introducción al aprendizaje profundo con PyTorch