updated generation process - epsilon

familizer.py

@@ -115,7 +115,6 @@ class Familizer:
 
 
 if __name__ == "__main__":
-
     # Choose number of jobs for parallel processing
     n_jobs = -1
 

generate.py

@@ -1,8 +1,5 @@
 from generation_utils import *
-from utils import WriteTextMidiToFile, get_miditok
-from load import LoadModel
-from decoder import TextDecoder
-from playback import get_music
+import random
 
 
 class GenerateMidiText:
@@ -100,15 +97,26 @@ class GenerateMidiText:
             text = text.rstrip(" ").rstrip("TRACK_END")
         return text
 
-    def get_last_generated_track(self, full_piece):
-        track = (
-            "TRACK_START "
-            + self.striping_track_ends(full_piece.split("TRACK_START ")[-1])
-            + "TRACK_END "
-        )  # forcing the space after track and
+    def get_last_generated_track(self, piece):
+        """Get the last track from a piece written as a single long string"""
+        track = self.get_tracks_from_a_piece(piece)[-1]
         return track
 
-    def get_selected_track_as_text(self, track_id):
+    def get_tracks_from_a_piece(self, piece):
+        """Get all the tracks from a piece written as a single long string"""
+        all_tracks = [
+            "TRACK_START " + the_track + "TRACK_END "
+            for the_track in self.striping_track_ends(piece.split("TRACK_START ")[1::])
+        ]
+        return all_tracks
+
+    def get_piece_from_track_list(self, track_list):
+        piece = "PIECE_START "
+        for track in track_list:
+            piece += track
+        return piece
+
+    def get_whole_track_from_bar_dict(self, track_id):
         text = ""
         for bar in self.piece_by_track[track_id]["bars"]:
             text += bar
@@ -122,18 +130,12 @@ class GenerateMidiText:
     def get_whole_piece_from_bar_dict(self):
         text = "PIECE_START "
         for track_id, _ in enumerate(self.piece_by_track):
-            text += self.get_selected_track_as_text(track_id)
+            text += self.get_whole_track_from_bar_dict(track_id)
         return text
 
-    def delete_one_track(self, track):  # TO BE TESTED
+    def delete_one_track(self, track):
         self.piece_by_track.pop(track)
 
-    # def update_piece_dict__add_track(self, track_id, track):
-    #     self.piece_dict[track_id] = track
-
-    # def update_all_dictionnaries__add_track(self, track):
-    # self.update_piece_dict__add_track(track_id, track)
-
     """Basic generation tools"""
 
     def tokenize_input_prompt(self, input_prompt, verbose=True):
@@ -238,10 +240,12 @@ class GenerateMidiText:
                     )
                 else:
                     print('"--- Wrong length - Regenerating ---')
+
             if not bar_count_checks:
                 failed += 1
-                if failed > 2:
-                    bar_count_checks = True  # TOFIX exit the while loop
+
+            if failed > 2:
+                bar_count_checks = True  # exit the while loop if failed too much
 
         return full_piece
 
@@ -298,8 +302,7 @@ class GenerateMidiText:
 
     """ Piece generation - Extra Bars """
 
