Co_compose_with_Jukebox_0_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JosephBless/Deep-Learning-Colab/blob/main/Co_compose_with_Jukebox_0_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6xiLpYRYZ5LH"
      },
      "source": [
        "# Co-compose with OpenAI Jukebox\n",
        "\n",
        "alpha 0.1\n",
        "\n",
        "**Usage** :\n",
        "\n",
        "All the cells in this notebook have detailed instructions. Please inspect the whole notebook before running for the first time, to understand the workflow.\n",
        "If Jukebox is unfamiliar, I recommend watching my video tutorial, link below.\n",
        "\n",
        "When you start a new project, fill in the details in the \"Project options\" form.\n",
        "Later if you resume the project, just fill in the project folder name (the working directory with the priming wav).\n",
        "\n",
        "When resuming, the only thing you need to run in every session is the setup. Then you can go straight to where you left off, either to continue the song or upsample it.\n",
        "\n",
        "**Features** :\n",
        "- all the checkpoints and data are saved automatically on Google Drive, you can always start from where you left\n",
        "- make branches of your progress\n",
        "- Zag's incremental upsampling\n",
        "- uses its own repo for Jukebox sources (no rewriting of sample.py)\n",
        "- artists/genres list\n",
        "\n",
        "**Restrictions**:\n",
        "- Co-composing only\n",
        "- Primed mode only (no ancestral)\n",
        "- 5b_lyrics model only\n",
        "\n",
        "\n",
        "#Thanks\n",
        "to the team at OpenAI for making Jukebox: Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever,\n",
        "\n",
        "SMarioMan and Zag, for authoring the Colab notebooks that this one is essentially based on. And Broccaloo for making tutorials and maintaining the Discord group\n",
        "\n",
        "[Tutorial video](https://youtu.be/5wn3htQl4JA)\n",
        "\n",
        "\n",
        "![johannezz.png](data:image/png;base64,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)\n",
        "\n",
        "\n",
        "Johannezz Music (johannezz.music@gmail.com)\n",
        "\n",
        "[deeplearn.art](https://deeplearn.art)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uq8uLwZCn0BV"
      },
      "source": [
        "\n",
        "![setup.png](data:image/png;base64,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)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OK9qYnel_5mQ"
      },
      "source": [
        "#@title Run this cell to see your GPU\n",
        "!nvidia-smi -L"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZPdMgaH_BPGN",
        "cellView": "form"
      },
      "source": [
        "#@title Run this cell to connect Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5BgzAP1eXOkY"
      },
      "source": [
        "# Project options\n",
        "\n",
        "Project Directory must always be given here. It is simply the folder on Google drive where the primer wav is located. This notebook will put everything else in the same folder."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J5RpbJ9OXLqS"
      },
      "source": [
        "PROJECT_DIRECTORY = '' #@param {type:\"string\"}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rX2VEf7X9Qkw"
      },
      "source": [
        "**Fill the other options only when beginning a new project. No need when you resume.**\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "**Compulsory (you have to supply these)**\n",
        "\n",
        "*Wav*: the name of the primer wav. Do not include .wav file extension.\n",
        "\n",
        "*Artist*: [pick one or more from the list](https://raw.githubusercontent.com/deeplearn-art/jukebox/master/artist_genres.txt)\n",
        "\n",
        "*Genre*:  [pick one or more from the list](https://raw.githubusercontent.com/openai/jukebox/master/jukebox/data/ids/v2_genre_ids.txt)\n",
        "\n",
        "*Prompt length*: How many seconds do you want to hear your priming wav in the beginning?\n",
        "\n",
        "*Initial song length*: How many seconds do you want to generate on the initial run?\n",
        "\n",
        "*Total song length*: How many seconds do you plan the final song to last?\n",
        "\n",
        "---\n",
        "\n",
        "**Optional (it's ok if you leave these blank)**\n",
        "\n",
        "*Lyrics*: Words of a song\n",
        "\n",
        "*Meta*: for instance link to the source of the primer wav\n",
        "\n",
        "*Note*: if you resume later and want to remember something\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jBYqHTb5snb9"
      },
      "source": [
        "#@title Run this cell to setup the project\n",
        "\n",
        "from pathlib import Path\n",
        "\n",
        "WAV = '' #@param {type:\"string\"}\n",
        "ARTIST= '' #@param {type:\"string\"}\n",
        "GENRE = '' #@param {type:\"string\"}\n",
        "\n",
        "PROMPT_LENGTH =  10#@param {type:\"number\"}\n",
        "INITIAL_SONG_LENGTH = 20 #@param {type:\"number\"}\n",
        "TOTAL_SONG_LENGTH =  45#@param {type:\"number\"}\n",
        "\n",
        "LYRICS = '' #@param {type:\"string\"}\n",
        "\n",
        "META = ''#@param {type:\"string\"}\n",
        "NOTE = \"\" #@param {type:\"string\"}\n",
        "SONG_LENGTH = 0\n",
        "\n",
        "sampling_temperature = .98\n",
        "hops = [.5, .5, .125]\n",
        "\n",
        "# Zag's variables\n",
        "leexportlyrics = False\n",
        "leprogress = True\n",
        "leautorename = True\n",
        "\n",
        "# saving and loading project options\n",
        "info = {}\n",
        "song_length = 0\n",
        "project_dir = f'/content/gdrive/MyDrive/{PROJECT_DIRECTORY}/'\n",
        "fname = \"info.txt\"\n",
        "\n",
        "def read_info():\n",
        "  with open(project_dir + fname) as f:\n",
        "    for line in f:\n",
        "      k, v = line.partition(\":\")[::2]\n",
        "      info[k.strip()] = v.strip()\n",
        "\n",
        "def init_info(dir_path):\n",
        "  f = open(dir_path  + fname, \"w\")\n",
        "  f.write(f'''\n",
        "       PROJECT_DIRECTORY : {PROJECT_DIRECTORY}\\n\n",
        "       WAV : {WAV}\n",
        "       ARTIST: {ARTIST}\n",
        "       GENRE : {GENRE}\n",
        "       PROMPT_LENGTH : {PROMPT_LENGTH}\n",
        "       INITIAL_SONG_LENGTH : {INITIAL_SONG_LENGTH}\n",
        "       TOTAL_SONG_LENGTH :  {TOTAL_SONG_LENGTH}\n",
        "       LYRICS : {LYRICS}\n",
        "       META : {META}\n",
        "       NOTE : {NOTE}\n",
        "       SONG_LENGTH : {SONG_LENGTH}\n",
        "  ''')\n",
        "  f.close()\n",
        "\n",
        "def save_info(dir_path):\n",
        "  !rm \"{dir_path + fname}\"\n",
        "  f = open(dir_path  + fname, \"w\")\n",
        "  f.write(f'''\n",
        "       PROJECT_DIRECTORY : {info['PROJECT_DIRECTORY']}\\n\n",
        "       WAV : {info['WAV']}\n",
        "       ARTIST: {info['ARTIST']}\n",
        "       GENRE : {info['GENRE']}\n",
        "       PROMPT_LENGTH : {info['PROMPT_LENGTH']}\n",
        "       INITIAL_SONG_LENGTH : {info['INITIAL_SONG_LENGTH']}\n",
        "       TOTAL_SONG_LENGTH :  {info['TOTAL_SONG_LENGTH']}\n",
        "       LYRICS : {info['LYRICS']}\n",
        "       META : {info['META']}\n",
        "       NOTE : {info['NOTE']}\n",
        "       SONG_LENGTH : {info['SONG_LENGTH']}\n",
        "  ''')\n",
        "  f.close()\n",
        "\n",
        "def print_fancy(txt):\n",
        "  print('\\x1b[6;30;42m' + txt + '\\x1b[0m')\n",
        "\n",
        "def backup(note):\n",
        "  d = datetime.datetime.now()\n",
        "  date_str = d.strftime(\"%m-%d-%Y\")\n",
        "  bak_dir = f'{hps.name}backup-{date_str}-{note}/'\n",
        "  info['PROJECT_DIRECTORY'] = bak_dir\n",
        "  info['NOTE'] = note\n",
        "  !mkdir \"{bak_dir}\"\n",
        "  #wav = f\"{hps.name}zs-checkpoint.t\"\n",
        "  !cp \"{hps.name}\"*.wav \"{bak_dir}\"\n",
        "  cpoint = f\"{hps.name}zs-checkpoint.t\"\n",
        "  !cp \"{cpoint}\" \"{bak_dir}\"\n",
        "  save_info(bak_dir)\n",
        "\n",
        "if Path(project_dir + fname).is_file() == False:\n",
        "  init_info(project_dir)\n",
        "\n",
        "read_info()\n",
        "INITIAL_SONG_LENGTH = int(info['INITIAL_SONG_LENGTH'])\n",
        "PROMPT_LENGTH = int(info['PROMPT_LENGTH'])\n",
        "TOTAL_SONG_LENGTH = int(info['TOTAL_SONG_LENGTH'])\n",
        "SONG_LENGTH = int(info['SONG_LENGTH'])\n",
        "song_length = SONG_LENGTH\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HNLX27fAnbAb"
      },
      "source": [
        "#@title Run this cell to install Jukebox. Do it only once in a session!\n",
        "\n",
        "!pip install git+https://github.com/deeplearn-art/jukebox\n",
        "import jukebox\n",
        "import torch as t\n",
        "import librosa\n",
        "import os\n",
        "import glob\n",
        "import torch\n",
        "import datetime\n",
        "from IPython.display import Audio\n",
        "from jukebox.make_models import make_vqvae, make_prior, MODELS, make_model\n",
        "from jukebox.hparams import Hyperparams, setup_hparams\n",
        "from jukebox.sample import sample_single_window, _sample, \\\n",
        "                           sample_partial_window, upsample, \\\n",
        "                           load_prompts\n",
        "from jukebox.utils.dist_utils import setup_dist_from_mpi\n",
        "from jukebox.utils.torch_utils import empty_cache\n",
        "rank, local_rank, device = setup_dist_from_mpi()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sAdFGF-bqVMY"
      },
      "source": [
        "#@title Run this cell to complete the setup. (Wait patiently)\n",
        "model = \"5b_lyrics\"\n",
        "hps = Hyperparams()\n",
        "hps.sr = 44100\n",
        "hps.n_samples = 3\n",
        "hps.name = project_dir\n",
        "hps.hop_fraction = hops\n",
        "hps.levels = 3\n",
        "lower_batch_size = 16\n",
        "max_batch_size = 3\n",
        "lower_level_chunk_size = 32\n",
        "chunk_size = 16\n",
        "\n",
        "vqvae, *priors = MODELS[model]\n",
        "vqvae = make_vqvae(setup_hparams(vqvae, dict(sample_length = 1048576)), device)\n",
        "top_prior = make_prior(setup_hparams(priors[-1], dict()), vqvae, device)\n",
        "\n",
        "# find out if we have saved anything\n",
        "checkpoint = \"\"\n",
        "if os.path.exists(hps.name):\n",
        "  data = f\"{hps.name}/level_1/data.pth.tar\"\n",
        "  compose = f\"{hps.name}/zs-checkpoint.t\"\n",
        "\n",
        "  if os.path.isfile(data):\n",
        "    mode = 'upsample'\n",
        "    codes_file = data\n",
        "    checkpoint = \"data\"\n",
        "    audio_file=None\n",
        "  elif os.path.isfile(compose):\n",
        "    checkpoint = \"compose\"\n",
        "\n",
        "if checkpoint != \"\":\n",
        "  print_fancy(f'Found checkpoint of type {checkpoint}')\n",
        "\n",
        "if checkpoint != 'data':\n",
        "  mode = 'primed'\n",
        "  codes_file=None\n",
        "  audio_file = project_dir + info['WAV'] + '.wav'\n",
        "\n",
        "sample_hps = Hyperparams(dict(mode=mode, codes_file=codes_file, audio_file=audio_file, prompt_length_in_seconds=PROMPT_LENGTH))\n",
        "\n",
        "sample_length_in_seconds = TOTAL_SONG_LENGTH\n",
        "hps.sample_length = (int(sample_length_in_seconds*hps.sr)//top_prior.raw_to_tokens)*top_prior.raw_to_tokens\n",
        "assert hps.sample_length >= top_prior.n_ctx*top_prior.raw_to_tokens, f'Please choose a larger sampling rate'\n",
        "\n",
        "metas = [dict(artist = info['ARTIST'],\n",
        "          genre = info['GENRE'],\n",
        "          total_length = hps.sample_length,\n",
        "          offset = 0,\n",
        "          lyrics = info['LYRICS'],\n",
        "          ),\n",
        "        ] * hps.n_samples\n",
        "\n",
        "if checkpoint != 'data':\n",
        "  labels = top_prior.labeller.get_batch_labels(metas, 'cuda')\n",
        "  sampling_kwargs = dict(temp=sampling_temperature, fp16=True, max_batch_size=lower_batch_size,\n",
        "                    chunk_size=lower_level_chunk_size)\n",
        "else:\n",
        "  labels = [None, None, top_prior.labeller.get_batch_labels(metas, 'cuda')]\n",
        "  sampling_kwargs = [dict(temp=.99, fp16=True, max_batch_size=lower_batch_size,\n",
        "                        chunk_size=lower_level_chunk_size),\n",
        "                    dict(temp=0.99, fp16=True, max_batch_size=lower_batch_size,\n",
        "                         chunk_size=lower_level_chunk_size),\n",
        "                    dict(temp=sampling_temperature, fp16=True,\n",
        "                         max_batch_size=max_batch_size, chunk_size=chunk_size)]\n",
        "\n",
        "def seconds_to_tokens(sec, sr, prior, chunk_size):\n",
        "  tokens = sec * hps.sr // prior.raw_to_tokens\n",
        "  tokens = ((tokens // chunk_size) + 1) * chunk_size\n",
        "  print(f\"tokens {tokens} prior.n_ctx {prior.n_ctx}\")\n",
        "  if tokens > prior.n_ctx:\n",
        "    tokens = prior.n_ctx\n",
        "  return tokens\n",
        "\n",
        "\n",
        "def get_length():\n",
        "  the_length = 0\n",
        "  level_0_wav = glob.glob(os.path.join(hps.name, 'level_0/*0.wav'))\n",
        "  level_1_wav = glob.glob(os.path.join(hps.name, 'level_1/*0.wav'))\n",
        "  if level_0_wav != []:\n",
        "    print_fancy(\"resuming level_0\")\n",
        "    the_length = librosa.get_duration(filename=level_0_wav[0])\n",
        "  else:\n",
        "    print_fancy(\"resuming level_1\")\n",
        "    the_length = librosa.get_duration(filename=level_1_wav[0])\n",
        "  return the_length\n",
        "\n",
        "the_length = get_length() if checkpoint == 'data' else INITIAL_SONG_LENGTH\n",
        "print(f\"rendered length {the_length}\")\n",
        "tokens_to_sample = seconds_to_tokens(the_length, hps.sr, top_prior, chunk_size)\n",
        "\n",
        "def write_audio(start):\n",
        "  for i in range(hps.n_samples):\n",
        "    librosa.output.write_wav(f'clip_{i}.wav', x[i][start*hps.sr:], sr=hps.sr)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "di8lvcBlx7ca",
        "cellView": "form"
      },
      "source": [
        "#@title Run this cell to free memory\n",
        "!nvidia-smi\n",
        "empty_cache()\n",
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jqh7Few5tKNG"
      },
      "source": [
        "![generation.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vxe9j_YKTLKW"
      },
      "source": [
        "This will generate the starting point of your song.\n",
        "\n",
        "**Skip this step if you are resuming from an earlier session.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nOntjnB1tIsH"
      },
      "source": [
        "#@title Run this cell to generate the beginning of your song\n",
        "\n",
        "if checkpoint == '':\n",
        "  # initial generation\n",
        "  assert sample_hps.audio_file is not None\n",
        "  audio_files = sample_hps.audio_file.split(',')\n",
        "  duration = (int(sample_hps.prompt_length_in_seconds*hps.sr)//top_prior.raw_to_tokens)*top_prior.raw_to_tokens\n",
        "  x = load_prompts(audio_files, duration, hps)\n",
        "  zs = top_prior.encode(x, start_level=0, end_level=len(priors), bs_chunks=x.shape[0])\n",
        "  zs = sample_partial_window(zs, labels, sampling_kwargs, 2, top_prior, tokens_to_sample, hps)\n",
        "  x = vqvae.decode(zs[2:], start_level=2).cpu().numpy()\n",
        "  song_length = INITIAL_SONG_LENGTH\n",
        "  print_fancy(f\"Song length: {song_length} seconds. Remaining time: {TOTAL_SONG_LENGTH - song_length}\")\n",
        "  write_audio(0)\n",
        "  t.save(zs, 'zs-checkpoint.t')\n",
        "  !cp /content/zs-checkpoint.t \"{hps.name}\"\n",
        "  !cp /content/clip_*.wav \"{hps.name}\"\n",
        "  info[\"SONG_LENGTH\"] = song_length\n",
        "  save_info(hps.name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfrapAMnAfKO"
      },
      "source": [
        "Once the initial generation has finished, you can listen the first three clips."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "5qwZJk7VASkr"
      },
      "source": [
        "#@title Run this cell to open clip 0\n",
        "Audio('clip_0.wav')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "iYoKaE9-AWeT"
      },
      "source": [
        " #@title Run this cell to open clip 1\n",
        " Audio('clip_1.wav')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "PHEQLhm2AZaX"
      },
      "source": [
        "#@title Run this cell to open clip 2\n",
        "Audio('clip_2.wav')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4MPeJYzsEHEN"
      },
      "source": [
        "If you didn't like any of the initial clips, just go back to *Initial generation* and run the first cell again.\n",
        "\n",
        "If there is one that you like, proceed to the next section (\"Add to the composition\").\n",
        "\n",
        "If there are more than one that you like, run the cell below to make a \"new branch\" that you can work with later. Then pick one to extend now and proceed to the next section (\"Add to the composition\")."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "qcW00sPH-Ahn"
      },
      "source": [
        "#@title Run this cell only if you want to extend another clip later\n",
        "NOTE = '' #@param {type:\"string\"}\n",
        "\n",
        "backup(NOTE)\n",
        "read_info()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o7CzSiv0MmFP"
      },
      "source": [
        "![add.png](data:image/png;base64,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)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Woh54TZcBh18"
      },
      "source": [
        "# Input song continuation options\n",
        "\n",
        "**Choice**: the number (0,1,2) of the clip you wish to extend. The clips can be found in the project folder.\n",
        "\n",
        "**Addition length**: How many seconds are you going to add to the song?\n",
        "\n",
        "**Playback start**: How many seconds (if any) do you wish to skip on playback?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "mnbfgWDXR1bN"
      },
      "source": [
        "CHOICE =  1#@param {type:\"number\"}\n",
        "ADDITION_LENGTH =  10#@param {type:\"number\"}\n",
        "PLAYBACK_START =  25#@param {type:\"number\"}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "j_XFtVi99CIY"
      },
      "source": [
        "#@title Run this cell to continue generating the song\n",
        "\n",
        "if checkpoint != \"data\":\n",
        "  if checkpoint == \"compose\":\n",
        "\n",
        "    # load the previous checkpoint\n",
        "    zs=t.load(f'{hps.name}/zs-checkpoint.t')\n",
        "\n",
        "  # generate music\n",
        "  zs[2]=zs[2][CHOICE].repeat(hps.n_samples,1)\n",
        "  tokens_to_sample = seconds_to_tokens(ADDITION_LENGTH, hps.sr, top_prior, chunk_size)\n",
        "  zs = sample_partial_window(zs, labels, sampling_kwargs, 2, top_prior, tokens_to_sample, hps)\n",
        "  x = vqvae.decode(zs[2:], start_level=2).cpu().numpy()\n",
        "\n",
        "  #write audio clips\n",
        "  write_audio(PLAYBACK_START)\n",
        "\n",
        "  # write checkpoint\n",
        "  song_length += ADDITION_LENGTH\n",
        "  print_fancy(f\"Song length: {song_length} seconds. Remaining time: {TOTAL_SONG_LENGTH - song_length}\")\n",
        "  t.save(zs, 'zs-checkpoint.t')\n",
        "  !cp /content/zs-checkpoint.t \"{hps.name}\"\n",
        "  !cp /content/clip_*.wav \"{hps.name}\"\n",
        "  info[\"SONG_LENGTH\"] = song_length\n",
        "  save_info(hps.name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t6MXgvYCDyxP"
      },
      "source": [
        "Once Jukebox has stopped extending the song, you can listen to three new versions of your song."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "gui1xiv1CPKQ"
      },
      "source": [
        "#@title Run this cell to open clip 0\n",
        "Audio('clip_0.wav')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "NIWzRg0WCKP5"
      },
      "source": [
        "#@title Run this cell to open clip 1\n",
        "Audio('clip_1.wav')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "9fY_B6HDCRft"
      },
      "source": [
        "#@title Run this cell to open clip 2\n",
        "Audio('clip_2.wav')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-OJT704dvnGv"
      },
      "source": [
        "To keep on extending the song, return to *Add to the composition*, input your choices and run the cells again.\n",
        "\n",
        "If your song is getting near the full length, or you are happy with it as it is now, proceed to the next section to upsample.\n",
        "\n",
        "If there are more than one that you like, run the cell below to make a \"new branch\" that you can work with later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "GSI9c_bls6bu"
      },
      "source": [
        "#@title Run this cell if you want to extend another clip later\n",
        "NOTE = '' #@param {type:\"string\"}\n",
        "backup(NOTE)\n",
        "read_info()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RzCrkCZJvUcQ"
      },
      "source": [
        "![upsample.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DsAJitNdGJBF"
      },
      "source": [
        "This last step renders your songs with better quality audio. It will take some time. The first pass is about 95 minutes for 45 seconds clip with Tesla P100 as GPU.\n",
        "\n",
        "The three upsampled clips can be found in a new folder called **level_1** inside your project directory. They are being saved while the upsampling is happening, and you can listen to them during the process.\n",
        "\n",
        "You can then render your clips to **level_0** (the best quality), but that will take even longer, and on Colab free tier, if it goes beyond 8 hours or so, your session might terminate before the clips are finished. If that happens, just open this notebook and pick up from where you left."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v17cEAqyCgfo"
      },
      "source": [
        "#@title Run this cell to make your clips better sounding\n",
        "\n",
        "if (checkpoint != \"data\"):\n",
        "  zs = t.load(f'{hps.name}/zs-checkpoint.t')\n",
        "  assert zs[2].shape[1]>=2048, f'Please first generate at least 2048 tokens at the top level, currently you have {zs[2].shape[1]}'\n",
        "  hps.sample_length = zs[2].shape[1]*top_prior.raw_to_tokens\n",
        "  del top_prior\n",
        "  empty_cache()\n",
        "  top_prior=None\n",
        "  upsamplers = [make_prior(setup_hparams(prior, dict()), vqvae, 'cpu') for prior in priors[:-1]]\n",
        "  sampling_kwargs = [dict(temp=.99, fp16=True, max_batch_size=16, chunk_size=32),\n",
        "                    dict(temp=0.99, fp16=True, max_batch_size=16, chunk_size=32),\n",
        "                    None]\n",
        "  if type(labels)==dict:\n",
        "    labels = [prior.labeller.get_batch_labels(metas, 'cuda') for prior in upsamplers] + [labels]\n",
        "\n",
        "\n",
        "else: #upsampling from level 1\n",
        "  assert sample_hps.codes_file is not None\n",
        "  data = t.load(sample_hps.codes_file, map_location='cpu')\n",
        "  zs = [z.cuda() for z in data['zs']]\n",
        "  assert zs[-1].shape[0] == hps.n_samples, f\"Expected bs = {hps.n_samples}, got {zs[-1].shape[0]}\"\n",
        "  del data\n",
        "  del top_prior\n",
        "  empty_cache()\n",
        "  top_prior=None\n",
        "  upsamplers = [make_prior(setup_hparams(prior, dict()), vqvae, 'cpu') for prior in priors[:-1]]\n",
        "  labels[:2] = [prior.labeller.get_batch_labels(metas, 'cuda') for prior in upsamplers]\n",
        "\n",
        "\n",
        "zs = upsample(zs, labels, sampling_kwargs, [*upsamplers, top_prior], hps)\n",
        "del upsamplers\n",
        "empty_cache()\n",
        "print(\"Done.\")"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}