diff --git a/Copy_of_LaMa_inpainting.ipynb b/Copy_of_LaMa_inpainting.ipynb new file mode 100644 index 00000000..765e510d --- /dev/null +++ b/Copy_of_LaMa_inpainting.ipynb @@ -0,0 +1,2175 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "_pRpIwnaOnb3" + }, + "source": [ + "# 🦙 **LaMa: Resolution-robust Large Mask Inpainting with Fourier Convolutions**\n", + "\n", + "[[Project page](https://advimman.github.io/lama-project/)] [[GitHub](https://github.com/advimman/lama)] [[arXiv](https://arxiv.org/abs/2109.07161)] [[Supplementary](https://ashukha.com/projects/lama_21/lama_supmat_2021.pdf)] [[BibTeX](https://senya-ashukha.github.io/projects/lama_21/paper.txt)]\n", + "\n", + "

\n", + "Our model generalizes surprisingly well to much higher resolutions (~2k❗️) than it saw during training (256x256), and achieves the excellent performance even in challenging scenarios, e.g. completion of periodic structures.\n", + "

\n", + "\n", + "# Try it yourself!👇\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "RwXRMaNHW4r5", + "outputId": "223f5e16-1621-402d-f8b6-857d95853202", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "> Cloning the repo\n", + "fatal: destination path 'lama' already exists and is not an empty directory.\n", + "\n", + "> Install dependencies\n", + "Requirement already satisfied: wldhx.yadisk-direct in /usr/local/lib/python3.11/dist-packages (0.0.6)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from wldhx.yadisk-direct) (2.32.3)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->wldhx.yadisk-direct) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->wldhx.yadisk-direct) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->wldhx.yadisk-direct) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->wldhx.yadisk-direct) (2025.1.31)\n", + "Requirement already satisfied: pip in /usr/local/lib/python3.11/dist-packages (25.0.1)\n", + "Requirement already satisfied: scikit-survival in /usr/local/lib/python3.11/dist-packages (0.24.1)\n", + "Requirement already satisfied: ecos in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (2.0.14)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (1.4.2)\n", + "Requirement already satisfied: numexpr in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (2.10.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (1.23.5)\n", + "Collecting osqp<1.0.0,>=0.6.3 (from scikit-survival)\n", + " Using cached osqp-0.6.7.post3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (1.9 kB)\n", + "Requirement already satisfied: pandas>=1.4.0 in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (2.2.2)\n", + "Requirement already satisfied: scipy>=1.3.2 in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (1.14.1)\n", + "Requirement already satisfied: scikit-learn<1.7,>=1.6.1 in /usr/local/lib/python3.11/dist-packages (from scikit-survival) (1.6.1)\n", + "Requirement already satisfied: qdldl in /usr/local/lib/python3.11/dist-packages (from osqp<1.0.0,>=0.6.3->scikit-survival) (0.1.7.post5)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.4.0->scikit-survival) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.4.0->scikit-survival) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.4.0->scikit-survival) (2025.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn<1.7,>=1.6.1->scikit-survival) (3.6.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas>=1.4.0->scikit-survival) (1.17.0)\n", + "Using cached osqp-0.6.7.post3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (298 kB)\n", + "Installing collected packages: osqp\n", + "Successfully installed osqp-0.6.7.post3\n", + "Found existing installation: kornia 0.8.0\n", + "Uninstalling kornia-0.8.0:\n", + " Successfully uninstalled kornia-0.8.0\n", + "Collecting kornia\n", + " Using cached kornia-0.8.0-py2.py3-none-any.whl.metadata (17 kB)\n", + "Using cached kornia-0.8.0-py2.py3-none-any.whl (1.1 MB)\n", + "Installing collected packages: kornia\n", + "Successfully installed kornia-0.8.0\n", + "Requirement already satisfied: kornia-rs in /usr/local/lib/python3.11/dist-packages (0.1.8)\n", + "Requirement already satisfied: pytorch-lightning in /usr/local/lib/python3.11/dist-packages (2.5.1)\n", + "Requirement already satisfied: torch>=2.1.0 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (2.6.0+cu124)\n", + "Requirement already satisfied: tqdm>=4.57.0 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (4.67.1)\n", + "Requirement already satisfied: PyYAML>=5.4 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (6.0.2)\n", + "Requirement already satisfied: fsspec>=2022.5.0 in /usr/local/lib/python3.11/dist-packages (from fsspec[http]>=2022.5.0->pytorch-lightning) (2025.3.2)\n", + "Requirement already satisfied: torchmetrics>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (1.7.1)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (24.2)\n", + "Requirement already satisfied: typing-extensions>=4.4.0 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (4.13.1)\n", + "Requirement already satisfied: lightning-utilities>=0.10.0 in /usr/local/lib/python3.11/dist-packages (from pytorch-lightning) (0.14.3)\n", + "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /usr/local/lib/python3.11/dist-packages (from fsspec[http]>=2022.5.0->pytorch-lightning) (3.11.15)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from lightning-utilities>=0.10.0->pytorch-lightning) (75.2.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (3.18.0)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (3.1.6)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.4.127)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (9.1.0.70)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.4.5.8)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (11.2.1.3)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (10.3.5.147)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (11.6.1.9)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.3.1.170)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (0.6.2)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.4.127)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (12.4.127)\n", + "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (3.2.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=2.1.0->pytorch-lightning) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=2.1.0->pytorch-lightning) (1.3.0)\n", + "Requirement already satisfied: numpy>1.20.0 in /usr/local/lib/python3.11/dist-packages (from torchmetrics>=0.7.0->pytorch-lightning) (1.23.5)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (2.6.1)\n", + "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (1.3.2)\n", + "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (25.3.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (1.5.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (6.3.2)\n", + "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (0.3.1)\n", + "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.11/dist-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (1.18.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=2.1.0->pytorch-lightning) (3.0.2)\n", + "Requirement already satisfied: idna>=2.0 in /usr/local/lib/python3.11/dist-packages (from yarl<2.0,>=1.17.0->aiohttp!=4.0.0a0,!=4.0.0a1->fsspec[http]>=2022.5.0->pytorch-lightning) (3.10)\n", + "Requirement already satisfied: hydra-core in /usr/local/lib/python3.11/dist-packages (1.3.2)\n", + "Requirement already satisfied: omegaconf<2.4,>=2.2 in /usr/local/lib/python3.11/dist-packages (from hydra-core) (2.3.0)\n", + "Requirement already satisfied: antlr4-python3-runtime==4.9.* in /usr/local/lib/python3.11/dist-packages (from hydra-core) (4.9.3)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from hydra-core) (24.2)\n", + "Requirement already satisfied: PyYAML>=5.1.0 in /usr/local/lib/python3.11/dist-packages (from omegaconf<2.4,>=2.2->hydra-core) (6.0.2)\n", + "Requirement already satisfied: webdataset in /usr/local/lib/python3.11/dist-packages (0.2.111)\n", + "Requirement already satisfied: braceexpand in /usr/local/lib/python3.11/dist-packages (from webdataset) (0.1.7)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from webdataset) (1.23.5)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.11/dist-packages (from webdataset) (6.0.2)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.11/dist-packages (2.6.0+cu124)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.11/dist-packages (0.21.0+cu124)\n", + "Requirement already satisfied: torchaudio in /usr/local/lib/python3.11/dist-packages (2.6.0+cu124)\n", + "Requirement already satisfied: torchtext in /usr/local/lib/python3.11/dist-packages (0.18.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch) (3.18.0)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.11/dist-packages (from torch) (4.13.1)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.6)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch) (2025.3.2)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /usr/local/lib/python3.11/dist-packages (from torch) (9.1.0.70)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.4.5.8 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.5.8)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.2.1.3 in /usr/local/lib/python3.11/dist-packages (from torch) (11.2.1.3)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.5.147 in /usr/local/lib/python3.11/dist-packages (from torch) (10.3.5.147)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.6.1.9 in /usr/local/lib/python3.11/dist-packages (from torch) (11.6.1.9)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.3.1.170 in /usr/local/lib/python3.11/dist-packages (from torch) (12.3.1.170)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.6.2 in /usr/local/lib/python3.11/dist-packages (from torch) (0.6.2)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n", + "Requirement already satisfied: triton==3.2.0 in /usr/local/lib/python3.11/dist-packages (from torch) (3.2.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchvision) (1.23.5)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.11/dist-packages (from torchvision) (11.1.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from torchtext) (4.67.1)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from torchtext) (2.32.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch) (3.0.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->torchtext) (2025.1.31)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " \u001b[1;31merror\u001b[0m: \u001b[1msubprocess-exited-with-error\u001b[0m\n", + " \n", + " \u001b[31m×\u001b[0m \u001b[32mpython setup.py egg_info\u001b[0m did not run successfully.\n", + " \u001b[31m│\u001b[0m exit code: \u001b[1;36m1\u001b[0m\n", + " \u001b[31m╰─>\u001b[0m See above for output.\n", + " \n", + " \u001b[1;35mnote\u001b[0m: This error originates from a subprocess, and is likely not a problem with pip.\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25herror\n", + "\u001b[1;31merror\u001b[0m: \u001b[1mmetadata-generation-failed\u001b[0m\n", + "\n", + "\u001b[31m×\u001b[0m Encountered error while generating package metadata.\n", + "\u001b[31m╰─>\u001b[0m See above for output.\n", + "\n", + "\u001b[1;35mnote\u001b[0m: This is an issue with the package mentioned above, not pip.\n", + "\u001b[1;36mhint\u001b[0m: See above for details.\n", + "\n", + "> Changing the dir to:\n", + "/content/lama\n", + "\n", + "> Download the model\n", + "Traceback (most recent call last):\n", + " File \"/usr/local/bin/yadisk-direct\", line 8, in \n", + " sys.exit(main())\n", + " ^^^^^^\n", + " File \"/usr/local/lib/python3.11/dist-packages/wldhx/yadisk_direct/main.py\", line 23, in main\n", + " print(*[get_real_direct_link(x) for x in args.sharing_link], sep=args.separator)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.11/dist-packages/wldhx/yadisk_direct/main.py\", line 23, in \n", + " print(*[get_real_direct_link(x) for x in args.sharing_link], sep=args.separator)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.11/dist-packages/wldhx/yadisk_direct/main.py\", line 12, in get_real_direct_link\n", + " return pk_request.json()['href']\n", + " ~~~~~~~~~~~~~~~~~^^^^^^^^\n", + "KeyError: 'href'\n", + "curl: no URL specified!\n", + "curl: try 'curl --help' or 'curl --manual' for more information\n", + "Archive: big-lama.zip\n", + "replace big-lama/config.yaml? [y]es, [n]o, [A]ll, [N]one, [r]ename: N\n", + ">fixing opencv\n", + "\u001b[31mERROR: Ignored the following yanked versions: 3.4.11.39, 3.4.11.41, 4.4.0.40, 4.4.0.42, 4.4.0.44, 4.5.5.62, 4.7.0.68, 4.8.0.74\u001b[0m\u001b[31m\n", + "\u001b[0m\u001b[31mERROR: Could not find a version that satisfies the requirement opencv-python-headless==4.1.2.30 (from versions: 3.4.10.37, 3.4.11.43, 3.4.11.45, 3.4.13.47, 3.4.15.55, 3.4.16.59, 3.4.17.61, 3.4.17.63, 3.4.18.65, 4.3.0.38, 4.4.0.46, 4.5.1.48, 4.5.3.56, 4.5.4.58, 4.5.4.60, 4.5.5.64, 4.6.0.66, 4.7.0.72, 4.8.0.76, 4.8.1.78, 4.9.0.80, 4.10.0.82, 4.10.0.84, 4.11.0.86)\u001b[0m\u001b[31m\n", + "\u001b[0m\u001b[31mERROR: No matching distribution found for opencv-python-headless==4.1.2.30\u001b[0m\u001b[31m\n", + "\u001b[0mRequirement already satisfied: opencv-python in /usr/local/lib/python3.11/dist-packages (4.11.0.86)\n", + "Requirement already satisfied: numpy>=1.21.2 in /usr/local/lib/python3.11/dist-packages (from opencv-python) (1.23.5)\n", + "\n", + "> Init mask-drawing code\n" + ] + } + ], + "source": [ + "#@title Run this sell to set everything up\n", + "print('\\n> Cloning the repo')\n", + "!git clone https://github.com/advimman/lama.git\n", + "\n", + "print('\\n> Install dependencies')\n", + "!pip install wldhx.yadisk-direct\n", + "!pip install --upgrade pip\n", + "!pip uninstall --yes --quiet osqp\n", + "!pip install -U scikit-survival\n", + "!pip uninstall kornia -y\n", + "!pip install kornia --no-dependencies\n", + "!pip install kornia-rs\n", + "!pip install pytorch-lightning\n", + "!pip install hydra-core\n", + "!pip install webdataset\n", + "!pip install torch torchvision torchaudio torchtext\n", + "!pip install -r lama/requirements.txt --quiet\n", + "!pip install wget --quiet\n", + "\n", + "\n", + "print('\\n> Changing the dir to:')\n", + "%cd /content/lama\n", + "\n", + "print('\\n> Download the model')\n", + "!curl -L $(yadisk-direct https://disk.yandex.ru/d/ouP6l8VJ0HpMZg) -o big-lama.zip\n", + "!unzip big-lama.zip\n", + "\n", + "print('>fixing opencv')\n", + "!pip uninstall opencv-python-headless -y --quiet\n", + "!pip install opencv-python-headless==4.1.2.30 --quiet\n", + "!pip install --upgrade opencv-python\n", + "\n", + "\n", + "print('\\n> Init mask-drawing code')\n", + "import base64, os\n", + "from IPython.display import HTML, Image\n", + "from google.colab.output import eval_js\n", + "from base64 import b64decode\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import wget\n", + "from shutil import copyfile\n", + "import shutil\n", + "\n", + "\n", + "\n", + "canvas_html = \"\"\"\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\"\"\"\n", + "\n", + "def draw(imgm, filename='drawing.png', w=400, h=200, line_width=1):\n", + " display(HTML(canvas_html % (w, h, w,h, filename.split('.')[-1], imgm, line_width)))\n", + " data = eval_js(\"data\")\n", + " binary = b64decode(data.split(',')[1])\n", + " with open(filename, 'wb') as f:\n", + " f.write(binary)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "23WaUHiJeyBO" + }, + "source": [ + "
\n", + "

Predefined photo: uncomment any line\n", + "
\n", + "Local file: leave the fname = None

\n", + "
" + ] + }, + { + "cell_type": "code", + "source": [ + "!curl -LJO https://huggingface.co/smartywu/big-lama/resolve/main/big-lama.zip" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5swBwGUy8XhN", + "outputId": "5407ba80-4f5d-4304-c34c-a0f88ac87235" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 1171 100 1171 0 0 2459 0 --:--:-- --:--:-- --:--:-- 2454\n", + "Warning: Failed to create the file big-lama.zip: File exists\n", + " 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\n", + "curl: (23) Failed writing header\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!unzip /content/lama/big-lama.zip" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MIpfCN6y8gzT", + "outputId": "27c59706-5b34-4ce5-b832-46ccf00c11b3" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Archive: /content/lama/big-lama.zip\n", + "replace big-lama/config.yaml? [y]es, [n]o, [A]ll, [N]one, [r]ename: N\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "IFIDDD4IhPXd" + }, + "outputs": [], + "source": [ + "fname = None\n", + "# fname = 'https://ic.pics.livejournal.com/mostovoy/28566193/1224276/1224276_original.jpg' # <-in the example\n", + "# fname = 'https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/images/1010286.jpeg'\n", + "# fname = 'https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/images/1010287.jpeg'\n", + "# fname = \"https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/images/alex.jpg\"" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip uninstall opencv-python opencv-python-headless numpy -y" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4vUw-aOS1wLS", + "outputId": "4a2317b6-fb21-4d32-8dfe-9bc12dc43214" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[33mWARNING: Skipping opencv-python as it is not installed.\u001b[0m\u001b[33m\n", + "\u001b[0mFound existing installation: opencv-python-headless 4.5.5.64\n", + "Uninstalling opencv-python-headless-4.5.5.64:\n", + " Successfully uninstalled opencv-python-headless-4.5.5.64\n", + "Found existing installation: numpy 2.0.2\n", + "Uninstalling numpy-2.0.2:\n", + " Successfully uninstalled numpy-2.0.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install opencv-python-headless numpy" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1g9bT3Xd1xrn", + "outputId": "a56a576d-e43e-48af-c6e8-0af25aa69d4f" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting opencv-python-headless\n", + " Downloading opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (20 kB)\n", + "Collecting numpy\n", + " Downloading numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (62 kB)\n", + "Downloading opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (50.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.0/50.0 MB\u001b[0m \u001b[31m68.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.4/16.4 MB\u001b[0m \u001b[31m152.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: numpy, opencv-python-headless\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "dopamine-rl 4.1.2 requires opencv-python>=3.4.8.29, which is not installed.\n", + "tensorflow 2.18.0 requires numpy<2.1.0,>=1.26.0, but you have numpy 2.2.4 which is incompatible.\n", + "numba 0.60.0 requires numpy<2.1,>=1.22, but you have numpy 2.2.4 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed numpy-2.2.4 opencv-python-headless-4.11.0.86\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "jEwWGufL4ftv" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip install albumentations==0.5.2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DB9TbPez13IU", + "outputId": "9bd12bab-ad7a-47ef-bdcb-cc606fb49036" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting albumentations==0.5.2\n", + " Using cached albumentations-0.5.2-py3-none-any.whl.metadata (30 kB)\n", + "Requirement already satisfied: numpy>=1.11.1 in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (2.2.4)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (1.14.1)\n", + "Requirement already satisfied: scikit-image>=0.16.1 in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (0.25.2)\n", + "Collecting imgaug>=0.4.0 (from albumentations==0.5.2)\n", + " Using cached imgaug-0.4.0-py2.py3-none-any.whl.metadata (1.8 kB)\n", + "Requirement already satisfied: PyYAML in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (6.0.2)\n", + "Requirement already satisfied: opencv-python-headless>=4.1.1 in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (4.11.0.86)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.11/dist-packages (from imgaug>=0.4.0->albumentations==0.5.2) (1.17.0)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.11/dist-packages (from imgaug>=0.4.0->albumentations==0.5.2) (11.1.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (from imgaug>=0.4.0->albumentations==0.5.2) (3.10.0)\n", + "Collecting opencv-python (from imgaug>=0.4.0->albumentations==0.5.2)\n", + " Using cached opencv_python-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (20 kB)\n", + "Requirement already satisfied: imageio in /usr/local/lib/python3.11/dist-packages (from imgaug>=0.4.0->albumentations==0.5.2) (2.37.0)\n", + "Requirement already satisfied: Shapely in /usr/local/lib/python3.11/dist-packages (from imgaug>=0.4.0->albumentations==0.5.2) (2.1.0)\n", + "Requirement already satisfied: networkx>=3.0 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (3.4.2)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (2025.3.30)\n", + "Requirement already satisfied: packaging>=21 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (24.2)\n", + "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (0.4)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug>=0.4.0->albumentations==0.5.2) (1.3.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug>=0.4.0->albumentations==0.5.2) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug>=0.4.0->albumentations==0.5.2) (4.57.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug>=0.4.0->albumentations==0.5.2) (1.4.8)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug>=0.4.0->albumentations==0.5.2) (3.2.3)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug>=0.4.0->albumentations==0.5.2) (2.8.2)\n", + "Using cached albumentations-0.5.2-py3-none-any.whl (72 kB)\n", + "Using cached imgaug-0.4.0-py2.py3-none-any.whl (948 kB)\n", + "Using cached opencv_python-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (63.0 MB)\n", + "Installing collected packages: opencv-python, imgaug, albumentations\n", + " Attempting uninstall: albumentations\n", + " Found existing installation: albumentations 2.0.5\n", + " Uninstalling albumentations-2.0.5:\n", + " Successfully uninstalled albumentations-2.0.5\n", + "Successfully installed albumentations-0.5.2 imgaug-0.4.0 opencv-python-4.11.0.86\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install numpy==1.23.5 albumentations==0.5.2 imgaug==0.4.0 opencv-python-headless==4.5.5.64" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XVLrybYu4hK8", + "outputId": "768cd054-02dc-4395-e1aa-3811be1fe016" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: numpy==1.23.5 in /usr/local/lib/python3.11/dist-packages (1.23.5)\n", + "Requirement already satisfied: albumentations==0.5.2 in /usr/local/lib/python3.11/dist-packages (0.5.2)\n", + "Requirement already satisfied: imgaug==0.4.0 in /usr/local/lib/python3.11/dist-packages (0.4.0)\n", + "Collecting opencv-python-headless==4.5.5.64\n", + " Using cached opencv_python_headless-4.5.5.64-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (18 kB)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (1.14.1)\n", + "Requirement already satisfied: scikit-image>=0.16.1 in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (0.24.0)\n", + "Requirement already satisfied: PyYAML in /usr/local/lib/python3.11/dist-packages (from albumentations==0.5.2) (6.0.2)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.11/dist-packages (from imgaug==0.4.0) (1.17.0)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.11/dist-packages (from imgaug==0.4.0) (11.1.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (from imgaug==0.4.0) (3.10.0)\n", + "Requirement already satisfied: opencv-python in /usr/local/lib/python3.11/dist-packages (from imgaug==0.4.0) (4.11.0.86)\n", + "Requirement already satisfied: imageio in /usr/local/lib/python3.11/dist-packages (from imgaug==0.4.0) (2.37.0)\n", + "Requirement already satisfied: Shapely in /usr/local/lib/python3.11/dist-packages (from imgaug==0.4.0) (2.1.0)\n", + "Requirement already satisfied: networkx>=2.8 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (3.4.2)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (2025.3.30)\n", + "Requirement already satisfied: packaging>=21 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (24.2)\n", + "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.11/dist-packages (from scikit-image>=0.16.1->albumentations==0.5.2) (0.4)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug==0.4.0) (1.3.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug==0.4.0) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug==0.4.0) (4.57.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug==0.4.0) (1.4.8)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug==0.4.0) (3.2.3)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib->imgaug==0.4.0) (2.8.2)\n", + "Using cached opencv_python_headless-4.5.5.64-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (47.8 MB)\n", + "Installing collected packages: opencv-python-headless\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "albucore 0.0.23 requires numpy>=1.24.4, but you have numpy 1.23.5 which is incompatible.\n", + "albucore 0.0.23 requires opencv-python-headless>=4.9.0.80, but you have opencv-python-headless 4.5.5.64 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed opencv-python-headless-4.5.5.64\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "tzturnvI6dds" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "-VZWySTMeGDM", + "outputId": "1492a8c7-bf30-470d-bcea-544168464853" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving hcehf.jpg to hcehf.jpg\n", + "Will use ./data_for_prediction/hcehf.jpg for inpainting\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Run inpainting\n", + "Detectron v2 is not installed\n", + "/content/lama/bin/predict.py:38: UserWarning: \n", + "The version_base parameter is not specified.\n", + "Please specify a compatability version level, or None.\n", + "Will assume defaults for version 1.1\n", + " @hydra.main(config_path='../configs/prediction', config_name='default.yaml')\n", + "/usr/local/lib/python3.11/dist-packages/hydra/_internal/hydra.py:119: UserWarning: Future Hydra versions will no longer change working directory at job runtime by default.\n", + "See https://hydra.cc/docs/1.2/upgrades/1.1_to_1.2/changes_to_job_working_dir/ for more information.\n", + " ret = run_job(\n", + "[2025-04-13 11:57:13,465][saicinpainting.utils][WARNING] - Setting signal 10 handler \n", + "[2025-04-13 11:57:13,486][root][INFO] - Make training model default\n", + "[2025-04-13 11:57:13,486][saicinpainting.training.trainers.base][INFO] - BaseInpaintingTrainingModule init called\n", + "[2025-04-13 11:57:13,487][root][INFO] - Make generator ffc_resnet\n", + "[2025-04-13 11:57:14,198][saicinpainting.training.trainers.base][INFO] - Generator\n", + "FFCResNetGenerator(\n", + " (model): Sequential(\n", + " (0): ReflectionPad2d((3, 3, 3, 3))\n", + " (1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(4, 64, kernel_size=(7, 7), stride=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Identity()\n", + " (convg2l): Identity()\n", + " (convg2g): Identity()\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): Identity()\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): Identity()\n", + " )\n", + " (2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Identity()\n", + " (convg2l): Identity()\n", + " (convg2g): Identity()\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): Identity()\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): Identity()\n", + " )\n", + " (3): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Identity()\n", + " (convg2l): Identity()\n", + " (convg2g): Identity()\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): Identity()\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): Identity()\n", + " )\n", + " (4): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(256, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(256, 384, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Identity()\n", + " (convg2g): Identity()\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (5): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (6): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (7): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (8): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (9): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (10): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (11): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (12): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (13): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (14): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (15): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (16): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (17): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (18): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (19): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (20): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (21): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (22): FFCResnetBlock(\n", + " (conv1): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " (conv2): FFC_BN_ACT(\n", + " (ffc): FFC(\n", + " (convl2l): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convl2g): Conv2d(128, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2l): Conv2d(384, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False, padding_mode=reflect)\n", + " (convg2g): SpectralTransform(\n", + " (downsample): Identity()\n", + " (conv1): Sequential(\n", + " (0): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (fu): FourierUnit(\n", + " (conv_layer): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (conv2): Conv2d(192, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " (gate): Identity()\n", + " )\n", + " (bn_l): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (bn_g): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (act_l): ReLU(inplace=True)\n", + " (act_g): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (23): ConcatTupleLayer()\n", + " (24): ConvTranspose2d(512, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n", + " (25): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (26): ReLU(inplace=True)\n", + " (27): ConvTranspose2d(256, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n", + " (28): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (29): ReLU(inplace=True)\n", + " (30): ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n", + " (31): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (32): ReLU(inplace=True)\n", + " (33): ReflectionPad2d((3, 3, 3, 3))\n", + " (34): Conv2d(64, 3, kernel_size=(7, 7), stride=(1, 1))\n", + " (35): Sigmoid()\n", + " )\n", + ")\n", + "[2025-04-13 11:57:14,266][saicinpainting.training.trainers.base][INFO] - BaseInpaintingTrainingModule init done\n", + "[2025-04-13 11:57:14,982][saicinpainting.training.data.datasets][INFO] - Make val dataloader default from /content/lama/data_for_prediction/\n", + "100% 1/1 [00:01<00:00, 1.45s/it]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "fname = None\n", + "# fname = 'https://ic.pics.livejournal.com/mostovoy/28566193/1224276/1224276_original.jpg' # <-in the example\n", + "# fname = 'https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/images/1010286.jpeg'\n", + "# fname = 'https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/images/1010287.jpeg'\n", + "# fname = \"https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/images/alex.jpg\"\n", + "\n", + "#@title Draw a Mask, Press Finish, Wait for Inpainting\n", + "\n", + "if fname is None:\n", + " from google.colab import files\n", + " files = files.upload()\n", + " fname = list(files.keys())[0]\n", + "else:\n", + " fname = wget.download(fname)\n", + "\n", + "shutil.rmtree('./data_for_prediction', ignore_errors=True)\n", + "!mkdir data_for_prediction\n", + "\n", + "copyfile(fname, f'./data_for_prediction/{fname}')\n", + "os.remove(fname)\n", + "fname = f'./data_for_prediction/{fname}'\n", + "\n", + "image64 = base64.b64encode(open(fname, 'rb').read())\n", + "image64 = image64.decode('utf-8')\n", + "\n", + "print(f'Will use {fname} for inpainting')\n", + "img = np.array(plt.imread(f'{fname}')[:,:,:3])\n", + "\n", + "draw(image64, filename=f\"./{fname.split('.')[1]}_mask.png\", w=img.shape[1], h=img.shape[0], line_width=0.04*img.shape[1])\n", + "#@title Show a masked image and save a mask\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams[\"figure.figsize\"] = (15,5)\n", + "plt.rcParams['figure.dpi'] = 200\n", + "plt.subplot(131)\n", + "with_mask = np.array(plt.imread(f\"./{fname.split('.')[1]}_mask.png\")[:,:,:3])\n", + "mask = (with_mask[:,:,0]==1)*(with_mask[:,:,1]==0)*(with_mask[:,:,2]==0)\n", + "plt.imshow(mask, cmap='gray')\n", + "plt.axis('off')\n", + "plt.title('mask')\n", + "plt.imsave(f\"./{fname.split('.')[1]}_mask.png\",mask, cmap='gray')\n", + "\n", + "plt.subplot(132)\n", + "img = np.array(plt.imread(f'{fname}')[:,:,:3])\n", + "plt.imshow(img)\n", + "plt.axis('off')\n", + "plt.title('img')\n", + "\n", + "plt.subplot(133)\n", + "img = np.array((1-mask.reshape(mask.shape[0], mask.shape[1], -1))*plt.imread(fname)[:,:,:3])\n", + "_=plt.imshow(img)\n", + "_=plt.axis('off')\n", + "_=plt.title('img * mask')\n", + "plt.show()\n", + "\n", + "print('Run inpainting')\n", + "if '.jpeg' in fname:\n", + " !PYTHONPATH=. TORCH_HOME=$(pwd) python3 bin/predict.py model.path=$(pwd)/big-lama indir=$(pwd)/data_for_prediction outdir=/content/output dataset.img_suffix=.jpeg\n", + "elif '.jpg' in fname:\n", + " !PYTHONPATH=. TORCH_HOME=$(pwd) python3 bin/predict.py model.path=$(pwd)/big-lama indir=$(pwd)/data_for_prediction outdir=/content/output dataset.img_suffix=.jpg\n", + "elif '.png' in fname:\n", + " !PYTHONPATH=. TORCH_HOME=$(pwd) python3 bin/predict.py model.path=$(pwd)/big-lama indir=$(pwd)/data_for_prediction outdir=/content/output dataset.img_suffix=.png\n", + "else:\n", + " print(f'Error: unknown suffix .{fname.split(\".\")[-1]} use [.png, .jpeg, .jpg]')\n", + "\n", + "plt.rcParams['figure.dpi'] = 200\n", + "plt.imshow(plt.imread(f\"/content/output/{fname.split('.')[1].split('/')[2]}_mask.png\"))\n", + "_=plt.axis('off')\n", + "_=plt.title('inpainting result')\n", + "plt.show()\n", + "fname = None" + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "files.download('/content/')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "GalFFift9JJf", + "outputId": "1c71fdc1-e3e4-45df-8d10-69a28a6377d6" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_c2cf6bf0-3866-47f4-bae7-0961cab324ab\", \"\", 4096)" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "0d1jxHLr1kHK" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/saicinpainting/training/trainers/__init__.py b/saicinpainting/training/trainers/__init__.py index c59241f5..5f604f49 100644 --- a/saicinpainting/training/trainers/__init__.py +++ b/saicinpainting/training/trainers/__init__.py @@ -24,7 +24,7 @@ def make_training_model(config): def load_checkpoint(train_config, path, map_location='cuda', strict=True): model: torch.nn.Module = make_training_model(train_config) - state = torch.load(path, map_location=map_location) + state = torch.load(path, map_location=map_location, weights_only=False) model.load_state_dict(state['state_dict'], strict=strict) model.on_load_checkpoint(state) return model