Lars_Ulrich_Transformer_Composer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Lars Ulrich Transformer Composer (ver. 5.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/Lars-Ulrich-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\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 Lars Ulrich Transformer modules...')\n",
        "\n",
        "import os\n",
        "import copy\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 Lars Ulrich Transformer modules...')\n",
        "import torch\n",
        "\n",
        "%cd /content/Lars-Ulrich-Transformer\n",
        "\n",
        "import TMIDIX\n",
        "\n",
        "from x_transformer import *\n",
        "\n",
        "%cd /content/\n",
        "print('=' * 70)\n",
        "print('Loading aux Lars Ulrich Transformer modules...')\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",
        "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",
      "execution_count": null,
      "metadata": {
        "id": "rDquonbXC2je",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load Lars Ulrich Transformer Small Model\n",
        "\n",
        "#@markdown Fast model, 32 layers, 201k MIDIs training corpus\n",
        "\n",
        "full_path_to_model_checkpoint = \"/content/Lars-Ulrich-Transformer/Model/Lars_Ulrich_Transformer_Small_Trained_Model_51000_steps_0.5062_loss_0.8283_acc.pth\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown Model precision option\n",
        "\n",
        "model_precision = \"bfloat16\" # @param [\"bfloat16\", \"float16\", \"float32\"]\n",
        "\n",
        "#@markdown bfloat16 == Third precision/triple speed (if supported, otherwise the model will default to float16)\n",
        "\n",
        "#@markdown float16 == Half precision/double speed\n",
        "\n",
        "#@markdown float32 == Full precision/normal speed\n",
        "\n",
        "display_tokens_embeddings = True #@param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Lars Ulrich Transformer Small 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/Lars-Ulrich-Transformer',\n",
        "                  filename='Lars_Ulrich_Transformer_Small_Trained_Model_51000_steps_0.5062_loss_0.8283_acc.pth',\n",
        "                  local_dir='/content/Lars-Ulrich-Transformer/Model/',\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",
        "if model_precision == 'float32':\n",
        "  dtype = 'float32'\n",
        "\n",
        "ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]\n",
        "ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)\n",
        "\n",
        "SEQ_LEN = 2048\n",
        "\n",
        "# instantiate the model\n",
        "\n",
        "model = TransformerWrapper(\n",
        "    num_tokens = 659,\n",
        "    max_seq_len = SEQ_LEN,\n",
        "    attn_layers = Decoder(dim = 1024, depth = 32, heads = 8, attn_flash=True)\n",
        ")\n",
        "\n",
        "model = AutoregressiveWrapper(model)\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",
        "print('Model will use', dtype, 'precision...')\n",
        "print('=' * 70)\n",
        "\n",
        "# Model stats\n",
        "print('Model summary...')\n",
        "summary(model)\n",
        "\n",
        "if display_tokens_embeddings:\n",
        "  # Plot Token Embeddings\n",
        "  tok_emb = model.module.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/Lars-Ulrich-Transformer-Small-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (LOAD SEED 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\", \"Nothing Else Matters\", \"Honesty\", \"House Of The Rising Sun\", \"Sharing The Night Together\"]\n",
        "number_of_prime_tokens = 300 # @param {type:\"slider\", min:30, max:5000, step:5}\n",
        "\n",
        "#@markdown Seed MIDI controls\n",
        "\n",
        "MIDI_timings_multiplier = 1 #@param {type:\"slider\", min:0.1, max:2, step:0.1}\n",
        "MIDI_pitches_transpose_value = 0 #@param {type:\"slider\", min:-6, max:5, step:1}\n",
        "MIDI_velocities_multiplier = 1 #@param {type:\"slider\", min:0.1, max:2, step:0.1}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "render_MIDI_to_audio = False #@param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Lars Ulrich 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/Lars-Ulrich-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",
        "  melody_chords_f = []\n",
        "  melody_chords_f1 = []\n",
        "  chords = []\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",
        "  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",
        "              [16, 17, 18, 19, 20], # Organ\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",
        "              ]\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] = 0 # All other instruments/patches channel\n",
        "                  event[5] = max(80, event[5])\n",
        "\n",
        "              if event[3] < 10: # We won't write chans 12-16 for now...\n",
        "                  events_matrix1.append(event)\n",
        "\n",
        "  if len(events_matrix1) > 0:\n",
        "\n",
        "      #=======================================================\n",
        "      # PRE-PROCESSING\n",
        "\n",
        "      if len(events_matrix1) > 0:\n",
        "\n",
        "        # recalculating timings\n",
        "        for e in events_matrix1:\n",
        "            e[1] = int(e[1] / 8) # Max 2 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[4], reverse = True)\n",
        "        events_matrix1.sort(key=lambda x: x[3])\n",
        "        events_matrix1.sort(key=lambda x: x[1])\n",
        "\n",
        "        #=======================================================\n",
        "        # FINAL PRE-PROCESSING\n",
        "\n",
        "        melody_chords = []\n",
        "        melody_chords_d = []\n",
        "\n",
        "        pe = events_matrix1[0]\n",
        "        ped = events_matrix1[0]\n",
        "\n",
        "        for e in events_matrix1:\n",
        "\n",
        "            if e[3] != 9:\n",
        "\n",
        "              # Cliping all values...\n",
        "              time = max(0, min(255, int((e[1]-pe[1]) * MIDI_timings_multiplier)))\n",
        "              dur = max(1, min(127, int(e[2] * MIDI_timings_multiplier)))\n",
        "              cha = max(0, min(9, e[3]))\n",
        "              ptc = max(1, min(127, e[4] + MIDI_pitches_transpose_value))\n",
        "\n",
        "              # Shifting drums pitches\n",
        "              if cha != 9:\n",
        "                  aug_ptc = ptc\n",
        "              else:\n",
        "                  aug_ptc = ptc + 128\n",
        "\n",
        "              # Calculating octo-velocity\n",
        "              vel = max(8, min(127, int(e[5] * MIDI_velocities_multiplier)))\n",
        "              velocity = round(vel / 15)-1\n",
        "\n",
        "              # Writing final note\n",
        "              melody_chords.append([time, dur, cha, aug_ptc, velocity])\n",
        "\n",
        "              pe = e\n",
        "\n",
        "            # Cliping all values...\n",
        "            time = max(0, min(255, int((e[1]-ped[1]) * MIDI_timings_multiplier)))\n",
        "            dur = max(1, min(127, int(e[2] * MIDI_timings_multiplier)))\n",
        "            cha = max(0, min(9, e[3]))\n",
        "            ptc = max(1, min(127, e[4] + MIDI_pitches_transpose_value))\n",
        "\n",
        "            # Shifting drums pitches\n",
        "            if cha != 9:\n",
        "                aug_ptc = ptc\n",
        "            else:\n",
        "                aug_ptc = ptc + 128\n",
        "\n",
        "            # Calculating octo-velocity\n",
        "            vel = max(8, min(127, int(e[5] * MIDI_velocities_multiplier)))\n",
        "            velocity = round(vel / 15)-1\n",
        "\n",
        "            # Writing final note\n",
        "            melody_chords_d.append([time, dur, cha, aug_ptc, velocity])\n",
        "\n",
        "            ped = e\n",
        "\n",
        "        #=======================================================\n",
        "        # FINAL PROCESSING\n",
        "        #=======================================================\n",
        "\n",
        "        # Break between compositions / Intro seq\n",
        "\n",
        "        melody_chords_f.extend([658, 658, 658, 658, 658])\n",
        "\n",
        "        #=======================================================\n",
        "\n",
        "        # TOTAL DICTIONARY SIZE 658+1=659\n",
        "\n",
        "        #=======================================================\n",
        "        # MAIN PROCESSING CYCLE\n",
        "        #=======================================================\n",
        "\n",
        "        for m in melody_chords_d:\n",
        "\n",
        "            # WRITING EACH NOTE HERE\n",
        "            time = m[0]\n",
        "            dur = m[1]\n",
        "            cha = m[2]\n",
        "            ptc = m[3]\n",
        "            vel = m[4]\n",
        "\n",
        "            melody_chords_f.extend([cha, time+10, dur+266, ptc+394, vel+650])\n",
        "            melody_chords_f1.append([cha, time+10, dur+266, ptc+394, vel+650])\n",
        "\n",
        "        cho = []\n",
        "\n",
        "        for m in melody_chords:\n",
        "\n",
        "            # WRITING EACH CHORD HERE\n",
        "            time = m[0]\n",
        "            dur = m[1]\n",
        "            cha = m[2]\n",
        "            ptc = m[3]\n",
        "            vel = m[4]\n",
        "\n",
        "            if time == 0:\n",
        "              cho.append([cha, time+10, dur+266, ptc+394, vel+650])\n",
        "            else:\n",
        "              if len(cho) > 0:\n",
        "                chords.append(cho)\n",
        "              cho = []\n",
        "              cho.append([cha, time+10, dur+266, ptc+394, vel+650])\n",
        "\n",
        "        if len(cho) > 0:\n",
        "            chords.append(cho)\n",
        "  #=======================================================\n",
        "\n",
        "  melody_chords_f1 = melody_chords_f1[:(number_of_prime_tokens // 5)]\n",
        "  melody_chords_f = melody_chords_f[:number_of_prime_tokens]\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  print('Composition stats:')\n",
        "  print('Composition has', len(melody_chords_f1), 'notes')\n",
        "  print('Composition has', len([y for y in melody_chords_d if y[0] != 0]), 'chords')\n",
        "  print('Composition has', len(melody_chords_f), 'tokens')\n",
        "  print('=' * 70)\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  song = melody_chords_f\n",
        "\n",
        "  song_f = []\n",
        "\n",
        "  time = 0\n",
        "  dur = 0\n",
        "  vel = 90\n",
        "  pitch = 0\n",
        "  channel = 0\n",
        "\n",
        "  for ss in song:\n",
        "\n",
        "    if ss >= 0 and ss < 10:\n",
        "\n",
        "        channel = ss\n",
        "\n",
        "    if ss >= 10 and ss < 266:\n",
        "\n",
        "        time += (ss-10) * 8\n",
        "\n",
        "    if ss >= 266 and ss < 394:\n",
        "\n",
        "        dur = (ss-266) * 32\n",
        "\n",
        "    if ss >= 394 and ss < 650:\n",
        "\n",
        "        pitch = ((ss-394) % 128)\n",
        "\n",
        "    if ss >= 650 and ss < 658:\n",
        "\n",
        "        vel = ((ss-650)+1) * 15\n",
        "\n",
        "        song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "  detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                            output_signature = 'Lars Ulrich Transformer',\n",
        "                                                            output_file_name = '/content/Lars-Ulrich-Transformer-Seed-Composition',\n",
        "                                                            track_name='Project Los Angeles',\n",
        "                                                            list_of_MIDI_patches=[0, 24, 32, 40, 42, 19, 56, 65, 73, 0, 0, 0, 0, 0, 0, 0],\n",
        "                                                            )\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  print('Displaying resulting composition...')\n",
        "  print('=' * 70)\n",
        "\n",
        "  fname = '/content/Lars-Ulrich-Transformer-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",
        "  block_lines = [(song_f[-1][1] / 1000)]\n",
        "  block_tokens = [min(len(melody_chords_f), number_of_prime_tokens)]\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",
        "    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()\n",
        "\n",
        "else:\n",
        "  print('=' * 70)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (COMPOSITION LOOP)\n",
        "\n",
        "## Run the cells below in a loop to generate endless continuation"
      ],
      "metadata": {
        "id": "LgLmg-ra-XBc"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dkvXYwR_qSnx",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Standard Continuation Generator\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "number_of_tokens_to_generate = 300 # @param {type:\"slider\", min:30, max:1025, step:5}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "preview_length_in_tokens = 120 # @param {type:\"slider\", min:30, max:250, step:5}\n",
        "number_of_memory_tokens = 2045 #@param {type:\"slider\", min:400, max:2045, step:5}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "render_MIDI_to_audio = True #@param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Lars Ulrich Standard Continuation Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "preview = melody_chords_f[-preview_length_in_tokens:]\n",
        "\n",
        "mel_cho = melody_chords_f[-number_of_memory_tokens:]\n",
        "\n",
        "inp = [mel_cho] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "with ctx:\n",
        "  out = model.module.generate(inp,\n",
        "                              number_of_tokens_to_generate,\n",
        "                              temperature=temperature,\n",
        "                              return_prime=False,\n",
        "                              eos_token=None,\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[:10])\n",
        "  print('=' * 70)\n",
        "\n",
        "  if len(out) != 0:\n",
        "\n",
        "      song = preview + out1\n",
        "      song_f = []\n",
        "\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      channel = 0\n",
        "      pitch = 0\n",
        "      vel = 90\n",
        "\n",
        "      for ss in song:\n",
        "\n",
        "        if ss >= 0 and ss < 10:\n",
        "\n",
        "            channel = ss\n",
        "\n",
        "        if ss >= 10 and ss < 266:\n",
        "\n",
        "            time += (ss-10) * 8\n",
        "\n",
        "        if ss >= 266 and ss < 394:\n",
        "\n",
        "            dur = (ss-266) * 32\n",
        "\n",
        "        if ss >= 394 and ss < 650:\n",
        "\n",
        "            pitch = ((ss-394) % 128)\n",
        "\n",
        "        if ss >= 650 and ss < 658:\n",
        "\n",
        "            vel = ((ss-650)+1) * 15\n",
        "\n",
        "            song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                                output_signature = 'Lars Ulrich Transformer',\n",
        "                                                                output_file_name = '/content/Lars-Ulrich-Transformer-Composition_'+str(i),\n",
        "                                                                track_name='Project Los Angeles',\n",
        "                                                                list_of_MIDI_patches=[0, 24, 32, 40, 42, 19, 56, 65, 73, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                                )\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Lars-Ulrich-Transformer-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",
        "      if render_MIDI_to_audio:\n",
        "        FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "        display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\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",
        "\n",
        "      pbl = song_f[(int(preview_length_in_tokens / 5))][1] / 1000\n",
        "\n",
        "      ax.axvline(x=pbl, c='w')\n",
        "\n",
        "      plt.xlabel(\"Time\")\n",
        "      plt.ylabel(\"Pitch\")\n",
        "      plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Choose one generated block to add to the composition\n",
        "block_action = \"add_last_generated_block\" #@param [\"add_last_generated_block\", \"remove_last_added_block\"]\n",
        "add_block_with_batch_number = 0 #@param {type:\"slider\", min:0, max:15, step:1}\n",
        "render_MIDI_to_audio = False #@param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if block_action == 'add_last_generated_block':\n",
        "  melody_chords_f.extend(out0[min(len(out0)-1, add_block_with_batch_number)])\n",
        "  print('Block added!')\n",
        "else:\n",
        "  if len(block_tokens) > 1:\n",
        "    melody_chords_f = melody_chords_f[:(len(melody_chords_f)-block_tokens[-1])]\n",
        "    print('Block removed!')\n",
        "  else:\n",
        "    print('Nothing to remove!!!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Composition now has', (len(melody_chords_f) // 5), 'notes')\n",
        "print('Composition now has', len(melody_chords_f), 'tokens')\n",
        "\n",
        "\n",
        "print('=' * 70)\n",
        "print('Sample INTs', out1[:10])\n",
        "print('=' * 70)\n",
        "\n",
        "if len(melody_chords_f) != 0:\n",
        "\n",
        "    song = melody_chords_f\n",
        "    song_f = []\n",
        "\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    channel = 0\n",
        "    pitch = 0\n",
        "    vel = 90\n",
        "\n",
        "    for ss in song:\n",
        "\n",
        "      if ss >= 0 and ss < 10:\n",
        "\n",
        "          channel = ss\n",
        "\n",
        "      if ss >= 10 and ss < 266:\n",
        "\n",
        "          time += (ss-10) * 8\n",
        "\n",
        "      if ss >= 266 and ss < 394:\n",
        "\n",
        "          dur = (ss-266) * 32\n",
        "\n",
        "      if ss >= 394 and ss < 650:\n",
        "\n",
        "          pitch = ((ss-394) % 128)\n",
        "\n",
        "      if ss >= 650 and ss < 658:\n",
        "\n",
        "          vel = ((ss-650)+1) * 15\n",
        "\n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'Lars Ulrich Transformer',\n",
        "                                                              output_file_name = '/content/Lars-Ulrich-Transformer-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 24, 32, 40, 42, 19, 56, 65, 73, 0, 0, 0, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Lars-Ulrich-Transformer-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",
        "    if block_action == 'add_last_generated_block':\n",
        "      block_lines.append((song_f[-1][1] / 1000))\n",
        "      block_tokens.append(len(out0[min(len(out0)-1, add_block_with_batch_number)]))\n",
        "\n",
        "    else:\n",
        "      if len(block_tokens) > 1:\n",
        "        block_lines.pop()\n",
        "        block_tokens.pop()\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",
        "      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",
        "\n",
        "    for bl in block_lines:\n",
        "      ax.axvline(x=bl, c='w')\n",
        "\n",
        "    plt.xlabel(\"Time\")\n",
        "    plt.ylabel(\"Pitch\")\n",
        "    plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "UZOwwHjRCFnR"
      },
      "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
}