def initialize_session(acoustic_checkpoint, hparams): """Initializes a transcription session.""" with tf.Graph().as_default(): examples = tf.placeholder(tf.string, [None]) hparams.batch_size = 1 batch, iterator = data.provide_batch( batch_size=1, examples=examples, hparams=hparams, is_training=False, truncated_length=0) model.get_model(batch, hparams, is_training=False) session = tf.Session() saver = tf.train.Saver() saver.restore(session, acoustic_checkpoint) onset_probs_flat = tf.get_default_graph().get_tensor_by_name( 'onsets/onset_probs_flat:0') frame_probs_flat = tf.get_default_graph().get_tensor_by_name( 'frame_probs_flat:0') velocity_values_flat = tf.get_default_graph().get_tensor_by_name( 'velocity/velocity_values_flat:0') return TranscriptionSession( session=session, examples=examples, iterator=iterator, onset_probs_flat=onset_probs_flat, frame_probs_flat=frame_probs_flat, velocity_values_flat=velocity_values_flat, hparams=hparams)
def initialize_session(acoustic_checkpoint, hparams): """Initializes a transcription session.""" with tf.Graph().as_default(): examples = tf.placeholder(tf.string, [None]) batch, iterator = data.provide_batch(batch_size=1, examples=examples, hparams=hparams, is_training=False, truncated_length=0) model.get_model(batch, hparams, is_training=False) session = tf.Session() saver = tf.train.Saver() saver.restore(session, acoustic_checkpoint) onset_probs_flat = tf.get_default_graph().get_tensor_by_name( 'onsets/onset_probs_flat:0') frame_probs_flat = tf.get_default_graph().get_tensor_by_name( 'frame_probs_flat:0') velocity_values_flat = tf.get_default_graph().get_tensor_by_name( 'velocity/velocity_values_flat:0') return TranscriptionSession(session=session, examples=examples, iterator=iterator, onset_probs_flat=onset_probs_flat, frame_probs_flat=frame_probs_flat, velocity_values_flat=velocity_values_flat, hparams=hparams)
def __init__(self, path='onsets-frames'): """Load the Onset-Frames Model (arXiv:1710.11153 [cs.SD]) and pretrained weights from the path using tensorflow and magenta. Args: path (str, optional): The path the model weights. Defaults to 'onsets-frames'. """ tf.disable_eager_execution() tf.disable_v2_behavior() tf.logging.set_verbosity(tf.logging.ERROR) self.config = configs.CONFIG_MAP['onsets_frames'] self.hparams = self.config.hparams self.hparams.use_cudnn = False self.hparams.batch_size = 1 self.checkpoint_dir = path self.examples = tf.placeholder(tf.string, [None]) self.dataset = data.provide_batch(examples=self.examples, preprocess_examples=True, params=self.hparams, is_training=False, shuffle_examples=False, skip_n_initial_records=0) self.estimator = train_util.create_estimator(self.config.model_fn, self.checkpoint_dir, self.hparams) self.iterator = tf.data.make_initializable_iterator(self.dataset) self.next_record = self.iterator.get_next()
def _get_data(examples_path, hparams, is_training): """Gets transcription data.""" hparams_dict = hparams.values() return data.provide_batch( hparams.batch_size, examples=examples_path, hparams=hparams, truncated_length=hparams_dict.get('truncated_length', None), is_training=is_training)
def _get_data(examples_path, hparams, is_training): hparams_dict = hparams.values() batch, _ = data.provide_batch(hparams.batch_size, examples=examples_path, hparams=hparams, truncated_length=hparams_dict.get( 'truncated_length', None), is_training=is_training) return batch
def _get_data(examples_path, hparams, is_training): """Gets transcription data.""" hparams_dict = hparams.values() return data.provide_batch(hparams.batch_size, examples=examples_path, hparams=hparams, truncated_length=hparams_dict.get( 'truncated_length', None), is_training=is_training)
def _get_data(examples_path, hparams, is_training): """Gets transcription data.""" hparams_dict = hparams.values() batch, _ = data.provide_batch( hparams.batch_size, examples=examples_path, hparams=hparams, truncated_length=hparams_dict.get('truncated_length', None), is_training=is_training, include_note_sequences=hparams_dict.get('include_events', False)) return batch
def _get_data(examples_path, hparams, is_training): """Gets transcription data.""" hparams_dict = hparams.values() batch, _ = data.provide_batch( hparams.batch_size, examples=examples_path, hparams=hparams, truncated_length=hparams_dict.get('truncated_length', None), is_training=is_training, include_note_sequences=hparams_dict.get('include_events', False)) return batch
def _get_data(examples, preprocess_examples, params, is_training, semisupervised_configs=None): """Gets transcription data.""" return data.provide_batch(examples=examples, preprocess_examples=preprocess_examples, hparams=params, is_training=is_training, semisupervised_configs=semisupervised_configs)
def _ValidateProvideBatch(self, examples, truncated_length, batch_size, expected_inputs, feed_dict=None): """Tests for correctness of batches.""" hparams = copy.deepcopy(configs.DEFAULT_HPARAMS) hparams.batch_size = batch_size hparams.truncated_length_secs = ( truncated_length / data.hparams_frames_per_second(hparams)) with self.test_session() as sess: dataset = data.provide_batch(examples=examples, preprocess_examples=True, params=hparams, is_training=False, shuffle_examples=False, skip_n_initial_records=0) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() sess.run([ tf.initializers.local_variables(), tf.initializers.global_variables(), iterator.initializer ], feed_dict=feed_dict) for i in range(0, len(expected_inputs), batch_size): # Wait to ensure example is pre-processed. time.sleep(0.1) features, labels = sess.run(next_record) inputs = [ features.spec, labels.labels, features.length, features.sequence_id ] max_length = np.max(inputs[2]) for j in range(batch_size): # Add batch padding if needed. input_length = expected_inputs[i + j][2] if input_length < max_length: expected_inputs[i + j] = list(expected_inputs[i + j]) pad_amt = max_length - input_length expected_inputs[i + j][0] = np.pad( expected_inputs[i + j][0], [(0, pad_amt), (0, 0)], 'constant') expected_inputs[i + j][1] = np.pad( expected_inputs[i + j][1], [(0, pad_amt), (0, 0)], 'constant') for exp_input, input_ in zip(expected_inputs[i + j], inputs): self.assertAllEqual(np.squeeze(exp_input), np.squeeze(input_[j])) with self.assertRaisesOpError('End of sequence'): _ = sess.run(next_record)
def _get_data(examples, preprocess_examples, params, is_training, shuffle_examples=None, skip_n_initial_records=0, semisupervised_configs=None): """Gets transcription data.""" return data.provide_batch( examples=examples, preprocess_examples=preprocess_examples, hparams=params, is_training=is_training, semisupervised_configs=semisupervised_configs, shuffle_examples=shuffle_examples, skip_n_initial_records=skip_n_initial_records)
def _ValidateProvideBatch(self, examples, truncated_length, batch_size, expected_inputs, crop_training_sequence_to_notes=False): """Tests for correctness of batches.""" hparams = copy.deepcopy(constants.DEFAULT_HPARAMS) hparams.crop_training_sequence_to_notes = crop_training_sequence_to_notes with self.test_session() as sess: batch, _ = data.provide_batch(batch_size=batch_size, examples=examples, hparams=hparams, truncated_length=truncated_length, is_training=False) sess.run(tf.local_variables_initializer()) input_tensors = [ batch.spec, batch.labels, batch.lengths, batch.filenames, batch.max_length ] self.assertEqual( len(expected_inputs) // batch_size, batch.num_batches) for i in range(0, batch.num_batches * batch_size, batch_size): # Wait to ensure example is pre-processed. time.sleep(0.1) inputs = sess.run(input_tensors) max_length = np.max(inputs[2]) self.assertEqual(inputs[4], max_length) inputs = inputs[0:-1] for j in range(batch_size): # Add batch padding if needed. input_length = expected_inputs[i + j][2] if input_length < max_length: expected_inputs[i + j] = list(expected_inputs[i + j]) pad_amt = max_length - input_length expected_inputs[i + j][0] = np.pad( expected_inputs[i + j][0], [(0, pad_amt), (0, 0)], 'constant') expected_inputs[i + j][1] = np.pad( expected_inputs[i + j][1], [(0, pad_amt), (0, 0)], 'constant') for exp_input, input_ in zip(expected_inputs[i + j], inputs): self.assertAllEqual(np.squeeze(exp_input), np.squeeze(input_[j])) with self.assertRaisesOpError('End of sequence'): _ = sess.run(input_tensors)
def _get_data(examples, preprocess_examples, params, is_training, shuffle_examples=None, skip_n_initial_records=0, semisupervised_configs=None): """Gets transcription data.""" return data.provide_batch(examples=examples, preprocess_examples=preprocess_examples, hparams=params, is_training=is_training, semisupervised_configs=semisupervised_configs, shuffle_examples=shuffle_examples, skip_n_initial_records=skip_n_initial_records)
def _ValidateProvideBatch(self, examples, truncated_length, batch_size, expected_inputs, feed_dict=None): """Tests for correctness of batches.""" hparams = copy.deepcopy(configs.DEFAULT_HPARAMS) hparams.batch_size = batch_size hparams.truncated_length_secs = ( truncated_length / data.hparams_frames_per_second(hparams)) with self.test_session() as sess: dataset = data.provide_batch( examples=examples, preprocess_examples=True, hparams=hparams, is_training=False) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() sess.run([ tf.initializers.local_variables(), tf.initializers.global_variables(), iterator.initializer ], feed_dict=feed_dict) for i in range(0, len(expected_inputs), batch_size): # Wait to ensure example is pre-processed. time.sleep(0.1) features, labels = sess.run(next_record) inputs = [ features.spec, labels.labels, features.length, features.sequence_id] max_length = np.max(inputs[2]) for j in range(batch_size): # Add batch padding if needed. input_length = expected_inputs[i + j][2] if input_length < max_length: expected_inputs[i + j] = list(expected_inputs[i + j]) pad_amt = max_length - input_length expected_inputs[i + j][0] = np.pad( expected_inputs[i + j][0], [(0, pad_amt), (0, 0)], 'constant') expected_inputs[i + j][1] = np.pad( expected_inputs[i + j][1], [(0, pad_amt), (0, 0)], 'constant') for exp_input, input_ in zip(expected_inputs[i + j], inputs): self.assertAllEqual(np.squeeze(exp_input), np.squeeze(input_[j])) with self.assertRaisesOpError('End of sequence'): _ = sess.run(next_record)
def validateProvideBatch(self, examples_path, truncated_length, batch_size, expected_inputs): """Tests for correctness of batches.""" hparams = copy.deepcopy(constants.DEFAULT_HPARAMS) with self.test_session() as sess: batch = data.provide_batch(batch_size=batch_size, examples_path=examples_path, hparams=hparams, truncated_length=truncated_length, is_training=False, batch_threads=1) sess.run(tf.local_variables_initializer()) input_tensors = [ batch.spec, batch.labels, batch.lengths, batch.filenames ] self.assertEqual( len(expected_inputs) // batch_size, batch.num_batches) with tf.contrib.slim.queues.QueueRunners(sess): for i in range(0, batch.num_batches * batch_size, batch_size): # Wait to ensure example is pre-processed. time.sleep(0.1) inputs = sess.run(input_tensors) max_length = np.max(inputs[2]) for j in range(batch_size): # Add batch padding if needed. input_length = expected_inputs[i + j][2] if input_length < max_length: expected_inputs[i + j] = list(expected_inputs[i + j]) pad_amt = max_length - input_length expected_inputs[i + j][0] = np.pad( expected_inputs[i + j][0], [(0, pad_amt), (0, 0)], 'constant') expected_inputs[i + j][1] = np.pad( expected_inputs[i + j][1], [(0, pad_amt), (0, 0)], 'constant') for exp_input, input_ in zip(expected_inputs[i + j], inputs): self.assertAllEqual(np.squeeze(exp_input), np.squeeze(input_[j])) with self.assertRaisesOpError( 'is closed and has insufficient elements ' '\\(requested %d, current size %d\\)' % (batch_size, len(expected_inputs) % batch_size)): _ = sess.run(input_tensors)
def _ValidateProvideBatch(self, examples, truncated_length, batch_size, expected_inputs, crop_training_sequence_to_notes=False): """Tests for correctness of batches.""" hparams = copy.deepcopy(constants.DEFAULT_HPARAMS) hparams.crop_training_sequence_to_notes = crop_training_sequence_to_notes with self.test_session() as sess: batch, _ = data.provide_batch( batch_size=batch_size, examples=examples, hparams=hparams, truncated_length=truncated_length, is_training=False) sess.run(tf.local_variables_initializer()) input_tensors = [ batch.spec, batch.labels, batch.lengths, batch.filenames, batch.max_length ] self.assertEqual(len(expected_inputs) // batch_size, batch.num_batches) for i in range(0, batch.num_batches * batch_size, batch_size): # Wait to ensure example is pre-processed. time.sleep(0.1) inputs = sess.run(input_tensors) max_length = np.max(inputs[2]) self.assertEqual(inputs[4], max_length) inputs = inputs[0:-1] for j in range(batch_size): # Add batch padding if needed. input_length = expected_inputs[i + j][2] if input_length < max_length: expected_inputs[i + j] = list(expected_inputs[i + j]) pad_amt = max_length - input_length expected_inputs[i + j][0] = np.pad( expected_inputs[i + j][0], [(0, pad_amt), (0, 0)], 'constant') expected_inputs[i + j][1] = np.pad( expected_inputs[i + j][1], [(0, pad_amt), (0, 0)], 'constant') for exp_input, input_ in zip(expected_inputs[i + j], inputs): self.assertAllEqual(np.squeeze(exp_input), np.squeeze(input_[j])) with self.assertRaisesOpError('End of sequence'): _ = sess.run(input_tensors)
def transcribe(audio, sr, cuda=False): """ Google sucks and want to use audio path (raw wav) instead of decoded samples loosing in decoupling between file format and DSP input audio and sample rate, output mat like asmd with (pitch, ons, offs, velocity) """ # simple hack because google sucks... in this way we can accept audio data # already loaded and keep our reasonable interface (and decouple i/o # from processing) original_google_sucks = audio_io.wav_data_to_samples audio_io.wav_data_to_samples = google_sucks audio = np.array(audio) config = configs.CONFIG_MAP['onsets_frames'] hparams = config.hparams hparams.use_cudnn = cuda hparams.batch_size = 1 examples = tf.placeholder(tf.string, [None]) dataset = data.provide_batch(examples=examples, preprocess_examples=True, params=hparams, is_training=False, shuffle_examples=False, skip_n_initial_records=0) estimator = train_util.create_estimator(config.model_fn, CHECKPOINT_DIR, hparams) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() example_list = list( audio_label_data_utils.process_record(wav_data=audio, sample_rate=sr, ns=music_pb2.NoteSequence(), example_id="fakeid", min_length=0, max_length=-1, allow_empty_notesequence=True, load_audio_with_librosa=False)) assert len(example_list) == 1 to_process = [example_list[0].SerializeToString()] sess = tf.Session() sess.run([ tf.initializers.global_variables(), tf.initializers.local_variables() ]) sess.run(iterator.initializer, {examples: to_process}) def transcription_data(params): del params return tf.data.Dataset.from_tensors(sess.run(next_record)) # put back the original function (it still writes and reload... stupid # though audio_io.wav_data_to_samples = original_google_sucks input_fn = infer_util.labels_to_features_wrapper(transcription_data) prediction_list = list( estimator.predict(input_fn, yield_single_examples=False)) assert len(prediction_list) == 1 notes = music_pb2.NoteSequence.FromString( prediction_list[0]['sequence_predictions'][0]).notes out = np.empty((len(notes), 4)) for i, note in enumerate(notes): out[i] = [note.pitch, note.start_time, note.end_time, note.velocity] return out
def _get_data(examples, preprocess_examples, params, is_training): """Gets transcription data.""" return data.provide_batch(examples=examples, preprocess_examples=preprocess_examples, hparams=params, is_training=is_training)
# Checkpoint 경로 설정 CHECKPOINT_DIR = '../train' # 하이퍼 파라미터 설정 config = configs.CONFIG_MAP['onsets_frames'] hparams = config.hparams hparams.use_cudnn = False hparams.batch_size = 1 # Placeholder 설정 examples = tf.placeholder(tf.string, [None]) # 배치 생성 dataset = data.provide_batch(examples=examples, preprocess_examples=True, params=hparams, is_training=False, shuffle_examples=False, skip_n_initial_records=0) # Estimator 생성 estimator = train_util.create_estimator( config.model_fn, CHECKPOINT_DIR, hparams) # Iterator 생성 iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() # 세션 생성 sess = tf.Session() # 세션 초기화 sess.run([tf.initializers.global_variables(), tf.initializers.local_variables()])
def model_inference(acoustic_checkpoint, hparams, examples_path, run_dir): """Runs inference for the given examples.""" tf.logging.info('acoustic_checkpoint=%s', acoustic_checkpoint) tf.logging.info('examples_path=%s', examples_path) tf.logging.info('run_dir=%s', run_dir) with tf.Graph().as_default(): num_dims = constants.MIDI_PITCHES # Build the acoustic model within an 'acoustic' scope to isolate its # variables from the other models. with tf.variable_scope('acoustic'): truncated_length = 0 if FLAGS.max_seconds_per_sequence: truncated_length = int( math.ceil((FLAGS.max_seconds_per_sequence * data.hparams_frames_per_second(hparams)))) acoustic_data_provider, _ = data.provide_batch( batch_size=1, examples=examples_path, hparams=hparams, is_training=False, truncated_length=truncated_length, include_note_sequences=True) _, _, data_labels, _, _ = model.get_model( acoustic_data_provider, hparams, is_training=False) # The checkpoints won't have the new scopes. acoustic_variables = { re.sub(r'^acoustic/', '', var.op.name): var for var in slim.get_variables(scope='acoustic/') } acoustic_restore = tf.train.Saver(acoustic_variables) onset_probs_flat = tf.get_default_graph().get_tensor_by_name( 'acoustic/onsets/onset_probs_flat:0') frame_probs_flat = tf.get_default_graph().get_tensor_by_name( 'acoustic/frame_probs_flat:0') offset_probs_flat = tf.get_default_graph().get_tensor_by_name( 'acoustic/offsets/offset_probs_flat:0') velocity_values_flat = tf.get_default_graph().get_tensor_by_name( 'acoustic/velocity/velocity_values_flat:0') # Define some metrics. (metrics_to_updates, metric_note_precision, metric_note_recall, metric_note_f1, metric_note_precision_with_offsets, metric_note_recall_with_offsets, metric_note_f1_with_offsets, metric_note_precision_with_offsets_velocity, metric_note_recall_with_offsets_velocity, metric_note_f1_with_offsets_velocity, metric_frame_labels, metric_frame_predictions) = infer_util.define_metrics(num_dims) summary_op = tf.summary.merge_all() global_step = tf.contrib.framework.get_or_create_global_step() global_step_increment = global_step.assign_add(1) # Use a custom init function to restore the acoustic and language models # from their separate checkpoints. def init_fn(unused_self, sess): acoustic_restore.restore(sess, acoustic_checkpoint) scaffold = tf.train.Scaffold(init_fn=init_fn) session_creator = tf.train.ChiefSessionCreator( scaffold=scaffold, master=FLAGS.master) with tf.train.MonitoredSession(session_creator=session_creator) as sess: tf.logging.info('running session') summary_writer = tf.summary.FileWriter( logdir=run_dir, graph=sess.graph) tf.logging.info('Inferring for %d batches', acoustic_data_provider.num_batches) infer_times = [] num_frames = [] for unused_i in range(acoustic_data_provider.num_batches): start_time = time.time() (labels, filenames, note_sequences, frame_probs, onset_probs, offset_probs, velocity_values) = sess.run([ data_labels, acoustic_data_provider.filenames, acoustic_data_provider.note_sequences, frame_probs_flat, onset_probs_flat, offset_probs_flat, velocity_values_flat, ]) # We expect these all to be length 1 because batch size is 1. assert len(filenames) == len(note_sequences) == 1 # These should be the same length and have been flattened. assert len(labels) == len(frame_probs) == len(onset_probs) frame_predictions = frame_probs > FLAGS.frame_threshold if FLAGS.require_onset: onset_predictions = onset_probs > FLAGS.onset_threshold else: onset_predictions = None if FLAGS.use_offset: offset_predictions = offset_probs > FLAGS.offset_threshold else: offset_predictions = None sequence_prediction = sequences_lib.pianoroll_to_note_sequence( frame_predictions, frames_per_second=data.hparams_frames_per_second(hparams), min_duration_ms=0, min_midi_pitch=constants.MIN_MIDI_PITCH, onset_predictions=onset_predictions, offset_predictions=offset_predictions, velocity_values=velocity_values) end_time = time.time() infer_time = end_time - start_time infer_times.append(infer_time) num_frames.append(frame_probs.shape[0]) tf.logging.info( 'Infer time %f, frames %d, frames/sec %f, running average %f', infer_time, frame_probs.shape[0], frame_probs.shape[0] / infer_time, np.sum(num_frames) / np.sum(infer_times)) tf.logging.info('Scoring sequence %s', filenames[0]) def shift_notesequence(ns_time): return ns_time + hparams.backward_shift_amount_ms / 1000. sequence_label = infer_util.score_sequence( sess, global_step_increment, summary_op, summary_writer, metrics_to_updates, metric_note_precision, metric_note_recall, metric_note_f1, metric_note_precision_with_offsets, metric_note_recall_with_offsets, metric_note_f1_with_offsets, metric_note_precision_with_offsets_velocity, metric_note_recall_with_offsets_velocity, metric_note_f1_with_offsets_velocity, metric_frame_labels, metric_frame_predictions, frame_labels=labels, sequence_prediction=sequence_prediction, frames_per_second=data.hparams_frames_per_second(hparams), sequence_label=sequences_lib.adjust_notesequence_times( music_pb2.NoteSequence.FromString(note_sequences[0]), shift_notesequence)[0], sequence_id=filenames[0]) # Make filenames UNIX-friendly. filename = filenames[0].decode('utf-8').replace('/', '_').replace( ':', '.') output_file = os.path.join(run_dir, filename + '.mid') tf.logging.info('Writing inferred midi file to %s', output_file) midi_io.sequence_proto_to_midi_file(sequence_prediction, output_file) label_output_file = os.path.join(run_dir, filename + '_label.mid') tf.logging.info('Writing label midi file to %s', label_output_file) midi_io.sequence_proto_to_midi_file(sequence_label, label_output_file) # Also write a pianoroll showing acoustic model output vs labels. pianoroll_output_file = os.path.join(run_dir, filename + '_pianoroll.png') tf.logging.info('Writing acoustic logit/label file to %s', pianoroll_output_file) with tf.gfile.GFile(pianoroll_output_file, mode='w') as f: scipy.misc.imsave( f, infer_util.posterior_pianoroll_image( frame_probs, sequence_prediction, labels, overlap=True, frames_per_second=data.hparams_frames_per_second(hparams))) summary_writer.flush()
def model_inference(model_fn, model_dir, checkpoint_path, hparams, examples_path, output_dir, summary_writer, master, preprocess_examples, write_summary_every_step=True): """Runs inference for the given examples.""" tf.logging.info('model_dir=%s', model_dir) tf.logging.info('checkpoint_path=%s', checkpoint_path) tf.logging.info('examples_path=%s', examples_path) tf.logging.info('output_dir=%s', output_dir) estimator = train_util.create_estimator( model_fn, model_dir, hparams, master=master) with tf.Graph().as_default(): num_dims = constants.MIDI_PITCHES dataset = data.provide_batch( examples=examples_path, preprocess_examples=preprocess_examples, hparams=hparams, is_training=False) # Define some metrics. (metrics_to_updates, metric_note_precision, metric_note_recall, metric_note_f1, metric_note_precision_with_offsets, metric_note_recall_with_offsets, metric_note_f1_with_offsets, metric_note_precision_with_offsets_velocity, metric_note_recall_with_offsets_velocity, metric_note_f1_with_offsets_velocity, metric_frame_labels, metric_frame_predictions) = infer_util.define_metrics(num_dims) summary_op = tf.summary.merge_all() if write_summary_every_step: global_step = tf.train.get_or_create_global_step() global_step_increment = global_step.assign_add(1) else: global_step = tf.constant( estimator.get_variable_value(tf.GraphKeys.GLOBAL_STEP)) global_step_increment = global_step iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() with tf.Session() as sess: sess.run([ tf.initializers.global_variables(), tf.initializers.local_variables() ]) infer_times = [] num_frames = [] sess.run(iterator.initializer) while True: try: record = sess.run(next_record) except tf.errors.OutOfRangeError: break def input_fn(params): del params return tf.data.Dataset.from_tensors(record) start_time = time.time() # TODO(fjord): This is a hack that allows us to keep using our existing # infer/scoring code with a tf.Estimator model. Ideally, we should # move things around so that we can use estimator.evaluate, which will # also be more efficient because it won't have to restore the checkpoint # for every example. prediction_list = list( estimator.predict( input_fn, checkpoint_path=checkpoint_path, yield_single_examples=False)) assert len(prediction_list) == 1 input_features = record[0] input_labels = record[1] filename = input_features.sequence_id[0] note_sequence = music_pb2.NoteSequence.FromString( input_labels.note_sequence[0]) labels = input_labels.labels[0] frame_probs = prediction_list[0]['frame_probs'][0] frame_predictions = prediction_list[0]['frame_predictions'][0] onset_predictions = prediction_list[0]['onset_predictions'][0] velocity_values = prediction_list[0]['velocity_values'][0] offset_predictions = prediction_list[0]['offset_predictions'][0] if not FLAGS.require_onset: onset_predictions = None if not FLAGS.use_offset: offset_predictions = None sequence_prediction = sequences_lib.pianoroll_to_note_sequence( frame_predictions, frames_per_second=data.hparams_frames_per_second(hparams), min_duration_ms=0, min_midi_pitch=constants.MIN_MIDI_PITCH, onset_predictions=onset_predictions, offset_predictions=offset_predictions, velocity_values=velocity_values) end_time = time.time() infer_time = end_time - start_time infer_times.append(infer_time) num_frames.append(frame_predictions.shape[0]) tf.logging.info( 'Infer time %f, frames %d, frames/sec %f, running average %f', infer_time, frame_predictions.shape[0], frame_predictions.shape[0] / infer_time, np.sum(num_frames) / np.sum(infer_times)) tf.logging.info('Scoring sequence %s', filename) def shift_notesequence(ns_time): return ns_time + hparams.backward_shift_amount_ms / 1000. sequence_label = sequences_lib.adjust_notesequence_times( note_sequence, shift_notesequence)[0] infer_util.score_sequence( sess, global_step_increment, metrics_to_updates, metric_note_precision, metric_note_recall, metric_note_f1, metric_note_precision_with_offsets, metric_note_recall_with_offsets, metric_note_f1_with_offsets, metric_note_precision_with_offsets_velocity, metric_note_recall_with_offsets_velocity, metric_note_f1_with_offsets_velocity, metric_frame_labels, metric_frame_predictions, frame_labels=labels, sequence_prediction=sequence_prediction, frames_per_second=data.hparams_frames_per_second(hparams), sequence_label=sequence_label, sequence_id=filename) if write_summary_every_step: # Make filenames UNIX-friendly. filename_safe = filename.decode('utf-8').replace('/', '_').replace( ':', '.') output_file = os.path.join(output_dir, filename_safe + '.mid') tf.logging.info('Writing inferred midi file to %s', output_file) midi_io.sequence_proto_to_midi_file(sequence_prediction, output_file) label_output_file = os.path.join(output_dir, filename_safe + '_label.mid') tf.logging.info('Writing label midi file to %s', label_output_file) midi_io.sequence_proto_to_midi_file(sequence_label, label_output_file) # Also write a pianoroll showing acoustic model output vs labels. pianoroll_output_file = os.path.join(output_dir, filename_safe + '_pianoroll.png') tf.logging.info('Writing acoustic logit/label file to %s', pianoroll_output_file) with tf.gfile.GFile(pianoroll_output_file, mode='w') as f: scipy.misc.imsave( f, infer_util.posterior_pianoroll_image( frame_probs, sequence_prediction, labels, overlap=True, frames_per_second=data.hparams_frames_per_second(hparams))) summary = sess.run(summary_op) summary_writer.add_summary(summary, sess.run(global_step)) summary_writer.flush() if not write_summary_every_step: # Only write the summary variables for the final step. summary = sess.run(summary_op) summary_writer.add_summary(summary, sess.run(global_step)) summary_writer.flush()
from magenta.models.onsets_frames_transcription import data from magenta.models.onsets_frames_transcription import split_audio_and_label_data from magenta.models.onsets_frames_transcription import train_util from magenta.music import midi_io from magenta.protobuf import music_pb2 from magenta.music import sequences_lib ## Define model and load checkpoint ## Only needs to be run once. config = configs.CONFIG_MAP['onsets_frames'] hparams = config.hparams hparams.use_cudnn = False hparams.batch_size = 1 examples = tf.placeholder(tf.string, [None]) dataset = data.provide_batch( examples=examples, preprocess_examples=True, hparams=hparams, is_training=False) CHECKPOINT_DIR = '/Users/junhoyeo/Desktop/magenta-school-song/maestro-v1.0.0' # change to downloaded checkpoint path estimator = train_util.create_estimator( config.model_fn, CHECKPOINT_DIR, hparams) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next()
CHECKPOINT_DIR = './train/train_50002' ##todo acoustic_checkpoint = tf.train.latest_checkpoint(CHECKPOINT_DIR) print('acoustic_checkpoint=' + acoustic_checkpoint) hparams = tf_utils.merge_hparams(constants.DEFAULT_HPARAMS, model.get_default_hparams()) with tf.Graph().as_default(): examples = tf.placeholder(tf.string, [None]) num_dims = constants.MIDI_PITCHES batch, iterator = data.provide_batch(batch_size=1, examples=examples, hparams=hparams, is_training=False, truncated_length=0) model.get_model(batch, hparams, is_training=False) session = tf.Session() saver = tf.train.Saver() saver.restore(session, acoustic_checkpoint) onset_probs_flat = tf.get_default_graph().get_tensor_by_name( 'onsets/onset_probs_flat:0') frame_probs_flat = tf.get_default_graph().get_tensor_by_name( 'frame_probs_flat:0') # file = open('./data/wav_format/xinjing.wav','w') ##todo
def main(argv): tf.logging.set_verbosity(FLAGS.log) config = configs.CONFIG_MAP[FLAGS.config] hparams = config.hparams # For this script, default to not using cudnn. hparams.use_cudnn = False hparams.parse(FLAGS.hparams) hparams.batch_size = 1 hparams.truncated_length_secs = 0 with tf.Graph().as_default(): examples = tf.placeholder(tf.string, [None]) dataset = data.provide_batch( examples=examples, preprocess_examples=True, hparams=hparams, is_training=False) estimator = train_util.create_estimator(config.model_fn, os.path.expanduser(FLAGS.model_dir), hparams) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() with tf.Session() as sess: sess.run([ tf.initializers.global_variables(), tf.initializers.local_variables() ]) for filename in argv[1:]: tf.logging.info('Starting transcription for %s...', filename) # The reason we bounce between two Dataset objects is so we can use # the data processing functionality in data.py without having to # construct all the Example protos in memory ahead of time or create # a temporary tfrecord file. tf.logging.info('Processing file...') sess.run(iterator.initializer, {examples: [create_example(filename)]}) def input_fn(params): del params return tf.data.Dataset.from_tensors(sess.run(next_record)) tf.logging.info('Running inference...') checkpoint_path = None if FLAGS.checkpoint_path: checkpoint_path = os.path.expanduser(FLAGS.checkpoint_path) prediction_list = list( estimator.predict( input_fn, checkpoint_path=checkpoint_path, yield_single_examples=False)) assert len(prediction_list) == 1 sequence_prediction = transcribe_audio(prediction_list[0], hparams) midi_filename = filename + '.midi' midi_io.sequence_proto_to_midi_file(sequence_prediction, midi_filename) tf.logging.info('Transcription written to %s.', midi_filename)
def main(input, output): MAESTRO_CHECKPOINT_DIR = '/data/maestro/train' config = configs.CONFIG_MAP['onsets_frames'] hparams = config.hparams hparams.use_cudnn = False hparams.batch_size = 1 checkpoint_dir = MAESTRO_CHECKPOINT_DIR examples = tf.placeholder(tf.string, [None]) dataset = data.provide_batch( examples=examples, preprocess_examples=True, params=hparams, is_training=False, shuffle_examples=False, skip_n_initial_records=0) estimator = train_util.create_estimator( config.model_fn, checkpoint_dir, hparams) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() to_process = [] def process(files): for fn in files: print('**\n\n', fn, '\n\n**') with open(fn, 'rb', buffering=0) as f: wav_data = f.read() example_list = list( audio_label_data_utils.process_record( wav_data=wav_data, ns=music_pb2.NoteSequence(), example_id=fn, min_length=0, max_length=-1, allow_empty_notesequence=True)) assert len(example_list) == 1 to_process.append(example_list[0].SerializeToString()) print('Processing complete for', fn) sess = tf.Session() sess.run([ tf.initializers.global_variables(), tf.initializers.local_variables() ]) sess.run(iterator.initializer, {examples: to_process}) def transcription_data(params): del params return tf.data.Dataset.from_tensors(sess.run(next_record)) input_fn = infer_util.labels_to_features_wrapper(transcription_data) #@title Run inference prediction_list = list( estimator.predict( input_fn, yield_single_examples=False)) assert len(prediction_list) == 1 # Ignore warnings caused by pyfluidsynth import warnings warnings.filterwarnings("ignore", category=DeprecationWarning) sequence_prediction = music_pb2.NoteSequence.FromString( prediction_list[0]['sequence_predictions'][0]) pathname = fn.split('/').pop() print('**\n\n', pathname, '\n\n**') midi_filename = '{outputs}/{file}.mid'.format(outputs=output,file=pathname) midi_io.sequence_proto_to_midi_file(sequence_prediction, midi_filename) files = ['{inputs}/{file}'.format(inputs=input, file=file) for file in os.listdir(input) if file.split('.').pop() == 'wav'] print('the files', files) process(files)
def main(argv): tf.logging.set_verbosity(FLAGS.log) config = configs.CONFIG_MAP[FLAGS.config] hparams = config.hparams # For this script, default to not using cudnn. hparams.use_cudnn = False hparams.parse(FLAGS.hparams) hparams.batch_size = 1 hparams.truncated_length_secs = 0 with tf.Graph().as_default(): examples = tf.placeholder(tf.string, [None]) dataset = data.provide_batch(examples=examples, preprocess_examples=True, hparams=hparams, is_training=False) estimator = train_util.create_estimator( config.model_fn, os.path.expanduser(FLAGS.model_dir), hparams) iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() with tf.Session() as sess: sess.run([ tf.initializers.global_variables(), tf.initializers.local_variables() ]) for filename in argv[1:]: tf.logging.info('Starting transcription for %s...', filename) # The reason we bounce between two Dataset objects is so we can use # the data processing functionality in data.py without having to # construct all the Example protos in memory ahead of time or create # a temporary tfrecord file. tf.logging.info('Processing file...') sess.run(iterator.initializer, {examples: [create_example(filename)]}) def input_fn(params): del params return tf.data.Dataset.from_tensors(sess.run(next_record)) tf.logging.info('Running inference...') checkpoint_path = None if FLAGS.checkpoint_path: checkpoint_path = os.path.expanduser(FLAGS.checkpoint_path) prediction_list = list( estimator.predict(input_fn, checkpoint_path=checkpoint_path, yield_single_examples=False)) assert len(prediction_list) == 1 sequence_prediction = transcribe_audio(prediction_list[0], hparams) midi_filename = filename + '.midi' midi_io.sequence_proto_to_midi_file(sequence_prediction, midi_filename) tf.logging.info('Transcription written to %s.', midi_filename)
def model_inference(model_dir, checkpoint_path, hparams, examples_path, output_dir, summary_writer, write_summary_every_step=True): """Runs inference for the given examples.""" tf.logging.info('model_dir=%s', model_dir) tf.logging.info('checkpoint_path=%s', checkpoint_path) tf.logging.info('examples_path=%s', examples_path) tf.logging.info('output_dir=%s', output_dir) estimator = train_util.create_estimator(model_dir, hparams) with tf.Graph().as_default(): num_dims = constants.MIDI_PITCHES if FLAGS.max_seconds_per_sequence: truncated_length = int( math.ceil((FLAGS.max_seconds_per_sequence * data.hparams_frames_per_second(hparams)))) else: truncated_length = 0 dataset = data.provide_batch(batch_size=1, examples=examples_path, hparams=hparams, is_training=False, truncated_length=truncated_length) # Define some metrics. (metrics_to_updates, metric_note_precision, metric_note_recall, metric_note_f1, metric_note_precision_with_offsets, metric_note_recall_with_offsets, metric_note_f1_with_offsets, metric_note_precision_with_offsets_velocity, metric_note_recall_with_offsets_velocity, metric_note_f1_with_offsets_velocity, metric_frame_labels, metric_frame_predictions) = infer_util.define_metrics(num_dims) summary_op = tf.summary.merge_all() if write_summary_every_step: global_step = tf.train.get_or_create_global_step() global_step_increment = global_step.assign_add(1) else: global_step = tf.constant( estimator.get_variable_value(tf.GraphKeys.GLOBAL_STEP)) global_step_increment = global_step iterator = dataset.make_initializable_iterator() next_record = iterator.get_next() with tf.Session() as sess: sess.run([ tf.initializers.global_variables(), tf.initializers.local_variables() ]) infer_times = [] num_frames = [] sess.run(iterator.initializer) while True: try: record = sess.run(next_record) except tf.errors.OutOfRangeError: break def input_fn(): return tf.data.Dataset.from_tensors(record) start_time = time.time() # TODO(fjord): This is a hack that allows us to keep using our existing # infer/scoring code with a tf.Estimator model. Ideally, we should # move things around so that we can use estimator.evaluate, which will # also be more efficient because it won't have to restore the checkpoint # for every example. prediction_list = list( estimator.predict(input_fn, checkpoint_path=checkpoint_path, yield_single_examples=False)) assert len(prediction_list) == 1 input_features = record[0] input_labels = record[1] filename = input_features.sequence_id[0] note_sequence = music_pb2.NoteSequence.FromString( input_labels.note_sequence[0]) labels = input_labels.labels[0] frame_probs = prediction_list[0]['frame_probs_flat'] onset_probs = prediction_list[0]['onset_probs_flat'] velocity_values = prediction_list[0]['velocity_values_flat'] offset_probs = prediction_list[0]['offset_probs_flat'] frame_predictions = frame_probs > FLAGS.frame_threshold if FLAGS.require_onset: onset_predictions = onset_probs > FLAGS.onset_threshold else: onset_predictions = None if FLAGS.use_offset: offset_predictions = offset_probs > FLAGS.offset_threshold else: offset_predictions = None sequence_prediction = sequences_lib.pianoroll_to_note_sequence( frame_predictions, frames_per_second=data.hparams_frames_per_second(hparams), min_duration_ms=0, min_midi_pitch=constants.MIN_MIDI_PITCH, onset_predictions=onset_predictions, offset_predictions=offset_predictions, velocity_values=velocity_values) end_time = time.time() infer_time = end_time - start_time infer_times.append(infer_time) num_frames.append(frame_probs.shape[0]) tf.logging.info( 'Infer time %f, frames %d, frames/sec %f, running average %f', infer_time, frame_probs.shape[0], frame_probs.shape[0] / infer_time, np.sum(num_frames) / np.sum(infer_times)) tf.logging.info('Scoring sequence %s', filename) def shift_notesequence(ns_time): return ns_time + hparams.backward_shift_amount_ms / 1000. sequence_label = sequences_lib.adjust_notesequence_times( note_sequence, shift_notesequence)[0] infer_util.score_sequence( sess, global_step_increment, metrics_to_updates, metric_note_precision, metric_note_recall, metric_note_f1, metric_note_precision_with_offsets, metric_note_recall_with_offsets, metric_note_f1_with_offsets, metric_note_precision_with_offsets_velocity, metric_note_recall_with_offsets_velocity, metric_note_f1_with_offsets_velocity, metric_frame_labels, metric_frame_predictions, frame_labels=labels, sequence_prediction=sequence_prediction, frames_per_second=data.hparams_frames_per_second(hparams), sequence_label=sequence_label, sequence_id=filename) if write_summary_every_step: # Make filenames UNIX-friendly. filename_safe = filename.decode('utf-8').replace( '/', '_').replace(':', '.') output_file = os.path.join(output_dir, filename_safe + '.mid') tf.logging.info('Writing inferred midi file to %s', output_file) midi_io.sequence_proto_to_midi_file( sequence_prediction, output_file) label_output_file = os.path.join( output_dir, filename_safe + '_label.mid') tf.logging.info('Writing label midi file to %s', label_output_file) midi_io.sequence_proto_to_midi_file( sequence_label, label_output_file) # Also write a pianoroll showing acoustic model output vs labels. pianoroll_output_file = os.path.join( output_dir, filename_safe + '_pianoroll.png') tf.logging.info('Writing acoustic logit/label file to %s', pianoroll_output_file) with tf.gfile.GFile(pianoroll_output_file, mode='w') as f: scipy.misc.imsave( f, infer_util.posterior_pianoroll_image( frame_probs, sequence_prediction, labels, overlap=True, frames_per_second=data. hparams_frames_per_second(hparams))) summary = sess.run(summary_op) summary_writer.add_summary(summary, sess.run(global_step)) summary_writer.flush() if not write_summary_every_step: # Only write the summary variables for the final step. summary = sess.run(summary_op) summary_writer.add_summary(summary, sess.run(global_step)) summary_writer.flush()