Add files via upload

contrib/machine-learning/PyTorch_Fundamentals.md

@@ -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.