|
from typing import List |
|
|
|
import librosa |
|
|
|
from data_generation.encoding import ParameterDescription, Sample |
|
from melody_synth.random_midi import RandomMidi |
|
from melody_synth.melody_generator import MelodyGenerator |
|
from scipy.io.wavfile import write |
|
from pathlib import Path |
|
from tqdm import tqdm |
|
import json |
|
import matplotlib.pyplot as plt |
|
import numpy as np |
|
import tensorflow as tf |
|
import matplotlib |
|
from configurations.read_configuration import parameter_range, is_discrete, get_conf_stft_hyperparameter |
|
import shutil |
|
|
|
|
|
from tools import power_to_db |
|
|
|
num_params = 16 |
|
|
|
|
|
def plot_spectrogram(signal: np.ndarray, |
|
path: str, |
|
frame_length=512, |
|
frame_step=256): |
|
"""Computes the spectrogram of the given signal and saves it. |
|
|
|
Parameters |
|
---------- |
|
signal: np.ndarray |
|
The signal for which to compute the spectrogram. |
|
path: str |
|
Path to save the the computed spectrogram. |
|
frame_length: |
|
Window size of the FFT. |
|
frame_step: |
|
Hop size of the FFT. |
|
""" |
|
|
|
|
|
|
|
spectrogram = tf.signal.stft(signal, |
|
frame_length=frame_length, |
|
frame_step=frame_step, |
|
pad_end=False) |
|
|
|
|
|
magnitude_spectrum = tf.abs(spectrogram) |
|
log_spectrum = power_to_db(magnitude_spectrum) |
|
matplotlib.pyplot.imsave(path, np.transpose(log_spectrum), vmin=-100, vmax=0, origin='lower') |
|
|
|
|
|
def plot_mel_spectrogram(signal: np.ndarray, |
|
path: str, |
|
frame_length=512, |
|
frame_step=256): |
|
|
|
spectrogram = librosa.feature.melspectrogram(signal, sr=16384, n_fft=2048, hop_length=frame_step, win_length=frame_length) |
|
matplotlib.pyplot.imsave(path, spectrogram, vmin=-100, vmax=0, origin='lower') |
|
|
|
|
|
|
|
param_descriptions: List[ParameterDescription] |
|
param_descriptions = [ |
|
|
|
|
|
ParameterDescription(name="osc1_amp", |
|
values=parameter_range('osc1_amp'), |
|
discrete=is_discrete('osc1_amp')), |
|
ParameterDescription(name="osc2_amp", |
|
values=parameter_range('osc2_amp'), |
|
discrete=is_discrete('osc2_amp')), |
|
|
|
|
|
ParameterDescription(name="attack", |
|
values=parameter_range('attack'), |
|
discrete=is_discrete('attack')), |
|
ParameterDescription(name="decay", |
|
values=parameter_range('decay'), |
|
discrete=is_discrete('decay')), |
|
ParameterDescription(name="sustain", |
|
values=parameter_range('sustain'), |
|
discrete=is_discrete('sustain')), |
|
ParameterDescription(name="release", |
|
values=parameter_range('release'), |
|
discrete=is_discrete('release')), |
|
|
|
ParameterDescription(name="cutoff_freq", |
|
values=parameter_range('cutoff_freq'), |
|
discrete=is_discrete('cutoff_freq')), |
|
|
|
|
|
|
|
|
|
ParameterDescription(name="osc_types", |
|
values=parameter_range('osc_types'), |
|
discrete=is_discrete('osc_types')), |
|
] |
|
|
|
|
|
def generate_dataset_for_cnn(n: int, |
|
path_name="./data/data_cnn_model", |
|
sample_rate=16384, |
|
n_samples_for_note=16384 * 4, |
|
n_samples_for_melody=16384 * 4, write_parameter=True, write_spectrogram=True): |
|
""" |
|
Generate dataset of size n for 'Inversynth' cnn model |
|
|
|
:param n: Int |
|
:param path_name: String--path to save the dataset |
|
:param sample_rate: Int |
|
:param n_samples_for_note: Int |
|
:param n_samples_for_melody: Int |
|
:param write_parameter: Boolean--if write parameter values in a .txt file |
|
:param write_spectrogram: Boolean--write spectrogram with parameter values in the file name |
|
:return: |
|
""" |
|
|
|
shutil.rmtree(path_name) |
|
Path(path_name).mkdir(parents=True, exist_ok=True) |
|
print("Generating dataset...") |
|
|
|
synth = MelodyGenerator(sample_rate, |
|
n_samples_for_note, n_samples_for_melody) |
|
randomMidi = RandomMidi() |
|
|
|
for i in tqdm(range(n)): |
|
parameter_values = [param.generate() for param in param_descriptions] |
|
|
|
|
|
parameter_values_raw = {param.name: param.value for param in parameter_values} |
|
|
|
strategy = {"rhythm_strategy": "free_rhythm", |
|
"pitch_strategy": "free_pitch", |
|
"duration_strategy": "random_duration", |
|
} |
|
midi_encode, midi = randomMidi(strategy) |
|
signal = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
|
|
|
|
path = path_name + f"/{i}" |
|
Path(path).mkdir(parents=True, exist_ok=True) |
|
|
|
if write_parameter: |
|
suffix = 'spectrogram' |
|
for parameter_value in parameter_values: |
|
suffix += f'_{parameter_value.name}={"%.3f" % parameter_value.value}' |
|
if write_spectrogram: |
|
plot_spectrogram(signal, path=path + f"/{suffix}.png", frame_length=1024, frame_step=256) |
|
else: |
|
with open(path + f"/{suffix}.txt", "w") as f: |
|
f.write("test") |
|
f.close() |
|
|
|
write(path + f"/{i}.wav", synth.sample_rate, signal) |
|
|
|
sample = Sample(parameter_values) |
|
|
|
|
|
with open(path + "/label.json", "w") as label_file: |
|
label = sample.get_values() |
|
label['midi'] = midi |
|
|
|
json.dump(label, label_file, ensure_ascii=True) |
|
|
|
print('Data generation done!') |
|
|
|
|
|
def generate_dataset_for_triplet(n: int, |
|
path_name="./data/data_triplet_val_10_500", |
|
sample_rate=16384, |
|
n_samples_for_note=16384 * 4, |
|
n_samples_for_melody=16384 * 4, |
|
n_labels=30, |
|
write_spectrogram=True): |
|
""" |
|
Generate dataset of size n for triplet model |
|
|
|
:param write_spectrogram: Boolean--if write spectrogram |
|
:param n: Int :param path_name: String--path to save the dataset :param sample_rate: Int :param |
|
n_samples_for_note: Int :param n_samples_for_melody: Int :param n_labels: Int--number of synthesizer parameter |
|
combinations contained in the dataset (a hyper parameter of triplet model) |
|
""" |
|
|
|
shutil.rmtree(path_name) |
|
Path(path_name).mkdir(parents=True, exist_ok=True) |
|
print("Generating dataset...") |
|
synth = MelodyGenerator(sample_rate, |
|
n_samples_for_note, n_samples_for_melody) |
|
randomMidi = RandomMidi() |
|
|
|
parameter_values_examples = [[param.generate() for param in param_descriptions] for i in range(n_labels)] |
|
parameter_values_raw_examples = [{param.name: param.value for param in parameter_values} for parameter_values in |
|
parameter_values_examples] |
|
|
|
np.random.seed() |
|
for i in tqdm(range(n)): |
|
label_index = np.random.randint(0, n_labels) |
|
parameter_values = parameter_values_examples[label_index] |
|
parameter_values_raw = parameter_values_raw_examples[label_index] |
|
|
|
strategy = {"rhythm_strategy": "free_rhythm", |
|
"pitch_strategy": "free_pitch", |
|
"duration_strategy": "random_duration", |
|
} |
|
midi_encode, midi = randomMidi(strategy) |
|
signal = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
|
|
|
|
path = path_name + f"/{i}" |
|
Path(path).mkdir(parents=True, exist_ok=True) |
|
|
|
write(path + f"/{i}.wav", synth.sample_rate, signal) |
|
suffix = 'spectrogram' |
|
for parameter_value in parameter_values: |
|
suffix += f'_{parameter_value.name}={"%.3f" % parameter_value.value}' |
|
|
|
if write_spectrogram: |
|
hp = get_conf_stft_hyperparameter() |
|
frame_l = hp['frame_length'] |
|
frame_s = hp['frame_length'] |
|
plot_spectrogram(signal, path=path + f"/{suffix}.png", frame_length=frame_l, frame_step=frame_s) |
|
else: |
|
with open(path + f"/{suffix}.txt", "w") as f: |
|
f.write("test") |
|
f.close() |
|
|
|
with open(path + "/label_index.json", "w") as label_index_file: |
|
index_json = {'index': label_index} |
|
json.dump(index_json, label_index_file, ensure_ascii=False) |
|
|
|
|
|
with open(path + "/midi.txt", "w") as midi_file: |
|
midi_file.write(str(midi)) |
|
midi_file.close() |
|
|
|
print('Data generation done!') |
|
|
|
|
|
def manhattan_distance(SP1, SP2): |
|
""" |
|
:param SP1: first input synthesizer parameter combination |
|
:param SP2: second input synthesizer parameter combination |
|
:return: Float--manhattan distance between SP1 and SP2 |
|
""" |
|
|
|
md = [] |
|
for key in SP1: |
|
parameter_name = key |
|
value1 = SP1[parameter_name] |
|
value2 = SP2[parameter_name] |
|
bins = parameter_range(parameter_name) |
|
bin_index1 = np.argmin(np.abs(np.array(bins) - value1)) |
|
bin_index2 = np.argmin(np.abs(np.array(bins) - value2)) |
|
|
|
if parameter_name == "osc_types": |
|
if bin_index1 == bin_index2: |
|
d = 0 |
|
else: |
|
d = 1 |
|
else: |
|
d = np.abs(bin_index1 - bin_index2) / (len(bins) - 1) |
|
md.append(d) |
|
|
|
return np.average(md) |
|
|
|
|
|
def generate_dataset_for_mixed_input_model(n: int, |
|
path_name="./data/data_mixed_input", |
|
sample_rate=16384, |
|
n_samples_for_note=16384 * 4, |
|
n_samples_for_melody=16384 * 4 |
|
): |
|
""" |
|
Generate dataset of size n for mixed_input_model model |
|
|
|
:param n: Int |
|
:param path_name: String--path to save the dataset |
|
:param sample_rate: Int |
|
:param n_samples_for_note: Int |
|
:param n_samples_for_melody: Int |
|
:return: |
|
""" |
|
|
|
shutil.rmtree(path_name) |
|
Path(path_name).mkdir(parents=True, exist_ok=True) |
|
print("Generating dataset...") |
|
synth = MelodyGenerator(sample_rate, |
|
n_samples_for_note, n_samples_for_melody) |
|
randomMidi = RandomMidi() |
|
|
|
strategy = {"rhythm_strategy": "free_rhythm", |
|
"pitch_strategy": "free_pitch", |
|
"duration_strategy": "random_duration", |
|
} |
|
strategy0 = {"rhythm_strategy": "single_note_rhythm", |
|
"pitch_strategy": "fixed_pitch", |
|
"duration_strategy": "fixed_duration", |
|
} |
|
strategy1 = {"rhythm_strategy": "single_note_rhythm", |
|
"pitch_strategy": "fixed_pitch1", |
|
"duration_strategy": "fixed_duration", |
|
} |
|
strategy2 = {"rhythm_strategy": "single_note_rhythm", |
|
"pitch_strategy": "fixed_pitch2", |
|
"duration_strategy": "fixed_duration", |
|
} |
|
strategy3 = {"rhythm_strategy": "single_note_rhythm", |
|
"pitch_strategy": "fixed_pitch3", |
|
"duration_strategy": "fixed_duration", |
|
} |
|
strategy4 = {"rhythm_strategy": "single_note_rhythm", |
|
"pitch_strategy": "fixed_pitch4", |
|
"duration_strategy": "fixed_duration", |
|
} |
|
|
|
np.random.seed() |
|
for i in tqdm(range(n)): |
|
path = path_name + f"/{i}" |
|
Path(path).mkdir(parents=True, exist_ok=True) |
|
parameter_values = [param.generate() for param in param_descriptions] |
|
parameter_values_raw = {param.name: param.value for param in parameter_values} |
|
|
|
|
|
midi_encode, midi = randomMidi(strategy) |
|
signal_query = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
write(path + f"/{i}.wav", synth.sample_rate, signal_query) |
|
|
|
|
|
if np.random.rand() < 0.01: |
|
with open(path + "/label.json", "w") as label_file: |
|
sample = Sample(parameter_values) |
|
label = sample.get_values() |
|
label['manhattan_distance'] = 0. |
|
json.dump(label, label_file, ensure_ascii=False) |
|
else: |
|
with open(path + "/label.json", "w") as label_file: |
|
query_sp = parameter_values_raw |
|
parameter_values = [param.generate() for param in param_descriptions] |
|
parameter_values_raw = {param.name: param.value for param in parameter_values} |
|
sample = Sample(parameter_values) |
|
label = sample.get_values() |
|
md = manhattan_distance(query_sp, parameter_values_raw) |
|
label['manhattan_distance'] = md |
|
json.dump(label, label_file, ensure_ascii=False) |
|
|
|
|
|
midi_encode, midi = randomMidi(strategy0) |
|
signal_single_note = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
write(path + f"/{i}_0.wav", synth.sample_rate, signal_single_note) |
|
|
|
|
|
|
|
midi_encode, midi = randomMidi(strategy1) |
|
signal_single_note = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
write(path + f"/{i}_1.wav", synth.sample_rate, signal_single_note) |
|
|
|
|
|
|
|
midi_encode, midi = randomMidi(strategy2) |
|
signal_single_note = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
write(path + f"/{i}_2.wav", synth.sample_rate, signal_single_note) |
|
|
|
|
|
|
|
midi_encode, midi = randomMidi(strategy3) |
|
signal_single_note = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
write(path + f"/{i}_3.wav", synth.sample_rate, signal_single_note) |
|
|
|
|
|
|
|
midi_encode, midi = randomMidi(strategy4) |
|
signal_single_note = synth.get_melody(parameter_values_raw, midi=midi).numpy() |
|
write(path + f"/{i}_4.wav", synth.sample_rate, signal_single_note) |
|
|
|
|
|
print('Data generation done!') |
|
|