Upload 10 files

Los_Angeles_MIDI_Dataset_Search_and_Explore.ipynb

@@ -11,7 +11,7 @@
         "id": "SiTIpPjArIyr"
       },
       "source": [
-        "# Los Angeles MIDI Dataset: Search and Explore (ver. 2.2)\n",
+        "# Los Angeles MIDI Dataset: Search and Explore (ver. 3.0)\n",
         "\n",
         "***\n",
         "\n",
@@ -145,23 +145,6 @@
         "\n",
         "#================================================\n",
         "\n",
-        "%cd /content/Los-Angeles-MIDI-Dataset/MIDI-MATRIXES\n",
-        "\n",
-        "print('=' * 70)\n",
-        "print('Unzipping MIDI-MATRIXES...Please wait...')\n",
-        "\n",
-        "!cat LAMDa_MIDI_MATRIXES.zip* > LAMDa_MIDI_MATRIXES.zip\n",
-        "print('=' * 70)\n",
-        "\n",
-        "!unzip -j LAMDa_MIDI_MATRIXES.zip\n",
-        "print('=' * 70)\n",
-        "\n",
-        "print('Done! Enjoy! :)')\n",
-        "print('=' * 70)\n",
-        "%cd /content/\n",
-        "\n",
-        "#==================================================\n",
-        "\n",
         "%cd /content/Los-Angeles-MIDI-Dataset/TOTALS\n",
         "\n",
         "print('=' * 70)\n",
@@ -192,10 +175,6 @@
         "meta_data = pickle.load(open('/content/Los-Angeles-MIDI-Dataset/META-DATA/LAMDa_META_DATA.pickle', 'rb'))\n",
         "print('Done!')\n",
         "print('=' * 70)\n",
-        "print('Loading LAMDa MIDI-MATRIXES...')\n",
-        "midi_matrixes = pickle.load(open('/content/Los-Angeles-MIDI-Dataset/MIDI-MATRIXES/LAMDa_MIDI_MATRIXES.pickle', 'rb'))\n",
-        "print('Done!')\n",
-        "print('=' * 70)\n",
         "print('Loading LAMDa TOTALS...')\n",
         "totals = pickle.load(open('/content/Los-Angeles-MIDI-Dataset/TOTALS/LAMDa_TOTALS.pickle', 'rb'))\n",
         "print('Done!')\n",
@@ -227,10 +206,10 @@
         "print('Downloading Los Angeles MIDI Dataset...Please wait...')\n",
         "print('=' * 70)\n",
         "\n",
-        "hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset', \n",
-        "                filename='Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip',\n",
+        "hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset',\n",
+        "                filename='Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip',\n",
         "                repo_type=\"dataset\",\n",
-        "                local_dir='/content/LAMD', \n",
+        "                local_dir='/content/LAMD',\n",
         "                local_dir_use_symlinks=False)\n",
         "print('=' * 70)\n",
         "print('Done! Enjoy! :)')\n",
@@ -251,7 +230,7 @@
         "\n",
         "print('=' * 70)\n",
         "print('Unzipping Los Angeles MIDI Dataset...Please wait...')\n",
-        "!unzip 'Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip'\n",
+        "!unzip 'Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip'\n",
         "print('=' * 70)\n",
         "\n",
         "print('Done! Enjoy! :)')\n",
@@ -316,7 +295,7 @@
         "#@title Plot totals from MIDI matrixes (legacy)\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      totals[0][0][4] \n",
+        "      totals[0][0][4]\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
@@ -329,7 +308,7 @@
         "plt.plot()\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      totals[0][0][5] \n",
+        "      totals[0][0][5]\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
@@ -342,7 +321,7 @@
         "plt.plot()\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      totals[0][0][6] \n",
+        "      totals[0][0][6]\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
@@ -355,7 +334,7 @@
         "plt.plot()\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      totals[0][0][7] \n",
+        "      totals[0][0][7]\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
@@ -368,7 +347,7 @@
         "plt.plot()\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      totals[0][0][8] \n",
+        "      totals[0][0][8]\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
@@ -381,7 +360,7 @@
         "plt.plot()\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      totals[0][0][9] \n",
+        "      totals[0][0][9]\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(cos_sim, cmap=\"inferno\", interpolation=\"none\")\n",
@@ -419,8 +398,8 @@
         "plt.plot(y, pitches_counts_totals)\n",
         "\n",
         "plt.title('MIDI Instruments Pitches')\n",
-        "plt.xlabel(\"Ratio\")\n",
-        "plt.ylabel(\"Pitch\")\n",
+        "plt.xlabel(\"Pitch\")\n",
+        "plt.ylabel(\"Count\")\n",
         "plt.tight_layout()\n",
         "plt.plot()\n",
         "\n",
@@ -437,15 +416,15 @@
         "  x += 1\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      sim_mat \n",
+        "      sim_mat\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(sim_mat, cmap=\"inferno\", interpolation=\"none\")\n",
         "im_ratio = 1\n",
         "plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)\n",
-        "plt.title('MIDI Instruments Pitches')\n",
-        "plt.xlabel(\"Ratio\")\n",
-        "plt.ylabel(\"Pitch\")\n",
+        "plt.title('MIDI Drums Pitches')\n",
+        "plt.xlabel(\"Pitch\")\n",
+        "plt.ylabel(\"Count\")\n",
         "plt.tight_layout()\n",
         "plt.plot()\n",
         "\n",
@@ -464,8 +443,8 @@
         "plt.plot(y, pitches_counts_totals)\n",
         "\n",
         "plt.title('MIDI Drums Pitches')\n",
-        "plt.xlabel(\"Ratio\")\n",
-        "plt.ylabel(\"Pitch\")\n",
+        "plt.xlabel(\"Pitch\")\n",
+        "plt.ylabel(\"Count\")\n",
         "plt.tight_layout()\n",
         "plt.plot()\n",
         "\n",
@@ -482,15 +461,15 @@
         "  x += 1\n",
         "\n",
         "cos_sim = pairwise.cosine_similarity(\n",
-        "      sim_mat \n",
+        "      sim_mat\n",
         "  )\n",
         "plt.figure(figsize=(8, 8))\n",
         "plt.imshow(sim_mat, cmap=\"inferno\", interpolation=\"none\")\n",
         "im_ratio = 1\n",
         "plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)\n",
         "plt.title('MIDI Drums Pitches')\n",
-        "plt.xlabel(\"Ratio\")\n",
-        "plt.ylabel(\"Pitch\")\n",
+        "plt.xlabel(\"Pitch\")\n",
+        "plt.ylabel(\"Count\")\n",
         "plt.tight_layout()\n",
         "plt.plot()\n",
         "\n",
@@ -500,7 +479,7 @@
         "\n",
         "\n",
         "for m in tqdm(meta_data):\n",
-        "  for mm in m[1][11][1]:\n",
+        "  for mm in m[1][12][1]:\n",
         "    patches_counts_totals[mm[0]] += mm[1]\n",
         "\n",
         "\n",
@@ -509,8 +488,8 @@
         "plt.plot(y, patches_counts_totals[:128])\n",
         "\n",
         "plt.title('MIDI Patches')\n",
-        "plt.xlabel(\"Ratio\")\n",
-        "plt.ylabel('Patch')\n",
+        "plt.xlabel(\"Patch\")\n",
+        "plt.ylabel('Count')\n",
         "plt.tight_layout()\n",
         "plt.plot()"
       ],
@@ -545,82 +524,6 @@
         "print('=' * 70)\n",
         "print('Loading MIDI file...')\n",
         "\n",
-        "score = MIDI.midi2ms_score(open(f, 'rb').read())\n",
-        "\n",
-        "events_matrix = []\n",
-        "\n",
-        "itrack = 1\n",
-        "\n",
-        "while itrack < len(score):\n",
-        "    for event in score[itrack]:         \n",
-        "      events_matrix.append(event)\n",
-        "    itrack += 1\n",
-        "\n",
-        "# Sorting...\n",
-        "events_matrix.sort(key=lambda x: x[1])\n",
-        "\n",
-        "# recalculating timings\n",
-        "for e in events_matrix:\n",
-        "    e[1] = int(e[1] / 10)\n",
-        "    if e[0] == 'note':\n",
-        "      e[2] = int(e[2] / 20)\n",
-        "\n",
-        "# final processing...\n",
-        "\n",
-        "melody_chords = []\n",
-        "\n",
-        "patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
-        "\n",
-        "pe = events_matrix[0]\n",
-        "for e in events_matrix:\n",
-        "\n",
-        "  if e[0] == 'note':\n",
-        "    # ['note', start_time, duration, channel, note, velocity]\n",
-        "    time = max(0, min(255, e[1]-pe[1]))\n",
-        "    duration = max(1, min(255, e[2]))\n",
-        "    channel = max(0, min(15, e[3]))\n",
-        "\n",
-        "    if e[3] != 9:\n",
-        "      instrument = max(0, min(127, patches[e[3]]))\n",
-        "    else:\n",
-        "      instrument = max(128, min(255, patches[e[3]]+128))\n",
-        "\n",
-        "    if e[3] != 9:\n",
-        "\n",
-        "      pitch = max(1, min(127, e[4]))\n",
-        "    else:\n",
-        "      pitch = max(129, min(255, e[4]+128))\n",
-        "\n",
-        "    if e[3] != 9:\n",
-        "      velocity = max(1, min(127, e[5]))\n",
-        "    else:\n",
-        "      velocity = max(129, min(255, e[5]+128))\n",
-        "\n",
-        "    melody_chords.append([time, duration, channel, instrument, pitch, velocity])\n",
-        "\n",
-        "  if e[0] == 'patch_change':\n",
-        "    # ['patch_change', dtime, channel, patch]\n",
-        "    time = max(0, min(127, e[1]-pe[1]))\n",
-        "    channel = max(0, min(15, e[2]))\n",
-        "    patch = max(0, min(127, e[3]))\n",
-        "\n",
-        "    patches[channel] = patch\n",
-        "\n",
-        "  pe = e # Previous event\n",
-        "\n",
-        "MATRIX = [[0]*256 for i in range(38)]\n",
-        "\n",
-        "for m in melody_chords:\n",
-        "\n",
-        "  MATRIX[0][m[0]] += 1\n",
-        "  MATRIX[1][m[1]] += 1\n",
-        "  MATRIX[2][m[2]] += 1 \n",
-        "  MATRIX[3][m[3]] += 1\n",
-        "  MATRIX[4][m[4]] += 1\n",
-        "  MATRIX[5][m[5]] += 1\n",
-        "  MATRIX[m[2]+6][m[3]] += 1\n",
-        "  MATRIX[m[2]+22][m[4]] += 1\n",
-        "\n",
         "#==================================================\n",
         "\n",
         "score = MIDI.midi2score(open(f, 'rb').read())\n",
