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],