Upload 2 files

Master_MIDI_Dataset_GPU_Search_and_Filter.ipynb

@@ -11,7 +11,7 @@
         "id": "SiTIpPjArIyr"
       },
       "source": [
-        "# Master MIDI Dataset GPU Search and Filter (ver. 5.0)\n",
+        "# Master MIDI Dataset GPU Search and Filter (ver. 6.0)\n",
         "\n",
         "***\n",
         "\n",
@@ -26,24 +26,10 @@
         "***"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "gradient": {
-          "editing": false,
-          "id": "fa0a611c-1803-42ae-bdf6-a49b5a4e781b",
-          "kernelId": ""
-        },
-        "id": "gOd93yV0sGd2"
-      },
-      "source": [
-        "# (SETUP ENVIRONMENT)"
-      ]
-    },
     {
       "cell_type": "markdown",
       "source": [
-        "# ( GPU CHECK)"
+        "# (GPU CHECK)"
       ],
       "metadata": {
         "id": "0rMwKVc9FFRw"
@@ -161,7 +147,7 @@
         "id": "ObPxlEutsQBj"
       },
       "source": [
-        "# (PREP MAIN MIDI DATASET)"
+        "# (DOWNLOAD AND UNZIP MAIN MIDI DATASET)"
       ]
     },
     {
@@ -210,6 +196,15 @@
       "execution_count": null,
       "outputs": []
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (CREATE MIDI DATASET FILES LIST)"
+      ],
+      "metadata": {
+        "id": "GE0hPlAEjCrs"
+      }
+    },
     {
       "cell_type": "code",
       "source": [
@@ -246,10 +241,19 @@
       "execution_count": null,
       "outputs": []
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (SIGNATURES SEARCH)"
+      ],
+      "metadata": {
+        "id": "iaeqXuIHI0_T"
+      }
+    },
     {
       "cell_type": "code",
       "source": [
-        "#@title Load Los Angeles MIDI Dataset Signatures Data\n",
+        "# @title Load Los Angeles MIDI Dataset Signatures Data\n",
         "\n",
         "print('=' * 70)\n",
         "print('Loading LAMDa Signatures Data...')\n",
@@ -290,22 +294,13 @@
       "execution_count": null,
       "outputs": []
     },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "# (SEARCH AND FILTER)\n",
-        "\n",
-        "### DO NOT FORGET TO UPLOAD YOUR MASTER DATASET TO \"Master-MIDI-Dataset\" FOLDER"
-      ],
-      "metadata": {
-        "id": "iaeqXuIHI0_T"
-      }
-    },
     {
       "cell_type": "code",
       "source": [
         "#@title Master MIDI Dataset Search and Filter\n",
         "\n",
+        "#@markdown DO NOT FORGET TO UPLOAD YOUR MASTER DATASET TO \"Master-MIDI-Dataset\" FOLDER\n",
+        "\n",
         "#@markdown NOTE: You can stop the search at any time to render partial results\n",
         "\n",
         "number_of_top_matches_MIDIs_to_collect = 30 #@param {type:\"slider\", min:5, max:50, step:1}\n",
@@ -597,6 +592,338 @@
       "execution_count": null,
       "outputs": []
     },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (KILO-CHORDS SEARCH)"
+      ],
+      "metadata": {
+        "id": "ekjgrYRaiFE0"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Load Los Angeles MIDI Dataset Kilo-Chords Data\n",
+        "search_matching_type = \"Full-Kilo-Chords\" # @param [\"Full-Kilo-Chords\", \"Unique-Kilo-Chords\"]\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Loading LAMDa Kilo-Chords Data...')\n",
+        "kilo_chords = pickle.load(open('/content/Main-MIDI-Dataset/KILO_CHORDS_DATA/LAMDa_KILO_CHORDS_DATA.pickle', 'rb'))\n",
+        "print('=' * 70)\n",
+        "\n",
+        "print('Prepping Kilo-Chords...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "random.shuffle(kilo_chords)\n",
+        "\n",
+        "if search_matching_type == 'Full-Kilo-Chords':\n",
+        "\n",
+        "  kilo_chords_file_names = []\n",
+        "\n",
+        "  for kc in tqdm(kilo_chords):\n",
+        "\n",
+        "    kilo_chords_file_names.append(kc[0])\n",
+        "\n",
+        "    kcho = kc[1]\n",
+        "\n",
+        "    kcho += [0] * (1000 - len(kcho))\n",
+        "\n",
+        "  print('=' * 70)\n",
+        "  print('Loading Kilo-Chords...')\n",
+        "  print('=' * 70)\n",
+        "\n",
+        "  kilo_chords_data = cp.array([kc[1] for kc in kilo_chords])\n",
+        "\n",
+        "else:\n",
+        "\n",
+        "  kilo_chords_file_names = []\n",
+        "\n",
+        "  kilo_chords_matrixes = [ [0]*(len(TMIDIX.ALL_CHORDS)+128) for i in range(len(kilo_chords))]\n",
+        "\n",
+        "  idx = 0\n",
+        "  for kc in tqdm(kilo_chords):\n",
+        "\n",
+        "    kilo_chords_file_names.append(kc[0])\n",
+        "\n",
+        "    for c in kc[1]:\n",
+        "      kilo_chords_matrixes[idx][c] += 1\n",
+        "\n",
+        "    idx += 1\n",
+        "\n",
+        "  print('=' * 70)\n",
+        "  print('Loading Kilo-Chords...')\n",
+        "  print('=' * 70)\n",
+        "\n",
+        "  kilo_chords_data = cp.array(kilo_chords_matrixes)\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "YVyUHQiNiJcX"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Master MIDI Dataset Search and Filter\n",
+        "\n",
+        "#@markdown DO NOT FORGET TO UPLOAD YOUR MASTER DATASET TO \"Master-MIDI-Dataset\" FOLDER\n",
+        "\n",
+        "#@markdown NOTE: You can stop the search at any time to render partial results\n",
+        "\n",
+        "number_of_top_matches_MIDIs_to_collect = 30 #@param {type:\"slider\", min:5, max:50, step:1}\n",
+        "maximum_match_ratio_to_search_for = 1 #@param {type:\"slider\", min:0, max:1, step:0.001}\n",
+        "match_results_weight = 1 # @param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
+        "match_lengths_weight = 0.5 # @param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
+        "match_counts_weight = 0.5 # @param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
+        "epsilon = 0.5 # @param {type:\"slider\", min:0.001, max:1, step:0.001}\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Master MIDI Dataset GPU Search and Filter')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "###########\n",
+        "\n",
+        "print('Loading MIDI files...')\n",
+        "print('This may take a while on a large dataset in particular.')\n",
+        "\n",
+        "dataset_addr = \"/content/Master-MIDI-Dataset\"\n",
+        "\n",
+        "filez = list()\n",
+        "\n",
+        "for (dirpath, dirnames, filenames) in os.walk(dataset_addr):\n",
+        "    for file in filenames:\n",
+        "        if file.endswith(('.mid', '.midi', '.kar')):\n",
+        "            filez.append(os.path.join(dirpath, file))\n",
+        "\n",
+        "print('=' * 70)\n",
+        "\n",
+        "if filez:\n",
+        "\n",
+        "  print('Randomizing file list...')\n",
+        "  random.shuffle(filez)\n",
+        "  print('=' * 70)\n",
+        "\n",
+        "  ###################\n",
+        "\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",
+        "  input_files_count = 0\n",
+        "  files_count = 0\n",
+        "\n",
+        "  for f in filez:\n",
+        "\n",
+        "    try:\n",
+        "\n",
+        "          input_files_count += 1\n",
+        "\n",
+        "          fn = os.path.basename(f)\n",
+        "          fn1 = os.path.splitext(fn)[0]\n",
+        "          ext = os.path.splitext(f)[1]\n",
+        "\n",
+        "          print('Processing MIDI File #', files_count+1, 'out of', len(filez))\n",
+        "          print('MIDI file name', fn)\n",
+        "          print('-' * 70)\n",
+        "\n",
+        "          #=======================================================\n",
+        "\n",
+        "          raw_score = TMIDIX.midi2single_track_ms_score(open(f, 'rb').read())\n",
+        "          escore = TMIDIX.advanced_score_processor(raw_score, return_score_analysis=False, return_enhanced_score_notes=True)[0]\n",
+        "\n",
+        "          for e in escore:\n",
+        "            e[1] = int(e[1] / 16)\n",
+        "            e[2] = int(e[2] / 16)\n",
+        "\n",
+        "          src_kilo_chords = []\n",
+        "\n",
+        "          for i in range(-6, 6):\n",
+        "\n",
+        "            escore_copy = copy.deepcopy(escore)\n",
+        "\n",
+        "            for e in escore_copy:\n",
+        "              e[4] += i\n",
+        "\n",
+        "            cscore = TMIDIX.chordify_score([1000, escore_copy])\n",
+        "\n",
+        "            kilo_chord = []\n",
+        "\n",
+        "            for c in cscore:\n",
+        "\n",
+        "              pitches = sorted(set([p[4] for p in c if p[3] != 9]))\n",
+        "\n",
+        "              if pitches:\n",
+        "                if len(pitches) > 1:\n",
+        "                  tones_chord = sorted(set([p % 12 for p in pitches]))\n",
+        "                  checked_tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)\n",
+        "\n",
+        "                  chord_token = TMIDIX.ALL_CHORDS.index(checked_tones_chord) + 128\n",
+        "\n",
+        "                elif len(pitches) == 1:\n",
+        "                  chord_token = pitches[0]\n",
+        "\n",
+        "                kilo_chord.append(chord_token)\n",
+        "\n",
+        "            if search_matching_type == 'Full-Kilo-Chords':\n",
+        "\n",
+        "              kilo_chord = kilo_chord[:1000]\n",
+        "              kilo_chord_matrix = kilo_chord + [0] * (1000 - len(kilo_chord))\n",
+        "\n",
+        "            else:\n",
+        "\n",
+        "              kilo_chord_matrix = [0] * (len(TMIDIX.ALL_CHORDS)+128)\n",
+        "\n",
+        "              for c in kilo_chord:\n",
+        "                kilo_chord_matrix[c] += 1\n",
+        "\n",
+        "            src_kilo_chords.append(kilo_chord_matrix)\n",
+        "\n",
+        "          src_kilo_chords = cp.stack(cp.array(src_kilo_chords))\n",
+        "\n",
+        "          #=======================================================\n",
+        "\n",
+        "          print('Searching for matches...Please wait...')\n",
+        "          print('-' * 70)\n",
+        "\n",
+        "          lower_threshold = 0.0\n",
+        "          upper_threshold = maximum_match_ratio_to_search_for\n",
+        "          filter_size = number_of_top_matches_MIDIs_to_collect\n",
+        "\n",
+        "          final_ratios = []\n",
+        "\n",
+        "          avg_idxs = []\n",
+        "\n",
+        "          all_filtered_means = []\n",
+        "          all_filtered_idxs = []\n",
+        "          all_filtered_tvs = []\n",
+        "\n",
+        "          tv_idx = -6\n",
+        "\n",
+        "          for target_kc in tqdm(src_kilo_chords):\n",
+        "\n",
+        "            comps_lengths = cp.vstack((cp.repeat(cp.sum(target_kc != 0), kilo_chords_data.shape[0]), cp.sum(kilo_chords_data != 0, axis=1)))\n",
+        "            comps_lengths_ratios = cp.divide(cp.min(comps_lengths, axis=0), cp.max(comps_lengths, axis=0))\n",
+        "\n",
+        "            comps_counts_sums = cp.vstack((cp.repeat(cp.sum(target_kc), kilo_chords_data.shape[0]), cp.sum(kilo_chords_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",
+        "            intersections = cp.where((kilo_chords_data == target_kc), kilo_chords_data, 0)\n",
+        "            results = cp.mean(intersections != 0, axis=1)\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",
+        "\n",
+        "            filtered_means = sorted_means[(sorted_means >= lower_threshold) & (sorted_means <= upper_threshold)][:filter_size]\n",
+        "\n",
+        "            filtered_idxs = cp.where(cp.in1d(results, filtered_means))[0]\n",
+        "\n",
+        "            all_filtered_means.extend(results[cp.in1d(results, filtered_means)].tolist())\n",
+        "\n",
+        "            all_filtered_idxs.extend(filtered_idxs.tolist())\n",
+        "\n",
+        "            filtered_tvs = [tv_idx] * filtered_idxs.shape[0]\n",
+        "\n",
+        "            all_filtered_tvs.extend(filtered_tvs)\n",
+        "\n",
+        "            tv_idx += 1\n",
+        "\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",
+        "          print('Done!')\n",
+        "          print('-' * 70)\n",
+        "          print('Max match ratio:', filtered_results[0][0])\n",
+        "          print('Max match transpose value:', filtered_results[0][2])\n",
+        "          print('Max match signature index:', filtered_results[0][1])\n",
+        "          print('Max match file name:', kilo_chords_file_names[filtered_results[0][1]])\n",
+        "          print('-' * 70)\n",
+        "          print('Copying max ratios MIDIs...')\n",
+        "\n",
+        "          for fr in filtered_results:\n",
+        "\n",
+        "            max_ratio_index = fr[1]\n",
+        "\n",
+        "            ffn = kilo_chords_file_names[fr[1]]\n",
+        "            ffn_idx = [y[0] for y in LAMD_files_list].index(ffn)\n",
+        "\n",
+        "            ff = LAMD_files_list[ffn_idx][1]\n",
+        "\n",
+        "            #=======================================================\n",
+        "\n",
+        "            dir_str = str(fn1)\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",
+        "            fff = str(fr[0] * 100) + '_' + str(fr[2]) + '_' + ffn + '.mid'\n",
+        "\n",
+        "            shutil.copy2(ff, copy_path+'/'+fff)\n",
+        "\n",
+        "          shutil.copy2(f, copy_path+'/'+fn)\n",
+        "\n",
+        "          #======================================================='''\n",
+        "          print('Done!')\n",
+        "          print('=' * 70)\n",
+        "\n",
+        "          #=======================================================\n",
+        "\n",
+        "          # Processed files counter\n",
+        "          files_count += 1\n",
+        "\n",
+        "    except KeyboardInterrupt:\n",
+        "        print('Quitting...')\n",
+        "        print('Total number of processed MIDI files', files_count)\n",
+        "        print('=' * 70)\n",
+        "        break\n",
+        "\n",
+        "    except Exception as ex:\n",
+        "        print('WARNING !!!')\n",
+        "        print('=' * 70)\n",
+        "        print('Bad file:', f)\n",
+        "        print('Error detected:', ex)\n",
+        "        print('=' * 70)\n",
+        "        continue\n",
+        "\n",
+        "    print('Total number of processed MIDI files', files_count)\n",
+        "    print('=' * 70)\n",
+        "\n",
+        "else:\n",
+        "  print('Could not find any MIDI files. Please check Dataset dir...')\n",
+        "  print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "fhgpI31piWiX"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
     {
       "cell_type": "markdown",
       "source": [

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. 5.0)
+# Master MIDI Dataset GPU Search and Filter (ver. 6.0)
 
 ***
 
@@ -20,9 +20,7 @@ Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools
 
 ***
 
-# (SETUP ENVIRONMENT)
-
-# ( GPU CHECK)
+# (GPU CHECK)
 """
 
 # @title NVIDIA GPU Check
@@ -79,7 +77,7 @@ if not os.path.exists('/content/Output-MIDI-Dataset'):
 print('Done!')
 print('Enjoy! :)')
 
-"""# (PREP MAIN MIDI DATASET)"""
+"""# (DOWNLOAD AND UNZIP MAIN MIDI DATASET)"""
 
 #@title Download Los Angeles MIDI Dataset
 print('=' * 70)
@@ -108,6 +106,8 @@ print('Done! Enjoy! :)')
 print('=' * 70)
 # %cd /content/
 
+"""# (CREATE MIDI DATASET FILES LIST)"""
+
 #@title Create Los Angeles MIDI Dataset files list
 print('=' * 70)
 print('Creating dataset files list...')
@@ -134,7 +134,9 @@ for f in tqdm(filez):
 print('Done!')
 print('=' * 70)
 
-#@title Load Los Angeles MIDI Dataset Signatures Data
+"""# (SIGNATURES SEARCH)"""
+
+# @title Load Los Angeles MIDI Dataset Signatures Data
 
 print('=' * 70)
 print('Loading LAMDa Signatures Data...')
@@ -168,13 +170,10 @@ signatures_data = cp.array(sigs_matrixes)
 print('Done!')
 print('=' * 70)
 
-"""# (SEARCH AND FILTER)
-
-### DO NOT FORGET TO UPLOAD YOUR MASTER DATASET TO "Master-MIDI-Dataset" FOLDER
-"""
-
 #@title Master MIDI Dataset Search and Filter
 
+#@markdown DO NOT FORGET TO UPLOAD YOUR MASTER DATASET TO "Master-MIDI-Dataset" FOLDER
+
 #@markdown NOTE: You can stop the search at any time to render partial results
 
 number_of_top_matches_MIDIs_to_collect = 30 #@param {type:"slider", min:5, max:50, step:1}
@@ -459,6 +458,311 @@ else:
   print('Could not find any MIDI files. Please check Dataset dir...')
   print('=' * 70)
 
+"""# (KILO-CHORDS SEARCH)"""
+
+#@title Load Los Angeles MIDI Dataset Kilo-Chords Data
+search_matching_type = "Full-Kilo-Chords" # @param ["Full-Kilo-Chords", "Unique-Kilo-Chords"]
+
+print('=' * 70)
+print('Loading LAMDa Kilo-Chords Data...')
+kilo_chords = pickle.load(open('/content/Main-MIDI-Dataset/KILO_CHORDS_DATA/LAMDa_KILO_CHORDS_DATA.pickle', 'rb'))
+print('=' * 70)
+
+print('Prepping Kilo-Chords...')
+print('=' * 70)
+
+random.shuffle(kilo_chords)
+
+if search_matching_type == 'Full-Kilo-Chords':
+
+  kilo_chords_file_names = []
+
+  for kc in tqdm(kilo_chords):
+
+    kilo_chords_file_names.append(kc[0])
+
+    kcho = kc[1]
+
+    kcho += [0] * (1000 - len(kcho))
+
+  print('=' * 70)
+  print('Loading Kilo-Chords...')
+  print('=' * 70)
+
+  kilo_chords_data = cp.array([kc[1] for kc in kilo_chords])
+
+else:
+
+  kilo_chords_file_names = []
+
+  kilo_chords_matrixes = [ [0]*(len(TMIDIX.ALL_CHORDS)+128) for i in range(len(kilo_chords))]
+
+  idx = 0
+  for kc in tqdm(kilo_chords):
+
+    kilo_chords_file_names.append(kc[0])
+
+    for c in kc[1]:
+      kilo_chords_matrixes[idx][c] += 1
+
+    idx += 1
+
+  print('=' * 70)
+  print('Loading Kilo-Chords...')
+  print('=' * 70)
+
+  kilo_chords_data = cp.array(kilo_chords_matrixes)
+
+print('Done!')
+print('=' * 70)
+
+#@title Master MIDI Dataset Search and Filter
+
+#@markdown DO NOT FORGET TO UPLOAD YOUR MASTER DATASET TO "Master-MIDI-Dataset" FOLDER
+
+#@markdown NOTE: You can stop the search at any time to render partial results
+
+number_of_top_matches_MIDIs_to_collect = 30 #@param {type:"slider", min:5, max:50, step:1}
+maximum_match_ratio_to_search_for = 1 #@param {type:"slider", min:0, max:1, step:0.001}
+match_results_weight = 1 # @param {type:"slider", min:0.1, max:3, step:0.1}
+match_lengths_weight = 0.5 # @param {type:"slider", min:0.1, max:3, step:0.1}
+match_counts_weight = 0.5 # @param {type:"slider", min:0.1, max:3, step:0.1}
+epsilon = 0.5 # @param {type:"slider", min:0.001, max:1, step:0.001}
+
+print('=' * 70)
+print('Master MIDI Dataset GPU Search and Filter')
+print('=' * 70)
+
+###########
+
+print('Loading MIDI files...')
+print('This may take a while on a large dataset in particular.')
+
+dataset_addr = "/content/Master-MIDI-Dataset"
+
+filez = list()
+
+for (dirpath, dirnames, filenames) in os.walk(dataset_addr):
+    for file in filenames:
+        if file.endswith(('.mid', '.midi', '.kar')):
+            filez.append(os.path.join(dirpath, file))
+
+print('=' * 70)
+
+if filez:
+
+  print('Randomizing file list...')
+  random.shuffle(filez)
+  print('=' * 70)
+
+  ###################
+
+  if not os.path.exists('/content/Output-MIDI-Dataset/'+search_matching_type):
+      os.makedirs('/content/Output-MIDI-Dataset/'+search_matching_type)
+
+  ###################
+
+  input_files_count = 0
+  files_count = 0
+
+  for f in filez:
+
+    try:
+
+          input_files_count += 1
+
+          fn = os.path.basename(f)
+          fn1 = os.path.splitext(fn)[0]
+          ext = os.path.splitext(f)[1]
+
+          print('Processing MIDI File #', files_count+1, 'out of', len(filez))
+          print('MIDI file name', fn)
+          print('-' * 70)
+
+          #=======================================================
+
+          raw_score = TMIDIX.midi2single_track_ms_score(open(f, 'rb').read())
+          escore = TMIDIX.advanced_score_processor(raw_score, return_score_analysis=False, return_enhanced_score_notes=True)[0]
+
+          for e in escore:
+            e[1] = int(e[1] / 16)
+            e[2] = int(e[2] / 16)
+
+          src_kilo_chords = []
+
+          for i in range(-6, 6):
+
+            escore_copy = copy.deepcopy(escore)
+
+            for e in escore_copy:
+              e[4] += i
+
+            cscore = TMIDIX.chordify_score([1000, escore_copy])
+
+            kilo_chord = []
+
+            for c in cscore:
+
+              pitches = sorted(set([p[4] for p in c if p[3] != 9]))
+
+              if pitches:
+                if len(pitches) > 1:
+                  tones_chord = sorted(set([p % 12 for p in pitches]))
+                  checked_tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)
+
+                  chord_token = TMIDIX.ALL_CHORDS.index(checked_tones_chord) + 128
+
+                elif len(pitches) == 1:
+                  chord_token = pitches[0]
+
+                kilo_chord.append(chord_token)
+
+            if search_matching_type == 'Full-Kilo-Chords':
+
+              kilo_chord = kilo_chord[:1000]
+              kilo_chord_matrix = kilo_chord + [0] * (1000 - len(kilo_chord))
+
+            else:
+
+              kilo_chord_matrix = [0] * (len(TMIDIX.ALL_CHORDS)+128)
+
+              for c in kilo_chord:
+                kilo_chord_matrix[c] += 1
+
+            src_kilo_chords.append(kilo_chord_matrix)
+
+          src_kilo_chords = cp.stack(cp.array(src_kilo_chords))
+
+          #=======================================================
+
+          print('Searching for matches...Please wait...')
+          print('-' * 70)
+
+          lower_threshold = 0.0
+          upper_threshold = maximum_match_ratio_to_search_for
+          filter_size = number_of_top_matches_MIDIs_to_collect
+
+          final_ratios = []
+
+          avg_idxs = []
+
+          all_filtered_means = []
+          all_filtered_idxs = []
+          all_filtered_tvs = []
+
+          tv_idx = -6
+
+          for target_kc in tqdm(src_kilo_chords):
+
+            comps_lengths = cp.vstack((cp.repeat(cp.sum(target_kc != 0), kilo_chords_data.shape[0]), cp.sum(kilo_chords_data != 0, axis=1)))
+            comps_lengths_ratios = cp.divide(cp.min(comps_lengths, axis=0), cp.max(comps_lengths, axis=0))
+
+            comps_counts_sums = cp.vstack((cp.repeat(cp.sum(target_kc), kilo_chords_data.shape[0]), cp.sum(kilo_chords_data, axis=1)))
+            comps_counts_sums_ratios = cp.divide(cp.min(comps_counts_sums, axis=0), cp.max(comps_counts_sums, axis=0))
+
+            intersections = cp.where((kilo_chords_data == target_kc), kilo_chords_data, 0)
+            results = cp.mean(intersections != 0, axis=1)
+
+            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]
+
+            filtered_means = sorted_means[(sorted_means >= lower_threshold) & (sorted_means <= upper_threshold)][:filter_size]
+
+            filtered_idxs = cp.where(cp.in1d(results, filtered_means))[0]
+
+            all_filtered_means.extend(results[cp.in1d(results, filtered_means)].tolist())
+
+            all_filtered_idxs.extend(filtered_idxs.tolist())
+
+            filtered_tvs = [tv_idx] * filtered_idxs.shape[0]
+
+            all_filtered_tvs.extend(filtered_tvs)
+
+            tv_idx += 1
+
+          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]
+
+          #=======================================================
+
+          print('Done!')
+          print('-' * 70)
+          print('Max match ratio:', filtered_results[0][0])
+          print('Max match transpose value:', filtered_results[0][2])
+          print('Max match signature index:', filtered_results[0][1])
+          print('Max match file name:', kilo_chords_file_names[filtered_results[0][1]])
+          print('-' * 70)
+          print('Copying max ratios MIDIs...')
+
+          for fr in filtered_results:
+
+            max_ratio_index = fr[1]
+
+            ffn = kilo_chords_file_names[fr[1]]
+            ffn_idx = [y[0] for y in LAMD_files_list].index(ffn)
+
+            ff = LAMD_files_list[ffn_idx][1]
+
+            #=======================================================
+
+            dir_str = str(fn1)
+            copy_path = '/content/Output-MIDI-Dataset/'+search_matching_type+'/'+dir_str
+            if not os.path.exists(copy_path):
+                os.mkdir(copy_path)
+
+            fff = str(fr[0] * 100) + '_' + str(fr[2]) + '_' + ffn + '.mid'
+
+            shutil.copy2(ff, copy_path+'/'+fff)
+
+          shutil.copy2(f, copy_path+'/'+fn)
+
+          #======================================================='''
+          print('Done!')
+          print('=' * 70)
+
+          #=======================================================
+
+          # Processed files counter
+          files_count += 1
+
+    except KeyboardInterrupt:
+        print('Quitting...')
+        print('Total number of processed MIDI files', files_count)
+        print('=' * 70)
+        break
+
+    except Exception as ex:
+        print('WARNING !!!')
+        print('=' * 70)
+        print('Bad file:', f)
+        print('Error detected:', ex)
+        print('=' * 70)
+        continue
+
+    print('Total number of processed MIDI files', files_count)
+    print('=' * 70)
+
+else:
+  print('Could not find any MIDI files. Please check Dataset dir...')
+  print('=' * 70)
+
 """# (DOWNLOAD RESULTS)"""
 
 # Commented out IPython magic to ensure Python compatibility.