def generateNewSequence(input_sequence, temperature, write_to_file): input_sequence = mm.quantize_note_sequence(input_sequence, 8) bundle = sequence_generator_bundle.read_bundle_file( '/Library/Application Support/Quin Scacheri/Magenta Beats/drum_kit_rnn.mag' ) generator_map = drums_rnn_sequence_generator.get_generator_map() drum_rnn = generator_map['drum_kit'](checkpoint=None, bundle=bundle) drum_rnn.initialize() qpm = input_sequence.tempos[0].qpm last_end_time = (max( n.end_time for n in input_sequence.notes) if input_sequence.notes else 0) # total_seconds = num_steps * input_sequence.quantization_info.steps_per_quarter; generator_options = generator_pb2.GeneratorOptions() generator_options.args['temperature'].float_value = temperature generate_section = generator_options.generate_sections.add( start_time=last_end_time, end_time=8.0) new_sequence = drum_rnn.generate(input_sequence, generator_options) new_sequence = mm.trim_note_sequence(new_sequence, 2.0, 4.0) new_sequence = mm.quantize_note_sequence(new_sequence, 4) # # new_sequence.quantization_info.steps_per_quarter = 8 if (True): mm.sequence_proto_to_midi_file(input_sequence, 'primer.mid') mm.sequence_proto_to_midi_file(new_sequence, 'new_sequence.mid') return new_sequence
def generateNewSequence(input_sequence, num_steps, temperature, write_to_file = False): input_sequence = mm.quantize_note_sequence(input_sequence, 8) bundle = sequence_generator_bundle.read_bundle_file('drum_kit_rnn.mag') generator_map = drums_rnn_sequence_generator.get_generator_map() drum_rnn = generator_map['drum_kit'](checkpoint=None, bundle=bundle) drum_rnn.initialize() qpm = input_sequence.tempos[0].qpm last_end_time = (max(n.end_time for n in input_sequence.notes) if input_sequence.notes else 0) total_seconds = num_steps * input_sequence.quantization_info.steps_per_quarter; generator_options = generator_pb2.GeneratorOptions() generator_options.args['temperature'].float_value = temperature generate_section = generator_options.generate_sections.add(start_time=last_end_time, end_time=total_seconds) new_sequence = drum_rnn.generate(input_sequence, generator_options) new_sequence.quantization_info.steps_per_quarter = 8 mm.quantize_note_sequence(new_sequence, 8) if (write_to_file == True): mm.sequence_proto_to_midi_file(input_sequence, 'oldSequence.mid') mm.sequence_proto_to_midi_file(new_sequence, 'newSequence.mid') return new_sequence
def extendTwinkle(): twinkle_twinkle = createTwinkle() print("Initializing Melody RNN...") bundle = sequence_generator_bundle.read_bundle_file('./basic_rnn.mag') generator_map = melody_rnn_sequence_generator.get_generator_map() melody_rnn = generator_map['basic_rnn'](checkpoint=None, bundle=bundle) melody_rnn.initialize() input_sequence = twinkle_twinkle # change this to teapot if you want num_steps = 128 # change this for shorter or longer sequences temperature = 1.0 # the higher the temperature the more random the sequence. # Set the start time to begin on the next step after the last note ends. last_end_time = (max(n.end_time for n in input_sequence.notes) if input_sequence.notes else 0) qpm = input_sequence.tempos[0].qpm seconds_per_step = 60.0 / qpm / melody_rnn.steps_per_quarter total_seconds = num_steps * seconds_per_step generator_options = generator_pb2.GeneratorOptions() generator_options.args['temperature'].float_value = temperature generate_section = generator_options.generate_sections.add(start_time=last_end_time + seconds_per_step, end_time=total_seconds) # Ask the model to continue the sequence. sequence = melody_rnn.generate(input_sequence, generator_options) mm.sequence_proto_to_midi_file(sequence, 'twinkleExtended.mid')
def __init__(self, generator_name, num_bars_to_generate, hparams, checkpoint=None, bundle_file=None): self._num_bars_to_generate = num_bars_to_generate if not checkpoint and not bundle_file: raise GeneratorException( 'No generator checkpoint or bundle location supplied.') if (checkpoint or generator_name or hparams) and bundle_file: raise GeneratorException( 'Cannot specify both bundle file and checkpoint, generator_name, ' 'or hparams.') bundle = None if bundle_file: bundle = sequence_generator_bundle.read_bundle_file(bundle_file) generator_name = bundle.generator_details.id if generator_name not in _GENERATOR_FACTORY_MAP: raise GeneratorException('Invalid generator name given: %s', generator_name) generator = _GENERATOR_FACTORY_MAP[generator_name].create_generator( checkpoint=checkpoint, bundle=bundle, hparams=hparams) generator.initialize() self._generator = generator
def main(_): bundle_file = FLAGS.bundle_path checkpoint_file = FLAGS.checkpoint_path metagraph_filename = checkpoint_file + '.meta' bundle = sequence_generator_bundle.read_bundle_file(bundle_file) with tf.gfile.Open(checkpoint_file, 'wb') as f: f.write(bundle.checkpoint_file[0]) with tf.gfile.Open(metagraph_filename, 'wb') as f: f.write(bundle.metagraph_file)
def get_bundle(): """Returns a generator_pb2.GeneratorBundle object based read from bundle_file. Returns: Either a generator_pb2.GeneratorBundle or None if the bundle_file flag is not set or the save_generator_bundle flag is set. """ if should_save_generator_bundle(): return None bundle_file = get_bundle_file() if bundle_file is None: return None return sequence_generator_bundle.read_bundle_file(bundle_file)
def extendDrums(): dt = createDrumTrack() print("Initializing Drums RNN...") bundle = sequence_generator_bundle.read_bundle_file('drum_kit_rnn.mag') generator_map = drums_rnn_sequence_generator.get_generator_map() drum_rnn = generator_map['drum_kit'](checkpoint=None, bundle=bundle) drum_rnn.initialize() input_sequence = drums # change this to teapot if you want num_steps = 128 # change this for shorter or longer sequences temperature = 1.0 # the higher the temperature the more random the sequence. # Set the start time to begin on the next step after the last note ends. # new_start_time = generator_options = generator_pb2.GeneratorOptions() # generator_options.args['primer_sequence'].string_value = "drums.mid" generate_section = generator_options.generate_sections.add(start_time=last_end_time + seconds_per_step, end_time=total_seconds) # Ask the model to continue the sequence. drum_rnn.generateDrumTrack(128, )
def load_generator_from_bundle_file(bundle_file): """loads a bundle file as a SequenceGenerator() object.""" try: bundle = read_bundle_file(bundle_file) except GeneratorBundleParseException: logging.warning("Failed to parse '{}'".format(bundle_file)) return None generator_id = bundle.generator_details.id # pylint: disable-msg=no-member if generator_id not in GENERATOR_MAP: logging.warning( "Unrecognized SequenceGenerator ID '{}' in '{}'".format( generator_id, bundle_file)) return None generator = GENERATOR_MAP[generator_id](checkpoint=None, bundle=bundle) generator.initialize() logging.info("Loaded '{}' generator bundle from file '{}'".format( bundle.generator_details.id, bundle_file)) # pylint: disable-msg=no-member return generator
def app(unused_argv): # Initialize MidiHub. hub = midi_hub.MidiHub(["magenta_in 1"], ["VirtualMIDISynth #1 0"], midi_hub.TextureType.POLYPHONIC) # TODO ex # Bundle TODO describe notebook_utils.download_bundle("drum_kit_rnn.mag", "bundles") bundle = sequence_generator_bundle.read_bundle_file( os.path.join("bundles", "drum_kit_rnn.mag")) # Generator TODO describe generator_map = drums_rnn_sequence_generator.get_generator_map() generator = generator_map["drum_kit"](checkpoint=None, bundle=bundle) generator.initialize() output_file = os.path.join("output", "out.html") interaction = LooperMidi(hub, generator, output_file) interaction.start() interaction.join() return 0
def generate(unused_argv): # Bundle TODO describe notebook_utils.download_bundle("drum_kit_rnn.mag", "bundles") bundle = sequence_generator_bundle.read_bundle_file( os.path.join("bundles", "drum_kit_rnn.mag")) # Generator TODO describe generator_map = drums_rnn_sequence_generator.get_generator_map() generator = generator_map["drum_kit"](checkpoint=None, bundle=bundle) generator.initialize() # TODO describe magenta.music.DrumTrack([frozenset([36])]) primer_drums = magenta.music.DrumTrack([ frozenset(pitches) for pitches in [(36, ), (), (), (), (46, ), (), (), ()] ]) primer_sequence = primer_drums.to_sequence(qpm=120) # TODO describe qpm = 120 # TODO describe # steps_per_quarter = 4 seconds_per_step = 60.0 / qpm / generator.steps_per_quarter # TODO describe num_steps = 32 # TODO describe total_seconds = num_steps * seconds_per_step # TODO describe # TODO same as min / max in 02 primer_end_time = primer_sequence.total_time # TODO describe start_time = primer_end_time + seconds_per_step end_time = total_seconds # TODO describe generator_options = generator_pb2.GeneratorOptions() generator_options.generate_sections.add(start_time=1, end_time=end_time) # TODO describe generator_options.args['temperature'].float_value = 0.1 generator_options.args['beam_size'].int_value = 1 generator_options.args['branch_factor'].int_value = 1 generator_options.args['steps_per_iteration'].int_value = 1 # TODO describe sequence = generator.generate(primer_sequence, generator_options) # TODO print last_end_time = max(n.end_time for n in sequence.notes) first_start_time = min(n.start_time for n in sequence.notes) primer_length = last_end_time - first_start_time print("seconds_per_step: " + str(seconds_per_step)) print("num_steps: " + str(num_steps)) print("total_seconds: " + str(total_seconds)) print("primer_end_time: " + str(primer_end_time)) print("start_time: " + str(start_time)) print("end_time: " + str(end_time)) print("last_end_time: " + str(last_end_time)) print("first_start_time: " + str(first_start_time)) print("primer_length: " + str(primer_length)) # TODO describe midi_file = os.path.join("output", "out.mid") midi_io.note_sequence_to_midi_file(sequence, midi_file) print(midi_file) # TODO describe plot_file = os.path.join("output", "out.html") print(plot_file) pm = midi_io.note_sequence_to_pretty_midi(sequence) output_file(plot_file) plot = plot_midi(pm) show(plot) return 0
# See the License for the specific language governing permissions and # limitations under the License. # import magenta.models.basic_rnn.basic_rnn_generator as basic_rnn_generator from magenta.music import sequence_generator_bundle from magenta.protobuf import generator_pb2 from magenta.music import midi_io from magenta.models.shared.melody_rnn_generate import _steps_to_seconds import os import tempfile basic_generator = basic_rnn_generator.create_generator( None, sequence_generator_bundle.read_bundle_file(os.path.abspath('./magenta/basic_rnn.mag')), 4) def generate_midi(midi_data, total_seconds=10): primer_sequence = midi_io.midi_to_sequence_proto(midi_data) generate_request = generator_pb2.GenerateSequenceRequest() if len(primer_sequence.notes) > 4: estimated_tempo = midi_data.estimate_tempo() if estimated_tempo > 240: qpm = estimated_tempo / 2 else: qpm = estimated_tempo else: qpm = 120 primer_sequence.tempos[0].qpm = qpm generate_request.input_sequence.CopyFrom(primer_sequence)
BUNDLE_DIR = "bundles" OUTPUT_DIR = "output" if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) MIDI_FILE = OUTPUT_DIR + "/" + MODEL_NAME + "_" + DATETIME + ".mid" PLOT_FILE = OUTPUT_DIR + "/" + MODEL_NAME + "_" + DATETIME + ".html" # The higher the value, the more random is the generated sequence # 1.0 is the default value ; 1.25 is more random ; 0.75 is less random TEMPERATURE = 1.0 # The primer sequence TODO describe # Bundle TODO describe notebook_utils.download_bundle(BUNDLE_NAME, BUNDLE_DIR) bundle = sequence_generator_bundle.read_bundle_file( os.path.join(BUNDLE_DIR, BUNDLE_NAME)) # Generator TODO describe generator_map = melody_rnn_sequence_generator.get_generator_map() generator = generator_map[MODEL_NAME](checkpoint=None, bundle=bundle) generator.initialize() # Generator options TODO describe generator_options = generator_pb2.GeneratorOptions() generator_options.args["temperature"].float_value = TEMPERATURE # TODO is this unused? generate_section = generator_options.generate_sections.add(start_time=0, end_time=30) # Generate the sequence TODO describe