Apply 4-class Model To Test and Real Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applying 4-class Model to Test and Real Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "### python packages\n",
    "import os\n",
    "from os import path\n",
    "import numpy as np\n",
    "import glob as glob\n",
    "from random import random\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import time\n",
    "\n",
    "### torch packages\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data.sampler import Sampler\n",
    "\n",
    "### sklearn packages\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import average_precision_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.model_selection import KFold\n",
    "\n",
    "\n",
    "### remove these later (for notebook version only)\n",
    "'''\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "from bokeh.plotting import figure\n",
    "from bokeh.io import output_notebook, show, export_png\n",
    "from bokeh.layouts import row\n",
    "output_notebook()\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "'''\n",
    "\n",
    "torch.cuda.manual_seed(42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def GetSimData(file):\n",
    "\n",
    "    ### grab local and global views\n",
    "    data_global = np.nan_to_num(np.load(file.replace('_info2.npy','_glob.npy'),encoding='latin1'))\n",
    "    data_local = np.nan_to_num(np.load(file.replace('_info2.npy','_loc.npy'),encoding='latin1'))\n",
    "\n",
    "    ### grab centroid views\n",
    "    data_global_cen = data_global[:,1][np.newaxis,:]\n",
    "    data_local_cen = data_local[:,1][np.newaxis,:]\n",
    "\n",
    "    data_global = data_global[:,0][np.newaxis,:]\n",
    "    data_local = data_local[:,0][np.newaxis,:]\n",
    "\n",
    "    ### info file contains: [0]kic, [1]tce, [2]period, [3]epoch, [4]duration, [5]label)\n",
    "    data_info = np.load(file,encoding='latin1')\n",
    "    #np.load(self.flist_info[idx],encoding='latin1')\n",
    "\n",
    "    if data_info[6]=='PL':\n",
    "        label=1\n",
    "    elif data_info[6]=='UNK':\n",
    "        label=0\n",
    "    elif data_info[6]=='EB':\n",
    "        label=2\n",
    "    else:\n",
    "        label=3\n",
    "\n",
    "    #collist=['TPERIOD','TDUR','DRRATIO','NTRANS','TSNR','TDEPTH','INDUR',\n",
    "    #         'SESMES_LOG_RATIO','PRAD_LOG_RATIO','TDUR_LOG_RATIO','RADRATIO','IMPACT',\n",
    "    #         'TESSMAG','RADIUS','PMTOTAL','LOGG','MH','TEFF']#from bls search, derived from transit model, from starpars\n",
    "    stelpars=np.nan_to_num(np.hstack((data_info[7:13].astype(float),data_info[-18:-6].astype(float))))[np.newaxis,:]\n",
    "\n",
    "    return (data_local.astype(float), data_global.astype(float), data_local_cen.astype(float), data_global_cen.astype(float), stelpars), label\n",
    "\n",
    "def GetRealData(file):\n",
    "    ### grab local and global views\n",
    "    data_global = np.nan_to_num(np.load(file.replace('_info2.npy','_glob.npy'),encoding='latin1'))\n",
    "    data_local = np.nan_to_num(np.load(file.replace('_info2.npy','_loc.npy'),encoding='latin1'))\n",
    "\n",
    "    ### grab centroid views\n",
    "    data_global_cen = data_global[:,1][np.newaxis,:]\n",
    "    data_local_cen = data_local[:,1][np.newaxis,:]\n",
    "\n",
    "    data_global = data_global[:,0][np.newaxis,:]\n",
    "    data_local = data_local[:,0][np.newaxis,:]\n",
    "\n",
    "    ### info file contains: [0]kic, [1]tce, [2]period, [3]epoch, [4]duration, [5]label)\n",
    "    data_info = np.load(file,encoding='latin1')\n",
    "    #np.load(self.flist_info[idx],encoding='latin1')\n",
    "\n",
    "    #collist=['TPERIOD','TDUR','DRRATIO','NTRANS','TSNR','TDEPTH','INDUR',\n",
    "    #         'SESMES_LOG_RATIO','PRAD_LOG_RATIO','TDUR_LOG_RATIO','RADRATIO','IMPACT',\n",
    "    #         'TESSMAG','RADIUS','PMTOTAL','LOGG','MH','TEFF']#from bls search, derived from transit model, from starpars\n",
    "    newixs=np.array([16, 24, 17, 30, 31, 21])\n",
    "    stelpars=np.nan_to_num(np.hstack((data_info[newixs].astype(float),data_info[-18:-6].astype(float))))[np.newaxis,:]\n",
    "\n",
    "    return (data_local.astype(float), data_global.astype(float), data_local_cen.astype(float), data_global_cen.astype(float), stelpars), np.nan\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "   \n",
    "class Model(nn.Module):\n",
    "\n",
    "    '''\n",
    "    \n",
    "    PURPOSE: DEFINE EXTRANET MODEL ARCHITECTURE\n",
    "    INPUT: GLOBAL + LOCAL LIGHT CURVES AND CENTROID CURVES, STELLAR PARAMETERS\n",
    "    OUTPUT: BINARY CLASSIFIER\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    def __init__(self):\n",
    "\n",
    "        ### initialize model\n",
    "        super(Model, self).__init__()\n",
    "\n",
    "        ### define global convolutional lalyer\n",
    "        self.fc_global = nn.Sequential(\n",
    "            nn.Conv1d(2, 16, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(16, 16, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(5, stride=2),\n",
    "            nn.Conv1d(16, 32, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(32, 32, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(5, stride=2),\n",
    "            nn.Conv1d(32, 64, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(64, 64, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(5, stride=2),\n",
    "            nn.Conv1d(64, 128, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(128, 128, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(5, stride=2),\n",
    "            nn.Conv1d(128, 256, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(256, 256, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(5, stride=2),\n",
    "        )\n",
    "\n",
    "        ### define local convolutional lalyer\n",
    "        self.fc_local = nn.Sequential(\n",
    "            nn.Conv1d(2, 16, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(16, 16, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(7, stride=2),\n",
    "            nn.Conv1d(16, 32, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv1d(32, 32, 5, stride=1, padding=2),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool1d(7, stride=2),\n",
    "        )\n",
    "\n",
    "        ### define fully connected layer that combines both views\n",
    "        self.final_layer = nn.Sequential(\n",
    "            nn.Linear(7858, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 256),\n",
    "            nn.ReLU(),\n",
    "            ### need output of 1 because using BCE for loss\n",
    "            nn.Linear(256, 4),\n",
    "            nn.Softmax(1))\n",
    "\n",
    "    def forward(self, x_local, x_local_cen, x_global, x_global_cen, x_star):\n",
    "        \n",
    "        x_local_all = torch.cat([x_local, x_local_cen], dim=1)\n",
    "        x_global_all = torch.cat([x_global, x_global_cen], dim=1)\n",
    "\n",
    "        ### get outputs of global and local convolutional layers\n",
    "        out_global = self.fc_global(x_global_all)\n",
    "        out_local = self.fc_local(x_local_all)\n",
    "        \n",
    "        ### flattening outputs (multi-dim tensor) from convolutional layers into vector\n",
    "        out_global = out_global.view(out_global.shape[0], -1)\n",
    "        out_local = out_local.view(out_local.shape[0], -1)\n",
    "\n",
    "        ### join two outputs together\n",
    "        out = torch.cat([out_global, out_local, x_star.squeeze(1)], dim=1)\n",
    "        out = self.final_layer(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_one_hot(labels, C=2):\n",
    "    '''\n",
    "    Converts an integer label torch.autograd.Variable to a one-hot Variable.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    labels : torch.autograd.Variable of torch.cuda.LongTensor\n",
    "        N x 1 x H x W, where N is batch size. \n",
    "        Each value is an integer representing correct classification.\n",
    "    C : integer. \n",
    "        number of classes in labels.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    target : torch.autograd.Variable of torch.cuda.FloatTensor\n",
    "        N x C x H x W, where C is class number. One-hot encoded.\n",
    "    '''\n",
    "    if type(labels)==list or type(labels)==np.ndarray:\n",
    "        target=np.zeros((len(labels),C))\n",
    "        target[np.arange(len(labels)), np.array(labels).astype(int)] = 1\n",
    "    else:\n",
    "        one_hot = torch.cuda.FloatTensor(labels.size(0), C, labels.size(2), labels.size(3)).zero_()\n",
    "        target = one_hot.scatter_(1, labels.data, 1)\n",
    "\n",
    "        target = Variable(target)\n",
    "        \n",
    "    return target\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "allmodels={}\n",
    "for k in range(8):\n",
    "    foldname    = \"/home/hosborn/TESS/final_runs/exonet_multiclass4_CV_globcents3b_k8\"\n",
    "    savename    = \"exonet_CV_\"+str(k)+\".8_101_all_Big\"\n",
    "    savedicname = \"exonet_multiclass4_CV_globcents3b_k8_dic\"\n",
    "    mod         = \"Big\"\n",
    "    aug         = \"all\"\n",
    "    fpath       = \"101\"\n",
    "    kcount      = \"0\"\n",
    "    #cont       = False\n",
    "\n",
    "    #Assigning a GPU:\n",
    "    os.environ['CUDA_VISIBLE_DEVICES'] = \"0\"\n",
    "\n",
    "    allmodels[k]=Model().cuda()\n",
    "    lr = 2.05e-5\n",
    "\n",
    "    optimizer = torch.optim.Adam(allmodels[k].parameters(), lr=lr)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    batch_size = 64\n",
    "    n_epochs = 700\n",
    "    \n",
    "    allmodels[k].load_state_dict(torch.load(path.join(foldname,savename.replace('_comp','')+'_temp.pth')))\n",
    "    \n",
    "    '''\n",
    "    print(savename,\"Loading datasets\")\n",
    "    kepler_val_data = KeplerDataLoaderCrossVal(infofiles=pickle.load(open(path.join(foldname,savename+'_valfiles.pickle'),'rb')))\n",
    "    kepler_train_data = KeplerDataLoaderCrossVal(infofiles=pickle.load(open(path.join(foldname,savename+'_trainfiles.pickle'),'rb')))\n",
    "    kepler_batch_sampler = pickle.load(open(path.join(foldname,savename+'_BBS.pickle'),'rb'))\n",
    "    kepler_data_loader = DataLoader(kepler_train_data, batch_sampler = kepler_batch_sampler, num_workers=4)\n",
    "    kepler_val_loader = DataLoader(kepler_val_data, batch_size=batch_size, shuffle=False, num_workers=4)\n",
    "    '''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = SimDataLoaderCrossVal(infofiles=glob.glob('/home/hosborn/TESS/processed_dv_101_centfixed2/test/*info2.npy'))\n",
    "test_data_loader = DataLoader(test_data, batch_size=batch_size, num_workers=4)\n",
    "\n",
    "#nan_data = SimDataLoaderCrossVal(infofiles=glob.glob('/home/hosborn/TESS/processed_dv_101_centfixed2/nans/*info2.npy'))\n",
    "#nan_data_loader = DataLoader(nan_data, batch_size=batch_size, num_workers=4)\n",
    "\n",
    "real_data = RealDataLoaderCrossVal(infofiles=glob.glob('/home/hosborn/TESS/Processed_RealDat_2/*info2.npy'))\n",
    "real_data_loader = DataLoader(real_data, batch_size=batch_size,num_workers=4)\n",
    "\n",
    "real_nan_data = RealDataLoaderCrossVal(infofiles=glob.glob('/home/hosborn/TESS/Processed_RealDat_2/nans/*info2.npy'))\n",
    "real_nan_data_loader = DataLoader(real_nan_data, batch_size=batch_size, num_workers=4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AP: [0.9784861  0.94486492 0.94663112 0.91748077]  average: 0.9632202029806928\n"
     ]
    }
   ],
   "source": [
    "dataloaders={'test':glob.glob('/home/hosborn/TESS/processed_dv_101_centfixed2/test/*info2.npy'),\n",
    "             'real':glob.glob('/home/hosborn/TESS/Processed_RealDat_2/*info2.npy'),\n",
    "             'real_nan':glob.glob('/home/hosborn/TESS/Processed_RealDat_2/nans/*info2.npy')}#,'nan':nan_data_loader\n",
    "model_output={}\n",
    "\n",
    "labels=['UNK','PL','EB','BEB']\n",
    "nclasses=4\n",
    "\n",
    "for data_loader in dataloaders:\n",
    "    model_output[data_loader]=pd.DataFrame()\n",
    "    \n",
    "    for file in dataloaders[data_loader]:\n",
    "        if data_loader=='test':\n",
    "            x_data, ys = GetSimData(file)\n",
    "        else:\n",
    "            x_data, ys = GetRealData(file)\n",
    "\n",
    "        ### get local view, global view, and label for training\n",
    "        x_local, x_global, x_local_cent,x_global_cent, x_star = x_data\n",
    "\n",
    "        x_local = Variable(torch.from_numpy(x_local)).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_local_cent = Variable(torch.from_numpy(x_local_cent)).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_global = Variable(torch.from_numpy(x_global)).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_global_cent = Variable(torch.from_numpy(x_global_cent)).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_star = Variable(torch.from_numpy(x_star)).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        \n",
    "        preds={}\n",
    "        for k in allmodels:\n",
    "            ### Looping through each model to predict:\n",
    "            modout=allmodels[k](x_local, x_local_cent, x_global, x_global_cent, x_star).cpu().detach().numpy().ravel()\n",
    "            \n",
    "            preds.update({labels[n]+'_'+str(k):modout[n] for n in range(nclasses)})\n",
    "        if data_loader is 'test':\n",
    "            preds['gt']=ys\n",
    "        model_output[data_loader] = model_output[data_loader].append(pd.Series(preds,name=file.split('/')[-1][:18]))\n",
    "    for n in range(nclasses):\n",
    "        allks=model_output[data_loader][[labels[n]+'_'+str(k) for k in range(8)]].values\n",
    "        model_output[data_loader][labels[n]+'_med'] = np.nanmedian(allks,axis=1)\n",
    "        model_output[data_loader][labels[n]+'_av'] = np.average(allks,axis=1)\n",
    "    if data_loader is 'test':\n",
    "        medvals=model_output['test'][[labels[nl]+'_med' for nl in range(nclasses)]].values\n",
    "        avvals=model_output['test'][[labels[nl]+'_av' for nl in range(nclasses)]].values\n",
    "        onehot=make_one_hot(model_output['test']['gt'].values,nclasses)\n",
    "        print(\"AP: average:\",average_precision_score(onehot,avallks,average='micro'))\n",
    "        for n in range(nclasses):\n",
    "            medvals=model_output['test'][[labels[nl]+'_med' for nl in range(nclasses)]].values\n",
    "            avvals=model_output['test'][[labels[nl]+'_av' for nl in range(nclasses)]].values\n",
    "            #print(labels[n],\"MED accuracy:\",np.sum((np.argmax(medvals,axis=1)==n)*onehot[:,n].astype(bool))/np.sum(np.argmax(medvals,axis=1)==n))\n",
    "            #print(labels[n],\"MED recall:\",np.sum((np.argmax(medvals,axis=1)==n)*onehot[:,n].astype(bool))/np.sum(onehot[:,n]))\n",
    "            #print(labels[n],\"MED A.P.:\", average_precision_score(onehot,medvals,average=None)[n])\n",
    "            print(labels[n],\" AV accuracy:\",np.sum((np.argmax(avvals,axis=1)==n)*onehot[:,n].astype(bool))/np.sum(np.argmax(avvals,axis=1)==n))\n",
    "            print(labels[n],\" AV recall:\",np.sum((np.argmax(avvals,axis=1)==n)*onehot[:,n].astype(bool))/np.sum(onehot[:,n]))\n",
    "            print(labels[n],\" AV A.P.:\", average_precision_score(onehot,avvals,average=None)[n])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(model_output,open('4classmod.pickle','wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AP: average: 0.9632202029806928\n",
      "UNK  AV accuracy: 0.9463452566096423\n",
      "UNK  AV recall: 0.9545098039215686\n",
      "UNK  AV A.P.: 0.9784861020935041\n",
      "PL  AV accuracy: 0.890625\n",
      "PL  AV recall: 0.8883116883116883\n",
      "PL  AV A.P.: 0.9448649150724617\n",
      "EB  AV accuracy: 0.8743169398907104\n",
      "EB  AV recall: 0.9169054441260746\n",
      "EB  AV A.P.: 0.9466311234826916\n",
      "BEB  AV accuracy: 0.8850931677018633\n",
      "BEB  AV recall: 0.8166189111747851\n",
      "BEB  AV A.P.: 0.9174807699755355\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x1800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "%matplotlib inline\n",
    "%config IPython.matplotlib.backend = \"retina\"\n",
    "from matplotlib import rcParams\n",
    "rcParams[\"savefig.dpi\"] = 300\n",
    "rcParams[\"figure.dpi\"] = 300\n",
    "\n",
    "plt.figure(figsize=(6,6))\n",
    "\n",
    "labels=['UNK','PL','EB','BEB']\n",
    "one_hot_gt=make_one_hot(model_output['test']['gt'].values,nclasses)\n",
    "### plot values\n",
    "for n in range(nclasses):\n",
    "    P, R, _ =precision_recall_curve(one_hot_gt[:,n],medvals[:,n])\n",
    "    steps=plt.step(R, P,label=labels[n]+'_Med',linewidth=2.5,alpha=0.75)\n",
    "    P, R, _ =precision_recall_curve(one_hot_gt[:,n],avvals[:,n])\n",
    "    plt.step(R, P,label=labels[n]+'_Av',linewidth=2.5,linestyle='--',color=steps[0].get_color(),alpha=0.75)\n",
    "plt.legend()\n",
    "plt.xlim(0.0,1.05)\n",
    "plt.ylim(0.2,1.05)\n",
    "plt.xlabel('Recall')\n",
    "plt.ylabel('Precision')\n",
    "savefile='4class_ensemble_testdat_avmedcomp'\n",
    "plt.savefig(path.join('/home/hosborn/TESS/PaperFigures',savefile+'_PR.png'))\n",
    "plt.savefig(path.join('/home/hosborn/TESS/PaperFigures',savefile+'_PR.pdf'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AP: [0.96226211 0.90032044 0.90142705 0.85852318]  average: 0.9337383322740341\n"
     ]
    }
   ],
   "source": [
    "dataloaders={'test':test_data_loader,'real':real_data_loader,'real_nan':real_nan_data_loader}#,'nan':nan_data_loader\n",
    "model_output={}\n",
    "for data_loader in dataloaders:\n",
    "    model_output[data_loader]={}\n",
    "    if data_loader is 'test':\n",
    "        gt=np.zeros(4)\n",
    "\n",
    "    for k in range(8):\n",
    "        model_output[data_loader][k]=np.zeros((4,4))\n",
    "\n",
    "    for x_data, ys in dataloaders[data_loader]:\n",
    "\n",
    "        ### get local view, global view, and label for training\n",
    "        x_local, x_global, x_local_cent,x_global_cent, x_star = x_data\n",
    "\n",
    "        x_local = Variable(x_local).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_local_cent = Variable(x_local_cent).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_global = Variable(x_global).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_global_cent = Variable(x_global_cent).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "        x_star = Variable(x_star).type(torch.FloatTensor).cuda().unsqueeze(1)\n",
    "\n",
    "        for k in allmodels:\n",
    "            ### Looping through each model to predict:\n",
    "            pred=allmodels[k](x_local, x_local_cent, x_global, x_global_cent, x_star)\n",
    "            model_output[data_loader][k] = np.vstack((model_output[data_loader][k],pred.cpu().detach().numpy()))\n",
    "        if data_loader is 'test':\n",
    "            gt=np.hstack((gt,ys))\n",
    "\n",
    "    allpreds=[]\n",
    "    for k in model_output[data_loader]:\n",
    "        model_output[data_loader][k]=model_output[data_loader][k][4:]\n",
    "        allpreds+=[model_output[data_loader][k]]\n",
    "    allpreds=np.dstack((allpreds))\n",
    "    model_output[data_loader]['med']=np.nanmedian(allpreds,axis=2)\n",
    "    model_output[data_loader]['av']=np.average(allpreds,axis=2)\n",
    "    if data_loader is 'test':\n",
    "        gt=gt[4:]\n",
    "        print(\"AP:\",average_precision_score(make_one_hot(gt,4),model_output[data_loader]['av'],average=None)\n",
    "              ,\" average:\",average_precision_score(make_one_hot(gt,4),model_output[data_loader]['av'],average='micro'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "onehot=make_one_hot(gt,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 recall: 0.9325490196078431\n",
      "0 accuracy: 0.9512\n",
      "1 recall: 0.9012987012987013\n",
      "1 accuracy: 0.8631840796019901\n",
      "2 recall: 0.8853868194842407\n",
      "2 accuracy: 0.8373983739837398\n",
      "3 recall: 0.7994269340974212\n",
      "3 accuracy: 0.827893175074184\n"
     ]
    }
   ],
   "source": [
    "for n in range(4):\n",
    "    print(n,\"AV recall:\",np.sum((np.argmax(model_output['test']['av'],axis=1)==n)*onehot[:,n].astype(bool))/np.sum(onehot[:,n]))\n",
    "    print(n,\"MED recall:\",np.sum((np.argmax(model_output['test']['med'],axis=1)==n)*onehot[:,n].astype(bool))/np.sum(onehot[:,n]))\n",
    "    print(n,\"AV accuracy:\",np.sum((np.argmax(model_output['test']['av'],axis=1)==n)*onehot[:,n].astype(bool))/np.sum(np.argmax(model_output['test']['av'],axis=1)==n))\n",
    "    print(n,\"MED accuracy:\",np.sum((np.argmax(model_output['test']['med'],axis=1)==n)*onehot[:,n].astype(bool))/np.sum(np.argmax(model_output['test']['av'],axis=1)==n))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('model_gt.npy',gt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2197"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(model_output[data_loader]['av'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2358"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(gt)"
   ]
  },
  {
   "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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(model_output,open('4classmod.pickle','wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('real_nan_idlist4.npy',real_nan_data.ids)\n",
    "np.save('real_idlist4.npy',real_data.ids)"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}