Escrevendo o primeiro loop de treinamento

Introdução a Deep Learning com PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Treinar uma rede neural

Crie um modelo
Escolha uma função de perda
Defina um conjunto de dados
Defina um otimizador
Execute um loop de treinamento:
- Calcule a perda (passagem direta)
- Calcule gradientes (retropropagação)
- Atualizar parâmetros do modelo

O conjunto de dados Data Science Salary

 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

Atributos: categóricos, alvo: salário (USD)
Saída final: camada linear
Perda: específica da regressão

Perda de erro quadrático médio

A perda de MSE é a média da diferença ao quadrado entre as previsões e a verdade base

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

in PyTorch:

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

Antes do loop de treinamento

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

O loop de treinamento

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 praticar!

Introdução a Deep Learning com PyTorch