Merge pull request #14 from Programmer-RD-AI/25/06/2023

25/06/2023

Author: Programmer-RD-AI

.ipynb_checkpoints/01-checkpoint.ipynb

@@ -0,0 +1,33 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09e4eaf8-3998-4393-abea-1afcc82a954d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/02-checkpoint.ipynb

@@ -29,7 +29,7 @@
 # Create data
 
 start = 0.0
-end = 5.0
+end = 1.0
 step = 0.02
 X = torch.arange(start, end ,step).unsqueeze(dim=1).to('cuda')
 y = (weight * X + bias).to('cuda')
@@ -119,6 +119,9 @@ def forward(self,X):
 from tqdm import tqdm
 # the model gets to see the data once
 epochs = 100
+epoch_count = []
+loss_values = []
+test_loss_values = []
 
 
 for epoch in tqdm(range(epochs)):
@@ -140,7 +143,20 @@ def forward(self,X):
     # Gradient Descent
     optimizer.step()
 
-    model_0.eval() # turns off gradient tracking
+    model_0.eval() # turns off  stf like dropout and batchnormalisation
+    
+    with torch.inference_mode(): # turns off gradient tracking 
+        # 1. Do the forward pass
+        test_pred = model_0(X_test)
+        
+        # Calculate the loss
+        test_loss = loss_fn(test_pred,y_test)
+    
+    if epoch % 10 == 0:
+        epoch_count.append(epoch)
+        loss_values.append(loss.cpu().detach())
+        test_loss_values.append(test_loss.cpu().detach())
+        print(f"Epoch: {epoch} | Test : {test_loss} | Loss : {loss}")
 
 
 y_preds[:5],y_train[:5]
@@ -152,4 +168,32 @@ def forward(self,X):
 plot_predictions(predictions=y_preds.cpu())
 
 
+model_0.state_dict()
+
+
+weight,bias
+
+
+# Plot the loss curves
+plt.plot(epoch_count,loss_values,label='Train Loss')
+plt.plot(epoch_count,test_loss_values,label='Test Loss')
+plt.title("Loss Curves")
+plt.ylabel("Loss")
+plt.xlabel("Epochs")
+plt.legend()
+
+
+# Saving out PyTorch model
+torch.save(model.state_dict(),'./models/01/00.pth')
+
+
+state_dict_00 = torch.load("./models/01/00.pth")
+
+
+model_01 = LinearRegressionModel()
+
+
+model_01.load_state_dict(state_dict_00)
+
+
 

.ipynb_checkpoints/Redo_01-checkpoint.ipynb

@@ -0,0 +1 @@
+

.virtual_documents/01.ipynb.py

@@ -0,0 +1,111 @@
+import torch
+from torch import nn
+from torch import optim
+import matplotlib.pyplot as plt
+import pandas as pd 
+import numpy as np
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+
+torch.__version__
+
+
+# y = mx+c
+m = 0.69
+c = 0.96
+X = torch.arange(0,1,0.002).to(device)
+y = torch.tensor(m*X+c).to(device)
+
+
+from sklearn.model_selection import train_test_split
+
+
+X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25)
+
+
+class LinearRegressionModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.m = nn.Parameter(torch.randn(1))
+        self.c = nn.Parameter(torch.randn(1))
+    
+    def forward(self,X):
+        return X*self.m+self.c
+
+
+model_0 = LinearRegressionModel().to(device)
+criterion = nn.L1Loss()
+optimizer = optim.Adam(model_0.parameters(),lr=0.01)
+
+
+epochs = 100
+
+
+m_iter = []
+c_iter = []
+train_loss_iter = []
+test_loss_iter = []
+
+
+for epoch in range(epochs):
+    # train
+    model_0.train()    
+    y_preds = model_0(X_train)
+    loss = criterion(y_preds,y_train)
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    # test
+    model_0.eval()
+    with torch.inference_mode():
+        y_test_preds = model_0(X_test)
+        test_loss = criterion(y_test_preds,y_test)
+    paramters = dict(model_0.state_dict())
+    m_iter.append(paramters['m'].cpu())
+    c_iter.append(paramters['c'].cpu())
+    train_loss_iter.append(loss.cpu().detach().numpy())
+    test_loss_iter.append(test_loss.cpu().detach().numpy())
+
+
+model_0.state_dict()
+
+
+plt.plot(range(epochs),m_iter)
+plt.xlabel('epochs')
+plt.ylabel('m_iter')
+plt.title("M_iter over time")
+plt.show()
+
+
+plt.plot(range(epochs),c_iter)
+plt.xlabel('epochs')
+plt.ylabel('c_iter')
+plt.title("c_iter over time")
+plt.show()
+
+
+plt.plot(range(epochs),test_loss_iter,'b')
+plt.plot(range(epochs),train_loss_iter,'r')
+plt.xlabel('epochs')
+plt.ylabel('loss')
+plt.title("Losss over time")
+plt.legend()
+plt.show()
+
+
+y_preds[5:7],y_train[5:7]
+
+
+state_dict = model_0.state_dict()
+
+
+torch.save(state_dict,'./models/01/redo_model_00.pth')
+
+
+model_01 = LinearRegressionModel()
+
+
+model_01.load_state_dict(torch.load('./models/01/redo_model_00.pth'))
+
+
+

.virtual_documents/02.ipynb.py

@@ -0,0 +1 @@
+

.virtual_documents/Redo_01.ipynb.py

@@ -0,0 +1,33 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09e4eaf8-3998-4393-abea-1afcc82a954d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}