neuralNet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statistics import mean, mode\n",
    "import torch\n",
    "from torch import nn\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_auc_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://towardsdatascience.com/lstms-in-pytorch-528b0440244\n",
    "# https://github.com/IHCA-Coding-to-Prevent-Coding/ML-SampleNeuralNet/blob/main/sampleneuralnet.py\n",
    "# data from https://archive.ics.uci.edu/ml/datasets/Power+consumption+of+Tetouan+city#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['DateTime', 'Temperature', 'Humidity', 'Wind Speed',\n",
       "       'general diffuse flows', 'diffuse flows', 'Zone 1 Power Consumption',\n",
       "       'Zone 2  Power Consumption', 'Zone 3  Power Consumption'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_csv('Tetuan City power consumption.csv')\n",
    "data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# changes data length so you don't run on 50,000 values every time\n",
    "data = data.iloc[:5000, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "xValues = data.iloc[:, [1, 2, 3, 4, 5]]\n",
    "yValues = data.iloc[:, [6]]\n",
    "assert len(xValues) == len(yValues)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    }
   ],
   "source": [
    "training, validation, trainTruth, valTruth = train_test_split(xValues, yValues, random_state=12, train_size = 0.7)\n",
    "validation, testing, valTruth, testTruth = train_test_split(validation, valTruth, random_state=2, train_size = 0.5)\n",
    "\n",
    "assert len(training)==len(trainTruth)\n",
    "assert len(testing)==len(testTruth)\n",
    "assert len(validation) == len(valTruth)\n",
    "print(type(training))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'torch.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "trainTruth = torch.tensor(trainTruth.values)\n",
    "training = torch.tensor(training.values)\n",
    "\n",
    "testTruth = torch.tensor(testTruth.values)\n",
    "testing = torch.tensor(testing.values)\n",
    "\n",
    "training = training.float()\n",
    "testing = testing.float()\n",
    "\n",
    "trainTruth = trainTruth.float()\n",
    "testTruth = testTruth.float()\n",
    "\n",
    "valTruth = torch.tensor(valTruth.values)\n",
    "validation = torch.tensor(validation.values)\n",
    "\n",
    "validation = validation.float()\n",
    "valTruth = valTruth.float()\n",
    "print(type(training))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "average = mean(x.item() for x in trainTruth)\n",
    "\n",
    "binaryTestTruth = torch.tensor([float(x>average) for x in testTruth])\n",
    "\n",
    "binaryTrainTruth = torch.tensor([float(x>average) for x in trainTruth])\n",
    "\n",
    "binaryValTruth = torch.tensor([float(x>average) for x in valTruth])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3500, 5])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\natha\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\torch\\nn\\modules\\loss.py:536: UserWarning: Using a target size (torch.Size([3500])) that is different to the input size (torch.Size([3500, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total change in loss: 0.31839506328105927\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#testing = torch.randn(batchSize, seqLength, inputSize)\n",
    "\n",
    "inputSize=5 # variables input\n",
    "hiddenSizeOne=32 # nodes of hidden layer\n",
    "hiddenSizeTwo=32 # nodes of hidden layer\n",
    "outSize=1 # power consumptoion in zone 1\n",
    "batchSize= 144*7 # how many data points are in batch\n",
    "lr = 0.025\n",
    "seqLength=144 # num of time values per input\n",
    "epochSize = 10\n",
    "\n",
    "class extractTensor(nn.Module):\n",
    "    def forward(self, x):\n",
    "        tensor, hs = x\n",
    "        return tensor.reshape(-1, hiddenSizeOne) \n",
    "\n",
    "model = nn.Sequential(\n",
    "    nn.LSTM(inputSize, hiddenSizeOne),\n",
    "    extractTensor(),\n",
    "    nn.Sigmoid(),\n",
    "    nn.Linear(hiddenSizeOne, hiddenSizeTwo),\n",
    "    #nn.Sigmoid(),\n",
    "    nn.Linear(hiddenSizeTwo, outSize)\n",
    "    #nn.Sigmoid() \n",
    "    #nn.Linear(linearSize, outSize)\n",
    ")\n",
    "\n",
    "MSEloss = torch.nn.MSELoss()\n",
    "def lossFunc(data=training, comparison=trainTruth, model=model):\n",
    "    prediction = model(data)\n",
    "\n",
    "    output = MSEloss(prediction, comparison)\n",
    "    \n",
    "    return output, prediction\n",
    "\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=lr)\n",
    "\n",
    "# model training starts here\n",
    "lossList = []\n",
    "print(training.shape)\n",
    "for i in range(epochSize):\n",
    "    loss, output = lossFunc(comparison = binaryTrainTruth)\n",
    "    lossList.append(loss.item())\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "plt.plot(lossList)\n",
    "training_loss = loss.item();\n",
    "print(f'total change in loss: {lossList[0]-lossList[-1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training loss:    0.24970413744449615\n",
      "testing loss:     0.24913786351680756\n",
      "testing-training: 0.0005662739276885986\n",
      "testing/training: 1.0022729340281527\n",
      "% error           0.002272934028152634\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\natha\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages\\torch\\nn\\modules\\loss.py:536: UserWarning: Using a target size (torch.Size([750])) that is different to the input size (torch.Size([750, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n"
     ]
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    testing_loss, prediction = lossFunc(validation, binaryValTruth);\n",
    "    testing_loss = testing_loss.item()\n",
    "   \n",
    "    print(f\"training loss:    {training_loss}\");\n",
    "    print(f\"testing loss:     {testing_loss}\");\n",
    "    print(f\"testing-training: {abs(testing_loss-training_loss)}\");\n",
    "    print(f\"testing/training: {training_loss/testing_loss}\");\n",
    "    print(f\"% error           {abs(testing_loss-training_loss)/testing_loss}\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicting same thing 0.26666666666666666%\n"
     ]
    }
   ],
   "source": [
    "common = mode([float(x) for x in output])\n",
    "\n",
    "count=0\n",
    "for x in output:\n",
    "    if x == common:\n",
    "        count+=1\n",
    "\n",
    "print(f'predicting same thing {count/len(prediction)*100}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUROC score: 0.48916542665827273\n"
     ]
    }
   ],
   "source": [
    "print(f'AUROC score: {roc_auc_score(binaryValTruth, prediction)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rounding percentage chances to 1 or 0 floats\n",
    "binaryPred = []\n",
    "for pred in prediction:\n",
    "    if pred.item() >= 0.5:\n",
    "        binaryPred.append(1.0)\n",
    "    else:\n",
    "        binaryPred.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 46.93333333333333\n"
     ]
    }
   ],
   "source": [
    "# accuracy for binary prediction\n",
    "\n",
    "correct=0\n",
    "for i in range(len(binaryPred)):\n",
    "    if binaryPred[i] == binaryValTruth[i]:\n",
    "        correct+=1\n",
    "print(f'accuracy: {(correct/ len(prediction))*100}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cross validation is necessary for true model\n",
    "# iterate above k times\n",
    "# each iteration change training and testing data (stratified data split probably best imo)\n",
    "# get average auroc score over all iterations\n",
    "\n",
    "# from sklearn.model_selection import cross_validate\n",
    "# https://www.baeldung.com/cs/k-fold-cross-validation"
   ]
  }
 ],
 "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "89627e806f793b932dfe80791ab48950fda4fb8e20d46d5d1c8fbf2fdce875b2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}