def make_music_vae(input_midi_file_1, input_midi_file_2): input_midi_1 = os.path.expanduser(input_midi_file_1) input_midi_2 = os.path.expanduser(input_midi_file_2) if not os.path.exists(input_midi_1): raise ValueError('Input MIDI 1 not found: %s' % input_midi_file_1) if not os.path.exists(input_midi_2): raise ValueError('Input MIDI 2 not found: %s' % input_midi_file_2) input_1 = mm.midi_file_to_note_sequence(input_midi_1) input_2 = mm.midi_file_to_note_sequence(input_midi_2) _check_extract_examples(input_1, input_midi_file_1, 1) _check_extract_examples(input_2, input_midi_file_2, 2)
def piano_continuation(primer): print("이함수도안돌아?") primer_ns = mm.midi_file_to_note_sequence(primer) # Handle sustain pedal in the primer. primer_ns = mm.apply_sustain_control_changes(primer_ns) # Trim to desired number of seconds. max_primer_seconds = 20 #@param {type:"slider", min:1, max:120} if primer_ns.total_time > max_primer_seconds: print('Primer is longer than %d seconds, truncating.' % max_primer_seconds) primer_ns = mm.extract_subsequence(primer_ns, 0, max_primer_seconds) # Remove drums from primer if present. if any(note.is_drum for note in primer_ns.notes): print('Primer contains drums; they will be removed.') notes = [note for note in primer_ns.notes if not note.is_drum] del primer_ns.notes[:] primer_ns.notes.extend(notes) # Set primer instrument and program. for note in primer_ns.notes: note.instrument = 1 note.program = 0 #note_sequence_to_midi_file(primer_ns, 'modified_'+primer) targets = uncondi_encoders['targets'].encode_note_sequence(primer_ns) # Remove the end token from the encoded primer. targets = targets[:-1] decode_length = max(0, 4096 - len(targets)) if len(targets) >= 4096: print( 'Primer has more events than maximum sequence length; nothing will be generated.' ) # Generate sample events. sample_ids = next(uncondi_samples)['outputs'] # Decode to NoteSequence. midi_filename = decode(sample_ids, encoder=uncondi_encoders['targets']) ns = mm.midi_file_to_note_sequence(midi_filename) # Append continuation to primer. continuation_ns = mm.concatenate_sequences([primer_ns, ns]) note_sequence_to_midi_file(continuation_ns, 'continuated_' + primer)
def test(): test_path = os.path.join(cfg.SEQ_SAMPLE_PATH, str(cfg.FRAME_TIME) + '_ms', 'test') test_files = list_files(test_path, 'pickle') idx = 40 print(test_files[idx]) sample = data.read_sample(test_files[idx]) m = model.OaF_Drum() m.load(os.path.join(m.checkpoint_dir, '8.h5')) onset, _ = m.predict(sample['Frames']) sequence1 = mm.midi_file_to_note_sequence(test_files[idx].split('.')[0] + '.mid') print(sequence1.tempos[0]) fig = mm.plot_sequence(sequence1, show_figure=False) data.export_png(fig, filename="test.png") sequence2 = data.matrix2sequence(sample['Onset'], onset=sample['Onset']) mm.sequence_proto_to_midi_file(sequence2, 'test.mid') fig2 = mm.plot_sequence(sequence2, show_figure=False) data.export_png(fig2, filename="test_gen.png") sequence3 = data.matrix2sequence(onset[0], onset=onset[0]) mm.sequence_proto_to_midi_file(sequence3, 'pred.mid') fig3 = mm.plot_sequence(sequence3, show_figure=False) data.export_png(fig3, filename="pred.png")
def __init__(self, *args, **kwargs): # Command-line arguments #self.args = kwargs.get('args') #self.model = kwargs.get('model') # Init model self.temperature = 1 self._modelpath = "/Users/carsault/Dropbox/work/code/gitlab/cat-mel_2bar_big.tar" self.config_name = 'cat-mel_2bar_big' self.config = configs.CONFIG_MAP[self.config_name] self.config.data_converter.max_tensors_per_item = None checkpoint_dir_or_path = os.path.expanduser(self._modelpath) print('Loading model') self.model = TrainedModel(self.config, batch_size=1,checkpoint_dir_or_path=checkpoint_dir_or_path) # Init encoded files self.style_name = ['blues', 'classic', 'country', 'jazz', 'poprock','world', 'game', 'empty', 'RnB'] input_files_list = ["./MVAE_input_valid/Blues1.mid", "./MVAE_input_valid/classic1.mid", "./MVAE_input_valid/country1.mid", "./MVAE_input_valid/jazz1.mid", "./MVAE_input_valid/poprock1.mid", "./MVAE_input_valid/World1.mid", "./MVAE_input_valid/game1.mid", "./MVAE_input_valid/empty1.mid", "./MVAE_input_valid/RnB1.mid"] self.input_z_list = [] for file in input_files_list: input_midi = os.path.expanduser(file) inp = mm.midi_file_to_note_sequence(input_midi) z, mu, _ = self.model.encode([inp]) self.input_z_list.append(z[0]) # Init OSC server super(MVAEServer, self).__init__(*args) self.print('Server is ready.')
def app(unused_argv): sequence = midi_file_to_note_sequence( os.path.join("primers", "52_jazz_125_beat_4-4.mid")) tapped_sequence = get_tapped_2bar(sequence) return 0
def encode_midi(tm, input_midi_path, output_path, print_progress=False): """ Convert midi file to latent vector file. If the midi file fails to convert to a NoteSequence, or the NoteSequence does not correspond to any tensors, do not output any file. tm: Trained model used for encoding input_midi_path: Path to midi file. output_path: Path to .npy file to save latent vectors. The output latent vector array has shape (# NoteSequences, # latent vector dimensions) """ try: ns = mm.midi_file_to_note_sequence(input_midi_path) except mm.MIDIConversionError as e: print(input_midi_path, 'Midi conversion error:', str(e)) return tensors = tm._config.data_converter.to_tensors(ns) if len(tensors.inputs) == 0 and print_progress: print(input_midi_path, 'does not encode to any vectors') return _, mu, _ = tm.encode_tensors( list(tensors.inputs), list(tensors.lengths), list(tensors.controls)) np.save(output_path, mu) if print_progress: print('Encoded', input_midi_path, '->', len(tensors.inputs), 'vectors at', output_path)
def create_song_prototype(song_path, start_time, stop_time, model_used='attention_rnn', temperature=1.0): magenta_model_path = '%s/magenta_models/%s.mag' % (MEDIA_ROOT, model_used) bundle = mm.sequence_generator_bundle.read_bundle_file(magenta_model_path) generator_map = melody_rnn_sequence_generator.get_generator_map() melody_rnn = generator_map[model_used](checkpoint=None, bundle=bundle) melody_rnn.initialize() base_sequence = midi_file_to_note_sequence(song_path) target_sequence = extract_subsequence(base_sequence, start_time, stop_time) generator_options = generator_pb2.GeneratorOptions() generator_options.args['temperature'].float_value = temperature generator_options.generate_sections.add( start_time=target_sequence.total_time, end_time=2 * target_sequence.total_time) generated_sequence = melody_rnn.generate(target_sequence, generator_options) proceed_sequence = extract_subsequence(generated_sequence, target_sequence.total_time, 2 * target_sequence.total_time) return proceed_sequence
def _read_midi(self, input_file): """ Read midi file into note sequence. :param input_file: A string path to midi file. :return: Note sequence. """ note_sequence = mm.midi_file_to_note_sequence(input_file) # Handle sustain pedal in primer. if self.config.sustain: note_sequence = mm.apply_sustain_control_changes(note_sequence) # Trim to desired number of seconds. if note_sequence.total_time > self.config.max_length: LOGGER.warning( 'Note sequence %d is longer than max seconds %d, truncating.', note_sequence.total_time, self.config.max_length) note_sequence = mm.extract_subsequence(note_sequence, 0, self.config.max_length) # Whether or not remove drums. if any(note.is_drum for note in note_sequence.notes) and not self.config.use_drum: LOGGER.warning('Midi file contains drum sounds, removing.') notes = [note for note in note_sequence.notes if not note.is_drum] del note_sequence.notes[:] note_sequence.notes.extend(notes) # Set primer instrument and program. for note in note_sequence.notes: note.instrument = 1 note.program = 0 return note_sequence
def get_primer_ns(filename, max_length): """ Convert Midi file to note sequences for priming. :param filename: Midi file name. :param max_length: Maximum note sequence length for priming in seconds. :return: Note sequences for priming. """ primer_ns = mm.midi_file_to_note_sequence(filename) # Handle sustain pedal in primer. primer_ns = mm.apply_sustain_control_changes(primer_ns) # Trim to desired number of seconds. if primer_ns.total_time > max_length: LOGGER.warn( 'Primer duration %d is longer than max second %d, truncating.' % (primer_ns.total_time, max_length)) primer_ns = mm.extract_subsequence(primer_ns, 0, max_length) # Remove drums from primer if present. if any(note.is_drum for note in primer_ns.notes): LOGGER.warn('Primer contains drums; they will be removed.') notes = [note for note in primer_ns.notes if not note.is_drum] del primer_ns.notes[:] primer_ns.notes.extend(notes) # Set primer instrument and program. for note in primer_ns.notes: note.instrument = 1 note.program = 0 return primer_ns
def run(config_map): date_and_time = time.strftime('%Y-%m-%d_%H%M%S') if FLAGS.run_dir is None == FLAGS.checkpoint_file is None: raise ValueError( 'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.' ) if FLAGS.output_npy is None: raise ValueError('`--output_npy` is required.') # tf.gfile.MakeDirs(FLAGS.output_npy) if FLAGS.config not in config_map: raise ValueError('Invalid config name: %s' % FLAGS.config) config = config_map[FLAGS.config] config.data_converter.max_tensors_per_item = None # Check midi file if not os.path.exists(FLAGS.midi_dir): raise ValueError('MIDI dir not found: %s' % FLAGS.midi_dir) logging.info( 'Attempting to extract examples from input MIDIs using config `%s`...', FLAGS.config) logging.info('Loading model...') if FLAGS.run_dir: checkpoint_dir_or_path = os.path.expanduser( os.path.join(FLAGS.run_dir, 'train')) else: checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file) model = TrainedModel(config, batch_size=min(FLAGS.max_batch_size, FLAGS.num_outputs), checkpoint_dir_or_path=checkpoint_dir_or_path) logging.info('Extracting latent parameters...') midi_files = [ f for f in listdir(FLAGS.midi_dir) if isfile(join(FLAGS.midi_dir, f)) ] extraction = np.zeros((len(midi_files), 3, 512)) for i, _midi_file in tqdm(enumerate(midi_files)): midi_file = FLAGS.midi_dir + '/' + _midi_file try: input_midi = mm.midi_file_to_note_sequence(midi_file) except: continue tensor = config.data_converter.to_tensors(input_midi).outputs if not tensor: # logging.info('Skipping {:s}'.format(_midi_file)) continue z, mu, sigma = model.encode([input_midi]) extraction[i, 0, :] = z extraction[i, 1, :] = mu extraction[i, 2, :] = sigma np.save(FLAGS.output_npy, extraction) logging.info('Done.')
def download(self, request): is_required_params = 'song_id' in request.query_params if not is_required_params: raise RequiredParamsNotProvidedException file_path = self.get_song_file_path( request.query_params.get('song_id')) note_sequence = midi_file_to_note_sequence(file_path) prepared_song = note_sequence_to_note_list(note_sequence) return Response(data=prepared_song, status=status.HTTP_200_OK)
def generate_primer(self): """ Put something important here. """ if self.conditioned: raise ValueError("Should be using an unconditioned model!") primer_ns = self.sequence primer_ns = mm.apply_sustain_control_changes(primer_ns) max_primer_seconds = 10 if primer_ns.total_time > max_primer_seconds: print(f'Primer is longer than {max_primer_seconds} seconds, truncating.') # cut primer if it's too long primer_ns = mm.extract_subsequence( primer_ns, 0, max_primer_seconds) if any(note.is_drum for note in primer_ns.notes): print('Primer contains drums; they will be removed.') notes = [note for note in primer_ns.notes if not note.is_drum] del primer_ns.notes[:] primer_ns.notes.extend(notes) for note in primer_ns.notes: # make into piano note.instrument = 1 note.program = 0 self.targets = self.encoders['targets'].encode_note_sequence( primer_ns) # Remove the end token from the encoded primer. self.targets = self.targets[:-1] self.decode_length = max(0, 4096 - len(self.targets)) if len(self.targets) >= 4096: print('Primer has more events than maximum sequence length; nothing will be generated.') # Generate sample events. sample_ids = next(self.samples)['outputs'] midi_filename = self.decode( sample_ids, encoder=self.encoders['targets']) ns = mm.midi_file_to_note_sequence(midi_filename) # Append continuation to primer. continuation_ns = mm.concatenate_sequences([primer_ns, ns]) request_dict = self.put_request_dict generated_sequence_2_mp3(continuation_ns, f"{self.unique_id}", use_salamander=True, request_dict=request_dict)
def main(): #load midi file loaded_sequence = mm.midi_file_to_note_sequence(base + "/input/input.mid") s = loaded_sequence s = change_tempo(get_tapped_2bar(s, velocity=85, ride=False), s.tempos[0].qpm) h = drumify(s, groovae_2bar_tap) h = change_tempo(h, s.tempos[0].qpm) midi_io.note_sequence_to_midi_file(start_notes_at_0(h), base + "/output/output.mid") print("Generate Done")
def generate(self): # based on i self.targets = [] self.decode_length = 1024 # Generate sample events. sample_ids = next(self.samples)['outputs'] # Decode to NoteSequence. midi_filename = self.decode( sample_ids, encoder=self.encoders['targets']) unconditional_ns = mm.midi_file_to_note_sequence(midi_filename) request_dict = self.put_request_dict generated_sequence_2_mp3(unconditional_ns, f"{self.unique_id}", use_salamander=True, request_dict=request_dict)
def generate( estimator, unconditional_encoders, decode_length, targets, primer_note_sequence, ): """ Generate unconditioned music samples from estimator :param estimator: Transformer estimator :param unconditional_encoders: A dictionary contains key and its encoder. :param decode_length: A number represents the duration of music snippet. :param targets: Target input for Transformer. :param primer_note_sequence: Notesequence represents the primer. :return: """ # Output filename tf.gfile.MakeDirs(FLAGS.output_dir) date_and_time = time.strftime("%Y-%m-%d_%H%M%S") base_name = os.path.join(FLAGS.output_dir, f"unconditioned_{date_and_time:s}.mid") # Generating sample LOGGER.info("Generating sample.") input_function = decoding.make_input_fn_from_generator( unconditional_input_generator(targets, decode_length)) unconditional_samples = estimator.predict(input_function, checkpoint_path=FLAGS.model_path) # Sample events LOGGER.info("Generating sample events.") sample_ids = next(unconditional_samples)["outputs"] # Decode to note sequence LOGGER.info("Decoding sample ID") midi_filename = decode(sample_ids, encoder=unconditional_encoders["targets"]) unconditional_note_seqs = mm.midi_file_to_note_sequence(midi_filename) # Append continuation to primer coninuation_note_sequence = mm.concatenate_sequences( [primer_note_sequence, unconditional_note_seqs]) # Saving MIDI file mm.sequence_proto_to_midi_file(coninuation_note_sequence, base_name)
def generate_basic_notes(self, qpm=160, failsafe=False): """ Requires melody conditioned model. """ if not self.conditioned: raise ValueError("Model should be conditioned!") if failsafe: self.failsafe() else: melody_ns = copy.deepcopy(self.sequence) try: melody_instrument = mm.infer_melody_for_sequence(melody_ns) notes = [note for note in melody_ns.notes if note.instrument == melody_instrument] melody_ns.notes.extend( sorted(notes, key=lambda note: note.start_time)) for i in range(len(melody_ns.notes) - 1): melody_ns.notes[i].end_time = melody_ns.notes[i + 1].start_time # sequence can only be one min to save time during inference. melody_ns = mm.extract_subsequence(melody_ns, 0, 60) self.inputs = self.encoders['inputs'].encode_note_sequence( melody_ns) print("Melody successfully parsed and encoded!") except Exception as e: print(f"Error in encoding stage {e}") print("Resorting to a basic melody") self.failsafe() self.decode_length = 4096 sample_ids = next(self.samples)['outputs'] # Decode to NoteSequence. midi_filename = self.decode( sample_ids, encoder=self.encoders['targets']) accompaniment_ns = mm.midi_file_to_note_sequence(midi_filename) request_dict = self.put_request_dict generated_sequence_2_mp3(accompaniment_ns, f"{self.unique_id}", use_salamander=True, request_dict=request_dict)
def get_primer_ns(filename): """ Convert MIDI file to note sequences for priming. :param filename: MIDI file name. :return: Note sequences for priming. """ primer_note_sequence = mm.midi_file_to_note_sequence(filename) # Handle sustain pedal in primer. primer_note_sequence = mm.apply_sustain_control_changes( primer_note_sequence) # Set primer instrument and program. for note in primer_note_sequence.notes: note.instrument = 1 note.program = 0 return primer_note_sequence
def get_melody_ns(filename): """ Convert melody Midi file to note sequence. :param filename: Midi file name. :return: Melody note sequences. """ melody_ns = mm.midi_file_to_note_sequence(filename) melody_instrument = mm.infer_melody_for_sequence(melody_ns) # pylint: disable=no-member notes = [ note for note in melody_ns.notes if note.instrument == melody_instrument ] del melody_ns.notes[:] melody_ns.notes.extend(sorted(notes, key=lambda note: note.start_time)) for i in range(len(melody_ns.notes) - 1): melody_ns.notes[i].end_time = melody_ns.notes[i + 1].start_time # pylint: disable=no-member return melody_ns
def generate(): if FLAGS.run_dir is None: raise ValueError('You must specify `run_dir`!') train_dir = os.path.join(os.path.expanduser(FLAGS.run_dir), 'train/') if FLAGS.load_model is None: raise ValueError('You must specify `load_model`!') checkpoints_dir = train_dir + FLAGS.load_model # configuration config = configs.CONFIG_MAP[FLAGS.config] hparams = config.hparams hparams.dropout_keep_prob = 1.0 # params z_size = hparams.z_size batch_size = hparams.batch_size graph = tf.get_default_graph() with graph.as_default(): sess = tf.Session() encoder = BidirectionalLstmEncoder( hparams, name_or_scope='vae-pg/bilstm-encoder') decoder_theta = LstmPolicyGradientDecoder( hparams, name_or_scope='vae-pg/PG-decoder') decoder_beta = LstmPolicyGradientDecoder( hparams, name_or_scope='vae-pg-copy/PG-decoder') dis = BidirectionalLstmDiscriminator(hparams) seq_vae = SeqVAE(hparams, encoder, decoder_theta, decoder_beta, dis) if FLAGS.mode == 'interpolate': if FLAGS.input_midi_1 is None or FLAGS.input_midi_2 is None: raise ValueError( '`--input_midi_1` and `--input_midi_2` must be specified in ' '`interpolate` mode.') logging.info('Interpolating...') input_midi_1 = os.path.expanduser(FLAGS.input_midi_1) input_midi_2 = os.path.expanduser(FLAGS.input_midi_2) input_1 = mm.midi_file_to_note_sequence(input_midi_1) input_2 = mm.midi_file_to_note_sequence(input_midi_2) inputs = [] lengths = [] for note_sequence in [input_1, input_2]: extracted_tensors = configs.mel_16bar_converter.to_tensors( note_sequence) if len(extracted_tensors.inputs) > 0: inputs.append(extracted_tensors.inputs[0]) lengths.append(extracted_tensors.lengths[0]) inputs = np.array(inputs).astype(np.float) inputs = tf.convert_to_tensor(inputs, dtype=tf.float32) mu = encoder.get_mu(inputs, lengths) # used to sample z mvn = tfd.MultivariateNormalDiag(loc=[0] * z_size, scale_diag=[1] * z_size) z_op = mvn.sample(batch_size) # generate_op generate_op, _ = seq_vae.generate(z_op) saver = tf.train.Saver() sess.run(tf.local_variables_initializer()) # load trained save_path = tf.train.latest_checkpoint(checkpoints_dir) logging.info('Load model from %s...' % save_path) saver.restore(sess, save_path) checkpoint = tf.train.get_checkpoint_state(checkpoints_dir) meta_graph_path = checkpoint.model_checkpoint_path + ".meta" step = int(meta_graph_path.split("-")[-1].split(".")[0]) logging.info('Start...') num = FLAGS.num count = 0 # generate music if FLAGS.mode == 'sample': basename = os.path.join(FLAGS.run_dir + FLAGS.output_dir, '%s-*.mid' % FLAGS.config) while count < num: f_ms = config.data_converter.to_items(sess.run(generate_op)) for f_m in f_ms: mm.sequence_proto_to_midi_file( f_m, basename.replace('*', '%03d' % count)) count += 1 if count == num: break elif FLAGS.mode == 'test': save_file_name = os.path.join( FLAGS.run_dir + FLAGS.output_dir, FLAGS.config + '_' + str(step // 1000) + 'k.npy') results = [] while count < num: f_ms = sess.run(generate_op) for f_m in f_ms: results.append(f_m) count += 1 if count == num: break np.save(save_file_name, results) elif FLAGS.mode == 'interpolate': mu_values = sess.run(mu) z = np.array([ utils.slerp(mu_values[0], mu_values[1], t) for t in np.linspace(0, 1, num) ]) results = sess.run(seq_vae.generate(z)[0]) note_sequence_arr = config.data_converter.to_items(results) basename = os.path.join(FLAGS.run_dir + FLAGS.output_dir, 'interpolate-*.mid') while count < num: mm.sequence_proto_to_midi_file( note_sequence_arr[count], basename.replace('*', '%03d' % count)) count += 1 logging.info('Done.')
type=int, default=DEFAULT_STEPS_PER_BAR) parser.add_argument("--num_output", type=int, default=6) parser.add_argument("--output_root_dir", type=str) return parser if __name__ == "__main__": def _expanduser(_path): return str(Path(_path).expanduser()) known_args, _ = get_parser().parse_known_args() output_root_dir = Path(known_args.output_root_dir).expanduser() if not output_root_dir.exists(): output_root_dir.mkdir(parents=True) total_bars = known_args.num_output * known_args.num_bar_per_sample num_steps_per_sample = known_args.num_bar_per_sample * known_args.num_steps_per_bar core.interpolate( known_args.model_name, start_sequence=mm.midi_file_to_note_sequence( _expanduser(known_args.input_midi_1)), end_sequence=mm.midi_file_to_note_sequence( _expanduser(known_args.input_midi_2)), num_steps_per_sample=num_steps_per_sample, num_output=known_args.num_output, total_bars=total_bars, output_dir=output_root_dir, )
input_fn = decoding.make_input_fn_from_generator(input_generator()) uncondi_samples = estimator.predict(input_fn, checkpoint_path=uncondi_ckpt_path) # "Burn" one. _ = next(uncondi_samples) print("ㅇㅣ건잘되지않아?") targets = [] decode_length = 1024 # Generate sample events. sample_ids = next(uncondi_samples)['outputs'] # Decode to NoteSequence. midi_filename = decode(sample_ids, encoder=uncondi_encoders['targets']) uncondi_ns = mm.midi_file_to_note_sequence(midi_filename) #@title Download Performance as MIDI #@markdown Download generated performance as MIDI (optional). note_sequence_to_midi_file(uncondi_ns, 'unconditional_piano_performance.mid') piano_continuation('c_major_arpeggio.mid') piano_continuation('c_major_scale.mid') piano_continuation('clair_de_lune.mid') piano_continuation('fur_elise.mid') piano_continuation('moonlight_sonata.mid') piano_continuation('prelude_in_c_major.mid') piano_continuation('twinkle_twinkle_little_star.mid') piano_continuation('mary_had_a_little_lamb.mid') # ###############################################################################################
twinkle_twinkle.notes.add(pitch=67, start_time=1.0, end_time=1.5, velocity=80) twinkle_twinkle.notes.add(pitch=67, start_time=1.5, end_time=2.0, velocity=80) twinkle_twinkle.notes.add(pitch=69, start_time=2.0, end_time=2.5, velocity=80) twinkle_twinkle.notes.add(pitch=69, start_time=2.5, end_time=3.0, velocity=80) twinkle_twinkle.notes.add(pitch=67, start_time=3.0, end_time=4.0, velocity=80) twinkle_twinkle.notes.add(pitch=65, start_time=4.0, end_time=4.5, velocity=80) twinkle_twinkle.notes.add(pitch=65, start_time=4.5, end_time=5.0, velocity=80) twinkle_twinkle.notes.add(pitch=64, start_time=5.0, end_time=5.5, velocity=80) twinkle_twinkle.notes.add(pitch=64, start_time=5.5, end_time=6.0, velocity=80) twinkle_twinkle.notes.add(pitch=62, start_time=6.0, end_time=6.5, velocity=80) twinkle_twinkle.notes.add(pitch=62, start_time=6.5, end_time=7.0, velocity=80) twinkle_twinkle.notes.add(pitch=60, start_time=7.0, end_time=8.0, velocity=80) twinkle_twinkle.total_time = 8 twinkle_twinkle.tempos.add(qpm=60) babyshark = mm.midi_file_to_note_sequence('./mid/babyshark.mid') babyshark = mm.extract_subsequence(babyshark, 0, 8) babyshark.ticks_per_quarter = 0 babyshark.time_signatures.pop() babyshark.key_signatures.pop() babyshark.tempos.pop() babyshark.tempos.add(qpm=60) for note in babyshark.notes: if note.pitch < 60: note.pitch = 60 note.instrument = 0 note.is_drum = False # This gives us a list of sequences.
def render_sequence_to_music_dict(midi_file, music_dict, model_string="melody_rnn"): sequence = mm.midi_file_to_note_sequence(midi_file) # scale to num steps. music_dict['num_steps'] = 1024 * music_dict['length'] backup_sequence = None basic_models = [ "melody_rnn", "performance_rnn", "polyphony_rnn", "pianoroll_rnn_nade" ] if model_string in basic_models: subsequence = mm.extract_subsequence(sequence, 0.0, C.SUBSEQUENCE_TIME) for note in subsequence.notes: # rnns can work with piano data. note.program = 0 note.instrument = 1 music_dict['sequence'] = subsequence if model_string == "performance_rnn": music_dict['num_steps'] = music_dict['num_steps'] * 4 elif model_string == "improv_rnn" or model_string == "music_vae": subsequence = mm.extract_subsequence(sequence, 0.0, C.SUBSEQUENCE_TIME) melody = mm.infer_melody_for_sequence(subsequence) new_sequence = music_pb2.NoteSequence() backup_sequence = music_pb2.NoteSequence() new_val = 0. backup_val = 0. for note in subsequence.notes: # rnns can work with piano data. if note.instrument == melody: start = note.start_time end = note.end_time diff = end - start new_sequence.notes.add(pitch=note.pitch, start_time=new_val, end_time=new_val + diff, velocity=160) backup_sequence.notes.add(pitch=note.pitch, start_time=backup_val, end_time=backup_val + 0.5, velocity=160) new_val += diff backup_val += 0.5 if model_string == "improv_rnn": note.program = 0 note.instrument = 1 new_sequence.total_time = new_val new_sequence.tempos.add(qpm=subsequence.tempos[0].qpm) backup_sequence.total_time = backup_val backup_sequence.tempos.add(qpm=60) music_dict['sequence'] = subsequence music_dict['backup_sequence'] = backup_sequence elif model_string == "music_transformer": # model generate will take care of things music_dict['sequence'] = sequence return music_dict
# Loading model checkpoint_dir_or_path = os.path.expanduser(checkpoint_file) model = TrainedModel(config, batch_size=8, checkpoint_dir_or_path=checkpoint_dir_or_path) input_midi_1 = os.path.expanduser(input_files_list[style_name.index( arguments['<style1>'])]) input_midi_2 = os.path.expanduser(input_files_list[style_name.index( arguments['<style2>'])]) input_midi_3 = os.path.expanduser(input_files_list[style_name.index( arguments['<style3>'])]) input_midi_4 = os.path.expanduser(input_files_list[style_name.index( arguments['<style4>'])]) input_1 = mm.midi_file_to_note_sequence(input_midi_1) input_2 = mm.midi_file_to_note_sequence(input_midi_2) input_3 = mm.midi_file_to_note_sequence(input_midi_3) input_4 = mm.midi_file_to_note_sequence(input_midi_4) #_check_extract_examples(input_1, path_midi_1, 1) #_check_extract_examples(input_2, path_midi_2, 2) #_, mu, _ = model.encode([input_1, input_2]) z, mu, _ = model.encode([input_1, input_2, input_3, input_4]) # Get the new 'z' with the interpolation values z_new = z[0] * float(arguments['<val1>']) + z[1] * float( arguments['<val2>']) + z[2] * float(arguments['<val3>']) + z[3] * float( arguments['<val4>']) z_new_2 = z_new + 0.05 z_new = np.expand_dims(z_new, axis=0)
def run(config_map): """Load model params, save config file and start trainer. Args: config_map: Dictionary mapping configuration name to Config object. Raises: ValueError: if required flags are missing or invalid. """ date_and_time = time.strftime('%Y-%m-%d_%H%M%S') if FLAGS.run_dir is None == FLAGS.checkpoint_file is None: raise ValueError( 'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.') if FLAGS.output_dir is None: raise ValueError('`--output_dir` is required.') tf.gfile.MakeDirs(FLAGS.output_dir) if FLAGS.mode != 'sample' and FLAGS.mode != 'interpolate': raise ValueError('Invalid value for `--mode`: %s' % FLAGS.mode) if FLAGS.config not in config_map: raise ValueError('Invalid config name: %s' % FLAGS.config) config = config_map[FLAGS.config] config.data_converter.max_tensors_per_item = None if FLAGS.mode == 'interpolate': if FLAGS.input_midi_1 is None or FLAGS.input_midi_2 is None: raise ValueError( '`--input_midi_1` and `--input_midi_2` must be specified in ' '`interpolate` mode.') input_midi_1 = os.path.expanduser(FLAGS.input_midi_1) input_midi_2 = os.path.expanduser(FLAGS.input_midi_2) if not os.path.exists(input_midi_1): raise ValueError('Input MIDI 1 not found: %s' % FLAGS.input_midi_1) if not os.path.exists(input_midi_2): raise ValueError('Input MIDI 2 not found: %s' % FLAGS.input_midi_2) input_1 = mm.midi_file_to_note_sequence(input_midi_1) input_2 = mm.midi_file_to_note_sequence(input_midi_2) def _check_extract_examples(input_ns, path, input_number): """Make sure each input returns exactly one example from the converter.""" tensors = config.data_converter.to_tensors(input_ns).outputs if not tensors: print( 'MusicVAE configs have very specific input requirements. Could not ' 'extract any valid inputs from `%s`. Try another MIDI file.' % path) sys.exit() elif len(tensors) > 1: basename = os.path.join( FLAGS.output_dir, '%s_input%d-extractions_%s-*-of-%03d.mid' % (FLAGS.config, input_number, date_and_time, len(tensors))) for i, ns in enumerate(config.data_converter.to_notesequences(tensors)): mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i)) print( '%d valid inputs extracted from `%s`. Outputting these potential ' 'inputs as `%s`. Call script again with one of these instead.' % (len(tensors), path, basename)) sys.exit() logging.info( 'Attempting to extract examples from input MIDIs using config `%s`...', FLAGS.config) _check_extract_examples(input_1, FLAGS.input_midi_1, 1) _check_extract_examples(input_2, FLAGS.input_midi_2, 2) logging.info('Loading model...') if FLAGS.run_dir: checkpoint_dir_or_path = os.path.expanduser( os.path.join(FLAGS.run_dir, 'train')) else: checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file) model = TrainedModel( config, batch_size=min(FLAGS.max_batch_size, FLAGS.num_outputs), checkpoint_dir_or_path=checkpoint_dir_or_path) if FLAGS.mode == 'interpolate': logging.info('Interpolating...') _, mu, _ = model.encode([input_1, input_2]) z = np.array([ _slerp(mu[0], mu[1], t) for t in np.linspace(0, 1, FLAGS.num_outputs)]) results = model.decode( length=config.hparams.max_seq_len, z=z, temperature=FLAGS.temperature) elif FLAGS.mode == 'sample': logging.info('Sampling...') results = model.sample( n=FLAGS.num_outputs, length=config.hparams.max_seq_len, temperature=FLAGS.temperature) basename = os.path.join( FLAGS.output_dir, '%s_%s_%s-*-of-%03d.mid' % (FLAGS.config, FLAGS.mode, date_and_time, FLAGS.num_outputs)) logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename) for i, ns in enumerate(results): mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i)) logging.info('Done.')
def start(self): init_contents() while True: self.print_controls() wait_for_user_input() if input.user_input == "empty": continue if input.user_input == "1": print() create_midi_samples() elif input.user_input == "2": print() input_sequence = twinkle_twinkle() num_steps = 128 temperature = 1.0 model_name = 'basic_rnn' generate_continue_for("twinkle_twinkle", input_sequence, model_name, num_steps, temperature) model_name = 'attention_rnn' generate_continue_for("twinkle_twinkle", input_sequence, model_name, num_steps, temperature) model_name = 'lookback_rnn' generate_continue_for("twinkle_twinkle", input_sequence, model_name, num_steps, temperature) model_name = 'mono_rnn' generate_continue_for("twinkle_twinkle", input_sequence, model_name, num_steps, temperature) elif input.user_input == "3": print() input_sequence = teapot() num_steps = 128 temperature = 1.0 model_name = 'basic_rnn' generate_continue_for("teapot", input_sequence, model_name, num_steps, temperature) model_name = 'attention_rnn' generate_continue_for("teapot", input_sequence, model_name, num_steps, temperature) model_name = 'lookback_rnn' generate_continue_for("teapot", input_sequence, model_name, num_steps, temperature) model_name = 'mono_rnn' generate_continue_for("teapot", input_sequence, model_name, num_steps, temperature) elif input.user_input == "4": print() if not os.path.isfile("./content/cat-mel_2bar_big.ckpt.data-00000-of-00001") \ or not os.path.isfile("./content/cat-mel_2bar_big.ckpt.index"): print("models for interpolate doesnt find!") return else: model_name = 'cat-mel_2bar_big' music_vae = init_music_vae(model_name) num_steps = 8 length = 32 generate_interpolation_for(model_name, music_vae, num_steps, length, twinkle_twinkle(), teapot()) elif input.user_input == "5": print() path = "./input" check_dir(path) check_dir("./output") for file in glob.glob(path + "/*.mid"): name = os.path.splitext(os.path.basename(file))[0] print(name) input_sequence = mm.midi_file_to_note_sequence(file) num_steps = 1028 temperature = 1.0 model_name = 'basic_rnn' generate_continue_for(name, input_sequence, model_name, num_steps, temperature) model_name = 'attention_rnn' generate_continue_for(name, input_sequence, model_name, num_steps, temperature) model_name = 'lookback_rnn' generate_continue_for(name, input_sequence, model_name, num_steps, temperature) model_name = 'mono_rnn' generate_continue_for(name, input_sequence, model_name, num_steps, temperature) elif input.user_input == "6": print("6 input") path = "./input" check_dir(path) check_dir("./output") for file in glob.glob(path + "/*.mid"): name = os.path.splitext(os.path.basename(file))[0] print(name) input_sequence = mm.midi_file_to_note_sequence(file) num_steps = 1028 temperature = 1.0 model_name = 'polyphony' polyphony_rnn = initialisation_polyphony(model_name) generate_continue_for_polyphony(input_sequence, model_name, name, num_steps, polyphony_rnn, temperature) # elif input.user_input == "7": # print("7 input") # elif input.user_input == "8": # print("8 input") # elif input.user_input == "9": # print("9 input") elif input.user_input == "0": print() print_versions() elif input.user_input == "esc": print("ESC pressed, exit") break
#@markdown Because we use a #@markdown [representation](http://g.co/magenta/performance-rnn) #@markdown where each event corresponds to a variable amount of #@markdown time, the actual number of seconds generated may vary. targets = [] decode_length = 1024 # Generate sample events. sample_ids = next(unconditional_samples)['outputs'] # Decode to NoteSequence. midi_filename = decode( sample_ids, encoder=unconditional_encoders['targets']) unconditional_ns = mm.midi_file_to_note_sequence(midi_filename) # Play and plot. mm.play_sequence( unconditional_ns, synth=mm.fluidsynth, sample_rate=SAMPLE_RATE, sf2_path=SF2_PATH) mm.plot_sequence(unconditional_ns) #@title Download Performance as MIDI #@markdown Download generated performance as MIDI (optional). mm.sequence_proto_to_midi_file( unconditional_ns, '/tmp/unconditional.mid') files.download('/tmp/unconditional.mid') #@title Choose Priming Sequence
def run(config_map): """Load model params, save config file and start trainer. Args: config_map: Dictionary mapping configuration name to Config object. Raises: ValueError: if required flags are missing or invalid. """ date_and_time = time.strftime('%Y-%m-%d_%H%M%S') if FLAGS.run_dir is None == FLAGS.checkpoint_file is None: raise ValueError( 'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.' ) if FLAGS.output_dir is None: raise ValueError('`--output_dir` is required.') tf.gfile.MakeDirs(FLAGS.output_dir) if FLAGS.mode != 'sample' and FLAGS.mode != 'interpolate' and FLAGS.mode != 'isample': raise ValueError('Invalid value for `--mode`: %s' % FLAGS.mode) if FLAGS.config not in config_map: raise ValueError('Invalid config name: %s' % FLAGS.config) config = config_map[FLAGS.config] config.data_converter.max_tensors_per_item = None if FLAGS.mode == 'interpolate': if FLAGS.input_midi_1 is None or FLAGS.input_midi_2 is None: raise ValueError( '`--input_midi_1` and `--input_midi_2` must be specified in ' '`interpolate` mode.') input_midi_1 = os.path.expanduser(FLAGS.input_midi_1) input_midi_2 = os.path.expanduser(FLAGS.input_midi_2) if not os.path.exists(input_midi_1): raise ValueError('Input MIDI 1 not found: %s' % FLAGS.input_midi_1) if not os.path.exists(input_midi_2): raise ValueError('Input MIDI 2 not found: %s' % FLAGS.input_midi_2) input_1 = mm.midi_file_to_note_sequence(input_midi_1) input_2 = mm.midi_file_to_note_sequence(input_midi_2) def _check_extract_examples(input_ns, path, input_number): """Make sure each input returns exactly one example from the converter.""" tensors = config.data_converter.to_tensors(input_ns).outputs if not tensors: print( 'MusicVAE configs have very specific input requirements. Could not ' 'extract any valid inputs from `%s`. Try another MIDI file.' % path) sys.exit() elif len(tensors) > 1: basename = os.path.join( FLAGS.output_dir, '%s_input%d-extractions_%s-*-of-%03d.mid' % (FLAGS.config, input_number, date_and_time, len(tensors))) for i, ns in enumerate( config.data_converter.to_notesequences(tensors)): mm.sequence_proto_to_midi_file( ns, basename.replace('*', '%03d' % i)) print( '%d valid inputs extracted from `%s`. Outputting these potential ' 'inputs as `%s`. Call script again with one of these instead.' % (len(tensors), path, basename)) sys.exit() logging.info( 'Attempting to extract examples from input MIDIs using config `%s`...', FLAGS.config) _check_extract_examples(input_1, FLAGS.input_midi_1, 1) _check_extract_examples(input_2, FLAGS.input_midi_2, 2) logging.info('Loading model...') if FLAGS.run_dir: checkpoint_dir_or_path = os.path.expanduser( os.path.join(FLAGS.run_dir, 'train')) else: checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file) model = TrainedModel(config, batch_size=min(FLAGS.max_batch_size, FLAGS.num_outputs), checkpoint_dir_or_path=checkpoint_dir_or_path) if FLAGS.mode == 'interpolate': logging.info('Interpolating...') _, mu, _ = model.encode([input_1, input_2]) z = np.array([ _slerp(mu[0], mu[1], t) for t in np.linspace(0, 1, FLAGS.num_outputs) ]) results = model.decode(length=config.hparams.max_seq_len, z=z, temperature=FLAGS.temperature) elif FLAGS.mode == 'sample': logging.info('Sampling...') results = model.sample(n=FLAGS.num_outputs, length=config.hparams.max_seq_len, temperature=FLAGS.temperature) elif FLAGS.mode == 'isample': assert FLAGS.input_image is not None, 'Provide an image to sample from' assert FLAGS.input_midi_1 is not None, 'Provide a music to sample from' logging.info('Sampling z from image vae...') img = cv2.imread(FLAGS.input_image) / 255. img = np.asarray(cv2.resize(img, (320, 240))) img = np.expand_dims(img, axis=0) print(img.shape) latent = None input_midi_1 = os.path.expanduser(FLAGS.input_midi_1) input_1 = mm.midi_file_to_note_sequence(input_midi_1) def _check_extract_examples(input_ns, path, input_number): """Make sure each input returns exactly one example from the converter.""" tensors = config.data_converter.to_tensors(input_ns).outputs if not tensors: print( 'MusicVAE configs have very specific input requirements. Could not ' 'extract any valid inputs from `%s`. Try another MIDI file.' % path) sys.exit() elif len(tensors) > 1: basename = os.path.join( FLAGS.output_dir, '%s_input%d-extractions_%s-*-of-%03d.mid' % (FLAGS.config, input_number, date_and_time, len(tensors))) for i, ns in enumerate( config.data_converter.to_notesequences(tensors)): mm.sequence_proto_to_midi_file( ns, basename.replace('*', '%03d' % i)) print( '%d valid inputs extracted from `%s`. Outputting these potential ' 'inputs as `%s`. Call script again with one of these instead.' % (len(tensors), path, basename)) sys.exit() logging.info( 'Attempting to extract examples from input MIDIs using config `%s`...', FLAGS.config) _check_extract_examples(input_1, FLAGS.input_midi_1, 1) with model._sess as sess: z_music, mu_music, sigma_music = model.encode([input_1]) dataset = tf.data.Dataset.from_tensors(img.astype(np.float32)) img = dataset.repeat().make_one_shot_iterator().get_next() mu, sigma = model.vae.encode(img, config.hparams) mu = mu.eval() sigma = sigma.eval() latent = ds.MultivariateNormalDiag(loc=mu + mu_music, scale_diag=sigma + sigma_music).sample().eval() results = model.decode(length=config.hparams.max_seq_len, z=latent, temperature=FLAGS.temperature) print(results) basename = os.path.join( FLAGS.output_dir, '%s_%s_%s-*-of-%03d.mid' % (FLAGS.config, FLAGS.mode, date_and_time, FLAGS.num_outputs)) logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename) for i, ns in enumerate(results): mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i)) logging.info('Done.')
def get_parser(_=None): parser = argparse.ArgumentParser("vae_groove") parser.add_argument("--model_name", type=str, default="groovae_2bar_humanize") parser.add_argument("--input_midi", type=str) parser.add_argument("--num_bar_per_sample", type=int, default=2) parser.add_argument("--num_steps_per_bar", type=int, default=DEFAULT_STEPS_PER_BAR) parser.add_argument("--num_output", type=int, default=6) parser.add_argument("--output_root_dir", type=str) return parser if __name__ == "__main__": known_args, _ = get_parser().parse_known_args() output_root_dir = Path(known_args.output_root_dir).expanduser() if not output_root_dir.exists(): output_root_dir.mkdir(parents=True) total_bars = known_args.num_output * known_args.num_bar_per_sample num_steps_per_sample = known_args.num_bar_per_sample * known_args.num_steps_per_bar core.groove( known_args.model_name, interpolate_sequence=mm.midi_file_to_note_sequence( str(Path(known_args.input_midi).expanduser()) ), num_steps_per_sample=num_steps_per_sample, num_output=known_args.num_output, total_bars=total_bars, output_dir=output_root_dir, )
def music_generator(primer='erik_gnossienne', primer_begin_buffer=10, primer_length=90, output_path='.', filename='./public/output'): SF2_PATH = './models/Yamaha-C5-Salamander-JNv5.1.sf2' SAMPLE_RATE = 16000 # Upload a MIDI file and convert to NoteSequence. def upload_midi(): data = list(files.upload().values()) if len(data) > 1: print('Multiple files uploaded; using only one.') return mm.midi_to_note_sequence(data[0]) # Decode a list of IDs. def decode(ids, encoder): ids = list(ids) if text_encoder.EOS_ID in ids: ids = ids[:ids.index(text_encoder.EOS_ID)] return encoder.decode(ids) model_name = 'transformer' hparams_set = 'transformer_tpu' ckpt_path = './models/checkpoints/unconditional_model_16.ckpt' class PianoPerformanceLanguageModelProblem(score2perf.Score2PerfProblem): @property def add_eos_symbol(self): return True problem = PianoPerformanceLanguageModelProblem() unconditional_encoders = problem.get_feature_encoders() # Set up HParams. hparams = trainer_lib.create_hparams(hparams_set=hparams_set) trainer_lib.add_problem_hparams(hparams, problem) hparams.num_hidden_layers = 16 hparams.sampling_method = 'random' # Set up decoding HParams. decode_hparams = decoding.decode_hparams() decode_hparams.alpha = 0.0 decode_hparams.beam_size = 1 # Create Estimator. run_config = trainer_lib.create_run_config(hparams) estimator = trainer_lib.create_estimator(model_name, hparams, run_config, decode_hparams=decode_hparams) # These values will be changed by subsequent cells. targets = [] decode_length = 0 # Create input generator (so we can adjust priming and # decode length on the fly). def input_generator(): global targets global decode_length while True: yield { 'targets': np.array([targets], dtype=np.int32), 'decode_length': np.array(decode_length, dtype=np.int32) } # Start the Estimator, loading from the specified checkpoint. input_fn = decoding.make_input_fn_from_generator(input_generator()) unconditional_samples = estimator.predict(input_fn, checkpoint_path=ckpt_path) # "Burn" one. _ = next(unconditional_samples) filenames = { 'C major arpeggio': './models/primers/c_major_arpeggio.mid', 'C major scale': './models/primers/c_major_scale.mid', 'Clair de Lune': './models/primers/clair_de_lune.mid', 'Classical': 'audio_midi/Classical_Piano_piano-midi.de_MIDIRip/bach/bach_846_format0.mid', 'erik_gymnopedie': 'audio_midi/erik_satie/gymnopedie_1_(c)oguri.mid', 'erik_gymnopedie_2': 'audio_midi/erik_satie/gymnopedie_2_(c)oguri.mid', 'erik_gymnopedie_3': 'audio_midi/erik_satie/gymnopedie_3_(c)oguri.mid', 'erik_gnossienne': 'audio_midi/erik_satie/gnossienne_1_(c)oguri.mid', 'erik_gnossienne_2': 'audio_midi/erik_satie/gnossienne_2_(c)oguri.mid', 'erik_gnossienne_3': 'audio_midi/erik_satie/gnossienne_3_(c)oguri.mid', 'erik_gnossienne_dery': 'audio_midi/erik_satie/gnossienne_1_(c)dery.mid', 'erik_gnossienne_dery_2': 'audio_midi/erik_satie/gnossienne_2_(c)dery.mid', 'erik_gnossienne_dery_3': 'audio_midi/erik_satie/gnossienne_3_(c)dery.mid', 'erik_gnossienne_dery_5': 'audio_midi/erik_satie/gnossienne_5_(c)dery.mid', 'erik_gnossienne_dery_6': 'audio_midi/erik_satie/gnossienne_6_(c)dery.mid', '1': 'audio_midi/erik_satie/1.mid', '2': 'audio_midi/erik_satie/2.mid', '3': 'audio_midi/erik_satie/3.mid', '4': 'audio_midi/erik_satie/4.mid', '5': 'audio_midi/erik_satie/5.mid', '6': 'audio_midi/erik_satie/6.mid', '7': 'audio_midi/erik_satie/7.mid', '8': 'audio_midi/erik_satie/8.mid', '9': 'audio_midi/erik_satie/9.mid', '10': 'audio_midi/erik_satie/10.mid', } # primer = 'C major scale' #if primer == 'Upload your own!': # primer_ns = upload_midi() #else: # # Use one of the provided primers. # primer_ns = mm.midi_file_to_note_sequence(filenames[primer]) primer_ns = mm.midi_file_to_note_sequence(filenames[primer]) # Handle sustain pedal in the primer. primer_ns = mm.apply_sustain_control_changes(primer_ns) # Trim to desired number of seconds. max_primer_seconds = primer_length if primer_ns.total_time > max_primer_seconds: print('Primer is longer than %d seconds, truncating.' % max_primer_seconds) primer_ns = mm.extract_subsequence( primer_ns, primer_begin_buffer, max_primer_seconds + primer_begin_buffer) # Remove drums from primer if present. if any(note.is_drum for note in primer_ns.notes): print('Primer contains drums; they will be removed.') notes = [note for note in primer_ns.notes if not note.is_drum] del primer_ns.notes[:] primer_ns.notes.extend(notes) # Set primer instrument and program. for note in primer_ns.notes: note.instrument = 1 note.program = 0 ## Play and plot the primer. #mm.play_sequence( # primer_ns, # synth=mm.fluidsynth, sample_rate=SAMPLE_RATE, sf2_path=SF2_PATH) #mm.plot_sequence(primer_ns) mm.sequence_proto_to_midi_file( primer_ns, join(output_path, 'primer_{}.mid'.format(filename))) targets = unconditional_encoders['targets'].encode_note_sequence(primer_ns) # Remove the end token from the encoded primer. targets = targets[:-1] decode_length = max(0, 10000 - len(targets)) if len(targets) >= 4096: print( 'Primer has more events than maximum sequence length; nothing will be generated.' ) # Generate sample events. sample_ids = next(unconditional_samples)['outputs'] # Decode to NoteSequence. midi_filename = decode(sample_ids, encoder=unconditional_encoders['targets']) ns = mm.midi_file_to_note_sequence(midi_filename) print('Sample IDs: {}'.format(sample_ids)) print('Sample IDs length: {}'.format(len(sample_ids))) print('Encoder: {}'.format(unconditional_encoders['targets'])) print('Unconditional Samples: {}'.format(unconditional_samples)) # print('{}'.format(ns)) # continuation_ns = mm.concatenate_sequences([primer_ns, ns]) continuation_ns = ns # mm.play_sequence( # continuation_ns, # synth=mm.fluidsynth, sample_rate=SAMPLE_RATE, sf2_path=SF2_PATH) # mm.plot_sequence(continuation_ns) # try: audio = mm.fluidsynth(continuation_ns, sample_rate=SAMPLE_RATE, sf2_path=SF2_PATH) normalizer = float(np.iinfo(np.int16).max) array_of_ints = np.array(np.asarray(audio) * normalizer, dtype=np.int16) wavfile.write(join(output_path, filename + '.wav'), SAMPLE_RATE, array_of_ints) print('[+] Output stored as {}'.format(filename + '.wav')) mm.sequence_proto_to_midi_file( continuation_ns, join(output_path, 'continuation_{}.mid'.format(filename)))
def run(config_map): """Load model params, save config file and start trainer. Args: config_map: Dictionary mapping configuration name to Config object. Raises: ValueError: if required flags are missing or invalid. """ date_and_time = time.strftime('%Y-%m-%d_%H%M%S') if (FLAGS.run_dir is None) == (FLAGS.checkpoint_file is None): raise ValueError( 'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.' ) if FLAGS.output_dir is None: raise ValueError('`--output_dir` is required.') tf.gfile.MakeDirs(FLAGS.output_dir) if FLAGS.mode != 'sample' and FLAGS.mode != 'interpolate': raise ValueError('Invalid value for `--mode`: %s' % FLAGS.mode) if FLAGS.config not in config_map: raise ValueError('Invalid config name: %s' % FLAGS.config) config = config_map[FLAGS.config] config.data_converter.max_tensors_per_item = None if FLAGS.mode == 'interpolate': if FLAGS.input_midi_1 is None or FLAGS.input_midi_2 is None: raise ValueError( '`--input_midi_1` and `--input_midi_2` must be specified in ' '`interpolate` mode.') input_midi_1 = os.path.expanduser(FLAGS.input_midi_1) input_midi_2 = os.path.expanduser(FLAGS.input_midi_2) if not os.path.exists(input_midi_1): raise ValueError('Input MIDI 1 not found: %s' % FLAGS.input_midi_1) if not os.path.exists(input_midi_2): raise ValueError('Input MIDI 2 not found: %s' % FLAGS.input_midi_2) input_1 = mm.midi_file_to_note_sequence(input_midi_1) input_2 = mm.midi_file_to_note_sequence(input_midi_2) def _check_extract_examples(input_ns, path, input_number): """Make sure each input returns exactly one example from the converter.""" tensors = config.data_converter.to_tensors(input_ns).outputs if not tensors: print( 'MusicVAE configs have very specific input requirements. Could not ' 'extract any valid inputs from `%s`. Try another MIDI file.' % path) sys.exit() elif len(tensors) > 1: basename = os.path.join( FLAGS.output_dir, '%s_input%d-extractions_%s-*-of-%03d.mid' % (FLAGS.config, input_number, date_and_time, len(tensors))) for i, ns in enumerate( config.data_converter.from_tensors(tensors)): mm.sequence_proto_to_midi_file( ns, basename.replace('*', '%03d' % i)) print( '%d valid inputs extracted from `%s`. Outputting these potential ' 'inputs as `%s`. Call script again with one of these instead.' % (len(tensors), path, basename)) sys.exit() logging.info( 'Attempting to extract examples from input MIDIs using config `%s`...', FLAGS.config) _check_extract_examples(input_1, FLAGS.input_midi_1, 1) _check_extract_examples(input_2, FLAGS.input_midi_2, 2) logging.info('Loading model...') if FLAGS.run_dir: checkpoint_dir_or_path = os.path.expanduser( os.path.join(FLAGS.run_dir, 'train')) else: checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file) model = TrainedModel(config, batch_size=min(FLAGS.max_batch_size, FLAGS.num_outputs), checkpoint_dir_or_path=checkpoint_dir_or_path) if FLAGS.mode == 'interpolate': logging.info('Interpolating...') _, mu, _ = model.encode([input_1, input_2]) z = np.array([ _slerp(mu[0], mu[1], t) for t in np.linspace(0, 1, FLAGS.num_outputs) ]) results = model.decode(length=config.hparams.max_seq_len, z=z, temperature=FLAGS.temperature) elif FLAGS.mode == 'sample': logging.info('Sampling...') results = model.sample(n=FLAGS.num_outputs, length=config.hparams.max_seq_len, temperature=FLAGS.temperature) basename = os.path.join( FLAGS.output_dir, '%s_%s_%s-*-of-%03d.mid' % (FLAGS.config, FLAGS.mode, date_and_time, FLAGS.num_outputs)) logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename) for i, ns in enumerate(results): mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i)) logging.info('Done.')