-    @staticmethod
-    def process_prompt_for_next_bar(self, track_idx):
+    def process_prompt_for_next_bar(self, track_idx, verbose=True):
         """Processing the prompt for the model to generate one more bar only.
         The prompt containts:
                 if not the first bar: the previous, already processed, bars of the track
@@ -318,6 +321,10 @@ class GenerateMidiText:
             if i != track_idx:
                 len_diff = len(othertrack["bars"]) - len(track["bars"])
                 if len_diff > 0:
+                    if verbose:
+                        print(
+                            f"Adding bars - {len(track['bars'][-self.model_n_bar :])} selected from SIDE track: {i} for prompt"
+                        )
                     # if other bars are longer, it mean that this one should catch up
                     pre_promt += othertrack["bars"][0]
                     for bar in track["bars"][-self.model_n_bar :]:
@@ -325,7 +332,7 @@ class GenerateMidiText:
                     pre_promt += "TRACK_END "
                 elif (
                     False
-                ):  # len_diff <= 0: # THIS DOES NOT WORK - It just fills things with empty bars
+                ):  # len_diff <= 0: # THIS DOES NOT WORK - It just adds empty bars
                     # adding an empty bars at the end of the other tracks if they have not been processed yet
                     pre_promt += othertracks["bars"][0]
                     for bar in track["bars"][-(self.model_n_bar - 1) :]:
@@ -337,27 +344,54 @@ class GenerateMidiText:
         # for the bar to prolong
         # initialization e.g TRACK_START INST=DRUMS DENSITY=2
         processed_prompt = track["bars"][0]
+        if verbose:
+            print(
+                f"Adding bars - {len(track['bars'][-(self.model_n_bar - 1) :])} selected from MAIN track: {track_idx} for prompt"
+            )
         for bar in track["bars"][-(self.model_n_bar - 1) :]:
             # adding the "last" bars of the track
             processed_prompt += bar
 
         processed_prompt += "BAR_START "
+
+        # making the preprompt short enought to avoid bug due to length of the prompt (model limitation)
+        pre_promt = self.force_prompt_length(pre_promt, 1500)
+
         print(
             f"--- prompt length = {len((pre_promt + processed_prompt).split(' '))} ---"
         )
+
         return pre_promt + processed_prompt
 
-    def generate_one_more_bar(self, i):
+    def force_prompt_length(self, prompt, expected_length):
+        """remove one instrument/track from the prompt it too long
+        Args:
+            prompt (str): the prompt to be processed
+            expected_length (int): the expected length of the prompt
+        Returns:
+            the truncated prompt"""
+        if len(prompt.split(" ")) < expected_length:
+            truncated_prompt = prompt
+        else:
+            tracks = self.get_tracks_from_a_piece(prompt)
+            selected_tracks = random.sample(tracks, len(tracks) - 1)
+            truncated_prompt = self.get_piece_from_track_list(selected_tracks)
+            print(f"Prompt too long - deleting one track")
+
+        return truncated_prompt
+
+    def generate_one_more_bar(self, track_index):
         """Generate one more bar from the input_prompt"""
-        processed_prompt = self.process_prompt_for_next_bar(self, i)
+        processed_prompt = self.process_prompt_for_next_bar(track_index)
+
         prompt_plus_bar = self.generate_until_track_end(
             input_prompt=processed_prompt,
-            temperature=self.piece_by_track[i]["temperature"],
+            temperature=self.piece_by_track[track_index]["temperature"],
             expected_length=1,
             verbose=False,
         )
         added_bar = self.get_newly_generated_bar(prompt_plus_bar)
-        self.update_track_dict__add_bars(added_bar, i)
+        self.update_track_dict__add_bars(added_bar, track_index)
 
     def get_newly_generated_bar(self, prompt_plus_bar):
         return "BAR_START " + self.striping_track_ends(
@@ -380,7 +414,6 @@ class GenerateMidiText:
         self.check_the_piece_for_errors()
 
     def check_the_piece_for_errors(self, piece: str = None):
-
         if piece is None:
             piece = self.get_whole_piece_from_bar_dict()
         errors = []

generation_utils.py

@@ -2,6 +2,7 @@ import os
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib
+from utils import writeToFile, get_datetime
 
 from constants import INSTRUMENT_CLASSES
 from playback import get_music, show_piano_roll
@@ -14,11 +15,38 @@ matplotlib.rcParams["axes.facecolor"] = "none"
 matplotlib.rcParams["axes.edgecolor"] = "grey"
 
 
-def define_generation_dir(model_repo_path):
-    generated_sequence_files_path = f"midi/generated/{model_repo_path}"
-    if not os.path.exists(generated_sequence_files_path):
-        os.makedirs(generated_sequence_files_path)
-    return generated_sequence_files_path
+class WriteTextMidiToFile:  # utils saving miditext from teh class GenerateMidiText to file
+    def __init__(self, generate_midi, output_path):
+        self.generated_midi = generate_midi.generated_piece
+        self.output_path = output_path
+        self.hyperparameter_and_bars = generate_midi.piece_by_track
+
+    def hashing_seq(self):
+        self.current_time = get_datetime()
+        self.output_path_filename = f"{self.output_path}/{self.current_time}.json"
+
+    def wrapping_seq_hyperparameters_in_dict(self):
+        # assert type(self.generated_midi) is str, "error: generate_midi must be a string"
+        # assert (
+        #     type(self.hyperparameter_dict) is dict
+        # ), "error: feature_dict must be a dictionnary"
+        return {
+            "generated_midi": self.generated_midi,
+            "hyperparameters_and_bars": self.hyperparameter_and_bars,
+        }
+
+    def text_midi_to_file(self):
+        self.hashing_seq()
+        output_dict = self.wrapping_seq_hyperparameters_in_dict()
+        print(f"Token generate_midi written: {self.output_path_filename}")
+        writeToFile(self.output_path_filename, output_dict)
+        return self.output_path_filename
+
+
+def define_generation_dir(generation_dir):
+    if not os.path.exists(generation_dir):
+        os.makedirs(generation_dir)
+    return generation_dir
 
 
 def bar_count_check(sequence, n_bars):
@@ -64,7 +92,8 @@ def check_if_prompt_density_in_tokenizer_vocab(tokenizer, density_prompt_list):
 
 def forcing_bar_count(input_prompt, generated, bar_count, expected_length):
     """Forcing the generated sequence to have the expected length
-    expected_length and bar_count refers to the length of newly_generated_only (without input prompt)"""
+    expected_length and bar_count refers to the length of newly_generated_only (without input prompt)
+    """
 
     if bar_count - expected_length > 0:  # Cut the sequence if too long
         full_piece = ""