Update app.py

app.py

@@ -120,32 +120,32 @@ def load_midi(midi_file):
     print('=' * 70)
 
     src_melody_chords_f = []
-    melody_chords_f = []
     
-    for i in range(0, len(melody_chords), 300):
+    for i in range(0, len(melody_chords), 150):
         
         chunk = melody_chords[i:i+300]
         
         src = []
-        src1 = []
-        trg = []
         
-        if len(chunk) == 300:
+        for mm in chunk:
+            src.append([mm[0], mm[2]+256, mm[1]+384, mm[3]+640])
     
-            for mm in chunk:
-                src.extend([mm[0], mm[2]+256])
-                src1.append([mm[0], mm[2]+256, mm[1]+384, mm[3]+640])
-                trg.extend([mm[0], mm[2]+256, mm[1]+384, mm[3]+640])
+        clen = len(src)
     
-            src_melody_chords_f.append(src1)
-            melody_chords_f.append([768] + src + [769] + trg + [770])
+        if clen  < 300:
+    
+            chunk_mult = (300 // clen) + 1
+    
+            src += src * chunk_mult
+    
+        src_melody_chords_f.append([clen, src[:300]])
             
     print('Done!')
     print('=' * 70)
-    print('Number of composition chunks:', len(melody_chords_f))
+    print('Number of composition chunks:', len(src_melody_chords_f))
     print('=' * 70)
 
-    return melody_chords_f, src_melody_chords_f
+    return src_melody_chords_f
 
 # =================================================================================================
                        
@@ -198,9 +198,7 @@ def Convert_Score_to_Performance(input_midi,
     model.eval()
 
     #==================================================================
-    
-    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
     
@@ -209,73 +207,145 @@ def Convert_Score_to_Performance(input_midi,
     
     #==================================================================
     
-    song_chunk = src_melody_chords_f[composition_chunk_idx]
+    if input_midi_type == 'Score':
+        
+        dur_top_k = 1
+        dur_temperature = 1.1
+        vel_temperature = 1.5
+    
+    elif input_midi_type == 'Performance':
+        
+        dur_top_k = 10
+        dur_temperature = 1.5
+        vel_temperature = 1.5
     
-    song = [768]
+    else:
+        
+        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 m in song_chunk:
-        song.extend(m[:2])
+    final_song = []
     
-    song.append(769)
+    for cc, (song_chunk_len, song_chunk) in enumerate(src_melody_chords_f):
     
-    for i in tqdm.tqdm(range(len(song_chunk))):
+        print('=' * 70)
+        print('Rendering song chunk #', cc)
+        print('=' * 70)
     
-        song.extend(song_chunk[i][:2])
+        #========================================================================
     
-        # Durations
+        song = [768]
     
-        if i < num_prime_notes:
-            song.append(song_chunk[i][2])
+        if cc == 0:
+    
+            for m in song_chunk:
+                song.extend(m[:2])
+            
+            song.append(769)
+    
+            sidx = 0
+            eidx = 300
     
         else:
+            for m in song_chunk[:150]:
+                psrc.extend(m[:2])
+    
+            psrc.append(769)
     
-            x = torch.LongTensor(song).cuda()
+            song = copy.deepcopy(psrc + ptrg)
     
-            y = 0 
+            sidx = 150
+            eidx = 300
+        
+        #========================================================================
+        
+        for i in tqdm.tqdm(range(sidx, eidx)):
+        
+            song.extend(song_chunk[i][:2])
     
-            while not 384 < y < 640:
+            if 'Durations' in input_conv_type:
+        
+                if i < num_prime_notes and cc == 0:
+                    song.append(song_chunk[i][2])
+            
+                else:
             
-                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)
+                    # Durations
                 
-                y = out.tolist()[0][0]
-        
-            song.append(y)
+                    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]
+                
+                    song.append(y)
+    
+            else:
+                song.append(song_chunk[i][2])
     
+            #========================================================================
     
-        # Velocities
+            if 'Velocities' in input_conv_type:
         
-        if i < num_prime_notes:
-            song.append(song_chunk[i][3])
+        
+                if i < num_prime_notes and cc == 0:
+                    song.append(song_chunk[i][3])
+            
+                else:
+            
+                    # Velocities
+                
+                    x = torch.LongTensor(song).cuda()
+                    
+                    y = 0 
+            
+                    while not 640 < y < 768:
+                            
+                        with ctx:
+                            out = model.generate(x,
+                                                 1,
+                                                 temperature=vel_temperature,
+                                                 return_prime=False,
+                                                 verbose=False)
+                        
+                        y = out.tolist()[0][0]
+                
+                    song.append(y)
+                    
+            else:
+                song.append(song_chunk[i][3])
+                
+        #========================================================================
+    
+        if cc == 0:
+            final_song.extend(song[602:][:(song_chunk_len * 4)])
     
         else:
+            final_song.extend(song[602:][600:(song_chunk_len * 4)])
     
-            x = torch.LongTensor(song).cuda()
-            
-            y = 0 
+        psrc = copy.deepcopy(song[1:301])
+        ptrg = copy.deepcopy(song[602:][:600])
+    
+        #========================================================================
+    
+        if len(final_song) >= input_number_conv_notes * 4:
+            break
+    
+        #========================================================================
     
-            while not 640 < y < 768:
-                    
-                with ctx:
-                    out = model.generate(x,
-                                         1,
-                                         temperature=vel_temperature,
-                                         #filter_logits_fn=top_k,
-                                         #filter_kwargs={'k': 10},
-                                         return_prime=False,
-                                         verbose=False)
-                
-                y = out.tolist()[0][0]
-        
-            song.append(y)
-
-            
     print('=' * 70)
     print('Done!')
     print('=' * 70)