Upload 6 files

MIDI.py

@@ -0,0 +1,1732 @@
+#! /usr/bin/python3
+# unsupported 20091104 ...
+#     ['set_sequence_number', dtime, sequence]
+#     ['raw_data', dtime, raw]
+
+# 20150914   jimbo1qaz   MIDI.py str/bytes bug report
+# I found a MIDI file which had Shift-JIS titles. When midi.py decodes it as
+# latin-1, it produces a string which cannot even be accessed without raising
+# a UnicodeDecodeError.  Maybe, when converting raw byte strings from MIDI,
+# you should keep them as bytes, not improperly decode them.  However, this
+# would change the API.  (ie: text = a "string" ? of 0 or more bytes).  It
+# could break compatiblity, but there's not much else you can do to fix the bug
+# https://en.wikipedia.org/wiki/Shift_JIS
+
+r'''
+This module offers functions:  concatenate_scores(), grep(),
+merge_scores(), mix_scores(), midi2opus(), midi2score(), opus2midi(),
+opus2score(), play_score(), score2midi(), score2opus(), score2stats(),
+score_type(), segment(), timeshift() and to_millisecs(),
+where "midi" means the MIDI-file bytes (as can be put in a .mid file,
+or piped into aplaymidi), and "opus" and "score" are list-structures
+as inspired by Sean Burke's MIDI-Perl CPAN module.
+
+Warning: Version 6.4 is not necessarily backward-compatible with
+previous versions, in that text-data is now bytes, not strings.
+This reflects the fact that many MIDI files have text data in
+encodings other that ISO-8859-1, for example in Shift-JIS.
+
+Download MIDI.py from   http://www.pjb.com.au/midi/free/MIDI.py
+and put it in your PYTHONPATH.  MIDI.py depends on Python3.
+
+There is also a call-compatible translation into Lua of this
+module: see http://www.pjb.com.au/comp/lua/MIDI.html
+
+Backup web site: https://peterbillam.gitlab.io/miditools/
+
+The "opus" is a direct translation of the midi-file-events, where
+the times are delta-times, in ticks, since the previous event.
+
+The "score" is more human-centric; it uses absolute times, and
+combines the separate note_on and note_off events into one "note"
+event, with a duration:
+ ['note', start_time, duration, channel, note, velocity] # in a "score"
+
+  EVENTS (in an "opus" structure)
+     ['note_off', dtime, channel, note, velocity]       # in an "opus"
+     ['note_on', dtime, channel, note, velocity]        # in an "opus"
+     ['key_after_touch', dtime, channel, note, velocity]
+     ['control_change', dtime, channel, controller(0-127), value(0-127)]
+     ['patch_change', dtime, channel, patch]
+     ['channel_after_touch', dtime, channel, velocity]
+     ['pitch_wheel_change', dtime, channel, pitch_wheel]
+     ['text_event', dtime, text]
+     ['copyright_text_event', dtime, text]
+     ['track_name', dtime, text]
+     ['instrument_name', dtime, text]
+     ['lyric', dtime, text]
+     ['marker', dtime, text]
+     ['cue_point', dtime, text]
+     ['text_event_08', dtime, text]
+     ['text_event_09', dtime, text]
+     ['text_event_0a', dtime, text]
+     ['text_event_0b', dtime, text]
+     ['text_event_0c', dtime, text]
+     ['text_event_0d', dtime, text]
+     ['text_event_0e', dtime, text]
+     ['text_event_0f', dtime, text]
+     ['end_track', dtime]
+     ['set_tempo', dtime, tempo]
+     ['smpte_offset', dtime, hr, mn, se, fr, ff]
+     ['time_signature', dtime, nn, dd, cc, bb]
+     ['key_signature', dtime, sf, mi]
+     ['sequencer_specific', dtime, raw]
+     ['raw_meta_event', dtime, command(0-255), raw]
+     ['sysex_f0', dtime, raw]
+     ['sysex_f7', dtime, raw]
+     ['song_position', dtime, song_pos]
+     ['song_select', dtime, song_number]
+     ['tune_request', dtime]
+
+  DATA TYPES
+     channel = a value 0 to 15
+     controller = 0 to 127 (see http://www.pjb.com.au/muscript/gm.html#cc )
+     dtime = time measured in "ticks", 0 to 268435455
+     velocity = a value 0 (soft) to 127 (loud)
+     note = a value 0 to 127  (middle-C is 60)
+     patch = 0 to 127 (see http://www.pjb.com.au/muscript/gm.html )
+     pitch_wheel = a value -8192 to 8191 (0x1FFF)
+     raw = bytes, of length 0 or more  (for sysex events see below)
+     sequence_number = a value 0 to 65,535 (0xFFFF)
+     song_pos = a value 0 to 16,383 (0x3FFF)
+     song_number = a value 0 to 127
+     tempo = microseconds per crochet (quarter-note), 0 to 16777215
+     text = bytes, of length 0 or more
+     ticks = the number of ticks per crochet (quarter-note)
+
+   In sysex_f0 events, the raw data must not start with a \xF0 byte,
+   since this gets added automatically;
+   but it must end with an explicit \xF7 byte!
+   In the very unlikely case that you ever need to split sysex data
+   into one sysex_f0 followed by one or more sysex_f7s, then only the
+   last of those sysex_f7 events must end with the explicit \xF7 byte
+   (again, the raw data of individual sysex_f7 events must not start
+   with any \xF7 byte, since this gets added automatically).
+
+   Since version 6.4, text data is in bytes, not in a ISO-8859-1 string.
+
+
+  GOING THROUGH A SCORE WITHIN A PYTHON PROGRAM
+    channels = {2,3,5,8,13}
+    itrack = 1   # skip 1st element which is ticks
+    while itrack < len(score):
+        for event in score[itrack]:
+            if event[0] == 'note':   # for example,
+                pass  # do something to all notes
+            # or, to work on events in only particular channels...
+            channel_index = MIDI.Event2channelindex.get(event[0], False)
+            if channel_index and (event[channel_index] in channels):
+                pass  # do something to channels 2,3,5,8 and 13
+        itrack += 1
+
+'''
+
+import sys, struct, copy
+# sys.stdout = os.fdopen(sys.stdout.fileno(), 'wb')
+Version = '6.7'
+VersionDate = '20201120'
+# 20201120 6.7 call to bytest() removed, and protect _unshift_ber_int
+# 20160702 6.6 to_millisecs() now handles set_tempo across multiple Tracks
+# 20150921 6.5 segment restores controllers as well as patch and tempo
+# 20150914 6.4 text data is bytes or bytearray, not ISO-8859-1 strings
+# 20150628 6.3 absent any set_tempo, default is 120bpm (see MIDI file spec 1.1)
+# 20150101 6.2 all text events can be 8-bit; let user get the right encoding
+# 20141231 6.1 fix _some_text_event; sequencer_specific data can be 8-bit
+# 20141230 6.0 synth_specific data can be 8-bit
+# 20120504 5.9 add the contents of mid_opus_tracks()
+# 20120208 5.8 fix num_notes_by_channel() ; should be a dict
+# 20120129 5.7 _encode handles empty tracks; score2stats num_notes_by_channel
+# 20111111 5.6 fix patch 45 and 46 in Number2patch, should be Harp
+# 20110129 5.5 add mix_opus_tracks() and event2alsaseq()
+# 20110126 5.4 "previous message repeated N times" to save space on stderr
+# 20110125 5.2 opus2score terminates unended notes at the end of the track
+# 20110124 5.1 the warnings in midi2opus display track_num
+# 21110122 5.0 if garbage, midi2opus returns the opus so far
+# 21110119 4.9 non-ascii chars stripped out of the text_events
+# 21110110 4.8 note_on with velocity=0 treated as a note-off
+# 21110108 4.6 unknown F-series event correctly eats just one byte
+# 21011010 4.2 segment() uses start_time, end_time named params
+# 21011005 4.1 timeshift() must not pad the set_tempo command
+# 21011003 4.0 pitch2note_event must be chapitch2note_event
+# 21010918 3.9 set_sequence_number supported, FWIW
+# 20100913 3.7 many small bugfixes; passes all tests
+# 20100910 3.6 concatenate_scores enforce ticks=1000, just like merge_scores
+# 20100908 3.5 minor bugs fixed in score2stats
+# 20091104 3.4 tune_request now supported
+# 20091104 3.3 fixed bug in decoding song_position and song_select
+# 20091104 3.2 unsupported: set_sequence_number tune_request raw_data
+# 20091101 3.1 document how to traverse a score within Python
+# 20091021 3.0 fixed bug in score2stats detecting GM-mode = 0
+# 20091020 2.9 score2stats reports GM-mode and bank msb,lsb events
+# 20091019 2.8 in merge_scores, channel 9 must remain channel 9 (in GM)
+# 20091018 2.7 handles empty tracks gracefully
+# 20091015 2.6 grep() selects channels
+# 20091010 2.5 merge_scores reassigns channels to avoid conflicts
+# 20091010 2.4 fixed bug in to_millisecs which now only does opusses
+# 20091010 2.3 score2stats returns channels & patch_changes, by_track & total
+# 20091010 2.2 score2stats() returns also pitches and percussion dicts
+# 20091010 2.1 bugs: >= not > in segment, to notice patch_change at time 0
+# 20091010 2.0 bugs: spurious pop(0) ( in _decode sysex
+# 20091008 1.9 bugs: ISO decoding in sysex; str( not int( in note-off warning
+# 20091008 1.8 add concatenate_scores()
+# 20091006 1.7 score2stats() measures nticks and ticks_per_quarter
+# 20091004 1.6 first mix_scores() and merge_scores()
+# 20090424 1.5 timeshift() bugfix: earliest only sees events after from_time
+# 20090330 1.4 timeshift() has also a from_time argument
+# 20090322 1.3 timeshift() has also a start_time argument
+# 20090319 1.2 add segment() and timeshift()
+# 20090301 1.1 add to_millisecs()
+
+_previous_warning = ''  # 5.4
+_previous_times = 0     # 5.4
+#------------------------------- Encoding stuff --------------------------
+
+def opus2midi(opus=[]):
+    r'''The argument is a list: the first item in the list is the "ticks"
+parameter, the others are the tracks. Each track is a list
+of midi-events, and each event is itself a list; see above.
+opus2midi() returns a bytestring of the MIDI, which can then be
+written either to a file opened in binary mode (mode='wb'),
+or to stdout by means of:   sys.stdout.buffer.write()
+
+my_opus = [
+    96, 
+    [   # track 0:
+        ['patch_change', 0, 1, 8],   # and these are the events...
+        ['note_on',   5, 1, 25, 96],
+        ['note_off', 96, 1, 25, 0],
+        ['note_on',   0, 1, 29, 96],
+        ['note_off', 96, 1, 29, 0],
+    ],   # end of track 0
+]
+my_midi = opus2midi(my_opus)
+sys.stdout.buffer.write(my_midi)
+'''
+    if len(opus) < 2:
+        opus=[1000, [],]
+    tracks = copy.deepcopy(opus)
+    ticks = int(tracks.pop(0))
+    ntracks = len(tracks)
+    if ntracks == 1:
+        format = 0
+    else:
+        format = 1
+
+    my_midi = b"MThd\x00\x00\x00\x06"+struct.pack('>HHH',format,ntracks,ticks)
+    for track in tracks:
+        events = _encode(track)
+        my_midi += b'MTrk' + struct.pack('>I',len(events)) + events
+    _clean_up_warnings()
+    return my_midi
+
+
+def score2opus(score=None):
+    r'''
+The argument is a list: the first item in the list is the "ticks"
+parameter, the others are the tracks. Each track is a list
+of score-events, and each event is itself a list.  A score-event
+is similar to an opus-event (see above), except that in a score:
+ 1) the times are expressed as an absolute number of ticks
+    from the track's start time
+ 2) the pairs of 'note_on' and 'note_off' events in an "opus"
+    are abstracted into a single 'note' event in a "score":
+    ['note', start_time, duration, channel, pitch, velocity]
+score2opus() returns a list specifying the equivalent "opus".
+
+my_score = [
+    96,
+    [   # track 0:
+        ['patch_change', 0, 1, 8],
+        ['note', 5, 96, 1, 25, 96],
+        ['note', 101, 96, 1, 29, 96]
+    ],   # end of track 0
+]
+my_opus = score2opus(my_score)
+'''
+    if len(score) < 2:
+        score=[1000, [],]
+    tracks = copy.deepcopy(score)
+    ticks = int(tracks.pop(0))
+    opus_tracks = []
+    for scoretrack in tracks:
+        time2events = dict([])
+        for scoreevent in scoretrack:
+            if scoreevent[0] == 'note':
+                note_on_event = ['note_on',scoreevent[1],
+                 scoreevent[3],scoreevent[4],scoreevent[5]]
+                note_off_event = ['note_off',scoreevent[1]+scoreevent[2],
+                 scoreevent[3],scoreevent[4],scoreevent[5]]
+                if time2events.get(note_on_event[1]):
+                   time2events[note_on_event[1]].append(note_on_event)
+                else:
+                   time2events[note_on_event[1]] = [note_on_event,]
+                if time2events.get(note_off_event[1]):
+                   time2events[note_off_event[1]].append(note_off_event)
+                else:
+                   time2events[note_off_event[1]] = [note_off_event,]
+                continue
+            if time2events.get(scoreevent[1]):
+               time2events[scoreevent[1]].append(scoreevent)
+            else:
+               time2events[scoreevent[1]] = [scoreevent,]
+
+        sorted_times = []  # list of keys
+        for k in time2events.keys():
+            sorted_times.append(k)
+        sorted_times.sort()
+
+        sorted_events = []  # once-flattened list of values sorted by key
+        for time in sorted_times:
+            sorted_events.extend(time2events[time])
+
+        abs_time = 0
+        for event in sorted_events:  # convert abs times => delta times
+            delta_time = event[1] - abs_time
+            abs_time = event[1]
+            event[1] = delta_time
+        opus_tracks.append(sorted_events)
+    opus_tracks.insert(0,ticks)
+    _clean_up_warnings()
+    return opus_tracks
+
+def score2midi(score=None):
+    r'''
+Translates a "score" into MIDI, using score2opus() then opus2midi()
+'''
+    return opus2midi(score2opus(score))
+
+#--------------------------- Decoding stuff ------------------------
+
+def midi2opus(midi=b''):
+    r'''Translates MIDI into a "opus".  For a description of the
+"opus" format, see opus2midi()
+'''
+    my_midi=bytearray(midi)
+    if len(my_midi) < 4:
+        _clean_up_warnings()
+        return [1000,[],]
+    id = bytes(my_midi[0:4])
+    if id != b'MThd':
+        _warn("midi2opus: midi starts with "+str(id)+" instead of 'MThd'")
+        _clean_up_warnings()
+        return [1000,[],]
+    [length, format, tracks_expected, ticks] = struct.unpack(
+     '>IHHH', bytes(my_midi[4:14]))
+    if length != 6:
+        _warn("midi2opus: midi header length was "+str(length)+" instead of 6")
+        _clean_up_warnings()
+        return [1000,[],]
+    my_opus = [ticks,]
+    my_midi = my_midi[14:]
+    track_num = 1   # 5.1
+    while len(my_midi) >= 8:
+        track_type   = bytes(my_midi[0:4])
+        if track_type != b'MTrk':
+            _warn('midi2opus: Warning: track #'+str(track_num)+' type is '+str(track_type)+" instead of b'MTrk'")
+        [track_length] = struct.unpack('>I', my_midi[4:8])
+        my_midi = my_midi[8:]
+        if track_length > len(my_midi):
+            _warn('midi2opus: track #'+str(track_num)+' length '+str(track_length)+' is too large')
+            _clean_up_warnings()
+            return my_opus   # 5.0
+        my_midi_track = my_midi[0:track_length]
+        my_track = _decode(my_midi_track)
+        my_opus.append(my_track)
+        my_midi = my_midi[track_length:]
+        track_num += 1   # 5.1
+    _clean_up_warnings()
+    return my_opus
+
+def opus2score(opus=[]):
+    r'''For a description of the "opus" and "score" formats,
+see opus2midi() and score2opus().
+'''
+    if len(opus) < 2:
+        _clean_up_warnings()
+        return [1000,[],]
+    tracks = copy.deepcopy(opus)  # couple of slices probably quicker...
+    ticks = int(tracks.pop(0))
+    score = [ticks,]
+    for opus_track in tracks:
+        ticks_so_far = 0
+        score_track = []
+        chapitch2note_on_events = dict([])   # 4.0
+        for opus_event in opus_track:
+            ticks_so_far += opus_event[1]
+            if opus_event[0] == 'note_off' or (opus_event[0] == 'note_on' and opus_event[4] == 0):  # 4.8
+                cha = opus_event[2]
+                pitch = opus_event[3]
+                key = cha*128 + pitch
+                if chapitch2note_on_events.get(key):
+                    new_event = chapitch2note_on_events[key].pop(0)
+                    new_event[2] = ticks_so_far - new_event[1]
+                    score_track.append(new_event)
+                elif pitch > 127:
+                    pass #_warn('opus2score: note_off with no note_on, bad pitch='+str(pitch))
+                else:
+                    pass #_warn('opus2score: note_off with no note_on cha='+str(cha)+' pitch='+str(pitch))
+            elif opus_event[0] == 'note_on':
+                cha = opus_event[2]
+                pitch = opus_event[3]
+                key = cha*128 + pitch
+                new_event = ['note',ticks_so_far,0,cha,pitch, opus_event[4]]
+                if chapitch2note_on_events.get(key):
+                    chapitch2note_on_events[key].append(new_event)
+                else:
+                    chapitch2note_on_events[key] = [new_event,]
+            else:
+                opus_event[1] = ticks_so_far
+                score_track.append(opus_event)
+        # check for unterminated notes (Oisín) -- 5.2
+        for chapitch in chapitch2note_on_events:
+            note_on_events = chapitch2note_on_events[chapitch]
+            for new_e in note_on_events:
+                new_e[2] = ticks_so_far - new_e[1]
+                score_track.append(new_e)
+                pass #_warn("opus2score: note_on with no note_off cha="+str(new_e[3])+' pitch='+str(new_e[4])+'; adding note_off at end')
+        score.append(score_track)
+    _clean_up_warnings()
+    return score
+
+def midi2score(midi=b''):
+    r'''
+Translates MIDI into a "score", using midi2opus() then opus2score()
+'''
+    return opus2score(midi2opus(midi))
+
+def midi2ms_score(midi=b''):
+    r'''
+Translates MIDI into a "score" with one beat per second and one
+tick per millisecond, using midi2opus() then to_millisecs()
+then opus2score()
+'''
+    return opus2score(to_millisecs(midi2opus(midi)))
+
+#------------------------ Other Transformations ---------------------
+
+def to_millisecs(old_opus=None):
+    r'''Recallibrates all the times in an "opus" to use one beat
+per second and one tick per millisecond.  This makes it
+hard to retrieve any information about beats or barlines,
+but it does make it easy to mix different scores together.
+'''
+    if old_opus == None:
+        return [1000,[],]
+    try:
+        old_tpq  = int(old_opus[0])
+    except IndexError:   # 5.0
+        _warn('to_millisecs: the opus '+str(type(old_opus))+' has no elements')
+        return [1000,[],]
+    new_opus = [1000,]
+    # 6.7 first go through building a table of set_tempos by absolute-tick
+    ticks2tempo = {}
+    itrack = 1
+    while itrack < len(old_opus):
+        ticks_so_far = 0
+        for old_event in old_opus[itrack]:
+            if old_event[0] == 'note':
+                raise TypeError('to_millisecs needs an opus, not a score')
+            ticks_so_far += old_event[1]
+            if old_event[0] == 'set_tempo':
+                ticks2tempo[ticks_so_far] = old_event[2]
+        itrack += 1
+    # then get the sorted-array of their keys
+    tempo_ticks = []  # list of keys
+    for k in ticks2tempo.keys():
+        tempo_ticks.append(k)
+    tempo_ticks.sort()
+    # then go through converting to millisec, testing if the next
+    # set_tempo lies before the next track-event, and using it if so.
+    itrack = 1
+    while itrack < len(old_opus):
+        ms_per_old_tick = 500.0 / old_tpq  # float: will round later 6.3
+        i_tempo_ticks = 0
+        ticks_so_far = 0
+        ms_so_far = 0.0
+        previous_ms_so_far = 0.0
+        new_track = [['set_tempo',0,1000000],]  # new "crochet" is 1 sec
+        for old_event in old_opus[itrack]:
+            # detect if ticks2tempo has something before this event
+            # 20160702 if ticks2tempo is at the same time, leave it
+            event_delta_ticks = old_event[1]
+            if (i_tempo_ticks < len(tempo_ticks) and
+              tempo_ticks[i_tempo_ticks] < (ticks_so_far + old_event[1])):
+                delta_ticks = tempo_ticks[i_tempo_ticks] - ticks_so_far
+                ms_so_far += (ms_per_old_tick * delta_ticks)
+                ticks_so_far = tempo_ticks[i_tempo_ticks]
+                ms_per_old_tick = ticks2tempo[ticks_so_far] / (1000.0*old_tpq)
+                i_tempo_ticks += 1
+                event_delta_ticks -= delta_ticks
+            new_event = copy.deepcopy(old_event)  # now handle the new event
+            ms_so_far += (ms_per_old_tick * old_event[1])
+            new_event[1] = round(ms_so_far - previous_ms_so_far)
+            if old_event[0] != 'set_tempo':
+                previous_ms_so_far = ms_so_far
+                new_track.append(new_event)
+            ticks_so_far += event_delta_ticks
+        new_opus.append(new_track)
+        itrack += 1
+    _clean_up_warnings()
+    return new_opus
+
+def event2alsaseq(event=None):   # 5.5
+    r'''Converts an event into the format needed by the alsaseq module,
+http://pp.com.mx/python/alsaseq
+The type of track (opus or score) is autodetected.
+'''
+    pass
+
+def grep(score=None, channels=None):
+    r'''Returns a "score" containing only the channels specified
+'''
+    if score == None:
+        return [1000,[],]
+    ticks = score[0]
+    new_score = [ticks,]
+    if channels == None:
+        return new_score
+    channels = set(channels)
+    global Event2channelindex
+    itrack = 1
+    while itrack < len(score):
+        new_score.append([])
+        for event in score[itrack]:
+            channel_index = Event2channelindex.get(event[0], False)
+            if channel_index:
+                if event[channel_index] in channels:
+                    new_score[itrack].append(event)
+            else:
+                new_score[itrack].append(event)
+        itrack += 1
+    return new_score
+
+def play_score(score=None):
+    r'''Converts the "score" to midi, and feeds it into 'aplaymidi -'
+'''
+    if score == None:
+        return
+    import subprocess
+    pipe = subprocess.Popen(['aplaymidi','-'], stdin=subprocess.PIPE)
+    if score_type(score) == 'opus':
+        pipe.stdin.write(opus2midi(score))
+    else:
+        pipe.stdin.write(score2midi(score))
+    pipe.stdin.close()
+
+def timeshift(score=None, shift=None, start_time=None, from_time=0, tracks={0,1,2,3,4,5,6,7,8,10,12,13,14,15}):
+    r'''Returns a "score" shifted in time by "shift" ticks, or shifted
+so that the first event starts at "start_time" ticks.
+
+If "from_time" is specified, only those events in the score
+that begin after it are shifted. If "start_time" is less than
+"from_time" (or "shift" is negative), then the intermediate
+notes are deleted, though patch-change events are preserved.
+
+If "tracks" are specified, then only those tracks get shifted.
+"tracks" can be a list, tuple or set; it gets converted to set
+internally.
+
+It is deprecated to specify both "shift" and "start_time".
+If this does happen, timeshift() will print a warning to
+stderr and ignore the "shift" argument.
+
+If "shift" is negative and sufficiently large that it would
+leave some event with a negative tick-value, then the score
+is shifted so that the first event occurs at time 0. This
+also occurs if "start_time" is negative, and is also the
+default if neither "shift" nor "start_time" are specified.
+'''
+    #_warn('tracks='+str(tracks))
+    if score == None or len(score) < 2:
+        return [1000, [],]
+    new_score = [score[0],]
+    my_type = score_type(score)
+    if my_type == '':
+        return new_score
+    if my_type == 'opus':
+        _warn("timeshift: opus format is not supported\n")
+        # _clean_up_scores()  6.2; doesn't exist! what was it supposed to do?
+        return new_score
+    if not (shift == None) and not (start_time == None):
+        _warn("timeshift: shift and start_time specified: ignoring shift\n")
+        shift = None
+    if shift == None:
+        if (start_time == None) or (start_time < 0):
+            start_time = 0
+        # shift = start_time - from_time
+
+    i = 1   # ignore first element (ticks)
+    tracks = set(tracks)  # defend against tuples and lists
+    earliest = 1000000000
+    if not (start_time == None) or shift < 0:  # first find the earliest event
+        while i < len(score):
+            if len(tracks) and not ((i-1) in tracks):
+                i += 1
+                continue
+            for event in score[i]:
+                 if event[1] < from_time:
+                     continue  # just inspect the to_be_shifted events
+                 if event[1] < earliest:
+                     earliest = event[1]
+            i += 1
+    if earliest > 999999999:
+        earliest = 0
+    if shift == None:
+        shift = start_time - earliest
+    elif (earliest + shift) < 0:
+        start_time = 0
+        shift = 0 - earliest
+
+    i = 1   # ignore first element (ticks)
+    while i < len(score):
+        if len(tracks) == 0 or not ((i-1) in tracks):  # 3.8
+            new_score.append(score[i])
+            i += 1
+            continue
+        new_track = []
+        for event in score[i]:
+            new_event = list(event)
+            #if new_event[1] == 0 and shift > 0 and new_event[0] != 'note':
+            #    pass
+            #elif new_event[1] >= from_time:
+            if new_event[1] >= from_time:
+                # 4.1 must not rightshift set_tempo
+                if new_event[0] != 'set_tempo' or shift<0:
+                    new_event[1] += shift
+            elif (shift < 0) and (new_event[1] >= (from_time+shift)):
+                continue
+            new_track.append(new_event)
+        if len(new_track) > 0:
+            new_score.append(new_track)
+        i += 1
+    _clean_up_warnings()
+    return new_score
+
+def segment(score=None, start_time=None, end_time=None, start=0, end=100000000,
+ tracks={0,1,2,3,4,5,6,7,8,10,11,12,13,14,15}):
+    r'''Returns a "score" which is a segment of the one supplied
+as the argument, beginning at "start_time" ticks and ending
+at "end_time" ticks (or at the end if "end_time" is not supplied).
+If the set "tracks" is specified, only those tracks will
+be returned.
+'''
+    if score == None or len(score) < 2:
+        return [1000, [],]
+    if start_time == None:  # as of 4.2 start_time is recommended
+        start_time = start  # start is legacy usage
+    if end_time == None:    # likewise
+        end_time = end
+    new_score = [score[0],]
+    my_type = score_type(score)
+    if my_type == '':
+        return new_score
+    if my_type == 'opus':
+        # more difficult (disconnecting note_on's from their note_off's)...
+        _warn("segment: opus format is not supported\n")
+        _clean_up_warnings()
+        return new_score
+    i = 1   # ignore first element (ticks); we count in ticks anyway
+    tracks = set(tracks)  # defend against tuples and lists
+    while i < len(score):
+        if len(tracks) and not ((i-1) in tracks):
+            i += 1
+            continue
+        new_track = []
+        channel2cc_num  = {}     # most recent controller change before start
+        channel2cc_val  = {}
+        channel2cc_time = {}
+        channel2patch_num  = {}  # keep most recent patch change before start
+        channel2patch_time = {}
+        set_tempo_num  = 500000 # most recent tempo change before start 6.3
+        set_tempo_time = 0
+        earliest_note_time = end_time
+        for event in score[i]:
+            if event[0] == 'control_change':  # 6.5
+                cc_time = channel2cc_time.get(event[2]) or 0
+                if (event[1] <= start_time) and (event[1] >= cc_time):
+                    channel2cc_num[event[2]]  = event[3]
+                    channel2cc_val[event[2]]  = event[4]
+                    channel2cc_time[event[2]] = event[1]
+            elif event[0] == 'patch_change':
+                patch_time = channel2patch_time.get(event[2]) or 0
+                if (event[1]<=start_time) and (event[1] >= patch_time):  # 2.0
+                    channel2patch_num[event[2]]  = event[3]
+                    channel2patch_time[event[2]] = event[1]
+            elif event[0] == 'set_tempo':
+                if (event[1]<=start_time) and (event[1]>=set_tempo_time): #6.4
+                    set_tempo_num  = event[2]
+                    set_tempo_time = event[1]
+            if (event[1] >= start_time) and (event[1] <= end_time):
+                new_track.append(event)
+                if (event[0] == 'note') and (event[1] < earliest_note_time):
+                    earliest_note_time = event[1]
+        if len(new_track) > 0:
+            new_track.append(['set_tempo', start_time, set_tempo_num])
+            for c in channel2patch_num:
+                new_track.append(['patch_change',start_time,c,channel2patch_num[c]],)
+            for c in channel2cc_num:   # 6.5
+                new_track.append(['control_change',start_time,c,channel2cc_num[c],channel2cc_val[c]])
+            new_score.append(new_track)
+        i += 1
+    _clean_up_warnings()
+    return new_score
+
+def score_type(opus_or_score=None):
+    r'''Returns a string, either 'opus' or 'score' or ''
+'''
+    if opus_or_score == None or str(type(opus_or_score)).find('list')<0 or len(opus_or_score) < 2:
+        return ''
+    i = 1   # ignore first element
+    while i < len(opus_or_score):
+        for event in opus_or_score[i]:
+            if event[0] == 'note':
+                return 'score'
+            elif event[0] == 'note_on':
+                return 'opus'
+        i += 1
+    return ''
+
+def concatenate_scores(scores):
+    r'''Concatenates a list of scores into one score.
+If the scores differ in their "ticks" parameter,
+they will all get converted to millisecond-tick format.
+'''
+    # the deepcopys are needed if the input_score's are refs to the same obj
+    # e.g. if invoked by midisox's repeat()
+    input_scores = _consistentise_ticks(scores)  # 3.7
+    output_score = copy.deepcopy(input_scores[0])
+    for input_score in input_scores[1:]:
+        output_stats = score2stats(output_score)
+        delta_ticks = output_stats['nticks']
+        itrack = 1
+        while itrack < len(input_score):
+            if itrack >= len(output_score): # new output track if doesn't exist
+                output_score.append([])
+            for event in input_score[itrack]:
+                output_score[itrack].append(copy.deepcopy(event))
+                output_score[itrack][-1][1] += delta_ticks
+            itrack += 1
+    return output_score
+
+def merge_scores(scores):
+    r'''Merges a list of scores into one score.  A merged score comprises
+all of the tracks from all of the input scores; un-merging is possible
+by selecting just some of the tracks.  If the scores differ in their
+"ticks" parameter, they will all get converted to millisecond-tick
+format.  merge_scores attempts to resolve channel-conflicts,
+but there are of course only 15 available channels...
+'''
+    input_scores = _consistentise_ticks(scores)  # 3.6
+    output_score = [1000]
+    channels_so_far = set()
+    all_channels = {0,1,2,3,4,5,6,7,8,10,11,12,13,14,15}
+    global Event2channelindex
+    for input_score in input_scores:
+        new_channels = set(score2stats(input_score).get('channels_total', []))
+        new_channels.discard(9)  # 2.8 cha9 must remain cha9 (in GM)
+        for channel in channels_so_far & new_channels:
+            # consistently choose lowest avaiable, to ease testing
+            free_channels = list(all_channels - (channels_so_far|new_channels))
+            if len(free_channels) > 0:
+                free_channels.sort()
+                free_channel = free_channels[0]
+            else:
+                free_channel = None
+                break
+            itrack = 1
+            while itrack < len(input_score):
+                for input_event in input_score[itrack]:
+                    channel_index=Event2channelindex.get(input_event[0],False)
+                    if channel_index and input_event[channel_index]==channel:
+                        input_event[channel_index] = free_channel
+                itrack += 1
+            channels_so_far.add(free_channel)
+
+        channels_so_far |= new_channels
+        output_score.extend(input_score[1:])
+    return output_score
+
+def _ticks(event):
+    return event[1]
+def mix_opus_tracks(input_tracks):   # 5.5
+    r'''Mixes an array of tracks into one track.  A mixed track
+cannot be un-mixed.  It is assumed that the tracks share the same
+ticks parameter and the same tempo.
+Mixing score-tracks is trivial (just insert all events into one array).
+Mixing opus-tracks is only slightly harder, but it's common enough
+that a dedicated function is useful.
+'''
+    output_score = [1000, []]
+    for input_track in input_tracks:   # 5.8
+        input_score = opus2score([1000, input_track])
+        for event in input_score[1]:
+            output_score[1].append(event)
+    output_score[1].sort(key=_ticks) 
+    output_opus = score2opus(output_score)
+    return output_opus[1]
+
+def mix_scores(scores):
+    r'''Mixes a list of scores into one one-track score.
+A mixed score cannot be un-mixed.  Hopefully the scores
+have no undesirable channel-conflicts between them.
+If the scores differ in their "ticks" parameter,
+they will all get converted to millisecond-tick format.
+'''
+    input_scores = _consistentise_ticks(scores)  # 3.6
+    output_score = [1000, []]
+    for input_score in input_scores:
+        for input_track in input_score[1:]:
+            output_score[1].extend(input_track)
+    return output_score
+
+def score2stats(opus_or_score=None):
+    r'''Returns a dict of some basic stats about the score, like
+bank_select (list of tuples (msb,lsb)),
+channels_by_track (list of lists), channels_total (set),
+general_midi_mode (list),
+ntracks, nticks, patch_changes_by_track (list of dicts),
+num_notes_by_channel (list of numbers),
+patch_changes_total (set),
+percussion (dict histogram of channel 9 events),
+pitches (dict histogram of pitches on channels other than 9),
+pitch_range_by_track (list, by track, of two-member-tuples),
+pitch_range_sum (sum over tracks of the pitch_ranges),
+'''
+    bank_select_msb = -1
+    bank_select_lsb = -1
+    bank_select = []
+    channels_by_track = []
+    channels_total    = set([])
+    general_midi_mode = []
+    num_notes_by_channel = dict([])
+    patches_used_by_track  = []
+    patches_used_total     = set([])
+    patch_changes_by_track = []
+    patch_changes_total    = set([])
+    percussion = dict([]) # histogram of channel 9 "pitches"
+    pitches    = dict([]) # histogram of pitch-occurrences channels 0-8,10-15
+    pitch_range_sum = 0   # u pitch-ranges of each track
+    pitch_range_by_track = []
+    is_a_score = True
+    if opus_or_score == None:
+        return {'bank_select':[], 'channels_by_track':[], 'channels_total':[],
+         'general_midi_mode':[], 'ntracks':0, 'nticks':0,
+         'num_notes_by_channel':dict([]),
+         'patch_changes_by_track':[], 'patch_changes_total':[],
+         'percussion':{}, 'pitches':{}, 'pitch_range_by_track':[],
+         'ticks_per_quarter':0, 'pitch_range_sum':0}
+    ticks_per_quarter = opus_or_score[0]
+    i = 1   # ignore first element, which is ticks
+    nticks = 0
+    while i < len(opus_or_score):
+        highest_pitch = 0
+        lowest_pitch = 128
+        channels_this_track = set([])
+        patch_changes_this_track = dict({})
+        for event in opus_or_score[i]:
+            if event[0] == 'note':
+                num_notes_by_channel[event[3]] = num_notes_by_channel.get(event[3],0) + 1
+                if event[3] == 9:
+                    percussion[event[4]] = percussion.get(event[4],0) + 1
+                else:
+                    pitches[event[4]]    = pitches.get(event[4],0) + 1
+                    if event[4] > highest_pitch:
+                        highest_pitch = event[4]
+                    if event[4] < lowest_pitch:
+                        lowest_pitch = event[4]
+                channels_this_track.add(event[3])
+                channels_total.add(event[3])
+                finish_time = event[1] + event[2]
+                if finish_time > nticks:
+                    nticks = finish_time
+            elif event[0] == 'note_off' or (event[0] == 'note_on' and event[4] == 0):  # 4.8
+                finish_time = event[1]
+                if finish_time > nticks:
+                    nticks = finish_time
+            elif event[0] == 'note_on':
+                is_a_score = False
+                num_notes_by_channel[event[2]] = num_notes_by_channel.get(event[2],0) + 1
+                if event[2] == 9:
+                    percussion[event[3]] = percussion.get(event[3],0) + 1
+                else:
+                    pitches[event[3]]    = pitches.get(event[3],0) + 1
+                    if event[3] > highest_pitch:
+                        highest_pitch = event[3]
+                    if event[3] < lowest_pitch:
+                        lowest_pitch = event[3]
+                channels_this_track.add(event[2])
+                channels_total.add(event[2])
+            elif event[0] == 'patch_change':
+                patch_changes_this_track[event[2]] = event[3]
+                patch_changes_total.add(event[3])
+            elif event[0] == 'control_change':
+                if event[3] == 0:  # bank select MSB
+                    bank_select_msb = event[4]
+                elif event[3] == 32:  # bank select LSB
+                    bank_select_lsb = event[4]
+                if bank_select_msb >= 0 and bank_select_lsb >= 0:
+                    bank_select.append((bank_select_msb,bank_select_lsb))
+                    bank_select_msb = -1
+                    bank_select_lsb = -1
+            elif event[0] == 'sysex_f0':
+                if _sysex2midimode.get(event[2], -1) >= 0:
+                    general_midi_mode.append(_sysex2midimode.get(event[2]))
+            if is_a_score:
+                if event[1] > nticks:
+                    nticks = event[1]
+            else:
+                nticks += event[1]
+        if lowest_pitch == 128:
+            lowest_pitch = 0
+        channels_by_track.append(channels_this_track)
+        patch_changes_by_track.append(patch_changes_this_track)
+        pitch_range_by_track.append((lowest_pitch,highest_pitch))
+        pitch_range_sum += (highest_pitch-lowest_pitch)
+        i += 1
+
+    return {'bank_select':bank_select,
+            'channels_by_track':channels_by_track,
+            'channels_total':channels_total,
+            'general_midi_mode':general_midi_mode,
+            'ntracks':len(opus_or_score)-1,
+            'nticks':nticks,
+            'num_notes_by_channel':num_notes_by_channel,
+            'patch_changes_by_track':patch_changes_by_track,
+            'patch_changes_total':patch_changes_total,
+            'percussion':percussion,
+            'pitches':pitches,
+            'pitch_range_by_track':pitch_range_by_track,
+            'pitch_range_sum':pitch_range_sum,
+            'ticks_per_quarter':ticks_per_quarter}
+
+#----------------------------- Event stuff --------------------------
+
+_sysex2midimode = {
+    "\x7E\x7F\x09\x01\xF7": 1,
+    "\x7E\x7F\x09\x02\xF7": 0,
+    "\x7E\x7F\x09\x03\xF7": 2,
+}
+
+# Some public-access tuples:
+MIDI_events = tuple('''note_off note_on key_after_touch
+control_change patch_change channel_after_touch
+pitch_wheel_change'''.split())
+
+Text_events = tuple('''text_event copyright_text_event
+track_name instrument_name lyric marker cue_point text_event_08
+text_event_09 text_event_0a text_event_0b text_event_0c
+text_event_0d text_event_0e text_event_0f'''.split())
+
+Nontext_meta_events = tuple('''end_track set_tempo
+smpte_offset time_signature key_signature sequencer_specific
+raw_meta_event sysex_f0 sysex_f7 song_position song_select
+tune_request'''.split())
+# unsupported: raw_data
+
+# Actually, 'tune_request' is is F-series event, not strictly a meta-event...
+Meta_events = Text_events + Nontext_meta_events
+All_events  = MIDI_events + Meta_events
+
+# And three dictionaries:
+Number2patch = {   # General MIDI patch numbers:
+0:'Acoustic Grand',
+1:'Bright Acoustic',
+2:'Electric Grand',
+3:'Honky-Tonk',
+4:'Electric Piano 1',
+5:'Electric Piano 2',
+6:'Harpsichord',
+7:'Clav',
+8:'Celesta',
+9:'Glockenspiel',
+10:'Music Box',
+11:'Vibraphone',
+12:'Marimba',
+13:'Xylophone',
+14:'Tubular Bells',
+15:'Dulcimer',
+16:'Drawbar Organ',
+17:'Percussive Organ',
+18:'Rock Organ',
+19:'Church Organ',
+20:'Reed Organ',
+21:'Accordion',
+22:'Harmonica',
+23:'Tango Accordion',
+24:'Acoustic Guitar(nylon)',
+25:'Acoustic Guitar(steel)',
+26:'Electric Guitar(jazz)',
+27:'Electric Guitar(clean)',
+28:'Electric Guitar(muted)',
+29:'Overdriven Guitar',
+30:'Distortion Guitar',
+31:'Guitar Harmonics',
+32:'Acoustic Bass',
+33:'Electric Bass(finger)',
+34:'Electric Bass(pick)',
+35:'Fretless Bass',
+36:'Slap Bass 1',
+37:'Slap Bass 2',
+38:'Synth Bass 1',
+39:'Synth Bass 2',
+40:'Violin',
+41:'Viola',
+42:'Cello',
+43:'Contrabass',
+44:'Tremolo Strings',
+45:'Pizzicato Strings',
+46:'Orchestral Harp',
+47:'Timpani',
+48:'String Ensemble 1',
+49:'String Ensemble 2',
+50:'SynthStrings 1',
+51:'SynthStrings 2',
+52:'Choir Aahs',
+53:'Voice Oohs',
+54:'Synth Voice',
+55:'Orchestra Hit',
+56:'Trumpet',
+57:'Trombone',
+58:'Tuba',
+59:'Muted Trumpet',
+60:'French Horn',
+61:'Brass Section',
+62:'SynthBrass 1',
+63:'SynthBrass 2',
+64:'Soprano Sax',
+65:'Alto Sax',
+66:'Tenor Sax',
+67:'Baritone Sax',
+68:'Oboe',
+69:'English Horn',
+70:'Bassoon',
+71:'Clarinet',
+72:'Piccolo',
+73:'Flute',
+74:'Recorder',
+75:'Pan Flute',
+76:'Blown Bottle',
+77:'Skakuhachi',
+78:'Whistle',
+79:'Ocarina',
+80:'Lead 1 (square)',
+81:'Lead 2 (sawtooth)',
+82:'Lead 3 (calliope)',
+83:'Lead 4 (chiff)',
+84:'Lead 5 (charang)',
+85:'Lead 6 (voice)',
+86:'Lead 7 (fifths)',
+87:'Lead 8 (bass+lead)',
+88:'Pad 1 (new age)',
+89:'Pad 2 (warm)',
+90:'Pad 3 (polysynth)',
+91:'Pad 4 (choir)',
+92:'Pad 5 (bowed)',
+93:'Pad 6 (metallic)',
+94:'Pad 7 (halo)',
+95:'Pad 8 (sweep)',
+96:'FX 1 (rain)',
+97:'FX 2 (soundtrack)',
+98:'FX 3 (crystal)',
+99:'FX 4 (atmosphere)',
+100:'FX 5 (brightness)',
+101:'FX 6 (goblins)',
+102:'FX 7 (echoes)',
+103:'FX 8 (sci-fi)',
+104:'Sitar',
+105:'Banjo',
+106:'Shamisen',
+107:'Koto',
+108:'Kalimba',
+109:'Bagpipe',
+110:'Fiddle',
+111:'Shanai',
+112:'Tinkle Bell',
+113:'Agogo',
+114:'Steel Drums',
+115:'Woodblock',
+116:'Taiko Drum',
+117:'Melodic Tom',
+118:'Synth Drum',
+119:'Reverse Cymbal',
+120:'Guitar Fret Noise',
+121:'Breath Noise',
+122:'Seashore',
+123:'Bird Tweet',
+124:'Telephone Ring',
+125:'Helicopter',
+126:'Applause',
+127:'Gunshot',
+}
+Notenum2percussion = {   # General MIDI Percussion (on Channel 9):
+35:'Acoustic Bass Drum',
+36:'Bass Drum 1',
+37:'Side Stick',
+38:'Acoustic Snare',
+39:'Hand Clap',
+40:'Electric Snare',
+41:'Low Floor Tom',
+42:'Closed Hi-Hat',
+43:'High Floor Tom',
+44:'Pedal Hi-Hat',
+45:'Low Tom',
+46:'Open Hi-Hat',
+47:'Low-Mid Tom',
+48:'Hi-Mid Tom',
+49:'Crash Cymbal 1',
+50:'High Tom',
+51:'Ride Cymbal 1',
+52:'Chinese Cymbal',
+53:'Ride Bell',
+54:'Tambourine',
+55:'Splash Cymbal',
+56:'Cowbell',
+57:'Crash Cymbal 2',
+58:'Vibraslap',
+59:'Ride Cymbal 2',
+60:'Hi Bongo',
+61:'Low Bongo',
+62:'Mute Hi Conga',
+63:'Open Hi Conga',
+64:'Low Conga',
+65:'High Timbale',
+66:'Low Timbale',
+67:'High Agogo',
+68:'Low Agogo',
+69:'Cabasa',
+70:'Maracas',
+71:'Short Whistle',
+72:'Long Whistle',
+73:'Short Guiro',
+74:'Long Guiro',
+75:'Claves',
+76:'Hi Wood Block',
+77:'Low Wood Block',
+78:'Mute Cuica',
+79:'Open Cuica',
+80:'Mute Triangle',
+81:'Open Triangle',
+}
+
+Event2channelindex = { 'note':3, 'note_off':2, 'note_on':2,
+ 'key_after_touch':2, 'control_change':2, 'patch_change':2,
+ 'channel_after_touch':2, 'pitch_wheel_change':2
+}
+
+################################################################
+# The code below this line is full of frightening things, all to
+# do with the actual encoding and decoding of binary MIDI data.
+
+def _twobytes2int(byte_a):
+    r'''decode a 16 bit quantity from two bytes,'''
+    return (byte_a[1] | (byte_a[0] << 8))
+
+def _int2twobytes(int_16bit):
+    r'''encode a 16 bit quantity into two bytes,'''
+    return bytes([(int_16bit>>8) & 0xFF, int_16bit & 0xFF])
+
+def _read_14_bit(byte_a):
+    r'''decode a 14 bit quantity from two bytes,'''
+    return (byte_a[0] | (byte_a[1] << 7))
+
+def _write_14_bit(int_14bit):
+    r'''encode a 14 bit quantity into two bytes,'''
+    return bytes([int_14bit & 0x7F, (int_14bit>>7) & 0x7F])
+
+def _ber_compressed_int(integer):
+    r'''BER compressed integer (not an ASN.1 BER, see perlpacktut for
+details).  Its bytes represent an unsigned integer in base 128,
+most significant digit first, with as few digits as possible.
+Bit eight (the high bit) is set on each byte except the last.
+'''
+    ber = bytearray(b'')
+    seven_bits = 0x7F & integer
+    ber.insert(0, seven_bits)  # XXX surely should convert to a char ?
+    integer >>= 7
+    while integer > 0:
+        seven_bits = 0x7F & integer
+        ber.insert(0, 0x80|seven_bits)  # XXX surely should convert to a char ?
+        integer >>= 7
+    return ber
+
+def _unshift_ber_int(ba):
+    r'''Given a bytearray, returns a tuple of (the ber-integer at the
+start, and the remainder of the bytearray).
+'''
+    if not len(ba):   # 6.7
+        _warn('_unshift_ber_int: no integer found')
+        return ((0, b""))
+    byte = ba.pop(0)
+    integer = 0
+    while True:
+        integer += (byte & 0x7F)
+        if not (byte & 0x80):
+            return ((integer, ba))
+        if not len(ba):
+            _warn('_unshift_ber_int: no end-of-integer found')
+            return ((0, ba))
+        byte = ba.pop(0)
+        integer <<= 7
+
+def _clean_up_warnings():  # 5.4
+    # Call this before returning from any publicly callable function
+    # whenever there's a possibility that a warning might have been printed
+    # by the function, or by any private functions it might have called.
+    global _previous_times
+    global _previous_warning
+    if _previous_times > 1:
+        # E:1176, 0: invalid syntax (<string>, line 1176) (syntax-error) ???
+        # print('  previous message repeated '+str(_previous_times)+' times', file=sys.stderr)
+        # 6.7
+        sys.stderr.write('  previous message repeated {0} times\n'.format(_previous_times))
+    elif _previous_times > 0:
+        sys.stderr.write('  previous message repeated\n')
+    _previous_times = 0
+    _previous_warning = ''
+
+def _warn(s=''):
+    global _previous_times
+    global _previous_warning
+    if s == _previous_warning:  # 5.4
+        _previous_times = _previous_times + 1
+    else:
+        _clean_up_warnings()
+        sys.stderr.write(str(s)+"\n")
+        _previous_warning = s
+
+def _some_text_event(which_kind=0x01, text=b'some_text'):
+    if str(type(text)).find("'str'") >= 0:   # 6.4 test for back-compatibility
+        data = bytes(text, encoding='ISO-8859-1')
+    else:
+        data = bytes(text)
+    return b'\xFF'+bytes((which_kind,))+_ber_compressed_int(len(data))+data
+
+def _consistentise_ticks(scores):  # 3.6
+    # used by mix_scores, merge_scores, concatenate_scores
+    if len(scores) == 1:
+         return copy.deepcopy(scores)
+    are_consistent = True
+    ticks = scores[0][0]
+    iscore = 1
+    while iscore < len(scores):
+        if scores[iscore][0] != ticks:
+            are_consistent = False
+            break
+        iscore += 1
+    if are_consistent:
+        return copy.deepcopy(scores)
+    new_scores = []
+    iscore = 0
+    while iscore < len(scores):
+        score = scores[iscore]
+        new_scores.append(opus2score(to_millisecs(score2opus(score))))
+        iscore += 1
+    return new_scores
+
+
+###########################################################################
+
+def _decode(trackdata=b'', exclude=None, include=None,
+ event_callback=None, exclusive_event_callback=None, no_eot_magic=False):
+    r'''Decodes MIDI track data into an opus-style list of events.
+The options:
+  'exclude' is a list of event types which will be ignored SHOULD BE A SET
+  'include' (and no exclude), makes exclude a list
+       of all possible events, /minus/ what include specifies
+  'event_callback' is a coderef
+  'exclusive_event_callback' is a coderef
+'''
+    trackdata = bytearray(trackdata)
+    if exclude == None:
+        exclude = []
+    if include == None:
+        include = []
+    if include and not exclude:
+        exclude = All_events
+    include = set(include)
+    exclude = set(exclude)
+
+    # Pointer = 0;  not used here; we eat through the bytearray instead.
+    event_code = -1; # used for running status
+    event_count = 0;
+    events = []
+
+    while(len(trackdata)):
+        # loop while there's anything to analyze ...
+        eot = False   # When True, the event registrar aborts this loop
+        event_count += 1
+
+        E = []
+        # E for events - we'll feed it to the event registrar at the end.
+
+        # Slice off the delta time code, and analyze it
+        [time, remainder] = _unshift_ber_int(trackdata)
+
+        # Now let's see what we can make of the command
+        first_byte = trackdata.pop(0) & 0xFF
+
+        if (first_byte < 0xF0):  # It's a MIDI event
+            if (first_byte & 0x80):
+                event_code = first_byte
+            else:
+                # It wants running status; use last event_code value
+                trackdata.insert(0, first_byte)
+                if (event_code == -1):
+                    _warn("Running status not set; Aborting track.")
+                    return []
+
+            command = event_code & 0xF0
+            channel = event_code & 0x0F
+
+            if (command == 0xF6):  #  0-byte argument
+                pass
+            elif (command == 0xC0 or command == 0xD0):  #  1-byte argument
+                parameter = trackdata.pop(0)  # could be B
+            else: # 2-byte argument could be BB or 14-bit
+                parameter = (trackdata.pop(0), trackdata.pop(0))
+
+            #################################################################
+            # MIDI events
+
+            if (command      == 0x80):
+                if 'note_off' in exclude:
+                    continue
+                E = ['note_off', time, channel, parameter[0], parameter[1]]
+            elif (command == 0x90):
+                if 'note_on' in exclude:
+                    continue
+                E = ['note_on', time, channel, parameter[0], parameter[1]]
+            elif (command == 0xA0):
+                if 'key_after_touch' in exclude:
+                    continue
+                E = ['key_after_touch',time,channel,parameter[0],parameter[1]]
+            elif (command == 0xB0):
+                if 'control_change' in exclude:
+                    continue
+                E = ['control_change',time,channel,parameter[0],parameter[1]]
+            elif (command == 0xC0):
+                if 'patch_change' in exclude:
+                    continue
+                E = ['patch_change', time, channel, parameter]
+            elif (command == 0xD0):
+                if 'channel_after_touch' in exclude:
+                    continue
+                E = ['channel_after_touch', time, channel, parameter]
+            elif (command == 0xE0):
+                if 'pitch_wheel_change' in exclude:
+                    continue
+                E = ['pitch_wheel_change', time, channel,
+                 _read_14_bit(parameter)-0x2000]
+            else:
+                _warn("Shouldn't get here; command="+hex(command))
+
+        elif (first_byte == 0xFF):  # It's a Meta-Event! ##################
+            #[command, length, remainder] =
+            #    unpack("xCwa*", substr(trackdata, $Pointer, 6));
+            #Pointer += 6 - len(remainder);
+            #    # Move past JUST the length-encoded.
+            command = trackdata.pop(0) & 0xFF
+            [length, trackdata] = _unshift_ber_int(trackdata)
+            if (command      == 0x00):
+                 if (length == 2):
+                     E = ['set_sequence_number',time,_twobytes2int(trackdata)]
+                 else:
+                     _warn('set_sequence_number: length must be 2, not '+str(length))
+                     E = ['set_sequence_number', time, 0]
+
+            elif command >= 0x01 and command <= 0x0f:   # Text events
+                # 6.2 take it in bytes; let the user get the right encoding.
+                # text_str = trackdata[0:length].decode('ascii','ignore')
+                # text_str = trackdata[0:length].decode('ISO-8859-1')
+                # 6.4 take it in bytes; let the user get the right encoding.
+                text_data = bytes(trackdata[0:length])   # 6.4
+                # Defined text events
+                if (command == 0x01):
+                     E = ['text_event', time, text_data]
+                elif (command == 0x02):
+                     E = ['copyright_text_event', time, text_data]
+                elif (command == 0x03):
+                     E = ['track_name', time, text_data]
+                elif (command == 0x04):
+                     E = ['instrument_name', time, text_data]
+                elif (command == 0x05):
+                     E = ['lyric', time, text_data]
+                elif (command == 0x06):
+                     E = ['marker', time, text_data]
+                elif (command == 0x07):
+                     E = ['cue_point', time, text_data]
+                # Reserved but apparently unassigned text events
+                elif (command == 0x08):
+                     E = ['text_event_08', time, text_data]
+                elif (command == 0x09):
+                     E = ['text_event_09', time, text_data]
+                elif (command == 0x0a):
+                     E = ['text_event_0a', time, text_data]
+                elif (command == 0x0b):
+                     E = ['text_event_0b', time, text_data]
+                elif (command == 0x0c):
+                     E = ['text_event_0c', time, text_data]
+                elif (command == 0x0d):
+                     E = ['text_event_0d', time, text_data]
+                elif (command == 0x0e):
+                     E = ['text_event_0e', time, text_data]
+                elif (command == 0x0f):
+                     E = ['text_event_0f', time, text_data]
+
+            # Now the sticky events -------------------------------------
+            elif (command == 0x2F):
+                 E = ['end_track', time]
+                     # The code for handling this, oddly, comes LATER,
+                     # in the event registrar.
+            elif (command == 0x51): # DTime, Microseconds/Crochet
+                 if length != 3:
+                     _warn('set_tempo event, but length='+str(length))
+                 E = ['set_tempo', time,
+                      struct.unpack(">I", b'\x00'+trackdata[0:3])[0]]
+            elif (command == 0x54):
+                 if length != 5:   # DTime, HR, MN, SE, FR, FF
+                     _warn('smpte_offset event, but length='+str(length))
+                 E = ['smpte_offset',time] + list(struct.unpack(">BBBBB",trackdata[0:5]))
+            elif (command == 0x58):
+                 if length != 4:   # DTime, NN, DD, CC, BB
+                     _warn('time_signature event, but length='+str(length))
+                 E = ['time_signature', time]+list(trackdata[0:4])
+            elif (command == 0x59):
+                 if length != 2:   # DTime, SF(signed), MI
+                     _warn('key_signature event, but length='+str(length))
+                 E = ['key_signature',time] + list(struct.unpack(">bB",trackdata[0:2]))
+            elif (command == 0x7F):   # 6.4
+                 E = ['sequencer_specific',time, bytes(trackdata[0:length])]
+            else:
+                 E = ['raw_meta_event', time, command,
+                   bytes(trackdata[0:length])]   # 6.0
+                 #"[uninterpretable meta-event command of length length]"
+                 # DTime, Command, Binary Data
+                 # It's uninterpretable; record it as raw_data.
+
+            # Pointer += length; #  Now move Pointer
+            trackdata = trackdata[length:]
+
+        ######################################################################
+        elif (first_byte == 0xF0 or first_byte == 0xF7):
+            # Note that sysexes in MIDI /files/ are different than sysexes
+            # in MIDI transmissions!! The vast majority of system exclusive
+            # messages will just use the F0 format. For instance, the
+            # transmitted message F0 43 12 00 07 F7 would be stored in a
+            # MIDI file as F0 05 43 12 00 07 F7. As mentioned above, it is
+            # required to include the F7 at the end so that the reader of the
+            # MIDI file knows that it has read the entire message. (But the F7
+            # is omitted if this is a non-final block in a multiblock sysex;
+            # but the F7 (if there) is counted in the message's declared
+            # length, so we don't have to think about it anyway.)
+            #command = trackdata.pop(0)
+            [length, trackdata] = _unshift_ber_int(trackdata)
+            if first_byte == 0xF0:
+                # 20091008 added ISO-8859-1 to get an 8-bit str
+                # 6.4 return bytes instead
+                E = ['sysex_f0', time, bytes(trackdata[0:length])]
+            else:
+                E = ['sysex_f7', time, bytes(trackdata[0:length])]
+            trackdata = trackdata[length:]
+
+        ######################################################################
+        # Now, the MIDI file spec says:
+        #  <track data> = <MTrk event>+
+        #  <MTrk event> = <delta-time> <event>
+        #  <event> = <MIDI event> | <sysex event> | <meta-event>
+        # I know that, on the wire, <MIDI event> can include note_on,
+        # note_off, and all the other 8x to Ex events, AND Fx events
+        # other than F0, F7, and FF -- namely, <song position msg>,
+        # <song select msg>, and <tune request>.
+        #
+        # Whether these can occur in MIDI files is not clear specified
+        # from the MIDI file spec.  So, I'm going to assume that
+        # they CAN, in practice, occur.  I don't know whether it's
+        # proper for you to actually emit these into a MIDI file.
+        
+        elif (first_byte == 0xF2):   # DTime, Beats
+            #  <song position msg> ::=     F2 <data pair>
+            E = ['song_position', time, _read_14_bit(trackdata[:2])]
+            trackdata = trackdata[2:]
+
+        elif (first_byte == 0xF3):   # <song select msg> ::= F3 <data singlet>
+            # E = ['song_select', time, struct.unpack('>B',trackdata.pop(0))[0]]
+            E = ['song_select', time, trackdata[0]]
+            trackdata = trackdata[1:]
+            # DTime, Thing (what?! song number?  whatever ...)
+
+        elif (first_byte == 0xF6):   # DTime
+            E = ['tune_request', time]
+            # What would a tune request be doing in a MIDI /file/?
+
+        #########################################################
+        # ADD MORE META-EVENTS HERE.  TODO:
+        # f1 -- MTC Quarter Frame Message. One data byte follows
+        #     the Status; it's the time code value, from 0 to 127.
+        # f8 -- MIDI clock.    no data.
+        # fa -- MIDI start.    no data.
+        # fb -- MIDI continue. no data.
+        # fc -- MIDI stop.     no data.
+        # fe -- Active sense.  no data.
+        # f4 f5 f9 fd -- unallocated
+
+            r'''
+        elif (first_byte > 0xF0) { # Some unknown kinda F-series event ####
+            # Here we only produce a one-byte piece of raw data.
+            # But the encoder for 'raw_data' accepts any length of it.
+            E = [ 'raw_data',
+                         time, substr(trackdata,Pointer,1) ]
+            # DTime and the Data (in this case, the one Event-byte)
+            ++Pointer;  # itself
+
+'''
+        elif first_byte > 0xF0:  # Some unknown F-series event
+            # Here we only produce a one-byte piece of raw data.
+            # E = ['raw_data', time, bytest(trackdata[0])]   # 6.4
+            E = ['raw_data', time, trackdata[0]]   # 6.4 6.7
+            trackdata = trackdata[1:]
+        else:  # Fallthru.
+            _warn("Aborting track.  Command-byte first_byte="+hex(first_byte))
+            break
+        # End of the big if-group
+
+
+        ######################################################################
+        #  THE EVENT REGISTRAR...
+        if E and  (E[0] == 'end_track'):
+            # This is the code for exceptional handling of the EOT event.
+            eot = True
+            if not no_eot_magic:
+                if E[1] > 0:  # a null text-event to carry the delta-time
+                    E = ['text_event', E[1], '']
+                else:
+                    E = []   # EOT with a delta-time of 0; ignore it.
+        
+        if E and not (E[0] in exclude):
+            #if ( $exclusive_event_callback ):
+            #    &{ $exclusive_event_callback }( @E );
+            #else:
+            #    &{ $event_callback }( @E ) if $event_callback;
+                events.append(E)
+        if eot:
+            break
+
+    # End of the big "Event" while-block
+
+    return events
+
+
+###########################################################################
+def _encode(events_lol, unknown_callback=None, never_add_eot=False,
+  no_eot_magic=False, no_running_status=False):
+    # encode an event structure, presumably for writing to a file
+    # Calling format:
+    #   $data_r = MIDI::Event::encode( \@event_lol, { options } );
+    # Takes a REFERENCE to an event structure (a LoL)
+    # Returns an (unblessed) REFERENCE to track data.
+
+    # If you want to use this to encode a /single/ event,
+    # you still have to do it as a reference to an event structure (a LoL)
+    # that just happens to have just one event.  I.e.,
+    #   encode( [ $event ] ) or encode( [ [ 'note_on', 100, 5, 42, 64] ] )
+    # If you're doing this, consider the never_add_eot track option, as in
+    #   print MIDI ${ encode( [ $event], { 'never_add_eot' => 1} ) };
+
+    data = [] # what I'll store the chunks of byte-data in
+
+    # This is so my end_track magic won't corrupt the original
+    events = copy.deepcopy(events_lol)
+
+    if not never_add_eot:
+        # One way or another, tack on an 'end_track'
+        if events:
+            last = events[-1]
+            if not (last[0] == 'end_track'):  # no end_track already
+                if (last[0] == 'text_event' and len(last[2]) == 0):
+                    # 0-length text event at track-end.
+                    if no_eot_magic:
+                        # Exceptional case: don't mess with track-final
+                        # 0-length text_events; just peg on an end_track
+                        events.append(['end_track', 0])
+                    else:
+                        # NORMAL CASE: replace with an end_track, leaving DTime
+                        last[0] = 'end_track'
+                else:
+                    # last event was neither 0-length text_event nor end_track
+                    events.append(['end_track', 0])
+        else:  # an eventless track!
+            events = [['end_track', 0],]
+
+    # maybe_running_status = not no_running_status # unused? 4.7
+    last_status = -1
+
+    for event_r in (events):
+        E = copy.deepcopy(event_r)
+        # otherwise the shifting'd corrupt the original
+        if not E:
+            continue
+
+        event = E.pop(0)
+        if not len(event):
+            continue
+
+        dtime = int(E.pop(0))
+        # print('event='+str(event)+' dtime='+str(dtime))
+
+        event_data = ''
+
+        if (   # MIDI events -- eligible for running status
+             event    == 'note_on'
+             or event == 'note_off'
+             or event == 'control_change'
+             or event == 'key_after_touch'
+             or event == 'patch_change'
+             or event == 'channel_after_touch'
+             or event == 'pitch_wheel_change'  ):
+
+            # This block is where we spend most of the time.  Gotta be tight.
+            if (event == 'note_off'):
+                status = 0x80 | (int(E[0]) & 0x0F)
+                parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F)
+            elif (event == 'note_on'):
+                status = 0x90 | (int(E[0]) & 0x0F)
+                parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F)
+            elif (event == 'key_after_touch'):
+                status = 0xA0 | (int(E[0]) & 0x0F)
+                parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F)
+            elif (event == 'control_change'):
+                status = 0xB0 | (int(E[0]) & 0x0F)
+                parameters = struct.pack('>BB', int(E[1])&0xFF, int(E[2])&0xFF)
+            elif (event == 'patch_change'):
+                status = 0xC0 | (int(E[0]) & 0x0F)
+                parameters = struct.pack('>B', int(E[1]) & 0xFF)
+            elif (event == 'channel_after_touch'):
+                status = 0xD0 | (int(E[0]) & 0x0F)
+                parameters = struct.pack('>B', int(E[1]) & 0xFF)
+            elif (event == 'pitch_wheel_change'):
+                status = 0xE0 | (int(E[0]) & 0x0F)
+                parameters =  _write_14_bit(int(E[1]) + 0x2000)
+            else:
+                _warn("BADASS FREAKOUT ERROR 31415!")
+
+            # And now the encoding
+            # w = BER compressed integer (not ASN.1 BER, see perlpacktut for
+            # details).  Its bytes represent an unsigned integer in base 128,
+            # most significant digit first, with as few digits as possible.
+            # Bit eight (the high bit) is set on each byte except the last.
+
+            data.append(_ber_compressed_int(dtime))
+            if (status != last_status) or no_running_status:
+                data.append(struct.pack('>B', status))
+            data.append(parameters)
+ 
+            last_status = status
+            continue
+        else:
+            # Not a MIDI event.
+            # All the code in this block could be more efficient,
+            # but this is not where the code needs to be tight.
+            # print "zaz $event\n";
+            last_status = -1
+
+            if event == 'raw_meta_event':
+                event_data = _some_text_event(int(E[0]), E[1])
+            elif (event == 'set_sequence_number'):  # 3.9
+                event_data = b'\xFF\x00\x02'+_int2twobytes(E[0])
+
+            # Text meta-events...
+            # a case for a dict, I think (pjb) ...
+            elif (event == 'text_event'):
+                event_data = _some_text_event(0x01, E[0])
+            elif (event == 'copyright_text_event'):
+                event_data = _some_text_event(0x02, E[0])
+            elif (event == 'track_name'):
+                event_data = _some_text_event(0x03, E[0])
+            elif (event == 'instrument_name'):
+                event_data = _some_text_event(0x04, E[0])
+            elif (event == 'lyric'):
+                event_data = _some_text_event(0x05, E[0])
+            elif (event == 'marker'):
+                event_data = _some_text_event(0x06, E[0])
+            elif (event == 'cue_point'):
+                event_data = _some_text_event(0x07, E[0])
+            elif (event == 'text_event_08'):
+                event_data = _some_text_event(0x08, E[0])
+            elif (event == 'text_event_09'):
+                event_data = _some_text_event(0x09, E[0])
+            elif (event == 'text_event_0a'):
+                event_data = _some_text_event(0x0A, E[0])
+            elif (event == 'text_event_0b'):
+                event_data = _some_text_event(0x0B, E[0])
+            elif (event == 'text_event_0c'):
+                event_data = _some_text_event(0x0C, E[0])
+            elif (event == 'text_event_0d'):
+                event_data = _some_text_event(0x0D, E[0])
+            elif (event == 'text_event_0e'):
+                event_data = _some_text_event(0x0E, E[0])
+            elif (event == 'text_event_0f'):
+                event_data = _some_text_event(0x0F, E[0])
+            # End of text meta-events
+
+            elif (event == 'end_track'):
+                event_data = b"\xFF\x2F\x00"
+
+            elif (event == 'set_tempo'):
+                #event_data = struct.pack(">BBwa*", 0xFF, 0x51, 3,
+                #              substr( struct.pack('>I', E[0]), 1, 3))
+                event_data = b'\xFF\x51\x03'+struct.pack('>I',E[0])[1:]
+            elif (event == 'smpte_offset'):
+                # event_data = struct.pack(">BBwBBBBB", 0xFF, 0x54, 5, E[0:5] )
+                event_data = struct.pack(">BBBbBBBB", 0xFF,0x54,0x05,E[0],E[1],E[2],E[3],E[4])
+            elif (event == 'time_signature'):
+                # event_data = struct.pack(">BBwBBBB",  0xFF, 0x58, 4, E[0:4] )
+                event_data = struct.pack(">BBBbBBB", 0xFF, 0x58, 0x04, E[0],E[1],E[2],E[3])
+            elif (event == 'key_signature'):
+                event_data = struct.pack(">BBBbB", 0xFF, 0x59, 0x02, E[0],E[1])
+            elif (event == 'sequencer_specific'):
+                # event_data = struct.pack(">BBwa*", 0xFF,0x7F, len(E[0]), E[0])
+                event_data = _some_text_event(0x7F, E[0])
+            # End of Meta-events
+
+            # Other Things...
+            elif (event == 'sysex_f0'):
+                 #event_data = struct.pack(">Bwa*", 0xF0, len(E[0]), E[0])
+                 #B=bitstring w=BER-compressed-integer a=null-padded-ascii-str
+                 event_data = bytearray(b'\xF0')+_ber_compressed_int(len(E[0]))+bytearray(E[0])
+            elif (event == 'sysex_f7'):
+                 #event_data = struct.pack(">Bwa*", 0xF7, len(E[0]), E[0])
+                 event_data = bytearray(b'\xF7')+_ber_compressed_int(len(E[0]))+bytearray(E[0])
+
+            elif (event == 'song_position'):
+                 event_data = b"\xF2" + _write_14_bit( E[0] )
+            elif (event == 'song_select'):
+                 event_data = struct.pack('>BB', 0xF3, E[0] )
+            elif (event == 'tune_request'):
+                 event_data = b"\xF6"
+            elif (event == 'raw_data'):
+                _warn("_encode: raw_data event not supported")
+                # event_data = E[0]
+                continue
+            # End of Other Stuff
+
+            else:
+                # The Big Fallthru
+                if unknown_callback:
+                    # push(@data, &{ $unknown_callback }( @$event_r ))
+                    pass
+                else:
+                    _warn("Unknown event: "+str(event))
+                    # To surpress complaint here, just set
+                    #  'unknown_callback' => sub { return () }
+                continue
+
+            #print "Event $event encoded part 2\n"
+            if str(type(event_data)).find("'str'") >= 0:
+                event_data = bytearray(event_data.encode('Latin1', 'ignore'))
+            if len(event_data): # how could $event_data be empty
+                # data.append(struct.pack('>wa*', dtime, event_data))
+                # print(' event_data='+str(event_data))
+                data.append(_ber_compressed_int(dtime)+event_data)
+
+    return b''.join(data)
+

