| import numpy as np | |
| from configurations.read_configuration import get_conf_sample_rate, get_conf_stft_hyperparameter,\ | |
| midi_parameter_range, get_conf_time_resolution, get_conf_max_n_notes | |
| from melody_synth.random_duration import RandomDuration | |
| from melody_synth.random_pitch import RandomPitch | |
| from melody_synth.random_rhythm import RandomRhythm | |
| class RandomMidi: | |
| """Pipeline generating random midi""" | |
| def __init__(self): | |
| self.randomRhythm = RandomRhythm() | |
| self.randomPitch = RandomPitch() | |
| self.randomDuration = RandomDuration() | |
| self.max_n_notes = get_conf_max_n_notes() | |
| def __call__(self, strategy=None, *args, **kwargs): | |
| """Assembles the pipeline based on given strategies and return random midi. | |
| Parameters | |
| ---------- | |
| strategy: Dict[str, str] | |
| Strategies names for random rhythm, pitch and duration generation (see Readme). | |
| Returns | |
| ------- | |
| encode, midi: List[int], List[(float, float, float)] | |
| encode -- Midi's label as a list of 0s and 1s | |
| midi -- A list of (onset, pitch, duration) tuples, each tuple refers to a note | |
| """ | |
| if strategy is None: | |
| strategy = {"rhythm_strategy": "non-test", | |
| "pitch_strategy": "random_major", | |
| "duration_strategy": "limited_random", | |
| } | |
| midi = self.randomRhythm(strategy["rhythm_strategy"]) | |
| midi = self.randomPitch(strategy["pitch_strategy"], midi) | |
| midi = self.randomDuration(strategy["duration_strategy"], midi) | |
| return self.get_encode(midi), midi | |
| def get_encode(self, midi): | |
| """Generate labels for midi | |
| Parameters | |
| ---------- | |
| midi: List[(onset, pitch, duration)] | |
| A list of (onset, pitch, duration) tuples, each tuple refers to a note | |
| Returns | |
| ------- | |
| encode: List[int] | |
| Midi's label as a list of 0s and 1s | |
| Encoding method | |
| ------- | |
| One-hot Encoding for each note. Stack all note labels to form midi label. | |
| """ | |
| duration_range = midi_parameter_range("duration") | |
| pitch_range = midi_parameter_range("pitch") | |
| time_resolution = get_conf_time_resolution() | |
| pixel_duration = get_conf_stft_hyperparameter()["frame_step"] / get_conf_sample_rate() | |
| single_note_encode_length = (time_resolution + len(pitch_range) + len(duration_range)) | |
| encode_length = single_note_encode_length * self.max_n_notes | |
| encode = [] | |
| for i in range(len(midi)): | |
| (location, pitch, duration) = midi[i] | |
| location_index = int(float(location) / pixel_duration) | |
| if location_index >= time_resolution: | |
| break | |
| pitch_index = pitch - pitch_range[0] | |
| duration_index = np.argmin(np.abs(np.array(duration_range) - duration)) | |
| single_note_encode = np.zeros(single_note_encode_length) | |
| single_note_encode[location_index] = 1 | |
| single_note_encode[time_resolution + pitch_index] = 1 | |
| single_note_encode[time_resolution + len(pitch_range) + duration_index] = 1 | |
| encode = np.hstack([encode, single_note_encode]) | |
| return np.hstack([encode, np.zeros(encode_length)])[:encode_length] | |