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

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applying 3-class Model to Test and Real Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "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",
    "\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",
    "    else:\n",
    "        label=2\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": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "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, 3),\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\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "allmodels={}\n",
    "for k in range(8):\n",
    "    #INPUTS:\n",
    "    foldname    = \"/home/hosborn/TESS/final_runs/exonet_multiclass3_CV_globcents3b_k8\"\n",
    "    savename    = \"exonet_CV_\"+str(k)+\".8_101_all_Big\"\n",
    "    savedicname = \"exonet_multiclass3_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",
    "    allmodels[k].load_state_dict(torch.load(path.join(foldname,savename.replace('_comp','')+'_temp.pth')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = SimDataLoaderCrossVal(infofiles=)\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": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AP: average: 0.9711121403126206\n",
      "UNK MED accuracy: 0.9467501957713391\n",
      "UNK MED recall: 0.9482352941176471\n",
      "UNK MED A.P.: 0.9686431917317233\n",
      "UNK  AV accuracy: 0.9482758620689655\n",
      "UNK  AV recall: 0.9490196078431372\n",
      "UNK  AV A.P.: 0.9773092760006252\n",
      "PL MED accuracy: 0.9007832898172323\n",
      "PL MED recall: 0.8961038961038961\n",
      "PL MED A.P.: 0.9397033318605802\n",
      "PL  AV accuracy: 0.9036458333333334\n",
      "PL  AV recall: 0.9012987012987013\n",
      "PL  AV A.P.: 0.9457146336827876\n",
      "EB MED accuracy: 0.9512893982808023\n",
      "EB MED recall: 0.9512893982808023\n",
      "EB MED A.P.: 0.9574337104175915\n",
      "EB  AV accuracy: 0.9512893982808023\n",
      "EB  AV recall: 0.9512893982808023\n",
      "EB  AV A.P.: 0.9689583201448094\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=3\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[data_loader]['gt'].values,nclasses)\n",
    "        print(\"AP: average:\",average_precision_score(onehot,avallks,average='micro'))\n",
    "        for n in range(nclasses):\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": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(model_output,open('3classmod.pickle','wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AP: average: 0.9711121403126206\n",
      "UNK  AV accuracy: 0.9482758620689655\n",
      "UNK  AV recall: 0.9490196078431372\n",
      "UNK  AV A.P.: 0.9773092760006252\n",
      "PL  AV accuracy: 0.9036458333333334\n",
      "PL  AV recall: 0.9012987012987013\n",
      "PL  AV A.P.: 0.9457146336827876\n",
      "EB  AV accuracy: 0.9512893982808023\n",
      "EB  AV recall: 0.9512893982808023\n",
      "EB  AV A.P.: 0.9689583201448094\n"
     ]
    }
   ],
   "source": [
    "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",
    "    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": null,
   "metadata": {},
   "outputs": [],
   "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='3class_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": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "000358070970_00_02    1.0\n",
       "000248988932_00_04    0.0\n",
       "000269594275_00_04    2.0\n",
       "000220476100_00_01    0.0\n",
       "000260356202_01_99    2.0\n",
       "000372908550_16_03    0.0\n",
       "000266716027_00_04    0.0\n",
       "000279726530_06_99    2.0\n",
       "000237339895_00_02    0.0\n",
       "000234520087_01_99    2.0\n",
       "000183985164_01_03    2.0\n",
       "000266966948_00_01    0.0\n",
       "000360736543_00_01    1.0\n",
       "000183495016_03_99    0.0\n",
       "000349192028_05_01    2.0\n",
       "000123292130_00_04    1.0\n",
       "000267114952_02_03    2.0\n",
       "000150358991_03_02    1.0\n",
       "000260078169_06_99    1.0\n",
       "000033835925_00_01    0.0\n",
       "000261542169_01_99    2.0\n",
       "000031942864_00_01    0.0\n",
       "000259863095_00_01    2.0\n",
       "000220526640_02_02    2.0\n",
       "000220432563_00_99    0.0\n",
       "000425938854_04_03    2.0\n",
       "000050381881_08_02    2.0\n",
       "000144000467_00_02    1.0\n",
       "000277147381_02_01    2.0\n",
       "000294784092_00_99    0.0\n",
       "                     ... \n",
       "000401839949_02_04    2.0\n",
       "000010803257_00_04    2.0\n",
       "000219984873_02_03    1.0\n",
       "000220436792_00_01    0.0\n",
       "000421940749_00_02    0.0\n",
       "000373523595_04_03    2.0\n",
       "000346704136_00_01    1.0\n",
       "000167087044_00_99    0.0\n",
       "000358071448_07_99    1.0\n",
       "000099734092_00_02    0.0\n",
       "000280684074_00_99    0.0\n",
       "000389526738_00_02    2.0\n",
       "000254225031_00_01    0.0\n",
       "000142087340_05_99    2.0\n",
       "000270653253_00_03    2.0\n",
       "000260241844_00_03    0.0\n",
       "000220486445_00_02    1.0\n",
       "000030467930_01_01    0.0\n",
       "000277892347_00_99    0.0\n",
       "000142242260_00_04    0.0\n",
       "000355480246_02_03    0.0\n",
       "000214659001_00_02    0.0\n",
       "000141757441_01_03    0.0\n",
       "000219195044_02_03    2.0\n",
       "000092198963_01_04    0.0\n",
       "000410338728_00_01    0.0\n",
       "000340634544_00_01    0.0\n",
       "000039018622_02_99    0.0\n",
       "000248390204_00_04    0.0\n",
       "000358402977_00_99    0.0\n",
       "Name: gt, Length: 2358, dtype: float64"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_output['test']['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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "### grab local and global views\n",
    "data_global = np.nan_to_num(np.load('/home/hosborn/TESS/Processed_RealDat_2/000001129033_00_04_glob.npy',encoding='latin1'))\n",
    "data_local = np.nan_to_num(np.load('/home/hosborn/TESS/Processed_RealDat_2/000001129033_00_04_loc.npy',encoding='latin1'))\n",
    "\n",
    "### grab centroid views\n",
    "x_global_cent = data_global[:,1]\n",
    "x_local_cent = data_local[:,1][np.newaxis,:]\n",
    "\n",
    "x_global = data_global[:,0][np.newaxis,:]\n",
    "x_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('/home/hosborn/TESS/Processed_RealDat_2/000001129033_00_04_info2.npy',encoding='latin1')\n",
    "#np.load(self.flist_info[idx],encoding='latin1')\n",
    "\n",
    "label=np.nan\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",
    "\n",
    "x_star=np.nan_to_num(np.hstack((data_info[newixs].astype(float),data_info[-18:-6].astype(float))))[np.newaxis,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "W77=[]\n",
    "for k in allmodels:\n",
    "    pred=allmodels[k](x_local, x_local_cent, x_global, x_global_cent, x_star)\n",
    "    W77+=[pred.cpu().detach().numpy()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32),\n",
       " array([[1.2458412e-14, 1.0000000e+00, 1.2592762e-23]], dtype=float32)]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W77"
   ]
  },
  {
   "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": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(model_output,open('3classmod.pickle','wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('real_nan_idlist3.npy',real_nan_data.ids)\n",
    "np.save('real_idlist3.npy',real_data.ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "average_precision_score?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.04026753e-16, 1.00000000e+00, 3.36392283e-23],\n",
       "       [1.00000000e+00, 4.62603018e-32, 4.59011311e-19],\n",
       "       [1.35944629e-05, 1.94485413e-20, 9.99986410e-01],\n",
       "       [1.00000000e+00, 5.81212925e-11, 9.34402382e-12],\n",
       "       [3.87693632e-07, 5.12899892e-22, 9.99999642e-01],\n",
       "       [1.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n",
       "       [1.00000000e+00, 1.08231546e-09, 3.43416322e-13],\n",
       "       [1.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n",
       "       [1.00000000e+00, 0.00000000e+00, 5.74532370e-44],\n",
       "       [1.01939613e-05, 2.09248008e-17, 9.99989748e-01],\n",
       "       [3.25027304e-06, 1.25134565e-25, 9.99996781e-01],\n",
       "       [1.00000000e+00, 3.31933647e-10, 3.08426147e-15],\n",
       "       [2.97330960e-08, 1.00000000e+00, 1.65461330e-14],\n",
       "       [1.00000000e+00, 4.08566872e-16, 5.78681677e-12],\n",
       "       [1.49439719e-13, 8.98340809e-26, 1.00000000e+00],\n",
       "       [9.55515445e-10, 1.00000000e+00, 5.84007940e-14],\n",
       "       [2.59327239e-12, 1.35251816e-29, 1.00000000e+00],\n",
       "       [2.67890164e-06, 9.99997377e-01, 1.79443586e-16],\n",
       "       [1.00000000e+00, 0.00000000e+00, 3.06706208e-37],\n",
       "       [1.00000000e+00, 1.33557834e-14, 2.45515840e-19],\n",
       "       [5.53868227e-17, 8.11716148e-41, 1.00000000e+00],\n",
       "       [9.99995947e-01, 6.00564822e-17, 4.01366287e-06],\n",
       "       [5.24099141e-06, 2.33318234e-19, 9.99994755e-01],\n",
       "       [8.75102094e-15, 1.24192213e-21, 1.00000000e+00],\n",
       "       [1.00000000e+00, 3.93993993e-09, 3.21939642e-10],\n",
       "       [7.27343918e-09, 6.50720526e-14, 1.00000000e+00],\n",
       "       [3.69455526e-03, 1.71574029e-20, 9.96305466e-01],\n",
       "       [1.75656646e-06, 9.99998212e-01, 1.35509366e-20],\n",
       "       [1.61554965e-15, 8.90000844e-19, 1.00000000e+00],\n",
       "       [1.00000000e+00, 1.23354322e-18, 5.82228781e-20],\n",
       "       [1.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n",
       "       [1.00000000e+00, 2.23707204e-08, 1.39409234e-10],\n",
       "       [5.41061927e-05, 9.99945879e-01, 1.93022241e-20],\n",
       "       [7.23447954e-07, 6.96661560e-14, 9.99999285e-01],\n",
       "       [1.00000000e+00, 5.79936911e-27, 9.68751452e-26],\n",
       "       [9.91056694e-08, 2.91597420e-18, 9.99999881e-01],\n",
       "       [1.00406478e-12, 6.80544486e-18, 1.00000000e+00],\n",
       "       [1.00000000e+00, 4.03169710e-16, 1.71032415e-21],\n",
       "       [5.80539561e-10, 1.00000000e+00, 2.29851407e-17],\n",
       "       [9.98113751e-01, 1.88384375e-19, 1.88631122e-03],\n",
       "       [9.66951001e-16, 1.30185852e-32, 1.00000000e+00],\n",
       "       [2.00820257e-04, 3.87746240e-06, 9.99795377e-01],\n",
       "       [5.07042841e-07, 3.60911664e-28, 9.99999523e-01],\n",
       "       [1.21576253e-19, 1.00000000e+00, 1.51322874e-30],\n",
       "       [2.09806850e-21, 1.25843140e-30, 1.00000000e+00],\n",
       "       [1.00000000e+00, 1.04487947e-26, 9.48404902e-14],\n",
       "       [1.16281553e-08, 3.41081191e-10, 1.00000000e+00],\n",
       "       [9.99963641e-01, 3.63932013e-05, 7.95817058e-12],\n",
       "       [4.17265000e-10, 1.00000000e+00, 1.06701807e-17],\n",
       "       [6.01173937e-08, 1.28495694e-14, 9.99999881e-01],\n",
       "       [9.99999523e-01, 4.52816835e-07, 2.33937147e-10],\n",
       "       [4.38310828e-08, 1.00000000e+00, 1.83837004e-22],\n",
       "       [2.74891256e-08, 1.00000000e+00, 1.39941712e-15],\n",
       "       [1.85169299e-07, 2.29300282e-19, 9.99999762e-01],\n",
       "       [4.80876915e-05, 9.99951959e-01, 8.60047242e-11],\n",
       "       [1.00000000e+00, 2.61498502e-14, 9.43109975e-19],\n",
       "       [4.32696352e-16, 6.23277581e-24, 1.00000000e+00],\n",
       "       [1.00000000e+00, 5.70516898e-12, 3.28422798e-17],\n",
       "       [1.00000000e+00, 6.42125317e-19, 1.11547684e-18],\n",
       "       [1.00000000e+00, 1.92824127e-23, 3.64372549e-23],\n",
       "       [9.98616695e-01, 1.38332823e-03, 5.87633186e-13],\n",
       "       [1.00000000e+00, 1.28872546e-09, 9.85551996e-09],\n",
       "       [1.96964905e-07, 1.65470993e-07, 9.99999642e-01],\n",
       "       [3.07252357e-08, 1.02002356e-21, 1.00000000e+00]], dtype=float32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred.cpu().detach().numpy()"
   ]
  },
  {
   "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
}