One-hot gecodeerde labels maken

One-hot encoding zet één geheelgetal-label om in een vector met N elementen, waarbij N het aantal klassen is. Deze vector bevat nullen en een één op de juiste positie.

In deze oefening maak je eerst handmatig een one-hot gecodeerde vector voor y en gebruik je daarna PyTorch om het proces te vereenvoudigen. Je gegevensset heeft drie klassen (0, 1, 2).

numpy (np), torch.nn.functional (F) en torch zijn al voor je geïmporteerd.

Deze oefening maakt deel uit van de cursus

Introductie tot Deep Learning met PyTorch

Cursus bekijken

Oefeninstructies

Voer handmatig one-hot encoding uit op het ground-truthlabel y met behulp van de gegeven NumPy-array en sla het op als one_hot_numpy.
Gebruik PyTorch om y one-hot te encoden en sla het op als one_hot_pytorch.

Praktische interactieve oefening

Probeer deze oefening eens door deze voorbeeldcode in te vullen.

y = 1
num_classes = 3

# Create the one-hot encoded vector using NumPy
one_hot_numpy = np.array([____, ____, ____])

# Create the one-hot encoded vector using PyTorch
one_hot_pytorch = F.____(torch.tensor(y), num_classes=____)

print("One-hot vector using NumPy:", one_hot_numpy)
print("One-hot vector using PyTorch:", one_hot_pytorch)

Code bewerken en uitvoeren

Deze oefening maakt deel uit van de cursus

Introductie tot Deep Learning met PyTorch

SkillTag.level.intermediateSkillTag.label

4.8+

Begin de cursus gratis

Self-driving cars, smartphones, search engines... Deep learning is now everywhere. Before you begin building complex models, you will become familiar with PyTorch, a deep learning framework. You will learn how to manipulate tensors, create PyTorch data structures, and build your first neural network in PyTorch with linear layers.

Exercise 1: Introduction to deep learning with PyTorch Exercise 2: Getting started with PyTorch tensors Exercise 3: Checking and adding tensors Exercise 4: Neural networks and layers Exercise 5: Linear layer network Exercise 6: Understanding weights Exercise 7: Hidden layers and parameters Exercise 8: Your first neural network Exercise 9: Stacking linear layers Exercise 10: Counting the number of parameters

To train a neural network in PyTorch, you will first need to understand additional components, such as activation and loss functions. You will then realize that training a network requires minimizing that loss function, which is done by calculating gradients. You will learn how to use these gradients to update your model's parameters.

Exercise 1: Ontdekken van activatiefuncties Exercise 2: Activeer je begrip!Exercise 3: De sigmoid- en softmax-functies Exercise 4: Een forward pass uitvoeren Exercise 5: Een binaire classifier bouwen in PyTorch Exercise 6: Van regressie naar multi-class-classificatie Exercise 7: Met verliesfuncties de voorspellingen van je model beoordelen Exercise 8: One-hot gecodeerde labels maken

Huidige oefening

Exercise 9: Cross-entropy loss berekenen Exercise 10: Afgeleiden gebruiken om modelparameters bij te werken Exercise 11: De modelparameters benaderen Exercise 12: De gewichten handmatig bijwerken Exercise 13: De PyTorch-optimizer gebruiken

Now that you've learned the key components of a neural network, you'll train one using a training loop. You'll explore potential issues like vanishing gradients and learn strategies to address them, such as alternative activation functions and tuning learning rate and momentum.

Exercise 1: A deeper dive into loading data Exercise 2: Using TensorDataset Exercise 3: Using DataLoader Exercise 4: Writing our first training loop Exercise 5: Using the MSELoss Exercise 6: Writing a training loop Exercise 7: ReLU activation functions Exercise 8: Implementing ReLU Exercise 9: Implementing leaky ReLU Exercise 10: Understanding activation functions Exercise 11: Learning rate and momentum Exercise 12: Experimenting with learning rate Exercise 13: Experimenting with momentum

Training a deep learning model is an art, and to make sure our model is trained correctly, we need to keep track of certain metrics during training, such as the loss or the accuracy. We will learn how to calculate such metrics and how to reduce overfitting.

Exercise 1: Layer initialization and transfer learning Exercise 2: Fine-tuning process Exercise 3: Freeze layers of a model Exercise 4: Layer initialization Exercise 5: Evaluating model performance Exercise 6: Writing the evaluation loop Exercise 7: Calculating accuracy using torchmetrics Exercise 8: Fighting overfitting Exercise 9: Experimenting with dropout Exercise 10: Understanding overfitting Exercise 11: Improving model performance Exercise 12: Implementing random search Exercise 13: Wrap-up video