def block_dataloader(self, batch_size):
"""
:return: torch Dataloader, returns batches of
(batch_size, num_blocks=1, num_tokens_per_block)
}
"""
dataset_manager = DatasetManager()
num_tokens_per_beat = subdivision * num_voices
# Positive dataset
num_beats = self.num_tokens_per_block // num_tokens_per_beat
chorale_dataset_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats,
'subdivision': subdivision,
}
dataset: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats', **chorale_dataset_kwargs)
return [
(
{
'x': t[0]
} # discard metadata
for t in dataloader)
for dataloader in dataset.data_loaders(batch_size)
]
def main(note_embedding_dim, metadata_embedding_dim, num_layers,
lstm_hidden_size, dropout_lstm, input_dropout, linear_hidden_size,
batch_size, num_epochs, train, log, lr, plot, teacher_forcing,
early_stop):
# init dataset
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
folk_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_test_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': False
}
folk_dataset: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_train_kwargs)
folk_dataset_test: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_test_kwargs)
model = ConstraintModelGaussianReg(
dataset=folk_dataset,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
teacher_forcing=teacher_forcing)
if train:
if torch.cuda.is_available():
model.cuda()
trainer = AnticipationRNNGaussianRegTrainer(dataset=folk_dataset,
model=model,
lr=lr,
early_stopping=early_stop)
trainer.train_model(batch_size=batch_size,
num_epochs=num_epochs,
plot=plot,
log=log)
else:
model.load()
model.cuda()
tester = AnticipationRNNTester(dataset=folk_dataset_test, model=model)
tester.test_model(batch_size=512)
def main(note_embedding_dim, metadata_embedding_dim, num_encoder_layers,
encoder_hidden_size, encoder_dropout_prob, latent_space_dim,
num_decoder_layers, decoder_hidden_size, decoder_dropout_prob,
has_metadata, batch_size, num_epochs, train, plot, log, lr):
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
mvae_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
mvae_test_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': False
}
folk_dataset: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **mvae_train_kwargs)
folk_dataset_test: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **mvae_test_kwargs)
model = MeasureVAE(dataset=folk_dataset,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_encoder_layers=num_encoder_layers,
encoder_hidden_size=encoder_hidden_size,
encoder_dropout_prob=encoder_dropout_prob,
latent_space_dim=latent_space_dim,
num_decoder_layers=num_decoder_layers,
decoder_hidden_size=decoder_hidden_size,
decoder_dropout_prob=decoder_dropout_prob,
has_metadata=has_metadata)
if train:
if torch.cuda.is_available():
model.cuda()
trainer = VAETrainer(dataset=folk_dataset, model=model, lr=lr)
trainer.train_model(batch_size=batch_size,
num_epochs=num_epochs,
plot=plot,
log=log)
else:
model.load()
model.cuda()
model.eval()
tester = VAETester(dataset=folk_dataset_test, model=model)
tester.test_model()
def main(note_embedding_dim,
meta_embedding_dim,
num_layers,
lstm_hidden_size,
dropout_lstm,
linear_hidden_size,
batch_size,
num_epochs,
train,
num_iterations,
sequence_length_ticks):
dataset_manager = DatasetManager()
metadatas = [
FermataMetadata(),
TickMetadata(subdivision=4),
KeyMetadata()
]
chorale_dataset_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': 8,
'subdivision': 4
}
bach_chorales_dataset = dataset_manager.get_dataset(
name='bach_chorales',
**chorale_dataset_kwargs
)
dataset = bach_chorales_dataset
deepbach = DeepBach(
dataset=dataset,
note_embedding_dim=note_embedding_dim,
meta_embedding_dim=meta_embedding_dim,
num_layers=num_layers,
lstm_hidden_size=lstm_hidden_size,
dropout_lstm=dropout_lstm,
linear_hidden_size=linear_hidden_size
)
if train:
deepbach.train(batch_size=batch_size,
num_epochs=num_epochs)
else:
deepbach.load()
deepbach.cuda()
print('Generation')
score, tensor_chorale, tensor_metadata = deepbach.generation(
num_iterations=num_iterations,
length=sequence_length_ticks,
)
score.write('midi', fp = 'test.mid')
def main(
note_embedding_dim,
meta_embedding_dim,
num_layers,
lstm_hidden_size,
dropout_lstm,
input_dropout,
linear_hidden_size,
batch_size,
num_epochs,
train,
no_metadata,
):
metadatas = [
TickMetadata(subdivision=4),
]
dataset_manager = DatasetManager()
chorale_dataset_kwargs = {
'voice_ids': [0],
'metadatas': metadatas,
'sequences_size': 20,
'subdivision': 4
}
bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name='bach_chorales', **chorale_dataset_kwargs)
model = AnticipationRNN(
chorale_dataset=bach_chorales_dataset,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=meta_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
no_metadata=no_metadata,
)
if train:
model.cuda()
model.train_model(batch_size=batch_size, num_epochs=num_epochs)
else:
model.load()
model.cuda()
print('Fill')
score, _, _ = model.fill(C3)
score.show()
def init_app(note_embedding_dim, meta_embedding_dim, num_layers,
lstm_hidden_size, dropout_lstm, linear_hidden_size,
num_iterations, sequence_length_ticks, ticks_per_quarter, port):
global metadatas
global _sequence_length_ticks
global _num_iterations
global _ticks_per_quarter
global bach_chorales_dataset
_ticks_per_quarter = ticks_per_quarter
_sequence_length_ticks = sequence_length_ticks
_num_iterations = num_iterations
dataset_manager = DatasetManager()
chorale_dataset_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': 8,
'subdivision': 4
}
_bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name='bach_chorales', **chorale_dataset_kwargs)
bach_chorales_dataset = _bach_chorales_dataset
assert sequence_length_ticks % bach_chorales_dataset.subdivision == 0
global deepbach
deepbach = DeepBach(dataset=bach_chorales_dataset,
note_embedding_dim=note_embedding_dim,
meta_embedding_dim=meta_embedding_dim,
num_layers=num_layers,
lstm_hidden_size=lstm_hidden_size,
dropout_lstm=dropout_lstm,
linear_hidden_size=linear_hidden_size)
deepbach.load()
deepbach.cuda()
# launch the script
# use threaded=True to fix Chrome/Chromium engine hanging on requests
# [https://stackoverflow.com/a/30670626]
local_only = False
if local_only:
# accessible only locally:
app.run(threaded=True)
else:
# accessible from outside:
app.run(host='0.0.0.0', port=port, threaded=True)
def main(include_transpositions):
dataset_manager = DatasetManager()
print('step 1/3: prepare dataset')
metadatas = [FermataMetadata(), TickMetadata(subdivision=4), KeyMetadata()]
chorale_dataset_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': 8,
'subdivision': 4,
'include_transpositions': include_transpositions,
}
bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name='bach_chorales', **chorale_dataset_kwargs)
dataset = bach_chorales_dataset
get_pairs(dataset, model_ids=[5, 9])
def setup(self):
"""Load the model"""
# music21.environment.set("musicxmlPath", "/bin/true")
note_embedding_dim = 20
meta_embedding_dim = 20
num_layers = 2
lstm_hidden_size = 256
dropout_lstm = 0.5
linear_hidden_size = 256
batch_size = 256
num_epochs = 5
train = False
num_iterations = 500
sequence_length_ticks = 64
dataset_manager = DatasetManager()
metadatas = [FermataMetadata(), TickMetadata(subdivision=4), KeyMetadata()]
chorale_dataset_kwargs = {
"voice_ids": [0, 1, 2, 3],
"metadatas": metadatas,
"sequences_size": 8,
"subdivision": 4,
}
bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name="bach_chorales", **chorale_dataset_kwargs
)
dataset = bach_chorales_dataset
self.deepbach = DeepBach(
dataset=dataset,
note_embedding_dim=note_embedding_dim,
meta_embedding_dim=meta_embedding_dim,
num_layers=num_layers,
lstm_hidden_size=lstm_hidden_size,
dropout_lstm=dropout_lstm,
linear_hidden_size=linear_hidden_size,
)
self.deepbach.load()
# load fluidsynth fo rmidi 2 audio conversion
self.fs = FluidSynth()
def init_app(
note_embedding_dim,
meta_embedding_dim,
num_layers,
lstm_hidden_size,
dropout_lstm,
input_dropout,
linear_hidden_size,
):
metadatas = [
TickMetadata(subdivision=4),
]
dataset_manager = DatasetManager()
chorale_dataset_kwargs = {
'voice_ids': [0],
'metadatas': metadatas,
'sequences_size': 20,
'subdivision': 4
}
bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name='bach_chorales', **chorale_dataset_kwargs)
global model
model = AnticipationRNN(
chorale_dataset=bach_chorales_dataset,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=meta_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
)
model.load()
model.cuda()
# launch the script
# accessible only locally:
app.run()
def _dataset(self):
if self.negative_sampling_method == 'random':
dataset_manager = DatasetManager()
self.cache_dir = dataset_manager.cache_dir
num_tokens_per_beat = subdivision * num_voices
num_tokens = self.num_tokens_per_block * (self.num_blocks_left +
self.num_blocks_right)
assert num_tokens % num_tokens_per_beat == 0
# Positive dataset
num_beats_positive = num_tokens // num_tokens_per_beat
chorale_dataset_positive_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats_positive,
'subdivision': subdivision,
}
dataset_positive: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats_test',
**chorale_dataset_positive_kwargs)
num_tokens_per_beat = subdivision * num_voices
num_beats_negative = self.num_tokens_per_block // num_tokens_per_beat
chorale_dataset_negative_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats_negative,
'subdivision': subdivision,
}
dataset_negative: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats_test',
**chorale_dataset_negative_kwargs)
return dataset_positive, dataset_negative
else:
raise NotImplementedError
for chord_root_index, chord_name_index \
in zip(tensor_chords_root_np,
tensor_chords_name_np
):
chord_root_index = chord_root_index.item()
chord_name_index = chord_name_index.item()
chord_desc = index2chordroot[chord_root_index] + \
index2chordname[chord_name_index]
chord_list.append(chord_desc)
return score, chord_list
if __name__ == '__main__':
from DatasetManager.dataset_manager import DatasetManager
dataset_manager = DatasetManager()
leadsheet_dataset_kwargs = {
'sequences_size': 64,
}
lsdb_dataset: LsdbDataset = dataset_manager.get_dataset(
name='lsdb_test', **leadsheet_dataset_kwargs)
dl, _, _ = lsdb_dataset.data_loaders(1)
tensor_lead, tensor_chord_root, tensor_chord_name = next(dl.__iter__())
print(tensor_lead[0].size(), tensor_chord_root[0].size(),
tensor_chord_name[0].size())
tensor_chord = (tensor_chord_root[0], tensor_chord_name[0])
score, chord_list = lsdb_dataset.tensor_leadsheet_to_score_and_chord_list(
tensor_lead[0], tensor_chord)
score.show()
print(chord_list)
metadata_tensor_dataset = torch.cat(metadata_tensor_dataset, 0)
num_datapoints, length, num_metadata = metadata_tensor_dataset.size()
metadata_tensor_dataset = metadata_tensor_dataset.view(
num_datapoints, 1, length, num_metadata)
dataset = TensorDataset(score_tensor_dataset, metadata_tensor_dataset)
print(f'Sizes: {score_tensor_dataset.size()}')
print(f'Sizes: {metadata_tensor_dataset.size()}')
return dataset
if __name__ == '__main__':
from DatasetManager.dataset_manager import DatasetManager
from DatasetManager.metadata import BeatMarkerMetadata, TickMetadata
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
folk_dataset_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 1,
'train': True
}
folk_dataset: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_chords', **folk_dataset_kwargs)
(train_dataloader, val_dataloader,
test_dataloader) = folk_dataset.data_loaders(batch_size=100,
split=(0.7, 0.2))
def _dataset(self):
"""
Loads the appropriate dataset depending on the sampling method
:return: ChoraleDataset or tuple(ChoraleDataset)
"""
dataset_manager = DatasetManager()
self.cache_dir = dataset_manager.cache_dir
if self.negative_sampling_method == 'random_bad':
num_tokens_per_beat = subdivision * num_voices
num_tokens = self.num_tokens_per_block * (self.num_blocks_left +
self.num_blocks_right)
assert num_tokens % num_tokens_per_beat == 0
# Positive dataset
num_beats_positive = num_tokens // num_tokens_per_beat
chorale_dataset_positive_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats_positive,
'subdivision': subdivision,
}
dataset: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats', **chorale_dataset_positive_kwargs)
return dataset
elif self.negative_sampling_method == 'same_sequence':
# FIXME for the moment, exactly the same as 'random' _dataset
dataset_manager = DatasetManager()
num_tokens_per_beat = subdivision * num_voices
num_tokens = self.num_tokens_per_block * (self.num_blocks_left +
self.num_blocks_right)
assert num_tokens % num_tokens_per_beat == 0
# Positive dataset
num_beats_positive = num_tokens // num_tokens_per_beat
chorale_dataset_positive_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats_positive,
'subdivision': subdivision,
}
dataset: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats', **chorale_dataset_positive_kwargs)
return dataset
if self.negative_sampling_method == 'random':
dataset_manager = DatasetManager()
num_tokens_per_beat = subdivision * num_voices
num_tokens = self.num_tokens_per_block * (self.num_blocks_left +
self.num_blocks_right)
assert num_tokens % num_tokens_per_beat == 0
# Positive dataset
num_beats_positive = num_tokens // num_tokens_per_beat
chorale_dataset_positive_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats_positive,
'subdivision': subdivision,
}
dataset_positive: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats', **chorale_dataset_positive_kwargs)
num_tokens_per_beat = subdivision * num_voices
num_beats_negative = self.num_tokens_per_block // num_tokens_per_beat
chorale_dataset_negative_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': num_beats_negative,
'subdivision': subdivision,
}
dataset_negative: ChoraleBeatsDataset = dataset_manager.get_dataset(
name='bach_chorales_beats', **chorale_dataset_negative_kwargs)
return dataset_positive, dataset_negative
else:
raise NotImplementedError
def main(block_attention, hierarchical, nade, num_layers, dropout,
input_dropout, input_dropout_token, per_head_dim, num_heads,
local_position_embedding_dim, position_ff_dim, enc_dec_conditioning,
lr, batch_size, num_epochs, action, loss_on_last_frame, mixup,
midi_input, temperature, num_batches, label_smoothing,
scheduled_training, dataset_type, conditioning, double_conditioning,
instrument_presence_in_encoder, cpc_config_name, num_examples_sampled,
suffix, subdivision, sequence_size, velocity_quantization,
max_transposition, group_instrument_per_section):
# Use all gpus available
gpu_ids = [int(gpu) for gpu in range(torch.cuda.device_count())]
print(gpu_ids)
config = get_config()
num_layers_l = [2, 3, 4, 5, 6]
enc_dec_conditionings_l = ['split', 'single']
sequence_sizes_l = [3, 5, 7]
grid_search = False
if grid_search:
configs = list(
itertools.product(
*[num_layers_l, enc_dec_conditionings_l, sequence_sizes_l]))
write_suffix = True
else:
configs = [(num_layers, enc_dec_conditioning, sequence_size)]
write_suffix = False
for this_config in configs:
num_layers, enc_dec_conditioning, sequence_size = this_config
if write_suffix:
this_suffix = f'{suffix}_{num_layers}_{enc_dec_conditioning}_{sequence_size}'
else:
this_suffix = suffix
# Get dataset
dataset_manager = DatasetManager()
dataset, processor_decoder, processor_encoder, processor_encodencoder = \
dataset_import.get_dataset(dataset_manager, dataset_type, subdivision, sequence_size, velocity_quantization,
max_transposition,
num_heads, per_head_dim, local_position_embedding_dim, block_attention,
group_instrument_per_section, nade, cpc_config_name, double_conditioning,
instrument_presence_in_encoder)
reduction_flag = dataset_type in [
'reduction', 'reduction_small', 'reduction_large',
'reduction_categorical', 'reduction_categorical_small',
'reduction_midiPiano', 'reduction_midiPiano_small'
]
if not conditioning:
print("NO CONDITIONING ????!!!!!!!!!!!!")
model = Transformer(dataset=dataset,
data_processor_encodencoder=processor_encodencoder,
data_processor_encoder=processor_encoder,
data_processor_decoder=processor_decoder,
num_heads=num_heads,
per_head_dim=per_head_dim,
position_ff_dim=position_ff_dim,
enc_dec_conditioning=enc_dec_conditioning,
hierarchical_encoding=hierarchical,
block_attention=block_attention,
nade=nade,
conditioning=conditioning,
double_conditioning=double_conditioning,
num_layers=num_layers,
dropout=dropout,
input_dropout=input_dropout,
input_dropout_token=input_dropout_token,
lr=lr,
reduction_flag=reduction_flag,
gpu_ids=gpu_ids,
suffix=this_suffix,
mixup=mixup,
scheduled_training=scheduled_training)
if action in ['generate', 'visualize']:
model.load()
overfit_flag = False
elif action in [
'generate_overfit', 'train_from_checkpoint',
'visualize_overfit'
]:
model.load_overfit()
overfit_flag = True
model.cuda()
if action in ['train', 'train_from_checkpoint']:
print(f"Train the model on gpus {gpu_ids}")
model.train_model(cache_dir=dataset_manager.cache_dir,
batch_size=batch_size,
num_epochs=num_epochs,
num_batches=num_batches,
label_smoothing=label_smoothing,
loss_on_last_frame=loss_on_last_frame)
overfit_flag = True
if action in ['generate', 'generate_overfit']:
print('Generation')
ascii_melody = MARIO_MELODY
# score, tensor_chorale, tensor_metadata = mode.generation_from_ascii(
# ascii_melody=ascii_melody
# )
# score.show()
# score, tensor_chorale, tensor_metadata = model.generation(
# num_tokens_per_beat=8,
# num_beats=64 * 4,
# temperature=1.
# )
# score, tensor_chorale, tensor_metadata = model.generation(
# num_tokens_per_beat=8,
# num_beats=64 * 4,
# num_experiments=4,
# link_experiments=False,
# temperature=1.2
# )
# score, tensor_chorale, tensor_metadata = model.plot_attentions()
# score, tensor_chorale, tensor_metadata = model.unconstrained_generation(
# num_tokens_per_beat=8,
# num_beats=64 * 4)
if dataset_type in [
'arrangement', 'arrangement_small',
'arrangement_midiPiano', 'arrangement_midiPiano_small',
'arrangement_voice', 'arrangement_voice_small'
]:
# (oppposite to standard) increasing temperature reduce agitation
# Cold means all event will eventually have almost same proba
# Hot accentuates spikes
# Number of complete pass over all time frames in, non auto-regressive sampling schemes
number_sampling_steps = 1
# Allows to override dataset quantization for generation
subdivision_generation = subdivision
# banned_instruments = ["Violin_1", "Violin_2", "Violoncello", "Contrabass", "Viola"]
banned_instruments = []
# Used for instruments_presence model
unknown_instruments = []
source_folder = f"{config['datapath']}/source_for_generation/"
sources = [
{
"source_path":
source_folder + "mouss_tableaux_small.xml",
"writing_name": "mouss_tableaux_small",
"writing_tempo": "adagio",
},
# {"source_path": source_folder + "guillaume_1.mid",
# "writing_name": "guillaume_1",
# "writing_tempo": "adagio"
# },
# {"source_path": source_folder + "guillaume_2.xml",
# "writing_name": "guillaume_2",
# "writing_tempo": "adagio"
# },
{
"source_path":
source_folder + "chopin_Prel_Op28_20.xml",
"writing_name": "chopin_Prel_Op28_20",
"writing_tempo": "largo"
},
{
"source_path": source_folder + "b_1_1.xml",
"writing_name": "b_1_1",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "b_3_3.xml",
"writing_name": "b_3_3",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "b_3_4.xml",
"writing_name": "b_3_4",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "b_7_2.xml",
"writing_name": "b_7_2",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "testpiano.xml",
"writing_name": "testpiano",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "schubert_21_1.xml",
"writing_name": "schubert_21_1",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "schubert_20_1.xml",
"writing_name": "schubert_20_1",
"writing_tempo": "adagio"
},
{
"source_path": source_folder + "Mozart_Nachtmusik.xml",
"writing_name": "Mozart_Nachtmusik",
"writing_tempo": "adagio"
},
]
if overfit_flag:
write_dir = model.log_dir_overfitted
else:
write_dir = model.log_dir
if midi_input is not None:
sources = [{
'source_path': f'midi_inputs/{midi_input}',
'writing_name': f'{midi_input}',
'writing_tempo': 'adagio'
}]
write_dir = 'midi_inputs'
for source in sources:
generation_from_file(
model=model,
temperature=temperature,
batch_size=num_examples_sampled,
filepath=source["source_path"],
write_dir=write_dir,
write_name=source["writing_name"],
banned_instruments=banned_instruments,
unknown_instruments=unknown_instruments,
writing_tempo=source["writing_tempo"],
subdivision=subdivision_generation,
number_sampling_steps=number_sampling_steps)
elif dataset_type in [
'reduction', 'reduction_large', 'reduction_small',
'reduction_categorical', 'reduction_categorical_small'
]:
# Allows to override dataset quantization for generation
subdivision_generation = 8
source_folder = f"{config['datapath']}/source_for_generation/"
sources = [
{
"source_path": source_folder + "b_7_2_orch.xml",
"writing_name": "b_7_2_orch",
"writing_tempo": "adagio"
},
# {"source_path": source_folder + "mouss_tableaux_orch.xml",
# "writing_name": "mouss_tableaux_orch",
# "writing_tempo": "adagio"
# },
# {"source_path": source_folder + "Debussy_SuiteBergam_Passepied_orch.xml",
# "writing_name": "Debussy_SuiteBergam_Passepied_orch",
# "writing_tempo": "adagio"
# },
# {
# "source_path": source_folder + "Romantic Concert Piece for Brass Orchestra_orch.xml",
# "writing_name": "Romantic Concert Piece for Brass Orchestra_orch",
# "writing_tempo": "adagio"
# },
# {
# "source_path": source_folder + "mozart_25_1.xml",
# "writing_name": "mozart_25_1",
# "writing_tempo": "adagio"
# },
# {
# "source_path": source_folder + "mozart_25_2.xml",
# "writing_name": "mozart_25_2",
# "writing_tempo": "adagio"
# },
# {
# "source_path": source_folder + "mozart_25_3.xml",
# "writing_name": "mozart_25_3",
# "writing_tempo": "adagio"
# },
{
"source_path":
source_folder + "brahms_symphony_2_1.xml",
"writing_name": "brahms_symphony_2_1",
"writing_tempo": "adagio"
},
{
"source_path":
source_folder + "haydn_symphony_91_1.xml",
"writing_name": "haydn_symphony_91_1",
"writing_tempo": "adagio"
},
{
"source_path":
source_folder + "mozart_symphony_183_4.xml",
"writing_name": "mozart_symphony_183_4",
"writing_tempo": "adagio"
},
{
"source_path":
source_folder + "mozart_symphony_183_2.xml",
"writing_name": "mozart_symphony_183_2",
"writing_tempo": "adagio"
},
]
for source in sources:
reduction_from_file(model=model,
temperature=temperature,
batch_size=num_examples_sampled,
filepath=source["source_path"],
write_name=source["writing_name"],
overfit_flag=overfit_flag,
writing_tempo=source["writing_tempo"],
subdivision=subdivision_generation)
elif dataset_type == "lsdb":
score, tensor_chorale, tensor_metadata = model.generation()
score.write('xml', 'results/test.xml')
elif dataset_type in ['bach', 'bach_small']:
if nade and (not conditioning):
scores = generation_bach_nade(
model=model,
temperature=temperature,
ascii_melody=ascii_melody,
batch_size=num_examples_sampled,
force_melody=False,
)
else:
scores = generation_bach(model=model,
temperature=temperature,
ascii_melody=ascii_melody,
batch_size=num_examples_sampled,
force_melody=False)
if overfit_flag:
writing_dir = model.log_dir_overfitted
else:
writing_dir = model.log_dir
for batch_index, score in enumerate(scores):
score.write('xml', f'{writing_dir}/{batch_index}.xml')
elif action in ['visualize', 'visualize_overfit']:
log_dir = model.log_dir if action == 'visualize' else model.log_dir_overfitted
visualize_arrangement(model, batch_size, log_dir)
return
def main(note_embedding_dim, metadata_embedding_dim, num_encoder_layers,
encoder_hidden_size, encoder_dropout_prob, latent_space_dim,
num_decoder_layers, decoder_hidden_size, decoder_dropout_prob,
has_metadata, num_latent_rnn_layers, latent_rnn_hidden_size,
latent_rnn_dropout_prob, num_layers, lstm_hidden_size, dropout_lstm,
input_dropout, linear_hidden_size, batch_size, num_target,
num_models):
# init dataset
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
mvae_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_dataset_vae: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **mvae_train_kwargs)
# init vae model
vae_model = MeasureVAE(dataset=folk_dataset_vae,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_encoder_layers=num_encoder_layers,
encoder_hidden_size=encoder_hidden_size,
encoder_dropout_prob=encoder_dropout_prob,
latent_space_dim=latent_space_dim,
num_decoder_layers=num_decoder_layers,
decoder_hidden_size=decoder_hidden_size,
decoder_dropout_prob=decoder_dropout_prob,
has_metadata=has_metadata)
vae_model.load() # VAE model must be pre-trained
if torch.cuda.is_available():
vae_model.cuda()
folk_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_test_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': False
}
folk_dataset_train: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_train_kwargs)
folk_dataset_test: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_test_kwargs)
# init latent_rnn model and latent_rnn_tester
latent_rnn_model = LatentRNN(dataset=folk_dataset_train,
vae_model=vae_model,
num_rnn_layers=num_latent_rnn_layers,
rnn_hidden_size=latent_rnn_hidden_size,
dropout=latent_rnn_dropout_prob,
rnn_class=torch.nn.GRU,
auto_reg=False,
teacher_forcing=True)
latent_rnn_model.load() # latent_rnn model must be pre-trained
if torch.cuda.is_available():
latent_rnn_model.cuda()
latent_rnn_tester = LatentRNNTester(dataset=folk_dataset_test,
model=latent_rnn_model)
# inti arnn model and arnn_testes
arnn_model = ConstraintModelGaussianReg(
dataset=folk_dataset_train,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
teacher_forcing=True)
arnn_model.load() # ARNN model must be pre-trained
if torch.cuda.is_available():
arnn_model.cuda()
arnn_tester = AnticipationRNNTester(dataset=folk_dataset_test,
model=arnn_model)
arnn_baseline_model = AnticipationRNNBaseline(
dataset=folk_dataset_train,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
teacher_forcing=True)
arnn_baseline_model.load() # ARNN model must be pre-trained
if torch.cuda.is_available():
arnn_baseline_model.cuda()
arnn_baseline_tester = AnticipationRNNTester(dataset=folk_dataset_test,
model=arnn_baseline_model)
# create test dataloader
(_, _,
test_dataloader) = folk_dataset_test.data_loaders(batch_size=batch_size,
split=(0.01, 0.01))
# test
print('Num Test Batches: ', len(test_dataloader))
latent_rnn_mean_loss, latent_rnn_mean_accuracy, \
arnn_mean_loss, arnn_mean_accuracy, \
arnn_baseline_mean_loss, arnn_baseline_mean_accuracy = loss_and_acc_test(
data_loader=test_dataloader,
latent_rnn_tester=latent_rnn_tester,
arnn_tester=arnn_tester,
arnn_baseline_tester=arnn_baseline_tester,
num_target_measures=num_target,
num_models=num_models
)
print('Test Epoch:')
print('latent_rnn Test Loss: ', latent_rnn_mean_loss, '\n'
'latent_rnn Test Accuracy: ', latent_rnn_mean_accuracy * 100, '\n'
'ARNN Test Loss: ', arnn_mean_loss, '\n'
'ARNN Test Accuracy: ', arnn_mean_accuracy * 100, '\n'
'ARNN Baseline Test Loss: ', arnn_baseline_mean_loss, '\n'
'ARNN Baseline Test Accuracy: ', arnn_baseline_mean_accuracy * 100,
'\n')
def main(note_embedding_dim, metadata_embedding_dim, num_encoder_layers,
encoder_hidden_size, encoder_dropout_prob, latent_space_dim,
num_decoder_layers, decoder_hidden_size, decoder_dropout_prob,
has_metadata, num_latent_rnn_layers, latent_rnn_hidden_size,
latent_rnn_dropout_prob, num_layers, lstm_hidden_size, dropout_lstm,
input_dropout, linear_hidden_size, batch_size, num_target,
num_models):
random.seed(0)
# init dataset
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
mvae_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_dataset_vae: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **mvae_train_kwargs)
# init vae model
vae_model = MeasureVAE(dataset=folk_dataset_vae,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_encoder_layers=num_encoder_layers,
encoder_hidden_size=encoder_hidden_size,
encoder_dropout_prob=encoder_dropout_prob,
latent_space_dim=latent_space_dim,
num_decoder_layers=num_decoder_layers,
decoder_hidden_size=decoder_hidden_size,
decoder_dropout_prob=decoder_dropout_prob,
has_metadata=has_metadata)
vae_model.load() # VAE model must be pre-trained
if torch.cuda.is_available():
vae_model.cuda()
folk_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_test_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': False
}
folk_dataset_train: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_train_kwargs)
folk_dataset_test: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_test_kwargs)
# Initialize stuff
test_filenames = folk_dataset_test.dataset_filenames
num_melodies = 32
num_measures = 16
req_length = num_measures * 4 * 6
num_past = 6
num_future = 6
num_target = 4
cur_dir = os.path.dirname(os.path.realpath(__file__))
save_folder = 'saved_midi/'
# First save original data
for i in tqdm(range(num_melodies)):
f = test_filenames[i]
f_id = f[:-4]
# save original scores
save_filename = os.path.join(cur_dir,
save_folder + f_id + '_original.mid')
if os.path.isfile(save_filename):
continue
f = os.path.join(folk_dataset_test.corpus_it_gen.raw_dataset_dir, f)
score = folk_dataset_test.corpus_it_gen.get_score_from_path(
f, fix_and_expand=True)
score_tensor = folk_dataset_test.get_score_tensor(score)
metadata_tensor = folk_dataset_test.get_metadata_tensor(score)
# ignore scores with less than 16 measures
if score_tensor.size(1) < req_length:
continue
score_tensor = score_tensor[:, :req_length]
metadata_tensor = metadata_tensor[:, :req_length, :]
trunc_score = folk_dataset_test.tensor_to_score(score_tensor)
trunc_score.write('midi', fp=save_filename)
# Initialize models and testers
latent_rnn_model = LatentRNN(dataset=folk_dataset_train,
vae_model=vae_model,
num_rnn_layers=num_latent_rnn_layers,
rnn_hidden_size=latent_rnn_hidden_size,
dropout=latent_rnn_dropout_prob,
rnn_class=torch.nn.GRU,
auto_reg=False,
teacher_forcing=True)
latent_rnn_model.load() # Latent RNN model must be pre-trained
if torch.cuda.is_available():
latent_rnn_model.cuda()
latent_rnn_tester = LatentRNNTester(dataset=folk_dataset_test,
model=latent_rnn_model)
def process_latent_rnn_batch(score_tensor,
num_past=6,
num_future=6,
num_target=4):
assert (num_past + num_future + num_target == 16)
score_tensor = score_tensor.unsqueeze(0)
score_tensor = LatentRNNTrainer.split_to_measures(score_tensor, 24)
tensor_past, tensor_future, tensor_target = LatentRNNTrainer.split_score(
score_tensor=score_tensor,
num_past=num_past,
num_future=num_future,
num_target=num_target,
measure_seq_len=24)
return tensor_past, tensor_future, tensor_target
# Second save latent_rnn generations
for i in tqdm(range(num_melodies)):
f = test_filenames[i]
f_id = f[:-4]
save_filename = os.path.join(cur_dir,
save_folder + f_id + '_latent_rnn.mid')
if os.path.isfile(save_filename):
continue
f = os.path.join(folk_dataset_test.corpus_it_gen.raw_dataset_dir, f)
score = folk_dataset_test.corpus_it_gen.get_score_from_path(
f, fix_and_expand=True)
score_tensor = folk_dataset_test.get_score_tensor(score)
# metadata_tensor = folk_dataset_test.get_metadata_tensor(score)
# ignore scores with less than 16 measures
if score_tensor.size(1) < req_length:
continue
score_tensor = score_tensor[:, :req_length]
# metadata_tensor = metadata_tensor[:, :req_length, :]
# save regeneration using latent_rnn
tensor_past, tensor_future, tensor_target = process_latent_rnn_batch(
score_tensor, num_past, num_future, num_target)
# forward pass through latent_rnn
weights, gen_target, _ = latent_rnn_tester.model(
past_context=tensor_past,
future_context=tensor_future,
target=tensor_target,
measures_to_generate=num_target,
train=False,
)
# convert to score
batch_size, _, _ = gen_target.size()
gen_target = gen_target.view(batch_size, num_target, 24)
gen_score_tensor = torch.cat((tensor_past, gen_target, tensor_future),
1)
latent_rnn_score = folk_dataset_test.tensor_to_score(
gen_score_tensor.cpu())
latent_rnn_score.write('midi', fp=save_filename)
# Intialize arnn model and arnn_tester
arnn_model = ConstraintModelGaussianReg(
dataset=folk_dataset_train,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
teacher_forcing=True)
arnn_model.load() # ARNN model must be pre-trained
if torch.cuda.is_available():
arnn_model.cuda()
arnn_tester = AnticipationRNNTester(dataset=folk_dataset_test,
model=arnn_model)
def process_arnn_batch(score_tensor,
metadata_tensor,
arnn_tester,
num_past=6,
num_target=4):
score_tensor = score_tensor.unsqueeze(0)
metadata_tensor = metadata_tensor.unsqueeze(0)
tensor_score = to_cuda_variable_long(score_tensor)
tensor_metadata = to_cuda_variable_long(metadata_tensor)
constraints_location, start_tick, end_tick = arnn_tester.get_constraints_location(
tensor_score,
is_stochastic=False,
start_measure=num_past,
num_measures=num_target)
arnn_batch = (tensor_score, tensor_metadata, constraints_location,
start_tick, end_tick)
return arnn_batch
# Third save ARNN-Reg generations
for i in tqdm(range(num_melodies)):
f = test_filenames[i]
f_id = f[:-4]
save_filename = os.path.join(cur_dir,
save_folder + f_id + '_arnn_reg.mid')
if os.path.isfile(save_filename):
continue
f = os.path.join(folk_dataset_test.corpus_it_gen.raw_dataset_dir, f)
score = folk_dataset_test.corpus_it_gen.get_score_from_path(
f, fix_and_expand=True)
score_tensor = folk_dataset_test.get_score_tensor(score)
metadata_tensor = folk_dataset_test.get_metadata_tensor(score)
# ignore scores with less than 16 measures
if score_tensor.size(1) < req_length:
continue
score_tensor = score_tensor[:, :req_length]
metadata_tensor = metadata_tensor[:, :req_length, :]
# save regeneration using latent_rnn
tensor_score, tensor_metadata, constraints_location, start_tick, end_tick = \
process_arnn_batch(score_tensor, metadata_tensor, arnn_tester, num_past, num_target)
# forward pass through latent_rnn
_, gen_target = arnn_tester.model.forward_inpaint(
score_tensor=tensor_score,
metadata_tensor=tensor_metadata,
constraints_loc=constraints_location,
start_tick=start_tick,
end_tick=end_tick,
)
# convert to score
arnn_score = folk_dataset_test.tensor_to_score(gen_target.cpu())
arnn_score.write('midi', fp=save_filename)
# Intialize arnn-baseline model and arnn_tester
arnn_baseline_model = AnticipationRNNBaseline(
dataset=folk_dataset_train,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_layers=num_layers,
num_lstm_constraints_units=lstm_hidden_size,
num_lstm_generation_units=lstm_hidden_size,
linear_hidden_size=linear_hidden_size,
dropout_prob=dropout_lstm,
dropout_input_prob=input_dropout,
unary_constraint=True,
teacher_forcing=True)
arnn_baseline_model.load() # ARNN model must be pre-trained
if torch.cuda.is_available():
arnn_baseline_model.cuda()
arnn_baseline_tester = AnticipationRNNTester(dataset=folk_dataset_test,
model=arnn_baseline_model)
# Fourth save ARNN-Baseline generations
for i in tqdm(range(num_melodies)):
f = test_filenames[i]
f_id = f[:-4]
save_filename = os.path.join(cur_dir,
save_folder + f_id + '_arnn_baseline.mid')
if os.path.isfile(save_filename):
continue
f = os.path.join(folk_dataset_test.corpus_it_gen.raw_dataset_dir, f)
score = folk_dataset_test.corpus_it_gen.get_score_from_path(
f, fix_and_expand=True)
score_tensor = folk_dataset_test.get_score_tensor(score)
metadata_tensor = folk_dataset_test.get_metadata_tensor(score)
# ignore scores with less than 16 measures
if score_tensor.size(1) < req_length:
continue
score_tensor = score_tensor[:, :req_length]
metadata_tensor = metadata_tensor[:, :req_length, :]
# save regeneration using latent_rnn
tensor_score, tensor_metadata, constraints_location, start_tick, end_tick = \
process_arnn_batch(score_tensor, metadata_tensor, arnn_baseline_tester, num_past, num_target)
# forward pass through latent_rnn
_, gen_target = arnn_baseline_tester.model.forward_inpaint(
score_tensor=tensor_score,
metadata_tensor=tensor_metadata,
constraints_loc=constraints_location,
start_tick=start_tick,
end_tick=end_tick,
)
# convert to score
arnn_baseline_score = folk_dataset_test.tensor_to_score(
gen_target.cpu())
arnn_baseline_score.write('midi', fp=save_filename)
from grader.grader import score_chorale
from DatasetManager.chorale_dataset import ChoraleDataset
from DatasetManager.dataset_manager import DatasetManager, all_datasets
from DatasetManager.metadata import FermataMetadata, TickMetadata, KeyMetadata
from DatasetManager.helpers import GeneratedChoraleIteratorGen
from DeepBach.model_manager import DeepBach
from DeepBach.helpers import *
print('step 1/3: prepare dataset')
dataset_manager = DatasetManager()
metadatas = [FermataMetadata(), TickMetadata(subdivision=4), KeyMetadata()]
chorale_dataset_kwargs = {
'voice_ids': [1, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': 8,
'subdivision': 4,
'include_transpositions': False,
}
bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name='bach_chorales', **chorale_dataset_kwargs)
dataset = bach_chorales_dataset
load_or_pickle_distributions(dataset)
print(dataset.gaussian.covariances_)
# chorale = converter.parse('generations/6/c187.mid')
# score = score_chorale(chorale, dataset)
# print(score)
def main(note_embedding_dim,
metadata_embedding_dim,
num_encoder_layers,
encoder_hidden_size,
encoder_dropout_prob,
latent_space_dim,
num_decoder_layers,
decoder_hidden_size,
decoder_dropout_prob,
has_metadata,
num_latent_rnn_layers,
latent_rnn_hidden_size,
latent_rnn_dropout_prob,
batch_size,
num_epochs,
train,
lr,
plot,
log,
auto_reg,
teacher_forcing,
early_stop
):
# init dataset
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
mvae_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_dataset_vae: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train',
**mvae_train_kwargs
)
# init vae model
vae_model = MeasureVAE(
dataset=folk_dataset_vae,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_encoder_layers=num_encoder_layers,
encoder_hidden_size=encoder_hidden_size,
encoder_dropout_prob=encoder_dropout_prob,
latent_space_dim=latent_space_dim,
num_decoder_layers=num_decoder_layers,
decoder_hidden_size=decoder_hidden_size,
decoder_dropout_prob=decoder_dropout_prob,
has_metadata=has_metadata
)
vae_model.load() # VAE model must be pre-trained
folk_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_test_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': False
}
folk_dataset_train: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train',
**folk_train_kwargs
)
folk_dataset_test: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train',
**folk_test_kwargs
)
# init latent_rnn model
model = LatentRNN(
dataset=folk_dataset_train,
vae_model=vae_model,
num_rnn_layers=num_latent_rnn_layers,
rnn_hidden_size=latent_rnn_hidden_size,
dropout=latent_rnn_dropout_prob,
rnn_class=torch.nn.GRU,
auto_reg=auto_reg,
teacher_forcing=teacher_forcing
)
if train:
if torch.cuda.is_available():
model.cuda()
trainer = LatentRNNTrainer(
dataset=folk_dataset_train,
model=model,
lr=lr,
early_stopping=early_stop
)
trainer.train_model(
batch_size=batch_size,
num_epochs=num_epochs,
plot=plot,
log=log
)
else:
model.load()
model.cuda()
model.eval()
tester = LatentRNNTester(
dataset=folk_dataset_test,
model=model
)
tester.test_model(
batch_size=batch_size
)
gen_score, score, original_score = tester.generation_random(
tensor_score=None,
start_measure=8,
num_measures_gen=2
)
print( " --- score --- " )
print( score )
gen_score.show()
original_score.show()
gen_score2, score, original_score2 = tester.generation_test()
gen_score2.show()
original_score2.show()
print( " --- score --- " )
print( score )
def __init__(self,
writing_dir,
corpus_it_gen,
subdivision_model=2,
subdivision_read=4,
sequence_size=3,
velocity_quantization=2,
temperature=1.2):
"""
:param subdivision: number of sixteenth notes per beat
"""
self.subdivision_read = subdivision_read
self.sequence_size = sequence_size
self.velocity_quantization = velocity_quantization
self.writing_dir = writing_dir
#################################################################
# Need the old db used to train the model (yes it sucks...)
dataset_manager = DatasetManager()
arrangement_dataset_kwargs = {
'transpose_to_sounding_pitch': True,
'subdivision': subdivision_model,
'sequence_size': sequence_size,
'velocity_quantization': velocity_quantization,
'max_transposition': 12,
'compute_statistics_flag': False
}
dataset = dataset_manager.get_dataset(name='arrangement_large',
**arrangement_dataset_kwargs)
# Model params (need to know them :))
num_heads = 8
per_head_dim = 64
local_position_embedding_dim = 8
position_ff_dim = 1024
hierarchical = False
block_attention = False
nade = False
conditioning = True
double_conditioning = False
num_layers = 2
suffix = 'TEST'
reducer_input_dim = num_heads * per_head_dim
processor_encoder = ReductionDataProcessor(
dataset=dataset,
embedding_dim=reducer_input_dim - local_position_embedding_dim,
reducer_input_dim=reducer_input_dim,
local_position_embedding_dim=local_position_embedding_dim,
flag='orchestra',
block_attention=False)
processor_decoder = ReductionDataProcessor(
dataset=dataset,
embedding_dim=reducer_input_dim - local_position_embedding_dim,
reducer_input_dim=reducer_input_dim,
local_position_embedding_dim=local_position_embedding_dim,
flag='piano',
block_attention=block_attention)
processor_encodencoder = None
#################################################################
#################################################################
# Init model
# Use all gpus available
gpu_ids = [int(gpu) for gpu in range(torch.cuda.device_count())]
print(gpu_ids)
self.model = Transformer(
dataset=dataset,
data_processor_encodencoder=processor_encodencoder,
data_processor_encoder=processor_encoder,
data_processor_decoder=processor_decoder,
num_heads=num_heads,
per_head_dim=per_head_dim,
position_ff_dim=position_ff_dim,
hierarchical_encoding=hierarchical,
block_attention=block_attention,
nade=nade,
conditioning=conditioning,
double_conditioning=double_conditioning,
num_layers=num_layers,
dropout=0.1,
input_dropout=0.2,
reduction_flag=True,
lr=1e-4,
gpu_ids=gpu_ids,
suffix=suffix)
#################################################################
self.corpus_it_gen = corpus_it_gen
self.temperature = temperature
return
def main(note_embedding_dim, meta_embedding_dim, num_layers, lstm_hidden_size,
dropout_lstm, linear_hidden_size, batch_size, num_epochs, train,
update, num_iterations, sequence_length_ticks, model_id,
include_transpositions, update_iterations, generations_per_iteration,
num_generations, score_chorales, write_scores):
print('step 1/3: prepare dataset')
dataset_manager = DatasetManager()
metadatas = [FermataMetadata(), TickMetadata(subdivision=4), KeyMetadata()]
chorale_dataset_kwargs = {
'voice_ids': [0, 1, 2, 3],
'metadatas': metadatas,
'sequences_size': 8,
'subdivision': 4,
'include_transpositions': include_transpositions,
}
bach_chorales_dataset: ChoraleDataset = dataset_manager.get_dataset(
name='bach_chorales', **chorale_dataset_kwargs)
dataset = bach_chorales_dataset
load_or_pickle_distributions(dataset)
print('step 2/3: prepare model')
print(f'Model ID: {model_id}')
deepbach = DeepBach(
dataset=dataset,
note_embedding_dim=note_embedding_dim,
meta_embedding_dim=meta_embedding_dim,
num_layers=num_layers,
lstm_hidden_size=lstm_hidden_size,
dropout_lstm=dropout_lstm,
linear_hidden_size=linear_hidden_size,
model_id=model_id,
)
if train:
print('step 2a/3: train base model')
deepbach.train(batch_size=batch_size,
num_epochs=num_epochs,
split=[0.85, 0.15])
else:
print('step 2a/3: load model')
deepbach.load()
deepbach.cuda()
if update:
print(
f'step 2b/3: update base model over {update_iterations} iterations'
)
thres = get_threshold('data/chorale_scores.csv', col=-1)
print(f'Threshold for selection: {thres}')
update_file = open('data/update_scores.csv', 'w')
reader = csv.writer(update_file)
reader.writerow(['iteration', 'chorale ID', 'score'])
for i in range(update_iterations):
print(f'----------- Iteration {i} -----------')
picked_chorales = []
num_picked_chorales = 0
ensure_dir(f'generations/{model_id}/{i}')
for j in tqdm(range(generations_per_iteration)):
chorale, tensor_chorale, tensor_metadata = deepbach.generation(
num_iterations=num_iterations,
sequence_length_ticks=sequence_length_ticks,
)
score = score_chorale(chorale, dataset)
# write data to csv file
reader.writerow([i, j,
score]) # iteration, generation #, score
# worst Bach chorale score rounded up to nearest .01
if score > thres:
print(f'Picked chorale {j} with score {score}')
picked_chorales.append(chorale)
num_picked_chorales += 1
chorale.write('midi', f'generations/{model_id}/{i}/c{j}.mid')
print(
f'Number of picked chorales for iteration {i}: {num_picked_chorales}'
)
if num_picked_chorales == 0:
continue
all_datasets.update({
f'generated_chorales_{i}': {
'dataset_class_name': ChoraleDataset,
'corpus_it_gen':
GeneratedChoraleIteratorGen(picked_chorales)
}
})
generated_dataset: ChoraleDataset = dataset_manager.get_dataset(
name=f'generated_chorales_{i}',
index2note_dicts=dataset.index2note_dicts,
note2index_dicts=dataset.note2index_dicts,
voice_ranges=dataset.voice_ranges,
**chorale_dataset_kwargs)
deepbach.dataset = generated_dataset
deepbach.train(
batch_size=batch_size,
num_epochs=2,
split=[1, 0], # use all selected chorales for training
early_stopping=False)
# generate chorales
if score_chorales:
chorale_scores = {}
print('Scoring real chorales')
for chorale_id, chorale in tqdm(enumerate(dataset.iterator_gen()),
total=num_generations):
score = score_chorale(chorale, dataset)
chorale_scores[chorale_id] = score
if chorale_id == num_generations:
break
# write scores to file
if write_scores:
with open('data/chorale_scores.csv', 'w') as chorale_file:
reader = csv.writer(chorale_file)
reader.writerow(['', 'score'] + list(weights.keys()))
for id, value in chorale_scores.items():
reader.writerow([id, value])
if num_generations != 0:
generation_scores = {}
print('Generating and scoring generated chorales')
ensure_dir(f'generations/{model_id}')
for i in range(num_generations):
chorale, tensor_chorale, tensor_metadata = deepbach.generation(
num_iterations=num_iterations,
sequence_length_ticks=sequence_length_ticks,
)
chorale.write('midi', f'generations/{model_id}/c{i}.mid')
score = score_chorale(chorale, dataset)
generation_scores[i] = score
# write scores to file
if write_scores:
with open(f'data/model{model_id}_scores.csv',
'w') as generation_file:
reader = csv.writer(generation_file)
reader.writerow(['', 'score'] + list(weights.keys()))
for id, value in generation_scores.items():
reader.writerow([id, value])
def main(
midi_input,
temperature,
num_examples_sampled,
suffix,
):
# Use all gpus available
gpu_ids = [int(gpu) for gpu in range(torch.cuda.device_count())]
print(gpu_ids)
hierarchical = False
nade = False
num_layers = 6
dropout = 0.
input_dropout = 0.
input_dropout_token = 0.
per_head_dim = 64
num_heads = 8
local_position_embedding_dim = 8
position_ff_dim = 2048
enc_dec_conditioning = 'split'
lr = 1
mixup = None
scheduled_training = 0
dataset_type = 'arrangement_voice'
conditioning = True
double_conditioning = None
subdivision = 16
sequence_size = 7
velocity_quantization = 2
max_transposition = 12
group_instrument_per_section = False
reduction_flag = False
instrument_presence_in_encoder = False
cpc_config_name = None
block_attention = False
# Get dataset
dataset_manager = DatasetManager()
dataset, processor_decoder, processor_encoder, processor_encodencoder = \
dataset_import.get_dataset(dataset_manager, dataset_type, subdivision, sequence_size, velocity_quantization,
max_transposition,
num_heads, per_head_dim, local_position_embedding_dim, block_attention,
group_instrument_per_section, nade, cpc_config_name, double_conditioning,
instrument_presence_in_encoder)
model = Transformer(dataset=dataset,
data_processor_encodencoder=processor_encodencoder,
data_processor_encoder=processor_encoder,
data_processor_decoder=processor_decoder,
num_heads=num_heads,
per_head_dim=per_head_dim,
position_ff_dim=position_ff_dim,
enc_dec_conditioning=enc_dec_conditioning,
hierarchical_encoding=hierarchical,
block_attention=block_attention,
nade=nade,
conditioning=conditioning,
double_conditioning=double_conditioning,
num_layers=num_layers,
dropout=dropout,
input_dropout=input_dropout,
input_dropout_token=input_dropout_token,
lr=lr,
reduction_flag=reduction_flag,
gpu_ids=gpu_ids,
suffix=suffix,
mixup=mixup,
scheduled_training=scheduled_training)
model.load_overfit()
model.cuda()
print('Generation')
# Allows to override dataset quantization for generation
subdivision_generation = subdivision
source = {
'source_path': f'midi_inputs/{midi_input}',
'writing_name': f'{midi_input}',
'writing_tempo': 'adagio'
}
write_dir = 'midi_inputs'
generation_from_file(model=model,
temperature=temperature,
batch_size=num_examples_sampled,
filepath=source["source_path"],
write_dir=write_dir,
write_name=source["writing_name"],
banned_instruments=[],
unknown_instruments=[],
writing_tempo=source["writing_tempo"],
subdivision=subdivision_generation,
number_sampling_steps=1)
return
group_instrument_per_section = False
reduction_flag = False
lr = 1.
cpc_config_name = None
subdivision = args.subdivision
# Use all gpus available
gpu_ids = [int(gpu) for gpu in range(torch.cuda.device_count())]
print(f'Using GPUs {gpu_ids}')
if len(gpu_ids) == 0:
device = 'cpu'
else:
device = 'cuda'
# Get dataset
dataset_manager = DatasetManager()
dataset, processor_decoder, processor_encoder, processor_encodencoder = \
dataset_import.get_dataset(dataset_manager, args.dataset_type, args.subdivision, args.sequence_size,
args.velocity_quantization, args.max_transposition,
args.num_heads, args.per_head_dim, args.local_position_embedding_dim,
args.block_attention,
group_instrument_per_section, args.nade, cpc_config_name, args.double_conditioning,
args.instrument_presence_in_encoder)
# Load model
model = Transformer(dataset=dataset,
data_processor_encodencoder=processor_encodencoder,
data_processor_encoder=processor_encoder,
data_processor_decoder=processor_decoder,
num_heads=args.num_heads,
per_head_dim=args.per_head_dim,
metadata_tensor_dataset = torch.cat(metadata_tensor_dataset, 0)
num_datapoints, length, num_metadata = metadata_tensor_dataset.size()
metadata_tensor_dataset = metadata_tensor_dataset.view(
num_datapoints, 1, length, num_metadata)
dataset = TensorDataset(score_tensor_dataset, metadata_tensor_dataset)
print(f'Sizes: {score_tensor_dataset.size()}')
print(f'Sizes: {metadata_tensor_dataset.size()}')
return dataset
if __name__ == '__main__':
from DatasetManager.dataset_manager import DatasetManager
from DatasetManager.metadata import BeatMarkerMetadata, TickMetadata
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
folk_dataset_kwargs = {'metadatas': metadatas, 'sequences_size': 32}
folk_dataset: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4measures_test', **folk_dataset_kwargs)
(train_dataloader, val_dataloader,
test_dataloader) = folk_dataset.data_loaders(batch_size=100,
split=(0.7, 0.2))
print('Num Train Batches: ', len(train_dataloader))
print('Num Valid Batches: ', len(val_dataloader))
print('Num Test Batches: ', len(test_dataloader))
for sample_id, (score, _) in tqdm(enumerate(train_dataloader)):
def main(args):
"""
:param args:
:return:
"""
dropout = 0.
input_dropout = 0.
input_dropout_token = 0.
mixup = False
scheduled_training = 0.
group_instrument_per_section = False
reduction_flag = False
lr = 1.
cpc_config_name = None
subdivision = args.subdivision
# Use all gpus available
gpu_ids = [int(gpu) for gpu in range(torch.cuda.device_count())]
print(f'Using GPUs {gpu_ids}')
if len(gpu_ids) == 0:
device = 'cpu'
else:
device = 'cuda'
# Get dataset
dataset_manager = DatasetManager()
dataset, processor_decoder, processor_encoder, processor_encodencoder = \
dataset_import.get_dataset(dataset_manager, args.dataset_type, args.subdivision, args.sequence_size,
args.velocity_quantization, args.max_transposition,
args.num_heads, args.per_head_dim, args.local_position_embedding_dim,
args.block_attention,
group_instrument_per_section, args.nade, cpc_config_name, args.double_conditioning,
args.instrument_presence_in_encoder)
# Load model
model = Transformer(dataset=dataset,
data_processor_encodencoder=processor_encodencoder,
data_processor_encoder=processor_encoder,
data_processor_decoder=processor_decoder,
num_heads=args.num_heads,
per_head_dim=args.per_head_dim,
position_ff_dim=args.position_ff_dim,
enc_dec_conditioning=args.enc_dec_conditioning,
hierarchical_encoding=args.hierarchical,
block_attention=args.block_attention,
nade=args.nade,
conditioning=args.conditioning,
double_conditioning=args.double_conditioning,
num_layers=args.num_layers,
dropout=dropout,
input_dropout=input_dropout,
input_dropout_token=input_dropout_token,
lr=lr,
reduction_flag=reduction_flag,
gpu_ids=gpu_ids,
suffix=args.suffix,
mixup=mixup,
scheduled_training=scheduled_training)
model.load_overfit(device=device)
model.to(device)
model = model.eval()
# Dir for writing generated files
writing_dir = f'{os.getcwd()}/generation'
if not os.path.isdir(writing_dir):
os.makedirs(writing_dir)
# Create server
server_address = (args.ip, args.port)
server = OrchestraServer(server_address, model, subdivision, writing_dir)
print(f'[Server listening to {args.ip} on port {args.port}]')
server.serve_forever()
def init_app(block_attention, hierarchical, nade, num_layers, dropout,
input_dropout, per_head_dim, num_heads,
local_position_embedding_dim, position_ff_dim, suffix,
subdivision, sequence_size, velocity_quantization,
max_transposition, port):
global metadatas
global _subdivision
global _batch_size
global _banned_instruments
global _temperature
global _lowest_entropy_first
global _context_size
_subdivision = subdivision
_batch_size = 1
_banned_instruments = []
_temperature = 1.2
_lowest_entropy_first = True
gpu_ids = [int(gpu) for gpu in range(torch.cuda.device_count())]
print(gpu_ids)
dataset_manager = DatasetManager()
arrangement_dataset_kwargs = {
'transpose_to_sounding_pitch': True,
'subdivision': subdivision,
'sequence_size': sequence_size,
'velocity_quantization': velocity_quantization,
'max_transposition': max_transposition,
'compute_statistics_flag': False
}
dataset: ArrangementDataset = dataset_manager.get_dataset(
name='arrangement', **arrangement_dataset_kwargs)
reducer_input_dim = num_heads * per_head_dim
processor_encoder = ArrangementDataProcessor(
dataset=dataset,
embedding_dim=reducer_input_dim - local_position_embedding_dim,
reducer_input_dim=reducer_input_dim,
local_position_embedding_dim=local_position_embedding_dim,
flag_orchestra=False,
block_attention=False)
processor_decoder = ArrangementDataProcessor(
dataset=dataset,
embedding_dim=reducer_input_dim - local_position_embedding_dim,
reducer_input_dim=reducer_input_dim,
local_position_embedding_dim=local_position_embedding_dim,
flag_orchestra=True,
block_attention=block_attention)
_context_size = processor_decoder.num_frames_orchestra - 1
global model
model = Transformer(
dataset=dataset,
data_processor_encoder=processor_encoder,
data_processor_decoder=processor_decoder,
num_heads=num_heads,
per_head_dim=per_head_dim,
position_ff_dim=position_ff_dim,
hierarchical_encoding=hierarchical,
block_attention=block_attention,
nade=nade,
num_layers=num_layers,
dropout=dropout,
input_dropout=input_dropout,
conditioning=True,
lr=0,
gpu_ids=gpu_ids,
suffix=suffix,
)
model.load_overfit()
model.cuda()
# TODO : piano should be modifiable (by dropping mxml file ?)
filepath = "/home/leo/Recherche/Databases/Orchestration/arrangement_mxml/source_for_generation/chopin_Prel_Op28_20_xs.xml"
global _piano
global _rhythm_piano
global _orchestra
global _orchestra_silenced_instruments
_piano, _rhythm_piano, _orchestra, _orchestra_silenced_instruments = \
model.data_processor_encoder.init_generation_filepath(_batch_size, filepath,
banned_instruments=_banned_instruments,
subdivision=_subdivision)
# launch the script
# use threaded=True to fix Chrome/Chromium engine hanging on requests
# [https://stackoverflow.com/a/30670626]
local_only = False
if local_only:
# accessible only locally:
app.run(threaded=True)
else:
# accessible from outside:
app.run(host='0.0.0.0', port=port, threaded=True)
def main(note_embedding_dim, metadata_embedding_dim, num_encoder_layers,
encoder_hidden_size, encoder_dropout_prob, latent_space_dim,
num_decoder_layers, decoder_hidden_size, decoder_dropout_prob,
has_metadata, num_latent_rnn_layers, latent_rnn_hidden_size,
latent_rnn_dropout_prob, num_layers, lstm_hidden_size, dropout_lstm,
input_dropout, linear_hidden_size, batch_size, num_target,
num_models):
random.seed(0)
# init dataset
dataset_manager = DatasetManager()
metadatas = [
BeatMarkerMetadata(subdivision=6),
TickMetadata(subdivision=6)
]
mvae_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_dataset_vae: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **mvae_train_kwargs)
# init vae model
vae_model = MeasureVAE(dataset=folk_dataset_vae,
note_embedding_dim=note_embedding_dim,
metadata_embedding_dim=metadata_embedding_dim,
num_encoder_layers=num_encoder_layers,
encoder_hidden_size=encoder_hidden_size,
encoder_dropout_prob=encoder_dropout_prob,
latent_space_dim=latent_space_dim,
num_decoder_layers=num_decoder_layers,
decoder_hidden_size=decoder_hidden_size,
decoder_dropout_prob=decoder_dropout_prob,
has_metadata=has_metadata)
vae_model.load() # VAE model must be pre-trained
if torch.cuda.is_available():
vae_model.cuda()
folk_train_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': True
}
folk_test_kwargs = {
'metadatas': metadatas,
'sequences_size': 32,
'num_bars': 16,
'train': False
}
folk_dataset_train: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_train_kwargs)
folk_dataset_test: FolkDataset = dataset_manager.get_dataset(
name='folk_4by4nbars_train', **folk_test_kwargs)
# Initialize stuff
test_filenames = folk_dataset_test.dataset_filenames
num_melodies = 32
num_measures = 16
req_length = num_measures * 4 * 6
num_past = 6
num_future = 6
num_target = 4
cur_dir = os.path.dirname(os.path.realpath(__file__))
save_folder = 'saved_midi/'
# Initialize models and testers
latent_rnn_model = LatentRNN(dataset=folk_dataset_train,
vae_model=vae_model,
num_rnn_layers=num_latent_rnn_layers,
rnn_hidden_size=latent_rnn_hidden_size,
dropout=latent_rnn_dropout_prob,
rnn_class=torch.nn.GRU,
auto_reg=False,
teacher_forcing=True)
latent_rnn_model.load() # latent_rnn model must be pre-trained
if torch.cuda.is_available():
latent_rnn_model.cuda()
latent_rnn_tester = LatentRNNTester(dataset=folk_dataset_test,
model=latent_rnn_model)
def process_latent_rnn_batch(score_tensor,
num_past=6,
num_future=6,
num_target=4):
assert (num_past + num_future + num_target == 16)
score_tensor = score_tensor.unsqueeze(0)
score_tensor = LatentRNNTrainer.split_to_measures(score_tensor, 24)
tensor_past, tensor_future, tensor_target = LatentRNNTrainer.split_score(
score_tensor=score_tensor,
num_past=num_past,
num_future=num_future,
num_target=num_target,
measure_seq_len=24)
return tensor_past, tensor_future, tensor_target
# Second save latent_rnn generations
for i in tqdm(range(num_melodies)):
f = test_filenames[i]
f_id = f[:-4]
if f_id == 'tune_16154':
for j in range(15):
save_filename = os.path.join(
cur_dir,
save_folder + f_id + '_' + str(j) + '_latent_rnn.mid')
f = os.path.join(
folk_dataset_test.corpus_it_gen.raw_dataset_dir, f)
score = folk_dataset_test.corpus_it_gen.get_score_from_path(
f, fix_and_expand=True)
score_tensor = folk_dataset_test.get_score_tensor(score)
# ignore scores with less than 16 measures
if score_tensor.size(1) < req_length:
continue
score_tensor = score_tensor[:, :req_length]
# metadata_tensor = metadata_tensor[:, :req_length, :]
# save regeneration using latent_rnn
tensor_past, tensor_future, tensor_target = process_latent_rnn_batch(
score_tensor, num_past, num_future, num_target)
# forward pass through latent_rnn
weights, gen_target, _ = latent_rnn_tester.model(
past_context=tensor_past,
future_context=tensor_future,
target=tensor_target,
measures_to_generate=num_target,
train=False,
)
# convert to score
batch_size, _, _ = gen_target.size()
gen_target = gen_target.view(batch_size, num_target, 24)
gen_score_tensor = torch.cat(
(tensor_past, gen_target, tensor_future), 1)
latent_rnn_score = folk_dataset_test.tensor_to_score(
gen_score_tensor.cpu())
latent_rnn_score.write('midi', fp=save_filename)