DL_Final_Preprocessing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "DL Final Preprocessing.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/QuinnStraus/CSCI-1470-final/blob/main/DL_Final_Preprocessing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_VW1PbEcO_I",
        "outputId": "57dbc794-30b2-413b-ef11-8b02590ebb7d"
      },
      "source": [
        " pip install pypianoroll"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pypianoroll\n",
            "  Downloading pypianoroll-1.0.4-py3-none-any.whl (26 kB)\n",
            "Requirement already satisfied: matplotlib>=1.5 in /usr/local/lib/python3.7/dist-packages (from pypianoroll) (3.2.2)\n",
            "Requirement already satisfied: scipy>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from pypianoroll) (1.4.1)\n",
            "Collecting pretty-midi>=0.2.8\n",
            "  Downloading pretty_midi-0.2.9.tar.gz (5.6 MB)\n",
            "\u001b[K     |████████████████████████████████| 5.6 MB 4.5 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.12.0 in /usr/local/lib/python3.7/dist-packages (from pypianoroll) (1.19.5)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=1.5->pypianoroll) (0.11.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=1.5->pypianoroll) (1.3.2)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=1.5->pypianoroll) (2.8.2)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib>=1.5->pypianoroll) (3.0.6)\n",
            "Collecting mido>=1.1.16\n",
            "  Downloading mido-1.2.10-py2.py3-none-any.whl (51 kB)\n",
            "\u001b[K     |████████████████████████████████| 51 kB 6.5 MB/s \n",
            "\u001b[?25hRequirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from pretty-midi>=0.2.8->pypianoroll) (1.15.0)\n",
            "Building wheels for collected packages: pretty-midi\n",
            "  Building wheel for pretty-midi (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pretty-midi: filename=pretty_midi-0.2.9-py3-none-any.whl size=5591953 sha256=6895c2c282f9ba5023494352d067aa4e7d2f2a2c07d46ac8e0103ca0a539e74e\n",
            "  Stored in directory: /root/.cache/pip/wheels/ad/74/7c/a06473ca8dcb63efb98c1e67667ce39d52100f837835ea18fa\n",
            "Successfully built pretty-midi\n",
            "Installing collected packages: mido, pretty-midi, pypianoroll\n",
            "Successfully installed mido-1.2.10 pretty-midi-0.2.9 pypianoroll-1.0.4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKhP0KJ0TX-Y"
      },
      "source": [
        "import pypianoroll\n",
        "import os\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import json\n",
        "import math\n",
        "from music21 import *\n",
        "import pdb\n"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SvcFgJKTzArr",
        "outputId": "23eed7c5-f334-4557-c4e4-a773cb65b4d4"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount(\"/content/gdrive/\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive/\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xI4sE-8U0HC1",
        "outputId": "fe6075bb-1f8e-4446-fa70-f231a1560679"
      },
      "source": [
        "!ls 'gdrive/Shared drives/CSCI1470 Final Project'\n",
        "root_dir = 'gdrive/Shared drives/CSCI1470 Final Project'\n",
        "data_dir = 'gdrive/Shared drives/CSCI1470 Final Project/lpd_5/lpd_5_cleansed'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " cleansed_ids.txt\t\t   lpd_5\t    msd_tagtraum_cd1.cls\n",
            "'Final Write Up Reflection.gdoc'   midi_info.json   songs.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ACFCc8tUVr7D"
      },
      "source": [
        "# Creates dict of song IDs with genres\n",
        "\n",
        "genre_file_dir = os.path.join(root_dir, 'msd_tagtraum_cd1.cls')\n",
        "ids = []\n",
        "genres = []\n",
        "with open(genre_file_dir) as f:\n",
        "    line = f.readline()\n",
        "    while line:\n",
        "        if line[0] != '#':\n",
        "            split = line.strip().split(\"\\t\")\n",
        "            if len(split) == 2:\n",
        "                ids.append(split[0])\n",
        "                genres.append(split[1])\n",
        "            elif len(split) == 3:\n",
        "                ids.append(split[0]) \n",
        "                ids.append(split[0])\n",
        "                genres.append(split[1])\n",
        "                genres.append(split[2])\n",
        "        line = f.readline()\n",
        "genre_df = pd.DataFrame(data={\"TrackID\": ids, \"Genre\": genres})\n",
        "\n",
        "genre_dict = genre_df.groupby('TrackID')['Genre'].apply(lambda x: x.tolist()).to_dict()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8nOgjWm-ekwJ",
        "outputId": "f628bd47-5847-48d0-a1e6-4e4609e6f051"
      },
      "source": [
        "# copied the path functions from the article\n",
        "# Utility functions for retrieving paths\n",
        "def msd_id_to_dirs(msd_id):\n",
        "    \"\"\"Given an MSD ID, generate the path prefix.\n",
        "    E.g. TRABCD12345678 -> A/B/C/TRABCD12345678\"\"\"\n",
        "    return os.path.join(msd_id[2], msd_id[3], msd_id[4], msd_id)\n",
        "\n",
        "# Load the midi npz file from the LMD cleansed folder\n",
        "def get_midi_npz_path(msd_id, midi_md5):\n",
        "    return os.path.join(data_dir,\n",
        "                        msd_id_to_dirs(msd_id), midi_md5 + '.npz')\n",
        "    \n",
        "# Load the midi file from the Music Dataset folder\n",
        "#def get_midi_path(msd_id, midi_md5):\n",
        "#    return os.path.join(music_dataset_lpd_dir,\n",
        "#                        msd_id_to_dirs(msd_id), midi_md5 + '.mid')\n",
        "    \n",
        "# Open the cleansed ids - cleansed file ids : msd ids\n",
        "cleansed_ids = pd.read_csv(os.path.join(root_dir, 'cleansed_ids.txt'), delimiter = '    ', header = None)\n",
        "lpd_to_msd_ids = {a:b for a, b in zip(cleansed_ids[0], cleansed_ids[1])}\n",
        "msd_to_lpd_ids = {a:b for a, b in zip(cleansed_ids[1], cleansed_ids[0])}\n",
        "print(len(msd_to_lpd_ids))\n",
        "\n",
        "# Creates list of all ids with Pop Rock genre tag\n",
        "\n",
        "pop_ids = {}\n",
        "for tag in msd_to_lpd_ids.keys():\n",
        "  if tag in genre_dict:\n",
        "    if 'Pop_Rock' in genre_dict.get(tag):\n",
        "      pop_ids[tag] = msd_to_lpd_ids.get(tag)\n",
        "print(len(pop_ids))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:19: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21425\n",
            "2423\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4aAQLLNvX3-"
      },
      "source": [
        "# DO NOT RUN!!\n",
        "\n",
        "# converts npz files to midi files, no need to run again as all midi files already saved\n",
        "\n",
        "for msd_file_name in cleansed_ids[1]:\n",
        "  lpd_file_name = msd_to_lpd_ids[msd_file_name] \n",
        "  # msd_file_name ex: TRLOCTJ12903CDEC24, lpd_file_name: 6b16a2b1720d11263069a9a189785dfb\n",
        "  npz_path = get_midi_npz_path(msd_file_name, lpd_file_name)\n",
        "  multitrack = pypianoroll.load(npz_path)\n",
        "  pm = pypianoroll.to_pretty_midi(multitrack)\n",
        "  new_midi_path = npz_path[:-4] + '.mid'\n",
        "  pypianoroll.write(new_midi_path, multitrack)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mLwOXh1RW5sV"
      },
      "source": [
        "# These hyperparameters determine what section of the song is encoded\n",
        "\n",
        "START_IND = 0\n",
        "NUM_TOKENS = 510\n",
        "\n",
        "# Converts file name to pypianoroll\n",
        "def get_midi(msd):\n",
        "  lpd_file_name = pop_ids[msd]\n",
        "  npz_path = get_midi_npz_path(msd, lpd_file_name)\n",
        "  new_midi_path = npz_path[:-4] + '.npz'\n",
        "  return(pypianoroll.load(new_midi_path))\n",
        "\n",
        "# Helper function that combines instruments, returns matrix of pitches\n",
        "def merge_instruments(multitrack):\n",
        "  size = multitrack.get_max_length()\n",
        "  out = np.zeros([size, 128])\n",
        "  for track in multitrack.pad_to_same().tracks:\n",
        "    if track.is_drum == False:\n",
        "      out += track\n",
        "  return out\n",
        "\n",
        "# Helper function that takes an array of notes and converts into string of tokens of pitch and duration\n",
        "def tokenize(part, spaces = False): \n",
        "  if spaces:\n",
        "    space = ' '\n",
        "  else:\n",
        "    space = ''\n",
        "  out = ''\n",
        "  br_count = 0\n",
        "  tokens = 0\n",
        "  note = START_IND\n",
        "  # Counts out and produces tokens\n",
        "  while tokens <= NUM_TOKENS and note < len(part):\n",
        "    out_note = ''\n",
        "    pitches = part[note].nonzero()[0]\n",
        "    for pitch in pitches:\n",
        "      if note == START_IND or part[note - 1, pitch] == 0:\n",
        "        duration = 1\n",
        "        holding = True\n",
        "        # Find duration of note\n",
        "        while holding:\n",
        "          if note + duration < len(part):\n",
        "            if part[note + duration, pitch] != 0:\n",
        "              duration += 1\n",
        "            else:\n",
        "              holding = False\n",
        "          else:\n",
        "            holding = False\n",
        "        out_note += str(pitch) + space + 'd' + str(duration) + ' '\n",
        "        if spaces:\n",
        "          tokens += 2\n",
        "        else:\n",
        "          tokens += 1\n",
        "    # Add breaks\n",
        "    if out_note != '':\n",
        "      if br_count != 0:\n",
        "        out_note = 'br' + space + 'd' + str(br_count) + ' ' + out_note\n",
        "        br_count = 0\n",
        "        if spaces:\n",
        "          tokens += 2\n",
        "        else:\n",
        "          tokens += 1\n",
        "    br_count += 1\n",
        "    out += out_note\n",
        "    note += 1\n",
        "  return out"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wsg9vzHvkKIW"
      },
      "source": [
        "# pypianoroll converting files to tokens\n",
        "\n",
        "# save songs to text file after tokenizing the midi files\n",
        "allSongs = []\n",
        "stopInd = 50\n",
        "song_ind = 0\n",
        "f = open(os.path.join(root_dir, \"songs.txt\"), \"w\")\n",
        "for msd in pop_ids.keys():\n",
        "  elt_ind = 0\n",
        "  midi = get_midi(msd)\n",
        "  if song_ind %20 == 0: \n",
        "    print(song_ind)\n",
        "  #open midi file and select piano part\n",
        "  res = 8\n",
        "  rolls = midi.set_resolution(res)\n",
        "  part = merge_instruments(rolls)\n",
        "  #pypianoroll.plot(pypianoroll.StandardTrack(pianoroll = part[10*4*res:15*4*res]))\n",
        "  output = tokenize(part, spaces = False)\n",
        "  if output != '':\n",
        "    f.write(output)\n",
        "    f.write('\\n') \n",
        "  song_ind+=1\n",
        "  #if song_ind % stopInd == 0:\n",
        "    #print(song_ind)\n",
        "f.close()\n",
        "    #break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rkA0PcdBSMmE"
      },
      "source": [
        "# Takes in a string of tokens representing one song, transforms into a pianoroll matrix\n",
        "def token_to_music(tokens):\n",
        "  token_list = tokens.replace(\" d\", \"d\").split()\n",
        "  mat = np.full([1, 128], False)\n",
        "  note = 0\n",
        "  for tk in token_list:\n",
        "    pitch_dur = tk.split('d')\n",
        "    if len(pitch_dur) == 2:\n",
        "      pitch = tk.split('d')[0]\n",
        "      dur = int(tk.split('d')[1])\n",
        "      if pitch == 'br':\n",
        "        note += dur\n",
        "      else:\n",
        "        for i in range(dur):\n",
        "          while note + i >= mat.shape[0]:\n",
        "            mat = np.append(mat, np.full([1, 128], False), axis = 0)\n",
        "          mat[note + i, int(pitch)] = True\n",
        "  return mat"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cMPRx6CDTbZ_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "56432f36-bf15-49b0-c94b-604e01c455ab"
      },
      "source": [
        "# Tests for token_to_music\n",
        "song_ind = 0\n",
        "for msd in pop_ids.keys():\n",
        "  print(msd)\n",
        "  roll = get_midi('TRUZHFD128F429C33B')\n",
        "  roll = roll.set_resolution(4)\n",
        "  part = merge_instruments(roll)[0:80]\n",
        "  tokenized = tokenize(part, True)\n",
        "  other_roll = pypianoroll.binarize(pypianoroll.Track(pianoroll = part)).pianoroll\n",
        "  print(token_to_music(tokenized).shape)\n",
        "  print(other_roll.shape)\n",
        "  print(np.all(token_to_music(tokenized) == other_roll))\n",
        "  song_ind += 1\n",
        "  if song_ind % 2 == 0:\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "TRKIZWL128EF342C5A\n",
            "(80, 128)\n",
            "(80, 128)\n",
            "True\n",
            "TRMJSWT12903CA8AE1\n",
            "(80, 128)\n",
            "(80, 128)\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ryf1m9qAfn0O",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e2f7bc5-a2b9-4ea5-feef-52c88591e239"
      },
      "source": [
        "roll = get_midi('TRMJSWT12903CA8AE1')\n",
        "roll = roll.set_resolution(4)\n",
        "part = merge_instruments(roll)[0:200]\n",
        "tokenized = tokenize(part)\n",
        "print(tokenized)\n",
        "track = pypianoroll.BinaryTrack(pianoroll=token_to_music(tokenized)) #fill in \"\" with tokens \n",
        "                                \n",
        "#pypianoroll.write(os.path.join(root_dir, \"output.mid\"), pypianoroll.Multitrack(resolution = 4, tempo = np.full([200, 1], 120), tracks = [track]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "brd158 35d3 47d3 54d3 brd2 37d3 49d3 56d3 brd6 35d3 47d3 54d3 brd2 37d3 49d3 56d3 brd6 35d3 47d3 54d3 brd2 37d3 49d3 56d3 brd2 47d1 48d1 brd1 44d2 45d1 46d1 brd1 41d1 42d1 43d1 brd1 40d1 brd7 48d1 49d1 brd1 45d2 46d1 47d1 brd1 42d1 43d1 44d1 brd1 39d2 40d1 41d4 brd1 29d3 38d1 48d3 53d3 brd2 30d6 42d6 49d6 54d6 \n"
          ]
        }
      ]
    }
  ]
}