Data-Driven.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import os\n",
    "import numpy as np\n",
    "import math\n",
    "import sys\n",
    "import torch\n",
    "import torch.distributions as distributions\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.utils import save_image\n",
    "import torch.utils.data as Data\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch\n",
    "from scipy.io import savemat\n",
    "import scipy.io as sio\n",
    "import sys\n",
    "import importlib\n",
    "import datetime\n",
    "import itertools\n",
    "import pickle\n",
    "import scipy\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from numpy import cov\n",
    "from numpy import trace\n",
    "from numpy import iscomplexobj\n",
    "from numpy.random import random\n",
    "from scipy.linalg import sqrtm\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.linear_model import Ridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = \"data/case30\"\n",
    "case_dir = os.path.join(data_dir)\n",
    "number = 20000\n",
    "train_index = 12000\n",
    "valid_index = 16000\n",
    "saveFile = \"data/case30/RNN_LR/S3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20000, 53)\n",
      "torch.Size([4000, 53])\n",
      "torch.Size([12000, 53])\n",
      "torch.Size([4000, 53])\n"
     ]
    }
   ],
   "source": [
    "#input data\n",
    "mat_input = os.path.join(case_dir, 'inputdata_sample.mat')\n",
    "PQ_injection = np.transpose(scipy.io.loadmat(mat_input)['sampledata'])[0:number,:]\n",
    "P_injection = PQ_injection.real\n",
    "Q_injection = PQ_injection.imag\n",
    "# print(Q_injection.shape)\n",
    "pv = [1-1,2-1,13-1,22-1,23-1,27-1]\n",
    "slack = 1-1\n",
    "P_injection = np.delete(P_injection,slack,1)\n",
    "Q_injection = np.delete(Q_injection,pv,1)\n",
    "# print(Q_injection.shape)\n",
    "PQ_injection = np.concatenate([P_injection, Q_injection], axis=1)       \n",
    "print(PQ_injection.shape)\n",
    "#output data\n",
    "mat_ang = os.path.join(case_dir, 'voltage_ang_reduced.mat')\n",
    "mat_mag = os.path.join(case_dir, 'voltage_mag_reduced.mat')\n",
    "voltage_ang = np.transpose(scipy.io.loadmat(mat_ang)['voltage_ang_reduced'])[0:number,:]\n",
    "voltage_mag = np.transpose(scipy.io.loadmat(mat_mag)['voltage_mag_reduced'])[0:number,:]\n",
    "voltage =  np.concatenate([voltage_ang,voltage_mag], axis=1) \n",
    "yTrain = torch.from_numpy(voltage[0:train_index,:])\n",
    "xTrain = torch.from_numpy(PQ_injection[0:train_index,:])\n",
    "yValid = torch.from_numpy(voltage[train_index:valid_index,:])\n",
    "xValid = torch.from_numpy(PQ_injection[train_index:valid_index,:])\n",
    "yTest = torch.from_numpy(voltage[valid_index:number,:])\n",
    "xTest = torch.from_numpy(PQ_injection[valid_index:number,:])\n",
    "dataset = torch.utils.data.TensorDataset(xTrain, yTrain)\n",
    "print(xValid.shape)\n",
    "print(xTrain.shape)\n",
    "print(xTest.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(batch_size=32, hidden1_dim=100, img_size=53, labels_dim=53, lr=1e-05, n_cpu=8, n_epochs=400, output1_dim=100)\n"
     ]
    }
   ],
   "source": [
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"--n_epochs\", type=int, default=1000, help=\"number of epochs of training\")\n",
    "parser.add_argument(\"--batch_size\", type=int, default=32, help=\"size of the batches\")\n",
    "parser.add_argument(\"--lr\", type=float, default=0.0001, help=\"learning rate\")\n",
    "parser.add_argument(\"--n_cpu\", type=int, default=8, help=\"number of cpu threads to use during batch generation\")\n",
    "parser.add_argument(\"--labels_dim\", type=int, default=53, help=\"dimensionality of the latent space\")\n",
    "parser.add_argument(\"--img_size\", type=int, default=53, help=\"size of each image dimension\")\n",
    "parser.add_argument(\"--hidden1_dim\", type=int, default=100, help=\"size of hidden_dim\")\n",
    "parser.add_argument(\"--output1_dim\", type=int, default=100, help=\"size of hidden_dim\")\n",
    "opt = parser.parse_args(args=[])\n",
    "print(opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuda = True if torch.cuda.is_available() else False\n",
    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor\n",
    "#reg = LinearRegression().fit(xTrain, yTrain)\n",
    "reg = Ridge(alpha = 0.0001).fit(xTrain, yTrain)\n",
    "initial_weight_original = reg.coef_\n",
    "initial_bias_original = reg.intercept_\n",
    "initial_weight = Tensor(initial_weight_original)\n",
    "initial_bias = Tensor(initial_bias_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([53])\n",
      "torch.Size([53, 53])\n"
     ]
    }
   ],
   "source": [
    "print(initial_bias.shape)\n",
    "print(initial_weight.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BasicBlock(nn.Module):\n",
    "    def __init__(self, in_feat, hidden_feat, out_feat):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.layers = nn.Linear(opt.labels_dim, opt.img_size)\n",
    "        self.layers1 = nn.Linear(opt.labels_dim, hidden_feat)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.layers2 = nn.Linear(hidden_feat, hidden_feat)\n",
    "        self.layers3 = nn.Linear(hidden_feat, out_feat)\n",
    "        self.layers.weight = torch.nn.Parameter(initial_weight)\n",
    "        self.layers.bias = torch.nn.Parameter(initial_bias)\n",
    "    def forward(self, x):\n",
    "        identity = self.layers(x)\n",
    "\n",
    "        out = self.layers1(x)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.layers2(out)\n",
    "        out = self.relu(out)\n",
    "        \n",
    "        out = self.layers3(out)\n",
    "        out = identity + out\n",
    "        #out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "class Resnet(nn.Module):\n",
    "    def __init__(self, block):\n",
    "        super(Resnet, self).__init__()\n",
    "        self.block = block\n",
    "        self.model = nn.Sequential(\n",
    "            block(opt.labels_dim,opt.hidden1_dim, opt.img_size),\n",
    "            #block(opt.output1_dim,opt.hidden2_dim,opt.output2_dim),\n",
    "            #block(opt.output1_dim,opt.hidden2_dim,opt.output2_dim),\n",
    "            #nn.Linear(opt.output1_dim,opt.img_size),\n",
    "        )   \n",
    "    def forward(self, x):\n",
    "        out = self.model(x)\n",
    "        return out\n",
    "MLP = Resnet(BasicBlock)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_TestHat = MLP.model[0].layers(xTest.float())\n",
    "rmse_test = torch.sqrt(torch.mean((y_TestHat - yTest.float())**2,axis = 0))\n",
    "rmse_ang_test = torch.mean(rmse_test[0:29])\n",
    "rmse_mag_test = torch.mean(rmse_test[29:53])\n",
    "print(rmse_ang_test)\n",
    "print(rmse_mag_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize generator and discriminator\n",
    "time = []\n",
    "loss_train = []  \n",
    "loss_valid = [] \n",
    "batch_loss_train = [] \n",
    "avg_train_losses = []\n",
    "L2_loss = nn.MSELoss()\n",
    "if cuda:\n",
    "    MLP.cuda()\n",
    "    L2_loss.cuda()\n",
    "# Configure data loader\n",
    "dataloader = torch.utils.data.DataLoader(\n",
    "    dataset,\n",
    "    batch_size=opt.batch_size,\n",
    "    shuffle=True,\n",
    ")\n",
    "\n",
    "# Optimizers\n",
    "optimizer = torch.optim.Adam(MLP.parameters(), lr=opt.lr)\n",
    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor\n",
    "# Create batch of latent vectors that we will use to check the progression of the generator\n",
    "# ----------\n",
    "#  Training\n",
    "# ----------\n",
    "\n",
    "batches_done = 0\n",
    "\n",
    "for epoch in range(opt.n_epochs):\n",
    "\n",
    "    for i, (xTrain, yTrain) in enumerate(dataloader):\n",
    "        # Configure input\n",
    "            # -----------------\n",
    "            #  Train Generator\n",
    "            # -----------------\n",
    "            startTime = datetime.datetime.now()\n",
    "            optimizer.zero_grad()\n",
    "            # Generate a batch of images\n",
    "            yHatTrain = MLP(xTrain.float())\n",
    "            # Adversarial loss\n",
    "            loss = L2_loss(yHatTrain,yTrain.float())\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            endTime = datetime.datetime.now()\n",
    "            timeElapsed = abs(endTime - startTime).total_seconds()\n",
    "            time.append(timeElapsed)\n",
    "            batch_loss_train.append(loss.item())  \n",
    "            print(\n",
    "                \"[Epoch %d/%d] [Batch %d/%d][G loss: %.9f]\"\n",
    "                % (epoch, opt.n_epochs, batches_done % len(dataloader), len(dataloader), loss.item())\n",
    "            )       \n",
    "            if (batches_done % (len(yValid)//opt.batch_size) == 0):\n",
    "                with torch.no_grad(): \n",
    "                    yHatValid = MLP(xValid.float()) \n",
    "                    # Compute loss\n",
    "                    lossValueValid = L2_loss(yHatValid, yValid)\n",
    "                    loss_valid.append(lossValueValid.item())\n",
    "                if epoch >= 799:\n",
    "                    if (epoch == 799):\n",
    "                        bestScore = lossValueValid\n",
    "                        torch.save(MLP.state_dict(), saveFile +'Best'+'.ckpt')\n",
    "                        torch.save(optimizer.state_dict(), saveFile+'Optim'+'Best'+'.ckpt')\n",
    "                    else:\n",
    "                        thisValidScore = lossValueValid\n",
    "                        if thisValidScore < bestScore:\n",
    "                            bestScore = thisValidScore\n",
    "                            torch.save(MLP.state_dict(), saveFile + 'Best'+'.ckpt')\n",
    "                            torch.save(optimizer.state_dict(), saveFile+'Optim'+'Best'+'.ckpt')                  \n",
    "            batches_done += 1\n",
    "    train_loss = np.average(batch_loss_train)\n",
    "    avg_train_losses.append(train_loss)\n",
    "    batch_loss_train = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(time, saveFile + 'Time')\n",
    "torch.save(MLP.state_dict(), saveFile + 'Last'+'.ckpt')\n",
    "torch.save(optimizer.state_dict(), saveFile+'Optim'+'Last'+'.ckpt') \n",
    "np.save(saveFile+'Train',avg_train_losses)\n",
    "np.save(saveFile+'Valid',loss_valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(avg_train_losses[200:1000])\n",
    "plt.ylabel('mean squared loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.title('neurons = 200')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(loss_valid[1500:3000:4])\n",
    "plt.plot(loss_valid[3000:4500:4])\n",
    "plt.ylabel('mean squared loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.05828424  0.02185371  0.01842796 ...  0.02359192  0.02597785\n",
      "   0.01951063]\n",
      " [ 0.03722832  0.05225526  0.03506538 ...  0.03061008  0.04599512\n",
      "   0.04030554]\n",
      " [ 0.04659604  0.04384759  0.05059697 ...  0.02643303  0.05388037\n",
      "   0.04053432]\n",
      " ...\n",
      " [ 0.00863184  0.02202503  0.0078987  ...  0.04428414  0.00922916\n",
      "   0.00701907]\n",
      " [-0.00566256  0.00067742 -0.00591888 ...  0.01032159  0.23695321\n",
      "   0.16194119]\n",
      " [-0.00514005  0.00357475  0.0103602  ...  0.00604989  0.15234019\n",
      "   0.29528347]]\n"
     ]
    }
   ],
   "source": [
    "color_map = plt.imshow(MLP.model[0].layers.weight.detach().numpy())\n",
    "color_map.set_cmap(\"RdYlBu_r\")\n",
    "plt.colorbar()\n",
    "plt.show()\n",
    "print(MLP.model[0].layers.weight.detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5.60702089e-02  2.16785491e-02  2.62218316e-02 ...  2.32561582e-02\n",
      "   2.56339433e-02  2.66821843e-02]\n",
      " [ 3.35620765e-02  5.22907896e-02  4.29217272e-02 ...  3.21805468e-02\n",
      "   3.98188564e-02  4.14456135e-02]\n",
      " [ 4.08151181e-02  4.35737460e-02  5.25302890e-02 ...  3.93158016e-02\n",
      "   4.84957861e-02  5.04807611e-02]\n",
      " ...\n",
      " [-4.41115840e-04  1.67364230e-02  2.03098215e-02 ...  4.71093064e-02\n",
      "   1.38145859e-02  1.43984945e-02]\n",
      " [-1.17336049e-05 -8.55315764e-05  2.85705797e-04 ... -9.44303201e-05\n",
      "   2.36257822e-01  1.50996113e-01]\n",
      " [-1.00457261e-05 -2.29201666e-05  7.78940855e-05 ... -4.56428140e-05\n",
      "   1.45595815e-01  2.99263242e-01]]\n"
     ]
    }
   ],
   "source": [
    "color_map = plt.imshow(initial_weight_original)\n",
    "plt.colorbar()\n",
    "color_map.set_cmap(\"RdYlBu_r\")\n",
    "plt.show()\n",
    "print(initial_weight_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#number = 200\n",
    "MLP.eval()\n",
    "yHatTest = MLP(xTest.float())\n",
    "rmse_test = np.mean((yHatTest.detach().numpy()-yTest.detach().numpy())**2)\n",
    "print(rmse_test)\n",
    "rmse_test1 = np.sqrt(np.mean((yHatTest.detach().numpy()-yTest.detach().numpy())**2,0))\n",
    "print(rmse_test1)\n",
    "print(np.mean(rmse_test1[0:29]))\n",
    "print(np.mean(rmse_test1[29:53]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(saveFile+'rmse_test_last',rmse_test1)\n",
    "np.save(saveFile+'yHatTest_last',yHatTest.detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Resnet(BasicBlock)\n",
    "model.load_state_dict(torch.load(saveFile + 'Best'+'.ckpt'))\n",
    "optimizer.load_state_dict(torch.load(saveFile+'Optim'+'Best'+'.ckpt'))\n",
    "model.eval()\n",
    "yHatTest = model(xTest.float())\n",
    "rmse_test2 = np.mean((yHatTest.detach().numpy()-yTest.detach().numpy())**2)\n",
    "print(rmse_test2)\n",
    "rmse_test3 = np.sqrt(np.mean((yHatTest.detach().numpy()-yTest.detach().numpy())**2,0))\n",
    "print(rmse_test3)\n",
    "print(np.mean(rmse_test3[0:29]))\n",
    "print(np.mean(rmse_test3[29:53]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(saveFile+'rmse_test_best',rmse_test3)\n",
    "np.save(saveFile+'yHatTest_best',yHatTest.detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(saveFile+'yTest',yTest.detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}