Lec4/Assignment3_cifar10_MLP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment3. Cifar10 Hyperparameter Tuning with MLP  \n",
    "\n",
    "이 과제에서는 cifar10 데이터셋에 대해서 MLP를 이용한 10-way Classification을 해볼 겁니다!  \n",
    "데이터의 차원이 3072 dimension이 된 만큼 MNIST보다는 쉽지 않겠죠?  \n",
    "\n",
    "특히 이번 과제는 각종 Regularization 기법들과 Optimizer등이 이미 구현되어 있는 코드(작성자에게 칭찬..!)를 통해서 직접 다양한 하이퍼파라미터들이 성능에 어떤 영향을 미치는지 체험해보셨으면 해요. \n",
    "\n",
    "### 만약 **제가 하이퍼파라미터를 튜닝한다면** 일반적으로..  \n",
    "\n",
    "1. 레이어 수랑 히든 유닛 수를 조절해서 적절한 (성능이 나오면서 파라미터 수는 작은) Model Capacity를 찾구요  \n",
    "2. Learning Rate를 조절하면서 적절한 속도로 학습이 되는 값을 찾습니다. (값이 너무 크면 loss가 요동치거나 발산합니다)\n",
    "3. Dropout과 l2 값을 조절하면서 Overfitting을 최대한 줄여보구요.  \n",
    "4. BatchNormalization과 Xavier Initialization을 껐다 켜보면서 성능 변화가 어느 정도 일어나는지 확인해봅니다.  \n",
    "\n",
    "이런 식으로 4~5개 정도의 실험을 거치면서 점점 하이퍼파라미터 영역을 좁혀나가면 그나마 안정적으로 값을 올릴 수 있었던 것 같습니다 :)  \n",
    "시간이 되시는 분들은 Random Search를 해봐도 재밌을 것 같네요!(하지만 시각화는 쉽지 않겠죠?)\n",
    "\n",
    "그리고 추가로..  \n",
    "\n",
    "1. Optimizer를 바꿔보세요!  \n",
    "2. Activation Function을 바꿔보세요!  \n",
    "\n",
    "### 실험이 다 끝나셨다면  \n",
    "\n",
    "각 실험의 그림과 결과도 유지해주시고 주피터 노트북(.ipynb) 파일의 끝 부분에 최종적으로 찾은 2개의 하이퍼파라미터 조합과 그때의 Train/Validation/Test Accuracy를 리포트해주세요! \n",
    "\n",
    "그리고 [과제 제출 및 피드백 링크](https://goo.gl/forms/XQHdElHCueyCwfoi2)를 통해 제출해주시면 감사하겠습니다 :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>  \n",
    "\n",
    "# 시작하기\n",
    "\n",
    "[제가 미리 만들어놓은 이 링크](https://colab.research.google.com/github/heartcored98/Standalone-DeepLearning/blob/master/Lec4/Assignment3_cifar10_MLP.ipynb)를 통해 Colab에서 바로 작업하실 수 있습니다!  \n",
    "만약 코드가 알록달록 하지 않다면(Syntax Highlighting이 안 된다면)  \n",
    "그냥 새로운 python3, GPU 런타임으로 Colab 파일을 만드신 후 코드를 복붙하시는게 빠를 겁니다.   \n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "아래 코드를 통해 Colab에 연결되어 있는 서버 컴퓨터 내에 결과들을 저장할 results 폴더를 만들어봅시다.  \n",
    "만약 이미 만들었다면 **File exists** 와 같은 에러가 뜨면서 새로운 폴더 생성이 불가능할텐데 폴더만 있다면 괜찮으니 넘어가줍시다.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: cannot create directory ‘results’: File exists\r\n"
     ]
    }
   ],
   "source": [
    "!mkdir results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PD4cIKKvKFCC"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import argparse\n",
    "import numpy as np\n",
    "import time\n",
    "from copy import deepcopy # Add Deepcopy for args\n",
    "import seaborn as sns \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "29UainWPco7Y"
   },
   "source": [
    "## Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 73
    },
    "colab_type": "code",
    "id": "Cu753dPPKGkV",
    "outputId": "43b9be12-27a2-48ac-d9d4-08ea5dab0658"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainset, valset = torch.utils.data.random_split(trainset, [40000, 10000])\n",
    "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "partition = {'train': trainset, 'val':valset, 'test':testset}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RxnfFJwBcsAv"
   },
   "source": [
    "## Model Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_G6bZbbkMWWt"
   },
   "outputs": [],
   "source": [
    "class MLP(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim, hid_dim, n_layer, act, dropout, use_bn, use_xavier):\n",
    "        super(MLP, self).__init__()\n",
    "        self.in_dim = in_dim\n",
    "        self.out_dim = out_dim\n",
    "        self.hid_dim = hid_dim\n",
    "        self.n_layer = n_layer\n",
    "        self.act = act\n",
    "        self.dropout = dropout\n",
    "        self.use_bn = use_bn\n",
    "        self.use_xavier = use_xavier\n",
    "        \n",
    "        # ====== Create Linear Layers ====== #\n",
    "        self.fc1 = nn.Linear(self.in_dim, self.hid_dim)\n",
    "        \n",
    "        self.linears = nn.ModuleList()\n",
    "        self.bns = nn.ModuleList()\n",
    "        for i in range(self.n_layer-1):\n",
    "            self.linears.append(nn.Linear(self.hid_dim, self.hid_dim))\n",
    "            if self.use_bn:\n",
    "                self.bns.append(nn.BatchNorm1d(self.hid_dim))\n",
    "                \n",
    "        self.fc2 = nn.Linear(self.hid_dim, self.out_dim)\n",
    "        \n",
    "        # ====== Create Activation Function ====== #\n",
    "        if self.act == 'relu':\n",
    "            self.act = nn.ReLU()\n",
    "        elif self.act == 'tanh':\n",
    "            self.act == nn.Tanh()\n",
    "        elif self.act == 'sigmoid':\n",
    "            self.act = nn.Sigmoid()\n",
    "        else:\n",
    "            raise ValueError('no valid activation function selected!')\n",
    "        \n",
    "        # ====== Create Regularization Layer ======= #\n",
    "        self.dropout = nn.Dropout(self.dropout)\n",
    "        if self.use_xavier:\n",
    "            self.xavier_init()\n",
    "          \n",
    "    def forward(self, x):\n",
    "        x = self.act(self.fc1(x))\n",
    "        for i in range(len(self.linears)):\n",
    "            x = self.act(self.linears[i](x))\n",
    "            if self.use_bn:\n",
    "                x = self.bns[i](x)\n",
    "            x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "    \n",
    "    def xavier_init(self):\n",
    "        for linear in self.linears:\n",
    "            nn.init.xavier_normal_(linear.weight)\n",
    "            linear.bias.data.fill_(0.01)\n",
    "            \n",
    "net = MLP(3072, 10, 100, 4, 'relu', 0.1, True, True) # Testing Model Construction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "itGsp6jDWs_a"
   },
   "source": [
    "## Train, Validate, Test and Experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(net, partition, optimizer, criterion, args):\n",
    "    trainloader = torch.utils.data.DataLoader(partition['train'], \n",
    "                                              batch_size=args.train_batch_size, \n",
    "                                              shuffle=True, num_workers=2)\n",
    "    net.train()\n",
    "\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    train_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        optimizer.zero_grad() # [21.01.05 오류 수정] 매 Epoch 마다 .zero_grad()가 실행되는 것을 매 iteration 마다 실행되도록 수정했습니다. \n",
    "\n",
    "        # get the inputs\n",
    "        inputs, labels = data\n",
    "        inputs = inputs.view(-1, 3072)\n",
    "        inputs = inputs.cuda()\n",
    "        labels = labels.cuda()\n",
    "        outputs = net(inputs)\n",
    "\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss += loss.item()\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "    train_loss = train_loss / len(trainloader)\n",
    "    train_acc = 100 * correct / total\n",
    "    return net, train_loss, train_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(net, partition, criterion, args):\n",
    "    valloader = torch.utils.data.DataLoader(partition['val'], \n",
    "                                            batch_size=args.test_batch_size, \n",
    "                                            shuffle=False, num_workers=2)\n",
    "    net.eval()\n",
    "\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    val_loss = 0 \n",
    "    with torch.no_grad():\n",
    "        for data in valloader:\n",
    "            images, labels = data\n",
    "            images = images.view(-1, 3072)\n",
    "            images = images.cuda()\n",
    "            labels = labels.cuda()\n",
    "            outputs = net(images)\n",
    "\n",
    "            loss = criterion(outputs, labels)\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "\n",
    "        val_loss = val_loss / len(valloader)\n",
    "        val_acc = 100 * correct / total\n",
    "    return val_loss, val_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(net, partition, args):\n",
    "    testloader = torch.utils.data.DataLoader(partition['test'], \n",
    "                                             batch_size=args.test_batch_size, \n",
    "                                             shuffle=False, num_workers=2)\n",
    "    net.eval()\n",
    "    \n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for data in testloader:\n",
    "            images, labels = data\n",
    "            images = images.view(-1, 3072)\n",
    "            images = images.cuda()\n",
    "            labels = labels.cuda()\n",
    "\n",
    "            outputs = net(images)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "\n",
    "        test_acc = 100 * correct / total\n",
    "    return test_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LiOCP6TqWw2V"
   },
   "outputs": [],
   "source": [
    "def experiment(partition, args):\n",
    "  \n",
    "    net = MLP(args.in_dim, args.out_dim, args.hid_dim, args.n_layer, args.act, args.dropout, args.use_bn, args.use_xavier)\n",
    "    net.cuda()\n",
    "\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    if args.optim == 'SGD':\n",
    "        optimizer = optim.SGD(net.parameters(), lr=args.lr, weight_decay=args.l2)\n",
    "    elif args.optim == 'RMSprop':\n",
    "        optimizer = optim.RMSprop(net.parameters(), lr=args.lr, weight_decay=args.l2)\n",
    "    elif args.optim == 'Adam':\n",
    "        optimizer = optim.Adam(net.parameters(), lr=args.lr, weight_decay=args.l2)\n",
    "    else:\n",
    "        raise ValueError('In-valid optimizer choice')\n",
    "    \n",
    "    train_losses = []\n",
    "    val_losses = []\n",
    "    train_accs = []\n",
    "    val_accs = []\n",
    "        \n",
    "    for epoch in range(args.epoch):  # loop over the dataset multiple times\n",
    "        ts = time.time()\n",
    "        net, train_loss, train_acc = train(net, partition, optimizer, criterion, args)\n",
    "        val_loss, val_acc = validate(net, partition, criterion, args)\n",
    "        te = time.time()\n",
    "        \n",
    "        train_losses.append(train_loss)\n",
    "        val_losses.append(val_loss)\n",
    "        train_accs.append(train_acc)\n",
    "        val_accs.append(val_acc)\n",
    "        \n",
    "        print('Epoch {}, Acc(train/val): {:2.2f}/{:2.2f}, Loss(train/val) {:2.2f}/{:2.2f}. Took {:2.2f} sec'.format(epoch, train_acc, val_acc, train_loss, val_loss, te-ts))\n",
    "        \n",
    "    test_acc = test(net, partition, args)    \n",
    "    \n",
    "    result = {}\n",
    "    result['train_losses'] = train_losses\n",
    "    result['val_losses'] = val_losses\n",
    "    result['train_accs'] = train_accs\n",
    "    result['val_accs'] = val_accs\n",
    "    result['train_acc'] = train_acc\n",
    "    result['val_acc'] = val_acc\n",
    "    result['test_acc'] = test_acc\n",
    "    return vars(args), result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manage Experiment Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hashlib\n",
    "import json\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "import pandas as pd\n",
    "\n",
    "def save_exp_result(setting, result):\n",
    "    exp_name = setting['exp_name']\n",
    "    del setting['epoch']\n",
    "    del setting['test_batch_size']\n",
    "\n",
    "    hash_key = hashlib.sha1(str(setting).encode()).hexdigest()[:6]\n",
    "    filename = './results/{}-{}.json'.format(exp_name, hash_key)\n",
    "    result.update(setting)\n",
    "    with open(filename, 'w') as f:\n",
    "        json.dump(result, f)\n",
    "\n",
    "    \n",
    "def load_exp_result(exp_name):\n",
    "    dir_path = './results'\n",
    "    filenames = [f for f in listdir(dir_path) if isfile(join(dir_path, f)) if '.json' in f]\n",
    "    list_result = []\n",
    "    for filename in filenames:\n",
    "        if exp_name in filename:\n",
    "            with open(join(dir_path, filename), 'r') as infile:\n",
    "                results = json.load(infile)\n",
    "                list_result.append(results)\n",
    "    df = pd.DataFrame(list_result) # .drop(columns=[])\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization Utility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_acc(var1, var2, df):\n",
    "\n",
    "    fig, ax = plt.subplots(1, 3)\n",
    "    fig.set_size_inches(15, 6)\n",
    "    sns.set_style(\"darkgrid\", {\"axes.facecolor\": \".9\"})\n",
    "\n",
    "    sns.barplot(x=var1, y='train_acc', hue=var2, data=df, ax=ax[0])\n",
    "    sns.barplot(x=var1, y='val_acc', hue=var2, data=df, ax=ax[1])\n",
    "    sns.barplot(x=var1, y='test_acc', hue=var2, data=df, ax=ax[2])\n",
    "    \n",
    "    ax[0].set_title('Train Accuracy')\n",
    "    ax[1].set_title('Validation Accuracy')\n",
    "    ax[2].set_title('Test Accuracy')\n",
    "\n",
    "    \n",
    "def plot_loss_variation(var1, var2, df, **kwargs):\n",
    "\n",
    "    list_v1 = df[var1].unique()\n",
    "    list_v2 = df[var2].unique()\n",
    "    list_data = []\n",
    "\n",
    "    for value1 in list_v1:\n",
    "        for value2 in list_v2:\n",
    "            row = df.loc[df[var1]==value1]\n",
    "            row = row.loc[df[var2]==value2]\n",
    "\n",
    "            train_losses = list(row.train_losses)[0]\n",
    "            val_losses = list(row.val_losses)[0]\n",
    "\n",
    "            for epoch, train_loss in enumerate(train_losses):\n",
    "                list_data.append({'type':'train', 'loss':train_loss, 'epoch':epoch, var1:value1, var2:value2})\n",
    "            for epoch, val_loss in enumerate(val_losses):\n",
    "                list_data.append({'type':'val', 'loss':val_loss, 'epoch':epoch, var1:value1, var2:value2})\n",
    "\n",
    "    df = pd.DataFrame(list_data)\n",
    "    g = sns.FacetGrid(df, row=var2, col=var1, hue='type', **kwargs)\n",
    "    g = g.map(plt.plot, 'epoch', 'loss', marker='.')\n",
    "    g.add_legend()\n",
    "    g.fig.suptitle('Train loss vs Val loss')\n",
    "    plt.subplots_adjust(top=0.89) # 만약 Title이 그래프랑 겹친다면 top 값을 조정해주면 됩니다! 함수 인자로 받으면 그래프마다 조절할 수 있겠죠?\n",
    "\n",
    "\n",
    "def plot_acc_variation(var1, var2, df, **kwargs):\n",
    "    list_v1 = df[var1].unique()\n",
    "    list_v2 = df[var2].unique()\n",
    "    list_data = []\n",
    "\n",
    "    for value1 in list_v1:\n",
    "        for value2 in list_v2:\n",
    "            row = df.loc[df[var1]==value1]\n",
    "            row = row.loc[df[var2]==value2]\n",
    "\n",
    "            train_accs = list(row.train_accs)[0]\n",
    "            val_accs = list(row.val_accs)[0]\n",
    "            test_acc = list(row.test_acc)[0]\n",
    "\n",
    "            for epoch, train_acc in enumerate(train_accs):\n",
    "                list_data.append({'type':'train', 'Acc':train_acc, 'test_acc':test_acc, 'epoch':epoch, var1:value1, var2:value2})\n",
    "            for epoch, val_acc in enumerate(val_accs):\n",
    "                list_data.append({'type':'val', 'Acc':val_acc, 'test_acc':test_acc, 'epoch':epoch, var1:value1, var2:value2})\n",
    "\n",
    "    df = pd.DataFrame(list_data)\n",
    "    g = sns.FacetGrid(df, row=var2, col=var1, hue='type', **kwargs)\n",
    "    g = g.map(plt.plot, 'epoch', 'Acc', marker='.')\n",
    "\n",
    "    def show_acc(x, y, metric, **kwargs):\n",
    "        plt.scatter(x, y, alpha=0.3, s=1)\n",
    "        metric = \"Test Acc: {:1.3f}\".format(list(metric.values)[0])\n",
    "        plt.text(0.05, 0.95, metric,  horizontalalignment='left', verticalalignment='center', transform=plt.gca().transAxes, bbox=dict(facecolor='yellow', alpha=0.5, boxstyle=\"round,pad=0.1\"))\n",
    "    g = g.map(show_acc, 'epoch', 'Acc', 'test_acc')\n",
    "\n",
    "    g.add_legend()\n",
    "    g.fig.suptitle('Train Accuracy vs Val Accuracy')\n",
    "    plt.subplots_adjust(top=0.89)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "omgExzmQgU1J"
   },
   "source": [
    "## Experiment1. N_layer vs Hidden_Dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DRoOy_B3Wu7B"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(act='relu', dropout=0.2, epoch=10, exp_name='exp1_n_layer_hid_dim', hid_dim=500, in_dim=3072, l2=1e-05, lr=0.0015, n_layer=1, optim='RMSprop', out_dim=10, test_batch_size=1024, train_batch_size=256, use_bn=True, use_xavier=True)\n",
      "Epoch 0, Acc(train/val): 23.60/26.74, Loss(train/val) 24.30/26.30. Took 5.38 sec\n",
      "Epoch 1, Acc(train/val): 26.16/22.29, Loss(train/val) 22.30/23.91. Took 5.36 sec\n",
      "Epoch 2, Acc(train/val): 26.73/25.71, Loss(train/val) 20.36/27.69. Took 5.40 sec\n",
      "Epoch 3, Acc(train/val): 26.83/24.98, Loss(train/val) 18.18/24.52. Took 5.37 sec\n",
      "Epoch 4, Acc(train/val): 27.38/26.99, Loss(train/val) 18.30/23.37. Took 5.40 sec\n",
      "Epoch 5, Acc(train/val): 27.64/24.01, Loss(train/val) 17.80/23.34. Took 5.41 sec\n",
      "Epoch 6, Acc(train/val): 27.41/25.66, Loss(train/val) 16.84/23.76. Took 5.39 sec\n",
      "Epoch 7, Acc(train/val): 27.49/27.32, Loss(train/val) 18.77/21.32. Took 5.37 sec\n",
      "Epoch 8, Acc(train/val): 28.03/27.28, Loss(train/val) 16.80/19.36. Took 5.37 sec\n",
      "Epoch 9, Acc(train/val): 28.47/25.42, Loss(train/val) 16.84/21.42. Took 5.34 sec\n",
      "Namespace(act='relu', dropout=0.2, epoch=10, exp_name='exp1_n_layer_hid_dim', hid_dim=300, in_dim=3072, l2=1e-05, lr=0.0015, n_layer=1, optim='RMSprop', out_dim=10, test_batch_size=1024, train_batch_size=256, use_bn=True, use_xavier=True)\n",
      "Epoch 0, Acc(train/val): 23.54/23.68, Loss(train/val) 15.42/15.85. Took 5.36 sec\n",
      "Epoch 1, Acc(train/val): 25.88/25.29, Loss(train/val) 12.26/16.06. Took 5.35 sec\n",
      "Epoch 2, Acc(train/val): 25.98/26.44, Loss(train/val) 12.50/13.04. Took 5.40 sec\n",
      "Epoch 3, Acc(train/val): 26.91/20.98, Loss(train/val) 9.35/12.61. Took 5.41 sec\n",
      "Epoch 4, Acc(train/val): 26.82/25.43, Loss(train/val) 10.72/12.84. Took 5.40 sec\n",
      "Epoch 5, Acc(train/val): 27.79/26.77, Loss(train/val) 10.35/13.12. Took 5.40 sec\n",
      "Epoch 6, Acc(train/val): 28.09/25.62, Loss(train/val) 10.21/13.00. Took 5.39 sec\n",
      "Epoch 7, Acc(train/val): 27.68/28.53, Loss(train/val) 11.51/14.20. Took 5.42 sec\n",
      "Epoch 8, Acc(train/val): 28.60/25.80, Loss(train/val) 10.45/13.99. Took 5.37 sec\n",
      "Epoch 9, Acc(train/val): 28.35/26.82, Loss(train/val) 10.56/13.51. Took 5.41 sec\n",
      "Namespace(act='relu', dropout=0.2, epoch=10, exp_name='exp1_n_layer_hid_dim', hid_dim=500, in_dim=3072, l2=1e-05, lr=0.0015, n_layer=2, optim='RMSprop', out_dim=10, test_batch_size=1024, train_batch_size=256, use_bn=True, use_xavier=True)\n",
      "Epoch 0, Acc(train/val): 28.64/33.93, Loss(train/val) 2.00/1.85. Took 5.39 sec\n",
      "Epoch 1, Acc(train/val): 33.76/35.38, Loss(train/val) 1.83/1.84. Took 5.38 sec\n",
      "Epoch 2, Acc(train/val): 36.45/36.57, Loss(train/val) 1.76/1.73. Took 5.36 sec\n",
      "Epoch 3, Acc(train/val): 39.07/41.15, Loss(train/val) 1.69/1.66. Took 5.39 sec\n",
      "Epoch 4, Acc(train/val): 41.76/43.10, Loss(train/val) 1.63/1.89. Took 5.33 sec\n",
      "Epoch 5, Acc(train/val): 43.92/43.06, Loss(train/val) 1.56/1.59. Took 5.33 sec\n",
      "Epoch 6, Acc(train/val): 47.02/46.08, Loss(train/val) 1.49/1.56. Took 5.37 sec\n",
      "Epoch 7, Acc(train/val): 48.14/44.96, Loss(train/val) 1.46/1.55. Took 5.40 sec\n",
      "Epoch 8, Acc(train/val): 50.10/48.77, Loss(train/val) 1.40/1.54. Took 5.39 sec\n",
      "Epoch 9, Acc(train/val): 52.50/48.49, Loss(train/val) 1.33/1.51. Took 5.39 sec\n",
      "Namespace(act='relu', dropout=0.2, epoch=10, exp_name='exp1_n_layer_hid_dim', hid_dim=300, in_dim=3072, l2=1e-05, lr=0.0015, n_layer=2, optim='RMSprop', out_dim=10, test_batch_size=1024, train_batch_size=256, use_bn=True, use_xavier=True)\n",
      "Epoch 0, Acc(train/val): 30.20/33.59, Loss(train/val) 1.94/2.09. Took 5.31 sec\n",
      "Epoch 1, Acc(train/val): 34.35/36.37, Loss(train/val) 1.81/2.37. Took 5.31 sec\n",
      "Epoch 2, Acc(train/val): 37.24/39.00, Loss(train/val) 1.73/2.11. Took 5.35 sec\n",
      "Epoch 3, Acc(train/val): 39.29/40.82, Loss(train/val) 1.69/2.10. Took 5.37 sec\n",
      "Epoch 4, Acc(train/val): 41.82/42.66, Loss(train/val) 1.62/1.91. Took 5.38 sec\n",
      "Epoch 5, Acc(train/val): 44.24/44.53, Loss(train/val) 1.56/1.56. Took 5.36 sec\n",
      "Epoch 6, Acc(train/val): 46.84/46.00, Loss(train/val) 1.49/1.53. Took 5.37 sec\n",
      "Epoch 7, Acc(train/val): 48.71/46.91, Loss(train/val) 1.44/1.51. Took 5.36 sec\n",
      "Epoch 8, Acc(train/val): 51.15/47.65, Loss(train/val) 1.38/1.50. Took 5.37 sec\n",
      "Epoch 9, Acc(train/val): 52.21/47.99, Loss(train/val) 1.34/1.48. Took 5.41 sec\n",
      "Namespace(act='relu', dropout=0.2, epoch=10, exp_name='exp1_n_layer_hid_dim', hid_dim=500, in_dim=3072, l2=1e-05, lr=0.0015, n_layer=3, optim='RMSprop', out_dim=10, test_batch_size=1024, train_batch_size=256, use_bn=True, use_xavier=True)\n",
      "Epoch 0, Acc(train/val): 28.73/34.64, Loss(train/val) 2.02/1.83. Took 5.36 sec\n",
      "Epoch 1, Acc(train/val): 34.16/34.73, Loss(train/val) 1.82/1.82. Took 5.40 sec\n",
      "Epoch 2, Acc(train/val): 36.87/38.03, Loss(train/val) 1.74/1.72. Took 5.37 sec\n",
      "Epoch 3, Acc(train/val): 39.21/40.48, Loss(train/val) 1.68/1.65. Took 5.42 sec\n",
      "Epoch 4, Acc(train/val): 42.12/42.41, Loss(train/val) 1.61/1.62. Took 5.36 sec\n",
      "Epoch 5, Acc(train/val): 43.45/43.42, Loss(train/val) 1.57/1.60. Took 5.33 sec\n",
      "Epoch 6, Acc(train/val): 45.25/45.39, Loss(train/val) 1.53/1.55. Took 5.38 sec\n",
      "Epoch 7, Acc(train/val): 47.41/45.61, Loss(train/val) 1.47/1.53. Took 5.33 sec\n",
      "Epoch 8, Acc(train/val): 49.05/46.50, Loss(train/val) 1.42/29.11. Took 5.37 sec\n",
      "Epoch 9, Acc(train/val): 50.23/48.86, Loss(train/val) 1.39/3.16. Took 5.35 sec\n",
      "Namespace(act='relu', dropout=0.2, epoch=10, exp_name='exp1_n_layer_hid_dim', hid_dim=300, in_dim=3072, l2=1e-05, lr=0.0015, n_layer=3, optim='RMSprop', out_dim=10, test_batch_size=1024, train_batch_size=256, use_bn=True, use_xavier=True)\n",
      "Epoch 0, Acc(train/val): 29.09/35.00, Loss(train/val) 1.96/1.82. Took 5.38 sec\n",
      "Epoch 1, Acc(train/val): 34.44/36.10, Loss(train/val) 1.81/1.80. Took 5.41 sec\n",
      "Epoch 2, Acc(train/val): 36.98/37.83, Loss(train/val) 1.73/1.83. Took 5.36 sec\n",
      "Epoch 3, Acc(train/val): 39.77/41.00, Loss(train/val) 1.66/1.64. Took 5.40 sec\n",
      "Epoch 4, Acc(train/val): 42.20/43.47, Loss(train/val) 1.60/1.58. Took 5.38 sec\n",
      "Epoch 5, Acc(train/val): 44.78/42.89, Loss(train/val) 1.55/1.58. Took 5.37 sec\n",
      "Epoch 6, Acc(train/val): 46.63/45.86, Loss(train/val) 1.49/1.50. Took 5.33 sec\n",
      "Epoch 7, Acc(train/val): 49.28/47.22, Loss(train/val) 1.42/1.47. Took 5.39 sec\n",
      "Epoch 8, Acc(train/val): 51.13/48.27, Loss(train/val) 1.36/1.45. Took 5.37 sec\n",
      "Epoch 9, Acc(train/val): 53.66/49.27, Loss(train/val) 1.30/1.44. Took 5.38 sec\n"
     ]
    }
   ],
   "source": [
    "# ====== Random Seed Initialization ====== #\n",
    "seed = 123\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "\n",
    "parser = argparse.ArgumentParser()\n",
    "args = parser.parse_args(\"\")\n",
    "args.exp_name = \"exp1_n_layer_hid_dim\"\n",
    "\n",
    "# ====== Model Capacity ====== #\n",
    "args.in_dim = 3072\n",
    "args.out_dim = 10\n",
    "args.hid_dim = 100\n",
    "args.act = 'relu'\n",
    "\n",
    "# ====== Regularization ======= #\n",
    "args.dropout = 0.2\n",
    "args.use_bn = True\n",
    "args.l2 = 0.00001\n",
    "args.use_xavier = True\n",
    "\n",
    "# ====== Optimizer & Training ====== #\n",
    "args.optim = 'RMSprop' #'RMSprop' #SGD, RMSprop, ADAM...\n",
    "args.lr = 0.0015\n",
    "args.epoch = 10\n",
    "\n",
    "args.train_batch_size = 256\n",
    "args.test_batch_size = 1024\n",
    "\n",
    "# ====== Experiment Variable ====== #\n",
    "name_var1 = 'n_layer'\n",
    "name_var2 = 'hid_dim'\n",
    "list_var1 = [1, 2, 3]\n",
    "list_var2 = [500, 300]\n",
    "\n",
    "\n",
    "for var1 in list_var1:\n",
    "    for var2 in list_var2:\n",
    "        setattr(args, name_var1, var1)\n",
    "        setattr(args, name_var2, var2)\n",
    "        print(args)\n",
    "                \n",
    "        setting, result = experiment(partition, deepcopy(args))\n",
    "        save_exp_result(setting, result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 707.375x432 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 707.375x432 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var1 = 'n_layer'\n",
    "var2 = 'hid_dim'\n",
    "df = load_exp_result('exp1')\n",
    "\n",
    "plot_acc(var1, var2, df)\n",
    "plot_loss_variation(var1, var2, df, sharey=False) #sharey를 True로 하면 모둔 subplot의 y축의 스케일이 같아집니다.\n",
    "plot_acc_variation(var1, var2, df, margin_titles=True, sharey=True) #margin_titles를 True로 하면 그래프의 가장자리에 var1과 var2 값이 표시되고 False로 하면 각 subplot 위에 표시됩니다."
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Untitled4.ipynb의 사본",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python (comet2)",
   "language": "python",
   "name": "comet2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}