@@ -630,7 +533,7 @@
         "track_count = 0\n",
         "\n",
         "for s in score:\n",
-        "    \n",
+        "\n",
         "    if track_count > 0:\n",
         "        track = s\n",
         "        track.sort(key=lambda x: x[1])\n",
@@ -639,7 +542,7 @@
         "        midi_ticks = s\n",
         "\n",
         "    track_count += 1\n",
-        "    \n",
+        "\n",
         "events_matrix.sort(key=lambda x: x[1])\n",
         "\n",
         "mult_pitches_counts = []\n",
@@ -662,7 +565,7 @@
         "\n",
         "  pitches_counts = [[y[0],y[1]] for y in Counter([y[4] for y in events_matrix1 if y[0] == 'note']).most_common()]\n",
         "  pitches_counts.sort(key=lambda x: x[0], reverse=True)\n",
-        "  \n",
+        "\n",
         "  mult_pitches_counts.append(pitches_counts)\n",
         "\n",
         "patches_list = sorted(list(set([y[3] for y in events_matrix if y[0] == 'patch_change'])))\n",
@@ -677,7 +580,7 @@
         "itrack1 = 1\n",
         "\n",
         "while itrack1 < len(ms_score):\n",
-        "    for event in ms_score[itrack1]:         \n",
+        "    for event in ms_score[itrack1]:\n",
         "        if event[0] == 'note':\n",
         "            ms_events_matrix.append(event)\n",
         "    itrack1 += 1\n",
@@ -702,7 +605,7 @@
         "          cho.append(e[4] % 12)\n",
         "\n",
         "    pe = e\n",
-        "    \n",
+        "\n",
         "if len(cho) > 0:\n",
         "    chords.append(sorted(cho))\n",
         "\n",
@@ -716,7 +619,7 @@
         "        times.append((e[1]-pt))\n",
         "        start = False\n",
         "    pt = e[1]\n",
-        "    \n",
+        "\n",
         "durs = [e[2] for e in ms_events_matrix]\n",
         "vels = [e[5] for e in ms_events_matrix]\n",
         "\n",
@@ -748,7 +651,7 @@
         "song_f = []\n",
         "\n",
         "while itrack < len(ms_score):\n",
-        "    for event in ms_score[itrack]:         \n",
+        "    for event in ms_score[itrack]:\n",
         "        if event[0] == 'note':\n",
         "            song_f.append(event)\n",
         "    itrack += 1\n",
