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

# The inner loop

From now on, it is very unlikely that you will ever use a (full) batch gradient descent again, both in this course or in real life. So once again, it makes sense to organize a piece of code that is going to be used repeatedly into its own function: the **mini-batch inner loop**!

The inner loop depends on three elements:

* The **device** where data is being sent to.

* A **data loader** to draw mini-batches from.
* A **step function**, returning the corresponding loss.

Taking these elements as inputs and using them to perform the inner loop, we will end up with a function like this:

def mini_batch(device, data_loader, step):
    mini_batch_losses = []
    for x_batch, y_batch in data_loader:
        x_batch = x_batch.to(device)
        y_batch = y_batch.to(device)

        mini_batch_loss = step(x_batch, y_batch)
        mini_batch_losses.append(mini_batch_loss)

    loss = np.mean(mini_batch_losses)
    return loss

In the last lesson, we realized that we were executing five times more updates (the `train_step` function) per epoch due to the mini-batch inner loop. Before, 1,000 epochs meant 1,000 updates. Now, we only need 200 epochs to perform the same 1,000 updates.

How does our training loop look like now? It has become very lean!

Learn about how you can implement the inner loop of mini-batch, add it into your training loop, and get a glimpse at using "random_split". 

Mini-Batch Inner Loop and Training Split

Learn about how you can implement the inner loop of mini-batch, add it into your training loop, and get a glimpse at using "random_split".

Introduction

Visualizing Gradient Descent

A Simple Regression Problem

Rethinking the Training Loop

Going Classy

A Simple Classification Problem

Conclusion

Appendix

Mini-Batch Inner Loop and Training Split