{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# About this notebook  \n",
    "\n",
    "TBD..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "if os.environ.get(\"KAGGLE_KERNEL_RUN_TYPE\") is None:\n",
    "    ON_KAGGLE = False\n",
    "else:\n",
    "    ON_KAGGLE = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['label_num_to_disease_map.json',\n",
       " 'sample_submission.csv',\n",
       " 'test_images',\n",
       " 'test_tfrecords',\n",
       " 'train.csv',\n",
       " 'train_images',\n",
       " 'train_tfrecords']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir(\"../input/cassava-leaf-disease-classification\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_id</th>\n",
       "      <th>label</th>\n",
       "      <th>source</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000015157.jpg</td>\n",
       "      <td>0</td>\n",
       "      <td>2020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1000201771.jpg</td>\n",
       "      <td>3</td>\n",
       "      <td>2020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100042118.jpg</td>\n",
       "      <td>1</td>\n",
       "      <td>2020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000723321.jpg</td>\n",
       "      <td>1</td>\n",
       "      <td>2020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1000812911.jpg</td>\n",
       "      <td>3</td>\n",
       "      <td>2020</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         image_id  label  source\n",
       "0  1000015157.jpg      0    2020\n",
       "1  1000201771.jpg      3    2020\n",
       "2   100042118.jpg      1    2020\n",
       "3  1000723321.jpg      1    2020\n",
       "4  1000812911.jpg      3    2020"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_id</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2216849948.jpg</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         image_id  label\n",
       "0  2216849948.jpg      4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Cassava Bacterial Blight (CBB)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Cassava Brown Streak Disease (CBSD)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Cassava Green Mottle (CGM)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Cassava Mosaic Disease (CMD)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Healthy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                     0\n",
       "0       Cassava Bacterial Blight (CBB)\n",
       "1  Cassava Brown Streak Disease (CBSD)\n",
       "2           Cassava Green Mottle (CGM)\n",
       "3         Cassava Mosaic Disease (CMD)\n",
       "4                              Healthy"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# train = pd.read_csv(\"../input/cassava-leaf-disease-classification/train.csv\")\n",
    "train = pd.read_csv(\"../input/cassava-leaf-disease-merged/merged.csv\")\n",
    "# train = pd.read_csv(\"../input/cassava-leaf-disease-merged/oversample-0124.csv\")  # label 0124 x3\n",
    "test = pd.read_csv(\"../input/cassava-leaf-disease-classification/sample_submission.csv\")\n",
    "label_map = pd.read_json(\"../input/cassava-leaf-disease-classification/label_num_to_disease_map.json\", orient=\"index\")\n",
    "display(train.head())\n",
    "display(test.head())\n",
    "display(label_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sugi/kernel/kaggle/.venv/lib/python3.7/site-packages/seaborn/distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='label'>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(train[\"label\"], kde=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Directory settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Directory settings\n",
    "# ====================================================\n",
    "import os\n",
    "\n",
    "OUTPUT_DIR = \"./\"\n",
    "if not os.path.exists(OUTPUT_DIR):\n",
    "    os.makedirs(OUTPUT_DIR)\n",
    "\n",
    "# TRAIN_PATH = \"../input/cassava-leaf-disease-classification/train_images\"\n",
    "TRAIN_PATH = \"../input/cassava-leaf-disease-merged/train\"\n",
    "TEST_PATH = \"../input/cassava-leaf-disease-classification/test_images\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CFG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# CFG\n",
    "# ====================================================\n",
    "class CFG:\n",
    "    debug = False\n",
    "    apex = False\n",
    "    print_freq = 100\n",
    "    num_workers = 4\n",
    "    model_name = (\n",
    "        \"tf_efficientnet_b4_ns\"  # resnext50_32x4d, tf_efficientnet_b3_ns, tf_efficientnet_b4_ns, vit_base_patch16_384\n",
    "    )\n",
    "    size = 384 if model_name.startswith(\"vit_base_\") else 512  # 512 if ON_KAGGLE else 384\n",
    "    criterion = \"BiTemperedLoss\"  # ['CrossEntropyLoss', 'BiTemperedLoss']\n",
    "    btl_t1 = 0.3  # Bi-Tempered Logistic Loss\n",
    "    btl_t2 = 1.0\n",
    "    label_smoothing = 0.05\n",
    "    scheduler = (\n",
    "        \"CosineAnnealingWarmRestarts\"  # ['ReduceLROnPlateau', 'CosineAnnealingLR', 'CosineAnnealingWarmRestarts']\n",
    "    )\n",
    "    epochs = 10\n",
    "    # factor=0.2 # ReduceLROnPlateau\n",
    "    # patience=4 # ReduceLROnPlateau\n",
    "    # eps=1e-6 # ReduceLROnPlateau\n",
    "    # T_max=10 # CosineAnnealingLR\n",
    "    T_0 = 10  # CosineAnnealingWarmRestarts\n",
    "    lr = 1e-4\n",
    "    min_lr = 1e-6\n",
    "    batch_size = 16  # resnext50_32x4d: 14-30, tf_efficientnet_b3_ns:10-22, tf_efficientnet_b4_ns: 8-16\n",
    "    weight_decay = 1e-6\n",
    "    gradient_accumulation_steps = 1\n",
    "    max_grad_norm = 1000\n",
    "    seed = 456\n",
    "    target_size = 5\n",
    "    target_col = \"label\"\n",
    "    n_fold = 5\n",
    "    trn_fold = [0, 1, 2, 3, 4]\n",
    "    train = True\n",
    "    inference = False\n",
    "\n",
    "\n",
    "if CFG.debug:\n",
    "    CFG.epochs = 1\n",
    "    train = train.sample(n=1000, random_state=CFG.seed).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Library\n",
    "# ====================================================\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"../input/pytorch-image-models/pytorch-image-models-master\")\n",
    "sys.path.append(\"../input/bitemperedlogloss/\")\n",
    "sys.path.append(\"../input/image-fmix/FMix-master\")\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import shutil\n",
    "import time\n",
    "import warnings\n",
    "from collections import Counter, defaultdict\n",
    "from contextlib import contextmanager\n",
    "from functools import partial\n",
    "from pathlib import Path\n",
    "\n",
    "import bi_tempered_loss_pytorch as btl\n",
    "import cv2\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy as sp\n",
    "import timm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision.models as models\n",
    "from albumentations import (\n",
    "    CoarseDropout,\n",
    "    Compose,\n",
    "    Cutout,\n",
    "    HorizontalFlip,\n",
    "    HueSaturationValue,\n",
    "    IAAAdditiveGaussianNoise,\n",
    "    ImageOnlyTransform,\n",
    "    Normalize,\n",
    "    OneOf,\n",
    "    RandomBrightness,\n",
    "    RandomBrightnessContrast,\n",
    "    RandomContrast,\n",
    "    RandomCrop,\n",
    "    RandomResizedCrop,\n",
    "    Resize,\n",
    "    Rotate,\n",
    "    ShiftScaleRotate,\n",
    "    Transpose,\n",
    "    VerticalFlip,\n",
    ")\n",
    "from albumentations.pytorch import ToTensorV2\n",
    "from fmix import sample_mask\n",
    "from PIL import Image\n",
    "from sklearn import preprocessing\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from torch.nn.parameter import Parameter\n",
    "from torch.optim import SGD, Adam\n",
    "from torch.optim.lr_scheduler import CosineAnnealingLR, CosineAnnealingWarmRestarts, ReduceLROnPlateau\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "if CFG.apex:\n",
    "    from apex import amp\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Utils\n",
    "# ====================================================\n",
    "def get_score(y_true, y_pred):\n",
    "    return accuracy_score(y_true, y_pred)\n",
    "\n",
    "\n",
    "@contextmanager\n",
    "def timer(name):\n",
    "    t0 = time.time()\n",
    "    LOGGER.info(f\"[{name}] start\")\n",
    "    yield\n",
    "    LOGGER.info(f\"[{name}] done in {time.time() - t0:.0f} s.\")\n",
    "\n",
    "\n",
    "def init_logger(log_file=OUTPUT_DIR + \"train.log\"):\n",
    "    from logging import INFO, FileHandler, Formatter, StreamHandler, getLogger\n",
    "\n",
    "    logger = getLogger(__name__)\n",
    "    logger.setLevel(INFO)\n",
    "    handler1 = StreamHandler()\n",
    "    handler1.setFormatter(Formatter(\"%(message)s\"))\n",
    "    handler2 = FileHandler(filename=log_file)\n",
    "    handler2.setFormatter(Formatter(\"%(message)s\"))\n",
    "    logger.addHandler(handler1)\n",
    "    logger.addHandler(handler2)\n",
    "    return logger\n",
    "\n",
    "\n",
    "LOGGER = init_logger()\n",
    "\n",
    "\n",
    "def seed_torch(seed=42):\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",
    "\n",
    "\n",
    "seed_torch(seed=CFG.seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CV split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fold  label\n",
      "0     0         299\n",
      "      1         695\n",
      "      2         604\n",
      "      3        3092\n",
      "      4         578\n",
      "1     0         299\n",
      "      1         695\n",
      "      2         604\n",
      "      3        3092\n",
      "      4         578\n",
      "2     0         298\n",
      "      1         695\n",
      "      2         603\n",
      "      3        3093\n",
      "      4         578\n",
      "3     0         298\n",
      "      1         695\n",
      "      2         603\n",
      "      3        3093\n",
      "      4         578\n",
      "4     0         298\n",
      "      1         696\n",
      "      2         603\n",
      "      3        3092\n",
      "      4         578\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "folds = train.copy()\n",
    "Fold = StratifiedKFold(n_splits=CFG.n_fold, shuffle=True, random_state=CFG.seed)\n",
    "for n, (train_index, val_index) in enumerate(Fold.split(folds, folds[CFG.target_col])):\n",
    "    folds.loc[val_index, \"fold\"] = int(n)\n",
    "folds[\"fold\"] = folds[\"fold\"].astype(int)\n",
    "print(folds.groupby([\"fold\", CFG.target_col]).size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Dataset\n",
    "# ====================================================\n",
    "class TrainDataset(Dataset):\n",
    "    def __init__(self, df, transform=None):\n",
    "        self.df = df\n",
    "        self.file_names = df[\"image_id\"].values\n",
    "        self.labels = df[\"label\"].values\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.df)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        file_name = self.file_names[idx]\n",
    "        file_path = f\"{TRAIN_PATH}/{file_name}\"\n",
    "        image = cv2.imread(file_path)\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        if self.transform:\n",
    "            augmented = self.transform(image=image)\n",
    "            image = augmented[\"image\"]\n",
    "        label = torch.tensor(self.labels[idx]).long()\n",
    "        return image, label\n",
    "\n",
    "\n",
    "class TestDataset(Dataset):\n",
    "    def __init__(self, df, transform=None):\n",
    "        self.df = df\n",
    "        self.file_names = df[\"image_id\"].values\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.df)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        file_name = self.file_names[idx]\n",
    "        file_path = f\"{TEST_PATH}/{file_name}\"\n",
    "        image = cv2.imread(file_path)\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        if self.transform:\n",
    "            augmented = self.transform(image=image)\n",
    "            image = augmented[\"image\"]\n",
    "        return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_dataset = TrainDataset(train, transform=None)\n",
    "\n",
    "for i in range(1):\n",
    "    image, label = train_dataset[i]\n",
    "    plt.imshow(image)\n",
    "    plt.title(f\"label: {label}\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Transforms\n",
    "# ====================================================\n",
    "def get_transforms(*, data):\n",
    "\n",
    "    if data == \"train\":\n",
    "        return Compose(\n",
    "            [\n",
    "                # Resize(CFG.size, CFG.size),\n",
    "                RandomResizedCrop(CFG.size, CFG.size),\n",
    "                Transpose(p=0.5),\n",
    "                HorizontalFlip(p=0.5),\n",
    "                VerticalFlip(p=0.5),\n",
    "                ShiftScaleRotate(p=0.5),\n",
    "                HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),\n",
    "                RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5),\n",
    "                CoarseDropout(p=0.5),\n",
    "                Cutout(p=0.5),\n",
    "                Normalize(\n",
    "                    mean=[0.485, 0.456, 0.406],\n",
    "                    std=[0.229, 0.224, 0.225],\n",
    "                ),\n",
    "                ToTensorV2(),\n",
    "            ]\n",
    "        )\n",
    "\n",
    "    elif data == \"valid\":\n",
    "        return Compose(\n",
    "            [\n",
    "                Resize(CFG.size, CFG.size),\n",
    "                Normalize(\n",
    "                    mean=[0.485, 0.456, 0.406],\n",
    "                    std=[0.229, 0.224, 0.225],\n",
    "                ),\n",
    "                ToTensorV2(),\n",
    "            ]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_dataset = TrainDataset(train, transform=get_transforms(data=\"train\"))\n",
    "\n",
    "for i in range(1):\n",
    "    image, label = train_dataset[i]\n",
    "    plt.imshow(image[0])\n",
    "    plt.title(f\"label: {label}\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CutMix / FMix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rand_bbox(size, lam):\n",
    "    W = size[2]\n",
    "    H = size[3]\n",
    "    cut_rat = np.sqrt(1.0 - lam)\n",
    "    cut_w = np.int(W * cut_rat)\n",
    "    cut_h = np.int(H * cut_rat)\n",
    "\n",
    "    # uniform\n",
    "    cx = np.random.randint(W)\n",
    "    cy = np.random.randint(H)\n",
    "\n",
    "    bbx1 = np.clip(cx - cut_w // 2, 0, W)\n",
    "    bby1 = np.clip(cy - cut_h // 2, 0, H)\n",
    "    bbx2 = np.clip(cx + cut_w // 2, 0, W)\n",
    "    bby2 = np.clip(cy + cut_h // 2, 0, H)\n",
    "    return bbx1, bby1, bbx2, bby2\n",
    "\n",
    "\n",
    "def cutmix(data, target, alpha):\n",
    "    indices = torch.randperm(data.size(0))\n",
    "    shuffled_data = data[indices]\n",
    "    shuffled_target = target[indices]\n",
    "\n",
    "    lam = np.clip(np.random.beta(alpha, alpha), 0.3, 0.4)\n",
    "    bbx1, bby1, bbx2, bby2 = rand_bbox(data.size(), lam)\n",
    "    new_data = data.clone()\n",
    "    new_data[:, :, bby1:bby2, bbx1:bbx2] = data[indices, :, bby1:bby2, bbx1:bbx2]\n",
    "    # adjust lambda to exactly match pixel ratio\n",
    "    lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (data.size()[-1] * data.size()[-2]))\n",
    "    targets = (target, shuffled_target, lam)\n",
    "\n",
    "    return new_data, targets\n",
    "\n",
    "\n",
    "def fmix(data, targets, alpha, decay_power, shape, max_soft=0.0, reformulate=False):\n",
    "    lam, mask = sample_mask(alpha, decay_power, shape, max_soft, reformulate)\n",
    "    # mask =torch.tensor(mask, device=device).float()\n",
    "    indices = torch.randperm(data.size(0))\n",
    "    shuffled_data = data[indices]\n",
    "    shuffled_targets = targets[indices]\n",
    "    x1 = torch.from_numpy(mask).to(device) * data\n",
    "    x2 = torch.from_numpy(1 - mask).to(device) * shuffled_data\n",
    "    targets = (targets, shuffled_targets, lam)\n",
    "\n",
    "    return (x1 + x2), targets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MODEL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# MODEL\n",
    "# ====================================================\n",
    "class CassvaImgClassifier(nn.Module):\n",
    "    def __init__(self, model_name=\"resnext50_32x4d\", pretrained=False):\n",
    "        super().__init__()\n",
    "        self.model = timm.create_model(model_name, pretrained=pretrained)\n",
    "\n",
    "        if model_name == \"resnext50_32x4d\":\n",
    "            n_features = self.model.fc.in_features\n",
    "            self.model.fc = nn.Linear(n_features, CFG.target_size)\n",
    "\n",
    "        elif model_name.startswith(\"tf_efficientnet\"):\n",
    "            n_features = self.model.classifier.in_features\n",
    "            self.model.classifier = nn.Linear(n_features, CFG.target_size)\n",
    "\n",
    "        elif model_name.startswith(\"vit_base_\"):\n",
    "            n_features = self.model.head.in_features\n",
    "            self.model.head = nn.Linear(n_features, CFG.target_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.model(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def freeze_batch_normalization(model):\n",
    "    if CFG.model_name.startswith(\"tf_efficientnet_\"):\n",
    "        for name1, child1 in model.named_children():\n",
    "            for name2, child2 in child1.named_children():\n",
    "                # print(f\"===== {name2} =====\")\n",
    "                if name2.startswith(\"bn\"):\n",
    "                    for param in child2.parameters():\n",
    "                        param.requires_grad = False\n",
    "                        # print(param.requires_grad)\n",
    "\n",
    "                for child3 in child2.children():\n",
    "                    if isinstance(child3, nn.modules.container.Sequential):\n",
    "                        for child4 in child3.children():\n",
    "                            for child5 in child4.children():\n",
    "                                if isinstance(child5, nn.BatchNorm2d):\n",
    "                                    # print(child5)\n",
    "                                    for param in child5.parameters():\n",
    "                                        param.requires_grad = False\n",
    "                                        # print(param.requires_grad)\n",
    "\n",
    "    elif CFG.model_name.startswith(\"resnext50_32x4d\"):\n",
    "        for name1, child1 in model.named_children():\n",
    "            for name2, child2 in child1.named_children():\n",
    "                # print(f\"===== {name2}: {type(child2)} =====\")\n",
    "                if name2.startswith(\"bn\"):\n",
    "                    for param in child2.parameters():\n",
    "                        param.requires_grad = False\n",
    "                        # print(param.requires_grad)\n",
    "\n",
    "                if isinstance(child2, nn.modules.container.Sequential):\n",
    "                    for child3 in child2.children():\n",
    "                        for child4 in child3.children():\n",
    "                            if isinstance(child4, nn.BatchNorm2d):\n",
    "                                # print(child4)\n",
    "                                for param in child4.parameters():\n",
    "                                    param.requires_grad = False\n",
    "                                    # print(param.requires_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.0077, -0.1135, -0.1015,  0.0450,  0.1333],\n",
      "        [ 0.3224,  0.1105, -0.0015, -0.2977, -0.2364],\n",
      "        [ 0.2010,  0.1567, -0.0204, -0.1257, -0.1870],\n",
      "        [-0.0093, -0.1135, -0.0722,  0.0301,  0.1537]],\n",
      "       grad_fn=<AddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "model = CassvaImgClassifier(model_name=CFG.model_name, pretrained=False)\n",
    "freeze_batch_normalization(model)\n",
    "\n",
    "train_dataset = TrainDataset(train, transform=get_transforms(data=\"train\"))\n",
    "train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=4, pin_memory=True, drop_last=True)\n",
    "\n",
    "for image, label in train_loader:\n",
    "    output = model(image)\n",
    "    print(output)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BiTemperedLogisticLoss(nn.Module):\n",
    "    def __init__(self, t1, t2, smoothing=0.0):\n",
    "        super(BiTemperedLogisticLoss, self).__init__()\n",
    "        self.t1 = t1\n",
    "        self.t2 = t2\n",
    "        self.smoothing = smoothing\n",
    "\n",
    "    def forward(self, logit_label, truth_label):\n",
    "        loss_label = btl.bi_tempered_logistic_loss(\n",
    "            logit_label, truth_label, t1=self.t1, t2=self.t2, label_smoothing=self.smoothing, reduction=\"none\"\n",
    "        )\n",
    "\n",
    "        loss_label = loss_label.mean()\n",
    "        return loss_label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Helper functions\n",
    "# ====================================================\n",
    "class AverageMeter(object):\n",
    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.val = 0\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.count = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.val = val\n",
    "        self.sum += val * n\n",
    "        self.count += n\n",
    "        self.avg = self.sum / self.count\n",
    "\n",
    "\n",
    "def asMinutes(s):\n",
    "    m = math.floor(s / 60)\n",
    "    s -= m * 60\n",
    "    return \"%dm %ds\" % (m, s)\n",
    "\n",
    "\n",
    "def timeSince(since, percent):\n",
    "    now = time.time()\n",
    "    s = now - since\n",
    "    es = s / (percent)\n",
    "    rs = es - s\n",
    "    return \"%s (remain %s)\" % (asMinutes(s), asMinutes(rs))\n",
    "\n",
    "\n",
    "def train_fn(train_loader, model, criterion, optimizer, epoch, scheduler, device):\n",
    "    batch_time = AverageMeter()\n",
    "    data_time = AverageMeter()\n",
    "    losses = AverageMeter()\n",
    "    scores = AverageMeter()\n",
    "    # switch to train mode\n",
    "    model.train()\n",
    "    start = end = time.time()\n",
    "    global_step = 0\n",
    "    for step, (images, labels) in enumerate(train_loader):\n",
    "        # measure data loading time\n",
    "        data_time.update(time.time() - end)\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        batch_size = labels.size(0)\n",
    "\n",
    "        # CutMix, FMix\n",
    "        mix_decision = np.random.rand()\n",
    "        if mix_decision < 0.25:\n",
    "            images, labels = cutmix(images, labels, 1.0)\n",
    "        elif mix_decision >= 0.25 and mix_decision < 0.5:\n",
    "            images, labels = fmix(images, labels, alpha=1.0, decay_power=5.0, shape=(CFG.size, CFG.size))\n",
    "\n",
    "        y_preds = model(images.float())\n",
    "\n",
    "        if mix_decision < 0.50:\n",
    "            loss = criterion(y_preds, labels[0]) * labels[2] + criterion(y_preds, labels[1]) * (1.0 - labels[2])\n",
    "        else:\n",
    "            loss = criterion(y_preds, labels)\n",
    "\n",
    "        # record loss\n",
    "        losses.update(loss.item(), batch_size)\n",
    "        if CFG.gradient_accumulation_steps > 1:\n",
    "            loss = loss / CFG.gradient_accumulation_steps\n",
    "        if CFG.apex:\n",
    "            with amp.scale_loss(loss, optimizer) as scaled_loss:\n",
    "                scaled_loss.backward()\n",
    "        else:\n",
    "            loss.backward()\n",
    "        grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), CFG.max_grad_norm)\n",
    "        if (step + 1) % CFG.gradient_accumulation_steps == 0:\n",
    "            optimizer.step()\n",
    "            optimizer.zero_grad()\n",
    "            global_step += 1\n",
    "        # measure elapsed time\n",
    "        batch_time.update(time.time() - end)\n",
    "        end = time.time()\n",
    "        if step % CFG.print_freq == 0 or step == (len(train_loader) - 1):\n",
    "            print(\n",
    "                \"Epoch: [{0}][{1}/{2}] \"\n",
    "                \"Data {data_time.val:.3f} ({data_time.avg:.3f}) \"\n",
    "                \"Elapsed {remain:s} \"\n",
    "                \"Loss: {loss.val:.4f}({loss.avg:.4f}) \"\n",
    "                \"Grad: {grad_norm:.4f}  \"\n",
    "                #'LR: {lr:.6f}  '\n",
    "                .format(\n",
    "                    epoch + 1,\n",
    "                    step,\n",
    "                    len(train_loader),\n",
    "                    batch_time=batch_time,\n",
    "                    data_time=data_time,\n",
    "                    loss=losses,\n",
    "                    remain=timeSince(start, float(step + 1) / len(train_loader)),\n",
    "                    grad_norm=grad_norm,\n",
    "                    # lr=scheduler.get_lr()[0],\n",
    "                )\n",
    "            )\n",
    "    return losses.avg\n",
    "\n",
    "\n",
    "def valid_fn(valid_loader, model, criterion, device):\n",
    "    batch_time = AverageMeter()\n",
    "    data_time = AverageMeter()\n",
    "    losses = AverageMeter()\n",
    "    scores = AverageMeter()\n",
    "    # switch to evaluation mode\n",
    "    model.eval()\n",
    "    preds = []\n",
    "    start = end = time.time()\n",
    "    for step, (images, labels) in enumerate(valid_loader):\n",
    "        # measure data loading time\n",
    "        data_time.update(time.time() - end)\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "        batch_size = labels.size(0)\n",
    "        # compute loss\n",
    "        with torch.no_grad():\n",
    "            y_preds = model(images)\n",
    "        loss = criterion(y_preds, labels)\n",
    "        losses.update(loss.item(), batch_size)\n",
    "        # record accuracy\n",
    "        preds.append(y_preds.softmax(1).to(\"cpu\").numpy())\n",
    "        if CFG.gradient_accumulation_steps > 1:\n",
    "            loss = loss / CFG.gradient_accumulation_steps\n",
    "        # measure elapsed time\n",
    "        batch_time.update(time.time() - end)\n",
    "        end = time.time()\n",
    "        if step % CFG.print_freq == 0 or step == (len(valid_loader) - 1):\n",
    "            print(\n",
    "                \"EVAL: [{0}/{1}] \"\n",
    "                \"Data {data_time.val:.3f} ({data_time.avg:.3f}) \"\n",
    "                \"Elapsed {remain:s} \"\n",
    "                \"Loss: {loss.val:.4f}({loss.avg:.4f}) \".format(\n",
    "                    step,\n",
    "                    len(valid_loader),\n",
    "                    batch_time=batch_time,\n",
    "                    data_time=data_time,\n",
    "                    loss=losses,\n",
    "                    remain=timeSince(start, float(step + 1) / len(valid_loader)),\n",
    "                )\n",
    "            )\n",
    "    predictions = np.concatenate(preds)\n",
    "    return losses.avg, predictions\n",
    "\n",
    "\n",
    "def inference(model, states, test_loader, device):\n",
    "    model.to(device)\n",
    "    tk0 = tqdm(enumerate(test_loader), total=len(test_loader))\n",
    "    probs = []\n",
    "    for i, (images) in tk0:\n",
    "        images = images.to(device)\n",
    "        avg_preds = []\n",
    "        for state in states:\n",
    "            model.load_state_dict(state[\"model\"])\n",
    "            model.eval()\n",
    "            with torch.no_grad():\n",
    "                y_preds = model(images)\n",
    "            avg_preds.append(y_preds.softmax(1).to(\"cpu\").numpy())\n",
    "        avg_preds = np.mean(avg_preds, axis=0)\n",
    "        probs.append(avg_preds)\n",
    "    probs = np.concatenate(probs)\n",
    "    return probs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# Train loop\n",
    "# ====================================================\n",
    "def train_loop(folds, fold):\n",
    "\n",
    "    LOGGER.info(f\"========== fold: {fold} training ==========\")\n",
    "\n",
    "    # ====================================================\n",
    "    # loader\n",
    "    # ====================================================\n",
    "    trn_idx = folds[folds[\"fold\"] != fold].index\n",
    "    val_idx = folds[folds[\"fold\"] == fold].index\n",
    "\n",
    "    train_folds = folds.loc[trn_idx].reset_index(drop=True)\n",
    "    valid_folds = folds.loc[val_idx].reset_index(drop=True)\n",
    "\n",
    "    train_dataset = TrainDataset(train_folds, transform=get_transforms(data=\"train\"))\n",
    "    valid_dataset = TrainDataset(valid_folds, transform=get_transforms(data=\"valid\"))\n",
    "\n",
    "    train_loader = DataLoader(\n",
    "        train_dataset,\n",
    "        batch_size=CFG.batch_size,\n",
    "        shuffle=True,\n",
    "        num_workers=CFG.num_workers,\n",
    "        pin_memory=True,\n",
    "        drop_last=True,\n",
    "    )\n",
    "    valid_loader = DataLoader(\n",
    "        valid_dataset,\n",
    "        batch_size=CFG.batch_size,\n",
    "        shuffle=False,\n",
    "        num_workers=CFG.num_workers,\n",
    "        pin_memory=True,\n",
    "        drop_last=False,\n",
    "    )\n",
    "\n",
    "    # ====================================================\n",
    "    # scheduler\n",
    "    # ====================================================\n",
    "    def get_scheduler(optimizer):\n",
    "        if CFG.scheduler == \"ReduceLROnPlateau\":\n",
    "            scheduler = ReduceLROnPlateau(\n",
    "                optimizer, mode=\"min\", factor=CFG.factor, patience=CFG.patience, verbose=True, eps=CFG.eps\n",
    "            )\n",
    "        elif CFG.scheduler == \"CosineAnnealingLR\":\n",
    "            scheduler = CosineAnnealingLR(optimizer, T_max=CFG.T_max, eta_min=CFG.min_lr, last_epoch=-1)\n",
    "        elif CFG.scheduler == \"CosineAnnealingWarmRestarts\":\n",
    "            scheduler = CosineAnnealingWarmRestarts(optimizer, T_0=CFG.T_0, T_mult=1, eta_min=CFG.min_lr, last_epoch=-1)\n",
    "        return scheduler\n",
    "\n",
    "    # ====================================================\n",
    "    # model & optimizer\n",
    "    # ====================================================\n",
    "    model = CassvaImgClassifier(CFG.model_name, pretrained=True)\n",
    "    freeze_batch_normalization(model)\n",
    "\n",
    "    model.to(device)\n",
    "\n",
    "    # Use multi GPU\n",
    "    if device == torch.device(\"cuda\"):\n",
    "        model = torch.nn.DataParallel(model)  # make parallel\n",
    "        # torch.backends.cudnn.benchmark=True\n",
    "\n",
    "    optimizer = Adam(model.parameters(), lr=CFG.lr, weight_decay=CFG.weight_decay, amsgrad=False)\n",
    "    scheduler = get_scheduler(optimizer)\n",
    "\n",
    "    # ====================================================\n",
    "    # apex\n",
    "    # ====================================================\n",
    "    if CFG.apex:\n",
    "        model, optimizer = amp.initialize(model, optimizer, opt_level=\"O1\", verbosity=0)\n",
    "\n",
    "    # ====================================================\n",
    "    # Criterion\n",
    "    # ====================================================\n",
    "    def get_criterion():\n",
    "        if CFG.criterion == \"CrossEntropyLoss\":\n",
    "            criterion = nn.CrossEntropyLoss()\n",
    "        elif CFG.criterion == \"BiTemperedLoss\":\n",
    "            criterion = BiTemperedLogisticLoss(t1=CFG.btl_t1, t2=CFG.btl_t2, smoothing=CFG.label_smoothing)\n",
    "        return criterion\n",
    "\n",
    "    criterion = get_criterion()\n",
    "\n",
    "    # ====================================================\n",
    "    # loop\n",
    "    # ====================================================\n",
    "    best_score = 0.0\n",
    "    best_loss = np.inf\n",
    "\n",
    "    for epoch in range(CFG.epochs):\n",
    "\n",
    "        start_time = time.time()\n",
    "\n",
    "        # train\n",
    "        avg_loss = train_fn(train_loader, model, criterion, optimizer, epoch, scheduler, device)\n",
    "\n",
    "        # eval\n",
    "        avg_val_loss, preds = valid_fn(valid_loader, model, criterion, device)\n",
    "        valid_labels = valid_folds[CFG.target_col].values\n",
    "\n",
    "        if isinstance(scheduler, ReduceLROnPlateau):\n",
    "            scheduler.step(avg_val_loss)\n",
    "        elif isinstance(scheduler, CosineAnnealingLR):\n",
    "            scheduler.step()\n",
    "        elif isinstance(scheduler, CosineAnnealingWarmRestarts):\n",
    "            scheduler.step()\n",
    "\n",
    "        # scoring\n",
    "        score = get_score(valid_labels, preds.argmax(1))\n",
    "\n",
    "        elapsed = time.time() - start_time\n",
    "\n",
    "        LOGGER.info(\n",
    "            f\"Epoch {epoch+1} - avg_train_loss: {avg_loss:.4f}  avg_val_loss: {avg_val_loss:.4f}  time: {elapsed:.0f}s\"\n",
    "        )\n",
    "        LOGGER.info(f\"Epoch {epoch+1} - Accuracy: {score}\")\n",
    "\n",
    "        if score > best_score:\n",
    "            best_score = score\n",
    "            LOGGER.info(f\"Epoch {epoch+1} - Save Best Score: {best_score:.4f} Model\")\n",
    "            torch.save(\n",
    "                {\"model\": model.state_dict(), \"preds\": preds}, OUTPUT_DIR + f\"{CFG.model_name}_fold{fold}_best.pth\"\n",
    "            )\n",
    "\n",
    "    check_point = torch.load(OUTPUT_DIR + f\"{CFG.model_name}_fold{fold}_best.pth\")\n",
    "    valid_folds[[str(c) for c in range(5)]] = check_point[\"preds\"]\n",
    "    valid_folds[\"preds\"] = check_point[\"preds\"].argmax(1)\n",
    "\n",
    "    return valid_folds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ====================================================\n",
    "# main\n",
    "# ====================================================\n",
    "def main():\n",
    "\n",
    "    \"\"\"\n",
    "    Prepare: 1.train  2.test  3.submission  4.folds\n",
    "    \"\"\"\n",
    "\n",
    "    def get_result(result_df):\n",
    "        preds = result_df[\"preds\"].values\n",
    "        labels = result_df[CFG.target_col].values\n",
    "        score = get_score(labels, preds)\n",
    "        LOGGER.info(f\"Score: {score:<.5f}\")\n",
    "\n",
    "    if CFG.train:\n",
    "        # train\n",
    "        oof_df = pd.DataFrame()\n",
    "        for fold in range(CFG.n_fold):\n",
    "            if fold in CFG.trn_fold:\n",
    "                _oof_df = train_loop(folds, fold)\n",
    "                oof_df = pd.concat([oof_df, _oof_df])\n",
    "                LOGGER.info(f\"========== fold: {fold} result ==========\")\n",
    "                get_result(_oof_df)\n",
    "        # CV result\n",
    "        LOGGER.info(f\"========== CV ==========\")\n",
    "        get_result(oof_df)\n",
    "        # save result\n",
    "        oof_df.to_csv(OUTPUT_DIR + \"oof_df.csv\", index=False)\n",
    "\n",
    "    if CFG.inference:\n",
    "        # inference\n",
    "        model = CassvaImgClassifier(CFG.model_name, pretrained=False)\n",
    "        states = [torch.load(OUTPUT_DIR + f\"{CFG.model_name}_fold{fold}_best.pth\") for fold in CFG.trn_fold]\n",
    "        test_dataset = TestDataset(test, transform=get_transforms(data=\"valid\"))\n",
    "        test_loader = DataLoader(\n",
    "            test_dataset, batch_size=CFG.batch_size, shuffle=False, num_workers=CFG.num_workers, pin_memory=True\n",
    "        )\n",
    "        predictions = inference(model, states, test_loader, device)\n",
    "        # submission\n",
    "        test[\"label\"] = predictions.argmax(1)\n",
    "        test[[\"image_id\", \"label\"]].to_csv(OUTPUT_DIR + \"submission.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "========== fold: 0 training ==========\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [1][0/1316] Data 0.924 (0.924) Elapsed 0m 4s (remain 108m 47s) Loss: 0.4978(0.4978) Grad: 0.7005  \n",
      "Epoch: [1][100/1316] Data 0.000 (0.009) Elapsed 2m 28s (remain 29m 40s) Loss: 0.2022(0.3485) Grad: 0.6275  \n",
      "Epoch: [1][200/1316] Data 0.000 (0.005) Elapsed 4m 52s (remain 27m 0s) Loss: 0.2485(0.3150) Grad: 0.5406  \n",
      "Epoch: [1][300/1316] Data 0.000 (0.003) Elapsed 7m 16s (remain 24m 32s) Loss: 0.2593(0.2909) Grad: 0.7517  \n",
      "Epoch: [1][400/1316] Data 0.000 (0.002) Elapsed 9m 41s (remain 22m 7s) Loss: 0.2433(0.2804) Grad: 0.8455  \n",
      "Epoch: [1][500/1316] Data 0.000 (0.002) Elapsed 12m 6s (remain 19m 42s) Loss: 0.0991(0.2709) Grad: 0.6197  \n",
      "Epoch: [1][600/1316] Data 0.000 (0.002) Elapsed 14m 32s (remain 17m 17s) Loss: 0.1718(0.2639) Grad: 0.9474  \n",
      "Epoch: [1][700/1316] Data 0.000 (0.001) Elapsed 16m 57s (remain 14m 52s) Loss: 0.5015(0.2571) Grad: 0.5796  \n",
      "Epoch: [1][800/1316] Data 0.000 (0.001) Elapsed 19m 23s (remain 12m 27s) Loss: 0.3637(0.2517) Grad: 0.6114  \n",
      "Epoch: [1][900/1316] Data 0.000 (0.001) Elapsed 21m 48s (remain 10m 2s) Loss: 0.2223(0.2471) Grad: 0.5962  \n",
      "Epoch: [1][1000/1316] Data 0.000 (0.001) Elapsed 24m 14s (remain 7m 37s) Loss: 0.3470(0.2442) Grad: 0.7353  \n",
      "Epoch: [1][1100/1316] Data 0.000 (0.001) Elapsed 26m 40s (remain 5m 12s) Loss: 0.2258(0.2408) Grad: 0.7489  \n",
      "Epoch: [1][1200/1316] Data 0.000 (0.001) Elapsed 29m 5s (remain 2m 47s) Loss: 0.2783(0.2388) Grad: 1.2229  \n",
      "Epoch: [1][1300/1316] Data 0.000 (0.001) Elapsed 31m 31s (remain 0m 21s) Loss: 0.1072(0.2362) Grad: 0.7449  \n",
      "Epoch: [1][1315/1316] Data 0.000 (0.001) Elapsed 31m 53s (remain 0m 0s) Loss: 0.3457(0.2359) Grad: 0.8033  \n",
      "EVAL: [0/330] Data 0.487 (0.487) Elapsed 0m 1s (remain 5m 35s) Loss: 0.0767(0.0767) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 44s (remain 1m 39s) Loss: 0.2550(0.1107) \n",
      "EVAL: [200/330] Data 0.000 (0.003) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1742(0.1095) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1253(0.1147) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1 - avg_train_loss: 0.2359  avg_val_loss: 0.1154  time: 2056s\n",
      "Epoch 1 - Accuracy: 0.8733864844343204\n",
      "Epoch 1 - Save Best Score: 0.8734 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.2288(0.1154) \n",
      "Epoch: [2][0/1316] Data 0.482 (0.482) Elapsed 0m 1s (remain 43m 39s) Loss: 0.2903(0.2903) Grad: 0.4568  \n",
      "Epoch: [2][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 40s) Loss: 0.2099(0.1977) Grad: 1.2390  \n",
      "Epoch: [2][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.1351(0.2036) Grad: 0.9939  \n",
      "Epoch: [2][300/1316] Data 0.000 (0.002) Elapsed 7m 20s (remain 24m 44s) Loss: 0.1545(0.1961) Grad: 0.6895  \n",
      "Epoch: [2][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 17s) Loss: 0.2125(0.1947) Grad: 0.8309  \n",
      "Epoch: [2][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2387(0.1945) Grad: 0.4939  \n",
      "Epoch: [2][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.2215(0.1946) Grad: 0.5326  \n",
      "Epoch: [2][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.0256(0.1968) Grad: 0.3253  \n",
      "Epoch: [2][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.1472(0.1954) Grad: 0.6280  \n",
      "Epoch: [2][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1047(0.1944) Grad: 1.1341  \n",
      "Epoch: [2][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.3487(0.1952) Grad: 0.6722  \n",
      "Epoch: [2][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.1480(0.1958) Grad: 0.7410  \n",
      "Epoch: [2][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2114(0.1965) Grad: 0.4567  \n",
      "Epoch: [2][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.2884(0.1967) Grad: 0.5203  \n",
      "Epoch: [2][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.1910(0.1967) Grad: 0.8041  \n",
      "EVAL: [0/330] Data 0.383 (0.383) Elapsed 0m 0s (remain 4m 48s) Loss: 0.0467(0.0467) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2596(0.1040) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1997(0.1073) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1140(0.1124) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2 - avg_train_loss: 0.1967  avg_val_loss: 0.1132  time: 2062s\n",
      "Epoch 2 - Accuracy: 0.8764236902050114\n",
      "Epoch 2 - Save Best Score: 0.8764 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1825(0.1132) \n",
      "Epoch: [3][0/1316] Data 0.520 (0.520) Elapsed 0m 2s (remain 44m 27s) Loss: 0.1304(0.1304) Grad: 0.6300  \n",
      "Epoch: [3][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.1388(0.1871) Grad: 0.6003  \n",
      "Epoch: [3][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.2048(0.1868) Grad: 0.4830  \n",
      "Epoch: [3][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1923(0.1826) Grad: 0.8748  \n",
      "Epoch: [3][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.1836(0.1814) Grad: 0.8411  \n",
      "Epoch: [3][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0581(0.1828) Grad: 0.3704  \n",
      "Epoch: [3][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.3299(0.1841) Grad: 0.5510  \n",
      "Epoch: [3][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.3001(0.1841) Grad: 0.6664  \n",
      "Epoch: [3][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.1170(0.1841) Grad: 0.8647  \n",
      "Epoch: [3][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0794(0.1844) Grad: 0.8676  \n",
      "Epoch: [3][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.0991(0.1843) Grad: 0.8175  \n",
      "Epoch: [3][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1577(0.1838) Grad: 0.7429  \n",
      "Epoch: [3][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.3378(0.1839) Grad: 0.7638  \n",
      "Epoch: [3][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.3561(0.1828) Grad: 0.8808  \n",
      "Epoch: [3][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.1167(0.1827) Grad: 0.8579  \n",
      "EVAL: [0/330] Data 0.373 (0.373) Elapsed 0m 0s (remain 4m 44s) Loss: 0.0640(0.0640) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2664(0.1032) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1963(0.1051) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0916(0.1095) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3 - avg_train_loss: 0.1827  avg_val_loss: 0.1104  time: 2060s\n",
      "Epoch 3 - Accuracy: 0.880030372057707\n",
      "Epoch 3 - Save Best Score: 0.8800 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.1142(0.1104) \n",
      "Epoch: [4][0/1316] Data 0.463 (0.463) Elapsed 0m 2s (remain 43m 57s) Loss: 0.1794(0.1794) Grad: 0.5877  \n",
      "Epoch: [4][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 37s) Loss: 0.1190(0.1854) Grad: 0.4638  \n",
      "Epoch: [4][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.0651(0.1782) Grad: 0.5405  \n",
      "Epoch: [4][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.0935(0.1775) Grad: 0.6181  \n",
      "Epoch: [4][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.1554(0.1771) Grad: 1.0250  \n",
      "Epoch: [4][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 47s) Loss: 0.2480(0.1759) Grad: 0.2912  \n",
      "Epoch: [4][600/1316] Data 0.000 (0.001) Elapsed 14m 35s (remain 17m 21s) Loss: 0.2892(0.1797) Grad: 0.5235  \n",
      "Epoch: [4][700/1316] Data 0.000 (0.001) Elapsed 17m 1s (remain 14m 56s) Loss: 0.0533(0.1795) Grad: 0.5829  \n",
      "Epoch: [4][800/1316] Data 0.000 (0.001) Elapsed 19m 26s (remain 12m 30s) Loss: 0.0586(0.1804) Grad: 0.6718  \n",
      "Epoch: [4][900/1316] Data 0.000 (0.001) Elapsed 21m 52s (remain 10m 4s) Loss: 0.1880(0.1812) Grad: 0.6664  \n",
      "Epoch: [4][1000/1316] Data 0.000 (0.001) Elapsed 24m 18s (remain 7m 38s) Loss: 0.2084(0.1812) Grad: 0.5794  \n",
      "Epoch: [4][1100/1316] Data 0.000 (0.001) Elapsed 26m 44s (remain 5m 13s) Loss: 0.1575(0.1803) Grad: 0.5686  \n",
      "Epoch: [4][1200/1316] Data 0.000 (0.001) Elapsed 29m 9s (remain 2m 47s) Loss: 0.1364(0.1803) Grad: 0.3684  \n",
      "Epoch: [4][1300/1316] Data 0.000 (0.001) Elapsed 31m 35s (remain 0m 21s) Loss: 0.2754(0.1798) Grad: 0.6184  \n",
      "Epoch: [4][1315/1316] Data 0.000 (0.001) Elapsed 31m 57s (remain 0m 0s) Loss: 0.0466(0.1796) Grad: 0.4825  \n",
      "EVAL: [0/330] Data 0.376 (0.376) Elapsed 0m 0s (remain 4m 50s) Loss: 0.0681(0.0681) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2386(0.1049) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1794(0.1047) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1284(0.1098) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4 - avg_train_loss: 0.1796  avg_val_loss: 0.1105  time: 2060s\n",
      "Epoch 4 - Accuracy: 0.8794608959757023\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.1320(0.1105) \n",
      "Epoch: [5][0/1316] Data 0.458 (0.458) Elapsed 0m 2s (remain 43m 51s) Loss: 0.2184(0.2184) Grad: 0.8305  \n",
      "Epoch: [5][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 36s) Loss: 0.2188(0.1635) Grad: 1.0695  \n",
      "Epoch: [5][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 7s) Loss: 0.0713(0.1685) Grad: 0.8104  \n",
      "Epoch: [5][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.2810(0.1684) Grad: 0.5435  \n",
      "Epoch: [5][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.3713(0.1694) Grad: 0.4948  \n",
      "Epoch: [5][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.0256(0.1703) Grad: 0.3608  \n",
      "Epoch: [5][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.2846(0.1723) Grad: 0.5360  \n",
      "Epoch: [5][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.1481(0.1715) Grad: 0.3896  \n",
      "Epoch: [5][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.1348(0.1722) Grad: 0.8561  \n",
      "Epoch: [5][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.3106(0.1718) Grad: 0.5322  \n",
      "Epoch: [5][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.1592(0.1719) Grad: 0.8161  \n",
      "Epoch: [5][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.2696(0.1722) Grad: 0.6599  \n",
      "Epoch: [5][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.3148(0.1717) Grad: 0.6237  \n",
      "Epoch: [5][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.2518(0.1716) Grad: 0.5291  \n",
      "Epoch: [5][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.3327(0.1720) Grad: 0.4664  \n",
      "EVAL: [0/330] Data 0.392 (0.392) Elapsed 0m 0s (remain 4m 56s) Loss: 0.1104(0.1104) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2592(0.0995) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1804(0.1003) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1164(0.1056) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5 - avg_train_loss: 0.1720  avg_val_loss: 0.1062  time: 2061s\n",
      "Epoch 5 - Accuracy: 0.8853454821564161\n",
      "Epoch 5 - Save Best Score: 0.8853 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.0675(0.1062) \n",
      "Epoch: [6][0/1316] Data 0.519 (0.519) Elapsed 0m 2s (remain 45m 11s) Loss: 0.3081(0.3081) Grad: 0.6271  \n",
      "Epoch: [6][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 40s) Loss: 0.1876(0.1709) Grad: 0.5317  \n",
      "Epoch: [6][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.3266(0.1796) Grad: 0.5779  \n",
      "Epoch: [6][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 43s) Loss: 0.0426(0.1787) Grad: 0.4119  \n",
      "Epoch: [6][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.1070(0.1742) Grad: 0.7655  \n",
      "Epoch: [6][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0564(0.1717) Grad: 0.3548  \n",
      "Epoch: [6][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.2742(0.1724) Grad: 0.5143  \n",
      "Epoch: [6][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.2740(0.1717) Grad: 0.5438  \n",
      "Epoch: [6][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0591(0.1727) Grad: 0.6014  \n",
      "Epoch: [6][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.0943(0.1741) Grad: 0.3977  \n",
      "Epoch: [6][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.0936(0.1733) Grad: 0.6162  \n",
      "Epoch: [6][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.0632(0.1726) Grad: 0.5146  \n",
      "Epoch: [6][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.0979(0.1719) Grad: 0.6397  \n",
      "Epoch: [6][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.3604(0.1706) Grad: 0.5570  \n",
      "Epoch: [6][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.1823(0.1706) Grad: 0.7370  \n",
      "EVAL: [0/330] Data 0.398 (0.398) Elapsed 0m 0s (remain 4m 49s) Loss: 0.0381(0.0381) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2054(0.0932) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1823(0.0970) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1430(0.1019) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6 - avg_train_loss: 0.1706  avg_val_loss: 0.1029  time: 2060s\n",
      "Epoch 6 - Accuracy: 0.8899012908124525\n",
      "Epoch 6 - Save Best Score: 0.8899 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.1367(0.1029) \n",
      "Epoch: [7][0/1316] Data 0.470 (0.470) Elapsed 0m 2s (remain 44m 13s) Loss: 0.0941(0.0941) Grad: 0.4417  \n",
      "Epoch: [7][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.1202(0.1687) Grad: 0.7274  \n",
      "Epoch: [7][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 10s) Loss: 0.3798(0.1689) Grad: 0.7270  \n",
      "Epoch: [7][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1759(0.1729) Grad: 0.3874  \n",
      "Epoch: [7][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2097(0.1685) Grad: 0.5254  \n",
      "Epoch: [7][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 49s) Loss: 0.1522(0.1687) Grad: 0.4477  \n",
      "Epoch: [7][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.1175(0.1692) Grad: 0.9020  \n",
      "Epoch: [7][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.2453(0.1681) Grad: 0.2920  \n",
      "Epoch: [7][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.1609(0.1670) Grad: 0.9881  \n",
      "Epoch: [7][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.1012(0.1636) Grad: 0.7180  \n",
      "Epoch: [7][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.1474(0.1643) Grad: 0.8838  \n",
      "Epoch: [7][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1757(0.1644) Grad: 0.7531  \n",
      "Epoch: [7][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1248(0.1646) Grad: 1.0252  \n",
      "Epoch: [7][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.2166(0.1653) Grad: 0.4707  \n",
      "Epoch: [7][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.3027(0.1654) Grad: 0.8402  \n",
      "EVAL: [0/330] Data 0.401 (0.401) Elapsed 0m 0s (remain 4m 55s) Loss: 0.0373(0.0373) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2280(0.0954) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1516(0.0974) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1258(0.1020) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7 - avg_train_loss: 0.1654  avg_val_loss: 0.1030  time: 2062s\n",
      "Epoch 7 - Accuracy: 0.884206529992407\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1080(0.1030) \n",
      "Epoch: [8][0/1316] Data 0.536 (0.536) Elapsed 0m 2s (remain 44m 18s) Loss: 0.1544(0.1544) Grad: 0.6241  \n",
      "Epoch: [8][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 35s) Loss: 0.2305(0.1541) Grad: 0.4927  \n",
      "Epoch: [8][200/1316] Data 0.000 (0.003) Elapsed 4m 52s (remain 27m 4s) Loss: 0.2281(0.1612) Grad: 1.0238  \n",
      "Epoch: [8][300/1316] Data 0.000 (0.002) Elapsed 7m 18s (remain 24m 38s) Loss: 0.0443(0.1586) Grad: 0.7676  \n",
      "Epoch: [8][400/1316] Data 0.000 (0.001) Elapsed 9m 43s (remain 22m 11s) Loss: 0.2666(0.1583) Grad: 0.4121  \n",
      "Epoch: [8][500/1316] Data 0.000 (0.001) Elapsed 12m 9s (remain 19m 46s) Loss: 0.0798(0.1591) Grad: 0.9439  \n",
      "Epoch: [8][600/1316] Data 0.000 (0.001) Elapsed 14m 34s (remain 17m 20s) Loss: 0.2407(0.1623) Grad: 0.5840  \n",
      "Epoch: [8][700/1316] Data 0.000 (0.001) Elapsed 17m 0s (remain 14m 55s) Loss: 0.1645(0.1634) Grad: 0.5787  \n",
      "Epoch: [8][800/1316] Data 0.000 (0.001) Elapsed 19m 26s (remain 12m 30s) Loss: 0.1876(0.1627) Grad: 0.6194  \n",
      "Epoch: [8][900/1316] Data 0.000 (0.001) Elapsed 21m 52s (remain 10m 4s) Loss: 0.1489(0.1620) Grad: 0.3294  \n",
      "Epoch: [8][1000/1316] Data 0.000 (0.001) Elapsed 24m 18s (remain 7m 38s) Loss: 0.1269(0.1637) Grad: 0.2893  \n",
      "Epoch: [8][1100/1316] Data 0.000 (0.001) Elapsed 26m 43s (remain 5m 13s) Loss: 0.2504(0.1636) Grad: 0.4334  \n",
      "Epoch: [8][1200/1316] Data 0.000 (0.001) Elapsed 29m 9s (remain 2m 47s) Loss: 0.2535(0.1644) Grad: 0.4722  \n",
      "Epoch: [8][1300/1316] Data 0.000 (0.001) Elapsed 31m 35s (remain 0m 21s) Loss: 0.1485(0.1636) Grad: 1.3311  \n",
      "Epoch: [8][1315/1316] Data 0.000 (0.001) Elapsed 31m 57s (remain 0m 0s) Loss: 0.1973(0.1635) Grad: 1.3803  \n",
      "EVAL: [0/330] Data 0.379 (0.379) Elapsed 0m 0s (remain 4m 55s) Loss: 0.0270(0.0270) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2030(0.0891) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1607(0.0926) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1225(0.0978) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8 - avg_train_loss: 0.1635  avg_val_loss: 0.0987  time: 2059s\n",
      "Epoch 8 - Accuracy: 0.889331814730448\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.0938(0.0987) \n",
      "Epoch: [9][0/1316] Data 0.464 (0.464) Elapsed 0m 1s (remain 43m 13s) Loss: 0.1888(0.1888) Grad: 0.4033  \n",
      "Epoch: [9][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.0658(0.1483) Grad: 0.4949  \n",
      "Epoch: [9][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.1645(0.1529) Grad: 0.4332  \n",
      "Epoch: [9][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.0807(0.1576) Grad: 0.6730  \n",
      "Epoch: [9][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.1844(0.1617) Grad: 0.5158  \n",
      "Epoch: [9][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2023(0.1588) Grad: 0.3875  \n",
      "Epoch: [9][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.2847(0.1606) Grad: 0.5950  \n",
      "Epoch: [9][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.1609(0.1600) Grad: 0.3467  \n",
      "Epoch: [9][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0421(0.1603) Grad: 0.5477  \n",
      "Epoch: [9][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1203(0.1609) Grad: 0.7418  \n",
      "Epoch: [9][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2980(0.1616) Grad: 0.4141  \n",
      "Epoch: [9][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.1021(0.1610) Grad: 0.7239  \n",
      "Epoch: [9][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.0115(0.1601) Grad: 0.2507  \n",
      "Epoch: [9][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.1989(0.1601) Grad: 0.9201  \n",
      "Epoch: [9][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1663(0.1602) Grad: 0.9576  \n",
      "EVAL: [0/330] Data 0.376 (0.376) Elapsed 0m 0s (remain 4m 45s) Loss: 0.0435(0.0435) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2228(0.0900) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1568(0.0934) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1388(0.0984) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9 - avg_train_loss: 0.1602  avg_val_loss: 0.0991  time: 2062s\n",
      "Epoch 9 - Accuracy: 0.8904707668944571\n",
      "Epoch 9 - Save Best Score: 0.8905 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.001 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.0857(0.0991) \n",
      "Epoch: [10][0/1316] Data 0.455 (0.455) Elapsed 0m 2s (remain 44m 18s) Loss: 0.2164(0.2164) Grad: 0.6334  \n",
      "Epoch: [10][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.1403(0.1531) Grad: 0.6436  \n",
      "Epoch: [10][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 7s) Loss: 0.0164(0.1515) Grad: 0.2810  \n",
      "Epoch: [10][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.1806(0.1519) Grad: 0.7654  \n",
      "Epoch: [10][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.0183(0.1545) Grad: 0.3826  \n",
      "Epoch: [10][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.1105(0.1559) Grad: 1.0527  \n",
      "Epoch: [10][600/1316] Data 0.000 (0.001) Elapsed 14m 35s (remain 17m 22s) Loss: 0.1778(0.1565) Grad: 0.3948  \n",
      "Epoch: [10][700/1316] Data 0.000 (0.001) Elapsed 17m 1s (remain 14m 56s) Loss: 0.1819(0.1560) Grad: 0.9295  \n",
      "Epoch: [10][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.2815(0.1576) Grad: 0.4172  \n",
      "Epoch: [10][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 4s) Loss: 0.0604(0.1568) Grad: 0.5849  \n",
      "Epoch: [10][1000/1316] Data 0.000 (0.001) Elapsed 24m 18s (remain 7m 39s) Loss: 0.1568(0.1560) Grad: 1.1589  \n",
      "Epoch: [10][1100/1316] Data 0.000 (0.001) Elapsed 26m 44s (remain 5m 13s) Loss: 0.1844(0.1574) Grad: 0.9275  \n",
      "Epoch: [10][1200/1316] Data 0.000 (0.001) Elapsed 29m 10s (remain 2m 47s) Loss: 0.3202(0.1580) Grad: 0.6691  \n",
      "Epoch: [10][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.1121(0.1581) Grad: 0.5801  \n",
      "Epoch: [10][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.0830(0.1582) Grad: 0.3648  \n",
      "EVAL: [0/330] Data 0.382 (0.382) Elapsed 0m 0s (remain 4m 48s) Loss: 0.0251(0.0251) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.2003(0.0905) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1599(0.0937) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1165(0.0986) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10 - avg_train_loss: 0.1582  avg_val_loss: 0.0994  time: 2060s\n",
      "Epoch 10 - Accuracy: 0.8876233864844343\n",
      "========== fold: 0 result ==========\n",
      "Score: 0.89047\n",
      "========== fold: 1 training ==========\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0923(0.0994) \n",
      "Epoch: [1][0/1316] Data 0.491 (0.491) Elapsed 0m 2s (remain 47m 28s) Loss: 0.4909(0.4909) Grad: 0.6279  \n",
      "Epoch: [1][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.2085(0.3461) Grad: 0.6894  \n",
      "Epoch: [1][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 9s) Loss: 0.1248(0.3022) Grad: 0.9495  \n",
      "Epoch: [1][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.2547(0.2843) Grad: 0.7888  \n",
      "Epoch: [1][400/1316] Data 0.000 (0.001) Elapsed 9m 46s (remain 22m 17s) Loss: 0.2063(0.2735) Grad: 0.6629  \n",
      "Epoch: [1][500/1316] Data 0.000 (0.001) Elapsed 12m 12s (remain 19m 51s) Loss: 0.0903(0.2669) Grad: 0.5253  \n",
      "Epoch: [1][600/1316] Data 0.000 (0.001) Elapsed 14m 38s (remain 17m 24s) Loss: 0.1290(0.2604) Grad: 0.7301  \n",
      "Epoch: [1][700/1316] Data 0.000 (0.001) Elapsed 17m 4s (remain 14m 58s) Loss: 0.2929(0.2537) Grad: 0.9980  \n",
      "Epoch: [1][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 32s) Loss: 0.2670(0.2496) Grad: 1.0395  \n",
      "Epoch: [1][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 6s) Loss: 0.2821(0.2455) Grad: 0.5788  \n",
      "Epoch: [1][1000/1316] Data 0.000 (0.001) Elapsed 24m 21s (remain 7m 39s) Loss: 0.1536(0.2427) Grad: 0.8297  \n",
      "Epoch: [1][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.2985(0.2407) Grad: 0.4620  \n",
      "Epoch: [1][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.1192(0.2376) Grad: 0.6618  \n",
      "Epoch: [1][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.2315(0.2344) Grad: 0.4662  \n",
      "Epoch: [1][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.0839(0.2340) Grad: 0.8840  \n",
      "EVAL: [0/330] Data 0.418 (0.418) Elapsed 0m 0s (remain 5m 0s) Loss: 0.1876(0.1876) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.0693(0.1223) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.0794(0.1162) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0629(0.1129) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1 - avg_train_loss: 0.2340  avg_val_loss: 0.1118  time: 2063s\n",
      "Epoch 1 - Accuracy: 0.8773728170083523\n",
      "Epoch 1 - Save Best Score: 0.8774 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0560(0.1118) \n",
      "Epoch: [2][0/1316] Data 0.497 (0.497) Elapsed 0m 2s (remain 43m 53s) Loss: 0.2535(0.2535) Grad: 0.5591  \n",
      "Epoch: [2][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.2510(0.2078) Grad: 0.7819  \n",
      "Epoch: [2][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 9s) Loss: 0.2535(0.2075) Grad: 0.3800  \n",
      "Epoch: [2][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.2208(0.2111) Grad: 0.4799  \n",
      "Epoch: [2][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.1758(0.2076) Grad: 0.8658  \n",
      "Epoch: [2][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1277(0.2092) Grad: 0.7219  \n",
      "Epoch: [2][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1783(0.2104) Grad: 0.7050  \n",
      "Epoch: [2][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.1608(0.2075) Grad: 0.5070  \n",
      "Epoch: [2][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.3827(0.2062) Grad: 0.8480  \n",
      "Epoch: [2][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1753(0.2048) Grad: 0.7444  \n",
      "Epoch: [2][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.3734(0.2043) Grad: 0.8755  \n",
      "Epoch: [2][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1566(0.2035) Grad: 1.0224  \n",
      "Epoch: [2][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.3478(0.2023) Grad: 0.6895  \n",
      "Epoch: [2][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.1355(0.2018) Grad: 0.7658  \n",
      "Epoch: [2][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.0789(0.2017) Grad: 0.6365  \n",
      "EVAL: [0/330] Data 0.414 (0.414) Elapsed 0m 0s (remain 5m 2s) Loss: 0.2068(0.2068) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.0803(0.1194) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1156(0.1130) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0513(0.1101) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2 - avg_train_loss: 0.2017  avg_val_loss: 0.1096  time: 2062s\n",
      "Epoch 2 - Accuracy: 0.881169324221716\n",
      "Epoch 2 - Save Best Score: 0.8812 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0768(0.1096) \n",
      "Epoch: [3][0/1316] Data 0.482 (0.482) Elapsed 0m 2s (remain 43m 57s) Loss: 0.2104(0.2104) Grad: 0.8045  \n",
      "Epoch: [3][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 36s) Loss: 0.1243(0.1859) Grad: 0.8227  \n",
      "Epoch: [3][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 8s) Loss: 0.1744(0.1866) Grad: 0.9100  \n",
      "Epoch: [3][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.4041(0.1871) Grad: 0.6033  \n",
      "Epoch: [3][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 14s) Loss: 0.0399(0.1867) Grad: 0.5169  \n",
      "Epoch: [3][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 49s) Loss: 0.0540(0.1864) Grad: 0.5018  \n",
      "Epoch: [3][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.0604(0.1859) Grad: 0.5714  \n",
      "Epoch: [3][700/1316] Data 0.000 (0.001) Elapsed 17m 1s (remain 14m 56s) Loss: 0.3524(0.1837) Grad: 0.6063  \n",
      "Epoch: [3][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.2843(0.1845) Grad: 0.7684  \n",
      "Epoch: [3][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 4s) Loss: 0.2729(0.1858) Grad: 0.5355  \n",
      "Epoch: [3][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.2076(0.1863) Grad: 0.8295  \n",
      "Epoch: [3][1100/1316] Data 0.000 (0.001) Elapsed 26m 44s (remain 5m 13s) Loss: 0.2425(0.1871) Grad: 0.5368  \n",
      "Epoch: [3][1200/1316] Data 0.000 (0.001) Elapsed 29m 10s (remain 2m 47s) Loss: 0.0993(0.1881) Grad: 0.7523  \n",
      "Epoch: [3][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.2090(0.1883) Grad: 0.6223  \n",
      "Epoch: [3][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.1383(0.1881) Grad: 0.4117  \n",
      "EVAL: [0/330] Data 0.415 (0.415) Elapsed 0m 0s (remain 4m 57s) Loss: 0.2342(0.2342) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.0960(0.1159) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.0974(0.1107) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0298(0.1068) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3 - avg_train_loss: 0.1881  avg_val_loss: 0.1061  time: 2061s\n",
      "Epoch 3 - Accuracy: 0.8880030372057707\n",
      "Epoch 3 - Save Best Score: 0.8880 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0723(0.1061) \n",
      "Epoch: [4][0/1316] Data 0.469 (0.469) Elapsed 0m 1s (remain 43m 22s) Loss: 0.2414(0.2414) Grad: 0.4749  \n",
      "Epoch: [4][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.2611(0.1990) Grad: 1.3931  \n",
      "Epoch: [4][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.0682(0.1926) Grad: 0.4918  \n",
      "Epoch: [4][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.0690(0.1904) Grad: 0.6004  \n",
      "Epoch: [4][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 14s) Loss: 0.1400(0.1863) Grad: 0.6838  \n",
      "Epoch: [4][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0636(0.1844) Grad: 0.7208  \n",
      "Epoch: [4][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.1118(0.1828) Grad: 1.1144  \n",
      "Epoch: [4][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.1153(0.1824) Grad: 0.7670  \n",
      "Epoch: [4][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0778(0.1810) Grad: 0.5025  \n",
      "Epoch: [4][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1323(0.1798) Grad: 0.9555  \n",
      "Epoch: [4][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.0283(0.1813) Grad: 0.4312  \n",
      "Epoch: [4][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.1622(0.1805) Grad: 0.6161  \n",
      "Epoch: [4][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.0659(0.1804) Grad: 0.4756  \n",
      "Epoch: [4][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.0741(0.1804) Grad: 0.5441  \n",
      "Epoch: [4][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1476(0.1801) Grad: 0.7991  \n",
      "EVAL: [0/330] Data 0.452 (0.452) Elapsed 0m 0s (remain 5m 16s) Loss: 0.2725(0.2725) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1133(0.1157) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1080(0.1090) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0340(0.1059) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4 - avg_train_loss: 0.1801  avg_val_loss: 0.1052  time: 2062s\n",
      "Epoch 4 - Accuracy: 0.8857251328777525\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0718(0.1052) \n",
      "Epoch: [5][0/1316] Data 0.487 (0.487) Elapsed 0m 1s (remain 43m 39s) Loss: 0.1700(0.1700) Grad: 0.6897  \n",
      "Epoch: [5][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 36s) Loss: 0.1742(0.1827) Grad: 0.6593  \n",
      "Epoch: [5][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 8s) Loss: 0.0796(0.1724) Grad: 0.6271  \n",
      "Epoch: [5][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.1715(0.1731) Grad: 0.6312  \n",
      "Epoch: [5][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 14s) Loss: 0.2378(0.1746) Grad: 0.7030  \n",
      "Epoch: [5][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.1998(0.1758) Grad: 0.8592  \n",
      "Epoch: [5][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.2985(0.1776) Grad: 0.4802  \n",
      "Epoch: [5][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.3078(0.1782) Grad: 0.8575  \n",
      "Epoch: [5][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.0502(0.1774) Grad: 0.6509  \n",
      "Epoch: [5][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.1891(0.1779) Grad: 0.9728  \n",
      "Epoch: [5][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.2505(0.1790) Grad: 0.3984  \n",
      "Epoch: [5][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1244(0.1785) Grad: 0.6357  \n",
      "Epoch: [5][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.0982(0.1791) Grad: 0.3285  \n",
      "Epoch: [5][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.3208(0.1787) Grad: 0.6535  \n",
      "Epoch: [5][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1932(0.1785) Grad: 0.2814  \n",
      "EVAL: [0/330] Data 0.438 (0.438) Elapsed 0m 0s (remain 5m 13s) Loss: 0.2601(0.2601) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1029(0.1111) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.0895(0.1068) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0250(0.1028) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5 - avg_train_loss: 0.1785  avg_val_loss: 0.1022  time: 2061s\n",
      "Epoch 5 - Accuracy: 0.8864844343204252\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1101(0.1022) \n",
      "Epoch: [6][0/1316] Data 0.524 (0.524) Elapsed 0m 2s (remain 44m 23s) Loss: 0.1696(0.1696) Grad: 0.7468  \n",
      "Epoch: [6][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.2405(0.1813) Grad: 0.7793  \n",
      "Epoch: [6][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.1751(0.1769) Grad: 1.0819  \n",
      "Epoch: [6][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1581(0.1756) Grad: 0.8190  \n",
      "Epoch: [6][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.0628(0.1747) Grad: 0.9902  \n",
      "Epoch: [6][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2836(0.1761) Grad: 0.5432  \n",
      "Epoch: [6][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.1998(0.1738) Grad: 0.5053  \n",
      "Epoch: [6][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.3346(0.1721) Grad: 0.3803  \n",
      "Epoch: [6][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0733(0.1717) Grad: 0.6468  \n",
      "Epoch: [6][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1838(0.1716) Grad: 0.3558  \n",
      "Epoch: [6][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.0772(0.1703) Grad: 0.6737  \n",
      "Epoch: [6][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.2461(0.1714) Grad: 0.4522  \n",
      "Epoch: [6][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.2818(0.1731) Grad: 0.5513  \n",
      "Epoch: [6][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.2253(0.1719) Grad: 0.5300  \n",
      "Epoch: [6][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.2381(0.1717) Grad: 0.3959  \n",
      "EVAL: [0/330] Data 0.439 (0.439) Elapsed 0m 0s (remain 5m 4s) Loss: 0.2318(0.2318) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 43s (remain 1m 39s) Loss: 0.0806(0.1079) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.0738(0.1005) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0210(0.0968) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6 - avg_train_loss: 0.1717  avg_val_loss: 0.0957  time: 2061s\n",
      "Epoch 6 - Accuracy: 0.8940774487471527\n",
      "Epoch 6 - Save Best Score: 0.8941 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1133(0.0957) \n",
      "Epoch: [7][0/1316] Data 0.517 (0.517) Elapsed 0m 2s (remain 44m 34s) Loss: 0.2252(0.2252) Grad: 0.4050  \n",
      "Epoch: [7][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.0386(0.1622) Grad: 0.7207  \n",
      "Epoch: [7][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.2554(0.1698) Grad: 0.3533  \n",
      "Epoch: [7][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.0869(0.1703) Grad: 0.5650  \n",
      "Epoch: [7][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.1814(0.1715) Grad: 1.4526  \n",
      "Epoch: [7][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2335(0.1718) Grad: 0.4254  \n",
      "Epoch: [7][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.0265(0.1728) Grad: 0.4136  \n",
      "Epoch: [7][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.2556(0.1758) Grad: 0.4395  \n",
      "Epoch: [7][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0641(0.1742) Grad: 0.5891  \n",
      "Epoch: [7][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.2944(0.1730) Grad: 0.7988  \n",
      "Epoch: [7][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.3202(0.1716) Grad: 0.7410  \n",
      "Epoch: [7][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1292(0.1706) Grad: 1.1420  \n",
      "Epoch: [7][1200/1316] Data 0.000 (0.001) Elapsed 29m 10s (remain 2m 47s) Loss: 0.1093(0.1704) Grad: 0.7843  \n",
      "Epoch: [7][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.0842(0.1700) Grad: 0.6725  \n",
      "Epoch: [7][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.2719(0.1695) Grad: 0.3430  \n",
      "EVAL: [0/330] Data 0.448 (0.448) Elapsed 0m 0s (remain 5m 9s) Loss: 0.2112(0.2112) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 43s (remain 1m 39s) Loss: 0.0868(0.1061) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.0714(0.0996) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0385(0.0965) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7 - avg_train_loss: 0.1695  avg_val_loss: 0.0956  time: 2061s\n",
      "Epoch 7 - Accuracy: 0.8910402429764617\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1741(0.0956) \n",
      "Epoch: [8][0/1316] Data 0.524 (0.524) Elapsed 0m 2s (remain 45m 15s) Loss: 0.2083(0.2083) Grad: 0.6031  \n",
      "Epoch: [8][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.3498(0.1665) Grad: 0.8035  \n",
      "Epoch: [8][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 8s) Loss: 0.1553(0.1639) Grad: 0.2034  \n",
      "Epoch: [8][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.2409(0.1676) Grad: 0.4547  \n",
      "Epoch: [8][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.2380(0.1656) Grad: 1.0137  \n",
      "Epoch: [8][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1535(0.1642) Grad: 0.9873  \n",
      "Epoch: [8][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.0628(0.1614) Grad: 0.6926  \n",
      "Epoch: [8][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.1118(0.1613) Grad: 0.6210  \n",
      "Epoch: [8][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.1025(0.1619) Grad: 0.6216  \n",
      "Epoch: [8][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1307(0.1606) Grad: 0.5826  \n",
      "Epoch: [8][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2303(0.1610) Grad: 1.1830  \n",
      "Epoch: [8][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.2481(0.1607) Grad: 0.4844  \n",
      "Epoch: [8][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2549(0.1603) Grad: 0.8582  \n",
      "Epoch: [8][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.1484(0.1601) Grad: 0.5118  \n",
      "Epoch: [8][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.0025(0.1602) Grad: 0.0533  \n",
      "EVAL: [0/330] Data 0.463 (0.463) Elapsed 0m 0s (remain 5m 18s) Loss: 0.2287(0.2287) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 44s (remain 1m 39s) Loss: 0.0795(0.1057) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.0654(0.1002) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0468(0.0965) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8 - avg_train_loss: 0.1602  avg_val_loss: 0.0959  time: 2062s\n",
      "Epoch 8 - Accuracy: 0.892369020501139\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1939(0.0959) \n",
      "Epoch: [9][0/1316] Data 0.513 (0.513) Elapsed 0m 2s (remain 44m 12s) Loss: 0.1368(0.1368) Grad: 1.1996  \n",
      "Epoch: [9][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 32s) Loss: 0.1211(0.1536) Grad: 1.0671  \n",
      "Epoch: [9][200/1316] Data 0.000 (0.003) Elapsed 4m 52s (remain 27m 5s) Loss: 0.0054(0.1571) Grad: 0.0952  \n",
      "Epoch: [9][300/1316] Data 0.000 (0.002) Elapsed 7m 18s (remain 24m 39s) Loss: 0.2583(0.1654) Grad: 0.6262  \n",
      "Epoch: [9][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 13s) Loss: 0.0611(0.1626) Grad: 0.8077  \n",
      "Epoch: [9][500/1316] Data 0.000 (0.001) Elapsed 12m 9s (remain 19m 47s) Loss: 0.1743(0.1607) Grad: 0.7374  \n",
      "Epoch: [9][600/1316] Data 0.000 (0.001) Elapsed 14m 35s (remain 17m 21s) Loss: 0.1306(0.1606) Grad: 1.0352  \n",
      "Epoch: [9][700/1316] Data 0.000 (0.001) Elapsed 17m 1s (remain 14m 56s) Loss: 0.0302(0.1597) Grad: 0.4765  \n",
      "Epoch: [9][800/1316] Data 0.000 (0.001) Elapsed 19m 26s (remain 12m 30s) Loss: 0.0988(0.1591) Grad: 0.6959  \n",
      "Epoch: [9][900/1316] Data 0.000 (0.001) Elapsed 21m 52s (remain 10m 4s) Loss: 0.1127(0.1615) Grad: 0.6626  \n",
      "Epoch: [9][1000/1316] Data 0.000 (0.001) Elapsed 24m 18s (remain 7m 38s) Loss: 0.2807(0.1621) Grad: 0.5857  \n",
      "Epoch: [9][1100/1316] Data 0.000 (0.001) Elapsed 26m 43s (remain 5m 13s) Loss: 0.1815(0.1629) Grad: 0.4532  \n",
      "Epoch: [9][1200/1316] Data 0.000 (0.001) Elapsed 29m 9s (remain 2m 47s) Loss: 0.1124(0.1612) Grad: 0.8365  \n",
      "Epoch: [9][1300/1316] Data 0.000 (0.001) Elapsed 31m 34s (remain 0m 21s) Loss: 0.1714(0.1616) Grad: 0.4124  \n",
      "Epoch: [9][1315/1316] Data 0.000 (0.001) Elapsed 31m 56s (remain 0m 0s) Loss: 0.1362(0.1615) Grad: 0.6319  \n",
      "EVAL: [0/330] Data 0.398 (0.398) Elapsed 0m 0s (remain 4m 57s) Loss: 0.2412(0.2412) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.0946(0.1083) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.0777(0.1018) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0221(0.0980) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9 - avg_train_loss: 0.1615  avg_val_loss: 0.0970  time: 2059s\n",
      "Epoch 9 - Accuracy: 0.8917995444191344\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1528(0.0970) \n",
      "Epoch: [10][0/1316] Data 0.474 (0.474) Elapsed 0m 1s (remain 43m 40s) Loss: 0.0960(0.0960) Grad: 0.3084  \n",
      "Epoch: [10][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 37s) Loss: 0.2939(0.1780) Grad: 0.4832  \n",
      "Epoch: [10][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 9s) Loss: 0.0542(0.1683) Grad: 0.5292  \n",
      "Epoch: [10][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1655(0.1701) Grad: 0.6136  \n",
      "Epoch: [10][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.1121(0.1665) Grad: 0.4406  \n",
      "Epoch: [10][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.1358(0.1601) Grad: 0.6420  \n",
      "Epoch: [10][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.1712(0.1591) Grad: 0.8302  \n",
      "Epoch: [10][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.1175(0.1600) Grad: 0.5673  \n",
      "Epoch: [10][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.1251(0.1596) Grad: 0.5779  \n",
      "Epoch: [10][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0663(0.1603) Grad: 0.8969  \n",
      "Epoch: [10][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.1566(0.1591) Grad: 0.7487  \n",
      "Epoch: [10][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.2945(0.1583) Grad: 0.6119  \n",
      "Epoch: [10][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.2466(0.1572) Grad: 1.0034  \n",
      "Epoch: [10][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.0828(0.1577) Grad: 0.6624  \n",
      "Epoch: [10][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.1694(0.1578) Grad: 0.4361  \n",
      "EVAL: [0/330] Data 0.439 (0.439) Elapsed 0m 1s (remain 5m 55s) Loss: 0.2301(0.2301) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 44s (remain 1m 39s) Loss: 0.0888(0.1081) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.0785(0.1022) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0314(0.0982) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10 - avg_train_loss: 0.1578  avg_val_loss: 0.0972  time: 2061s\n",
      "Epoch 10 - Accuracy: 0.894457099468489\n",
      "Epoch 10 - Save Best Score: 0.8945 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1622(0.0972) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "========== fold: 1 result ==========\n",
      "Score: 0.89446\n",
      "========== fold: 2 training ==========\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [1][0/1316] Data 0.533 (0.533) Elapsed 0m 2s (remain 44m 59s) Loss: 0.5073(0.5073) Grad: 0.6358  \n",
      "Epoch: [1][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.3590(0.3487) Grad: 0.8537  \n",
      "Epoch: [1][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.3745(0.3180) Grad: 0.4715  \n",
      "Epoch: [1][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.3598(0.2954) Grad: 0.5851  \n",
      "Epoch: [1][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.0675(0.2801) Grad: 0.5679  \n",
      "Epoch: [1][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2553(0.2696) Grad: 0.6766  \n",
      "Epoch: [1][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.2989(0.2651) Grad: 1.1186  \n",
      "Epoch: [1][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.3102(0.2591) Grad: 0.7105  \n",
      "Epoch: [1][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.2741(0.2532) Grad: 0.5445  \n",
      "Epoch: [1][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1362(0.2486) Grad: 0.6410  \n",
      "Epoch: [1][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2057(0.2449) Grad: 1.0677  \n",
      "Epoch: [1][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1450(0.2409) Grad: 0.6662  \n",
      "Epoch: [1][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1651(0.2380) Grad: 0.8454  \n",
      "Epoch: [1][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.2849(0.2354) Grad: 0.7025  \n",
      "Epoch: [1][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.0609(0.2350) Grad: 0.6180  \n",
      "EVAL: [0/330] Data 0.403 (0.403) Elapsed 0m 0s (remain 4m 58s) Loss: 0.2310(0.2310) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1805(0.1400) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1951(0.1354) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.2006(0.1344) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1 - avg_train_loss: 0.2350  avg_val_loss: 0.1357  time: 2061s\n",
      "Epoch 1 - Accuracy: 0.8483007404594646\n",
      "Epoch 1 - Save Best Score: 0.8483 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.3403(0.1357) \n",
      "Epoch: [2][0/1316] Data 0.476 (0.476) Elapsed 0m 1s (remain 43m 22s) Loss: 0.1730(0.1730) Grad: 1.0713  \n",
      "Epoch: [2][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.1726(0.2015) Grad: 0.5946  \n",
      "Epoch: [2][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 9s) Loss: 0.3702(0.2029) Grad: 0.5501  \n",
      "Epoch: [2][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.0219(0.2001) Grad: 0.4076  \n",
      "Epoch: [2][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.2423(0.2031) Grad: 0.6674  \n",
      "Epoch: [2][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 50s) Loss: 0.2795(0.2043) Grad: 0.4186  \n",
      "Epoch: [2][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 24s) Loss: 0.1051(0.2018) Grad: 0.7185  \n",
      "Epoch: [2][700/1316] Data 0.000 (0.001) Elapsed 17m 4s (remain 14m 58s) Loss: 0.0884(0.2040) Grad: 0.7497  \n",
      "Epoch: [2][800/1316] Data 0.000 (0.001) Elapsed 19m 30s (remain 12m 32s) Loss: 0.2736(0.2026) Grad: 0.4046  \n",
      "Epoch: [2][900/1316] Data 0.000 (0.001) Elapsed 21m 56s (remain 10m 6s) Loss: 0.2047(0.2032) Grad: 0.9252  \n",
      "Epoch: [2][1000/1316] Data 0.000 (0.001) Elapsed 24m 22s (remain 7m 40s) Loss: 0.1497(0.2006) Grad: 0.8944  \n",
      "Epoch: [2][1100/1316] Data 0.000 (0.001) Elapsed 26m 48s (remain 5m 14s) Loss: 0.2241(0.1994) Grad: 0.6427  \n",
      "Epoch: [2][1200/1316] Data 0.000 (0.001) Elapsed 29m 14s (remain 2m 47s) Loss: 0.1302(0.1986) Grad: 0.7473  \n",
      "Epoch: [2][1300/1316] Data 0.000 (0.001) Elapsed 31m 40s (remain 0m 21s) Loss: 0.2335(0.1994) Grad: 0.4523  \n",
      "Epoch: [2][1315/1316] Data 0.000 (0.001) Elapsed 32m 2s (remain 0m 0s) Loss: 0.0885(0.1989) Grad: 0.7097  \n",
      "EVAL: [0/330] Data 0.417 (0.417) Elapsed 0m 0s (remain 5m 5s) Loss: 0.2069(0.2069) \n",
      "EVAL: [100/330] Data 0.001 (0.004) Elapsed 0m 44s (remain 1m 40s) Loss: 0.1958(0.1239) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1399(0.1168) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.1069(0.1156) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2 - avg_train_loss: 0.1989  avg_val_loss: 0.1184  time: 2064s\n",
      "Epoch 2 - Accuracy: 0.8667172963736473\n",
      "Epoch 2 - Save Best Score: 0.8667 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.4159(0.1184) \n",
      "Epoch: [3][0/1316] Data 0.461 (0.461) Elapsed 0m 1s (remain 43m 29s) Loss: 0.3434(0.3434) Grad: 1.1571  \n",
      "Epoch: [3][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.0312(0.1874) Grad: 0.3956  \n",
      "Epoch: [3][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 9s) Loss: 0.2837(0.1830) Grad: 0.6823  \n",
      "Epoch: [3][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 43s) Loss: 0.1384(0.1830) Grad: 0.2207  \n",
      "Epoch: [3][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.0115(0.1853) Grad: 0.1425  \n",
      "Epoch: [3][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1441(0.1861) Grad: 0.6309  \n",
      "Epoch: [3][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 24s) Loss: 0.0849(0.1863) Grad: 0.6482  \n",
      "Epoch: [3][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1397(0.1851) Grad: 0.6218  \n",
      "Epoch: [3][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.1877(0.1862) Grad: 0.7153  \n",
      "Epoch: [3][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1912(0.1866) Grad: 0.5028  \n",
      "Epoch: [3][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2018(0.1861) Grad: 0.5260  \n",
      "Epoch: [3][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.1026(0.1853) Grad: 0.3988  \n",
      "Epoch: [3][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2204(0.1853) Grad: 0.7544  \n",
      "Epoch: [3][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.2811(0.1856) Grad: 0.3231  \n",
      "Epoch: [3][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.2164(0.1855) Grad: 0.4247  \n",
      "EVAL: [0/330] Data 0.433 (0.433) Elapsed 0m 0s (remain 5m 5s) Loss: 0.2323(0.2323) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1602(0.1111) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1556(0.1084) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0822(0.1071) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3 - avg_train_loss: 0.1855  avg_val_loss: 0.1084  time: 2063s\n",
      "Epoch 3 - Accuracy: 0.87848870324663\n",
      "Epoch 3 - Save Best Score: 0.8785 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.2430(0.1084) \n",
      "Epoch: [4][0/1316] Data 0.468 (0.468) Elapsed 0m 2s (remain 44m 34s) Loss: 0.2008(0.2008) Grad: 0.3380  \n",
      "Epoch: [4][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.2734(0.1691) Grad: 0.4596  \n",
      "Epoch: [4][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.1376(0.1771) Grad: 0.7847  \n",
      "Epoch: [4][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.0729(0.1800) Grad: 0.5542  \n",
      "Epoch: [4][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.1779(0.1824) Grad: 0.3040  \n",
      "Epoch: [4][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0849(0.1797) Grad: 0.6164  \n",
      "Epoch: [4][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.1234(0.1805) Grad: 1.0026  \n",
      "Epoch: [4][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.1698(0.1828) Grad: 0.4526  \n",
      "Epoch: [4][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0920(0.1826) Grad: 0.7490  \n",
      "Epoch: [4][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0972(0.1822) Grad: 0.4693  \n",
      "Epoch: [4][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1747(0.1825) Grad: 0.3299  \n",
      "Epoch: [4][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.2637(0.1812) Grad: 0.6840  \n",
      "Epoch: [4][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.0681(0.1802) Grad: 0.2455  \n",
      "Epoch: [4][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.2956(0.1800) Grad: 0.4723  \n",
      "Epoch: [4][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.3475(0.1799) Grad: 0.4106  \n",
      "EVAL: [0/330] Data 0.386 (0.386) Elapsed 0m 0s (remain 4m 52s) Loss: 0.1918(0.1918) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1764(0.1046) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1430(0.1015) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0967(0.1015) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4 - avg_train_loss: 0.1799  avg_val_loss: 0.1040  time: 2062s\n",
      "Epoch 4 - Accuracy: 0.8860831592937156\n",
      "Epoch 4 - Save Best Score: 0.8861 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1980(0.1040) \n",
      "Epoch: [5][0/1316] Data 0.495 (0.495) Elapsed 0m 1s (remain 43m 39s) Loss: 0.1864(0.1864) Grad: 0.3915  \n",
      "Epoch: [5][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 37s) Loss: 0.2420(0.1758) Grad: 0.9469  \n",
      "Epoch: [5][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.0564(0.1682) Grad: 0.5443  \n",
      "Epoch: [5][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.3968(0.1651) Grad: 0.6088  \n",
      "Epoch: [5][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2284(0.1702) Grad: 0.7617  \n",
      "Epoch: [5][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0734(0.1714) Grad: 0.5233  \n",
      "Epoch: [5][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.2049(0.1716) Grad: 0.3081  \n",
      "Epoch: [5][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.2732(0.1706) Grad: 0.5244  \n",
      "Epoch: [5][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.2712(0.1725) Grad: 0.5277  \n",
      "Epoch: [5][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1883(0.1719) Grad: 1.1763  \n",
      "Epoch: [5][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1541(0.1727) Grad: 0.2966  \n",
      "Epoch: [5][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.0429(0.1731) Grad: 0.5579  \n",
      "Epoch: [5][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2016(0.1740) Grad: 0.3825  \n",
      "Epoch: [5][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.1807(0.1748) Grad: 0.5294  \n",
      "Epoch: [5][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.1526(0.1752) Grad: 0.8989  \n",
      "EVAL: [0/330] Data 0.392 (0.392) Elapsed 0m 0s (remain 4m 59s) Loss: 0.2123(0.2123) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1455(0.1079) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1399(0.1076) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0817(0.1072) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5 - avg_train_loss: 0.1752  avg_val_loss: 0.1091  time: 2063s\n",
      "Epoch 5 - Accuracy: 0.8801974558572242\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.3172(0.1091) \n",
      "Epoch: [6][0/1316] Data 0.462 (0.462) Elapsed 0m 1s (remain 43m 7s) Loss: 0.1323(0.1323) Grad: 0.7090  \n",
      "Epoch: [6][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 35s) Loss: 0.3286(0.1590) Grad: 0.7164  \n",
      "Epoch: [6][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 9s) Loss: 0.1081(0.1648) Grad: 0.5601  \n",
      "Epoch: [6][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1278(0.1641) Grad: 0.6832  \n",
      "Epoch: [6][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.1531(0.1676) Grad: 0.6768  \n",
      "Epoch: [6][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1486(0.1683) Grad: 0.8893  \n",
      "Epoch: [6][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1618(0.1696) Grad: 0.8981  \n",
      "Epoch: [6][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 58s) Loss: 0.3144(0.1712) Grad: 0.6210  \n",
      "Epoch: [6][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 32s) Loss: 0.2538(0.1718) Grad: 0.6913  \n",
      "Epoch: [6][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 5s) Loss: 0.1516(0.1719) Grad: 0.7517  \n",
      "Epoch: [6][1000/1316] Data 0.000 (0.001) Elapsed 24m 21s (remain 7m 39s) Loss: 0.2183(0.1712) Grad: 0.5663  \n",
      "Epoch: [6][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.3230(0.1713) Grad: 0.7716  \n",
      "Epoch: [6][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.1308(0.1700) Grad: 0.8480  \n",
      "Epoch: [6][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.2497(0.1712) Grad: 0.3713  \n",
      "Epoch: [6][1315/1316] Data 0.000 (0.001) Elapsed 32m 1s (remain 0m 0s) Loss: 0.3257(0.1712) Grad: 0.6192  \n",
      "EVAL: [0/330] Data 0.413 (0.413) Elapsed 0m 0s (remain 5m 0s) Loss: 0.2063(0.2063) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1479(0.1063) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1523(0.1038) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0484(0.1017) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6 - avg_train_loss: 0.1712  avg_val_loss: 0.1034  time: 2064s\n",
      "Epoch 6 - Accuracy: 0.8874121891019555\n",
      "Epoch 6 - Save Best Score: 0.8874 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.3531(0.1034) \n",
      "Epoch: [7][0/1316] Data 0.532 (0.532) Elapsed 0m 2s (remain 44m 56s) Loss: 0.2564(0.2564) Grad: 0.6240  \n",
      "Epoch: [7][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 35s) Loss: 0.0113(0.1571) Grad: 0.2338  \n",
      "Epoch: [7][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 7s) Loss: 0.2855(0.1663) Grad: 0.3963  \n",
      "Epoch: [7][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.2417(0.1638) Grad: 0.4187  \n",
      "Epoch: [7][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2297(0.1643) Grad: 0.6403  \n",
      "Epoch: [7][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0914(0.1629) Grad: 0.6850  \n",
      "Epoch: [7][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1126(0.1617) Grad: 0.6441  \n",
      "Epoch: [7][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1212(0.1612) Grad: 0.7861  \n",
      "Epoch: [7][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.0439(0.1603) Grad: 0.6764  \n",
      "Epoch: [7][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0428(0.1601) Grad: 0.6613  \n",
      "Epoch: [7][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.0594(0.1606) Grad: 0.4594  \n",
      "Epoch: [7][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.1821(0.1614) Grad: 0.9196  \n",
      "Epoch: [7][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.0911(0.1618) Grad: 0.7826  \n",
      "Epoch: [7][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.2304(0.1617) Grad: 0.3770  \n",
      "Epoch: [7][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1585(0.1621) Grad: 0.3116  \n",
      "EVAL: [0/330] Data 0.425 (0.425) Elapsed 0m 0s (remain 5m 0s) Loss: 0.2065(0.2065) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1508(0.1054) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1612(0.1017) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0473(0.1001) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7 - avg_train_loss: 0.1621  avg_val_loss: 0.1017  time: 2062s\n",
      "Epoch 7 - Accuracy: 0.8889310803113727\n",
      "Epoch 7 - Save Best Score: 0.8889 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.1308(0.1017) \n",
      "Epoch: [8][0/1316] Data 0.469 (0.469) Elapsed 0m 1s (remain 43m 22s) Loss: 0.1072(0.1072) Grad: 0.3811  \n",
      "Epoch: [8][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 33s) Loss: 0.0698(0.1419) Grad: 0.7052  \n",
      "Epoch: [8][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.1957(0.1515) Grad: 0.8820  \n",
      "Epoch: [8][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1431(0.1569) Grad: 0.6876  \n",
      "Epoch: [8][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.3127(0.1561) Grad: 0.4194  \n",
      "Epoch: [8][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.0645(0.1557) Grad: 0.5359  \n",
      "Epoch: [8][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.0850(0.1586) Grad: 0.7220  \n",
      "Epoch: [8][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.2194(0.1586) Grad: 0.7940  \n",
      "Epoch: [8][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.2535(0.1600) Grad: 0.4733  \n",
      "Epoch: [8][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.2553(0.1603) Grad: 0.4646  \n",
      "Epoch: [8][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.0771(0.1591) Grad: 0.3143  \n",
      "Epoch: [8][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.2228(0.1589) Grad: 0.3290  \n",
      "Epoch: [8][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1229(0.1594) Grad: 0.3020  \n",
      "Epoch: [8][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.1976(0.1599) Grad: 0.5071  \n",
      "Epoch: [8][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.3083(0.1602) Grad: 0.6135  \n",
      "EVAL: [0/330] Data 0.391 (0.391) Elapsed 0m 0s (remain 4m 59s) Loss: 0.1393(0.1393) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1443(0.1071) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1382(0.1029) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0987(0.1016) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8 - avg_train_loss: 0.1602  avg_val_loss: 0.1034  time: 2061s\n",
      "Epoch 8 - Accuracy: 0.886652743497247\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.2272(0.1034) \n",
      "Epoch: [9][0/1316] Data 0.500 (0.500) Elapsed 0m 1s (remain 43m 34s) Loss: 0.0794(0.0794) Grad: 0.7266  \n",
      "Epoch: [9][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.1285(0.1532) Grad: 0.9461  \n",
      "Epoch: [9][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 12s) Loss: 0.3957(0.1601) Grad: 0.7240  \n",
      "Epoch: [9][300/1316] Data 0.000 (0.002) Elapsed 7m 20s (remain 24m 44s) Loss: 0.2047(0.1608) Grad: 0.5317  \n",
      "Epoch: [9][400/1316] Data 0.000 (0.001) Elapsed 9m 46s (remain 22m 17s) Loss: 0.0294(0.1579) Grad: 0.4553  \n",
      "Epoch: [9][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 50s) Loss: 0.0491(0.1561) Grad: 0.7168  \n",
      "Epoch: [9][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 24s) Loss: 0.2667(0.1562) Grad: 0.6652  \n",
      "Epoch: [9][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 58s) Loss: 0.2156(0.1577) Grad: 0.6783  \n",
      "Epoch: [9][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 32s) Loss: 0.0616(0.1577) Grad: 0.5361  \n",
      "Epoch: [9][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 6s) Loss: 0.0809(0.1584) Grad: 0.8202  \n",
      "Epoch: [9][1000/1316] Data 0.000 (0.001) Elapsed 24m 21s (remain 7m 39s) Loss: 0.1910(0.1581) Grad: 0.8391  \n",
      "Epoch: [9][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.2027(0.1574) Grad: 0.4058  \n",
      "Epoch: [9][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.1417(0.1572) Grad: 0.9386  \n",
      "Epoch: [9][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.2106(0.1570) Grad: 0.4526  \n",
      "Epoch: [9][1315/1316] Data 0.000 (0.001) Elapsed 32m 1s (remain 0m 0s) Loss: 0.2366(0.1570) Grad: 0.7041  \n",
      "EVAL: [0/330] Data 0.390 (0.390) Elapsed 0m 0s (remain 4m 59s) Loss: 0.1496(0.1496) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1441(0.1070) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1522(0.1025) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1156(0.1013) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9 - avg_train_loss: 0.1570  avg_val_loss: 0.1033  time: 2063s\n",
      "Epoch 9 - Accuracy: 0.8885513575090184\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.2613(0.1033) \n",
      "Epoch: [10][0/1316] Data 0.466 (0.466) Elapsed 0m 1s (remain 43m 45s) Loss: 0.2544(0.2544) Grad: 0.5822  \n",
      "Epoch: [10][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 44s) Loss: 0.0782(0.1595) Grad: 1.0577  \n",
      "Epoch: [10][200/1316] Data 0.000 (0.002) Elapsed 4m 54s (remain 27m 11s) Loss: 0.1264(0.1572) Grad: 0.8583  \n",
      "Epoch: [10][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 43s) Loss: 0.2346(0.1537) Grad: 0.3128  \n",
      "Epoch: [10][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.2273(0.1530) Grad: 0.4052  \n",
      "Epoch: [10][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 50s) Loss: 0.1725(0.1575) Grad: 0.2491  \n",
      "Epoch: [10][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1526(0.1563) Grad: 0.4477  \n",
      "Epoch: [10][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1225(0.1543) Grad: 0.9221  \n",
      "Epoch: [10][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.2024(0.1549) Grad: 0.6070  \n",
      "Epoch: [10][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 5s) Loss: 0.2444(0.1560) Grad: 1.2002  \n",
      "Epoch: [10][1000/1316] Data 0.000 (0.001) Elapsed 24m 21s (remain 7m 39s) Loss: 0.1208(0.1556) Grad: 0.5659  \n",
      "Epoch: [10][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.0331(0.1564) Grad: 0.4799  \n",
      "Epoch: [10][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.2561(0.1569) Grad: 1.1103  \n",
      "Epoch: [10][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.2217(0.1566) Grad: 0.3756  \n",
      "Epoch: [10][1315/1316] Data 0.000 (0.001) Elapsed 32m 1s (remain 0m 0s) Loss: 0.1824(0.1565) Grad: 0.3470  \n",
      "EVAL: [0/330] Data 0.432 (0.432) Elapsed 0m 0s (remain 5m 2s) Loss: 0.1586(0.1586) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1395(0.1033) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1613(0.0988) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0786(0.0976) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10 - avg_train_loss: 0.1565  avg_val_loss: 0.0995  time: 2064s\n",
      "Epoch 10 - Accuracy: 0.8904499715207899\n",
      "Epoch 10 - Save Best Score: 0.8904 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.2628(0.0995) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "========== fold: 2 result ==========\n",
      "Score: 0.89045\n",
      "========== fold: 3 training ==========\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [1][0/1316] Data 0.497 (0.497) Elapsed 0m 2s (remain 44m 18s) Loss: 0.4864(0.4864) Grad: 0.6253  \n",
      "Epoch: [1][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 37s) Loss: 0.3103(0.3278) Grad: 0.6774  \n",
      "Epoch: [1][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 6s) Loss: 0.2516(0.3022) Grad: 1.0590  \n",
      "Epoch: [1][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.2319(0.2869) Grad: 0.5984  \n",
      "Epoch: [1][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.1834(0.2738) Grad: 0.6620  \n",
      "Epoch: [1][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.3429(0.2680) Grad: 0.6728  \n",
      "Epoch: [1][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1461(0.2613) Grad: 1.0345  \n",
      "Epoch: [1][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1617(0.2565) Grad: 0.8308  \n",
      "Epoch: [1][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.2178(0.2534) Grad: 0.5026  \n",
      "Epoch: [1][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 5s) Loss: 0.2094(0.2486) Grad: 0.7122  \n",
      "Epoch: [1][1000/1316] Data 0.000 (0.001) Elapsed 24m 21s (remain 7m 39s) Loss: 0.3036(0.2441) Grad: 0.9940  \n",
      "Epoch: [1][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.2563(0.2407) Grad: 1.0055  \n",
      "Epoch: [1][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.3905(0.2380) Grad: 1.1596  \n",
      "Epoch: [1][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.3152(0.2358) Grad: 0.7820  \n",
      "Epoch: [1][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.0981(0.2359) Grad: 0.8656  \n",
      "EVAL: [0/330] Data 0.398 (0.398) Elapsed 0m 0s (remain 4m 59s) Loss: 0.2061(0.2061) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1807(0.1736) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1959(0.1679) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.2548(0.1637) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1 - avg_train_loss: 0.2359  avg_val_loss: 0.1613  time: 2063s\n",
      "Epoch 1 - Accuracy: 0.824568065312322\n",
      "Epoch 1 - Save Best Score: 0.8246 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0837(0.1613) \n",
      "Epoch: [2][0/1316] Data 0.488 (0.488) Elapsed 0m 1s (remain 43m 48s) Loss: 0.2000(0.2000) Grad: 0.5244  \n",
      "Epoch: [2][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.3008(0.2081) Grad: 0.4048  \n",
      "Epoch: [2][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 9s) Loss: 0.2231(0.2008) Grad: 0.4759  \n",
      "Epoch: [2][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.2178(0.1997) Grad: 1.0470  \n",
      "Epoch: [2][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2095(0.1990) Grad: 0.9789  \n",
      "Epoch: [2][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1699(0.2001) Grad: 0.8350  \n",
      "Epoch: [2][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.2528(0.2014) Grad: 0.5765  \n",
      "Epoch: [2][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1125(0.2005) Grad: 0.8539  \n",
      "Epoch: [2][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.2194(0.1993) Grad: 0.7505  \n",
      "Epoch: [2][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0327(0.1963) Grad: 0.5052  \n",
      "Epoch: [2][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2446(0.1966) Grad: 0.3919  \n",
      "Epoch: [2][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.1937(0.1959) Grad: 0.5507  \n",
      "Epoch: [2][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.0881(0.1962) Grad: 0.9329  \n",
      "Epoch: [2][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.3017(0.1958) Grad: 0.4933  \n",
      "Epoch: [2][1315/1316] Data 0.000 (0.001) Elapsed 32m 1s (remain 0m 0s) Loss: 0.3266(0.1955) Grad: 0.5237  \n",
      "EVAL: [0/330] Data 0.465 (0.465) Elapsed 0m 0s (remain 5m 22s) Loss: 0.0988(0.0988) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1990(0.1243) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1299(0.1182) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1773(0.1139) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2 - avg_train_loss: 0.1955  avg_val_loss: 0.1142  time: 2064s\n",
      "Epoch 2 - Accuracy: 0.87715967343839\n",
      "Epoch 2 - Save Best Score: 0.8772 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0373(0.1142) \n",
      "Epoch: [3][0/1316] Data 0.491 (0.491) Elapsed 0m 2s (remain 43m 53s) Loss: 0.3657(0.3657) Grad: 0.6158  \n",
      "Epoch: [3][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 36s) Loss: 0.2691(0.1830) Grad: 0.5370  \n",
      "Epoch: [3][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 8s) Loss: 0.3442(0.1987) Grad: 0.4801  \n",
      "Epoch: [3][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.1936(0.1909) Grad: 0.8759  \n",
      "Epoch: [3][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.1002(0.1856) Grad: 0.6555  \n",
      "Epoch: [3][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.3544(0.1849) Grad: 0.9347  \n",
      "Epoch: [3][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.1337(0.1868) Grad: 0.7333  \n",
      "Epoch: [3][700/1316] Data 0.000 (0.001) Elapsed 17m 1s (remain 14m 56s) Loss: 0.2133(0.1864) Grad: 0.4859  \n",
      "Epoch: [3][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.1865(0.1866) Grad: 1.2046  \n",
      "Epoch: [3][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.0400(0.1871) Grad: 0.4797  \n",
      "Epoch: [3][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.2022(0.1880) Grad: 0.7348  \n",
      "Epoch: [3][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1237(0.1874) Grad: 0.4293  \n",
      "Epoch: [3][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.4064(0.1887) Grad: 0.7169  \n",
      "Epoch: [3][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.1403(0.1884) Grad: 0.8228  \n",
      "Epoch: [3][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1436(0.1887) Grad: 0.7451  \n",
      "EVAL: [0/330] Data 0.406 (0.406) Elapsed 0m 0s (remain 5m 1s) Loss: 0.0831(0.0831) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1566(0.1178) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1412(0.1128) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.1609(0.1084) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3 - avg_train_loss: 0.1887  avg_val_loss: 0.1090  time: 2062s\n",
      "Epoch 3 - Accuracy: 0.8803873172584014\n",
      "Epoch 3 - Save Best Score: 0.8804 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0424(0.1090) \n",
      "Epoch: [4][0/1316] Data 0.530 (0.530) Elapsed 0m 2s (remain 45m 41s) Loss: 0.2312(0.2312) Grad: 0.5140  \n",
      "Epoch: [4][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.1342(0.1871) Grad: 0.2002  \n",
      "Epoch: [4][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.3963(0.1853) Grad: 0.9609  \n",
      "Epoch: [4][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.1157(0.1845) Grad: 0.4506  \n",
      "Epoch: [4][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.0266(0.1806) Grad: 0.2965  \n",
      "Epoch: [4][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2694(0.1818) Grad: 0.6463  \n",
      "Epoch: [4][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.0973(0.1820) Grad: 0.9909  \n",
      "Epoch: [4][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1409(0.1801) Grad: 0.6119  \n",
      "Epoch: [4][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0743(0.1802) Grad: 0.5146  \n",
      "Epoch: [4][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.2646(0.1817) Grad: 0.5431  \n",
      "Epoch: [4][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1400(0.1825) Grad: 0.6232  \n",
      "Epoch: [4][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.2219(0.1816) Grad: 0.6629  \n",
      "Epoch: [4][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1736(0.1820) Grad: 1.1634  \n",
      "Epoch: [4][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.2719(0.1826) Grad: 0.7095  \n",
      "Epoch: [4][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1773(0.1824) Grad: 1.0955  \n",
      "EVAL: [0/330] Data 0.438 (0.438) Elapsed 0m 0s (remain 5m 6s) Loss: 0.0793(0.0793) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1455(0.1244) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1503(0.1184) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1641(0.1133) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4 - avg_train_loss: 0.1824  avg_val_loss: 0.1131  time: 2062s\n",
      "Epoch 4 - Accuracy: 0.8786785646478071\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0960(0.1131) \n",
      "Epoch: [5][0/1316] Data 0.524 (0.524) Elapsed 0m 2s (remain 44m 42s) Loss: 0.1411(0.1411) Grad: 0.6090  \n",
      "Epoch: [5][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 44s) Loss: 0.0299(0.1601) Grad: 0.5351  \n",
      "Epoch: [5][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.2430(0.1725) Grad: 0.4883  \n",
      "Epoch: [5][300/1316] Data 0.000 (0.002) Elapsed 7m 20s (remain 24m 44s) Loss: 0.1167(0.1772) Grad: 0.7690  \n",
      "Epoch: [5][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 17s) Loss: 0.2569(0.1755) Grad: 0.3681  \n",
      "Epoch: [5][500/1316] Data 0.000 (0.001) Elapsed 12m 12s (remain 19m 50s) Loss: 0.0261(0.1765) Grad: 0.3322  \n",
      "Epoch: [5][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 24s) Loss: 0.1503(0.1778) Grad: 0.4838  \n",
      "Epoch: [5][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 58s) Loss: 0.3857(0.1786) Grad: 0.6795  \n",
      "Epoch: [5][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 32s) Loss: 0.2415(0.1769) Grad: 0.7198  \n",
      "Epoch: [5][900/1316] Data 0.000 (0.001) Elapsed 21m 56s (remain 10m 6s) Loss: 0.1018(0.1776) Grad: 0.3262  \n",
      "Epoch: [5][1000/1316] Data 0.000 (0.001) Elapsed 24m 22s (remain 7m 40s) Loss: 0.2290(0.1768) Grad: 0.6231  \n",
      "Epoch: [5][1100/1316] Data 0.000 (0.001) Elapsed 26m 48s (remain 5m 14s) Loss: 0.1522(0.1772) Grad: 0.4558  \n",
      "Epoch: [5][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.2537(0.1758) Grad: 0.4567  \n",
      "Epoch: [5][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.0489(0.1751) Grad: 0.6056  \n",
      "Epoch: [5][1315/1316] Data 0.000 (0.001) Elapsed 32m 1s (remain 0m 0s) Loss: 0.0926(0.1754) Grad: 0.7398  \n",
      "EVAL: [0/330] Data 0.399 (0.399) Elapsed 0m 0s (remain 5m 4s) Loss: 0.1233(0.1233) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 40s) Loss: 0.1049(0.1116) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1238(0.1051) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.1520(0.1006) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5 - avg_train_loss: 0.1754  avg_val_loss: 0.1016  time: 2064s\n",
      "Epoch 5 - Accuracy: 0.8921587241313841\n",
      "Epoch 5 - Save Best Score: 0.8922 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0280(0.1016) \n",
      "Epoch: [6][0/1316] Data 0.505 (0.505) Elapsed 0m 2s (remain 44m 15s) Loss: 0.0397(0.0397) Grad: 0.6022  \n",
      "Epoch: [6][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.0443(0.1778) Grad: 0.5719  \n",
      "Epoch: [6][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.2017(0.1767) Grad: 0.6325  \n",
      "Epoch: [6][300/1316] Data 0.000 (0.002) Elapsed 7m 20s (remain 24m 43s) Loss: 0.3237(0.1791) Grad: 0.3943  \n",
      "Epoch: [6][400/1316] Data 0.001 (0.001) Elapsed 9m 46s (remain 22m 18s) Loss: 0.1599(0.1801) Grad: 0.6823  \n",
      "Epoch: [6][500/1316] Data 0.000 (0.001) Elapsed 12m 12s (remain 19m 51s) Loss: 0.1583(0.1762) Grad: 0.9529  \n",
      "Epoch: [6][600/1316] Data 0.000 (0.001) Elapsed 14m 38s (remain 17m 25s) Loss: 0.3748(0.1739) Grad: 0.6785  \n",
      "Epoch: [6][700/1316] Data 0.000 (0.001) Elapsed 17m 4s (remain 14m 58s) Loss: 0.1682(0.1738) Grad: 0.8967  \n",
      "Epoch: [6][800/1316] Data 0.000 (0.001) Elapsed 19m 30s (remain 12m 32s) Loss: 0.2024(0.1715) Grad: 0.5977  \n",
      "Epoch: [6][900/1316] Data 0.000 (0.001) Elapsed 21m 56s (remain 10m 6s) Loss: 0.1216(0.1730) Grad: 0.8516  \n",
      "Epoch: [6][1000/1316] Data 0.000 (0.001) Elapsed 24m 22s (remain 7m 40s) Loss: 0.1080(0.1736) Grad: 1.0018  \n",
      "Epoch: [6][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.2953(0.1721) Grad: 0.4785  \n",
      "Epoch: [6][1200/1316] Data 0.000 (0.001) Elapsed 29m 13s (remain 2m 47s) Loss: 0.2722(0.1715) Grad: 0.3372  \n",
      "Epoch: [6][1300/1316] Data 0.000 (0.001) Elapsed 31m 39s (remain 0m 21s) Loss: 0.0526(0.1713) Grad: 0.4477  \n",
      "Epoch: [6][1315/1316] Data 0.000 (0.001) Elapsed 32m 1s (remain 0m 0s) Loss: 0.2227(0.1713) Grad: 0.6231  \n",
      "EVAL: [0/330] Data 0.395 (0.395) Elapsed 0m 0s (remain 4m 56s) Loss: 0.1232(0.1232) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1132(0.1079) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1021(0.1026) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1756(0.0990) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6 - avg_train_loss: 0.1713  avg_val_loss: 0.0998  time: 2064s\n",
      "Epoch 6 - Accuracy: 0.8925384469337384\n",
      "Epoch 6 - Save Best Score: 0.8925 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.0183(0.0998) \n",
      "Epoch: [7][0/1316] Data 0.490 (0.490) Elapsed 0m 1s (remain 43m 42s) Loss: 0.1199(0.1199) Grad: 0.7230  \n",
      "Epoch: [7][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 42s) Loss: 0.1473(0.1639) Grad: 0.2399  \n",
      "Epoch: [7][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.0680(0.1696) Grad: 0.7057  \n",
      "Epoch: [7][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.1180(0.1674) Grad: 0.8545  \n",
      "Epoch: [7][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.0617(0.1692) Grad: 0.8131  \n",
      "Epoch: [7][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 50s) Loss: 0.4083(0.1692) Grad: 0.5351  \n",
      "Epoch: [7][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.0663(0.1706) Grad: 0.7163  \n",
      "Epoch: [7][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1567(0.1699) Grad: 0.3134  \n",
      "Epoch: [7][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.1314(0.1683) Grad: 0.7879  \n",
      "Epoch: [7][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1946(0.1691) Grad: 0.3361  \n",
      "Epoch: [7][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2374(0.1691) Grad: 0.3577  \n",
      "Epoch: [7][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.0643(0.1691) Grad: 0.3662  \n",
      "Epoch: [7][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2102(0.1677) Grad: 0.9978  \n",
      "Epoch: [7][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.1234(0.1678) Grad: 0.6934  \n",
      "Epoch: [7][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.2173(0.1675) Grad: 1.0007  \n",
      "EVAL: [0/330] Data 0.419 (0.419) Elapsed 0m 1s (remain 5m 53s) Loss: 0.1345(0.1345) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1437(0.1137) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1344(0.1088) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.1802(0.1049) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7 - avg_train_loss: 0.1675  avg_val_loss: 0.1051  time: 2062s\n",
      "Epoch 7 - Accuracy: 0.8857034364913613\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0536(0.1051) \n",
      "Epoch: [8][0/1316] Data 0.467 (0.467) Elapsed 0m 1s (remain 43m 37s) Loss: 0.2948(0.2948) Grad: 0.3840  \n",
      "Epoch: [8][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 41s) Loss: 0.0775(0.1470) Grad: 0.8149  \n",
      "Epoch: [8][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 10s) Loss: 0.1638(0.1590) Grad: 0.3642  \n",
      "Epoch: [8][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.0524(0.1575) Grad: 0.8789  \n",
      "Epoch: [8][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2270(0.1607) Grad: 0.2931  \n",
      "Epoch: [8][500/1316] Data 0.001 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.0616(0.1626) Grad: 0.6503  \n",
      "Epoch: [8][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.2678(0.1629) Grad: 0.3546  \n",
      "Epoch: [8][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.0505(0.1626) Grad: 0.5472  \n",
      "Epoch: [8][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.2504(0.1630) Grad: 0.6772  \n",
      "Epoch: [8][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0967(0.1633) Grad: 0.7225  \n",
      "Epoch: [8][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.2491(0.1627) Grad: 0.3997  \n",
      "Epoch: [8][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.2502(0.1619) Grad: 0.3679  \n",
      "Epoch: [8][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1027(0.1620) Grad: 0.3917  \n",
      "Epoch: [8][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.3021(0.1630) Grad: 0.6809  \n",
      "Epoch: [8][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1772(0.1631) Grad: 0.8061  \n",
      "EVAL: [0/330] Data 0.452 (0.452) Elapsed 0m 0s (remain 5m 12s) Loss: 0.1178(0.1178) \n",
      "EVAL: [100/330] Data 0.000 (0.005) Elapsed 0m 43s (remain 1m 39s) Loss: 0.0929(0.1070) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1020(0.1021) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.1531(0.0985) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8 - avg_train_loss: 0.1631  avg_val_loss: 0.0989  time: 2062s\n",
      "Epoch 8 - Accuracy: 0.8932978925384469\n",
      "Epoch 8 - Save Best Score: 0.8933 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.002) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0254(0.0989) \n",
      "Epoch: [9][0/1316] Data 0.506 (0.506) Elapsed 0m 2s (remain 47m 42s) Loss: 0.0920(0.0920) Grad: 0.9687  \n",
      "Epoch: [9][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 40s) Loss: 0.1828(0.1701) Grad: 0.6621  \n",
      "Epoch: [9][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 9s) Loss: 0.0688(0.1617) Grad: 0.6475  \n",
      "Epoch: [9][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.2314(0.1646) Grad: 0.6549  \n",
      "Epoch: [9][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2855(0.1670) Grad: 0.9139  \n",
      "Epoch: [9][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1547(0.1623) Grad: 0.9603  \n",
      "Epoch: [9][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.1905(0.1636) Grad: 0.3898  \n",
      "Epoch: [9][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.2808(0.1619) Grad: 0.3695  \n",
      "Epoch: [9][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.3504(0.1615) Grad: 0.5319  \n",
      "Epoch: [9][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1858(0.1609) Grad: 0.7546  \n",
      "Epoch: [9][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1070(0.1617) Grad: 0.4023  \n",
      "Epoch: [9][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.0507(0.1619) Grad: 0.7248  \n",
      "Epoch: [9][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.1792(0.1621) Grad: 0.7386  \n",
      "Epoch: [9][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.1232(0.1620) Grad: 0.5284  \n",
      "Epoch: [9][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.2125(0.1618) Grad: 0.3089  \n",
      "EVAL: [0/330] Data 0.427 (0.427) Elapsed 0m 0s (remain 5m 8s) Loss: 0.1070(0.1070) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1005(0.1058) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1040(0.1009) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.1519(0.0972) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9 - avg_train_loss: 0.1618  avg_val_loss: 0.0975  time: 2062s\n",
      "Epoch 9 - Accuracy: 0.8953863679513955\n",
      "Epoch 9 - Save Best Score: 0.8954 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0219(0.0975) \n",
      "Epoch: [10][0/1316] Data 0.473 (0.473) Elapsed 0m 1s (remain 43m 29s) Loss: 0.2438(0.2438) Grad: 0.6649  \n",
      "Epoch: [10][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 37s) Loss: 0.0946(0.1561) Grad: 0.6092  \n",
      "Epoch: [10][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.2179(0.1626) Grad: 1.2039  \n",
      "Epoch: [10][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.2541(0.1589) Grad: 0.5722  \n",
      "Epoch: [10][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.4005(0.1629) Grad: 0.6882  \n",
      "Epoch: [10][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2014(0.1597) Grad: 0.4008  \n",
      "Epoch: [10][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1837(0.1605) Grad: 0.3558  \n",
      "Epoch: [10][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.2203(0.1623) Grad: 0.6329  \n",
      "Epoch: [10][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.0432(0.1615) Grad: 0.7092  \n",
      "Epoch: [10][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 5s) Loss: 0.2470(0.1612) Grad: 0.8053  \n",
      "Epoch: [10][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2335(0.1593) Grad: 0.4515  \n",
      "Epoch: [10][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.2959(0.1594) Grad: 0.3810  \n",
      "Epoch: [10][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2050(0.1595) Grad: 0.3938  \n",
      "Epoch: [10][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.1758(0.1600) Grad: 0.3777  \n",
      "Epoch: [10][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.1730(0.1599) Grad: 0.4810  \n",
      "EVAL: [0/330] Data 0.438 (0.438) Elapsed 0m 0s (remain 5m 8s) Loss: 0.1203(0.1203) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1039(0.1052) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.0998(0.1005) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.1548(0.0967) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10 - avg_train_loss: 0.1599  avg_val_loss: 0.0971  time: 2063s\n",
      "Epoch 10 - Accuracy: 0.8942471995443326\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0332(0.0971) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "========== fold: 3 result ==========\n",
      "Score: 0.89539\n",
      "========== fold: 4 training ==========\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [1][0/1316] Data 0.504 (0.504) Elapsed 0m 2s (remain 44m 13s) Loss: 0.5068(0.5068) Grad: 0.7058  \n",
      "Epoch: [1][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 37s) Loss: 0.2476(0.3405) Grad: 0.7874  \n",
      "Epoch: [1][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.2941(0.3104) Grad: 0.7930  \n",
      "Epoch: [1][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.3453(0.2895) Grad: 0.7813  \n",
      "Epoch: [1][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.3505(0.2743) Grad: 1.1310  \n",
      "Epoch: [1][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1828(0.2642) Grad: 0.8183  \n",
      "Epoch: [1][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.0753(0.2563) Grad: 0.3932  \n",
      "Epoch: [1][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.2270(0.2523) Grad: 0.4987  \n",
      "Epoch: [1][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.2662(0.2479) Grad: 0.7013  \n",
      "Epoch: [1][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.3637(0.2436) Grad: 0.5993  \n",
      "Epoch: [1][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1960(0.2411) Grad: 0.8825  \n",
      "Epoch: [1][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.0993(0.2390) Grad: 0.4928  \n",
      "Epoch: [1][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.2632(0.2375) Grad: 0.7101  \n",
      "Epoch: [1][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.1590(0.2340) Grad: 0.7775  \n",
      "Epoch: [1][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.1958(0.2335) Grad: 0.4272  \n",
      "EVAL: [0/330] Data 0.389 (0.389) Elapsed 0m 0s (remain 4m 52s) Loss: 0.1728(0.1728) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1042(0.1208) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.0901(0.1249) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0650(0.1240) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1 - avg_train_loss: 0.2335  avg_val_loss: 0.1249  time: 2063s\n",
      "Epoch 1 - Accuracy: 0.862350484146573\n",
      "Epoch 1 - Save Best Score: 0.8624 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0010(0.1249) \n",
      "Epoch: [2][0/1316] Data 0.469 (0.469) Elapsed 0m 1s (remain 43m 41s) Loss: 0.2100(0.2100) Grad: 0.5599  \n",
      "Epoch: [2][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.2577(0.2184) Grad: 0.4677  \n",
      "Epoch: [2][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.1680(0.2179) Grad: 0.7284  \n",
      "Epoch: [2][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.1105(0.2096) Grad: 0.4697  \n",
      "Epoch: [2][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.2388(0.2014) Grad: 0.5051  \n",
      "Epoch: [2][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.3007(0.2033) Grad: 0.6679  \n",
      "Epoch: [2][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.4195(0.2041) Grad: 0.7813  \n",
      "Epoch: [2][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.5166(0.2033) Grad: 0.6142  \n",
      "Epoch: [2][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.2627(0.2020) Grad: 0.5168  \n",
      "Epoch: [2][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.3505(0.2031) Grad: 0.6672  \n",
      "Epoch: [2][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.0927(0.2022) Grad: 0.8978  \n",
      "Epoch: [2][1100/1316] Data 0.000 (0.001) Elapsed 26m 44s (remain 5m 13s) Loss: 0.1260(0.2014) Grad: 0.5856  \n",
      "Epoch: [2][1200/1316] Data 0.000 (0.001) Elapsed 29m 10s (remain 2m 47s) Loss: 0.2612(0.1998) Grad: 0.8257  \n",
      "Epoch: [2][1300/1316] Data 0.000 (0.001) Elapsed 31m 36s (remain 0m 21s) Loss: 0.2039(0.1994) Grad: 0.5238  \n",
      "Epoch: [2][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.0652(0.1987) Grad: 0.6287  \n",
      "EVAL: [0/330] Data 0.389 (0.389) Elapsed 0m 0s (remain 4m 56s) Loss: 0.1572(0.1572) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.0947(0.1126) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.0867(0.1176) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0604(0.1166) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2 - avg_train_loss: 0.1987  avg_val_loss: 0.1179  time: 2060s\n",
      "Epoch 2 - Accuracy: 0.8697550787924815\n",
      "Epoch 2 - Save Best Score: 0.8698 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0012(0.1179) \n",
      "Epoch: [3][0/1316] Data 0.447 (0.447) Elapsed 0m 2s (remain 43m 58s) Loss: 0.1971(0.1971) Grad: 0.4694  \n",
      "Epoch: [3][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 35s) Loss: 0.1848(0.1802) Grad: 0.5853  \n",
      "Epoch: [3][200/1316] Data 0.000 (0.002) Elapsed 4m 53s (remain 27m 8s) Loss: 0.0372(0.1825) Grad: 0.5178  \n",
      "Epoch: [3][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 42s) Loss: 0.2591(0.1878) Grad: 0.4422  \n",
      "Epoch: [3][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.2868(0.1891) Grad: 0.5664  \n",
      "Epoch: [3][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.1832(0.1879) Grad: 0.5380  \n",
      "Epoch: [3][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.1661(0.1871) Grad: 0.7288  \n",
      "Epoch: [3][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.2187(0.1874) Grad: 0.9351  \n",
      "Epoch: [3][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.2585(0.1868) Grad: 0.3681  \n",
      "Epoch: [3][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.1262(0.1862) Grad: 0.6539  \n",
      "Epoch: [3][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.3117(0.1854) Grad: 0.4234  \n",
      "Epoch: [3][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.1580(0.1869) Grad: 0.8124  \n",
      "Epoch: [3][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.4054(0.1868) Grad: 0.7647  \n",
      "Epoch: [3][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.3397(0.1861) Grad: 0.5829  \n",
      "Epoch: [3][1315/1316] Data 0.000 (0.000) Elapsed 31m 59s (remain 0m 0s) Loss: 0.2140(0.1861) Grad: 0.3412  \n",
      "EVAL: [0/330] Data 0.391 (0.391) Elapsed 0m 0s (remain 4m 55s) Loss: 0.1654(0.1654) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.0886(0.1157) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1151(0.1185) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0736(0.1164) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3 - avg_train_loss: 0.1861  avg_val_loss: 0.1178  time: 2062s\n",
      "Epoch 3 - Accuracy: 0.8693753559901272\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0018(0.1178) \n",
      "Epoch: [4][0/1316] Data 0.506 (0.506) Elapsed 0m 2s (remain 44m 32s) Loss: 0.0939(0.0939) Grad: 0.4809  \n",
      "Epoch: [4][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 38s) Loss: 0.2449(0.1803) Grad: 0.4719  \n",
      "Epoch: [4][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 8s) Loss: 0.2266(0.1782) Grad: 0.5385  \n",
      "Epoch: [4][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 41s) Loss: 0.0871(0.1784) Grad: 0.2717  \n",
      "Epoch: [4][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 14s) Loss: 0.1230(0.1778) Grad: 0.8685  \n",
      "Epoch: [4][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.2382(0.1785) Grad: 0.9607  \n",
      "Epoch: [4][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 23s) Loss: 0.1136(0.1813) Grad: 0.6057  \n",
      "Epoch: [4][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.1017(0.1837) Grad: 0.3358  \n",
      "Epoch: [4][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.2476(0.1814) Grad: 0.5815  \n",
      "Epoch: [4][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 5s) Loss: 0.1675(0.1816) Grad: 0.7336  \n",
      "Epoch: [4][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1206(0.1816) Grad: 0.6841  \n",
      "Epoch: [4][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.1122(0.1805) Grad: 0.5877  \n",
      "Epoch: [4][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.0780(0.1794) Grad: 0.2948  \n",
      "Epoch: [4][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.0511(0.1797) Grad: 0.3610  \n",
      "Epoch: [4][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.2333(0.1800) Grad: 0.3908  \n",
      "EVAL: [0/330] Data 0.394 (0.394) Elapsed 0m 0s (remain 4m 52s) Loss: 0.1798(0.1798) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.0885(0.1005) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1230(0.1071) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0698(0.1091) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4 - avg_train_loss: 0.1800  avg_val_loss: 0.1108  time: 2062s\n",
      "Epoch 4 - Accuracy: 0.8773495348395671\n",
      "Epoch 4 - Save Best Score: 0.8773 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0027(0.1108) \n",
      "Epoch: [5][0/1316] Data 0.485 (0.485) Elapsed 0m 2s (remain 48m 27s) Loss: 0.2126(0.2126) Grad: 0.4923  \n",
      "Epoch: [5][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 39s) Loss: 0.1880(0.1614) Grad: 0.6605  \n",
      "Epoch: [5][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 10s) Loss: 0.2084(0.1741) Grad: 0.5640  \n",
      "Epoch: [5][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 43s) Loss: 0.2619(0.1784) Grad: 0.4430  \n",
      "Epoch: [5][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.1258(0.1799) Grad: 0.7317  \n",
      "Epoch: [5][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 49s) Loss: 0.2628(0.1774) Grad: 0.9182  \n",
      "Epoch: [5][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 23s) Loss: 0.3538(0.1798) Grad: 0.4519  \n",
      "Epoch: [5][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.1537(0.1775) Grad: 1.0520  \n",
      "Epoch: [5][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.0187(0.1769) Grad: 0.3452  \n",
      "Epoch: [5][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.0467(0.1763) Grad: 0.5100  \n",
      "Epoch: [5][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.1252(0.1743) Grad: 0.6767  \n",
      "Epoch: [5][1100/1316] Data 0.000 (0.001) Elapsed 26m 46s (remain 5m 13s) Loss: 0.2784(0.1741) Grad: 0.6055  \n",
      "Epoch: [5][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1402(0.1741) Grad: 0.5149  \n",
      "Epoch: [5][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.3030(0.1752) Grad: 0.5359  \n",
      "Epoch: [5][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.2990(0.1752) Grad: 0.6036  \n",
      "EVAL: [0/330] Data 0.386 (0.386) Elapsed 0m 0s (remain 4m 54s) Loss: 0.1458(0.1458) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1042(0.1018) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1400(0.1074) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0548(0.1062) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5 - avg_train_loss: 0.1752  avg_val_loss: 0.1075  time: 2062s\n",
      "Epoch 5 - Accuracy: 0.8826656540725271\n",
      "Epoch 5 - Save Best Score: 0.8827 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0037(0.1075) \n",
      "Epoch: [6][0/1316] Data 0.507 (0.507) Elapsed 0m 2s (remain 44m 18s) Loss: 0.1254(0.1254) Grad: 0.6634  \n",
      "Epoch: [6][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 36s) Loss: 0.0555(0.1637) Grad: 0.5080  \n",
      "Epoch: [6][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.2504(0.1645) Grad: 0.6869  \n",
      "Epoch: [6][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 43s) Loss: 0.1835(0.1699) Grad: 0.5872  \n",
      "Epoch: [6][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 16s) Loss: 0.1464(0.1749) Grad: 0.2661  \n",
      "Epoch: [6][500/1316] Data 0.000 (0.001) Elapsed 12m 11s (remain 19m 50s) Loss: 0.1957(0.1731) Grad: 0.3326  \n",
      "Epoch: [6][600/1316] Data 0.000 (0.001) Elapsed 14m 37s (remain 17m 24s) Loss: 0.0815(0.1711) Grad: 0.8535  \n",
      "Epoch: [6][700/1316] Data 0.000 (0.001) Elapsed 17m 3s (remain 14m 57s) Loss: 0.2187(0.1721) Grad: 0.9373  \n",
      "Epoch: [6][800/1316] Data 0.000 (0.001) Elapsed 19m 29s (remain 12m 31s) Loss: 0.2606(0.1723) Grad: 0.5929  \n",
      "Epoch: [6][900/1316] Data 0.000 (0.001) Elapsed 21m 55s (remain 10m 5s) Loss: 0.1171(0.1729) Grad: 0.8397  \n",
      "Epoch: [6][1000/1316] Data 0.000 (0.001) Elapsed 24m 21s (remain 7m 39s) Loss: 0.2764(0.1738) Grad: 0.5825  \n",
      "Epoch: [6][1100/1316] Data 0.000 (0.001) Elapsed 26m 47s (remain 5m 13s) Loss: 0.1162(0.1721) Grad: 0.6190  \n",
      "Epoch: [6][1200/1316] Data 0.000 (0.001) Elapsed 29m 12s (remain 2m 47s) Loss: 0.1846(0.1720) Grad: 0.8554  \n",
      "Epoch: [6][1300/1316] Data 0.000 (0.001) Elapsed 31m 38s (remain 0m 21s) Loss: 0.0193(0.1717) Grad: 0.2891  \n",
      "Epoch: [6][1315/1316] Data 0.000 (0.001) Elapsed 32m 0s (remain 0m 0s) Loss: 0.1775(0.1715) Grad: 0.3267  \n",
      "EVAL: [0/330] Data 0.408 (0.408) Elapsed 0m 0s (remain 5m 5s) Loss: 0.1475(0.1475) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1259(0.1062) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 27s (remain 0m 55s) Loss: 0.1282(0.1105) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0395(0.1099) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6 - avg_train_loss: 0.1715  avg_val_loss: 0.1113  time: 2063s\n",
      "Epoch 6 - Accuracy: 0.8760205050313271\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0040(0.1113) \n",
      "Epoch: [7][0/1316] Data 0.520 (0.520) Elapsed 0m 2s (remain 44m 27s) Loss: 0.0702(0.0702) Grad: 0.6528  \n",
      "Epoch: [7][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 34s) Loss: 0.1738(0.1688) Grad: 0.4909  \n",
      "Epoch: [7][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 6s) Loss: 0.0499(0.1671) Grad: 0.3945  \n",
      "Epoch: [7][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.1950(0.1638) Grad: 0.5123  \n",
      "Epoch: [7][400/1316] Data 0.000 (0.001) Elapsed 9m 44s (remain 22m 13s) Loss: 0.0574(0.1639) Grad: 0.6698  \n",
      "Epoch: [7][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.1119(0.1632) Grad: 1.0027  \n",
      "Epoch: [7][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.1083(0.1636) Grad: 0.6885  \n",
      "Epoch: [7][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 56s) Loss: 0.0560(0.1630) Grad: 0.4137  \n",
      "Epoch: [7][800/1316] Data 0.000 (0.001) Elapsed 19m 27s (remain 12m 30s) Loss: 0.0884(0.1617) Grad: 0.7047  \n",
      "Epoch: [7][900/1316] Data 0.000 (0.001) Elapsed 21m 53s (remain 10m 5s) Loss: 0.1049(0.1620) Grad: 0.7354  \n",
      "Epoch: [7][1000/1316] Data 0.000 (0.001) Elapsed 24m 19s (remain 7m 39s) Loss: 0.1045(0.1624) Grad: 0.5520  \n",
      "Epoch: [7][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.1809(0.1631) Grad: 0.4841  \n",
      "Epoch: [7][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.2374(0.1640) Grad: 0.9986  \n",
      "Epoch: [7][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.1495(0.1645) Grad: 0.2331  \n",
      "Epoch: [7][1315/1316] Data 0.000 (0.001) Elapsed 31m 58s (remain 0m 0s) Loss: 0.1897(0.1647) Grad: 0.9086  \n",
      "EVAL: [0/330] Data 0.389 (0.389) Elapsed 0m 0s (remain 4m 54s) Loss: 0.1227(0.1227) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1143(0.1050) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1386(0.1098) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0583(0.1099) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7 - avg_train_loss: 0.1647  avg_val_loss: 0.1112  time: 2061s\n",
      "Epoch 7 - Accuracy: 0.8782988418454528\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0037(0.1112) \n",
      "Epoch: [8][0/1316] Data 0.528 (0.528) Elapsed 0m 2s (remain 44m 29s) Loss: 0.2186(0.2186) Grad: 0.4681  \n",
      "Epoch: [8][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 43s) Loss: 0.1811(0.1657) Grad: 0.5412  \n",
      "Epoch: [8][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.0996(0.1645) Grad: 0.6951  \n",
      "Epoch: [8][300/1316] Data 0.000 (0.002) Elapsed 7m 20s (remain 24m 44s) Loss: 0.1271(0.1662) Grad: 0.6065  \n",
      "Epoch: [8][400/1316] Data 0.000 (0.001) Elapsed 9m 46s (remain 22m 18s) Loss: 0.1950(0.1623) Grad: 0.7401  \n",
      "Epoch: [8][500/1316] Data 0.000 (0.001) Elapsed 12m 12s (remain 19m 50s) Loss: 0.1074(0.1588) Grad: 0.7589  \n",
      "Epoch: [8][600/1316] Data 0.000 (0.001) Elapsed 14m 38s (remain 17m 25s) Loss: 0.2153(0.1603) Grad: 0.4433  \n",
      "Epoch: [8][700/1316] Data 0.000 (0.001) Elapsed 17m 4s (remain 14m 58s) Loss: 0.1704(0.1604) Grad: 0.4940  \n",
      "Epoch: [8][800/1316] Data 0.000 (0.001) Elapsed 19m 30s (remain 12m 32s) Loss: 0.1812(0.1595) Grad: 0.8937  \n",
      "Epoch: [8][900/1316] Data 0.000 (0.001) Elapsed 21m 56s (remain 10m 6s) Loss: 0.0198(0.1587) Grad: 0.5845  \n",
      "Epoch: [8][1000/1316] Data 0.000 (0.001) Elapsed 24m 22s (remain 7m 40s) Loss: 0.3419(0.1587) Grad: 0.5480  \n",
      "Epoch: [8][1100/1316] Data 0.000 (0.001) Elapsed 26m 48s (remain 5m 14s) Loss: 0.1671(0.1582) Grad: 0.7080  \n",
      "Epoch: [8][1200/1316] Data 0.000 (0.001) Elapsed 29m 14s (remain 2m 47s) Loss: 0.1024(0.1572) Grad: 1.0853  \n",
      "Epoch: [8][1300/1316] Data 0.000 (0.001) Elapsed 31m 40s (remain 0m 21s) Loss: 0.1744(0.1580) Grad: 0.7290  \n",
      "Epoch: [8][1315/1316] Data 0.000 (0.001) Elapsed 32m 2s (remain 0m 0s) Loss: 0.2958(0.1581) Grad: 0.5475  \n",
      "EVAL: [0/330] Data 0.390 (0.390) Elapsed 0m 0s (remain 4m 52s) Loss: 0.1184(0.1184) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1177(0.1038) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1186(0.1080) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0379(0.1074) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8 - avg_train_loss: 0.1581  avg_val_loss: 0.1088  time: 2064s\n",
      "Epoch 8 - Accuracy: 0.8828555154737042\n",
      "Epoch 8 - Save Best Score: 0.8829 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.001 (0.001) Elapsed 2m 21s (remain 0m 0s) Loss: 0.0050(0.1088) \n",
      "Epoch: [9][0/1316] Data 0.510 (0.510) Elapsed 0m 2s (remain 48m 44s) Loss: 0.1967(0.1967) Grad: 0.6506  \n",
      "Epoch: [9][100/1316] Data 0.000 (0.005) Elapsed 2m 28s (remain 29m 40s) Loss: 0.1492(0.1391) Grad: 0.7674  \n",
      "Epoch: [9][200/1316] Data 0.000 (0.003) Elapsed 4m 54s (remain 27m 11s) Loss: 0.0739(0.1485) Grad: 0.3919  \n",
      "Epoch: [9][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 43s) Loss: 0.1994(0.1461) Grad: 0.3467  \n",
      "Epoch: [9][400/1316] Data 0.000 (0.001) Elapsed 9m 46s (remain 22m 17s) Loss: 0.3146(0.1504) Grad: 0.4562  \n",
      "Epoch: [9][500/1316] Data 0.000 (0.001) Elapsed 12m 12s (remain 19m 51s) Loss: 0.0896(0.1524) Grad: 0.2908  \n",
      "Epoch: [9][600/1316] Data 0.000 (0.001) Elapsed 14m 38s (remain 17m 24s) Loss: 0.0726(0.1548) Grad: 0.4067  \n",
      "Epoch: [9][700/1316] Data 0.000 (0.001) Elapsed 17m 4s (remain 14m 58s) Loss: 0.2567(0.1563) Grad: 0.5261  \n",
      "Epoch: [9][800/1316] Data 0.000 (0.001) Elapsed 19m 30s (remain 12m 32s) Loss: 0.0670(0.1561) Grad: 0.7442  \n",
      "Epoch: [9][900/1316] Data 0.000 (0.001) Elapsed 21m 57s (remain 10m 6s) Loss: 0.1258(0.1544) Grad: 0.5914  \n",
      "Epoch: [9][1000/1316] Data 0.000 (0.001) Elapsed 24m 23s (remain 7m 40s) Loss: 0.1909(0.1552) Grad: 0.4980  \n",
      "Epoch: [9][1100/1316] Data 0.000 (0.001) Elapsed 26m 49s (remain 5m 14s) Loss: 0.1615(0.1564) Grad: 0.9721  \n",
      "Epoch: [9][1200/1316] Data 0.000 (0.001) Elapsed 29m 15s (remain 2m 48s) Loss: 0.0829(0.1560) Grad: 0.2906  \n",
      "Epoch: [9][1300/1316] Data 0.000 (0.001) Elapsed 31m 41s (remain 0m 21s) Loss: 0.2658(0.1554) Grad: 0.5017  \n",
      "Epoch: [9][1315/1316] Data 0.000 (0.001) Elapsed 32m 3s (remain 0m 0s) Loss: 0.2042(0.1550) Grad: 0.3474  \n",
      "EVAL: [0/330] Data 0.407 (0.407) Elapsed 0m 0s (remain 4m 57s) Loss: 0.1318(0.1318) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 44s (remain 1m 39s) Loss: 0.1056(0.1012) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1174(0.1064) \n",
      "EVAL: [300/330] Data 0.000 (0.002) Elapsed 2m 9s (remain 0m 12s) Loss: 0.0390(0.1057) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9 - avg_train_loss: 0.1550  avg_val_loss: 0.1071  time: 2066s\n",
      "Epoch 9 - Accuracy: 0.8843744066831213\n",
      "Epoch 9 - Save Best Score: 0.8844 Model\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0031(0.1071) \n",
      "Epoch: [10][0/1316] Data 0.480 (0.480) Elapsed 0m 2s (remain 44m 45s) Loss: 0.1226(0.1226) Grad: 0.6177  \n",
      "Epoch: [10][100/1316] Data 0.000 (0.005) Elapsed 2m 27s (remain 29m 34s) Loss: 0.1390(0.1459) Grad: 0.7875  \n",
      "Epoch: [10][200/1316] Data 0.000 (0.003) Elapsed 4m 53s (remain 27m 7s) Loss: 0.1062(0.1573) Grad: 0.3829  \n",
      "Epoch: [10][300/1316] Data 0.000 (0.002) Elapsed 7m 19s (remain 24m 40s) Loss: 0.1022(0.1625) Grad: 0.4409  \n",
      "Epoch: [10][400/1316] Data 0.000 (0.001) Elapsed 9m 45s (remain 22m 15s) Loss: 0.2986(0.1604) Grad: 0.4605  \n",
      "Epoch: [10][500/1316] Data 0.000 (0.001) Elapsed 12m 10s (remain 19m 48s) Loss: 0.2289(0.1588) Grad: 0.7564  \n",
      "Epoch: [10][600/1316] Data 0.000 (0.001) Elapsed 14m 36s (remain 17m 22s) Loss: 0.0610(0.1584) Grad: 0.5973  \n",
      "Epoch: [10][700/1316] Data 0.000 (0.001) Elapsed 17m 2s (remain 14m 57s) Loss: 0.0384(0.1574) Grad: 0.5982  \n",
      "Epoch: [10][800/1316] Data 0.000 (0.001) Elapsed 19m 28s (remain 12m 31s) Loss: 0.1482(0.1584) Grad: 1.2386  \n",
      "Epoch: [10][900/1316] Data 0.000 (0.001) Elapsed 21m 54s (remain 10m 5s) Loss: 0.2459(0.1586) Grad: 0.4895  \n",
      "Epoch: [10][1000/1316] Data 0.000 (0.001) Elapsed 24m 20s (remain 7m 39s) Loss: 0.2991(0.1583) Grad: 0.5614  \n",
      "Epoch: [10][1100/1316] Data 0.000 (0.001) Elapsed 26m 45s (remain 5m 13s) Loss: 0.3125(0.1579) Grad: 0.6606  \n",
      "Epoch: [10][1200/1316] Data 0.000 (0.001) Elapsed 29m 11s (remain 2m 47s) Loss: 0.1614(0.1577) Grad: 0.8896  \n",
      "Epoch: [10][1300/1316] Data 0.000 (0.001) Elapsed 31m 37s (remain 0m 21s) Loss: 0.1539(0.1574) Grad: 0.9930  \n",
      "Epoch: [10][1315/1316] Data 0.000 (0.001) Elapsed 31m 59s (remain 0m 0s) Loss: 0.1101(0.1578) Grad: 0.7051  \n",
      "EVAL: [0/330] Data 0.390 (0.390) Elapsed 0m 0s (remain 4m 57s) Loss: 0.1235(0.1235) \n",
      "EVAL: [100/330] Data 0.000 (0.004) Elapsed 0m 43s (remain 1m 39s) Loss: 0.1022(0.1008) \n",
      "EVAL: [200/330] Data 0.000 (0.002) Elapsed 1m 26s (remain 0m 55s) Loss: 0.1204(0.1062) \n",
      "EVAL: [300/330] Data 0.000 (0.001) Elapsed 2m 10s (remain 0m 12s) Loss: 0.0383(0.1055) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10 - avg_train_loss: 0.1578  avg_val_loss: 0.1067  time: 2061s\n",
      "Epoch 10 - Accuracy: 0.8830453768748814\n",
      "========== fold: 4 result ==========\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EVAL: [329/330] Data 0.000 (0.001) Elapsed 2m 22s (remain 0m 0s) Loss: 0.0033(0.1067) \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Score: 0.88437\n",
      "========== CV ==========\n",
      "Score: 0.89103\n"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kaggle",
   "language": "python",
   "name": "kaggle"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}