inventer_images.ipynb

{
    "nbformat": 4,
    "nbformat_minor": 2,
    "metadata": {
        "colab": {
            "name": "xDEADC0DE / VQGANCLIP.ipynb",
            "private_outputs": true,
            "provenance": [
                {
                    "file_id": "1go6YwMFe5MX6XM9tv-cnQiSTU50N9EeT",
                    "timestamp": 1625995767038
                },
                {
                    "file_id": "1L8oL-vLJXVcRzCFbPwOoMkPKJ8-aYdPN",
                    "timestamp": 1621115030940
                },
                {
                    "file_id": "15UwYDsnNeldJFHJ9NdgYBYeo6xPmSelP",
                    "timestamp": 1618333741979
                }
            ],
            "collapsed_sections": [
                "w6GDHnyrHP9U"
            ],
            "toc_visible": true,
            "machine_shape": "hm"
        },
        "kernelspec": {
            "name": "python3",
            "display_name": "Python 3"
        },
        "language_info": {
            "name": "python"
        },
        "accelerator": "GPU"
    },
    "cells": [
        {
            "cell_type": "markdown",
            "source": [
                "# Générateur d’images à partir de phrases, avec VQGAN + CLIP\r\n",
                "version du : 04/10/2021"
            ],
            "metadata": {
                "id": "CppIQlPhhwhs"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "Cette page permet de créer des images à partir de phrases.\r\n",
                "\r\n",
                "Rien n’est installé sur votre ordinateur, et l’utilisation de cette page est gratuite. Pour lancer le programme vous devez exécuter chaque « bloc » l’un après l’autre, en cliquant sur l’icone « play »\r\n",
                "\r\n",
                "Vous êtes libres de modifier tout ou partie de ce notebook, mais pour enregistrer vos modifications vous devrez d’abord le copier sur votre propre Google Drive."
            ],
            "metadata": {
                "id": "TS-JTGbWJgkI"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "# 📚 Installation"
            ],
            "metadata": {
                "id": "0RBvozuyyCNm"
            }
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "# @title 📚 Bibliothéques et définitions\r\n",
                "\r\n",
                "!nvidia-smi\r\n",
                "print()\r\n",
                "\r\n",
                "print(\"(1/5) Téléchargement de CLIP…\")\r\n",
                "!git clone https://github.com/openai/CLIP                 &> /dev/null\r\n",
                " \r\n",
                "print(\"(2/6) Installation des bibliothèques Python pour l'IA…\")\r\n",
                "!git clone https://github.com/CompVis/taming-transformers &> /dev/null\r\n",
                "!pip install ftfy regex tqdm omegaconf pytorch-lightning  &> /dev/null\r\n",
                "!pip install kornia                                       &> /dev/null\r\n",
                "!pip install einops                                       &> /dev/null\r\n",
                "!pip install transformers &> /dev/null # ajout perso\r\n",
                "\r\n",
                "print(\"(3/6) Installation des bibliothèques Python pour la manipulation de métadonnées…\")\r\n",
                "!pip install stegano                                      &> /dev/null\r\n",
                "!apt install exempi                                       &> /dev/null\r\n",
                "!pip install python-xmp-toolkit                           &> /dev/null\r\n",
                "!pip install imgtag                                       &> /dev/null\r\n",
                "!pip install pillow==7.1.2                                &> /dev/null\r\n",
                "\r\n",
                "print(\"(4/6) Installation des bibliothèques Python pour la création de vidéos…\")\r\n",
                "!pip install imageio-ffmpeg &> /dev/null\r\n",
                "\r\n",
                "# téléchargement police Noto, pour les sous-titres\r\n",
                "print(\"(5/6) Téléchargement de la police Noto Serif…\")\r\n",
                "!wget \"https://noto-website-2.storage.googleapis.com/pkgs/NotoSerif-hinted.zip\" &> /dev/null \r\n",
                "!unzip -p \"NotoSerif-hinted.zip\" NotoSerif-Regular.ttf > NotoSerif-Regular.ttf\r\n",
                "!rm \"NotoSerif-hinted.zip\"\r\n",
                "\r\n",
                "print(\"(6/6) Configuration Python…\")\r\n",
                "\r\n",
                "import argparse\r\n",
                "import math\r\n",
                "from pathlib import Path\r\n",
                "import sys\r\n",
                "# remove before sharing\r\n",
                "import datetime \r\n",
                " \r\n",
                "sys.path.append('./taming-transformers')\r\n",
                "from IPython import display\r\n",
                "from base64 import b64encode\r\n",
                "from omegaconf import OmegaConf\r\n",
                "from PIL import Image, ImageDraw, ImageFont\r\n",
                "from taming.models import cond_transformer, vqgan\r\n",
                "import torch\r\n",
                "from torch import nn, optim\r\n",
                "from torch.nn import functional as F\r\n",
                "from torchvision import transforms\r\n",
                "from torchvision.transforms import functional as TF\r\n",
                "from tqdm.notebook import tqdm\r\n",
                " \r\n",
                "from CLIP import clip\r\n",
                "import kornia.augmentation as K\r\n",
                "import numpy as np\r\n",
                "import imageio\r\n",
                "from PIL import ImageFile, Image\r\n",
                "from imgtag import ImgTag    # metadatos \r\n",
                "from libxmp import *         # metadatos\r\n",
                "import libxmp                # metadatos\r\n",
                "from stegano import lsb\r\n",
                "import json\r\n",
                "ImageFile.LOAD_TRUNCATED_IMAGES = True\r\n",
                " \r\n",
                "def sinc(x):\r\n",
                "    return torch.where(x != 0, torch.sin(math.pi * x) / (math.pi * x), x.new_ones([]))\r\n",
                " \r\n",
                " \r\n",
                "def lanczos(x, a):\r\n",
                "    cond = torch.logical_and(-a < x, x < a)\r\n",
                "    out = torch.where(cond, sinc(x) * sinc(x/a), x.new_zeros([]))\r\n",
                "    return out / out.sum()\r\n",
                " \r\n",
                " \r\n",
                "def ramp(ratio, width):\r\n",
                "    n = math.ceil(width / ratio + 1)\r\n",
                "    out = torch.empty([n])\r\n",
                "    cur = 0\r\n",
                "    for i in range(out.shape[0]):\r\n",
                "        out[i] = cur\r\n",
                "        cur += ratio\r\n",
                "    return torch.cat([-out[1:].flip([0]), out])[1:-1]\r\n",
                " \r\n",
                " \r\n",
                "def resample(input, size, align_corners=True):\r\n",
                "    n, c, h, w = input.shape\r\n",
                "    dh, dw = size\r\n",
                " \r\n",
                "    input = input.view([n * c, 1, h, w])\r\n",
                " \r\n",
                "    if dh < h:\r\n",
                "        kernel_h = lanczos(ramp(dh / h, 2), 2).to(input.device, input.dtype)\r\n",
                "        pad_h = (kernel_h.shape[0] - 1) // 2\r\n",
                "        input = F.pad(input, (0, 0, pad_h, pad_h), 'reflect')\r\n",
                "        input = F.conv2d(input, kernel_h[None, None, :, None])\r\n",
                " \r\n",
                "    if dw < w:\r\n",
                "        kernel_w = lanczos(ramp(dw / w, 2), 2).to(input.device, input.dtype)\r\n",
                "        pad_w = (kernel_w.shape[0] - 1) // 2\r\n",
                "        input = F.pad(input, (pad_w, pad_w, 0, 0), 'reflect')\r\n",
                "        input = F.conv2d(input, kernel_w[None, None, None, :])\r\n",
                " \r\n",
                "    input = input.view([n, c, h, w])\r\n",
                "    return F.interpolate(input, size, mode='bicubic', align_corners=align_corners)\r\n",
                " \r\n",
                " \r\n",
                "class ReplaceGrad(torch.autograd.Function):\r\n",
                "    @staticmethod\r\n",
                "    def forward(ctx, x_forward, x_backward):\r\n",
                "        ctx.shape = x_backward.shape\r\n",
                "        return x_forward\r\n",
                " \r\n",
                "    @staticmethod\r\n",
                "    def backward(ctx, grad_in):\r\n",
                "        return None, grad_in.sum_to_size(ctx.shape)\r\n",
                " \r\n",
                " \r\n",
                "replace_grad = ReplaceGrad.apply\r\n",
                " \r\n",
                " \r\n",
                "class ClampWithGrad(torch.autograd.Function):\r\n",
                "    @staticmethod\r\n",
                "    def forward(ctx, input, min, max):\r\n",
                "        ctx.min = min\r\n",
                "        ctx.max = max\r\n",
                "        ctx.save_for_backward(input)\r\n",
                "        return input.clamp(min, max)\r\n",
                " \r\n",
                "    @staticmethod\r\n",
                "    def backward(ctx, grad_in):\r\n",
                "        input, = ctx.saved_tensors\r\n",
                "        return grad_in * (grad_in * (input - input.clamp(ctx.min, ctx.max)) >= 0), None, None\r\n",
                " \r\n",
                " \r\n",
                "clamp_with_grad = ClampWithGrad.apply\r\n",
                " \r\n",
                " \r\n",
                "def vector_quantize(x, codebook):\r\n",
                "    d = x.pow(2).sum(dim=-1, keepdim=True) + codebook.pow(2).sum(dim=1) - 2 * x @ codebook.T\r\n",
                "    indices = d.argmin(-1)\r\n",
                "    x_q = F.one_hot(indices, codebook.shape[0]).to(d.dtype) @ codebook\r\n",
                "    return replace_grad(x_q, x)\r\n",
                " \r\n",
                " \r\n",
                "class Prompt(nn.Module):\r\n",
                "    def __init__(self, embed, weight=1., stop=float('-inf')):\r\n",
                "        super().__init__()\r\n",
                "        self.register_buffer('embed', embed)\r\n",
                "        self.register_buffer('weight', torch.as_tensor(weight))\r\n",
                "        self.register_buffer('stop', torch.as_tensor(stop))\r\n",
                " \r\n",
                "    def forward(self, input):\r\n",
                "        input_normed = F.normalize(input.unsqueeze(1), dim=2)\r\n",
                "        embed_normed = F.normalize(self.embed.unsqueeze(0), dim=2)\r\n",
                "        dists = input_normed.sub(embed_normed).norm(dim=2).div(2).arcsin().pow(2).mul(2)\r\n",
                "        dists = dists * self.weight.sign()\r\n",
                "        return self.weight.abs() * replace_grad(dists, torch.maximum(dists, self.stop)).mean()\r\n",
                " \r\n",
                " \r\n",
                "def parse_prompt(prompt):\r\n",
                "    vals = prompt.rsplit(':', 2)\r\n",
                "    vals = vals + ['', '1', '-inf'][len(vals):]\r\n",
                "    return vals[0], float(vals[1]), float(vals[2])\r\n",
                " \r\n",
                " \r\n",
                "class MakeCutouts(nn.Module):\r\n",
                "    def __init__(self, cut_size, cutn, cut_pow=1.):\r\n",
                "        super().__init__()\r\n",
                "        self.cut_size = cut_size\r\n",
                "        self.cutn = cutn\r\n",
                "        self.cut_pow = cut_pow\r\n",
                "        self.augs = nn.Sequential(\r\n",
                "            K.RandomHorizontalFlip(p=0.5),\r\n",
                "            # K.RandomSolarize(0.01, 0.01, p=0.7),\r\n",
                "            K.RandomSharpness(0.3,p=0.4),\r\n",
                "            K.RandomAffine(degrees=30, translate=0.1, p=0.8, padding_mode='border'),\r\n",
                "            K.RandomPerspective(0.2,p=0.4),\r\n",
                "            K.ColorJitter(hue=0.01, saturation=0.01, p=0.7))\r\n",
                "        self.noise_fac = 0.1\r\n",
                " \r\n",
                " \r\n",
                "    def forward(self, input):\r\n",
                "        sideY, sideX = input.shape[2:4]\r\n",
                "        max_size = min(sideX, sideY)\r\n",
                "        min_size = min(sideX, sideY, self.cut_size)\r\n",
                "        cutouts = []\r\n",
                "        for _ in range(self.cutn):\r\n",
                "            size = int(torch.rand([])**self.cut_pow * (max_size - min_size) + min_size)\r\n",
                "            offsetx = torch.randint(0, sideX - size + 1, ())\r\n",
                "            offsety = torch.randint(0, sideY - size + 1, ())\r\n",
                "            cutout = input[:, :, offsety:offsety + size, offsetx:offsetx + size]\r\n",
                "            cutouts.append(resample(cutout, (self.cut_size, self.cut_size)))\r\n",
                "        batch = self.augs(torch.cat(cutouts, dim=0))\r\n",
                "        if self.noise_fac:\r\n",
                "            facs = batch.new_empty([self.cutn, 1, 1, 1]).uniform_(0, self.noise_fac)\r\n",
                "            batch = batch + facs * torch.randn_like(batch)\r\n",
                "        return batch\r\n",
                " \r\n",
                " \r\n",
                "def load_vqgan_model(config_path, checkpoint_path):\r\n",
                "    config = OmegaConf.load(config_path)\r\n",
                "    if config.model.target == 'taming.models.vqgan.VQModel':\r\n",
                "        model = vqgan.VQModel(**config.model.params)\r\n",
                "        model.eval().requires_grad_(False)\r\n",
                "        model.init_from_ckpt(checkpoint_path)\r\n",
                "    elif config.model.target == 'taming.models.cond_transformer.Net2NetTransformer':\r\n",
                "        parent_model = cond_transformer.Net2NetTransformer(**config.model.params)\r\n",
                "        parent_model.eval().requires_grad_(False)\r\n",
                "        parent_model.init_from_ckpt(checkpoint_path)\r\n",
                "        model = parent_model.first_stage_model\r\n",
                "    else:\r\n",
                "        raise ValueError(f'unknown model type: {config.model.target}')\r\n",
                "    del model.loss\r\n",
                "    return model\r\n",
                " \r\n",
                " \r\n",
                "def resize_image(image, out_size):\r\n",
                "    ratio = image.size[0] / image.size[1]\r\n",
                "    area = min(image.size[0] * image.size[1], out_size[0] * out_size[1])\r\n",
                "    size = round((area * ratio)**0.5), round((area / ratio)**0.5)\r\n",
                "    return image.resize(size, Image.LANCZOS)\r\n",
                "\r\n",
                "print(\"Installation terminée.\")\r\n",
                "\r\n"
            ],
            "outputs": [],
            "metadata": {
                "id": "EXMSuW2EQWsd",
                "cellView": "form"
            }
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "#@title 📖 Sélection des modèles à télécharger\r\n",
                "#@markdown Cette page créée des images en se basant sur différents « modèles ». Chaque modèle doit être téléchargé avant de pouvoir être utilisé.\r\n",
                "\r\n",
                "#@markdown **Remarque importante :** ces fichiers sont téléchargés sur une machine gérée par Google, rien n'est téléchargé sur votre ordinateur.\r\n",
                "\r\n",
                "imagenet_1024 = False #@param {type:\"boolean\"}\r\n",
                "imagenet_16384 = True #@param {type:\"boolean\"}\r\n",
                "#gumbel_8192 = False #@param {type:\"boolean\"}\r\n",
                "coco = False #@param {type:\"boolean\"}\r\n",
                "faceshq = False #@param {type:\"boolean\"}\r\n",
                "wikiart_1024 = False #@param {type:\"boolean\"}\r\n",
                "wikiart_16384 = False #@param {type:\"boolean\"}\r\n",
                "sflckr = False #@param {type:\"boolean\"}\r\n",
                "ade20k = False #@param {type:\"boolean\"}\r\n",
                "ffhq = False #@param {type:\"boolean\"}\r\n",
                "celebahq = False #@param {type:\"boolean\"}\r\n",
                "\r\n",
                "#@markdown ---\r\n",
                "\r\n",
                "#@markdown Pour ne pas avoir à télécharger ces fichiers à chaque fois, vous pouvez utiliser votre compte Google Drive en cochant la case suivante :\r\n",
                "\r\n",
                "utiliser_google_drive = False #@param {type:\"boolean\"}\r\n",
                "\r\n",
                "#@markdown Google vous demandera alors de confirmer la connexion en suivant le lien qui va s'afficher, puis en recopiant le mot de passe temporaire dans la zone de texte.\r\n",
                "\r\n",
                "#@markdown Si la case est cochée, les modèles seront téléchargés dans le dossier suivant sur votre Drive :\r\n",
                "dossier_gdrive = \"VQGANCLIP\" #@param {type: \"string\"}\r\n",
                "\r\n",
                "MODE_GDRIVE = False\r\n",
                "models_path = ''\r\n",
                "\r\n",
                "if utiliser_google_drive:\r\n",
                "  abs_root_path = \"/content\"\r\n",
                "  if len(dossier_gdrive) > 0:\r\n",
                "      abs_root_path = abs_root_path + \"/drive/MyDrive/\" + dossier_gdrive\r\n",
                "      if abs_root_path[-1] != \"/\":\r\n",
                "        abs_root_path += '/'\r\n",
                "      print(abs_root_path)\r\n",
                "\r\n",
                "  from google.colab import drive\r\n",
                "  drive.mount(\"/content/drive\", force_remount=True)\r\n",
                "\r\n",
                "  #TODO: à revoir\r\n",
                "  models_path = abs_root_path\r\n",
                "\r\n",
                "  MODE_GDRIVE = True\r\n",
                "  print(\"MODE_GDRIVE == True\") #TODO: à revoir\r\n",
                "else:\r\n",
                "  print(\"MODE_GDRIVE == False\") #TODO: à revoir\r\n",
                "\r\n",
                "\r\n",
                "\r\n",
                "\r\n",
                "if imagenet_1024:\r\n",
                "  print()\r\n",
                "  print(\"imagenet_1024\")\r\n",
                "  !curl -L -o {models_path}vqgan_imagenet_f16_1024.yaml -C - 'https://heibox.uni-heidelberg.de/d/8088892a516d4e3baf92/files/?p=%2Fconfigs%2Fmodel.yaml&dl=1' #ImageNet 1024\r\n",
                "  !curl -L -o {models_path}vqgan_imagenet_f16_1024.ckpt -C - 'https://heibox.uni-heidelberg.de/d/8088892a516d4e3baf92/files/?p=%2Fckpts%2Flast.ckpt&dl=1'  #ImageNet 1024 # 914 Mo\r\n",
                "if imagenet_16384:\r\n",
                "  print()\r\n",
                "  print(\"imagenet_16384\")\r\n",
                "  !curl -L -o {models_path}vqgan_imagenet_f16_16384.yaml -C - 'https://heibox.uni-heidelberg.de/d/a7530b09fed84f80a887/files/?p=%2Fconfigs%2Fmodel.yaml&dl=1' #ImageNet 16384\r\n",
                "  !curl -L -o {models_path}vqgan_imagenet_f16_16384.ckpt -C - 'https://heibox.uni-heidelberg.de/d/a7530b09fed84f80a887/files/?p=%2Fckpts%2Flast.ckpt&dl=1' #ImageNet 16384 # 935 Mo\r\n",
                "#if gumbel_8192:\r\n",
                "#  print()\r\n",
                "#  print(\"gumbel_8192\")\r\n",
                "#  !curl -L -o {models_path}gumbel_8192.yaml -C - 'https://heibox.uni-heidelberg.de/d/2e5662443a6b4307b470/files/?p=%2Fconfigs%2Fmodel.yaml&dl=1' #Gumbel 8192\r\n",
                "#  !curl -L -o {models_path}gumbel_8192.ckpt -C - 'https://heibox.uni-heidelberg.de/d/2e5662443a6b4307b470/files/?p=%2Fckpts%2Flast.ckpt&dl=1' #Gumbel 8192 #TODO: noter taille fichier\r\n",
                "if coco:\r\n",
                "  print()\r\n",
                "  print(\"coco\")\r\n",
                "  !curl -L -o {models_path}coco.yaml -C - 'https://dl.nmkd.de/ai/clip/coco/coco.yaml' #COCO\r\n",
                "  !curl -L -o {models_path}coco.ckpt -C - 'https://dl.nmkd.de/ai/clip/coco/coco.ckpt' #COCO # 7.9 Go\r\n",
                "if faceshq:\r\n",
                "  print()\r\n",
                "  print(\"faceshq\")\r\n",
                "  !curl -L -o {models_path}faceshq.yaml -C - 'https://drive.google.com/uc?export=download&id=1fHwGx_hnBtC8nsq7hesJvs-Klv-P0gzT' #FacesHQ\r\n",
                "  !curl -L -o {models_path}faceshq.ckpt -C - 'https://app.koofr.net/content/links/a04deec9-0c59-4673-8b37-3d696fe63a5d/files/get/last.ckpt?path=%2F2020-11-13T21-41-45_faceshq_transformer%2Fcheckpoints%2Flast.ckpt' #FacesHQ # 3.7 Go (?)\r\n",
                "if wikiart_1024:\r\n",
                "  print()\r\n",
                "  print(\"wikiart_1024\")\r\n",
                "  !curl -L -o {models_path}wikiart_1024.yaml -C - 'http://mirror.io.community/blob/vqgan/wikiart.yaml' #WikiArt 1024\r\n",
                "  !curl -L -o {models_path}wikiart_1024.ckpt -C - 'http://mirror.io.community/blob/vqgan/wikiart.ckpt' #WikiArt 1024 # 914 Mo\r\n",
                "if wikiart_16384: \r\n",
                "  print()\r\n",
                "  print(\"wikiart_16384\")\r\n",
                "  !curl -L -o {models_path}wikiart_16384.yaml -C - 'http://eaidata.bmk.sh/data/Wikiart_16384/wikiart_f16_16384_8145600.yaml' #WikiArt 16384\r\n",
                "  !curl -L -o {models_path}wikiart_16384.ckpt -C - 'http://eaidata.bmk.sh/data/Wikiart_16384/wikiart_f16_16384_8145600.ckpt' #WikiArt 16384 # 959 Mo\r\n",
                "if sflckr:\r\n",
                "  print()\r\n",
                "  print(\"sflckr\")\r\n",
                "  !curl -L -o {models_path}sflckr.yaml -C - 'https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/files/?p=%2Fconfigs%2F2020-11-09T13-31-51-project.yaml&dl=1' #S-FLCKR\r\n",
                "  !curl -L -o {models_path}sflckr.ckpt -C - 'https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/files/?p=%2Fcheckpoints%2Flast.ckpt&dl=1' #S-FLCKR # 4 Go\r\n",
                "if ade20k:\r\n",
                "  print()\r\n",
                "  print(\"ade20k\")\r\n",
                "  !curl -L -o {models_path}ade20k.yaml -C - 'https://static.miraheze.org/intercriaturaswiki/b/bf/Ade20k.txt' #ADE20K\r\n",
                "  !curl -L -o {models_path}ade20k.ckpt -C - 'https://app.koofr.net/content/links/0f65c2cd-7102-4550-a2bd-07fd383aac9e/files/get/last.ckpt?path=%2F2020-11-20T21-45-44_ade20k_transformer%2Fcheckpoints%2Flast.ckpt' #ADE20K  #TODO: noter taille fichier\r\n",
                "if ffhq:\r\n",
                "  print()\r\n",
                "  print(\"ffhq\")\r\n",
                "  !curl -L -o {models_path}ffhq.yaml -C - 'https://app.koofr.net/content/links/0fc005bf-3dca-4079-9d40-cdf38d42cd7a/files/get/2021-04-23T18-19-01-project.yaml?path=%2F2021-04-23T18-19-01_ffhq_transformer%2Fconfigs%2F2021-04-23T18-19-01-project.yaml&force' #FFHQ\r\n",
                "  !curl -L -o {models_path}ffhq.ckpt -C - 'https://app.koofr.net/content/links/0fc005bf-3dca-4079-9d40-cdf38d42cd7a/files/get/last.ckpt?path=%2F2021-04-23T18-19-01_ffhq_transformer%2Fcheckpoints%2Flast.ckpt&force' #FFHQ  #TODO: noter taille fichier\r\n",
                "if celebahq:\r\n",
                "  print()\r\n",
                "  print(\"celebahq\")\r\n",
                "  !curl -L -o {models_path}celebahq.yaml -C - 'https://app.koofr.net/content/links/6dddf083-40c8-470a-9360-a9dab2a94e96/files/get/2021-04-23T18-11-19-project.yaml?path=%2F2021-04-23T18-11-19_celebahq_transformer%2Fconfigs%2F2021-04-23T18-11-19-project.yaml&force' #CelebA-HQ\r\n",
                "  !curl -L -o {models_path}celebahq.ckpt -C - 'https://app.koofr.net/content/links/6dddf083-40c8-470a-9360-a9dab2a94e96/files/get/last.ckpt?path=%2F2021-04-23T18-11-19_celebahq_transformer%2Fcheckpoints%2Flast.ckpt&force' #CelebA-HQ  #TODO: noter taille fichier\r\n"
            ],
            "outputs": [],
            "metadata": {
                "id": "FhhdWrSxQhwg",
                "cellView": "form"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "# 🏃 Exécution\r\n",
                "\r\n",
                "La première chose à modifier est le champ `textes:`, qui correspond au texte qui sera utilisé pour crééer les images. Vous pouvez mettre plusieurs textes séparés par le caractère `|`. L’algorithme cherchera à « mélanger » tous les textes, en donnant la même priorité à chacun.\r\n",
                "\r\n",
                "Pour donner une image de départ au modèle, vous devez d’abord l’envoyer sur Colab, en cliquant sur l’iconne « dossier » à gauche, vous pourrez ensuite remplacer `image_origine:` par le chemin complet de l’image.\r\n",
                "\r\n",
                "Vous pouvez également modifier le modèle à utiliser via la liste déroulante `modèle`. Avant d’utiliser un modèle, vous devez le télécharger.\r\n",
                "\r\n",
                "Vous pouvez également utiliser `image_cible`, qui revient à ajouter une ou plusieurs images que l’IA utilisera comme objectif. Cela revient au même que d’ajouter des textes. Vous pouvez indiquer plusieures images en les séparant avec `|`."
            ],
            "metadata": {
                "id": "1tthw0YaispD"
            }
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "#@title ⚙️ Paramètres\r\n",
                "textes = \"a fantasy dragon flying over the sea\" #@param {type:\"string\"}\r\n",
                "largeur =  600#@param {type:\"number\"}\r\n",
                "hauteur =  600#@param {type:\"number\"}\r\n",
                "modèle = \"vqgan_imagenet_f16_16384\" #@param [\"vqgan_imagenet_f16_16384\", \"vqgan_imagenet_f16_1024\", \"wikiart_1024\", \"wikiart_16384\", \"coco\", \"faceshq\", \"sflckr\", \"ade20k\", \"ffhq\", \"celebahq\"]\r\n",
                "#, \"gumbel_8192\"]\r\n",
                "nbr_iteration_max = 100#@param {type:\"number\"}\r\n",
                "#@markdown paramètres avancés :\r\n",
                "#reuse_last_image = False #@param {type:\"boolean\"}\r\n",
                "reuse_last_image = False\r\n",
                "freq_affichage_images = 100#@param {type:\"number\"}\r\n",
                "image_origine = \"None\"#@param {type:\"string\"}\r\n",
                "image_cible = \"None\"#@param {type:\"string\"}\r\n",
                "seed = -1#@param {type:\"number\"}\r\n",
                "\r\n",
                "input_images = \"\"\r\n",
                "\r\n",
                "#TODO\r\n",
                "#if not reuse_last_image:\r\n",
                "print(\"Suppression des images déjà crées…\")\r\n",
                "!rm steps/*.png  > /dev/null 2>&1\r\n",
                "!rmdir steps > /dev/null 2>&1\r\n",
                "!mkdir steps\r\n",
                "\r\n",
                "noms_modèles={\"vqgan_imagenet_f16_16384\": 'ImageNet 16384',\"vqgan_imagenet_f16_1024\":\"ImageNet 1024\", \"wikiart_1024\":\"WikiArt 1024\", \"wikiart_16384\":\"WikiArt 16384\", \"coco\":\"COCO-Stuff\", \"faceshq\":\"FacesHQ\", \"sflckr\":\"S-FLCKR\", \"ade20k\":\"ADE20K\", \"ffhq\":\"FFHQ\", \"celebahq\":\"CelebA-HQ\", \"gumbel_8192\": \"Gumbel 8192\"}\r\n",
                "nom_modèle = noms_modèles[modèle]     \r\n",
                "\r\n",
                "if seed == -1:\r\n",
                "    seed = None\r\n",
                "if image_origine == \"None\":\r\n",
                "    image_origine = None\r\n",
                "if image_cible == \"None\" or not image_cible:\r\n",
                "    image_cible = []\r\n",
                "else:\r\n",
                "    image_cible = image_cible.split(\"|\")\r\n",
                "    image_cible = [image.strip() for image in image_cible]\r\n",
                "\r\n",
                "if image_origine or image_cible != []:\r\n",
                "    input_images = True\r\n",
                "\r\n",
                "#textes = [frase.strip() for frase in textes.split(\"|\")]\r\n",
                "prompts_list = []\r\n",
                "for text in textes.split('*'):\r\n",
                "  tmp = [frase.strip() for frase in text.split(\"|\")]\r\n",
                "  if tmp != ['']:\r\n",
                "    prompts_list.append(tmp)\r\n",
                "if prompts_list == ['']:\r\n",
                "    prompts_list = []\r\n",
                "\r\n",
                "args = argparse.Namespace(\r\n",
                "    prompts=prompts_list,\r\n",
                "    image_prompts=image_cible,\r\n",
                "    noise_prompt_seeds=[],\r\n",
                "    noise_prompt_weights=[],\r\n",
                "    size=[largeur, hauteur],\r\n",
                "    init_image=image_origine,\r\n",
                "    init_weight=0.,\r\n",
                "    clip_model='ViT-B/32',\r\n",
                "    vqgan_config=f'{modèle}.yaml',\r\n",
                "    vqgan_checkpoint=f'{modèle}.ckpt',\r\n",
                "    step_size=0.1,\r\n",
                "    cutn=64,\r\n",
                "    cut_pow=1.,\r\n",
                "    display_freq=freq_affichage_images,\r\n",
                "    seed=seed,\r\n",
                ")\r\n",
                "\r\n",
                "if MODE_GDRIVE:\r\n",
                "  args.vqgan_config = models_path + args.vqgan_config\r\n",
                "  args.vqgan_checkpoint = models_path + args.vqgan_checkpoint\r\n",
                "  # debug\r\n",
                "  #print(args.vqgan_checkpoint)\r\n",
                "  #print()\r\n",
                "\r\n",
                "\r\n",
                "print(prompts_list)\r\n",
                "if (len(prompts_list)>1):\r\n",
                "  MODE_MULTIPLE = True \r\n",
                "  print(len(prompts_list), \" prompts\")\r\n",
                "else:\r\n",
                "  MODE_MULTIPLE = False \r\n",
                "\r\n",
                "\r\n",
                "def synth(z):\r\n",
                "    z_q = vector_quantize(z.movedim(1, 3), model.quantize.embedding.weight).movedim(3, 1)\r\n",
                "    return clamp_with_grad(model.decode(z_q).add(1).div(2), 0, 1)\r\n",
                "\r\n",
                "def add_xmp_data(nombrefichero):\r\n",
                "    imagen = ImgTag(filename=nombrefichero)\r\n",
                "    imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'creator', 'VQGAN+CLIP', {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    if args.prompts:\r\n",
                "        imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'title', \" * \".join([\" | \".join([str(c) for c in lst]) for lst in args.prompts]), {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    else:\r\n",
                "        imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'title', 'None', {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'i', str(i), {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'model', nom_modèle, {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'seed',str(seed) , {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'input_images',str(input_images) , {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    #for frases in args.prompts:\r\n",
                "    #    imagen.xmp.append_array_item(libxmp.consts.XMP_NS_DC, 'Prompt' ,frases, {\"prop_array_is_ordered\":True, \"prop_value_is_array\":True})\r\n",
                "    imagen.close()\r\n",
                "\r\n",
                "def add_stegano_data(filename):\r\n",
                "    data = {\r\n",
                "        \"title\": \" * \".join([\" | \".join([str(c) for c in lst]) for lst in args.prompts]) if args.prompts else None,\r\n",
                "        \"notebook\": \"VQGAN+CLIP\",\r\n",
                "        \"i\": i,\r\n",
                "        \"model\": nom_modèle,\r\n",
                "        \"seed\": str(seed),\r\n",
                "        \"input_images\": input_images\r\n",
                "    }\r\n",
                "    lsb.hide(filename, json.dumps(data)).save(filename)\r\n",
                "\r\n",
                "@torch.no_grad()\r\n",
                "def checkin(i, losses):\r\n",
                "    losses_str = ', '.join(f'{loss.item():g}' for loss in losses)\r\n",
                "    tqdm.write(f'i: {i}, loss: {sum(losses).item():g}, losses: {losses_str}')\r\n",
                "    out = synth(z)\r\n",
                "    TF.to_pil_image(out[0].cpu()).save('progress.png')\r\n",
                "    add_stegano_data('progress.png')\r\n",
                "    add_xmp_data('progress.png')\r\n",
                "    display.display(display.Image('progress.png'))\r\n",
                "\r\n",
                "def ascend_txt():\r\n",
                "    global i\r\n",
                "    out = synth(z)\r\n",
                "    iii = perceptor.encode_image(normalize(make_cutouts(out))).float()\r\n",
                "\r\n",
                "    result = []\r\n",
                "\r\n",
                "    if args.init_weight:\r\n",
                "        result.append(F.mse_loss(z, z_orig) * args.init_weight / 2)\r\n",
                "\r\n",
                "    for prompt in pMs:\r\n",
                "        result.append(prompt(iii))\r\n",
                "    img = np.array(out.mul(255).clamp(0, 255)[0].cpu().detach().numpy().astype(np.uint8))[:,:,:]\r\n",
                "    img = np.transpose(img, (1, 2, 0))\r\n",
                "    filename = f\"steps/{i:04}.png\"\r\n",
                "    imageio.imwrite(filename, np.array(img))\r\n",
                "    add_stegano_data(filename)\r\n",
                "    add_xmp_data(filename)\r\n",
                "    return result\r\n",
                "\r\n",
                "def train(i):\r\n",
                "    opt.zero_grad()\r\n",
                "    lossAll = ascend_txt()\r\n",
                "    if (i != 0) and ((i % args.display_freq == 0) or (i % nbr_iteration_max == 0)):\r\n",
                "        checkin(i, lossAll)\r\n",
                "    loss = sum(lossAll)\r\n",
                "    loss.backward()\r\n",
                "    opt.step()\r\n",
                "    with torch.no_grad():\r\n",
                "        z.copy_(z.maximum(z_min).minimum(z_max))\r\n",
                "\r\n",
                "\r\n",
                "\r\n",
                "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\r\n",
                "print('Using device:', device)\r\n",
                "\r\n",
                "\r\n",
                "i = 0\r\n",
                "run = 1\r\n",
                "for prompts in args.prompts:\r\n",
                "  print()\r\n",
                "  print('prompt #', run, ': ', prompts)\r\n",
                "  if image_cible:\r\n",
                "      #TODO: revoir/tester ça\r\n",
                "      print('Using image prompts:', image_cible)\r\n",
                "  if args.seed is None:\r\n",
                "      seed = torch.seed()\r\n",
                "  else:\r\n",
                "      seed = args.seed\r\n",
                "  torch.manual_seed(seed)\r\n",
                "  print('Using seed:', seed)\r\n",
                "\r\n",
                "  model = load_vqgan_model(args.vqgan_config, args.vqgan_checkpoint).to(device)\r\n",
                "  perceptor = clip.load(args.clip_model, jit=False)[0].eval().requires_grad_(False).to(device)\r\n",
                "\r\n",
                "  cut_size = perceptor.visual.input_resolution\r\n",
                "  e_dim = model.quantize.e_dim\r\n",
                "  f = 2**(model.decoder.num_resolutions - 1)\r\n",
                "  make_cutouts = MakeCutouts(cut_size, args.cutn, cut_pow=args.cut_pow)\r\n",
                "  n_toks = model.quantize.n_e\r\n",
                "  toksX, toksY = args.size[0] // f, args.size[1] // f\r\n",
                "  sideX, sideY = toksX * f, toksY * f\r\n",
                "  z_min = model.quantize.embedding.weight.min(dim=0).values[None, :, None, None]\r\n",
                "  z_max = model.quantize.embedding.weight.max(dim=0).values[None, :, None, None]\r\n",
                "\r\n",
                "\r\n",
                "  if args.init_image:\r\n",
                "      pil_image = Image.open(args.init_image).convert('RGB')\r\n",
                "      pil_image = pil_image.resize((sideX, sideY), Image.LANCZOS)\r\n",
                "      z, *_ = model.encode(TF.to_tensor(pil_image).to(device).unsqueeze(0) * 2 - 1)\r\n",
                "  else:\r\n",
                "      one_hot = F.one_hot(torch.randint(n_toks, [toksY * toksX], device=device), n_toks).float()\r\n",
                "      z = one_hot @ model.quantize.embedding.weight\r\n",
                "      z = z.view([-1, toksY, toksX, e_dim]).permute(0, 3, 1, 2)\r\n",
                "  z_orig = z.clone()\r\n",
                "  z.requires_grad_(True)\r\n",
                "  opt = optim.Adam([z], lr=args.step_size)\r\n",
                "\r\n",
                "  normalize = transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],\r\n",
                "                                  std=[0.26862954, 0.26130258, 0.27577711])\r\n",
                "\r\n",
                "\r\n",
                "  pMs = []\r\n",
                "\r\n",
                "  for prompt in prompts:\r\n",
                "      txt, weight, stop = parse_prompt(prompt)\r\n",
                "      embed = perceptor.encode_text(clip.tokenize(txt).to(device)).float()\r\n",
                "      pMs.append(Prompt(embed, weight, stop).to(device))\r\n",
                "\r\n",
                "  for prompt in args.image_prompts:\r\n",
                "      path, weight, stop = parse_prompt(prompt)\r\n",
                "      img = resize_image(Image.open(path).convert('RGB'), (sideX, sideY))\r\n",
                "      batch = make_cutouts(TF.to_tensor(img).unsqueeze(0).to(device))\r\n",
                "      embed = perceptor.encode_image(normalize(batch)).float()\r\n",
                "      pMs.append(Prompt(embed, weight, stop).to(device))\r\n",
                "\r\n",
                "  for seed, weight in zip(args.noise_prompt_seeds, args.noise_prompt_weights):\r\n",
                "      gen = torch.Generator().manual_seed(seed)\r\n",
                "      embed = torch.empty([1, perceptor.visual.output_dim]).normal_(generator=gen)\r\n",
                "      pMs.append(Prompt(embed, weight).to(device))\r\n",
                "\r\n",
                "  try:\r\n",
                "      with tqdm(total=nbr_iteration_max) as pbar:\r\n",
                "          while True:\r\n",
                "              train(i)\r\n",
                "              if i == (nbr_iteration_max*run):\r\n",
                "                  # on met à jour l'image initiale\r\n",
                "                  if reuse_last_image:\r\n",
                "                    args.init_image = f\"steps/{i:04}.png\"\r\n",
                "\r\n",
                "                  current_prompt = \" - \".join(prompts)\r\n",
                "\r\n",
                "                  now = datetime.datetime.now(datetime.timezone.utc)\r\n",
                "                  print(\"nom de fichier suggéré : {:02d}-{:02d} {:02d}h{:02d} {:s} {:d} {:s}\".format( \\\r\n",
                "                      now.month, now.day, now.hour+2, now.minute, \\\r\n",
                "                      nom_modèle, \\\r\n",
                "                      i, \\\r\n",
                "                      current_prompt[:min(len(current_prompt),100)].replace(':','_')))\r\n",
                "                  break\r\n",
                "              i += 1\r\n",
                "              pbar.update()\r\n",
                "  except KeyboardInterrupt:\r\n",
                "      pass\r\n",
                "  \r\n",
                "  run += 1\r\n"
            ],
            "outputs": [],
            "metadata": {
                "id": "g7EDme5RYCrt",
                "cellView": "form"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "# 📽️  En faire une vidéo\n"
            ],
            "metadata": {
                "id": "02ZbcWw5YYnU"
            }
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "#@title 📝 Ajouter les textes en bas de chaque image (optionnel)\r\n",
                "sous_titres = \"None\"#@param {type:\"string\"}\r\n",
                "#@markdown `sous_titres` : liste des textes à ajouter en bas des images, séparés par le caractère `*`.<br>Laisser à None pour utiliser automatiquement `textes`\r\n",
                "hauteur_bordure =  30#@param {type:\"number\"}\r\n",
                "#@markdown `hauteur_bordure` : taille en pixels de la bordure ajoutée en bas\r\n",
                "\r\n",
                "font = ImageFont.truetype(\"NotoSerif-Regular.ttf\", 20)\r\n",
                "\r\n",
                "def ajouter_texte_v2(chemin_image, caption=None):\r\n",
                "  image_pil = Image.open(chemin_image)\r\n",
                "\r\n",
                "  # ajout de place en bas\r\n",
                "  img_colour = (0,0,0)\r\n",
                "  width, height = image_pil.size\r\n",
                "  result = Image.new(image_pil.mode, (width, height+hauteur_bordure), img_colour)\r\n",
                "  result.paste(image_pil, (0, 0))\r\n",
                "\r\n",
                "  # ajout du texte \r\n",
                "  if caption:\r\n",
                "    draw = ImageDraw.Draw(result)\r\n",
                "    draw.text((10, height), caption, size=20, font=font)\r\n",
                "\r\n",
                "  result.save(chemin_image)\r\n",
                "\r\n",
                "\r\n",
                "def ajouter_texte(chemin_image, caption=None):\r\n",
                "  image_pil = Image.open(chemin_image)\r\n",
                "\r\n",
                "  # ajout de place en bas\r\n",
                "  img_colour = (0,0,0)\r\n",
                "  width, height = image_pil.size\r\n",
                "  #if height < hauteur+hauteur_bordure:\r\n",
                "  result = Image.new(image_pil.mode, (width, height+hauteur_bordure), img_colour)\r\n",
                "  result.paste(image_pil, (0, 0))\r\n",
                "  #else:\r\n",
                "  #  result = image_pil\r\n",
                "\r\n",
                "  # ajout du texte \r\n",
                "  if caption:\r\n",
                "    draw = ImageDraw.Draw(result)\r\n",
                "    draw.text((10, height+5), caption, size=20)\r\n",
                "\r\n",
                "  result.save(chemin_image)\r\n",
                "\r\n",
                "if sous_titres == \"None\":\r\n",
                "  sous_titres = prompts_list\r\n",
                "else:\r\n",
                "  captions_list = []\r\n",
                "  for caption in sous_titres.split('*'):\r\n",
                "    tmp = [frase.strip() for frase in caption.split(\"|\")]\r\n",
                "    if tmp != ['']:\r\n",
                "      captions_list.append(tmp)\r\n",
                "  if captions_list == ['']:\r\n",
                "      captions_list = []\r\n",
                "  sous_titres = captions_list\r\n",
                "\r\n",
                "print(\"sous-titres : \", sous_titres)\r\n",
                "print()\r\n",
                "\r\n",
                "i -= 1 # 100 itérations, dernier fichier : 0100.png et non 0099.png\r\n",
                "\r\n",
                "premiere_image = 0\r\n",
                "derniere_image = i\r\n",
                "for t in range(premiere_image,derniere_image+1): # ne pas oublier le +1 :)\r\n",
                "  ajouter_texte_v2(f\"steps/{t:04}.png\", sous_titres[t // nbr_iteration_max][0])\t# // : floor division\r\n",
                "\r\n",
                "  if t % nbr_iteration_max == 0:\r\n",
                "    print('image {:04d}\\t{:s}'.format(t,sous_titres[t // nbr_iteration_max][0]))\r\n",
                "\r\n",
                "print()\r\n",
                "print(\"dernière image :\", f\"steps/{t:04}.png\")\r\n",
                "display.display(display.Image(f\"steps/{t:04}.png\"))\r\n"
            ],
            "outputs": [],
            "metadata": {
                "id": "C1L9i9FZRt5-",
                "cellView": "form"
            }
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "#@title 📽️ Créer la vidéo\r\n",
                "\r\n",
                "#@markdown `intervale` indique à quelle fréquence les images doivent être ajoutées à la vidéo – 1 correspond à toutes les images, 2 correspond à une image sur deux, etc.\r\n",
                "première_image = 1 #@param {type: Number} #Este es el frame donde el vídeo empezará\r\n",
                "dernière_image = i-1\r\n",
                "\r\n",
                "fps = 20 #@param {type: Number} #\r\n",
                "intervale = 1 #@param {type: Number} #\r\n",
                "\r\n",
                "total_frames = dernière_image-première_image\r\n",
                "\r\n",
                "frames = []\r\n",
                "tqdm.write('Création de la vidéo…')\r\n",
                "\r\n",
                "#ensure first frame is always appended\r\n",
                "if(première_image % intervale is not 0):\r\n",
                "    filename = f\"steps/{première_image:04}.png\"\r\n",
                "    frames.append(Image.open(filename))\r\n",
                "\r\n",
                "#for i in range(première_image,min(dernière_image,nbr_iteration_max)+1): \r\n",
                "for i in range(première_image,dernière_image+1):\r\n",
                "    if(i % intervale is not 0):\r\n",
                "       continue\r\n",
                "    filename = f\"steps/{i:04}.png\"\r\n",
                "    frames.append(Image.open(filename))\r\n",
                "\r\n",
                "#ensure last frame is always appended\r\n",
                "if(dernière_image % intervale is not 0):\r\n",
                "    filename = f\"steps/{dernière_image:04}.png\"\r\n",
                "    frames.append(Image.open(filename))\r\n",
                "\r\n",
                "from subprocess import Popen, PIPE\r\n",
                "p = Popen(['ffmpeg', '-y', '-f', 'image2pipe', '-vcodec', 'png', '-r', str(fps), '-i', '-', '-vcodec', 'libx264', '-r', str(fps), '-pix_fmt', 'yuv420p', '-crf', '17', '-preset', 'veryslow', 'video.mp4'], stdin=PIPE)\r\n",
                "for im in tqdm(frames):\r\n",
                "    im.save(p.stdin, 'PNG')\r\n",
                "p.stdin.close()\r\n",
                "\r\n",
                "print(\"La vidéo est en train d'être finalisée…\")\r\n",
                "p.wait()\r\n",
                "print(\"La vidéo est prête.\")\r\n"
            ],
            "outputs": [],
            "metadata": {
                "id": "QOC0QQHiNXoo",
                "cellView": "form"
            }
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "source": [
                "# @title 📥 Télécharger la vidéo\r\n",
                "from google.colab import files\r\n",
                "files.download(\"video.mp4\")"
            ],
            "outputs": [],
            "metadata": {
                "id": "SGZBlTlLZ3Cj",
                "cellView": "form"
            }
        },
        {
            "cell_type": "markdown",
            "source": [
                "# 🏰 Historique\r\n",
                "\r\n",
                "Méthode d’origine BigGAN+CLIP créée par https://twitter.com/advadnoun, adapté par Katherine Crowson (https://github.com/crowsonkb, https://twitter.com/RiversHaveWings).\r\n",
                "\r\n",
                "Traduction en espagnol, modifications, et explications ajoutées par Eleiber#8347, et interface conviviale conçue par Abulafia#3734.\r\n",
                "\r\n",
                "Améliorations et traduction en français par Épinards & Caramel (https://github.com/xDEADC0DE, https://twitter.com/epinardscaramel)\r\n",
                "\r\n",
                "Un tutoriel détaillé est disponible (en espagnol) à https://tuscriaturas.miraheze.org/wiki/Ayuda:Crear_imágenes_con_VQGAN+CLIP, écrit par Jakeukalane#2767 et Avengium (Ángel)#3715."
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "# ⚖️ Licence\r\n",
                "\r\n",
                "**Licensed under the MIT License**\r\n",
                "\r\n",
                "Copyright (c) 2021 Katherine Crowson\r\n",
                "\r\n",
                "Permission is hereby granted, free of charge, to any person obtaining a copy\r\n",
                "of this software and associated documentation files (the \"Software\"), to deal\r\n",
                "in the Software without restriction, including without limitation the rights\r\n",
                "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n",
                "copies of the Software, and to permit persons to whom the Software is\r\n",
                "furnished to do so, subject to the following conditions:\r\n",
                "\r\n",
                "The above copyright notice and this permission notice shall be included in\r\n",
                "all copies or substantial portions of the Software.\r\n",
                "\r\n",
                "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n",
                "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n",
                "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n",
                "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n",
                "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n",
                "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n",
                "THE SOFTWARE."
            ],
            "metadata": {
                "id": "jM8INRnvIlvU"
            }
        }
    ]
}