Euterpe.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "ac5a4cf0-d9d2-47b5-9633-b53f8d99a4d2",
          "kernelId": ""
        },
        "id": "SiTIpPjArIyr"
      },
      "source": [
        "# Euterpe (ver. 1.0)\n",
        "\n",
        "***\n",
        "\n",
        "Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools\n",
        "\n",
        "***\n",
        "\n",
        "Credit for GPT2-RGA code used in this colab goes out @ Sashmark97 https://github.com/Sashmark97/midigen and @ Damon Gwinn https://github.com/gwinndr/MusicTransformer-Pytorch\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 2022\n",
        "\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "fa0a611c-1803-42ae-bdf6-a49b5a4e781b",
          "kernelId": ""
        },
        "id": "gOd93yV0sGd2"
      },
      "source": [
        "# (Setup Environment)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "gradient": {
          "editing": false,
          "id": "39411b40-9e39-416e-8fe4-d40f733e7956",
          "kernelId": ""
        },
        "id": "lw-4aqV3sKQG"
      },
      "outputs": [],
      "source": [
        "#@title nvidia-smi gpu check\n",
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "a1a45a91-d909-4fd4-b67a-5e16b971d179",
          "kernelId": ""
        },
        "id": "fX12Yquyuihc",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Install all dependencies (run only once per session)\n",
        "\n",
        "!git clone https://github.com/asigalov61/Euterpe\n",
        "\n",
        "!pip install torch\n",
        "!pip install torch-summary\n",
        "\n",
        "!pip install tqdm\n",
        "!pip install matplotlib\n",
        "!pip install sklearn\n",
        "\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": {
        "cellView": "form",
        "gradient": {
          "editing": false,
          "id": "b8207b76-9514-4c07-95db-95a4742e52c5",
          "kernelId": ""
        },
        "id": "z7n9vnKmug1J"
      },
      "outputs": [],
      "source": [
        "#@title Import all needed modules\n",
        "\n",
        "print('Loading needed modules. Please wait...')\n",
        "import os\n",
        "import random\n",
        "import copy\n",
        "\n",
        "from collections import OrderedDict\n",
        "\n",
        "from tqdm.notebook import tqdm\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from torchsummary import summary\n",
        "from sklearn import metrics\n",
        "\n",
        "print('Loading TMIDIX module...')\n",
        "os.chdir('/content/Euterpe')\n",
        "\n",
        "import TMIDIX\n",
        "from GPT2RGAX import *\n",
        "\n",
        "from midi2audio import FluidSynth\n",
        "from IPython.display import Audio, display\n",
        "\n",
        "os.chdir('/content/')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (UNZIP MODEL)"
      ],
      "metadata": {
        "id": "iJ4xaSoA9A9s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Unzip pre-trained Euterpe Model\n",
        "%cd /content/Euterpe/Model\n",
        "\n",
        "print('=' * 70)\n",
        "print('Unzipping pre-trained model...Please wait...')\n",
        "print('=' * 70)\n",
        "\n",
        "!cat /content/Euterpe/Model/Euterpe-Trained-Model.zip* > Euterpe-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j Euterpe-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/"
      ],
      "metadata": {
        "cellView": "form",
        "id": "hvybRqy05RnI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdKFoeke9L7H"
      },
      "source": [
        "# (LOAD)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Load/Reload the model\n",
        "\n",
        "full_path_to_model_checkpoint = \"/content/Euterpe/Model/Euterpe-Trained-Model_66924_steps_0.8806_loss.pth\" #@param {type:\"string\"}\n",
        "\n",
        "print('Loading the model...')\n",
        "config = GPTConfig(512, \n",
        "                   1280,\n",
        "                   dim_feedforward=1280,\n",
        "                   n_layer=16, \n",
        "                   n_head=16, \n",
        "                   n_embd=1280,\n",
        "                   enable_rpr=True,\n",
        "                   er_len=1280)\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "model = GPT(config)\n",
        "\n",
        "state_dict = torch.load(full_path_to_model_checkpoint, map_location=device)\n",
        "\n",
        "new_state_dict = OrderedDict()\n",
        "for k, v in state_dict.items():\n",
        "    name = k[7:] #remove 'module'\n",
        "    new_state_dict[name] = v\n",
        "\n",
        "model.load_state_dict(new_state_dict)\n",
        "\n",
        "model.to(device)\n",
        "\n",
        "model.eval()\n",
        "\n",
        "print('Done!')\n",
        "\n",
        "summary(model)\n",
        "\n",
        "cos_sim = metrics.pairwise.cosine_similarity(\n",
        "    model.tok_emb.weight.detach().cpu().numpy()\n",
        ")\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\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/Euterpe-Positional-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "-NLe35B0b9a5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GENERATE)"
      ],
      "metadata": {
        "id": "RCKJSbl4erb0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Improvisation from scratch"
      ],
      "metadata": {
        "id": "30XNZkwMy6-4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Improv Generator\n",
        "\n",
        "#@markdown Select desired instruments (any combination is fine)\n",
        "\n",
        "Piano = True #@param {type:\"boolean\"}\n",
        "Guitar = True #@param {type:\"boolean\"}\n",
        "Bass = True #@param {type:\"boolean\"}\n",
        "Violin = False #@param {type:\"boolean\"}\n",
        "Cello = False #@param {type:\"boolean\"}\n",
        "Harp = False #@param {type:\"boolean\"}\n",
        "Trumpet = False #@param {type:\"boolean\"}\n",
        "Clarinet = False #@param {type:\"boolean\"}\n",
        "Flute = False #@param {type:\"boolean\"}\n",
        "Drums = True #@param {type:\"boolean\"}\n",
        "Choir = False #@param {type:\"boolean\"}\n",
        "Organ = False #@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown Improv Timings and Velocity\n",
        "\n",
        "desired_prime_time = 18 #@param {type:\"slider\", min:1, max:126, step:1}\n",
        "desired_prime_duration = 15 #@param {type:\"slider\", min:1, max:126, step:1}\n",
        "desired_velocity = 4 #@param {type:\"slider\", min:1, max:6, step:1}\n",
        "\n",
        "#@markdown Model settings\n",
        "\n",
        "number_of_notes_to_generate = 512 #@param {type:\"slider\", min:16, max:2048, step:16}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:16, max:1280, step:16}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "\n",
        "instruments = []\n",
        "\n",
        "if Piano:\n",
        "  instruments += [(0 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  60+384] + [(0 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  48+384]\n",
        "\n",
        "if Guitar:\n",
        "  instruments += [(1 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  60+384]\n",
        "\n",
        "if Bass:\n",
        "  instruments += [(2 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  46+384]\n",
        "\n",
        "if Violin:\n",
        "  instruments += [(3 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  72+384]\n",
        "\n",
        "if Cello:\n",
        "  instruments += [(4 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  46+384]\n",
        "\n",
        "if Harp:\n",
        "  instruments += [(5 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  72+384]\n",
        "\n",
        "if Trumpet:\n",
        "  instruments += [(6 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  72+384]\n",
        "\n",
        "if Clarinet:\n",
        "  instruments += [(7 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  72+384]\n",
        "\n",
        "if Flute:\n",
        "  instruments += [(8 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  72+384]\n",
        "\n",
        "if Drums:\n",
        "  instruments += [(9 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  35+384]\n",
        "\n",
        "if Choir:\n",
        "  instruments += [(10 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  58+384]\n",
        "\n",
        "if Organ:\n",
        "  instruments += [(11 * 11)+desired_velocity,\n",
        "                  0+128,\n",
        "                  desired_prime_duration+256,\n",
        "                  58+384]\n",
        "instruments[1] = desired_prime_time+128\n",
        "instruments[5::4] = [0+128] * len(instruments[5::4])\n",
        "\n",
        "prime = instruments\n",
        "\n",
        "#===================================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Euterpe Music Model Improvisation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of notes to generate:', number_of_notes_to_generate)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "out1 = []\n",
        "out1.extend(prime)\n",
        "\n",
        "for i in tqdm(range(number_of_notes_to_generate)):\n",
        "\n",
        "  if len(out1)+4 < number_of_memory_tokens:\n",
        "    num_memtoks = len(out1)+4\n",
        "  else:\n",
        "    num_memtoks = number_of_memory_tokens\n",
        "\n",
        "  rand_seq = model.generate(torch.Tensor(out1[-(number_of_memory_tokens-4):]), \n",
        "                                          target_seq_length=num_memtoks,\n",
        "                                          temperature=temperature,\n",
        "                                          stop_token=512,\n",
        "                                          verbose=show_stats)\n",
        "    \n",
        "  out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "  out1.extend(out[-4:])\n",
        "\n",
        "if len(out1) != 0:\n",
        "    \n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "    son = []\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "    \n",
        "    for s in song1:\n",
        "      if s[0] > 0 and s[1] >= 128:\n",
        "        if s[2] > 256 and s[3] > 384:\n",
        "\n",
        "          channel = s[0] // 11\n",
        "\n",
        "          vel = (s[0] % 11) * 19\n",
        "\n",
        "          time += (s[1]-128) * 16\n",
        "      \n",
        "          dur = (s[2] - 256) * 32\n",
        "          \n",
        "          pitch = (s[3] - 384)\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'Euterpe',  \n",
        "                                                        output_file_name = '/content/Euterpe-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/Euterpe-Music-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "for s in song_f:\n",
        "  x.append(s[1] / 1000)\n",
        "  y.append(s[4])\n",
        "  c.append(colors[s[3]])\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\n",
        "plt.figure(figsize=(14,5))\n",
        "ax=plt.axes(title=fname)\n",
        "ax.set_facecolor('black')\n",
        "\n",
        "plt.scatter(x,y, c=c)\n",
        "plt.xlabel(\"Time\")\n",
        "plt.ylabel(\"Pitch\")\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "SbI-NfigHiMV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Continuation / Inpainting / Melody Orchestration"
      ],
      "metadata": {
        "id": "-OY_5PjpVJQ7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Load Seed/Custom MIDI\n",
        "full_path_to_custom_MIDI_file = \"/content/Euterpe/Euterpe-MI-Seed-1.mid\" #@param {type:\"string\"}\n",
        "\n",
        "print('Loading custom MIDI file...')\n",
        "score = TMIDIX.midi2ms_score(open(full_path_to_custom_MIDI_file, 'rb').read())\n",
        "\n",
        "events_matrix = []\n",
        "\n",
        "itrack = 1\n",
        "\n",
        "patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
        "\n",
        "patch_map = [[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",
        "              [71, 72], # Clarinet\n",
        "              [73, 74, 75], # Flute\n",
        "              [-1], # Fake 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",
        "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] < 12: # We won't write chans 11-16 for now...\n",
        "                events_matrix1.append(event)\n",
        "\n",
        "# Sorting...\n",
        "events_matrix1.sort(key=lambda x: (x[1], x[3]))\n",
        "\n",
        "# recalculating timings\n",
        "for e in events_matrix1:\n",
        "    e[1] = int(e[1] / 16)\n",
        "    e[2] = int(e[2] / 32)\n",
        "\n",
        "# final processing...\n",
        "\n",
        "inputs = []\n",
        "\n",
        "melody = []\n",
        "\n",
        "melody_chords = []\n",
        "\n",
        "pe = events_matrix1[0]\n",
        "for e in events_matrix1:\n",
        "\n",
        "    time = max(0, min(127, e[1]-pe[1]))\n",
        "    dur = max(1, min(127, e[2]))\n",
        "    cha = max(0, min(11, e[3]))\n",
        "    ptc = max(1, min(127, e[4]))\n",
        "    vel = max(19, min(127, e[5]))\n",
        "\n",
        "    div_vel = int(vel / 19)\n",
        "\n",
        "    chan_vel = (cha * 11) + div_vel\n",
        "\n",
        "    # Continuation / Inpainting\n",
        "    inputs.extend([chan_vel, time+128, dur+256, ptc+384])\n",
        "\n",
        "    # Melody Orchestration\n",
        "    if time != 0:\n",
        "      if ptc < 60:\n",
        "        ptc = (ptc % 12) + 60  \n",
        "\n",
        "      # Converted to Piano\n",
        "      melody.extend([div_vel, time+128, dur+256, ptc+384])\n",
        "\n",
        "    # For future development\n",
        "    melody_chords.append([time, dur, cha, ptc, vel])\n",
        "\n",
        "    pe = e\n",
        "\n",
        "# =================================\n",
        "\n",
        "out1 = inputs\n",
        "\n",
        "if len(out1) != 0:\n",
        "    \n",
        "    song = out1\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "    son = []\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "    \n",
        "    for s in song1:\n",
        "      if s[0] > 0 and s[1] >= 128:\n",
        "        if s[2] > 256 and s[3] > 384:\n",
        "\n",
        "          channel = s[0] // 11\n",
        "\n",
        "          vel = (s[0] % 11) * 19\n",
        "\n",
        "          time += (s[1]-128) * 16\n",
        "      \n",
        "          dur = (s[2] - 256) * 32\n",
        "          \n",
        "          pitch = (s[3] - 384)\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'Euterpe',  \n",
        "                                                        output_file_name = '/content/Euterpe-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/Euterpe-Music-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "for s in song_f:\n",
        "  x.append(s[1] / 1000)\n",
        "  y.append(s[4])\n",
        "  c.append(colors[s[3]])\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\n",
        "plt.figure(figsize=(14,5))\n",
        "ax=plt.axes(title=fname)\n",
        "ax.set_facecolor('black')\n",
        "\n",
        "plt.scatter(x,y, c=c)\n",
        "plt.xlabel(\"Time\")\n",
        "plt.ylabel(\"Pitch\")\n",
        "plt.show()\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "dJaRwK9bUKwG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Continuation"
      ],
      "metadata": {
        "id": "aI0laUdWAkA3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Single Continuation Block Generator\n",
        "\n",
        "#@markdown NOTE: Play with the settings to get different results\n",
        "number_of_prime_tokens = 512 #@param {type:\"slider\", min:16, max:512, step:16}\n",
        "number_of_tokens_to_generate = 1024 #@param {type:\"slider\", min:64, max:1264, step:32}\n",
        "number_of_batches = 2 #@param {type:\"slider\", min:1, max:8, step:1}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = True #@param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('Euterpe Music Model Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime tokens:', number_of_prime_tokens)\n",
        "print('Number of tokens to generate:', number_of_tokens_to_generate)\n",
        "print('Number of batches:', number_of_batches)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "num_toks = min(1280, number_of_prime_tokens+number_of_tokens_to_generate)\n",
        "\n",
        "inp = inputs[:number_of_prime_tokens]\n",
        "\n",
        "rand_seq = model.generate_batches(torch.Tensor(inp), \n",
        "                                          target_seq_length=num_toks,\n",
        "                                          temperature=temperature,\n",
        "                                          num_batches=number_of_batches,\n",
        "                                          verbose=show_stats)\n",
        "  \n",
        "out1 = rand_seq.cpu().tolist()\n",
        "\n",
        "bcount = 1\n",
        "\n",
        "for o in out1:\n",
        "\n",
        "  if len(o) != 0:\n",
        "      \n",
        "      song = o\n",
        "      song_f = []\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      vel = 0\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "      son = []\n",
        "      song1 = []\n",
        "\n",
        "      for s in song:\n",
        "        if s > 127:\n",
        "          son.append(s)\n",
        "\n",
        "        else:\n",
        "          if len(son) == 4:\n",
        "            song1.append(son)\n",
        "          son = []\n",
        "          son.append(s)\n",
        "      \n",
        "      for s in song1:\n",
        "        if s[0] > 0 and s[1] >= 128:\n",
        "          if s[2] > 256 and s[3] > 384:\n",
        "\n",
        "            channel = s[0] // 11\n",
        "\n",
        "            vel = (s[0] % 11) * 19\n",
        "\n",
        "            time += (s[1]-128) * 16\n",
        "        \n",
        "            dur = (s[2] - 256) * 32\n",
        "            \n",
        "            pitch = (s[3] - 384)\n",
        "                                      \n",
        "            song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "      detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Euterpe',  \n",
        "                                                          output_file_name = '/content/Euterpe-Music-Composition_'+str(bcount), \n",
        "                                                          track_name='Project Los Angeles',\n",
        "                                                          list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "      print('Done!')\n",
        "\n",
        "  print('Displaying resulting composition...')\n",
        "  fname = '/content/Euterpe-Music-Composition_' + str(bcount)\n",
        "\n",
        "  x = []\n",
        "  y =[]\n",
        "  c = []\n",
        "\n",
        "  colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "  for s in song_f:\n",
        "    x.append(s[1] / 1000)\n",
        "    y.append(s[4])\n",
        "    c.append(colors[s[3]])\n",
        "\n",
        "  FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "  display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\n",
        "  plt.figure(figsize=(14,5))\n",
        "  ax=plt.axes(title=fname)\n",
        "  ax.set_facecolor('black')\n",
        "\n",
        "  plt.scatter(x,y, c=c)\n",
        "  plt.xlabel(\"Time\")\n",
        "  plt.ylabel(\"Pitch\")\n",
        "  plt.show()\n",
        "\n",
        "  bcount += 1"
      ],
      "metadata": {
        "cellView": "form",
        "id": "bAWBH-MudV3t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Auto-Continue Custom MIDI\n",
        "\n",
        "#@markdown NOTE: This may or may not work well due to long-term structure decay\n",
        "number_of_continuation_notes = 400 #@param {type:\"slider\", min:10, max:2000, step:10}\n",
        "number_of_memory_tokens = 1276 #@param {type:\"slider\", min:64, max:1276, step:4}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "print('=' * 70)\n",
        "print('Euterpe Music Model Auto-Continuation Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of continuation notes:', number_of_continuation_notes)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "out2 = copy.deepcopy(inputs)\n",
        "\n",
        "memt = min(number_of_memory_tokens, len(out2)-4)\n",
        "seqt = min(number_of_memory_tokens+4, memt+4)\n",
        "\n",
        "for i in tqdm(range(number_of_continuation_notes)):\n",
        "\n",
        "  rand_seq = model.generate(torch.Tensor(out2[-memt:]), \n",
        "                                            target_seq_length=seqt,\n",
        "                                            temperature=temperature,\n",
        "                                            stop_token=512,\n",
        "                                            verbose=show_stats)\n",
        "    \n",
        "  out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "  out2.extend(out[-4:])\n",
        "\n",
        "if len(out2) != 0:\n",
        "    \n",
        "    song = out2\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "    son = []\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "    \n",
        "    for s in song1:\n",
        "      if s[0] > 0 and s[1] >= 128:\n",
        "        if s[2] > 256 and s[3] > 384:\n",
        "\n",
        "          channel = s[0] // 11\n",
        "\n",
        "          vel = (s[0] % 11) * 19\n",
        "\n",
        "          time += (s[1]-128) * 16\n",
        "      \n",
        "          dur = (s[2] - 256) * 32\n",
        "          \n",
        "          pitch = (s[3] - 384)\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'Euterpe',  \n",
        "                                                        output_file_name = '/content/Euterpe-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/Euterpe-Music-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "for s in song_f:\n",
        "  x.append(s[1] / 1000)\n",
        "  y.append(s[4])\n",
        "  c.append(colors[s[3]])\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\n",
        "plt.figure(figsize=(14,5))\n",
        "ax=plt.axes(title=fname)\n",
        "ax.set_facecolor('black')\n",
        "\n",
        "plt.scatter(x,y, c=c)\n",
        "plt.xlabel(\"Time\")\n",
        "plt.ylabel(\"Pitch\")\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "TaH2748zN2oz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Inpainting"
      ],
      "metadata": {
        "id": "qGRjXyUnAmWX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Inpainting / Controlled Generation\n",
        "control_type = \"Channel-Velocity-Time-Duration\" #@param [\"Channel-Velocity\", \"Channel-Velocity-Time\", \"Channel-Velocity-Time-Duration\"]\n",
        "number_of_prime_notes = 16 #@param {type:\"slider\", min:1, max:64, step:1}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:64, max:1280, step:16}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Euterpe Music Model Inpainting Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Control type:', control_type)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "out2 = copy.deepcopy(inputs)\n",
        "\n",
        "memt = min(number_of_memory_tokens, len(out2)-4)\n",
        "seqt = min(number_of_memory_tokens+4, memt+4)\n",
        "\n",
        "if control_type == 'Channel-Velocity':\n",
        "  ctrl = 1\n",
        "\n",
        "if control_type == 'Channel-Velocity-Time':\n",
        "  ctrl = 2\n",
        "\n",
        "if control_type == 'Channel-Velocity-Time-Duration':\n",
        "  ctrl = 3\n",
        "\n",
        "out3 = []\n",
        "\n",
        "out3.extend(inputs[:number_of_prime_notes * 4])\n",
        "\n",
        "for i in tqdm(range(((number_of_prime_notes+1) * 4), len(inputs), 4)):\n",
        "\n",
        "  out3.extend(out2[i:i+ctrl])\n",
        "\n",
        "  rand_seq = model.generate(torch.Tensor(out3[-memt:]), \n",
        "                                            target_seq_length=len(out3[-memt:])+(4-ctrl),\n",
        "                                            temperature=temperature,\n",
        "                                            stop_token=512,\n",
        "                                            verbose=show_stats)\n",
        "    \n",
        "  out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "  out3.extend(out[-(4-ctrl):])\n",
        "\n",
        "if len(out3) != 0:\n",
        "    \n",
        "    song = out3\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "    son = []\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "    \n",
        "    for s in song1:\n",
        "      if s[0] > 0 and s[1] >= 128:\n",
        "        if s[2] > 256 and s[3] > 384:\n",
        "\n",
        "          channel = s[0] // 11\n",
        "\n",
        "          vel = (s[0] % 11) * 19\n",
        "\n",
        "          time += (s[1]-128) * 16\n",
        "      \n",
        "          dur = (s[2] - 256) * 32\n",
        "          \n",
        "          pitch = (s[3] - 384)\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'Euterpe',  \n",
        "                                                        output_file_name = '/content/Euterpe-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/Euterpe-Music-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "for s in song_f:\n",
        "  x.append(s[1] / 1000)\n",
        "  y.append(s[4])\n",
        "  c.append(colors[s[3]])\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\n",
        "plt.figure(figsize=(14,5))\n",
        "ax=plt.axes(title=fname)\n",
        "ax.set_facecolor('black')\n",
        "\n",
        "plt.scatter(x,y, c=c)\n",
        "plt.xlabel(\"Time\")\n",
        "plt.ylabel(\"Pitch\")\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "TjZBr_HaZXaM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Melody Orchestration"
      ],
      "metadata": {
        "id": "YiTcgKzEApGX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Melody Orchestration\n",
        "number_of_prime_notes = 12 #@param {type:\"slider\", min:1, max:64, step:1}\n",
        "number_of_memory_tokens = 512 #@param {type:\"slider\", min:64, max:1280, step:16}\n",
        "number_of_desired_instruments = 3 #@param {type:\"slider\", min:1, max:10, step:1}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "show_stats = False #@param {type:\"boolean\"}\n",
        "\n",
        "#===================================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Euterpe Music Model Melody Orchestration Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Generation settings:')\n",
        "print('=' * 70)\n",
        "print('Number of prime notes:', number_of_prime_notes)\n",
        "print('Number of memory tokens:', number_of_memory_tokens)\n",
        "print('Number of desired instruments:', number_of_desired_instruments)\n",
        "print('Model temperature:', temperature)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Generating...')\n",
        "\n",
        "\n",
        "out2 = copy.deepcopy(melody)\n",
        "\n",
        "memt = min(number_of_memory_tokens, len(out2)-4)\n",
        "seqt = min(number_of_memory_tokens+4, memt+4)\n",
        "\n",
        "out3 = []\n",
        "\n",
        "out3.extend(melody[:(number_of_prime_notes * 4)+2])\n",
        "\n",
        "\n",
        "number_of_desired_instruments = 3\n",
        "\n",
        "for i in tqdm(range(((number_of_prime_notes+1) * 4)-2, len(melody)-2, 4)):\n",
        "\n",
        "  out3.extend(out2[i:i+4])\n",
        "\n",
        "  for j in range(number_of_desired_instruments):\n",
        "\n",
        "    rand_seq = model.generate(torch.Tensor(out3[-memt:]), \n",
        "                                              target_seq_length=len(out3[-memt:])+4,\n",
        "                                              temperature=temperature,\n",
        "                                              stop_token=512,\n",
        "                                              verbose=show_stats)\n",
        "      \n",
        "    out = rand_seq[0].cpu().tolist()\n",
        "\n",
        "    out3.extend(out[-4:])\n",
        "\n",
        "\n",
        "    out3[-2] = ((j+1)*11)+(out3[-6] % 11)\n",
        "\n",
        "    out3[-1] = 128\n",
        "\n",
        "if len(out3) != 0:\n",
        "    \n",
        "    song = out3\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "    son = []\n",
        "    song1 = []\n",
        "\n",
        "    for s in song:\n",
        "      if s > 127:\n",
        "        son.append(s)\n",
        "\n",
        "      else:\n",
        "        if len(son) == 4:\n",
        "          song1.append(son)\n",
        "        son = []\n",
        "        son.append(s)\n",
        "    \n",
        "    for s in song1:\n",
        "      if s[0] > 0 and s[1] >= 128:\n",
        "        if s[2] > 256 and s[3] > 384:\n",
        "\n",
        "          channel = s[0] // 11\n",
        "\n",
        "          vel = (s[0] % 11) * 19\n",
        "\n",
        "          time += (s[1]-128) * 16\n",
        "      \n",
        "          dur = (s[2] - 256) * 32\n",
        "          \n",
        "          pitch = (s[3] - 384)\n",
        "                                    \n",
        "          song_f.append(['note', time, dur, channel, pitch, vel ])\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                        output_signature = 'Euterpe',  \n",
        "                                                        output_file_name = '/content/Euterpe-Music-Composition', \n",
        "                                                        track_name='Project Los Angeles',\n",
        "                                                        list_of_MIDI_patches=[0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 53, 19, 0, 0, 0, 0],\n",
        "                                                        number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "fname = '/content/Euterpe-Music-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "for s in song_f:\n",
        "  x.append(s[1] / 1000)\n",
        "  y.append(s[4])\n",
        "  c.append(colors[s[3]])\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "display(Audio(str(fname + '.wav'), rate=16000))\n",
        "\n",
        "plt.figure(figsize=(14,5))\n",
        "ax=plt.axes(title=fname)\n",
        "ax.set_facecolor('black')\n",
        "\n",
        "plt.scatter(x,y, c=c)\n",
        "plt.xlabel(\"Time\")\n",
        "plt.ylabel(\"Pitch\")\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "ZU9Fp0ulvoqT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YzCMd94Tu_gz"
      },
      "source": [
        "# Congrats! You did it! :)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "private_outputs": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.7"
    },
    "gpuClass": "standard",
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}