rdm stf

Co-Authored-By: Ranuga <[email protected]>

Author: Programmer-RD-AI

.ipynb_checkpoints/03-checkpoint.ipynb

@@ -5,32 +5,82 @@
    "id": "bb5eee40-7a7b-4d5c-ab73-800776e96510",
    "metadata": {},
    "source": [
-    "# Crross Entropy Loss\n"
+    "# Crross Entropy Loss\n",
+    "\n",
+    "https://towardsdatascience.com/cross-entropy-loss-function-f38c4ec8643e"
    ]
   },
   {
    "cell_type": "markdown",
    "id": "49dd39b1-221c-40fa-a34c-a548b7acca8d",
    "metadata": {},
    "source": [
-    "# Dropout"
+    "# Dropout\n",
+    "\n",
+    "Dropout is used to make the model not over fit and it reduces the number of nodes used or essentially deactivates them\n",
+    "\n",
+    "By dropping a unit out, we mean temporarily removing it from the network, along with all its incoming and outgoing connections\n",
+    "\n",
+    "Dilution and dropout are regularization techniques for reducing overfitting in artificial neural networks by preventing complex co-adaptations on training data. They are an efficient way of performing model averaging with neural networks. Wikipedia\n",
+    "\n",
+    "https://jmlr.org/papers/volume15/srivastava14a/srivastava14a.pdf"
    ]
   },
   {
    "cell_type": "markdown",
    "id": "311e5114-dd67-4d9d-a837-f6d8a7a53e2c",
    "metadata": {},
    "source": [
-    "# Batch normalization"
+    "# Batch normalization\n",
+    "\n",
+    "Another way to prevent model overfitting\n",
+    "\n",
+    "Normalization is a data preprocessing too used\n",
+    "\n",
+    "When we normalise the model we can generalize its weights and biases\n",
+    "\n",
+    "The batch normalization is kind of a filter where it blends up all of the information\n",
+    "\n",
+    "https://arxiv.org/pdf/1502.03167.pdf"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "05e944ee-5b08-4ff8-9cfb-25fd73eed387",
    "metadata": {},
    "outputs": [],
    "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2ab2057f-a717-4a50-9245-d1c530ff4bf0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(tensor([-0.7186, -0.2342,  1.0638,  1.7499,  0.0266,  0.2970, -0.0000, -0.4345,\n",
+       "         -0.0000,  0.0000, -2.3886,  0.0000, -0.2310,  2.1409, -0.9096, -0.7719]),\n",
+       " tensor([-0.5749, -0.1873,  0.8511,  1.3999,  0.0213,  0.2376, -0.6571, -0.3476,\n",
+       "         -0.0300,  0.8420, -1.9109,  1.0163, -0.1848,  1.7127, -0.7276, -0.6175]))"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0cb61562-a5c7-445c-8218-4752a52d24c1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

.ipynb_checkpoints/Theory_02-checkpoint.ipynb

@@ -1 +1,118 @@
+import torch
+import torchvision
+from torch import nn, optim
+from torchvision import datasets,models,transforms
+from torch.utils.data import Dataset,DataLoader
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+
+torch.__version__,torchvision.__version__
+
+
+# Setup training data
+train_data = datasets.FashionMNIST(root="data/03/",train=True,download=True,transform=transforms.ToTensor())
+test_data = datasets.FashionMNIST(root="data/03/",train=False,download=True,transform=transforms.ToTensor())
+
+
+
+len(train_data),len(test_data)
+
+
+# See the first training example
+image,label = train_data[0]
+
+
+image.shape,label
+
+
+class_names = train_data.classes
+
+
+class_names
+
+
+class_to_idx = train_data.class_to_idx
+
+
+class_to_idx
+
+
+image.shape,label # C,H,W
+
+
+plt.imshow(image.view(28,28,1),cmap="gray")
+plt.title(class_names[label])
+plt.axis(False);
+
+
+# Plot more images
+# torch.manual_seed(42)
+fig = plt.figure(figsize=(9,9))
+row,cols = 4,4
+for i in range(1,row*cols+1):
+    random_idx = torch.randint(0,len(train_data),size=[1]).item()
+    img,label = train_data[random_idx]
+    fig.add_subplot(row,cols,i)
+    plt.imshow(img.view(28,28,1),cmap="gray")
+    plt.title(class_names[label])
+    plt.axis(False)
+
+
+BATCH_SIZE = 32
+
+train_dataloader = DataLoader(train_data,batch_size=BATCH_SIZE,shuffle=True)
+test_dataloader = DataLoader(test_data,batch_size=BATCH_SIZE,shuffle=True)
+
+
+train_features_batch,train_labels_batch = next(iter(train_dataloader))
+train_features_batch.shape,train_labels_batch.shape
+
+
+rdm_idx = torch.randint(0,len(train_features_batch),size = [1]).item()
+img,label = train_features_batch[rdm_idx],train_labels_batch[rdm_idx]
+plt.imshow(img.squeeze(),cmap="gray")
+plt.title(class_names[label])
+plt.axis(False)
+
+
+# Create a flatten layer
+flatten_model = nn.Flatten()
+x = train_features_batch[0]
+x.shape,flatten_model(x).shape
+
+
+from torch import nn
+class FashionMNISTModelV0(nn.Module):
+    def __init__(self,input_shape:int,hidden_units: int, output_shape:int) -> None:
+        super().__init__()
+        self.layer_stack = nn.Sequential(
+            nn.Flatten(), # No learning parameters
+            nn.Linear(in_features=input_shape,out_features=hidden_units),
+            nn.Linear(in_features=hidden_units,out_features=output_shape)
+        )
+    
+    def forward(self,X) -> torch.Tensor():
+        return self.layer_stack(X)
+
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+
+torch.manual_seed(42)
+
+# Setup model with input parameters
+
+model_0 = FashionMNISTModelV0(input_shape=28*28,hidden_units=2048,output_shape=len(class_names))
+
+
+optimizer = optim.Adam(model_0.parameters(),lr=0.01)
+criterion = nn.CrossEntropyLoss()
+
+
+dummy_X = torch.rand([1,1,28,28])
+model_0(dummy_X)
+
+
 

.virtual_documents/03.ipynb.py

@@ -1 +1,7 @@
 
+
+
+
+
+
+