1. Классификация квартир.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Классификация квартир.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "YU6uIx65g_mo"
      },
      "source": [
        "import torch\n",
        "import cv2\n",
        "import tqdm\n",
        "from PIL import Image\n",
        "import pandas as pd\n",
        "import torch.nn as nn\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torchvision.models as models"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cMWp-4n1h8we"
      },
      "source": [
        "#Строим нейросеть#\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gBXl3rlWjroJ"
      },
      "source": [
        "Создаем даталоадеры для обучения нейросети"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m7Yh7HiojwjZ"
      },
      "source": [
        "images_dataset = torchvision.datasets.ImageFolder(\"./drive/MyDrive/ML/rucode_house/data/train1\", transform = transforms.Compose([\n",
        "                                                                                transforms.ToTensor(),\n",
        "                                                                                transforms.Resize(256),\n",
        "                                                                                transforms.CenterCrop(224),\n",
        "                                                                                # нормализуем как в ImageNet\n",
        "                                                                                torchvision.transforms.Normalize([0.485, 0.456, 0.406],\n",
        "                                                                                                                 [0.229, 0.224, 0.225])\n",
        "    ]))\n",
        "images_dataloader = torch.utils.data.DataLoader(images_dataset, batch_size=16, shuffle=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "phYnLGSlr5aZ"
      },
      "source": [
        "Будем использовать предобученную на ImageNet сеть ResNet18"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kvLg9Kf3r_rC",
        "outputId": "8118a8d5-0710-4f4e-ff86-3b67db5c818c"
      },
      "source": [
        "net = models.resnet18(True, True).cuda()\n",
        "net"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ResNet(\n",
              "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
              "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (relu): ReLU(inplace=True)\n",
              "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
              "  (layer1): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer2): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer3): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer4): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
              "  (fc): Linear(in_features=512, out_features=1000, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jgT8ZTo4t09C"
      },
      "source": [
        "Заменим последний полносвязный слой сети на слой, который будет выдавать 4 значения на выходе (т.к. у нас 4 класса)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4q_sn8oguKi5"
      },
      "source": [
        "net.fc = nn.Linear(512,4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "acqKNt9KuQQl"
      },
      "source": [
        "Заморозим все слои нейросети, кроме самого последнего, только что добавленного fc-слоя. Будем обучать только последний слой сети."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FSmuW8CYuZhK"
      },
      "source": [
        "for i, child in enumerate(net.children()):\n",
        "  if i==9:\n",
        "    break\n",
        "  for param in child.parameters():\n",
        "    param.requires_grad = False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ufPiJo3NutMc"
      },
      "source": [
        "Объявляем лосс-функцию и оптимизатор:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C568ki9lu0I6"
      },
      "source": [
        "# стандартная лосс-функция для задачи классификации\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Pyfdp33vV5Z",
        "outputId": "fdce1190-9556-41e9-a0a5-ace242959560"
      },
      "source": [
        "# для обучения на GPU\n",
        "device = 'cuda:0'\n",
        "net.to(device)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ResNet(\n",
              "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
              "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (relu): ReLU(inplace=True)\n",
              "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
              "  (layer1): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer2): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer3): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer4): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
              "  (fc): Linear(in_features=512, out_features=4, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U4RoEKLrvdvX"
      },
      "source": [
        "Обучаем сеть 5 эпох:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GBDfaWYZvj5x",
        "outputId": "f4bed0e8-d3c1-46df-e33f-5b1aebf5ecc2"
      },
      "source": [
        "n_epochs = 5\n",
        "print_every = 10\n",
        "\n",
        "total_step = len(images_dataloader)\n",
        "\n",
        "for epoch in range(1, n_epochs+1):\n",
        "  print(f'Epoch {epoch}\\n')\n",
        "  for batch_idx, (data, target) in enumerate(images_dataloader):\n",
        "    # кладем данные на GPU\n",
        "    data, target = data.to(device), target.to(device)\n",
        "\n",
        "    # делаем шаг обучения сети\n",
        "    optimizer.zero_grad()\n",
        "    outputs = net(data)\n",
        "    loss = criterion(outputs, target)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    if (batch_idx) % 20 == 0:\n",
        "      print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch, n_epochs, batch_idx, total_step, loss.item()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
            "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/5], Step [0/148], Loss: 1.6830\n",
            "Epoch [1/5], Step [20/148], Loss: 0.8080\n",
            "Epoch [1/5], Step [40/148], Loss: 0.6496\n",
            "Epoch [1/5], Step [60/148], Loss: 0.4331\n",
            "Epoch [1/5], Step [80/148], Loss: 0.4345\n",
            "Epoch [1/5], Step [100/148], Loss: 0.3975\n",
            "Epoch [1/5], Step [120/148], Loss: 0.4259\n",
            "Epoch [1/5], Step [140/148], Loss: 0.4603\n",
            "Epoch 2\n",
            "\n",
            "Epoch [2/5], Step [0/148], Loss: 0.2872\n",
            "Epoch [2/5], Step [20/148], Loss: 0.6118\n",
            "Epoch [2/5], Step [40/148], Loss: 0.2406\n",
            "Epoch [2/5], Step [60/148], Loss: 0.2860\n",
            "Epoch [2/5], Step [80/148], Loss: 0.2225\n",
            "Epoch [2/5], Step [100/148], Loss: 0.3495\n",
            "Epoch [2/5], Step [120/148], Loss: 0.2826\n",
            "Epoch [2/5], Step [140/148], Loss: 0.1784\n",
            "Epoch 3\n",
            "\n",
            "Epoch [3/5], Step [0/148], Loss: 0.1778\n",
            "Epoch [3/5], Step [20/148], Loss: 0.1165\n",
            "Epoch [3/5], Step [40/148], Loss: 0.3383\n",
            "Epoch [3/5], Step [60/148], Loss: 0.0799\n",
            "Epoch [3/5], Step [80/148], Loss: 0.7694\n",
            "Epoch [3/5], Step [100/148], Loss: 0.2890\n",
            "Epoch [3/5], Step [120/148], Loss: 0.2206\n",
            "Epoch [3/5], Step [140/148], Loss: 0.1739\n",
            "Epoch 4\n",
            "\n",
            "Epoch [4/5], Step [0/148], Loss: 0.2005\n",
            "Epoch [4/5], Step [20/148], Loss: 0.0869\n",
            "Epoch [4/5], Step [40/148], Loss: 0.2258\n",
            "Epoch [4/5], Step [60/148], Loss: 0.1550\n",
            "Epoch [4/5], Step [80/148], Loss: 0.4864\n",
            "Epoch [4/5], Step [100/148], Loss: 0.2036\n",
            "Epoch [4/5], Step [120/148], Loss: 0.3390\n",
            "Epoch [4/5], Step [140/148], Loss: 0.1342\n",
            "Epoch 5\n",
            "\n",
            "Epoch [5/5], Step [0/148], Loss: 0.2458\n",
            "Epoch [5/5], Step [20/148], Loss: 0.2389\n",
            "Epoch [5/5], Step [40/148], Loss: 0.0727\n",
            "Epoch [5/5], Step [60/148], Loss: 0.0910\n",
            "Epoch [5/5], Step [80/148], Loss: 0.3396\n",
            "Epoch [5/5], Step [100/148], Loss: 0.1779\n",
            "Epoch [5/5], Step [120/148], Loss: 0.3138\n",
            "Epoch [5/5], Step [140/148], Loss: 0.0808\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmlqne88Mp61"
      },
      "source": [
        "Тестируем обученную сеть на тестовом наборе картинок"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XmWH_WYBav26",
        "outputId": "15b40bce-beef-45b8-9070-e5b998c071aa"
      },
      "source": [
        "#image_path=f'./drive/MyDrive/ML/rucode_house/data/test/2381.jpg'\n",
        "#image = cv2.imread(image_path)\n",
        "transform = transforms.Compose([\n",
        "                                                                                transforms.ToTensor(),\n",
        "                                                                                transforms.Resize(256),\n",
        "                                                                                transforms.CenterCrop(224),\n",
        "                                                                                # нормализуем как в ImageNet\n",
        "                                                                                torchvision.transforms.Normalize([0.485, 0.456, 0.406],\n",
        "                                                                                                                 [0.229, 0.224, 0.225])\n",
        "])\n",
        "#net.eval()\n",
        "#predict = net(image)\n",
        "\n",
        "\n",
        "# load your image(s)\n",
        "img = Image.open(f'./drive/MyDrive/ML/rucode_house/data/test/2381.jpg')\n",
        "\n",
        "# Transform\n",
        "input = transform(img)\n",
        "\n",
        "# unsqueeze batch dimension, in case you are dealing with a single image\n",
        "input = input.unsqueeze(0)\n",
        "\n",
        "input = input.to(device)\n",
        "\n",
        "# Set model to eval\n",
        "net.eval()\n",
        "\n",
        "# Get prediction\n",
        "output = net(input)\n",
        "\n",
        "prediction = int(torch.max(output.cpu().data, 1)[1].numpy())\n",
        "prediction"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mjtfNllHWMY9"
      },
      "source": [
        "result = []\n",
        "transform = transforms.Compose([\n",
        "                                                                                transforms.ToTensor(),\n",
        "                                                                                transforms.Resize(256),\n",
        "                                                                                transforms.CenterCrop(224),\n",
        "                                                                                # нормализуем как в ImageNet\n",
        "                                                                                torchvision.transforms.Normalize([0.485, 0.456, 0.406],\n",
        "                                                                                                                 [0.229, 0.224, 0.225])\n",
        "])\n",
        "net.eval()\n",
        "for name in range(2289,4734):\n",
        "  image_path=f'./drive/MyDrive/ML/rucode_house/data/test/{name}.jpg'\n",
        "  try:\n",
        "    img = Image.open(image_path)\n",
        "  except:\n",
        "    continue\n",
        "  input = transform(img)\n",
        "  input = input.unsqueeze(0)\n",
        "  input = input.to(device)\n",
        "  output = net(input)\n",
        "  prediction = int(torch.max(output.cpu().data, 1)[1].numpy()) \n",
        "  result.append(prediction)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PXeszQ-yqdFK"
      },
      "source": [
        "submission = pd.DataFrame(result)\n",
        "submission.to_csv('ans.csv', index=False,header=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "0xhyUBN8VgWo",
        "outputId": "2f67fdd9-fdc8-454f-88d6-79e9eeafc9bf"
      },
      "source": [
        "datas = pd.read_csv(\"./ans.csv\")\n",
        "datas.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   0\n",
              "0  0\n",
              "1  0\n",
              "2  0\n",
              "3  0\n",
              "4  0"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    }
  ]
}