Die erste Trainingsschleife schreiben

Einführung in Deep Learning mit PyTorch

Jasmin Ludolf

Senior Data Science Content Developer, DataCamp

Ein neuronales Netzwerk trainieren

Modell erstellen
Verlustfunktion auswählen
Datensatz definieren
Optimierer festlegen
Trainingsschleife durchlaufen:
- Verlust berechnen (Vorwärtsdurchlauf)
- Gradienten berechnen (Backpropagation)
- Modellparameter aktualisieren

Einführung in den Datensatz Gehälter von Mitarbeitenden der Datenwissenschaft

 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

Merkmale: kategorisch, Ziel: Gehalt (USD)
Finale Ausgabe: lineare Schicht
Verlust: regressionsspezifisch

Verlust der mittleren quadratischen Abweichung

Der MSE-Verlust ist der Mittelwert der quadratischen Differenz zwischen Vorhersagen und Ground Truth

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)

Vor der Trainingsschleife

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

Die Trainingsschleife

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

Lass uns üben!

Einführung in Deep Learning mit PyTorch