Quad_Music_Transformer_Composer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Quad Music Transformer Composer (ver. 1.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 2024\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/Quad-Music-Transformer\n",
        "!pip install huggingface_hub\n",
        "!pip install einops\n",
        "!pip install torch-summary\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DzCOZU_gBiQV",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Import modules\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading core Quad Music Transformer modules...')\n",
        "\n",
        "import os\n",
        "import pickle\n",
        "import secrets\n",
        "import statistics\n",
        "from time import time\n",
        "import tqdm\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading main Quad Music Transformer modules...')\n",
        "import torch\n",
        "\n",
        "%cd /content/Quad-Music-Transformer\n",
        "\n",
        "import TMIDIX\n",
        "\n",
        "from midi_to_colab_audio import midi_to_colab_audio\n",
        "\n",
        "from x_transformer_1_23_2 import *\n",
        "\n",
        "import random\n",
        "\n",
        "%cd /content/\n",
        "print('=' * 70)\n",
        "print('Loading aux Quad Music Transformer modules...')\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from torchsummary import summary\n",
        "from sklearn import metrics\n",
        "\n",
        "from IPython.display import Audio, display\n",
        "\n",
        "from huggingface_hub import hf_hub_download\n",
        "\n",
        "from google.colab import files\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('Enjoy! :)')\n",
        "print('=' * 70)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eI3aQtHzqSnp"
      },
      "source": [
        "# (LOAD MODEL)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rDquonbXC2je",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load Quad Music Transformer Pre-Trained Model\n",
        "\n",
        "#@markdown Model precision option\n",
        "\n",
        "model_precision = \"bfloat16\" # @param [\"bfloat16\", \"float16\"]\n",
        "\n",
        "#@markdown bfloat16 == Half precision/faster speed (if supported, otherwise the model will default to float16)\n",
        "\n",
        "#@markdown float16 == Full precision/fast speed\n",
        "\n",
        "plot_tokens_embeddings = False # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading Quad Music Transformer Pre-Trained Model...')\n",
        "print('Please wait...')\n",
        "print('=' * 70)\n",
        "\n",
        "full_path_to_models_dir = \"/content/Quad-Music-Transformer/Model/Optimized\"\n",
        "\n",
        "model_checkpoint_file_name = 'Quad_Music_Transformer_Large_Optimized_Trained_Model_47708_steps_0.7875_loss_0.7387_acc.pth'\n",
        "model_path = full_path_to_models_dir+'/'+model_checkpoint_file_name\n",
        "num_layers = 16\n",
        "\n",
        "if os.path.isfile(model_path):\n",
        "  print('Model already exists...')\n",
        "\n",
        "else:\n",
        "  hf_hub_download(repo_id='asigalov61/Quad-Music-Transformer',\n",
        "                  filename=model_checkpoint_file_name,\n",
        "                  local_dir='/content/Quad-Music-Transformer/Model/Optimized',\n",
        "                  local_dir_use_symlinks=False)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Instantiating model...')\n",
        "\n",
        "device_type = 'cuda'\n",
        "\n",
        "if model_precision == 'bfloat16' and torch.cuda.is_bf16_supported():\n",
        "  dtype = 'bfloat16'\n",
        "else:\n",
        "  dtype = 'float16'\n",
        "\n",
        "if model_precision == 'float16':\n",
        "  dtype = 'float16'\n",
        "\n",
        "ptdtype = {'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]\n",
        "ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)\n",
        "\n",
        "SEQ_LEN = 8192\n",
        "\n",
        "# instantiate the model\n",
        "\n",
        "model = TransformerWrapper(\n",
        "    num_tokens = 2598,\n",
        "    max_seq_len = SEQ_LEN,\n",
        "    attn_layers = Decoder(dim = 2048, depth = num_layers, heads = 16, attn_flash = True)\n",
        ")\n",
        "\n",
        "model = AutoregressiveWrapper(model, ignore_index=2597)\n",
        "\n",
        "model.cuda()\n",
        "print('=' * 70)\n",
        "\n",
        "print('Loading model checkpoint...')\n",
        "\n",
        "model.load_state_dict(torch.load(model_path))\n",
        "print('=' * 70)\n",
        "\n",
        "model.eval()\n",
        "\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Model will use', dtype, 'precision...')\n",
        "print('=' * 70)\n",
        "\n",
        "# Model stats\n",
        "print('Model summary...')\n",
        "summary(model)\n",
        "\n",
        "# Plot Token Embeddings\n",
        "if plot_tokens_embeddings:\n",
        "  tok_emb = model.net.token_emb.emb.weight.detach().cpu().tolist()\n",
        "\n",
        "  cos_sim = metrics.pairwise_distances(\n",
        "    tok_emb, metric='cosine'\n",
        "  )\n",
        "  plt.figure(figsize=(7, 7))\n",
        "  plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"nearest\")\n",
        "  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]\n",
        "  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)\n",
        "  plt.xlabel(\"Position\")\n",
        "  plt.ylabel(\"Position\")\n",
        "  plt.tight_layout()\n",
        "  plt.plot()\n",
        "  plt.savefig(\"/content/Quad-Music-Transformer-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (SETUP MODEL CHANNELS MIDI PATCHES)"
      ],
      "metadata": {
        "id": "pwTTaPAXcERl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Setup and load model channels MIDI patches\n",
        "\n",
        "model_channel_0_piano_family = \"Acoustic Grand\" # @param [\"Acoustic Grand\", \"Bright Acoustic\", \"Electric Grand\", \"Honky-Tonk\", \"Electric Piano 1\", \"Electric Piano 2\", \"Harpsichord\", \"Clav\"]\n",
        "model_channel_1_chromatic_percussion_family = \"Music Box\" # @param [\"Celesta\", \"Glockenspiel\", \"Music Box\", \"Vibraphone\", \"Marimba\", \"Xylophone\", \"Tubular Bells\", \"Dulcimer\"]\n",
        "model_channel_2_organ_family = \"Church Organ\" # @param [\"Drawbar Organ\", \"Percussive Organ\", \"Rock Organ\", \"Church Organ\", \"Reed Organ\", \"Accordion\", \"Harmonica\", \"Tango Accordion\"]\n",
        "model_channel_3_guitar_family = \"Acoustic Guitar(nylon)\" # @param [\"Acoustic Guitar(nylon)\", \"Acoustic Guitar(steel)\", \"Electric Guitar(jazz)\", \"Electric Guitar(clean)\", \"Electric Guitar(muted)\", \"Overdriven Guitar\", \"Distortion Guitar\", \"Guitar Harmonics\"]\n",
        "model_channel_4_bass_family = \"Fretless Bass\" # @param [\"Acoustic Bass\", \"Electric Bass(finger)\", \"Electric Bass(pick)\", \"Fretless Bass\", \"Slap Bass 1\", \"Slap Bass 2\", \"Synth Bass 1\", \"Synth Bass 2\"]\n",
        "model_channel_5_strings_family = \"Violin\" # @param [\"Violin\", \"Viola\", \"Cello\", \"Contrabass\", \"Tremolo Strings\", \"Pizzicato Strings\", \"Orchestral Harp\", \"Timpani\"]\n",
        "model_channel_6_ensemble_family = \"Choir Aahs\" # @param [\"String Ensemble 1\", \"String Ensemble 2\", \"SynthStrings 1\", \"SynthStrings 2\", \"Choir Aahs\", \"Voice Oohs\", \"Synth Voice\", \"Orchestra Hit\"]\n",
        "model_channel_7_brass_family = \"Trumpet\" # @param [\"Trumpet\", \"Trombone\", \"Tuba\", \"Muted Trumpet\", \"French Horn\", \"Brass Section\", \"SynthBrass 1\", \"SynthBrass 2\"]\n",
        "model_channel_8_reed_family = \"Alto Sax\" # @param [\"Soprano Sax\", \"Alto Sax\", \"Tenor Sax\", \"Baritone Sax\", \"Oboe\", \"English Horn\", \"Bassoon\", \"Clarinet\"]\n",
        "model_channel_9_pipe_family = \"Flute\" # @param [\"Piccolo\", \"Flute\", \"Recorder\", \"Pan Flute\", \"Blown Bottle\", \"Skakuhachi\", \"Whistle\", \"Ocarina\"]\n",
        "model_channel_10_synth_lead_family = \"Lead 8 (bass+lead)\" # @param [\"Lead 1 (square)\", \"Lead 2 (sawtooth)\", \"Lead 3 (calliope)\", \"Lead 4 (chiff)\", \"Lead 5 (charang)\", \"Lead 6 (voice)\", \"Lead 7 (fifths)\", \"Lead 8 (bass+lead)\"]\n",
        "model_channel_11_synth_pad_family = \"Pad 2 (warm)\" # @param [\"Pad 1 (new age)\", \"Pad 2 (warm)\", \"Pad 3 (polysynth)\", \"Pad 4 (choir)\", \"Pad 5 (bowed)\", \"Pad 6 (metallic)\", \"Pad 7 (halo)\", \"Pad 8 (sweep)\"]\n",
        "model_channel_12_synth_effects_family = \"FX 3 (crystal)\" # @param [\"FX 1 (rain)\", \"FX 2 (soundtrack)\", \"FX 3 (crystal)\", \"FX 4 (atmosphere)\", \"FX 5 (brightness)\", \"FX 6 (goblins)\", \"FX 7 (echoes)\", \"FX 8 (sci-fi)\"]\n",
        "model_channel_13_ethnic_family = \"Banjo\" # @param [\"Sitar\", \"Banjo\", \"Shamisen\", \"Koto\", \"Kalimba\", \"Bagpipe\", \"Fiddle\", \"Shanai\"]\n",
        "model_channel_14_percussive_family = \"Melodic Tom\" # @param [\"Tinkle Bell\", \"Agogo\", \"Steel Drums\", \"Woodblock\", \"Taiko Drum\", \"Melodic Tom\", \"Synth Drum\", \"Reverse Cymbal\"]\n",
        "model_channel_15_sound_effects_family = \"Bird Tweet\" # @param [\"Guitar Fret Noise\", \"Breath Noise\", \"Seashore\", \"Bird Tweet\", \"Telephone Ring\", \"Helicopter\", \"Applause\", \"Gunshot\"]\n",
        "model_channel_16_drums_family = \"Drums\" # @param [\"Drums\"]\n",
        "\n",
        "print('=' * 70)\n",
        "print('Setting up patches...')\n",
        "print('=' * 70)\n",
        "\n",
        "instruments = [v[1] for v in TMIDIX.Number2patch.items()]\n",
        "\n",
        "patches = [instruments.index(model_channel_0_piano_family),\n",
        "                       instruments.index(model_channel_1_chromatic_percussion_family),\n",
        "                       instruments.index(model_channel_2_organ_family),\n",
        "                       instruments.index(model_channel_3_guitar_family),\n",
        "                       instruments.index(model_channel_4_bass_family),\n",
        "                       instruments.index(model_channel_5_strings_family),\n",
        "                       instruments.index(model_channel_6_ensemble_family),\n",
        "                       instruments.index(model_channel_7_brass_family),\n",
        "                       instruments.index(model_channel_8_reed_family),\n",
        "                       9, # Drums patch\n",
        "                       instruments.index(model_channel_9_pipe_family),\n",
        "                       instruments.index(model_channel_10_synth_lead_family),\n",
        "                       instruments.index(model_channel_11_synth_pad_family),\n",
        "                       instruments.index(model_channel_12_synth_effects_family),\n",
        "                       instruments.index(model_channel_13_ethnic_family),\n",
        "                       instruments.index(model_channel_15_sound_effects_family)\n",
        "                       ]\n",
        "\n",
        "print('Done!')\n",
        "print('=' * 70)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "nay8gIZDcHD4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (LOAD SEED MIDI)"
      ],
      "metadata": {
        "id": "7xNyANjZsCOi"
      }
    },
    {
      "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\", \"Quad-Music-Transformer-Piano-Seed-1\", \"Quad-Music-Transformer-Piano-Seed-2\", \"Quad-Music-Transformer-Piano-Seed-3\", \"Quad-Music-Transformer-Piano-Seed-4\", \"Quad-Music-Transformer-Piano-Seed-5\", \"Quad-Music-Transformer-Piano-Seed-6\", \"Quad-Music-Transformer-MI-Seed-1\", \"Quad-Music-Transformer-MI-Seed-2\", \"Quad-Music-Transformer-MI-Seed-3\", \"Quad-Music-Transformer-MI-Seed-4\", \"Quad-Music-Transformer-MI-Seed-5\", \"Quad-Music-Transformer-MI-Seed-6\"]\n",
        "number_of_prime_tokens = 8190 # @param {type:\"slider\", min:80, max:8192, step:4}\n",
        "render_MIDI_to_audio = False # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Quad Music Transformer Seed MIDI Loader')\n",
        "print('=' * 70)\n",
        "\n",
        "#=====================================================\n",
        "# Helper function\n",
        "#=====================================================\n",
        "\n",
        "f = ''\n",
        "\n",
        "if select_seed_MIDI != \"Upload your own custom MIDI\":\n",
        "  print('Loading seed MIDI...')\n",
        "  f = '/content/Quad-Music-Transformer/Seeds/'+select_seed_MIDI+'.mid'\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",
        "    f = list(uploaded_MIDI.keys())[0]\n",
        "\n",
        "if f != '':\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('File:', f)\n",
        "  print('=' * 70)\n",
        "\n",
        "  #===============================================================================\n",
        "  # Raw single-track ms score\n",
        "\n",
        "  raw_score = TMIDIX.midi2single_track_ms_score(f)\n",
        "\n",
        "  #===============================================================================\n",
        "  # Enhanced score notes\n",
        "\n",
        "  escore_notes = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]\n",
        "\n",
        "  if len(escore_notes) > 0:\n",
        "\n",
        "      #=======================================================\n",
        "      # PRE-PROCESSING\n",
        "\n",
        "      # checking number of instruments in a composition\n",
        "      instruments_list = list(set([y[3] for y in escore_notes]))\n",
        "\n",
        "      #===============================================================================\n",
        "      # Augmented enhanced score notes\n",
        "\n",
        "      escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes)\n",
        "\n",
        "      #=======================================================\n",
        "      # FINAL PROCESSING\n",
        "\n",
        "      melody_chords = []\n",
        "      melody_chords2 = []\n",
        "\n",
        "      # Break between compositions / Intro seq\n",
        "\n",
        "      if 9 in instruments_list:\n",
        "          drums_present = 2450 # Yes\n",
        "      else:\n",
        "          drums_present = 2449 # No\n",
        "\n",
        "      if escore_notes[0][3] != 9:\n",
        "          fpat = escore_notes[0][6]\n",
        "          fptc = escore_notes[0][4]\n",
        "      else:\n",
        "          fpat = 128\n",
        "          fptc = escore_notes[0][4]\n",
        "\n",
        "      fchan = fpat // 8\n",
        "\n",
        "      melody_chords.extend([2595, drums_present, 2450+fchan, 2467+fptc]) # Intro seq\n",
        "\n",
        "      #=======================================================\n",
        "      # MAIN PROCESSING CYCLE\n",
        "      #=======================================================\n",
        "\n",
        "      pe = escore_notes[0]\n",
        "\n",
        "      chords_counter = 1\n",
        "\n",
        "      comp_chords_len = len(list(set([y[1] for y in escore_notes])))\n",
        "\n",
        "      for e in escore_notes:\n",
        "\n",
        "        #=======================================================\n",
        "        # Timings...\n",
        "\n",
        "        if (e[1] - pe[1]) != 0:\n",
        "            time = (e[1]-pe[1])\n",
        "        else:\n",
        "            time = 0\n",
        "\n",
        "        dur = e[2]\n",
        "\n",
        "        if time != 0 and time % 2 != 0:\n",
        "            time += 1\n",
        "        if dur % 2 != 0:\n",
        "            dur += 1\n",
        "\n",
        "        delta_time = int(max(0, min(255, time)) / 2)\n",
        "\n",
        "        # Durations and channels\n",
        "\n",
        "        dur = int(max(0, min(255, dur)) / 2)\n",
        "\n",
        "        cha = max(0, min(15, e[3]))\n",
        "\n",
        "        # Patches\n",
        "        if cha == 9: # Drums patch will be == 128\n",
        "            pat = 128\n",
        "\n",
        "        else:\n",
        "            pat = e[6]\n",
        "\n",
        "        # Channels\n",
        "\n",
        "        chan = pat // 8\n",
        "\n",
        "        # Pitches\n",
        "\n",
        "        if cha != 9:\n",
        "            ptc = max(1, min(127, e[4]))\n",
        "        else:\n",
        "            ptc = max(1, min(127, e[4]))\n",
        "\n",
        "        # Velocities\n",
        "\n",
        "        # Calculating octo-velocity\n",
        "        velocity = max(8, min(127, e[5]))\n",
        "        vel = round(velocity / 8)-1\n",
        "\n",
        "        #=======================================================\n",
        "        # Outro seq\n",
        "\n",
        "        # if comp_chords_len >= 250:\n",
        "        #    if ((comp_chords_len - chords_counter) == 50) and (delta_time != 0):\n",
        "        #        melody_chords.extend([2448, 2448, 2448, 2448]) # outro seq\n",
        "\n",
        "        # if delta_time != 0:\n",
        "        #    chords_counter += 1\n",
        "\n",
        "        #=======================================================\n",
        "        # FINAL NOTE SEQ\n",
        "\n",
        "        # Writing final note asynchronously\n",
        "\n",
        "        cha_ptc = (128 * chan) + ptc\n",
        "\n",
        "        melody_chords.extend([delta_time, dur+128, cha_ptc+256, vel+2432])\n",
        "        melody_chords2.append([delta_time, dur+128, cha_ptc+256, vel+2432])\n",
        "\n",
        "        pe = e\n",
        "\n",
        "        #=======================================================\n",
        "\n",
        "      # melody_chords.extend([2596]) # EOS\n",
        "\n",
        "      #=======================================================\n",
        "\n",
        "      # TOTAL DICTIONARY SIZE 2596+1=2597\n",
        "      #=======================================================\n",
        "\n",
        "  melody_chords_f = melody_chords[: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 0 <= ss < 128:\n",
        "\n",
        "          time += ss * 32\n",
        "\n",
        "      if 128 <= ss < 256:\n",
        "\n",
        "          dur = (ss-128) * 32\n",
        "\n",
        "      if 256 <= ss < 2432:\n",
        "\n",
        "          chan = (ss-256) // 128\n",
        "\n",
        "          if chan < 9:\n",
        "              channel = chan\n",
        "          elif 9 < chan < 15:\n",
        "              channel = chan+1\n",
        "          elif chan == 15:\n",
        "              channel = 15\n",
        "          elif chan == 16:\n",
        "              channel = 9\n",
        "\n",
        "          pitch = (ss-256) % 128\n",
        "\n",
        "      if 2432 <= ss < 2448:\n",
        "\n",
        "          vel = (((ss-2432)+1) * 8)-1\n",
        "\n",
        "          song_f.append(['note', time, dur, channel, pitch, vel, chan*8 ])\n",
        "\n",
        "  detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                            output_signature = 'Quad Music Transformer',\n",
        "                                                            output_file_name = '/content/Quad-Music-Transformer-Seed-Composition',\n",
        "                                                            track_name='Project Los Angeles',\n",
        "                                                            list_of_MIDI_patches=patches\n",
        "                                                            )\n",
        "\n",
        "  #=======================================================\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Composition stats:')\n",
        "  print('Composition has', int(len(melody_chords_f) / 3), 'notes')\n",
        "  print('Composition has', len(melody_chords_f), 'tokens')\n",
        "  print('Composition MIDI channels:', sorted(list(set([((y-256) // 128) for y in melody_chords if 256 <= y < 2432]))))\n",
        "  print('=' * 70)\n",
        "\n",
        "  print('Displaying resulting composition...')\n",
        "  print('=' * 70)\n",
        "\n",
        "  fname = '/content/Quad-Music-Transformer-Seed-Composition'\n",
        "\n",
        "  block_lines = [(song_f[-1][1] / 1000)]\n",
        "  block_tokens = [min(len(melody_chords_f), number_of_prime_tokens)]\n",
        "  pblock = []\n",
        "\n",
        "  if render_MIDI_to_audio:\n",
        "    midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "    display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "  TMIDIX.plot_ms_SONG(song_f, plot_title=fname)\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": "69AGT0QTSdqA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Standard Continuation Generator\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "try_to_generate_outro = False #@param {type:\"boolean\"}\n",
        "try_to_introduce_drums = False # @param {type:\"boolean\"}\n",
        "number_of_tokens_to_generate = 404 # @param {type:\"slider\", min:32, max:1024, step:4}\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:32, max:240, step:4}\n",
        "number_of_memory_tokens = 7160 # @param {type:\"slider\", min:300, max:8192, step:4}\n",
        "temperature = 0.9 # @param {type:\"slider\", min:0.1, max:1, step:0.05}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "allow_model_to_stop_generation_if_needed = False #@param {type:\"boolean\"}\n",
        "render_MIDI_to_audio = True # @param {type:\"boolean\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Quad Music Transformer Standard Continuation Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if allow_model_to_stop_generation_if_needed:\n",
        "  min_stop_token = 2596\n",
        "else:\n",
        "  min_stop_token = None\n",
        "\n",
        "preview = melody_chords_f[-preview_length_in_tokens:]\n",
        "\n",
        "mel_cho = melody_chords_f[-number_of_memory_tokens:]\n",
        "\n",
        "if try_to_introduce_drums:\n",
        "  last_note = mel_cho[-4:]\n",
        "  drums = [36, 38, 47, 54]\n",
        "  if 0 <= last_note[0] < 256:\n",
        "    for d in random.choices(drums, k = random.randint(1, len(drums))):\n",
        "      mel_cho.extend([0, min(4+128, last_note[1]), ((128*16)+d)+256, 100+2432])\n",
        "\n",
        "if try_to_generate_outro:\n",
        "  mel_cho.extend([2448, 2448, 2448, 2448])\n",
        "\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "inp = [mel_cho] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "with ctx:\n",
        "  out = model.generate(inp,\n",
        "                        number_of_tokens_to_generate,\n",
        "                        temperature=temperature,\n",
        "                        return_prime=False,\n",
        "                        eos_token=min_stop_token,\n",
        "                        verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "print('Rendering results...')\n",
        "\n",
        "for i in range(number_of_batches_to_generate):\n",
        "\n",
        "  print('=' * 70)\n",
        "  print('Batch #', i)\n",
        "  print('=' * 70)\n",
        "\n",
        "  out1 = out0[i]\n",
        "\n",
        "  print('Sample INTs', out1[:12])\n",
        "  print('=' * 70)\n",
        "\n",
        "  if len(out) != 0:\n",
        "\n",
        "      song = preview + out1\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 0 <= ss < 128:\n",
        "\n",
        "              time += ss * 32\n",
        "\n",
        "          if 128 <= ss < 256:\n",
        "\n",
        "              dur = (ss-128) * 32\n",
        "\n",
        "          if 256 <= ss < 2432:\n",
        "\n",
        "              chan = (ss-256) // 128\n",
        "\n",
        "              if chan < 9:\n",
        "                  channel = chan\n",
        "              elif 9 < chan < 15:\n",
        "                  channel = chan+1\n",
        "              elif chan == 15:\n",
        "                  channel = 15\n",
        "              elif chan == 16:\n",
        "                  channel = 9\n",
        "\n",
        "              pitch = (ss-256) % 128\n",
        "\n",
        "          if 2432 <= ss < 2448:\n",
        "\n",
        "              vel = (((ss-2432)+1) * 8)-1\n",
        "\n",
        "              song_f.append(['note', time, dur, channel, pitch, vel, chan*8 ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Quad Music Transformer',\n",
        "                                                          output_file_name = '/content/Quad-Music-Transformer-Composition_'+str(i),\n",
        "                                                          track_name='Project Los Angeles',\n",
        "                                                          list_of_MIDI_patches=patches\n",
        "                                                          )\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/Quad-Music-Transformer-Composition_'+str(i)\n",
        "\n",
        "      if render_MIDI_to_audio:\n",
        "        midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "        display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "      TMIDIX.plot_ms_SONG(song_f,\n",
        "                          plot_title=fname,\n",
        "                          preview_length_in_notes=int(preview_length_in_tokens / 4)\n",
        "                          )"
      ],
      "metadata": {
        "cellView": "form",
        "id": "UXxG_JXkShcY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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",
        "\n",
        "  new_block = out0[min(len(out0)-1, add_block_with_batch_number)]\n",
        "\n",
        "  if new_block != pblock:\n",
        "    melody_chords_f.extend(new_block)\n",
        "    print('Block added!')\n",
        "\n",
        "  else:\n",
        "    print('Nothing to add!!!')\n",
        "\n",
        "else:\n",
        "  if len(block_tokens) > 1:\n",
        "    melody_chords_f = melody_chords_f[:(len(melody_chords_f)-block_tokens[-1])]\n",
        "\n",
        "    block_lines.pop()\n",
        "    block_tokens.pop()\n",
        "    print('Block removed!')\n",
        "\n",
        "    pblock = []\n",
        "\n",
        "  else:\n",
        "    print('Nothing to remove!!!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Composition now has', (len(melody_chords_f) // 4), 'notes')\n",
        "print('Composition now has', len(melody_chords_f), 'tokens')\n",
        "print('Composition MIDI channels:', sorted(list(set([((y-256) // 128) for y in melody_chords if 256 <= y < 2432]))))\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",
        "\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 90\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "\n",
        "    for ss in song:\n",
        "\n",
        "        if 0 <= ss < 128:\n",
        "\n",
        "            time += ss * 32\n",
        "\n",
        "        if 128 <= ss < 256:\n",
        "\n",
        "            dur = (ss-128) * 32\n",
        "\n",
        "        if 256 <= ss < 2432:\n",
        "\n",
        "            chan = (ss-256) // 128\n",
        "\n",
        "            if chan < 9:\n",
        "                channel = chan\n",
        "            elif 9 < chan < 15:\n",
        "                channel = chan+1\n",
        "            elif chan == 15:\n",
        "                channel = 15\n",
        "            elif chan == 16:\n",
        "                channel = 9\n",
        "\n",
        "            pitch = (ss-256) % 128\n",
        "\n",
        "        if 2432 <= ss < 2448:\n",
        "\n",
        "            vel = (((ss-2432)+1) * 8)-1\n",
        "\n",
        "            song_f.append(['note', time, dur, channel, pitch, vel, chan*8 ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,\n",
        "                                                              output_signature = 'Quad Music Transformer',\n",
        "                                                              output_file_name = '/content/Quad-Music-Transformer-Composition',\n",
        "                                                              track_name='Project Los Angeles',\n",
        "                                                              list_of_MIDI_patches=patches\n",
        "                                                              )\n",
        "\n",
        "    if block_action == 'add_last_generated_block' and new_block != pblock:\n",
        "      block_tokens.append(len(new_block))\n",
        "      block_lines.append((song_f[-1][1] / 1000))\n",
        "      pblock = new_block\n",
        "\n",
        "    print('=' * 70)\n",
        "    print('Displaying resulting composition...')\n",
        "    print('=' * 70)\n",
        "\n",
        "    fname = '/content/Quad-Music-Transformer-Composition'\n",
        "\n",
        "    if render_MIDI_to_audio:\n",
        "      midi_audio = midi_to_colab_audio(fname + '.mid')\n",
        "      display(Audio(midi_audio, rate=16000, normalize=False))\n",
        "\n",
        "    TMIDIX.plot_ms_SONG(song_f,\n",
        "                        plot_title=fname,\n",
        "                        block_lines_times_list=block_lines[:-1]\n",
        "                        )"
      ],
      "metadata": {
        "cellView": "form",
        "id": "ykBh-aXyShYC"
      },
      "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
}