Learn and practice PyTorch, a framework for developing deep learning models.

Become a Deep Learning Professional

In this module, we’ll be introduced to the fundamentals of PyTorch: autograd, model classes, datasets, data loaders, and more. We’ll develop models and understand them step-by-step. We'll understand the reasoning behind the code and how to avoid some common pitfalls and errors along the way.
By the time we finish this module, we’ll have a thorough understanding of the concepts and tools necessary to start developing and training our own models using PyTorch.

Deep Learning with PyTorch

Check all that apply. Tensors, by definition, may have __ dimensions.


Check all that apply. Tensors, by definition, may have __ dimensions.

After executing the code below, which option reflects the state of variable `x`?

```python
x = torch.ones((2,2))
y = x.view(-1,)
y[-1] = 0
```

After executing the code below, which option reflects the state of variable <code>x</code>?
<pre><code class="language-python">x = torch.ones((2,2))
y = x.view(-1,)
y[-1] = 0
</code></pre>

The statement below is a typical way of determining the device to be used.

```python
device = 'cuda' if torch.cuda.is_available() else 'cpu'
```

The statement below is a typical way of determining the device to be used.
<pre><code class="language-python">device = 'cuda' if torch.cuda.is_available() else 'cpu'
</code></pre>

`torch.randn(1, requires_grad=True, device='cpu')`

`torch.randn(1, requires_grad=False, device='cuda')`

`torch.ones(2, 3, requires_grad=True, device='cpu')`

Check all that apply. Which tensors may be used as trainable parameters? 

Check all that apply. Which tensors may be used as trainable parameters?

`torch.randn(1, requires_grad=True).to('cuda')`

`torch.randn(1, requires_grad=True, device='cuda')`

Which one is the recommended way of creating a GPU tensor for a parameter?

Which one is the recommended way of creating a GPU tensor for a parameter?

```python
x = torch.randn(1, device='cuda')
x.numpy()
```

```python
x = torch.randn(1, device='cuda')
x.cpu().numpy()
```

```python
x = torch.randn(1, device='cpu')
x.cpu().numpy()
```

```python
x = torch.randn(1, device='cpu')
x.numpy()
```

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

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

What would be the output of the following code?

```python
import torch

tensor = torch.tensor([
    [1, 2, 3],
    [1, 2, 3],
    [1, 2, 3]
])

print(tensor.size())
```

What would be the output of the following code?
<pre><code class="language-python">import torch

tensor = torch.tensor([
 [1, 2, 3],
 [1, 2, 3],
 [1, 2, 3]
])

print(tensor.size())
</code></pre>

```python
tensor([[1, 2, 3],
        [1, 2, 3],
        [1, 2, 3]])
```

```python
tensor([[1, 2, 3],
        [0, 1, 2],
        [1, 5, 3]])
```

```python
tensor([[1, 2, 3],
        [0, 1, 2],
        [5, 5, 5]])
```

```python
ValueError: setting an array element with a sequence.
```

What would be the output of the following code?

```python
import numpy as np
import torch

dummy_array = np.array([
    [1, 2, 3],
    [1, 2, 3],
    [1, 2, 3]
])
dummy_tensor = torch.as_tensor(dummy_array)

dummy_array[1] = [0,1,2]
dummy_array[2] = [5]
print(dummy_tensor)
```

What would be the output of the following code?
<pre><code class="language-python">import numpy as np
import torch

dummy_array = np.array([
 [1, 2, 3],
 [1, 2, 3],
 [1, 2, 3]
])
dummy_tensor = torch.as_tensor(dummy_array)

dummy_array[1] = [0,1,2]
dummy_array[2] = [5]
print(dummy_tensor)
</code></pre>

Only creates CPU tensors, which will not work if you have a GPU.

The approach is fine, and we end up with gradient-requiring GPU tensors for our parameters: `b` and `w`.

The gradients get lost when working with this approach.

This approach creates nontrainable parameters: `b` and `w`.

Why is the following approach not recommended for creating parameters in PyTorch:

```python
import torch

device = 'cuda' if torch.cuda.is_available() else 'cpu'
torch.manual_seed(42)
b = torch.randn(1, requires_grad=True, dtype=torch.float).to(device)
w = torch.randn(1, requires_grad=True, dtype=torch.float).to(device)
```

Why is the following approach not recommended for creating parameters in PyTorch:
<pre><code class="language-python">import torch

device = 'cuda' if torch.cuda.is_available() else 'cpu'
torch.manual_seed(42)
b = torch.randn(1, requires_grad=True, dtype=torch.float).to(device)
w = torch.randn(1, requires_grad=True, dtype=torch.float).to(device)
</code></pre>

It is recommended to always assign tensors to a device at the moment of its creation.

When creating parameters, the outputs are different in both CPU and GPU because PyTorch generates different sequences of random numbers in different devices. 

The `view` method creates an entirely new tensor from the original, and if you modify it, the original tensor will not change. 

You can use the `numpy` method to turn a tensor into a GPU 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

Appendix

Conclusion

Quiz