Onze eerste trainingslus schrijven

Introductie tot Deep Learning met PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Een neuraal netwerk trainen

Maak een model
Kies een verliesfunctie
Definieer een dataset
Stel een optimizer in
Voer een trainingslus uit:
- Bereken verlies (forward pass)
- Bereken gradiënten (backpropagation)
- Werk modelparameters bij

Kennismaking met de Data Science Salary-dataset

 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

Features: categorisch, target: salaris (USD)
Eindoutput: lineaire laag
Verlies: regressiespecifiek

Mean Squared Error (MSE)-verlies

MSE-verlies is het gemiddelde van het kwadraat van het verschil tussen voorspellingen en grondwaarheid

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)

Voor de trainingslus

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

De trainingslus

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

Laten we oefenen!

Introductie tot Deep Learning met PyTorch