Upload 7 files

Monster-MIDI-Dataset-main.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:65b6f00e480627c897b7f93d26a5971cbedfd3613a2c3ebe867821cc5e73007d
-size 5810003
+oid sha256:9a16ad46342c4cdafbedabc9606f06c7a934737888e213afc6f021098302a055
+size 5811367

Monster_MIDI_Dataset_GPU_Search_and_Filter.ipynb

@@ -74,7 +74,8 @@
         "#@title Install all dependencies (run only once per session)\n",
         "\n",
         "!git clone --depth 1 https://github.com/asigalov61/Monster-MIDI-Dataset\n",
-        "!pip install huggingface_hub"
+        "!pip install huggingface_hub\n",
+        "!pip install hf_transfer"
       ]
     },
     {
@@ -105,6 +106,8 @@
         "import statistics\n",
         "import shutil\n",
         "\n",
+        "os.environ[\"HF_HUB_ENABLE_HF_TRANSFER\"] = \"1\"\n",
+        "\n",
         "try:\n",
         "  import locale\n",
         "  locale.getpreferredencoding = lambda: \"UTF-8\"\n",
@@ -395,15 +398,7 @@
         "          raw_score = TMIDIX.midi2single_track_ms_score(f)\n",
         "          escore = TMIDIX.advanced_score_processor(raw_score, 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",
-        "          # Sorting by patch, pitch, then by start-time\n",
-        "\n",
-        "          escore.sort(key=lambda x: x[6])\n",
-        "          escore.sort(key=lambda x: x[4], reverse=True)\n",
-        "          escore.sort(key=lambda x: x[1])\n",
+        "          escore = TMIDIX.augment_enhanced_score_notes(escore)\n",
         "\n",
         "          drums_offset = len(TMIDIX.ALL_CHORDS_SORTED) + 128\n",
         "\n",
@@ -435,7 +430,7 @@
         "                  try:\n",
         "                      sig_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord) + 128\n",
         "                  except:\n",
-        "                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord, pitches[0])\n",
+        "                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord)\n",
         "                      sig_token = TMIDIX.ALL_CHORDS_SORTED.index(checked_tones_chord) + 128\n",
         "\n",
         "                elif len(pitches) == 1:\n",
@@ -790,15 +785,7 @@
         "          raw_score = TMIDIX.midi2single_track_ms_score(f)\n",
         "          escore = TMIDIX.advanced_score_processor(raw_score, 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",
-        "          # Sorting by patch, pitch, then by start-time\n",
-        "\n",
-        "          escore.sort(key=lambda x: x[6])\n",
-        "          escore.sort(key=lambda x: x[4], reverse=True)\n",
-        "          escore.sort(key=lambda x: x[1])\n",
+        "          escore = TMIDIX.augment_enhanced_score_notes(escore)\n",
         "\n",
         "          src_kilo_chords = []\n",
         "\n",
@@ -824,7 +811,7 @@
         "                  try:\n",
         "                      chord_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord) + 128\n",
         "                  except:\n",
-        "                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord, pitches[0])\n",
+        "                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord)\n",
         "                      chord_token = TMIDIX.ALL_CHORDS_SORTED.index(checked_tones_chord) + 128\n",
         "\n",
         "                elif len(pitches) == 1:\n",

TMIDIX.py

@@ -4690,7 +4690,8 @@ def augment_enhanced_score_notes(enhanced_score_notes,
                                   pitch_shift=0,
                                   ceil_timings=False,
                                   round_timings=False,
-                                  legacy_timings=True
+                                  legacy_timings=True,
+                                  sort_drums_last=False
                                 ):
 
     esn = copy.deepcopy(enhanced_score_notes)
@@ -4740,6 +4741,9 @@ def augment_enhanced_score_notes(enhanced_score_notes,
       esn.sort(key=lambda x: x[6])
       esn.sort(key=lambda x: x[4], reverse=True)
       esn.sort(key=lambda x: x[1])
+      
+    if sort_drums_last:
+        esn.sort(key=lambda x: (x[1], -x[4], x[6]) if x[6] != 128 else (x[1], x[6], -x[4]))
 
     return esn
 
@@ -7883,19 +7887,21 @@ def solo_piano_escore_notes(escore_notes,
     chord = []
 
     for cc in c:
-      if cc[pitches_index] not in seen:
 
-          if cc[channels_index] != 9:
+      if cc[channels_index] != 9:
+        if cc[pitches_index] not in seen:
+            
             cc[channels_index] = 0
             cc[patches_index] = 0
-            
+        
             chord.append(cc)
             seen.append(cc[pitches_index])
-          
-          else:
-            if keep_drums:
+      
+      else:
+        if keep_drums:
+          if cc[pitches_index]+128 not in seen:
               chord.append(cc)
-              seen.append(cc[pitches_index])
+              seen.append(cc[pitches_index]+128)
 
     sp_escore_notes.append(chord)
 
@@ -9254,6 +9260,127 @@ def find_highest_density_escore_notes_chunk(escore_notes, max_chunk_time=512):
     
     return chunk_escore
 
+###################################################################################
+
+def advanced_add_drums_to_escore_notes(escore_notes,
+                                       main_beat_min_dtime=5,
+                                       main_beat_dtime_thres=1,
+                                       drums_durations_value=2,
+                                       drums_pitches_velocities=[(36, 100), 
+                                                                 (38, 100), 
+                                                                 (41, 125)],
+                                       recalculate_score_timings=True,
+                                       intro_drums_count=4,
+                                       intro_drums_time_k=4,
+                                       intro_drums_pitch_velocity=[37, 110]
+                                      ):
+
+    #===========================================================
+    
+    new_dscore = delta_score_notes(escore_notes)
+
+    times = [d[1] for d in new_dscore if d[1] != 0]
+
+    time = [c[0] for c in Counter(times).most_common() if c[0] >= main_beat_min_dtime][0]
+
+    #===========================================================
+
+    if intro_drums_count > 0:
+
+        drums_score = []
+
+        for i in range(intro_drums_count):
+
+            if i == 0:
+                dtime = 0
+
+            else:
+                dtime = time
+            
+            drums_score.append(['note', 
+                                dtime * intro_drums_time_k, 
+                                drums_durations_value, 
+                                9, 
+                                intro_drums_pitch_velocity[0], 
+                                intro_drums_pitch_velocity[1], 
+                                128]
+                              )
+            
+        new_dscore[0][1] = time * intro_drums_time_k
+
+        new_dscore = drums_score + new_dscore
+
+    #===========================================================
+
+    for e in new_dscore:
+    
+        if abs(e[1] - time) == main_beat_dtime_thres:
+            e[1] = time
+
+        if recalculate_score_timings:
+        
+            if e[1] % time != 0 and e[1] > time:
+                if e[1] % time < time // 2:
+                    e[1] -= e[1] % time
+        
+                else:
+                    e[1] += time - (e[1] % time)
+
+    #===========================================================
+
+    drums_score = []
+    
+    dtime = 0
+    
+    idx = 0
+    
+    for i, e in enumerate(new_dscore):
+        
+        drums_score.append(e)
+        
+        dtime += e[1]
+
+        if e[1] != 0:
+            idx += 1
+
+        if i >= intro_drums_count:
+    
+            if (e[1] % time == 0 and e[1] != 0) or i == 0:
+                
+                if idx % 2 == 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[0][0], 
+                                        drums_pitches_velocities[0][1], 
+                                        128]
+                                      )
+                    
+                if idx % 2 != 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[1][0], 
+                                        drums_pitches_velocities[1][1], 
+                                        128]
+                                      )
+        
+                if idx % 4 == 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[2][0], 
+                                        drums_pitches_velocities[2][1], 
+                                        128]
+                                      )
+
+    #===========================================================
+    
+    return delta_score_to_abs_score(drums_score)
+
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module

