mlp_mixer_cifar10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with mlp mixer, you need to clone my repository, all packeges I wrote in there"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can easily run the ipynb via https://www.kaggle.com/oguzhanercan/mlp-mixer-cifar10-classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !git clone https://github.com/Oguzhanercan/MLP-Mixer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Libraries and packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import einops\n",
    "import os \n",
    "import pandas as pd\n",
    "import cv2\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "from tqdm import tqdm\n",
    "from __future__ import print_function\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_path= \"model.pt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below I import my mlp mixer implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlp_mixer import mlp_mixer as mm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are dealing with multi-class image classification, so we use Cross Entropy Loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MLP-Mixer paper suggest the patch size as 16. But we are dealing with 32x32 images. So if we use patch size as 16, there will be 4 patches. In this case the attention queries will be to small, the most important parameter for this model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model(patch_size):\n",
    " return  mm.Mixer(\n",
    "        num_classes= 10,\n",
    "        img_size= 32,\n",
    "        patch_size=patch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "initialization of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_params(path):\n",
    "    model.load_state_dict(torch.load(path,map_location=dvc))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating selected optimizer, I offer 2 different optimizers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_optimizer(optimizer_name,lr):\n",
    "    if optimizer_name == \"Adam\":\n",
    "        return torch.optim.Adam(model.parameters(),lr = lr,betas = (0.9,0.999),weight_decay=0.3)\n",
    "    else:\n",
    "        return torch.optim.SGD(model.parameters(),lr = lr)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train validation and test datasets will be created on the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data_loaders(valid_per,batch_size,num_workers):\n",
    "\n",
    "    transform = transforms.Compose([transforms.Pad(4),transforms.RandomHorizontalFlip(),transforms.RandomCrop(32),transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])\n",
    "    test_transform  = transforms.Compose([transforms.ToTensor(),transforms.Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))])\n",
    "    train_dataset = torchvision.datasets.CIFAR10(root='/home/computer/Desktop/mind/Machine_learning/MLP_Mixer', train=True,transform=transform, download=True)\n",
    "    test_dataset = torchvision.datasets.CIFAR10(root='/home/computer/Desktop/mind/Machine_learning/MLP_Mixer', train=False,transform=test_transform)\n",
    "\n",
    "    indices = torch.randperm(len(train_dataset))\n",
    "    split = int(np.floor((valid_per)*(len(train_dataset))))\n",
    "    t_idx, v_idx = indices[:split], indices[split:]\n",
    "    train_sampler = SubsetRandomSampler(v_idx)\n",
    "    val_sampler = SubsetRandomSampler(t_idx)\n",
    "\n",
    "    trainloader = torch.utils.data.DataLoader(\n",
    "                train_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, sampler=train_sampler)\n",
    "    validloader = torch.utils.data.DataLoader(\n",
    "                train_dataset, batch_size=batch_size, num_workers=num_workers, drop_last=True, sampler=val_sampler)\n",
    "    testloader = torch.utils.data.DataLoader(test_dataset,batch_size=batch_size,num_workers=num_workers,drop_last=True)\n",
    "\n",
    "    return trainloader,validloader,testloader\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below saves the state of losses of the training process "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_loss_state(loss_train,loss_valid,checkpoints):\n",
    "    train = open(\"train_loss_state.txt\",\"w\")\n",
    "    train.write(str(loss_train))\n",
    "    train.close()\n",
    "    valid = open(\"valid_loss_state.txt\",\"w\")\n",
    "    valid.write(str(loss_valid))\n",
    "    valid.close()\n",
    "    check = open(\"check_state.txt\",\"w\")\n",
    "    check.write(str(loss_train))\n",
    "    check.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The train function that optimizes the parameters of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train():\n",
    "    check_points = []\n",
    "    loss_train = []\n",
    "    loss_valid = []\n",
    "    valid_loss_min = np.Inf\n",
    "    \n",
    "    for i in tqdm(range(epoch_widget.value)):\n",
    "        print(\"Epoch - {} Started\".format(i+1))\n",
    "\n",
    "        train_loss = 0.0\n",
    "        valid_loss = 0.0\n",
    "\n",
    "        model.train()\n",
    "        for data, target in trainloader:\n",
    "            data, target = data.to(dvc), target.to(dvc)\n",
    "            optimizer.zero_grad()\n",
    "            output = model(data)\n",
    "            loss = criterion(output, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            train_loss += loss.item()*data.size(0)\n",
    "\n",
    "        model.eval()\n",
    "        for data, target in validloader:\n",
    "            data, target = data.to(dvc), target.to(dvc)\n",
    "            output = model(data)\n",
    "            loss = criterion(output, target)\n",
    "            valid_loss += loss.item()*data.size(0)\n",
    "\n",
    "        train_loss = train_loss/len(trainloader.sampler)\n",
    "        valid_loss = valid_loss/len(validloader.sampler)\n",
    "        loss_train.append(train_loss)\n",
    "        loss_valid.append(valid_loss)\n",
    "        print('Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}'.format(\n",
    "            i+1, train_loss, valid_loss))\n",
    "\n",
    "        if valid_loss <= valid_loss_min:\n",
    "            print('Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...'.format(\n",
    "                valid_loss_min,\n",
    "                valid_loss))\n",
    "            check_points.append(i)\n",
    "            torch.save(model.state_dict(), 'model.pt')\n",
    "            valid_loss_min = valid_loss\n",
    "    save_loss_state(loss_train,loss_valid,check_points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The test function that calculates the accuracy of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(loader):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        total = 0\n",
    "        correct =0\n",
    "        for images, labels in loader:\n",
    "            images = images.to(dvc)\n",
    "            labels = labels.to(dvc)\n",
    "            outputs = model(images)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "        print('Accuracy : {} %'.format(100 * correct / total))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The predict function that takes an image and returns the predicted class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(images):\n",
    "    with torch.no_grad():\n",
    "        images = images.to(device)\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        print(f\"prediction {predicted}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below extracts the number of samples that belongs to the each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_dist(dataset,num_class):\n",
    "    counter = np.ones(num_class)\n",
    "    for i in dataset:\n",
    "        counter[i[1]]+=1\n",
    "    return counter\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below visualizes a pie chart that contains informations about class distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_histogram(counter):\n",
    "    plt.title(\"Class Distribution\")\n",
    "    labels = np.arange(len(counter))\n",
    "    plt.pie(counter,labels = labels,wedgeprops={\"edgecolor\":\"black\"},shadow=True,autopct=\"%1.1f%%\")\n",
    "    plt.tight_layout()\n",
    "    plt.show( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below visualizes a line plot about the training loss and also visualizes a scatter&line plot mix that contains training loss, validation loss and checkpoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_analyze(train_loss,val_loss,check_points):\n",
    "    plt.style.use('seaborn')\n",
    "    lt = np.arange(len(train_loss))\n",
    "    ltc = []\n",
    "    for i in check_points:\n",
    "        ltc.append(val_loss[i])\n",
    "    fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1)\n",
    "\n",
    "    ax1.plot(lt, train_loss, color='#444444',\n",
    "            linestyle='--', label='Train Loss')\n",
    "\n",
    "\n",
    "    ax2.plot(lt, train_loss, label='Train Loss')\n",
    "    ax2.plot(lt, val_loss, label='Validation Loss')\n",
    "    ax2.scatter(check_points,ltc,label = \"Check Points\")\n",
    "    \n",
    "\n",
    "    ax1.legend()\n",
    "\n",
    "    ax1.set_title('Train Loss')\n",
    "    ax1.set_xlabel('Epochs')\n",
    "    ax1.set_ylabel('Loss')\n",
    "   \n",
    "    ax2.legend()\n",
    "\n",
    "    ax2.set_title('Train - Validation Loss with check points')\n",
    "    ax2.set_xlabel('Epochs')\n",
    "    ax2.set_ylabel('Loss')\n",
    "\n",
    "  \n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hyper parameter settings widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_widget = widgets.FloatSlider(\n",
    "    value=0.0003,\n",
    "    min=0,\n",
    "    max=0.2,\n",
    "    step=0.0001,\n",
    "    description='Learning Rate',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.4f',\n",
    ")\n",
    "bs_widget = widgets.IntSlider(\n",
    "    value=8,\n",
    "    min=1,\n",
    "    max=32,\n",
    "    step=1,\n",
    "    description='Batch Size',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.0f',\n",
    ")\n",
    "patch_s_widget = widgets.IntSlider(\n",
    "    value=8,\n",
    "    min=4,\n",
    "    max=32,\n",
    "    step=4,\n",
    "    description='Patch size of MLP-Mixer',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.0f',\n",
    ")\n",
    "valid_per_widget = widgets.FloatSlider(\n",
    "    value=0.2,\n",
    "    min=0.1,\n",
    "    max=0.9,\n",
    "    step=0.1,\n",
    "    description='% of Val',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "num_workers_widget = widgets.IntSlider(\n",
    "    value=1,\n",
    "    min=1,\n",
    "    max=5,\n",
    "    step=1,\n",
    "    description='Num Workers',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.0f',\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6b775ffd19e4460fada5fec0b9dee619",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='Set Hyper Parameters'), FloatSlider(value=0.2, continuous_update=False, descriptio…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "caption = widgets.Label(value='Set Hyper Parameters')\n",
    "widgets.VBox([caption,valid_per_widget, patch_s_widget,lr_widget,bs_widget,num_workers_widget])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_per,batch_size,num_workers,lr,patch_s = valid_per_widget.value,bs_widget.value,num_workers_widget.value,lr_widget.value,patch_s_widget.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below provides a widget to choose the device for computations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f391b1a2f4384e6dbb7c4393cbd3d430",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='device', options=('cuda', 'cpu'), value='cuda'), Output()), _dom_c…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(device):\n",
    "    global dvc\n",
    "    if device == \"cuda\" and torch.cuda.is_available(): \n",
    "        dvc = \"cuda\"\n",
    "        print(\"Device selected as cuda\")\n",
    "        return \"cuda\"\n",
    "    elif device == \"cuda\":\n",
    "        dvc = \"cpu\"\n",
    "        print(\"Device selected as cpu, cuda is not avaliable\")\n",
    "        return \"cpu\"\n",
    "    else:\n",
    "        dvc = \"cpu\"\n",
    "        print(\"Device selected as cpu\")\n",
    "        return \"cpu\"\n",
    "device_widget = interact(f, device=['cuda','cpu'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create and initiliaze the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = create_model(patch_s)\n",
    "init_params(param_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f3ea219358949c9a0e0cf9f10f80aa0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='Optimizer', options=('Adam', 'SGD'), value='Adam'), Output()), _do…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def op(Optimizer):\n",
    "    print(\"Optimizer selected as \"+Optimizer)\n",
    "    global optimizer \n",
    "    optimizer = create_optimizer(Optimizer,lr)\n",
    "    return Optimizer\n",
    "optimizer_widget = interact(op, Optimizer=['Adam','SGD']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The widget below lets the user to choose epoch number to train and validate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "34382051c53f44ba969657680a7a3698",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "IntSlider(value=1, continuous_update=False, description='Epoch number', min=1, readout_format='.0f')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epoch_widget = widgets.IntSlider(\n",
    "    value=1,\n",
    "    min=1,\n",
    "    max=100,\n",
    "    step=1,\n",
    "    description='Epoch number',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.0f',\n",
    ")\n",
    "epoch_widget"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the dataloaders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "trainloader, validloader, testloader = create_data_loaders(valid_per,batch_size,num_workers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below provides a widget to choose a dataset for the purpose of calculating accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b6d3a5983bcb4477892915e6ffd733d2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='dataset', options=('test', 'validation', 'train'), value='test'), …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def op(dataset):\n",
    "    global data2test\n",
    "    \n",
    "    if(dataset == \"train\"):\n",
    "        data2test = trainloader\n",
    "        print(\"Dataset selected as \")\n",
    "        return dataset\n",
    "    elif(dataset == \"validation\"):\n",
    "        data2test = validloader\n",
    "        print(\"Dataset selected as \")\n",
    "        return dataset\n",
    "    else:\n",
    "        data2test = testloader\n",
    "        print(\"Dataset selected as \")\n",
    "        return dataset\n",
    "test_widget = interact(op, dataset=['test','validation','train']);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 71.0 %\n"
     ]
    }
   ],
   "source": [
    "test(data2test) # Test Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LOSS, Train Validation Trade-off, Checkpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f605adf90a0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = Image.open(\"fig.png\") # the result of loss_analyze function\n",
    "plt.figure(figsize=(20,10))\n",
    "plt.imshow(img)\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d5685fc1ae7990eecb1e764b7accbf55b66ada28e6d2f75bd22a6963da0cb178"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 64-bit ('base': conda)",
   "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": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}