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

# Introduction to loss functions

We will now tackle the **loss computation** process. As expected, PyTorch got us covered once again. There are many [loss functions](https://bit.ly/2ZTRZTo) to choose from depending on the task at hand. Since ours is a regression, we are using the Mean Squared Error (MSE) as our loss, and thus we need PyTorch's [`nn.MSELoss`](https://bit.ly/3hNYn4R):

import torch.nn as nn

# Defines a MSE loss function
loss_fn = nn.MSELoss(reduction='mean')
print(loss_fn)

Notice that `nn.MSELoss` is not the loss function itself. We do not pass predictions and labels to it! Instead, as you can see, it returns another function, which we called `loss_fn`. That is the actual loss function. So, we can pass a prediction and a label to it, and get the corresponding loss value:

import torch
import torch.nn as nn

# Defines a MSE loss function
loss_fn = nn.MSELoss(reduction='mean')

# This is a random example to illustrate the loss function
predictions = torch.tensor([0.5, 1.0])
labels = torch.tensor([2.0, 1.3])
print(loss_fn(predictions, labels))

> Moreover, you can also specify a **reduction method** to be applied. How do you want to aggregate the errors for individual points? You can average them (`reduction="mean"`) or simply sum them up (`reduction="sum"`). In our example, we use the typical `mean` reduction to compute MSE. If we had used `sum` as reduction, we would actually be computing SSE (Sum of Squared Errors).

> Technically speaking, `nn.MSELoss` is a **higher-order function**.
<br/><br/>
> If you're not familiar with the concept, it will be explained briefly in the chapter, **Rethinking the Training Loop**.

Learn about how loss can be computed using loss functions and how the loss tensor can be converted to a Numpy array.

Loss

Introduction

Visualizing Gradient Descent

A Simple Regression Problem

Rethinking the Training Loop

Going Classy

A Simple Classification Problem

Conclusion

Appendix

Loss

Introduction to loss functions