LAMB_Explorer_and_Tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "LAMB_Explorer_and_Tutorial.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AzeU7rK66cyR"
      },
      "source": [
        "# Los Angeles MIDI MetaBase (LAMB) Explorer and Tutorial Notebook (ver. 1.0)\n",
        "\n",
        "***\n",
        "\n",
        "## Kilo-Scale MIDI MIR Meta Database\n",
        "\n",
        "## https://github.com/asigalov61/Los-Angeles-MIDI-Metabase\n",
        "\n",
        "***\n",
        "\n",
        "### Project Los Angeles\n",
        "\n",
        "### Tegridy Code 2021\n",
        "\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GbZnVWuU7A1Z"
      },
      "source": [
        "# Setup Environment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pQPzIzVVyYdA"
      },
      "source": [
        "# Install tegridy-tools\n",
        "\n",
        "!git clone https://github.com/asigalov61/tegridy-tools"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MQju2w1E0Dzw"
      },
      "source": [
        "# Import all needed modules\n",
        "\n",
        "os.chdir('/content/')\n",
        "print('Loading needed modules. Please wait...')\n",
        "\n",
        "import sys\n",
        "import os\n",
        "import copy\n",
        "import secrets\n",
        "import random\n",
        "import difflib\n",
        "import json\n",
        "from pathlib import Path\n",
        "import pickle\n",
        "\n",
        "os.chdir('/content/')\n",
        "\n",
        "if not os.path.exists('/content/Dataset'):\n",
        "    os.makedirs('/content/Dataset')\n",
        "\n",
        "if not os.path.exists('/content/Output'):\n",
        "    os.makedirs('/content/Output')\n",
        "\n",
        "os.chdir('/content/tegridy-tools/tegridy-tools')\n",
        "\n",
        "import TMIDI\n",
        "import TMIDIX\n",
        "import MIDI\n",
        "import HaystackSearch\n",
        "import tqdm\n",
        "\n",
        "os.chdir('/content/')\n",
        "print('Loading complete. Enjoy! :)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ix4k7j2dBrt5"
      },
      "source": [
        "# Download LAKH MIDI Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FFc9fn57XAiI"
      },
      "source": [
        "# Download and untar LAKH MIDI Dataset\n",
        "\n",
        "%cd /content/\n",
        "!wget http://hog.ee.columbia.edu/craffel/lmd/lmd_full.tar.gz\n",
        "!tar -xvf lmd_full.tar.gz\n",
        "%cd /content/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BO1GhixV0IIk"
      },
      "source": [
        "# Create/save list of dataset files and count all of them\n",
        "\n",
        "print('Loading MIDI files...')\n",
        "print('This may take a while on a large dataset in particular.')\n",
        "%cd /content/\n",
        "dataset_addr = \"/content/lmd_full\"\n",
        "os.chdir(dataset_addr)\n",
        "filez = list()\n",
        "for (dirpath, dirnames, filenames) in os.walk(dataset_addr):\n",
        "    filez += [os.path.join(dirpath, file) for file in filenames]\n",
        "print('=' * 70)\n",
        "filez_l = len(filez)\n",
        "print(len(filez))\n",
        "\n",
        "TMIDIX.Tegridy_Any_Pickle_File_Writer(filez, '/content/filez.pickle')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7BzFLBb9Bqjn"
      },
      "source": [
        "# LAMB Metabase"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pYQdDVtM8l0f"
      },
      "source": [
        "# Download and unzip Los Angeles MIDI Metabase (LAMB)\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/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.001'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.002'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.003'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.004'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.005'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.006'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.007'\n",
        "!wget 'https://github.com/asigalov61/Los-Angeles-MIDI-Metabase/raw/main/Metabase/Los-Angeles-MIDI-Metabase-210000.zip.008'\n",
        "\n",
        "!cat Los-Angeles-MIDI-Metabase-210000.zip* > Los-Angeles-MIDI-Metabase-210000.zip\n",
        "print('=' * 70)\n",
        "\n",
        "!unzip -j Los-Angeles-MIDI-Metabase-210000.zip\n",
        "print('=' * 70)\n",
        "\n",
        "print('Done! Enjoy! :)')\n",
        "print('=' * 70)\n",
        "%cd /content/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4IaJwPifEgKc"
      },
      "source": [
        "# Load the LAMB pickle file\n",
        "\n",
        "LAMB = TMIDIX.Tegridy_Any_Pickle_File_Reader('/content/Los-Angeles-MIDI-Metabase-210000')\n",
        "\n",
        "print('Done! :)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fo8qna3iCEFZ"
      },
      "source": [
        "# LAMB use example code/tutorial"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2kyW-uv7G6CH"
      },
      "source": [
        "# Now we are going to have some fun... :)\n",
        "\n",
        "# In the following excercise we are going to use LAMB to classify any source MIDI. \n",
        "# We are going to make a simple, yet powerful MIDI classifier (80%-90% accuracy)\n",
        "\n",
        "# Let's begin...\n",
        "\n",
        "# Load some MIDI file (absolutely any will do)\n",
        "song = TMIDIX.Optimus_MIDI_TXT_Processor('/content/tegridy-tools/tegridy-tools/seed-lyrics.mid', \n",
        "                                         MIDI_channel=-1, \n",
        "                                         MIDI_patch=range(0, 127))\n",
        "\n",
        "#  Compute some basic stats about it...\n",
        "song_len = len(song[2])\n",
        "song_start_times_avg = int(sum([y[1] for y in song[2]]) / song_len)\n",
        "song_durations_avg = int(sum([y[2] for y in song[2]]) / song_len)\n",
        "song_channels_avg = int(sum([y[3] for y in song[2]]) / song_len)\n",
        "song_pitches_avg = int(sum([y[4] for y in song[2]]) / song_len)\n",
        "song_velocities_avg = int(sum([y[5] for y in song[2]]) / song_len)\n",
        "\n",
        "# ...and create a matching MIDI signature to compare against the dataset\n",
        "Source_MIDI_Signature = [song_len, song_start_times_avg, \n",
        "                  song_durations_avg, song_channels_avg, \n",
        "                  song_pitches_avg, \n",
        "                  song_velocities_avg]\n",
        "\n",
        "# Check the resuilts. They should have similar structure \n",
        "# There should be 5 entries if you did everything right\n",
        "print('Source MIDI Signature:', Source_MIDI_Signature)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUHKMUOLFeAR"
      },
      "source": [
        "# Here is a simple MIDI classifier/code...\n",
        "\n",
        "sigs_match_ratings = []\n",
        "sig_match_rating2 = []\n",
        "\n",
        "for i in tqdm.tqdm(range(1, len(LAMB[2][1]))):\n",
        "  # Computing signatures for each dataset file...\n",
        "  Dataset_MIDI_Signature = [int(LAMB[2][1][i][0]),\n",
        "                            int(LAMB[2][1][i][1] / (LAMB[2][1][i][0]+1)),\n",
        "                            int(LAMB[2][1][i][2] / (LAMB[2][1][i][0]+1)),\n",
        "                            int(LAMB[2][1][i][3] / (LAMB[2][1][i][0]+1)),\n",
        "                            int(LAMB[2][1][i][4] / (LAMB[2][1][i][0]+1)),\n",
        "                            int(LAMB[2][1][i][5] / (LAMB[2][1][i][0]+1))]\n",
        "  # Computing ratings\n",
        "  sig_match_rating = difflib.SequenceMatcher(None, ' '.join(map(str, Source_MIDI_Signature[2:])), ' '.join(map(str, Dataset_MIDI_Signature[2:]))).ratio()\n",
        "  sigs_match_ratings.append(sig_match_rating)\n",
        "\n",
        "# Computing some info\n",
        "FNAME = LAMB[2][1][sigs_match_ratings.index(max(sigs_match_ratings))+1]\n",
        "INFO = LAMB[2][0][sigs_match_ratings.index(max(sigs_match_ratings))+1][1:3]\n",
        "\n",
        "# Info printout...\n",
        "print(chr(10))\n",
        "print(FNAME)\n",
        "print(INFO[0])\n",
        "print(INFO[1][0])\n",
        "print(INFO[1][1])\n",
        "print(sigs_match_ratings.index(max(sigs_match_ratings))+1)\n",
        "print(max(sigs_match_ratings))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xaw8N-QmYLjQ"
      },
      "source": [
        "# Simple code to search LAKH MIDI Dataset directory for MIDI matches\n",
        "\n",
        "# If nothing found, MIDI is most likely NOT from LAKH MIDI Dataset\n",
        "\n",
        "path = ''\n",
        "print('Searching LAKH for:', INFO[0])\n",
        "from pathlib import Path\n",
        "for path in Path('/content/lmd_full').rglob(INFO[0]):\n",
        "    print('File found!!!')\n",
        "    print('The file below is the best possible match with the source MIDI:')\n",
        "    print(path)\n",
        "\n",
        "if len(str(path)) == 0:\n",
        "  print('Could not locate the file. Check the code and the dataset.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mR5rmBlBBkhG"
      },
      "source": [
        "# Plot and Play your MIDI here"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TGLVX2QLIx3z"
      },
      "source": [
        "# stuff for listening and plotting the results\n",
        "\n",
        "!apt install fluidsynth #Pip does not work for some reason. Only apt works\n",
        "!pip install midi2audio\n",
        "!pip install pretty_midi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6VsDwfFwItgz"
      },
      "source": [
        "# Plot and Play your MIDI file here...\n",
        "\n",
        "# Full path to any MIDI file...\n",
        "MIDI_FILE_TO_PLAY = '/content/tegridy-tools/tegridy-tools/seed3.mid'\n",
        "\n",
        "# Code...\n",
        "from midi2audio import FluidSynth\n",
        "from IPython.display import display, Javascript, HTML, Audio\n",
        "import pretty_midi\n",
        "import librosa.display\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits import mplot3d\n",
        "import numpy as np\n",
        "os.chdir('/content/')\n",
        "print('Synthesizing the last output MIDI... ')\n",
        "fname = str(MIDI_FILE_TO_PLAY)\n",
        "\n",
        "fn = os.path.basename(MIDI_FILE_TO_PLAY)\n",
        "fn1 = fn.split('.')[0]\n",
        "\n",
        "print('Plotting the composition. Please wait...')\n",
        "\n",
        "pm = pretty_midi.PrettyMIDI(fname)\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(fn1)\n",
        "\n",
        "FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname), str('/content/composition' + '.wav'))\n",
        "Audio(str('/content/composition' + '.wav'), rate=16000)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}