Text2Image_v2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Text2Image_v2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tg-bomze/collection-of-notebooks/blob/master/Text2Image_v2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iM9oQbE6tvTK"
      },
      "source": [
        "<b><font color=\"black\" size=\"+4\">Text2Image v.2.0</font></b>\r\n",
        "\r\n",
        "<b><font color=\"black\" size=\"+2\">Based on:</font></b>\r\n",
        "\r\n",
        "**GitHub repository**: [CLIP](https://github.com/openai/CLIP), [BigGAN](https://github.com/ajbrock/BigGAN-PyTorch)\r\n",
        "\r\n",
        "Article: [Learning Transferable Visual Models From Natural Language Supervision](https://cdn.openai.com/papers/Learning_Transferable_Visual_Models_From_Natural_Language_Supervision.pdf)\r\n",
        "\r\n",
        "Creator: **[OpenAI](https://openai.com/)**\r\n",
        "\r\n",
        "Colab based on **[Ryan Murdock's](https://rynmurdock.github.io/)** [notebook](https://colab.research.google.com/drive/1NCceX2mbiKOSlAd_o7IU7nA9UskKN5WR).\r\n",
        "\r\n",
        "<b><font color=\"black\" size=\"+2\">Colab created by:</font></b>\r\n",
        "\r\n",
        "GitHub: [@tg-bomze](https://github.com/tg-bomze),\r\n",
        "Telegram: [@bomze](https://t.me/bomze),\r\n",
        "Twitter: [@tg_bomze](https://twitter.com/tg_bomze).\r\n",
        "\r\n",
        "---\r\n",
        "\r\n",
        "\r\n",
        "```\r\n",
        "(ENG) To get started, click on the button (where the red arrow indicates). After clicking, wait until the execution is complete.\r\n",
        "```\r\n",
        "```\r\n",
        "(RUS) Чтобы начать, поочередно нажимайте на кнопки (куда указывают красные стрелки), дожидаясь завершения выполнения каждого блока.\r\n",
        "```\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "etzxXVZ_r-Nf",
        "cellView": "form"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Install all necessary libraries</font></b>\r\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Установить все необходимые библиотеки</font></b>\r\n",
        "\r\n",
        "try: \r\n",
        "  !pip3 install googletrans==3.1.0a0\r\n",
        "  from googletrans import Translator, constants\r\n",
        "  from pprint import pprint\r\n",
        "  translator = Translator()\r\n",
        "except: pass\r\n",
        "\r\n",
        "import subprocess\r\n",
        "CUDA_version = [s for s in subprocess.check_output([\"nvcc\", \"--version\"]).decode(\"UTF-8\").split(\", \") if s.startswith(\"release\")][0].split(\" \")[-1]\r\n",
        "print(\"CUDA version:\", CUDA_version)\r\n",
        "\r\n",
        "if CUDA_version == \"10.0\":\r\n",
        "    torch_version_suffix = \"+cu100\"\r\n",
        "elif CUDA_version == \"10.1\":\r\n",
        "    torch_version_suffix = \"+cu101\"\r\n",
        "elif CUDA_version == \"10.2\":\r\n",
        "    torch_version_suffix = \"\"\r\n",
        "else:\r\n",
        "    torch_version_suffix = \"+cu110\"\r\n",
        "\r\n",
        "!pip install torch==1.7.1{torch_version_suffix} torchvision==0.8.2{torch_version_suffix} -f https://download.pytorch.org/whl/torch_stable.html ftfy regex\r\n",
        "\r\n",
        "import torch\r\n",
        "import numpy as np\r\n",
        "import torchvision\r\n",
        "import torchvision.transforms.functional as TF\r\n",
        "\r\n",
        "import PIL\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "\r\n",
        "import os\r\n",
        "import random\r\n",
        "import imageio\r\n",
        "from IPython import display\r\n",
        "from IPython.core.interactiveshell import InteractiveShell\r\n",
        "InteractiveShell.ast_node_interactivity = \"all\"\r\n",
        "\r\n",
        "import glob\r\n",
        "\r\n",
        "from google.colab import output\r\n",
        "\r\n",
        "%cd /content/\r\n",
        "!git clone https://github.com/openai/CLIP.git\r\n",
        "%cd /content/CLIP/\r\n",
        "!pip install ftfy\r\n",
        "import os\r\n",
        "import clip\r\n",
        "import torch\r\n",
        "import numpy as np\r\n",
        "perceptor, preprocess = clip.load('ViT-B/32')\r\n",
        "\r\n",
        "!mkdir frames\r\n",
        "#import moviepy.editor as mpy\r\n",
        "#from moviepy.video.io.ffmpeg_writer import FFMPEG_VideoWriter\r\n",
        "from google.colab import files\r\n",
        "import warnings\r\n",
        "from IPython.display import clear_output\r\n",
        "import matplotlib.pyplot as plt\r\n",
        "warnings.filterwarnings(\"ignore\")\r\n",
        "%matplotlib inline\r\n",
        "clear_output()\r\n",
        "!nvidia-smi -L\r\n",
        "print('\\nDone!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gCj1wr8pOqOe",
        "trusted": true,
        "cellView": "form"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Define some helper functions</font></b>\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Определить несколько вспомогательных функций</font></b>\n",
        "\n",
        "def displ(img, pre_scaled=True):\n",
        "  img = np.array(img)[:,:,:]\n",
        "  img = np.transpose(img, (1, 2, 0))\n",
        "  if not pre_scaled:\n",
        "    img = scale(img, 48*4, 32*4)\n",
        "  imageio.imwrite('result.png', np.array(img))\n",
        "  file_path = '/content/CLIP/frames/{}.png'.format(str(len(os.listdir('/content/CLIP/frames'))).zfill(5))\n",
        "  imageio.imwrite(file_path, np.array(img))\n",
        "  return display.Image('result.png')\n",
        "\n",
        "def gallery(array, ncols=2):\n",
        "    nindex, height, width, intensity = array.shape\n",
        "    nrows = nindex//ncols\n",
        "    assert nindex == nrows*ncols\n",
        "    # want result.shape = (height*nrows, width*ncols, intensity)\n",
        "    result = (array.reshape(nrows, ncols, height, width, intensity)\n",
        "              .swapaxes(1,2)\n",
        "              .reshape(height*nrows, width*ncols, intensity))\n",
        "    return result\n",
        "\n",
        "def card_padded(im, to_pad=3):\n",
        "  return np.pad(np.pad(np.pad(im, [[1,1], [1,1], [0,0]],constant_values=0), [[2,2], [2,2], [0,0]],constant_values=1),\n",
        "            [[to_pad,to_pad], [to_pad,to_pad], [0,0]],constant_values=0)\n",
        "\n",
        "def get_all(img):\n",
        "  img = np.transpose(img, (0,2,3,1))\n",
        "  cards = np.zeros((img.shape[0], sideX+12, sideY+12, 3))\n",
        "  for i in range(len(img)):\n",
        "    cards[i] = card_padded(img[i])\n",
        "  print(img.shape)\n",
        "  cards = gallery(cards)\n",
        "  imageio.imwrite('result.png', np.array(cards))\n",
        "  file_path = '/content/CLIP/frames/{}.png'.format(str(len(os.listdir('/content/CLIP/frames'))).zfill(5))\n",
        "  imageio.imwrite(file_path, np.array(cards))\n",
        "  return display.Image('result.png')\n",
        "\n",
        "!pip install pytorch-pretrained-biggan\n",
        "\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import math\n",
        "import json\n",
        "import logging\n",
        "import os\n",
        "import shutil\n",
        "import tempfile\n",
        "from functools import wraps\n",
        "from hashlib import sha256\n",
        "import sys\n",
        "from io import open\n",
        "\n",
        "import boto3\n",
        "import requests\n",
        "from botocore.exceptions import ClientError\n",
        "from tqdm import tqdm\n",
        "\n",
        "try:\n",
        "    from urllib.parse import urlparse\n",
        "except ImportError:\n",
        "    from urlparse import urlparse\n",
        "\n",
        "try:\n",
        "    from pathlib import Path\n",
        "    PYTORCH_PRETRAINED_BIGGAN_CACHE = Path(os.getenv('PYTORCH_PRETRAINED_BIGGAN_CACHE',\n",
        "                                                   Path.home() / '.pytorch_pretrained_biggan'))\n",
        "except (AttributeError, ImportError):\n",
        "    PYTORCH_PRETRAINED_BIGGAN_CACHE = os.getenv('PYTORCH_PRETRAINED_BIGGAN_CACHE',\n",
        "                                              os.path.join(os.path.expanduser(\"~\"), '.pytorch_pretrained_biggan'))\n",
        "\n",
        "logger = logging.getLogger(__name__)  # pylint: disable=invalid-name\n",
        "\n",
        "\n",
        "def url_to_filename(url, etag=None):\n",
        "    \"\"\"\n",
        "    Convert `url` into a hashed filename in a repeatable way.\n",
        "    If `etag` is specified, append its hash to the url's, delimited\n",
        "    by a period.\n",
        "    \"\"\"\n",
        "    url_bytes = url.encode('utf-8')\n",
        "    url_hash = sha256(url_bytes)\n",
        "    filename = url_hash.hexdigest()\n",
        "\n",
        "    if etag:\n",
        "        etag_bytes = etag.encode('utf-8')\n",
        "        etag_hash = sha256(etag_bytes)\n",
        "        filename += '.' + etag_hash.hexdigest()\n",
        "\n",
        "    return filename\n",
        "\n",
        "\n",
        "def filename_to_url(filename, cache_dir=None):\n",
        "    \"\"\"\n",
        "    Return the url and etag (which may be ``None``) stored for `filename`.\n",
        "    Raise ``EnvironmentError`` if `filename` or its stored metadata do not exist.\n",
        "    \"\"\"\n",
        "    if cache_dir is None:\n",
        "        cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE\n",
        "    if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n",
        "        cache_dir = str(cache_dir)\n",
        "\n",
        "    cache_path = os.path.join(cache_dir, filename)\n",
        "    if not os.path.exists(cache_path):\n",
        "        raise EnvironmentError(\"file {} not found\".format(cache_path))\n",
        "\n",
        "    meta_path = cache_path + '.json'\n",
        "    if not os.path.exists(meta_path):\n",
        "        raise EnvironmentError(\"file {} not found\".format(meta_path))\n",
        "\n",
        "    with open(meta_path, encoding=\"utf-8\") as meta_file:\n",
        "        metadata = json.load(meta_file)\n",
        "    url = metadata['url']\n",
        "    etag = metadata['etag']\n",
        "\n",
        "    return url, etag\n",
        "\n",
        "\n",
        "def cached_path(url_or_filename, cache_dir=None):\n",
        "    \"\"\"\n",
        "    Given something that might be a URL (or might be a local path),\n",
        "    determine which. If it's a URL, download the file and cache it, and\n",
        "    return the path to the cached file. If it's already a local path,\n",
        "    make sure the file exists and then return the path.\n",
        "    \"\"\"\n",
        "    if cache_dir is None:\n",
        "        cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE\n",
        "    if sys.version_info[0] == 3 and isinstance(url_or_filename, Path):\n",
        "        url_or_filename = str(url_or_filename)\n",
        "    if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n",
        "        cache_dir = str(cache_dir)\n",
        "\n",
        "    parsed = urlparse(url_or_filename)\n",
        "\n",
        "    if parsed.scheme in ('http', 'https', 's3'):\n",
        "        # URL, so get it from the cache (downloading if necessary)\n",
        "        return get_from_cache(url_or_filename, cache_dir)\n",
        "    elif os.path.exists(url_or_filename):\n",
        "        # File, and it exists.\n",
        "        return url_or_filename\n",
        "    elif parsed.scheme == '':\n",
        "        # File, but it doesn't exist.\n",
        "        raise EnvironmentError(\"file {} not found\".format(url_or_filename))\n",
        "    else:\n",
        "        # Something unknown\n",
        "        raise ValueError(\"unable to parse {} as a URL or as a local path\".format(url_or_filename))\n",
        "\n",
        "\n",
        "def split_s3_path(url):\n",
        "    \"\"\"Split a full s3 path into the bucket name and path.\"\"\"\n",
        "    parsed = urlparse(url)\n",
        "    if not parsed.netloc or not parsed.path:\n",
        "        raise ValueError(\"bad s3 path {}\".format(url))\n",
        "    bucket_name = parsed.netloc\n",
        "    s3_path = parsed.path\n",
        "    # Remove '/' at beginning of path.\n",
        "    if s3_path.startswith(\"/\"):\n",
        "        s3_path = s3_path[1:]\n",
        "    return bucket_name, s3_path\n",
        "\n",
        "\n",
        "def s3_request(func):\n",
        "    \"\"\"\n",
        "    Wrapper function for s3 requests in order to create more helpful error\n",
        "    messages.\n",
        "    \"\"\"\n",
        "\n",
        "    @wraps(func)\n",
        "    def wrapper(url, *args, **kwargs):\n",
        "        try:\n",
        "            return func(url, *args, **kwargs)\n",
        "        except ClientError as exc:\n",
        "            if int(exc.response[\"Error\"][\"Code\"]) == 404:\n",
        "                raise EnvironmentError(\"file {} not found\".format(url))\n",
        "            else:\n",
        "                raise\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "\n",
        "@s3_request\n",
        "def s3_etag(url):\n",
        "    \"\"\"Check ETag on S3 object.\"\"\"\n",
        "    s3_resource = boto3.resource(\"s3\")\n",
        "    bucket_name, s3_path = split_s3_path(url)\n",
        "    s3_object = s3_resource.Object(bucket_name, s3_path)\n",
        "    return s3_object.e_tag\n",
        "\n",
        "\n",
        "@s3_request\n",
        "def s3_get(url, temp_file):\n",
        "    \"\"\"Pull a file directly from S3.\"\"\"\n",
        "    s3_resource = boto3.resource(\"s3\")\n",
        "    bucket_name, s3_path = split_s3_path(url)\n",
        "    s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file)\n",
        "\n",
        "\n",
        "def http_get(url, temp_file):\n",
        "    req = requests.get(url, stream=True)\n",
        "    content_length = req.headers.get('Content-Length')\n",
        "    total = int(content_length) if content_length is not None else None\n",
        "    progress = tqdm(unit=\"B\", total=total)\n",
        "    for chunk in req.iter_content(chunk_size=1024):\n",
        "        if chunk: # filter out keep-alive new chunks\n",
        "            progress.update(len(chunk))\n",
        "            temp_file.write(chunk)\n",
        "    progress.close()\n",
        "\n",
        "\n",
        "def get_from_cache(url, cache_dir=None):\n",
        "    \"\"\"\n",
        "    Given a URL, look for the corresponding dataset in the local cache.\n",
        "    If it's not there, download it. Then return the path to the cached file.\n",
        "    \"\"\"\n",
        "    if cache_dir is None:\n",
        "        cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE\n",
        "    if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n",
        "        cache_dir = str(cache_dir)\n",
        "\n",
        "    if not os.path.exists(cache_dir):\n",
        "        os.makedirs(cache_dir)\n",
        "\n",
        "    # Get eTag to add to filename, if it exists.\n",
        "    if url.startswith(\"s3://\"):\n",
        "        etag = s3_etag(url)\n",
        "    else:\n",
        "        response = requests.head(url, allow_redirects=True)\n",
        "        if response.status_code != 200:\n",
        "            raise IOError(\"HEAD request failed for url {} with status code {}\"\n",
        "                          .format(url, response.status_code))\n",
        "        etag = response.headers.get(\"ETag\")\n",
        "\n",
        "    filename = url_to_filename(url, etag)\n",
        "\n",
        "    # get cache path to put the file\n",
        "    cache_path = os.path.join(cache_dir, filename)\n",
        "\n",
        "    if not os.path.exists(cache_path):\n",
        "        # Download to temporary file, then copy to cache dir once finished.\n",
        "        # Otherwise you get corrupt cache entries if the download gets interrupted.\n",
        "        with tempfile.NamedTemporaryFile() as temp_file:\n",
        "            logger.info(\"%s not found in cache, downloading to %s\", url, temp_file.name)\n",
        "\n",
        "            # GET file object\n",
        "            if url.startswith(\"s3://\"):\n",
        "                s3_get(url, temp_file)\n",
        "            else:\n",
        "                http_get(url, temp_file)\n",
        "\n",
        "            # we are copying the file before closing it, so flush to avoid truncation\n",
        "            temp_file.flush()\n",
        "            # shutil.copyfileobj() starts at the current position, so go to the start\n",
        "            temp_file.seek(0)\n",
        "\n",
        "            logger.info(\"copying %s to cache at %s\", temp_file.name, cache_path)\n",
        "            with open(cache_path, 'wb') as cache_file:\n",
        "                shutil.copyfileobj(temp_file, cache_file)\n",
        "\n",
        "            logger.info(\"creating metadata file for %s\", cache_path)\n",
        "            meta = {'url': url, 'etag': etag}\n",
        "            meta_path = cache_path + '.json'\n",
        "            with open(meta_path, 'w', encoding=\"utf-8\") as meta_file:\n",
        "                json.dump(meta, meta_file)\n",
        "\n",
        "            logger.info(\"removing temp file %s\", temp_file.name)\n",
        "\n",
        "    return cache_path\n",
        "\n",
        "\n",
        "def read_set_from_file(filename):\n",
        "    '''\n",
        "    Extract a de-duped collection (set) of text from a file.\n",
        "    Expected file format is one item per line.\n",
        "    '''\n",
        "    collection = set()\n",
        "    with open(filename, 'r', encoding='utf-8') as file_:\n",
        "        for line in file_:\n",
        "            collection.add(line.rstrip())\n",
        "    return collection\n",
        "\n",
        "\n",
        "def get_file_extension(path, dot=True, lower=True):\n",
        "    ext = os.path.splitext(path)[1]\n",
        "    ext = ext if dot else ext[1:]\n",
        "    return ext.lower() if lower else ext\n",
        "\n",
        "\n",
        "PRETRAINED_MODEL_ARCHIVE_MAP = {\n",
        "    'biggan-deep-128': \"https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-128-pytorch_model.bin\",\n",
        "    'biggan-deep-256': \"https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-256-pytorch_model.bin\",\n",
        "    'biggan-deep-512': \"https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-512-pytorch_model.bin\",\n",
        "}\n",
        "\n",
        "PRETRAINED_CONFIG_ARCHIVE_MAP = {\n",
        "    'biggan-deep-128': \"https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-128-config.json\",\n",
        "    'biggan-deep-256': \"https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-256-config.json\",\n",
        "    'biggan-deep-512': \"https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-512-config.json\",\n",
        "}\n",
        "\n",
        "WEIGHTS_NAME = 'pytorch_model.bin'\n",
        "CONFIG_NAME = 'config.json'\n",
        "import copy\n",
        "import json\n",
        "\n",
        "class BigGANConfig(object):\n",
        "    \"\"\" Configuration class to store the configuration of a `BigGAN`. \n",
        "        Defaults are for the 128x128 model.\n",
        "        layers tuple are (up-sample in the layer ?, input channels, output channels)\n",
        "    \"\"\"\n",
        "    def __init__(self,\n",
        "                 output_dim=128,\n",
        "                 z_dim=128,\n",
        "                 class_embed_dim=128,\n",
        "                 channel_width=128,\n",
        "                 num_classes=1000,\n",
        "                 layers=[(False, 16, 16),\n",
        "                         (True, 16, 16),\n",
        "                         (False, 16, 16),\n",
        "                         (True, 16, 8),\n",
        "                         (False, 8, 8),\n",
        "                         (True, 8, 4),\n",
        "                         (False, 4, 4),\n",
        "                         (True, 4, 2),\n",
        "                         (False, 2, 2),\n",
        "                         (True, 2, 1)],\n",
        "                 attention_layer_position=8,\n",
        "                 eps=1e-4,\n",
        "                 n_stats=51):\n",
        "        \"\"\"Constructs BigGANConfig. \"\"\"\n",
        "        self.output_dim = output_dim\n",
        "        self.z_dim = z_dim\n",
        "        self.class_embed_dim = class_embed_dim\n",
        "        self.channel_width = channel_width\n",
        "        self.num_classes = num_classes\n",
        "        self.layers = layers\n",
        "        self.attention_layer_position = attention_layer_position\n",
        "        self.eps = eps\n",
        "        self.n_stats = n_stats\n",
        "\n",
        "    @classmethod\n",
        "    def from_dict(cls, json_object):\n",
        "        \"\"\"Constructs a `BigGANConfig` from a Python dictionary of parameters.\"\"\"\n",
        "        config = BigGANConfig()\n",
        "        for key, value in json_object.items():\n",
        "            config.__dict__[key] = value\n",
        "        return config\n",
        "\n",
        "    @classmethod\n",
        "    def from_json_file(cls, json_file):\n",
        "        \"\"\"Constructs a `BigGANConfig` from a json file of parameters.\"\"\"\n",
        "        with open(json_file, \"r\", encoding='utf-8') as reader:\n",
        "            text = reader.read()\n",
        "        return cls.from_dict(json.loads(text))\n",
        "\n",
        "    def __repr__(self):\n",
        "        return str(self.to_json_string())\n",
        "\n",
        "    def to_dict(self):\n",
        "        \"\"\"Serializes this instance to a Python dictionary.\"\"\"\n",
        "        output = copy.deepcopy(self.__dict__)\n",
        "        return output\n",
        "\n",
        "    def to_json_string(self):\n",
        "        \"\"\"Serializes this instance to a JSON string.\"\"\"\n",
        "        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + \"\\n\"\n",
        "\n",
        "\n",
        "def snconv2d(eps=1e-12, **kwargs):\n",
        "    return nn.utils.spectral_norm(nn.Conv2d(**kwargs), eps=eps)\n",
        "\n",
        "def snlinear(eps=1e-12, **kwargs):\n",
        "    return nn.utils.spectral_norm(nn.Linear(**kwargs), eps=eps)\n",
        "\n",
        "def sn_embedding(eps=1e-12, **kwargs):\n",
        "    return nn.utils.spectral_norm(nn.Embedding(**kwargs), eps=eps)\n",
        "\n",
        "class SelfAttn(nn.Module):\n",
        "    \"\"\" Self attention Layer\"\"\"\n",
        "    def __init__(self, in_channels, eps=1e-12):\n",
        "        super(SelfAttn, self).__init__()\n",
        "        self.in_channels = in_channels\n",
        "        self.snconv1x1_theta = snconv2d(in_channels=in_channels, out_channels=in_channels//8,\n",
        "                                        kernel_size=1, bias=False, eps=eps)\n",
        "        self.snconv1x1_phi = snconv2d(in_channels=in_channels, out_channels=in_channels//8,\n",
        "                                      kernel_size=1, bias=False, eps=eps)\n",
        "        self.snconv1x1_g = snconv2d(in_channels=in_channels, out_channels=in_channels//2,\n",
        "                                    kernel_size=1, bias=False, eps=eps)\n",
        "        self.snconv1x1_o_conv = snconv2d(in_channels=in_channels//2, out_channels=in_channels,\n",
        "                                         kernel_size=1, bias=False, eps=eps)\n",
        "        self.maxpool = nn.MaxPool2d(2, stride=2, padding=0)\n",
        "        self.softmax  = nn.Softmax(dim=-1)\n",
        "        self.gamma = nn.Parameter(torch.zeros(1))\n",
        "\n",
        "    def forward(self, x):\n",
        "        _, ch, h, w = x.size()\n",
        "        # Theta path\n",
        "        theta = self.snconv1x1_theta(x)\n",
        "        theta = theta.view(-1, ch//8, h*w)\n",
        "        # Phi path\n",
        "        phi = self.snconv1x1_phi(x)\n",
        "        phi = self.maxpool(phi)\n",
        "        phi = phi.view(-1, ch//8, h*w//4)\n",
        "        # Attn map\n",
        "        attn = torch.bmm(theta.permute(0, 2, 1), phi)\n",
        "        attn = self.softmax(attn)\n",
        "        # g path\n",
        "        g = self.snconv1x1_g(x)\n",
        "        g = self.maxpool(g)\n",
        "        g = g.view(-1, ch//2, h*w//4)\n",
        "        # Attn_g - o_conv\n",
        "        attn_g = torch.bmm(g, attn.permute(0, 2, 1))\n",
        "        attn_g = attn_g.view(-1, ch//2, h, w)\n",
        "        attn_g = self.snconv1x1_o_conv(attn_g)\n",
        "        # Out\n",
        "        out = x + self.gamma*attn_g\n",
        "        return out\n",
        "\n",
        "\n",
        "class BigGANBatchNorm(nn.Module):\n",
        "    \"\"\" This is a batch norm module that can handle conditional input and can be provided with pre-computed\n",
        "        activation means and variances for various truncation parameters.\n",
        "        We cannot just rely on torch.batch_norm since it cannot handle\n",
        "        batched weights (pytorch 1.0.1). We computate batch_norm our-self without updating running means and variances.\n",
        "        If you want to train this model you should add running means and variance computation logic.\n",
        "    \"\"\"\n",
        "    def __init__(self, num_features, condition_vector_dim=None, n_stats=51, eps=1e-4, conditional=True):\n",
        "        super(BigGANBatchNorm, self).__init__()\n",
        "        self.num_features = num_features\n",
        "        self.eps = eps\n",
        "        self.conditional = conditional\n",
        "\n",
        "        # We use pre-computed statistics for n_stats values of truncation between 0 and 1\n",
        "        self.register_buffer('running_means', torch.zeros(n_stats, num_features))\n",
        "        self.register_buffer('running_vars', torch.ones(n_stats, num_features))\n",
        "        self.step_size = 1.0 / (n_stats - 1)\n",
        "\n",
        "        if conditional:\n",
        "            assert condition_vector_dim is not None\n",
        "            self.scale = snlinear(in_features=condition_vector_dim, out_features=num_features, bias=False, eps=eps)\n",
        "            self.offset = snlinear(in_features=condition_vector_dim, out_features=num_features, bias=False, eps=eps)\n",
        "        else:\n",
        "            self.weight = torch.nn.Parameter(torch.Tensor(num_features))\n",
        "            self.bias = torch.nn.Parameter(torch.Tensor(num_features))\n",
        "\n",
        "    def forward(self, x, truncation, condition_vector=None):\n",
        "        # Retreive pre-computed statistics associated to this truncation\n",
        "        coef, start_idx = math.modf(truncation / self.step_size)\n",
        "        start_idx = int(start_idx)\n",
        "        if coef != 0.0:  # Interpolate\n",
        "            running_mean = self.running_means[start_idx] * coef + self.running_means[start_idx + 1] * (1 - coef)\n",
        "            running_var = self.running_vars[start_idx] * coef + self.running_vars[start_idx + 1] * (1 - coef)\n",
        "        else:\n",
        "            running_mean = self.running_means[start_idx]\n",
        "            running_var = self.running_vars[start_idx]\n",
        "\n",
        "        if self.conditional:\n",
        "            running_mean = running_mean.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n",
        "            running_var = running_var.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)\n",
        "\n",
        "            weight = 1 + self.scale(condition_vector).unsqueeze(-1).unsqueeze(-1)\n",
        "            bias = self.offset(condition_vector).unsqueeze(-1).unsqueeze(-1)\n",
        "\n",
        "            out = (x - running_mean) / torch.sqrt(running_var + self.eps) * weight + bias\n",
        "        else:\n",
        "            out = F.batch_norm(x, running_mean, running_var, self.weight, self.bias,\n",
        "                               training=False, momentum=0.0, eps=self.eps)\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "class GenBlock(nn.Module):\n",
        "    def __init__(self, in_size, out_size, condition_vector_dim, reduction_factor=4, up_sample=False,\n",
        "                 n_stats=51, eps=1e-12):\n",
        "        super(GenBlock, self).__init__()\n",
        "        self.up_sample = up_sample\n",
        "        self.drop_channels = (in_size != out_size)\n",
        "        middle_size = in_size // reduction_factor\n",
        "\n",
        "        self.bn_0 = BigGANBatchNorm(in_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True)\n",
        "        self.conv_0 = snconv2d(in_channels=in_size, out_channels=middle_size, kernel_size=1, eps=eps)\n",
        "\n",
        "        self.bn_1 = BigGANBatchNorm(middle_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True)\n",
        "        self.conv_1 = snconv2d(in_channels=middle_size, out_channels=middle_size, kernel_size=3, padding=1, eps=eps)\n",
        "\n",
        "        self.bn_2 = BigGANBatchNorm(middle_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True)\n",
        "        self.conv_2 = snconv2d(in_channels=middle_size, out_channels=middle_size, kernel_size=3, padding=1, eps=eps)\n",
        "\n",
        "        self.bn_3 = BigGANBatchNorm(middle_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True)\n",
        "        self.conv_3 = snconv2d(in_channels=middle_size, out_channels=out_size, kernel_size=1, eps=eps)\n",
        "\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "    def forward(self, x, cond_vector, truncation):\n",
        "        x0 = x\n",
        "\n",
        "        x = self.bn_0(x, truncation, cond_vector)\n",
        "        x = self.relu(x)\n",
        "        x = self.conv_0(x)\n",
        "\n",
        "        x = self.bn_1(x, truncation, cond_vector)\n",
        "        x = self.relu(x)\n",
        "        if self.up_sample:\n",
        "            x = F.interpolate(x, scale_factor=2, mode='nearest')\n",
        "        x = self.conv_1(x)\n",
        "\n",
        "        x = self.bn_2(x, truncation, cond_vector)\n",
        "        x = self.relu(x)\n",
        "        x = self.conv_2(x)\n",
        "\n",
        "        x = self.bn_3(x, truncation, cond_vector)\n",
        "        x = self.relu(x)\n",
        "        x = self.conv_3(x)\n",
        "\n",
        "        if self.drop_channels:\n",
        "            new_channels = x0.shape[1] // 2\n",
        "            x0 = x0[:, :new_channels, ...]\n",
        "        if self.up_sample:\n",
        "            x0 = F.interpolate(x0, scale_factor=2, mode='nearest')\n",
        "\n",
        "        out = x + x0\n",
        "        return out\n",
        "\n",
        "class Generator(nn.Module):\n",
        "    def __init__(self, config):\n",
        "        super(Generator, self).__init__()\n",
        "        self.config = config\n",
        "        ch = config.channel_width\n",
        "        condition_vector_dim = config.z_dim * 2\n",
        "\n",
        "        self.gen_z = snlinear(in_features=condition_vector_dim,\n",
        "                              out_features=4 * 4 * 16 * ch, eps=config.eps)\n",
        "\n",
        "        layers = []\n",
        "        for i, layer in enumerate(config.layers):\n",
        "            if i == config.attention_layer_position:\n",
        "                layers.append(SelfAttn(ch*layer[1], eps=config.eps))\n",
        "            layers.append(GenBlock(ch*layer[1],\n",
        "                                   ch*layer[2],\n",
        "                                   condition_vector_dim,\n",
        "                                   up_sample=layer[0],\n",
        "                                   n_stats=config.n_stats,\n",
        "                                   eps=config.eps))\n",
        "        self.layers = nn.ModuleList(layers)\n",
        "\n",
        "        self.bn = BigGANBatchNorm(ch, n_stats=config.n_stats, eps=config.eps, conditional=False)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.conv_to_rgb = snconv2d(in_channels=ch, out_channels=ch, kernel_size=3, padding=1, eps=config.eps)\n",
        "        self.tanh = nn.Tanh()\n",
        "\n",
        "    def forward(self, cond_vector, truncation):\n",
        "        z = self.gen_z(cond_vector[0].unsqueeze(0))\n",
        "\n",
        "        # We use this conversion step to be able to use TF weights:\n",
        "        # TF convention on shape is [batch, height, width, channels]\n",
        "        # PT convention on shape is [batch, channels, height, width]\n",
        "        z = z.view(-1, 4, 4, 16 * self.config.channel_width)\n",
        "        z = z.permute(0, 3, 1, 2).contiguous()\n",
        "\n",
        "        for i, layer in enumerate(self.layers):\n",
        "            if isinstance(layer, GenBlock):\n",
        "                z = layer(z, cond_vector[i+1].unsqueeze(0), truncation)\n",
        "                # z = layer(z, cond_vector[].unsqueeze(0), truncation)\n",
        "            else:\n",
        "                z = layer(z)\n",
        "\n",
        "        z = self.bn(z, truncation)\n",
        "        z = self.relu(z)\n",
        "        z = self.conv_to_rgb(z)\n",
        "        z = z[:, :3, ...]\n",
        "        z = self.tanh(z)\n",
        "        return z\n",
        "\n",
        "class BigGAN(nn.Module):\n",
        "    \"\"\"BigGAN Generator.\"\"\"\n",
        "\n",
        "    @classmethod\n",
        "    def from_pretrained(cls, pretrained_model_name_or_path, cache_dir=None, *inputs, **kwargs):\n",
        "        if pretrained_model_name_or_path in PRETRAINED_MODEL_ARCHIVE_MAP:\n",
        "            model_file = PRETRAINED_MODEL_ARCHIVE_MAP[pretrained_model_name_or_path]\n",
        "            config_file = PRETRAINED_CONFIG_ARCHIVE_MAP[pretrained_model_name_or_path]\n",
        "        else:\n",
        "            model_file = os.path.join(pretrained_model_name_or_path, WEIGHTS_NAME)\n",
        "            config_file = os.path.join(pretrained_model_name_or_path, CONFIG_NAME)\n",
        "\n",
        "        try:\n",
        "            resolved_model_file = cached_path(model_file, cache_dir=cache_dir)\n",
        "            resolved_config_file = cached_path(config_file, cache_dir=cache_dir)\n",
        "        except EnvironmentError:\n",
        "            logger.error(\"Wrong model name, should be a valid path to a folder containing \"\n",
        "                         \"a {} file and a {} file or a model name in {}\".format(\n",
        "                         WEIGHTS_NAME, CONFIG_NAME, PRETRAINED_MODEL_ARCHIVE_MAP.keys()))\n",
        "            raise\n",
        "\n",
        "        logger.info(\"loading model {} from cache at {}\".format(pretrained_model_name_or_path, resolved_model_file))\n",
        "\n",
        "        # Load config\n",
        "        config = BigGANConfig.from_json_file(resolved_config_file)\n",
        "        logger.info(\"Model config {}\".format(config))\n",
        "\n",
        "        # Instantiate model.\n",
        "        model = cls(config, *inputs, **kwargs)\n",
        "        state_dict = torch.load(resolved_model_file, map_location='cpu' if not torch.cuda.is_available() else None)\n",
        "        model.load_state_dict(state_dict, strict=False)\n",
        "        return model\n",
        "\n",
        "    def __init__(self, config):\n",
        "        super(BigGAN, self).__init__()\n",
        "        self.config = config\n",
        "        self.embeddings = nn.Linear(config.num_classes, config.z_dim, bias=False)\n",
        "        self.generator = Generator(config)\n",
        "\n",
        "    def forward(self, z, class_label, truncation):\n",
        "        assert 0 < truncation <= 1\n",
        "\n",
        "        embed = self.embeddings(class_label)\n",
        "        cond_vector = torch.cat((z, embed), dim=1)\n",
        "\n",
        "        z = self.generator(cond_vector, truncation)\n",
        "        return z\n",
        "\n",
        "def one_hot_from_int(int_or_list, batch_size=1):\n",
        "    \"\"\" Create a one-hot vector from a class index or a list of class indices.\n",
        "        Params:\n",
        "            int_or_list: int, or list of int, of the imagenet classes (between 0 and 999)\n",
        "            batch_size: batch size.\n",
        "                If int_or_list is an int create a batch of identical classes.\n",
        "                If int_or_list is a list, we should have `len(int_or_list) == batch_size`\n",
        "        Output:\n",
        "            array of shape (batch_size, 1000)\n",
        "    \"\"\"\n",
        "    if isinstance(int_or_list, int):\n",
        "        int_or_list = [int_or_list]\n",
        "\n",
        "    if len(int_or_list) == 1 and batch_size > 1:\n",
        "        int_or_list = [int_or_list[0]] * batch_size\n",
        "\n",
        "    assert batch_size == len(int_or_list)\n",
        "\n",
        "    array = np.zeros((batch_size, 1000), dtype=np.float32)\n",
        "    for i, j in enumerate(int_or_list):\n",
        "        array[i, j] = 1.0\n",
        "    return array\n",
        "\n",
        "class Pars(torch.nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Pars, self).__init__()\n",
        "        # params = torch.zeros(32, 1).normal_(std=1)\n",
        "\n",
        "        # self.stds = torch.nn.Parameter(params)\n",
        "\n",
        "        # params = torch.zeros(32, 1).normal_(std=.1)\n",
        "        # self.means = torch.nn.Parameter(params)\n",
        "        \n",
        "        self.normu = torch.nn.Parameter(torch.zeros(32, 128).normal_(std=1).cuda())\n",
        "\n",
        "\n",
        "        params_other = torch.zeros(32, 1000).normal_(-3.9, .3)\n",
        "        self.cls = torch.nn.Parameter(params_other)\n",
        "\n",
        "        self.thrsh_lat = torch.tensor(1).cuda()\n",
        "\n",
        "        self.thrsh_cls = torch.tensor(1.9).cuda()\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self):\n",
        "      # return self.ff2(self.ff1(self.latent_code)), torch.softmax(1000*self.ff4(self.ff3(self.cls)), -1)\n",
        "      return self.normu, torch.sigmoid(self.cls)\n",
        "\n",
        "clear_output()\n",
        "print('Done!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "z2kA4ycNfcm-"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Start Processing</font></b>\r\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Начать обработку</font></b>\r\n",
        "\r\n",
        "!rm -rf /content/CLIP/frames/*.*\r\n",
        "#@markdown **(ENG)** Enter a description for the picture and click the \"Play\" button. Text can be written in any language.\r\n",
        "\r\n",
        "#@markdown **(RUS)** Введите описание картинки и нажмите кнопку \"Play\". Текст можно писать на любом языке.\r\n",
        "text = 'an armchair in the shape of an avocado' #@param {type:\"string\"}\r\n",
        "try:\r\n",
        "  translation = translator.translate(text)\r\n",
        "  prompt = translation.text\r\n",
        "except: prompt = text\r\n",
        "\r\n",
        "#@markdown **(ENG) Attention!** This process is almost endless, so watch the results and stop this block when you think it's time. Press the \"Play\" button again to stop.\r\n",
        "\r\n",
        "#@markdown **(RUS) Внимание!** Этот процесс почти бесконечный, поэтому смотрите за результатами и остановите работу этого блока когда посчитаете, что уже пора. Для остановки снова нажмите кнопку \"Play\".\r\n",
        "\r\n",
        "#@markdown ---\r\n",
        "resolution = \"256\" #@param [128, 256, 512]\r\n",
        "res = int(resolution)\r\n",
        "im_shape = [res, res, 3]\r\n",
        "sideX, sideY, channels = im_shape\r\n",
        "\r\n",
        "tx = clip.tokenize(prompt)\r\n",
        "frames_frequency = \"high\" #@param ['high', 'medium', 'low']\r\n",
        "if frames_frequency=='low': fr = 150\r\n",
        "elif frames_frequency=='medium': fr = 100\r\n",
        "else: fr = 50\r\n",
        "audio_notification = False #@param {type:\"boolean\"}\r\n",
        "\r\n",
        "model_name = 'biggan-deep-' + resolution\r\n",
        "model = BigGAN.from_pretrained(model_name)\r\n",
        "model = model.cuda().eval()\r\n",
        "\r\n",
        "torch.manual_seed(0)\r\n",
        "lats = Pars().cuda()\r\n",
        "optimizer = torch.optim.Adam(lats.parameters(), .07)\r\n",
        "eps = 0\r\n",
        "nom = torchvision.transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))\r\n",
        "t = perceptor.encode_text(tx.cuda()).detach().clone()\r\n",
        "\r\n",
        "with torch.no_grad():\r\n",
        "  al = (model(*lats(), 1).cpu()).numpy()\r\n",
        "\r\n",
        "def checkin(loss):\r\n",
        "  #print(loss)\r\n",
        "  best = torch.topk(loss[2], k=1, largest=False)[1]\r\n",
        "  with torch.no_grad():\r\n",
        "    al = model(*lats(), 1)[best:best+1].cpu().numpy()\r\n",
        "  for allls in al:\r\n",
        "    displ(allls)\r\n",
        "    clear_output()\r\n",
        "    pic_num = str(len(os.listdir('/content/CLIP/frames'))-1)\r\n",
        "    if int(pic_num) != 0:\r\n",
        "      print(f'Number of frames {pic_num}\\n')\r\n",
        "      display.display(display.Image('result.png'))\r\n",
        "    print('\\n(ENG) Please wait a few seconds until the next picture')\r\n",
        "    print('(RUS) Пожалуйста подождите несколько секунд, пока не появится новое изображение')\r\n",
        "  if audio_notification == True: output.eval_js('new Audio(\"https://freesound.org/data/previews/80/80921_1022651-lq.ogg\").play()')\r\n",
        "\r\n",
        "def ascend_txt():\r\n",
        "  out = model(*lats(), 1)\r\n",
        "  cutn = 128\r\n",
        "  p_s = []\r\n",
        "  for ch in range(cutn):\r\n",
        "    size = int(sideX*torch.zeros(1,).normal_(mean=.8, std=.3).clip(.5, .95))\r\n",
        "    offsetx = torch.randint(0, sideX - size, ())\r\n",
        "    offsety = torch.randint(0, sideX - size, ())\r\n",
        "    apper = out[:, :, offsetx:offsetx + size, offsety:offsety + size]\r\n",
        "    apper = torch.nn.functional.interpolate(apper, (224,224), mode='nearest')\r\n",
        "    p_s.append(apper)\r\n",
        "  into = torch.cat(p_s, 0)\r\n",
        "  # into = torch.nn.functional.interpolate(out, (224,224), mode='nearest')\r\n",
        "  into = nom((into + 1) / 2)\r\n",
        "  iii = perceptor.encode_image(into)\r\n",
        "  llls = lats()\r\n",
        "  lat_l = torch.abs(1 - torch.std(llls[0], dim=1)).mean() + \\\r\n",
        "  torch.abs(torch.mean(llls[0])).mean() + \\\r\n",
        "  4*torch.max(torch.square(llls[0]).mean(), lats.thrsh_lat)\r\n",
        "\r\n",
        "  for array in llls[0]:\r\n",
        "    mean = torch.mean(array)\r\n",
        "    diffs = array - mean\r\n",
        "    var = torch.mean(torch.pow(diffs, 2.0))\r\n",
        "    std = torch.pow(var, 0.5)\r\n",
        "    zscores = diffs / std\r\n",
        "    skews = torch.mean(torch.pow(zscores, 3.0))\r\n",
        "    kurtoses = torch.mean(torch.pow(zscores, 4.0)) - 3.0\r\n",
        "\r\n",
        "    lat_l = lat_l + torch.abs(kurtoses) / llls[0].shape[0] + torch.abs(skews) / llls[0].shape[0]\r\n",
        "\r\n",
        "  cls_l = ((50*torch.topk(llls[1],largest=False,dim=1,k=999)[0])**2).mean()\r\n",
        "  return [lat_l, cls_l, -100*torch.cosine_similarity(t, iii, dim=-1).mean()]\r\n",
        "\r\n",
        "def train(epoch, i):\r\n",
        "  loss1 = ascend_txt()\r\n",
        "  loss = loss1[0] + loss1[1] + loss1[2]\r\n",
        "  optimizer.zero_grad()\r\n",
        "  loss.backward()\r\n",
        "  optimizer.step()\r\n",
        "  \r\n",
        "  if itt % fr == 0:\r\n",
        "    checkin(loss1)\r\n",
        "\r\n",
        "itt = 0\r\n",
        "for epochs in range(10000):\r\n",
        "  for i in range(50000):\r\n",
        "    train(eps, i)\r\n",
        "    itt+=1\r\n",
        "  eps+=1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "A5sxq2wamu2Y"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Generate Video</font></b>\r\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Сгенерировать видео</font></b>\r\n",
        "\r\n",
        "#@markdown **(ENG) Attention!** The duration of the video will depend on how many pictures you generated in the previous block. 10 frames = 1 sec.\r\n",
        "\r\n",
        "#@markdown **(RUS) Внимание!** Длительность видео будет зависеть от того, сколько картинок вы сгенерировали на предыдущем блоке. 10 кадров = 1 сек.\r\n",
        "!rm -rf /content/CLIP/frames/00000.png\r\n",
        "frames = []\r\n",
        "img = os.listdir(\"/content/CLIP/frames\")\r\n",
        "img.sort()\r\n",
        "for i in img:\r\n",
        "  frames.append(imageio.imread(\"/content/CLIP/frames/\"+i))\r\n",
        "frames = np.array(frames)\r\n",
        "imageio.mimsave('/content/CLIP/video.mp4', frames)\r\n",
        "clear_output()\r\n",
        "\r\n",
        "from IPython.display import HTML\r\n",
        "import io\r\n",
        "import base64\r\n",
        "video = io.open('/content/CLIP/video.mp4', 'r+b').read()\r\n",
        "encoded = base64.b64encode(video)\r\n",
        "play_html = ('<video alt=\"test\" controls><source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" /> </video>'.format(encoded.decode('ascii')))\r\n",
        "HTML(data=play_html)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "MePaf9j8mxPe"
      },
      "source": [
        "#@title <b><font color=\"red\" size=\"+3\">←</font><font color=\"black\" size=\"+3\"> Download results</font></b>\r\n",
        "#@markdown <b><font color=\"black\" size=\"+1\"> (RUS) Скачать результаты</font></b>\r\n",
        "last_image = True #@param {type:\"boolean\"}\r\n",
        "video = True #@param {type:\"boolean\"}\r\n",
        "if last_image==True: files.download('/content/CLIP/result.png')\r\n",
        "if video==True: files.download('/content/CLIP/video.mp4')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}