@@ -800,296 +703,7 @@
     {
       "cell_type": "code",
       "source": [
-        "#@title Legacy MIDI Matrixes Search (Slow)\n",
-        "\n",
-        "#@markdown NOTE: You can stop the search at any time to render partial results\n",
-        "\n",
-        "minimum_match_ratio_to_search_for = 0 #@param {type:\"slider\", min:0, max:500, step:1}\n",
-        "stop_search_on_exact_match = True #@param {type:\"boolean\"}\n",
-        "skip_exact_matches = False #@param {type:\"boolean\"}\n",
-        "render_MIDI_to_audio = False #@param {type:\"boolean\"}\n",
-        "download_MIDI = False #@param {type:\"boolean\"}\n",
-        "\n",
-        "#=================================================================================\n",
-        "\n",
-        "matching_type = \"minkowski\"\n",
-        "\n",
-        "def compress_matrix(midi_matrix):\n",
-        "\n",
-        "  MX = 38\n",
-        "  MY = 256\n",
-        "\n",
-        "  if len(midi_matrix) == MX:\n",
-        "\n",
-        "    compressed_matrix = []\n",
-        "    zeros = 0\n",
-        "    zeros_shift = 0\n",
-        "    zeros_count = 0\n",
-        "\n",
-        "    for m in midi_matrix:\n",
-        "      for mm in m:\n",
-        "        zeros_shift = max(zeros_shift, mm) + 1\n",
-        "\n",
-        "    compressed_matrix.append(zeros_shift)\n",
-        "\n",
-        "    for m in midi_matrix:\n",
-        "      if len(m) == MY:\n",
-        "        for mm in m:\n",
-        "          if mm != 0:\n",
-        "            if zeros > 0:\n",
-        "              compressed_matrix.append(zeros+zeros_shift)\n",
-        "              zeros = 0\n",
-        "            compressed_matrix.append(mm)\n",
-        "          \n",
-        "          else:\n",
-        "            zeros += 1\n",
-        "            zeros_count += 1\n",
-        "      \n",
-        "      else:\n",
-        "        print('Wrong matrix format!')\n",
-        "        return [1]\n",
-        "\n",
-        "    if zeros > 0:\n",
-        "      compressed_matrix.append(zeros+zeros_shift)\n",
-        "\n",
-        "    compressed_matrix.append(zeros_count+zeros_shift)\n",
-        "    compressed_matrix.append(zeros_shift)\n",
-        "\n",
-        "    return compressed_matrix\n",
-        "\n",
-        "  else:\n",
-        "    print('Wrong matrix format!')\n",
-        "    return [0]\n",
-        "\n",
-        "#=================================================================================\n",
-        "\n",
-        "def decompress_matrix(compressed_midi_matrix):\n",
-        "\n",
-        "  MX = 38\n",
-        "  MY = 256\n",
-        "\n",
-        "  zeros_count = 0\n",
-        "\n",
-        "  temp_matrix = []\n",
-        "  decompressed_matrix = [[0]*MY for i in range(MX)]\n",
-        "\n",
-        "  if compressed_midi_matrix[0] == compressed_midi_matrix[-1]:\n",
-        "    zeros_shift = compressed_midi_matrix[0]\n",
-        "    mcount = 0\n",
-        "\n",
-        "    for c in compressed_midi_matrix[1:-2]:\n",
-        "      if c > zeros_shift:\n",
-        "        temp_matrix.extend([0] * (c-zeros_shift))\n",
-        "        zeros_count += (c-zeros_shift)\n",
-        "\n",
-        "      else:\n",
-        "        temp_matrix.extend([c])\n",
-        "\n",
-        "    if len(temp_matrix) == (MX * MY):\n",
-        "\n",
-        "      for i in range(MX):\n",
-        "        for j in range(MY):\n",
-        "          decompressed_matrix[i][j] = copy.deepcopy(temp_matrix[(i*MY) + j])\n",
-        "      \n",
-        "      if len(decompressed_matrix) == MX and zeros_count == (compressed_midi_matrix[-2]-zeros_shift):\n",
-        "        return decompressed_matrix\n",
-        "\n",
-        "      else:\n",
-        "        print('Matrix is corrupted!')\n",
-        "        return [len(decompressed_matrix), (MX * MY), zeros_count, (compressed_midi_matrix[-2]-zeros_shift)]\n",
-        "    \n",
-        "    else:\n",
-        "      print('Matrix is corrupted!')\n",
-        "      return [len(temp_matrix), zeros_count]\n",
-        "\n",
-        "  else:\n",
-        "    print('Matrix is corrupted!')\n",
-        "    return [0]\n",
-        "\n",
-        "#=================================================================================\n",
-        "\n",
-        "def batched_scores(matbatch, matrix):\n",
-        "\n",
-        "  sco= []\n",
-        "  for D in matbatch:\n",
-        "\n",
-        "    dist = pairwise_distances(matrix, decompress_matrix(D[1]), metric=matching_type)[0][0]\n",
-        "\n",
-        "    if skip_exact_matches:\n",
-        "      if dist == 0:\n",
-        "        dist = 999999\n",
-        "\n",
-        "    if dist <= minimum_match_ratio_to_search_for:\n",
-        "      dist = 999999\n",
-        "\n",
-        "    sco.append(dist)\n",
-        "\n",
-        "  return sco\n",
-        "\n",
-        "#=================================================================================\n",
-        "\n",
-        "print('=' * 70)\n",
-        "print('Searching...Please wait...')\n",
-        "print('=' * 70)\n",
-        "\n",
-        "scores = []\n",
-        "\n",
-        "c_count = multiprocessing.cpu_count()\n",
-        "\n",
-        "par = Parallel(n_jobs=c_count)\n",
-        "\n",
-        "num_jobs = c_count\n",
-        "scores_per_job = 100\n",
-        "\n",
-        "MATRIX_X = [MATRIX] * num_jobs\n",
-        "\n",
-        "for i in tqdm(range(0, len(midi_matrixes), (num_jobs*scores_per_job))):\n",
-        "  \n",
-        "  try:\n",
-        "\n",
-        "    MAT_BATCHES = []\n",
-        "\n",
-        "    for j in range(num_jobs):\n",
-        "      MAT_BATCHES.append(midi_matrixes[i+(j*scores_per_job):i+((j+1)*scores_per_job)])\n",
-        "\n",
-        "    output = par(delayed(batched_scores) (MB, MAT) for MB, MAT in zip(MAT_BATCHES, MATRIX_X))\n",
-        "\n",
-        "    output1 = []\n",
-        "\n",
-        "    for o in output:\n",
-        "      output1.extend(o)\n",
-        "\n",
-        "    scores.extend(output1)                            \n",
-        "\n",
-        "    if stop_search_on_exact_match:\n",
-        "      if 0 in output1:\n",
-        "        print('=' * 70)\n",
-        "        print('Found exact match!')\n",
-        "        print('Stoping further search...')\n",
-        "        print('=' * 70)\n",
-        "        break\n",
-        "\n",
-        "    else:\n",
-        "      if 0 in output1:\n",
-        "        print('=' * 70)\n",
-        "        print('Found exact match!')\n",
-        "        print('=' * 70)\n",
-        "        print('LAMDa Index:', scores.index(min(scores)))\n",
-        "        print('LAMDa File Name:', midi_matrixes[scores.index(min(scores))][0])\n",
-        "        print('=' * 70)\n",
-        "        print('Continuing search...')\n",
-        "        print('=' * 70)\n",
-        "\n",
-        "  except KeyboardInterrupt:\n",
-        "    break\n",
-        "  \n",
-        "  except Exception as e:\n",
-        "    print('WARNING !!!')\n",
-        "    print('=' * 70)\n",
-        "    print('Error detected:', e)\n",
-        "    print('=' * 70)\n",
-        "    continue\n",
-        "\n",
-        "print('Done!')\n",
-        "print('=' * 70)\n",
-        "print('Best match:')\n",
-        "print('=' * 70)   \n",
-        "print(matching_type.title(), 'distance ==', min(scores))\n",
-        "print('LAMDa Index:', scores.index(min(scores)))\n",
-        "print('LAMDa File Name:', midi_matrixes[scores.index(min(scores))][0])\n",
-        "print('=' * 70)\n",
-        "\n",
-        "#============================================\n",
-        "# MIDI rendering code\n",
-        "#============================================\n",
-        "\n",
-        "print('Rendering source MIDI...')\n",
-        "print('=' * 70)\n",
-        "\n",
-        "fn = midi_matrixes[scores.index(min(scores))][0]\n",
-        "\n",
-        "try:\n",
-        "  fn_idx = [y[0] for y in LAMD_files_list].index(fn)\n",
-        "\n",
-        "  f = LAMD_files_list[fn_idx][1]\n",
-        "\n",
-        "  ms_score = MIDI.midi2ms_score(open(f, 'rb').read())\n",
-        "\n",
-        "  itrack = 1\n",
-        "  song_f = []\n",
-        "\n",
-        "  while itrack < len(ms_score):\n",
-        "      for event in ms_score[itrack]:         \n",
-        "          if event[0] == 'note':\n",
-        "              song_f.append(event)\n",
-        "      itrack += 1\n",
-        "\n",
-        "  song_f.sort(key=lambda x: x[1])\n",
-        "\n",
-        "  fname = f.split('.mid')[0]\n",
-        "\n",
-        "  x = []\n",
-        "  y =[]\n",
-        "  c = []\n",
-        "\n",
-        "  colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver', 'aqua', 'azure', 'bisque', 'coral']\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",
-        "  if render_MIDI_to_audio:\n",
-        "    FluidSynth(\"/usr/share/sounds/sf2/FluidR3_GM.sf2\", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))\n",
-        "    display(Audio(str(fname + '.wav'), rate=16000))\n",
-        "\n",
-        "  plt.figure(figsize=(14,5))\n",
-        "  ax=plt.axes(title=fname)\n",
-        "  ax.set_facecolor('black')\n",
-        "\n",
-        "  plt.scatter(x,y, c=c)\n",
-        "  plt.xlabel(\"Time\")\n",
-        "  plt.ylabel(\"Pitch\")\n",
-        "  plt.show()\n",
-        "\n",
-        "except:\n",
-        "  pass\n",
-        "#==============================================\n",
-        "\n",
-        "if download_MIDI:\n",
-        "  print('=' * 70)\n",
-        "  print('Downloading MIDI file', str(fn) + '.mid')\n",
-        "  files.download(f)\n",
-        "  print('=' * 70)\n",
-        "  \n",
-        "#============================================\n",
-        "\n",
-        "print('Top 100 matches')\n",
-        "print('=' * 70)\n",
-        "\n",
-        "top_matches = []\n",
-        "\n",
-        "for i in range(len(scores)):\n",
-        "  top_matches.append([midi_matrixes[i][0], scores[i]])\n",
-        "\n",
-        "top_matches.sort(key=lambda x: x[1])\n",
-        "\n",
-        "for t in top_matches[:100]:\n",
-        "  print(t)\n",
-        "  \n",
-        "print('=' * 70)"
-      ],
-      "metadata": {
-        "cellView": "form",
-        "id": "pNQG6Qgfrlfi"
-      },
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#@title MIDI Pitches Search (Fast)\n",
+        "#@title MIDI Pitches Search\n",
         "\n",
         "#@markdown NOTE: You can stop the search at any time to render partial results\n",
         "\n",
@@ -1128,7 +742,7 @@
         "    max_p_count = p_counts[0][1]\n",
         "    trimmed_p_counts = [y for y in p_counts if y[1] >= (max_p_count * pitches_counts_cutoff_threshold_ratio)]\n",
         "    total_p_counts = sum([y[1] for y in trimmed_p_counts])\n",
-        "    \n",
+        "\n",
         "    if search_transposed_pitches:\n",
         "      search_pitches = mult_pitches_counts\n",
         "    else:\n",
@@ -1144,8 +758,8 @@
         "\n",
         "    if add_timings_ratios:\n",
         "\n",
-        "      source_times = [avg_time, \n",
-        "                      median_time, \n",
+        "      source_times = [avg_time,\n",
+        "                      median_time,\n",
         "                      mode_time]\n",
         "\n",
         "      match_times = meta_data[0][1][3][1]\n",
@@ -1197,7 +811,7 @@
         "\n",
         "      same_pitches = set([T[0] for T in trimmed_p_counts]) & set([m[0] for m in trimmed_pitches_counts])\n",
         "      num_same_pitches = len(same_pitches)\n",
-        "      \n",
+        "\n",
         "      if num_same_pitches == len(trimmed_pitches_counts):\n",
         "        same_pitches_ratio = (num_same_pitches / len(trimmed_p_counts))\n",
         "      else:\n",
@@ -1243,36 +857,36 @@
         "\n",
         "      if add_pitches_counts_ratios:\n",
         "        r_list.append(spcrat[0])\n",
-        "      \n",
+        "\n",
         "      if add_timings_ratios:\n",
         "        r_list.append(atrat[0])\n",
-        "        \n",
+        "\n",
         "      if add_durations_ratios:\n",
         "        r_list.append(adrat[0])\n",
         "\n",
         "      ratios_list.append(r_list)\n",
         "\n",
         "    #===================================================\n",
-        "    \n",
+        "\n",
         "    avg_ratios_list = []\n",
         "\n",
         "    for r in ratios_list:\n",
         "      avg_ratios_list.append(sum(r) / len(r))\n",
         "\n",
         "    #===================================================\n",
-        "    \n",
+        "\n",
         "    final_ratio = max(avg_ratios_list)\n",
-        "    \n",
+        "\n",
         "    if final_ratio > maximum_match_ratio_to_search_for:\n",
         "        final_ratio = 0\n",
         "\n",
         "    final_ratios.append(final_ratio)\n",
         "\n",
         "    #===================================================\n",
-        "  \n",
+        "\n",
         "  except KeyboardInterrupt:\n",
         "    break\n",
-        "  \n",
+        "\n",
         "  except Exception as e:\n",
         "    print('WARNING !!!')\n",
         "    print('=' * 70)\n",
@@ -1310,7 +924,7 @@
         "song_f = []\n",
         "\n",
         "while itrack < len(ms_score):\n",
-        "    for event in ms_score[itrack]:         \n",
+        "    for event in ms_score[itrack]:\n",
         "        if event[0] == 'note':\n",
         "            song_f.append(event)\n",
         "    itrack += 1\n",
@@ -1361,7 +975,7 @@
     {
       "cell_type": "code",
       "source": [
-        "#@title MIDI Chords Search (Fast)\n",
+        "#@title MIDI Chords Search\n",
         "\n",
         "#@markdown NOTE: You can stop the search at any time to render partial results\n",
         "\n",
@@ -1387,19 +1001,19 @@
         "\n",
         "    c_counts.sort(reverse = True, key = lambda x: x[0][1])\n",
         "    max_c_count = c_counts[0][1]\n",
-        "    trimmed_c_counts = [y for y in c_counts if y[1] >= (max_c_count * chords_counts_cutoff_threshold_ratio)] \n",
+        "    trimmed_c_counts = [y for y in c_counts if y[1] >= (max_c_count * chords_counts_cutoff_threshold_ratio)]\n",
         "    trimmed_c_counts.sort(reverse = True, key = lambda x: x[1])\n",
-        "    \n",
+        "\n",
         "    max_chords_count = ms_chords_counts[0][1]\n",
-        "    trimmed_chords_counts = [y for y in ms_chords_counts if y[1] >= (max_chords_count * chords_counts_cutoff_threshold_ratio)] \n",
+        "    trimmed_chords_counts = [y for y in ms_chords_counts if y[1] >= (max_chords_count * chords_counts_cutoff_threshold_ratio)]\n",
         "\n",
         "    num_same_chords = len(set([tuple(T[0]) for T in trimmed_c_counts]) & set([tuple(t[0]) for t in trimmed_chords_counts]))\n",
-        "    \n",
+        "\n",
         "    if num_same_chords == len(trimmed_chords_counts):\n",
         "      same_chords_ratio = (num_same_chords / len(trimmed_c_counts))\n",
         "    else:\n",
         "      same_chords_ratio = (num_same_chords / max(len(trimmed_c_counts), len(trimmed_chords_counts)))\n",
-        " \n",
+        "\n",
         "    if skip_exact_matches:\n",
         "      if same_chords_ratio == 1:\n",
         "        same_chords_ratio = 0\n",
@@ -1408,10 +1022,10 @@
         "      same_chords_ratio = 0\n",
         "\n",
         "    ratios.append(same_chords_ratio)\n",
-        "  \n",
+        "\n",
         "  except KeyboardInterrupt:\n",
         "    break\n",
-        "  \n",
+        "\n",
         "  except Exception as e:\n",
         "    print('WARNING !!!')\n",
         "    print('=' * 70)\n",
@@ -1449,7 +1063,7 @@
         "song_f = []\n",
         "\n",
         "while itrack < len(ms_score):\n",
-        "    for event in ms_score[itrack]:         \n",
+        "    for event in ms_score[itrack]:\n",
         "        if event[0] == 'note':\n",
         "            song_f.append(event)\n",
         "    itrack += 1\n",
@@ -1500,7 +1114,7 @@
     {
       "cell_type": "code",
       "source": [
-        "#@title MIDI Patches Search (Fast)\n",
+        "#@title MIDI Patches Search\n",
         "\n",
         "#@markdown NOTE: You can stop the search at any time to render partial results\n",
         "\n",
@@ -1519,17 +1133,17 @@
         "\n",
         "  try:\n",
         "\n",
-        "    p_list= d[1][12][1]\n",
+        "    p_list= d[1][11][1]\n",
         "\n",
         "    num_same_patches = len(set(p_list) & set(patches_list))\n",
-        "    \n",
+        "\n",
         "    if len(set(p_list + patches_list)) > 0:\n",
-        "      \n",
+        "\n",
         "      if num_same_patches == len(patches_list):\n",
         "        same_patches_ratio = num_same_patches / len(p_list)\n",
         "      else:\n",
         "        same_patches_ratio = num_same_patches / max(len(p_list), len(patches_list))\n",
-        "    \n",
+        "\n",
         "    else:\n",
         "      same_patches_ratio = 0\n",
         "\n",
@@ -1539,12 +1153,12 @@
         "\n",
         "    if same_patches_ratio > maximum_match_ratio_to_search_for:\n",
         "      same_patches_ratio = 0\n",
-        "      \n",
+        "\n",
         "    ratios.append(same_patches_ratio)\n",
-        "  \n",
+        "\n",
         "  except KeyboardInterrupt:\n",
         "    break\n",
-        "  \n",
+        "\n",
         "  except Exception as e:\n",
         "    print('WARNING !!!')\n",
         "    print('=' * 70)\n",
@@ -1582,7 +1196,7 @@
         "song_f = []\n",
         "\n",
         "while itrack < len(ms_score):\n",
-        "    for event in ms_score[itrack]:         \n",
+        "    for event in ms_score[itrack]:\n",
         "        if event[0] == 'note':\n",
         "            song_f.append(event)\n",
         "    itrack += 1\n",
@@ -1641,10 +1255,10 @@
         "md5_hash_MIDI_file_name = \"d9a7e1c6a375b8e560155a5977fc10f8\" #@param {type:\"string\"}\n",
         "case_sensitive_search = False #@param {type:\"boolean\"}\n",
         "\n",
-        "fields_to_search = ['track_name', \n",
-        "                    'text_event', \n",
-        "                    'lyric', \n",
-        "                    'copyright_text_event', \n",
+        "fields_to_search = ['track_name',\n",
+        "                    'text_event',\n",
+        "                    'lyric',\n",
+        "                    'copyright_text_event',\n",
         "                    'marker',\n",
         "                    'text_event_08',\n",
         "                    'text_event_09',\n",
@@ -1674,12 +1288,12 @@
         "        pprint.pprint(['Result:', d[1][:16]], compact = True)\n",
         "        print('=' * 70)\n",
         "        break\n",
-        " \n",
+        "\n",
         "    except KeyboardInterrupt:\n",
         "      print('Ending search...')\n",
         "      print('=' * 70)\n",
         "      break\n",
-        "    \n",
+        "\n",
         "    except Exception as e:\n",
         "      print('WARNING !!!')\n",
         "      print('=' * 70)\n",
@@ -1708,7 +1322,7 @@
         "              print('-' * 70)\n",
         "              pprint.pprint(['Result:', dd[2][:16]], compact = True)\n",
         "              print('=' * 70)\n",
-        "          \n",
+        "\n",
         "          else:\n",
         "            if str(search_query).lower() in str(dd[2]).lower():\n",
         "              print('Found!')\n",
@@ -1718,12 +1332,12 @@
         "              print('-' * 70)\n",
         "              pprint.pprint(['Result:', dd[2][:16]], compact = True)\n",
         "              print('=' * 70)\n",
-        "    \n",
+        "\n",
         "    except KeyboardInterrupt:\n",
         "      print('Ending search...')\n",
         "      print('=' * 70)\n",
         "      break\n",
-        "    \n",
+        "\n",
         "    except:\n",
         "      print('Ending search...')\n",
         "      print('=' * 70)\n",
@@ -1775,9 +1389,9 @@
         "    fn = md5_hash_MIDI_file_name\n",
         "    fn_idx = [y[0] for y in LAMD_files_list].index(fn)\n",
         "    f = LAMD_files_list[fn_idx][1]\n",
-        "    \n",
+        "\n",
         "    print('Using md5 hash filename')\n",
-        "  \n",
+        "\n",
         "  print('=' * 70)\n",
         "  print('Rendering MIDI...')\n",
         "  print('=' * 70)\n",
@@ -1788,7 +1402,7 @@
         "  song_f = []\n",
         "\n",
         "  while itrack < len(ms_score):\n",
-        "      for event in ms_score[itrack]:         \n",
+        "      for event in ms_score[itrack]:\n",
         "          if event[0] == 'note':\n",
         "              song_f.append(event)\n",
         "      itrack += 1\n",
@@ -1996,11 +1610,11 @@
         "        score = MIDI.midi2score(open(f, 'rb').read())\n",
         "\n",
         "        events_matrix = []\n",
-        "        \n",
+        "\n",
         "        itrack = 1\n",
         "\n",
         "        while itrack < len(score):\n",
-        "            for event in score[itrack]:        \n",
+        "            for event in score[itrack]:\n",
         "              events_matrix.append(event)\n",
         "            itrack += 1\n",
         "\n",
@@ -2008,7 +1622,7 @@
         "        events_matrix.sort(key=lambda x: x[1])\n",
         "\n",
         "        if len(events_matrix) > 0:\n",
-        "          \n",
+        "\n",
         "          #=======================================================\n",
         "          # INSERT YOUR CUSTOM ANAYLSIS CODE RIGHT HERE\n",
         "          #=======================================================\n",
@@ -2024,7 +1638,7 @@
         "\n",
         "    except KeyboardInterrupt:\n",
         "        print('Saving current progress and quitting...')\n",
-        "        break  \n",
+        "        break\n",
         "\n",
         "    except Exception as ex:\n",
         "        print('WARNING !!!')\n",
@@ -2042,7 +1656,7 @@
         "print('=' * 70)\n",
         "print('Total good processed MIDI files:', files_count)\n",
         "print('=' * 70)\n",
-        "print('Done!')   \n",
+        "print('Done!')\n",
         "print('=' * 70)"
       ],
       "metadata": {

Master_MIDI_Dataset_Search_and_Filter.ipynb

@@ -11,7 +11,7 @@
         "id": "SiTIpPjArIyr"
       },
       "source": [
-        "# Master MIDI Dataset Search and Filter (ver. 1.0)\n",
+        "# Master MIDI Dataset Search and Filter (ver. 3.0)\n",
         "\n",
         "***\n",
         "\n",
@@ -134,10 +134,10 @@
         "print('Downloading Los Angeles MIDI Dataset...Please wait...')\n",
         "print('=' * 70)\n",
         "\n",
-        "hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset', \n",
-        "                filename='Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip',\n",
+        "hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset',\n",
+        "                filename='Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip',\n",
         "                repo_type=\"dataset\",\n",
-        "                local_dir='/content/Main-MIDI-Dataset', \n",
+        "                local_dir='/content/Main-MIDI-Dataset',\n",
         "                local_dir_use_symlinks=False)\n",
         "print('=' * 70)\n",
         "print('Done! Enjoy! :)')\n",
@@ -158,7 +158,7 @@
         "\n",
         "print('=' * 70)\n",
         "print('Unzipping Los Angeles MIDI Dataset...Please wait...')\n",
-        "!unzip 'Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip'\n",
+        "!unzip 'Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip'\n",
         "print('=' * 70)\n",
         "\n",
         "print('Done! Enjoy! :)')\n",
@@ -298,7 +298,7 @@
         "\n",
         "for f in filez:\n",
         "    try:\n",
-        "        \n",
+        "\n",
         "        input_files_count += 1\n",
         "\n",
         "        fn = os.path.basename(f)\n",
@@ -309,88 +309,10 @@
         "\n",
         "          print('Processing MIDI File #', files_count+1, 'out of', len(filez))\n",
         "          print('MIDI file name', fn)\n",
-        "          print('-' * 70)          \n",
+        "          print('-' * 70)\n",
         "\n",
         "          #=======================================================\n",
         "\n",
-        "          score = TMIDIX.midi2ms_score(open(f, 'rb').read())\n",
-        "\n",
-        "          events_matrix = []\n",
-        "\n",
-        "          itrack = 1\n",
-        "\n",
-        "          while itrack < len(score):\n",
-        "              for event in score[itrack]:         \n",
-        "                events_matrix.append(event)\n",
-        "              itrack += 1\n",
-        "\n",
-        "          # Sorting...\n",
-        "          events_matrix.sort(key=lambda x: x[1])\n",
-        "\n",
-        "          # recalculating timings\n",
-        "          for e in events_matrix:\n",
-        "              e[1] = int(e[1] / 10)\n",
-        "              if e[0] == 'note':\n",
-        "                e[2] = int(e[2] / 20)\n",
-        "\n",
-        "          # final processing...\n",
-        "\n",
-        "          melody_chords = []\n",
-        "\n",
-        "          patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
-        "\n",
-        "          pe = events_matrix[0]\n",
-        "          for e in events_matrix:\n",
-        "\n",
-        "            if e[0] == 'note':\n",
-        "              # ['note', start_time, duration, channel, note, velocity]\n",
-        "              time = max(0, min(255, e[1]-pe[1]))\n",
-        "              duration = max(1, min(255, e[2]))\n",
-        "              channel = max(0, min(15, e[3]))\n",
-        "\n",
-        "              if e[3] != 9:\n",
-        "                instrument = max(0, min(127, patches[e[3]]))\n",
-        "              else:\n",
-        "                instrument = max(128, min(255, patches[e[3]]+128))\n",
-        "\n",
-        "              if e[3] != 9:\n",
-        "\n",
-        "                pitch = max(1, min(127, e[4]))\n",
-        "              else:\n",
-        "                pitch = max(129, min(255, e[4]+128))\n",
-        "\n",
-        "              if e[3] != 9:\n",
-        "                velocity = max(1, min(127, e[5]))\n",
-        "              else:\n",
-        "                velocity = max(129, min(255, e[5]+128))\n",
-        "\n",
-        "              melody_chords.append([time, duration, channel, instrument, pitch, velocity])\n",
-        "\n",
-        "            if e[0] == 'patch_change':\n",
-        "              # ['patch_change', dtime, channel, patch]\n",
-        "              time = max(0, min(127, e[1]-pe[1]))\n",
-        "              channel = max(0, min(15, e[2]))\n",
-        "              patch = max(0, min(127, e[3]))\n",
-        "\n",
-        "              patches[channel] = patch\n",
-        "\n",
-        "            pe = e # Previous event\n",
-        "\n",
-        "          MATRIX = [[0]*256 for i in range(38)]\n",
-        "\n",
-        "          for m in melody_chords:\n",
-        "\n",
-        "            MATRIX[0][m[0]] += 1\n",
-        "            MATRIX[1][m[1]] += 1\n",
-        "            MATRIX[2][m[2]] += 1 \n",
-        "            MATRIX[3][m[3]] += 1\n",
-        "            MATRIX[4][m[4]] += 1\n",
-        "            MATRIX[5][m[5]] += 1\n",
-        "            MATRIX[m[2]+6][m[3]] += 1\n",
-        "            MATRIX[m[2]+22][m[4]] += 1\n",
-        "\n",
-        "          #==================================================\n",
-        "\n",
         "          score = TMIDIX.midi2score(open(f, 'rb').read())\n",
         "\n",
         "          events_matrix = []\n",
@@ -398,7 +320,7 @@
         "          track_count = 0\n",
         "\n",
         "          for s in score:\n",
-        "              \n",
+        "\n",
         "              if track_count > 0:\n",
         "                  track = s\n",
         "                  track.sort(key=lambda x: x[1])\n",
@@ -407,7 +329,7 @@
         "                  midi_ticks = s\n",
         "\n",
         "              track_count += 1\n",
-        "              \n",
+        "\n",
         "          events_matrix.sort(key=lambda x: x[1])\n",
         "\n",
         "          mult_pitches_counts = []\n",
@@ -430,7 +352,7 @@
         "\n",
         "            pitches_counts = [[y[0],y[1]] for y in Counter([y[4] for y in events_matrix1 if y[0] == 'note']).most_common()]\n",
         "            pitches_counts.sort(key=lambda x: x[0], reverse=True)\n",
-        "            \n",
+        "\n",
         "            mult_pitches_counts.append(pitches_counts)\n",
         "\n",
         "          patches_list = sorted(list(set([y[3] for y in events_matrix if y[0] == 'patch_change'])))\n",
@@ -444,7 +366,7 @@
         "          itrack1 = 1\n",
         "\n",
         "          while itrack1 < len(ms_score):\n",
-        "              for event in ms_score[itrack1]:         \n",
+        "              for event in ms_score[itrack1]:\n",
         "                  if event[0] == 'note':\n",
         "                      ms_events_matrix.append(event)\n",
         "              itrack1 += 1\n",
@@ -469,7 +391,7 @@
         "                    cho.append(e[4] % 12)\n",
         "\n",
         "              pe = e\n",
-        "              \n",
+        "\n",
         "          if len(cho) > 0:\n",
         "              chords.append(sorted(cho))\n",
         "\n",
@@ -483,7 +405,7 @@
         "                  times.append((e[1]-pt))\n",
         "                  start = False\n",
         "              pt = e[1]\n",
-        "              \n",
+        "\n",
         "          durs = [e[2] for e in ms_events_matrix]\n",
         "          vels = [e[5] for e in ms_events_matrix]\n",
         "\n",
@@ -510,7 +432,7 @@
         "              max_p_count = p_counts[0][1]\n",
         "              trimmed_p_counts = [y for y in p_counts if y[1] >= (max_p_count * pitches_counts_cutoff_threshold_ratio)]\n",
         "              total_p_counts = sum([y[1] for y in trimmed_p_counts])\n",
-        "              \n",
+        "\n",
         "              if search_transposed_pitches:\n",
         "                search_pitches = mult_pitches_counts\n",
         "              else:\n",
@@ -526,8 +448,8 @@
         "\n",
         "              if add_timings_ratios:\n",
         "\n",
-        "                source_times = [avg_time, \n",
-        "                                median_time, \n",
+        "                source_times = [avg_time,\n",
+        "                                median_time,\n",
         "                                mode_time]\n",
         "\n",
         "                match_times = meta_data[0][1][3][1]\n",
@@ -579,12 +501,12 @@
         "\n",
         "                same_pitches = set([T[0] for T in trimmed_p_counts]) & set([m[0] for m in trimmed_pitches_counts])\n",
         "                num_same_pitches = len(same_pitches)\n",
-        "                \n",
+        "\n",
         "                if num_same_pitches == len(trimmed_pitches_counts):\n",
         "                  same_pitches_ratio = (num_same_pitches / len(trimmed_p_counts))\n",
         "                else:\n",
         "                  same_pitches_ratio = (num_same_pitches / max(len(trimmed_p_counts), len(trimmed_pitches_counts)))\n",
-        "               \n",
+        "\n",
         "                if skip_exact_matches:\n",
         "                  if same_pitches_ratio == 1:\n",
         "                    same_pitches_ratio = 0\n",
@@ -625,26 +547,26 @@
         "\n",
         "                if add_pitches_counts_ratios:\n",
         "                  r_list.append(spcrat[0])\n",
-        "                \n",
+        "\n",
         "                if add_timings_ratios:\n",
         "                  r_list.append(atrat[0])\n",
-        "                  \n",
+        "\n",
         "                if add_durations_ratios:\n",
         "                  r_list.append(adrat[0])\n",
         "\n",
         "                ratios_list.append(r_list)\n",
         "\n",
         "              #===================================================\n",
-        "              \n",
+        "\n",
         "              avg_ratios_list = []\n",
         "\n",
         "              for r in ratios_list:\n",
         "                avg_ratios_list.append(sum(r) / len(r))\n",
         "\n",
         "              #===================================================\n",
-        "              \n",
+        "\n",
         "              final_ratio = max(avg_ratios_list)\n",
-        "              \n",
+        "\n",
         "              if final_ratio > maximum_match_ratio_to_search_for:\n",
         "                  final_ratio = 0\n",
         "\n",
@@ -670,7 +592,7 @@
         "            ff = LAMD_files_list[ffn_idx][1]\n",
         "\n",
         "            #=======================================================\n",
-        "            \n",
+        "\n",
         "            dir_str = str(fn1)\n",
         "            copy_path = '/content/Output-MIDI-Dataset/'+dir_str\n",
         "            if not os.path.exists(copy_path):\n",
@@ -679,11 +601,11 @@
         "            fff = str(m * 100) + '_' + ffn + '.mid'\n",
         "\n",
         "            shutil.copy2(ff, copy_path+'/'+fff)\n",
-        "          \n",
+        "\n",
         "          shutil.copy2(f, copy_path+'/'+fn)\n",
         "\n",
         "          #=======================================================\n",
-        "          \n",
+        "\n",
         "          print('Done!')\n",
         "          print('=' * 70)\n",
         "\n",
@@ -691,12 +613,12 @@
         "\n",
         "          # Processed files counter\n",
         "          files_count += 1\n",
-        "                                        \n",
+        "\n",
         "    except KeyboardInterrupt:\n",
         "        print('Quitting...')\n",
         "        print('Total number of processed MIDI files', files_count)\n",
         "        print('=' * 70)\n",
-        "        break  \n",
+        "        break\n",
         "\n",
         "    except Exception as ex:\n",
         "        print('WARNING !!!')\n",

los_angeles_midi_dataset_search_and_explore.py

@@ -6,7 +6,7 @@ Automatically generated by Colaboratory.
 Original file is located at
     https://colab.research.google.com/github/asigalov61/Los-Angeles-MIDI-Dataset/blob/main/Los_Angeles_MIDI_Dataset_Search_and_Explore.ipynb
 
-# Los Angeles MIDI Dataset: Search and Explore (ver. 2.2)
+# Los Angeles MIDI Dataset: Search and Explore (ver. 3.0)
 
 ***
 
@@ -89,23 +89,6 @@ print('=' * 70)
 
 #================================================
 
-# %cd /content/Los-Angeles-MIDI-Dataset/MIDI-MATRIXES
-
-print('=' * 70)
-print('Unzipping MIDI-MATRIXES...Please wait...')
-
-!cat LAMDa_MIDI_MATRIXES.zip* > LAMDa_MIDI_MATRIXES.zip
-print('=' * 70)
-
-!unzip -j LAMDa_MIDI_MATRIXES.zip
-print('=' * 70)
-
-print('Done! Enjoy! :)')
-print('=' * 70)
-# %cd /content/
-
-#==================================================
-
 # %cd /content/Los-Angeles-MIDI-Dataset/TOTALS
 
 print('=' * 70)
@@ -126,10 +109,6 @@ print('Loading LAMDa META-DATA...')
 meta_data = pickle.load(open('/content/Los-Angeles-MIDI-Dataset/META-DATA/LAMDa_META_DATA.pickle', 'rb'))
 print('Done!')
 print('=' * 70)
-print('Loading LAMDa MIDI-MATRIXES...')
-midi_matrixes = pickle.load(open('/content/Los-Angeles-MIDI-Dataset/MIDI-MATRIXES/LAMDa_MIDI_MATRIXES.pickle', 'rb'))
-print('Done!')
-print('=' * 70)
 print('Loading LAMDa TOTALS...')
 totals = pickle.load(open('/content/Los-Angeles-MIDI-Dataset/TOTALS/LAMDa_TOTALS.pickle', 'rb'))
 print('Done!')
@@ -144,10 +123,10 @@ print('=' * 70)
 print('Downloading Los Angeles MIDI Dataset...Please wait...')
 print('=' * 70)
 
-hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset', 
-                filename='Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip',
+hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset',
+                filename='Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip',
                 repo_type="dataset",
-                local_dir='/content/LAMD', 
+                local_dir='/content/LAMD',
                 local_dir_use_symlinks=False)
 print('=' * 70)
 print('Done! Enjoy! :)')
@@ -159,7 +138,7 @@ print('=' * 70)
 
 print('=' * 70)
 print('Unzipping Los Angeles MIDI Dataset...Please wait...')
-!unzip 'Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip'
+!unzip 'Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip'
 print('=' * 70)
 
 print('Done! Enjoy! :)')
@@ -197,7 +176,7 @@ print('=' * 70)
 #@title Plot totals from MIDI matrixes (legacy)
 
 cos_sim = pairwise.cosine_similarity(
-      totals[0][0][4] 
+      totals[0][0][4]
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(cos_sim, cmap="inferno", interpolation="none")
@@ -210,7 +189,7 @@ plt.tight_layout()
 plt.plot()
 
 cos_sim = pairwise.cosine_similarity(
-      totals[0][0][5] 
+      totals[0][0][5]
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(cos_sim, cmap="inferno", interpolation="none")
@@ -223,7 +202,7 @@ plt.tight_layout()
 plt.plot()
 
 cos_sim = pairwise.cosine_similarity(
-      totals[0][0][6] 
+      totals[0][0][6]
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(cos_sim, cmap="inferno", interpolation="none")
@@ -236,7 +215,7 @@ plt.tight_layout()
 plt.plot()
 
 cos_sim = pairwise.cosine_similarity(
-      totals[0][0][7] 
+      totals[0][0][7]
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(cos_sim, cmap="inferno", interpolation="none")
@@ -249,7 +228,7 @@ plt.tight_layout()
 plt.plot()
 
 cos_sim = pairwise.cosine_similarity(
-      totals[0][0][8] 
+      totals[0][0][8]
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(cos_sim, cmap="inferno", interpolation="none")
@@ -262,7 +241,7 @@ plt.tight_layout()
 plt.plot()
 
 cos_sim = pairwise.cosine_similarity(
-      totals[0][0][9] 
+      totals[0][0][9]
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(cos_sim, cmap="inferno", interpolation="none")
@@ -290,8 +269,8 @@ plt.figure(figsize=(8, 8))
 plt.plot(y, pitches_counts_totals)
 
 plt.title('MIDI Instruments Pitches')
-plt.xlabel("Ratio")
-plt.ylabel("Pitch")
+plt.xlabel("Pitch")
+plt.ylabel("Count")
 plt.tight_layout()
 plt.plot()
 
@@ -308,15 +287,15 @@ for p in pitches_counts_totals:
   x += 1
 
 cos_sim = pairwise.cosine_similarity(
-      sim_mat 
+      sim_mat
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(sim_mat, cmap="inferno", interpolation="none")
 im_ratio = 1
 plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
-plt.title('MIDI Instruments Pitches')
-plt.xlabel("Ratio")
-plt.ylabel("Pitch")
+plt.title('MIDI Drums Pitches')
+plt.xlabel("Pitch")
+plt.ylabel("Count")
 plt.tight_layout()
 plt.plot()
 
@@ -335,8 +314,8 @@ plt.figure(figsize=(8, 8))
 plt.plot(y, pitches_counts_totals)
 
 plt.title('MIDI Drums Pitches')
-plt.xlabel("Ratio")
-plt.ylabel("Pitch")
+plt.xlabel("Pitch")
+plt.ylabel("Count")
 plt.tight_layout()
 plt.plot()
 
@@ -353,15 +332,15 @@ for p in pitches_counts_totals:
   x += 1
 
 cos_sim = pairwise.cosine_similarity(
-      sim_mat 
+      sim_mat
   )
 plt.figure(figsize=(8, 8))
 plt.imshow(sim_mat, cmap="inferno", interpolation="none")
 im_ratio = 1
 plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
 plt.title('MIDI Drums Pitches')
-plt.xlabel("Ratio")
-plt.ylabel("Pitch")
+plt.xlabel("Pitch")
+plt.ylabel("Count")
 plt.tight_layout()
 plt.plot()
 
@@ -371,7 +350,7 @@ patches_counts_totals = [0] * 256
 
 
 for m in tqdm(meta_data):
-  for mm in m[1][11][1]:
+  for mm in m[1][12][1]:
     patches_counts_totals[mm[0]] += mm[1]
 
 
@@ -380,8 +359,8 @@ plt.figure(figsize=(8, 8))
 plt.plot(y, patches_counts_totals[:128])
 
 plt.title('MIDI Patches')
-plt.xlabel("Ratio")
-plt.ylabel('Patch')
+plt.xlabel("Patch")
+plt.ylabel('Count')
 plt.tight_layout()
 plt.plot()
 
@@ -399,82 +378,6 @@ f = full_path_to_source_MIDI
 print('=' * 70)
 print('Loading MIDI file...')
 
-score = MIDI.midi2ms_score(open(f, 'rb').read())
-
-events_matrix = []
-
-itrack = 1
-
-while itrack < len(score):
-    for event in score[itrack]:         
-      events_matrix.append(event)
-    itrack += 1
-
-# Sorting...
-events_matrix.sort(key=lambda x: x[1])
-
-# recalculating timings
-for e in events_matrix:
-    e[1] = int(e[1] / 10)
-    if e[0] == 'note':
-      e[2] = int(e[2] / 20)
-
-# final processing...
-
-melody_chords = []
-
-patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-
-pe = events_matrix[0]
-for e in events_matrix:
-
-  if e[0] == 'note':
-    # ['note', start_time, duration, channel, note, velocity]
-    time = max(0, min(255, e[1]-pe[1]))
-    duration = max(1, min(255, e[2]))
-    channel = max(0, min(15, e[3]))
-
-    if e[3] != 9:
-      instrument = max(0, min(127, patches[e[3]]))
-    else:
-      instrument = max(128, min(255, patches[e[3]]+128))
-
-    if e[3] != 9:
-
-      pitch = max(1, min(127, e[4]))
-    else:
-      pitch = max(129, min(255, e[4]+128))
-
-    if e[3] != 9:
-      velocity = max(1, min(127, e[5]))
-    else:
-      velocity = max(129, min(255, e[5]+128))
-
-    melody_chords.append([time, duration, channel, instrument, pitch, velocity])
-
-  if e[0] == 'patch_change':
-    # ['patch_change', dtime, channel, patch]
-    time = max(0, min(127, e[1]-pe[1]))
-    channel = max(0, min(15, e[2]))
-    patch = max(0, min(127, e[3]))
-
-    patches[channel] = patch
-
-  pe = e # Previous event
-
-MATRIX = [[0]*256 for i in range(38)]
-
-for m in melody_chords:
-
-  MATRIX[0][m[0]] += 1
-  MATRIX[1][m[1]] += 1
-  MATRIX[2][m[2]] += 1 
-  MATRIX[3][m[3]] += 1
-  MATRIX[4][m[4]] += 1
-  MATRIX[5][m[5]] += 1
-  MATRIX[m[2]+6][m[3]] += 1
-  MATRIX[m[2]+22][m[4]] += 1
-
 #==================================================
 
 score = MIDI.midi2score(open(f, 'rb').read())
@@ -484,7 +387,7 @@ events_matrix = []
 track_count = 0
 
 for s in score:
-    
+
     if track_count > 0:
         track = s
         track.sort(key=lambda x: x[1])
@@ -493,7 +396,7 @@ for s in score:
         midi_ticks = s
 
     track_count += 1
-    
+
 events_matrix.sort(key=lambda x: x[1])
 
 mult_pitches_counts = []
@@ -516,7 +419,7 @@ for i in range(-6, 6):
 
   pitches_counts = [[y[0],y[1]] for y in Counter([y[4] for y in events_matrix1 if y[0] == 'note']).most_common()]
   pitches_counts.sort(key=lambda x: x[0], reverse=True)
-  
+
   mult_pitches_counts.append(pitches_counts)
 
 patches_list = sorted(list(set([y[3] for y in events_matrix if y[0] == 'patch_change'])))
@@ -531,7 +434,7 @@ ms_events_matrix = []
 itrack1 = 1
 
 while itrack1 < len(ms_score):
-    for event in ms_score[itrack1]:         
+    for event in ms_score[itrack1]:
         if event[0] == 'note':
             ms_events_matrix.append(event)
     itrack1 += 1
@@ -556,7 +459,7 @@ for e in ms_events_matrix:
           cho.append(e[4] % 12)
 
     pe = e
-    
+
 if len(cho) > 0:
     chords.append(sorted(cho))
 
@@ -570,7 +473,7 @@ for e in ms_events_matrix:
         times.append((e[1]-pt))
         start = False
     pt = e[1]
-    
+
 durs = [e[2] for e in ms_events_matrix]
 vels = [e[5] for e in ms_events_matrix]
 
@@ -602,7 +505,7 @@ itrack = 1
 song_f = []
 
 while itrack < len(ms_score):
-    for event in ms_score[itrack]:         
+    for event in ms_score[itrack]:
         if event[0] == 'note':
             song_f.append(event)
     itrack += 1
@@ -637,286 +540,7 @@ plt.show()
 
 """# (SEARCH AND EXPLORE)"""
 
-#@title Legacy MIDI Matrixes Search (Slow)
-
-#@markdown NOTE: You can stop the search at any time to render partial results
-
-minimum_match_ratio_to_search_for = 0 #@param {type:"slider", min:0, max:500, step:1}
-stop_search_on_exact_match = True #@param {type:"boolean"}
-skip_exact_matches = False #@param {type:"boolean"}
-render_MIDI_to_audio = False #@param {type:"boolean"}
-download_MIDI = False #@param {type:"boolean"}
-
-#=================================================================================
-
-matching_type = "minkowski"
-
-def compress_matrix(midi_matrix):
-
-  MX = 38
-  MY = 256
-
-  if len(midi_matrix) == MX:
-
-    compressed_matrix = []
-    zeros = 0
-    zeros_shift = 0
-    zeros_count = 0
-
-    for m in midi_matrix:
-      for mm in m:
-        zeros_shift = max(zeros_shift, mm) + 1
-
-    compressed_matrix.append(zeros_shift)
-
-    for m in midi_matrix:
-      if len(m) == MY:
-        for mm in m:
-          if mm != 0:
-            if zeros > 0:
-              compressed_matrix.append(zeros+zeros_shift)
-              zeros = 0
-            compressed_matrix.append(mm)
-          
-          else:
-            zeros += 1
-            zeros_count += 1
-      
-      else:
-        print('Wrong matrix format!')
-        return [1]
-
-    if zeros > 0:
-      compressed_matrix.append(zeros+zeros_shift)
-
-    compressed_matrix.append(zeros_count+zeros_shift)
-    compressed_matrix.append(zeros_shift)
-
-    return compressed_matrix
-
-  else:
-    print('Wrong matrix format!')
-    return [0]
-
-#=================================================================================
-
-def decompress_matrix(compressed_midi_matrix):
-
-  MX = 38
-  MY = 256
-
-  zeros_count = 0
-
-  temp_matrix = []
-  decompressed_matrix = [[0]*MY for i in range(MX)]
-
-  if compressed_midi_matrix[0] == compressed_midi_matrix[-1]:
-    zeros_shift = compressed_midi_matrix[0]
-    mcount = 0
-
-    for c in compressed_midi_matrix[1:-2]:
-      if c > zeros_shift:
-        temp_matrix.extend([0] * (c-zeros_shift))
-        zeros_count += (c-zeros_shift)
-
-      else:
-        temp_matrix.extend([c])
-
-    if len(temp_matrix) == (MX * MY):
-
-      for i in range(MX):
-        for j in range(MY):
-          decompressed_matrix[i][j] = copy.deepcopy(temp_matrix[(i*MY) + j])
-      
-      if len(decompressed_matrix) == MX and zeros_count == (compressed_midi_matrix[-2]-zeros_shift):
-        return decompressed_matrix
-
-      else:
-        print('Matrix is corrupted!')
-        return [len(decompressed_matrix), (MX * MY), zeros_count, (compressed_midi_matrix[-2]-zeros_shift)]
-    
-    else:
-      print('Matrix is corrupted!')
-      return [len(temp_matrix), zeros_count]
-
-  else:
-    print('Matrix is corrupted!')
-    return [0]
-
-#=================================================================================
-
-def batched_scores(matbatch, matrix):
-
-  sco= []
-  for D in matbatch:
-
-    dist = pairwise_distances(matrix, decompress_matrix(D[1]), metric=matching_type)[0][0]
-
-    if skip_exact_matches:
-      if dist == 0:
-        dist = 999999
-
-    if dist <= minimum_match_ratio_to_search_for:
-      dist = 999999
-
-    sco.append(dist)
-
-  return sco
-
-#=================================================================================
-
-print('=' * 70)
-print('Searching...Please wait...')
-print('=' * 70)
-
-scores = []
-
-c_count = multiprocessing.cpu_count()
-
-par = Parallel(n_jobs=c_count)
-
-num_jobs = c_count
-scores_per_job = 100
-
-MATRIX_X = [MATRIX] * num_jobs
-
-for i in tqdm(range(0, len(midi_matrixes), (num_jobs*scores_per_job))):
-  
-  try:
-
-    MAT_BATCHES = []
-
-    for j in range(num_jobs):
-      MAT_BATCHES.append(midi_matrixes[i+(j*scores_per_job):i+((j+1)*scores_per_job)])
-
-    output = par(delayed(batched_scores) (MB, MAT) for MB, MAT in zip(MAT_BATCHES, MATRIX_X))
-
-    output1 = []
-
-    for o in output:
-      output1.extend(o)
-
-    scores.extend(output1)                            
-
-    if stop_search_on_exact_match:
-      if 0 in output1:
-        print('=' * 70)
-        print('Found exact match!')
-        print('Stoping further search...')
-        print('=' * 70)
-        break
-
-    else:
-      if 0 in output1:
-        print('=' * 70)
-        print('Found exact match!')
-        print('=' * 70)
-        print('LAMDa Index:', scores.index(min(scores)))
-        print('LAMDa File Name:', midi_matrixes[scores.index(min(scores))][0])
-        print('=' * 70)
-        print('Continuing search...')
-        print('=' * 70)
-
-  except KeyboardInterrupt:
-    break
-  
-  except Exception as e:
-    print('WARNING !!!')
-    print('=' * 70)
-    print('Error detected:', e)
-    print('=' * 70)
-    continue
-
-print('Done!')
-print('=' * 70)
-print('Best match:')
-print('=' * 70)   
-print(matching_type.title(), 'distance ==', min(scores))
-print('LAMDa Index:', scores.index(min(scores)))
-print('LAMDa File Name:', midi_matrixes[scores.index(min(scores))][0])
-print('=' * 70)
-
-#============================================
-# MIDI rendering code
-#============================================
-
-print('Rendering source MIDI...')
-print('=' * 70)
-
-fn = midi_matrixes[scores.index(min(scores))][0]
-
-try:
-  fn_idx = [y[0] for y in LAMD_files_list].index(fn)
-
-  f = LAMD_files_list[fn_idx][1]
-
-  ms_score = MIDI.midi2ms_score(open(f, 'rb').read())
-
-  itrack = 1
-  song_f = []
-
-  while itrack < len(ms_score):
-      for event in ms_score[itrack]:         
-          if event[0] == 'note':
-              song_f.append(event)
-      itrack += 1
-
-  song_f.sort(key=lambda x: x[1])
-
-  fname = f.split('.mid')[0]
-
-  x = []
-  y =[]
-  c = []
-
-  colors = ['red', 'yellow', 'green', 'cyan', 'blue', 'pink', 'orange', 'purple', 'gray', 'white', 'gold', 'silver', 'aqua', 'azure', 'bisque', 'coral']
-
-  for s in song_f:
-    x.append(s[1] / 1000)
-    y.append(s[4])
-    c.append(colors[s[3]])
-
-  if render_MIDI_to_audio:
-    FluidSynth("/usr/share/sounds/sf2/FluidR3_GM.sf2", 16000).midi_to_audio(str(fname + '.mid'), str(fname + '.wav'))
-    display(Audio(str(fname + '.wav'), rate=16000))
-
-  plt.figure(figsize=(14,5))
-  ax=plt.axes(title=fname)
-  ax.set_facecolor('black')
-
-  plt.scatter(x,y, c=c)
-  plt.xlabel("Time")
-  plt.ylabel("Pitch")
-  plt.show()
-
-except:
-  pass
-#==============================================
-
-if download_MIDI:
-  print('=' * 70)
-  print('Downloading MIDI file', str(fn) + '.mid')
-  files.download(f)
-  print('=' * 70)
-  
-#============================================
-
-print('Top 100 matches')
-print('=' * 70)
-
-top_matches = []
-
-for i in range(len(scores)):
-  top_matches.append([midi_matrixes[i][0], scores[i]])
-
-top_matches.sort(key=lambda x: x[1])
-
-for t in top_matches[:100]:
-  print(t)
-  
-print('=' * 70)
-
-#@title MIDI Pitches Search (Fast)
+#@title MIDI Pitches Search
 
 #@markdown NOTE: You can stop the search at any time to render partial results
 
@@ -955,7 +579,7 @@ for d in tqdm(meta_data):
     max_p_count = p_counts[0][1]
     trimmed_p_counts = [y for y in p_counts if y[1] >= (max_p_count * pitches_counts_cutoff_threshold_ratio)]
     total_p_counts = sum([y[1] for y in trimmed_p_counts])
-    
+
     if search_transposed_pitches:
       search_pitches = mult_pitches_counts
     else:
@@ -971,8 +595,8 @@ for d in tqdm(meta_data):
 
     if add_timings_ratios:
 
-      source_times = [avg_time, 
-                      median_time, 
+      source_times = [avg_time,
+                      median_time,
                       mode_time]
 
       match_times = meta_data[0][1][3][1]
@@ -1024,7 +648,7 @@ for d in tqdm(meta_data):
 
       same_pitches = set([T[0] for T in trimmed_p_counts]) & set([m[0] for m in trimmed_pitches_counts])
       num_same_pitches = len(same_pitches)
-      
+
       if num_same_pitches == len(trimmed_pitches_counts):
         same_pitches_ratio = (num_same_pitches / len(trimmed_p_counts))
       else:
@@ -1070,36 +694,36 @@ for d in tqdm(meta_data):
 
       if add_pitches_counts_ratios:
         r_list.append(spcrat[0])
-      
+
       if add_timings_ratios:
         r_list.append(atrat[0])
-        
+
       if add_durations_ratios:
         r_list.append(adrat[0])
 
       ratios_list.append(r_list)
 
     #===================================================
-    
+
     avg_ratios_list = []
 
     for r in ratios_list:
       avg_ratios_list.append(sum(r) / len(r))
 
     #===================================================
-    
+
     final_ratio = max(avg_ratios_list)
-    
+
     if final_ratio > maximum_match_ratio_to_search_for:
         final_ratio = 0
 
     final_ratios.append(final_ratio)
 
     #===================================================
-  
+
   except KeyboardInterrupt:
     break
-  
+
   except Exception as e:
     print('WARNING !!!')
     print('=' * 70)
@@ -1137,7 +761,7 @@ itrack = 1
 song_f = []
 
 while itrack < len(ms_score):
-    for event in ms_score[itrack]:         
+    for event in ms_score[itrack]:
         if event[0] == 'note':
             song_f.append(event)
     itrack += 1
@@ -1178,7 +802,7 @@ if download_MIDI:
   files.download(f)
   print('=' * 70)
 
-#@title MIDI Chords Search (Fast)
+#@title MIDI Chords Search
 
 #@markdown NOTE: You can stop the search at any time to render partial results
 
@@ -1204,19 +828,19 @@ for d in tqdm(meta_data):
 
     c_counts.sort(reverse = True, key = lambda x: x[0][1])
     max_c_count = c_counts[0][1]
-    trimmed_c_counts = [y for y in c_counts if y[1] >= (max_c_count * chords_counts_cutoff_threshold_ratio)] 
+    trimmed_c_counts = [y for y in c_counts if y[1] >= (max_c_count * chords_counts_cutoff_threshold_ratio)]
     trimmed_c_counts.sort(reverse = True, key = lambda x: x[1])
-    
+
     max_chords_count = ms_chords_counts[0][1]
-    trimmed_chords_counts = [y for y in ms_chords_counts if y[1] >= (max_chords_count * chords_counts_cutoff_threshold_ratio)] 
+    trimmed_chords_counts = [y for y in ms_chords_counts if y[1] >= (max_chords_count * chords_counts_cutoff_threshold_ratio)]
 
     num_same_chords = len(set([tuple(T[0]) for T in trimmed_c_counts]) & set([tuple(t[0]) for t in trimmed_chords_counts]))
-    
+
     if num_same_chords == len(trimmed_chords_counts):
       same_chords_ratio = (num_same_chords / len(trimmed_c_counts))
     else:
       same_chords_ratio = (num_same_chords / max(len(trimmed_c_counts), len(trimmed_chords_counts)))
- 
+
     if skip_exact_matches:
       if same_chords_ratio == 1:
         same_chords_ratio = 0
@@ -1225,10 +849,10 @@ for d in tqdm(meta_data):
       same_chords_ratio = 0
 
     ratios.append(same_chords_ratio)
-  
+
   except KeyboardInterrupt:
     break
-  
+
   except Exception as e:
     print('WARNING !!!')
     print('=' * 70)
@@ -1266,7 +890,7 @@ itrack = 1
 song_f = []
 
 while itrack < len(ms_score):
-    for event in ms_score[itrack]:         
+    for event in ms_score[itrack]:
         if event[0] == 'note':
             song_f.append(event)
     itrack += 1
@@ -1307,7 +931,7 @@ if download_MIDI:
   files.download(f)
   print('=' * 70)
 
-#@title MIDI Patches Search (Fast)
+#@title MIDI Patches Search
 
 #@markdown NOTE: You can stop the search at any time to render partial results
 
@@ -1326,17 +950,17 @@ for d in tqdm(meta_data):
 
   try:
 
-    p_list= d[1][12][1]
+    p_list= d[1][11][1]
 
     num_same_patches = len(set(p_list) & set(patches_list))
-    
+
     if len(set(p_list + patches_list)) > 0:
-      
+
       if num_same_patches == len(patches_list):
         same_patches_ratio = num_same_patches / len(p_list)
       else:
         same_patches_ratio = num_same_patches / max(len(p_list), len(patches_list))
-    
+
     else:
       same_patches_ratio = 0
 
@@ -1346,12 +970,12 @@ for d in tqdm(meta_data):
 
     if same_patches_ratio > maximum_match_ratio_to_search_for:
       same_patches_ratio = 0
-      
+
     ratios.append(same_patches_ratio)
-  
+
   except KeyboardInterrupt:
     break
-  
+
   except Exception as e:
     print('WARNING !!!')
     print('=' * 70)
@@ -1389,7 +1013,7 @@ itrack = 1
 song_f = []
 
 while itrack < len(ms_score):
-    for event in ms_score[itrack]:         
+    for event in ms_score[itrack]:
         if event[0] == 'note':
             song_f.append(event)
     itrack += 1
@@ -1438,10 +1062,10 @@ search_query = "Come To My Window" #@param {type:"string"}
 md5_hash_MIDI_file_name = "d9a7e1c6a375b8e560155a5977fc10f8" #@param {type:"string"}
 case_sensitive_search = False #@param {type:"boolean"}
 
-fields_to_search = ['track_name', 
-                    'text_event', 
-                    'lyric', 
-                    'copyright_text_event', 
+fields_to_search = ['track_name',
+                    'text_event',
+                    'lyric',
+                    'copyright_text_event',
                     'marker',
                     'text_event_08',
                     'text_event_09',
@@ -1471,12 +1095,12 @@ if md5_hash_MIDI_file_name != '':
         pprint.pprint(['Result:', d[1][:16]], compact = True)
         print('=' * 70)
         break
- 
+
     except KeyboardInterrupt:
       print('Ending search...')
       print('=' * 70)
       break
-    
+
     except Exception as e:
       print('WARNING !!!')
       print('=' * 70)
@@ -1505,7 +1129,7 @@ else:
               print('-' * 70)
               pprint.pprint(['Result:', dd[2][:16]], compact = True)
               print('=' * 70)
-          
+
           else:
             if str(search_query).lower() in str(dd[2]).lower():
               print('Found!')
@@ -1515,12 +1139,12 @@ else:
               print('-' * 70)
               pprint.pprint(['Result:', dd[2][:16]], compact = True)
               print('=' * 70)
-    
+
     except KeyboardInterrupt:
       print('Ending search...')
       print('=' * 70)
       break
-    
+
     except:
       print('Ending search...')
       print('=' * 70)
@@ -1555,9 +1179,9 @@ try:
     fn = md5_hash_MIDI_file_name
     fn_idx = [y[0] for y in LAMD_files_list].index(fn)
     f = LAMD_files_list[fn_idx][1]
-    
+
     print('Using md5 hash filename')
-  
+
   print('=' * 70)
   print('Rendering MIDI...')
   print('=' * 70)
@@ -1568,7 +1192,7 @@ try:
   song_f = []
 
   while itrack < len(ms_score):
-      for event in ms_score[itrack]:         
+      for event in ms_score[itrack]:
           if event[0] == 'note':
               song_f.append(event)
       itrack += 1
@@ -1742,11 +1366,11 @@ for f in tqdm(filez[START_FILE_NUMBER:]):
         score = MIDI.midi2score(open(f, 'rb').read())
 
         events_matrix = []
-        
+
         itrack = 1
 
         while itrack < len(score):
-            for event in score[itrack]:        
+            for event in score[itrack]:
               events_matrix.append(event)
             itrack += 1
 
@@ -1754,7 +1378,7 @@ for f in tqdm(filez[START_FILE_NUMBER:]):
         events_matrix.sort(key=lambda x: x[1])
 
         if len(events_matrix) > 0:
-          
+
           #=======================================================
           # INSERT YOUR CUSTOM ANAYLSIS CODE RIGHT HERE
           #=======================================================
@@ -1770,7 +1394,7 @@ for f in tqdm(filez[START_FILE_NUMBER:]):
 
     except KeyboardInterrupt:
         print('Saving current progress and quitting...')
-        break  
+        break
 
     except Exception as ex:
         print('WARNING !!!')
@@ -1788,7 +1412,7 @@ print('Resulting Stats:')
 print('=' * 70)
 print('Total good processed MIDI files:', files_count)
 print('=' * 70)
-print('Done!')   
+print('Done!')
 print('=' * 70)
 
 """# Congrats! You did it! :)"""

master_midi_dataset_search_and_filter.py

@@ -6,7 +6,7 @@ Automatically generated by Colaboratory.
 Original file is located at
     https://colab.research.google.com/github/asigalov61/Los-Angeles-MIDI-Dataset/blob/main/Extras/Master_MIDI_Dataset_Search_and_Filter.ipynb
 
-# Master MIDI Dataset Search and Filter (ver. 1.0)
+# Master MIDI Dataset Search and Filter (ver. 3.0)
 
 ***
 
@@ -72,10 +72,10 @@ print('=' * 70)
 print('Downloading Los Angeles MIDI Dataset...Please wait...')
 print('=' * 70)
 
-hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset', 
-                filename='Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip',
+hf_hub_download(repo_id='projectlosangeles/Los-Angeles-MIDI-Dataset',
+                filename='Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip',
                 repo_type="dataset",
-                local_dir='/content/Main-MIDI-Dataset', 
+                local_dir='/content/Main-MIDI-Dataset',
                 local_dir_use_symlinks=False)
 print('=' * 70)
 print('Done! Enjoy! :)')
@@ -87,7 +87,7 @@ print('=' * 70)
 
 print('=' * 70)
 print('Unzipping Los Angeles MIDI Dataset...Please wait...')
-!unzip 'Los-Angeles-MIDI-Dataset-Ver-2-0-CC-BY-NC-SA.zip'
+!unzip 'Los-Angeles-MIDI-Dataset-Ver-3-0-CC-BY-NC-SA.zip'
 print('=' * 70)
 
 print('Done! Enjoy! :)')
@@ -191,7 +191,7 @@ files_count = 0
 
 for f in filez:
     try:
-        
+
         input_files_count += 1
 
         fn = os.path.basename(f)
@@ -202,88 +202,10 @@ for f in filez:
 
           print('Processing MIDI File #', files_count+1, 'out of', len(filez))
           print('MIDI file name', fn)
-          print('-' * 70)          
+          print('-' * 70)
 
           #=======================================================
 
-          score = TMIDIX.midi2ms_score(open(f, 'rb').read())
-
-          events_matrix = []
-
-          itrack = 1
-
-          while itrack < len(score):
-              for event in score[itrack]:         
-                events_matrix.append(event)
-              itrack += 1
-
-          # Sorting...
-          events_matrix.sort(key=lambda x: x[1])
-
-          # recalculating timings
-          for e in events_matrix:
-              e[1] = int(e[1] / 10)
-              if e[0] == 'note':
-                e[2] = int(e[2] / 20)
-
-          # final processing...
-
-          melody_chords = []
-
-          patches = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-
-          pe = events_matrix[0]
-          for e in events_matrix:
-
-            if e[0] == 'note':
-              # ['note', start_time, duration, channel, note, velocity]
-              time = max(0, min(255, e[1]-pe[1]))
-              duration = max(1, min(255, e[2]))
-              channel = max(0, min(15, e[3]))
-
-              if e[3] != 9:
-                instrument = max(0, min(127, patches[e[3]]))
-              else:
-                instrument = max(128, min(255, patches[e[3]]+128))
-
-              if e[3] != 9:
-
-                pitch = max(1, min(127, e[4]))
-              else:
-                pitch = max(129, min(255, e[4]+128))
-
-              if e[3] != 9:
-                velocity = max(1, min(127, e[5]))
-              else:
-                velocity = max(129, min(255, e[5]+128))
-
-              melody_chords.append([time, duration, channel, instrument, pitch, velocity])
-
-            if e[0] == 'patch_change':
-              # ['patch_change', dtime, channel, patch]
-              time = max(0, min(127, e[1]-pe[1]))
-              channel = max(0, min(15, e[2]))
-              patch = max(0, min(127, e[3]))
-
-              patches[channel] = patch
-
-            pe = e # Previous event
-
-          MATRIX = [[0]*256 for i in range(38)]
-
-          for m in melody_chords:
-
-            MATRIX[0][m[0]] += 1
-            MATRIX[1][m[1]] += 1
-            MATRIX[2][m[2]] += 1 
-            MATRIX[3][m[3]] += 1
-            MATRIX[4][m[4]] += 1
-            MATRIX[5][m[5]] += 1
-            MATRIX[m[2]+6][m[3]] += 1
-            MATRIX[m[2]+22][m[4]] += 1
-
-          #==================================================
-
           score = TMIDIX.midi2score(open(f, 'rb').read())
 
           events_matrix = []
@@ -291,7 +213,7 @@ for f in filez:
           track_count = 0
 
           for s in score:
-              
+
               if track_count > 0:
                   track = s
                   track.sort(key=lambda x: x[1])
@@ -300,7 +222,7 @@ for f in filez:
                   midi_ticks = s
 
               track_count += 1
-              
+
           events_matrix.sort(key=lambda x: x[1])
 
           mult_pitches_counts = []
@@ -323,7 +245,7 @@ for f in filez:
 
             pitches_counts = [[y[0],y[1]] for y in Counter([y[4] for y in events_matrix1 if y[0] == 'note']).most_common()]
             pitches_counts.sort(key=lambda x: x[0], reverse=True)
-            
+
             mult_pitches_counts.append(pitches_counts)
 
           patches_list = sorted(list(set([y[3] for y in events_matrix if y[0] == 'patch_change'])))
@@ -337,7 +259,7 @@ for f in filez:
           itrack1 = 1
 
           while itrack1 < len(ms_score):
-              for event in ms_score[itrack1]:         
+              for event in ms_score[itrack1]:
                   if event[0] == 'note':
                       ms_events_matrix.append(event)
               itrack1 += 1
@@ -362,7 +284,7 @@ for f in filez:
                     cho.append(e[4] % 12)
 
               pe = e
-              
+
           if len(cho) > 0:
               chords.append(sorted(cho))
 
@@ -376,7 +298,7 @@ for f in filez:
                   times.append((e[1]-pt))
                   start = False
               pt = e[1]
-              
+
           durs = [e[2] for e in ms_events_matrix]
           vels = [e[5] for e in ms_events_matrix]
 
@@ -403,7 +325,7 @@ for f in filez:
               max_p_count = p_counts[0][1]
               trimmed_p_counts = [y for y in p_counts if y[1] >= (max_p_count * pitches_counts_cutoff_threshold_ratio)]
               total_p_counts = sum([y[1] for y in trimmed_p_counts])
-              
+
               if search_transposed_pitches:
                 search_pitches = mult_pitches_counts
               else:
@@ -419,8 +341,8 @@ for f in filez:
 
               if add_timings_ratios:
 
-                source_times = [avg_time, 
-                                median_time, 
+                source_times = [avg_time,
+                                median_time,
                                 mode_time]
 
                 match_times = meta_data[0][1][3][1]
@@ -472,12 +394,12 @@ for f in filez:
 
                 same_pitches = set([T[0] for T in trimmed_p_counts]) & set([m[0] for m in trimmed_pitches_counts])
                 num_same_pitches = len(same_pitches)
-                
+
                 if num_same_pitches == len(trimmed_pitches_counts):
                   same_pitches_ratio = (num_same_pitches / len(trimmed_p_counts))
                 else:
                   same_pitches_ratio = (num_same_pitches / max(len(trimmed_p_counts), len(trimmed_pitches_counts)))
-               
+
                 if skip_exact_matches:
                   if same_pitches_ratio == 1:
                     same_pitches_ratio = 0
@@ -518,26 +440,26 @@ for f in filez:
 
                 if add_pitches_counts_ratios:
                   r_list.append(spcrat[0])
-                
+
                 if add_timings_ratios:
                   r_list.append(atrat[0])
-                  
+
                 if add_durations_ratios:
                   r_list.append(adrat[0])
 
                 ratios_list.append(r_list)
 
               #===================================================
-              
+
               avg_ratios_list = []
 
               for r in ratios_list:
                 avg_ratios_list.append(sum(r) / len(r))
 
               #===================================================
-              
+
               final_ratio = max(avg_ratios_list)
-              
+
               if final_ratio > maximum_match_ratio_to_search_for:
                   final_ratio = 0
 
@@ -563,7 +485,7 @@ for f in filez:
             ff = LAMD_files_list[ffn_idx][1]
 
             #=======================================================
-            
+
             dir_str = str(fn1)
             copy_path = '/content/Output-MIDI-Dataset/'+dir_str
             if not os.path.exists(copy_path):
@@ -572,11 +494,11 @@ for f in filez:
             fff = str(m * 100) + '_' + ffn + '.mid'
 
             shutil.copy2(ff, copy_path+'/'+fff)
-          
+
           shutil.copy2(f, copy_path+'/'+fn)
 
           #=======================================================
-          
+
           print('Done!')
           print('=' * 70)
 
@@ -584,12 +506,12 @@ for f in filez:
 
           # Processed files counter
           files_count += 1
-                                        
+
     except KeyboardInterrupt:
         print('Quitting...')
         print('Total number of processed MIDI files', files_count)
         print('=' * 70)
-        break  
+        break
 
     except Exception as ex:
         print('WARNING !!!')