Update app.py

app.py

@@ -184,7 +184,7 @@ def Convert_Score_to_Performance(input_midi,
 
     #==================================================================
 
-    melody_chords, src_melody_chords = load_midi(input_midi)
+    melody_chords_f, src_melody_chords_f = load_midi(input_midi)
 
     #==================================================================
     
@@ -196,106 +196,83 @@ def Convert_Score_to_Performance(input_midi,
     model.eval()
 
     #==================================================================
-
-    def generate_continuation(num_prime_tokens, num_gen_tokens):
-
-        x = torch.tensor(TMIDIX.flatten(prime_toks)[:num_prime_tokens], dtype=torch.long, device=DEVICE)
-        
-        with ctx:
-          out = model.generate(x,
-                              num_gen_tokens,
-                              filter_logits_fn=top_p,
-                              filter_kwargs={'thres': input_model_top_p},
-                              temperature=input_model_temperature,
-                              return_prime=True,
-                              verbose=True)
-        
-        y = out.tolist()[0]
-
-        return y
-
+    
+    composition_chunk_idx = 0 # Composition chunk idx to generate durations and velocities for. Each chunk is 300 notes
+    
+    num_prime_notes = input_number_prime_notes # Priming improves the results but it is not necessary and you can set it to zero
+    dur_top_k = input_model_dur_top_k # Use k == 1 if src composition is score and k > 1 if src composition is performance
+    
+    dur_temperature = input_model_dur_temperature # For best results, durations temperature should be more than 1.0 but less than velocities temperature
+    vel_temperature = input_model_vel_temperature # For best results, velocities temperature must be larger than 1.3 and larger than durations temperature
+    
     #==================================================================
-
-    def generate_tokens(seq, max_num_ptcs=5, max_tries=10):
     
-        input = copy.deepcopy(seq)
-
-        pcount = 0
-        y = 545
-        tries = 0
+    song_chunk = src_melody_chords_f[composition_chunk_idx]
     
-        gen_tokens = []
-
-        seen = False
+    song = [768]
     
-        if 256 < input[-1] < 544:
-          seen = True 
-
-        while pcount < max_num_ptcs and y > 255 and tries < max_tries:
+    for m in song_chunk:
+        song.extend(m[:2])
+    
+    song.append(769)
+    
+    for i in tqdm.tqdm(range(len(song_chunk))):
     
-            x = torch.tensor(input[-input_num_memory_tokens:], dtype=torch.long, device=DEVICE)
+        song.extend(song_chunk[i][:2])
+    
+        # Durations
+    
+        if i < num_prime_notes:
+            song.append(song_chunk[i][2])
+    
+        else:
+    
+            x = torch.LongTensor(song).cuda()
+    
+            y = 0 
+    
+            while not 384 < y < 640:
+            
+                with ctx:
+                    out = model.generate(x,
+                                         1,
+                                         temperature=dur_temperature,
+                                         filter_logits_fn=top_k,
+                                         filter_kwargs={'k': dur_top_k},
+                                         return_prime=False,
+                                         verbose=False)
+                
+                y = out.tolist()[0][0]
         
-            with ctx:
-              out = model.generate(x,
-                                  1,
-                                  filter_logits_fn=top_p,
-                                  filter_kwargs={'thres': input_model_top_p},
-                                  return_prime=False,
-                                  verbose=False)
+            song.append(y)
+    
+    
+        # Velocities
+        
+        if i < num_prime_notes:
+            song.append(song_chunk[i][3])
+    
+        else:
+    
+            x = torch.LongTensor(song).cuda()
             
-            y = out[0].tolist()[0]
+            y = 0 
     
-            if 256 < y < 544:
-                if not seen:
-                    input.append(y)
-                    gen_tokens.append(y)
-                    seen = True
-                    
-                else:
-                    tries += 1
+            while not 640 < y < 768:
                     
-            if y > 544 and seen:
-                if pcount < max_num_ptcs and y not in gen_tokens:    
-                    input.append(y)
-                    gen_tokens.append(y)
-                    pcount += 1
-    
-                else:
-                    tries += 1
+                with ctx:
+                    out = model.generate(x,
+                                         1,
+                                         temperature=vel_temperature,
+                                         #filter_logits_fn=top_k,
+                                         #filter_kwargs={'k': 10},
+                                         return_prime=False,
+                                         verbose=False)
                 
-        return gen_tokens
-
-    #==================================================================
-
-    song = []
-    
-    if input_gen_type == 'Freestyle':
+                y = out.tolist()[0][0]
         
-        output = generate_continuation(input_number_prime_tokens, input_number_gen_tokens)
-        song.extend(output)
+            song.append(y)
 
-    else:
-
-        for i in range(input_number_prime_chords):
-            song.extend(prime_toks[i])
-        
-        for i in tqdm.tqdm(range(input_number_prime_chords, input_number_prime_chords+input_number_gen_chords)):
-            
-            song.extend(score_toks[i])
-        
-            if control_toks[i]:
-                for ct in control_toks[i]:
-                    
-                    if input_use_original_durations:
-                        song.append(ct[0])
-                        
-                    if input_match_original_pitches_counts:
-                        out_seq = generate_tokens(song, ct[1])
-                        
-                    else:
-                        out_seq = generate_tokens(song)
-                        
-                    song.extend(out_seq)
             
     print('=' * 70)
     print('Done!')
@@ -308,42 +285,39 @@ def Convert_Score_to_Performance(input_midi,
     print('=' * 70)
     print('Sample INTs', song[:15])
     print('=' * 70)
+
+    song_f = []
     
     if len(song) != 0:
     
-        song_f = []
-    
         time = 0
-        dur = 32
-        channel = 0
-        pitch = 60
+        dur = 0
         vel = 90
+        pitch = 60
+        channel = 0
+        patch = 0
         
-        patches = [0, 10, 19, 24, 35, 40, 52, 56, 65, 9, 0, 0, 0, 0, 0, 0]
-        velocities = [80, 100, 90, 100, 110, 100, 100, 100, 100, 110]
-    
-        for ss in song:
-    
-            if 0 <= ss < 128:
-    
-                time += ss * 32
-                
-            if 128 < ss < 256:
-                
-                song_f.append(['note', time, 32, 9, ss-128, velocities[9], 128])
+        patches = [0] * 16
+        
+        for ss in song1:
+        
+            if 0 <= ss < 256:
+        
+                time += ss * 16
+        
+            if 256 <= ss < 384:
+        
+                pitch = ss-256
+        
+            if 384 <= ss < 640:
+        
+                dur = (ss-384) * 16
+        
+            if 640 <= ss < 768:
                 
-            if 256 < ss < 544:
-    
-                dur =  ((ss-256) % 32) * 4 * 32
-                channel = (ss-256) // 32
-    
-            if 544 < ss < 672:
-    
-                patch = channel * 8
-    
-                pitch = ss-544
-    
-                song_f.append(['note', time, dur, channel, pitch, velocities[channel], patch])
+                vel = (ss-640)
+            
+                song_f.append(['note', time, dur, channel, pitch, vel, patch])
 
     fn1 = "Score-2-Performance-Transformer-Composition"