fluidsynth-master.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f16ae34ae87eeb54fef8b8c62579ef39c0b5f3b7094813bd9602812f817f31be
-size 1965503
+oid sha256:5d67bb7863cc8b2c927c7f726ff8f5344ac875650a00c522939caa0e03bc2209
+size 1960774

monster_midi_dataset_gpu_search_and_filter.py

@@ -32,6 +32,7 @@ Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools
 
 !git clone --depth 1 https://github.com/asigalov61/Monster-MIDI-Dataset
 !pip install huggingface_hub
+!pip install hf_transfer
 
 #@title Import all needed modules
 
@@ -47,6 +48,8 @@ import pprint
 import statistics
 import shutil
 
+os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
 try:
   import locale
   locale.getpreferredencoding = lambda: "UTF-8"
@@ -268,15 +271,7 @@ if filez:
           raw_score = TMIDIX.midi2single_track_ms_score(f)
           escore = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
 
-          for e in escore:
-            e[1] = int(e[1] / 16)
-            e[2] = int(e[2] / 16)
-
-          # Sorting by patch, pitch, then by start-time
-
-          escore.sort(key=lambda x: x[6])
-          escore.sort(key=lambda x: x[4], reverse=True)
-          escore.sort(key=lambda x: x[1])
+          escore = TMIDIX.augment_enhanced_score_notes(escore)
 
           drums_offset = len(TMIDIX.ALL_CHORDS_SORTED) + 128
 
@@ -308,7 +303,7 @@ if filez:
                   try:
                       sig_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord) + 128
                   except:
-                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord, pitches[0])
+                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord)
                       sig_token = TMIDIX.ALL_CHORDS_SORTED.index(checked_tones_chord) + 128
 
                 elif len(pitches) == 1:
@@ -636,15 +631,7 @@ if filez:
           raw_score = TMIDIX.midi2single_track_ms_score(f)
           escore = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
 
-          for e in escore:
-            e[1] = int(e[1] / 16)
-            e[2] = int(e[2] / 16)
-
-          # Sorting by patch, pitch, then by start-time
-
-          escore.sort(key=lambda x: x[6])
-          escore.sort(key=lambda x: x[4], reverse=True)
-          escore.sort(key=lambda x: x[1])
+          escore = TMIDIX.augment_enhanced_score_notes(escore)
 
           src_kilo_chords = []
 
@@ -670,7 +657,7 @@ if filez:
                   try:
                       chord_token = TMIDIX.ALL_CHORDS_SORTED.index(tones_chord) + 128
                   except:
-                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord, pitches[0])
+                      checked_tones_chord = TMIDIX.advanced_check_and_fix_tones_chord(tones_chord)
                       chord_token = TMIDIX.ALL_CHORDS_SORTED.index(checked_tones_chord) + 128
 
                 elif len(pitches) == 1: