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

We have covered a lot of ground in this chapter:

* Writing a higher-order function that builds functions to perform training steps.

* Understanding PyTorch's `Dataset` and `TensorDataset` classes, implementing its `__init__`, `__get_item__`, and `__len__` methods.
* Using PyTorch's `DataLoader` class to generate mini-batches out of a dataset.

* Modifying our training loop to incorporate mini-batch gradient descent logic.
* Writing a helper function to handle the mini-batch inner loop.
* Using PyTorch's `random_split` method to generate training and validation datasets.
* Writing a higher-order function that builds functions to perform validation steps.
* Realizing the importance of including `model.eval()` inside the validation loop.
* Remembering the purpose of `no_grad()` and using it to prevent any kind of gradient computation during validation.
* Using `SummaryWriter` to interface with TensorBoard for logging.
* Adding a graph representing our model to TensorBoard.
* Sending scalars to TensorBoard to track the evolution of training and validation losses.

* Saving/checkpointing and loading models to and from disk to allow resuming model training or deployment.
* Realizing the importance of setting the mode of the model for checkpointing or deploying for prediction, respectively: `train()` or `eval()`.

Congratulations! You now possess the necessary knowledge and tools to tackle more interesting problems using PyTorch. We will put them to good use in the next chapters.

# Jupyter notebook

To understand the concepts tested in this chapter, you have been provided with the following Jupyter notebook, which contains the entire code that has been discussed in this chapter. You can run the complete code to see the results for yourself and play around and experiment with it. 

A quick overview of what you have learned, and test it on the provided notebook. 

Recap

Introduction

Visualizing Gradient Descent

A Simple Regression Problem

Rethinking the Training Loop

Going Classy

A Simple Classification Problem

Conclusion

Appendix

Recap

General overview