GradNormv10.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8000, 100)\n",
      "(1000, 100)\n",
      "(1000, 100)\n",
      "(8000,)\n",
      "(8000,)\n",
      "(1000,)\n",
      "(1000,)\n",
      "(1000,)\n",
      "(1000,)\n",
      "torch.Size([8000, 100])\n",
      "torch.Size([1000, 100])\n",
      "torch.Size([1000, 100])\n",
      "torch.Size([8000])\n",
      "torch.Size([8000])\n",
      "torch.Size([1000])\n",
      "torch.Size([1000])\n",
      "torch.Size([1000])\n",
      "torch.Size([1000])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "import os\n",
    "from torch.autograd import Variable\n",
    "import pandas as pd\n",
    "import math\n",
    "import sklearn.preprocessing as sk\n",
    "from tensorboardX import SummaryWriter\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn import metrics\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.linear_model import RidgeCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "import random\n",
    "\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "N = 10000\n",
    "M = 100\n",
    "c = 0.5\n",
    "p = 0.9\n",
    "k = np.random.randn(M)\n",
    "u1 = np.random.randn(M)\n",
    "u1 -= u1.dot(k) * k / np.linalg.norm(k)**2\n",
    "u1 /= np.linalg.norm(u1) \n",
    "k /= np.linalg.norm(k) \n",
    "u2 = k\n",
    "w1 = c*u1\n",
    "w2 = c*(p*u1+np.sqrt((1-p**2))*u2)\n",
    "X = np.random.normal(0, 1, (N, M))\n",
    "eps1 = np.random.normal(0, 0.01)\n",
    "eps2 = np.random.normal(0, 0.01)\n",
    "Y1 = np.matmul(X, w1) + np.sin(np.matmul(X, w1))+eps1\n",
    "Y2 = np.matmul(X, w2) + np.sin(np.matmul(X, w2))+eps2\n",
    "split = list(np.random.permutation(N))\n",
    "\n",
    "X_train = X[split[0:8000],:]\n",
    "Y1_train = Y1[split[0:8000]]\n",
    "Y2_train = Y2[split[0:8000]]\n",
    "X_valid = X[8000:9000,:]\n",
    "Y1_valid = Y1[8000:9000]\n",
    "Y2_valid = Y2[8000:9000]\n",
    "X_test = X[9000:10000,:]\n",
    "Y1_test = Y1[9000:10000]\n",
    "Y2_test = Y2[9000:10000]\n",
    "print(X_train.shape)\n",
    "print(X_valid.shape)\n",
    "print(X_test.shape)\n",
    "print(Y1_train.shape)\n",
    "print(Y2_train.shape)\n",
    "print(Y1_valid.shape)\n",
    "print(Y2_valid.shape)\n",
    "print(Y1_test.shape)\n",
    "print(Y2_test.shape)\n",
    "\n",
    "X_train = torch.from_numpy(X_train)\n",
    "X_train = X_train.float()\n",
    "Y1_train = torch.tensor(Y1_train)\n",
    "Y1_train = Y1_train.float()\n",
    "Y2_train = torch.tensor(Y2_train)\n",
    "Y2_train = Y2_train.float()\n",
    "\n",
    "X_valid = torch.from_numpy(X_valid)\n",
    "X_valid = X_valid.float()\n",
    "Y1_valid = torch.tensor(Y1_valid)\n",
    "Y1_valid = Y1_valid.float()\n",
    "Y2_valid = torch.tensor(Y2_valid)\n",
    "Y2_valid = Y2_valid.float()\n",
    "\n",
    "X_test = torch.from_numpy(X_test)\n",
    "X_test = X_test.float()\n",
    "Y1_test = torch.tensor(Y1_test)\n",
    "Y1_test = Y1_test.float()\n",
    "Y2_test = torch.tensor(Y2_test)\n",
    "Y2_test = Y2_test.float()\n",
    "\n",
    "print(X_train.shape)\n",
    "print(X_valid.shape)\n",
    "print(X_test.shape)\n",
    "print(Y1_train.shape)\n",
    "print(Y2_train.shape)\n",
    "print(Y1_valid.shape)\n",
    "print(Y2_valid.shape)\n",
    "print(Y1_test.shape)\n",
    "print(Y2_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size, feature_size = X.shape\n",
    "shared_layer_size = 64\n",
    "tower_h1 = 32\n",
    "tower_h2 = 16\n",
    "output_size = 1\n",
    "LR = 0.001\n",
    "epoch = 50\n",
    "mb_size = 100\n",
    "cost1tr = []\n",
    "cost2tr = []\n",
    "cost1D = []\n",
    "cost2D = []\n",
    "cost1ts = []\n",
    "cost2ts = []\n",
    "costtr = []\n",
    "costD = []\n",
    "costts = []\n",
    "\n",
    "class MTLnet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MTLnet, self).__init__()\n",
    "        self.sharedlayer = nn.Sequential(\n",
    "            nn.Linear(feature_size, shared_layer_size),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout()\n",
    "        )\n",
    "        self.tower1 = nn.Sequential(\n",
    "            nn.Linear(shared_layer_size, tower_h1),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(tower_h1, tower_h2),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(tower_h2, output_size)\n",
    "        )\n",
    "        self.tower2 = nn.Sequential(\n",
    "            nn.Linear(shared_layer_size, tower_h1),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(tower_h1, tower_h2),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(),\n",
    "            nn.Linear(tower_h2, output_size)\n",
    "        )        \n",
    "\n",
    "    def forward(self, x):\n",
    "        h_shared = self.sharedlayer(x)\n",
    "        out1 = self.tower1(h_shared)\n",
    "        out2 = self.tower2(h_shared)\n",
    "        return out1, out2\n",
    "\n",
    "def random_mini_batches(XE, R1E, R2E, mini_batch_size = 10, seed = 42): \n",
    "    # Creating the mini-batches\n",
    "    np.random.seed(seed)            \n",
    "    m = XE.shape[0]                  \n",
    "    mini_batches = []\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_XE = XE[permutation,:]\n",
    "    shuffled_X1R = R1E[permutation]\n",
    "    shuffled_X2R = R2E[permutation]\n",
    "    num_complete_minibatches = math.floor(m/mini_batch_size)\n",
    "    for k in range(0, int(num_complete_minibatches)):\n",
    "        mini_batch_XE = shuffled_XE[k * mini_batch_size : (k+1) * mini_batch_size, :]\n",
    "        mini_batch_X1R = shuffled_X1R[k * mini_batch_size : (k+1) * mini_batch_size]\n",
    "        mini_batch_X2R = shuffled_X2R[k * mini_batch_size : (k+1) * mini_batch_size]\n",
    "        mini_batch = (mini_batch_XE, mini_batch_X1R, mini_batch_X2R)\n",
    "        mini_batches.append(mini_batch)\n",
    "    Lower = int(num_complete_minibatches * mini_batch_size)\n",
    "    Upper = int(m - (mini_batch_size * math.floor(m/mini_batch_size)))\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_XE = shuffled_XE[Lower : Lower + Upper, :]\n",
    "        mini_batch_X1R = shuffled_X1R[Lower : Lower + Upper]\n",
    "        mini_batch_X2R = shuffled_X2R[Lower : Lower + Upper]\n",
    "        mini_batch = (mini_batch_XE, mini_batch_X1R, mini_batch_X2R)\n",
    "        mini_batches.append(mini_batch)\n",
    "    \n",
    "    return mini_batches\n",
    "\n",
    "Weightloss1 = torch.tensor(torch.FloatTensor([1]), requires_grad=True)\n",
    "Weightloss2 = torch.tensor(torch.FloatTensor([1]), requires_grad=True)\n",
    "\n",
    "params = [Weightloss1, Weightloss2]\n",
    "MTL = MTLnet()\n",
    "opt1 = torch.optim.Adam(MTL.parameters(), lr=LR)\n",
    "opt2 = torch.optim.Adam(params, lr=LR)\n",
    "loss_func = nn.MSELoss()\n",
    "Gradloss = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter-0; MTL loss: 0.8929\n",
      "Iter-1; MTL loss: 0.71\n",
      "Iter-2; MTL loss: 0.3467\n",
      "Iter-3; MTL loss: 0.3949\n",
      "Iter-4; MTL loss: 0.3204\n",
      "Iter-5; MTL loss: 0.3043\n",
      "Iter-6; MTL loss: 0.3192\n",
      "Iter-7; MTL loss: 0.3081\n",
      "Iter-8; MTL loss: 0.3141\n",
      "Iter-9; MTL loss: 0.2374\n",
      "Iter-10; MTL loss: 0.2495\n",
      "Iter-11; MTL loss: 0.2667\n",
      "Iter-12; MTL loss: 0.2737\n",
      "Iter-13; MTL loss: 0.2362\n",
      "Iter-14; MTL loss: 0.289\n",
      "Iter-15; MTL loss: 0.2686\n",
      "Iter-16; MTL loss: 0.2591\n",
      "Iter-17; MTL loss: 0.239\n",
      "Iter-18; MTL loss: 0.2266\n",
      "Iter-19; MTL loss: 0.2591\n",
      "Iter-20; MTL loss: 0.2291\n",
      "Iter-21; MTL loss: 0.2437\n",
      "Iter-22; MTL loss: 0.2385\n",
      "Iter-23; MTL loss: 0.2334\n",
      "Iter-24; MTL loss: 0.2087\n",
      "Iter-25; MTL loss: 0.2407\n",
      "Iter-26; MTL loss: 0.2161\n",
      "Iter-27; MTL loss: 0.1826\n",
      "Iter-28; MTL loss: 0.1976\n",
      "Iter-29; MTL loss: 0.2257\n",
      "Iter-30; MTL loss: 0.19\n",
      "Iter-31; MTL loss: 0.2222\n",
      "Iter-32; MTL loss: 0.2262\n",
      "Iter-33; MTL loss: 0.2063\n",
      "Iter-34; MTL loss: 0.1642\n",
      "Iter-35; MTL loss: 0.2289\n",
      "Iter-36; MTL loss: 0.192\n",
      "Iter-37; MTL loss: 0.1991\n",
      "Iter-38; MTL loss: 0.1982\n",
      "Iter-39; MTL loss: 0.2408\n",
      "Iter-40; MTL loss: 0.1831\n",
      "Iter-41; MTL loss: 0.1953\n",
      "Iter-42; MTL loss: 0.2261\n",
      "Iter-43; MTL loss: 0.1753\n",
      "Iter-44; MTL loss: 0.2032\n",
      "Iter-45; MTL loss: 0.212\n",
      "Iter-46; MTL loss: 0.2006\n",
      "Iter-47; MTL loss: 0.1949\n",
      "Iter-48; MTL loss: 0.1841\n",
      "Iter-49; MTL loss: 0.2118\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "alph = 0.16\n",
    "for it in range(epoch):\n",
    "    epoch_cost = 0\n",
    "    epoch_cost1 = 0\n",
    "    epoch_cost2 = 0\n",
    "    coef = 0\n",
    "    num_minibatches = int(input_size / mb_size) \n",
    "    minibatches = random_mini_batches(X_train, Y1_train, Y2_train, mb_size)\n",
    "    for minibatch in minibatches:\n",
    "        MTL.train()\n",
    "        XE, YE1, YE2  = minibatch \n",
    "        \n",
    "        Yhat1, Yhat2 = MTL(XE)\n",
    "        l1 = params[0]*loss_func(Yhat1, YE1.view(-1,1))    \n",
    "        l2 = params[1]*loss_func(Yhat2, YE2.view(-1,1))\n",
    "        loss = torch.div(torch.add(l1,l2), 2)\n",
    "\n",
    "        # for the first epoch with no l0\n",
    "        if it == 0:\n",
    "            l01 = l1.data  \n",
    "            l02 = l2.data\n",
    "        \n",
    "        opt1.zero_grad()\n",
    "        \n",
    "        loss.backward(retain_graph=True)   \n",
    "        \n",
    "        # Getting gradients of the first layers of each tower and calculate their l2-norm \n",
    "        param = list(MTL.parameters())\n",
    "        G1R = torch.autograd.grad(l1, param[0], retain_graph=True, create_graph=True)\n",
    "        G1 = torch.norm(G1R[0], 2)\n",
    "        G2R = torch.autograd.grad(l2, param[0], retain_graph=True, create_graph=True)\n",
    "        G2 = torch.norm(G2R[0], 2)\n",
    "        G_avg = torch.div(torch.add(G1, G2), 2)\n",
    "        \n",
    "        # Calculating relative losses \n",
    "        lhat1 = torch.div(l1,l01)\n",
    "        lhat2 = torch.div(l2,l02)\n",
    "        lhat_avg = torch.div(torch.add(lhat1, lhat2), 2)\n",
    "        \n",
    "        # Calculating relative inverse training rates for tasks \n",
    "        inv_rate1 = torch.div(lhat1,lhat_avg)\n",
    "        inv_rate2 = torch.div(lhat2,lhat_avg)\n",
    "        \n",
    "        # Calculating the constant target for Eq. 2 in the GradNorm paper\n",
    "        C1 = G_avg*(inv_rate1)**alph\n",
    "        C2 = G_avg*(inv_rate2)**alph\n",
    "        C1 = C1.detach()\n",
    "        C2 = C2.detach()\n",
    "        \n",
    "        opt2.zero_grad()\n",
    "        # Calculating the gradient loss according to Eq. 2 in the GradNorm paper\n",
    "        Lgrad = torch.add(Gradloss(G1, C1),Gradloss(G2, C2))\n",
    "        Lgrad.backward()\n",
    "        \n",
    "        # Updating loss weights \n",
    "        opt2.step()\n",
    "\n",
    "        # Updating the model weights\n",
    "        opt1.step()\n",
    "\n",
    "        # Renormalizing the losses weights\n",
    "        coef = 2/torch.add(Weightloss1, Weightloss2)\n",
    "        params = [coef*Weightloss1, coef*Weightloss2]\n",
    "        #print(\"Weights are:\",Weightloss1, Weightloss2)\n",
    "        #print(\"params are:\", params)\n",
    "        epoch_cost = epoch_cost + (loss / num_minibatches)\n",
    "        epoch_cost1 = epoch_cost1 + (l1 / num_minibatches)\n",
    "        epoch_cost2 = epoch_cost2 + (l2 / num_minibatches)\n",
    "        \n",
    "    costtr.append(torch.mean(epoch_cost))\n",
    "    cost1tr.append(torch.mean(epoch_cost1))\n",
    "    cost2tr.append(torch.mean(epoch_cost2))\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        MTL.eval()\n",
    "        Yhat1D, Yhat2D = MTL(X_valid)\n",
    "        l1D = params[0]*loss_func(Yhat1D, Y1_valid.view(-1,1))\n",
    "        l2D = params[1]*loss_func(Yhat2D, Y2_valid.view(-1,1))\n",
    "        cost1D.append(l1D)\n",
    "        cost2D.append(l2D)\n",
    "        costD.append(torch.div(torch.add(l1D,l2D),2))\n",
    "        print('Iter-{}; MTL loss: {:.4}'.format(it, loss.item()))\n",
    "        #print('Iter-{}; Grad loss: {:.4}'.format(it, Lgrad.item()))\n",
    "    \n",
    "plt.plot(np.squeeze(costtr),'-r',np.squeeze(costD), '-b')\n",
    "plt.ylabel('total cost')\n",
    "plt.xlabel('iterations')\n",
    "plt.show() \n",
    "\n",
    "plt.plot(np.squeeze(cost1tr),'-r', np.squeeze(cost1D), '-b')\n",
    "plt.ylabel('task 1 cost')\n",
    "plt.xlabel('iterations')\n",
    "plt.show() \n",
    "\n",
    "plt.plot(np.squeeze(cost2tr),'-r', np.squeeze(cost2D),'-b')\n",
    "plt.ylabel('task 2 cost')\n",
    "plt.xlabel('iterations')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[tensor([1.0002], grad_fn=<ThMulBackward>), tensor([0.9998], grad_fn=<ThMulBackward>)]\n"
     ]
    }
   ],
   "source": [
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}