def parse_gin_config(self, ckpt): """Parse the model operative config with special streaming parameters.""" with gin.unlock_config(): ckpt_dir = os.path.dirname(ckpt) operative_config = train_util.get_latest_operative_config(ckpt_dir) print(f'Parsing from operative_config {operative_config}') gin.parse_config_file(operative_config, skip_unknown=True) # Set streaming specific params. # Remove reverb processor. pg_string = """ProcessorGroup.dag = [ (@synths.Harmonic(), ['amps', 'harmonic_distribution', 'f0_hz']), (@synths.FilteredNoise(), ['noise_magnitudes']), (@processors.Add(), ['filtered_noise/signal', 'harmonic/signal']), ]""" time_steps = gin.query_parameter('F0PowerPreprocessor.time_steps') n_samples = gin.query_parameter('Harmonic.n_samples') samples_per_frame = int(n_samples / time_steps) gin.parse_config([ 'F0PowerPreprocessor.time_steps=1', f'Harmonic.n_samples={samples_per_frame}', f'FilteredNoise.n_samples={samples_per_frame}', pg_string, ])
def parse_gin(restore_dir): """Parse gin config from --gin_file, --gin_param, and the model directory.""" # Add user folders to the gin search path. for gin_search_path in [GIN_PATH] + FLAGS.gin_search_path: gin.add_config_file_search_path(gin_search_path) # Parse gin configs, later calls override earlier ones. with gin.unlock_config(): # Optimization defaults. use_tpu = bool(FLAGS.tpu) opt_default = 'base.gin' if not use_tpu else 'base_tpu.gin' gin.parse_config_file(os.path.join('optimization', opt_default)) eval_default = 'eval/basic.gin' gin.parse_config_file(eval_default) # Load operative_config if it exists (model has already trained). operative_config = train_util.get_latest_operative_config(restore_dir) if tf.io.gfile.exists(operative_config): logging.info('Using operative config: %s', operative_config) operative_config = cloud.make_file_paths_local( operative_config, GIN_PATH) gin.parse_config_file(operative_config, skip_unknown=True) # User gin config and user hyperparameters from flags. gin_file = cloud.make_file_paths_local(FLAGS.gin_file, GIN_PATH) gin.parse_config_files_and_bindings(gin_file, FLAGS.gin_param, skip_unknown=True)
def parse_gin_config(self, ckpt): """Parse the model operative config with new length parameters.""" with gin.unlock_config(): ckpt_dir = os.path.dirname(ckpt) operative_config = train_util.get_latest_operative_config(ckpt_dir) print(f'Parsing from operative_config {operative_config}') gin.parse_config_file(operative_config, skip_unknown=True) # Set gin params to new length. # Remove reverb processor. pg_string = """ProcessorGroup.dag = [ (@synths.Harmonic(), ['amps', 'harmonic_distribution', 'f0_hz']), (@synths.FilteredNoise(), ['noise_magnitudes']), (@processors.Add(), ['filtered_noise/signal', 'harmonic/signal']), ]""" gin.parse_config([ 'Harmonic.n_samples=%d' % self.n_samples, 'FilteredNoise.n_samples=%d' % self.n_samples, 'F0LoudnessPreprocessor.time_steps=%d' % self.time_steps, 'oscillator_bank.use_angular_cumsum=True', pg_string, ])
def parse_gin_config(self, ckpt): with gin.unlock_config(): ckpt_dir = os.path.dirname(ckpt) operative_config = train_util.get_latest_operative_config(ckpt_dir) print(f'Parsing from operative_config {operative_config}') gin.parse_config_file(operative_config, skip_unknown=True)
def parse_operative_config(ckpt_dir): with gin.unlock_config(): operative_config = train_util.get_latest_operative_config(ckpt_dir) print(f'Parsing from operative_config {operative_config}') gin.parse_config_file(operative_config, skip_unknown=True)
def prepare_complete_tfrecord(dataset_dir='nsynth_guitar', split='train', sample_rate=16000, frame_rate=250): split_dir = os.path.join(dataset_dir, split) operative_config_file = train_util.get_latest_operative_config(split_dir) partial_tfrecord_file = os.path.join(split_dir, 'partial.tfrecord') complete_tfrecord_file = os.path.join(split_dir, 'complete.tfrecord') with gin.unlock_config(): if tf.io.gfile.exists(operative_config_file): gin.parse_config_file(operative_config_file, skip_unknown=True) data_provider = PartialTFRecordProvider( file_pattern=partial_tfrecord_file + '*', example_secs=4, sample_rate=sample_rate, frame_rate=frame_rate) dataset = data_provider.get_batch(1, shuffle=False, repeats=1) strategy = train_util.get_strategy() with strategy.scope(): model = models.get_model() trainer = trainers.Trainer(model, strategy) trainer.restore(split_dir) # steps = dataset.cardinality() with tf.io.TFRecordWriter(complete_tfrecord_file) as writer: for step, e in enumerate(dataset): start_time = time.perf_counter() sample_name = e['sample_name'][0].numpy() note_number = e['note_number'][0].numpy() velocity = e['velocity'][0].numpy() instrument_source = e['instrument_source'][0].numpy() qualities = e['qualities'][0].numpy() audio = e['audio'][0].numpy() f0_hz = e['f0_hz'][0].numpy() f0_confidence = e['f0_confidence'][0].numpy() loudness_db = e['loudness_db'][0].numpy() complete_dataset_dict = { 'sample_name': _byte_feature(sample_name), 'note_number': _int64_feature(note_number), 'velocity': _int64_feature(velocity), 'instrument_source': _int64_feature(instrument_source), 'qualities': _int64_feature(qualities), 'audio': _float_feature(audio), 'f0_hz': _float_feature(f0_hz), 'f0_confidence': _float_feature(f0_confidence), 'loudness_db': _float_feature(loudness_db), } e = model.encode(e, training=False) f0_scaled = tf.squeeze(e['f0_scaled']).numpy() ld_scaled = tf.squeeze(e['ld_scaled']).numpy() z = tf.reshape(e['z'], shape=(-1)).numpy() complete_dataset_dict.update({ 'f0_scaled': _float_feature(f0_scaled), 'ld_scaled': _float_feature(ld_scaled), 'z': _float_feature(z), }) tf_example = tf.train.Example( features=tf.train.Features(feature=complete_dataset_dict)) writer.write(tf_example.SerializeToString()) stop_time = time.perf_counter() elapsed_time = stop_time - start_time print('{} - sample_name: {} - elapsed_time: {:.3f}'.format( step+1, e['sample_name'], elapsed_time))