Upload 11 files

Master_MIDI_Dataset_GPU_Search_and_Filter.ipynb

@@ -11,7 +11,7 @@
         "id": "SiTIpPjArIyr"
       },
       "source": [
-        "# Master MIDI Dataset GPU Search and Filter (ver. 2.0)\n",
+        "# Master MIDI Dataset GPU Search and Filter (ver. 5.0)\n",
         "\n",
         "***\n",
         "\n",
@@ -119,10 +119,15 @@
         "import statistics\n",
         "import shutil\n",
         "\n",
+        "import locale\n",
+        "locale.getpreferredencoding = lambda: \"UTF-8\"\n",
+        "\n",
         "import cupy as cp\n",
         "\n",
         "from huggingface_hub import hf_hub_download\n",
         "\n",
+        "from google.colab import files\n",
+        "\n",
         "print('Loading TMIDIX module...')\n",
         "os.chdir('/content/Los-Angeles-MIDI-Dataset')\n",
         "\n",
@@ -257,17 +262,15 @@
         "random.shuffle(sigs_data)\n",
         "\n",
         "signatures_file_names = []\n",
-        "sigs_matrixes = [ [0]*(len(TMIDIX.ALL_CHORDS)+128) for i in range(len(sigs_data))]\n",
+        "sigs_matrixes = [ [0]*(len(TMIDIX.ALL_CHORDS)+256) for i in range(len(sigs_data))]\n",
         "\n",
         "idx = 0\n",
         "for s in tqdm(sigs_data):\n",
         "\n",
         "  signatures_file_names.append(s[0])\n",
         "\n",
-        "  counts_sum = sum([c[1] for c in s[1]])\n",
-        "\n",
         "  for ss in s[1]:\n",
-        "    sigs_matrixes[idx][ss[0]] = ss[1] / counts_sum\n",
+        "    sigs_matrixes[idx][ss[0]] = ss[1]\n",
         "\n",
         "  idx += 1\n",
         "\n",
@@ -305,10 +308,15 @@
         "\n",
         "#@markdown NOTE: You can stop the search at any time to render partial results\n",
         "\n",
-        "number_of_top_matches_MIDIs_to_collect = 20 #@param {type:\"slider\", min:5, max:50, step:1}\n",
-        "search_matching_type = \"ratios\" # @param [\"ratios\", \"distances\"]\n",
+        "number_of_top_matches_MIDIs_to_collect = 30 #@param {type:\"slider\", min:5, max:50, step:1}\n",
+        "search_matching_type = \"Ratios\" # @param [\"Ratios\", \"Distances\", \"Correlations\"]\n",
+        "maximum_match_ratio_to_search_for = 1 #@param {type:\"slider\", min:0, max:1, step:0.001}\n",
+        "match_results_weight = 2 # @param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
+        "match_lengths_weight = 1 # @param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
+        "match_counts_weight = 1 # @param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
         "distances_norm_order = 3 # @param {type:\"slider\", min:1, max:10, step:1}\n",
-        "maximum_match_ratio_to_search_for = 0.999 #@param {type:\"slider\", min:0, max:1, step:0.001}\n",
+        "epsilon = 0.5 # @param {type:\"slider\", min:0.001, max:1, step:0.001}\n",
+        "match_drums = False # @param {type:\"boolean\"}\n",
         "\n",
         "print('=' * 70)\n",
         "print('Master MIDI Dataset GPU Search and Filter')\n",
@@ -338,8 +346,8 @@
         "\n",
         "  ###################\n",
         "\n",
-        "  if not os.path.exists('/content/Output-MIDI-Dataset'):\n",
-        "      os.makedirs('/content/Output-MIDI-Dataset')\n",
+        "  if not os.path.exists('/content/Output-MIDI-Dataset/'+search_matching_type):\n",
+        "      os.makedirs('/content/Output-MIDI-Dataset/'+search_matching_type)\n",
         "\n",
         "  ###################\n",
         "\n",
@@ -368,6 +376,8 @@
         "            e[1] = int(e[1] / 16)\n",
         "            e[2] = int(e[2] / 16)\n",
         "\n",
+        "          drums_offset = len(TMIDIX.ALL_CHORDS) + 128\n",
+        "\n",
         "          src_sigs = []\n",
         "\n",
         "          for i in range(-6, 6):\n",
@@ -380,10 +390,12 @@
         "            cscore = TMIDIX.chordify_score([1000, escore_copy])\n",
         "\n",
         "            sig = []\n",
+        "            dsig = []\n",
         "\n",
         "            for c in cscore:\n",
         "\n",
         "              pitches = sorted(set([p[4] for p in c if p[3] != 9]))\n",
+        "              drums = sorted(set([p[4] for p in c if p[3] == 9]))\n",
         "\n",
         "              if pitches:\n",
         "                if len(pitches) > 1:\n",
@@ -397,20 +409,28 @@
         "\n",
         "                sig.append(sig_token)\n",
         "\n",
-        "            fsig = [list(v) for v in Counter(sig).most_common()]\n",
+        "              if drums:\n",
+        "                dsig.extend(drums)\n",
+        "\n",
+        "            sig_p = dict.fromkeys(sig+dsig, 0)\n",
+        "            for item in sig+dsig:\n",
+        "              sig_p[item] += 1\n",
         "\n",
-        "            src_sig_mat = [0] * (len(TMIDIX.ALL_CHORDS)+128)\n",
+        "            fsig = [list(v) for v in sig_p.items()]\n",
         "\n",
-        "            counts_sum = sum([c[1] for c in fsig])\n",
+        "            src_sig_mat = [0] * (len(TMIDIX.ALL_CHORDS)+256)\n",
         "\n",
         "            for s in fsig:\n",
         "\n",
-        "              src_sig_mat[s[0]] = s[1] / counts_sum\n",
+        "              src_sig_mat[s[0]] = s[1]\n",
         "\n",
         "            src_sigs.append(src_sig_mat)\n",
         "\n",
         "          src_signatures = cp.stack(cp.array(src_sigs))\n",
         "\n",
+        "          if not match_drums:\n",
+        "            src_signatures = cp.where(src_signatures < drums_offset, src_signatures, epsilon)\n",
+        "\n",
         "          #=======================================================\n",
         "\n",
         "          print('Searching for matches...Please wait...')\n",
@@ -432,18 +452,49 @@
         "\n",
         "          for target_sig in tqdm(src_signatures):\n",
         "\n",
-        "            if search_matching_type == 'ratios':\n",
+        "            if not match_drums:\n",
+        "              target_sig = cp.where(target_sig < drums_offset, target_sig, epsilon)\n",
+        "\n",
+        "            comps_lengths = cp.vstack((cp.repeat(cp.sum(target_sig != 0), signatures_data.shape[0]), cp.sum(signatures_data != 0, axis=1)))\n",
+        "            comps_lengths_ratios = cp.divide(cp.min(comps_lengths, axis=0), cp.max(comps_lengths, axis=0))\n",
         "\n",
-        "              ratios = cp.where(target_sig != 0, cp.divide(cp.minimum(signatures_data, target_sig), cp.maximum(signatures_data, target_sig)), 0)\n",
-        "              max_comp_lengths = cp.maximum(cp.repeat(cp.sum(target_sig != 0), signatures_data.shape[0]), cp.sum(signatures_data != 0, axis=1))\n",
+        "            comps_counts_sums = cp.vstack((cp.repeat(cp.sum(target_sig), signatures_data.shape[0]), cp.sum(signatures_data, axis=1)))\n",
+        "            comps_counts_sums_ratios = cp.divide(cp.min(comps_counts_sums, axis=0), cp.max(comps_counts_sums, axis=0))\n",
         "\n",
-        "              results = cp.divide(cp.sum(ratios, axis=1), max_comp_lengths)\n",
+        "            if search_matching_type == 'Ratios':\n",
         "\n",
-        "            elif search_matching_type == 'distances':\n",
+        "              ratios = cp.where(target_sig != 0, cp.divide(cp.minimum(signatures_data, target_sig), cp.maximum(signatures_data, target_sig)), epsilon)\n",
+        "              results = cp.mean(ratios, axis=1)\n",
+        "\n",
+        "            elif search_matching_type == 'Distances':\n",
         "\n",
         "              distances = cp.power(cp.sum(cp.power(cp.abs(signatures_data - target_sig), distances_norm_order), axis=1), 1 / distances_norm_order)\n",
         "\n",
-        "              results = cp.max(distances) - distances\n",
+        "              distances_mean = cp.mean(distances)\n",
+        "              distances_std = cp.std(distances)\n",
+        "\n",
+        "              results = 1 - cp.divide((distances - distances_mean), distances_std)\n",
+        "\n",
+        "            elif search_matching_type == 'Correlations':\n",
+        "\n",
+        "                main_array_mean = cp.mean(signatures_data, axis=1, keepdims=True)\n",
+        "                main_array_std = cp.std(signatures_data, axis=1, keepdims=True)\n",
+        "                target_array_mean = cp.mean(target_sig)\n",
+        "                target_array_std = cp.std(target_sig)\n",
+        "\n",
+        "                signatures_data_normalized = cp.where(main_array_std != 0, (signatures_data - main_array_mean) / main_array_std, epsilon)\n",
+        "                target_sig_normalized = cp.where(target_array_std != 0, (target_sig - target_array_mean) / target_array_std, epsilon)\n",
+        "\n",
+        "                correlations = cp.divide(cp.einsum('ij,j->i', signatures_data_normalized, target_sig_normalized), (signatures_data.shape[1] - 1))\n",
+        "                scaled_correlations = cp.divide(correlations, cp.sqrt(cp.sum(correlations**2)))\n",
+        "                exp = cp.exp(scaled_correlations - cp.max(scaled_correlations))\n",
+        "                results = cp.multiply(cp.divide(exp, cp.sum(exp)), 1e5)\n",
+        "\n",
+        "            results_weight = match_results_weight\n",
+        "            comp_lengths_weight = match_lengths_weight\n",
+        "            comp_counts_sums_weight = match_counts_weight\n",
+        "\n",
+        "            results = cp.divide(cp.add(cp.add(results_weight, comp_lengths_weight), comp_counts_sums_weight), cp.add(cp.add(cp.divide(results_weight, cp.where(results !=0, results, epsilon)), cp.divide(comp_lengths_weight, cp.where(comps_lengths_ratios !=0, comps_lengths_ratios, epsilon))), cp.divide(comp_counts_sums_weight, cp.where(comps_counts_sums_ratios !=0, comps_counts_sums_ratios, epsilon))))\n",
         "\n",
         "            unique_means = cp.unique(results)\n",
         "            sorted_means = cp.sort(unique_means)[::-1]\n",
@@ -462,7 +513,19 @@
         "\n",
         "            tv_idx += 1\n",
         "\n",
-        "          filtered_results = sorted(zip(all_filtered_means, all_filtered_idxs, all_filtered_tvs), key=lambda x: x[0], reverse=True)[:filter_size]\n",
+        "          f_results = sorted(zip(all_filtered_means, all_filtered_idxs, all_filtered_tvs), key=lambda x: x[0], reverse=True)\n",
+        "\n",
+        "          triplet_dict = {}\n",
+        "\n",
+        "          for triplet in f_results:\n",
+        "\n",
+        "              if triplet[0] not in triplet_dict:\n",
+        "                triplet_dict[triplet[0]] = triplet\n",
+        "              else:\n",
+        "                if triplet[2] == 0:\n",
+        "                  triplet_dict[triplet[0]] = triplet\n",
+        "\n",
+        "          filtered_results = list(triplet_dict.values())[:filter_size]\n",
         "\n",
         "          #=======================================================\n",
         "\n",
@@ -487,7 +550,7 @@
         "            #=======================================================\n",
         "\n",
         "            dir_str = str(fn1)\n",
-        "            copy_path = '/content/Output-MIDI-Dataset/'+dir_str\n",
+        "            copy_path = '/content/Output-MIDI-Dataset/'+search_matching_type+'/'+dir_str\n",
         "            if not os.path.exists(copy_path):\n",
         "                os.mkdir(copy_path)\n",
         "\n",
@@ -534,6 +597,75 @@
       "execution_count": null,
       "outputs": []
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (DOWNLOAD RESULTS)"
+      ],
+      "metadata": {
+        "id": "7Lyy0vjV0dlI"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Zip and download all search results\n",
+        "\n",
+        "print('=' * 70)\n",
+        "\n",
+        "try:\n",
+        "    os.remove('Master_MIDI_Dataset_Search_Results.zip')\n",
+        "except OSError:\n",
+        "    pass\n",
+        "\n",
+        "print('Zipping... Please wait...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "%cd /content/Output-MIDI-Dataset/\n",
+        "!zip -r Master_MIDI_Dataset_Search_Results.zip *\n",
+        "%cd /content/\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Done!')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "print('Downloading final zip file...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "files.download('/content/Output-MIDI-Dataset/Master_MIDI_Dataset_Search_Results.zip')\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "1psdj0RJ0aWH"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Delete search results directory and files\n",
+        "\n",
+        "#@markdown WARNING: This can't be undone so make sure you downloaded the search results first\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Deleting... Please wait...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "!rm -rf /content/Output-MIDI-Dataset\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "z3B-YHIz0jDt"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
     {
       "cell_type": "markdown",
       "metadata": {

TMIDIX.py

@@ -1461,6 +1461,7 @@ import tqdm
 
 from itertools import zip_longest
 from itertools import groupby
+from collections import Counter
 
 from operator import itemgetter
 
@@ -4538,6 +4539,29 @@ def check_and_fix_tones_chord(tones_chord):
 
 ###################################################################################
 
+def create_similarity_matrix(list_of_values, matrix_length=0):
+
+    counts = Counter(list_of_values).items()
+
+    if matrix_length > 0:
+      sim_matrix = [0] * max(matrix_length, len(list_of_values))
+    else:
+      sim_matrix = [0] * len(counts)
+
+    for c in counts:
+      sim_matrix[c[0]] = c[1]
+
+    similarity_matrix = [[0] * len(sim_matrix) for _ in range(len(sim_matrix))]
+
+    for i in range(len(sim_matrix)):
+      for j in range(len(sim_matrix)):
+        if max(sim_matrix[i], sim_matrix[j]) != 0:
+          similarity_matrix[i][j] = min(sim_matrix[i], sim_matrix[j]) / max(sim_matrix[i], sim_matrix[j])
+
+    return similarity_matrix, sim_matrix
+
+###################################################################################
+
 # This is the end of the TMIDI X Python module
 
 ###################################################################################

master_midi_dataset_gpu_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_GPU_Search_and_Filter.ipynb
 
-# Master MIDI Dataset GPU Search and Filter (ver. 2.0)
+# Master MIDI Dataset GPU Search and Filter (ver. 5.0)
 
 ***
 
@@ -49,10 +49,15 @@ import pprint
 import statistics
 import shutil
 
+import locale
+locale.getpreferredencoding = lambda: "UTF-8"
+
 import cupy as cp
 
 from huggingface_hub import hf_hub_download
 
+from google.colab import files
+
 print('Loading TMIDIX module...')
 os.chdir('/content/Los-Angeles-MIDI-Dataset')
 
@@ -142,17 +147,15 @@ print('=' * 70)
 random.shuffle(sigs_data)
 
 signatures_file_names = []
-sigs_matrixes = [ [0]*(len(TMIDIX.ALL_CHORDS)+128) for i in range(len(sigs_data))]
+sigs_matrixes = [ [0]*(len(TMIDIX.ALL_CHORDS)+256) for i in range(len(sigs_data))]
 
 idx = 0
 for s in tqdm(sigs_data):
 
   signatures_file_names.append(s[0])
 
-  counts_sum = sum([c[1] for c in s[1]])
-
   for ss in s[1]:
-    sigs_matrixes[idx][ss[0]] = ss[1] / counts_sum
+    sigs_matrixes[idx][ss[0]] = ss[1]
 
   idx += 1
 
@@ -174,10 +177,15 @@ print('=' * 70)
 
 #@markdown NOTE: You can stop the search at any time to render partial results
 
-number_of_top_matches_MIDIs_to_collect = 20 #@param {type:"slider", min:5, max:50, step:1}
-search_matching_type = "ratios" # @param ["ratios", "distances"]
+number_of_top_matches_MIDIs_to_collect = 30 #@param {type:"slider", min:5, max:50, step:1}
+search_matching_type = "Ratios" # @param ["Ratios", "Distances", "Correlations"]
+maximum_match_ratio_to_search_for = 1 #@param {type:"slider", min:0, max:1, step:0.001}
+match_results_weight = 2 # @param {type:"slider", min:0.1, max:3, step:0.1}
+match_lengths_weight = 1 # @param {type:"slider", min:0.1, max:3, step:0.1}
+match_counts_weight = 1 # @param {type:"slider", min:0.1, max:3, step:0.1}
 distances_norm_order = 3 # @param {type:"slider", min:1, max:10, step:1}
-maximum_match_ratio_to_search_for = 0.999 #@param {type:"slider", min:0, max:1, step:0.001}
+epsilon = 0.5 # @param {type:"slider", min:0.001, max:1, step:0.001}
+match_drums = False # @param {type:"boolean"}
 
 print('=' * 70)
 print('Master MIDI Dataset GPU Search and Filter')
@@ -207,8 +215,8 @@ if filez:
 
   ###################
 
-  if not os.path.exists('/content/Output-MIDI-Dataset'):
-      os.makedirs('/content/Output-MIDI-Dataset')
+  if not os.path.exists('/content/Output-MIDI-Dataset/'+search_matching_type):
+      os.makedirs('/content/Output-MIDI-Dataset/'+search_matching_type)
 
   ###################
 
@@ -237,6 +245,8 @@ if filez:
             e[1] = int(e[1] / 16)
             e[2] = int(e[2] / 16)
 
+          drums_offset = len(TMIDIX.ALL_CHORDS) + 128
+
           src_sigs = []
 
           for i in range(-6, 6):
@@ -249,10 +259,12 @@ if filez:
             cscore = TMIDIX.chordify_score([1000, escore_copy])
 
             sig = []
+            dsig = []
 
             for c in cscore:
 
               pitches = sorted(set([p[4] for p in c if p[3] != 9]))
+              drums = sorted(set([p[4] for p in c if p[3] == 9]))
 
               if pitches:
                 if len(pitches) > 1:
@@ -266,20 +278,28 @@ if filez:
 
                 sig.append(sig_token)
 
-            fsig = [list(v) for v in Counter(sig).most_common()]
+              if drums:
+                dsig.extend(drums)
+
+            sig_p = dict.fromkeys(sig+dsig, 0)
+            for item in sig+dsig:
+              sig_p[item] += 1
 
-            src_sig_mat = [0] * (len(TMIDIX.ALL_CHORDS)+128)
+            fsig = [list(v) for v in sig_p.items()]
 
-            counts_sum = sum([c[1] for c in fsig])
+            src_sig_mat = [0] * (len(TMIDIX.ALL_CHORDS)+256)
 
             for s in fsig:
 
-              src_sig_mat[s[0]] = s[1] / counts_sum
+              src_sig_mat[s[0]] = s[1]
 
             src_sigs.append(src_sig_mat)
 
           src_signatures = cp.stack(cp.array(src_sigs))
 
+          if not match_drums:
+            src_signatures = cp.where(src_signatures < drums_offset, src_signatures, epsilon)
+
           #=======================================================
 
           print('Searching for matches...Please wait...')
@@ -301,18 +321,49 @@ if filez:
 
           for target_sig in tqdm(src_signatures):
 
-            if search_matching_type == 'ratios':
+            if not match_drums:
+              target_sig = cp.where(target_sig < drums_offset, target_sig, epsilon)
 
-              ratios = cp.where(target_sig != 0, cp.divide(cp.minimum(signatures_data, target_sig), cp.maximum(signatures_data, target_sig)), 0)
-              max_comp_lengths = cp.maximum(cp.repeat(cp.sum(target_sig != 0), signatures_data.shape[0]), cp.sum(signatures_data != 0, axis=1))
+            comps_lengths = cp.vstack((cp.repeat(cp.sum(target_sig != 0), signatures_data.shape[0]), cp.sum(signatures_data != 0, axis=1)))
+            comps_lengths_ratios = cp.divide(cp.min(comps_lengths, axis=0), cp.max(comps_lengths, axis=0))
 
-              results = cp.divide(cp.sum(ratios, axis=1), max_comp_lengths)
+            comps_counts_sums = cp.vstack((cp.repeat(cp.sum(target_sig), signatures_data.shape[0]), cp.sum(signatures_data, axis=1)))
+            comps_counts_sums_ratios = cp.divide(cp.min(comps_counts_sums, axis=0), cp.max(comps_counts_sums, axis=0))
 
-            elif search_matching_type == 'distances':
+            if search_matching_type == 'Ratios':
+
+              ratios = cp.where(target_sig != 0, cp.divide(cp.minimum(signatures_data, target_sig), cp.maximum(signatures_data, target_sig)), epsilon)
+              results = cp.mean(ratios, axis=1)
+
+            elif search_matching_type == 'Distances':
 
               distances = cp.power(cp.sum(cp.power(cp.abs(signatures_data - target_sig), distances_norm_order), axis=1), 1 / distances_norm_order)
 
-              results = cp.max(distances) - distances
+              distances_mean = cp.mean(distances)
+              distances_std = cp.std(distances)
+
+              results = 1 - cp.divide((distances - distances_mean), distances_std)
+
+            elif search_matching_type == 'Correlations':
+
+                main_array_mean = cp.mean(signatures_data, axis=1, keepdims=True)
+                main_array_std = cp.std(signatures_data, axis=1, keepdims=True)
+                target_array_mean = cp.mean(target_sig)
+                target_array_std = cp.std(target_sig)
+
+                signatures_data_normalized = cp.where(main_array_std != 0, (signatures_data - main_array_mean) / main_array_std, epsilon)
+                target_sig_normalized = cp.where(target_array_std != 0, (target_sig - target_array_mean) / target_array_std, epsilon)
+
+                correlations = cp.divide(cp.einsum('ij,j->i', signatures_data_normalized, target_sig_normalized), (signatures_data.shape[1] - 1))
+                scaled_correlations = cp.divide(correlations, cp.sqrt(cp.sum(correlations**2)))
+                exp = cp.exp(scaled_correlations - cp.max(scaled_correlations))
+                results = cp.multiply(cp.divide(exp, cp.sum(exp)), 1e5)
+
+            results_weight = match_results_weight
+            comp_lengths_weight = match_lengths_weight
+            comp_counts_sums_weight = match_counts_weight
+
+            results = cp.divide(cp.add(cp.add(results_weight, comp_lengths_weight), comp_counts_sums_weight), cp.add(cp.add(cp.divide(results_weight, cp.where(results !=0, results, epsilon)), cp.divide(comp_lengths_weight, cp.where(comps_lengths_ratios !=0, comps_lengths_ratios, epsilon))), cp.divide(comp_counts_sums_weight, cp.where(comps_counts_sums_ratios !=0, comps_counts_sums_ratios, epsilon))))
 
             unique_means = cp.unique(results)
             sorted_means = cp.sort(unique_means)[::-1]
@@ -331,7 +382,19 @@ if filez:
 
             tv_idx += 1
 
-          filtered_results = sorted(zip(all_filtered_means, all_filtered_idxs, all_filtered_tvs), key=lambda x: x[0], reverse=True)[:filter_size]
+          f_results = sorted(zip(all_filtered_means, all_filtered_idxs, all_filtered_tvs), key=lambda x: x[0], reverse=True)
+
+          triplet_dict = {}
+
+          for triplet in f_results:
+
+              if triplet[0] not in triplet_dict:
+                triplet_dict[triplet[0]] = triplet
+              else:
+                if triplet[2] == 0:
+                  triplet_dict[triplet[0]] = triplet
+
+          filtered_results = list(triplet_dict.values())[:filter_size]
 
           #=======================================================
 
@@ -356,7 +419,7 @@ if filez:
             #=======================================================
 
             dir_str = str(fn1)
-            copy_path = '/content/Output-MIDI-Dataset/'+dir_str
+            copy_path = '/content/Output-MIDI-Dataset/'+search_matching_type+'/'+dir_str
             if not os.path.exists(copy_path):
                 os.mkdir(copy_path)
 
@@ -396,4 +459,47 @@ else:
   print('Could not find any MIDI files. Please check Dataset dir...')
   print('=' * 70)
 
+"""# (DOWNLOAD RESULTS)"""
+
+# Commented out IPython magic to ensure Python compatibility.
+#@title Zip and download all search results
+
+print('=' * 70)
+
+try:
+    os.remove('Master_MIDI_Dataset_Search_Results.zip')
+except OSError:
+    pass
+
+print('Zipping... Please wait...')
+print('=' * 70)
+
+# %cd /content/Output-MIDI-Dataset/
+!zip -r Master_MIDI_Dataset_Search_Results.zip *
+# %cd /content/
+
+print('=' * 70)
+print('Done!')
+print('=' * 70)
+
+print('Downloading final zip file...')
+print('=' * 70)
+
+files.download('/content/Output-MIDI-Dataset/Master_MIDI_Dataset_Search_Results.zip')
+
+print('Done!')
+print('=' * 70)
+
+# @title Delete search results directory and files
+
+#@markdown WARNING: This can't be undone so make sure you downloaded the search results first
+
+print('=' * 70)
+print('Deleting... Please wait...')
+print('=' * 70)
+
+!rm -rf /content/Output-MIDI-Dataset
+print('Done!')
+print('=' * 70)
+
 """# Congrats! You did it! :)"""