Update app.py

app.py

@@ -96,111 +96,26 @@ print('=' * 70)
 # =================================================================================================
 
 @spaces.GPU
-def generate_drums(chords,
-                   drums_biases,
-                   banned_drums,
-                   input_temperature,
-                   input_top_p_value
-                  ):
+def generate_chords(chords,
+                    input_temperature,
+                    input_top_p_value
+                   ):
 
-    flat_chords = TMIDIX.flatten(chords)
 
-    tries = 0
-    max_tries = 30
-    good_seq = False
-    pitches_set = set()
-
-    while not good_seq and tries < max_tries:
-
-        ci_num = random.choice([37, 42])
-
-        input_seq = [640] + flat_chords + [641] + [0, ci_num+384, 127+512]
-    
-        dcount = 0
-    
-        for i in tqdm.tqdm(range(len(chords))):
-    
-            y = 0
-            dtime = 0
-
-            if 0 < i < len(chords):
-                next_dtime = chords[i][0]
-
-            elif i == len(chords):
-                next_dtime = 1
-
-            else:
-                next_dtime = 512
-            
-            while y < 128 or 384 < y < 642:
     
-                x = torch.LongTensor(input_seq).to(DEVICE)
-            
-                with ctx:
-                    out = model.generate_advanced(x,
-                                                  1,
-                                                  temperature=input_temperature,
-                                                  filter_logits_fn=top_p,
-                                                  filter_kwargs={'thres': input_top_p_value},
-                                                  logits_bias=drums_biases,
-                                                  masked_tokens=banned_drums,
-                                                  return_prime=False,
-                                                  verbose=False
-                                                 )
+    x = torch.LongTensor(input_seq).to(DEVICE)
+
+    with ctx:
+        out = model.generate(x,
+                             1,
+                             temperature=input_temperature,
+                             filter_logits_fn=top_p,
+                             filter_kwargs={'thres': input_top_p_value},
+                             return_prime=False,
+                             verbose=False
+                            )
                 
-                y = out.tolist()[0]
-    
-                if y < 128 or 384 < y < 642:
-
-                    if y < 128 and dtime+y >= next_dtime:
-                        input_seq.extend([chords[i][0]-dtime] + chords[i][1:])
-                        dtime = 0
-                        break
-                        
-                    if y < 128 and dtime+y < next_dtime and next_dtime != 512:
-                       dtime += y 
-                        
-                    input_seq.append(y)
-    
-                    if 384 < y < 512:
-                        dcount += 1
-                        pitches_set.add(y)
-                        
-                else:
-                    if i != 0:
-                        input_seq[-1] = chords[i][0]-dtime
-                    input_seq.extend(chords[i][1:])
-                    dtime = 0
-
-            if i == 0 and 256 < y < 384:
-                print('Bad sequence! (Bad start chord)')
-                tries += 1
-                print('Retry attempt:', tries)
-                break
-            
-            if i == len(chords) // 4:
-                if dcount < i // 2:
-                    print('Bad sequence! (Insufficient drums density)')
-                    tries += 1
-                    print('Retry attempt:', tries)
-                    break
-                    
-                if len(pitches_set) < 3:
-                    print('Bad sequence! (Insufficient drums types)')
-                    tries += 1
-                    print('Retry attempt:', tries)
-                    break
-
-        if i == len(chords)-1:
-            if dcount > len(chords) // 2:
-                good_seq = True
-                print('Generated good seq!')
-    
-            else:
-                print('Bad sequence! (Insufficient total drums count)')
-
-    if not good_seq or tries > max_tries-1:
-        print('Failed to generate good seq!')
+        y = out.tolist()[0]
     
     return input_seq[len(flat_chords)+2:]
                        
@@ -217,101 +132,41 @@ def tokens_to_escore_notes(tokens):
     channel = 0
     patch = 0
 
-    for m in tokens:
+    patches = [0] * 16
 
+    for m in tokens:
+    
         if 0 <= m < 128:
-            time += m
-
-        elif 128 < m < 256:
-            dur = (m-128)
-
-        elif 256 < m < 512:
-            pitch = (m-256) % 128
-            chan = (m-256) // 128
+            time += m * 32
             
-            if chan == 0:
-                song_f.append(['note', time, dur, 0, pitch, max(40, pitch), 0])
-                
-        elif 512 < m < 640:
-            vel = m-512
-
-            if chan == 1:
-                song_f.append(['note', time, 2, 9, pitch, vel, 128])
+        elif 461 < m < 589:
+            pitch = (m-461)
+            
+        elif 589 < m < 717:
+            dur = (m-589) * 32
+            song_f.append(['note', time, dur, 0, pitch, max(40, pitch), 0])
 
     return song_f
 
 # =================================================================================================
 
-def Generate_Drums(input_midi,
-                   input_model,
-                   input_drums,
-                   input_drums_bias,
-                   input_temperature,
-                   input_top_p_value
-                  ):
+def Generate_Chords(input_midi,
+                    input_chords,
+                    input_temperature,
+                    input_top_p_value
+                   ):
     
     print('=' * 70)
     print('Req start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
     start_time = reqtime.time()
 
-    fn = os.path.basename(input_midi.name)
-    fn1 = fn.split('.')[0]
-
     print('=' * 70)
-    print('Input file name:', fn)
-    print('Input model:', input_model)
-    print('input drums:', input_drums)
-    print('Req drums bias:', input_drums_bias)
+    print('Input chords:', input_chords)
     print('Req model temp:', input_temperature)
     print('Req top_k value:', input_top_p_value)
     print('=' * 70)
 
-    raw_score = TMIDIX.midi2single_track_ms_score(input_midi.name)
-    escore_notes = TMIDIX.advanced_score_processor(raw_score,
-                                                   return_enhanced_score_notes=True,
-                                                   apply_sustain=True
-                                                  )
-
-    if escore_notes and escore_notes[0]:
-    
-        escore_notes = TMIDIX.augment_enhanced_score_notes(escore_notes[0], timings_divider=32)
-        
-        escore_notes = TMIDIX.fix_escore_notes_durations(escore_notes, min_notes_gap=0)
-        
-        escore_notes = TMIDIX.strip_drums_from_escore_notes(escore_notes)
-
-        if escore_notes:
-    
-            escore_notes = TMIDIX.recalculate_score_timings(escore_notes)
-
-            escore_notes = TMIDIX.delta_score_to_abs_score(TMIDIX.delta_score_notes(escore_notes, timings_clip_value=127))
-            
-            sp_score = TMIDIX.solo_piano_escore_notes(escore_notes)
 
-            if sp_score:
-            
-                cscore = TMIDIX.chordify_score([1000, sp_score])
-                
-                score = []
-                
-                pc = cscore[0]
-                
-                chords = []
-                
-                for c in cscore:
-                    
-                    cho = []
-                    
-                    score.append(max(0, min(127, c[0][1]-pc[0][1])))
-                    cho.append(max(0, min(127, c[0][1]-pc[0][1])))
-                
-                    for n in c:
-                        score.extend([max(1, min(127, n[2]))+128, max(1, min(127, n[4]))+256])
-                        cho.extend([max(1, min(127, n[2]))+128, max(1, min(127, n[4]))+256])
-                
-                    chords.append(cho)
-                
-                    pc = c
     
                 
                 print('Score has', len(chords), 'chords')