{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Autoencoder MNIST" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Importing required packages" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np \n", "import matplotlib.pyplot as plt \n", "import torch \n", "import torch.nn as nn \n", "import torch.nn.functional as F\n", "from torch.utils.data import DataLoader, SubsetRandomSampler\n", "import torch.optim\n", "from torchvision import datasets,transforms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining transforms" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "transforms=transforms.ToTensor()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Downloading requried data" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "train_data=datasets.MNIST('data',train=True,download=True,transform=transforms)\n", "test_data=datasets.MNIST('data',train=False,download=True,transform=transforms)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining dataloaders" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "tags": [] }, "outputs": [], "source": [ "valid_size=0.2\n", "\n", "# IMPORTANT \n", "batch_size=20\n", "\n", "num_workers=0\n", "\n", "train_length = len(train_data)\n", "\n", "# obtain training dataset indices that will be used for validation dataset\n", "indices = list(range(train_length))\n", "\n", "np.random.shuffle(indices)\n", "split = int(np.floor(valid_size * train_length))\n", "train_idx, valid_idx = indices[split:], indices[:split]\n", "\n", "# define samplers for obtaining training and validation batches\n", "train_sampler = SubsetRandomSampler(train_idx)\n", "valid_sampler = SubsetRandomSampler(valid_idx)\n", "\n", "# prepare data loaders for train, test and validation dataset\n", "train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size,\n", " sampler=train_sampler, num_workers=num_workers)\n", "valid_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, \n", " sampler=valid_sampler, num_workers=num_workers)\n", "test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, \n", " num_workers=num_workers)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2400, 600, 500)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "# Printing the length of our train, valid and test dataloaders\n", "# NOTE : Here batch size is 20\n", "len(train_loader),len(valid_loader),len(test_loader)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([[[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]],\n", "\n", "\n", " [[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]],\n", "\n", "\n", " [[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]],\n", "\n", "\n", " ...,\n", "\n", "\n", " [[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]],\n", "\n", "\n", " [[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]],\n", "\n", "\n", " [[[0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " ...,\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.],\n", " [0., 0., 0., ..., 0., 0., 0.]]]]) torch.Size([20, 1, 28, 28]) 20 torch.Size([1, 28, 28])\n", "\n", "tensor([0, 9, 7, 3, 4, 7, 0, 1, 2, 9, 7, 3, 9, 5, 4, 3, 3, 3, 3, 2]) torch.Size([20]) 20\n" ] } ], "source": [ "# checking our data\n", "dataiter=iter(train_loader)\n", "images,labels=dataiter.next()\n", "print(images, images.shape, len(images), images[0].shape)\n", "print()\n", "print(labels,labels.shape,len(labels))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualizing a Training batch" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Displaying images and labels of a batch\n", "fig=plt.figure(figsize=(30,10))\n", "for i in range(len(labels)):\n", " ax=fig.add_subplot(2,10,i+1,xticks=[],yticks=[])\n", " plt.imshow(np.squeeze(images[i]))\n", " ax.set_title(labels[i].item(),color='blue')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining Architecture" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "class F_Auto_MNIST(nn.Module):\n", " def __init__(self,en_dim):\n", " super(F_Auto_MNIST,self).__init__()\n", " self.encoder=nn.Linear(784,en_dim)\n", " self.decoder=nn.Linear(en_dim,784)\n", " \n", " def forward(self,x):\n", " x=F.relu(self.encoder(x))\n", " x=F.sigmoid(self.decoder(x))\n", " return x\n", "\n", "class Tran_conv_Auto_MNIST(nn.Module):\n", " def __init__(self):\n", " super(Tran_conv_Auto_MNIST,self).__init__()\n", " self.en_conv1=nn.Conv2d(1,16,3,padding=1)\n", " self.en_conv2=nn.Conv2d(16,4,3,padding=1)\n", " self.pool=nn.MaxPool2d(2,2)\n", "\n", " self.de_conv1=nn.ConvTranspose2d(4,16,2,stride=2)\n", " self.de_conv2=nn.ConvTranspose2d(16,1,2,stride=2)\n", "\n", " def forward(self,x):\n", " x=self.pool(F.relu(self.en_conv1(x)))\n", " x=self.pool(F.relu(self.en_conv2(x)))\n", " x=F.relu(self.de_conv1(x))\n", " x=F.sigmoid(self.de_conv2(x))\n", " return x\n", "\n", "class upsamp_conv_Auto_MNIST(nn.Module):\n", " def __init__(self):\n", " super(upsamp_conv_Auto_MNIST,self).__init__()\n", " self.en_conv1=nn.Conv2d(1,16,3,padding=1)\n", " self.en_conv2=nn.Conv2d(16,4,3,padding=1)\n", " self.pool=nn.MaxPool2d(2,2)\n", "\n", " self.de_conv1=nn.Conv2d(4,16,3,padding=1)\n", " self.de_conv2=nn.Conv2d(16,1,3,padding=1)\n", "\n", " def forward(self,x):\n", " x=self.pool(F.relu(self.en_conv1(x)))\n", " x=self.pool(F.relu(self.en_conv2(x)))\n", " x = F.upsample(x, scale_factor=2, mode='nearest')\n", " x=F.relu(self.de_conv1(x))\n", " x = F.upsample(x, scale_factor=2, mode='nearest')\n", " x=F.sigmoid(self.de_conv2(x))\n", " return x\n", "\n", "#Since the images are normalized between 0 and 1, we need to use a sigmoid activation on the output layer to get values that match this input value range." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "F_Auto_MNIST(\n", " (encoder): Linear(in_features=784, out_features=32, bias=True)\n", " (decoder): Linear(in_features=32, out_features=784, bias=True)\n", ") \n", "\n", "\n", "\n", " Tran_conv_Auto_MNIST(\n", " (en_conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (en_conv2): Conv2d(16, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (de_conv1): ConvTranspose2d(4, 16, kernel_size=(2, 2), stride=(2, 2))\n", " (de_conv2): ConvTranspose2d(16, 1, kernel_size=(2, 2), stride=(2, 2))\n", ") \n", "\n", "\n", "\n", " upsamp_conv_Auto_MNIST(\n", " (en_conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (en_conv2): Conv2d(16, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (de_conv1): Conv2d(4, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (de_conv2): Conv2d(16, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", ") \n", "\n", "\n", "\n", " On GPU : True\n" ] } ], "source": [ "model_1=F_Auto_MNIST(32)\n", "model_2=Tran_conv_Auto_MNIST()\n", "model_3=upsamp_conv_Auto_MNIST()\n", "\n", "def weight_init_normal(m):\n", " classname=m.__class__.__name__\n", " if classname.find('Linear')!=-1:\n", " n = m.in_features\n", " y = (1.0/np.sqrt(n))\n", " m.weight.data.normal_(0, y)\n", " m.bias.data.fill_(0)\n", "\n", "model_1.apply(weight_init_normal)\n", "\n", "use_cuda=True\n", "if use_cuda and torch.cuda.is_available():\n", " model_1.cuda()\n", " model_2.cuda()\n", " model_3.cuda()\n", "print(model_1,'\\n\\n\\n\\n',model_2,'\\n\\n\\n\\n',model_3,'\\n\\n\\n\\n','On GPU : ',torch.cuda.is_available())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining our Loss Function" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Used when comapring pixel values.\n", "criterion=nn.MSELoss()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Training and Validation Phase" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def trainNet(model,lr,state='fully'):\n", " optimizer=torch.optim.Adam(model.parameters(),lr=lr)\n", "\n", " # Number of epochs to train for\n", " loss_keeper={'train':[],'valid':[]}\n", " epochs=20\n", "\n", " # minimum validation loss ----- set initial minimum to infinity\n", " valid_loss_min = np.Inf \n", "\n", " for epoch in range(epochs):\n", " train_loss=0.0\n", " valid_loss=0.0\n", "\n", " \"\"\"\n", " TRAINING PHASE\n", " \"\"\"\n", " model.train() # TURN ON DROPOUT for training\n", " for images,_ in train_loader:\n", " if use_cuda and torch.cuda.is_available():\n", " images=images.cuda()\n", " if state=='fully':\n", " images=images.view(images.size(0),-1)\n", " optimizer.zero_grad()\n", " output=model(images)\n", " loss=criterion(output,images)\n", " loss.backward()\n", " optimizer.step()\n", " train_loss+=loss.item()\n", "\n", " \"\"\"\n", " VALIDATION PHASE\n", " \"\"\"\n", " model.eval() # TURN OFF DROPOUT for validation\n", " for images,_ in valid_loader:\n", " if use_cuda and torch.cuda.is_available():\n", " images=images.cuda()\n", " if state=='fully':\n", " images=images.view(images.size(0),-1)\n", " output=model(images)\n", " loss=criterion(output,images)\n", " valid_loss+=loss.item()\n", "\n", " # Calculating loss over entire batch size for every epoch\n", " train_loss = train_loss/len(train_loader)\n", " valid_loss = valid_loss/len(valid_loader)\n", "\n", "\n", " # saving loss values\n", " loss_keeper['train'].append(train_loss)\n", " loss_keeper['valid'].append(valid_loss)\n", "\n", " print(f\"\\nEpoch : {epoch+1}\\tTraining Loss : {train_loss}\\tValidation Loss : {valid_loss}\")\n", " if valid_loss<=valid_loss_min:\n", " print(f\"Validation loss decreased from : {valid_loss_min} ----> {valid_loss} ----> Saving Model.......\")\n", " z=type(model).__name__\n", " torch.save(model.state_dict(), z+'_model.pth')\n", " valid_loss_min=valid_loss\n", " return(loss_keeper)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.8/site-packages/torch/nn/functional.py:1791: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n", " warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Epoch : 1\tTraining Loss : 0.02896550076858451\tValidation Loss : 0.02558390931536754\n", "Validation loss decreased from : inf ----> 0.02558390931536754 ----> Saving Model.......\n", "\n", "Epoch : 2\tTraining Loss : 0.025176408106150728\tValidation Loss : 0.02528782489709556\n", "Validation loss decreased from : 0.02558390931536754 ----> 0.02528782489709556 ----> Saving Model.......\n", "\n", "Epoch : 3\tTraining Loss : 0.024819760410270342\tValidation Loss : 0.025184290970986088\n", "Validation loss decreased from : 0.02528782489709556 ----> 0.025184290970986088 ----> Saving Model.......\n", "\n", "Epoch : 4\tTraining Loss : 0.024684938127951077\tValidation Loss : 0.024978625137979785\n", "Validation loss decreased from : 0.025184290970986088 ----> 0.024978625137979785 ----> Saving Model.......\n", "\n", "Epoch : 5\tTraining Loss : 0.02461117018557464\tValidation Loss : 0.024704792660971482\n", "Validation loss decreased from : 0.024978625137979785 ----> 0.024704792660971482 ----> Saving Model.......\n", "\n", "Epoch : 6\tTraining Loss : 0.02453265693426753\tValidation Loss : 0.024526091638642052\n", "Validation loss decreased from : 0.024704792660971482 ----> 0.024526091638642052 ----> Saving Model.......\n", "\n", "Epoch : 7\tTraining Loss : 0.02452039873227477\tValidation Loss : 0.025005564683427413\n", "\n", "Epoch : 8\tTraining Loss : 0.024493249881391725\tValidation Loss : 0.024609612664207817\n", "\n", "Epoch : 9\tTraining Loss : 0.02441008546234419\tValidation Loss : 0.02443290878397723\n", "Validation loss decreased from : 0.024526091638642052 ----> 0.02443290878397723 ----> Saving Model.......\n", "\n", "Epoch : 10\tTraining Loss : 0.024413449682760983\tValidation Loss : 0.02457001187838614\n", "\n", "Epoch : 11\tTraining Loss : 0.024409184464408706\tValidation Loss : 0.02450792974171539\n", "\n", "Epoch : 12\tTraining Loss : 0.024386933309336504\tValidation Loss : 0.02464316023203234\n", "\n", "Epoch : 13\tTraining Loss : 0.024386077628781398\tValidation Loss : 0.025601022808502117\n", "\n", "Epoch : 14\tTraining Loss : 0.024367613326758145\tValidation Loss : 0.024593018628656864\n", "\n", "Epoch : 15\tTraining Loss : 0.024350769221782684\tValidation Loss : 0.025083829602226614\n", "\n", "Epoch : 16\tTraining Loss : 0.024340832543093712\tValidation Loss : 0.024487837087363004\n", "\n", "Epoch : 17\tTraining Loss : 0.02432938082842156\tValidation Loss : 0.024501989167183637\n", "\n", "Epoch : 18\tTraining Loss : 0.02432120726676658\tValidation Loss : 0.02441405748948455\n", "Validation loss decreased from : 0.02443290878397723 ----> 0.02441405748948455 ----> Saving Model.......\n", "\n", "Epoch : 19\tTraining Loss : 0.024334008230362088\tValidation Loss : 0.024071271003534397\n", "Validation loss decreased from : 0.02441405748948455 ----> 0.024071271003534397 ----> Saving Model.......\n", "\n", "Epoch : 20\tTraining Loss : 0.024329502811500182\tValidation Loss : 0.02478131710551679\n" ] } ], "source": [ "m1_loss=trainNet(model_1,0.01)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Epoch : 1\tTraining Loss : 0.03177310996611292\tValidation Loss : 0.02294422238133848\n", "Validation loss decreased from : inf ----> 0.02294422238133848 ----> Saving Model.......\n", "\n", "Epoch : 2\tTraining Loss : 0.022251348613838977\tValidation Loss : 0.021716179943953952\n", "Validation loss decreased from : 0.02294422238133848 ----> 0.021716179943953952 ----> Saving Model.......\n", "\n", "Epoch : 3\tTraining Loss : 0.021415203340584412\tValidation Loss : 0.021288092794517675\n", "Validation loss decreased from : 0.021716179943953952 ----> 0.021288092794517675 ----> Saving Model.......\n", "\n", "Epoch : 4\tTraining Loss : 0.02102814870653674\tValidation Loss : 0.020969783617183567\n", "Validation loss decreased from : 0.021288092794517675 ----> 0.020969783617183567 ----> Saving Model.......\n", "\n", "Epoch : 5\tTraining Loss : 0.020830238189082594\tValidation Loss : 0.020881876127483944\n", "Validation loss decreased from : 0.020969783617183567 ----> 0.020881876127483944 ----> Saving Model.......\n", "\n", "Epoch : 6\tTraining Loss : 0.02071243806509301\tValidation Loss : 0.021263521847625574\n", "\n", "Epoch : 7\tTraining Loss : 0.020601106696994977\tValidation Loss : 0.020638965046964587\n", "Validation loss decreased from : 0.020881876127483944 ----> 0.020638965046964587 ----> Saving Model.......\n", "\n", "Epoch : 8\tTraining Loss : 0.020529524291632698\tValidation Loss : 0.02063611346296966\n", "Validation loss decreased from : 0.020638965046964587 ----> 0.02063611346296966 ----> Saving Model.......\n", "\n", "Epoch : 9\tTraining Loss : 0.02048876623545463\tValidation Loss : 0.020422629211097956\n", "Validation loss decreased from : 0.02063611346296966 ----> 0.020422629211097956 ----> Saving Model.......\n", "\n", "Epoch : 10\tTraining Loss : 0.020451771730246645\tValidation Loss : 0.02051652069669217\n", "\n", "Epoch : 11\tTraining Loss : 0.02042667766334489\tValidation Loss : 0.02041566351428628\n", "Validation loss decreased from : 0.020422629211097956 ----> 0.02041566351428628 ----> Saving Model.......\n", "\n", "Epoch : 12\tTraining Loss : 0.02040461980116864\tValidation Loss : 0.020760528462318083\n", "\n", "Epoch : 13\tTraining Loss : 0.02038108475971967\tValidation Loss : 0.021521709747612475\n", "\n", "Epoch : 14\tTraining Loss : 0.0203536097984761\tValidation Loss : 0.020373039105907084\n", "Validation loss decreased from : 0.02041566351428628 ----> 0.020373039105907084 ----> Saving Model.......\n", "\n", "Epoch : 15\tTraining Loss : 0.02029531226687444\tValidation Loss : 0.020294588779409727\n", "Validation loss decreased from : 0.020373039105907084 ----> 0.020294588779409727 ----> Saving Model.......\n", "\n", "Epoch : 16\tTraining Loss : 0.02024639687423284\tValidation Loss : 0.02036019109499951\n", "\n", "Epoch : 17\tTraining Loss : 0.02022059344492542\tValidation Loss : 0.02101065499863277\n", "\n", "Epoch : 18\tTraining Loss : 0.020201791205521052\tValidation Loss : 0.020049034748226405\n", "Validation loss decreased from : 0.020294588779409727 ----> 0.020049034748226405 ----> Saving Model.......\n", "\n", "Epoch : 19\tTraining Loss : 0.020169476004472622\tValidation Loss : 0.020887272069230675\n", "\n", "Epoch : 20\tTraining Loss : 0.020138987054039412\tValidation Loss : 0.0201443353202194\n" ] } ], "source": [ "m2_loss=trainNet(model_2,0.01,'conv')" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.8/site-packages/torch/nn/functional.py:3437: UserWarning: nn.functional.upsample is deprecated. Use nn.functional.interpolate instead.\n", " warnings.warn(\"nn.functional.upsample is deprecated. Use nn.functional.interpolate instead.\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Epoch : 1\tTraining Loss : 0.1121672908992817\tValidation Loss : 0.11204921410729488\n", "Validation loss decreased from : inf ----> 0.11204921410729488 ----> Saving Model.......\n", "\n", "Epoch : 2\tTraining Loss : 0.11199091531336308\tValidation Loss : 0.11204921394586563\n", "Validation loss decreased from : 0.11204921410729488 ----> 0.11204921394586563 ----> Saving Model.......\n", "\n", "Epoch : 3\tTraining Loss : 0.11199091541891297\tValidation Loss : 0.1120492144053181\n", "\n", "Epoch : 4\tTraining Loss : 0.11199091523885726\tValidation Loss : 0.112049213933448\n", "Validation loss decreased from : 0.11204921394586563 ----> 0.112049213933448 ----> Saving Model.......\n", "\n", "Epoch : 5\tTraining Loss : 0.11199091527611017\tValidation Loss : 0.1120492139707009\n", "\n", "Epoch : 6\tTraining Loss : 0.11199091535372038\tValidation Loss : 0.11204921375960111\n", "Validation loss decreased from : 0.112049213933448 ----> 0.11204921375960111 ----> Saving Model.......\n", "\n", "Epoch : 7\tTraining Loss : 0.11199091545616587\tValidation Loss : 0.11204921414454778\n", "\n", "Epoch : 8\tTraining Loss : 0.1119909154654791\tValidation Loss : 0.11204921407004198\n", "\n", "Epoch : 9\tTraining Loss : 0.11199091540028651\tValidation Loss : 0.11204921378443639\n", "\n", "Epoch : 10\tTraining Loss : 0.1119909155368805\tValidation Loss : 0.11204921374718348\n", "Validation loss decreased from : 0.11204921375960111 ----> 0.11204921374718348 ----> Saving Model.......\n", "\n", "Epoch : 11\tTraining Loss : 0.11199091542201738\tValidation Loss : 0.11204921416938304\n", "\n", "Epoch : 12\tTraining Loss : 0.11199091530404985\tValidation Loss : 0.11204921402037143\n", "\n", "Epoch : 13\tTraining Loss : 0.11199091540339093\tValidation Loss : 0.11204921420663595\n", "\n", "Epoch : 14\tTraining Loss : 0.11199091546237469\tValidation Loss : 0.1120492138216893\n", "\n", "Epoch : 15\tTraining Loss : 0.11199091541891297\tValidation Loss : 0.11204921410729488\n", "\n", "Epoch : 16\tTraining Loss : 0.11199091549652318\tValidation Loss : 0.11204921410729488\n", "\n", "Epoch : 17\tTraining Loss : 0.11199091548410554\tValidation Loss : 0.1120492142935594\n", "\n", "Epoch : 18\tTraining Loss : 0.11199091542201738\tValidation Loss : 0.11204921446740627\n", "\n", "Epoch : 19\tTraining Loss : 0.11199091549341877\tValidation Loss : 0.1120492140079538\n", "\n", "Epoch : 20\tTraining Loss : 0.11199091544995705\tValidation Loss : 0.11204921392103036\n" ] } ], "source": [ "m3_loss=trainNet(model_3,0.01,'conv')" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model_1.load_state_dict(torch.load('F_Auto_MNIST_model.pth'))\n", "model_2.load_state_dict(torch.load('Tran_conv_Auto_MNIST_model.pth'))\n", "model_3.load_state_dict(torch.load('upsamp_conv_Auto_MNIST_model.pth'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting Loss" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "title=['FFNN','Transpose CNN','Upsampled CNN']\n", "model_losses=[m1_loss,m2_loss,m3_loss]\n", "\n", "fig=plt.figure(1,figsize=(25,5))\n", "idx=1\n", "for i in model_losses:\n", " ax=fig.add_subplot(1,3,idx)\n", " ax.plot(i['train'],label=\"Training Loss\")\n", " ax.plot(i['valid'],label=\"Validation Loss\")\n", " ax.set_title('MNIST Autoencoder: '+title[idx-1])\n", " idx+=1\n", " plt.legend();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Testing Phase" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# 예제로 MSE를 사용하여 유사성을 계산하는 함수\n", "def calculate_similarity(img1, img2):\n", " criterion = torch.nn.MSELoss()\n", " loss = criterion(img1, img2)\n", " return -loss.item() # Negative loss because higher similarity corresponds to lower loss\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def test(model,state='fully'):\n", " # obtain one batch of test images\n", " dataiter = iter(test_loader)\n", " images, _ = dataiter.next()\n", " if use_cuda and torch.cuda.is_available():\n", " images=images.cuda()\n", " if state=='fully':\n", " images = images.view(images.size(0), -1)\n", "\n", " # 전처리된 이미지를 모델에 전달하여 재구성 이미지 생성\n", " with torch.no_grad():\n", " output = model(images)\n", "\n", " # 유사도 측정 (예: MSE를 사용하여 유사성 계산)\n", " similarity_scores = []\n", " for reconstructed_img in output:\n", " reconstructed_img = torch.unsqueeze(torch.from_numpy(reconstructed_img), dim=0) # NumPy 배열을 PyTorch 텐서로 변환하여 unsqueeze 사용\n", " font_img_tensor = torch.unsqueeze(torch.from_numpy(images), dim=0) # NumPy 배열을 PyTorch 텐서로 변환하여 unsqueeze 사용\n", " similarity_score = calculate_similarity(reconstructed_img, font_img_tensor) # calculate_similarity 함수는 유사도를 측정하는 함수\n", " similarity_scores.append(similarity_score)\n", "\n", "\n", " # 시각화\n", " fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(25,4))\n", "\n", " # input images on top row, reconstructions on bottom\n", " for images, row in zip([images, output], axes):\n", " for img, ax in zip(images, row):\n", " if state=='fully':\n", " img = img.view(1, 28, 28)\n", " ax.imshow(np.squeeze(img.cpu().numpy()), cmap='gray')\n", " ax.get_xaxis().set_visible(False)\n", " ax.get_yaxis().set_visible(False)\n", "\n", " plt.show()\n", "\n", " return similarity_scores" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## FFNN Autoencoder" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\r\n", "\r\n", "\r\n", "\r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", "\r\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "test(model_1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Transpose CNN Autoencoder" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "test(model_2,'conv')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Upsampled CNN Autoencoder" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "test(model_3,'conv')" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "expected np.ndarray (got Tensor)", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m# 모델 테스트 및 유사도 측정\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0msimilarity_scores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel_2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'conv'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Similarity Scores:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msimilarity_scores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m\u001b[0m in \u001b[0;36mtest\u001b[0;34m(model, state)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0msimilarity_scores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mreconstructed_img\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mreconstructed_img\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_numpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreconstructed_img\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# NumPy 배열을 PyTorch 텐서로 변환하여 unsqueeze 사용\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 18\u001b[0m \u001b[0mfont_img_tensor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_numpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# NumPy 배열을 PyTorch 텐서로 변환하여 unsqueeze 사용\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0msimilarity_score\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcalculate_similarity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreconstructed_img\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfont_img_tensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# calculate_similarity 함수는 유사도를 측정하는 함수\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: expected np.ndarray (got Tensor)" ] } ], "source": [ "font_img = np.random.rand(28, 28) # 예시로 랜덤한 이미지 생성\n", "font_img = (font_img * 255).astype(np.uint8)\n", "\n", "# 모델 생성 예시\n", "# model = your_model_here\n", "\n", "# 모델 테스트 및 유사도 측정\n", "similarity_scores = test(model_2, 'conv')\n", "print(\"Similarity Scores:\", similarity_scores)" ] } ], "metadata": { "kernelspec": { "display_name": "base", "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.8.8" }, "orig_nbformat": 2 }, "nbformat": 4, "nbformat_minor": 2 }