Delve into PyTorch basics: autograd, model classes, datasets, and data loaders. Gain insights into model development while avoiding common pitfalls. Start creating and training your own PyTorch models.

Deep learning with Pytorch, A beginner's Guide By Daniel Godoy.png

jupyter_final.tar.gz

codesnip1

tensorboard

jupyterp-autograd

jupyterp-computation

jupyterp-rethinking

jupyterp-minibatch

jupyterp-dataloader

jupyterp-evaluation

jupyterp-saveload

jupyterp-predictions

jupyterp-training-predictions

jupyterp-checkpointing

jupyterp-classy

jupyterp-classification

jupyterp-retest

jupyterp-retest-copy

jupyterp-retest-copy-copy

jupyterp-retest-copy-copy-copy

jupyterp-retest-copy-copy-copy-copy

jupyterp-retest-question

jupyterp-retest-question-copy

jupyterp-retest-question-copy-copy

jupyterp-retest-question-copy-copy-copy

jupyterp-retest-question-copy-copy-copy-copy

jupyterp-retest-challenge

jupyterp-retest-challenge-copy

jupyterp-retest-challenge-copy-copy

jupyterp-retest-challenge-copy-copy-copy

jupyterp-retest-challenge-copy-copy-copy-copy

jupyterp-putting1

jupyterp-putting2

jupyterp-putting3

jupyterp-putting4

jupyterp-tensorboard

jupyterp-tensorboard-graphs

jupyterp-tensorboard-scalers

jupyterp-tensorboard-training

GUI-Tensorboard

GUI-Tensorboard-graphs

GUI-Tensorboard-scalers

GUI-Tensorboard-training

GUI-Chapter04

GUI-No-Jupyter-Tensorboard

This course is designed to provide you with an easy-to-follow, structured, incremental, and from-first-principles approach to learning PyTorch. In this course, you’ll be introduced to the fundamentals of PyTorch: autograd, model classes, datasets, data loaders, and more. You will develop, step-by-step, not only the models themselves but also your understanding of them. You'll be shown both the reasoning behind the code and how to avoid some common pitfalls and errors along the way. By the time you finish this course, you’ll have a thorough understanding of the concepts and tools necessary to start developing and training your own models using PyTorch.

Deep Learning with PyTorch Step-by-Step: Part I - Fundamentals

## Updating parameters

In the final step, we use the gradients to update the parameters. Since we are trying to minimize our losses, we reverse the sign of the gradient for the update.

There is still another hyperparameter to consider: the **learning rate**, denoted by the Greek letter eta (that looks like the letter `n`). This presents the **multiplicative factor** that we need to apply to the gradient for the parameter update. Our equation now becomes the following:

<div style="font-size: 1.7em;r">
<center>

$b = b - \eta{\frac{\partial MSE}{\partial b}}$

$\space\space w = w - \eta{\frac{\partial MSE}{\partial w}}$

</center>
</div>

We can also interpret this a bit differently; each parameter is going to have its value updated by a constant value, eta (the learning rate). But this constant is going to be weighted by how much that parameter contributes to minimizing the loss (its gradient).

Honestly, I believe that this way of thinking about the parameter update makes more sense. First, you decide on a learning rate that specifies your **step size**, while the gradients tell you the relative impact (on the loss) of taking a step for each parameter. Then you take a given number of steps that is proportional to that relative impact; more impact, more steps.

# Updating parameters

In the final step, we use the gradients to update the parameters. Since we are trying to minimize our losses, we reverse the sign of the gradient for the update.

There is still another hyperparameter to consider: the **learning rate**, denoted by the Greek letter eta (that looks like the letter `n`). This presents the **multiplicative factor** that we need to apply to the gradient for the parameter update. Our equation now becomes the following:

<div style="font-size: 1.7em;r">
<center>

$b = b - \eta{\frac{\partial MSE}{\partial b}}$

$\space\space w = w - \eta{\frac{\partial MSE}{\partial w}}$

</center>
</div>

We can also interpret this a bit differently; each parameter is going to have its value updated by a constant value, eta (the learning rate). But this constant is going to be weighted by how much that parameter contributes to minimizing the loss (its gradient).

Honestly, I believe that this way of thinking about the parameter update makes more sense. First, you decide on a learning rate that specifies your **step size**, while the gradients tell you the relative impact (on the loss) of taking a step for each parameter. Then you take a given number of steps that is proportional to that relative impact; more impact, more steps.

# Updating parameters

In the final step, we use the gradients to update the parameters. Since we are trying to minimize our losses, we reverse the sign of the gradient for the update.

There is still another hyperparameter to consider: the **learning rate**, denoted by the Greek letter eta (that looks like the letter `n`). This presents the **multiplicative factor** that we need to apply to the gradient for the parameter update. Our equation now becomes the following:

<div>
<center>

$b = b - \eta{\frac{\partial MSE}{\partial b}}$

$\space\space w = w - \eta{\frac{\partial MSE}{\partial w}}$

</center>
</div>

We can also interpret this a bit differently; each parameter is going to have its value updated by a constant value, eta (the learning rate). But this constant is going to be weighted by how much that parameter contributes to minimizing the loss (its gradient).

Honestly, I believe that this way of thinking about the parameter update makes more sense. First, you decide on a learning rate that specifies your **step size**, while the gradients tell you the relative impact (on the loss) of taking a step for each parameter. Then you take a given number of steps that is proportional to that relative impact; more impact, more steps.

Learn about how you can use the gradients and the learning rate to update the parameters.

Step 4 - Update the Parameters

Introduction

Visualizing Gradient Descent

A Simple Regression Problem

Rethinking the Training Loop

Going Classy

A Simple Classification Problem

Conclusion

Appendix

Step 4 - Update the Parameters

Updating parameters