def testAddInstruments(self):
# Remove closed hi-hat from inputs.
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, add_instruments=[2])
tensors = converter.to_tensors(self.one_bar_sequence)
output_sequences = converter.to_items(tensors.outputs)
# Output sequence should match the initial input.
self.compare_seqs(self.one_bar_sequence, output_sequences[0])
# Input sequence should match the pre-defined sequence.
input_sequences = converter.to_items(tensors.inputs)
self.compare_seqs(self.no_closed_hh_sequence, input_sequences[0])
# Remove snare from inputs.
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, add_instruments=[1])
tensors = converter.to_tensors(self.one_bar_sequence)
output_sequences = converter.to_items(tensors.outputs)
# Output sequence should match the initial input.
self.compare_seqs(self.one_bar_sequence, output_sequences[0])
# Input sequence should match the pre-defined sequence.
input_sequences = converter.to_items(tensors.inputs)
self.compare_seqs(self.no_snare_sequence, input_sequences[0])
def testSmallDrumSet(self):
# Convert one or two measures to a tensor and back
# This example should yield basically a perfect reconstruction
small_drum_set = [
data.REDUCED_DRUM_PITCH_CLASSES[0],
data.REDUCED_DRUM_PITCH_CLASSES[1] +
data.REDUCED_DRUM_PITCH_CLASSES[4] +
data.REDUCED_DRUM_PITCH_CLASSES[5] +
data.REDUCED_DRUM_PITCH_CLASSES[6],
data.REDUCED_DRUM_PITCH_CLASSES[2] + data.REDUCED_DRUM_PITCH_CLASSES[8],
data.REDUCED_DRUM_PITCH_CLASSES[3] + data.REDUCED_DRUM_PITCH_CLASSES[7]
]
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, pitch_classes=small_drum_set)
# Test one bar sequence
tensors = converter.to_tensors(self.one_bar_sequence)
# Should output a tuple containing a tensor of shape (16, 12)
self.assertEqual((16, 12), tensors.outputs[0].shape)
sequences = converter.to_items(tensors.outputs)
self.assertEqual(1, len(sequences))
self.compare_seqs(self.one_bar_sequence, sequences[0])
def testHitsAsControls(self):
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, hits_as_controls=True)
tensors = converter.to_tensors(self.one_bar_sequence)
self.assertEqual((16, 9), tensors.controls[0].shape)
def testToTensorAndNoteSequence(self):
# Convert one or two measures to a tensor and back
# This example should yield basically a perfect reconstruction
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5)
# Test one bar sequence
tensors = converter.to_tensors(self.one_bar_sequence)
# Should output a tuple containing a tensor of shape (16,27)
self.assertEqual((16, 27), tensors.outputs[0].shape)
sequences = converter.to_items(tensors.outputs)
self.assertEqual(1, len(sequences))
self.compare_seqs(self.one_bar_sequence, sequences[0])
# Test two bar sequence
tensors = converter.to_tensors(self.two_bar_sequence)
# Should output a tuple containing a tensor of shape (32,27)
self.assertEqual((32, 27), tensors.outputs[0].shape)
sequences = converter.to_items(tensors.outputs)
self.assertEqual(1, len(sequences))
self.compare_seqs(self.two_bar_sequence, sequences[0])
def testHitsAsControlsSplitInstruments(self):
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, split_instruments=True,
hits_as_controls=True)
tensors = converter.to_tensors(self.two_bar_sequence)
controls = tensors.controls
self.assertEqual((32*9, 10), controls[0].shape)
def testCycleData(self):
converter = data.GrooveConverter(
split_bars=1, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, hop_size=4)
tensors = converter.to_tensors(self.two_bar_sequence)
outputs = tensors.outputs
for output in outputs:
self.assertEqual(output.shape, (16, 27))
output_sequences = converter.to_items(tensors.outputs)
self.assertEqual(len(output_sequences), 5)
def testCategorical(self):
# Removes closed hi-hat from inputs.
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, add_instruments=[3],
num_velocity_bins=32, num_offset_bins=32)
tensors = converter.to_tensors(self.one_bar_sequence)
self.assertEqual((16, 585), tensors.outputs[0].shape)
output_sequences = converter.to_items(tensors.outputs)
self.compare_seqs(self.one_bar_sequence, output_sequences[0],
categorical=True)
def testHumanize(self):
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, humanize=True)
tensors = converter.to_tensors(self.one_bar_sequence)
output_sequences = converter.to_items(tensors.outputs)
# Output sequence should match the initial input.
self.compare_seqs(self.one_bar_sequence, output_sequences[0])
# Input sequence should match the pre-defined quantized_sequence.
input_sequences = converter.to_items(tensors.inputs)
self.compare_seqs(self.quantized_sequence, input_sequences[0])
def testModeMappings(self):
default_pitches = [
[0, 1],
[2, 3],
]
inference_pitches = [
[1, 2],
[3, 0],
]
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, pitch_classes=default_pitches,
inference_pitch_classes=inference_pitches)
test_seq = self.initialize_sequence()
testing_lib.add_track_to_sequence(
test_seq,
9,
[
(0, 50, 0, 0),
(1, 60, 0.25, 0.25),
(2, 70, 0.5, 0.5),
(3, 80, 0.75, 0.75),
])
# Test in default mode.
default_tensors = converter.to_tensors(test_seq)
default_sequences = converter.to_items(default_tensors.outputs)
expected_default_sequence = music_pb2.NoteSequence()
expected_default_sequence.CopyFrom(test_seq)
expected_default_sequence.notes[1].pitch = 0
expected_default_sequence.notes[3].pitch = 2
self.compare_seqs(expected_default_sequence, default_sequences[0])
# Test in train mode.
converter.set_mode('train')
train_tensors = converter.to_tensors(test_seq)
train_sequences = converter.to_items(train_tensors.outputs)
self.compare_seqs(expected_default_sequence, train_sequences[0])
# Test in inference mode.
converter.set_mode('infer')
infer_tensors = converter.to_tensors(test_seq)
infer_sequences = converter.to_items(infer_tensors.outputs)
expected_infer_sequence = music_pb2.NoteSequence()
expected_infer_sequence.CopyFrom(test_seq)
expected_infer_sequence.notes[0].pitch = 3
expected_infer_sequence.notes[2].pitch = 1
self.compare_seqs(expected_infer_sequence, infer_sequences[0])
def testContinuousSplitInstruments(self):
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, split_instruments=True)
tensors = converter.to_tensors(self.one_bar_sequence)
self.assertEqual((16 * 9, 3), tensors.outputs[0].shape)
self.assertEqual((16 * 9, 9), tensors.controls[0].shape)
for i, v in enumerate(np.argmax(tensors.controls[0], axis=-1)):
self.assertEqual(i % 9, v)
output_sequences = converter.to_items(tensors.outputs)
self.compare_seqs(self.one_bar_sequence, output_sequences[0],
categorical=True)
def testTapWithFixedVelocity(self):
converter = data.GrooveConverter(
split_bars=None, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5, tapify=True, fixed_velocities=True)
tensors = converter.to_tensors(self.one_bar_sequence)
output_sequences = converter.to_items(tensors.outputs)
# Output sequence should match the initial input.
self.compare_seqs(self.one_bar_sequence, output_sequences[0])
# Input sequence should match the pre-defined tap_sequence but with 0 vels.
input_sequences = converter.to_items(tensors.inputs)
tap_notes = self.tap_sequence.notes
for note in tap_notes:
note.velocity = 0
self.compare_notes(tap_notes, input_sequences[0].notes)
def testToTensorAndNoteSequenceWithSlicing(self):
converter = data.GrooveConverter(
split_bars=1, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=5)
# Test one bar sequence
tensors = converter.to_tensors(self.one_bar_sequence)
# Should output a tuple containing a tensor of shape (16,27)
self.assertEqual(1, len(tensors.outputs))
self.assertEqual((16, 27), tensors.outputs[0].shape)
sequences = converter.to_items(tensors.outputs)
self.assertEqual(1, len(sequences))
self.compare_seqs(self.one_bar_sequence, sequences[0])
# Test two bar sequence
tensors = converter.to_tensors(self.two_bar_sequence)
# Should output a tuple containing 2 tensors of shape (16,27)
self.assertEqual((16, 27), tensors.outputs[0].shape)
self.assertEqual((16, 27), tensors.outputs[1].shape)
sequences = converter.to_items(tensors.outputs)
self.assertEqual(2, len(sequences))
# Get notes in first bar
sequence0 = sequences[0]
notes0 = [n for n in self.two_bar_sequence.notes if n.start_time < 2]
reconstructed_notes0 = [n for n in sequence0.notes]
# Get notes in second bar, back them up by 2 secs for comparison
sequence1 = sequences[1]
notes1 = [n for n in self.two_bar_sequence.notes if n.start_time >= 2]
for n in notes1:
n.start_time = n.start_time-2
n.end_time = n.end_time-2
reconstructed_notes1 = [n for n in sequence1.notes]
self.compare_notes(notes0, reconstructed_notes0)
self.compare_notes(notes1, reconstructed_notes1)
def testCycleDataSplitInstruments(self):
converter = data.GrooveConverter(
split_bars=1, steps_per_quarter=4, quarters_per_bar=4,
max_tensors_per_notesequence=10, hop_size=4,
split_instruments=True)
tensors = converter.to_tensors(self.two_bar_sequence)
outputs = tensors.outputs
controls = tensors.controls
output_sequences = converter.to_items(outputs)
self.assertEqual(len(outputs), 5)
self.assertEqual(len(controls), 5)
for output in outputs:
self.assertEqual(output.shape, (16*9, 3))
for control in controls:
self.assertEqual(control.shape, (16*9, 9))
# This compares output_sequences[0] to the first bar of two_bar_sequence
# since they are not actually the same length.
self.compare_seqs(self.two_bar_sequence, output_sequences[0])
self.assertEqual(output_sequences[0].notes[-1].start_time, 1.75)
lstm_models.get_default_hparams(),
HParams(
batch_size=512,
max_seq_len=16 * 4, # 4 bars w/ 16 steps per bar
z_size=256,
enc_rnn_size=[512],
dec_rnn_size=[256, 256],
max_beta=0.2,
free_bits=48,
dropout_keep_prob=0.3,
)),
note_sequence_augmenter=None,
data_converter=data.GrooveConverter(
split_bars=4,
steps_per_quarter=4,
quarters_per_bar=4,
max_tensors_per_notesequence=20,
pitch_classes=data.ROLAND_DRUM_PITCH_CLASSES,
inference_pitch_classes=data.REDUCED_DRUM_PITCH_CLASSES),
tfds_name='groove/4bar-midionly',
)
CONFIG_MAP['groovae_2bar_humanize'] = Config(
model=MusicVAE(lstm_models.BidirectionalLstmEncoder(),
lstm_models.GrooveLstmDecoder()),
hparams=merge_hparams(
lstm_models.get_default_hparams(),
HParams(
batch_size=512,
max_seq_len=16 * 2, # 2 bars w/ 16 steps per bar
z_size=256,
# GrooVAE configs
CONFIG_MAP['groovae_4bar'] = Config(
model=MusicVAE(lstm_models.BidirectionalLstmEncoder(),
lstm_models.GrooveLstmDecoder()),
hparams=merge_hparams(
lstm_models.get_default_hparams(),
HParams(
batch_size=512,
max_seq_len=16 * 4, # 4 bars w/ 16 steps per bar
z_size=256,
enc_rnn_size=[512],
dec_rnn_size=[256, 256],
)),
note_sequence_augmenter=None,
data_converter=data.GrooveConverter(split_bars=4,
steps_per_quarter=4,
quarters_per_bar=4,
max_tensors_per_notesequence=20),
train_examples_path=None,
eval_examples_path=None,
)
CONFIG_MAP['groovae_2bar_humanize'] = Config(
model=MusicVAE(lstm_models.BidirectionalLstmEncoder(),
lstm_models.GrooveLstmDecoder()),
hparams=merge_hparams(
lstm_models.get_default_hparams(),
HParams(
batch_size=512,
max_seq_len=16 * 2, # 2 bars w/ 16 steps per bar
z_size=256,
enc_rnn_size=[512],
