thesis_omniglot20w5s.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.init as init\n",
    "import torch.nn.functional as F\n",
    "import torch.utils as utils\n",
    "import torch.utils.data\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.transforms.functional as TF\n",
    "import torchvision.datasets as dsets\n",
    "from torchvision import models\n",
    "from torchvision.utils import save_image\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "writer = SummaryWriter('runs/thesis06_20w_1s')\n",
    "\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from flows import PlanarFlow\n",
    "from utils import Binarize\n",
    "from codes import Linear_flipout, Flatten, count_parameters, EfficientNet\n",
    "\n",
    "from torchmeta.datasets import Omniglot, CIFARFS\n",
    "from torchmeta.transforms import Categorical, ClassSplitter, Rotation\n",
    "from torchvision.transforms import Compose, Resize, ToTensor\n",
    "from torchmeta.utils.data import BatchMetaDataLoader\n",
    "\n",
    "\n",
    "#from __future__ import print_function\n",
    "import argparse\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import os\n",
    "cur_dir = \"C:/Users/KJH/OneDrive - skku.edu/KJH/Projects/2019winter_research\"\n",
    "#cur_dir = \"C:/Users/KJH-Laptop/OneDrive - skku.edu/KJH/Projects/2019winter_research/\"\n",
    "os.chdir(cur_dir)\n",
    "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n",
    "os.environ[\"CUDA_LAUNCH_BLOCKING\"] = \"1\"\n",
    "\n",
    "import time\n",
    "import copy\n",
    "import random as rd\n",
    "\n",
    "device = torch.device('cuda')\n",
    "\n",
    "class net(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super(net, self).__init__()\n",
    "        self.input_dim = [1, 28, 28]\n",
    "        self.num_classes = num_classes\n",
    "        \n",
    "        self.ctx = torch.hub.load('rwightman/gen-efficientnet-pytorch', 'efficientnet_b0', pretrained=True)\n",
    "        self.ctx.conv_stem = nn.Conv2d(1, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
    "        self.ctx.classifier = nn.Sequential(\n",
    "            nn.BatchNorm1d(1280),\n",
    "            nn.Linear(1280, 320, bias = True),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        self.layer = nn.LSTM(input_size=1280, hidden_size=1280, num_layers=5, bias=True, batch_first = True).to(device)\n",
    "        self.dec_mu = nn.ModuleList()\n",
    "        self.dec_logvar = nn.ModuleList()\n",
    "        \n",
    "        self.num_params = [[200 * 200, 200], [200 * 200, 200], [200 * self.num_classes, self.num_classes]]\n",
    "        \n",
    "        for layer_size in self.num_params:\n",
    "            self.dec_mu.append(\n",
    "                nn.Sequential(\n",
    "                    nn.ELU(),\n",
    "                    nn.Linear(1280, 1280, bias = True),\n",
    "                    nn.ELU(),\n",
    "                    nn.Linear(1280, layer_size[0] + layer_size[1], bias = True),\n",
    "                ).to(device))\n",
    "            \n",
    "            self.dec_logvar.append(\n",
    "                nn.Sequential(\n",
    "                    nn.ELU(),\n",
    "                    nn.Linear(1280, 1280, bias = True),\n",
    "                    nn.ELU(),\n",
    "                    nn.Linear(1280, layer_size[0] + layer_size[1], bias = True),\n",
    "                ).to(device))\n",
    "        \n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.BatchNorm2d(1),\n",
    "            Flatten(),            \n",
    "            nn.Linear(784, 200, bias = False),\n",
    "            nn.ELU()\n",
    "        )\n",
    "\n",
    "            \n",
    "            \n",
    "    def forward(self, input_train, label_train, input_test, label_test, adapt_lr, adapt_step = 1):\n",
    "        ctx = self.ctx(input_train).view(input_train.shape[0], 5, -1)\n",
    "        h = torch.stack([ctx[torch.where(label_train == x)].mean(dim = 0) for x in range(self.num_classes)], dim = 1)\n",
    "        h = h.view(5, 1, -1)\n",
    "        \n",
    "        params = nn.ParameterList()\n",
    "        param_vals = []\n",
    "        kld = torch.tensor(0., device=device)\n",
    "        c = torch.empty([5, 1, 1280], requires_grad = False, device = device).fill_(0)\n",
    "        x_test_init = self.encoder(input_test)\n",
    "        x_test = x_test_init\n",
    "\n",
    "        for ind, (dec_mu, dec_logvar) in enumerate(zip(self.dec_mu, self.dec_logvar)):\n",
    "            x = torch.empty([1, 1, 1280], requires_grad=False, device = device).normal_(0, 1)\n",
    "            f, (h, c) = self.layer(x, (h, c))\n",
    "            \n",
    "            mu = dec_mu(f.view(1, -1)).squeeze()\n",
    "            logvar = dec_logvar(f.view(1, -1)).squeeze()\n",
    "            params.append(nn.Parameter(torch.stack((mu, logvar), dim = 0), requires_grad = True))\n",
    "        \n",
    "        optimizer = optim.SGD(params, lr = adapt_lr)\n",
    "        \n",
    "        for step in range(adapt_step + 1):\n",
    "            x_test = x_test_init\n",
    "            kld = torch.tensor(0., device=device)\n",
    "            for ind, param in enumerate(params):\n",
    "                param.retain_grad()\n",
    "\n",
    "                weight_mu = param[0, :self.num_params[ind][0]].view(-1, self.num_params[ind][1])\n",
    "                bias_mu = param[0, self.num_params[ind][0]:]\n",
    "\n",
    "                weight_logvar = param[1, :self.num_params[ind][0]].view(-1, self.num_params[ind][1])\n",
    "                bias_logvar = param[1, self.num_params[ind][0]:]\n",
    "\n",
    "                weight_noise = torch.empty(weight_mu.shape, requires_grad = False, device = device).normal_(0,1)\n",
    "                bias_noise = torch.empty(bias_mu.shape, requires_grad = False, device = device).normal_(0,1)\n",
    "                in_sign = torch.empty(x_test.shape, requires_grad = False, device = device).uniform_(-1,1).sign()\n",
    "                out_sign = torch.empty([x_test.shape[0], self.num_params[ind][1]], requires_grad = False, device = device).uniform_(-1,1).sign()\n",
    "\n",
    "                x_test = torch.mm(x_test, weight_mu) + torch.mm(in_sign * x_test, weight_noise * weight_mu * weight_logvar.div(2).exp()) * out_sign\n",
    "                x_test += (1 + bias_noise * bias_logvar.div(2).exp()) * bias_mu\n",
    "                x_test = F.elu(x_test)\n",
    "\n",
    "                kld += (mu.pow(2) - logvar + logvar.exp() - 1).mean()/2\n",
    "                \n",
    "            if step < adapt_step:\n",
    "                optimizer.zero_grad()\n",
    "                loss = F.cross_entropy(x_test, label_test) + 1e-6 * kld\n",
    "                loss.backward(retain_graph = True)\n",
    "                optimizer.step()\n",
    "\n",
    "        return x_test, kld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using cache found in C:\\Users\\KJH/.cache\\torch\\hub\\rwightman_gen-efficientnet-pytorch_master\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0) loss = 2.603963, kld = 0.000764, acc = 0.237708, time = 17.765 sec\n",
      " 10) loss = 2.070702, kld = 0.000124, acc = 0.426667, time = 30.516 sec\n",
      " 20) loss = 2.021549, kld = 0.000041, acc = 0.460417, time = 30.990 sec\n",
      " 30) loss = 1.873713, kld = 0.000021, acc = 0.499583, time = 30.326 sec\n",
      " 40) loss = 1.851576, kld = 0.000015, acc = 0.499167, time = 31.190 sec\n",
      " 50) loss = 1.920723, kld = 0.000012, acc = 0.500208, time = 30.166 sec\n",
      " 60) loss = 1.933874, kld = 0.000011, acc = 0.482083, time = 30.712 sec\n",
      " 70) loss = 1.856399, kld = 0.000011, acc = 0.501458, time = 30.725 sec\n",
      " 80) loss = 2.082198, kld = 0.000011, acc = 0.444167, time = 30.432 sec\n",
      " 90) loss = 1.875944, kld = 0.000011, acc = 0.501875, time = 31.062 sec\n",
      "100) loss = 1.768155, kld = 0.000010, acc = 0.526458, time = 30.601 sec\n",
      "110) loss = 1.845184, kld = 0.000010, acc = 0.513542, time = 30.124 sec\n",
      "120) loss = 1.921565, kld = 0.000010, acc = 0.503333, time = 30.439 sec\n",
      "130) loss = 1.740383, kld = 0.000011, acc = 0.531875, time = 31.052 sec\n",
      "140) loss = 1.867197, kld = 0.000010, acc = 0.510000, time = 31.122 sec\n",
      "150) loss = 2.004575, kld = 0.000010, acc = 0.489375, time = 30.131 sec\n",
      "160) loss = 1.755130, kld = 0.000010, acc = 0.514167, time = 30.042 sec\n",
      "170) loss = 1.779709, kld = 0.000010, acc = 0.537708, time = 30.124 sec\n",
      "180) loss = 1.610682, kld = 0.000010, acc = 0.575000, time = 29.982 sec\n",
      "190) loss = 1.803173, kld = 0.000010, acc = 0.524583, time = 30.124 sec\n"
     ]
    }
   ],
   "source": [
    "batch_size = 16\n",
    "meta_trainset = Omniglot('./data/',\n",
    "                   # Number of ways\n",
    "                   num_classes_per_task=20,\n",
    "                   # Resize the images to 28x28 and converts them to PyTorch tensors (from Torchvision)\n",
    "                   transform=Compose([Resize(28), ToTensor()]),\n",
    "                   # Transform the labels to integers (e.g. (\"Glagolitic/character01\", \"Sanskrit/character14\", ...) to (0, 1, ...))\n",
    "                   target_transform=Categorical(num_classes=20),\n",
    "                   # Creates new virtual classes with rotated versions of the images (from Santoro et al., 2016)\n",
    "                   class_augmentations=[Rotation([90, 180, 270])],\n",
    "                   meta_train=True,\n",
    "                   download=True)\n",
    "meta_trainset = ClassSplitter(meta_trainset, shuffle=True, num_train_per_class=5, num_test_per_class=15)\n",
    "meta_trainloader = BatchMetaDataLoader(meta_trainset, batch_size=batch_size, num_workers=0)\n",
    "\n",
    "model = net(20).cuda()\n",
    "optimizer = optim.Adam(model.parameters(), lr=1e-2)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "num_batches = 200\n",
    "for batch_idx, meta_train_batch in zip(range(num_batches), meta_trainloader):\n",
    "    start = time.time()\n",
    "\n",
    "    train_inputs, train_targets = [x.to(device) for x in meta_train_batch[\"train\"]]\n",
    "    test_inputs, test_targets = [x.to(device) for x in meta_train_batch[\"test\"]]\n",
    "    \n",
    "    cum_loss = torch.tensor(0., device=device)\n",
    "    accuracy = torch.tensor(0., device=device)\n",
    "    reg = torch.tensor(0., device=device)\n",
    "\n",
    "    for task_idx, (train_input, train_target, test_input, test_target) in enumerate(\n",
    "        zip(train_inputs, train_targets, test_inputs, test_targets)):\n",
    "        optimizer.zero_grad()\n",
    "        pred, kld = model(train_input, train_target, test_input, test_target, 0.5, 5)\n",
    "        loss = criterion(pred, test_target)\n",
    "        (loss + 1e-6 * kld).backward()\n",
    "        optimizer.step()\n",
    "        with torch.no_grad():\n",
    "            cum_loss += loss\n",
    "            accuracy += torch.sum(pred.argmax(1) == test_target.cuda())\n",
    "            reg += kld\n",
    "    cum_loss /= batch_size\n",
    "    accuracy /= batch_size * 20 * 15\n",
    "    reg /= batch_size\n",
    "\n",
    "    if batch_idx % 10 == 0:\n",
    "        print(\"%3d) loss = %f, kld = %f, acc = %f, time = %.3f sec\" %(batch_idx, cum_loss, reg, accuracy, time.time() - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0) loss = 2.531750, kld = 0.000010, acc = 0.418125, time = 29.869 sec\n",
      " 10) loss = 2.003087, kld = 0.000010, acc = 0.461875, time = 30.248 sec\n",
      " 20) loss = 1.943420, kld = 0.000010, acc = 0.492083, time = 30.127 sec\n",
      " 30) loss = 1.942439, kld = 0.000010, acc = 0.503750, time = 30.166 sec\n",
      " 40) loss = 1.869648, kld = 0.000010, acc = 0.517083, time = 30.000 sec\n",
      " 50) loss = 1.982632, kld = 0.000010, acc = 0.490833, time = 30.098 sec\n",
      " 60) loss = 1.494840, kld = 0.000010, acc = 0.585417, time = 30.877 sec\n",
      " 70) loss = 1.660182, kld = 0.000010, acc = 0.551667, time = 31.406 sec\n",
      " 80) loss = 1.659267, kld = 0.000010, acc = 0.568750, time = 30.541 sec\n",
      " 90) loss = 1.527660, kld = 0.000010, acc = 0.585417, time = 31.039 sec\n",
      "100) loss = 1.698551, kld = 0.000010, acc = 0.542917, time = 31.140 sec\n",
      "110) loss = 1.744369, kld = 0.000010, acc = 0.541458, time = 31.131 sec\n",
      "120) loss = 2.010949, kld = 0.000010, acc = 0.481458, time = 30.920 sec\n",
      "130) loss = 1.537902, kld = 0.000010, acc = 0.582292, time = 31.205 sec\n",
      "140) loss = 1.745841, kld = 0.000010, acc = 0.548542, time = 31.026 sec\n",
      "150) loss = 1.726605, kld = 0.000010, acc = 0.540833, time = 30.433 sec\n",
      "160) loss = 1.524956, kld = 0.000010, acc = 0.576458, time = 31.398 sec\n",
      "170) loss = 1.610029, kld = 0.000010, acc = 0.560208, time = 31.050 sec\n",
      "180) loss = 1.643855, kld = 0.000010, acc = 0.565417, time = 31.217 sec\n",
      "190) loss = 1.718126, kld = 0.000010, acc = 0.538542, time = 30.368 sec\n"
     ]
    }
   ],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=1e-4)\n",
    "\n",
    "num_batches = 200\n",
    "for batch_idx, meta_train_batch in zip(range(num_batches), meta_trainloader):\n",
    "    start = time.time()\n",
    "\n",
    "    train_inputs, train_targets = [x.to(device) for x in meta_train_batch[\"train\"]]\n",
    "    test_inputs, test_targets = [x.to(device) for x in meta_train_batch[\"test\"]]\n",
    "    \n",
    "    cum_loss = torch.tensor(0., device=device)\n",
    "    accuracy = torch.tensor(0., device=device)\n",
    "    reg = torch.tensor(0., device=device)\n",
    "\n",
    "    for task_idx, (train_input, train_target, test_input, test_target) in enumerate(\n",
    "        zip(train_inputs, train_targets, test_inputs, test_targets)):\n",
    "        optimizer.zero_grad()\n",
    "        pred, kld = model(train_input, train_target, test_input, test_target, 0.5, 5)\n",
    "        loss = criterion(pred, test_target)\n",
    "        (loss + 1e-6 * kld).backward()\n",
    "        optimizer.step()\n",
    "        with torch.no_grad():\n",
    "            cum_loss += loss\n",
    "            accuracy += torch.sum(pred.argmax(1) == test_target.cuda())\n",
    "            reg += kld\n",
    "    cum_loss /= batch_size\n",
    "    accuracy /= batch_size * 20 * 15\n",
    "    reg /= batch_size\n",
    "\n",
    "    if batch_idx % 10 == 0:\n",
    "        print(\"%3d) loss = %f, kld = %f, acc = %f, time = %.3f sec\" %(batch_idx, cum_loss, reg, accuracy, time.time() - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0) loss = 1.651697, kld = 0.000010, acc = 0.552083, time = 30.315 sec\n",
      " 10) loss = 1.846209, kld = 0.000010, acc = 0.525417, time = 31.014 sec\n",
      " 20) loss = 1.680036, kld = 0.000010, acc = 0.565625, time = 31.535 sec\n",
      " 30) loss = 1.593975, kld = 0.000010, acc = 0.561667, time = 31.352 sec\n",
      " 40) loss = 1.688189, kld = 0.000010, acc = 0.541875, time = 30.849 sec\n",
      " 50) loss = 1.697957, kld = 0.000010, acc = 0.551458, time = 30.337 sec\n",
      " 60) loss = 1.623374, kld = 0.000010, acc = 0.561667, time = 30.434 sec\n",
      " 70) loss = 1.761743, kld = 0.000010, acc = 0.541875, time = 30.296 sec\n",
      " 80) loss = 1.679443, kld = 0.000010, acc = 0.565000, time = 30.201 sec\n",
      " 90) loss = 1.729807, kld = 0.000010, acc = 0.535625, time = 30.275 sec\n",
      "100) loss = 1.851496, kld = 0.000010, acc = 0.495625, time = 30.841 sec\n",
      "110) loss = 1.534651, kld = 0.000010, acc = 0.571042, time = 30.097 sec\n",
      "120) loss = 1.737582, kld = 0.000010, acc = 0.535833, time = 29.730 sec\n",
      "130) loss = 1.667550, kld = 0.000010, acc = 0.544375, time = 30.140 sec\n",
      "140) loss = 1.800410, kld = 0.000010, acc = 0.534792, time = 30.761 sec\n",
      "150) loss = 1.648618, kld = 0.000010, acc = 0.563333, time = 30.585 sec\n",
      "160) loss = 1.729128, kld = 0.000010, acc = 0.532917, time = 30.504 sec\n",
      "170) loss = 1.986174, kld = 0.000010, acc = 0.511667, time = 30.743 sec\n",
      "180) loss = 1.772293, kld = 0.000010, acc = 0.533542, time = 30.736 sec\n",
      "190) loss = 1.767555, kld = 0.000010, acc = 0.546458, time = 30.822 sec\n"
     ]
    }
   ],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=1e-6)\n",
    "\n",
    "num_batches = 200\n",
    "for batch_idx, meta_train_batch in zip(range(num_batches), meta_trainloader):\n",
    "    start = time.time()\n",
    "\n",
    "    train_inputs, train_targets = [x.to(device) for x in meta_train_batch[\"train\"]]\n",
    "    test_inputs, test_targets = [x.to(device) for x in meta_train_batch[\"test\"]]\n",
    "    \n",
    "    cum_loss = torch.tensor(0., device=device)\n",
    "    accuracy = torch.tensor(0., device=device)\n",
    "    reg = torch.tensor(0., device=device)\n",
    "\n",
    "    for task_idx, (train_input, train_target, test_input, test_target) in enumerate(\n",
    "        zip(train_inputs, train_targets, test_inputs, test_targets)):\n",
    "        optimizer.zero_grad()\n",
    "        pred, kld = model(train_input, train_target, test_input, test_target, 0.5, 5)\n",
    "        loss = criterion(pred, test_target)\n",
    "        (loss + 1e-6 * kld).backward()\n",
    "        optimizer.step()\n",
    "        with torch.no_grad():\n",
    "            cum_loss += loss\n",
    "            accuracy += torch.sum(pred.argmax(1) == test_target.cuda())\n",
    "            reg += kld\n",
    "    cum_loss /= batch_size\n",
    "    accuracy /= batch_size * 20 * 15\n",
    "    reg /= batch_size\n",
    "\n",
    "    if batch_idx % 10 == 0:\n",
    "        print(\"%3d) loss = %f, kld = %f, acc = %f, time = %.3f sec\" %(batch_idx, cum_loss, reg, accuracy, time.time() - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = 1.743715, test_kld = 0.000010, meta_test_acc = 0.543837, time = 24.121 sec\n"
     ]
    }
   ],
   "source": [
    "meta_testset  = Omniglot('./data/',\n",
    "                   # Number of ways\n",
    "                   num_classes_per_task=20,\n",
    "                   # Resize the images to 28x28 and converts them to PyTorch tensors (from Torchvision)\n",
    "                   transform=Compose([Resize(28), ToTensor()]),\n",
    "                   # Transform the labels to integers (e.g. (\"Glagolitic/character01\", \"Sanskrit/character14\", ...) to (0, 1, ...))\n",
    "                   target_transform=Categorical(num_classes=20),\n",
    "                   # Creates new virtual classes with rotated versions of the images (from Santoro et al., 2016)\n",
    "                   class_augmentations=[Rotation([90, 180, 270])],\n",
    "                   meta_test=True,\n",
    "                   download=True)\n",
    "meta_testset = ClassSplitter(meta_testset, shuffle=True, num_train_per_class=5, num_test_per_class=15)\n",
    "meta_testloader = BatchMetaDataLoader(meta_testset, batch_size=batch_size, num_workers=0)\n",
    "\n",
    "tot_loss = torch.tensor(0., device=device)\n",
    "tot_acc = torch.tensor(0., device=device)\n",
    "tot_reg = torch.tensor(0., device=device)\n",
    "\n",
    "for batch_idx, meta_test_batch in zip(range(num_batches), meta_testloader):\n",
    "    start = time.time()\n",
    "    train_inputs, train_targets = [x.to(device) for x in meta_test_batch[\"train\"]]\n",
    "    test_inputs, test_targets = [x.to(device) for x in meta_test_batch[\"test\"]]\n",
    "    \n",
    "    cum_loss = torch.tensor(0., device=device)\n",
    "    accuracy = torch.tensor(0., device=device)\n",
    "    reg = torch.tensor(0., device=device)\n",
    "\n",
    "    for task_idx, (train_input, train_target, test_input, test_target) in enumerate(\n",
    "        zip(train_inputs, train_targets, test_inputs, test_targets)):\n",
    "        optimizer.zero_grad()\n",
    "        pred, kld = model(train_input, train_target, test_input, test_target, 0.5, 5)\n",
    "        with torch.no_grad():            \n",
    "            loss = criterion(pred, test_target)\n",
    "            cum_loss += loss\n",
    "            accuracy += torch.sum(pred.argmax(1) == test_target.cuda())\n",
    "            reg += kld\n",
    "\n",
    "    tot_loss += cum_loss / batch_size\n",
    "    tot_acc += accuracy  / (batch_size * 20 * 15)\n",
    "    tot_reg += reg / batch_size\n",
    "        \n",
    "tot_loss /= num_batches\n",
    "tot_acc /= num_batches\n",
    "tot_reg /= num_batches\n",
    "        \n",
    "print(\"loss = %f, test_kld = %f, meta_test_acc = %f, time = %.3f sec\" %(tot_loss, tot_reg, tot_acc, time.time() - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), \"./save/thesis06_omniglot20w5s_5step\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}