Task4.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Pogozhelskaya/MachineLearningCourse/blob/main/Task4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "hrqa5iMzN70c"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "ppJhu9xMVflg"
      },
      "outputs": [],
      "source": [
        "# Device configuration\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZmL_14U8PD5Y",
        "outputId": "ddce6ef0-480c-42d9-a156-cb81430fd233"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        }
      ],
      "source": [
        "train_transform = transforms.Compose(\n",
        "    [transforms.RandomHorizontalFlip(),\n",
        "     transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
        ")\n",
        "\n",
        "test_transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
        ")\n",
        "\n",
        "# CIFAR-10 dataset\n",
        "train_set = torchvision.datasets.CIFAR10(root='./data',\n",
        "                                        train=True,\n",
        "                                        download=True,\n",
        "                                        transform=train_transform)\n",
        "\n",
        "test_set = torchvision.datasets.CIFAR10(root='./data',\n",
        "                                       train=False,\n",
        "                                       download=True,\n",
        "                                       transform=test_transform)\n",
        "\n",
        "# Data test loader\n",
        "train_loader = torch.utils.data.DataLoader(train_set, batch_size=4,\n",
        "                                          shuffle=True, num_workers=8)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(test_set, batch_size=4,\n",
        "                                         shuffle=False, num_workers=8)\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat', 'deer',\n",
        "           'dog', 'frog', 'horse', 'ship', 'truck')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "itL5xioGQkwC",
        "outputId": "6357beda-04e9-4245-a8ab-b2ef3ac5f7e3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Model(\n",
              "  (conv_layer): Sequential(\n",
              "    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (2): ReLU(inplace=True)\n",
              "    (3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (4): ReLU(inplace=True)\n",
              "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "    (6): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (8): ReLU(inplace=True)\n",
              "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "    (11): ReLU(inplace=True)\n",
              "    (12): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "  )\n",
              "  (fc_layer): Sequential(\n",
              "    (0): Dropout(p=0.1, inplace=False)\n",
              "    (1): Linear(in_features=4096, out_features=1024, bias=True)\n",
              "    (2): ReLU(inplace=True)\n",
              "    (3): Linear(in_features=1024, out_features=512, bias=True)\n",
              "    (4): ReLU(inplace=True)\n",
              "    (5): Dropout(p=0.1, inplace=False)\n",
              "    (6): Linear(in_features=512, out_features=10, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "class Model(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "        self.conv_layer = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(32),\n",
        "            nn.ReLU(inplace=True),\n",
        "            # nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1),\n",
        "            # nn.BatchNorm2d(64),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1),\n",
        "            nn.BatchNorm2d(128),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "\n",
        "            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1),\n",
        "            # nn.BatchNorm2d(256),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "        )\n",
        "\n",
        "        self.fc_layer = nn.Sequential(\n",
        "            nn.Dropout(p=0.1),\n",
        "            \n",
        "            nn.Linear(4096, 1024),\n",
        "            nn.ReLU(inplace=True),\n",
        "\n",
        "            nn.Linear(1024, 512),\n",
        "            nn.ReLU(inplace=True),\n",
        "\n",
        "            nn.Dropout(p=0.1),\n",
        "\n",
        "            nn.Linear(512, 10),\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv_layer(x)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = self.fc_layer(x)\n",
        "        return x\n",
        "\n",
        "model = Model()\n",
        "model.to(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "zmQS2SQhT7Gf"
      },
      "outputs": [],
      "source": [
        "# Loss and optimizer\n",
        "\n",
        "loss_function = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(), lr=0.001)\n",
        "# optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.0005)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zNon0m5cUELl",
        "outputId": "199e1171-ad2b-4a02-bc4b-c1125b6f9a76"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,  2000] loss: 2.195\n",
            "[1,  4000] loss: 1.827\n",
            "[1,  6000] loss: 1.669\n",
            "[1,  8000] loss: 1.555\n",
            "[1, 10000] loss: 1.496\n",
            "[1, 12000] loss: 1.423\n",
            "[2,  2000] loss: 1.298\n",
            "[2,  4000] loss: 1.221\n",
            "[2,  6000] loss: 1.175\n",
            "[2,  8000] loss: 1.125\n",
            "[2, 10000] loss: 1.082\n",
            "[2, 12000] loss: 1.058\n",
            "[3,  2000] loss: 0.976\n",
            "[3,  4000] loss: 0.957\n",
            "[3,  6000] loss: 0.959\n",
            "[3,  8000] loss: 0.918\n",
            "[3, 10000] loss: 0.903\n",
            "[3, 12000] loss: 0.889\n",
            "[4,  2000] loss: 0.829\n",
            "[4,  4000] loss: 0.813\n",
            "[4,  6000] loss: 0.827\n",
            "[4,  8000] loss: 0.818\n",
            "[4, 10000] loss: 0.801\n",
            "[4, 12000] loss: 0.776\n",
            "[5,  2000] loss: 0.736\n",
            "[5,  4000] loss: 0.731\n",
            "[5,  6000] loss: 0.752\n",
            "[5,  8000] loss: 0.739\n",
            "[5, 10000] loss: 0.708\n",
            "[5, 12000] loss: 0.692\n",
            "[6,  2000] loss: 0.668\n",
            "[6,  4000] loss: 0.671\n",
            "[6,  6000] loss: 0.661\n",
            "[6,  8000] loss: 0.670\n",
            "[6, 10000] loss: 0.644\n",
            "[6, 12000] loss: 0.634\n",
            "[7,  2000] loss: 0.593\n",
            "[7,  4000] loss: 0.600\n",
            "[7,  6000] loss: 0.620\n",
            "[7,  8000] loss: 0.606\n",
            "[7, 10000] loss: 0.599\n",
            "[7, 12000] loss: 0.594\n",
            "[8,  2000] loss: 0.550\n",
            "[8,  4000] loss: 0.558\n",
            "[8,  6000] loss: 0.549\n",
            "[8,  8000] loss: 0.558\n",
            "[8, 10000] loss: 0.570\n",
            "[8, 12000] loss: 0.567\n",
            "[9,  2000] loss: 0.517\n",
            "[9,  4000] loss: 0.518\n",
            "[9,  6000] loss: 0.511\n",
            "[9,  8000] loss: 0.540\n",
            "[9, 10000] loss: 0.480\n",
            "[9, 12000] loss: 0.512\n",
            "[10,  2000] loss: 0.477\n",
            "[10,  4000] loss: 0.466\n",
            "[10,  6000] loss: 0.475\n",
            "[10,  8000] loss: 0.470\n",
            "[10, 10000] loss: 0.475\n",
            "[10, 12000] loss: 0.494\n",
            "[11,  2000] loss: 0.427\n",
            "[11,  4000] loss: 0.443\n",
            "[11,  6000] loss: 0.426\n",
            "[11,  8000] loss: 0.461\n",
            "[11, 10000] loss: 0.450\n",
            "[11, 12000] loss: 0.458\n",
            "[12,  2000] loss: 0.397\n",
            "[12,  4000] loss: 0.417\n",
            "[12,  6000] loss: 0.426\n",
            "[12,  8000] loss: 0.407\n",
            "[12, 10000] loss: 0.415\n",
            "[12, 12000] loss: 0.414\n",
            "[13,  2000] loss: 0.373\n",
            "[13,  4000] loss: 0.390\n",
            "[13,  6000] loss: 0.367\n",
            "[13,  8000] loss: 0.402\n",
            "[13, 10000] loss: 0.396\n",
            "[13, 12000] loss: 0.399\n",
            "[14,  2000] loss: 0.349\n",
            "[14,  4000] loss: 0.338\n",
            "[14,  6000] loss: 0.370\n",
            "[14,  8000] loss: 0.345\n",
            "[14, 10000] loss: 0.363\n",
            "[14, 12000] loss: 0.387\n",
            "[15,  2000] loss: 0.319\n",
            "[15,  4000] loss: 0.337\n",
            "[15,  6000] loss: 0.326\n",
            "[15,  8000] loss: 0.332\n",
            "[15, 10000] loss: 0.349\n",
            "[15, 12000] loss: 0.344\n",
            "[16,  2000] loss: 0.307\n",
            "[16,  4000] loss: 0.315\n",
            "[16,  6000] loss: 0.306\n",
            "[16,  8000] loss: 0.324\n",
            "[16, 10000] loss: 0.295\n",
            "[16, 12000] loss: 0.313\n",
            "[17,  2000] loss: 0.281\n",
            "[17,  4000] loss: 0.280\n",
            "[17,  6000] loss: 0.288\n",
            "[17,  8000] loss: 0.284\n",
            "[17, 10000] loss: 0.289\n",
            "[17, 12000] loss: 0.298\n",
            "[18,  2000] loss: 0.261\n",
            "[18,  4000] loss: 0.271\n",
            "[18,  6000] loss: 0.270\n",
            "[18,  8000] loss: 0.278\n",
            "[18, 10000] loss: 0.274\n",
            "[18, 12000] loss: 0.248\n",
            "[19,  2000] loss: 0.225\n",
            "[19,  4000] loss: 0.238\n",
            "[19,  6000] loss: 0.236\n",
            "[19,  8000] loss: 0.249\n",
            "[19, 10000] loss: 0.258\n",
            "[19, 12000] loss: 0.262\n",
            "[20,  2000] loss: 0.218\n",
            "[20,  4000] loss: 0.219\n",
            "[20,  6000] loss: 0.228\n",
            "[20,  8000] loss: 0.237\n",
            "[20, 10000] loss: 0.247\n",
            "[20, 12000] loss: 0.221\n",
            "[21,  2000] loss: 0.198\n",
            "[21,  4000] loss: 0.207\n",
            "[21,  6000] loss: 0.205\n",
            "[21,  8000] loss: 0.202\n",
            "[21, 10000] loss: 0.219\n",
            "[21, 12000] loss: 0.223\n",
            "[22,  2000] loss: 0.175\n",
            "[22,  4000] loss: 0.183\n",
            "[22,  6000] loss: 0.196\n",
            "[22,  8000] loss: 0.195\n",
            "[22, 10000] loss: 0.206\n",
            "[22, 12000] loss: 0.204\n",
            "[23,  2000] loss: 0.162\n",
            "[23,  4000] loss: 0.176\n",
            "[23,  6000] loss: 0.170\n",
            "[23,  8000] loss: 0.177\n",
            "[23, 10000] loss: 0.172\n",
            "[23, 12000] loss: 0.183\n",
            "[24,  2000] loss: 0.158\n",
            "[24,  4000] loss: 0.160\n",
            "[24,  6000] loss: 0.166\n",
            "[24,  8000] loss: 0.170\n",
            "[24, 10000] loss: 0.170\n",
            "[24, 12000] loss: 0.163\n",
            "[25,  2000] loss: 0.139\n",
            "[25,  4000] loss: 0.136\n",
            "[25,  6000] loss: 0.150\n",
            "[25,  8000] loss: 0.151\n",
            "[25, 10000] loss: 0.162\n",
            "[25, 12000] loss: 0.154\n"
          ]
        }
      ],
      "source": [
        "# Train the model\n",
        "\n",
        "num_epochs = 25\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(train_loader, 0):\n",
        "        inputs, labels = data[0].to(device), data[1].to(device)\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        outputs = model(inputs)\n",
        "        loss = loss_function(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        running_loss += loss.item()\n",
        "        if i % 2000 == 1999:\n",
        "            print('[%d, %5d] loss: %.3f' %\n",
        "                  (epoch + 1, i + 1, running_loss / 2000))\n",
        "            running_loss = 0.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "xkMVIupqVGz0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37974c34-70ca-4dc0-cae7-9b44042b309d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy of the model: 82.84%\n"
          ]
        }
      ],
      "source": [
        "# Test the model\n",
        "\n",
        "correct = 0\n",
        "total = 0\n",
        "\n",
        "with torch.no_grad():\n",
        "    for data in test_loader:\n",
        "        images, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "        outputs = model(images)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "print('Test Accuracy of the model: %.2f%%' % (100 * correct / total))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "76wFMtC-Oz6I",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "outputId": "ec33a06b-80f2-4216-d8a3-2a87bafbf607"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 8 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1800x288 with 4 Axes>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "%matplotlib inline\n",
        "\n",
        "def imshow(img):\n",
        "    img = img / 2 + 0.5 \n",
        "    plt.imshow(np.transpose(img, (1, 2, 0))) \n",
        "\n",
        "dataiter = iter(train_loader)\n",
        "images, labels = dataiter.next()\n",
        "images = images.numpy()\n",
        "\n",
        "fig = plt.figure(figsize=(25, 4))\n",
        "\n",
        "for idx in range(len(images)):\n",
        "    ax = fig.add_subplot(2, 10, idx + 1, xticks=[], yticks=[])\n",
        "    imshow(images[idx])\n",
        "    ax.set_title(classes[labels[idx]])"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "task4_Pogozhelskaya.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}