GIGA_Piano_XL.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "ac5a4cf0-d9d2-47b5-9633-b53f8d99a4d2",
          "kernelId": ""
        },
        "id": "SiTIpPjArIyr"
      },
      "source": [
        "# GIGA-Piano XL (ver. 3.0)\n",
        "\n",
        "***\n",
        "\n",
        "Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools\n",
        "\n",
        "***\n",
        "\n",
        "Credit for GPT2-RGA code used in this colab goes out @ Sashmark97 https://github.com/Sashmark97/midigen and @ Damon Gwinn https://github.com/gwinndr/MusicTransformer-Pytorch\n",
        "\n",
        "***\n",
        "\n",
        "WARNING: This complete implementation is a functioning model of the Artificial Intelligence. Please excercise great humility, care, and respect. https://www.nscai.gov/\n",
        "\n",
        "***\n",
        "\n",
        "#### Project Los Angeles\n",
        "\n",
        "#### Tegridy Code 2022\n",
        "\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (NVIDIA GPU CHECK)"
      ],
      "metadata": {
        "id": "UZUJzaAiVYxr"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "gradient": {
          "editing": false,
          "id": "39411b40-9e39-416e-8fe4-d40f733e7956",
          "kernelId": ""
        },
        "id": "lw-4aqV3sKQG"
      },
      "outputs": [],
      "source": [
        "#@title nvidia-smi gpu check\n",
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "fa0a611c-1803-42ae-bdf6-a49b5a4e781b",
          "kernelId": ""
        },
        "id": "gOd93yV0sGd2"
      },
      "source": [
        "# (SETUP ENVIRONMENT)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "a1a45a91-d909-4fd4-b67a-5e16b971d179",
          "kernelId": ""
        },
        "id": "fX12Yquyuihc",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Install all dependencies (run only once per session)\n",
        "\n",
        "!git clone --depth 1 https://github.com/asigalov61/GIGA-Piano-XL\n",
        "\n",
        "!pip install torch\n",
        "\n",
        "!pip install tqdm\n",
        "!pip install matplotlib\n",
        "!pip install torch-summary\n",
        "\n",
        "!pip install numpy\n",
        "\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works\n",
        "!pip install midi2audio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "gradient": {
          "editing": false,
          "id": "b8207b76-9514-4c07-95db-95a4742e52c5",
          "kernelId": ""
        },
        "id": "z7n9vnKmug1J"
      },
      "outputs": [],
      "source": [
        "#@title Import all needed modules\n",
        "\n",
        "print('Loading needed modules. Please wait...')\n",
        "import os\n",
        "import random\n",
        "import copy\n",
        "import statistics\n",
        "from collections import OrderedDict\n",
        "\n",
        "from tqdm import tqdm\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "from torchsummary import summary\n",
        "from sklearn import metrics\n",
        "from sklearn.neighbors import NearestNeighbors\n",
        "from sklearn.metrics import pairwise_distances\n",
        "\n",
        "print('Loading core modules...')\n",
        "os.chdir('/content/GIGA-Piano-XL')\n",
        "\n",
        "import TMIDIX\n",
        "from GPT2RGAX import *\n",
        "\n",
        "print('Loading aux modules...')\n",
        "\n",
        "from midi2audio import FluidSynth\n",
        "import librosa.display\n",
        "from IPython.display import Audio, display\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "os.chdir('/content/')\n",
        "\n",
        "print('Done!')\n",
        "print('Enjoy!!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdKFoeke9L7H"
      },
      "source": [
        "# (LOAD MODEL)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Unzip Pre-Trained GIGA-Piano XL Model\n",
        "%cd /content/GIGA-Piano-XL/Model\n",
        "\n",
        "print('=' * 70)\n",
        "print('Unzipping pre-trained GIGA-Piano XL model...Please wait...')\n",
        "\n",
        "!cat GIGA-Piano-XL-Trained-Model.zip* > GIGA-Piano-XL-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j GIGA-Piano-XL-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/"
      ],
      "metadata": {
        "cellView": "form",
        "id": "QefHQ_qG7IA9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Load/Reload the model\n",
        "full_path_to_model_checkpoint = \"/content/GIGA-Piano-XL/Model/GIGA_Piano_XL_Trained_Model_138600_steps_1.259_loss.pth\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown Model precision option\n",
        "\n",
        "model_precision = \"bfloat16\" # @param [\"bfloat16\", \"float16\", \"float32\"]\n",
        "\n",
        "#@markdown bfloat16 == Third precision/triple speed (if supported, otherwise the model will default to float16)\n",
        "\n",
        "#@markdown float16 == Half precision/double speed\n",
        "\n",
        "#@markdown float32 == Full precision/normal speed\n",
        "\n",
        "plot_tokens_embeddings = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading GIGA-Piano XL model...')\n",
        "\n",
        "torch.backends.cuda.matmul.allow_tf32 = True # allow tf32 on matmul\n",
        "torch.backends.cudnn.allow_tf32 = True # allow tf32 on cudnn\n",
        "device_type = 'cuda'\n",
        "\n",
        "if model_precision == 'bfloat16' and torch.cuda.is_bf16_supported():\n",
        "  dtype = 'bfloat16'\n",
        "else:\n",
        "  dtype = 'float16'\n",
        "\n",
        "if model_precision == 'float16':\n",
        "  dtype = 'float16'\n",
        "\n",
        "if model_precision == 'float32':\n",
        "  dtype = 'float32'\n",
        "\n",
        "ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]\n",
        "ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)\n",
        "\n",
        "config = GPTConfig(512,\n",
        "                  2048,\n",
        "                  dim_feedforward=2048,\n",
        "                  n_layer=24,\n",
        "                  n_head=8,\n",
        "                  n_embd=1024,\n",
        "                  enable_rpr=True,\n",
        "                  er_len=2048)\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "model = GPT(config)\n",
        "\n",
        "model = torch.nn.DataParallel(model)\n",
        "\n",
        "model.load_state_dict(torch.load(full_path_to_model_checkpoint, map_location=device))\n",
        "\n",
        "model.to(device)\n",
        "\n",
        "model.eval()\n",
        "\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "print('Model will use', dtype, 'precision...')\n",
        "\n",
        "summary(model)\n",
        "\n",
        "if plot_tokens_embeddings:\n",
        "  cos_sim = metrics.pairwise.cosine_similarity(\n",
        "      model.module.tok_emb.weight.detach().cpu().numpy()\n",
        "  )\n",
        "  plt.figure(figsize=(8, 8))\n",
        "  plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
        "  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]\n",
        "  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)\n",
        "  plt.xlabel(\"Position\")\n",
        "  plt.ylabel(\"Position\")\n",
        "  plt.tight_layout()\n",
        "  plt.plot()\n",
        "  plt.savefig(\"/content/GIGA-Piano-XL-Positional-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ],
      "metadata": {
        "id": "zXogMrM9JALU",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (CUSTOM MIDI)"
      ],
      "metadata": {
        "id": "I18Ej90IaIyY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Upload your own seed MIDI\n",
        "\n",
        "#@markdown Press play button to summon MIDI file upload widget below\n",
        "\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "uploaded_MIDI = files.upload()\n",
        "\n",
        "print('=' * 70)\n",
        "if list(uploaded_MIDI.keys()):\n",
        "\n",
        "  score = TMIDIX.midi2ms_score(list(uploaded_MIDI.values())[0])\n",
        "  f = list(uploaded_MIDI.keys())[0]\n",
        "\n",
        "  print('Loading custom MIDI file...')\n",
        "\n",
        "  events_matrix = []\n",
        "\n",
        "  itrack = 1\n",
        "\n",
        "  while itrack < len(score):\n",
        "      for event in score[itrack]:\n",
        "          if event[0] == 'note' and event[3] != 9:\n",
        "              events_matrix.append(event)\n",
        "      itrack += 1\n",
        "\n",
        "  # Sorting...\n",
        "  events_matrix.sort(key=lambda x: x[4], reverse=True)\n",
        "  events_matrix.sort(key=lambda x: x[1])\n",
        "\n",
        "  # recalculating timings\n",
        "  for e in events_matrix:\n",
        "      e[1] = int(e[1] / 10)\n",
        "      e[2] = int(e[2] / 20)\n",
        "\n",
        "  # final processing...\n",
        "\n",
        "  melody = []\n",
        "  melody_chords = []\n",
        "  memory_melody_chords = []\n",
        "\n",
        "  pe = events_matrix[0]\n",
        "  for e in events_matrix:\n",
        "\n",
        "      time = max(0, min(126, e[1]-pe[1]))\n",
        "      dur = max(1, min(126, e[2]))\n",
        "\n",
        "      ptc = max(1, min(126, e[4]))\n",
        "      vel = max(1, min(126, e[5]))\n",
        "\n",
        "      melody_chords.append([time, dur+128, ptc+256, vel+384])\n",
        "\n",
        "      if time != 0:\n",
        "        if ptc < 60:\n",
        "          ptc = (ptc % 12) + 60\n",
        "        melody.append([time, dur+128, ptc+256, vel+384])\n",
        "\n",
        "      pe = e\n",
        "\n",
        "  inputs = []\n",
        "\n",
        "  for m in melody_chords:\n",
        "    inputs.extend(m)\n",
        "\n",
        "  memory_chunks_train = []\n",
        "\n",
        "  for i in range(0, (len(inputs) // 128)*128, 128): # 32 notes\n",
        "    memory_chunks_train.append(inputs[i:i+128])\n",
        "\n",
        "  memory_chunks_test = []\n",
        "\n",
        "  for i in range(64, (((len(inputs) // 128)-1)*128), 128): # 32 notes\n",
        "    memory_chunks_test.append(inputs[i:i+128])\n",
        "\n",
        "  memory_chunks = memory_chunks_train + memory_chunks_test\n",
        "\n",
        "  print('Done!')\n",
        "  print('=' * 70)\n",
        "  print('Composition has', len(melody_chords), 'notes')\n",
        "  print('Composition has', len(inputs), 'tokens')\n",
        "  print('Composition has', len(melody), 'melody notes')\n",
        "  print('Composition has', len(melody)*4, 'melody tokens')\n",
        "  print('=' * 70)\n",
        "\n",
        "  out1 = inputs\n",
        "\n",
        "  if len(out1) != 0:\n",
        "\n",
        "      song = out1\n",
        "      song_f = []\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      vel = 0\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "\n",
        "      son = []\n",
        "\n",
        "      song1 = []\n",
        "\n",
        "      for s in song:\n",
        "        if s > 127:\n",
        "          son.append(s)\n",
        "\n",
        "        else:\n",
        "          if len(son) == 4:\n",
        "            song1.append(son)\n",
        "          son = []\n",
        "          son.append(s)\n",
        "\n",
        "      for s in song1:\n",
        "\n",
        "          time += s[0] * 10\n",
        "\n",
        "          dur = (s[1]-128) * 20\n",
        "\n",
        "          channel = 0\n",
        "\n",
        "          pitch = s[2]-256\n",
        "\n",
        "          vel = s[3]-384\n",
        "\n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                                output_signature = 'GIGA-Piano XL',\n",
        "                                                                output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                                track_name='Project Los Angeles',\n",
        "                                                                list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                                )\n",
        "\n",
        "      print('Done!')\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Displaying resulting composition...')\n",
        "  print('=' * 70)\n",
        "\n",
        "  fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "  pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "  pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "  for s in song_f:\n",
        "    for i in range(s[2]):\n",
        "      try:\n",
        "        pianoroll[s[4]][i+s[1]] = s[4]\n",
        "      except:\n",
        "        pass\n",
        "\n",
        "  piano_roll = np.array(pianoroll)\n",
        "\n",
        "  plt.figure(figsize=(14, 5))\n",
        "  librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "  plt.title(fname)\n",
        "\n",
        "  if render_MIDI_to_audio:\n",
        "    FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "    display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "id": "zpNJ3mPO_xlM",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GENERATE)"
      ],
      "metadata": {
        "id": "RCKJSbl4erb0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (SINGLE BLOCK CONTINUATION)"
      ],
      "metadata": {
        "id": "mgSzlC1mWEel"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Single Continuation Block Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "custom_MIDI_or_improvisation = True #@param {type:\"boolean\"}\n",
        "number_of_prime_notes = 128 #@param {type:\"slider\", min:32, max:256, step:8}\n",
        "number_of_tokens_to_generate = 1024 #@param {type:\"slider\", min:512, max:1920, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "number_of_batches = 2 #@param {type:\"slider\", min:1, max:8, step:1}\n",
        "show_stats = True #@param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Model temperature:', temperature)\n",
        "print('Number of batches:', number_of_batches)\n",
        "print('=' * 70)\n",
        "\n",
        "if custom_MIDI_or_improvisation:\n",
        "  inp = inputs[:number_of_prime_notes*4]\n",
        "else:\n",
        "  inp = [126, 126+128, 0+256, 0+384]\n",
        "\n",
        "with ctx:\n",
        "  rand_seq = model.module.generate_batches(torch.Tensor(inp),\n",
        "                                            target_seq_length=number_of_tokens_to_generate,\n",
        "                                            temperature=temperature,\n",
        "                                            num_batches=number_of_batches,\n",
        "                                            verbose=show_stats)\n",
        "\n",
        "out1 = rand_seq[0].cpu().tolist()\n",
        "\n",
        "print('Done!')"
      ],
      "metadata": {
        "id": "nD-Iu_R0xbnx",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Explore generated continuations\n",
        "batch_number = 0 #@param {type:\"slider\", min:0, max:7, step:1}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "if batch_number >= number_of_batches:\n",
        "  bn = 0\n",
        "else:\n",
        "  bn = batch_number\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying batch #:',bn )\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = rand_seq[bn].cpu().tolist()\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "oN9eNsqN8JxH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (MULTIPLE BLOCKS CONTINUATIONS)"
      ],
      "metadata": {
        "id": "WvXy3Ray7UJr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Simple Multiple Continuation Blocks Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the generation at any time to render partial results\n",
        "\n",
        "custom_MIDI_or_improvisation = True #@param {type:\"boolean\"}\n",
        "number_of_prime_notes = 128 #@param {type:\"slider\", min:8, max:256, step:8}\n",
        "size_of_continuation_blocks_in_notes = 16 #@param {type:\"slider\", min:1, max:128, step:1}\n",
        "number_of_continuation_blocks = 16 #@param {type:\"slider\", min:1, max:50, step:1}\n",
        "number_of_memory_tokens = 1024 #@param {type:\"slider\", min:128, max:2016, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Size of continuation blocks in notes:', size_of_continuation_blocks_in_notes)\n",
        "print('Number of continuation blocks:', number_of_continuation_blocks)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "if custom_MIDI_or_improvisation:\n",
        "  out1 = inputs[:number_of_prime_notes*4]\n",
        "else:\n",
        "  out1.extend([126, 126+128, 0+256, 0+384])\n",
        "\n",
        "for i in tqdm(range(number_of_continuation_blocks)):\n",
        "  try:\n",
        "\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate(torch.Tensor(out1[-number_of_memory_tokens:]),\n",
        "                                                target_seq_length=len(out1[-number_of_memory_tokens:])+(size_of_continuation_blocks_in_notes*4),\n",
        "                                                temperature=temperature,\n",
        "                                                stop_token=512,\n",
        "                                                verbose=show_stats)\n",
        "\n",
        "    out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "    out1.extend(out[-(size_of_continuation_blocks_in_notes*4):])\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping generation...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "8isYVtBLcZn4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Euclidian Distance Chunks Multiple Continuation Blocks Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the generation at any time to render partial results\n",
        "\n",
        "custom_MIDI_or_improvisation = True #@param {type:\"boolean\"}\n",
        "number_of_prime_notes = 128 #@param {type:\"slider\", min:32, max:256, step:8}\n",
        "number_of_continuation_chunks = 10 #@param {type:\"slider\", min:1, max:100, step:1}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:16, max:1008, step:16}\n",
        "number_of_batches = 4 #@param {type:\"slider\", min:1, max:8, step:1}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Euclidian Distance Chunks Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Number of continuation chunks:', number_of_continuation_chunks)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "if custom_MIDI_or_improvisation:\n",
        "  out1 = inputs[:number_of_prime_notes*4]\n",
        "else:\n",
        "  out1.extend([20, 8+128, 60+256, 90+384])\n",
        "\n",
        "for i in tqdm(range(number_of_continuation_chunks)):\n",
        "  try:\n",
        "\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate_batches(torch.Tensor(out1[-number_of_memory_tokens:]),\n",
        "                                                target_seq_length=len(out1[-number_of_memory_tokens:])+128,\n",
        "                                                temperature=temperature,\n",
        "                                                num_batches=number_of_batches,\n",
        "                                                verbose=show_stats)\n",
        "\n",
        "    out = rand_seq.cpu().tolist()\n",
        "\n",
        "    chunks = []\n",
        "\n",
        "    for i in range(len(out)):\n",
        "      chunk = out[i][-128:]\n",
        "      chunks.append(chunk)\n",
        "\n",
        "    min_euc_dist = []\n",
        "\n",
        "    for j in range(len(chunks)):\n",
        "      euc_dist = []\n",
        "      for i in range(len(memory_chunks)):\n",
        "          euc_dist.append(pairwise_distances([chunks[j]], [memory_chunks[i]])[0][0])\n",
        "\n",
        "      min_euc_dist.append(min(euc_dist))\n",
        "\n",
        "    out = chunks[min_euc_dist.index(min(min_euc_dist))]\n",
        "\n",
        "    out1.extend(out)\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping generation...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "bw5mbA88d1tJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title KNN Chunks Multiple Continuation Blocks Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the generation at any time to render partial results\n",
        "\n",
        "custom_MIDI_or_improvisation = True #@param {type:\"boolean\"}\n",
        "number_of_prime_notes = 128 #@param {type:\"slider\", min:16, max:256, step:8}\n",
        "number_of_continuation_chunks = 10 #@param {type:\"slider\", min:1, max:100, step:1}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:16, max:1008, step:16}\n",
        "number_of_batches = 4 #@param {type:\"slider\", min:1, max:8, step:1}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model KNN Chunks Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Number of continuation chunks:', number_of_continuation_chunks)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "neigh = NearestNeighbors(n_neighbors=1)\n",
        "neigh.fit(memory_chunks)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "if custom_MIDI_or_improvisation:\n",
        "  out1 = inputs[:number_of_prime_notes*4]\n",
        "else:\n",
        "  out1.extend([126, 126+128, 0+256, 0+384])\n",
        "\n",
        "for i in tqdm(range(number_of_continuation_chunks)):\n",
        "  try:\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate_batches(torch.Tensor(out1[-number_of_memory_tokens:]),\n",
        "                                                target_seq_length=len(out1[-number_of_memory_tokens-1:])+128,\n",
        "                                                temperature=temperature,\n",
        "                                                num_batches=number_of_batches,\n",
        "                                                verbose=show_stats)\n",
        "\n",
        "    out = rand_seq.cpu().tolist()\n",
        "\n",
        "    chunks = []\n",
        "    knn_notes = []\n",
        "\n",
        "    for i in range(len(out)):\n",
        "      chunk = out[i][-128:]\n",
        "      chunks.append(chunk)\n",
        "\n",
        "    scores = [y[0] for y in neigh.kneighbors(chunks)[0].tolist()]\n",
        "\n",
        "    out = chunks[scores.index(min(scores))]\n",
        "\n",
        "    out1.extend(out)\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping generation...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "pXEZppuVGdC0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (INPAINTING)"
      ],
      "metadata": {
        "id": "19F4ivwBs-00"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Custom MIDI Inpaiting / Controlled Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the inpainting at any time to render partial results\n",
        "\n",
        "control_type = \"Time-Duration\" #@param [\"Time\", \"Time-Duration\", \"Time-Duration-Pitch\", \"Pitch\"]\n",
        "number_of_prime_notes = 64 #@param {type:\"slider\", min:1, max:256, step:1}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:64, max:1920, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Inpainting / Controlled Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Control type:', control_type)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Number of memory tokens', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "for m in melody_chords[:number_of_prime_notes]:\n",
        "  out1.extend(m)\n",
        "\n",
        "if control_type == 'Pitch':\n",
        "  ctrl = 3\n",
        "  out1 = out1[:-1]\n",
        "\n",
        "if control_type == 'Time':\n",
        "  ctrl = 3\n",
        "  out1.extend(melody_chords[number_of_prime_notes][:1])\n",
        "\n",
        "if control_type == 'Time-Duration':\n",
        "  ctrl = 2\n",
        "  out1.extend(melody_chords[number_of_prime_notes][:2])\n",
        "\n",
        "if control_type == 'Time-Duration-Pitch':\n",
        "  ctrl = 1\n",
        "  out1.extend(melody_chords[number_of_prime_notes][:3])\n",
        "\n",
        "for i in tqdm(range(number_of_prime_notes+2, len(melody_chords)-1)):\n",
        "  try:\n",
        "\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate(torch.Tensor(out1[-(number_of_memory_tokens-ctrl):]),\n",
        "                                                target_seq_length=len(out1[-(number_of_memory_tokens-ctrl):])+ctrl,\n",
        "                                                temperature=temperature,\n",
        "                                                stop_token=512,\n",
        "                                                verbose=False)\n",
        "\n",
        "    out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "    if control_type == 'Pitch':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend([melody_chords[i+1][2]])\n",
        "\n",
        "    if control_type == 'Time':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend(melody_chords[i][:1])\n",
        "\n",
        "    if control_type == 'Time-Duration':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend(melody_chords[i][:2])\n",
        "\n",
        "    if control_type == 'Time-Duration-Pitch':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend(melody_chords[i][:3])\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping inpainting...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'GIGA-Piano XL',\n",
        "                                                        output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                        )\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "id": "dpN7VEcSbRD6",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Assisted Custom MIDI Inpaiting / Controlled Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the inpainting at any time to render partial results\n",
        "\n",
        "control_type = \"Time-Duration\" #@param [\"Time\", \"Time-Duration\", \"Time-Duration-Pitch\", \"Pitch\"]\n",
        "number_of_prime_notes = 64 #@param {type:\"slider\", min:1, max:256, step:1}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:64, max:1920, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Assisted Inpainting / Controlled Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Control type:', control_type)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "for m in melody_chords[:number_of_prime_notes]:\n",
        "  out1.extend(m)\n",
        "\n",
        "if control_type == 'Pitch':\n",
        "  ctrl = 3\n",
        "  out1 = out1[:-1]\n",
        "\n",
        "if control_type == 'Time':\n",
        "  ctrl = 3\n",
        "  out1.extend(melody_chords[number_of_prime_notes][:1])\n",
        "\n",
        "if control_type == 'Time-Duration':\n",
        "  ctrl = 2\n",
        "  out1.extend(melody_chords[number_of_prime_notes][:2])\n",
        "\n",
        "if control_type == 'Time-Duration-Pitch':\n",
        "  ctrl = 1\n",
        "  out1.extend(melody_chords[number_of_prime_notes][:3])\n",
        "\n",
        "for i in tqdm(range(number_of_prime_notes+2, len(melody_chords)-3, 2)):\n",
        "  try:\n",
        "\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate(torch.Tensor(out1[-(number_of_memory_tokens-ctrl):]),\n",
        "                                                target_seq_length=len(out1[-(number_of_memory_tokens-ctrl):])+ctrl,\n",
        "                                                temperature=temperature,\n",
        "                                                stop_token=512,\n",
        "                                                verbose=False)\n",
        "\n",
        "    out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "    if control_type == 'Time':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend(melody_chords[i+2][:1])\n",
        "\n",
        "    if control_type == 'Time-Duration':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend(melody_chords[i+2][:2])\n",
        "\n",
        "    if control_type == 'Time-Duration-Pitch':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend(melody_chords[i+2][:3])\n",
        "\n",
        "    if control_type == 'Pitch':\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend([i for s in melody_chords[i+1:i+3] for i in s][2:7])\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping inpainting...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'GIGA-Piano XL',\n",
        "                                                        output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                        )\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "irQeN9H9ZmFY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (HARMONIZATION)"
      ],
      "metadata": {
        "id": "DQuRKkDO_u1N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Melody Harmonization Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the harmonization at any time to render partial results\n",
        "\n",
        "number_of_prime_notes = 8 #@param {type:\"slider\", min:1, max:64, step:1}\n",
        "number_of_notes_per_chord = 3 #@param {type:\"slider\", min:1, max:5, step:1}\n",
        "random_number_of_notes_per_chord = False #@param {type:\"boolean\"}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:64, max:1920, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Melody Harmonization Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "inp = []\n",
        "\n",
        "for i in range(number_of_prime_notes):\n",
        "  inp.extend(melody[i])\n",
        "\n",
        "for i in tqdm(range(number_of_prime_notes+1, len(melody))):\n",
        "  try:\n",
        "\n",
        "    inp.extend(melody[i])\n",
        "\n",
        "\n",
        "    if random_number_of_notes_per_chord:\n",
        "      nnpc = random.randint(1, number_of_notes_per_chord)\n",
        "    else:\n",
        "      nnpc = number_of_notes_per_chord\n",
        "\n",
        "    for j in range(nnpc):\n",
        "      inp.extend([0])\n",
        "\n",
        "      with ctx:\n",
        "        rand_seq = model.module.generate(torch.Tensor(inp[-(number_of_memory_tokens-1):]),\n",
        "                                                  target_seq_length=len(inp[-(number_of_memory_tokens-1):])+3,\n",
        "                                                  temperature=temperature,\n",
        "                                                  stop_token=512,\n",
        "                                                  verbose=show_stats)\n",
        "\n",
        "      out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "      inp.extend(out[-3:])\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping harmonization...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = inp\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "PfPdnWT35UOC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (NOTES / CHORDS PROGRESSIONS)"
      ],
      "metadata": {
        "id": "hYkJsl-rwZIy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Notes Progressions Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the generation at any time to render partial results\n",
        "\n",
        "control_type = \"Time\" #@param [\"Time\", \"Time-Duration\"]\n",
        "number_of_notes_to_generate = 100 #@param {type:\"slider\", min:10, max:5000, step:1}\n",
        "desired_time = 10 #@param {type:\"slider\", min:1, max:127, step:1}\n",
        "desired_duration = 9 #@param {type:\"slider\", min:1, max:127, step:1}\n",
        "number_of_memory_tokens = 64 #@param {type:\"slider\", min:64, max:1920, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Notes Progressions Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Control Type:', control_type)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "if control_type == 'Time':\n",
        "  ctrl = 3\n",
        "  out1.extend([desired_time])\n",
        "\n",
        "else:\n",
        "  ctrl = 2\n",
        "  out1.extend([desired_time])\n",
        "  out1.extend([desired_duration+256])\n",
        "\n",
        "for i in tqdm(range(number_of_notes_to_generate)):\n",
        "\n",
        "  try:\n",
        "\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate(torch.Tensor(out1[-(number_of_memory_tokens-ctrl):]),\n",
        "                                                target_seq_length=len(out1[-(number_of_memory_tokens-ctrl):])+ctrl,\n",
        "                                                temperature=temperature,\n",
        "                                                stop_token=512,\n",
        "                                                verbose=show_stats)\n",
        "\n",
        "    out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "    if control_type == 'Time':\n",
        "\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend([desired_time])\n",
        "\n",
        "    else:\n",
        "      out1.extend(out[-ctrl:])\n",
        "      out1.extend([desired_time])\n",
        "      out1.extend([desired_duration+256])\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping generation...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "p8FpUIipibVh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Chords Progressions Generator\n",
        "\n",
        "#@markdown Play with the settings to get different results\n",
        "\n",
        "#@markdown You can stop the generation at any time to render partial results\n",
        "\n",
        "control_type = \"Time\" #@param [\"Time\", \"Time-Duration\"]\n",
        "number_of_chords_to_generate = 40 #@param {type:\"slider\", min:10, max:200, step:1}\n",
        "number_of_notes_per_chord = 2 #@param {type:\"slider\", min:1, max:5, step:1}\n",
        "random_number_of_notes_per_chord = False #@param {type:\"boolean\"}\n",
        "desired_time = 30 #@param {type:\"slider\", min:1, max:127, step:1}\n",
        "desired_duration = 20 #@param {type:\"slider\", min:1, max:127, step:1}\n",
        "number_of_memory_tokens = 64 #@param {type:\"slider\", min:64, max:1920, step:32}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('GIGA-Piano XL Music Model Chords Progressions Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Control Type:', control_type)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = []\n",
        "\n",
        "if control_type == 'Time':\n",
        "  ctrl = 3\n",
        "  out1.extend([desired_time])\n",
        "\n",
        "else:\n",
        "  ctrl = 2\n",
        "  out1.extend([desired_time])\n",
        "  out1.extend([desired_duration+256])\n",
        "\n",
        "nnpc = number_of_notes_per_chord\n",
        "\n",
        "for i in tqdm(range(number_of_chords_to_generate)):\n",
        "  try:\n",
        "\n",
        "    with ctx:\n",
        "      rand_seq = model.module.generate(torch.Tensor(out1[-(number_of_memory_tokens-ctrl):]),\n",
        "                                                target_seq_length=len(out1[-(number_of_memory_tokens-ctrl):])+ctrl,\n",
        "                                                temperature=temperature,\n",
        "                                                stop_token=512,\n",
        "                                                verbose=show_stats)\n",
        "\n",
        "    out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "    out1.extend(out[-ctrl:])\n",
        "\n",
        "    if random_number_of_notes_per_chord:\n",
        "      nnpc = random.randint(1, number_of_notes_per_chord)\n",
        "\n",
        "    for j in range(nnpc):\n",
        "      out1.extend([0])\n",
        "\n",
        "      if control_type == 'Time-Duration':\n",
        "        out1.extend([desired_duration+256])\n",
        "\n",
        "      with ctx:\n",
        "        rand_seq = model.module.generate(torch.Tensor(out1[-(number_of_memory_tokens-ctrl):]),\n",
        "                                                target_seq_length=len(out1[-(number_of_memory_tokens-ctrl):])+ctrl,\n",
        "                                                temperature=temperature,\n",
        "                                                stop_token=512,\n",
        "                                                verbose=show_stats)\n",
        "\n",
        "      out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "      out1.extend(out[-ctrl:])\n",
        "\n",
        "    if control_type == 'Time':\n",
        "      out1.extend([desired_time])\n",
        "\n",
        "    else:\n",
        "      out1.extend([desired_time])\n",
        "      out1.extend([desired_duration+256])\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    print('Stopping generation...')\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "\n",
        "    for s in song1:\n",
        "\n",
        "        time += s[0] * 10\n",
        "\n",
        "        dur = (s[1]-128) * 20\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        pitch = s[2]-256\n",
        "\n",
        "        vel = s[3]-384\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'GIGA-Piano XL',\n",
        "                                                              output_file_name = '/content/GIGA-Piano-XL-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/GIGA-Piano-XL-Music-Composition'\n",
        "\n",
        "pr_duration = song_f[-1][1]+song_f[-1][2]\n",
        "\n",
        "pianoroll = [[0] * pr_duration for i in range(128)]\n",
        "\n",
        "for s in song_f:\n",
        "  for i in range(s[2]):\n",
        "    try:\n",
        "      pianoroll[s[4]][i+s[1]] = s[4]\n",
        "    except:\n",
        "      pass\n",
        "\n",
        "piano_roll = np.array(pianoroll)\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=16, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "if render_MIDI_to_audio:\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "QYSsp0HewhuP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YzCMd94Tu_gz"
      },
      "source": [
        "# Congrats! You did it! :)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "private_outputs": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.7"
    },
    "gpuClass": "standard",
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}