GIGA_Piano_Composer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "ac5a4cf0-d9d2-47b5-9633-b53f8d99a4d2",
          "kernelId": ""
        },
        "id": "SiTIpPjArIyr"
      },
      "source": [
        "# GIGA Piano Composer (ver. 2.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",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "fa0a611c-1803-42ae-bdf6-a49b5a4e781b",
          "kernelId": ""
        },
        "id": "gOd93yV0sGd2"
      },
      "source": [
        "# (Setup Environment)"
      ]
    },
    {
      "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": "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 https://github.com/asigalov61/GIGA-Piano\n",
        "\n",
        "!pip install torch\n",
        "\n",
        "!pip install tqdm\n",
        "!pip install matplotlib\n",
        "!pip install torch-summary\n",
        "!pip install sklearn\n",
        "\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works\n",
        "!pip install midi2audio\n",
        "!pip install numpy"
      ]
    },
    {
      "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",
        "\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",
        "\n",
        "print('Loading core modules...')\n",
        "os.chdir('/content/GIGA-Piano')\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",
        "os.chdir('/content/')\n",
        "\n",
        "print('Done!')\n",
        "print('Enjoy!!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdKFoeke9L7H"
      },
      "source": [
        "# (MODEL LOAD)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Unzip Pre-Trained GIGA Piano Models\n",
        "%cd /content/GIGA-Piano/Model\n",
        "\n",
        "print('=' * 70)\n",
        "print('Unzipping small pre-trained GIGA Piano model...Please wait...')\n",
        "\n",
        "!cat GIGA_Piano_Trained_Model.zip* > GIGA-Piano-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j GIGA-Piano-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/\n",
        "\n",
        "%cd /content/GIGA-Piano/Model/Large\n",
        "\n",
        "print('=' * 70)\n",
        "print('Unzipping large pre-trained GIGA Piano model...Please wait...')\n",
        "\n",
        "!cat GIGA_Piano_Trained_Model.zip* > GIGA-Piano-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j GIGA-Piano-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",
        "\n",
        "\n",
        "desired_model_to_load = \"GIGA-Piano Large\" #@param [\"GIGA-Piano Large\", \"GIGA-Piano Small\"]\n",
        "\n",
        "if desired_model_to_load == 'GIGA-Piano Large':\n",
        "\n",
        "  print('Loading Large GIGA-Piano model...')\n",
        "  config = GPTConfig(128, \n",
        "                    1024,\n",
        "                    dim_feedforward=1024,\n",
        "                    n_layer=24, \n",
        "                    n_head=16, \n",
        "                    n_embd=1024,\n",
        "                    enable_rpr=True,\n",
        "                    er_len=1024)\n",
        "\n",
        "  device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "  model = GPT(config)\n",
        "\n",
        "  state_dict = torch.load('/content/GIGA-Piano/Model/Large/GIGA_Piano_Trained_Model_1_epoch_60000_steps_0.9514_loss.pth', map_location=device)\n",
        "\n",
        "  new_state_dict = OrderedDict()\n",
        "  for k, v in state_dict.items():\n",
        "      name = k[7:] #remove 'module'\n",
        "      new_state_dict[name] = v\n",
        "\n",
        "  model.load_state_dict(new_state_dict)\n",
        "\n",
        "  model.to(device)\n",
        "\n",
        "  model.eval()\n",
        "\n",
        "  print('Done!')\n",
        "\n",
        "  summary(model)\n",
        "\n",
        "  cos_sim = metrics.pairwise.cosine_similarity(\n",
        "      model.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-Large-Positional-Embeddings-Plot.png\", bbox_inches=\"tight\")\n",
        "\n",
        "else:\n",
        "\n",
        "  print('Loading Small GIGA-Piano model...')\n",
        "  config = GPTConfig(128, \n",
        "                    1024,\n",
        "                    dim_feedforward=1024,\n",
        "                    n_layer=16, \n",
        "                    n_head=16, \n",
        "                    n_embd=1024,\n",
        "                    enable_rpr=True,\n",
        "                    er_len=1024)\n",
        "\n",
        "  device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "  model = GPT(config)\n",
        "\n",
        "  state_dict = torch.load('/content/GIGA-Piano/Model/GIGA_Piano_Trained_Model_120000_steps_0.8075_loss.pth', map_location=device)\n",
        "\n",
        "  new_state_dict = OrderedDict()\n",
        "  for k, v in state_dict.items():\n",
        "      name = k[7:] #remove 'module'\n",
        "      new_state_dict[name] = v\n",
        "\n",
        "  model.load_state_dict(new_state_dict)\n",
        "\n",
        "  model.to(device)\n",
        "\n",
        "  model.eval()\n",
        "\n",
        "  print('Done!')\n",
        "\n",
        "  summary(model)\n",
        "\n",
        "  cos_sim = metrics.pairwise.cosine_similarity(\n",
        "      model.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-Small-Positional-Embeddings-Plot.png\", bbox_inches=\"tight\")\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "-NLe35B0b9a5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GENERATE)"
      ],
      "metadata": {
        "id": "RCKJSbl4erb0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load Custom MIDI / MIDI seed"
      ],
      "metadata": {
        "id": "I18Ej90IaIyY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Custom MIDI option\n",
        "full_path_to_custom_MIDI = \"/content/GIGA-Piano/GIGA-Piano-Seed-1.mid\" #@param {type:\"string\"}\n",
        "simulated_or_constant_velocity = False #@param {type:\"boolean\"}\n",
        "\n",
        "print('Loading custom MIDI file...')\n",
        "\n",
        "#print('Loading MIDI file...')\n",
        "score = TMIDIX.midi2ms_score(open(full_path_to_custom_MIDI, 'rb').read())\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] / 16)\n",
        "    e[2] = int(e[2] / 32)\n",
        "\n",
        "# final processing...\n",
        "\n",
        "melody = []\n",
        "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",
        "\n",
        "    melody_chords.append([time, dur, ptc])\n",
        "\n",
        "    if time != 0:\n",
        "      melody.append([time, dur, ptc])\n",
        "\n",
        "    pe = e\n",
        "\n",
        "inputs = []\n",
        "\n",
        "for m in melody_chords:\n",
        "  inputs.extend([127])\n",
        "  inputs.extend(m)\n",
        "  \n",
        "inputs.extend([127])\n",
        "\n",
        "print('Done!')\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) == 3:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "\n",
        "    song2 = []\n",
        "    cho = []\n",
        "    for s in song1:\n",
        "      if s[0] == 0:\n",
        "        cho.append(s)\n",
        "      else:\n",
        "        song2.append(cho)\n",
        "        cho = []\n",
        "        cho.append(s)\n",
        "    \n",
        "    for s in song2:\n",
        "      if len(s) > 0:\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        if simulated_or_constant_velocity:\n",
        "          if len(s) == 1:\n",
        "            vel = s[0][2] + 10\n",
        "          else:\n",
        "            vel = s[0][2] + 30\n",
        "        else:\n",
        "          vel = 90\n",
        "        \n",
        "        for ss in s:\n",
        "\n",
        "          time += ss[0] * 16\n",
        "              \n",
        "          dur = ss[1] * 32\n",
        "          \n",
        "          pitch = ss[2]\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'GIGA Piano',  \n",
        "                                                        output_file_name = '/content/GIGA-Piano-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 0, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/GIGA-Piano-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",
        "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 PRIME COMPOSITION BLOCK"
      ],
      "metadata": {
        "id": "mgSzlC1mWEel"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Single Continuation Block Generator\n",
        "\n",
        "#@markdown NOTE: Play with the settings to get different results\n",
        "\n",
        "custom_MIDI_or_improvisation = True #@param {type:\"boolean\"}\n",
        "number_of_prime_tokens = 256 #@param {type:\"slider\", min:32, max:512, step:8}\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 Music Model Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime tokens:', number_of_prime_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "print('Number of batches:', number_of_batches)\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "if custom_MIDI_or_improvisation:\n",
        "  inp = inputs[:number_of_prime_tokens+1]\n",
        "else:\n",
        "  inp = [127]\n",
        "\n",
        "rand_seq = model.generate_batches(torch.Tensor(inp), \n",
        "                                          target_seq_length=1024,\n",
        "                                          temperature=temperature,\n",
        "                                          num_batches=number_of_batches,\n",
        "                                          verbose=show_stats)\n",
        "  \n",
        "out1 = rand_seq[0].cpu().numpy().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",
        "simulated_or_constant_velocity = False #@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",
        "out2 = []\n",
        "\n",
        "out1 = rand_seq[bn].cpu().numpy().tolist()\n",
        "\n",
        "final_composition = copy.deepcopy(out1)\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) == 3:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "\n",
        "    song2 = []\n",
        "    cho = []\n",
        "    for s in song1:\n",
        "      if s[0] == 0:\n",
        "        cho.append(s)\n",
        "      else:\n",
        "        song2.append(cho)\n",
        "        cho = []\n",
        "        cho.append(s)\n",
        "    \n",
        "    for s in song2:\n",
        "      if len(s) > 0:\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        if simulated_or_constant_velocity:\n",
        "          if len(s) == 1:\n",
        "            vel = s[0][2] + 10\n",
        "          else:\n",
        "            vel = s[0][2] + 30\n",
        "        else:\n",
        "          vel = 90\n",
        "        \n",
        "        for ss in s:\n",
        "\n",
        "          time += ss[0] * 16\n",
        "              \n",
        "          dur = ss[1] * 32\n",
        "          \n",
        "          pitch = ss[2]\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'GIGA Piano',  \n",
        "                                                        output_file_name = '/content/GIGA-Piano-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 0, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "    \n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/GIGA-Piano-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",
        "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": "_SDWyxirjyCF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MAIN COMPOSITION LOOP"
      ],
      "metadata": {
        "id": "d_m6sDsRG-9j"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### RUN CELLS BELOW IN A LOOP"
      ],
      "metadata": {
        "id": "tUxR3tgZQbon"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Single Continuation Block Generator\n",
        "\n",
        "#@markdown NOTE: Play with the settings to get different results\n",
        "regenerate_same_block_again = False #@param {type:\"boolean\"}\n",
        "number_of_prime_tokens = 512 #@param {type:\"slider\", min:256, max:768, step:8}\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 Music Model Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime tokens:', number_of_prime_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "print('Number of batches:', number_of_batches)\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "if out2 == []:\n",
        "  inp = copy.deepcopy(out1[-number_of_prime_tokens:])\n",
        "else:\n",
        "  inp = copy.deepcopy(out2[-number_of_prime_tokens:])\n",
        "\n",
        "if regenerate_same_block_again:\n",
        "  inp = copy.deepcopy(out2[:number_of_prime_tokens])\n",
        "\n",
        "rand_seq = model.generate_batches(torch.Tensor(inp), \n",
        "                                          target_seq_length=1024,\n",
        "                                          temperature=temperature,\n",
        "                                          num_batches=number_of_batches,\n",
        "                                          verbose=show_stats)\n",
        "\n",
        "print('Done!')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "gsgHNtZsHCXu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Explore generated continuations\n",
        "batch_number = 1 #@param {type:\"slider\", min:0, max:7, step:1}\n",
        "simulated_or_constant_velocity = False #@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",
        "out2 = rand_seq[bn].cpu().numpy().tolist()\n",
        "\n",
        "if len(out2) != 0:\n",
        "    \n",
        "    song = out2[number_of_prime_tokens:]\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) == 3:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "\n",
        "    song2 = []\n",
        "    cho = []\n",
        "    for s in song1:\n",
        "      if s[0] == 0:\n",
        "        cho.append(s)\n",
        "      else:\n",
        "        song2.append(cho)\n",
        "        cho = []\n",
        "        cho.append(s)\n",
        "    \n",
        "    for s in song2:\n",
        "      if len(s) > 0:\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        if simulated_or_constant_velocity:\n",
        "          if len(s) == 1:\n",
        "            vel = s[0][2] + 10\n",
        "          else:\n",
        "            vel = s[0][2] + 30\n",
        "        else:\n",
        "          vel = 90\n",
        "        \n",
        "        for ss in s:\n",
        "\n",
        "          time += ss[0] * 16\n",
        "              \n",
        "          dur = ss[1] * 32\n",
        "          \n",
        "          pitch = ss[2]\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'GIGA Piano',  \n",
        "                                                        output_file_name = '/content/GIGA-Piano-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 0, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "    \n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/GIGA-Piano-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",
        "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": "VsshTHXQHqMq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ADD/REMOVE LAST GENERATED BLOCK"
      ],
      "metadata": {
        "id": "RX_6wwb1I-Rl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ADD BLOCK\n",
        "final_composition = final_composition + out2[number_of_prime_tokens:]\n",
        "print('Block added!')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "oveLetD5I9gV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title REMOVE BLOCK\n",
        "final_composition = final_composition[:-number_of_prime_tokens]\n",
        "print('Block removed!')"
      ],
      "metadata": {
        "cellView": "form",
        "id": "3joxTQ9LJeS5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PLAY/PLOT FINAL COMPOSITION"
      ],
      "metadata": {
        "id": "qWjBH9pAJvN8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Display final composition\n",
        "if len(final_composition) != 0:\n",
        "    \n",
        "    song = final_composition\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) == 3:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "\n",
        "    song2 = []\n",
        "    cho = []\n",
        "    for s in song1:\n",
        "      if s[0] == 0:\n",
        "        cho.append(s)\n",
        "      else:\n",
        "        song2.append(cho)\n",
        "        cho = []\n",
        "        cho.append(s)\n",
        "    \n",
        "    for s in song2:\n",
        "      if len(s) > 0:\n",
        "\n",
        "        channel = 0\n",
        "\n",
        "        if simulated_or_constant_velocity:\n",
        "          if len(s) == 1:\n",
        "            vel = s[0][2] + 10\n",
        "          else:\n",
        "            vel = s[0][2] + 30\n",
        "        else:\n",
        "          vel = 90\n",
        "        \n",
        "        for ss in s:\n",
        "\n",
        "          time += ss[0] * 16\n",
        "              \n",
        "          dur = ss[1] * 32\n",
        "          \n",
        "          pitch = ss[2]\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'GIGA Piano',  \n",
        "                                                        output_file_name = '/content/GIGA-Piano-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 0, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/GIGA-Piano-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",
        "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": "njHsfyG5Jz7A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YzCMd94Tu_gz"
      },
      "source": [
        "# Congrats! You did it! :)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "GIGA_Piano_Composer.ipynb",
      "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
}