calculate features-test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(action='once')\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pylab as plt\n",
    "import seaborn as sns\n",
    "import datetime\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "import pickle\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "from exp.misc import *\n",
    "from exp.ProcessData import *\n",
    "from exp.PytorchModels import *\n",
    "from exp.LearnerClass import *\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.utils.data as D\n",
    "import torch.nn.functional as F\n",
    "import copy\n",
    "from torchvision import transforms\n",
    "import PIL.Image\n",
    "from sklearn.metrics import roc_auc_score\n",
    "import torchvision.transforms.functional as TF\n",
    "from types import MethodType\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params=json_to_parameters('config.json')\n",
    "num_folds=3\n",
    "SEEDS=[220,432,8153]\n",
    "add_seed=2\n",
    "model_type='tf_efficientnet_b5_ns'\n",
    "name_tamplate='image_mlps_cut_128_seed_fullv{}'\n",
    "\n",
    "device = device_by_name('Tesla')\n",
    "\n",
    "torch.cuda.set_device(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df=pd.read_csv(params.path.data+'test.csv')\n",
    "prepare_df(test_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_metric(y_pred,y_true):\n",
    "    preds=torch.sigmoid(torch.tensor(y_pred[:,1],dtype=torch.float32)).numpy()\n",
    "    preds1=F.softmax(torch.tensor(y_pred,dtype=torch.float32),-1)[:,1].numpy()\n",
    "    preds2=0.5*preds1/preds1.std()+0.5*preds/preds.std()\n",
    "    return {'metric':-roc_auc_score(y_true[:,-1], preds1),'metric1':-roc_auc_score(y_true[:,-1], preds),\n",
    "                                                                'metric2':-roc_auc_score(y_true[:,-1], preds2)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyLoss():\n",
    "    def __init__(self,weight):\n",
    "        self.weight=weight\n",
    "    def __call__(self,y_pred,y_true):\n",
    "        return self.weight*F.binary_cross_entropy_with_logits(y_pred[:,1],y_true[:,1].to(torch.float32),weight=torch.tensor(1.,device=device))+\\\n",
    "               (1-self.weight)*F.cross_entropy(y_pred,y_true[:,0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform=transforms.Compose([HairTransform(1.0),transforms.RandomRotation(45),\n",
    "                              transforms.RandomHorizontalFlip(p=0.5),transforms.RandomVerticalFlip(p=0.5),\n",
    "                              transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.3, hue=0.1),\n",
    "                              transforms.RandomResizedCrop((600,900), scale=(0.7, 1.1)),\n",
    "                              transforms.ToTensor(),CutoutTransform(0.5,24,fill_const=False),\n",
    "                              CutoutTransform(0.5,16,fill_const=False)])\n",
    "\n",
    "transform_val=transforms.Compose([transforms.ToTensor()])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ds=ImageDataset(params.path.test_jpg_small,test_df,transform=transform,meta_aug=0.1)\n",
    "for SEED in SEEDS:\n",
    "    for fold in range(num_folds): \n",
    "        torch.manual_seed(SEED+fold+add_seed)\n",
    "        np.random.seed(SEED+fold+add_seed)\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        model = get_model(model_type,8,extra=[8,8,[7,32]],mid_extra=128,mlps=[1024,256],dropout=0.4,bn=True).to(device)\n",
    "        name=params.model_format.format(model_type,f'image_mlps_cut_128_seed_fullv_large{SEED}',1,fold)\n",
    "        print (name)\n",
    "        my_loss=MyLoss(0.9)\n",
    "        #my_loss=my_one_loss\n",
    "        learner = Learner(model,None,loss_func=my_loss,name=name,scheduler=None,device=device)\n",
    "        learner.load_model(params.path.models)\n",
    "        learner.init_amp()\n",
    "        learner.model.last_linear=Noop()\n",
    "        def new_get_x(self,batch):\n",
    "            return batch\n",
    "        learner.get_x=MethodType(new_get_x, learner)\n",
    "        featuress=[]\n",
    "        for i in notebook.tqdm(range(16)):\n",
    "            features=learner.predict(ds,batch_size=32,num_workers=8)\n",
    "            featuress.append(features)\n",
    "        features=np.stack(featuress,0)\n",
    "        with open(params.path.features+(name.split('.')[0]+'_test.pkl'),'wb') as f:\n",
    "            pickle.dump(features,f,protocol=4)\n",
    "            "
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}