[GC]_Morpheus.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "gradient": {
          "editing": false,
          "id": "ac5a4cf0-d9d2-47b5-9633-b53f8d99a4d2",
          "kernelId": ""
        },
        "id": "SiTIpPjArIyr"
      },
      "source": [
        "# Morpheus (ver. 1.0)\n",
        "\n",
        "***\n",
        "\n",
        "Powered by tegridy-tools TMIDIX Optimus Processors: 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 2021\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": {
        "cellView": "form",
        "gradient": {
          "editing": false,
          "id": "a1a45a91-d909-4fd4-b67a-5e16b971d179",
          "kernelId": ""
        },
        "id": "fX12Yquyuihc"
      },
      "outputs": [],
      "source": [
        "#@title Install all dependencies (run only once per session)\n",
        "\n",
        "!git clone https://github.com/asigalov61/tegridy-tools\n",
        "!pip install torch\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\n",
        "!pip install pretty_midi"
      ]
    },
    {
      "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",
        "from datetime import datetime\n",
        "import secrets\n",
        "import copy\n",
        "import tqdm as tqdm\n",
        "from tqdm import tqdm\n",
        "\n",
        "if not os.path.exists('/content/Dataset'):\n",
        "    os.makedirs('/content/Dataset')\n",
        "\n",
        "print('Loading TMIDIX module...')\n",
        "os.chdir('/content/tegridy-tools/tegridy-tools')\n",
        "import TMIDIX\n",
        "\n",
        "os.chdir('/content/tegridy-tools/tegridy-tools')\n",
        "from GPT2RGAX import *\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from midi2audio import FluidSynth\n",
        "import pretty_midi\n",
        "import librosa.display\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits import mplot3d\n",
        "\n",
        "from IPython.display import display, Javascript, HTML, Audio\n",
        "\n",
        "from google.colab import output, drive\n",
        "\n",
        "os.chdir('/content/')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ObPxlEutsQBj"
      },
      "source": [
        "# (MODEL)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Download 5-in-1 Morpheus Model\n",
        "\n",
        "#@markdown 9 MuseNet Instruments + Drums \n",
        "\n",
        "%cd /content/\n",
        "\n",
        "print('=' * 70)\n",
        "print('Downloading pre-trained dataset-model...Please wait...')\n",
        "print('=' * 70)\n",
        "\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.001\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.002\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.003\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.004\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.005\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.006\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.007\n",
        "!wget https://github.com/asigalov61/Morpheus/raw/main/Model/Morpheus-Trained-Model.zip.008\n",
        "\n",
        "\n",
        "\n",
        "!cat Morpheus-Trained-Model.zip* > Morpheus-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j Morpheus-Trained-Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/"
      ],
      "metadata": {
        "cellView": "form",
        "id": "hYz2P5Zmoobl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mdKFoeke9L7H"
      },
      "source": [
        "# (LOAD)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "gradient": {
          "id": "c83edd89-9a36-430a-9fa7-3a967417c88e",
          "kernelId": ""
        },
        "id": "OaNkGcFo9UP_"
      },
      "outputs": [],
      "source": [
        "#@title Load/Reload the model\n",
        "full_path_to_model_checkpoint = \"/content/Morpheus-Trained-Model.pth\" #@param {type:\"string\"}\n",
        "\n",
        "print('Loading the model...')\n",
        "config = GPTConfig(5640, \n",
        "                   max_seq,\n",
        "                   dim_feedforward=1024,\n",
        "                   n_layer=6, \n",
        "                   n_head=8, \n",
        "                   n_embd=1024,\n",
        "                   enable_rpr=True,\n",
        "                   er_len=max_seq)\n",
        "\n",
        "model = GPT(config).to(get_device())\n",
        "\n",
        "model.load_state_dict(torch.load(full_path_to_model_checkpoint))\n",
        "\n",
        "model.eval()\n",
        "print('Done!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UX1_5y5Fu8AH"
      },
      "source": [
        "# (GENERATE MUSIC)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MufDqdyBl4sa"
      },
      "source": [
        "## Custom MIDI option"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "gradient": {
          "id": "5f771604-39e7-431d-b1dd-86d7437b8872",
          "kernelId": ""
        },
        "id": "cOXRDAvOl4sa"
      },
      "outputs": [],
      "source": [
        "#@title Load your custom MIDI here\n",
        "full_path_tp_custom_MIDI = \"/content/tegridy-tools/tegridy-tools/seed2.mid\" #@param {type:\"string\"}\n",
        "print('=' * 70)\n",
        "\n",
        "print('Loading custom MIDI...')\n",
        "\n",
        "print('File name:', full_path_tp_custom_MIDI)\n",
        "\n",
        "data = TMIDIX.Optimus_MIDI_TXT_Processor(full_path_tp_custom_MIDI, \n",
        "                                         dataset_MIDI_events_time_denominator=10, \n",
        "                                         perfect_timings=True, \n",
        "                                         musenet_encoding=True, \n",
        "                                         char_offset=0, \n",
        "                                         MIDI_channel=16, \n",
        "                                         MIDI_patch=range(0, 127)\n",
        "                                        )\n",
        "print('=' * 70)\n",
        "print('Converting to INTs...')\n",
        "\n",
        "times = []\n",
        "pitches = []\n",
        "\n",
        "itimes = []\n",
        "ipitches = []\n",
        "\n",
        "melody = []\n",
        "\n",
        "SONG = data[5]\n",
        "inputs = []\n",
        "\n",
        "avg_vel = int(sum([y[4] for y in SONG]) / len(SONG))\n",
        "\n",
        "for i in SONG:\n",
        "    if max(i) < 256 and min(i) >= 0 and i[2] < 10:\n",
        "\n",
        "        if i[0] != 0:\n",
        "            inputs.extend([i[0] + (int(i[1] / 25) * 256)])\n",
        "            \n",
        "            melody.extend([i[0] + (int(i[1] / 25) * 256)])\n",
        "            \n",
        "            if i[4] > avg_vel:\n",
        "                melody.extend([(256 * 11) + 128 + (256 * i[2])+i[3]])\n",
        "            else:\n",
        "                melody.extend([(256 * 11) + (256 * i[2])+i[3]])\n",
        "\n",
        "            if i[2] < 10:\n",
        "              times.extend([i[0] + (int(i[1] / 25) * 256)])\n",
        "              \n",
        "              if i[4] > avg_vel:\n",
        "                  pitches.extend([(256 * 11) + 128 + (256 * i[2])+i[3]])\n",
        "              else:\n",
        "                  pitches.extend([(256 * 11) + (256 * i[2])+i[3]])\n",
        "\n",
        "        if i[4] > avg_vel:\n",
        "            inputs.extend([(256 * 11) + 128 + (256 * i[2])+i[3]])\n",
        "        else:\n",
        "            inputs.extend([(256 * 11) + (256 * i[2])+i[3]])\n",
        "        \n",
        "        if i[2] < 10:\n",
        "              itimes.extend([i[0] + (int(i[1] / 25) * 256)])\n",
        "              \n",
        "              if i[4] > avg_vel:\n",
        "                  ipitches.extend([(256 * 11) + 128 + (256 * i[2])+i[3]])\n",
        "              else:\n",
        "                  ipitches.extend([(256 * 11) + (256 * i[2])+i[3]])\n",
        "        pe = i\n",
        "\n",
        "print('=' * 70)\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "fname = full_path_tp_custom_MIDI.split('.')[0]\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname + '.mid')\n",
        "\n",
        "# Retrieve piano roll of the MIDI file\n",
        "piano_roll = pm.get_piano_roll()\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=160, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TOOBCgGQ2zoi"
      },
      "source": [
        "# Continuation Generation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "gradient": {
          "id": "97793d01-6a74-4e34-be95-ea337277b38d",
          "kernelId": ""
        },
        "id": "M_K93hWWv2Yx"
      },
      "outputs": [],
      "source": [
        "#@title Generate a continuation from a custom MIDI\n",
        "\n",
        "#@markdown NOTE: The first continuation sample may not be perfect, so generate several samples if you are not getting good results\n",
        "\n",
        "number_of_tokens_to_generate = 768 #@param {type:\"slider\", min:512, max:1024, step:8}\n",
        "priming_type = \"Custom MIDI\" #@param [\"Intro\", \"Outro\", \"Custom MIDI\"]\n",
        "custom_MIDI_trim_type = \"From Start\" #@param [\"From Start\", \"From End\"]\n",
        "number_of_instruments = 1 #@param {type:\"slider\", min:1, max:10, step:1}\n",
        "\n",
        "temperature = 1 #@param {type:\"slider\", min:0.1, max:1.3, step:0.1}\n",
        "\n",
        "\n",
        "#===================================================================\n",
        "\n",
        "tokens_range = (256 * 11) + (256 * number_of_instruments)\n",
        "\n",
        "fname = '/content/Morpheus-Music-Composition'\n",
        "\n",
        "print('Morpheus Music Model Continuation Generator')\n",
        "\n",
        "output_signature = 'Morpheus'\n",
        "song_name = 'RGA Composition'\n",
        "out = []\n",
        "\n",
        "print('=' * 70)\n",
        "print('Priming type:', priming_type)\n",
        "print('Custom MIDI trim type:', custom_MIDI_trim_type)\n",
        "print('Temperature:', temperature)\n",
        "print('Tokens range:', tokens_range)\n",
        "\n",
        "print('=' * 70)\n",
        "if priming_type == 'Intro':\n",
        "    rand_seq = model.generate(torch.Tensor([(256 * 11)+(256 * 11)-1, \n",
        "                                            (256 * 11)+(256 * 11)-3]), \n",
        "                                            target_seq_length=number_of_tokens_to_generate,\n",
        "                                            temperature=temperature,\n",
        "                                            stop_token=tokens_range,\n",
        "                                            verbose=True)\n",
        "    \n",
        "    out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "if priming_type == 'Outro':\n",
        "    rand_seq = model.generate(torch.Tensor([(256 * 11)+(256 * 11)-2]), \n",
        "                              target_seq_length=number_of_tokens_to_generate,\n",
        "                              temperature=temperature,\n",
        "                              stop_token=tokens_range,\n",
        "                              verbose=True)\n",
        "    \n",
        "    out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "if priming_type == 'Custom MIDI' and inputs != []:\n",
        "    out = []\n",
        "\n",
        "    if custom_MIDI_trim_type == 'From Start':\n",
        "      sequence = inputs[:512]\n",
        "    else:\n",
        "      sequence = inputs[-512:]\n",
        "\n",
        "    rand_seq = model.generate(torch.Tensor(sequence), \n",
        "                              target_seq_length=number_of_tokens_to_generate, \n",
        "                              temperature=temperature,\n",
        "                              stop_token=tokens_range,\n",
        "                              verbose=True)\n",
        "    \n",
        "    out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "if len(out) != 0:\n",
        "    song = []\n",
        "    song = out[len(sequence):]\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    duration = 0\n",
        "    once = True\n",
        "    for s in song:\n",
        "        if s >= 0 and s <= 256 * 11:\n",
        "            time += s % 256\n",
        "            dur = ((s // 256) + 1) * 250\n",
        "\n",
        "        if s >= 256 * 11 and s < (256 * 21):\n",
        "            if (s // 128) % 2 != 0:\n",
        "                vel = 80 + (s % 256) % 24\n",
        "                channel = ((s-128-(256*11)) // 256)\n",
        "            else:\n",
        "                vel = 64 + (s % 256) % 24\n",
        "                channel = ((s-(256*11)) // 256)\n",
        "\n",
        "            pitch = s % 256\n",
        "\n",
        "            song_f.append(['note', (abs(time))*10, dur, channel, pitch, vel ])\n",
        "\n",
        "            if song.index(s) >= len(sequence) and once:\n",
        "                song_f.append(['text_event', abs(time) * 10, 'Continuation Start Here'])\n",
        "                once = False\n",
        "\n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Morpheus',  \n",
        "                                                          output_file_name = '/content/Morpheus-Music-Composition', \n",
        "                                                          track_name='Project Los Angeles', \n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "else:\n",
        "  print('Models output is empty! Check the code...')\n",
        "  print('Shutting down...')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "fname = '/content/Morpheus-Music-Composition'\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname + '.mid')\n",
        "\n",
        "# Retrieve piano roll of the MIDI file\n",
        "piano_roll = pm.get_piano_roll()\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=160, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LvRYhK9WnySz"
      },
      "source": [
        "# Melody Generator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "ztt0yNhgnySz"
      },
      "outputs": [],
      "source": [
        "#@title Generate melody from the custom MIDI\n",
        "number_of_input_melody_notes = 64 #@param {type:\"slider\", min:16, max:256, step:16}\n",
        "number_of_instruments = 1 #@param {type:\"slider\", min:1, max:10, step:1} \n",
        "print('=' * 70)\n",
        "\n",
        "\n",
        "print('Morpheus Music Model Melody Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "song = []\n",
        "sng = melody[:number_of_input_melody_notes * 2]\n",
        "\n",
        "for i in tqdm(range(number_of_input_melody_notes)):\n",
        "  \n",
        "  if len(sng)+2  >= 1024:\n",
        "    break\n",
        "  \n",
        "\n",
        "  rand_seq = model.generate(torch.Tensor(sng), \n",
        "                              target_seq_length=len(sng) + 2,\n",
        "                              temperature=1,\n",
        "                              stop_token=(256*11)+(256 * number_of_instruments),\n",
        "                              verbose=False)\n",
        "\n",
        "  out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "  #if out[-2] < 256 * 11 and out[-1] > 256 * 11:\n",
        "  sng.extend(out[-2:])\n",
        "\n",
        "print('=' * 70)\n",
        "print('Converting to MIDI...')\n",
        "\n",
        "if len(sng) != 0:\n",
        "    song = []\n",
        "    song = sng[len(melody[:number_of_input_melody_notes * 2]):]\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    duration = 0\n",
        "    once = True\n",
        "    for s in song:\n",
        "        if s >= 0 and s <= 256 * 11:\n",
        "            time += s % 256\n",
        "            dur = ((s // 256) + 1) * 250\n",
        "\n",
        "        if s >= 256 * 11 and s < (256 * 21):\n",
        "            if (s // 128) % 2 != 0:\n",
        "                vel = 80 + (s % 256) % 24\n",
        "                channel = ((s-128-(256*11)) // 256)\n",
        "            else:\n",
        "                vel = 64 + (s % 256) % 24\n",
        "                channel = ((s-(256*11)) // 256)\n",
        "\n",
        "            pitch = s % 256\n",
        "\n",
        "            song_f.append(['note', (abs(time))*10, dur, channel, pitch, vel ])\n",
        "      \n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Morpheus',  \n",
        "                                                          output_file_name = '/content/Morpheus-Music-Composition', \n",
        "                                                          track_name='Project Los Angeles', \n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "fname = '/content/Morpheus-Music-Composition'\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname + '.mid')\n",
        "\n",
        "# Retrieve piano roll of the MIDI file\n",
        "piano_roll = pm.get_piano_roll()\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=160, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_RQi3EGweAO1"
      },
      "source": [
        "# Accompaniment Generation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rYEVUd-remHL"
      },
      "source": [
        "## Simple Accompaniment Generator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "j1WqkcfZeQX3"
      },
      "outputs": [],
      "source": [
        "#@title Generate an accompaniment for the custom MIDI\n",
        "#@markdown NOTE: The first accompaniment sample may not be perfect, so generate several samples if you are not getting good results\n",
        "\n",
        "number_of_input_melody_notes = 64 #@param {type:\"slider\", min:16, max:256, step:16}\n",
        "number_of_instruments = 10 #@param {type:\"slider\", min:1, max:10, step:1} \n",
        "number_of_prime_notes = 0 #@param {type:\"slider\", min:0, max:16, step:1}\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "\n",
        "print('Morpheus Music Model Accompaniment Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "song = []\n",
        "sng = []\n",
        "\n",
        "for i in range(number_of_prime_notes):\n",
        "    sng.append(times[i])\n",
        "    sng.append(pitches[i])\n",
        "    \n",
        "for i in tqdm(range(number_of_prime_notes, min(number_of_input_melody_notes, len(pitches)))):\n",
        "  \n",
        "  #if len(sng + [times[i], pitches[i]]) + 16 >= 1024:\n",
        "    #break\n",
        "  \n",
        "  rand_seq = model.generate(torch.Tensor(sng[-1006:] + [times[i], pitches[i]]), \n",
        "                              target_seq_length=len(sng[-1006:]) + 2 + 16, \n",
        "                              temperature=1,\n",
        "                              stop_token=(256*11)+(256 * number_of_instruments),\n",
        "                              verbose=False)\n",
        "    \n",
        "  out = rand_seq[0].cpu().numpy().tolist()\n",
        "\n",
        "  outy = []\n",
        "  \n",
        "  for o in out[len(sng[-1006:])+2:]:\n",
        "    if o >=256 * 11:\n",
        "      outy.append(o)\n",
        "    else:\n",
        "      break\n",
        "  sng.extend([times[i], pitches[i]])\n",
        "  sng.extend(outy)\n",
        "  # print(len(outy))\n",
        "\n",
        "print('=' * 70)\n",
        "print('Converting to MIDI...')\n",
        "\n",
        "if len(sng) != 0:\n",
        "    song = []\n",
        "    song = sng\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    duration = 0\n",
        "    once = True\n",
        "    for s in song:\n",
        "        if s >= 0 and s <= 256 * 11:\n",
        "            time += s % 256\n",
        "            dur = ((s // 256) + 1) * 250\n",
        "\n",
        "        if s >= 256 * 11 and s < (256 * 21):\n",
        "            if (s // 128) % 2 != 0:\n",
        "                vel = 80 + (s % 256) % 24\n",
        "                channel = ((s-128-(256*11)) // 256)\n",
        "            else:\n",
        "                vel = 64 + (s % 256) % 24\n",
        "                channel = ((s-(256*11)) // 256)\n",
        "\n",
        "            pitch = s % 256\n",
        "\n",
        "            song_f.append(['note', (abs(time))*10, dur, channel, pitch, vel ])\n",
        "      \n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Morpheus',  \n",
        "                                                          output_file_name = '/content/Morpheus-Music-Composition', \n",
        "                                                          track_name='Project Los Angeles', \n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "    print('Done!')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "fname = '/content/Morpheus-Music-Composition'\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname + '.mid')\n",
        "\n",
        "# Retrieve piano roll of the MIDI file\n",
        "piano_roll = pm.get_piano_roll()\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=160, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TgdoWM7lepkL"
      },
      "source": [
        "## Advanced Accompaniment Generator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "noW4aO8dOrmV"
      },
      "outputs": [],
      "source": [
        "#@title Generate an accompaniment for the custom MIDI\n",
        "#@markdown NOTE: The first accompaniment sample may not be perfect, so generate several samples if you are not getting good results\n",
        "\n",
        "number_of_input_melody_notes = 256 #@param {type:\"slider\", min:16, max:256, step:16}\n",
        "number_of_instruments = 10 #@param {type:\"slider\", min:1, max:10, step:1} \n",
        "minimum_beat_delta_time = 12 #@param {type:\"slider\", min:6, max:24, step:6}\n",
        "number_of_prime_notes = 0 #@param {type:\"slider\", min:0, max:16, step:1}\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "\n",
        "print('Morpheus Music Model Advanced Accompaniment Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "song = []\n",
        "sng = []\n",
        "tim = 0\n",
        "\n",
        "for i in range(number_of_prime_notes):\n",
        "    sng.append(times[i])\n",
        "    sng.append(pitches[i])\n",
        "\n",
        "for i in tqdm(range(number_of_prime_notes, min(number_of_input_melody_notes, len(pitches))-1)):\n",
        "  \n",
        "  #if len(sng) + 2 + 16 >= 1024:\n",
        "    #break\n",
        "  \n",
        "  rand_seq = model.generate(torch.Tensor(sng[-1006:] + [abs(times[i]-tim), pitches[i]]), \n",
        "                              target_seq_length=len(sng[-1006:]) + 2 + 16, \n",
        "                              stop_token=(256*11)+(256 * number_of_instruments),\n",
        "                              verbose=False)\n",
        "    \n",
        "  out = rand_seq[0].cpu().numpy().tolist()\n",
        "    \n",
        "  sng.extend([abs(times[i]-tim), pitches[i]])\n",
        "\n",
        "  outy = []\n",
        "  tim = 0\n",
        "\n",
        "  for o in out[len(sng[-1006:])+2:]:\n",
        "    if o >=(256*11):\n",
        "      outy.append(o)\n",
        "\n",
        "    else:\n",
        "      if ((times[i+1] % 256) -tim)  > o % 256 and o % 256 > minimum_beat_delta_time * 2:\n",
        "         outy.append(o)\n",
        "         tim += o % 256 \n",
        "      else:\n",
        "         break\n",
        "\n",
        "  sng.extend(outy)\n",
        "\n",
        "print('=' * 70)\n",
        "print('Converting to MIDI...')\n",
        "\n",
        "if len(sng) != 0:\n",
        "    song = []\n",
        "    song = sng\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    duration = 0\n",
        "    once = True\n",
        "    for s in song:\n",
        "        if s >= 0 and s <= 256 * 11:\n",
        "            time += s % 256\n",
        "            dur = ((s // 256) + 1) * 250\n",
        "\n",
        "        if s >= 256 * 11 and s < (256 * 21):\n",
        "            if (s // 128) % 2 != 0:\n",
        "                vel = 80 + (s % 256) % 24\n",
        "                channel = ((s-128-(256*11)) // 256)\n",
        "            \n",
        "            else:\n",
        "                vel = 64 + (s % 256) % 24\n",
        "                channel = ((s-(256*11)) // 256)\n",
        "\n",
        "            pitch = s % 256\n",
        "\n",
        "            song_f.append(['note', (abs(time))*10, dur, channel, pitch, vel ])\n",
        "          \n",
        "      \n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Morpheus',  \n",
        "                                                          output_file_name = '/content/Morpheus-Music-Composition', \n",
        "                                                          track_name='Project Los Angeles', \n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "else:\n",
        "  print('Models output is empty! Check the code...')\n",
        "  print('Shutting down...')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "fname = '/content/Morpheus-Music-Composition'\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname + '.mid')\n",
        "\n",
        "# Retrieve piano roll of the MIDI file\n",
        "piano_roll = pm.get_piano_roll()\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=160, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wHIRevpVnyS1"
      },
      "source": [
        "# Pitches Inpainting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Pjn7Lpt7nyS2"
      },
      "outputs": [],
      "source": [
        "#@title Generate pitches inpainting from custom MIDI time map\n",
        "number_of_input_melody_notes = 128 #@param {type:\"slider\", min:16, max:256, step:16}\n",
        "number_of_instruments = 1  #@param {type:\"slider\", min:1, max:10, step:1} \n",
        "number_of_prime_notes = 16 #@param {type:\"slider\", min:0, max:64, step:1}\n",
        "original_pitch_ratio = 4 #@param {type:\"slider\", min:1, max:10, step:1}\n",
        "\n",
        "print('=' * 70)\n",
        "\n",
        "\n",
        "print('Morpheus Music Model Pitches Inpainting Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "song = []\n",
        "sng = []\n",
        "tim = 0\n",
        "out = [0]\n",
        "\n",
        "for i in range(number_of_prime_notes):\n",
        "    sng.append(itimes[i])\n",
        "    sng.append(ipitches[i])\n",
        "\n",
        "for i in tqdm(range(number_of_prime_notes, min(number_of_input_melody_notes, len(ipitches))-1)):\n",
        "  \n",
        "  if len(sng) + 2 >= 1024:\n",
        "    break\n",
        "  \n",
        "  for j in range(100):\n",
        "\n",
        "      rand_seq = model.generate(torch.Tensor(sng + [abs(itimes[i]) ]), \n",
        "                                  target_seq_length=len(sng) + 2, \n",
        "                                  stop_token=(256*11)+(256 * number_of_instruments),\n",
        "                                  verbose=False)\n",
        "\n",
        "      out = rand_seq[0].cpu().numpy().tolist()\n",
        "        \n",
        "      if out[-1] > 256 * 11:\n",
        "        break\n",
        "    \n",
        "  sng.extend([abs(itimes[i])])\n",
        "  \n",
        "  if i % original_pitch_ratio == 0:\n",
        "    sng.extend([pitches[i]])\n",
        "  \n",
        "  else:\n",
        "    sng.extend([out[-1]])\n",
        "\n",
        "print('=' * 70)\n",
        "print('Converting to MIDI...')\n",
        "\n",
        "if len(sng) != 0:\n",
        "    song = []\n",
        "    song = sng\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 0\n",
        "    pitch = 0\n",
        "    duration = 0\n",
        "    once = True\n",
        "    for s in song:\n",
        "        if s >= 0 and s <= 256 * 11:\n",
        "            time += s % 256\n",
        "            dur = ((s // 256) + 1) * 250\n",
        "\n",
        "        if s >= 256 * 11 and s < (256 * 21):\n",
        "            if (s // 128) % 2 != 0:\n",
        "                vel = 80 + (s % 256) % 24\n",
        "                channel = ((s-128-(256*11)) // 256)\n",
        "            \n",
        "            else:\n",
        "                vel = 64 + (s % 256) % 24\n",
        "                channel = ((s-(256*11)) // 256)\n",
        "\n",
        "            pitch = s % 256\n",
        "\n",
        "            song_f.append(['note', (abs(time))*10, dur, channel, pitch, vel ])\n",
        "          \n",
        "      \n",
        "    detailed_stats = TMIDIX.Tegridy_SONG_to_MIDI_Converter(song_f,\n",
        "                                                          output_signature = 'Morpheus',  \n",
        "                                                          output_file_name = '/content/Morpheus-Music-Composition', \n",
        "                                                          track_name='Project Los Angeles', \n",
        "                                                          number_of_ticks_per_quarter=500)\n",
        "\n",
        "else:\n",
        "  print('Models output is empty! Check the code...')\n",
        "  print('Shutting down...')\n",
        "\n",
        "print('=' * 70)\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "fname = '/content/Morpheus-Music-Composition'\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname + '.mid')\n",
        "\n",
        "# Retrieve piano roll of the MIDI file\n",
        "piano_roll = pm.get_piano_roll()\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "librosa.display.specshow(piano_roll, x_axis='time', y_axis='cqt_note', fmin=1, hop_length=160, sr=16000, cmap=plt.cm.hot)\n",
        "plt.title(fname)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
        "Audio(str(fname + '.wav'), rate=16000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YzCMd94Tu_gz"
      },
      "source": [
        "# Congrats! You did it! :)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "machine_shape": "hm",
      "name": "[GC] Morpheus.ipynb",
      "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.8.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}