Los_Angeles_Music_Composer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Los Angeles Music Composer (ver. 2.2)\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 https://github.com/asigalov61/Los-Angeles-Music-Composer\n",
        "!pip install torch\n",
        "!pip install einops\n",
        "!pip install torch-summary\n",
        "!pip install sklearn\n",
        "!pip install tqdm\n",
        "!pip install matplotlib\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": {
        "id": "DzCOZU_gBiQV",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Import modules\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading core Los Angeles Music Composer modules...')\n",
        "\n",
        "import os\n",
        "import pickle\n",
        "import random\n",
        "import secrets\n",
        "import statistics\n",
        "from time import time\n",
        "import tqdm\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading main Los Angeles Music Composer modules...')\n",
        "import torch\n",
        "\n",
        "%cd /content/Los-Angeles-Music-Composer\n",
        "\n",
        "import TMIDIX\n",
        "from lwa_transformer import *\n",
        "\n",
        "%cd /content/\n",
        "print('=' * 70)\n",
        "print('Loading aux Los Angeles Music Composer modeules...')\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from torchsummary import summary\n",
        "from sklearn import metrics\n",
        "\n",
        "from midi2audio import FluidSynth\n",
        "from IPython.display import Audio, display\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 Unzip Pre-Trained Los Angeles Music Composer Model\n",
        "print('=' * 70)\n",
        "%cd /content/Los-Angeles-Music-Composer/Model\n",
        "\n",
        "print('=' * 70)\n",
        "print('Unzipping pre-trained Los Angeles Music Composer model...Please wait...')\n",
        "\n",
        "!cat /content/Los-Angeles-Music-Composer/Model/Los_Angeles_Music_Composer_Trained_Model.zip* > /content/Los-Angeles-Music-Composer/Model/Los_Angeles_Music_Composer_Trained_Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j /content/Los-Angeles-Music-Composer/Model/Los_Angeles_Music_Composer_Trained_Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/\n",
        "print('=' * 70)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "SqbxcFYVq63r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rDquonbXC2je",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load Los Angeles Music Composer Model\n",
        "full_path_to_model_checkpoint = \"/content/Los-Angeles-Music-Composer/Model/Los_Angeles_Music_Composer_Model_88835_steps_0.643_loss.pth\" #@param {type:\"string\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Los Angeles Music Composer Pre-Trained Model...')\n",
        "print('Please wait...')\n",
        "print('=' * 70)\n",
        "print('Instantiating model...')\n",
        "\n",
        "SEQ_LEN = 4096\n",
        "\n",
        "# instantiate the model\n",
        "\n",
        "model = LocalTransformer(\n",
        "    num_tokens = 2831,\n",
        "    dim = 1024,\n",
        "    depth = 36,\n",
        "    causal = True,\n",
        "    local_attn_window_size = 512,\n",
        "    max_seq_len = SEQ_LEN\n",
        ")\n",
        "\n",
        "model = torch.nn.DataParallel(model)\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",
        "# Model stats\n",
        "print('Model summary...')\n",
        "summary(model)\n",
        "\n",
        "# Plot Token Embeddings\n",
        "tok_emb = model.module.token_emb.weight.detach().cpu().tolist()\n",
        "\n",
        "tok_emb1 = []\n",
        "\n",
        "for t in tok_emb:\n",
        "    tok_emb1.append([abs(statistics.median(t))])\n",
        "\n",
        "cos_sim = metrics.pairwise_distances(\n",
        "   tok_emb1, metric='euclidean'\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/Los-Angeles-Music-Composer-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GENERATE)"
      ],
      "metadata": {
        "id": "7xNyANjZsCOi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Improv Generator\n",
        "\n",
        "#@markdown Select desired instruments (any combination is fine)\n",
        "\n",
        "Piano = True #@param {type:\"boolean\"}\n",
        "Guitar = True #@param {type:\"boolean\"}\n",
        "Bass = True #@param {type:\"boolean\"}\n",
        "Violin = False #@param {type:\"boolean\"}\n",
        "Cello = False #@param {type:\"boolean\"}\n",
        "Harp = False #@param {type:\"boolean\"}\n",
        "Trumpet = False #@param {type:\"boolean\"}\n",
        "Clarinet = False #@param {type:\"boolean\"}\n",
        "Flute = False #@param {type:\"boolean\"}\n",
        "Drums = True #@param {type:\"boolean\"}\n",
        "Choir = True #@param {type:\"boolean\"}\n",
        "Organ = False #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown Improv Timings and Velocity\n",
        "desired_prime_time = 10 #@param {type:\"slider\", min:0, max:127, step:1}\n",
        "desired_prime_duration = 20 #@param {type:\"slider\", min:1, max:126, step:1}\n",
        "desired_velocity = 6 #@param {type:\"slider\", min:1, max:8, step:1}\n",
        "\n",
        "#@markdown Model settings\n",
        "\n",
        "number_of_tokens_tp_generate = 512 #@param {type:\"slider\", min:32, max:4064, step:32}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "temperature = 0.9 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "instruments = []\n",
        "\n",
        "if Piano:\n",
        "  instruments += [\n",
        "                  0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((0 * 128) + 60)+1152, # instrument number(1) + start pitch(60)\n",
        "                 ]\n",
        "\n",
        "if Guitar:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((1 * 128) + 60)+1152, # instrument number(1) + start pitch(60)\n",
        "                  ]\n",
        "\n",
        "if Bass:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((2 * 128) + 48)+1152, # instrument number(2) + start pitch(48)\n",
        "                  ]\n",
        "if Violin:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((3 * 128) + 72)+1152, # instrument number(3) + start pitch(72)\n",
        "                  ]\n",
        "\n",
        "if Cello:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((4 * 128) + 48)+1152, # instrument number(4) + start pitch(48)\n",
        "                  ]\n",
        "\n",
        "if Harp:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((5 * 128) + 72)+1152, # instrument number(5) + start pitch(72)\n",
        "                  ]\n",
        "\n",
        "if Trumpet:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((6 * 128) + 72)+1152, # instrument number(6) + start pitch(72)\n",
        "                  ]\n",
        "\n",
        "if Clarinet:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((7 * 128) + 72)+1152, # instrument number(7) + start pitch(72)\n",
        "                  ]\n",
        "\n",
        "if Flute:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((8 * 128) + 72)+1152, # instrument number(8) + start pitch(72)\n",
        "                  ]\n",
        "\n",
        "if Drums:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((9 * 128) + 35)+1152, # instrument number(9) + start pitch(35)\n",
        "                  ]\n",
        "\n",
        "if Choir:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((10 * 128) + 72)+1152, # instrument number(10) + start pitch(72)\n",
        "                  ]\n",
        "\n",
        "if Organ:\n",
        "  instruments += [0, # delta start time (0)\n",
        "                  ((desired_prime_duration * 8) + (desired_velocity-1))+128,\n",
        "                  ((11 * 128) + 60)+1152, # instrument number(11) + start pitch(60)\n",
        "                  ]\n",
        "\n",
        "instruments[0] = desired_prime_time\n",
        "instruments[3::3] = [0] * len(instruments[3::3])\n",
        "\n",
        "outy = instruments\n",
        "\n",
        "#===================================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Los Angeles Music Composer Model Improvisation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\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",
        "#start_time = time()\n",
        "\n",
        "out = model.module.generate(inp, \n",
        "                      number_of_tokens_tp_generate, \n",
        "                      temperature=temperature, \n",
        "                      return_prime=True, \n",
        "                      min_stop_token=0, \n",
        "                      verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "#print('Generation took', time() - start_time, \"seconds\")\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\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",
        "      tim = 0\n",
        "      dur = 0\n",
        "      vel = 0\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "\n",
        "      son = []\n",
        "      song1 = []\n",
        "\n",
        "      for s in song:\n",
        "        if s >= 128 and s < (12*128)+1152:\n",
        "          son.append(s)\n",
        "        else:\n",
        "          if len(son) == 3:\n",
        "            song1.append(son)\n",
        "          son = []\n",
        "          son.append(s)\n",
        "                      \n",
        "      for ss in song1:\n",
        "\n",
        "        tim += ss[0] * 10\n",
        "\n",
        "        dur = (((ss[1]-128) // 8)+1) * 20\n",
        "        vel = (((ss[1]-128) % 8)+1) * 15\n",
        "    \n",
        "        channel = (ss[2]-1152) // 128\n",
        "        pitch = (ss[2]-1152) % 128\n",
        "                        \n",
        "        song_f.append(['note', tim, dur, channel, pitch, vel ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Los Angeles Music Composer',  \n",
        "                                                          output_file_name = '/content/Los-Angeles-Music-Composer-Music-Composition_'+str(i), \n",
        "                                                          track_name='Project Los Angeles',\n",
        "                                                          list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Los-Angeles-Music-Composer-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\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",
        "      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",
        "\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": "4ZPGiOEIUlpV"
      },
      "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",
        "select_seed_MIDI = \"Los-Angeles-Music-Composer-Piano-Seed-1\" #@param [\"Los-Angeles-Music-Composer-Piano-Seed-1\", \"Los-Angeles-Music-Composer-Piano-Seed-2\", \"Los-Angeles-Music-Composer-Piano-Seed-3\", \"Los-Angeles-Music-Composer-Piano-Seed-4\", \"Los-Angeles-Music-Composer-Piano-Seed-5\", \"Los-Angeles-Music-Composer-MI-Seed-1\", \"Los-Angeles-Music-Composer-MI-Seed-2\", \"Los-Angeles-Music-Composer-MI-Seed-3\", \"Los-Angeles-Music-Composer-MI-Seed-4\", \"Los-Angeles-Music-Composer-MI-Seed-5\"]\n",
        "full_path_to_custom_seed_MIDI = \"\" #@param {type:\"string\"}\n",
        "\n",
        "if full_path_to_custom_seed_MIDI == '':\n",
        "  f = '/content/Los-Angeles-Music-Composer/Seeds/'+select_seed_MIDI+'.mid'\n",
        "\n",
        "else:\n",
        "  f = full_path_to_custom_seed_MIDI\n",
        "\n",
        "print('=' * 70)\n",
        "print('Los Angeles Music Composer Seed MIDI Loader')\n",
        "print('=' * 70)\n",
        "print('Loading seed MIDI...')\n",
        "print('=' * 70)\n",
        "print('File:', f)\n",
        "print('=' * 70)\n",
        "\n",
        "transpose_to_model_average_pitch = False\n",
        "\n",
        "#=======================================================\n",
        "# START PROCESSING\n",
        "\n",
        "# Convering MIDI to ms score with MIDI.py module\n",
        "score = TMIDIX.midi2ms_score(open(f, 'rb').read())\n",
        "\n",
        "# INSTRUMENTS CONVERSION CYCLE\n",
        "events_matrix = []\n",
        "melody_chords_f = []\n",
        "melody_chords_f1 = []\n",
        "\n",
        "itrack = 1\n",
        "\n",
        "patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "patch_map = [\n",
        "            [0, 1, 2, 3, 4, 5, 6, 7], # Piano \n",
        "            [24, 25, 26, 27, 28, 29, 30], # Guitar\n",
        "            [32, 33, 34, 35, 36, 37, 38, 39], # Bass\n",
        "            [40, 41], # Violin\n",
        "            [42, 43], # Cello\n",
        "            [46], # Harp\n",
        "            [56, 57, 58, 59, 60], # Trumpet\n",
        "            [64, 65, 66, 67, 68, 69, 70, 71], # Sax\n",
        "            [72, 73, 74, 75, 76, 77, 78], # Flute\n",
        "            [-1], # Drums\n",
        "            [52, 53], # Choir\n",
        "            [16, 17, 18, 19, 20] # Organ\n",
        "            ]\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",
        "      once = False\n",
        "\n",
        "      for p in patch_map:\n",
        "          if event[6] in p and event[3] != 9: # Except the drums\n",
        "              event[3] = patch_map.index(p)\n",
        "              once = True\n",
        "\n",
        "      if not once and event[3] != 9: # Except the drums\n",
        "          event[3] = 15 # All other instruments/patches channel\n",
        "          event[5] = max(80, event[5])\n",
        "\n",
        "      if event[3] < 12: # We won't write chans 12-16 for now...\n",
        "          events_matrix1.append(event)\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",
        "\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] / 10) # Max 1 seconds for start-times\n",
        "      e[2] = int(e[2] / 20) # Max 2 seconds for durations\n",
        "\n",
        "  # Sorting by pitch, then by start-time\n",
        "  events_matrix1.sort(key=lambda x: x[4], reverse=True)\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",
        "    if e[1] >= 0 and e[2] > 0:\n",
        "\n",
        "      # Cliping all values...\n",
        "      tim = max(0, min(127, e[1]-pe[1]))             \n",
        "      dur = max(1, min(127, e[2]))\n",
        "      cha = max(0, min(11, e[3]))\n",
        "      ptc = max(1, min(127, e[4]))\n",
        "      vel = max(8, min(127, e[5]))\n",
        "\n",
        "      velocity = round(vel / 15)\n",
        "\n",
        "      # Writing final note \n",
        "      melody_chords.append([tim, dur, cha, ptc, velocity])\n",
        "\n",
        "      pe = e\n",
        "\n",
        "instruments_list = list(set([y[2] for y in melody_chords]))\n",
        "num_instr = len(instruments_list)\n",
        "\n",
        "#=======================================================\n",
        "# FINAL PROCESSING\n",
        "#=======================================================\n",
        "\n",
        "# Break between compositions / Intro seq\n",
        "\n",
        "if 9 in instruments_list:\n",
        "  drums_present = 2818 # Yes\n",
        "else:\n",
        "  drums_present = 2817 # No\n",
        "\n",
        "melody_chords_f.extend([2816, drums_present, 2819+(num_instr-1)])\n",
        "\n",
        "#=======================================================\n",
        "\n",
        "# Composition control seq\n",
        "intro_mode_time = statistics.mode([0] + [y[0] for y in melody_chords if y[2] != 9 and y[0] != 0])\n",
        "intro_mode_dur = statistics.mode([y[1] for y in melody_chords if y[2] != 9])\n",
        "intro_mode_pitch = statistics.mode([y[3] for y in melody_chords if y[2] != 9])\n",
        "intro_mode_velocity = statistics.mode([y[4] for y in melody_chords if y[2] != 9])\n",
        "\n",
        "# Instrument value 12 is reserved for composition control seq\n",
        "intro_dur_vel = (intro_mode_dur * 8) + (intro_mode_velocity-1)\n",
        "intro_cha_ptc = (12 * 128) + intro_mode_pitch\n",
        "\n",
        "melody_chords_f.extend([intro_mode_time, intro_dur_vel+128, intro_cha_ptc+1152])\n",
        "\n",
        "# TOTAL DICTIONARY SIZE 2831\n",
        "\n",
        "#=======================================================\n",
        "# MAIN PROCESSING CYCLE\n",
        "#=======================================================\n",
        "\n",
        "for m in melody_chords:\n",
        "\n",
        "  # WRITING EACH NOTE HERE\n",
        "  dur_vel = (m[1] * 8) + (m[4]-1)\n",
        "  cha_ptc = (m[2] * 128) + m[3]\n",
        "\n",
        "  melody_chords_f.extend([m[0], dur_vel+128, cha_ptc+1152])\n",
        "  melody_chords_f1.append([m[0], dur_vel+128, cha_ptc+1152])\n",
        "\n",
        "#=======================================================\n",
        "  \n",
        "song = melody_chords_f\n",
        "song_f = []\n",
        "tim = 0\n",
        "dur = 0\n",
        "vel = 0\n",
        "pitch = 0\n",
        "channel = 0\n",
        "\n",
        "son = []\n",
        "song1 = []\n",
        "\n",
        "for s in song:\n",
        "  if s >= 128 and s < (12*128)+1152:\n",
        "    son.append(s)\n",
        "  else:\n",
        "    if len(son) == 3:\n",
        "      song1.append(son)\n",
        "    son = []\n",
        "    son.append(s)\n",
        "                \n",
        "for ss in song1:\n",
        "\n",
        "  tim += ss[0] * 10\n",
        "\n",
        "  dur = ((ss[1]-128) // 8) * 20\n",
        "  vel = (((ss[1]-128) % 8)+1) * 15\n",
        "\n",
        "  channel = (ss[2]-1152) // 128\n",
        "  pitch = (ss[2]-1152) % 128\n",
        "                  \n",
        "  song_f.append(['note', tim, dur, channel, pitch, vel ])\n",
        "\n",
        "detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                      output_signature = 'Los Angeles Music Composer',  \n",
        "                                                      output_file_name = '/content/Los-Angeles-Music-Composer-Seed-Composition',\n",
        "                                                      track_name='Project Los Angeles',\n",
        "                                                      list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                      number_of_ticks_per_quarter=500)\n",
        "    \n",
        "#=======================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Composition stats:')\n",
        "print('Composition has', len(melody_chords_f1), 'notes')\n",
        "print('Composition has', len(melody_chords_f), 'tokens')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/Los-Angeles-Music-Composer-Seed-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\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",
        "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",
        "\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": "code",
      "source": [
        "#@title Improv Generation\n",
        "\n",
        "number_of_tokens_tp_generate = 1024 #@param {type:\"slider\", min:32, max:4064, step:32}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "\n",
        "#@markdown Use custom MIDI sequences if you want to have model try to mimic custom MIDI composition. Or you can specify your own, completely custom sequence for the model to use\n",
        "\n",
        "start_improv_sequence_type = \"user_defined_seq\" #@param [\"custom_MIDI_instruments_seq\", \"custom_MIDI_instruments_and_composition_seq\", \"user_defined_seq\"]\n",
        "\n",
        "#@markdown Specify user-defined improv sequence below\n",
        "\n",
        "drums_present_or_not = True #@param {type:\"boolean\"}\n",
        "number_of_instruments = 4 #@param {type:\"slider\", min:1, max:12, step:1}\n",
        "\n",
        "#@markdown NOTE: If you want to specify composition seq, you must specify all four parameters. All four parameters must be > 0\n",
        "\n",
        "desired_time = 0 #@param {type:\"slider\", min:0, max:127, step:1}\n",
        "desired_duration = 0 #@param {type:\"slider\", min:0, max:127, step:1}\n",
        "desired_pitch = 0 #@param {type:\"slider\", min:0, max:127, step:1}\n",
        "desired_velocity = 0 #@param {type:\"slider\", min:0, max:8, step:1}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "allow_model_to_stop_generation_if_needed = False #@param {type:\"boolean\"}\n",
        "temperature = 1 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Los Angeles Music Composer Improv Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if allow_model_to_stop_generation_if_needed:\n",
        "  min_stop_token = 2816\n",
        "else:\n",
        "  min_stop_token = 0\n",
        "\n",
        "if start_improv_sequence_type == 'custom_MIDI_instruments_seq':\n",
        "  outy = melody_chords_f[:3]\n",
        "\n",
        "if start_improv_sequence_type == 'custom_MIDI_instruments_and_composition_seq':\n",
        "  outy = melody_chords_f[:6]\n",
        "\n",
        "if start_improv_sequence_type == 'user_defined_seq':\n",
        "  if drums_present_or_not:\n",
        "    drumsp = 1\n",
        "  else:\n",
        "    drumsp = 0\n",
        "\n",
        "  outy = [2816, 2817+drumsp, 2819+((number_of_instruments)-1)]\n",
        "  test_info = [desired_time, desired_duration, desired_pitch, desired_velocity]\n",
        "\n",
        "  if 0 not in test_info:\n",
        "    dur_vel = (desired_duration * 8) + (desired_velocity-1)\n",
        "    cha_ptc = (12 * 128) + desired_pitch\n",
        "    \n",
        "    outy.extend([desired_time, dur_vel+128, cha_ptc+1152])\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",
        "#start_time = time()\n",
        "\n",
        "out = model.module.generate(inp, \n",
        "                      number_of_tokens_tp_generate, \n",
        "                      temperature=temperature, \n",
        "                      return_prime=True, \n",
        "                      min_stop_token=min_stop_token, \n",
        "                      verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "#print('Generation took', time() - start_time, \"seconds\")\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\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",
        "      tim = 0\n",
        "      dur = 0\n",
        "      vel = 0\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "\n",
        "      son = []\n",
        "      song1 = []\n",
        "\n",
        "      for s in song:\n",
        "        if s >= 128 and s < (12*128)+1152:\n",
        "          son.append(s)\n",
        "        else:\n",
        "          if len(son) == 3:\n",
        "            song1.append(son)\n",
        "          son = []\n",
        "          son.append(s)\n",
        "                      \n",
        "      for ss in song1:\n",
        "\n",
        "        tim += ss[0] * 10\n",
        "\n",
        "        dur = (((ss[1]-128) // 8)+1) * 20\n",
        "        vel = (((ss[1]-128) % 8)+1) * 15\n",
        "    \n",
        "        channel = (ss[2]-1152) // 128\n",
        "        pitch = (ss[2]-1152) % 128\n",
        "                        \n",
        "        song_f.append(['note', tim, dur, channel, pitch, vel ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Los Angeles Music Composer',  \n",
        "                                                          output_file_name = '/content/Los-Angeles-Music-Composer-Music-Composition_'+str(i), \n",
        "                                                          track_name='Project Los Angeles',\n",
        "                                                          list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Los-Angeles-Music-Composer-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\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",
        "      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",
        "\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": "code",
      "execution_count": null,
      "metadata": {
        "id": "dkvXYwR_qSnx",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Standard/Simple Continuation\n",
        "\n",
        "number_of_prime_tokens = 512 #@param {type:\"slider\", min:4, max:3072, step:4}\n",
        "number_of_tokens_to_generate = 1024 #@param {type:\"slider\", min:32, max:4096, step:32}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "include_prime_tokens_in_generated_output = True #@param {type:\"boolean\"}\n",
        "allow_model_to_stop_generation_if_needed = False #@param {type:\"boolean\"}\n",
        "temperature = 1 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Los Angeles Music Composer Standard Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if allow_model_to_stop_generation_if_needed:\n",
        "  min_stop_token = 2816\n",
        "else:\n",
        "  min_stop_token = 0\n",
        "\n",
        "outy = melody_chords_f[:number_of_prime_tokens]\n",
        "\n",
        "inp = [outy] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "#start_time = time()\n",
        "\n",
        "out = model.module.generate(inp, \n",
        "                      number_of_tokens_to_generate, \n",
        "                      temperature=temperature, \n",
        "                      return_prime=include_prime_tokens_in_generated_output, \n",
        "                      min_stop_token=min_stop_token, \n",
        "                      verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "#print('Generation took', time() - start_time, \"seconds\")\n",
        "#print('=' * 70)\n",
        "#======================================================================\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\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",
        "      tim = 0\n",
        "      dur = 0\n",
        "      vel = 0\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "\n",
        "      son = []\n",
        "      song1 = []\n",
        "\n",
        "      for s in song:\n",
        "        if s >= 128 and s < (12*128)+1152:\n",
        "          son.append(s)\n",
        "        else:\n",
        "          if len(son) == 3:\n",
        "            song1.append(son)\n",
        "          son = []\n",
        "          son.append(s)\n",
        "                      \n",
        "      for ss in song1:\n",
        "\n",
        "        tim += ss[0] * 10\n",
        "\n",
        "        dur = ((ss[1]-128) // 8) * 20\n",
        "        vel = (((ss[1]-128) % 8)+1) * 15\n",
        "    \n",
        "        channel = (ss[2]-1152) // 128\n",
        "        pitch = (ss[2]-1152) % 128\n",
        "                        \n",
        "        song_f.append(['note', tim, dur, channel, pitch, vel ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Los Angeles Music Composer',  \n",
        "                                                          output_file_name = '/content/Los-Angeles-Music-Composer-Music-Composition_'+str(i), \n",
        "                                                          track_name='Project Los Angeles',\n",
        "                                                          list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Los-Angeles-Music-Composer-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\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",
        "      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",
        "\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": [
        "# (INPAINT)"
      ],
      "metadata": {
        "id": "jUdZ93-K9ABR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Pitches/Instruments Inpainting\n",
        "number_of_prime_notes = 16 #@param {type:\"slider\", min:0, max:128, step:1}\n",
        "temperature = 1 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Los Angeles Music Composer Standard Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "out2 = []\n",
        "\n",
        "for m in melody_chords_f1[:number_of_prime_notes]:\n",
        "  out2.extend(m)\n",
        "\n",
        "for i in tqdm.tqdm(range(number_of_prime_notes, len(melody_chords_f1))):\n",
        "\n",
        "  out2.extend(melody_chords_f1[i][:2])\n",
        "\n",
        "  inp = torch.LongTensor(out2).cuda()\n",
        "\n",
        "  out1 = model.module.generate(inp[None, ...], \n",
        "                        1, \n",
        "                        temperature=temperature, \n",
        "                        return_prime=False, \n",
        "                        verbose=False)\n",
        "  \n",
        "  out2.extend(out1[0].tolist())\n",
        "\n",
        "print('=' * 70)\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",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    son = []\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s >= 128 and s < (12*128)+1152:\n",
        "        son.append(s)\n",
        "      else:\n",
        "        if len(son) == 3:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "                    \n",
        "    for ss in song1:\n",
        "\n",
        "      time += ss[0] * 10\n",
        "\n",
        "      dur = ((ss[1]-128) // 8) * 20\n",
        "      vel = (((ss[1]-128) % 8)+1) * 15\n",
        "   \n",
        "      channel = (ss[2]-1152) // 128\n",
        "      pitch = (ss[2]-1152) % 128\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 = 'Los Angeles Music Composer',  \n",
        "                                                        output_file_name = '/content/Los-Angeles-Music-Composer-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Los-Angeles-Music-Composer-Music-Composition'\n",
        "\n",
        "    x = []\n",
        "    y =[]\n",
        "    c = []\n",
        "\n",
        "    colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\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",
        "    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",
        "\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": [
        "# (HARMONIZE)"
      ],
      "metadata": {
        "id": "-ljIsqzx0jwr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Melody Harmonization\n",
        "\n",
        "melody_instrument = \"Flute\" #@param [\"Piano\", \"Guitar\", \"Bass\", \"Violin\", \"Cello\", \"Harp\", \"Trumpet\", \"Clarinet\", \"Flute\", \"Choir\", \"Organ\"]\n",
        "melody_length_in_notes = 48 #@param {type:\"slider\", min:16, max:512, step:16}\n",
        "number_of_prime_notes = 0 #@param {type:\"slider\", min:0, max:32, step:1}\n",
        "number_of_generation_attempts_per_melody_note = 16 #@param {type:\"slider\", min:1, max:64, step:1}\n",
        "temperature = 1 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Los Angeles Music Composer Advanced Melody Harmonization Model Generator')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Extracting melody...')\n",
        "#=======================================================\n",
        "\n",
        "instruments_list = [\"Piano\", \"Guitar\", \"Bass\", \"Violin\", \"Cello\", \"Harp\", \"Trumpet\", \"Clarinet\", \"Flute\", 'Drums', \"Choir\", \"Organ\"]\n",
        "melody_instrument_number = instruments_list.index(melody_instrument)\n",
        "\n",
        "melody = []\n",
        "pe = events_matrix1[0]\n",
        "\n",
        "for e in events_matrix1:\n",
        "    if e[3] != 9:\n",
        "\n",
        "      # Cliping all values...\n",
        "      tim = max(0, min(127, e[1]-pe[1]))\n",
        "      dur = max(1, min(127, e[2]))\n",
        "      cha = max(0, min(11, e[3]))\n",
        "      ptc = max(1, min(127, e[4]))\n",
        "      vel = max(8, min(127, e[5]))\n",
        "\n",
        "      velocity = round(vel / 15)\n",
        "\n",
        "      \n",
        "      # WRITING EACH NOTE HERE\n",
        "      dur_vel = (dur * 8) + (velocity-1)\n",
        "      cha_ptc = (melody_instrument_number * 128) + ptc\n",
        "\n",
        "      if tim != 0:\n",
        "        melody.append([tim, dur_vel+128, cha_ptc+1152])\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)*4, 'tokens')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Starting harmonization...')\n",
        "print('=' * 70)\n",
        "\n",
        "inp = []\n",
        "\n",
        "for m in melody[:number_of_prime_notes]:\n",
        "  inp.extend(m)\n",
        "\n",
        "#start_time = time()\n",
        "chord_time = 0\n",
        "\n",
        "for i in tqdm.tqdm(range(number_of_prime_notes, len(melody[:melody_length_in_notes])-1)):\n",
        "\n",
        "  next_note_time = melody[i+1][0]\n",
        "\n",
        "  if i > 0:\n",
        "    melody[i][0] = abs(melody[i][0] - pct)\n",
        "\n",
        "  inp.extend(melody[i])\n",
        "\n",
        "  inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "  chord_time = 0\n",
        "  count = 0\n",
        "\n",
        "  while chord_time < next_note_time and count < number_of_generation_attempts_per_melody_note:\n",
        "   \n",
        "    out1 = model.module.generate(inp[None, ...], \n",
        "                          3, \n",
        "                          temperature=temperature, \n",
        "                          return_prime=False, \n",
        "                          verbose=False)\n",
        "    \n",
        "    inp = torch.cat((inp, out1[0]))\n",
        "\n",
        "    pct = chord_time\n",
        "\n",
        "    count += 1\n",
        "\n",
        "    if out1[0][0] < 128:\n",
        "      \n",
        "      chord_time += out1[0][0].item()\n",
        "\n",
        "  inp = inp[:-3].tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "#print('Generation took', time() - start_time, \"seconds\")\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\n",
        "\n",
        "out1 = inp\n",
        "\n",
        "print('Sample INTs', out1[:12])\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",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s >= 128 and s < (12*128)+1152:\n",
        "        son.append(s)\n",
        "      else:\n",
        "        if len(son) == 3:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "                    \n",
        "    for ss in song1:\n",
        "\n",
        "      time += ss[0] * 10\n",
        "\n",
        "      dur = ((ss[1]-128) // 8) * 20\n",
        "      vel = (((ss[1]-128) % 8)+1) * 15\n",
        "   \n",
        "      channel = (ss[2]-1152) // 128\n",
        "      pitch = (ss[2]-1152) % 128\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 = 'Los Angeles Music Composer',  \n",
        "                                                        output_file_name = '/content/Los-Angeles-Music-Composer-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Los-Angeles-Music-Composer-Music-Composition'\n",
        "\n",
        "    x = []\n",
        "    y =[]\n",
        "    c = []\n",
        "\n",
        "    colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\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",
        "    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",
        "\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": "tGviAhtH0nOb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Congrats! You did it! :)"
      ],
      "metadata": {
        "id": "eoWDEy6CwDr6"
      }
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "private_outputs": true,
      "provenance": []
    },
    "gpuClass": "premium",
    "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.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}