kopia lustrzana https://github.com/animator/learn-python
Add files via upload
rodzic
ebaff124c1
commit
7c5e89c0ba
|
@ -0,0 +1,427 @@
|
|||
# PyTorch Fundamentals
|
||||
|
||||
|
||||
```python
|
||||
# Import pytorch in our codespace
|
||||
import torch
|
||||
print(torch.__version__)
|
||||
```
|
||||
|
||||
2.3.0+cu121
|
||||
|
||||
|
||||
2.3.0 is the pytorch version and 121 is the cuda version
|
||||
|
||||
Now you have already seen how to create a tensor in pytorch. In this notebook i am going to show you the operations which can be applied on a tensor with a quick previous revision.
|
||||
|
||||
### 1. Creating tensors
|
||||
|
||||
|
||||
```python
|
||||
# Scalar tensor ( a zero dimension tensor)
|
||||
scalar = torch.tensor(7)
|
||||
print(scalar)
|
||||
```
|
||||
|
||||
tensor(7)
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Check the dimension of the above tensor
|
||||
print(scalar.ndim)
|
||||
```
|
||||
|
||||
0
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# To retrieve the number from the tensor we use `item()`
|
||||
print(scalar.item())
|
||||
```
|
||||
|
||||
7
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Vector (It is a single dimension tensor but contain many numbers)
|
||||
vector = torch.tensor([1,2])
|
||||
print(vector)
|
||||
```
|
||||
|
||||
tensor([1, 2])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Check the dimensions
|
||||
print(vector.ndim)
|
||||
```
|
||||
|
||||
1
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Check the shape of the vector
|
||||
print(vector.shape)
|
||||
```
|
||||
|
||||
torch.Size([2])
|
||||
|
||||
|
||||
The above returns torch.Size([2]) which means our vector has a shape of [2]. This is because of the two elements we placed inside the square brackets ([1,2])
|
||||
|
||||
Note:
|
||||
I'll let you in on a trick.
|
||||
|
||||
You can tell the number of dimensions a tensor in PyTorch has by the number of square brackets on the outside ([) and you only need to count one side.
|
||||
|
||||
|
||||
```python
|
||||
# Let's create a matrix
|
||||
MATRIX = torch.tensor([[1,2],
|
||||
[4,5]])
|
||||
print(MATRIX)
|
||||
```
|
||||
|
||||
tensor([[1, 2],
|
||||
[4, 5]])
|
||||
|
||||
|
||||
There are two brackets so it must be 2 dimensions , lets check
|
||||
|
||||
|
||||
```python
|
||||
print(MATRIX.ndim)
|
||||
```
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Shape
|
||||
print(MATRIX.shape)
|
||||
```
|
||||
|
||||
torch.Size([2, 2])
|
||||
|
||||
|
||||
It means MATRIX has 2 rows and 2 columns.
|
||||
|
||||
|
||||
```python
|
||||
# Let's create a TENSOR
|
||||
TENSOR = torch.tensor([[[1,2,3],
|
||||
[4,5,6],
|
||||
[7,8,9]]])
|
||||
print(TENSOR)
|
||||
```
|
||||
|
||||
tensor([[[1, 2, 3],
|
||||
[4, 5, 6],
|
||||
[7, 8, 9]]])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Let's check the dimensions
|
||||
print(TENSOR.ndim)
|
||||
```
|
||||
|
||||
3
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# shape?
|
||||
print(TENSOR.shape)
|
||||
```
|
||||
|
||||
torch.Size([1, 3, 3])
|
||||
|
||||
|
||||
The dimensions go outer to inner.
|
||||
|
||||
That means there's 1 dimension of 3 by 3.
|
||||
|
||||
##### Let's summarise
|
||||
|
||||
* scalar -> a single number having 0 dimension.
|
||||
* vector -> have many numbers but having 1 dimension.
|
||||
* matrix -> a array of numbers having 2 dimensions.
|
||||
* tensor -> a array of numbers having n dimensions.
|
||||
|
||||
### Random Tensors
|
||||
|
||||
We can create them using `torch.rand()` and passing in the `size` parameter.
|
||||
|
||||
|
||||
```python
|
||||
# creating a random tensor of size (3,4)
|
||||
rand_tensor = torch.rand(size = (3,4))
|
||||
print(rand_tensor)
|
||||
```
|
||||
|
||||
tensor([[0.7462, 0.4950, 0.7851, 0.8277],
|
||||
[0.6112, 0.5159, 0.1728, 0.6847],
|
||||
[0.4472, 0.1612, 0.6481, 0.3236]])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Check the dimensions
|
||||
print(rand_tensor.ndim)
|
||||
```
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Shape
|
||||
print(rand_tensor.shape)
|
||||
```
|
||||
|
||||
torch.Size([3, 4])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# datatype
|
||||
print(rand_tensor.dtype)
|
||||
```
|
||||
|
||||
torch.float32
|
||||
|
||||
|
||||
### Zeros and ones
|
||||
|
||||
Here we will create a tensor of any shape filled with zeros and ones
|
||||
|
||||
|
||||
```python
|
||||
# Create a tensor of all zeros
|
||||
zeros = torch.zeros(size = (3,4))
|
||||
print(zeros)
|
||||
```
|
||||
|
||||
tensor([[0., 0., 0., 0.],
|
||||
[0., 0., 0., 0.],
|
||||
[0., 0., 0., 0.]])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# create a tensor of ones
|
||||
ones = torch.ones(size = (3,4))
|
||||
print(ones)
|
||||
```
|
||||
|
||||
tensor([[1., 1., 1., 1.],
|
||||
[1., 1., 1., 1.],
|
||||
[1., 1., 1., 1.]])
|
||||
|
||||
|
||||
### Create a tensor having range of numbers
|
||||
|
||||
You can use `torch.arange(start, end, step)` to do so.
|
||||
|
||||
Where:
|
||||
|
||||
* start = start of range (e.g. 0)
|
||||
* end = end of range (e.g. 10)
|
||||
* step = how many steps in between each value (e.g. 1)
|
||||
|
||||
> Note: In Python, you can use range() to create a range. However in PyTorch, torch.range() is deprecated show error, show use `torch.arange()`
|
||||
|
||||
|
||||
```python
|
||||
zero_to_ten = torch.arange(start = 0,
|
||||
end = 10,
|
||||
step = 1)
|
||||
print(zero_to_ten)
|
||||
```
|
||||
|
||||
tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
|
||||
|
||||
|
||||
# 2. Manipulating tensors (tensor operations)
|
||||
|
||||
The operations are :
|
||||
|
||||
* Addition
|
||||
* Substraction
|
||||
* Multiplication (element-wise)
|
||||
* Division
|
||||
* Matrix multiplication
|
||||
|
||||
### 1. Addition
|
||||
|
||||
|
||||
```python
|
||||
tensor = torch.tensor([1,2,3])
|
||||
print(tensor+10)
|
||||
```
|
||||
|
||||
tensor([11, 12, 13])
|
||||
|
||||
|
||||
We have add 10 to each tensor element.
|
||||
|
||||
|
||||
```python
|
||||
tensor1 = torch.tensor([4,5,6])
|
||||
print(tensor+tensor1)
|
||||
```
|
||||
|
||||
tensor([5, 7, 9])
|
||||
|
||||
|
||||
We have added two tensors , remember that addition takes place element wise.
|
||||
|
||||
### 2. Subtraction
|
||||
|
||||
|
||||
```python
|
||||
print(tensor-8)
|
||||
```
|
||||
|
||||
tensor([-7, -6, -5])
|
||||
|
||||
|
||||
We've subtracted 8 from the above tensor.
|
||||
|
||||
|
||||
```python
|
||||
print(tensor-tensor1)
|
||||
```
|
||||
|
||||
tensor([-3, -3, -3])
|
||||
|
||||
|
||||
### 3. Multiplication
|
||||
|
||||
|
||||
```python
|
||||
# Multiply the tensor with 10 (element wise)
|
||||
print(tensor*10)
|
||||
```
|
||||
|
||||
tensor([10, 20, 30])
|
||||
|
||||
|
||||
Each element of tensor gets multiplied by 10.
|
||||
|
||||
Note:
|
||||
|
||||
PyTorch also has a bunch of built-in functions like `torch.mul()` (short for multiplication) and `torch.add()` to perform basic operations.
|
||||
|
||||
|
||||
```python
|
||||
# let's see them
|
||||
print(torch.add(tensor,10))
|
||||
```
|
||||
|
||||
tensor([11, 12, 13])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
print(torch.mul(tensor,10))
|
||||
```
|
||||
|
||||
tensor([10, 20, 30])
|
||||
|
||||
|
||||
### Matrix multiplication (is all you need)
|
||||
One of the most common operations in machine learning and deep learning algorithms (like neural networks) is matrix multiplication.
|
||||
|
||||
PyTorch implements matrix multiplication functionality in the `torch.matmul()` method.
|
||||
|
||||
The main two rules for matrix multiplication to remember are:
|
||||
|
||||
The inner dimensions must match:
|
||||
* (3, 2) @ (3, 2) won't work
|
||||
* (2, 3) @ (3, 2) will work
|
||||
* (3, 2) @ (2, 3) will work
|
||||
The resulting matrix has the shape of the outer dimensions:
|
||||
* (2, 3) @ (3, 2) -> (2, 2)
|
||||
* (3, 2) @ (2, 3) -> (3, 3)
|
||||
|
||||
|
||||
Note: "@" in Python is the symbol for matrix multiplication.
|
||||
|
||||
|
||||
```python
|
||||
# let's perform the matrix multiplication
|
||||
tensor1 = torch.tensor([[[1,2,3],
|
||||
[4,5,6],
|
||||
[7,8,9]]])
|
||||
tensor2 = torch.tensor([[[1,1,1],
|
||||
[2,2,2],
|
||||
[3,3,3]]])
|
||||
|
||||
print(tensor1) , print(tensor2)
|
||||
```
|
||||
|
||||
tensor([[[1, 2, 3],
|
||||
[4, 5, 6],
|
||||
[7, 8, 9]]])
|
||||
tensor([[[1, 1, 1],
|
||||
[2, 2, 2],
|
||||
[3, 3, 3]]])
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
(None, None)
|
||||
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# let's check the shape
|
||||
print(tensor1.shape) , print(tensor2.shape)
|
||||
```
|
||||
|
||||
torch.Size([1, 3, 3])
|
||||
torch.Size([1, 3, 3])
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
(None, None)
|
||||
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Matrix multiplication
|
||||
print(torch.matmul(tensor1, tensor2))
|
||||
```
|
||||
|
||||
tensor([[[14, 14, 14],
|
||||
[32, 32, 32],
|
||||
[50, 50, 50]]])
|
||||
|
||||
|
||||
|
||||
```python
|
||||
# Can also use the "@" symbol for matrix multiplication, though not recommended
|
||||
print(tensor1 @ tensor2)
|
||||
```
|
||||
|
||||
tensor([[[14, 14, 14],
|
||||
[32, 32, 32],
|
||||
[50, 50, 50]]])
|
||||
|
||||
|
||||
Note:
|
||||
|
||||
If shape is not perfect you can transpose the tensor and perform the matrix multiplication.
|
Ładowanie…
Reference in New Issue