distances.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle as pkl\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "# y = np.array([1, 1, 2, 2])\n",
    "# pred = np.array([0.1, 0.4, 0.35, 0.8])\n",
    "# fpr, tpr, thresholds = metrics.roc_curve(y, pred, pos_label=2)\n",
    "# metrics.auc(fpr, tpr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats # gaussian_kde"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"x_defender.pickle\", \"rb\") as f:\n",
    "    x_defender = pkl.load(f)\n",
    "    \n",
    "with open(\"x_reserve.pickle\", \"rb\") as f:\n",
    "    x_reserve = pkl.load(f)\n",
    "    \n",
    "with open(\"y_defender.pickle\", \"rb\") as f:\n",
    "    y_defender = pkl.load(f)\n",
    "    \n",
    "with open(\"y_reserve.pickle\", \"rb\") as f:\n",
    "    y_reserve = pkl.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"nn_dict.pickle\", 'rb') as f:\n",
    "  dump_dict = pkl.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['W1_early', 'W10_early', 'W2_early', 'W20_early', 'W1star', 'W10star', 'W2star', 'W20star', 'W1_last', 'W10_last', 'W2_last', 'W20_last', 'EPOCHS', 'norms', 'trng_loss', 'test_loss', 'best_ind'])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dump_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1_early is shape: (512, 128)\n",
      "W10_early is shape: (128,)\n",
      "W2_early is shape: (128, 10)\n",
      "W20_early is shape: (10,)\n",
      "W1star is shape: (512, 128)\n",
      "W10star is shape: (128,)\n",
      "W2star is shape: (128, 10)\n",
      "W20star is shape: (10,)\n",
      "W1_last is shape: (512, 128)\n",
      "W10_last is shape: (128,)\n",
      "W2_last is shape: (128, 10)\n",
      "W20_last is shape: (10,)\n",
      "norms is shape: (10010,)\n",
      "trng_loss is shape: (1001,)\n",
      "test_loss is shape: (1001,)\n"
     ]
    }
   ],
   "source": [
    "for k,v in dump_dict.items():\n",
    "    if type(v) is np.ndarray:\n",
    "        print(f\"{k} is shape: {v.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Norm of Gradient')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(dump_dict['norms']) # plot norms of gradients\n",
    "plt.xlabel('Iteration', fontsize=16)\n",
    "plt.ylabel('Norm of Gradient', fontsize=16)\n",
    "#plt.savefig('grad_norm.pdf')\n",
    "#plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Loss')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i_axis = np.arange(dump_dict['EPOCHS']) # abscissa for plots of loss & accuracy\n",
    "\n",
    "# plot loss each epoch\n",
    "loss_min = min(min(dump_dict['trng_loss']),\n",
    "               min(dump_dict['test_loss'])\n",
    "               ) # min of vertical dashed line\n",
    "loss_max = max(max(dump_dict['trng_loss']),\n",
    "               max(dump_dict['test_loss'])\n",
    "               ) # max of vertical dashed line\n",
    "\n",
    "plt.plot(i_axis, dump_dict['trng_loss'], 'b--', label='Train') # plot loss\n",
    "plt.plot(i_axis, dump_dict['test_loss'], 'r--', label='Test')\n",
    "plt.plot((240+dump_dict['best_ind'], 240+dump_dict['best_ind']), (loss_min, loss_max), 'g--')\n",
    "plt.legend()\n",
    "plt.xlabel('Epoch', fontsize=16)\n",
    "plt.ylabel('Loss', fontsize=16)\n",
    "#plt.savefig('loss.pdf')\n",
    "#plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining my activation functions\n",
    "def relu(x):\n",
    "    '''the Relu activation function'''\n",
    "    return np.maximum(0,x)\n",
    "\n",
    "def softmax(x):\n",
    "    '''the softmax activation function applied to each column'''\n",
    "    temp = x - np.amax(x, axis=0, keepdims=True) # to avoid overflow\n",
    "    # softmax(z_k) = exp(z_k)/sum_k' {exp(z_k')}\n",
    "    return np.exp(temp)/np.sum(np.exp(temp), axis=0, keepdims=True)\n",
    "  \n",
    "def cross_ent1(p, q):\n",
    "  \n",
    "    return -1*(p * np.log(q)).sum(axis=0)\n",
    "  \n",
    "def cross_ent2(p, xw):\n",
    "  \n",
    "    temp = np.log( np.sum( np.exp(xw), axis=0 ) ) - xw\n",
    "  \n",
    "    return np.sum( temp * p, axis=0 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "xw1 = np.random.randint(low=-9, high=10, size=(3,5))\n",
    "xw2 = np.random.randint(low=-9, high=10, size=(3,5))\n",
    "p1 = softmax(xw1)\n",
    "p2 = softmax(xw2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.21490858,  0.83540002, 12.56930832,  3.25163915, 12.76620116])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cross_ent1(p1, p2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.21490858,  0.83540002, 12.56930832,  3.25163915, 12.76620116])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cross_ent2(p1, xw2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(W1,W10,W2,W20):\n",
    "  \n",
    "    def f(x):\n",
    "        H1 = relu(np.tensordot(np.transpose(W1),x, axes=1) + W10)\n",
    "        XW = np.tensordot(np.transpose(W2),H1, axes=1) + W20\n",
    "        \n",
    "        return XW\n",
    "      \n",
    "    return f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad(W1,W10,W2,W20):\n",
    "  \n",
    "    N1, K = W2.shape\n",
    "    BATCH_SIZE = 1\n",
    "  \n",
    "    pdRelu1 = np.zeros((BATCH_SIZE, N1, N1)) # partial relu1(z)/partial z\n",
    "    pdSigma = np.zeros((BATCH_SIZE, K, K)) # partial softmax(z)/partial z\n",
    "  \n",
    "    def g(xbatch, ybatch):\n",
    "      \n",
    "        # FORWARD PROP\n",
    "        H1 = relu(np.tensordot(np.transpose(W1),xbatch, axes=1) + W10)\n",
    "        XW = np.tensordot(np.transpose(W2),H1, axes=1) + W20\n",
    "        Yhat = softmax(XW)\n",
    "      \n",
    "        # BACK PROP - compute the gradients, working backwards\n",
    "        gradYhat = -ybatch/Yhat # gradient of output\n",
    "\n",
    "        # partial softmax(z)/partial z\n",
    "        for b in range(BATCH_SIZE):\n",
    "            pdSigma[b,:,:] = np.matmul(\n",
    "                np.diag(Yhat[:,b]),\n",
    "                    np.identity(K) - Yhat[:,b]\n",
    "                    )\n",
    "\n",
    "        gradW2 = (\n",
    "            np.matmul(\n",
    "                np.matmul(\n",
    "                    np.expand_dims(np.transpose(H1),axis=2), # col vecs\n",
    "                    np.expand_dims(np.transpose(gradYhat),axis=1) # row vecs\n",
    "                    ), # outer product, effectively\n",
    "                pdSigma\n",
    "                )\n",
    "            )\n",
    "\n",
    "        gradW20 = (\n",
    "            np.matmul(\n",
    "                pdSigma,\n",
    "                np.expand_dims(np.transpose(gradYhat),axis=2), # col vecs\n",
    "                )\n",
    "            )\n",
    "\n",
    "        gradH1 = (\n",
    "            np.matmul(\n",
    "                W2,\n",
    "                np.matmul(\n",
    "                    pdSigma,\n",
    "                    np.expand_dims(np.transpose(gradYhat),axis=2), # col vecs\n",
    "                    )\n",
    "                )\n",
    "            )\n",
    "\n",
    "        # partial Relu(z)/partial z for H1\n",
    "        for b in range(BATCH_SIZE):\n",
    "            pdRelu1[b,:,:] = np.diag(np.sign(H1[:,b]))\n",
    "\n",
    "        gradW1 = (\n",
    "            np.matmul(\n",
    "                np.matmul(\n",
    "                    np.expand_dims(np.transpose(xbatch),axis=2), # col vecs\n",
    "                    np.swapaxes(gradH1,1,2) # row vecs\n",
    "                    ), # outer product, effectively\n",
    "                pdRelu1\n",
    "                )\n",
    "            )\n",
    "\n",
    "        gradW10 = (\n",
    "            np.matmul(\n",
    "                pdRelu1,\n",
    "                gradH1 # col vecs\n",
    "                )\n",
    "            )\n",
    "        \n",
    "        return gradW1, gradW10, gradW2, gradW20\n",
    "  \n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loss (-LCL)\n",
    "def loss(y, XW): \n",
    "  \n",
    "    L = (\n",
    "        -np.sum(np.transpose(y) *\n",
    "                (XW -\n",
    "                 np.log(\n",
    "                     np.sum(np.exp(XW),\n",
    "                            axis=0, \n",
    "                            keepdims=True\n",
    "                            )\n",
    "                     )\n",
    "                 )\n",
    "                )\n",
    "        )/XW.shape[1]\n",
    "    return L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# total accuracy\n",
    "def accuracy(y, XW):\n",
    "  \n",
    "    return np.sum(y == np.argmax(XW, axis=0))/XW.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shapes of weights and biases:\n",
      "(512, 128)\n",
      "(128, 1)\n",
      "(128, 10)\n",
      "(10, 1)\n",
      "\n",
      "\n",
      "Shapes of data:\n",
      "(512, 400)\n",
      "(512, 400)\n",
      "(10, 400)\n",
      "(10, 400)\n"
     ]
    }
   ],
   "source": [
    "W1_D = dump_dict['W1_last'].copy()\n",
    "W10_D = (dump_dict['W10_last'].copy())[:,None]\n",
    "W2_D = dump_dict['W2_last'].copy()\n",
    "W20_D = (dump_dict['W20_last'].copy())[:,None]\n",
    "\n",
    "N = 400\n",
    "x_D = np.transpose(x_defender[:N,:]) # each sample is stored as a column\n",
    "x_R = np.transpose(x_reserve[:N,:])\n",
    "y_D = np.transpose(y_defender[:N,:]) # each sample is stored as a column\n",
    "y_R = np.transpose(y_reserve[:N,:])\n",
    "\n",
    "print(\"Shapes of weights and biases:\")\n",
    "print(W1_D.shape)\n",
    "print(W10_D.shape)\n",
    "print(W2_D.shape)\n",
    "print(W20_D.shape)\n",
    "print(\"\\n\")\n",
    "print(\"Shapes of data:\")\n",
    "print(x_D.shape)\n",
    "print(x_R.shape)\n",
    "print(y_D.shape)\n",
    "print(y_R.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "M_D = model(W1_D,W10_D,W2_D,W20_D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(512, 800)\n",
      "(10, 800)\n",
      "(1, 800)\n"
     ]
    }
   ],
   "source": [
    "all_data = np.concatenate((x_D,x_R), axis=1)\n",
    "all_lbls = np.concatenate((y_D,y_R), axis=1)\n",
    "all_mem_lbls = np.concatenate( ( np.ones((1,N)), np.zeros((1,N)) ), axis=1 )\n",
    "print(all_data.shape)\n",
    "print(all_lbls.shape)\n",
    "print(all_mem_lbls.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 800)\n"
     ]
    }
   ],
   "source": [
    "M_D_XW_all = M_D(all_data)\n",
    "print(M_D_XW_all.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 800)\n"
     ]
    }
   ],
   "source": [
    "M_D_yhat_all = softmax(M_D_XW_all)\n",
    "print(M_D_yhat_all.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "M_D_grad = grad(W1_D,W10_D,W2_D,W20_D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(800, 512, 128)\n",
      "(800, 128, 1)\n",
      "(800, 128, 10)\n",
      "(800, 10, 1)\n"
     ]
    }
   ],
   "source": [
    "M_D_grad_all = M_D_grad(all_data, all_lbls)\n",
    "for g in M_D_grad_all:\n",
    "    print(g.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 800)\n"
     ]
    }
   ],
   "source": [
    "grad_all_norms = np.zeros((1,2*N))\n",
    "for i in range(2*N):\n",
    "    grad_all_norms[0,i] = np.sqrt(\n",
    "        np.sum((M_D_grad_all[0][i,:,:])**2) +\n",
    "        np.sum((M_D_grad_all[1][i,:,:])**2) +\n",
    "        np.sum((M_D_grad_all[2][i,:,:])**2) +\n",
    "        np.sum((M_D_grad_all[3][i,:,:])**2)\n",
    "    )\n",
    "print(grad_all_norms.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "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>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>4.000000e+02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.191745e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.945353e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>2.247666e-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>6.294145e-08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>4.385972e-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.484072e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>7.234369e+00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  0\n",
       "count  4.000000e+02\n",
       "mean   1.191745e+00\n",
       "std    1.945353e+00\n",
       "min    2.247666e-09\n",
       "25%    6.294145e-08\n",
       "50%    4.385972e-03\n",
       "75%    2.484072e+00\n",
       "max    7.234369e+00"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(grad_all_norms[:,:N].T).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>4.000000e+02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>4.854294e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>5.151783e+01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>2.291953e-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>7.203463e-08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>2.154456e-02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.863140e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.016057e+03</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  0\n",
       "count  4.000000e+02\n",
       "mean   4.854294e+00\n",
       "std    5.151783e+01\n",
       "min    2.291953e-09\n",
       "25%    7.203463e-08\n",
       "50%    2.154456e-02\n",
       "75%    2.863140e+00\n",
       "max    1.016057e+03"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(grad_all_norms[:,N:].T).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.54344375\n"
     ]
    }
   ],
   "source": [
    "auroc = metrics.roc_auc_score(all_mem_lbls[0,:], -1*grad_all_norms[0,:])\n",
    "print(auroc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5175\n"
     ]
    }
   ],
   "source": [
    "pair_accuracy = 0\n",
    "for i in range(N):\n",
    "    if grad_all_norms[0,i] < grad_all_norms[0,N+i]: pair_accuracy += 1/N\n",
    "print(pair_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "kde_D = stats.gaussian_kde(grad_all_norms[0,:N].T)\n",
    "kde_R = stats.gaussian_kde(grad_all_norms[0,:N].T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fa5febcafd0>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid = np.linspace(np.min(grad_all_norms), np.max(grad_all_norms), 50)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5,3))\n",
    "ax.plot(grid, kde_D(grid), c='r', label = \"D grad norms\")\n",
    "ax.plot(grid, kde_R(grid), c='b', label = \"R grad norms\")\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xylims = np.linspace(min(np.min(grad_all_norms[:,:N].T), np.min(grad_all_norms[:,:N].T)),\n",
    "                     max(np.max(grad_all_norms[:,:N].T), np.max(grad_all_norms[:,:N].T)))\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = plt.gca()\n",
    "ax.scatter(grad_all_norms[:,:N].T,grad_all_norms[:,N:].T, c='b', alpha=0.3)\n",
    "ax.plot(xylims,xylims, c='k', linestyle='--')\n",
    "ax.set_yscale('log')\n",
    "ax.set_xscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(800, 800, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "etas = [2e-7,2e-5,2e-3]\n",
    "all_distances = np.zeros((2*N,2*N,3,len(etas)))\n",
    "print(all_distances.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 0\n",
      "i = 80\n",
      "i = 160\n",
      "i = 240\n",
      "i = 320\n",
      "i = 400\n",
      "i = 480\n",
      "i = 560\n",
      "i = 640\n",
      "i = 720\n"
     ]
    }
   ],
   "source": [
    "for i in range(2*N):\n",
    "    for j, eta in enumerate(etas):\n",
    "        W1_i = W1_D + eta*M_D_grad_all[0][i,:,:]\n",
    "        W10_i = W10_D + eta*M_D_grad_all[1][i,:,:]\n",
    "        W2_i = W2_D + eta*M_D_grad_all[2][i,:,:]\n",
    "        W20_i = W20_D + eta*M_D_grad_all[3][i,:,:]\n",
    "        \n",
    "        M_i = model(W1_i,W10_i,W2_i,W20_i)\n",
    "        M_i_XW_all = M_i(all_data)\n",
    "        M_i_yhat_all = softmax(M_i_XW_all)\n",
    "        \n",
    "        # 2norm on predictions\n",
    "        all_distances[i,:,0,j] = np.linalg.norm(M_D_yhat_all - M_i_yhat_all, axis=0)\n",
    "        all_distances[i,:,1,j] = np.linalg.norm(M_D_XW_all - M_i_XW_all, axis=0)\n",
    "        all_distances[i,:,2,j] = cross_ent2(M_D_yhat_all, M_i_XW_all)\n",
    "        \n",
    "    if i % 80 == 0:\n",
    "        print(f\"i = {i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(800, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "dist_to_Mi_Ui = np.zeros((2*N,3,len(etas)))\n",
    "for i in range(2*N):\n",
    "    dist_to_Mi_Ui[i,:,:] = all_distances[i,i,:,:]\n",
    "print(dist_to_Mi_Ui.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For distance function 0:\n",
      "\tAUC for eta= 2e-07: 0.553625\n",
      "\tAUC for eta= 2e-05: 0.55345625\n",
      "\tAUC for eta= 2e-03: 0.55286875\n",
      "\n",
      "\n",
      "For distance function 1:\n",
      "\tAUC for eta= 2e-07: 0.5434312499999999\n",
      "\tAUC for eta= 2e-05: 0.543625\n",
      "\tAUC for eta= 2e-03: 0.5436749999999999\n",
      "\n",
      "\n",
      "For distance function 2:\n",
      "\tAUC for eta= 2e-07: 0.5767687499999999\n",
      "\tAUC for eta= 2e-05: 0.57690625\n",
      "\tAUC for eta= 2e-03: 0.5776249999999999\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(f\"For distance function {i}:\")\n",
    "    for j, eta in enumerate(etas):\n",
    "        auc = metrics.roc_auc_score(all_mem_lbls[0,:], -1*dist_to_Mi_Ui[:,i,j])\n",
    "        print(f\"\\tAUC for eta={eta: .0e}: {auc}\")\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(800, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "dist_to_Mi_all = np.mean(all_distances, axis=1)\n",
    "\n",
    "print(dist_to_Mi_all.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For distance function 0:\n",
      "\tAUC for eta= 2e-07: 0.5429875\n",
      "\tAUC for eta= 2e-05: 0.5430125\n",
      "\tAUC for eta= 2e-03: 0.5432875\n",
      "\n",
      "\n",
      "For distance function 1:\n",
      "\tAUC for eta= 2e-07: 0.54350625\n",
      "\tAUC for eta= 2e-05: 0.5435249999999999\n",
      "\tAUC for eta= 2e-03: 0.5435625\n",
      "\n",
      "\n",
      "For distance function 2:\n",
      "\tAUC for eta= 2e-07: 0.542975\n",
      "\tAUC for eta= 2e-05: 0.5485968749999999\n",
      "\tAUC for eta= 2e-03: 0.540209375\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(f\"For distance function {i}:\")\n",
    "    for j, eta in enumerate(etas):\n",
    "        auc = metrics.roc_auc_score(all_mem_lbls[0,:], -1*dist_to_Mi_all[:,i,j])\n",
    "        print(f\"\\tAUC for eta={eta: .0e}: {auc}\")\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Cross Entropy Loss of Prediction on Point')"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xylims = np.linspace(min(np.min(grad_all_norms[0,:]), np.min(dist_to_Mi_Ui[:,2,2])),\n",
    "                     max(np.max(grad_all_norms[0,:]), np.max(dist_to_Mi_Ui[:,2,2])))\n",
    "\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = plt.gca()\n",
    "ax.scatter(grad_all_norms[0,:N], dist_to_Mi_Ui[:N,2,2], c='r', alpha=0.1)\n",
    "ax.scatter(grad_all_norms[0,N:], dist_to_Mi_Ui[N:,2,2], c='b', alpha=0.1)\n",
    "ax.plot(xylims,xylims, c='k', linestyle='--')\n",
    "ax.set_yscale('log')\n",
    "ax.set_xscale('log')\n",
    "ax.set_xlabel(\"Norm of Gradient at Point\", fontsize=14)\n",
    "ax.set_ylabel(\"Cross Entropy Loss of Prediction on Point\", fontsize=14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:joe_env]",
   "language": "python",
   "name": "conda-env-joe_env-py"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}