dataset_and_dataloader.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import pandas as pd \n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>85</td>\n",
       "      <td>66</td>\n",
       "      <td>29</td>\n",
       "      <td>0</td>\n",
       "      <td>26.6</td>\n",
       "      <td>0.351</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>137</td>\n",
       "      <td>40</td>\n",
       "      <td>35</td>\n",
       "      <td>168</td>\n",
       "      <td>43.1</td>\n",
       "      <td>2.288</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>763</th>\n",
       "      <td>10</td>\n",
       "      <td>101</td>\n",
       "      <td>76</td>\n",
       "      <td>48</td>\n",
       "      <td>180</td>\n",
       "      <td>32.9</td>\n",
       "      <td>0.171</td>\n",
       "      <td>63</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>764</th>\n",
       "      <td>2</td>\n",
       "      <td>122</td>\n",
       "      <td>70</td>\n",
       "      <td>27</td>\n",
       "      <td>0</td>\n",
       "      <td>36.8</td>\n",
       "      <td>0.340</td>\n",
       "      <td>27</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>765</th>\n",
       "      <td>5</td>\n",
       "      <td>121</td>\n",
       "      <td>72</td>\n",
       "      <td>23</td>\n",
       "      <td>112</td>\n",
       "      <td>26.2</td>\n",
       "      <td>0.245</td>\n",
       "      <td>30</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>766</th>\n",
       "      <td>1</td>\n",
       "      <td>126</td>\n",
       "      <td>60</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>30.1</td>\n",
       "      <td>0.349</td>\n",
       "      <td>47</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>767</th>\n",
       "      <td>1</td>\n",
       "      <td>93</td>\n",
       "      <td>70</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "      <td>30.4</td>\n",
       "      <td>0.315</td>\n",
       "      <td>23</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>768 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "0              6      148             72             35        0  33.6   \n",
       "1              1       85             66             29        0  26.6   \n",
       "2              8      183             64              0        0  23.3   \n",
       "3              1       89             66             23       94  28.1   \n",
       "4              0      137             40             35      168  43.1   \n",
       "..           ...      ...            ...            ...      ...   ...   \n",
       "763           10      101             76             48      180  32.9   \n",
       "764            2      122             70             27        0  36.8   \n",
       "765            5      121             72             23      112  26.2   \n",
       "766            1      126             60              0        0  30.1   \n",
       "767            1       93             70             31        0  30.4   \n",
       "\n",
       "     DiabetesPedigreeFunction  Age  Outcome  \n",
       "0                       0.627   50        1  \n",
       "1                       0.351   31        0  \n",
       "2                       0.672   32        1  \n",
       "3                       0.167   21        0  \n",
       "4                       2.288   33        1  \n",
       "..                        ...  ...      ...  \n",
       "763                     0.171   63        0  \n",
       "764                     0.340   27        0  \n",
       "765                     0.245   30        0  \n",
       "766                     0.349   47        1  \n",
       "767                     0.315   23        0  \n",
       "\n",
       "[768 rows x 9 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv(\"diabetes.csv\")\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of null values Pregnancies                 0\n",
      "Glucose                     0\n",
      "BloodPressure               0\n",
      "SkinThickness               0\n",
      "Insulin                     0\n",
      "BMI                         0\n",
      "DiabetesPedigreeFunction    0\n",
      "Age                         0\n",
      "Outcome                     0\n",
      "dtype: int64\n",
      "No. of duplicate values 0\n"
     ]
    }
   ],
   "source": [
    "print(f\"No. of null values {df.isnull().sum()}\")\n",
    "print(f\"No. of duplicate values {df.duplicated().sum()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Outcome\n",
       "0    65.104167\n",
       "1    34.895833\n",
       "Name: proportion, dtype: float64"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['Outcome'].value_counts(normalize=\"columns\")*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(768, 9)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=df.drop(columns=['Outcome']).values\n",
    "y=df['Outcome'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(768, 8)\n",
      "(768,)\n"
     ]
    }
   ],
   "source": [
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(614, 8)\n",
      "(614,)\n",
      "(154, 8)\n",
      "(154,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(y_train.shape)\n",
    "print(X_test.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler=StandardScaler()\n",
    "X_train=scaler.fit_transform(X_train)\n",
    "X_test=scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_tensor=torch.tensor(X_train,dtype=torch.float32)\n",
    "X_test_tensor=torch.tensor(X_test,dtype=torch.float32)\n",
    "y_train_tensor=torch.tensor(y_train,dtype=torch.float32)\n",
    "y_test_tensor=torch.tensor(y_test,dtype=torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset,DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomDataset(Dataset):\n",
    "    def __init__(self,features,labels):\n",
    "        self.features=features\n",
    "        self.labels=labels\n",
    "    def __len__(self):\n",
    "        return self.features.shape[0]\n",
    "    def __getitem__(self,index):\n",
    "        # Here we can apply the transformation\n",
    "        return self.features[index],self.labels[index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset=CustomDataset(X_train_tensor,y_train_tensor)\n",
    "test_dataset=CustomDataset(X_test_tensor,y_test_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader=DataLoader(train_dataset,batch_size=32,shuffle=False)\n",
    "test_dataloader=DataLoader(test_dataset,batch_size=32,shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self,input_shape ):\n",
    "        super().__init__()\n",
    "        self.Network=nn.Sequential(\n",
    "            nn.Linear(in_features=input_shape,out_features=32),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(in_features=32,out_features=16),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(in_features=16,out_features=9),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(in_features=9,out_features=1),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "    def forward(self,features):\n",
    "        out=self.Network(features)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "model=Net(X_train_tensor.shape[1])\n",
    "# model(X_train_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs=100\n",
    "learning_rate=0.01\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "loss_function = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs: 0, loss: 0.5315\n",
      "Epochs: 1, loss: 0.4595\n",
      "Epochs: 2, loss: 0.4464\n",
      "Epochs: 3, loss: 0.4256\n",
      "Epochs: 4, loss: 0.4083\n",
      "Epochs: 5, loss: 0.3780\n",
      "Epochs: 6, loss: 0.3525\n",
      "Epochs: 7, loss: 0.3311\n",
      "Epochs: 8, loss: 0.3056\n",
      "Epochs: 9, loss: 0.2742\n",
      "Epochs: 10, loss: 0.2597\n",
      "Epochs: 11, loss: 0.2172\n",
      "Epochs: 12, loss: 0.2172\n",
      "Epochs: 13, loss: 0.1845\n",
      "Epochs: 14, loss: 0.1659\n",
      "Epochs: 15, loss: 0.1835\n",
      "Epochs: 16, loss: 0.1199\n",
      "Epochs: 17, loss: 0.0899\n",
      "Epochs: 18, loss: 0.0964\n",
      "Epochs: 19, loss: 0.0634\n",
      "Epochs: 20, loss: 0.0763\n",
      "Epochs: 21, loss: 0.0557\n",
      "Epochs: 22, loss: 0.0581\n",
      "Epochs: 23, loss: 0.0826\n",
      "Epochs: 24, loss: 0.0647\n",
      "Epochs: 25, loss: 0.0662\n",
      "Epochs: 26, loss: 0.0735\n",
      "Epochs: 27, loss: 0.0395\n",
      "Epochs: 28, loss: 0.0468\n",
      "Epochs: 29, loss: 0.0306\n",
      "Epochs: 30, loss: 0.0445\n",
      "Epochs: 31, loss: 0.2705\n",
      "Epochs: 32, loss: 0.2037\n",
      "Epochs: 33, loss: 0.1814\n",
      "Epochs: 34, loss: 0.0369\n",
      "Epochs: 35, loss: 0.0272\n",
      "Epochs: 36, loss: 0.0225\n",
      "Epochs: 37, loss: 0.0447\n",
      "Epochs: 38, loss: 0.0773\n",
      "Epochs: 39, loss: 0.0137\n",
      "Epochs: 40, loss: 0.0094\n",
      "Epochs: 41, loss: 0.0432\n",
      "Epochs: 42, loss: 0.0074\n",
      "Epochs: 43, loss: 0.0162\n",
      "Epochs: 44, loss: 0.0436\n",
      "Epochs: 45, loss: 0.0605\n",
      "Epochs: 46, loss: 0.0120\n",
      "Epochs: 47, loss: 0.0046\n",
      "Epochs: 48, loss: 0.0330\n",
      "Epochs: 49, loss: 0.0151\n",
      "Epochs: 50, loss: 0.0142\n",
      "Epochs: 51, loss: 0.0022\n",
      "Epochs: 52, loss: 0.0129\n",
      "Epochs: 53, loss: 0.0062\n",
      "Epochs: 54, loss: 0.0389\n",
      "Epochs: 55, loss: 0.0028\n",
      "Epochs: 56, loss: 0.0025\n",
      "Epochs: 57, loss: 0.0155\n",
      "Epochs: 58, loss: 0.0011\n",
      "Epochs: 59, loss: 0.0016\n",
      "Epochs: 60, loss: 0.0061\n",
      "Epochs: 61, loss: 0.2066\n",
      "Epochs: 62, loss: 0.1019\n",
      "Epochs: 63, loss: 0.0146\n",
      "Epochs: 64, loss: 0.0058\n",
      "Epochs: 65, loss: 0.0042\n",
      "Epochs: 66, loss: 0.0023\n",
      "Epochs: 67, loss: 0.0013\n",
      "Epochs: 68, loss: 0.0033\n",
      "Epochs: 69, loss: 0.0013\n",
      "Epochs: 70, loss: 0.0014\n",
      "Epochs: 71, loss: 0.0002\n",
      "Epochs: 72, loss: 0.0041\n",
      "Epochs: 73, loss: 0.0002\n",
      "Epochs: 74, loss: 0.0007\n",
      "Epochs: 75, loss: 0.0005\n",
      "Epochs: 76, loss: 0.0005\n",
      "Epochs: 77, loss: 0.0002\n",
      "Epochs: 78, loss: 0.0003\n",
      "Epochs: 79, loss: 0.0001\n",
      "Epochs: 80, loss: 0.0002\n",
      "Epochs: 81, loss: 0.0006\n",
      "Epochs: 82, loss: 0.0477\n",
      "Epochs: 83, loss: 0.0140\n",
      "Epochs: 84, loss: 0.0091\n",
      "Epochs: 85, loss: 0.0019\n",
      "Epochs: 86, loss: 0.0047\n",
      "Epochs: 87, loss: 0.0010\n",
      "Epochs: 88, loss: 0.0054\n",
      "Epochs: 89, loss: 0.0013\n",
      "Epochs: 90, loss: 0.0023\n",
      "Epochs: 91, loss: 0.0016\n",
      "Epochs: 92, loss: 0.0023\n",
      "Epochs: 93, loss: 0.0003\n",
      "Epochs: 94, loss: 0.0002\n",
      "Epochs: 95, loss: 0.0000\n",
      "Epochs: 96, loss: 0.0001\n",
      "Epochs: 97, loss: 0.0040\n",
      "Epochs: 98, loss: 0.0016\n",
      "Epochs: 99, loss: 0.0002\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(epochs):\n",
    "    for batch_features,batch_lables in train_dataloader:\n",
    "        y_pred=model(batch_features)\n",
    "        loss=loss_function(y_pred,batch_lables.view(-1,1))\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "    print(f\"Epochs: {epoch}, loss: {loss:.4f}\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 15.4805\n"
     ]
    }
   ],
   "source": [
    "# Initialize accuracy variables\n",
    "total_correct = 0\n",
    "total_samples = 0\n",
    "\n",
    "# Iterate over the test dataloader\n",
    "with torch.no_grad():\n",
    "    for batch_features, batch_labels in test_dataloader:\n",
    "        # Get predictions\n",
    "        y_pred = model(batch_features)\n",
    "        \n",
    "        # Convert predictions to class labels (0 or 1)\n",
    "        # predicted_labels = torch.round(y_pred)\n",
    "        predicted_labels = (y_pred > 0.1).float()\n",
    "        \n",
    "        # Calculate correct predictions\n",
    "        correct_predictions = (predicted_labels == batch_labels).sum()\n",
    "        \n",
    "        # Update accuracy variables\n",
    "        total_correct += correct_predictions.item()\n",
    "        total_samples += batch_labels.shape[0]\n",
    "\n",
    "# Calculate accuracy\n",
    "accuracy = total_correct / total_samples\n",
    "print(f\"Test Accuracy: {accuracy:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Less accuracy maybe because of imbalance Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}