Monster_MIDI_Dataset_GPU_Search_and_Filter.ipynb

@@ -0,0 +1,1030 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "gradient": {
+          "editing": false,
+          "id": "ac5a4cf0-d9d2-47b5-9633-b53f8d99a4d2",
+          "kernelId": ""
+        },
+        "id": "SiTIpPjArIyr"
+      },
+      "source": [
+        "# Monster MIDI Dataset GPU Search and Filter (ver. 1.0)\n",
+        "\n",
+        "***\n",
+        "\n",
+        "Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools\n",
+        "\n",
+        "***\n",
+        "\n",
+        "#### Project Los Angeles\n",
+        "\n",
+        "#### Tegridy Code 2024\n",
+        "\n",
+        "***"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (GPU CHECK)"
+      ],
+      "metadata": {
+        "id": "0rMwKVc9FFRw"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title NVIDIA GPU Check\n",
+        "!nvidia-smi"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "dVSaUaEZFIip"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (SETUP ENVIRONMENT)"
+      ],
+      "metadata": {
+        "id": "YRTt3Hx0FQeu"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "gradient": {
+          "editing": false,
+          "id": "a1a45a91-d909-4fd4-b67a-5e16b971d179",
+          "kernelId": ""
+        },
+        "id": "fX12Yquyuihc"
+      },
+      "outputs": [],
+      "source": [
+        "#@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"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "gradient": {
+          "editing": false,
+          "id": "b8207b76-9514-4c07-95db-95a4742e52c5",
+          "kernelId": ""
+        },
+        "id": "z7n9vnKmug1J",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Import all needed modules\n",
+        "\n",
+        "print('Loading core modules... Please wait...')\n",
+        "\n",
+        "import os\n",
+        "import copy\n",
+        "from collections import Counter\n",
+        "import random\n",
+        "import pickle\n",
+        "from tqdm import tqdm\n",
+        "import pprint\n",
+        "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/Monster-MIDI-Dataset')\n",
+        "\n",
+        "import TMIDIX\n",
+        "\n",
+        "os.chdir('/content/')\n",
+        "\n",
+        "print('Creating IO dirs... Please wait...')\n",
+        "\n",
+        "if not os.path.exists('/content/Master-MIDI-Dataset'):\n",
+        "    os.makedirs('/content/Master-MIDI-Dataset')\n",
+        "\n",
+        "if not os.path.exists('/content/Output-MIDI-Dataset'):\n",
+        "    os.makedirs('/content/Output-MIDI-Dataset')\n",
+        "\n",
+        "print('Done!')\n",
+        "print('Enjoy! :)')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "gradient": {
+          "editing": false,
+          "id": "20b8698a-0b4e-4fdb-ae49-24d063782e77",
+          "kernelId": ""
+        },
+        "id": "ObPxlEutsQBj"
+      },
+      "source": [
+        "# (DOWNLOAD AND UNZIP MAIN MIDI DATASET)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Download Monster MIDI Dataset\n",
+        "print('=' * 70)\n",
+        "print('Downloading Monster MIDI Dataset...Please wait...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "hf_hub_download(repo_id='projectlosangeles/Monster-MIDI-Dataset',\n",
+        "                filename='Monster-MIDI-Dataset-Ver-1-0-CC-BY-NC-SA.zip',\n",
+        "                repo_type=\"dataset\",\n",
+        "                local_dir='/content/Main-MIDI-Dataset',\n",
+        "                local_dir_use_symlinks=False)\n",
+        "print('=' * 70)\n",
+        "print('Done! Enjoy! :)')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "7aItlhq9cRxZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Unzip Monster MIDI Dataset\n",
+        "%cd /content/Main-MIDI-Dataset/\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Unzipping Monster MIDI Dataset...Please wait...')\n",
+        "!unzip 'Monster-MIDI-Dataset-Ver-1-0-CC-BY-NC-SA.zip'\n",
+        "print('=' * 70)\n",
+        "\n",
+        "print('Done! Enjoy! :)')\n",
+        "print('=' * 70)\n",
+        "%cd /content/"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "zMF4vdMNDYYg"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (CREATE MIDI DATASET FILES LIST)"
+      ],
+      "metadata": {
+        "id": "GE0hPlAEjCrs"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Create Monster MIDI Dataset files list\n",
+        "print('=' * 70)\n",
+        "print('Creating dataset files list...')\n",
+        "dataset_addr = \"/content/Main-MIDI-Dataset/MIDIs\"\n",
+        "\n",
+        "# os.chdir(dataset_addr)\n",
+        "filez = list()\n",
+        "for (dirpath, dirnames, filenames) in os.walk(dataset_addr):\n",
+        "    filez += [os.path.join(dirpath, file) for file in filenames]\n",
+        "\n",
+        "if filez == []:\n",
+        "    print('Could not find any MIDI files. Please check Dataset dir...')\n",
+        "    print('=' * 70)\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Randomizing file list...')\n",
+        "random.shuffle(filez)\n",
+        "print('=' * 70)\n",
+        "\n",
+        "LAMD_files_list = []\n",
+        "\n",
+        "for f in tqdm(filez):\n",
+        "  LAMD_files_list.append([f.split('/')[-1].split('.mid')[0], f])\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "btrUDk8MDfdw"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (SIGNATURES SEARCH)"
+      ],
+      "metadata": {
+        "id": "iaeqXuIHI0_T"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Load Monster MIDI Dataset Signatures Data\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Loading Monster MIDI Dataset Signatures Data...')\n",
+        "sigs_data = pickle.load(open('/content/Main-MIDI-Dataset/SIGNATURES_DATA/MONSTER_SIGNATURES_DATA.pickle', 'rb'))\n",
+        "print('=' * 70)\n",
+        "\n",
+        "print('Prepping signatures...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "random.shuffle(sigs_data)\n",
+        "\n",
+        "signatures_file_names = []\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",
+        "  for ss in s[1]:\n",
+        "    sigs_matrixes[idx][ss[0]] = ss[1]\n",
+        "\n",
+        "  idx += 1\n",
+        "\n",
+        "print('=' * 70)\n",
+        "print('Loading signatures...')\n",
+        "print('=' * 70)\n",
+        "\n",
+        "signatures_data = cp.array(sigs_matrixes)\n",
+        "\n",
+        "print('Done!')\n",
+        "print('=' * 70)"
+      ],
+      "metadata": {
+        "id": "Mv-pjxbrIqi2",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Monster 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",
+        "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",
+        "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('Monster 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",
+        "    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",
+        "          drums_offset = len(TMIDIX.ALL_CHORDS) + 128\n",
+        "\n",
+        "          src_sigs = []\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",
+        "            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",
+        "                  tones_chord = sorted(set([p % 12 for p in pitches]))\n",
+        "                  checked_tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)\n",
+        "\n",
+        "                  sig_token = TMIDIX.ALL_CHORDS.index(checked_tones_chord) + 128\n",
+        "\n",
+        "                elif len(pitches) == 1:\n",
+        "                  sig_token = pitches[0]\n",
+        "\n",
+        "                sig.append(sig_token)\n",
+        "\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",
+        "            fsig = [list(v) for v in sig_p.items()]\n",
+        "\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]\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",
+        "          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_sig in tqdm(src_signatures):\n",
+        "\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",
+        "            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",
+        "            if search_matching_type == 'Ratios':\n",
+        "\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",
+        "              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",
+        "\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:', signatures_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 = signatures_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": "M0JWCPzBGNvh"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# (KILO-CHORDS SEARCH)"
+      ],
+      "metadata": {
+        "id": "ekjgrYRaiFE0"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Load Monster 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 Monster MIDI Dataset Kilo-Chords Data...')\n",
+        "kilo_chords = pickle.load(open('/content/Main-MIDI-Dataset/KILO_CHORDS_DATA/MONSTER_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 Monster 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('Monster 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": [
+        "# (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('Monster_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 Monster_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/Monster_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": {
+        "id": "YzCMd94Tu_gz"
+      },
+      "source": [
+        "# Congrats! You did it! :)"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "private_outputs": true,
+      "provenance": [],
+      "gpuType": "T4",
+      "machine_shape": "hm"
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.7"
+    },
+    "accelerator": "GPU"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

fluidsynth-master.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d1af8f1d50572e1e161ab1af5f511c22e7f916df8633756ef34fa3abc14a4db
+size 1958466

monster_midi_dataset_gpu_search_and_filter.py

@@ -0,0 +1,806 @@
+# -*- coding: utf-8 -*-
+"""Monster_MIDI_Dataset_GPU_Search_and_Filter.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1eNurM1t0Y1lTEl8sshfPqVEgYaR-ZgWU
+
+# Monster MIDI Dataset GPU Search and Filter (ver. 1.0)
+
+***
+
+Powered by tegridy-tools: https://github.com/asigalov61/tegridy-tools
+
+***
+
+#### Project Los Angeles
+
+#### Tegridy Code 2024
+
+***
+
+# (GPU CHECK)
+"""
+
+# @title NVIDIA GPU Check
+!nvidia-smi
+
+"""# (SETUP ENVIRONMENT)"""
+
+#@title Install all dependencies (run only once per session)
+
+!git clone --depth 1 https://github.com/asigalov61/Monster-MIDI-Dataset
+!pip install huggingface_hub
+
+#@title Import all needed modules
+
+print('Loading core modules... Please wait...')
+
+import os
+import copy
+from collections import Counter
+import random
+import pickle
+from tqdm import tqdm
+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/Monster-MIDI-Dataset')
+
+import TMIDIX
+
+os.chdir('/content/')
+
+print('Creating IO dirs... Please wait...')
+
+if not os.path.exists('/content/Master-MIDI-Dataset'):
+    os.makedirs('/content/Master-MIDI-Dataset')
+
+if not os.path.exists('/content/Output-MIDI-Dataset'):
+    os.makedirs('/content/Output-MIDI-Dataset')
+
+print('Done!')
+print('Enjoy! :)')
+
+"""# (DOWNLOAD AND UNZIP MAIN MIDI DATASET)"""
+
+#@title Download Monster MIDI Dataset
+print('=' * 70)
+print('Downloading Monster MIDI Dataset...Please wait...')
+print('=' * 70)
+
+hf_hub_download(repo_id='projectlosangeles/Monster-MIDI-Dataset',
+                filename='Monster-MIDI-Dataset-Ver-1-0-CC-BY-NC-SA.zip',
+                repo_type="dataset",
+                local_dir='/content/Main-MIDI-Dataset',
+                local_dir_use_symlinks=False)
+print('=' * 70)
+print('Done! Enjoy! :)')
+print('=' * 70)
+
+# Commented out IPython magic to ensure Python compatibility.
+#@title Unzip Monster MIDI Dataset
+# %cd /content/Main-MIDI-Dataset/
+
+print('=' * 70)
+print('Unzipping Monster MIDI Dataset...Please wait...')
+!unzip 'Monster-MIDI-Dataset-Ver-1-0-CC-BY-NC-SA.zip'
+print('=' * 70)
+
+print('Done! Enjoy! :)')
+print('=' * 70)
+# %cd /content/
+
+"""# (CREATE MIDI DATASET FILES LIST)"""
+
+#@title Create Monster MIDI Dataset files list
+print('=' * 70)
+print('Creating dataset files list...')
+dataset_addr = "/content/Main-MIDI-Dataset/MIDIs"
+
+# os.chdir(dataset_addr)
+filez = list()
+for (dirpath, dirnames, filenames) in os.walk(dataset_addr):
+    filez += [os.path.join(dirpath, file) for file in filenames]
+
+if filez == []:
+    print('Could not find any MIDI files. Please check Dataset dir...')
+    print('=' * 70)
+
+print('=' * 70)
+print('Randomizing file list...')
+random.shuffle(filez)
+print('=' * 70)
+
+LAMD_files_list = []
+
+for f in tqdm(filez):
+  LAMD_files_list.append([f.split('/')[-1].split('.mid')[0], f])
+print('Done!')
+print('=' * 70)
+
+"""# (SIGNATURES SEARCH)"""
+
+# @title Load Monster MIDI Dataset Signatures Data
+
+print('=' * 70)
+print('Loading Monster MIDI Dataset Signatures Data...')
+sigs_data = pickle.load(open('/content/Main-MIDI-Dataset/SIGNATURES_DATA/MONSTER_SIGNATURES_DATA.pickle', 'rb'))
+print('=' * 70)
+
+print('Prepping signatures...')
+print('=' * 70)
+
+random.shuffle(sigs_data)
+
+signatures_file_names = []
+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])
+
+  for ss in s[1]:
+    sigs_matrixes[idx][ss[0]] = ss[1]
+
+  idx += 1
+
+print('=' * 70)
+print('Loading signatures...')
+print('=' * 70)
+
+signatures_data = cp.array(sigs_matrixes)
+
+print('Done!')
+print('=' * 70)
+
+#@title Monster 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}
+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}
+epsilon = 0.5 # @param {type:"slider", min:0.001, max:1, step:0.001}
+match_drums = False # @param {type:"boolean"}
+
+print('=' * 70)
+print('Monster 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)
+
+          drums_offset = len(TMIDIX.ALL_CHORDS) + 128
+
+          src_sigs = []
+
+          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])
+
+            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:
+                  tones_chord = sorted(set([p % 12 for p in pitches]))
+                  checked_tones_chord = TMIDIX.check_and_fix_tones_chord(tones_chord)
+
+                  sig_token = TMIDIX.ALL_CHORDS.index(checked_tones_chord) + 128
+
+                elif len(pitches) == 1:
+                  sig_token = pitches[0]
+
+                sig.append(sig_token)
+
+              if drums:
+                dsig.extend(drums)
+
+            sig_p = dict.fromkeys(sig+dsig, 0)
+            for item in sig+dsig:
+              sig_p[item] += 1
+
+            fsig = [list(v) for v in sig_p.items()]
+
+            src_sig_mat = [0] * (len(TMIDIX.ALL_CHORDS)+256)
+
+            for s in fsig:
+
+              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...')
+          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_sig in tqdm(src_signatures):
+
+            if not match_drums:
+              target_sig = cp.where(target_sig < drums_offset, target_sig, epsilon)
+
+            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))
+
+            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))
+
+            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)
+
+              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]
+
+            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:', signatures_file_names[filtered_results[0][1]])
+          print('-' * 70)
+          print('Copying max ratios MIDIs...')
+
+          for fr in filtered_results:
+
+            max_ratio_index = fr[1]
+
+            ffn = signatures_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)
+
+"""# (KILO-CHORDS SEARCH)"""
+
+#@title Load Monster MIDI Dataset Kilo-Chords Data
+search_matching_type = "Full-Kilo-Chords" # @param ["Full-Kilo-Chords", "Unique-Kilo-Chords"]
+
+print('=' * 70)
+print('Loading Monster MIDI Dataset Kilo-Chords Data...')
+kilo_chords = pickle.load(open('/content/Main-MIDI-Dataset/KILO_CHORDS_DATA/MONSTER_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 Monster 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('Monster 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.
+#@title Zip and download all search results
+
+print('=' * 70)
+
+try:
+    os.remove('Monster_MIDI_Dataset_Search_Results.zip')
+except OSError:
+    pass
+
+print('Zipping... Please wait...')
+print('=' * 70)
+
+# %cd /content/Output-MIDI-Dataset/
+!zip -r Monster_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/Monster_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! :)"""