filter-training.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled15.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9O9sJ6_9j7fT",
        "outputId": "cb371289-fc38-4124-e9ad-505ea450951b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "WARNING: timestamping does nothing in combination with -O. See the manual\n",
            "for details.\n",
            "\n",
            "--2021-12-12 17:12:04--  https://github.com/baidut/PaQ-2-PiQ/releases/download/v1.0/RoIPoolModel-fit.10.bs.120.pth\n",
            "Resolving github.com (github.com)... 52.69.186.44\n",
            "Connecting to github.com (github.com)|52.69.186.44|:443... connected.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://objects.githubusercontent.com/github-production-release-asset-2e65be/237024974/a1c42500-4755-11ea-9c0e-7bf2246fe9e5?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20211212%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20211212T171205Z&X-Amz-Expires=300&X-Amz-Signature=109d5e396246889a22bd5ee9f4e0d2b4d385b47355171347d0de8d47957ef916&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=237024974&response-content-disposition=attachment%3B%20filename%3DRoIPoolModel-fit.10.bs.120.pth&response-content-type=application%2Foctet-stream [following]\n",
            "--2021-12-12 17:12:05--  https://objects.githubusercontent.com/github-production-release-asset-2e65be/237024974/a1c42500-4755-11ea-9c0e-7bf2246fe9e5?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20211212%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20211212T171205Z&X-Amz-Expires=300&X-Amz-Signature=109d5e396246889a22bd5ee9f4e0d2b4d385b47355171347d0de8d47957ef916&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=237024974&response-content-disposition=attachment%3B%20filename%3DRoIPoolModel-fit.10.bs.120.pth&response-content-type=application%2Foctet-stream\n",
            "Resolving objects.githubusercontent.com (objects.githubusercontent.com)... 185.199.111.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 140552190 (134M) [application/octet-stream]\n",
            "Saving to: ‘RoIPoolModel.pth’\n",
            "\n",
            "RoIPoolModel.pth    100%[===================>] 134.04M  17.9MB/s    in 9.2s    \n",
            "\n",
            "2021-12-12 17:12:15 (14.6 MB/s) - ‘RoIPoolModel.pth’ saved [140552190/140552190]\n",
            "\n",
            "--2021-12-12 17:12:15--  https://github.com/baidut/PaQ-2-PiQ/releases/download/v1.0/Picture1.jpg\n",
            "Resolving github.com (github.com)... 13.114.40.48\n",
            "Connecting to github.com (github.com)|13.114.40.48|:443... connected.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://objects.githubusercontent.com/github-production-release-asset-2e65be/237024974/b488b880-6231-11ea-8328-cd6123862fda?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20211212%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20211212T171216Z&X-Amz-Expires=300&X-Amz-Signature=b6b1ae6af0d45ca4c3b6f53aa3b1a8bf5bcc285fe431a3098b1248ee12aafd05&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=237024974&response-content-disposition=attachment%3B%20filename%3DPicture1.jpg&response-content-type=application%2Foctet-stream [following]\n",
            "--2021-12-12 17:12:16--  https://objects.githubusercontent.com/github-production-release-asset-2e65be/237024974/b488b880-6231-11ea-8328-cd6123862fda?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20211212%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20211212T171216Z&X-Amz-Expires=300&X-Amz-Signature=b6b1ae6af0d45ca4c3b6f53aa3b1a8bf5bcc285fe431a3098b1248ee12aafd05&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=237024974&response-content-disposition=attachment%3B%20filename%3DPicture1.jpg&response-content-type=application%2Foctet-stream\n",
            "Resolving objects.githubusercontent.com (objects.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.110.133, ...\n",
            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 110901 (108K) [application/octet-stream]\n",
            "Saving to: ‘Picture1.jpg’\n",
            "\n",
            "Picture1.jpg        100%[===================>] 108.30K   163KB/s    in 0.7s    \n",
            "\n",
            "2021-12-12 17:12:17 (163 KB/s) - ‘Picture1.jpg’ saved [110901/110901]\n",
            "\n",
            "--2021-12-12 17:12:17--  https://raw.githubusercontent.com/baidut/PaQ-2-PiQ_GAE/master/paq2piq_standalone.py\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.109.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 6486 (6.3K) [text/plain]\n",
            "Saving to: ‘paq2piq_standalone.py’\n",
            "\n",
            "paq2piq_standalone. 100%[===================>]   6.33K  --.-KB/s    in 0s      \n",
            "\n",
            "Last-modified header missing -- time-stamps turned off.\n",
            "2021-12-12 17:12:18 (58.7 MB/s) - ‘paq2piq_standalone.py’ saved [6486/6486]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# download the model\n",
        "!wget -O RoIPoolModel.pth -N https://github.com/baidut/PaQ-2-PiQ/releases/download/v1.0/RoIPoolModel-fit.10.bs.120.pth\n",
        "\n",
        "# download a test image\n",
        "!wget -N https://github.com/baidut/PaQ-2-PiQ/releases/download/v1.0/Picture1.jpg\n",
        "\n",
        "# download the standalone version of code\n",
        "!wget -N https://raw.githubusercontent.com/baidut/PaQ-2-PiQ_GAE/master/paq2piq_standalone.py"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "from paq2piq_standalone import *\n",
        "from torch.autograd import Variable\n",
        "import imageio\n",
        "import os\n",
        "import subprocess "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PgnbSTKxj_M4",
        "outputId": "b1ff53e1-2683-4b1d-f96e-e76e772ba031"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "IMAGE_NET_MEAN = [0.485, 0.456, 0.406]\n",
        "IMAGE_NET_STD = [0.229, 0.224, 0.225]\n",
        "\n",
        "\n",
        "class Transform:\n",
        "    def __init__(self):\n",
        "        # normalize = transforms.Normalize(mean=IMAGE_NET_MEAN, std=IMAGE_NET_STD)\n",
        "\n",
        "        self._train_transform = transforms.Compose(\n",
        "            [\n",
        "                transforms.ToTensor(),\n",
        "            ]\n",
        "        )\n",
        "\n",
        "        self._val_transform = transforms.Compose([transforms.ToTensor()])\n",
        "\n",
        "    @property\n",
        "    def train_transform(self):\n",
        "        return self._train_transform\n",
        "\n",
        "    @property\n",
        "    def val_transform(self):\n",
        "        return self._val_transform"
      ],
      "metadata": {
        "id": "hylPZbYHkC3t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_state = torch.load('RoIPoolModel.pth', map_location=lambda storage, loc: storage)\n",
        "model = RoIPoolModel()\n",
        "model.load_state_dict(model_state[\"model\"])\n",
        "model = model.to(device)\n",
        "transform = Transform().val_transform\n",
        "model.eval()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1NNsuQNvkFam",
        "outputId": "1d984857-ceb9-47bd-dcab-778e38dcdfca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RoIPoolModel(\n",
              "  (body): Sequential(\n",
              "    (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
              "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (2): ReLU(inplace=True)\n",
              "    (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
              "    (4): 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",
              "    (5): 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",
              "    (6): 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",
              "    (7): 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",
              "  )\n",
              "  (head): Sequential(\n",
              "    (0): AdaptiveConcatPool2d(\n",
              "      (ap): AdaptiveAvgPool2d(output_size=(1, 1))\n",
              "      (mp): AdaptiveMaxPool2d(output_size=(1, 1))\n",
              "    )\n",
              "    (1): Flatten(start_dim=1, end_dim=-1)\n",
              "    (2): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (3): Dropout(p=0.25, inplace=False)\n",
              "    (4): Linear(in_features=1024, out_features=512, bias=True)\n",
              "    (5): ReLU(inplace=True)\n",
              "    (6): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (7): Dropout(p=0.5, inplace=False)\n",
              "    (8): Linear(in_features=512, out_features=1, bias=True)\n",
              "  )\n",
              "  (roi_pool): RoIPool(output_size=(2, 2), spatial_scale=0.03125)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "blk_size = (3, 5)\n",
        "from tqdm import tqdm"
      ],
      "metadata": {
        "id": "nBAQg1XTkF4Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.autograd import Variable\n",
        "import cv2\n",
        "import numpy as np\n",
        "import numpy as np\n",
        "import torch\n",
        "from torch.autograd import Variable\n",
        "from torch import optim\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "from torchvision import transforms\n",
        "import imageio\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt \n",
        "from torch import nn\n",
        "from torch.nn import functional as F\n",
        "import numpy as np\n",
        "from torchvision import transforms\n",
        "from tqdm import tqdm\n",
        "import torch\n",
        "from torch.nn import functional as F\n",
        "from torch.utils.data import DataLoader\n",
        "import torchvision \n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "from torch.utils.data import Dataset\n",
        "from typing import Optional\n",
        "import os\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import pandas as pd\n",
        "from torchvision import transforms\n",
        "import random"
      ],
      "metadata": {
        "id": "ZI6-ZaQDkF_o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "metadata": {
        "id": "O9UsPrngkQf_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Filter(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()        \n",
        "        self.layer1 = nn.Sequential(\n",
        "          nn.Conv2d(3, 64, 5, padding='same'),\n",
        "          nn.ReLU(),\n",
        "          nn.Conv2d(64, 64, 5, padding='same'),\n",
        "          nn.ReLU(),\n",
        "          nn.Conv2d(64, 3, 5, padding='same')\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        output = torch.sigmoid(self.layer1(x))\n",
        "        return output"
      ],
      "metadata": {
        "id": "OmZhJV5NkSws"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MyCustomDataset(Dataset):\n",
        "    def __init__(self, \n",
        "                 path_gt\n",
        "                ):\n",
        "        \n",
        "        self._items = [] \n",
        "        self._index = 0\n",
        "        dir_img = os.listdir(path_gt)\n",
        "        img_pathes = dir_img\n",
        "\n",
        "        for img_path in img_pathes:\n",
        "          self._items.append((\n",
        "            os.path.join(path_gt, img_path)\n",
        "          ))\n",
        "        random.shuffle(self._items)\n",
        "\n",
        "    def __len__(self):\n",
        "      return len(self._items)\n",
        "\n",
        "    def next_data(self):\n",
        "      gt_path = self._items[self._index]\n",
        "      self._index += 1 \n",
        "      if self._index == len(self._items):\n",
        "        self._index = 0\n",
        "        random.shuffle(self._items)\n",
        "\n",
        "      gt_image = Image.open(gt_path).convert('RGB')\n",
        "      gt_image = np.array(gt_image).astype(np.float32) / 255.\n",
        "      gt_image = transform(gt_image)\n",
        "      gt_image = gt_image.unsqueeze_(0)\n",
        "      y = gt_image.to(device)\n",
        "      return y"
      ],
      "metadata": {
        "id": "h9Tmhuhxkw2p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#filter = Filter().to(device)\n",
        "#filter.load_state_dict(torch.load('/content/drive/MyDrive/metrics/filter.pth'))\n",
        "filter.train()\n",
        "optimizer = torch.optim.Adam(filter.parameters(), lr=0.001)\n",
        "path_gt = '/content/drive/MyDrive/metrics/for_train'\n",
        "dl = MyCustomDataset(path_gt=path_gt)\n",
        "n_epoch = 6\n",
        "id = 0\n",
        "for epoch in range(n_epoch):\n",
        "  loss_list = []\n",
        "  for u in range(len(dl)):\n",
        "    y = dl.next_data()\n",
        "    out = filter(y)\n",
        "    \n",
        "    optimizer.zero_grad()\n",
        "    loss = 1 - model(out).mean() / 100 + 10 * ((out - y).square().mean()).sqrt()\n",
        "    #print(((out - y).square().mean()).sqrt())\n",
        "    #print(loss.item())\n",
        "    loss_list.append(loss.item())\n",
        "    loss.backward()\n",
        "    torch.nn.utils.clip_grad_norm_(filter.parameters(), 1)\n",
        "    optimizer.step()\n",
        "  print(epoch, np.array(loss_list).mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f1YPx-94lDm5",
        "outputId": "203c0660-f14a-4226-f46c-075b18a5f52d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 0.7078634292790384\n",
            "1 0.7248694395477121\n",
            "2 0.6512469071330447\n",
            "3 0.6055388143568328\n",
            "4 0.6370953565294092\n",
            "5 0.6300029452099944\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(filter.state_dict(), '/content/drive/MyDrive/metrics/filter_v2.pth')"
      ],
      "metadata": {
        "id": "bkLv2Zs5oxp6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "filter.eval()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wmv5sZApoxs3",
        "outputId": "40da395d-8d64-48d7-a22b-28c2ba0a1886"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Filter(\n",
              "  (layer1): Sequential(\n",
              "    (0): Conv2d(3, 64, kernel_size=(5, 5), stride=(1, 1), padding=same)\n",
              "    (1): ReLU()\n",
              "    (2): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=same)\n",
              "    (3): ReLU()\n",
              "    (4): Conv2d(64, 3, kernel_size=(5, 5), stride=(1, 1), padding=same)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_pic = \"/content/drive/MyDrive/metrics/for_train/pic041.png\""
      ],
      "metadata": {
        "id": "Hg-3LU_kryMe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "image = cv2.imread(test_pic)\n",
        "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "image = transform(image)\n",
        "image = image.unsqueeze_(0)\n",
        "y = image.to(device)\n",
        "out = filter(y)\n",
        "res_img = (out.squeeze().data.cpu().numpy().transpose(1, 2, 0) * 255).astype('uint8')\n",
        "imageio.imwrite(\"/content/drive/MyDrive/metrics/res19.png\", res_img)"
      ],
      "metadata": {
        "id": "XTwaopn3oxwF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "paq2piq_before = []\n",
        "paq2piq_after = []"
      ],
      "metadata": {
        "id": "I2vnX-UX95vT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "psnr_diff = []\n",
        "ssim_diff = []"
      ],
      "metadata": {
        "id": "2wKW74v1CaWB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "img_dir = \"/content/drive/MyDrive/metrics/sunflower/gt\"\n",
        "for img_name in tqdm(sorted(os.listdir(img_dir))):\n",
        "  img_path = os.path.join(img_dir, img_name)\n",
        "  image = cv2.imread(img_path)\n",
        "  image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "  image = transform(image)\n",
        "  image = image.unsqueeze_(0)\n",
        "  image = image.to(device)\n",
        "  out = filter(image)\n",
        "  res_img = (out.squeeze().data.cpu().numpy().transpose(1, 2, 0) * 255).astype('uint8')\n",
        "  imageio.imwrite(\"/content/drive/MyDrive/metrics/sunflower/filter/\"+img_name, res_img)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Wnu5625H11v",
        "outputId": "cb8655aa-1574-4b5c-ac36-737822fb1d3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 75/75 [08:11<00:00,  6.55s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import subprocess"
      ],
      "metadata": {
        "id": "90VDc4K5I3_i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.chdir(\"/content\")"
      ],
      "metadata": {
        "id": "8RvJk_YzI94A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "subprocess.run(['ffmpeg', '-r', '25', '-f', 'image2', '-s', '1920x1080', '-i',\n",
        "                'pic%03d.png', '-c:v', 'libx264', '-b:v', '3M','-pix_fmt', 'yuv420p', 'gt3M.mp4'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "80VtzyFCJByO",
        "outputId": "7b979872-e168-4266-e3ef-0b056761bc30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "CompletedProcess(args=['ffmpeg', '-r', '25', '-f', 'image2', '-s', '1920x1080', '-i', 'pic%03d.png', '-c:v', 'libx264', '-b:v', '3M', '-pix_fmt', 'yuv420p', 'gt3M.mp4'], returncode=0)"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ssim_scores = []\n",
        "psnr_scores = []\n",
        "paq2piq_scores = []\n",
        "folder = '/content/drive/MyDrive/metrics/sunflower/filter/'\n",
        "cap = cv2.VideoCapture(folder + 'gt_prep1M.mp4')\n",
        "for i in tqdm(range(75)):\n",
        "  ref, frame = cap.read()\n",
        "  gt = cv2.imread('/content/drive/MyDrive/metrics/sunflower/gt/'+f'pic{i:03}.png')\n",
        "  frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
        "  gt = cv2.cvtColor(gt, cv2.COLOR_BGR2RGB)\n",
        "  overall_model = InferenceModel(RoIPoolModel(), 'RoIPoolModel.pth')\n",
        "  overall_model.blk_size = (3, 5)\n",
        "  score = overall_model.predict(frame)['global_score']\n",
        "  paq2piq_scores.append(score)\n",
        "  psnr_score = peak_signal_noise_ratio(gt, frame)\n",
        "  ssim_score = structural_similarity(gt, frame, multichannel=True)\n",
        "  ssim_scores.append(ssim_score)\n",
        "  psnr_scores.append(psnr_score)\n",
        "ssim_scores = np.array(ssim_scores)\n",
        "psnr_scores = np.array(psnr_scores)\n",
        "paq2piq_scores = np.array(paq2piq_scores)\n",
        "with open(folder+'ssim1M.npy', 'wb') as f:\n",
        "    np.save(f, ssim_scores)\n",
        "with open(folder+'psnr1M.npy', 'wb') as f:\n",
        "    np.save(f, psnr_scores)\n",
        "with open(folder+'paq2piq1M.npy', 'wb') as f:\n",
        "    np.save(f, paq2piq_scores)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pOK9AD_uJGj0",
        "outputId": "7c0e7aaf-5b0c-438c-fc1e-f9c363bf1320"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 75/75 [01:54<00:00,  1.52s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/paq2piq1M.npy', 'rb') as f:\n",
        "    gt_paq2piq1M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/paq2piq2M.npy', 'rb') as f:\n",
        "    gt_paq2piq2M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/paq2piq3M.npy', 'rb') as f:\n",
        "    gt_paq2piq3M = np.load(f)\n",
        "\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/paq2piq1M.npy', 'rb') as f:\n",
        "    paq2piq1M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/paq2piq2M.npy', 'rb') as f:\n",
        "    paq2piq2M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/paq2piq3M.npy', 'rb') as f:\n",
        "    paq2piq3M = np.load(f) \n",
        "\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/psnr1M.npy', 'rb') as f:\n",
        "    gt_psnr1M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/psnr2M.npy', 'rb') as f:\n",
        "    gt_psnr2M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/psnr3M.npy', 'rb') as f:\n",
        "    gt_psnr3M = np.load(f)\n",
        "\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/psnr1M.npy', 'rb') as f:\n",
        "    psnr1M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/psnr2M.npy', 'rb') as f:\n",
        "    psnr2M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/psnr3M.npy', 'rb') as f:\n",
        "    psnr3M = np.load(f) \n",
        "\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/ssim1M.npy', 'rb') as f:\n",
        "    gt_ssim1M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/ssim2M.npy', 'rb') as f:\n",
        "    gt_ssim2M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/gt/ssim3M.npy', 'rb') as f:\n",
        "    gt_ssim3M = np.load(f)\n",
        "\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/ssim1M.npy', 'rb') as f:\n",
        "    ssim1M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/ssim2M.npy', 'rb') as f:\n",
        "    ssim2M = np.load(f)\n",
        "with open('/content/drive/MyDrive/metrics/sunflower/filter/ssim3M.npy', 'rb') as f:\n",
        "    ssim3M = np.load(f) "
      ],
      "metadata": {
        "id": "NAJABLjXNpBh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "gt_paq2piq1M = gt_paq2piq1M.mean()\n",
        "gt_paq2piq2M = gt_paq2piq2M.mean()\n",
        "gt_paq2piq3M = gt_paq2piq3M.mean()\n",
        "paq2piq1M = paq2piq1M.mean()\n",
        "paq2piq2M = paq2piq2M.mean()\n",
        "paq2piq3M = paq2piq3M.mean()\n",
        "\n",
        "gt_psnr1M = gt_psnr1M.mean()\n",
        "gt_psnr2M = gt_psnr2M.mean()\n",
        "gt_psnr3M = gt_psnr3M.mean()\n",
        "psnr1M = psnr1M.mean()\n",
        "psnr2M = psnr2M.mean()\n",
        "psnr3M = psnr3M.mean()\n",
        "\n",
        "gt_ssim1M = gt_ssim1M.mean()\n",
        "gt_ssim2M = gt_ssim2M.mean()\n",
        "gt_ssim3M = gt_ssim3M.mean()\n",
        "ssim1M = ssim1M.mean()\n",
        "ssim2M = ssim2M.mean()\n",
        "ssim3M = ssim3M.mean()"
      ],
      "metadata": {
        "id": "o7Z4EASJO0vy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = [1, 2, 3]"
      ],
      "metadata": {
        "id": "Llxmd9z4PxW-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "gt_paq2piq = [gt_paq2piq1M, gt_paq2piq2M, gt_paq2piq3M]\n",
        "paq2piq = [paq2piq1M, paq2piq2M, paq2piq3M]\n",
        "gt_psnr = [gt_psnr1M, gt_psnr2M, gt_psnr3M]\n",
        "psnr = [psnr1M, psnr2M, psnr3M]\n",
        "gt_ssim = [gt_ssim1M, gt_ssim2M, gt_ssim3M]\n",
        "ssim = [ssim1M, ssim2M, ssim3M]"
      ],
      "metadata": {
        "id": "sFzA-ZMSP7Az"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fig, ax = plt.subplots(1, 3, figsize=(15, 4))\n",
        "ax[0].plot(x, gt_paq2piq, '-o', label='gt with compression', color='green')\n",
        "ax[0].plot(x, paq2piq, '-o', label='preprocessed with compression', color='orange')\n",
        "ax[0].set_ylabel('Paq2Piq scores')\n",
        "ax[0].set_xlabel('bitrate')\n",
        "ax[0].legend()\n",
        "\n",
        "ax[1].plot(x, gt_psnr, '-o', label='gt with compression', color='green')\n",
        "ax[1].plot(x, psnr, '-o', label='preprocessed with compression', color='orange')\n",
        "ax[1].set_ylabel('PSNR scores')\n",
        "ax[1].set_xlabel('bitrate')\n",
        "ax[1].legend()\n",
        "\n",
        "ax[2].plot(x, gt_ssim, '-o', label='gt with compression', color='green')\n",
        "ax[2].plot(x, ssim, '-o', label='preprocessed with compression', color='orange')\n",
        "ax[2].set_ylabel('SSIM scores')\n",
        "ax[2].set_xlabel('bitrate')\n",
        "ax[2].legend()\n",
        "fig.tight_layout()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "4nqyS7oZPvfE",
        "outputId": "bf2d730a-dd6f-4b72-ffce-7086cfc7c476"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x288 with 3 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for img in tqdm(sorted(os.listdir('/content/drive/MyDrive/metrics/for_train/'))):\n",
        "  path = os.path.join('/content/drive/MyDrive/metrics/for_train', img)\n",
        "  image = cv2.imread(path)\n",
        "  image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "  t_image = transform(image)\n",
        "  t_image = t_image.unsqueeze_(0)\n",
        "  y = t_image.to(device)\n",
        "  out = filter(y)\n",
        "  res_img = (out.squeeze().data.cpu().numpy().transpose(1, 2, 0) * 255).astype('uint8')\n",
        "  psnr_diff.append(peak_signal_noise_ratio(image, res_img))\n",
        "  ssim_diff.append(structural_similarity(image, res_img, multichannel=True))\n",
        "  #overall_model = InferenceModel(RoIPoolModel(), 'RoIPoolModel.pth')\n",
        "  #overall_model.blk_size = (3, 5)\n",
        "  #score = overall_model.predict(image)['global_score']\n",
        "  #paq2piq_before.append(score)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mYbfbp9Y9Pn5",
        "outputId": "f9bf92cf-2fff-4bf2-ac52-6c63c6122c6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 66/66 [01:45<00:00,  1.60s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.arange(0, 67)\n",
        "plt.plot(x, psnr_diff)\n",
        "plt.title('PSNR between gt and processed on train')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "id": "O1meMf7eC5t8",
        "outputId": "dcd789a0-1ab7-43fa-c628-1a0baffff271"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'PSNR between gt and processed on train')"
            ]
          },
          "metadata": {},
          "execution_count": 92
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from skimage.metrics import structural_similarity\n",
        "from skimage.metrics import peak_signal_noise_ratio"
      ],
      "metadata": {
        "id": "fADMPq1DAWmK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "overall_model = InferenceModel(RoIPoolModel(), 'RoIPoolModel.pth')\n",
        "overall_model.blk_size = (3, 5)\n",
        "overall_model.predict_from_file(test_pic)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dwYcoq8joxy5",
        "outputId": "9ada7d12-c6b2-49db-d54e-d5eb709faf6b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'category': 'Bad',\n",
              " 'global_score': 46.3004,\n",
              " 'local_scores': array([[50.590996, 52.181446, 50.09887 , 50.166298, 51.837616],\n",
              "        [49.622414, 50.16311 , 48.47332 , 49.992004, 50.95299 ],\n",
              "        [49.025974, 48.418827, 48.213444, 50.06582 , 51.741856]],\n",
              "       dtype=float32),\n",
              " 'normalized_global_score': 4.205833435058594,\n",
              " 'normalized_local_scores': array([[15.52419662, 19.71971512, 14.22599411, 14.403862  , 18.81270981],\n",
              "        [12.96912384, 14.39545441,  9.93788147, 13.94408798, 16.47911835],\n",
              "        [11.39575195,  9.79412842,  9.25233841, 14.1388092 , 18.56010056]])}"
            ]
          },
          "metadata": {},
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.arange(0, 66)\n",
        "plt.plot(x, paq2piq_before, label='before')\n",
        "plt.plot(x, paq2piq_after, label='after')\n",
        "plt.title('on train frames')\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "id": "MymomO9L-dhQ",
        "outputId": "4f99c45c-e7dd-4e90-e949-446d1e2e91b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fa017a96a10>"
            ]
          },
          "metadata": {},
          "execution_count": 75
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.arange(0, 24)\n",
        "plt.plot(x, paq2piq_before, label='before')\n",
        "plt.plot(x, paq2piq_after, label='after')\n",
        "plt.title('on val frames')\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "id": "afgCyN2kAl5i",
        "outputId": "d618ae4e-0ac6-461f-f0d8-066079118371"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fa01d0b1450>"
            ]
          },
          "metadata": {},
          "execution_count": 84
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "overall_model = InferenceModel(RoIPoolModel(), 'RoIPoolModel.pth')\n",
        "overall_model.blk_size = (3, 5)\n",
        "overall_model.predict_from_file(\"/content/drive/MyDrive/metrics/res19.png\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WvyaLlq3ox1s",
        "outputId": "262b78ad-0a78-426e-ea1b-ebed072b4867"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'category': 'Fair',\n",
              " 'global_score': 66.35417,\n",
              " 'local_scores': array([[61.331394, 65.9566  , 66.624466, 66.59766 , 73.48888 ],\n",
              "        [55.63141 , 63.757812, 65.128685, 63.20622 , 65.639275],\n",
              "        [54.02604 , 56.96768 , 55.136673, 63.870975, 64.43458 ]],\n",
              "       dtype=float32),\n",
              " 'normalized_global_score': 57.106605529785156,\n",
              " 'normalized_local_scores': array([[43.85678864, 56.05782318, 57.81962967, 57.748909  , 74.89239502],\n",
              "        [28.82053375, 50.2575531 , 53.87384033, 48.80247498, 55.2207489 ],\n",
              "        [24.5856514 , 32.34555054, 27.51544571, 50.55606842, 52.04282379]])}"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "aCMw66wVsFJy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "IxXobLjbsFMX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "Gkz93vAfsFOc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "2_Pt8MTPsFRk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "UgRvIxfNsFUo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "qIEEFmzJox5M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "idx = 0"
      ],
      "metadata": {
        "id": "Syi3E6kgmt2Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dest_folder = '/content/drive/MyDrive/metrics/sunflower/compressed/'\n",
        "cap = cv2.VideoCapture('/content/drive/MyDrive/metrics/gt/sunflower2M.mp4')\n",
        "ret, frame = cap.read()\n",
        "while ret:\n",
        "  cv2.imwrite(dest_folder + f'pic{idx:03}.png', frame)\n",
        "  idx += 1\n",
        "  ret, frame = cap.read()"
      ],
      "metadata": {
        "id": "nrOw4__cmt5x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "MkG6cbAjnYHf"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}