Allegro_Music_Transformer_Composer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Allegro Music Transformer Composer (ver. 5.0)\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/Allegro-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\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 Allegro Music Transformer modules...')\n",
        "\n",
        "import os\n",
        "import pickle\n",
        "import random\n",
        "import secrets\n",
        "import statistics\n",
        "import tqdm\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading main Allegro Music Transformer modules...')\n",
        "import torch\n",
        "\n",
        "%cd /content/Allegro-Music-Transformer\n",
        "\n",
        "import TMIDIX\n",
        "from x_transformer import *\n",
        "\n",
        "%cd /content/\n",
        "print('=' * 70)\n",
        "print('Loading aux Allegro Music 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": "markdown",
      "source": [
        "# Choose one and do not forget to restart colab runtime if switching between models"
      ],
      "metadata": {
        "id": "sSErY0WdaSYs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Load Allegro Music Transformer Tiny Model (FAST)\n",
        "\n",
        "#@markdown Very fast model, 16 layers, 225k MIDIs training corpus\n",
        "\n",
        "full_path_to_model_checkpoint = \"/content/Allegro-Music-Transformer/Models/Tiny/Allegro_Music_Transformer_Tiny_Trained_Model_80000_steps_0.9457_loss_0.7443_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",
        "plot_tokens_embeddings = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Allegro Music Transformer Tiny 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/Allegro-Music-Transformer',\n",
        "                  filename='Allegro_Music_Transformer_Tiny_Trained_Model_80000_steps_0.9457_loss_0.7443_acc.pth',\n",
        "                  local_dir='/content/Allegro-Music-Transformer/Models/Tiny/',\n",
        "                  local_dir_use_symlinks=False)\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 = 3088,\n",
        "    max_seq_len = SEQ_LEN,\n",
        "    attn_layers = Decoder(dim = 1024, depth = 16, 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",
        "# Plot Token Embeddings\n",
        "\n",
        "if plot_tokens_embeddings:\n",
        "\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/Allegro-Music-Transformer-Tiny-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "KjcwVEelXcYf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rDquonbXC2je",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load Allegro Music Transformer Small Model (BEST)\n",
        "\n",
        "#@markdown Fast model, 32 layers, 225k MIDIs training corpus\n",
        "\n",
        "full_path_to_model_checkpoint = \"/content/Allegro-Music-Transformer/Models/Small/Allegro_Music_Transformer_Small_Trained_Model_56000_steps_0.9399_loss_0.7374_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",
        "plot_tokens_embeddings = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Allegro Music 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/Allegro-Music-Transformer',\n",
        "                  filename='Allegro_Music_Transformer_Small_Trained_Model_56000_steps_0.9399_loss_0.7374_acc.pth',\n",
        "                  local_dir='/content/Allegro-Music-Transformer/Models/Small/',\n",
        "                  local_dir_use_symlinks=False)\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 = 3088,\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",
        "# Plot Token Embeddings\n",
        "\n",
        "if plot_tokens_embeddings:\n",
        "\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/Allegro-Music-Transformer-Small-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (LOAD SEED MIDI)"
      ],
      "metadata": {
        "id": "Gt03VtO6uKkb"
      }
    },
    {
      "cell_type": "code",
      "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\", \"Allegro-Music-Transformer-Piano-Seed-1\", \"Allegro-Music-Transformer-Piano-Seed-2\", \"Allegro-Music-Transformer-Piano-Seed-3\", \"Allegro-Music-Transformer-Piano-Seed-4\", \"Allegro-Music-Transformer-Piano-Seed-5\", \"Allegro-Music-Transformer-MI-Seed-1\", \"Allegro-Music-Transformer-MI-Seed-2\", \"Allegro-Music-Transformer-MI-Seed-3\", \"Allegro-Music-Transformer-MI-Seed-4\", \"Allegro-Music-Transformer-MI-Seed-5\"]\n",
        "number_of_prime_tokens = 300 # @param {type:\"slider\", min:128, max:5000, step:16}\n",
        "render_MIDI_to_audio = False # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Allegro 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/Allegro-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",
        "  melody_chords_f = []\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",
        "              [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",
        "  if len(events_matrix1) > 0:\n",
        "\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] / 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[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(255, 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",
        "\n",
        "            # Calculating octo-velocity\n",
        "            vel = max(8, min(127, e[5]))\n",
        "            velocity = round(vel / 15)-1\n",
        "\n",
        "            # Writing final note\n",
        "            melody_chords.append([time, dur, cha, ptc, velocity])\n",
        "\n",
        "            pe = e\n",
        "\n",
        "        times = [y[0] for y in melody_chords[12:]]\n",
        "        avg_time = sum(times) / len(times)\n",
        "\n",
        "        times_list = list(set(times))\n",
        "\n",
        "        mode_dur = statistics.mode([y[1] for y in melody_chords if y[2] != 9])\n",
        "\n",
        "        instruments_list = list(set([y[2] for y in melody_chords]))\n",
        "        num_instr = len(instruments_list)\n",
        "\n",
        "        #=======================================================\n",
        "\n",
        "        # TOTAL DICTIONARY SIZE 3087+1=3088\n",
        "\n",
        "        #=======================================================\n",
        "        # MAIN PROCESSING CYCLE\n",
        "        #=======================================================\n",
        "\n",
        "        chords_count = 0\n",
        "\n",
        "        melody_chords_f.extend([2816]) # Zero chords count\n",
        "\n",
        "        if melody_chords[0][0] == 0:\n",
        "          melody_chords_f.extend([0]) # Zero time, if present\n",
        "\n",
        "        notes_counter = 0\n",
        "        chords_counter = 0\n",
        "\n",
        "        for m in melody_chords:\n",
        "\n",
        "          time = m[0]\n",
        "\n",
        "          # Chords counter token\n",
        "          if chords_count % 50 == 0 and chords_count != 0 and time != 0:\n",
        "            melody_chords_f.extend([2816+min(255, ((chords_count // 50)))])\n",
        "\n",
        "          if time != 0:\n",
        "            chords_count += 1\n",
        "\n",
        "          # WRITING EACH NOTE HERE\n",
        "          dur_vel = (m[1] * 8) + m[4]\n",
        "          cha_ptc = (m[2] * 128) + m[3]\n",
        "\n",
        "          if time != 0:\n",
        "              melody_chords_f.extend([time, dur_vel+256, cha_ptc+1280])\n",
        "              chords_counter += 1\n",
        "\n",
        "          else:\n",
        "              melody_chords_f.extend([dur_vel+256, cha_ptc+1280])\n",
        "\n",
        "          notes_counter += 1\n",
        "\n",
        "  melody_chords_f = melody_chords_f[:number_of_prime_tokens]\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 < 256:\n",
        "\n",
        "        time += ss * 8\n",
        "\n",
        "    if ss >= 256 and ss < 1280:\n",
        "\n",
        "        dur = ((ss-256) // 8) * 32\n",
        "        vel = (((ss-256) % 8)+1) * 15\n",
        "\n",
        "    if ss >= 1280 and ss < 2816:\n",
        "        channel = (ss-1280) // 128\n",
        "        pitch = (ss-1280) % 128\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 = 'Allegro Music Transformer',\n",
        "                                                            output_file_name = '/content/Allegro-Music-Transformer-Seed-Composition',\n",
        "                                                            track_name='Project Los Angeles',\n",
        "                                                            list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 65, 73, 0, 53, 19, 0, 0, 0, 0]\n",
        "                                                            )\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Composition stats:')\n",
        "  print('Composition has', notes_counter, 'notes')\n",
        "  print('Composition has', chords_counter, 'chords')\n",
        "  print('Composition has', len(melody_chords_f), 'tokens')\n",
        "  print('=' * 70)\n",
        "\n",
        "  fname = '/content/Allegro-Music-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)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "XGQi15DfVU_a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (COMPOSITION LOOP)\n",
        "\n",
        "## Run the cells below in a loop to generate endless continuation"
      ],
      "metadata": {
        "id": "7xNyANjZsCOi"
      }
    },
    {
      "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:33, max:1023, step:3}\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:33, max:240, step:3}\n",
        "number_of_memory_tokens = 2048 # @param {type:\"slider\", min:402, max:2048, step:2}\n",
        "temperature = 0.9 #@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('Allegro Music Transformer Standard Continuation Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "preview = melody_chords_f[-preview_length_in_tokens:]\n",
        "\n",
        "inp = [melody_chords_f[-number_of_memory_tokens:]] * 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",
        "                              verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "\n",
        "#======================================================================\n",
        "print('=' * 70)\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 = preview + out1\n",
        "      song_f = []\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      vel = 0\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "\n",
        "      for ss in song:\n",
        "\n",
        "        if ss > 0 and ss < 256:\n",
        "\n",
        "            time += ss * 8\n",
        "\n",
        "        if ss >= 256 and ss < 1280:\n",
        "\n",
        "            dur = ((ss-256) // 8) * 32\n",
        "            vel = (((ss-256) % 8)+1) * 15\n",
        "\n",
        "        if ss >= 1280 and ss < 2816:\n",
        "            channel = (ss-1280) // 128\n",
        "            pitch = (ss-1280) % 128\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 = 'Allegro Music Transformer',\n",
        "                                                                output_file_name = '/content/Allegro-Music-Transformer-Music-Composition_'+str(i),\n",
        "                                                                track_name='Project Los Angeles',\n",
        "                                                                list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 65, 73, 0, 53, 19, 0, 0, 0, 0]\n",
        "                                                                )\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Allegro-Music-Transformer-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",
        "      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 / 3))][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), 'tokens')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Sample INTs', out1[:12])\n",
        "print('=' * 70)\n",
        "\n",
        "if len(melody_chords_f) != 0:\n",
        "\n",
        "    song = melody_chords_f\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    for ss in song:\n",
        "\n",
        "      if ss > 0 and ss < 256:\n",
        "\n",
        "          time += ss * 8\n",
        "\n",
        "      if ss >= 256 and ss < 1280:\n",
        "\n",
        "          dur = ((ss-256) // 8) * 32\n",
        "          vel = (((ss-256) % 8)+1) * 15\n",
        "\n",
        "      if ss >= 1280 and ss < 2816:\n",
        "          channel = (ss-1280) // 128\n",
        "          pitch = (ss-1280) % 128\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 = 'Allegro Music Transformer',\n",
        "                                                              output_file_name = '/content/Allegro-Music-Transformer-Music-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 65, 73, 0, 53, 19, 0, 0, 0, 0]\n",
        "                                                              )\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Allegro-Music-Transformer-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",
        "    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",
        "    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": "3YdlOR_9TdYX"
      },
      "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",
      "gpuType": "T4"
    },
    "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
}