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 `backward` method is usually applied to a variable representing the _____.

The <code>backward</code> method is usually applied to a variable representing the _____.

Check all that apply. Which operations are always valid? That is, do not throw an error? 

Check all that apply. Which operations are always valid? That is, do not throw an error?

If `b` and `w` are trainable parameters and `x` is a feature vector, which computation graph best represents the operation `yhat = b + w * x`?

If <code>b</code> and <code>w</code> are trainable parameters and <code>x</code> is a feature vector, which computation graph best represents the operation <code>yhat = b + w * x</code>?

Check all that apply. The optimizer can be used for:

Check all that apply. The optimizer can be used for:

True, the SGD optimizer can only be used with stochastic gradient descent.

False, the SGD optimizer can be used with any type of gradient descent: batch, mini-batch, or stochastic.

The SGD optimizer CANNOT be used to train a model using batch gradient descent.

The SGD optimizer CANNOT be used to train a model using batch gradient descent.

We can compute the Mean Squared Error loss using the labels and predictions below and by using `nn.MSELoss(yhat, y)`:

```python
y = torch.tensor([1., 2. ,3.])
yhat = torch.tensor([1., 3. ,5.])
```

We can compute the Mean Squared Error loss using the labels and predictions below and by using <code>nn.MSELoss(yhat, y)</code>:
<pre><code class="language-python">y = torch.tensor([1., 2. ,3.])
yhat = torch.tensor([1., 3. ,5.])
</code></pre>

Which method is used by the optimizer to update the parameters?

Which method is used by the optimizer to update the parameters?

```python
b -= lr * b.grad                             
w -= lr * w.grad                             
```

```python
b = b - lr * b.grad                          
w = w - lr * w.grad                                 
```

```python
b -= lr * b.step                             
w -= lr * w.step
```

```python
with torch.no_grad():                          
    b -= lr * b.grad                           
    w -= lr * w.grad     
```

From the following choices given, which approach is recommended for updating the parameters?

From the following choices given, which approach is recommended for updating the parameters?

| **Box** | **Component**|
|--- |---|
| `a` | Blue |
| `c` | Gray |
| `d` | Blue |

| **Box** | **Component**|
|--- |---|
| `w1` | Blue |
| `b` | Gray |
| `d` | Green |

| **Box** | **Component**|
|--- |---|
| `w1` | Gray |
| `b` | Gray |
| `d` | Green |

| **Box** | **Component**|
|--- |---|
| `w1` | Green |
| `b` | Blue |
| `d` | Gray |

You have been provided with the following code, which generates a dynamic computation graph:

```python
a = torch.randn((3,3), requires_grad = True)
w1 = torch.randn((3,3), requires_grad = True)
w2 = torch.randn((3,3), requires_grad = True)

b = w1 * a 
c = w2 * a
d = b + c

make_dot(d)
```

Looking at the code above and the concepts you have studied, select the correct option where all components lie in their appropriate boxes.

You have been provided with the following code, which generates a dynamic computation graph:
<pre><code class="language-python">a = torch.randn((3,3), requires_grad = True)
w1 = torch.randn((3,3), requires_grad = True)
w2 = torch.randn((3,3), requires_grad = True)

b = w1 * a 
c = w2 * a
d = b + c

make_dot(d)
</code></pre>
Looking at the code above and the concepts you have studied, select the correct option where all components lie in their appropriate boxes.

We can use the `zero_` method of an optimizer to zero the gradients.

Accumulating gradients is a serious problem since we only need the gradients corresponding to the current loss to perform the parameter update.

By setting the reduction method to be `sum` (`nn.MSELoss(reduction='sum')`), we take the average of all the errors of individual points. 

The following tensors fall in the category of being handled by the `backward()` method:

|`b` | `yhat` | `x_train_tensor ` |

Check all that apply. Which of the following statements are correct? 

Check all that apply. Which of the following statements are correct?

Test your understanding of the concepts explained in this chapter with this quiz!

Introduction

Visualizing Gradient Descent

A Simple Regression Problem

Rethinking the Training Loop

Going Classy

A Simple Classification Problem

Conclusion

Appendix

Quiz