Heptabit_Music_Transformer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Heptabit Music Transformer (ver. 1.5)\n",
        "\n",
        "***\n",
        "\n",
        "Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools\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 2023\n",
        "\n",
        "***"
      ],
      "metadata": {
        "id": "gpy3qsulqHa5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GPU CHECK)"
      ],
      "metadata": {
        "id": "W_So4w8fqPGL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X3rABEpKCO02",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title NVIDIA GPU check\n",
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (SETUP ENVIRONMENT)"
      ],
      "metadata": {
        "id": "C0XxnXGFqVyh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vK40g6V_BTNj",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Install dependencies\n",
        "!git clone --depth 1 https://github.com/asigalov61/Heptabit-Music-Transformer\n",
        "!pip install huggingface_hub\n",
        "!pip install torch\n",
        "!pip install einops\n",
        "!pip install torch-summary\n",
        "!pip install tqdm\n",
        "!pip install matplotlib\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DzCOZU_gBiQV",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Import modules\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading core Heptabit Music Transformer modules...')\n",
        "\n",
        "import os\n",
        "import pickle\n",
        "import secrets\n",
        "import statistics\n",
        "from time import time\n",
        "import tqdm\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading main Heptabit Music Transformer modules...')\n",
        "import torch\n",
        "\n",
        "%cd /content/Heptabit-Music-Transformer\n",
        "\n",
        "import TMIDIX\n",
        "\n",
        "from midi_to_colab_audio import midi_to_colab_audio\n",
        "\n",
        "from x_transformer_1_23_2 import *\n",
        "\n",
        "import random\n",
        "\n",
        "%cd /content/\n",
        "print('=' * 70)\n",
        "print('Loading aux Heptabit Music Transformer modules...')\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from torchsummary import summary\n",
        "from sklearn import metrics\n",
        "\n",
        "from IPython.display import Audio, display\n",
        "\n",
        "from huggingface_hub import hf_hub_download\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('Enjoy! :)')\n",
        "print('=' * 70)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eI3aQtHzqSnp"
      },
      "source": [
        "# (LOAD MODEL)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Load Heptabit Music Transformer Large Model\n",
        "\n",
        "#@markdown Very fast model, 32 layers, 245k MIDIs training corpus\n",
        "\n",
        "full_path_to_model_checkpoint = \"/content/Heptabit-Music-Transformer/Models/Large/Heptabit_Music_Transformer_Large_Trained_Model_38430_steps_0.4225_loss_0.8744_acc.pth\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown Model precision option\n",
        "\n",
        "model_precision = \"bfloat16\" # @param [\"bfloat16\", \"float16\"]\n",
        "\n",
        "#@markdown bfloat16 == Half precision/faster speed (if supported, otherwise the model will default to float16)\n",
        "\n",
        "#@markdown float16 == Full precision/fast speed\n",
        "\n",
        "plot_tokens_embeddings = False # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Heptabit Music Transformer Large Pre-Trained Model...')\n",
        "print('Please wait...')\n",
        "print('=' * 70)\n",
        "\n",
        "if os.path.isfile(full_path_to_model_checkpoint):\n",
        "  print('Model already exists...')\n",
        "\n",
        "else:\n",
        "  hf_hub_download(repo_id='asigalov61/Heptabit-Music-Transformer',\n",
        "                  filename='Heptabit_Music_Transformer_Large_Trained_Model_38430_steps_0.4225_loss_0.8744_acc.pth',\n",
        "                  local_dir='/content/Heptabit-Music-Transformer/Models/Large',\n",
        "                  local_dir_use_symlinks=False)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Instantiating 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",
        "ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]\n",
        "ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)\n",
        "\n",
        "SEQ_LEN = 8192\n",
        "\n",
        "# instantiate the model\n",
        "\n",
        "model = TransformerWrapper(\n",
        "    num_tokens = 17287,\n",
        "    max_seq_len = SEQ_LEN,\n",
        "    attn_layers = Decoder(dim = 1024, depth = 32, heads = 32, attn_flash = True)\n",
        ")\n",
        "\n",
        "model = AutoregressiveWrapper(model, ignore_index=17286)\n",
        "\n",
        "model.cuda()\n",
        "print('=' * 70)\n",
        "\n",
        "print('Loading model checkpoint...')\n",
        "\n",
        "model.load_state_dict(torch.load(full_path_to_model_checkpoint))\n",
        "print('=' * 70)\n",
        "\n",
        "model.eval()\n",
        "\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Model will use', dtype, 'precision...')\n",
        "print('=' * 70)\n",
        "\n",
        "# Model stats\n",
        "print('Model summary...')\n",
        "summary(model)\n",
        "\n",
        "# Plot Token Embeddings\n",
        "if plot_tokens_embeddings:\n",
        "  tok_emb = model.net.token_emb.emb.weight.detach().cpu().tolist()\n",
        "\n",
        "  cos_sim = metrics.pairwise_distances(\n",
        "    tok_emb, metric='cosine'\n",
        "  )\n",
        "  plt.figure(figsize=(7, 7))\n",
        "  plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"nearest\")\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/Heptabit-Music-Transformer-Large-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "V4s_G8yUL0cH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (LOAD VELOCITIES MAP)"
      ],
      "metadata": {
        "id": "NQflmu8GNAhQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Load velocities map\n",
        "\n",
        "#@markdown Select velocity type to apply to the generated output\n",
        "\n",
        "plot_velocities_map = False # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Heptabit Music Transformer Velocities Map...')\n",
        "print('=' * 70)\n",
        "\n",
        "dynamic_velocities_map = TMIDIX.Tegridy_Any_Pickle_File_Reader('/content/Heptabit-Music-Transformer/Aux-Data/pitches_patches_MIDI_velocities_map')[0]\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "if plot_velocities_map:\n",
        "  cos_sim = metrics.pairwise_distances(\n",
        "    dynamic_velocities_map, metric='minkowski'\n",
        "  )\n",
        "  plt.figure(figsize=(7, 7))\n",
        "  plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"nearest\")\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(\"Pitches\")\n",
        "  plt.ylabel(\"Patches\")\n",
        "  plt.tight_layout()\n",
        "  plt.plot()\n",
        "  plt.savefig(\"/content/Heptabit-Music-Transformer-Velocities-Map-Plot.png\", bbox_inches=\"tight\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "hw7gJGp0NFE8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GENERATE)"
      ],
      "metadata": {
        "id": "7xNyANjZsCOi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (IMPROV)"
      ],
      "metadata": {
        "id": "BxepTeHVmmKO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Standard Improv Generator\n",
        "\n",
        "#@markdown Improv type\n",
        "\n",
        "improv_type = \"Freestyle without Drums\" # @param [\"Freestyle without Drums\", \"Freestyle with Drums\", \"Custom\"]\n",
        "\n",
        "#@markdown Custom Improv settings\n",
        "\n",
        "first_note_MIDI_patch_number = 0 # @param {type:\"slider\", min:0, max:128, step:1}\n",
        "add_drums = False #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "number_of_tokens_tp_generate = 1500 # @param {type:\"slider\", min:30, max:8190, step:3}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "temperature = 0.85 # @param {type:\"slider\", min:0.1, max:1, step:0.05}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Heptabit Music Transformer Standard Improv Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if improv_type == 'Freestyle without Drums':\n",
        "\n",
        "  outy = [17285, 17154]\n",
        "\n",
        "if improv_type == 'Freestyle with Drums':\n",
        "\n",
        "  outy = [17285, 17155]\n",
        "\n",
        "if improv_type == 'Custom':\n",
        "\n",
        "  if add_drums:\n",
        "    drumsp = 17155 # Yes\n",
        "  else:\n",
        "    drumsp = 17154 # No\n",
        "\n",
        "  outy = [17285, drumsp, 17156+first_note_MIDI_patch_number]\n",
        "\n",
        "print('Selected Improv sequence:')\n",
        "print(outy)\n",
        "print('=' * 70)\n",
        "\n",
        "inp = [outy] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "with ctx:\n",
        "  out = model.generate(inp,\n",
        "                        number_of_tokens_tp_generate,\n",
        "                        temperature=temperature,\n",
        "                        return_prime=True,\n",
        "                        verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "\n",
        "for i in range(number_of_batches_to_generate):\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Batch #', i)\n",
        "  print('=' * 70)\n",
        "\n",
        "  out1 = out0[i]\n",
        "\n",
        "  print('Sample INTs', out1[:12])\n",
        "  print('=' * 70)\n",
        "\n",
        "  if len(out1) != 0:\n",
        "\n",
        "      song = out1\n",
        "      song_f = []\n",
        "\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      channel = 0\n",
        "      pitch = 0\n",
        "      vel = 90\n",
        "\n",
        "      patches = [-1] * 16\n",
        "\n",
        "      channels = [0] * 16\n",
        "      channels[9] = 1\n",
        "\n",
        "      for ss in song:\n",
        "\n",
        "          if 0 <= ss < 128:\n",
        "\n",
        "              time += (ss * 32)\n",
        "\n",
        "          if 128 <= ss < 256:\n",
        "\n",
        "              dur = ((ss-128) * 32)\n",
        "\n",
        "          if 256 <= ss < 16897:\n",
        "              patch = (ss-256) // 129\n",
        "\n",
        "              if patch < 128:\n",
        "\n",
        "                  if patch not in patches:\n",
        "                    if 0 in channels:\n",
        "                        cha = channels.index(0)\n",
        "                        channels[cha] = 1\n",
        "                    else:\n",
        "                        cha = 15\n",
        "\n",
        "                    patches[cha] = patch\n",
        "                    channel = patches.index(patch)\n",
        "                  else:\n",
        "                    channel = patches.index(patch)\n",
        "\n",
        "              if patch == 128:\n",
        "                  channel = 9\n",
        "\n",
        "              pitch = (ss-256) % 129\n",
        "\n",
        "              vel = round(dynamic_velocities_map[pitch][patch])\n",
        "\n",
        "              song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "      patches = [0 if x==-1 else x for x in patches]\n",
        "\n",
        "      data = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                      output_signature = 'Heptabit Music Transformer',\n",
        "                                                      output_file_name = '/content/Heptabit-Music-Transformer-Music-Composition_'+str(i),\n",
        "                                                      track_name='Project Los Angeles',\n",
        "                                                      list_of_MIDI_patches=patches\n",
        "                                                      )\n",
        "\n",
        "\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Heptabit-Music-Transformer-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan',\n",
        "                'blue', 'pink', 'orange', 'purple',\n",
        "                'gray', 'white', 'gold', 'silver',\n",
        "                'lightgreen', 'indigo', 'maroon', 'turquoise']\n",
        "\n",
        "      for s in song_f:\n",
        "        x.append(s[1] / 1000)\n",
        "        y.append(s[4])\n",
        "        c.append(colors[s[3]])\n",
        "\n",
        "      if render_MIDI_to_audio:\n",
        "        midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "        display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "      plt.figure(figsize=(14,5))\n",
        "      ax=plt.axes(title=fname)\n",
        "      ax.set_facecolor('black')\n",
        "\n",
        "      plt.scatter(x,y, c=c)\n",
        "      plt.xlabel(\"Time\")\n",
        "      plt.ylabel(\"Pitch\")\n",
        "      plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Jwxz-eaF0K1y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (CUSTOM MIDI)"
      ],
      "metadata": {
        "id": "Gt03VtO6uKkb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4QXbFLsKqSnt",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load Seed MIDI\n",
        "\n",
        "#@markdown Press play button to to upload your own seed MIDI or to load one of the provided sample seed MIDIs from the dropdown list below\n",
        "\n",
        "select_seed_MIDI = \"Upload your own custom MIDI\" # @param [\"Upload your own custom MIDI\", \"Heptabit-Music-Transformer-Piano-Seed-1\", \"Heptabit-Music-Transformer-Piano-Seed-2\", \"Heptabit-Music-Transformer-Piano-Seed-3\", \"Heptabit-Music-Transformer-Piano-Seed-4\", \"Heptabit-Music-Transformer-Piano-Seed-5\", \"Heptabit-Music-Transformer-MI-Seed-1\", \"Heptabit-Music-Transformer-MI-Seed-2\", \"Heptabit-Music-Transformer-MI-Seed-3\", \"Heptabit-Music-Transformer-MI-Seed-4\", \"Heptabit-Music-Transformer-MI-Seed-5\"]\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Heptabit Music Transformer Seed MIDI Loader')\n",
        "print('=' * 70)\n",
        "\n",
        "f = ''\n",
        "\n",
        "if select_seed_MIDI != \"Upload your own custom MIDI\":\n",
        "  print('Loading seed MIDI...')\n",
        "  f = '/content/Heptabit-Music-Transformer/Seeds/'+select_seed_MIDI+'.mid'\n",
        "  score = TMIDIX.midi2single_track_ms_score(open(f, 'rb').read(), recalculate_channels=False)\n",
        "\n",
        "else:\n",
        "  print('Upload your own custom MIDI...')\n",
        "  print('=' * 70)\n",
        "  uploaded_MIDI = files.upload()\n",
        "  if list(uploaded_MIDI.keys()):\n",
        "    score = TMIDIX.midi2single_track_ms_score(list(uploaded_MIDI.values())[0], recalculate_channels=False)\n",
        "    f = list(uploaded_MIDI.keys())[0]\n",
        "\n",
        "if f != '':\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('File:', f)\n",
        "  print('=' * 70)\n",
        "\n",
        "  #=======================================================\n",
        "  # START PROCESSING\n",
        "\n",
        "  # Convering MIDI to ms score with MIDI.py module\n",
        "  score = TMIDIX.midi2single_track_ms_score(open(f, 'rb').read(), recalculate_channels=False)\n",
        "\n",
        "  # INSTRUMENTS CONVERSION CYCLE\n",
        "  events_matrix = []\n",
        "  itrack = 1\n",
        "  patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "  while itrack < len(score):\n",
        "      for event in score[itrack]:\n",
        "          if event[0] == 'note' or event[0] == 'patch_change':\n",
        "              events_matrix.append(event)\n",
        "      itrack += 1\n",
        "\n",
        "  events_matrix.sort(key=lambda x: x[1])\n",
        "\n",
        "  events_matrix1 = []\n",
        "\n",
        "  for event in events_matrix:\n",
        "          if event[0] == 'patch_change':\n",
        "                patches[event[2]] = event[3]\n",
        "\n",
        "          if event[0] == 'note':\n",
        "                event.extend([patches[event[3]]])\n",
        "\n",
        "                events_matrix1.append(event)\n",
        "\n",
        "  if len(events_matrix1) > 0:\n",
        "    if min([e[1] for e in events_matrix1]) >= 0 and min([e[2] for e in events_matrix1]) >= 0:\n",
        "\n",
        "      #=======================================================\n",
        "      # PRE-PROCESSING\n",
        "\n",
        "      # checking number of instruments in a composition\n",
        "      instruments_list_without_drums = list(set([y[3] for y in events_matrix1 if y[3] != 9]))\n",
        "      instruments_list = list(set([y[3] for y in events_matrix1]))\n",
        "\n",
        "      if len(events_matrix1) > 0 and len(instruments_list_without_drums) > 0:\n",
        "\n",
        "        # recalculating timings\n",
        "        for e in events_matrix1:\n",
        "            e[1] = int(e[1] / 32) # Max 4 seconds for start-times\n",
        "            e[2] = int(e[2] / 32) # Max 4 seconds for durations\n",
        "\n",
        "        # Sorting by pitch, then by start-time\n",
        "        events_matrix1.sort(key=lambda x: x[6])\n",
        "        events_matrix1.sort(key=lambda x: x[4])\n",
        "        events_matrix1.sort(key=lambda x: x[1])\n",
        "\n",
        "        #=======================================================\n",
        "        # FINAL PRE-PROCESSING\n",
        "\n",
        "        melody_chords = []\n",
        "\n",
        "        pe = events_matrix1[0]\n",
        "\n",
        "        for e in events_matrix1:\n",
        "\n",
        "            # Cliping all values...\n",
        "            time = max(0, min(127, e[1]-pe[1]))\n",
        "            dur = max(0, min(127, e[2]))\n",
        "            cha = max(0, min(15, e[3]))\n",
        "            ptc = max(1, min(127, e[4]))\n",
        "\n",
        "            pat = max(0, min(127, e[6]))\n",
        "\n",
        "            # Writing final note\n",
        "            melody_chords.append([time, dur, cha, ptc, pat])\n",
        "\n",
        "            pe = e\n",
        "\n",
        "        #=======================================================\n",
        "        # FINAL PROCESSING\n",
        "        #=======================================================\n",
        "\n",
        "        melody_chords2 = []\n",
        "\n",
        "        # Break between compositions / Intro seq\n",
        "\n",
        "        if 9 in instruments_list:\n",
        "          drums_present = 17155 # Yes\n",
        "        else:\n",
        "          drums_present = 17154 # No\n",
        "\n",
        "        if melody_chords[0][2] != 9:\n",
        "            pat = melody_chords[0][4]\n",
        "        else:\n",
        "            pat = 128\n",
        "\n",
        "        melody_chords2.extend([17285, drums_present, 17156+pat]) # Intro seq\n",
        "\n",
        "        #=======================================================\n",
        "\n",
        "        # TOTAL DICTIONARY SIZE 17285+1=17286\n",
        "\n",
        "        #=======================================================\n",
        "        # MAIN PROCESSING CYCLE\n",
        "        #=======================================================\n",
        "\n",
        "        chords_counter = 1\n",
        "\n",
        "        comp_chords_len = len([y for y in melody_chords if y[0] != 0])\n",
        "\n",
        "        for m in melody_chords:\n",
        "\n",
        "            # if ((comp_chords_len - chords_counter) == 50) and (m[0] != 0):\n",
        "            #    melody_chords2.extend([17153, 17153, 17153]) # Outro token seq\n",
        "\n",
        "            if (chords_counter % 50 == 0) and (m[0] != 0):\n",
        "                nct = 16897+min(255, ((chords_counter // 50)-1)) # chords counter token\n",
        "                melody_chords2.extend([nct, nct, nct])\n",
        "                chords_counter += 1\n",
        "            else:\n",
        "                if m[0] != 0:\n",
        "                    chords_counter += 1\n",
        "\n",
        "            # Drums patch\n",
        "            if m[2] == 9: # Drums patch will be == 128\n",
        "                pat = 128\n",
        "            else:\n",
        "                pat = m[4]\n",
        "\n",
        "            cha_pat = (129 * pat) + m[3]\n",
        "\n",
        "            melody_chords2.extend([m[0], m[1]+128, cha_pat+256])\n",
        "\n",
        "        # melody_chords2.extend([17285, 17285, 17285]) # EOS\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  song = melody_chords2\n",
        "\n",
        "  song_f = []\n",
        "\n",
        "  time = 0\n",
        "  dur = 0\n",
        "  channel = 0\n",
        "  pitch = 0\n",
        "  vel = 90\n",
        "\n",
        "  patches = [-1] * 16\n",
        "\n",
        "  channels = [0] * 16\n",
        "  channels[9] = 1\n",
        "\n",
        "  for ss in song:\n",
        "\n",
        "      if 0 <= ss < 128:\n",
        "\n",
        "          time += (ss * 32)\n",
        "\n",
        "      if 128 <= ss < 256:\n",
        "\n",
        "          dur = ((ss-128) * 32)\n",
        "\n",
        "      if 256 <= ss < 16897:\n",
        "          patch = (ss-256) // 129\n",
        "\n",
        "          if patch < 128:\n",
        "\n",
        "              if patch not in patches:\n",
        "                if 0 in channels:\n",
        "                    cha = channels.index(0)\n",
        "                    channels[cha] = 1\n",
        "                else:\n",
        "                    cha = 15\n",
        "\n",
        "                patches[cha] = patch\n",
        "                channel = patches.index(patch)\n",
        "              else:\n",
        "                channel = patches.index(patch)\n",
        "\n",
        "          if patch == 128:\n",
        "              channel = 9\n",
        "\n",
        "          pitch = (ss-256) % 129\n",
        "\n",
        "          vel = round(dynamic_velocities_map[pitch][patch])\n",
        "\n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "  patches = [0 if x==-1 else x for x in patches]\n",
        "\n",
        "  detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                            output_signature = 'Heptabit Music Transformer',\n",
        "                                                            output_file_name = '/content/Heptabit-Music-Transformer-Seed-Composition',\n",
        "                                                            track_name='Project Los Angeles',\n",
        "                                                            list_of_MIDI_patches=patches\n",
        "                                                            )\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Composition stats:')\n",
        "  print('Composition has', len(melody_chords), 'notes')\n",
        "  print('Composition has', len(melody_chords2), 'tokens')\n",
        "  print('Composition MIDI patches:', sorted(list(set([((y-256) // 129) for y in melody_chords2 if 256 <= y < 16897]))))\n",
        "  print('=' * 70)\n",
        "\n",
        "  print('Displaying resulting composition...')\n",
        "  print('=' * 70)\n",
        "\n",
        "  fname = '/content/Heptabit-Music-Transformer-Seed-Composition'\n",
        "\n",
        "  x = []\n",
        "  y =[]\n",
        "  c = []\n",
        "\n",
        "  colors = ['red', 'yellow', 'green', 'cyan',\n",
        "            'blue', 'pink', 'orange', 'purple',\n",
        "            'gray', 'white', 'gold', 'silver',\n",
        "            'lightgreen', 'indigo', 'maroon', 'turquoise']\n",
        "\n",
        "  for s in song_f:\n",
        "    x.append(s[1] / 1000)\n",
        "    y.append(s[4])\n",
        "    c.append(colors[s[3]])\n",
        "\n",
        "  if render_MIDI_to_audio:\n",
        "    midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "    display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "  plt.figure(figsize=(14,5))\n",
        "  ax=plt.axes(title=fname)\n",
        "  ax.set_facecolor('black')\n",
        "\n",
        "  plt.scatter(x,y, c=c)\n",
        "  plt.xlabel(\"Time\")\n",
        "  plt.ylabel(\"Pitch\")\n",
        "  plt.show()\n",
        "\n",
        "else:\n",
        "  print('=' * 70)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (CONTINUATION)"
      ],
      "metadata": {
        "id": "fmm3KjOtoVp9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dkvXYwR_qSnx",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Standard Continuation\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "try_to_generate_outro = False #@param {type:\"boolean\"}\n",
        "number_of_prime_tokens = 8190 # @param {type:\"slider\", min:3, max:8190, step:3}\n",
        "number_of_tokens_to_generate = 1500 # @param {type:\"slider\", min:30, max:8190, step:3}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "temperature = 0.85 # @param {type:\"slider\", min:0.1, max:1, step:0.05}\n",
        "\n",
        "#@markdown Other settings\n",
        "include_prime_tokens_in_generated_output = True #@param {type:\"boolean\"}\n",
        "allow_model_to_stop_generation_if_needed = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Heptabit Music Transformer Standard Continuation Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if allow_model_to_stop_generation_if_needed:\n",
        "  min_stop_token = 17285\n",
        "else:\n",
        "  min_stop_token = None\n",
        "\n",
        "outy = melody_chords2[:number_of_prime_tokens]\n",
        "\n",
        "if try_to_generate_outro:\n",
        "  outy.extend([17153, 17153, 17153])\n",
        "\n",
        "inp = [outy] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "with ctx:\n",
        "  out = model.generate(inp,\n",
        "                        number_of_tokens_to_generate,\n",
        "                        temperature=temperature,\n",
        "                        return_prime=include_prime_tokens_in_generated_output,\n",
        "                        eos_token=min_stop_token,\n",
        "                        verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "print('Rendering results...')\n",
        "\n",
        "for i in range(number_of_batches_to_generate):\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Batch #', i)\n",
        "  print('=' * 70)\n",
        "\n",
        "  out1 = out0[i]\n",
        "\n",
        "  print('Sample INTs', out1[:12])\n",
        "  print('=' * 70)\n",
        "\n",
        "  if len(out) != 0:\n",
        "\n",
        "      song = out1\n",
        "      song_f = []\n",
        "\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      channel = 0\n",
        "      pitch = 0\n",
        "      vel = 90\n",
        "\n",
        "      patches = [-1] * 16\n",
        "\n",
        "      channels = [0] * 16\n",
        "      channels[9] = 1\n",
        "\n",
        "      for ss in song:\n",
        "\n",
        "          if 0 <= ss < 128:\n",
        "\n",
        "              time += (ss * 32)\n",
        "\n",
        "          if 128 <= ss < 256:\n",
        "\n",
        "              dur = ((ss-128) * 32)\n",
        "\n",
        "          if 256 <= ss < 16897:\n",
        "              patch = (ss-256) // 129\n",
        "\n",
        "              if patch < 128:\n",
        "\n",
        "                  if patch not in patches:\n",
        "                    if 0 in channels:\n",
        "                        cha = channels.index(0)\n",
        "                        channels[cha] = 1\n",
        "                    else:\n",
        "                        cha = 15\n",
        "\n",
        "                    patches[cha] = patch\n",
        "                    channel = patches.index(patch)\n",
        "                  else:\n",
        "                    channel = patches.index(patch)\n",
        "\n",
        "              if patch == 128:\n",
        "                  channel = 9\n",
        "\n",
        "              pitch = (ss-256) % 129\n",
        "\n",
        "              vel = round(dynamic_velocities_map[pitch][patch])\n",
        "\n",
        "              song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "      patches = [0 if x==-1 else x for x in patches]\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                                output_signature = 'Heptabit Music Transformer',\n",
        "                                                                output_file_name = '/content/Heptabit-Music-Transformer-Music-Composition_'+str(i),\n",
        "                                                                track_name='Project Los Angeles',\n",
        "                                                                list_of_MIDI_patches=patches\n",
        "                                                                )\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Heptabit-Music-Transformer-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan',\n",
        "                'blue', 'pink', 'orange', 'purple',\n",
        "                'gray', 'white', 'gold', 'silver',\n",
        "                'lightgreen', 'indigo', 'maroon', 'turquoise']\n",
        "\n",
        "      for s in song_f:\n",
        "        x.append(s[1] / 1000)\n",
        "        y.append(s[4])\n",
        "        c.append(colors[s[3]])\n",
        "\n",
        "      if render_MIDI_to_audio:\n",
        "        midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "        display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "      plt.figure(figsize=(14,5))\n",
        "      ax=plt.axes(title=fname)\n",
        "      ax.set_facecolor('black')\n",
        "\n",
        "      plt.scatter(x,y, c=c)\n",
        "      plt.xlabel(\"Time\")\n",
        "      plt.ylabel(\"Pitch\")\n",
        "      plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (INPAINTING)"
      ],
      "metadata": {
        "id": "jUdZ93-K9ABR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Pitches/Instruments Inpainting\n",
        "\n",
        "#@markdown You can stop the inpainting at any time to render partial results\n",
        "\n",
        "#@markdown Inpainting settings\n",
        "\n",
        "#@markdown Select MIDI patch present in the composition to inpaint\n",
        "\n",
        "inpaint_MIDI_patch = 0 # @param {type:\"slider\", min:0, max:128, step:1}\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "number_of_prime_tokens = 300 # @param {type:\"slider\", min:3, max:8190, step:3}\n",
        "number_of_memory_tokens = 8190 # @param {type:\"slider\", min:3, max:8190, step:3}\n",
        "number_of_samples_per_inpainted_note = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "temperature = 0.85 # @param {type:\"slider\", min:0.1, max:1, step:0.05}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Heptabit Music Transformer Inpainting Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "out2 = []\n",
        "\n",
        "for m in melody_chords2[:number_of_prime_tokens]:\n",
        "  out2.append(m)\n",
        "\n",
        "for i in tqdm.tqdm(range(number_of_prime_tokens, len(melody_chords2))):\n",
        "\n",
        "  try:\n",
        "\n",
        "    cpatch = (melody_chords2[i]-256) // 129\n",
        "\n",
        "    if 256 <= melody_chords2[i] < 16897 and (cpatch) == inpaint_MIDI_patch:\n",
        "\n",
        "        samples = []\n",
        "\n",
        "        for j in range(number_of_samples_per_inpainted_note):\n",
        "\n",
        "          inp = torch.LongTensor(out2[-number_of_memory_tokens:]).cuda()\n",
        "\n",
        "          with ctx:\n",
        "            out1 = model.generate(inp,\n",
        "                                  1,\n",
        "                                  temperature=temperature,\n",
        "                                  return_prime=True,\n",
        "                                  verbose=False)\n",
        "\n",
        "            with torch.no_grad():\n",
        "              test_loss, test_acc = model(out1)\n",
        "\n",
        "          samples.append([out1.tolist()[0][-1], test_acc.tolist()])\n",
        "\n",
        "        accs = [y[1] for y in samples]\n",
        "        max_acc = max(accs)\n",
        "        max_acc_sample = samples[accs.index(max_acc)][0]\n",
        "\n",
        "        cpitch = (max_acc_sample-256) % 129\n",
        "\n",
        "        out2.extend([((cpatch * 129) + cpitch)+256])\n",
        "\n",
        "    else:\n",
        "        out2.append(melody_chords2[i])\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('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "#==================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out2) != 0:\n",
        "\n",
        "    song = out2\n",
        "    song_f = []\n",
        "\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    channel = 0\n",
        "    pitch = 0\n",
        "    vel = 90\n",
        "\n",
        "    patches = [-1] * 16\n",
        "\n",
        "    channels = [0] * 16\n",
        "    channels[9] = 1\n",
        "\n",
        "    for ss in song:\n",
        "\n",
        "        if 0 <= ss < 128:\n",
        "\n",
        "            time += (ss * 32)\n",
        "\n",
        "        if 128 <= ss < 256:\n",
        "\n",
        "            dur = ((ss-128) * 32)\n",
        "\n",
        "        if 256 <= ss < 16897:\n",
        "            patch = (ss-256) // 129\n",
        "\n",
        "            if patch < 128:\n",
        "\n",
        "                if patch not in patches:\n",
        "                  if 0 in channels:\n",
        "                      cha = channels.index(0)\n",
        "                      channels[cha] = 1\n",
        "                  else:\n",
        "                      cha = 15\n",
        "\n",
        "                  patches[cha] = patch\n",
        "                  channel = patches.index(patch)\n",
        "                else:\n",
        "                  channel = patches.index(patch)\n",
        "\n",
        "            if patch == 128:\n",
        "                channel = 9\n",
        "\n",
        "            pitch = (ss-256) % 129\n",
        "\n",
        "            vel = round(dynamic_velocities_map[pitch][patch])\n",
        "\n",
        "            song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    patches = [0 if x==-1 else x for x in patches]\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'Heptabit Music Transformer',\n",
        "                                                              output_file_name = '/content/Heptabit-Music-Transformer-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=patches\n",
        "                                                              )\n",
        "\n",
        "\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Heptabit-Music-Transformer-Music-Composition'\n",
        "\n",
        "    x = []\n",
        "    y =[]\n",
        "    c = []\n",
        "\n",
        "    colors = ['red', 'yellow', 'green', 'cyan',\n",
        "              'blue', 'pink', 'orange', 'purple',\n",
        "              'gray', 'white', 'gold', 'silver',\n",
        "              'lightgreen', 'indigo', 'maroon', 'turquoise']\n",
        "\n",
        "    for s in song_f:\n",
        "      x.append(s[1] / 1000)\n",
        "      y.append(s[4])\n",
        "      c.append(colors[s[3]])\n",
        "\n",
        "    if render_MIDI_to_audio:\n",
        "      midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "      display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "    plt.figure(figsize=(14,5))\n",
        "    ax=plt.axes(title=fname)\n",
        "    ax.set_facecolor('black')\n",
        "\n",
        "    plt.scatter(x,y, c=c)\n",
        "    plt.xlabel(\"Time\")\n",
        "    plt.ylabel(\"Pitch\")\n",
        "    plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "ejdp32D_9Cs-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (HARMONIZATION)"
      ],
      "metadata": {
        "id": "-ljIsqzx0jwr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Melody Harmonization\n",
        "\n",
        "#@markdown NOTE: You can stop the harmonization at any time to render partial results\n",
        "\n",
        "#@markdown Harmonization settings\n",
        "\n",
        "melody_MIDI_patch = 40 # @param {type:\"slider\", min:0, max:128, step:1}\n",
        "number_of_prime_melody_notes = 0 # @param {type:\"slider\", min:0, max:50, step:1}\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "number_of_memory_tokens = 8190 # @param {type:\"slider\", min:33, max:8190, step:3}\n",
        "temperature = 0.85 # @param {type:\"slider\", min:0.1, max:1, step:0.05}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Heptabit Music Transformer Melody Harmonization Model Generator')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Extracting melody...')\n",
        "#=======================================================\n",
        "\n",
        "melody = []\n",
        "\n",
        "events_matrix1.sort(key=lambda x: x[6])\n",
        "events_matrix1.sort(key=lambda x: x[4], reverse=True)\n",
        "events_matrix1.sort(key=lambda x: x[1])\n",
        "\n",
        "pe = events_matrix1[0]\n",
        "\n",
        "for e in events_matrix1:\n",
        "    if e[3] != 9:\n",
        "\n",
        "      # Cliping all values...\n",
        "      time = max(0, min(127, e[1]-pe[1]))\n",
        "      dur = max(0, min(127, e[2]))\n",
        "      cha = max(0, min(15, e[3]))\n",
        "      ptc = max(1, min(127, e[4]))\n",
        "\n",
        "      pat = melody_MIDI_patch\n",
        "\n",
        "      if ptc < 60:\n",
        "        ptc_aug = (ptc % 12) + 60\n",
        "      else:\n",
        "        ptc_aug = ptc\n",
        "\n",
        "      # WRITING EACH NOTE HERE\n",
        "\n",
        "      cha_pat = (129 * pat) + ptc_aug\n",
        "\n",
        "      if time != 0:\n",
        "        melody.append([time, dur+128, cha_pat+256])\n",
        "\n",
        "      pe = e\n",
        "\n",
        "melody[0][0] = 0\n",
        "\n",
        "#=======================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Melody has', len(melody), 'notes')\n",
        "print('Melody has', len(melody)*3, 'tokens')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Starting harmonization...')\n",
        "print('=' * 70)\n",
        "\n",
        "outy = []\n",
        "\n",
        "for m in melody[:number_of_prime_melody_notes]:\n",
        "  outy.extend(m)\n",
        "\n",
        "next_chord_time = 0\n",
        "chord_time_delta = 0\n",
        "cur_time = 0\n",
        "\n",
        "for i in tqdm.tqdm(range(number_of_prime_melody_notes, len(melody))):\n",
        "\n",
        "  try:\n",
        "    outy.extend(melody[i])\n",
        "\n",
        "    #====================================================\n",
        "\n",
        "    outy.extend([0])\n",
        "\n",
        "    inp = [outy[-number_of_memory_tokens:]]\n",
        "    inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "    with ctx:\n",
        "      out = model.generate(inp,\n",
        "                            2,\n",
        "                            temperature=temperature,\n",
        "                            return_prime=False,\n",
        "                            eos_token=None,\n",
        "                            verbose=False)\n",
        "\n",
        "    out0 = out.tolist()[0]\n",
        "\n",
        "    # ((out0[1]-256) % 129) != ((melody[i][2]-256) % 129)\n",
        "\n",
        "    if ((out0[1]-256) // 129) != melody_MIDI_patch:\n",
        "      outy.extend(out0)\n",
        "    else:\n",
        "      outy.pop()\n",
        "\n",
        "    #====================================================\n",
        "\n",
        "    out0 = [0, 0, 0]\n",
        "    pout0 = []\n",
        "\n",
        "    while out0[0] == 0 and out0 != pout0:\n",
        "\n",
        "      pout0 = out0\n",
        "\n",
        "      inp = [outy[-number_of_memory_tokens:]]\n",
        "      inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "      with ctx:\n",
        "        out = model.generate(inp,\n",
        "                              3,\n",
        "                              temperature=temperature,\n",
        "                              return_prime=False,\n",
        "                              eos_token=None,\n",
        "                              verbose=False)\n",
        "\n",
        "      out0 = out.tolist()[0]\n",
        "\n",
        "      # ((out0[2]-256) % 129) != ((melody[i][2]-256) % 129)\n",
        "\n",
        "      if out0[0] == 0 and (((out0[2]-256) // 129) != melody_MIDI_patch) and out0 != pout0:\n",
        "        outy.extend(out0)\n",
        "\n",
        "    #====================================================\n",
        "\n",
        "  except KeyboardInterrupt:\n",
        "    break\n",
        "\n",
        "  except Exception as e:\n",
        "    print('Error', e)\n",
        "    break\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = outy\n",
        "\n",
        "print('Sample INTs', out1[:12])\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out1) != 0:\n",
        "\n",
        "    song = out1\n",
        "    song_f = []\n",
        "\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    channel = 0\n",
        "    pitch = 0\n",
        "    vel = 90\n",
        "\n",
        "    patches = [-1] * 16\n",
        "\n",
        "    channels = [0] * 16\n",
        "    channels[9] = 1\n",
        "\n",
        "    for ss in song:\n",
        "\n",
        "        if 0 <= ss < 128:\n",
        "\n",
        "            time += (ss * 32)\n",
        "\n",
        "        if 128 <= ss < 256:\n",
        "\n",
        "            dur = ((ss-128) * 32)\n",
        "\n",
        "        if 256 <= ss < 16897:\n",
        "            patch = (ss-256) // 129\n",
        "\n",
        "            if patch < 128:\n",
        "\n",
        "                if patch not in patches:\n",
        "                  if 0 in channels:\n",
        "                      cha = channels.index(0)\n",
        "                      channels[cha] = 1\n",
        "                  else:\n",
        "                      cha = 15\n",
        "\n",
        "                  patches[cha] = patch\n",
        "                  channel = patches.index(patch)\n",
        "                else:\n",
        "                  channel = patches.index(patch)\n",
        "\n",
        "            if patch == 128:\n",
        "                channel = 9\n",
        "\n",
        "            pitch = (ss-256) % 129\n",
        "\n",
        "            vel = round(dynamic_velocities_map[pitch][patch])\n",
        "\n",
        "            song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    patches = [0 if x==-1 else x for x in patches]\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'Heptabit Music Transformer',\n",
        "                                                              output_file_name = '/content/Heptabit-Music-Transformer-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=patches\n",
        "                                                              )\n",
        "\n",
        "\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Heptabit-Music-Transformer-Music-Composition'\n",
        "\n",
        "    x = []\n",
        "    y =[]\n",
        "    c = []\n",
        "\n",
        "    colors = ['red', 'yellow', 'green', 'cyan',\n",
        "              'blue', 'pink', 'orange', 'purple',\n",
        "              'gray', 'white', 'gold', 'silver',\n",
        "              'lightgreen', 'indigo', 'maroon', 'turquoise']\n",
        "\n",
        "    for s in song_f:\n",
        "      x.append(s[1] / 1000)\n",
        "      y.append(s[4])\n",
        "      c.append(colors[s[3]])\n",
        "\n",
        "    if render_MIDI_to_audio:\n",
        "      midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "      display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "    plt.figure(figsize=(14,5))\n",
        "    ax=plt.axes(title=fname)\n",
        "    ax.set_facecolor('black')\n",
        "\n",
        "    plt.scatter(x,y, c=c)\n",
        "    plt.xlabel(\"Time\")\n",
        "    plt.ylabel(\"Pitch\")\n",
        "    plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "N9bBlUQlsR67"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Congrats! You did it! :)"
      ],
      "metadata": {
        "id": "eoWDEy6CwDr6"
      }
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "gpuType": "T4",
      "gpuClass": "premium"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}