Update app.py

app.py

@@ -6,7 +6,7 @@ import time as reqtime
 import datetime
 from pytz import timezone
 
-import copy
+import re
 
 import gradio as gr
 
@@ -18,9 +18,26 @@ import TMIDIX
 
 import matplotlib.pyplot as plt
     
-# =================================================================================================
+#=====================================================================================
 
-# =================================================================================================
+def parsons_code_to_tokens(parsons_code_str):
+
+  tokens = [388]
+
+  for chr in parsons_code_str[1:]:
+
+    if chr == 'D':
+      tokens.extend([385])
+
+    elif chr == 'R':
+      tokens.extend([386])
+
+    elif chr == 'U':
+      tokens.extend([387])
+
+  return tokens
+
+#====================================================================================
 
 def Generate_Melody(input_parsons_code, 
                    input_first_note_duration, 
@@ -31,243 +48,133 @@ def Generate_Melody(input_parsons_code,
     print('Req start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
     start_time = reqtime.time()
 
-    print('-' * 70)
+    print('=' * 70)
     print('Requested settings:')
     print('-' * 70)
     print('Parsons code:', input_parsons_code)
     print('First note duration:', input_first_note_duration)
     print('First note MIDI pitch:', iinput_first_note_MIDI_pitch)
-    print('-' * 70)
+    print('=' * 70)
 
     #===============================================================================
-    raw_score = TMIDIX.midi2single_track_ms_score(input_midi.name)
+
+    print('Instantiating Parsons Code Melody Transformer model...')
+
+    SEQ_LEN = 322
+    PAD_IDX = 392
     
-    #===============================================================================
-    # Enhanced score notes
+    model = TransformerWrapper(
+        num_tokens = PAD_IDX+1,
+        max_seq_len = SEQ_LEN,
+        attn_layers = Decoder(dim = 1024,
+                              depth = 4,
+                              heads = 8,
+                              rotary_pos_emb = True,
+                              attn_flash = True
+                             )
+        )
     
-    raw_escore = TMIDIX.advanced_score_processor(raw_score, return_enhanced_score_notes=True)[0]
+    model = AutoregressiveWrapper(model, ignore_index = PAD_IDX, pad_value=PAD_IDX)
     
-    if len(raw_escore) > 0:
+    print('=' * 70)
+    print('Loading model checkpoint...')
     
-        #===============================================================================
-        # Augmented enhanced score notes
-        
-        src_escore = TMIDIX.recalculate_score_timings(TMIDIX.augment_enhanced_score_notes([e for e in raw_escore if e[6] < 80]))
-
-        src_cscore = TMIDIX.chordify_score([1000, src_escore])
-        
-        src_melody = [c[0] for c in src_cscore][:256]
-
-        if input_transform == 'Flip Melody':
-            src_melody = TMIDIX.flip_enhanced_score_notes(src_melody)
-            
-        elif input_transform == 'Reverse Melody':
-            src_melody = TMIDIX.reverse_enhanced_score_notes(src_melody)
-
-        mel_avg_time = TMIDIX.escore_notes_averages(src_melody)[0]
-        
-        src_melody_pitches = [p[4] for p in src_melody]
-        
-        src_harm_tones_chords = TMIDIX.harmonize_enhanced_melody_score_notes(src_melody)
-        
-        #===============================================================================
-        
-        matched_songs = [a for a in all_songs if a[2] == max(32, len(src_melody))]
-        
-        random.shuffle(matched_songs)
-
-        max_match_ratio = -1
-        max_match_ratios_count = len(matched_songs)
-
-        if input_find_best_match:
-            new_song, max_match_ratio, max_match_ratios_count = find_similar_song(matched_songs, src_melody)
-        else:
-            new_song = random.choice(matched_songs)
-        
-        print('Selected Monster Mono Melodies MIDI:', new_song[0])
-        print('Selected melody match ratio:', max_match_ratio)
-        print('Selected melody instrument:', TMIDIX.Number2patch[new_song[1]], '(', new_song[1], ')')
-        print('Melody notes count:', new_song[2])
-        print('Matched melodies pool count', max_match_ratios_count)
-        
-        MIDI_Summary = 'Selected Monster Mono Melodies MIDI: ' + str(new_song[0]) + '\n'
-        MIDI_Summary += 'Selected melody match ratio: ' + str(max_match_ratio) + '\n'
-        MIDI_Summary += 'Selected melody instrument: ' + str(TMIDIX.Number2patch[new_song[1]]) + ' (' + str(new_song[1]) + ')' + '\n'
-        MIDI_Summary += 'Melody notes count: ' + str(new_song[2]) + '\n'
-        MIDI_Summary += 'Matched melodies pool count: ' + str(max_match_ratios_count)
+    model_path = 'Parsons_Code_Melody_Transformer_Trained_Model_13786_steps_0.3058_loss_0.8819_acc.pth'
+    
+    model.load_state_dict(torch.load(model_path, map_location='cpu'))
 
-        fn1 += '_' + str(new_song[0]) + '_' + str(TMIDIX.Number2patch[new_song[1]]) + '_' + str(new_song[1]) + '_' + str(new_song[2])
-        
-        trg_patch = new_song[1]
-        
-        trg_song = copy.deepcopy(new_song[3])
-        
-        mix_avg_time = TMIDIX.escore_notes_averages(trg_song)[0]
-        mix_mel_avg_time = TMIDIX.escore_notes_averages([e for e in trg_song if e[6] == trg_patch])[0]
-        
-        TMIDIX.adjust_score_velocities(trg_song, 95)
-        
-        cscore = TMIDIX.chordify_score([1000, trg_song])
-        
-        print('=' * 70)
-        print('Done loading source and target MIDIs...!')
-        print('=' * 70)
-        print('Mixing...')
+    model.cpu()
+    model.eval()
 
-        mixed_song = []
-        
-        midx = 0
-        next_note_dtime = 255
-        
-        for i, c in enumerate(cscore):
-            cho = copy.deepcopy(c)
-            
-            patches = sorted(set([e[6] for e in c]))
-            
-            if trg_patch in patches:
-
-                if input_adjust_melody_notes_durations:
-                    if midx < len(src_melody)-1:
-                        next_note_dtime = src_melody[midx+1][1] - src_melody[midx][1]
-                    else:
-                        next_note_dtime = 255
-                    
-                mixed_song.extend(mix_chord(c, src_harm_tones_chords[midx], trg_patch, src_melody_pitches[midx], next_note_dtime))
-                
-                midx += 1
-            
-            else:
-                if input_adjust_accompaniment_notes_durations:
-                    if i < len(cscore)-1:
-                        next_note_dtime = cscore[i+1][0][1] - cscore[i][0][1]
-                    else:
-                        next_note_dtime = 255
-                
-                mixed_song.extend(mix_chord(cho, src_harm_tones_chords[midx], trg_patch, src_melody_pitches[midx], next_note_dtime))
+    dtype = torch.bfloat16
+    
+    ctx = torch.amp.autocast(device_type='cpu', dtype=dtype)
 
-            if midx == len(src_melody):
-                break      
+    print('Done!')
+    print('=' * 70)
 
-        print('=' * 70)
-        print('Done!')
-        print('=' * 70)
+    #===============================================================================
 
-        #===============================================================================
+    print('Prepping Parsons code string...')
 
-        if input_output_as_solo_piano:
-            
-            csong = TMIDIX.chordify_score([1000, mixed_song])
+    td_str = '*DUDUA'
+    
+    td_str = re.sub('[^*DRU]', '', td_str)
+    
+    print(len(td_str))
+    print('=' * 70)
+    
+    if '*' in td_str and len(td_str) > 1:
+      code_mult = (64 // len(td_str[1:]))+1
+      mult_code = ('*' + (td_str[1:] * code_mult))[:64]
+    
+    else:
+      mult_code = '*UUUUUUUDDDDDDDUUUUUUUDDDDDDDUUUUUUUDDDDDDDUUUUUUUDDDDDDDUUUUUUU'
 
-            mixed_song = []
+    print('Done!')
+    print('=' * 70)
 
-            for c in csong:
-                
-                pitches = [e[4] for e in c if e[6] == trg_patch]
-                
-                for cc in c:
-                    
-                    ccc = copy.deepcopy(cc)
-                    
-                    if cc[3] != 9: 
-                        if cc[6] == trg_patch:
-                            ccc[3] = 3
-                            ccc[6] = 0
-                            mixed_song.append(ccc)
-                            
-                        else:
-                            if cc[4] not in pitches:
-                                ccc[3] = 0
-                                ccc[6] = 0
-                                mixed_song.append(ccc)
-                                pitches.append(cc[4])
-            
-                    else:
-                        mixed_song.append(ccc)    
-                    
-        if input_remove_drums:
-            mixed_song = [e for e in mixed_song if e[3] != 9]
+    #===============================================================================
 
-        if input_output_tempo == 'Mix':
     
-            time_k = mel_avg_time / mix_avg_time
     
-            mixed_song = TMIDIX.adjust_escore_notes_timings(mixed_song, time_k)
+    #===============================================================================
+    print('Rendering results...')
+    
+    print('=' * 70)
+    print('Sample INTs', mixed_song[:5])
+    print('=' * 70)
+    
+    output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(mixed_song)
 
-        elif input_output_tempo == 'Source Melody':
+    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
+                                                              output_signature = 'Harmonic Melody MIDI Mixer',
+                                                              output_file_name = fn1,
+                                                              track_name='Project Los Angeles',
+                                                              list_of_MIDI_patches=patches,
+                                                              timings_multiplier=16
+                                                              )
+    
+    new_fn = fn1+'.mid'
             
-            time_k = mel_avg_time / mix_mel_avg_time
     
-            mixed_song = TMIDIX.adjust_escore_notes_timings(mixed_song, time_k)
+    audio = midi_to_colab_audio(new_fn, 
+                        soundfont_path=soundfont,
+                        sample_rate=16000,
+                        volume_scale=10,
+                        output_for_gradio=True
+                        )
+    
+    print('Done!')
+    print('=' * 70)
 
-        if input_transform == 'Flip Mix':
-            mixed_song = TMIDIX.flip_enhanced_score_notes(mixed_song)
-            
-        elif input_transform == 'Reverse Mix':
-            mixed_song = TMIDIX.reverse_enhanced_score_notes(mixed_song)        
+    #========================================================
 
-        if input_transpose_value != 0:
-            mixed_song = TMIDIX.transpose_escore_notes(mixed_song, input_transpose_value)
+    output_midi_title = str(fn1)
+    output_midi_summary = str(MIDI_Summary)
+    output_midi = str(new_fn)
+    output_audio = (16000, audio)
 
-        if input_transpose_to_C4:
-            mixed_song = TMIDIX.transpose_escore_notes_to_pitch(mixed_song)
-            
-        #===============================================================================
-        print('Rendering results...')
-        
-        print('=' * 70)
-        print('Sample INTs', mixed_song[:5])
-        print('=' * 70)
-        
-        output_score, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(mixed_song)
-
-        detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(output_score,
-                                                                  output_signature = 'Harmonic Melody MIDI Mixer',
-                                                                  output_file_name = fn1,
-                                                                  track_name='Project Los Angeles',
-                                                                  list_of_MIDI_patches=patches,
-                                                                  timings_multiplier=16
-                                                                  )
-        
-        new_fn = fn1+'.mid'
-                
-        
-        audio = midi_to_colab_audio(new_fn, 
-                            soundfont_path=soundfont,
-                            sample_rate=16000,
-                            volume_scale=10,
-                            output_for_gradio=True
-                            )
-        
-        print('Done!')
-        print('=' * 70)
+    for o in output_score:
+        o[1] *= 16
+        o[2] *= 16
     
-        #========================================================
-    
-        output_midi_title = str(fn1)
-        output_midi_summary = str(MIDI_Summary)
-        output_midi = str(new_fn)
-        output_audio = (16000, audio)
-
-        for o in output_score:
-            o[1] *= 16
-            o[2] *= 16
-        
-        output_plot = TMIDIX.plot_ms_SONG(output_score, plot_title=output_midi_title, return_plt=True)
-    
-        print('Output MIDI file name:', output_midi)
-        print('Output MIDI title:', output_midi_title)
-        print('Output MIDI summary:', MIDI_Summary)
-        print('=' * 70) 
-        
+    output_plot = TMIDIX.plot_ms_SONG(output_score, plot_title=output_midi_title, return_plt=True)
+
+    print('Output MIDI file name:', output_midi)
+    print('Output MIDI title:', output_midi_title)
+    print('Output MIDI summary:', MIDI_Summary)
+    print('=' * 70) 
     
-        #========================================================
-        
-        print('-' * 70)
-        print('Req end time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
-        print('-' * 70)
-        print('Req execution time:', (reqtime.time() - start_time), 'sec')
+
+    #========================================================
     
-        return output_midi_title, output_midi_summary, output_midi, output_audio, output_plot
+    print('-' * 70)
+    print('Req end time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
+    print('-' * 70)
+    print('Req execution time:', (reqtime.time() - start_time), 'sec')
+
+    return output_midi_title, output_midi_summary, output_midi, output_audio, output_plot
 
 # =================================================================================================