mnist_generator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader, RandomSampler\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"]=\"TRUE\"\n",
    "\n",
    "from mnist_classifier.model import Mnist_classifer\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch = 64\n",
    "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n",
    "\n",
    "mnist = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "\n",
    "\n",
    "mnist_indice = torch.randperm(len(mnist))\n",
    "mnist_train_sampler = RandomSampler(mnist_indice[:int(len(mnist) * 0.95)])\n",
    "mnist_valid_sampler = RandomSampler(mnist_indice[int(len(mnist) * 0.95):])\n",
    "\n",
    "\n",
    "mnist_train_dataloader = DataLoader(mnist, sampler=mnist_train_sampler, batch_size=batch)\n",
    "mnist_val_dataloader = DataLoader(mnist, sampler=mnist_valid_sampler, batch_size=batch)\n",
    "\n",
    "# for x, y in mnist_train_dataloader:\n",
    "#     print(x[1])\n",
    "#     print(y[1])\n",
    "#     break\n",
    "# for x, y in mnist_val_dataloader:\n",
    "#     print(x[1])\n",
    "#     print(y[1])\n",
    "#     break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Generator, self).__init__()\n",
    "\n",
    "    \n",
    "\n",
    "        self.output = nn.Sequential(nn.Linear(100, 256),#雜訊是長度512的tensor\n",
    "                                    nn.LeakyReLU(0.2),\n",
    "                                    nn.Linear(256, 512),\n",
    "                                    nn.LeakyReLU(0.2),\n",
    "                                    nn.Linear(512, 784),\n",
    "                                    nn.Tanh())#輸出值域要藉於-1~1\n",
    "        \n",
    "        self.output.apply(self.init_net_work)\n",
    "    def forward(self, batch_size : int, use_gpu = False):\n",
    "        x = torch.randn(batch_size * 100)#隨機正態分布\n",
    "        x = x.view(-1, 100)\n",
    "        if (use_gpu): x = x.to(device=\"cuda\", dtype=torch.float32)\n",
    "        return self.output(x)\n",
    "    def generate_image(self, num : int):\n",
    "        image = self.forward(batch_size=num)\n",
    "        image = image.view(-1, 28, 28).detach().numpy()\n",
    "        image = (image + 1) * 255 / 2\n",
    "        return image\n",
    "    \n",
    "    def init_net_work(self, tensor : torch.tensor): \n",
    "        if (type(tensor) == nn.Linear):\n",
    "            nn.init.kaiming_uniform_(tensor.weight, nonlinearity='leaky_relu')\n",
    "            nn.init.zeros_(tensor.bias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Classifier(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Classifier, self).__init__()\n",
    "        self.output = nn.Sequential(nn.Linear(784, 512),\n",
    "                                    nn.LeakyReLU(0.2),\n",
    "                                    nn.Dropout(0.3),\n",
    "                                    nn.Linear(512, 256),\n",
    "                                    nn.LeakyReLU(0.2),\n",
    "                                    nn.Dropout(0.3),\n",
    "                                    nn.Linear(256, 1),\n",
    "                                    nn.Sigmoid()\n",
    "                                    )\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 784)\n",
    "        return self.output(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#呼叫模型\n",
    "generator = Generator()\n",
    "classifier = Classifier()\n",
    "image = generator.generate_image(10)\n",
    "plt.imshow(image[0])\n",
    "plt.show()\n",
    "\n",
    "#使用手寫辨識模型\n",
    "mnist_classifer = Mnist_classifer()\n",
    "mnist_classifer_checkpoint = torch.load(\"mnist_classifier/checkpoint.pth\")\n",
    "mnist_classifer.load_state_dict(mnist_classifer_checkpoint)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test classifier\n",
    "\n",
    "def validate(classifier, loss_function, dataloader, use_gpu : bool):\n",
    "    val_loss = 0\n",
    "    count = 0\n",
    "    classifier.eval()\n",
    "    with torch.no_grad():\n",
    "        for x, y in dataloader:\n",
    "            count += 1\n",
    "            label = torch.ones(len(x))\n",
    "            if (use_gpu):\n",
    "                x = x.to(device=\"cuda\", dtype=torch.float32)\n",
    "                label = label.to(device=\"cuda\", dtype=torch.float32)\n",
    "\n",
    "            predict = classifier(x)\n",
    "            label = label.view(predict.shape)\n",
    "            loss = loss_function(predict, label)\n",
    "            val_loss += loss\n",
    "\n",
    "    return val_loss / count\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU\n"
     ]
    }
   ],
   "source": [
    "use_gpu = torch.cuda.is_available()\n",
    "\n",
    "epoch = 1000\n",
    "lr = 0.0002\n",
    "beta = (0.5, 0.999)\n",
    "\n",
    "optim_G = optim.Adam(generator.parameters(), lr=lr, betas=beta)#刪掉正規化\n",
    "optim_C = optim.Adam(classifier.parameters(), lr=lr, betas=beta)\n",
    "loss_function = nn.BCELoss()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "if (use_gpu):\n",
    "    print(\"GPU\")\n",
    "    loss_function = loss_function.to(device=\"cuda\", dtype=torch.float32)\n",
    "    generator = generator.to(device=\"cuda\", dtype=torch.float32)\n",
    "    classifier = classifier.to(device=\"cuda\", dtype=torch.float32)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classifer_loss_function(real : torch.tensor, fake : torch.tensor, ones_label : torch.tensor, zeros_label : torch.tensor):\n",
    "    real_loss = loss_function(real, ones_label)#越大越好\n",
    "    fake_loss = loss_function(fake, zeros_label)#越小越好\n",
    "    return real_loss + fake_loss\n",
    "\n",
    "def generator_loss_function(fake : torch.tensor, ones_label : torch.tensor):\n",
    "    return loss_function(fake, ones_label)#越大越好"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_c(x : torch.tensor) -> float:\n",
    "    \"\"\"\n",
    "    x : train data\n",
    "\n",
    "    return:\n",
    "    classifier_loss\n",
    "    \"\"\"\n",
    "    classifier.train()\n",
    "    optim_C.zero_grad()\n",
    "    optim_G.zero_grad()\n",
    "\n",
    "\n",
    "    #根據batch大小生成對應大小標籤\n",
    "    zeros_label = torch.zeros((len(x), 1))\n",
    "    ones_label = torch.ones((len(x), 1))\n",
    "\n",
    "\n",
    "    if (use_gpu): \n",
    "        x = x.to(device=\"cuda\", dtype=torch.float32)\n",
    "        zeros_label = zeros_label.to(device=\"cuda\", dtype=torch.float32)\n",
    "        ones_label = ones_label.to(device=\"cuda\", dtype=torch.float32)\n",
    "\n",
    "    #訓練辨識器\n",
    "    classifier.train()\n",
    "    #reshape mnist data\n",
    "    x = x.view(-1, 784)     \n",
    "    #生成假資料\n",
    "    with torch.no_grad(): fake_mnist = generator(batch_size=len(x), use_gpu=use_gpu)\n",
    "\n",
    "    #預測真假資料的分數\n",
    "    real_predict = classifier(x)\n",
    "    fake_predict = classifier(fake_mnist)\n",
    "\n",
    "    #classifier_loss計算+反向傳播\n",
    "    c_loss = classifer_loss_function(real_predict, fake_predict, ones_label, zeros_label)\n",
    "    c_loss.backward()\n",
    "    optim_C.step()\n",
    "    \n",
    "    return c_loss.item()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_g(x_size : int) -> float:\n",
    "    \"\"\"\n",
    "    x_size : len(x)\n",
    "\n",
    "    return : g_loss.item()\n",
    "    \"\"\"\n",
    "\n",
    "    ones_label = torch.ones((x_size, 1))\n",
    "    if (use_gpu): ones_label = ones_label.to(device=\"cuda\", dtype=torch.float32)\n",
    "\n",
    "    #訓練生成器\n",
    "    optim_C.zero_grad()\n",
    "    optim_G.zero_grad()\n",
    "    classifier.eval()\n",
    "    #生成假資料\n",
    "    fake_mnist = generator(batch_size=x_size, use_gpu=use_gpu)\n",
    "\n",
    "    #預測假資料的分數\n",
    "    fake_predict = classifier(fake_mnist)\n",
    "\n",
    "    #fake_loss計算+反向傳播\n",
    "    g_loss = generator_loss_function(fake_predict, ones_label)\n",
    "    g_loss.backward()\n",
    "    optim_G.step()\n",
    "\n",
    "    return g_loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1/1000:\n",
      "classifier train loss: 1.020590302585619, val loss: 0.39978915452957153 |  generator loss: 1.3145574038946535\n",
      "save model\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\weiso131\\AppData\\Local\\Temp\\ipykernel_19644\\2888401379.py:52: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  topk, top_class = mnist_classifer(torch.tensor(fake_images)).topk(1, dim=1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x800 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 2/1000:\n",
      "classifier train loss: 1.1077313892769092, val loss: 0.5261772274971008 |  generator loss: 1.1350514541571388\n",
      "epoch: 3/1000:\n",
      "classifier train loss: 1.0813981855223342, val loss: 0.4022407829761505 |  generator loss: 1.1532414931172608\n",
      "epoch: 4/1000:\n",
      "classifier train loss: 1.0839000253297397, val loss: 0.38220861554145813 |  generator loss: 1.157812195260383\n",
      "save model\n",
      "epoch: 5/1000:\n",
      "classifier train loss: 1.1142161429664235, val loss: 0.7008337378501892 |  generator loss: 1.1182438354567112\n",
      "epoch: 6/1000:\n",
      "classifier train loss: 1.1485999064012007, val loss: 0.5009833574295044 |  generator loss: 1.0720055277901466\n",
      "epoch: 7/1000:\n",
      "classifier train loss: 1.1750864342406944, val loss: 0.579425036907196 |  generator loss: 1.0373770528034998\n",
      "epoch: 8/1000:\n",
      "classifier train loss: 1.1868872965626445, val loss: 0.4368344843387604 |  generator loss: 1.0255269333971069\n",
      "epoch: 9/1000:\n",
      "classifier train loss: 1.2001569475790468, val loss: 0.6299708485603333 |  generator loss: 1.0208867917424769\n",
      "epoch: 10/1000:\n",
      "classifier train loss: 1.2086592253075974, val loss: 0.4473520815372467 |  generator loss: 1.0149296526823248\n",
      "epoch: 11/1000:\n",
      "classifier train loss: 1.2134481479824593, val loss: 0.6382471323013306 |  generator loss: 1.0099711668344191\n",
      "epoch: 12/1000:\n",
      "classifier train loss: 1.2228538741166344, val loss: 0.7640964984893799 |  generator loss: 1.0028818775507737\n",
      "epoch: 13/1000:\n",
      "classifier train loss: 1.2257934384608242, val loss: 0.6822068095207214 |  generator loss: 1.0054545421926795\n",
      "epoch: 14/1000:\n",
      "classifier train loss: 1.2328505434438704, val loss: 0.6237000226974487 |  generator loss: 1.0047297293757216\n",
      "epoch: 15/1000:\n",
      "classifier train loss: 1.2386327056103417, val loss: 0.6270105242729187 |  generator loss: 1.0036720784023554\n",
      "epoch: 16/1000:\n",
      "classifier train loss: 1.2428936361597578, val loss: 0.7845814228057861 |  generator loss: 1.0023876460714372\n",
      "epoch: 17/1000:\n",
      "classifier train loss: 1.2441925409800811, val loss: 0.5922201871871948 |  generator loss: 1.0021102103989\n",
      "epoch: 18/1000:\n",
      "classifier train loss: 1.2496037666511322, val loss: 0.7185354828834534 |  generator loss: 1.0000478696207673\n",
      "epoch: 19/1000:\n",
      "classifier train loss: 1.2482898181803967, val loss: 0.6782962679862976 |  generator loss: 1.0044217132424933\n",
      "epoch: 20/1000:\n",
      "classifier train loss: 1.249827770539272, val loss: 0.6656653881072998 |  generator loss: 1.0101489841469744\n",
      "epoch: 21/1000:\n",
      "classifier train loss: 1.2541116233894185, val loss: 0.8405167460441589 |  generator loss: 0.999489434908001\n",
      "epoch: 22/1000:\n",
      "classifier train loss: 1.258202049333506, val loss: 0.7054823040962219 |  generator loss: 1.007638043492999\n",
      "epoch: 23/1000:\n",
      "classifier train loss: 1.2604068759849711, val loss: 0.7166926264762878 |  generator loss: 1.0042535217790358\n",
      "epoch: 24/1000:\n",
      "classifier train loss: 1.2643199602495272, val loss: 0.5687010288238525 |  generator loss: 1.0033020447400283\n",
      "epoch: 25/1000:\n",
      "classifier train loss: 1.2635015940960543, val loss: 0.6534735560417175 |  generator loss: 1.0031268494966723\n",
      "epoch: 26/1000:\n",
      "classifier train loss: 1.265128816418375, val loss: 0.6058186888694763 |  generator loss: 1.0018271518208497\n",
      "epoch: 27/1000:\n",
      "classifier train loss: 1.265237641254258, val loss: 0.7633419036865234 |  generator loss: 1.0048894677499327\n",
      "epoch: 28/1000:\n",
      "classifier train loss: 1.268700855214454, val loss: 0.6135138273239136 |  generator loss: 1.0022805531150698\n",
      "epoch: 29/1000:\n",
      "classifier train loss: 1.2681781759968511, val loss: 0.6364611387252808 |  generator loss: 1.0029565114632466\n",
      "epoch: 30/1000:\n",
      "classifier train loss: 1.2718899866814832, val loss: 0.6431489586830139 |  generator loss: 1.0008189354413821\n",
      "epoch: 31/1000:\n",
      "classifier train loss: 1.2697840264081688, val loss: 0.6058160662651062 |  generator loss: 1.0011650757356123\n",
      "epoch: 32/1000:\n",
      "classifier train loss: 1.2716006472723518, val loss: 0.6235899329185486 |  generator loss: 1.0000451375739743\n",
      "epoch: 33/1000:\n",
      "classifier train loss: 1.2729173534780773, val loss: 0.7229283452033997 |  generator loss: 0.9975903537270732\n",
      "epoch: 34/1000:\n",
      "classifier train loss: 1.2746021512113972, val loss: 0.6722699403762817 |  generator loss: 0.9982283739529876\n",
      "epoch: 35/1000:\n",
      "classifier train loss: 1.2721108818963989, val loss: 0.7922227382659912 |  generator loss: 0.9952268895476756\n",
      "epoch: 36/1000:\n",
      "classifier train loss: 1.2727536365774479, val loss: 0.7709187269210815 |  generator loss: 0.9969756785867993\n",
      "epoch: 37/1000:\n",
      "classifier train loss: 1.2717785773721475, val loss: 0.5832077264785767 |  generator loss: 0.9968373353366231\n",
      "epoch: 38/1000:\n",
      "classifier train loss: 1.273633526498086, val loss: 0.7457084655761719 |  generator loss: 1.0000871597850898\n",
      "epoch: 39/1000:\n",
      "classifier train loss: 1.273140418007719, val loss: 0.6310750246047974 |  generator loss: 1.0006239857068902\n",
      "epoch: 40/1000:\n",
      "classifier train loss: 1.2707663411912158, val loss: 0.7517164349555969 |  generator loss: 1.0026930615422969\n",
      "epoch: 41/1000:\n",
      "classifier train loss: 1.274370615196014, val loss: 0.7806276082992554 |  generator loss: 1.0023795128805202\n",
      "epoch: 42/1000:\n",
      "classifier train loss: 1.2720178067349692, val loss: 0.7371160387992859 |  generator loss: 1.0039502488643632\n",
      "epoch: 43/1000:\n",
      "classifier train loss: 1.2723222562894811, val loss: 0.7571636438369751 |  generator loss: 1.0022574748789554\n",
      "epoch: 44/1000:\n",
      "classifier train loss: 1.2740081404194687, val loss: 0.7129814028739929 |  generator loss: 1.0026538278384909\n",
      "epoch: 45/1000:\n",
      "classifier train loss: 1.26984060038086, val loss: 0.6004624962806702 |  generator loss: 1.0049946823237854\n",
      "epoch: 46/1000:\n",
      "classifier train loss: 1.2698785061252906, val loss: 0.7372549772262573 |  generator loss: 1.0021306698437358\n",
      "epoch: 47/1000:\n",
      "classifier train loss: 1.2718858032515554, val loss: 0.7663099765777588 |  generator loss: 1.000361015031367\n",
      "epoch: 48/1000:\n",
      "classifier train loss: 1.270866699090309, val loss: 0.6442338824272156 |  generator loss: 1.0032757647778718\n",
      "epoch: 49/1000:\n",
      "classifier train loss: 1.2708096732996932, val loss: 0.7432172298431396 |  generator loss: 1.0051106888838488\n",
      "epoch: 50/1000:\n",
      "classifier train loss: 1.27073227890948, val loss: 0.7258411645889282 |  generator loss: 1.0028170727184993\n",
      "epoch: 51/1000:\n",
      "classifier train loss: 1.272017768871637, val loss: 0.6871297359466553 |  generator loss: 1.0036520252859285\n",
      "epoch: 52/1000:\n",
      "classifier train loss: 1.2700540061484014, val loss: 0.757000744342804 |  generator loss: 1.0066086979693702\n",
      "epoch: 53/1000:\n",
      "classifier train loss: 1.2715709614833999, val loss: 0.6147945523262024 |  generator loss: 1.004434798100982\n",
      "epoch: 54/1000:\n",
      "classifier train loss: 1.2721646586652557, val loss: 0.5974016785621643 |  generator loss: 1.001381303926911\n",
      "epoch: 55/1000:\n",
      "classifier train loss: 1.2709564341171555, val loss: 0.6457936763763428 |  generator loss: 1.0060505458267717\n",
      "epoch: 56/1000:\n",
      "classifier train loss: 1.2705580283763298, val loss: 0.7211780548095703 |  generator loss: 1.0005324279552892\n",
      "epoch: 57/1000:\n",
      "classifier train loss: 1.2739308950743156, val loss: 0.730879008769989 |  generator loss: 0.9997987906405688\n",
      "epoch: 58/1000:\n",
      "classifier train loss: 1.2708638103722723, val loss: 0.532536506652832 |  generator loss: 1.0010615351090393\n",
      "epoch: 59/1000:\n",
      "classifier train loss: 1.2742000843673176, val loss: 0.7059450745582581 |  generator loss: 1.0007379618959396\n",
      "epoch: 60/1000:\n",
      "classifier train loss: 1.269846214991226, val loss: 0.6779518127441406 |  generator loss: 1.004518878446551\n",
      "epoch: 61/1000:\n",
      "classifier train loss: 1.2719341947307223, val loss: 0.7052563428878784 |  generator loss: 1.0023918253537916\n",
      "epoch: 62/1000:\n",
      "classifier train loss: 1.2713023179307932, val loss: 0.7353335022926331 |  generator loss: 1.0030182791344913\n",
      "epoch: 63/1000:\n",
      "classifier train loss: 1.2710948791835712, val loss: 0.6644505262374878 |  generator loss: 1.002648290426509\n",
      "epoch: 64/1000:\n",
      "classifier train loss: 1.2706020967459972, val loss: 0.6656213402748108 |  generator loss: 1.0028918030286076\n",
      "epoch: 65/1000:\n",
      "classifier train loss: 1.2722052943157962, val loss: 0.6600047945976257 |  generator loss: 1.0019531563074902\n",
      "epoch: 66/1000:\n",
      "classifier train loss: 1.2727763939117878, val loss: 0.5927261710166931 |  generator loss: 0.9987002360298979\n",
      "epoch: 67/1000:\n",
      "classifier train loss: 1.2752134964522288, val loss: 0.7215033769607544 |  generator loss: 1.0009585801599805\n",
      "epoch: 68/1000:\n",
      "classifier train loss: 1.2735114547138664, val loss: 0.681694746017456 |  generator loss: 0.9951619822301982\n",
      "epoch: 69/1000:\n",
      "classifier train loss: 1.2743308635137967, val loss: 0.653246283531189 |  generator loss: 0.9980546876905207\n",
      "epoch: 70/1000:\n",
      "classifier train loss: 1.2690870851512441, val loss: 0.7034609913825989 |  generator loss: 1.001718770708433\n",
      "epoch: 71/1000:\n",
      "classifier train loss: 1.270372562269303, val loss: 0.7648908495903015 |  generator loss: 0.9997905392438073\n",
      "epoch: 72/1000:\n",
      "classifier train loss: 1.273149658801446, val loss: 0.5964332818984985 |  generator loss: 0.9987432869061342\n",
      "epoch: 73/1000:\n",
      "classifier train loss: 1.2716911879987962, val loss: 0.6947623491287231 |  generator loss: 0.999878714381645\n",
      "epoch: 74/1000:\n",
      "classifier train loss: 1.2725509284722685, val loss: 0.7028984427452087 |  generator loss: 1.0027790026097454\n",
      "epoch: 75/1000:\n",
      "classifier train loss: 1.274440597203444, val loss: 0.716704785823822 |  generator loss: 0.9992358293196167\n",
      "epoch: 76/1000:\n",
      "classifier train loss: 1.2695187532272938, val loss: 0.7449119091033936 |  generator loss: 1.0031426149586635\n",
      "epoch: 77/1000:\n",
      "classifier train loss: 1.2715880485496136, val loss: 0.5958707928657532 |  generator loss: 1.0005685432190043\n",
      "epoch: 78/1000:\n",
      "classifier train loss: 1.2730110418114196, val loss: 0.6788648962974548 |  generator loss: 1.0018079931754724\n",
      "epoch: 79/1000:\n",
      "classifier train loss: 1.2731747018501547, val loss: 0.7096601128578186 |  generator loss: 0.9960050285197\n",
      "epoch: 80/1000:\n",
      "classifier train loss: 1.2717670362806481, val loss: 0.6236803531646729 |  generator loss: 0.9968839560694968\n",
      "epoch: 81/1000:\n",
      "classifier train loss: 1.271196569122717, val loss: 0.654547393321991 |  generator loss: 0.9990324041524987\n",
      "epoch: 82/1000:\n",
      "classifier train loss: 1.2701668356671745, val loss: 0.6436783671379089 |  generator loss: 0.9982292720364401\n",
      "epoch: 83/1000:\n",
      "classifier train loss: 1.2708171722463486, val loss: 0.6902357935905457 |  generator loss: 1.0019032317647496\n",
      "epoch: 84/1000:\n",
      "classifier train loss: 1.2735246513561502, val loss: 0.7637186050415039 |  generator loss: 0.9971270354508551\n",
      "epoch: 85/1000:\n",
      "classifier train loss: 1.2738065708901076, val loss: 0.6869519352912903 |  generator loss: 0.9978049730612373\n",
      "epoch: 86/1000:\n",
      "classifier train loss: 1.273437632053388, val loss: 0.7236762046813965 |  generator loss: 0.9976464467150328\n",
      "epoch: 87/1000:\n",
      "classifier train loss: 1.2715528743168052, val loss: 0.7293793559074402 |  generator loss: 0.9971925078417717\n",
      "epoch: 88/1000:\n",
      "classifier train loss: 1.273460292655611, val loss: 0.7478345036506653 |  generator loss: 0.9950459143930814\n",
      "epoch: 89/1000:\n",
      "classifier train loss: 1.2744023937702713, val loss: 0.6959783434867859 |  generator loss: 0.9963662742765664\n",
      "epoch: 90/1000:\n",
      "classifier train loss: 1.2744114180874209, val loss: 0.6618802547454834 |  generator loss: 0.9963996020364173\n",
      "epoch: 91/1000:\n",
      "classifier train loss: 1.2699656564110993, val loss: 0.6913268566131592 |  generator loss: 0.9946041497852398\n",
      "epoch: 92/1000:\n",
      "classifier train loss: 1.2700124574965233, val loss: 0.6819648742675781 |  generator loss: 0.9988593548101474\n",
      "epoch: 93/1000:\n",
      "classifier train loss: 1.2721164769730315, val loss: 0.7071616053581238 |  generator loss: 0.9987851006682339\n",
      "epoch: 94/1000:\n",
      "classifier train loss: 1.271410163805541, val loss: 0.7015061378479004 |  generator loss: 0.9954463185284675\n",
      "epoch: 95/1000:\n",
      "classifier train loss: 1.2719932298200032, val loss: 0.6734673380851746 |  generator loss: 0.9984772772633802\n",
      "epoch: 96/1000:\n",
      "classifier train loss: 1.2737609968174721, val loss: 0.6720780730247498 |  generator loss: 0.9954453496017841\n",
      "epoch: 97/1000:\n",
      "classifier train loss: 1.269954691163351, val loss: 0.6555383205413818 |  generator loss: 0.9961454210056601\n",
      "epoch: 98/1000:\n",
      "classifier train loss: 1.27264084706269, val loss: 0.7191223502159119 |  generator loss: 0.9935992920037472\n",
      "epoch: 99/1000:\n",
      "classifier train loss: 1.2717313137653834, val loss: 0.7742056846618652 |  generator loss: 0.994136349654492\n",
      "epoch: 100/1000:\n",
      "classifier train loss: 1.271232368167402, val loss: 0.6318603157997131 |  generator loss: 0.9959140213250312\n",
      "epoch: 101/1000:\n",
      "classifier train loss: 1.2722103047183602, val loss: 0.6453438997268677 |  generator loss: 0.9963927715180565\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x800 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 102/1000:\n",
      "classifier train loss: 1.2724631161802145, val loss: 0.6513514518737793 |  generator loss: 0.9996484706698845\n",
      "epoch: 103/1000:\n",
      "classifier train loss: 1.2710377510415451, val loss: 0.7671570181846619 |  generator loss: 0.996661678709165\n",
      "epoch: 104/1000:\n",
      "classifier train loss: 1.2737357133432938, val loss: 0.760760486125946 |  generator loss: 0.9938956328514048\n",
      "epoch: 105/1000:\n",
      "classifier train loss: 1.2707308774310198, val loss: 0.7666987776756287 |  generator loss: 0.9963548263047814\n",
      "epoch: 106/1000:\n",
      "classifier train loss: 1.2726931561257033, val loss: 0.7845264077186584 |  generator loss: 0.9942907328423694\n",
      "epoch: 107/1000:\n",
      "classifier train loss: 1.2725144928419496, val loss: 0.6383538842201233 |  generator loss: 0.9934757974011328\n",
      "epoch: 108/1000:\n",
      "classifier train loss: 1.2731581416595665, val loss: 0.7243489027023315 |  generator loss: 0.9992511181451389\n",
      "epoch: 109/1000:\n",
      "classifier train loss: 1.273250355463638, val loss: 0.7526348829269409 |  generator loss: 0.9966366980078512\n",
      "epoch: 110/1000:\n",
      "classifier train loss: 1.2698850954154257, val loss: 0.7821112275123596 |  generator loss: 0.9954684301792706\n",
      "epoch: 111/1000:\n",
      "classifier train loss: 1.270906324070846, val loss: 0.7955307364463806 |  generator loss: 0.9987831813451551\n",
      "epoch: 112/1000:\n",
      "classifier train loss: 1.2721052199234197, val loss: 0.7408894896507263 |  generator loss: 1.0029984893889807\n",
      "epoch: 113/1000:\n",
      "classifier train loss: 1.2682284876687493, val loss: 0.660281240940094 |  generator loss: 1.0012860084757393\n",
      "epoch: 114/1000:\n",
      "classifier train loss: 1.270484051185291, val loss: 0.7341217994689941 |  generator loss: 0.9984950570412624\n",
      "epoch: 115/1000:\n",
      "classifier train loss: 1.266252001661778, val loss: 0.5454095005989075 |  generator loss: 1.0014058895384021\n",
      "epoch: 116/1000:\n",
      "classifier train loss: 1.271981526036589, val loss: 0.6908068060874939 |  generator loss: 1.0000590956304745\n",
      "epoch: 117/1000:\n",
      "classifier train loss: 1.2687312897073166, val loss: 0.8095497488975525 |  generator loss: 0.9978033791888844\n",
      "epoch: 118/1000:\n",
      "classifier train loss: 1.2696806712851647, val loss: 0.7278358340263367 |  generator loss: 1.0018727363293152\n",
      "epoch: 119/1000:\n",
      "classifier train loss: 1.2692896228045325, val loss: 0.6739644408226013 |  generator loss: 1.0024617940488487\n",
      "epoch: 120/1000:\n",
      "classifier train loss: 1.2698069852343044, val loss: 0.7071834206581116 |  generator loss: 1.0013279221809808\n",
      "epoch: 121/1000:\n",
      "classifier train loss: 1.2699431118071414, val loss: 0.6636661291122437 |  generator loss: 0.9967881673246656\n",
      "epoch: 122/1000:\n",
      "classifier train loss: 1.2670505545891229, val loss: 0.6639998555183411 |  generator loss: 1.0030416520490122\n",
      "epoch: 123/1000:\n",
      "classifier train loss: 1.2669421478554055, val loss: 0.7492872476577759 |  generator loss: 1.0017134610116147\n",
      "epoch: 124/1000:\n",
      "classifier train loss: 1.266097056210108, val loss: 0.727696418762207 |  generator loss: 1.0039531042680194\n",
      "epoch: 125/1000:\n",
      "classifier train loss: 1.2661662619523328, val loss: 0.6661068797111511 |  generator loss: 1.001922555309621\n",
      "epoch: 126/1000:\n",
      "classifier train loss: 1.2662457960890867, val loss: 0.7048189640045166 |  generator loss: 1.001282216657024\n",
      "epoch: 127/1000:\n",
      "classifier train loss: 1.2669190272739037, val loss: 0.6696583032608032 |  generator loss: 1.002343507059228\n",
      "epoch: 128/1000:\n",
      "classifier train loss: 1.2656196424053976, val loss: 0.8075113296508789 |  generator loss: 1.0021549526823623\n",
      "epoch: 129/1000:\n",
      "classifier train loss: 1.2656304160620093, val loss: 0.55915367603302 |  generator loss: 1.0028212370829683\n",
      "epoch: 130/1000:\n",
      "classifier train loss: 1.2644132500144367, val loss: 0.6695851683616638 |  generator loss: 1.0064551071687178\n",
      "epoch: 131/1000:\n",
      "classifier train loss: 1.2665094621521322, val loss: 0.6449289917945862 |  generator loss: 1.0023660087157313\n",
      "epoch: 132/1000:\n",
      "classifier train loss: 1.2655837303058868, val loss: 0.7024515867233276 |  generator loss: 1.0083616196640948\n",
      "epoch: 133/1000:\n",
      "classifier train loss: 1.2630376141480726, val loss: 0.737356424331665 |  generator loss: 1.0095069316768752\n",
      "epoch: 134/1000:\n",
      "classifier train loss: 1.2635453988941163, val loss: 0.7002074718475342 |  generator loss: 1.0124615761299862\n",
      "epoch: 135/1000:\n",
      "classifier train loss: 1.2637919358800425, val loss: 0.7884025573730469 |  generator loss: 1.0158222616053323\n",
      "epoch: 136/1000:\n",
      "classifier train loss: 1.2652662906850094, val loss: 0.6602051854133606 |  generator loss: 1.007835326638955\n",
      "epoch: 137/1000:\n",
      "classifier train loss: 1.2650460451674113, val loss: 0.710193932056427 |  generator loss: 1.0087553837350187\n",
      "epoch: 138/1000:\n",
      "classifier train loss: 1.2645073456127367, val loss: 0.769380509853363 |  generator loss: 1.010195651774187\n",
      "epoch: 139/1000:\n",
      "classifier train loss: 1.2652824515044088, val loss: 0.6909893155097961 |  generator loss: 1.0103195339742332\n",
      "epoch: 140/1000:\n",
      "classifier train loss: 1.2601084544602468, val loss: 0.7095999717712402 |  generator loss: 1.0075151218575928\n",
      "epoch: 141/1000:\n",
      "classifier train loss: 1.2638430656942587, val loss: 0.6787035465240479 |  generator loss: 1.0096417510951008\n",
      "epoch: 142/1000:\n",
      "classifier train loss: 1.2633215247848888, val loss: 0.7947263121604919 |  generator loss: 1.004263266636734\n",
      "epoch: 143/1000:\n",
      "classifier train loss: 1.2630550141553953, val loss: 0.6552293300628662 |  generator loss: 1.0092799603336988\n",
      "epoch: 144/1000:\n",
      "classifier train loss: 1.2637531433576419, val loss: 0.7596983909606934 |  generator loss: 1.0109748310512967\n",
      "epoch: 145/1000:\n",
      "classifier train loss: 1.262719972232643, val loss: 0.7734536528587341 |  generator loss: 1.0098982040595794\n",
      "epoch: 146/1000:\n",
      "classifier train loss: 1.2608462411546546, val loss: 0.654034435749054 |  generator loss: 1.0112363170293044\n",
      "epoch: 147/1000:\n",
      "classifier train loss: 1.2583128726308461, val loss: 0.680395245552063 |  generator loss: 1.0131229264567596\n",
      "epoch: 148/1000:\n",
      "classifier train loss: 1.2580108253241389, val loss: 0.8495791554450989 |  generator loss: 1.017115499368554\n",
      "epoch: 149/1000:\n",
      "classifier train loss: 1.2596240697886405, val loss: 0.7051776051521301 |  generator loss: 1.0143025018416938\n",
      "epoch: 150/1000:\n",
      "classifier train loss: 1.264453449902176, val loss: 0.6535221338272095 |  generator loss: 1.0148671615939884\n",
      "epoch: 151/1000:\n",
      "classifier train loss: 1.2620293200350503, val loss: 0.7332289218902588 |  generator loss: 1.0105810006191969\n",
      "epoch: 152/1000:\n",
      "classifier train loss: 1.2611079728429433, val loss: 0.6936327219009399 |  generator loss: 1.0108489954110347\n",
      "epoch: 153/1000:\n",
      "classifier train loss: 1.2573255101170737, val loss: 0.6507031917572021 |  generator loss: 1.013430849604066\n",
      "epoch: 154/1000:\n",
      "classifier train loss: 1.2592083210361793, val loss: 0.765527606010437 |  generator loss: 1.0147192286187416\n",
      "epoch: 155/1000:\n",
      "classifier train loss: 1.2600998240287857, val loss: 0.6521744728088379 |  generator loss: 1.0188236561019546\n",
      "epoch: 156/1000:\n",
      "classifier train loss: 1.2604616476362938, val loss: 0.7297864556312561 |  generator loss: 1.0166298236643558\n",
      "epoch: 157/1000:\n",
      "classifier train loss: 1.2588580866855403, val loss: 0.7786067128181458 |  generator loss: 1.0125723724012021\n",
      "epoch: 158/1000:\n",
      "classifier train loss: 1.2577239803459774, val loss: 0.711574137210846 |  generator loss: 1.0178251469844386\n",
      "epoch: 159/1000:\n",
      "classifier train loss: 1.257986953630458, val loss: 0.5962108373641968 |  generator loss: 1.0182830590324101\n",
      "epoch: 160/1000:\n",
      "classifier train loss: 1.2544070736460144, val loss: 0.7649641633033752 |  generator loss: 1.018430362914414\n",
      "epoch: 161/1000:\n",
      "classifier train loss: 1.2598888379020992, val loss: 0.6209408640861511 |  generator loss: 1.0187929890773915\n",
      "epoch: 162/1000:\n",
      "classifier train loss: 1.2555019673541206, val loss: 0.6686878204345703 |  generator loss: 1.015459117196358\n",
      "epoch: 163/1000:\n",
      "classifier train loss: 1.256662011815509, val loss: 0.6714038252830505 |  generator loss: 1.0203058023913005\n",
      "epoch: 164/1000:\n",
      "classifier train loss: 1.2575607955388883, val loss: 0.6467316746711731 |  generator loss: 1.021007135393376\n",
      "epoch: 165/1000:\n",
      "classifier train loss: 1.254369017919975, val loss: 0.7686930298805237 |  generator loss: 1.0181502757382848\n",
      "epoch: 166/1000:\n",
      "classifier train loss: 1.25502651789373, val loss: 0.7501587867736816 |  generator loss: 1.0223223815194418\n",
      "epoch: 167/1000:\n",
      "classifier train loss: 1.2548843693117768, val loss: 0.5940456390380859 |  generator loss: 1.0225846218206531\n",
      "epoch: 168/1000:\n",
      "classifier train loss: 1.2566538453771074, val loss: 0.6788761019706726 |  generator loss: 1.0162516883192907\n",
      "epoch: 169/1000:\n",
      "classifier train loss: 1.2560040590872803, val loss: 0.6922587752342224 |  generator loss: 1.0252178465209558\n",
      "epoch: 170/1000:\n",
      "classifier train loss: 1.2547673787064557, val loss: 0.697414219379425 |  generator loss: 1.02138239198796\n",
      "epoch: 171/1000:\n",
      "classifier train loss: 1.2557799739869757, val loss: 0.7941914796829224 |  generator loss: 1.0208652564705958\n",
      "epoch: 172/1000:\n",
      "classifier train loss: 1.2585527677461086, val loss: 0.6805774569511414 |  generator loss: 1.018815515084165\n",
      "epoch: 173/1000:\n",
      "classifier train loss: 1.2566143769340214, val loss: 0.7967254519462585 |  generator loss: 1.0192926122684671\n",
      "epoch: 174/1000:\n",
      "classifier train loss: 1.2554717170937963, val loss: 0.7163643836975098 |  generator loss: 1.0154479928690978\n",
      "epoch: 175/1000:\n",
      "classifier train loss: 1.256489426198632, val loss: 0.8274132609367371 |  generator loss: 1.017998701728688\n",
      "epoch: 176/1000:\n",
      "classifier train loss: 1.2536162624990632, val loss: 0.6584417819976807 |  generator loss: 1.0205055829785623\n",
      "epoch: 177/1000:\n",
      "classifier train loss: 1.2530121375147074, val loss: 0.7208849191665649 |  generator loss: 1.0256468522562054\n",
      "epoch: 178/1000:\n",
      "classifier train loss: 1.2549853132228659, val loss: 0.6768412590026855 |  generator loss: 1.0221930265292842\n",
      "epoch: 179/1000:\n",
      "classifier train loss: 1.256893846456183, val loss: 0.6693276166915894 |  generator loss: 1.0168212604710014\n",
      "epoch: 180/1000:\n",
      "classifier train loss: 1.2564373411045866, val loss: 0.7317182421684265 |  generator loss: 1.0211749143070645\n",
      "epoch: 181/1000:\n",
      "classifier train loss: 1.2567364773498775, val loss: 0.6684725284576416 |  generator loss: 1.0228227425772198\n",
      "epoch: 182/1000:\n",
      "classifier train loss: 1.2554874168635752, val loss: 0.6323027014732361 |  generator loss: 1.0231992848526883\n",
      "epoch: 183/1000:\n",
      "classifier train loss: 1.2512750228246052, val loss: 0.7179602384567261 |  generator loss: 1.0265920085270128\n",
      "epoch: 184/1000:\n",
      "classifier train loss: 1.2545762428664733, val loss: 0.7116785049438477 |  generator loss: 1.0283591703801311\n",
      "epoch: 185/1000:\n",
      "classifier train loss: 1.2537805520324192, val loss: 0.7316803336143494 |  generator loss: 1.0270787141004663\n",
      "epoch: 186/1000:\n",
      "classifier train loss: 1.2531892106723037, val loss: 0.8484857082366943 |  generator loss: 1.0284079575511877\n",
      "epoch: 187/1000:\n",
      "classifier train loss: 1.2531258875272089, val loss: 0.6981406211853027 |  generator loss: 1.029981764344923\n",
      "epoch: 188/1000:\n",
      "classifier train loss: 1.2571693728400937, val loss: 0.711542010307312 |  generator loss: 1.0240508032299989\n",
      "epoch: 189/1000:\n",
      "classifier train loss: 1.2473380591063923, val loss: 0.8054450750350952 |  generator loss: 1.0321634438570366\n",
      "epoch: 190/1000:\n",
      "classifier train loss: 1.2559460843050922, val loss: 0.6720386743545532 |  generator loss: 1.0305679720794043\n",
      "epoch: 191/1000:\n",
      "classifier train loss: 1.2507060687282403, val loss: 0.702507495880127 |  generator loss: 1.0261536838631036\n",
      "epoch: 192/1000:\n",
      "classifier train loss: 1.2509435104868896, val loss: 0.7219833731651306 |  generator loss: 1.0261994344083014\n",
      "epoch: 193/1000:\n",
      "classifier train loss: 1.2512355416712135, val loss: 0.6815635561943054 |  generator loss: 1.0296157801191415\n",
      "epoch: 194/1000:\n",
      "classifier train loss: 1.2494136123143462, val loss: 0.7223259806632996 |  generator loss: 1.0351433086341746\n",
      "epoch: 195/1000:\n",
      "classifier train loss: 1.2515406306210057, val loss: 0.6759193539619446 |  generator loss: 1.036265510768869\n",
      "epoch: 196/1000:\n",
      "classifier train loss: 1.2529925969580875, val loss: 0.6721218228340149 |  generator loss: 1.0371336166304772\n",
      "epoch: 197/1000:\n",
      "classifier train loss: 1.2481587734554218, val loss: 0.7716760039329529 |  generator loss: 1.0325974779899674\n",
      "epoch: 198/1000:\n",
      "classifier train loss: 1.2526225372061852, val loss: 0.6339434385299683 |  generator loss: 1.036255404938485\n",
      "epoch: 199/1000:\n",
      "classifier train loss: 1.250322160228468, val loss: 0.6418185830116272 |  generator loss: 1.0372577824041365\n",
      "epoch: 200/1000:\n",
      "classifier train loss: 1.2512039085296134, val loss: 0.6749069094657898 |  generator loss: 1.0306845991699785\n",
      "epoch: 201/1000:\n",
      "classifier train loss: 1.2476508189264506, val loss: 0.6874154210090637 |  generator loss: 1.0319297203980178\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x800 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 202/1000:\n",
      "classifier train loss: 1.2466975141454626, val loss: 0.6562403440475464 |  generator loss: 1.040699933782036\n",
      "epoch: 203/1000:\n",
      "classifier train loss: 1.2496108587342079, val loss: 0.6728769540786743 |  generator loss: 1.0322882569866416\n",
      "epoch: 204/1000:\n",
      "classifier train loss: 1.2469971945256362, val loss: 0.7074848413467407 |  generator loss: 1.0400618042474912\n",
      "epoch: 205/1000:\n",
      "classifier train loss: 1.24279630652448, val loss: 0.7427480816841125 |  generator loss: 1.0396172313310215\n",
      "epoch: 206/1000:\n",
      "classifier train loss: 1.2480385933660898, val loss: 0.7688546180725098 |  generator loss: 1.0400668879015544\n",
      "epoch: 207/1000:\n",
      "classifier train loss: 1.2468257979244228, val loss: 0.708198606967926 |  generator loss: 1.0395550808119853\n",
      "epoch: 208/1000:\n",
      "classifier train loss: 1.2440318269226553, val loss: 0.705893874168396 |  generator loss: 1.0403474016087892\n",
      "epoch: 209/1000:\n",
      "classifier train loss: 1.2462146560484846, val loss: 0.885698676109314 |  generator loss: 1.0374976172457908\n",
      "epoch: 210/1000:\n",
      "classifier train loss: 1.2462757942251084, val loss: 0.7834250926971436 |  generator loss: 1.041321423117962\n",
      "epoch: 211/1000:\n",
      "classifier train loss: 1.2468001687299255, val loss: 0.737170398235321 |  generator loss: 1.0410526657077734\n",
      "epoch: 212/1000:\n",
      "classifier train loss: 1.2474881913659281, val loss: 0.7073256373405457 |  generator loss: 1.0449491906513937\n",
      "epoch: 213/1000:\n",
      "classifier train loss: 1.2468086945355006, val loss: 0.7019264101982117 |  generator loss: 1.0416935183250007\n",
      "epoch: 214/1000:\n",
      "classifier train loss: 1.2494413186404039, val loss: 0.7328619956970215 |  generator loss: 1.038978204047506\n",
      "epoch: 215/1000:\n",
      "classifier train loss: 1.248688229406723, val loss: 0.8608915209770203 |  generator loss: 1.0383194701706386\n",
      "epoch: 216/1000:\n",
      "classifier train loss: 1.2447001566121607, val loss: 0.7502061128616333 |  generator loss: 1.0431531147924737\n",
      "epoch: 217/1000:\n",
      "classifier train loss: 1.2443255168687883, val loss: 0.6761630773544312 |  generator loss: 1.0482823953082665\n",
      "epoch: 218/1000:\n",
      "classifier train loss: 1.2464159543800568, val loss: 0.7377752661705017 |  generator loss: 1.0415479006992046\n",
      "epoch: 219/1000:\n",
      "classifier train loss: 1.2469134496652452, val loss: 0.6405704617500305 |  generator loss: 1.0392563277489677\n",
      "epoch: 220/1000:\n",
      "classifier train loss: 1.2435789519019935, val loss: 0.7124891877174377 |  generator loss: 1.0471807919634981\n",
      "epoch: 221/1000:\n",
      "classifier train loss: 1.243745390012208, val loss: 0.7262138724327087 |  generator loss: 1.045821141781898\n",
      "epoch: 222/1000:\n",
      "classifier train loss: 1.2448220290452676, val loss: 0.743821382522583 |  generator loss: 1.0452045676550346\n",
      "epoch: 223/1000:\n",
      "classifier train loss: 1.245702920671799, val loss: 0.7312649488449097 |  generator loss: 1.039659888254673\n",
      "epoch: 224/1000:\n",
      "classifier train loss: 1.2444929126671, val loss: 0.6218836903572083 |  generator loss: 1.0400377808997927\n",
      "epoch: 225/1000:\n",
      "classifier train loss: 1.241619997688148, val loss: 0.657307505607605 |  generator loss: 1.046783722142713\n",
      "epoch: 226/1000:\n",
      "classifier train loss: 1.2435543604036239, val loss: 0.7830050587654114 |  generator loss: 1.0487390937896155\n",
      "epoch: 227/1000:\n",
      "classifier train loss: 1.2457907393859025, val loss: 0.748431384563446 |  generator loss: 1.0461474102488002\n",
      "epoch: 228/1000:\n",
      "classifier train loss: 1.24197049748349, val loss: 0.6451979279518127 |  generator loss: 1.045924114926763\n",
      "epoch: 229/1000:\n",
      "classifier train loss: 1.2400745194902858, val loss: 0.6744320392608643 |  generator loss: 1.0489605912054427\n",
      "epoch: 230/1000:\n",
      "classifier train loss: 1.24087881934897, val loss: 0.7150675654411316 |  generator loss: 1.0459436382241254\n",
      "epoch: 231/1000:\n",
      "classifier train loss: 1.2431536855387233, val loss: 0.70440274477005 |  generator loss: 1.0528575649566523\n",
      "epoch: 232/1000:\n",
      "classifier train loss: 1.2421686186399792, val loss: 0.5818827152252197 |  generator loss: 1.0487672304598705\n",
      "epoch: 233/1000:\n",
      "classifier train loss: 1.2418826229778337, val loss: 0.7605750560760498 |  generator loss: 1.0527926442599056\n",
      "epoch: 234/1000:\n",
      "classifier train loss: 1.2364197922609204, val loss: 0.6120039224624634 |  generator loss: 1.0527091546759728\n",
      "epoch: 235/1000:\n",
      "classifier train loss: 1.2411841265146446, val loss: 0.6697067022323608 |  generator loss: 1.0564451854504586\n",
      "epoch: 236/1000:\n",
      "classifier train loss: 1.2375624296239731, val loss: 0.7435857653617859 |  generator loss: 1.06030833279645\n",
      "epoch: 237/1000:\n",
      "classifier train loss: 1.24111140296114, val loss: 0.756090521812439 |  generator loss: 1.0549524320095076\n",
      "epoch: 238/1000:\n",
      "classifier train loss: 1.2381550776035295, val loss: 0.5932343602180481 |  generator loss: 1.0555199814163876\n",
      "epoch: 239/1000:\n",
      "classifier train loss: 1.238773830143022, val loss: 0.6981651186943054 |  generator loss: 1.0526648418670552\n",
      "epoch: 240/1000:\n",
      "classifier train loss: 1.2367013916289633, val loss: 0.6770780086517334 |  generator loss: 1.052667952011999\n",
      "epoch: 241/1000:\n",
      "classifier train loss: 1.238358426441916, val loss: 0.8382474780082703 |  generator loss: 1.0584997445779751\n",
      "epoch: 242/1000:\n",
      "classifier train loss: 1.2374356233177228, val loss: 0.6830103397369385 |  generator loss: 1.059051720983653\n",
      "epoch: 243/1000:\n",
      "classifier train loss: 1.2367388084948931, val loss: 0.6895747780799866 |  generator loss: 1.0570456653866838\n",
      "epoch: 244/1000:\n",
      "classifier train loss: 1.2394340981538048, val loss: 0.6456624269485474 |  generator loss: 1.0594319880476972\n",
      "epoch: 245/1000:\n",
      "classifier train loss: 1.240428853382834, val loss: 0.6656827330589294 |  generator loss: 1.0536404001191007\n",
      "epoch: 246/1000:\n",
      "classifier train loss: 1.236689592852737, val loss: 0.7505404353141785 |  generator loss: 1.0569882285849146\n",
      "epoch: 247/1000:\n",
      "classifier train loss: 1.2357162674669464, val loss: 0.7800887823104858 |  generator loss: 1.0621197018291546\n",
      "epoch: 248/1000:\n",
      "classifier train loss: 1.2397863844829777, val loss: 0.6865767240524292 |  generator loss: 1.057113969165468\n",
      "epoch: 249/1000:\n",
      "classifier train loss: 1.2354958955152535, val loss: 0.5881560444831848 |  generator loss: 1.0600309842229558\n",
      "epoch: 250/1000:\n",
      "classifier train loss: 1.2364019572935523, val loss: 0.6245384812355042 |  generator loss: 1.0556168862598647\n",
      "epoch: 251/1000:\n",
      "classifier train loss: 1.2341058066932173, val loss: 0.6325553059577942 |  generator loss: 1.0576090611994067\n",
      "epoch: 252/1000:\n",
      "classifier train loss: 1.2369424645213032, val loss: 0.6730349063873291 |  generator loss: 1.0529083464415923\n",
      "epoch: 253/1000:\n",
      "classifier train loss: 1.2343615856770045, val loss: 0.6282203793525696 |  generator loss: 1.0582392768961546\n",
      "epoch: 254/1000:\n",
      "classifier train loss: 1.2363432119992446, val loss: 0.7457805871963501 |  generator loss: 1.0646021920690099\n",
      "epoch: 255/1000:\n",
      "classifier train loss: 1.2312045158895712, val loss: 0.7234156131744385 |  generator loss: 1.0619706533573292\n",
      "epoch: 256/1000:\n",
      "classifier train loss: 1.2358089531578467, val loss: 0.6835785508155823 |  generator loss: 1.056821925003253\n",
      "epoch: 257/1000:\n",
      "classifier train loss: 1.2318903807170196, val loss: 0.7076149582862854 |  generator loss: 1.0640777045762633\n",
      "epoch: 258/1000:\n",
      "classifier train loss: 1.2365110899864222, val loss: 0.6804846525192261 |  generator loss: 1.057306470828158\n",
      "epoch: 259/1000:\n",
      "classifier train loss: 1.233174461975911, val loss: 0.7169162631034851 |  generator loss: 1.0595268569677634\n",
      "epoch: 260/1000:\n",
      "classifier train loss: 1.2319219972683257, val loss: 0.6812132000923157 |  generator loss: 1.0574542001709257\n",
      "epoch: 261/1000:\n",
      "classifier train loss: 1.2362038111178295, val loss: 0.7163355946540833 |  generator loss: 1.0552142726050482\n",
      "epoch: 262/1000:\n",
      "classifier train loss: 1.2354709758234077, val loss: 0.7066718935966492 |  generator loss: 1.0580173017066201\n",
      "epoch: 263/1000:\n",
      "classifier train loss: 1.2348877650452517, val loss: 0.6053144931793213 |  generator loss: 1.0566777921418684\n",
      "epoch: 264/1000:\n",
      "classifier train loss: 1.2315230614408499, val loss: 0.6762253046035767 |  generator loss: 1.0599491639704548\n",
      "epoch: 265/1000:\n",
      "classifier train loss: 1.233639798448008, val loss: 0.6821953058242798 |  generator loss: 1.0627991668838175\n",
      "epoch: 266/1000:\n",
      "classifier train loss: 1.2309294993896143, val loss: 0.6138826012611389 |  generator loss: 1.0630613229625288\n",
      "epoch: 267/1000:\n",
      "classifier train loss: 1.2330652562322306, val loss: 0.6277071833610535 |  generator loss: 1.0677440000570448\n",
      "epoch: 268/1000:\n",
      "classifier train loss: 1.2335807831600458, val loss: 0.7519887089729309 |  generator loss: 1.0656666601814673\n",
      "epoch: 269/1000:\n",
      "classifier train loss: 1.2279470203701495, val loss: 0.6795504093170166 |  generator loss: 1.0674174538365118\n",
      "epoch: 270/1000:\n",
      "classifier train loss: 1.2302498295652344, val loss: 0.694009006023407 |  generator loss: 1.0658814823453542\n",
      "epoch: 271/1000:\n",
      "classifier train loss: 1.2307769418699306, val loss: 0.6528513431549072 |  generator loss: 1.066301577219658\n",
      "epoch: 272/1000:\n",
      "classifier train loss: 1.2301520109176636, val loss: 0.7522058486938477 |  generator loss: 1.0739683134922409\n",
      "epoch: 273/1000:\n",
      "classifier train loss: 1.2330122799450567, val loss: 0.7586471438407898 |  generator loss: 1.0640223061061735\n",
      "epoch: 274/1000:\n",
      "classifier train loss: 1.232146997109273, val loss: 0.6695418357849121 |  generator loss: 1.069111921035347\n",
      "epoch: 275/1000:\n",
      "classifier train loss: 1.230253201007308, val loss: 0.5980004072189331 |  generator loss: 1.0708750685725015\n",
      "epoch: 276/1000:\n",
      "classifier train loss: 1.2325687278668354, val loss: 0.712584912776947 |  generator loss: 1.06853661526467\n",
      "epoch: 277/1000:\n",
      "classifier train loss: 1.228807604674137, val loss: 0.785797655582428 |  generator loss: 1.0739839009430538\n",
      "epoch: 278/1000:\n",
      "classifier train loss: 1.2334487042175533, val loss: 0.6737350821495056 |  generator loss: 1.0654209547171287\n",
      "epoch: 279/1000:\n",
      "classifier train loss: 1.230643303974978, val loss: 0.7046862244606018 |  generator loss: 1.071658701741468\n",
      "epoch: 280/1000:\n",
      "classifier train loss: 1.2304396728340088, val loss: 0.6356146931648254 |  generator loss: 1.0743162085445375\n",
      "epoch: 281/1000:\n",
      "classifier train loss: 1.2288137036140518, val loss: 0.5748039484024048 |  generator loss: 1.0674699734892241\n",
      "epoch: 282/1000:\n",
      "classifier train loss: 1.2346717669104887, val loss: 0.6397410035133362 |  generator loss: 1.0674652027093736\n",
      "epoch: 283/1000:\n",
      "classifier train loss: 1.2290451213566944, val loss: 0.7120314836502075 |  generator loss: 1.0679757433173098\n",
      "epoch: 284/1000:\n",
      "classifier train loss: 1.2264055558192877, val loss: 0.6408560872077942 |  generator loss: 1.0763141086741062\n",
      "epoch: 285/1000:\n",
      "classifier train loss: 1.2267031882347081, val loss: 0.7059687972068787 |  generator loss: 1.0740418744542115\n",
      "epoch: 286/1000:\n",
      "classifier train loss: 1.2299171393166488, val loss: 0.6525915265083313 |  generator loss: 1.0708730106401925\n",
      "epoch: 287/1000:\n",
      "classifier train loss: 1.2251332592883897, val loss: 0.7147868871688843 |  generator loss: 1.0750674507700901\n",
      "epoch: 288/1000:\n",
      "classifier train loss: 1.2290115523686178, val loss: 0.7502984404563904 |  generator loss: 1.0755014999546988\n",
      "epoch: 289/1000:\n",
      "classifier train loss: 1.2258545955022175, val loss: 0.6670787334442139 |  generator loss: 1.0750074464196442\n",
      "epoch: 290/1000:\n",
      "classifier train loss: 1.2275056915251092, val loss: 0.641513466835022 |  generator loss: 1.0740804584606998\n",
      "epoch: 291/1000:\n",
      "classifier train loss: 1.2273557227602443, val loss: 0.7244837880134583 |  generator loss: 1.0770025221854616\n",
      "epoch: 292/1000:\n",
      "classifier train loss: 1.228488245395699, val loss: 0.7249644994735718 |  generator loss: 1.0736315404927288\n",
      "epoch: 293/1000:\n",
      "classifier train loss: 1.2291153007083468, val loss: 0.6694353222846985 |  generator loss: 1.0747637629642766\n",
      "epoch: 294/1000:\n",
      "classifier train loss: 1.2245449985050325, val loss: 0.5831313729286194 |  generator loss: 1.0732308041500858\n",
      "epoch: 295/1000:\n",
      "classifier train loss: 1.2249312138584192, val loss: 0.6987541317939758 |  generator loss: 1.0826592577159337\n",
      "epoch: 296/1000:\n",
      "classifier train loss: 1.2286437203988483, val loss: 0.655812680721283 |  generator loss: 1.0805073206539775\n",
      "epoch: 297/1000:\n",
      "classifier train loss: 1.2240331796417065, val loss: 0.6601130962371826 |  generator loss: 1.0795352188023655\n",
      "epoch: 298/1000:\n",
      "classifier train loss: 1.226984824261949, val loss: 0.7884762287139893 |  generator loss: 1.080439951751636\n",
      "epoch: 299/1000:\n",
      "classifier train loss: 1.227442726141676, val loss: 0.8643637299537659 |  generator loss: 1.0776056625224926\n",
      "epoch: 300/1000:\n",
      "classifier train loss: 1.2260631946334668, val loss: 0.7756391763687134 |  generator loss: 1.081158377907493\n",
      "epoch: 301/1000:\n",
      "classifier train loss: 1.2264424470137265, val loss: 0.5659925937652588 |  generator loss: 1.0797443335037573\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x800 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 302/1000:\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[11], line 23\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m x, y \u001b[38;5;129;01min\u001b[39;00m mnist_train_dataloader:\n\u001b[0;32m     21\u001b[0m     count \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m---> 23\u001b[0m     classifier_loss_epoch \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[43mtrain_c\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     24\u001b[0m     generator_loss_epoch \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m train_g(\u001b[38;5;28mlen\u001b[39m(x))\n\u001b[0;32m     28\u001b[0m val_loss \u001b[38;5;241m=\u001b[39m validate(classifier, loss_function, mnist_val_dataloader, use_gpu)\n",
      "Cell \u001b[1;32mIn[9], line 32\u001b[0m, in \u001b[0;36mtrain_c\u001b[1;34m(x)\u001b[0m\n\u001b[0;32m     30\u001b[0m \u001b[38;5;66;03m#預測真假資料的分數\u001b[39;00m\n\u001b[0;32m     31\u001b[0m real_predict \u001b[38;5;241m=\u001b[39m classifier(x)\n\u001b[1;32m---> 32\u001b[0m fake_predict \u001b[38;5;241m=\u001b[39m \u001b[43mclassifier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfake_mnist\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     34\u001b[0m \u001b[38;5;66;03m#classifier_loss計算+反向傳播\u001b[39;00m\n\u001b[0;32m     35\u001b[0m c_loss \u001b[38;5;241m=\u001b[39m classifer_loss_function(real_predict, fake_predict, ones_label, zeros_label)\n",
      "File \u001b[1;32mc:\\Users\\weiso131\\anaconda3\\envs\\AI\\lib\\site-packages\\torch\\nn\\modules\\module.py:1501\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1496\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1497\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1499\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1500\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1501\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1502\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[0;32m   1503\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "Cell \u001b[1;32mIn[4], line 15\u001b[0m, in \u001b[0;36mClassifier.forward\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[0;32m     14\u001b[0m     x \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mview(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m784\u001b[39m)\n\u001b[1;32m---> 15\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\weiso131\\anaconda3\\envs\\AI\\lib\\site-packages\\torch\\nn\\modules\\module.py:1501\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1496\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1497\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1499\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1500\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1501\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1502\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[0;32m   1503\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "File \u001b[1;32mc:\\Users\\weiso131\\anaconda3\\envs\\AI\\lib\\site-packages\\torch\\nn\\modules\\container.py:217\u001b[0m, in \u001b[0;36mSequential.forward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m    215\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[0;32m    216\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[1;32m--> 217\u001b[0m         \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m    218\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n",
      "File \u001b[1;32mc:\\Users\\weiso131\\anaconda3\\envs\\AI\\lib\\site-packages\\torch\\nn\\modules\\module.py:1501\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1496\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1497\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1499\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1500\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1501\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m forward_call(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m   1502\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[0;32m   1503\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
      "File \u001b[1;32mc:\\Users\\weiso131\\anaconda3\\envs\\AI\\lib\\site-packages\\torch\\nn\\modules\\linear.py:114\u001b[0m, in \u001b[0;36mLinear.forward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m    113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[1;32m--> 114\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# classifier_loss = [1]\n",
    "# generator_loss = [0]\n",
    "\n",
    "min_val_loss = 1e9\n",
    "max_val_acc = 0\n",
    "\n",
    "\n",
    "\n",
    "mnist_classifer.eval()\n",
    "for i in range(epoch):\n",
    "    print(f\"epoch: {i + 1}/{epoch}:\")\n",
    "    \n",
    "    classifier_loss_epoch = 0\n",
    "    generator_loss_epoch = 0\n",
    "    \n",
    "    \n",
    "    count = 0\n",
    "    \n",
    "    for x, y in mnist_train_dataloader:\n",
    "        \n",
    "        count += 1\n",
    "\n",
    "        classifier_loss_epoch += train_c(x)\n",
    "        generator_loss_epoch += train_g(len(x))\n",
    "\n",
    "\n",
    "    \n",
    "    val_loss = validate(classifier, loss_function, mnist_val_dataloader, use_gpu)\n",
    "\n",
    "    print(f\"classifier train loss: {classifier_loss_epoch / count}, val loss: {val_loss} |  generator loss: {generator_loss_epoch / count}\")\n",
    "    \n",
    "\n",
    "    #把最好的辨識器保存\n",
    "    if (val_loss < min_val_loss):\n",
    "        min_val_loss = val_loss\n",
    "        checkpoint = classifier.state_dict()\n",
    "        torch.save(checkpoint, \"classifier_checkpoint.pth\")\n",
    "        print(\"save model\")\n",
    "    #辨識器壞了，拿最好的重新開始\n",
    "    elif (abs(val_loss - min_val_loss) > 1):\n",
    "        checkpoints = torch.load(\"classifier_checkpoint.pth\")\n",
    "        classifier.load_state_dict(checkpoint)\n",
    "        print(\"redo model\")\n",
    "    \n",
    "\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "    if (i % 100 == 0):\n",
    "        if (use_gpu): generator = generator.to(device=\"cpu\", dtype=torch.float32)\n",
    "        fake_images = generator.generate_image(num=10).squeeze()\n",
    "        fake_images = torch.tensor(fake_images)\n",
    "        topk, top_class = mnist_classifer(torch.tensor(fake_images)).topk(1, dim=1)\n",
    "\n",
    "        fig, axs = plt.subplots(2, 5, figsize=(20, 8))  # 創建一個2x5的子圖網路\n",
    "        \n",
    "        for i, ax in enumerate(axs.flat):\n",
    "            \n",
    "            ax.imshow(fake_images[i], cmap='gray')  # 顯示圖片\n",
    "            ax.set_title(f\"It looks like \\\"{int(top_class[i])}\\\".\")\n",
    "            ax.axis('off')  # 關閉坐標軸\n",
    "           \n",
    "\n",
    "        plt.show()\n",
    "        if (use_gpu): generator = generator.to(device=\"cuda\", dtype=torch.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "AI",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}