Update app.py

app.py

@@ -47,6 +47,7 @@ SOUDFONT_PATH = 'SGM-v2.01-YamahaGrand-Guit-Bass-v2.7.sf2'
 #==================================================================================
 
 print('Loading MIDI Loops Small Dataset...')
+print('-' * 70)
 
 midi_loops_dataset = TMIDIX.Tegridy_Any_Pickle_File_Reader('MIDI-Loops-Dataset-Small-CC-BY-NC-SA.pickle')
 
@@ -68,6 +69,7 @@ def find_matches(src_array, trg_array):
 #==================================================================================
 
 def find_closest_tuple(tuples_list, src_tuple):
+    
     def euclidean_distance(t1, t2):
         return sum((a - b) ** 2 for a, b in zip(t1, t2)) ** 0.5
 
@@ -119,10 +121,6 @@ def Mix_Loops(input_midi,
                model_temperature
               ):
 
-    #===============================================================================
-
-
-
     #===============================================================================
     
     print('=' * 70)
@@ -143,22 +141,199 @@ def Mix_Loops(input_midi,
    
     print('=' * 70)
 
-    #==================================================================
-
+    #===============================================================================
 
+    chunk_len = 5
+    chunk_chords_set = 13
+    
+    all_chords_chunks = []
+    
+    midi_loops = [l for l in midi_loops_dataset if len(set(l[1][0])) >= chunk_chords_set]
+    
+    for loop in tqdm.tqdm(midi_loops):
+        fn = loop[0]
+        chords = loop[1]
+        score = loop[2]
+    
+        for c in chords:
+            all_chords_chunks.append(c[:chunk_len])
+    
+    all_chords_chunks = np.array(all_chords_chunks)
 
     #==================================================================
     
     print('=' * 70)
     print('Generating...')
 
+    max_num_loops = 4
+    max_tries = 100
+    loops_mult = 1
+    
+    song_loops_counter = 0
+    
+    stries = 0
+    
+    while song_loops_counter < max_num_loops:
+    
+        if stries % 25 == 0:
+            print('Attempt', stries)
+        stries += 1
+    
+        midxs = []
+        sidxs = [-1]
+        
+        while not midxs:
+        
+            song_names = []
+            song_chords = []
+            song_scores = []
+            song_idxs = []
+            sidx = -1
+    
+            while sidx in sidxs:
+                sidx = random.randint(0, len(midi_loops)-1)
+                
+            song_idxs.append(sidx)
+            sidxs.append(sidx)
+            
+            song_names.append(midi_loops[sidx][0])
+            song_chords.append(midi_loops[sidx][1][0][-chunk_len:]) #tv
+            song_scores.append(midi_loops[sidx][2])
+            
+            song_midxs = [(song_idxs[-1]*loops_mult)+3]
+        
+            midxs = [song_midxs[-1]]
+        
+            midxs = find_matches(np.array(song_chords[-1]), all_chords_chunks)
+            midxs = [midx for midx in midxs if midx != song_midxs[-1]]
+        
+        song_loops_counter = 1
+        rtries = 0
+        end = False
+        
+        while song_loops_counter < max_num_loops and not end:
+        
+            midxs = [song_midxs[-1]]
+            midxs = []
+            rmidxs = [-1]
+        
+            midxs = find_matches(np.array(song_chords[-1]), all_chords_chunks)
+            midxs = [midx for midx in midxs if midx != song_midxs[-1]]
+        
+            if midxs:
+                midx = find_best_midx(midxs, song_midxs[-1])
+        
+            else:
+                midx = rmidxs[-1]
+        
+            if midx not in rmidxs and midx not in song_midxs:    
+            
+                song_midxs.append(midx)
+            
+            
+                sidx = int(midx // loops_mult)
+                song_idxs.append(sidx)
+            
+                song = midi_loops[sidx]    
+                
+                song_names.append(song[0])
+                song_chords.append(song[1][0][-chunk_len:]) # tv
+                song_scores.append(song[2])    
+        
+                song_loops_counter += 1
+                #print(song_loops_counter)
+        
+            else:
+                if len(rmidxs) > 1 and rtries < max_tries:
+                    song_idxs.pop()
+                    song_midxs.pop()
+                    song_names.pop()
+                    song_chords.pop()
+                    song_scores.pop()
+                    #print('revert')
+                    song_loops_counter -= 1
+                    rtries += 1
+                    rmidxs.append(midx)
+        
+                else:
+                    #print('end')
+                    end = True
+                    break
+    
+            if end:
+                break
 
-   
     print('=' * 70)
     print('Done!')
     print('=' * 70)
     
     #===============================================================================
+
+    final_song = []
+    last_max_dur = 0
+    last_dtime = 0
+    mode_dtime = 0
+    mode_dur = 0
+    
+    for i, src_score in enumerate(song_scores):
+    
+        final_song.append(['text_event', 0, song_names[i]])
+    
+        score = copy.deepcopy(src_score)
+    
+        for j in range(2):
+    
+            if j == 1:
+    
+                if i > 0:
+                    last_chord = score[[e for e in range(len(score)) if score[e][0] > 0][-1]:]
+                    last_dtime = last_chord[0][0]
+                    last_max_dur = max([e[1] for e in last_chord])
+                
+                    dtimes = [e[0] for e in score if e[0] != 0]
+                    durs = [e[1] for e in score]
+                    
+                    mode_dtime= statistics.mode(dtimes)
+                    mode_dur = statistics.mode(durs)
+                        
+                score[0][0] = max(mode_dtime, mode_dur)
+            
+                rscore = list(reversed(score))
+            
+                ccount = 0
+                for r in range(len(rscore)):
+                    if rscore[r][0] > 0:
+                        ccount += 1
+                
+                    if ccount == chunk_len:
+                        break
+                        
+                trimmed_score = score[:-(r+1)]
+    
+                extended_score = [['note'] + e for e in trimmed_score]
+    
+                final_song.extend(extended_score)
+                
+    
+            else:
+                if i > 0:
+                    last_chord = score[[e for e in range(len(score)) if score[e][0] > 0][-1]:]
+                    last_dtime = last_chord[0][0]
+                    last_max_dur = max([e[1] for e in last_chord])
+                    
+                    dtimes = [e[0] for e in score if e[0] != 0]
+                    durs = [e[1] for e in score]
+                    
+                    mode_dtime= statistics.mode(dtimes)
+                    mode_dur = statistics.mode(durs)
+                        
+                score[0][0] = max(mode_dtime, mode_dur)
+        
+                extended_score = [['note'] + e for e in score]
+    
+                final_song.extend(extended_score)
+
+    #===============================================================================
     
     print('Rendering results...')
     
@@ -172,7 +347,7 @@ def Mix_Loops(input_midi,
 
     fn1 = "MIDI-Loops-Mixer-Composition"
     
-    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,
+    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
                                                               output_signature = 'MIDI Loops Mixer',
                                                               output_file_name = fn1,
                                                               track_name='Project Los Angeles',
@@ -194,6 +369,7 @@ def Mix_Loops(input_midi,
 
     #========================================================
 
+    output_midi_summary = ''
     output_midi = str(new_fn)
     output_audio = (16000, audio)
     
@@ -204,6 +380,7 @@ def Mix_Loops(input_midi,
                                      )
 
     print('Output MIDI file name:', output_midi)
+    print('Output MIDI summary:', output_midi_summary)
     print('=' * 70) 
     
     #========================================================
@@ -213,7 +390,7 @@ def Mix_Loops(input_midi,
     print('-' * 70)
     print('Req execution time:', (reqtime.time() - start_time), 'sec')
 
-    return output_audio, output_plot, output_midi
+    return output_midi_summary, output_audio, output_plot, output_midi
     
 #==================================================================================
 
@@ -256,18 +433,22 @@ with gr.Blocks() as demo:
     generate_btn = gr.Button("Generate", variant="primary")
 
     gr.Markdown("## Generation results")
-    
+
+    output_midi_summary = gr.Textbox(label="MIDI summary")
     output_audio = gr.Audio(label="MIDI audio", format="wav", elem_id="midi_audio")
     output_plot = gr.Plot(label="MIDI score plot")
     output_midi = gr.File(label="MIDI file", file_types=[".mid"])
 
     generate_btn.click(Mix_Loops, 
-                       [input_midi, 
+                       [
+                        input_midi, 
                         generation_type,
                         melody_patch,
                         model_temperature
                        ], 
-                       [output_audio,
+                       [
+                        output_midi_summary,
+                        output_audio,
                         output_plot,
                         output_midi                          
                        ]