3_cvpr_ohe_2lstm_4logits_weight_kednall_tanh1_decoder.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "with open('./data/CVPR_2022_NAS_Track2_train.json', 'r') as f:\n",
    "    train_data = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_cols = ['cplfw_rank', 'market1501_rank', 'dukemtmc_rank', 'msmt17_rank', 'veri_rank', 'vehicleid_rank', 'veriwild_rank', 'sop_rank']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_df(train_data):\n",
    "    ret = []\n",
    "    for k, v in train_data.items():\n",
    "        tmp = list(v['arch'])\n",
    "        tmp1 = []\n",
    "        for c in target_cols:\n",
    "            tmp1.append(v[c])\n",
    "        ret.append(tmp+tmp1+[k,v['arch']])\n",
    "    retf = pd.DataFrame(ret,columns=[f'col{_}' for _ in range(len(tmp))]+target_cols+['id','arch'])\n",
    "    retf['col0'] = retf['col0'].map({'l':1, 'j':2, 'k':3})\n",
    "    int_cols = [x for x in retf.columns if x not in ['id','arch']]\n",
    "    retf[int_cols] = retf[int_cols].astype(float)\n",
    "    return retf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = get_df(train_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.special import erfinv \n",
    "\n",
    "for c in target_cols:\n",
    "    train_y=train_df[c]\n",
    "    mmin=np.min(train_y)+1\n",
    "    mmax=np.max(train_y)+1\n",
    "    train_y=np.sqrt(2) * erfinv(2 * (train_y+mmin)/(mmin+mmax)-1)\n",
    "    train_df[c+'_trans_y'] = train_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_step(train_df):\n",
    "    res0 = []\n",
    "    res1 = []\n",
    "    res2 = []\n",
    "    res3 = []\n",
    "    res4 = []\n",
    "    map_={'l':1, 'j':2, 'k':3}\n",
    "    time_step=12\n",
    "    head_ = set([1+_*3 for _ in range(12)])\n",
    "    mlp_ = set([2+_*3 for _ in range(12)])\n",
    "    emb_ = set([3+_*3 for _ in range(12)])\n",
    "    depth_ = set([0])\n",
    "    for item in train_df.arch:\n",
    "        ret = np.array(list(item[1:]),dtype=np.float32).reshape(-1,3)\n",
    "        res0.append([1 if x in head_ else 0 for x in range(37)])\n",
    "        res1.append([1 if x in mlp_ else 0 for x in range(37)])\n",
    "        res2.append([1 if x in emb_ else 0 for x in range(37)])\n",
    "        res3.append([1 if x in depth_ else 0 for x in range(37)])\n",
    "        res4.append([map_[item[0]]]+list(np.array(list(item[1:]),dtype=np.float32)))\n",
    "        \n",
    "    train_df['head'] = res0\n",
    "    train_df['mlp'] = res1\n",
    "    train_df['emb'] = res2\n",
    "    train_df['depth'] = res3\n",
    "    train_df['all_emb'] = res4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_step(train_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "base cols len: 37\n",
      "embedding size: 93\n"
     ]
    }
   ],
   "source": [
    "#获取col级别的ohe映射\n",
    "base_cols = [x for x in train_df.columns if x[:3]=='col']\n",
    "print(f'base cols len: {len(base_cols)}')\n",
    "cnt=0\n",
    "emb_map={}\n",
    "for i, c in enumerate(base_cols):\n",
    "    nunique = sorted(train_df[c].unique())\n",
    "    emb_map[i] = {}\n",
    "    for v in nunique:\n",
    "        emb_map[i][v]=cnt\n",
    "        cnt+=1\n",
    "emb_size = 0\n",
    "for k, v in emb_map.items():\n",
    "    emb_size += len(v)\n",
    "print(f'embedding size: {emb_size}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_emb_trans(x, emb_map):\n",
    "    ret=[]\n",
    "    for i, v in enumerate(x):\n",
    "        ret.append(emb_map[i][v])\n",
    "    return ret\n",
    "    \n",
    "def ohe_trans(train_df, emb_map):\n",
    "    train_df['all_emb_vec'] = train_df['all_emb'].map(lambda x: all_emb_trans(x, emb_map))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ohe_trans(train_df, emb_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8, ..., 86, 89, 92],\n",
       "       [ 2,  3,  6, ..., 83, 87, 91],\n",
       "       [ 1,  4,  7, ..., 83, 87, 91],\n",
       "       ...,\n",
       "       [ 0,  3,  6, ..., 85, 90, 92],\n",
       "       [ 2,  3,  7, ..., 83, 87, 91],\n",
       "       [ 0,  5,  7, ..., 86, 88, 92]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(train_df['all_emb_vec'].tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#定义数据\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "class MyDataset(Dataset):\n",
    "    def __init__(self,df,use_cols,target_cols,show=0):\n",
    "        self.df = df\n",
    "        self.show = show\n",
    "        self.use_cols = use_cols\n",
    "        self.target_cols = target_cols\n",
    "\n",
    "        self.prepare_data()\n",
    "        \n",
    "    def __len__(self):\n",
    "        return self.df.shape[0]\n",
    "    \n",
    "    def prepare_data(self):\n",
    "#         self.y = self.df[self.target_cols].values\n",
    "        self.y = self.df[[x+'_trans_y' for x in self.target_cols]].values\n",
    "        self.y0 = self.df[[self.target_cols[0]]].values\n",
    "        self.y1 = self.df[[self.target_cols[1]]].values\n",
    "        self.y2 = self.df[[self.target_cols[2]]].values\n",
    "        self.y3 = self.df[[self.target_cols[3]]].values\n",
    "        self.y4 = self.df[[self.target_cols[4]]].values\n",
    "        self.y5 = self.df[[self.target_cols[5]]].values\n",
    "        self.y6 = self.df[[self.target_cols[6]]].values\n",
    "        self.y7 = self.df[[self.target_cols[7]]].values\n",
    "        \n",
    "        self.inputs = np.array(self.df['all_emb_vec'].tolist())\n",
    "\n",
    "        if self.show==1:\n",
    "            print('inputs_shape',self.inputs.shape)\n",
    "            print('y_shape',self.y.shape)\n",
    "        \n",
    "    def __getitem__(self, idx):\n",
    "        data = {\n",
    "            \"input\": F.one_hot(torch.tensor(self.inputs[idx]).long(), num_classes=emb_size).float(),\n",
    "            \"y\": torch.tensor(self.y[idx], dtype=torch.float),\n",
    "            \"y0\": torch.tensor(self.y0[idx], dtype=torch.float),\n",
    "            \"y1\": torch.tensor(self.y1[idx], dtype=torch.float),\n",
    "            \"y2\": torch.tensor(self.y2[idx], dtype=torch.float),\n",
    "            \"y3\": torch.tensor(self.y3[idx], dtype=torch.float),\n",
    "            \"y4\": torch.tensor(self.y4[idx], dtype=torch.float),\n",
    "            \"y5\": torch.tensor(self.y5[idx], dtype=torch.float),\n",
    "            \"y6\": torch.tensor(self.y6[idx], dtype=torch.float),\n",
    "            \"y7\": torch.tensor(self.y7[idx], dtype=torch.float),\n",
    "        }\n",
    "        \n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch.nn.functional as F\n",
    "os.environ['CUDA_LAUNCH_BLOCKING'] = '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gc\n",
    "import os\n",
    "import time\n",
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import scipy\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from transformers import get_linear_schedule_with_warmup\n",
    "\n",
    "\n",
    "def seed_everything(seed):\n",
    "    random.seed(seed)\n",
    "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    \n",
    "    \n",
    "def count_parameters(model, all=False):\n",
    "    if all:\n",
    "        return sum(p.numel() for p in model.parameters())\n",
    "    else:\n",
    "        return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "\n",
    "def save_model_weights(model, modelpath, filename):\n",
    "    torch.save(model.state_dict(), modelpath+filename)\n",
    "    return f\"\\n -> Save weights to {modelpath+filename}\\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_metric(pred, y):\n",
    "    corr = []\n",
    "    if pred.shape[1]>2:\n",
    "        for i in range(8):\n",
    "            corr.append(scipy.stats.stats.kendalltau(pred[:, i], y[:, i])[0])\n",
    "    else:\n",
    "        corr.append(scipy.stats.stats.kendalltau(pred, y)[0])\n",
    "    return np.array(corr)\n",
    "\n",
    "    \n",
    "class CVPRLoss_tanh1(nn.Module):\n",
    "    # kendall tanh\n",
    "    def __call__(self, pred, y):\n",
    "        return 1-torch.cat(\n",
    "            [self.get_score(pred[:,i], y[:,i]).reshape(1) for i in range(y.shape[1])]\n",
    "        ).reshape(1,-1)\n",
    "    \n",
    "    def get_score(self, outputs, labels):\n",
    "        output1 = outputs.unsqueeze(1).repeat(1,outputs.shape[0])\n",
    "        label1 = labels.unsqueeze(1).repeat(1,labels.shape[0])\n",
    "\n",
    "        tmp = ((output1-output1.t())*torch.sign(label1-label1.t())).tanh()\n",
    "        eye_tmp = tmp*torch.eye(tmp.shape[0]).cuda()\n",
    "        new_tmp = tmp - eye_tmp\n",
    "        \n",
    "        loss = torch.sum(new_tmp)/(outputs.shape[0]*(outputs.shape[0]-1))\n",
    "\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_sig(model, \n",
    "        train_dataset, \n",
    "        val_dataset, \n",
    "        verbose=20, \n",
    "        fold_=0,\n",
    "        modelname='MLP_base',\n",
    "        modelpath=r'./model'+'//',\n",
    "        input='input',\n",
    "        y='y',\n",
    "        early_stop_round=60,\n",
    "        debug=False):\n",
    "    \n",
    "    print(f'Model parameters count: {count_parameters(model)}')\n",
    "    #数据加载\n",
    "    train_loader = DataLoader(\n",
    "        train_dataset,\n",
    "        batch_size=BATCH_SIZE,\n",
    "        shuffle=False,\n",
    "        drop_last=True,\n",
    "        pin_memory=True\n",
    "    )\n",
    "    val_loader = DataLoader(\n",
    "        val_dataset,\n",
    "        batch_size=BATCH_SIZE_TEST,\n",
    "        shuffle=False,\n",
    "        drop_last=False,\n",
    "        pin_memory=True\n",
    "    )\n",
    "    print(f'train batch num: {len(train_loader)}')\n",
    "    print(f'val batch num: {len(val_loader)}')\n",
    "            \n",
    "    # Optimizer\n",
    "    optimizer = getattr(torch.optim, optim)(model.parameters(), lr=LR)\n",
    "    # Scheduler\n",
    "    num_warmup_steps = int(0.1 * EPOCHS * len(train_loader))\n",
    "    num_training_steps = int(EPOCHS * len(train_loader))\n",
    "    scheduler = get_linear_schedule_with_warmup(\n",
    "        optimizer, num_warmup_steps, num_training_steps\n",
    "    )\n",
    "    print(f'optim: {optim}, lr: {LR}, warmup_steps: {num_warmup_steps}')\n",
    "    \n",
    "    \n",
    "    #train\n",
    "    bst_epoch={_:0 for _ in range(8)}\n",
    "    score_best={_:0 for _ in range(8)}\n",
    "    first_epoch_eval=0\n",
    "    for epoch in range(EPOCHS):\n",
    "        \n",
    "        model.train()\n",
    "        model.zero_grad()\n",
    "        start_time = time.time()\n",
    "\n",
    "        avg_loss = 0\n",
    "        for data in train_loader:\n",
    "            pred = model(data[input].to(device))\n",
    "#             print(pred.shape,data['y'].shape)\n",
    "\n",
    "            loss = loss_fct(\n",
    "                pred,\n",
    "                data[y].to(device)\n",
    "            ).mean()\n",
    "\n",
    "            loss.backward()\n",
    "            avg_loss += loss.item() / len(train_loader)\n",
    "\n",
    "            optimizer.step()\n",
    "            scheduler.step()\n",
    "\n",
    "            optimizer.zero_grad(set_to_none=True)\n",
    "\n",
    "        #VAL\n",
    "        model.eval()\n",
    "        mae, avg_val_loss = 0, 0\n",
    "        preds = []\n",
    "\n",
    "        with torch.no_grad():\n",
    "            for data in val_loader:\n",
    "                pred = model(data[input].to(device))\n",
    "\n",
    "                loss = loss_fct(\n",
    "                    pred,\n",
    "                    data[y].to(device)\n",
    "                ).mean()\n",
    "\n",
    "                avg_val_loss += loss.item() / len(val_loader)\n",
    "\n",
    "                preds.append(pred.detach().cpu().numpy())\n",
    "\n",
    "        preds = np.concatenate(preds, 0)\n",
    "        if y=='y':\n",
    "            mae = compute_metric(preds,val_dataset.df[target_cols].values).mean()\n",
    "        else:\n",
    "            mae = compute_metric(preds,val_dataset.df[[target_cols[int(y.replace('y',''))]]].values).mean()\n",
    "        \n",
    "        elapsed_time = time.time() - start_time\n",
    "        if (epoch + 1) % verbose == 0:\n",
    "            elapsed_time = elapsed_time * verbose\n",
    "            lr = scheduler.get_last_lr()[0]\n",
    "    #         lr=LR\n",
    "            print(\n",
    "                f\"Epoch {epoch + 1:02d}/{ EPOCHS:02d} \\t lr={lr:.1e}\\t t={elapsed_time:.0f}s \\t\"\n",
    "                f\"loss={avg_loss:.4f}\",\n",
    "                end=\"\\t\",\n",
    "            )\n",
    "\n",
    "            if (epoch + 1 >= first_epoch_eval) or (epoch + 1 == EPOCHS):\n",
    "                print(f\"val_loss={avg_val_loss:.4f}\\tcorr={mae:.4f}\")\n",
    "            else:\n",
    "                print(\"\")\n",
    "                \n",
    "        #保存最优模型\n",
    "        score1 = compute_metric(preds,val_dataset.df[target_cols].values)\n",
    "        for i in range(8):\n",
    "            if score1[i] > score_best[i]:\n",
    "                bst = save_model_weights(model, modelpath, f'{modelname}_target{i}_{fold_}.pt')\n",
    "                score_best[i] = score1[i]\n",
    "                bst_epoch[i] = epoch\n",
    "#                 print(f'target{i} best score {score_best[i]}, best epoch: {bst_epoch[i]}, {bst} ' )\n",
    "                \n",
    "    bst_list = [score_best[i] for i in range(8)]\n",
    "    print(bst_list,'\\n\\n')\n",
    "    del (val_loader, train_loader, loss, data, pred)\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()\n",
    "    \n",
    "    return bst_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CVPRModel(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_dim=3,\n",
    "        num_classes=8,\n",
    "        time_step=12,\n",
    "        bi=True\n",
    "    ):\n",
    "        super(CVPRModel,self).__init__()\n",
    "        \n",
    "        self.bi_num = 2 if bi else 1\n",
    "        self.time_step = time_step\n",
    "        \n",
    "        self.MLP = nn.Sequential(\n",
    "            nn.Linear(input_dim, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 256),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        self.LSTM0 = nn.LSTM(256, 256, \n",
    "                    batch_first=True, \n",
    "                    bidirectional=bi, \n",
    "                    num_layers=1,\n",
    "                    dropout=0)\n",
    "                                 \n",
    "        \n",
    "        self.LSTM1 = nn.LSTM(512, 256, \n",
    "                    batch_first=True, \n",
    "                    bidirectional=bi, \n",
    "                    num_layers=1,\n",
    "                    dropout=0\n",
    "                            )    \n",
    "        \n",
    "        self.Logits0 = nn.Sequential(\n",
    "            nn.Flatten(start_dim=1),\n",
    "            nn.Linear((93)*self.time_step, 256),\n",
    "            nn.ReLU(),\n",
    "        \n",
    "        )\n",
    "        \n",
    "        self.Logits1 = nn.Sequential(\n",
    "            nn.Flatten(start_dim=1),\n",
    "            nn.Linear((256)*self.time_step, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 256),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        self.Logits2 = nn.Sequential(\n",
    "            nn.Flatten(start_dim=1),\n",
    "            nn.Linear((512)*self.time_step, 1024),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(1024, 256),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        self.Logits3 = nn.Sequential(\n",
    "            nn.Flatten(start_dim=1),\n",
    "            nn.Linear((512)*self.time_step, 1024),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(1024, 256),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        \n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(4, 1),\n",
    "            nn.Flatten(start_dim=1),\n",
    "            nn.Linear(256, num_classes)\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x1 = self.MLP(x)\n",
    "        x2, (h0, c0) = self.LSTM0(x1)\n",
    "        x3, (h1, c1) = self.LSTM1(x2, (h0, c0))\n",
    "        \n",
    "        p0 = self.Logits0(x)\n",
    "        p1 = self.Logits1(x1)\n",
    "        p2 = self.Logits2(x2)\n",
    "        p3 = self.Logits3(x3)\n",
    "\n",
    "\n",
    "        c1 = torch.cat([\n",
    "            p0.unsqueeze(2), \n",
    "            p1.unsqueeze(2), \n",
    "            p2.unsqueeze(2), \n",
    "            p3.unsqueeze(2), \n",
    "                       ],-1\n",
    "        )\n",
    "        \n",
    "        pred = self.fc(c1)\n",
    "        \n",
    "        return pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 参数设置\n",
    "seed = 666\n",
    "BATCH_SIZE = 400\n",
    "BATCH_SIZE_TEST = 128\n",
    "EPOCHS = 300\n",
    "LR = 0.001\n",
    "optim = \"Adam\"\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "modelpath = r'./model'+'//'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "use_cols=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FOLD 0\n",
      "train size: 400, val size: 100\n",
      "Model parameters count: 47929357\n",
      "train batch num: 1\n",
      "val batch num: 1\n",
      "optim: Adam, lr: 0.001, warmup_steps: 30\n",
      "Epoch 10/300 \t lr=3.3e-04\t t=4s \tloss=0.9944\tval_loss=0.9941\tcorr=0.3516\n",
      "Epoch 20/300 \t lr=6.7e-04\t t=3s \tloss=0.9461\tval_loss=0.9386\tcorr=0.4895\n",
      "Epoch 30/300 \t lr=1.0e-03\t t=3s \tloss=0.5329\tval_loss=0.5487\tcorr=0.4619\n",
      "Epoch 40/300 \t lr=9.6e-04\t t=2s \tloss=0.4277\tval_loss=0.4784\tcorr=0.5292\n",
      "Epoch 50/300 \t lr=9.3e-04\t t=2s \tloss=0.3558\tval_loss=0.3806\tcorr=0.6351\n",
      "Epoch 60/300 \t lr=8.9e-04\t t=4s \tloss=0.2947\tval_loss=0.3149\tcorr=0.6967\n",
      "Epoch 70/300 \t lr=8.5e-04\t t=4s \tloss=0.2561\tval_loss=0.2833\tcorr=0.7261\n",
      "Epoch 80/300 \t lr=8.1e-04\t t=4s \tloss=0.2305\tval_loss=0.2556\tcorr=0.7525\n",
      "Epoch 90/300 \t lr=7.8e-04\t t=3s \tloss=0.2083\tval_loss=0.2341\tcorr=0.7709\n",
      "Epoch 100/300 \t lr=7.4e-04\t t=2s \tloss=0.1941\tval_loss=0.2224\tcorr=0.7822\n",
      "Epoch 110/300 \t lr=7.0e-04\t t=2s \tloss=0.1848\tval_loss=0.2206\tcorr=0.7833\n",
      "Epoch 120/300 \t lr=6.7e-04\t t=1s \tloss=0.1777\tval_loss=0.2184\tcorr=0.7830\n",
      "Epoch 130/300 \t lr=6.3e-04\t t=2s \tloss=0.1741\tval_loss=0.2145\tcorr=0.7871\n",
      "Epoch 140/300 \t lr=5.9e-04\t t=2s \tloss=0.1639\tval_loss=0.2146\tcorr=0.7875\n",
      "Epoch 150/300 \t lr=5.6e-04\t t=2s \tloss=0.1564\tval_loss=0.2187\tcorr=0.7824\n",
      "Epoch 160/300 \t lr=5.2e-04\t t=2s \tloss=0.1814\tval_loss=0.2301\tcorr=0.7718\n",
      "Epoch 170/300 \t lr=4.8e-04\t t=2s \tloss=0.1588\tval_loss=0.2155\tcorr=0.7875\n",
      "Epoch 180/300 \t lr=4.4e-04\t t=2s \tloss=0.1469\tval_loss=0.2161\tcorr=0.7862\n",
      "Epoch 190/300 \t lr=4.1e-04\t t=2s \tloss=0.1372\tval_loss=0.2196\tcorr=0.7830\n",
      "Epoch 200/300 \t lr=3.7e-04\t t=3s \tloss=0.1280\tval_loss=0.2221\tcorr=0.7806\n",
      "Epoch 210/300 \t lr=3.3e-04\t t=2s \tloss=0.1210\tval_loss=0.2234\tcorr=0.7787\n",
      "Epoch 220/300 \t lr=3.0e-04\t t=2s \tloss=0.1135\tval_loss=0.2237\tcorr=0.7780\n",
      "Epoch 230/300 \t lr=2.6e-04\t t=2s \tloss=0.1067\tval_loss=0.2262\tcorr=0.7753\n",
      "Epoch 240/300 \t lr=2.2e-04\t t=2s \tloss=0.1007\tval_loss=0.2269\tcorr=0.7740\n",
      "Epoch 250/300 \t lr=1.9e-04\t t=2s \tloss=0.0956\tval_loss=0.2279\tcorr=0.7732\n",
      "Epoch 260/300 \t lr=1.5e-04\t t=2s \tloss=0.0911\tval_loss=0.2302\tcorr=0.7716\n",
      "Epoch 270/300 \t lr=1.1e-04\t t=2s \tloss=0.0873\tval_loss=0.2306\tcorr=0.7707\n",
      "Epoch 280/300 \t lr=7.4e-05\t t=2s \tloss=0.0844\tval_loss=0.2311\tcorr=0.7706\n",
      "Epoch 290/300 \t lr=3.7e-05\t t=2s \tloss=0.0826\tval_loss=0.2315\tcorr=0.7697\n",
      "Epoch 300/300 \t lr=0.0e+00\t t=2s \tloss=0.0819\tval_loss=0.2315\tcorr=0.7703\n",
      "[0.32363636363636367, 0.9014141414141416, 0.9022222222222224, 0.953939393939394, 0.8892929292929294, 0.7111111111111112, 0.9244444444444447, 0.8113131313131314] \n",
      "\n",
      "\n",
      "FOLD 1\n",
      "train size: 400, val size: 100\n",
      "Model parameters count: 47929357\n",
      "train batch num: 1\n",
      "val batch num: 1\n",
      "optim: Adam, lr: 0.001, warmup_steps: 30\n",
      "Epoch 10/300 \t lr=3.3e-04\t t=4s \tloss=0.9945\tval_loss=0.9940\tcorr=0.3732\n",
      "Epoch 20/300 \t lr=6.7e-04\t t=4s \tloss=0.9485\tval_loss=0.9404\tcorr=0.5469\n",
      "Epoch 30/300 \t lr=1.0e-03\t t=2s \tloss=0.5516\tval_loss=0.5328\tcorr=0.4999\n",
      "Epoch 40/300 \t lr=9.6e-04\t t=3s \tloss=0.4299\tval_loss=0.4273\tcorr=0.5822\n",
      "Epoch 50/300 \t lr=9.3e-04\t t=4s \tloss=0.3370\tval_loss=0.3582\tcorr=0.6564\n",
      "Epoch 60/300 \t lr=8.9e-04\t t=4s \tloss=0.2892\tval_loss=0.3235\tcorr=0.6866\n",
      "Epoch 70/300 \t lr=8.5e-04\t t=3s \tloss=0.2560\tval_loss=0.3008\tcorr=0.7065\n",
      "Epoch 80/300 \t lr=8.1e-04\t t=2s \tloss=0.2307\tval_loss=0.2750\tcorr=0.7329\n",
      "Epoch 90/300 \t lr=7.8e-04\t t=2s \tloss=0.2119\tval_loss=0.2575\tcorr=0.7483\n",
      "Epoch 100/300 \t lr=7.4e-04\t t=1s \tloss=0.1986\tval_loss=0.2472\tcorr=0.7573\n",
      "Epoch 110/300 \t lr=7.0e-04\t t=2s \tloss=0.1891\tval_loss=0.2368\tcorr=0.7671\n",
      "Epoch 120/300 \t lr=6.7e-04\t t=2s \tloss=0.1819\tval_loss=0.2315\tcorr=0.7715\n",
      "Epoch 130/300 \t lr=6.3e-04\t t=2s \tloss=0.1764\tval_loss=0.2300\tcorr=0.7721\n",
      "Epoch 140/300 \t lr=5.9e-04\t t=2s \tloss=0.1714\tval_loss=0.2273\tcorr=0.7741\n",
      "Epoch 150/300 \t lr=5.6e-04\t t=2s \tloss=0.1660\tval_loss=0.2249\tcorr=0.7782\n",
      "Epoch 160/300 \t lr=5.2e-04\t t=2s \tloss=0.1610\tval_loss=0.2256\tcorr=0.7748\n",
      "Epoch 170/300 \t lr=4.8e-04\t t=2s \tloss=0.1527\tval_loss=0.2243\tcorr=0.7779\n",
      "Epoch 180/300 \t lr=4.4e-04\t t=2s \tloss=0.1438\tval_loss=0.2238\tcorr=0.7778\n",
      "Epoch 190/300 \t lr=4.1e-04\t t=2s \tloss=0.1358\tval_loss=0.2240\tcorr=0.7792\n",
      "Epoch 200/300 \t lr=3.7e-04\t t=2s \tloss=0.1265\tval_loss=0.2274\tcorr=0.7747\n",
      "Epoch 210/300 \t lr=3.3e-04\t t=2s \tloss=0.1198\tval_loss=0.2315\tcorr=0.7704\n",
      "Epoch 220/300 \t lr=3.0e-04\t t=2s \tloss=0.1129\tval_loss=0.2294\tcorr=0.7720\n",
      "Epoch 230/300 \t lr=2.6e-04\t t=2s \tloss=0.1076\tval_loss=0.2302\tcorr=0.7718\n",
      "Epoch 240/300 \t lr=2.2e-04\t t=2s \tloss=0.1013\tval_loss=0.2321\tcorr=0.7682\n",
      "Epoch 250/300 \t lr=1.9e-04\t t=2s \tloss=0.0979\tval_loss=0.2336\tcorr=0.7674\n",
      "Epoch 260/300 \t lr=1.5e-04\t t=2s \tloss=0.0933\tval_loss=0.2332\tcorr=0.7683\n",
      "Epoch 270/300 \t lr=1.1e-04\t t=2s \tloss=0.0900\tval_loss=0.2344\tcorr=0.7666\n",
      "Epoch 280/300 \t lr=7.4e-05\t t=2s \tloss=0.0875\tval_loss=0.2354\tcorr=0.7663\n",
      "Epoch 290/300 \t lr=3.7e-05\t t=2s \tloss=0.0859\tval_loss=0.2362\tcorr=0.7654\n",
      "Epoch 300/300 \t lr=0.0e+00\t t=2s \tloss=0.0852\tval_loss=0.2364\tcorr=0.7646\n",
      "[0.30464646464646467, 0.8715151515151516, 0.9086868686868688, 0.9604040404040406, 0.8929292929292931, 0.6569696969696971, 0.9046464646464647, 0.7967676767676769] \n",
      "\n",
      "\n",
      "FOLD 2\n",
      "train size: 400, val size: 100\n",
      "Model parameters count: 47929357\n",
      "train batch num: 1\n",
      "val batch num: 1\n",
      "optim: Adam, lr: 0.001, warmup_steps: 30\n",
      "Epoch 10/300 \t lr=3.3e-04\t t=3s \tloss=0.9941\tval_loss=0.9951\tcorr=0.2911\n",
      "Epoch 20/300 \t lr=6.7e-04\t t=5s \tloss=0.9425\tval_loss=0.9430\tcorr=0.4362\n",
      "Epoch 30/300 \t lr=1.0e-03\t t=2s \tloss=0.5697\tval_loss=0.5738\tcorr=0.4758\n",
      "Epoch 40/300 \t lr=9.6e-04\t t=2s \tloss=0.4278\tval_loss=0.4109\tcorr=0.6145\n",
      "Epoch 50/300 \t lr=9.3e-04\t t=4s \tloss=0.3434\tval_loss=0.3376\tcorr=0.6785\n",
      "Epoch 60/300 \t lr=8.9e-04\t t=4s \tloss=0.2914\tval_loss=0.2981\tcorr=0.7106\n",
      "Epoch 70/300 \t lr=8.5e-04\t t=3s \tloss=0.2553\tval_loss=0.2662\tcorr=0.7425\n",
      "Epoch 80/300 \t lr=8.1e-04\t t=3s \tloss=0.2302\tval_loss=0.2455\tcorr=0.7611\n",
      "Epoch 90/300 \t lr=7.8e-04\t t=4s \tloss=0.2096\tval_loss=0.2293\tcorr=0.7765\n",
      "Epoch 100/300 \t lr=7.4e-04\t t=3s \tloss=0.1970\tval_loss=0.2220\tcorr=0.7829\n",
      "Epoch 110/300 \t lr=7.0e-04\t t=3s \tloss=0.1888\tval_loss=0.2167\tcorr=0.7871\n",
      "Epoch 120/300 \t lr=6.7e-04\t t=2s \tloss=0.1845\tval_loss=0.2175\tcorr=0.7862\n",
      "Epoch 130/300 \t lr=6.3e-04\t t=2s \tloss=0.1806\tval_loss=0.2175\tcorr=0.7848\n",
      "Epoch 140/300 \t lr=5.9e-04\t t=2s \tloss=0.1791\tval_loss=0.2197\tcorr=0.7822\n",
      "Epoch 150/300 \t lr=5.6e-04\t t=2s \tloss=0.1738\tval_loss=0.2197\tcorr=0.7826\n",
      "Epoch 160/300 \t lr=5.2e-04\t t=2s \tloss=0.1699\tval_loss=0.2249\tcorr=0.7765\n",
      "Epoch 170/300 \t lr=4.8e-04\t t=2s \tloss=0.1634\tval_loss=0.2255\tcorr=0.7760\n",
      "Epoch 180/300 \t lr=4.4e-04\t t=2s \tloss=0.1573\tval_loss=0.2266\tcorr=0.7746\n",
      "Epoch 190/300 \t lr=4.1e-04\t t=2s \tloss=0.1519\tval_loss=0.2297\tcorr=0.7718\n",
      "Epoch 200/300 \t lr=3.7e-04\t t=2s \tloss=0.1468\tval_loss=0.2298\tcorr=0.7722\n",
      "Epoch 210/300 \t lr=3.3e-04\t t=2s \tloss=0.1404\tval_loss=0.2328\tcorr=0.7676\n",
      "Epoch 220/300 \t lr=3.0e-04\t t=2s \tloss=0.1339\tval_loss=0.2359\tcorr=0.7656\n",
      "Epoch 230/300 \t lr=2.6e-04\t t=2s \tloss=0.1295\tval_loss=0.2343\tcorr=0.7669\n",
      "Epoch 240/300 \t lr=2.2e-04\t t=2s \tloss=0.1240\tval_loss=0.2357\tcorr=0.7653\n",
      "Epoch 250/300 \t lr=1.9e-04\t t=2s \tloss=0.1194\tval_loss=0.2377\tcorr=0.7631\n",
      "Epoch 260/300 \t lr=1.5e-04\t t=2s \tloss=0.1155\tval_loss=0.2380\tcorr=0.7633\n",
      "Epoch 270/300 \t lr=1.1e-04\t t=2s \tloss=0.1122\tval_loss=0.2382\tcorr=0.7628\n",
      "Epoch 280/300 \t lr=7.4e-05\t t=2s \tloss=0.1098\tval_loss=0.2387\tcorr=0.7621\n",
      "Epoch 290/300 \t lr=3.7e-05\t t=2s \tloss=0.1081\tval_loss=0.2391\tcorr=0.7617\n",
      "Epoch 300/300 \t lr=0.0e+00\t t=2s \tloss=0.1075\tval_loss=0.2393\tcorr=0.7622\n",
      "[0.3078787878787879, 0.8472727272727274, 0.9010101010101011, 0.964848484848485, 0.9159595959595961, 0.7232323232323233, 0.9236363636363638, 0.7975757575757577] \n",
      "\n",
      "\n",
      "FOLD 3\n",
      "train size: 400, val size: 100\n",
      "Model parameters count: 47929357\n",
      "train batch num: 1\n",
      "val batch num: 1\n",
      "optim: Adam, lr: 0.001, warmup_steps: 30\n",
      "Epoch 10/300 \t lr=3.3e-04\t t=3s \tloss=0.9944\tval_loss=0.9943\tcorr=0.3431\n",
      "Epoch 20/300 \t lr=6.7e-04\t t=3s \tloss=0.9478\tval_loss=0.9405\tcorr=0.5139\n",
      "Epoch 30/300 \t lr=1.0e-03\t t=2s \tloss=0.5557\tval_loss=0.6237\tcorr=0.3765\n",
      "Epoch 40/300 \t lr=9.6e-04\t t=2s \tloss=0.4375\tval_loss=0.4672\tcorr=0.5449\n",
      "Epoch 50/300 \t lr=9.3e-04\t t=2s \tloss=0.3539\tval_loss=0.4032\tcorr=0.6156\n",
      "Epoch 60/300 \t lr=8.9e-04\t t=2s \tloss=0.2950\tval_loss=0.3554\tcorr=0.6555\n",
      "Epoch 70/300 \t lr=8.5e-04\t t=3s \tloss=0.2612\tval_loss=0.3254\tcorr=0.6808\n",
      "Epoch 80/300 \t lr=8.1e-04\t t=3s \tloss=0.2372\tval_loss=0.3075\tcorr=0.6997\n",
      "Epoch 90/300 \t lr=7.8e-04\t t=3s \tloss=0.2196\tval_loss=0.2888\tcorr=0.7165\n",
      "Epoch 100/300 \t lr=7.4e-04\t t=3s \tloss=0.2037\tval_loss=0.2656\tcorr=0.7390\n",
      "Epoch 110/300 \t lr=7.0e-04\t t=2s \tloss=0.1898\tval_loss=0.2486\tcorr=0.7575\n",
      "Epoch 120/300 \t lr=6.7e-04\t t=3s \tloss=0.1817\tval_loss=0.2417\tcorr=0.7623\n",
      "Epoch 130/300 \t lr=6.3e-04\t t=3s \tloss=0.1754\tval_loss=0.2396\tcorr=0.7633\n",
      "Epoch 140/300 \t lr=5.9e-04\t t=2s \tloss=0.1695\tval_loss=0.2397\tcorr=0.7620\n",
      "Epoch 150/300 \t lr=5.6e-04\t t=2s \tloss=0.1631\tval_loss=0.2399\tcorr=0.7624\n",
      "Epoch 160/300 \t lr=5.2e-04\t t=2s \tloss=0.1553\tval_loss=0.2412\tcorr=0.7609\n",
      "Epoch 170/300 \t lr=4.8e-04\t t=2s \tloss=0.1488\tval_loss=0.2421\tcorr=0.7588\n",
      "Epoch 180/300 \t lr=4.4e-04\t t=2s \tloss=0.1369\tval_loss=0.2460\tcorr=0.7561\n",
      "Epoch 190/300 \t lr=4.1e-04\t t=2s \tloss=0.1301\tval_loss=0.2495\tcorr=0.7528\n",
      "Epoch 200/300 \t lr=3.7e-04\t t=2s \tloss=0.1216\tval_loss=0.2438\tcorr=0.7574\n",
      "Epoch 210/300 \t lr=3.3e-04\t t=2s \tloss=0.1126\tval_loss=0.2452\tcorr=0.7558\n",
      "Epoch 220/300 \t lr=3.0e-04\t t=2s \tloss=0.1059\tval_loss=0.2464\tcorr=0.7549\n",
      "Epoch 230/300 \t lr=2.6e-04\t t=2s \tloss=0.1012\tval_loss=0.2486\tcorr=0.7515\n",
      "Epoch 240/300 \t lr=2.2e-04\t t=2s \tloss=0.0955\tval_loss=0.2494\tcorr=0.7514\n",
      "Epoch 250/300 \t lr=1.9e-04\t t=2s \tloss=0.0903\tval_loss=0.2486\tcorr=0.7525\n",
      "Epoch 260/300 \t lr=1.5e-04\t t=2s \tloss=0.0865\tval_loss=0.2480\tcorr=0.7535\n",
      "Epoch 270/300 \t lr=1.1e-04\t t=2s \tloss=0.0831\tval_loss=0.2488\tcorr=0.7524\n",
      "Epoch 280/300 \t lr=7.4e-05\t t=2s \tloss=0.0806\tval_loss=0.2500\tcorr=0.7508\n",
      "Epoch 290/300 \t lr=3.7e-05\t t=2s \tloss=0.0790\tval_loss=0.2504\tcorr=0.7506\n",
      "Epoch 300/300 \t lr=0.0e+00\t t=2s \tloss=0.0784\tval_loss=0.2508\tcorr=0.7502\n",
      "[0.26343434343434347, 0.884848484848485, 0.8892929292929294, 0.9644444444444447, 0.890909090909091, 0.593939393939394, 0.903838383838384, 0.7915151515151516] \n",
      "\n",
      "\n",
      "FOLD 4\n",
      "train size: 400, val size: 100\n",
      "Model parameters count: 47929357\n",
      "train batch num: 1\n",
      "val batch num: 1\n",
      "optim: Adam, lr: 0.001, warmup_steps: 30\n",
      "Epoch 10/300 \t lr=3.3e-04\t t=2s \tloss=0.9943\tval_loss=0.9939\tcorr=0.3554\n",
      "Epoch 20/300 \t lr=6.7e-04\t t=2s \tloss=0.9450\tval_loss=0.9337\tcorr=0.5328\n",
      "Epoch 30/300 \t lr=1.0e-03\t t=2s \tloss=0.5504\tval_loss=0.5294\tcorr=0.5242\n",
      "Epoch 40/300 \t lr=9.6e-04\t t=1s \tloss=0.4297\tval_loss=0.4349\tcorr=0.5714\n",
      "Epoch 50/300 \t lr=9.3e-04\t t=4s \tloss=0.3548\tval_loss=0.3543\tcorr=0.6593\n",
      "Epoch 60/300 \t lr=8.9e-04\t t=2s \tloss=0.2945\tval_loss=0.2909\tcorr=0.7227\n",
      "Epoch 70/300 \t lr=8.5e-04\t t=1s \tloss=0.2574\tval_loss=0.2677\tcorr=0.7415\n",
      "Epoch 80/300 \t lr=8.1e-04\t t=1s \tloss=0.2283\tval_loss=0.2480\tcorr=0.7599\n",
      "Epoch 90/300 \t lr=7.8e-04\t t=2s \tloss=0.2062\tval_loss=0.2384\tcorr=0.7668\n",
      "Epoch 100/300 \t lr=7.4e-04\t t=4s \tloss=0.1914\tval_loss=0.2280\tcorr=0.7771\n",
      "Epoch 110/300 \t lr=7.0e-04\t t=2s \tloss=0.1852\tval_loss=0.2200\tcorr=0.7844\n",
      "Epoch 120/300 \t lr=6.7e-04\t t=2s \tloss=0.1810\tval_loss=0.2180\tcorr=0.7847\n",
      "Epoch 130/300 \t lr=6.3e-04\t t=2s \tloss=0.1751\tval_loss=0.2174\tcorr=0.7838\n",
      "Epoch 140/300 \t lr=5.9e-04\t t=2s \tloss=0.1689\tval_loss=0.2181\tcorr=0.7835\n",
      "Epoch 150/300 \t lr=5.6e-04\t t=2s \tloss=0.1675\tval_loss=0.2184\tcorr=0.7827\n",
      "Epoch 160/300 \t lr=5.2e-04\t t=2s \tloss=0.1598\tval_loss=0.2125\tcorr=0.7888\n",
      "Epoch 170/300 \t lr=4.8e-04\t t=2s \tloss=0.1540\tval_loss=0.2168\tcorr=0.7848\n",
      "Epoch 180/300 \t lr=4.4e-04\t t=2s \tloss=0.1471\tval_loss=0.2125\tcorr=0.7895\n",
      "Epoch 190/300 \t lr=4.1e-04\t t=2s \tloss=0.1404\tval_loss=0.2143\tcorr=0.7869\n",
      "Epoch 200/300 \t lr=3.7e-04\t t=2s \tloss=0.1316\tval_loss=0.2116\tcorr=0.7890\n",
      "Epoch 210/300 \t lr=3.3e-04\t t=2s \tloss=0.1255\tval_loss=0.2137\tcorr=0.7873\n",
      "Epoch 220/300 \t lr=3.0e-04\t t=2s \tloss=0.1172\tval_loss=0.2158\tcorr=0.7866\n",
      "Epoch 230/300 \t lr=2.6e-04\t t=2s \tloss=0.1107\tval_loss=0.2161\tcorr=0.7859\n",
      "Epoch 240/300 \t lr=2.2e-04\t t=2s \tloss=0.1038\tval_loss=0.2156\tcorr=0.7862\n",
      "Epoch 250/300 \t lr=1.9e-04\t t=2s \tloss=0.0986\tval_loss=0.2151\tcorr=0.7862\n",
      "Epoch 260/300 \t lr=1.5e-04\t t=2s \tloss=0.0949\tval_loss=0.2163\tcorr=0.7850\n",
      "Epoch 270/300 \t lr=1.1e-04\t t=2s \tloss=0.0904\tval_loss=0.2145\tcorr=0.7863\n",
      "Epoch 280/300 \t lr=7.4e-05\t t=2s \tloss=0.0877\tval_loss=0.2151\tcorr=0.7862\n",
      "Epoch 290/300 \t lr=3.7e-05\t t=2s \tloss=0.0860\tval_loss=0.2152\tcorr=0.7859\n",
      "Epoch 300/300 \t lr=0.0e+00\t t=2s \tloss=0.0854\tval_loss=0.2154\tcorr=0.7857\n",
      "[0.3393939393939394, 0.8525252525252527, 0.9179797979797981, 0.9636363636363638, 0.9131313131313133, 0.711919191919192, 0.9357575757575758, 0.8024242424242426] \n",
      "\n",
      "\n",
      "0.79286 [0.3078, 0.87152, 0.90384, 0.96145, 0.90044, 0.67943, 0.91846, 0.79992]\n"
     ]
    }
   ],
   "source": [
    "# train with soft kendall\n",
    "loss_fct = CVPRLoss_tanh1()\n",
    "k=5\n",
    "scoref = []\n",
    "skf = KFold(n_splits=k, shuffle=False)\n",
    "for index, (train_index, test_index) in enumerate(skf.split(train_df)):   \n",
    "    print(f'FOLD {index}')\n",
    "    train0 = train_df.iloc[train_index]\n",
    "    val0 = train_df.iloc[test_index]   \n",
    "    train_dataset = MyDataset(train0, use_cols, target_cols)\n",
    "    val_dataset = MyDataset(val0, use_cols, target_cols)\n",
    "    print(f'train size: {len(train0)}, val size: {len(val0)}')\n",
    "\n",
    "    modelname = f'torch_ohe_2lstm_4logits_weight_kednall_tanh1'\n",
    "    seed_everything(seed)\n",
    "    model = CVPRModel(input_dim=93,\n",
    "                    num_classes=8,\n",
    "                    bi=True,\n",
    "                    time_step=37\n",
    "                   ).to(device)\n",
    "\n",
    "    _ = train_sig(model, \n",
    "                train_dataset, \n",
    "                val_dataset, \n",
    "                verbose=10, \n",
    "                fold_=index,\n",
    "                modelname=modelname,\n",
    "                modelpath=modelpath,\n",
    "                input='input',\n",
    "                y='y',\n",
    "                debug=False\n",
    "                 )\n",
    "    scoref.append(_)\n",
    "scoreff = scoref\n",
    "print(np.round(np.array(scoreff).mean(1).mean(), 5), [round(x, 5) for x in np.array(scoreff).mean(0)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.79286,\n",
       " [0.3078, 0.87152, 0.90384, 0.96145, 0.90044, 0.67943, 0.91846, 0.79992])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(np.array(scoreff).mean(1).mean(), 5), [round(x, 5) for x in np.array(scoreff).mean(0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#加载test\n",
    "with open('./data/CVPR_2022_NAS_Track2_test.json', 'r') as f:\n",
    "    test_data = json.load(f)\n",
    "    \n",
    "test_df = get_df(test_data)\n",
    "get_step(test_df)\n",
    "ohe_trans(test_df, emb_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pred_cuda(test_df, model):\n",
    "    #获得预测\n",
    "    test_dataset = MyDataset(test_df, use_cols, target_cols, 0)\n",
    "    test_loader = DataLoader(\n",
    "        test_dataset,\n",
    "        batch_size=1024*16,\n",
    "        shuffle=False,\n",
    "        drop_last=False,\n",
    "        pin_memory=True\n",
    "    )\n",
    "\n",
    "    preds = []\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for data in tqdm(test_loader):\n",
    "            pred = model(data['input'].to(device))\n",
    "            preds.append(pred.detach().cpu().numpy())\n",
    "    preds = np.concatenate(preds, 0)\n",
    "    print(preds.shape)\n",
    "\n",
    "    del test_dataset, test_loader, model;\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()\n",
    "    return preds\n",
    "        \n",
    "def predict_sig(test_df, k=5, modelname=''):\n",
    "    for target in range(8):        \n",
    "        cols = []\n",
    "        for fold_ in range(k):\n",
    "            modelname1 = f'{modelname}_target{target}_{fold_}.pt'\n",
    "            print(f'Model {modelname1}')\n",
    "            model = CVPRModel(input_dim=93,\n",
    "                        num_classes=8,\n",
    "                        bi=True,\n",
    "                        time_step=37\n",
    "                       ).to(device)\n",
    "            model.load_state_dict(torch.load(modelpath+modelname1))\n",
    "\n",
    "            pred_ = pred_cuda(test_df, model)[:, target]\n",
    "            tmp_c = f'{target_cols[target]}_{fold_}'\n",
    "            test_df[tmp_c] = pred_\n",
    "            cols.append(tmp_c)\n",
    "            print(f'Done {tmp_c}')\n",
    "            \n",
    "        print(cols)\n",
    "        test_df[cols] = test_df[cols].rank()\n",
    "        test_df[target_cols[target]] = test_df[cols].mean(axis=1).rank()\n",
    "        \n",
    "def predict_all(test_df, k=5, modelname = f'lstm2y稠密_bc400_lr001_softsign'):\n",
    "\n",
    "    print(f'Model {modelname}')\n",
    "\n",
    "    cols = []\n",
    "    for fold_ in range(k):\n",
    "        model = CVPRModel(input_dim=1,\n",
    "                    num_classes=8,\n",
    "                    bi=True,\n",
    "                    time_step=37\n",
    "                   ).to(device)\n",
    "        model.load_state_dict(torch.load(modelpath+f'{modelname}_{fold_}.pt'))\n",
    "\n",
    "        pred_ = pred_cuda(test_df, model)\n",
    "        tmp_c = [f'{target}_{fold_}' for target in target_cols]\n",
    "        test_df[tmp_c] = pred_\n",
    "        cols += tmp_c\n",
    "    #get rank\n",
    "    print(cols)\n",
    "    test_df[cols] = test_df[cols].rank()\n",
    "    for c in target_cols:\n",
    "        test_df[c] = test_df[[f'{c}_{fold_}' for fold_ in range(k)]].mean(axis=1)\n",
    "        test_df[c] = test_df[c].rank()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 'torch_ohe_2lstm_4logits_weight_kednall_tanh1')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k, modelname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df[[x+'_trans_y' for x in target_cols]]=np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target0_0.pt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\45928\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:15: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  from ipykernel import kernelapp as app\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "070a37c5d5fe48a09e0ca36f1bab868e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done cplfw_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target0_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5652e0ed70ba45dc9bf035477edc0138",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done cplfw_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target0_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "89dd18052b9943c9813e87e96bc63980",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done cplfw_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target0_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e4790cad19d4f189f967cdca55f5c26",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done cplfw_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target0_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4cab2c338cba4e63bb4eee8f47bb1758",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done cplfw_rank_4\n",
      "['cplfw_rank_0', 'cplfw_rank_1', 'cplfw_rank_2', 'cplfw_rank_3', 'cplfw_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target1_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b86d6f745d845d7b597c6a607dea02f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done market1501_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target1_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e05a2ed3e15e41b88f6591b5691324ab",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done market1501_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target1_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c6ac92680b84a5781c78694c41db74e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done market1501_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target1_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1fa831805a114861878ad79753839806",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done market1501_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target1_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "42486964d65142aca27352a8297d34bc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done market1501_rank_4\n",
      "['market1501_rank_0', 'market1501_rank_1', 'market1501_rank_2', 'market1501_rank_3', 'market1501_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target2_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc33f70c91b4429db89cd5a620f20714",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done dukemtmc_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target2_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8171418abe974be19b8a9dd25f083f12",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done dukemtmc_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target2_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "20e08839172f427b9196bbb62ff5ca9d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done dukemtmc_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target2_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aad51c0245304f239633438c26c314e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done dukemtmc_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target2_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bdb1f950f9de4c118348a7ca7b072c53",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done dukemtmc_rank_4\n",
      "['dukemtmc_rank_0', 'dukemtmc_rank_1', 'dukemtmc_rank_2', 'dukemtmc_rank_3', 'dukemtmc_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target3_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2bdb217c711343e8933640e69df76bcf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done msmt17_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target3_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a56939f1ebe4372a8245013ccea285b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done msmt17_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target3_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5862407b00054f3ca7cc03bf40e3dc72",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done msmt17_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target3_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f5f280c11aca49da8748d1c72f1a469b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done msmt17_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target3_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b048d65fb71244d49fb0b75c393bce94",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done msmt17_rank_4\n",
      "['msmt17_rank_0', 'msmt17_rank_1', 'msmt17_rank_2', 'msmt17_rank_3', 'msmt17_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target4_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b69640379937418cbc2a9a0de958aacd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veri_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target4_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "704108dcc7604f1a95a63edbb92987b6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veri_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target4_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "481d9fdca1df45c5b725bcf82b029caa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veri_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target4_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "46f6af27c1464e29b5cf21e548d5589e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veri_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target4_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0114679476cf4383b1ff5911a7cfb83b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veri_rank_4\n",
      "['veri_rank_0', 'veri_rank_1', 'veri_rank_2', 'veri_rank_3', 'veri_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target5_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "04cd435d1e134ff18ff88319fdfda2d6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done vehicleid_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target5_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a4374865152147cabdc4e96f7a29e0b5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done vehicleid_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target5_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "76aecfc59e81414f9388ed587f869ba5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done vehicleid_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target5_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f7c30c6972d4053ae2c0f1e5a535f63",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done vehicleid_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target5_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f17d4e7b3f594e15915fc63b27ebdd56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done vehicleid_rank_4\n",
      "['vehicleid_rank_0', 'vehicleid_rank_1', 'vehicleid_rank_2', 'vehicleid_rank_3', 'vehicleid_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target6_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3ff4c570b44c49278c0dd8d0f8ab4b9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veriwild_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target6_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "28ada6cb372e4d9e9768319d0de31d98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veriwild_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target6_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6132d4029f5d403898f328086d225d41",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veriwild_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target6_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "869a3ece3c4f494899fc694ca8bb3645",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veriwild_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target6_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9ddafdf7d0f645e381c38f793e795810",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done veriwild_rank_4\n",
      "['veriwild_rank_0', 'veriwild_rank_1', 'veriwild_rank_2', 'veriwild_rank_3', 'veriwild_rank_4']\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target7_0.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "61d3340252a246459602863fc3cc6c9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done sop_rank_0\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target7_1.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ab01ba9efd9e4adca775943338f35728",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done sop_rank_1\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target7_2.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22383ae4fc204d7d9984c739bdb2cb65",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done sop_rank_2\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target7_3.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b063403550cc4260b6f355c0ee227698",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done sop_rank_3\n",
      "Model torch_ohe_2lstm_4logits_weight_kednall_tanh1_target7_4.pt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "22663b518aed4fac9e96c6241c1c2552",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99500, 8)\n",
      "Done sop_rank_4\n",
      "['sop_rank_0', 'sop_rank_1', 'sop_rank_2', 'sop_rank_3', 'sop_rank_4']\n"
     ]
    }
   ],
   "source": [
    "predict_sig(test_df, k=5, modelname='torch_ohe_2lstm_4logits_weight_kednall_tanh1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df[target_cols] = test_df[target_cols].astype(int)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cplfw_rank         91761\n",
       "market1501_rank    91358\n",
       "dukemtmc_rank      92086\n",
       "msmt17_rank        92015\n",
       "veri_rank          92005\n",
       "vehicleid_rank     93083\n",
       "veriwild_rank      92253\n",
       "sop_rank           91416\n",
       "dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df[target_cols].nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'torch_ohe_2lstm_4logits_weight_kednall_tanh1'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to_sub\n",
    "def to_sub(test_df, test_data, name='CVPR_2022_lgb_score'):\n",
    "    for i in tqdm(test_df[['id']+target_cols].values):\n",
    "        id_ = i[0]\n",
    "        for k,v in enumerate(target_cols):\n",
    "            k += 1\n",
    "            test_data[id_][v] = i[k]\n",
    "            \n",
    "    with open(f'./sub/{name}.json', 'w') as f:\n",
    "        json.dump(test_data, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\45928\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30dbc4e095184f5596fe963fe102ae77",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/99500 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "to_sub(test_df, test_data, name='CVPR_2022_torch_ohe_2lstm_4logits_weight_kednall_tanh1')"
   ]
  },
  {
   "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 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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}