Update app.py

app.py

@@ -198,185 +198,141 @@ def save_midi(tokens, batch_number=None, model_selector=''):
 #==================================================================================
 
 @spaces.GPU
-def generate_accompaniment(input_midi, 
+def Generate_Accompaniment(input_midi, 
                            num_gen_tokens,
                            model_temperature
                           ):
 
-    if not prime:
-        inputs = [0]
+    #===============================================================================
+    
+    print('=' * 70)
+    print('Req start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
+    start_time = reqtime.time()
+    print('=' * 70)
 
-    else:
-        inputs = prime[-num_mem_tokens:]
+    fn = os.path.basename(input_midi)
+    fn1 = fn.split('.')[0]
 
-    model = model_state[0]
-    ctx = model_state[1]
-        
-    model.cuda()
-    model.eval()
+    print('=' * 70)
+    print('Requested settings:')
+    print('=' * 70)
+    print('Input MIDI file name:', fn)
+    print('Input MIDI type:', input_midi_type)
+    print('Conversion type:', input_conv_type)
+    print('Number of prime notes:', input_number_prime_notes)
+    print('Number of notes to convert:', input_number_conv_notes)
+    print('Model durations sampling top value:', input_model_dur_top_k)
+    print('Model durations temperature:', input_model_dur_temperature)
+    print('Model velocities temperature:', input_model_vel_temperature)
+    
+    print('=' * 70)
 
+    #==================================================================
+
+    src_melody_chords_f = load_midi(input_midi.name)
+
+    #==================================================================
+    
+    print('Sample output events', src_melody_chords_f[0][1][:3])
+    print('=' * 70)
     print('Generating...')
+
+    model.to(DEVICE)
+    model.eval()
+
+    #==================================================================
     
-    inp = [inputs] * num_gen_batches
+    print('=' * 70)
+    print('Done!')
+    print('=' * 70)
     
-    inp = torch.LongTensor(inp).cuda()
+    #===============================================================================
     
-    with ctx:
-        out = model.generate(inp,
-                              num_gen_tokens,
-                              #filter_logits_fn=top_p,
-                              #filter_kwargs={'thres': model_sampling_top_p},
-                              temperature=model_temperature,
-                              return_prime=False,
-                              verbose=False)
+    print('Rendering results...')
     
-    output = out.tolist()
-
-    print('Done!')
     print('=' * 70)
-            
-    return output
-    
-#==================================================================================
+    print('Sample INTs', final_song[:15])
+    print('=' * 70)
 
-def generate_callback(input_midi, 
-                      num_prime_tokens, 
-                      num_gen_tokens,
-                      num_mem_tokens,
-                      model_temperature,
-                      # model_sampling_top_p,
-                      final_composition, 
-                      generated_batches, 
-                      block_lines,
-                      model_state
-                     ):
-
-    generated_batches = []
-
-    if not final_composition and input_midi is not None:
-        final_composition = load_midi(input_midi, model_selector=model_state[2])[:num_prime_tokens]
-        midi_score = save_midi(final_composition, model_selector=model_state[2])
-        block_lines.append(midi_score[-1][1] / 1000)
-        
-    batched_gen_tokens = generate_music(final_composition, 
-                                        num_gen_tokens,
-                                        num_mem_tokens,
-                                        NUM_OUT_BATCHES,
-                                        model_temperature,
-                                        # model_sampling_top_p,
-                                        model_state
-                                       )
+    song_f = []
     
-    outputs = []
+    if len(final_song) != 0:
     
-    for i in range(len(batched_gen_tokens)):
-
-        tokens = batched_gen_tokens[i]
+        time = 0
+        dur = 0
+        vel = 90
+        pitch = 60
+        channel = 0
+        patch = 0
         
-        # Preview
-        tokens_preview = final_composition[-PREVIEW_LENGTH:]
+        patches = [0] * 16
         
-        # Save MIDI to a temporary file
-        midi_score = save_midi(tokens_preview + tokens, i, model_selector=model_state[2])
-
-        # MIDI plot
-
-        if len(final_composition) > PREVIEW_LENGTH:
-            midi_plot = TMIDIX.plot_ms_SONG(midi_score, 
-                                            plot_title='Batch # ' + str(i),
-                                            preview_length_in_notes=int(PREVIEW_LENGTH / 3),
-                                            return_plt=True
-                                           )
-
-        else:
-            midi_plot = TMIDIX.plot_ms_SONG(midi_score, 
-                                            plot_title='Batch # ' + str(i), 
-                                            return_plt=True
-                                           )
-
-        # File name
-        fname = 'Guided-Accompaniment-Transformer-Music-Composition_'+str(i)
+        for ss in final_song:
         
-        # Save audio to a temporary file
-        midi_audio = midi_to_colab_audio(fname + '.mid', 
-                                        soundfont_path=SOUDFONT_PATH,
-                                        sample_rate=16000,
-                                        output_for_gradio=True
-                                        )
-
-        outputs.append([(16000, midi_audio), midi_plot, tokens])
+            if 0 <= ss < 256:
         
-    return outputs, final_composition, generated_batches, block_lines
-
-#==================================================================================
-
-def generate_callback_wrapper(input_midi, 
-                              num_prime_tokens, 
-                              num_gen_tokens,
-                              num_mem_tokens,
-                              model_temperature,
-                              # model_sampling_top_p,
-                              final_composition, 
-                              generated_batches, 
-                              block_lines,
-                              model_selector,
-                              model_state
-                             ):
+                time += ss * 16
+        
+            if 256 <= ss < 384:
+        
+                pitch = ss-256
+        
+            if 384 <= ss < 640:
+        
+                dur = (ss-384) * 16
+        
+            if 640 <= ss < 768:
+                
+                vel = (ss-640)
+            
+                song_f.append(['note', time, dur, channel, pitch, vel, patch])
 
-    print('=' * 70)
-    print('Req start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
-    start_time = reqtime.time()
+    fn1 = "Score-2-Performance-Transformer-Composition"
+    
+    detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(song_f,
+                                                              output_signature = 'Score 2 Performance Transformer',
+                                                              output_file_name = fn1,
+                                                              track_name='Project Los Angeles',
+                                                              list_of_MIDI_patches=patches
+                                                              )
     
+    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)
-    if input_midi is not None:
-            fn = os.path.basename(input_midi.name)
-            fn1 = fn.split('.')[0]
-            print('Input file name:', fn)
 
-    print('Selected model type:', model_selector)
+    #========================================================
 
-    if not model_state:
-        model_state = load_model(model_selector)
-        model_state.append(model_selector)
-
-    else:
-        if model_selector != model_state[2]:
-            print('=' * 70)
-            print('Switching model...')
-            model_state = load_model(model_selector)
-            model_state.append(model_selector)
-            print('=' * 70)
-    
-    print('Num prime tokens:', num_prime_tokens)
-    print('Num gen tokens:', num_gen_tokens)
-    print('Num mem tokens:', num_mem_tokens)
-
-    print('Model temp:', model_temperature)
-    # print('Model top_p:', model_sampling_top_p)
-    print('=' * 70)
+    output_midi_title = str(fn1)
+    output_midi_summary = str(song_f[:3])
+    output_midi = str(new_fn)
+    output_audio = (16000, audio)
     
-    result = generate_callback(input_midi, 
-                                num_prime_tokens, 
-                                num_gen_tokens,
-                                num_mem_tokens,
-                                model_temperature,
-                                # model_sampling_top_p,
-                                final_composition,
-                                generated_batches,
-                                block_lines,
-                                model_state
-                             )
+    output_plot = TMIDIX.plot_ms_SONG(song_f, plot_title=output_midi, return_plt=True)
+
+    print('Output MIDI file name:', output_midi)
+    print('Output MIDI title:', output_midi_title)
+    print('Output MIDI summary:', output_midi_summary)
+    print('=' * 70) 
     
-    generated_batches = [sublist[-1] for sublist in result[0]]
 
-    print('=' * 70)
+    #========================================================
+    
+    print('-' * 70)
     print('Req end time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
-    print('=' * 70)
+    print('-' * 70)
     print('Req execution time:', (reqtime.time() - start_time), 'sec')
-    print('*' * 70)    
-    
-    return tuple([result[1], generated_batches, result[3]] + [item for sublist in result[0] for item in sublist[:-1]] + [model_state])
 
+    return output_midi, output_audio, output_plot
+    
 #==================================================================================
 
 PDT = timezone('US/Pacific')
@@ -391,10 +347,6 @@ with gr.Blocks() as demo:
 
     #==================================================================================
 
-    demo.load(reset_demo)
-
-    #==================================================================================
-
     gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Guided Accompaniment Transformer</h1>")
     gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Guided melody accompaniment generation with transformers</h1>")
     gr.HTML("""
@@ -435,7 +387,7 @@ with gr.Blocks() as demo:
             
     outputs.extend([model_state])
 
-    generate_btn.click(generate_accompaniment, 
+    generate_btn.click(Generate_Accompaniment, 
                        [input_midi, 
                         num_gen_tokens,
                         model_temperature
@@ -446,11 +398,27 @@ with gr.Blocks() as demo:
                         output_midi,                           
                        ]
                       )
-    
-    #==================================================================================
-
-    demo.unload(reset_demo)
 
+    '''gr.Examples(
+        [["asap_midi_score_21.mid", "Score", "Durations and Velocities", 8, 600, 1, 1.1, 1.5],
+         ["asap_midi_score_45.mid", "Score", "Durations and Velocities", 8, 600, 1, 1.1, 1.5],
+         ["asap_midi_score_69.mid", "Score", "Durations and Velocities", 8, 600, 1, 1.1, 1.5],
+         ["asap_midi_score_118.mid", "Score", "Durations and Velocities", 8, 600, 1, 1.1, 1.5],
+         ["asap_midi_score_167.mid", "Score", "Durations and Velocities", 8, 600, 1, 1.1, 1.5],
+        ],
+        [input_midi,
+         input_midi_type,
+         input_conv_type,
+         input_number_prime_notes,
+         input_number_conv_notes,
+         input_model_dur_top_k,
+         input_model_dur_temperature,
+         input_model_vel_temperature
+        ],
+        [output_midi_title, output_midi_summary, output_midi, output_audio, output_plot],
+        Convert_Score_to_Performance
+    )'''
+        
 #==================================================================================
 
 demo.launch()