def testExtractDrumTracksTooShort(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 127, 3, 4), (14, 50, 6, 7)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
drum_tracks, _ = drum_pipelines.extract_drum_tracks(
quantized_sequence, min_bars=2, gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual([], drum_tracks)
del self.note_sequence.notes[:]
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 127, 3, 4), (14, 50, 7, 8)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
drum_tracks, _ = drum_pipelines.extract_drum_tracks(
quantized_sequence, min_bars=2, gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual(
[[NO_DRUMS, NO_DRUMS, NO_DRUMS, DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(14)]],
drum_tracks)
def testExtractDrumTracksSimple(self):
music_testing_lib.add_track_to_sequence(self.note_sequence,
0, [(12, 100, 2, 4),
(11, 1, 6, 7)],
is_drum=True)
music_testing_lib.add_track_to_sequence(self.note_sequence,
1, [(12, 127, 2, 4),
(14, 50, 6, 9)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
expected = [[
NO_DRUMS, NO_DRUMS,
DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(11, 14)
]]
drum_tracks, _ = drum_pipelines.extract_drum_tracks(quantized_sequence,
min_bars=1,
gap_bars=1)
self.assertEqual(1, len(drum_tracks))
self.assertIsInstance(drum_tracks[0], drums_lib.DrumTrack)
drum_tracks = sorted([list(drums) for drums in drum_tracks])
self.assertEqual(expected, drum_tracks)
def testExtractDrumTracksPadEnd(self):
music_testing_lib.add_track_to_sequence(self.note_sequence,
0, [(12, 127, 2, 4),
(14, 50, 6, 7)],
is_drum=True)
music_testing_lib.add_track_to_sequence(self.note_sequence,
1, [(12, 127, 2, 4),
(15, 50, 6, 8)],
is_drum=True)
music_testing_lib.add_track_to_sequence(self.note_sequence,
2, [(12, 127, 2, 4),
(16, 50, 8, 9)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
expected = [[
NO_DRUMS, NO_DRUMS,
DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(14, 15), NO_DRUMS,
DRUMS(16), NO_DRUMS, NO_DRUMS, NO_DRUMS
]]
drum_tracks, _ = drum_pipelines.extract_drum_tracks(quantized_sequence,
min_bars=1,
gap_bars=1,
pad_end=True)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual(expected, drum_tracks)
def testExtractMultipleDrumTracks(self):
music_testing_lib.add_track_to_sequence(self.note_sequence,
0, [(12, 100, 2, 4),
(11, 1, 6, 11)],
is_drum=True)
music_testing_lib.add_track_to_sequence(self.note_sequence,
1, [(12, 127, 2, 4),
(14, 50, 6, 8),
(50, 100, 33, 37),
(52, 100, 37, 38)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
expected = [[
NO_DRUMS, NO_DRUMS,
DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(11, 14)
], [NO_DRUMS,
DRUMS(50), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(52)]]
drum_tracks, _ = drum_pipelines.extract_drum_tracks(quantized_sequence,
min_bars=1,
gap_bars=2)
drum_tracks = sorted([list(drums) for drums in drum_tracks])
self.assertEqual(expected, drum_tracks)
def testExtractDrumTracksLateStart(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, 102, 103), (13, 100, 104, 106)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
expected = [[NO_DRUMS, NO_DRUMS, DRUMS(12), NO_DRUMS, DRUMS(13)]]
drum_tracks, _ = drum_pipelines.extract_drum_tracks(
quantized_sequence, min_bars=1, gap_bars=1)
drum_tracks = sorted([list(drums) for drums in drum_tracks])
self.assertEqual(expected, drum_tracks)
def testExtractDrumTracksTooLongDiscard(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 127, 2, 4), (14, 50, 6, 15), (14, 50, 10, 15), (16, 100, 14, 19),
(14, 100, 18, 19)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
drum_tracks, _ = drum_pipelines.extract_drum_tracks(
quantized_sequence, min_bars=1, max_steps_discard=18, gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual([], drum_tracks)
def testExtractDrumTracksTooLongTruncate(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 127, 2, 4), (14, 50, 6, 15), (14, 50, 10, 15), (16, 100, 14, 19)],
is_drum=True)
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
expected = [[NO_DRUMS, NO_DRUMS, DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(14), NO_DRUMS, NO_DRUMS, NO_DRUMS, DRUMS(14), NO_DRUMS,
NO_DRUMS, NO_DRUMS]]
drum_tracks, _ = drum_pipelines.extract_drum_tracks(
quantized_sequence, min_bars=1, max_steps_truncate=14, gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual(expected, drum_tracks)
def _generate(self, input_sequence, generator_options):
if len(generator_options.input_sections) > 1:
raise sequence_generator.SequenceGeneratorError(
'This model supports at most one input_sections message, but got %s'
% len(generator_options.input_sections))
if len(generator_options.generate_sections) != 1:
raise sequence_generator.SequenceGeneratorError(
'This model supports only 1 generate_sections message, but got %s'
% len(generator_options.generate_sections))
if input_sequence and input_sequence.tempos:
qpm = input_sequence.tempos[0].qpm
else:
qpm = note_seq.DEFAULT_QUARTERS_PER_MINUTE
steps_per_second = note_seq.steps_per_quarter_to_steps_per_second(
self.steps_per_quarter, qpm)
generate_section = generator_options.generate_sections[0]
if generator_options.input_sections:
input_section = generator_options.input_sections[0]
primer_sequence = note_seq.trim_note_sequence(
input_sequence, input_section.start_time,
input_section.end_time)
input_start_step = note_seq.quantize_to_step(
input_section.start_time,
steps_per_second,
quantize_cutoff=0.0)
else:
primer_sequence = input_sequence
input_start_step = 0
if primer_sequence.notes:
last_end_time = max(n.end_time for n in primer_sequence.notes)
else:
last_end_time = 0
if last_end_time > generate_section.start_time:
raise sequence_generator.SequenceGeneratorError(
'Got GenerateSection request for section that is before the end of '
'the NoteSequence. This model can only extend sequences. Requested '
'start time: %s, Final note end time: %s' %
(generate_section.start_time, last_end_time))
# Quantize the priming sequence.
quantized_sequence = note_seq.quantize_note_sequence(
primer_sequence, self.steps_per_quarter)
# Setting gap_bars to infinite ensures that the entire input will be used.
extracted_drum_tracks, _ = drum_pipelines.extract_drum_tracks(
quantized_sequence,
search_start_step=input_start_step,
min_bars=0,
gap_bars=float('inf'),
ignore_is_drum=True)
assert len(extracted_drum_tracks) <= 1
start_step = note_seq.quantize_to_step(generate_section.start_time,
steps_per_second,
quantize_cutoff=0.0)
# Note that when quantizing end_step, we set quantize_cutoff to 1.0 so it
# always rounds down. This avoids generating a sequence that ends at 5.0
# seconds when the requested end time is 4.99.
end_step = note_seq.quantize_to_step(generate_section.end_time,
steps_per_second,
quantize_cutoff=1.0)
if extracted_drum_tracks and extracted_drum_tracks[0]:
drums = extracted_drum_tracks[0]
else:
# If no drum track could be extracted, create an empty drum track that
# starts 1 step before the request start_step. This will result in 1 step
# of silence when the drum track is extended below.
steps_per_bar = int(
note_seq.steps_per_bar_in_quantized_sequence(
quantized_sequence))
drums = note_seq.DrumTrack(
[],
start_step=max(0, start_step - 1),
steps_per_bar=steps_per_bar,
steps_per_quarter=self.steps_per_quarter)
# Ensure that the drum track extends up to the step we want to start
# generating.
drums.set_length(start_step - drums.start_step)
# Extract generation arguments from generator options.
arg_types = {
'temperature': lambda arg: arg.float_value,
'beam_size': lambda arg: arg.int_value,
'branch_factor': lambda arg: arg.int_value,
'steps_per_iteration': lambda arg: arg.int_value
}
args = dict((name, value_fn(generator_options.args[name]))
for name, value_fn in arg_types.items()
if name in generator_options.args)
generated_drums = self._model.generate_drum_track(
end_step - drums.start_step, drums, **args)
generated_sequence = generated_drums.to_sequence(qpm=qpm)
assert (generated_sequence.total_time -
generate_section.end_time) <= 1e-5
return generated_sequence
