DeBussy_X.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# DeBussy X (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 2023\n",
        "\n",
        "***"
      ],
      "metadata": {
        "id": "gpy3qsulqHa5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GPU CHECK)"
      ],
      "metadata": {
        "id": "W_So4w8fqPGL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X3rABEpKCO02",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title NVIDIA GPU check\n",
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (SETUP ENVIRONMENT)"
      ],
      "metadata": {
        "id": "C0XxnXGFqVyh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vK40g6V_BTNj",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Install dependencies\n",
        "!git clone https://github.com/asigalov61/DeBussy-X\n",
        "!pip install torch\n",
        "!pip install einops\n",
        "!pip install torch-summary\n",
        "!pip install sklearn\n",
        "!pip install tqdm\n",
        "!pip install matplotlib\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works\n",
        "!pip install midi2audio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DzCOZU_gBiQV",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Import modules\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading core DeBussy X modules...')\n",
        "\n",
        "import os\n",
        "import pickle\n",
        "import random\n",
        "import secrets\n",
        "import statistics\n",
        "from time import time\n",
        "import tqdm\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading main DeBussy X modules...')\n",
        "import torch\n",
        "\n",
        "%cd /content/DeBussy-X\n",
        "\n",
        "import TMIDIX\n",
        "from lwa_transformer import *\n",
        "\n",
        "%cd /content/\n",
        "print('=' * 70)\n",
        "print('Loading aux DeBussy X modeules...')\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from torchsummary import summary\n",
        "from sklearn import metrics\n",
        "\n",
        "from midi2audio import FluidSynth\n",
        "from IPython.display import Audio, display\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('Enjoy! :)')\n",
        "print('=' * 70)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eI3aQtHzqSnp"
      },
      "source": [
        "# (LOAD MODEL)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Unzip Pre-Trained DeBussy X Model\n",
        "print('=' * 70)\n",
        "%cd /content/DeBussy-X/Model\n",
        "\n",
        "print('=' * 70)\n",
        "print('Unzipping pre-trained DeBussy X model...Please wait...')\n",
        "\n",
        "!cat /content/DeBussy-X/Model/DeBussy_X_Trained_Model.zip* > /content/DeBussy-X/Model/DeBussy_X_Trained_Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j /content/DeBussy-X/Model/DeBussy_X_Trained_Model.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/\n",
        "print('=' * 70)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "SqbxcFYVq63r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rDquonbXC2je",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load DeBussy X Model\n",
        "full_path_to_model_checkpoint = \"/content/DeBussy-X/Model/DeBussy_X_Trained_Model_14012_steps_1.4825_loss.pth\" #@param {type:\"string\"}\n",
        "\n",
        "print('=' * 70)\n",
        "print('Loading DeBussy X Pre-Trained Model...')\n",
        "print('Please wait...')\n",
        "print('=' * 70)\n",
        "print('Instantiating model...')\n",
        "\n",
        "SEQ_LEN = 2048\n",
        "\n",
        "# instantiate the model\n",
        "\n",
        "model = LocalTransformer(\n",
        "    num_tokens = 644,\n",
        "    dim = 1024,\n",
        "    depth = 32,\n",
        "    heads=12,\n",
        "    ff_mult=2,\n",
        "    causal = True,\n",
        "    local_attn_window_size = 512,\n",
        "    max_seq_len = SEQ_LEN\n",
        ")\n",
        "\n",
        "model = torch.nn.DataParallel(model)\n",
        "\n",
        "model.cuda()\n",
        "print('=' * 70)\n",
        "\n",
        "print('Loading model checkpoint...')\n",
        "\n",
        "model.load_state_dict(torch.load(full_path_to_model_checkpoint))\n",
        "print('=' * 70)\n",
        "\n",
        "model.eval()\n",
        "\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "\n",
        "# Model stats\n",
        "print('Model summary...')\n",
        "summary(model)\n",
        "\n",
        "# Plot Token Embeddings\n",
        "tok_emb = model.module.token_emb.weight.detach().cpu().tolist()\n",
        "\n",
        "tok_emb1 = []\n",
        "\n",
        "for t in tok_emb:\n",
        "    tok_emb1.append([abs(statistics.median(t))])\n",
        "\n",
        "cos_sim = metrics.pairwise_distances(\n",
        "   tok_emb1, metric='euclidean'\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/DeBussy-X-Tokens-Embeddings-Plot.png\", bbox_inches=\"tight\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (GENERATE)"
      ],
      "metadata": {
        "id": "7xNyANjZsCOi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Improv Generation\n",
        "\n",
        "#@markdown Generation settings\n",
        "\n",
        "number_of_tokens_tp_generate = 256 #@param {type:\"slider\", min:32, max:4064, step:32}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "\n",
        "#@markdown Other settings\n",
        "\n",
        "allow_model_to_stop_generation_if_needed = False #@param {type:\"boolean\"}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "print('=' * 70)\n",
        "print('DeBussy X Improv Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if allow_model_to_stop_generation_if_needed:\n",
        "  min_stop_token = 643\n",
        "else:\n",
        "  min_stop_token = 0\n",
        "\n",
        "outy = [643]\n",
        "\n",
        "print('Selected Improv sequence:')\n",
        "print(outy)\n",
        "print('=' * 70)\n",
        "\n",
        "inp = [outy] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "#start_time = time()\n",
        "\n",
        "out = model.module.generate(inp, \n",
        "                      number_of_tokens_tp_generate, \n",
        "                      temperature=temperature, \n",
        "                      return_prime=True, \n",
        "                      min_stop_token=min_stop_token, \n",
        "                      verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\n",
        "#print('Generation took', time() - start_time, \"seconds\")\n",
        "print('=' * 70)\n",
        "\n",
        "#======================================================================\n",
        "\n",
        "print('Rendering results...')\n",
        "print('=' * 70)\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(out1) != 0:\n",
        "    \n",
        "      song = out1\n",
        "      song_f = []\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      vel = 90\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "                      \n",
        "      for ss in song:\n",
        "        \n",
        "        if ss >= 0 and ss < 256:\n",
        "\n",
        "            time += ss * 8\n",
        "          \n",
        "        if ss >= 256 and ss < 512:\n",
        "\n",
        "            dur = (ss-256) * 16\n",
        "            \n",
        "        if ss >=512 and ss < 640:\n",
        "            \n",
        "            pitch = (ss-512)\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 = 'DeBussy X',  \n",
        "                                                          output_file_name = '/content/DeBussy-X-Music-Composition_'+str(i), \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",
        "\n",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/DeBussy-X-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "      for s in song_f:\n",
        "        x.append(s[1] / 1000)\n",
        "        y.append(s[4])\n",
        "        c.append(colors[s[3]])\n",
        "\n",
        "      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": "Jwxz-eaF0K1y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# (CUSTOM MIDI)"
      ],
      "metadata": {
        "id": "Gt03VtO6uKkb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4QXbFLsKqSnt",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Load Seed MIDI\n",
        "full_path_to_custom_seed_MIDI = \"\" #@param {type:\"string\"}\n",
        "\n",
        "f = full_path_to_custom_seed_MIDI\n",
        "\n",
        "print('=' * 70)\n",
        "print('DeBussy X Seed MIDI Loader')\n",
        "print('=' * 70)\n",
        "print('Loading seed MIDI...')\n",
        "print('=' * 70)\n",
        "print('File:', f)\n",
        "print('=' * 70)\n",
        "\n",
        "#=======================================================\n",
        "# START PROCESSING\n",
        "\n",
        "# Convering MIDI to ms score with MIDI.py module\n",
        "score = TMIDIX.midi2ms_score(open(f, 'rb').read())\n",
        "\n",
        "# INSTRUMENTS CONVERSION CYCLE\n",
        "events_matrix1 = []\n",
        "melody_chords_f = []\n",
        "melody_chords_f1 = []\n",
        "\n",
        "itrack = 1\n",
        "\n",
        "while itrack < len(score):\n",
        "  for event in score[itrack]:         \n",
        "      if event[0] == 'note' and event[3] != 9:\n",
        "          events_matrix1.append(event)\n",
        "  itrack += 1\n",
        "\n",
        "events_matrix1.sort(key=lambda x: x[1])\n",
        "\n",
        "#=======================================================\n",
        "# PRE-PROCESSING\n",
        "\n",
        "if len(events_matrix1) > 0:\n",
        "\n",
        "    # recalculating timings\n",
        "    for e in events_matrix1:\n",
        "        e[1] = int(e[1] / 8) # Max 2 seconds for start-times\n",
        "        e[2] = int(e[2] / 16) # Max 4 seconds for durations\n",
        "\n",
        "    # Sorting by pitch, then by start-time\n",
        "    events_matrix1.sort(key=lambda x: x[4], reverse=True)\n",
        "    events_matrix1.sort(key=lambda x: x[1])\n",
        "\n",
        "    #=======================================================\n",
        "    # FINAL PRE-PROCESSING\n",
        "\n",
        "    melody_chords = []\n",
        "\n",
        "    pe = events_matrix1[0]\n",
        "\n",
        "    for e in events_matrix1:\n",
        "      if e[1] >= 0 and e[2] > 0:\n",
        "\n",
        "        # Cliping all values...\n",
        "        time = max(0, min(255, e[1]-pe[1]))             \n",
        "        dur = max(1, min(255, e[2]))\n",
        "        cha = 0\n",
        "        ptc = max(1, min(127, e[4]))\n",
        "\n",
        "        # Writing final note \n",
        "        melody_chords.append([time, dur, ptc])\n",
        "\n",
        "\n",
        "        pe = e\n",
        "\n",
        "    if len([y for y in melody_chords if y[2] != 9]) > 12: # Filtering out tiny/bad MIDIs...\n",
        "\n",
        "      times = [y[0] for y in melody_chords[12:]]\n",
        "      avg_time = sum(times) / len(times)\n",
        "\n",
        "      if avg_time < 96: # Filtering out bad MIDIs...\n",
        "\n",
        "            #=======================================================\n",
        "            # FINAL PROCESSING\n",
        "            #=======================================================\n",
        "\n",
        "            # \n",
        "\n",
        "            #=======================================================\n",
        "\n",
        "            cho = []\n",
        "            chords = []\n",
        "\n",
        "            for m in melody_chords:\n",
        "                if m[0] == 0:\n",
        "                    if m not in cho:\n",
        "                        cho.append(m)\n",
        "                else:\n",
        "                    if len(cho) > 0:\n",
        "                        cho.sort(key=lambda x: x[2], reverse=True)\n",
        "                        chords.append(cho)\n",
        "                    cho = []\n",
        "                    if m not in cho:\n",
        "                        cho.append(m)\n",
        "\n",
        "            if len(cho) > 0:\n",
        "                cho.sort(key=lambda x: x[2], reverse=True)\n",
        "                chords.append(cho)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "            #=======================================================\n",
        "            # MAIN PROCESSING CYCLE\n",
        "            #=======================================================\n",
        "\n",
        "            chords_count = 0\n",
        "            melody_chords_f = []\n",
        "            melody_chords_f.extend([643]) # Zero token\n",
        "\n",
        "            for c in chords:\n",
        "                if len(chords) - chords_count == 200:\n",
        "                    melody_chords_f.extend([642]) # Outro Token\n",
        "\n",
        "                if len(c) == 1:\n",
        "                    melody_chords_f.extend([640]) # Note\n",
        "                else:\n",
        "                    melody_chords_f.extend([641]) # Chord\n",
        "\n",
        "                time = c[0][0]\n",
        "                dur = c[0][1]\n",
        "\n",
        "                melody_chords_f.extend([time, dur+256])\n",
        "\n",
        "                for cc in c:\n",
        "\n",
        "                    ptc = cc[2]\n",
        "\n",
        "                    melody_chords_f.extend([ptc+512])\n",
        "                    melody_chords_f1.extend([ptc+512])\n",
        "\n",
        "                chords_count += 1\n",
        "\n",
        "#=======================================================\n",
        "\n",
        "if len(melody_chords_f) != 0:\n",
        "  \n",
        "    song = melody_chords_f\n",
        "    song_f = []\n",
        "    time = 0\n",
        "    dur = 0\n",
        "    vel = 90\n",
        "    pitch = 0\n",
        "    channel = 0\n",
        "                    \n",
        "    for ss in song:\n",
        "      \n",
        "      if ss >= 0 and ss < 256:\n",
        "\n",
        "          time += ss * 8\n",
        "        \n",
        "      if ss >= 256 and ss < 512:\n",
        "\n",
        "          dur = (ss-256) * 16\n",
        "          \n",
        "      if ss >=512 and ss < 640:\n",
        "          \n",
        "          pitch = (ss-512)\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 = 'DeBussy X',  \n",
        "                                                      output_file_name = '/content/DeBussy-X-Seed-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",
        "#=======================================================\n",
        "\n",
        "print('=' * 70)\n",
        "print('Composition stats:')\n",
        "print('Composition has', len(melody_chords_f1), 'notes')\n",
        "print('Composition has', len(melody_chords_f), 'tokens')\n",
        "print('=' * 70)\n",
        "\n",
        "print('Displaying resulting composition...')\n",
        "print('=' * 70)\n",
        "\n",
        "fname = '/content/DeBussy-X-Seed-Composition'\n",
        "\n",
        "x = []\n",
        "y =[]\n",
        "c = []\n",
        "\n",
        "colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "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()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dkvXYwR_qSnx",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title Standard/Simple Continuation\n",
        "\n",
        "number_of_prime_tokens = 256 #@param {type:\"slider\", min:4, max:2048, step:4}\n",
        "number_of_tokens_to_generate = 256 #@param {type:\"slider\", min:32, max:2048, step:32}\n",
        "number_of_batches_to_generate = 4 #@param {type:\"slider\", min:1, max:16, step:1}\n",
        "include_prime_tokens_in_generated_output = True #@param {type:\"boolean\"}\n",
        "allow_model_to_stop_generation_if_needed = False #@param {type:\"boolean\"}\n",
        "temperature = 0.8 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
        "\n",
        "print('=' * 70)\n",
        "print('DeBussy X Standard Model Generator')\n",
        "print('=' * 70)\n",
        "\n",
        "if allow_model_to_stop_generation_if_needed:\n",
        "  min_stop_token = 643\n",
        "else:\n",
        "  min_stop_token = 0\n",
        "\n",
        "outy = melody_chords_f[:number_of_prime_tokens]\n",
        "\n",
        "inp = [outy] * number_of_batches_to_generate\n",
        "\n",
        "inp = torch.LongTensor(inp).cuda()\n",
        "\n",
        "#start_time = time()\n",
        "\n",
        "out = model.module.generate(inp, \n",
        "                      number_of_tokens_to_generate, \n",
        "                      temperature=temperature, \n",
        "                      return_prime=include_prime_tokens_in_generated_output, \n",
        "                      min_stop_token=min_stop_token, \n",
        "                      verbose=True)\n",
        "\n",
        "out0 = out.tolist()\n",
        "print('=' * 70)\n",
        "print('Done!')\n",
        "print('=' * 70)\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(out1) != 0:\n",
        "  \n",
        "      song = out1\n",
        "      song_f = []\n",
        "      time = 0\n",
        "      dur = 0\n",
        "      vel = 90\n",
        "      pitch = 0\n",
        "      channel = 0\n",
        "                      \n",
        "      for ss in song:\n",
        "        \n",
        "        if ss >= 0 and ss < 256:\n",
        "\n",
        "            time += ss * 8\n",
        "          \n",
        "        if ss >= 256 and ss < 512:\n",
        "\n",
        "            dur = (ss-256) * 16\n",
        "            \n",
        "        if ss >=512 and ss < 640:\n",
        "            \n",
        "            pitch = (ss-512)\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 = 'DeBussy X',  \n",
        "                                                          output_file_name = '/content/DeBussy-X-Music-Composition_'+str(i), \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",
        "      print('=' * 70)\n",
        "      print('Displaying resulting composition...')\n",
        "      print('=' * 70)\n",
        "\n",
        "      fname = '/content/DeBussy-X-Music-Composition_'+str(i)\n",
        "\n",
        "      x = []\n",
        "      y =[]\n",
        "      c = []\n",
        "\n",
        "      colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver']\n",
        "\n",
        "      for s in song_f:\n",
        "        x.append(s[1] / 1000)\n",
        "        y.append(s[4])\n",
        "        c.append(colors[s[3]])\n",
        "\n",
        "      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() "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Congrats! You did it! :)"
      ],
      "metadata": {
        "id": "eoWDEy6CwDr6"
      }
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "private_outputs": true,
      "provenance": []
    },
    "gpuClass": "premium",
    "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.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}