def _to_notesequences(self, samples):
output_sequences = []
for s in samples:
if self._roll_output:
if self.end_token is not None:
end_i = np.where(s[:, self.end_token])
if len(end_i): # pylint: disable=g-explicit-length-test
s = s[:end_i[0]]
events_list = [frozenset(np.where(e)[0]) for e in s]
else:
s = np.argmax(s, axis=-1)
if self.end_token is not None and self.end_token in s:
s = s[:s.tolist().index(self.end_token)]
events_list = [
self._oh_encoder_decoder.decode_event(e) for e in s
]
# Map classes to exemplars.
events_list = [
frozenset(self._pitch_classes[c][0] for c in e)
for e in events_list
]
track = mm.DrumTrack(events=events_list,
steps_per_bar=self._steps_per_bar,
steps_per_quarter=self._steps_per_quarter)
output_sequences.append(track.to_sequence(velocity=80))
return output_sequences
def midiToMatrix(midi_file, steps_per_quarter):
"""
Args:
midi_file: Ruta donde se encuentra el archivo midi.
steps_per_quarter: Division del primer tiempo en 4 semicorcheas, 8 en fusas y 16 en semifusas.
Returns:
aa: Matriz binaria, jump: Duracion en tiempo de cada fila, steps_per_bar: Numero de filas en el primer tiempo, steps_per_quarter: Numero de filas del primer compas.
"""
print(midi_file)
sequence = mm.midi_file_to_sequence_proto(midi_file)
quantized_sequence = sequences_lib.quantize_note_sequence(
sequence, steps_per_quarter=steps_per_quarter)
drum_song = mm.DrumTrack()
drum_song.from_quantized_sequence(quantized_sequence, gap_bars=50)
steps_per_bar = drum_song.steps_per_bar
steps_per_quarter = drum_song.steps_per_quarter
print('steps_per_bar: ', drum_song.steps_per_bar)
print('steps_per_quarter: ', drum_song.steps_per_quarter)
drum_song = drum_song.to_sequence()
print("total_time", drum_song.total_time)
count = 0
fila = 0
jump = drum_song.notes[0].end_time - drum_song.notes[0].start_time
print("step_duration", jump)
active = collections.defaultdict(list)
while count + jump <= drum_song.total_time:
active['fila'].append(fila)
active['start_time'].append(count)
active['end_time'].append(count + jump)
count += jump
fila += 1
df_1 = pd.DataFrame(active)
#print(df_1)
aa = np.zeros((fila, PITCH_LIMIT))
print()
print("WaitMidiToMatrix...........:(")
for note in drum_song.notes:
for indice_fila, fila in df_1.iterrows():
if fila.start_time == note.start_time and note.end_time == fila.end_time:
aa[int(fila.fila), note.pitch] = 1
print("Done.......................:)")
print()
return aa, jump, steps_per_bar, steps_per_quarter
def generate(unused_argv):
"""Generates a basic drum sequence of 4 seconds based on a hard coded
primer"""
# TODO doc
mm.notebook_utils.download_bundle("drum_kit_rnn.mag", "bundles")
bundle = mm.sequence_generator_bundle.read_bundle_file(
os.path.join("bundles", "drum_kit_rnn.mag"))
generator_map = drums_rnn_sequence_generator.get_generator_map()
generator = generator_map["drum_kit"](checkpoint=None, bundle=bundle)
generator.initialize()
qpm = 120
num_bars = 3
seconds_per_step = 60.0 / qpm / generator.steps_per_quarter
num_steps_per_bar = constants.DEFAULT_STEPS_PER_BAR
seconds_per_bar = num_steps_per_bar * seconds_per_step
# Creates a primer sequence that is fed into the model for the generator,
# which will generate a sequence based on this one
# A DrumTrack models a drum sequence by step, so you have step 1 being the
# midi note 36 (bass drum), followed by 3 steps of silence (those four steps
# constitutes the first beat or quarter), followed by both notes 36 and 41
# being struck at the same time (followed by silence by these are optional)
primer_drums = mm.DrumTrack(
[frozenset(pitches) for pitches in
[(38, 51), (), (36,), (),
(38, 44, 51), (), (36,), (),
(), (), (38,), (),
(38, 44), (), (36, 51), (), ]])
primer_sequence = primer_drums.to_sequence(qpm=qpm)
primer_start_time = 0
primer_end_time = primer_start_time + seconds_per_bar
# Defines the start and end of the generation, which starts at the step
# after the end of the primer (we'll see in 03.py this calculation makes
# it harder to fall on proper beats) and ends at total seconds
# The complete generation will thus contain the primer and the total length
# needs to be at least the size of the primer
# TODO doc
generation_start_time = primer_end_time
generation_end_time = generation_start_time + (seconds_per_bar * num_bars)
generator_options = generator_pb2.GeneratorOptions()
generator_options.args['temperature'].float_value = 1.1
generator_options.generate_sections.add(
start_time=generation_start_time,
end_time=generation_end_time)
# We are using the primer sequence here instead of an empty sequence
sequence = generator.generate(primer_sequence, generator_options)
# TODO doc
plot_file = os.path.join("output", "out.html")
print("Generated plot file: " + str(os.path.abspath(plot_file)))
pretty_midi = mm.midi_io.note_sequence_to_pretty_midi(sequence)
plotter = Plotter()
plotter.show(pretty_midi, plot_file)
# TODO doc
input_ports = [name for name in mido.get_output_names()
if "VirtualMIDISynth" in name
or "FLUID Synth" in name]
if not input_ports:
print("Cannot find proper input port in "
+ str(mido.get_output_names()))
print("Playing generated MIDI in input port names: "
+ str(input_ports))
midi_hub = mh.MidiHub([], input_ports, None)
# TODO doc
empty_sequence = music_pb2.NoteSequence()
player = midi_hub.start_playback(empty_sequence,
allow_updates=True)
player._channel = 9
# TODO doc
wall_start_time = time.time()
sequence_adjusted = music_pb2.NoteSequence()
sequence_adjusted.CopyFrom(sequence)
sequence_adjusted = adjust_sequence_times(sequence_adjusted,
wall_start_time)
player.update_sequence(sequence_adjusted,
start_time=wall_start_time)
# TODO doc
try:
player.join(generation_end_time)
except KeyboardInterrupt:
return 0
finally:
return 0
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 = mm.DEFAULT_QUARTERS_PER_MINUTE
steps_per_second = mm.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 = mm.trim_note_sequence(input_sequence,
input_section.start_time,
input_section.end_time)
input_start_step = mm.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 = mm.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 = mm.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 = mm.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(
mm.steps_per_bar_in_quantized_sequence(quantized_sequence))
drums = mm.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
def _generate(self, input_sequence, generator_options):
if len(generator_options.input_sections) > 1:
raise mm.SequenceGeneratorException(
'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 mm.SequenceGeneratorException(
'This model supports only 1 generate_sections message, but got %s'
% len(generator_options.generate_sections))
qpm = (input_sequence.tempos[0].qpm if input_sequence
and input_sequence.tempos else mm.DEFAULT_QUARTERS_PER_MINUTE)
generate_section = generator_options.generate_sections[0]
if generator_options.input_sections:
input_section = generator_options.input_sections[0]
primer_sequence = mm.trim_note_sequence(input_sequence,
input_section.start_time,
input_section.end_time)
input_start_step = self.seconds_to_steps(input_section.start_time,
qpm)
else:
primer_sequence = input_sequence
input_start_step = 0
last_end_time = (max(
n.end_time
for n in primer_sequence.notes) if primer_sequence.notes else 0)
if last_end_time > generate_section.start_time:
raise mm.SequenceGeneratorException(
'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 = mm.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, _ = mm.extract_drum_tracks(
quantized_sequence,
search_start_step=input_start_step,
min_bars=0,
gap_bars=float('inf'))
assert len(extracted_drum_tracks) <= 1
start_step = self.seconds_to_steps(generate_section.start_time, qpm)
end_step = self.seconds_to_steps(generate_section.end_time, qpm)
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.
drums = mm.DrumTrack([], start_step=max(0, start_step - 1))
# 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
def drumtrack_fn():
return mm.DrumTrack(steps_per_bar=steps_per_bar,
steps_per_quarter=steps_per_quarter)
def generate(unused_argv):
# Downloads the bundle from the magenta website, a bundle (.mag file) is a
# trained model that is used by magenta
mm.notebook_utils.download_bundle("drum_kit_rnn.mag", "bundles")
bundle = mm.sequence_generator_bundle.read_bundle_file(
os.path.join("bundles", "drum_kit_rnn.mag"))
# Initialize the generator "drum_kit", this need to fit the bundle we
# downloaded before
generator_map = drums_rnn_sequence_generator.get_generator_map()
generator = generator_map["drum_kit"](checkpoint=None, bundle=bundle)
generator.initialize()
# We will generate 3 bars, so with a
# 1 bar primer we'll have 4 bars total
num_bars = 3
qpm = 120
# The steps per quarter for this generator
# is 4 steps per quarter
seconds_per_step = 60.0 / qpm / generator.steps_per_quarter
# We are using a default 16 steps per bar, which is
# 4/4 music sampled at 4 steps per quarter note
num_steps_per_bar = constants.DEFAULT_STEPS_PER_BAR
# We calculate how many seconds per bar for
# the generation time
seconds_per_bar = num_steps_per_bar * seconds_per_step
print(f"Seconds per step: {seconds_per_step}")
print(f"Seconds per bar: {seconds_per_bar}")
# Creates a primer sequence that is fed into the model for the generator,
# which will generate a sequence based on this one
# A DrumTrack models a drum sequence by step, so you have step 1 being the
# midi note 36 (bass drum), followed by 3 steps of silence (those four steps
# constitutes the first beat or quarter), followed by both notes 36 and 41
# being struck at the same time (followed by silence by these are optional)
primer_drums = mm.DrumTrack([
frozenset(pitches) for pitches in [
(38, 51),
(),
(36, ),
(),
(38, 44, 51),
(),
(36, ),
(),
(),
(),
(38, ),
(),
(38, 44),
(),
(36, 51),
(),
]
])
primer_sequence = primer_drums.to_sequence(qpm=qpm)
# We store those time because the generation
# will start after the end of the primer
primer_start_time = 0
primer_end_time = primer_start_time + seconds_per_bar
# We calculate the generation start and end
# for a duration of num_bars
generation_start_time = primer_end_time
generation_end_time = generation_start_time + (seconds_per_bar * num_bars)
print(f"Primer start and end:" f"[{primer_start_time}, {primer_end_time}]")
print(f"Generation start and end:"
f"[{generation_start_time}, {generation_end_time}]")
# The generator interface is common for all models
generator_options = generator_pb2.GeneratorOptions()
# Add a bit of temperature for more flavor
temperature = 1.1
print(f"Temperature: {temperature}")
generator_options.args['temperature'].float_value = temperature
# Defines the generation section
generator_options.generate_sections.add(start_time=generation_start_time,
end_time=generation_end_time)
# We are using the primer sequence here instead of an empty sequence,
# the resulting sequence is a NoteSequence instance
sequence = generator.generate(primer_sequence, generator_options)
# Write the resulting midi file to the output directory
midi_file = os.path.join("output", "out.mid")
mm.midi_io.note_sequence_to_midi_file(sequence, midi_file)
print(f"Generated midi file: {os.path.abspath(midi_file)}")
# Write the resulting plot file to the output directory
plot_file = os.path.join("output", "out.html")
pretty_midi = mm.midi_io.note_sequence_to_pretty_midi(sequence)
plotter = Plotter()
plotter.show(pretty_midi, plot_file)
print(f"Generated plot file: {os.path.abspath(plot_file)}")
return 0
def generate(unused_argv):
"""Generates a basic drum sequence of 4 seconds based on a hard coded
primer"""
# TODO doc
mm.notebook_utils.download_bundle("drum_kit_rnn.mag", "bundles")
bundle = mm.sequence_generator_bundle.read_bundle_file(
os.path.join("bundles", "drum_kit_rnn.mag"))
generator_map = drums_rnn_sequence_generator.get_generator_map()
generator = generator_map["drum_kit"](checkpoint=None, bundle=bundle)
generator.initialize()
qpm = 120
num_bars = 3
seconds_per_step = 60.0 / qpm / generator.steps_per_quarter
num_steps_per_bar = constants.DEFAULT_STEPS_PER_BAR
seconds_per_bar = num_steps_per_bar * seconds_per_step
# Creates a primer sequence that is fed into the model for the generator,
# which will generate a sequence based on this one
# A DrumTrack models a drum sequence by step, so you have step 1 being the
# midi note 36 (bass drum), followed by 3 steps of silence (those four steps
# constitutes the first beat or quarter), followed by both notes 36 and 41
# being struck at the same time (followed by silence by these are optional)
primer_drums = mm.DrumTrack([
frozenset(pitches) for pitches in [
(38, 51),
(),
(36, ),
(),
(38, 44, 51),
(),
(36, ),
(),
(),
(),
(38, ),
(),
(38, 44),
(),
(36, 51),
(),
]
])
primer_sequence = primer_drums.to_sequence(qpm=qpm)
primer_start_time = 0
primer_end_time = primer_start_time + seconds_per_bar
# Defines the start and end of the generation, which starts at the step
# after the end of the primer (we'll see in 03.py this calculation makes
# it harder to fall on proper beats) and ends at total seconds
# The complete generation will thus contain the primer and the total length
# needs to be at least the size of the primer
# TODO doc
generation_start_time = primer_end_time
generation_end_time = generation_start_time + (seconds_per_bar * num_bars)
generator_options = generator_pb2.GeneratorOptions()
generator_options.args['temperature'].float_value = 1.1
generator_options.generate_sections.add(start_time=generation_start_time,
end_time=generation_end_time)
# We are using the primer sequence here instead of an empty sequence
sequence = generator.generate(primer_sequence, generator_options)
midi_file = os.path.join("output", "out.mid")
mm.midi_io.note_sequence_to_midi_file(sequence, midi_file)
print("Generated midi file: " + str(os.path.abspath(midi_file)))
plot_file = os.path.join("output", "out.html")
print("Generated plot file: " + str(os.path.abspath(plot_file)))
pretty_midi = mm.midi_io.note_sequence_to_pretty_midi(sequence)
plotter = Plotter()
plotter.show(pretty_midi, plot_file)
return 0
