FaceColab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FaceColab.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/andentze/FaceColab_Unofficial/blob/main/FaceColab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_7-0WoBC71P8"
      },
      "source": [
        "# Faceswap Notebook\n",
        " \n",
        "Welcome to the Faceswap *not official* notebook. Ever had a problem with your PC/laptop not being good enough for Faceswap? This notebook will help you out with **everything** regarding Faceswap.\n",
        " \n",
        " \n",
        "Feel free to set up the environment as you like. I, personally, prefer my dataset and the model being on the Google Drive directly, or something like this:\n",
        " \n",
        "> \"/content/drive/My Drive/colab/faceswap/model\n",
        " \n",
        "> \"/content/drive/My Drive/colab/faceswap/faces/A\n",
        " \n",
        "> /content/drive/My Drive/colab/faceswap/faces/B\n",
        " \n",
        "> /content/drive/My Drive/colab/faceswap/config\n",
        " \n",
        "and so on.\n",
        " \n",
        "You can choose to either use the GUI version of Faceswap(*which can take some time to set up*) or the CLI version of Faceswap that is present here.\n",
        " \n",
        "You will also receive 4 kinds of GPUs: P4, T4, K80 or P100(*different kinds of GPU's in Colab Pro which are proven to be faster*). Also, you get 12 hours of notebook usage until you get disconnected(24 hours in Colab Pro). You *might* get frequent disconnects.\n",
        " \n",
        "And before you start using this notebook, clone it to your Google Drive. (File -> Save a copy in Drive)\n",
        "\n",
        "**I TAKE NO CREDIT FOR ANY REPOSITORIES, NOR SOFTWARE USED IN THIS NOTEBOOK. ANYTHING USED HERE IS NOT MINE.**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7TctjDRl8d3N",
        "cellView": "form"
      },
      "source": [
        "#@title Check the current GPU\n",
        "#@markdown Right here you can check what kind of GPU you have available right now. Run this code to output the GPU used.\n",
        "#@markdown If it errors out, make sure your runtime type is set to \"GPU\".\n",
        "\n",
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "btFh5tBGExWQ",
        "cellView": "form"
      },
      "source": [
        "#@title Keep-Alive Script\n",
        "#@markdown You have to activate this to automatically reconnect if Colab disconnects you. Run this code, to activate the \"Keep-Alive\" script.\n",
        "#@markdown And just to make sure, open the console using Ctrl+Shift+I, and paste the code below. This will work efficently for both CLI and DE.\n",
        " \n",
        "import IPython\n",
        "from google.colab import output\n",
        " \n",
        "display(IPython.display.Javascript('''\n",
        "function ClickConnect() {\n",
        "  console.log('Working')\n",
        "  document\n",
        "    .querySelector('#top-toolbar > colab-connect-button')\n",
        "    .shadowRoot.querySelector('#connect')\n",
        "    .click()\n",
        "}\n",
        " \n",
        "setInterval(ClickConnect, 60000)\n",
        "'''))\n",
        " \n",
        "print(\"Done.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vnAN0NQAGe49"
      },
      "source": [
        "> function ClickConnect() {\n",
        "\n",
        ">  console.log('Working')\n",
        "\n",
        ">  document\n",
        "\n",
        ">    .querySelector('#top-toolbar > colab-connect-button')\n",
        "\n",
        ">    .shadowRoot.querySelector('#connect')\n",
        "\n",
        ">    .click()\n",
        "}\n",
        "\n",
        ">    setInterval(ClickConnect, 60000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IVcGpeieHXHb"
      },
      "source": [
        "# Setting up the CLI\n",
        "\n",
        "Not a fan of the GUI or it simply doesn't work? Look no furher. From this point you will install Faceswap directly to Colab without the need of the DE.\n",
        "\n",
        "It was set up so even a toddler could figure out how it works."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I6ZS8LK0IjPK",
        "cellView": "form"
      },
      "source": [
        "#@title Install Faceswap\n",
        "#@markdown Install Faceswap using this code snippet.\n",
        "#@markdown This will also copy your configuration files from your Drive, so specify the directory to each .ini file *if needed*.\n",
        "\n",
        "#@markdown It will also ask for a Google authentication with a prompt. That is for a Google Drive mounting. You need this for persistance storage. Make sure your Drive is ready to use.\n",
        "train = \"train.ini dir(/content/dir/train.ini)\" #@param {type:\"string\"}\n",
        "extract = \"extract.ini dir(/content/dir/extract.ini)\" #@param {type:\"string\"}\n",
        "convert = \"extract.ini dir(/content/dir/convert.ini)\" #@param {type:\"string\"}\n",
        "#@markdown If you install Faceswap to your drive, you'll have to tick \"drive_install\" on every code chunk. But, it saves your time so you won't have to install Faceswap again everytime you crash.\n",
        "install_to_drive = False #@param {type:\"boolean\"}\n",
        "\n",
        "from IPython.display import clear_output\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "!git clone https://github.com/deepfakes/faceswap.git\n",
        "!git clone https://github.com/andentze/facecolab_requirements\n",
        "!cp \"{train}\" faceswap/config/\n",
        "!cp \"{extract}\" faceswap/config/\n",
        "!cp \"{convert}\" faceswap/config/\n",
        "clear_output()\n",
        "#!pip install -r faceswap/requirements_nvidia.txt\n",
        "#!pip uninstall -y imageio\n",
        "#!pip uninstall -y imageio-ffmpeg\n",
        "!pip uninstall -y tensorflow\n",
        "#!pip uninstall -y tensorflow-gpu\n",
        "\n",
        "!pip install -r \"/content/facecolab_requirements/requirements_nvidia.txt\"\n",
        "#!pip install \"imageio>=2.9.0\"\n",
        "#!pip install \"imageio-ffmpeg<0.4.3\"\n",
        "#!pip install \"ffmpy==0.2.3\"\n",
        "#!pip install \"tensorflow-gpu>=2.2.0,<2.5.0\"\n",
        "\n",
        "if install_to_drive:\n",
        "  !cp \"/content/faceswap\" \"/content/drive/My Drive/\" -r\n",
        "  print(\"Installed to Google Drive.\")\n",
        "  print(\"Deleting the old faceswap folder.\")\n",
        "  !rm -r \"/content/faceswap/\"\n",
        "%env FACESWAP_BACKEND = \"nvidia\"\n",
        "clear_output()\n",
        "print(\"Done.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hvi8sfssLKR8"
      },
      "source": [
        "And with that, you're good to go! You can go ahead, and use Faceswap at your own will!(*that is, until you hit a 12 hour mark.*)\n",
        "\n",
        "**It appears Colab doesn't like long-terms calculations. So it will disconnect you at the most random times. BE AWARE OF THAT.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PgIDaoDPemKr"
      },
      "source": [
        "# Workflow\n",
        " \n",
        "Welcome to the Faceswap environment. Your first step is to extract the faces from your footage. After which you're going to have to fix your dataset. While PC/laptop users can fix that locally, mobile users will have to use the DE to do so."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zta3jdNf7Wlf",
        "cellView": "form"
      },
      "source": [
        "#@title Extraction\n",
        "#@markdown Extraction is the first step for dataset creation. You **must** have good data in order for training to work better. Use this code snippet to extract your dataset.\n",
        " \n",
        "#set variables start\n",
        " \n",
        "input_dir = \"/your/dir/to/videos/here\" #@param {type:\"string\"}\n",
        "output_dir = \"your/dir/to/faces/here\" #@param {type:\"string\"}\n",
        "detector = \"s3fd\" #@param [\"cv2-dnn\", \"mtcnn\", \"s3fd\"]\n",
        "alignment = \"fan\" #@param [\"cv2dnn\", \"fan\"]\n",
        "masker = \"unet-dfl\" #@param [\"bisenet-fp\", \"unet-dfl\", \"vgg-clear\", \"vgg-obstructed\"]\n",
        "al_normalization = \"hist\" #@param [\"clahe\", \"hist\", \"mean\"]\n",
        "refeed = 3 #@param {type:\"slider\", min:0, max:10, step:1}\n",
        "size = 512 #@param {type:\"slider\", min:256, max:2048, step:64}\n",
        "extract_every_n = 1 #@param {type:\"slider\", min:1, max:30, step:1}\n",
        "drive_install = False #@param {type:\"boolean\"}\n",
        "if drive_install:\n",
        "  path = \"/content/drive/My Drive/faceswap/\"\n",
        "  print(\"The installation is on Google Drive. Using Drive directory.\")\n",
        "if not drive_install:\n",
        "  path = \"/content/faceswap/\"\n",
        "  print(\"The installation is local. Using local directory.\")\n",
        "#set variables end\n",
        "\n",
        "!python3 '{path}'faceswap.py extract \\\n",
        "-i '{input_dir}' \\\n",
        "-o '{output_dir}' \\\n",
        "-D '{detector}' \\\n",
        "-A '{alignment}' \\\n",
        "-M '{masker}' \\\n",
        "-nm '{al_normalization}' \\\n",
        "-rf '{refeed}' \\\n",
        "-min 20 -l 0.4 \\\n",
        "-sz '{size}' \\\n",
        "-een '{extract_every_n}' \\\n",
        "-si 0 -ssf -L INFO"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Extraction with saving faces\n",
        "#@markdown Extraction is the first step for dataset creation. You **must** have good data in order for training to work better. Use this code snippet to extract your dataset.\n",
        "\n",
        "#@markdown The script above extracts each face and does not save faces to the directory. Use this code to actually save faces and tinker around with them.\n",
        "\n",
        "#set variables start\n",
        "\n",
        "!python3 '{path}'faceswap.py extract \\\n",
        "-i '{input_dir}' \\\n",
        "-o '{output_dir}' \\\n",
        "-D '{detector}' \\\n",
        "-A '{alignment}' \\\n",
        "-M '{masker}' \\\n",
        "-nm '{al_normalization}' \\\n",
        "-rf '{refeed}' \\\n",
        "-min 20 -l 0.4 \\\n",
        "-sz '{size}' \\\n",
        "-een '{extract_every_n}' \\\n",
        "-si 0 -L INFO"
      ],
      "metadata": {
        "cellView": "form",
        "id": "twHA2JGjzPXB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6D42AWnZUc6",
        "cellView": "form"
      },
      "source": [
        "#@title Training\n",
        "#@markdown Now, you have your dataset at tip-top shape! All you have to do is start training now! But wait. Before you actually start, make sure your configuration was set right.\n",
        " \n",
        "#@markdown Made sure? Then get to training by setting up the variables first.\n",
        " \n",
        "#set variables start\n",
        "input_a = \"your/dir/here/A\" #@param {type:\"string\"}\n",
        "input_b = \"your/dir/here/B\" #@param {type:\"string\"}\n",
        "num_iterations = 1200000 #@param {type:\"slider\", min:100000, max:3000000, step:25000}\n",
        "save_every = 360 #@param {type:\"slider\", min:360, max:1800, step:360}\n",
        "save_model_every = 25000 #@param {type:\"slider\", min:25000, max:100000, step:25000}\n",
        "batch_num = 48 #@param {type:\"slider\", min:4, max:72, step:4}\n",
        " \n",
        "trainer_type = \"dfaker\" #@param [\"lightweight\", \"original\", \"iae\", \"dfaker\", \"dlight\", \"unbalanced\", \"dfl-h128\", \"villain\"]\n",
        " \n",
        "model_dir = \"/content/dir/your_model/\" #@param {type:\"string\"}\n",
        "timelapse_dir = \"/content/dir/timelapse/\" #@param {type:\"string\"}\n",
        "\n",
        "drive_install = False #@param {type:\"boolean\"}\n",
        "if drive_install:\n",
        "  path = \"/content/drive/My Drive/faceswap/\"\n",
        "  print(\"The installation is on Google Drive. Using Drive directory.\")\n",
        "if not drive_install:\n",
        "  path = \"/content/faceswap/\"\n",
        "  print(\"The installation is local. Using local directory.\")\n",
        "#set variables end\n",
        " \n",
        "   #fit training args: -nw -nf\n",
        " \n",
        "!python3 '{path}'/faceswap.py train \\\n",
        "  -A '{input_a}' \\\n",
        "  -B '{input_b}' \\\n",
        "  -m '{model_dir}' \\\n",
        "  -t '{trainer_type}' \\\n",
        "  -bs '{batch_num}' \\\n",
        "  -it '{num_iterations}' \\\n",
        "  -s '{save_every}' \\\n",
        "  -ss '{save_model_every}' \\\n",
        "  -tia '{input_a}' \\\n",
        "  -tib '{input_b}' \\\n",
        "  -to '{timelapse_dir}' \\\n",
        "  -w "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "YnHtwcncTuOd"
      },
      "source": [
        "#@title Training with No Warp\n",
        "#@markdown Disabling the warp can let you achieve extra sharpness. Start this training sequence if you think your model has trained enough(*judge by the previews*).\n",
        "#@markdown Your variables are saved from the training session above. If not, start your normal training sequence first, then terminate it.\n",
        "\n",
        "drive_install = False #@param {type:\"boolean\"}\n",
        "if drive_install:\n",
        "  path = \"/content/drive/My Drive/faceswap/\"\n",
        "  print(\"The installation is on Google Drive. Using Drive directory.\")\n",
        "if not drive_install:\n",
        "  path = \"/content/faceswap/\"\n",
        "  print(\"The installation is local. Using local directory.\")\n",
        "\n",
        "!python3 '{path}'/faceswap.py train \\\n",
        "  -A '{input_a}' \\\n",
        "  -B '{input_b}' \\\n",
        "  -m '{model_dir}' \\\n",
        "  -t '{trainer_type}' \\\n",
        "  -bs '{batch_num}' \\\n",
        "  -it '{num_iterations}' \\\n",
        "  -s '{save_every}' \\\n",
        "  -ss '{save_model_every}' \\\n",
        "  -tia '{input_a}' \\\n",
        "  -tib '{input_b}' \\\n",
        "  -to '{timelapse_dir}' \\\n",
        "  -w \\\n",
        "  -nw"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ORdq3Tx1lgAu",
        "cellView": "form"
      },
      "source": [
        "#@title Convert\n",
        "#@markdown After your model is trained enough, you can convert your final result. Fill the variables and run the code yet another time.\n",
        "\n",
        "#variables set\n",
        "input_video = \"/content/dir/videoA.mp4\" #@param {type:\"string\"}\n",
        "output_dir = \"/content/dir/output\" #@param {type:\"string\"}\n",
        "alingments = \"/content/dir/alignments.fsa\" #@param {type:\"string\"}\n",
        "model_dir = \"/content/dir/your_model\" #@param {type:\"string\"}\n",
        "color_adj = \"\" #@param [\"\", \"avg-color\", \"color-transfer\", \"manual-balance\", \"match-hist\", \"seamless-clone\"]\n",
        "mask = \"\" #@param [\"\", \"components\", \"extended\", \"unet-dfl\", \"vgg-clear\", \"vgg-obstructed\", \"predicted\"]\n",
        "writer = \"ffmpeg\" #@param [\"ffmpeg\", \"gif\", \"opencv\", \"pillow\"]\n",
        "output_scale = 100 #@param {type:\"slider\", min:25, max:400, step:5}\n",
        "drive_install = False #@param {type:\"boolean\"}\n",
        "if drive_install:\n",
        "  path = \"/content/drive/My Drive/faceswap/\"\n",
        "  print(\"The installation is on Google Drive. Using Drive directory.\")\n",
        "if not drive_install:\n",
        "  path = \"/content/faceswap/\"\n",
        "  print(\"The installation is local. Using local directory.\")\n",
        "#@markdown \"Predicted\" mask type is used only if you trained your own mask using \"Learn Mask\". If you're not sure, use \"Components\" or \"Extended\" as they are used by default.\n",
        "#variables end\n",
        "\n",
        "!python3 faceswap/faceswap.py convert \\\n",
        "-i '{input_video}' \\\n",
        "-o '{output_dir}' \\\n",
        "-al '{alignments}' \\\n",
        "-m '{model_dir}' \\\n",
        "-c '{color_adj}' \\\n",
        "-M '{mask}aa' \\\n",
        "-w '{writer}' \\\n",
        "-osc '{output_scale}' -l 0.4 -j 0 -L INFO"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Convert with Swap Model\n",
        "#@markdown Noticed that you trained the model the other way around? Do not worry. Run this to convert it the other way around.\n",
        "\n",
        "#@markdown The variables should stay the same as from the code above.\n",
        "\n",
        "!python3 faceswap/faceswap.py convert \\\n",
        "-i '{input_video}' \\\n",
        "-o '{output_dir}' \\\n",
        "-al '{alignments}' \\\n",
        "-m '{model_dir}' \\\n",
        "-c '{color_adj}' \\\n",
        "-M '{mask}aa' \\\n",
        "-w '{writer}' \\\n",
        "-osc '{output_scale}' -s -l 0.4 -j 0 -L INFO"
      ],
      "metadata": {
        "cellView": "form",
        "id": "PYMlgKBSw8iZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vqe2bTXRKjGC"
      },
      "source": [
        "# Various Tools\n",
        "\n",
        "*Use if necessary.*\n",
        "\n",
        "Faceswap provides a couple of handy tools for you to make your dataset managment easier. Here you can do whatever you want(*limited to the \"Manual\" tool as it requires a desktop environment*)."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Download a video from YouTube\n",
        "\n",
        "#@markdown Using this code snippet you can download your desired YouTube video to your Drive immediately. This is proven to save some time downloading it locally and copying it to the Drive.\n",
        "\n",
        "#@markdown Go ahead and get your URL and the path with your desired quality and run the code.\n",
        "from IPython.display import clear_output\n",
        "\n",
        "!pip install pytube\n",
        "clear_output()\n",
        "\n",
        "from pytube import YouTube\n",
        "\n",
        "url = \"https://www.youtube.com/watch?v=yourlinkhere\" #@param {type:\"string\"}\n",
        "path = \"/content/drive/MyDrive/your/dir/here\" #@param {type:\"string\"}\n",
        "video_name = \"your_file_name.mp4\" #@param {type:\"string\"}\n",
        "#@markdown Make sure that your video supports your desired quality, else you're not going to succeed with the download.\n",
        "quality = \"1080p\" #@param [\"720p\", \"1080p\"]\n",
        "\n",
        "try:\n",
        "  yt = YouTube(url)\n",
        "  print(\"Downloading the video. Please wait.\")\n",
        "  yt.streams.filter(res = quality, progressive = True, file_extension = \"mp4\").first().download(output_path = path, filename = video_name)\n",
        "  clear_output()\n",
        "except:\n",
        "  clear_output()\n",
        "  print(\"Something went wrong. Please double-check your set variables, verify the video exists and try again.\")\n",
        "  print(\"Else use an external downloader and copy the file manually.\")\n",
        "print(\"Done.\")\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "7ItrEbDjk-QK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Faceswap Tools\n",
        "\n",
        "#@markdown These are the most handy tools to use for managing the dataset using Faceswap."
      ],
      "metadata": {
        "cellView": "form",
        "id": "MKwLQMDRqzY5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Alignments\n",
        "#@markdown This tool allows you to perform various actions to the alignments file. It is usually stored next to the video source file.\n",
        "#@markdown You would only need \"Remove Faces\" job for most of the time.\n",
        "#@markdown If you wish to use any other tool, proceed to the guides to find out how to use some of them.\n",
        "#set variables\n",
        "job = \"remove-faces\" #@param [\"draw\", \"extract\", \"missing-alignments\", \"missing-frames\", \"multi-faces\", \"no-faces\", \"remove-faces\", \"rename\", \"sort\"]\n",
        "alignments = \"/content/dir/alignments.fsa\" #@param {type:\"string\"}\n",
        "faces = \"/content/dir/A or B\" #@param {type:\"string\"}\n",
        "drive_install = False #@param {type:\"boolean\"}\n",
        "if drive_install:\n",
        "  path = \"/content/drive/My Drive/faceswap/\"\n",
        "  print(\"The installation is on Google Drive. Using Drive directory.\")\n",
        "if not drive_install:\n",
        "  path = \"/content/faceswap/\"\n",
        "  print(\"The installation is local. Using local directory.\")\n",
        "#end variables\n",
        "!python3 faceswap\\tools.py alignments \\\n",
        "-j '{job}' \\\n",
        "-o console \\\n",
        "-a '{alignments}' \\\n",
        "-fc '{faces}' \\\n",
        "-een 1 -sz 512 -L INFO\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "83ydXHCnqjDR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title FFmpeg\n",
        "#@markdown Generate videos for timelapse(*usually this tool is required for that*). **Strongly** recommended to use BRU first to rename each timestamp to start from 000000.jpeg.\n",
        "\n",
        "#set variables\n",
        "input = \"your/timelapse/dir/here\" #@param {type:\"string\"}\n",
        "output = \"your/video/output/here/example.mp4\" #@param {type:\"string\"}\n",
        "fps = 5 #@param {type:\"slider\", min:1, max:60}\n",
        "\n",
        "#end variables\n",
        "!python3 faceswap\\tools.py effmpeg \\\n",
        "-a gen-vid \\\n",
        "-i input \\\n",
        "-o output \\\n",
        "-fps fps \\\n",
        "-ef .png \\\n",
        "-s 00:00:00 \\\n",
        "-e 00:00:00 \\\n",
        "-d 00:00:00 -sc 1920x1080 -L INFO"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Td8VqXsuq8S4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Sort\n",
        "\n",
        "#@markdown This is the Sort tool. It helps you with cleaning your dataset more efficiently.\n",
        "\n",
        "#@markdown The sorting may require **a lot** of RAM depending on your dataset quantity. The bigger your dataset is, the more RAM you may need.\n",
        "\n",
        "#@markdown The formula for calculating the ammount of RAM is: *(n² * 24) / 1.8* where *n* is the number of images.\n",
        "#@markdown The number you'll get is in bytes, so divide it by 1024 for megabytes, and by 1024 again to get gigabytes.\n",
        "\n",
        "#@markdown If the sorting fails(*i.e. the OOM issue*), divide the dataset in some small parts and sort each one of them.\n",
        "\n",
        "#@markdown Please note, that there are only those jobs, that **I** think are useful.\n",
        "input = \"/content/drive/MyDrive/colab_files/faceswap/faces/A\" #@param{type:\"string\"}\n",
        "job = \"face\" #@param [\"face\", \"blur\", \"hist\"]\n",
        "\n",
        "!python3 faceswap/tools.py sort \\\n",
        "-i '{input}' \\\n",
        "-s '{job}' \\\n",
        "-t -1.0 -fp rename -g hist -b 5 -lf sort_log.json -L INFO"
      ],
      "metadata": {
        "cellView": "form",
        "id": "YjpMdDFktO-m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P6YcIgZV_3xA"
      },
      "source": [
        "# Setting up the Desktop Environment\n",
        " \n",
        "Now that we know we have a GPU available, we're set. Now, **you** choose what kind of environment you need or want.\n",
        " \n",
        "*   Desktop Environment\n",
        "*   Command Line(CLI)\n",
        " \n",
        "A little side-note:\n",
        " \n",
        "*   Desktop Environments take 5-8 minutes to set up, while CLI takes around 4 minutes.\n",
        "*   Desktop Environments are a bit unstable, as Colab was not intended to use in such way. So, be careful.\n",
        " \n",
        "The RDP snippet was taken from this repository:\n",
        "https://github.com/PradyumnaKrishna/Colab-Hacks/\n",
        "\n",
        "**YET TO BE IMPLEMENTED COMPLETELY, DO NOT USE UNTIL IT IS DONE. CLI IS USABLE FOR NOW**\n",
        "\n",
        "**NOT RECOMMENDED TO USE**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XDQlUuKeBbX6",
        "cellView": "form"
      },
      "source": [
        "#@title Create a User\n",
        "#@markdown Create a user here, you can leave the name and the password as default.\n",
        "#@markdown This is **required** for the DE(Desktop Environment).\n",
        " \n",
        "import os\n",
        " \n",
        "username = \"user\" #@param {type:\"string\"}\n",
        "password = \"root\" #@param {type:\"string\"}\n",
        " \n",
        "print(\"Creating User and Setting it up\")\n",
        " \n",
        "# Creation of user\n",
        "os.system(f\"useradd -m {username}\")\n",
        " \n",
        "# Add user to sudo group\n",
        "os.system(f\"adduser {username} sudo\")\n",
        "    \n",
        "# Set password of user to 'root'\n",
        "os.system(f\"echo '{username}:{password}' | sudo chpasswd\")\n",
        " \n",
        "# Change default shell from sh to bash\n",
        "os.system(\"sed -i 's/\\/bin\\/sh/\\/bin\\/bash/g' /etc/passwd\")\n",
        " \n",
        "print(\"User Created and Configured\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LQ71d37CCOPr",
        "cellView": "form"
      },
      "source": [
        "#@title Install the RDP\n",
        "#@markdown Now, you can install RDP. Visit http://remotedesktop.google.com/headless and copy the command for Debian after authentication. Then, run this code. It will take 5-8 minutes to install.\n",
        " \n",
        "import os\n",
        "import subprocess\n",
        " \n",
        "CRP = \"DISPLAY= /opt/google/chrome-remote-desktop/start-host --code=\\\"4/0AY0e-g7_v-8XXFg429fOGy2bLQ_93HV7FdbGr7k6RtwqUEkzAoH6J0FH1MUmFZ3wyu7fNQ\\\" --redirect-url=\\\"https://remotedesktop.google.com/_/oauthredirect\\\" --name=$(hostname)\" #@param {type:\"string\"}\n",
        " \n",
        "#@markdown Enter a pin more or equal to 6 digits.\n",
        "Pin = 123456 #@param {type: \"integer\"}\n",
        " \n",
        " \n",
        "class CRD:\n",
        "    def __init__(self):\n",
        "        os.system(\"apt update\")\n",
        "        self.installCRD()\n",
        "        self.installDesktopEnvironment()\n",
        "        self.installGoogleChorme()\n",
        "        self.finish()\n",
        " \n",
        "    @staticmethod\n",
        "    def installCRD():\n",
        "        print(\"Installing Chrome Remote Desktop\")\n",
        "        subprocess.run(['wget', 'https://dl.google.com/linux/direct/chrome-remote-desktop_current_amd64.deb'], stdout=subprocess.PIPE)\n",
        "        subprocess.run(['dpkg', '--install', 'chrome-remote-desktop_current_amd64.deb'], stdout=subprocess.PIPE)\n",
        "        subprocess.run(['apt', 'install', '--assume-yes', '--fix-broken'], stdout=subprocess.PIPE)\n",
        " \n",
        "    @staticmethod\n",
        "    def installDesktopEnvironment():\n",
        "        print(\"Installing Desktop Environment\")\n",
        "        os.system(\"export DEBIAN_FRONTEND=noninteractive\")\n",
        "        os.system(\"apt install --assume-yes xfce4 desktop-base xfce4-terminal\")\n",
        "        os.system(\"bash -c 'echo \\\"exec /etc/X11/Xsession /usr/bin/xfce4-session\\\" > /etc/chrome-remote-desktop-session'\")\n",
        "        os.system(\"apt remove --assume-yes gnome-terminal\")\n",
        "        os.system(\"apt install --assume-yes xscreensaver\")\n",
        "        os.system(\"systemctl disable lightdm.service\")\n",
        " \n",
        "    @staticmethod\n",
        "    def installGoogleChorme():\n",
        "        print(\"Installing Google Chrome\")\n",
        "        subprocess.run([\"wget\", \"https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb\"], stdout=subprocess.PIPE)\n",
        "        subprocess.run([\"dpkg\", \"--install\", \"google-chrome-stable_current_amd64.deb\"], stdout=subprocess.PIPE)\n",
        "        subprocess.run(['apt', 'install', '--assume-yes', '--fix-broken'], stdout=subprocess.PIPE)\n",
        " \n",
        "    @staticmethod\n",
        "    def finish():\n",
        "        print(\"Finalizing\")\n",
        "        os.system(f\"adduser {username} chrome-remote-desktop\")\n",
        "        command = f\"{CRP} --pin={Pin}\"\n",
        "        os.system(f\"su - {username} -c '{command}'\")\n",
        "        os.system(\"service chrome-remote-desktop start\")\n",
        "        print(\"Finished Succesfully\")\n",
        " \n",
        " \n",
        "try:\n",
        "    if username:\n",
        "        if CRP == \"\":\n",
        "            print(\"Please enter authcode from the given link\")\n",
        "        elif len(str(Pin)) < 6:\n",
        "            print(\"Enter a pin more or equal to 6 digits\")\n",
        "        else:\n",
        "            CRD()\n",
        "except NameError as e:\n",
        "    print(\"username variable not found\")\n",
        "    print(\"Create a User First\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RidH0tfrDBg6",
        "cellView": "form"
      },
      "source": [
        "#@title Mount the Google Drive\n",
        "#@markdown Google Drive is used as Persistance HDD for files. It is mounted at your `user` folder. (*`root` if the username was not set*)\n",
        "#@markdown This is for DE, look farther down for CLI.\n",
        " \n",
        "def MountGDrive():\n",
        "    from google.colab import drive\n",
        " \n",
        "    ! runuser -l $user -c \"yes | python3 -m pip install --user google-colab\"  > /dev/null 2>&1\n",
        " \n",
        "    mount = \"\"\"from os import environ as env\n",
        "from google.colab import drive\n",
        " \n",
        "env['CLOUDSDK_CONFIG']  = '/content/.config'\n",
        "drive.mount('{}')\"\"\".format(mountpoint)\n",
        " \n",
        "    with open('/content/mount.py', 'w') as script:\n",
        "        script.write(mount)\n",
        " \n",
        "    ! runuser -l $user -c \"python3 /content/mount.py\"\n",
        " \n",
        "try:\n",
        "    if username:\n",
        "        mountpoint = \"/home/\"+username+\"/drive\"\n",
        "        user = username\n",
        "except NameError:\n",
        "    print(\"username variable not found, mounting at `/content/drive' using `root'\")\n",
        "    mountpoint = '/content/drive'\n",
        "    user = 'root'\n",
        " \n",
        "MountGDrive()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b5jP2nJCEiX5"
      },
      "source": [
        "From there, you can install Faceswap *easily*. Or, you can use this to clean your dataset. But. Don't forget that Colab terminates your session if it's not active. So make sure your \"Keep-Alive\" script is active.\n",
        "\n",
        "*After checking the installation, turns out it doesn't like a couple of dependicies.*\n",
        "\n",
        "(yet to be checked and fixed if necessary)\n",
        "\n",
        "**AGAIN, NOT RECOMMENDED TO USE**"
      ]
    }
  ]
}