def _make_example(ids, raw_num_bytes): if FLAGS.combine_to_length > 0: ids += [0] * (FLAGS.combine_to_length - len(ids)) return generator_utils.to_example({ "targets": ids, "inputs": [0], "raw_num_bytes": [raw_num_bytes] }).SerializeToString()
def __call__(self): for case in self._gen: source_ints = case["inputs"] target_ints = case["targets"] yield generator_utils.to_example({ "inputs": source_ints, "targets": target_ints })
def _make_example(ids, raw_num_bytes): if FLAGS.combine_to_length > 0: ids += [0] * (FLAGS.combine_to_length - len(ids)) return generator_utils.to_example({ "targets": ids, "inputs": [0], "raw_num_bytes": [raw_num_bytes] }).SerializeToString()
def _get_online_predictions(self, lines: List[str]) -> List[int]: """retrieves predictions by triggering google cloud function, which invokes ml-engine to make a prediction for each line. """ # constructs instances for predictions contexts = self._get_line_context(lines, n=CONTEXT_N_LINES) instances = [] for i, line in enumerate(lines): context = contexts[i] if MAX_LENGTH > 0: if len(line) > MAX_LENGTH: line = line[:MAX_LENGTH] context = '' elif (len(line) + len(context)) > MAX_LENGTH: context = context[:MAX_LENGTH-len(line)] assert (len(line) + len(context)) <= MAX_LENGTH instances.append({'inputs': line, 'context': context}) if self.verbosity > 0: print(f'making "line type" predictions for {len(instances)} lines...') if self.verbosity > 1: raw_instances = instances.copy() problem_class = PROBLEM_CLASSES[PROBLEM] problem = problem_class() encoders = problem.feature_encoders(data_dir=DATA_DIR) instances_b64 = [] for instance in instances: if 'label' not in instance: instance['label'] = 0 encoded_instance = problem.encode_example(instance, encoders) # encoded_sample.pop('targets') # encoded_sample.pop('context') serialized_instance = to_example(encoded_instance).SerializeToString() instances_b64.append({"b64": base64.b64encode(serialized_instance).decode('utf-8')}) instances = instances_b64 preds = [] batch_generator = batchify(instances, BATCH_SIZE) if self.verbosity > 0: batch_generator = tqdm(batch_generator, total=np.ceil(len(instances)/BATCH_SIZE).astype(int)) for batch in batch_generator: if LOCAL: res = requests.post(LOCAL_URL, data=json.dumps({"instances": batch}), headers={"Content-Type": "application/json"}) else: res = self._get_cloud_predictions(project=PROJECT, model=MODEL, instances=batch, version=VERSION) assert res.ok, f'request failed. Reason: {res.reason}.' predictions = json.loads(res.content) predictions = predictions['predictions'] for i, pred in enumerate(predictions): preds.append(pred['outputs'][0][0][0]) if self.verbosity > 1: for i, pred in enumerate(preds): instance = raw_instances[i] if 'label' in instance: instance.pop('label') print(f'INPUT: {instance}\nOUTPUT: {pred}') return preds
def save(df_row, save_folder, num_rows, num_cols, use_sparse=False): dictionaries = pandas2dict(df_row, num_rows, num_cols, use_sparse) for i, dictionary in enumerate(dictionaries): filename = get_save_path(df_row.image_path, save_folder, use_sparse, i + 1) print(filename) tf_example = to_example(dictionary).SerializeToString() writer = tf.python_io.TFRecordWriter(filename) writer.write(tf_example) writer.close()
def _mean_to_example(mean_stdev): """Converts the found mean and stdev to tfrecords example.""" # mean_stdev is a dict mean_stdev['mean'] = np.reshape(mean_stdev['mean'], [10]).astype(np.float32).tolist() mean_stdev['variance'] = np.reshape(mean_stdev['variance'], [10]).astype(np.float32).tolist() mean_stdev['stddev'] = np.reshape(mean_stdev['stddev'], [10]).astype(np.float32).tolist() mean_stdev['count'] = np.reshape(mean_stdev['count'], [1]).astype(np.int64).tolist() return generator_utils.to_example(mean_stdev)
def process(self, source_target_list): example_dicts = [ self._make_spm_example_dict(source_text, target_text) for source_text, target_text in source_target_list ] if self._packed_examples: example_dicts = pack_examples( example_dicts, has_inputs=True, packed_length=self._packed_length) for example_dict in example_dicts: try: padded_example_dict = self._pad_example_dict(example_dict) except ValueError: metrics.Metrics.counter('err_too_long', 'count').inc() else: yield to_example(padded_example_dict).SerializeToString()
def my_fn(records): """Function from list of TFRecords to list of TFRecords.""" examples = [] for record in records: x = tf.train.Example() x.ParseFromString(record) example_dict = {} if self.has_inputs: example_dict["inputs"] = [ int(i) for i in x.features.feature["inputs"].int64_list.value] example_dict["targets"] = [ int(i) for i in x.features.feature["targets"].int64_list.value] examples.append(example_dict) examples = list(self._maybe_pack_examples(examples)) return [ generator_utils.to_example(x).SerializeToString() for x in examples]
def predict_hansard_line_type4(request): """HTTP Cloud Function. Args: request (flask.Request): The request object. <http://flask.pocoo.org/docs/1.0/api/#flask.Request> Returns: The response text, or any set of values that can be turned into a Response object using `make_response` <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>. """ if request.method == 'POST': assert 'content-type' in request.headers and request.headers['content-type'] == 'application/json' # retrieve problem encoder. problem = HansardLineType4() assert problem.vocab_type == VocabType.CHARACTER encoder = problem.get_or_create_vocab(data_dir=None, tmp_dir=None) # serialize raw string instances request_json = request.get_json(silent=True) request_args = request.args raw_instances = request_json['instances'] model_name = escape(request_args['model_name']) if 'model_name' in request_args else MODEL_NAME serialized_instances = [] for instance in raw_instances: if isinstance(instance, str): instance = {'inputs': instance} inputs = escape(instance['inputs']) context = escape(instance['context']) if 'context' in instance else '' encoded_instance = problem.encode_example({"inputs": inputs, "context": context, "label": 0}, encoder) # encoded_sample.pop('targets') # encoded_sample.pop('context') serialized_instance = to_example(encoded_instance).SerializeToString() serialized_instances.append(serialized_instance) instances = [] for serialized_instance in serialized_instances: instances.append({"b64": base64.b64encode(serialized_instance).decode('utf-8')}) # model_name = "hansard_line_type4_predict_lstm_encoder_lstm_attention" # url = "https://us-central1-hansardparser.cloudfunctions.net/predictHansardLineType4" # headers = {"Content-Type": "application/json"} # makes predict request. predictions = _predict_json(PROJECT_NAME, model_name, instances, version=None) return jsonify(predictions) return abort(405)
def _create_example(pathuni): """Bulk of dataset processing. Converts str path to serialized tf.Example.""" path, uni, binary_fp = pathuni final = {} # zoom out path = svg_utils.zoom_out(path) # make clockwise path = svg_utils.canonicalize(path) # render path for training final['rendered'] = svg_utils.per_step_render(path, absolute=True) # make path relative path = svg_utils.make_relative(path) # convert to vector vector = svg_utils.path_to_vector(path, categorical=True) # make simple vector vector = np.array(vector) vector = np.concatenate( [np.take(vector, [0, 4, 5, 9], axis=-1), vector[..., -6:]], axis=-1) # count some stats final['seq_len'] = np.shape(vector)[0] final['class'] = int(svg_utils.map_uni_to_alphanum(uni)) final['binary_fp'] = str(binary_fp) # append eos vector = svg_utils.append_eos(vector.tolist(), True, 10) # pad path to 51 (with eos) final['sequence'] = np.concatenate( (vector, np.zeros(((50 - final['seq_len']), 10))), 0) # make pure list: final['rendered'] = np.reshape(final['rendered'][..., 0], [64 * 64]).astype(np.float32).tolist() final['sequence'] = np.reshape(final['sequence'], [51 * 10]).astype(np.float32).tolist() final['class'] = np.reshape(final['class'], [1]).astype(np.int64).tolist() final['seq_len'] = np.reshape(final['seq_len'], [1]).astype(np.int64).tolist() return generator_utils.to_example(final).SerializeToString()
def random_load_from_generator(self, generator, prefix_tag_length=4, max_num_examples=-1, log_every=100): """Builds TFExample from dict, serializes, and writes to CBT.""" prefix = self.prefix table = self.table for i, example_dict in enumerate(generator): if not isinstance(example_dict, dict): msg = "Expected generator to yield dict's, saw {}.".format( type(example_dict)) raise ValueError(msg) example = to_example(example_dict) example = example.SerializeToString() # Random target key target_key = random_key(prefix=prefix, length=prefix_tag_length).encode() row = table.row(target_key) row.set_cell(column_family_id="tfexample", column="example", value=example, timestamp=datetime.datetime(1970, 1, 1)) # Don't set a timestamp so we set instead of # append cell values. #timestamp=datetime.datetime.utcnow()) table.mutate_rows([row]) if log_every > 0 and i % log_every == 0: tf.logging.info("Generated {} examples...".format(i)) if max_num_examples > 0 and i >= max_num_examples: break tf.logging.info("Generated {} examples.".format(i)) return i
def process(self, kv): # Seed random number generator based on key so that hop times are # deterministic. key, ns_str = kv m = hashlib.md5(key) random.seed(int(m.hexdigest(), 16)) # Deserialize NoteSequence proto. ns = music_pb2.NoteSequence.FromString(ns_str) # Apply sustain pedal. ns = sequences_lib.apply_sustain_control_changes(ns) # Remove control changes as there are potentially a lot of them and they are # no longer needed. del ns.control_changes[:] for _ in range(self._num_replications): for augment_fn in self._augment_fns: # Augment and encode the performance. try: augmented_performance_sequence = augment_fn(ns) except DataAugmentationError: Metrics.counter('extract_examples', 'augment_performance_failed').inc() continue seq = self._encode_performance_fn( augmented_performance_sequence) # feed in performance as both input/output to music transformer # chopping sequence into length 2048 (throw out shorter sequences) if len(seq) >= 2048: max_offset = len(seq) - 2048 offset = random.randrange(max_offset + 1) cropped_seq = seq[offset:offset + 2048] example_dict = { 'inputs': cropped_seq, 'targets': cropped_seq } yield generator_utils.to_example(example_dict)
def process(self, kv): # Seed random number generator based on key so that hop times are # deterministic. key, ns_str = kv m = hashlib.md5(key) random.seed(int(m.hexdigest(), 16)) # Deserialize NoteSequence proto. ns = note_seq.NoteSequence.FromString(ns_str) # Apply sustain pedal. ns = sequences_lib.apply_sustain_control_changes(ns) # Remove control changes as there are potentially a lot of them and they are # no longer needed. del ns.control_changes[:] for _ in range(self._num_replications): for augment_fn in self._augment_fns: # Augment and encode the performance. try: augmented_performance_sequence = augment_fn(ns) except DataAugmentationError: Metrics.counter('extract_examples', 'augment_performance_failed').inc() continue seq = self._encode_performance_fn( augmented_performance_sequence) # feed in performance as both input/output to music transformer # chopping sequence into length 2048 (throw out shorter sequences) if len(seq) >= 2048: max_offset = len(seq) - 2048 offset = random.randrange(max_offset + 1) cropped_seq = seq[offset:offset + 2048] example_dict = { 'inputs': cropped_seq, 'targets': cropped_seq } if self._melody: # decode truncated performance sequence for melody inference decoded_midi = self._decode_performance_fn(cropped_seq) decoded_ns = note_seq.midi_io.midi_file_to_note_sequence( decoded_midi) # extract melody from cropped performance sequence melody_instrument = melody_inference.infer_melody_for_sequence( decoded_ns, melody_interval_scale=2.0, rest_prob=0.1, instantaneous_non_max_pitch_prob=1e-15, instantaneous_non_empty_rest_prob=0.0, instantaneous_missing_pitch_prob=1e-15) # remove non-melody notes from score score_sequence = copy.deepcopy(decoded_ns) score_notes = [] for note in score_sequence.notes: if note.instrument == melody_instrument: score_notes.append(note) del score_sequence.notes[:] score_sequence.notes.extend(score_notes) # encode melody encode_score_fn = self._encode_score_fns['melody'] example_dict['melody'] = encode_score_fn( score_sequence) # make sure performance input also matches targets; needed for # compatibility of both perf and (mel & perf) autoencoders if self._noisy: # randomly sample a pitch shift to construct noisy performance all_pitches = [x.pitch for x in decoded_ns.notes] min_val = min(all_pitches) max_val = max(all_pitches) transpose_range = range(-(min_val - 21), 108 - max_val + 1) try: transpose_range.remove( 0) # make sure you transpose except ValueError: pass transpose_amount = random.choice(transpose_range) augmented_ns, _ = sequences_lib.transpose_note_sequence( decoded_ns, transpose_amount, min_allowed_pitch=21, max_allowed_pitch=108, in_place=False) aug_seq = self._encode_performance_fn(augmented_ns) example_dict['performance'] = aug_seq else: example_dict['performance'] = example_dict[ 'targets'] del example_dict['inputs'] Metrics.counter('extract_examples', 'encoded_example').inc() Metrics.distribution( 'extract_examples', 'performance_length_in_seconds').update( int(augmented_performance_sequence.total_time)) yield generator_utils.to_example(example_dict)
def process(self, kv): # Seed random number generator based on key so that hop times are # deterministic. key, ns_str = kv m = hashlib.md5(key.encode('utf-8')) random.seed(int(m.hexdigest(), 16)) # Deserialize NoteSequence proto. ns = note_seq.NoteSequence.FromString(ns_str) # Apply sustain pedal. ns = sequences_lib.apply_sustain_control_changes(ns) # Remove control changes as there are potentially a lot of them and they are # no longer needed. del ns.control_changes[:] if (self._min_hop_size_seconds and ns.total_time < self._min_hop_size_seconds): Metrics.counter('extract_examples', 'sequence_too_short').inc() return sequences = [] for _ in range(self._num_replications): if self._max_hop_size_seconds: if self._max_hop_size_seconds == self._min_hop_size_seconds: # Split using fixed hop size. sequences += sequences_lib.split_note_sequence( ns, self._max_hop_size_seconds) else: # Sample random hop positions such that each segment size is within # the specified range. hop_times = [0.0] while hop_times[ -1] <= ns.total_time - self._min_hop_size_seconds: if hop_times[ -1] + self._max_hop_size_seconds < ns.total_time: # It's important that we get a valid hop size here, since the # remainder of the sequence is too long. max_offset = min( self._max_hop_size_seconds, ns.total_time - self._min_hop_size_seconds - hop_times[-1]) else: # It's okay if the next hop time is invalid (in which case we'll # just stop). max_offset = self._max_hop_size_seconds offset = random.uniform(self._min_hop_size_seconds, max_offset) hop_times.append(hop_times[-1] + offset) # Split at the chosen hop times (ignoring zero and the final invalid # time). sequences += sequences_lib.split_note_sequence( ns, hop_times[1:-1]) else: sequences += [ns] for performance_sequence in sequences: if self._encode_score_fns: # We need to extract a score. if not self._absolute_timing: # Beats are required to extract a score with metric timing. beats = [ ta for ta in performance_sequence.text_annotations if ta.annotation_type == BEAT and ta.time <= performance_sequence.total_time ] if len(beats) < 2: Metrics.counter('extract_examples', 'not_enough_beats').inc() continue # Ensure the sequence starts and ends on a beat. performance_sequence = sequences_lib.extract_subsequence( performance_sequence, start_time=min(beat.time for beat in beats), end_time=max(beat.time for beat in beats)) # Infer beat-aligned chords (only for relative timing). try: chord_inference.infer_chords_for_sequence( performance_sequence, chord_change_prob=0.25, chord_note_concentration=50.0, add_key_signatures=True) except chord_inference.ChordInferenceError: Metrics.counter('extract_examples', 'chord_inference_failed').inc() continue # Infer melody regardless of relative/absolute timing. try: melody_instrument = melody_inference.infer_melody_for_sequence( performance_sequence, melody_interval_scale=2.0, rest_prob=0.1, instantaneous_non_max_pitch_prob=1e-15, instantaneous_non_empty_rest_prob=0.0, instantaneous_missing_pitch_prob=1e-15) except melody_inference.MelodyInferenceError: Metrics.counter('extract_examples', 'melody_inference_failed').inc() continue if not self._absolute_timing: # Now rectify detected beats to occur at fixed tempo. # TODO(iansimon): also include the alignment score_sequence, unused_alignment = sequences_lib.rectify_beats( performance_sequence, beats_per_minute=SCORE_BPM) else: # Score uses same timing as performance. score_sequence = copy.deepcopy(performance_sequence) # Remove melody notes from performance. performance_notes = [] for note in performance_sequence.notes: if note.instrument != melody_instrument: performance_notes.append(note) del performance_sequence.notes[:] performance_sequence.notes.extend(performance_notes) # Remove non-melody notes from score. score_notes = [] for note in score_sequence.notes: if note.instrument == melody_instrument: score_notes.append(note) del score_sequence.notes[:] score_sequence.notes.extend(score_notes) # Remove key signatures and beat/chord annotations from performance. del performance_sequence.key_signatures[:] del performance_sequence.text_annotations[:] Metrics.counter('extract_examples', 'extracted_score').inc() for augment_fn in self._augment_fns: # Augment and encode the performance. try: augmented_performance_sequence = augment_fn( performance_sequence) except DataAugmentationError: Metrics.counter('extract_examples', 'augment_performance_failed').inc() continue example_dict = { 'targets': self._encode_performance_fn(augmented_performance_sequence) } if not example_dict['targets']: Metrics.counter('extract_examples', 'skipped_empty_targets').inc() continue if (self._random_crop_length and len(example_dict['targets']) > self._random_crop_length): # Take a random crop of the encoded performance. max_offset = len( example_dict['targets']) - self._random_crop_length offset = random.randrange(max_offset + 1) example_dict['targets'] = example_dict['targets'][ offset:offset + self._random_crop_length] if self._encode_score_fns: # Augment the extracted score. try: augmented_score_sequence = augment_fn(score_sequence) except DataAugmentationError: Metrics.counter('extract_examples', 'augment_score_failed').inc() continue # Apply all score encoding functions. skip = False for name, encode_score_fn in self._encode_score_fns.items( ): example_dict[name] = encode_score_fn( augmented_score_sequence) if not example_dict[name]: Metrics.counter('extract_examples', 'skipped_empty_%s' % name).inc() skip = True break if skip: continue Metrics.counter('extract_examples', 'encoded_example').inc() Metrics.distribution( 'extract_examples', 'performance_length_in_seconds').update( int(augmented_performance_sequence.total_time)) yield generator_utils.to_example(example_dict)
def _get_online_predictions(self, lines: List[str], types: List[str] = None) -> List[int]: """retrieves predictions by triggering google cloud function, which invokes ml-engine to make a prediction for each line. """ contexts = self._get_line_context(lines, n=CONTEXT_N_LINES) instances = [] for i, line in enumerate(lines): context = contexts[i] if MAX_LENGTH > 0: if len(line) > MAX_LENGTH: line = line[:MAX_LENGTH] context = '' elif (len(line) + len(context)) > MAX_LENGTH: context = context[:MAX_LENGTH-len(line)] assert (len(line) + len(context)) <= MAX_LENGTH instances.append({'inputs': line, 'context': context}) if self.verbosity > 1: raw_instances = instances.copy() if LABEL_SPEECHES_ONLY: assert types is not None, '`types` must be provided when LABEL_SPEECHES_ONLY == True.' assert len(types) == len(lines), f'types must have same length as lines, but {len(types)} != {len(lines)}.' speeches = [] speeches_idx = [] for i, instance in enumerate(instances): if types[i] == 'speech': speeches.append(instance) speeches_idx.append(i) instances = speeches if self.verbosity > 0: print(f'Making "speaker span" predictions for {len(instances)} lines...') problem_class = PROBLEM_CLASSES[PROBLEM] problem = problem_class() encoders = problem.feature_encoders(data_dir=DATA_DIR) instances_b64 = [] for instance in instances: if 'targets' not in instance: instance['targets'] = '' encoded_instance = problem.encode_example(instance, encoders) # encoded_sample.pop('targets') # encoded_sample.pop('context') serialized_instance = to_example(encoded_instance).SerializeToString() instances_b64.append({"b64": base64.b64encode(serialized_instance).decode('utf-8')}) instances = instances_b64 preds = [] batch_generator = batchify(instances, BATCH_SIZE) if self.verbosity > 0: batch_generator = tqdm(batch_generator, total=np.ceil(len(instances)/BATCH_SIZE).astype(int)) for batch in batch_generator: try: # print([len(inst['inputs']) + len(inst['context']) for inst in raw_instances[len(preds):len(preds)+BATCH_SIZE]]) if LOCAL: res = requests.post(LOCAL_URL, data=json.dumps({"instances": batch}), headers={"Content-Type": "application/json"}) else: res = self._get_cloud_predictions(project=PROJECT, model=MODEL, instances=batch, version=VERSION) assert res.ok, f'request failed. Reason: {res.reason}.' predictions = json.loads(res.content) predictions = predictions['predictions'] for i, pred in enumerate(predictions): pred_out = pred['outputs'] pred_out = encoders['targets'].decode(pred_out) # removes spaces. pred_out = re.sub(r'\s+', '', pred_out) try: eos_idx = pred_out.lower().index('<eos>') pred_out = pred_out[:eos_idx] except ValueError: if self.verbosity > 1: logging.warn(f'<eos> not found in prediction: {pred_out}') preds.append(pred_out) # preds.append([token_pred[0][0] for token_pred in pred['outputs']]) except AssertionError as e: print(e) for i in range(len(batch)): preds.append(None) if LABEL_SPEECHES_ONLY: preds_all_lines = [] for i, line in enumerate(lines): pred = 'O' * len(line) preds_all_lines.append(pred) n_preds = 0 assert len(speeches_idx) == len(preds) for i, idx in enumerate(speeches_idx): preds_all_lines[idx] = preds[i] n_preds += 1 # sanity check. assert n_preds == len(preds) preds = preds_all_lines if self.verbosity > 1: for i, pred in enumerate(preds): instance = raw_instances[i] if 'targets' in instance: instance.pop('targets') if 'label' in instance: instance.pop('label') print(f'INPUT (len={len(instance["inputs"])}): {instance}\nOUTPUT (len={len(pred) if pred is not None else None}): {pred}') return preds
def process(self, kv): # Seed random number generator based on key so that hop times are # deterministic. key, ns_str = kv m = hashlib.md5(key) random.seed(int(m.hexdigest(), 16)) # Deserialize NoteSequence proto. ns = music_pb2.NoteSequence.FromString(ns_str) # Apply sustain pedal. ns = sequences_lib.apply_sustain_control_changes(ns) # Remove control changes as there are potentially a lot of them and they are # no longer needed. del ns.control_changes[:] if (self._min_hop_size_seconds and ns.total_time < self._min_hop_size_seconds): Metrics.counter('extract_examples', 'sequence_too_short').inc() return sequences = [] for _ in range(self._num_replications): if self._max_hop_size_seconds: if self._max_hop_size_seconds == self._min_hop_size_seconds: # Split using fixed hop size. sequences += sequences_lib.split_note_sequence( ns, self._max_hop_size_seconds) else: # Sample random hop positions such that each segment size is within # the specified range. hop_times = [0.0] while hop_times[-1] <= ns.total_time - self._min_hop_size_seconds: if hop_times[-1] + self._max_hop_size_seconds < ns.total_time: # It's important that we get a valid hop size here, since the # remainder of the sequence is too long. max_offset = min( self._max_hop_size_seconds, ns.total_time - self._min_hop_size_seconds - hop_times[-1]) else: # It's okay if the next hop time is invalid (in which case we'll # just stop). max_offset = self._max_hop_size_seconds offset = random.uniform(self._min_hop_size_seconds, max_offset) hop_times.append(hop_times[-1] + offset) # Split at the chosen hop times (ignoring zero and the final invalid # time). sequences += sequences_lib.split_note_sequence(ns, hop_times[1:-1]) else: sequences += [ns] for performance_sequence in sequences: if self._encode_score_fns: # We need to extract a score. if not self._absolute_timing: # Beats are required to extract a score with metric timing. beats = [ ta for ta in performance_sequence.text_annotations if (ta.annotation_type == music_pb2.NoteSequence.TextAnnotation.BEAT) and ta.time <= performance_sequence.total_time ] if len(beats) < 2: Metrics.counter('extract_examples', 'not_enough_beats').inc() continue # Ensure the sequence starts and ends on a beat. performance_sequence = sequences_lib.extract_subsequence( performance_sequence, start_time=min(beat.time for beat in beats), end_time=max(beat.time for beat in beats) ) # Infer beat-aligned chords (only for relative timing). try: chord_inference.infer_chords_for_sequence( performance_sequence, chord_change_prob=0.25, chord_note_concentration=50.0, add_key_signatures=True) except chord_inference.ChordInferenceError: Metrics.counter('extract_examples', 'chord_inference_failed').inc() continue # Infer melody regardless of relative/absolute timing. try: melody_instrument = melody_inference.infer_melody_for_sequence( performance_sequence, melody_interval_scale=2.0, rest_prob=0.1, instantaneous_non_max_pitch_prob=1e-15, instantaneous_non_empty_rest_prob=0.0, instantaneous_missing_pitch_prob=1e-15) except melody_inference.MelodyInferenceError: Metrics.counter('extract_examples', 'melody_inference_failed').inc() continue if not self._absolute_timing: # Now rectify detected beats to occur at fixed tempo. # TODO(iansimon): also include the alignment score_sequence, unused_alignment = sequences_lib.rectify_beats( performance_sequence, beats_per_minute=SCORE_BPM) else: # Score uses same timing as performance. score_sequence = copy.deepcopy(performance_sequence) # Remove melody notes from performance. performance_notes = [] for note in performance_sequence.notes: if note.instrument != melody_instrument: performance_notes.append(note) del performance_sequence.notes[:] performance_sequence.notes.extend(performance_notes) # Remove non-melody notes from score. score_notes = [] for note in score_sequence.notes: if note.instrument == melody_instrument: score_notes.append(note) del score_sequence.notes[:] score_sequence.notes.extend(score_notes) # Remove key signatures and beat/chord annotations from performance. del performance_sequence.key_signatures[:] del performance_sequence.text_annotations[:] Metrics.counter('extract_examples', 'extracted_score').inc() for augment_fn in self._augment_fns: # Augment and encode the performance. try: augmented_performance_sequence = augment_fn(performance_sequence) except DataAugmentationError: Metrics.counter( 'extract_examples', 'augment_performance_failed').inc() continue example_dict = { 'targets': self._encode_performance_fn( augmented_performance_sequence) } if not example_dict['targets']: Metrics.counter('extract_examples', 'skipped_empty_targets').inc() continue if self._encode_score_fns: # Augment the extracted score. try: augmented_score_sequence = augment_fn(score_sequence) except DataAugmentationError: Metrics.counter('extract_examples', 'augment_score_failed').inc() continue # Apply all score encoding functions. skip = False for name, encode_score_fn in self._encode_score_fns.items(): example_dict[name] = encode_score_fn(augmented_score_sequence) if not example_dict[name]: Metrics.counter('extract_examples', 'skipped_empty_%s' % name).inc() skip = True break if skip: continue Metrics.counter('extract_examples', 'encoded_example').inc() Metrics.distribution( 'extract_examples', 'performance_length_in_seconds').update( int(augmented_performance_sequence.total_time)) yield generator_utils.to_example(example_dict)
def dataset(self, mode, data_dir=None, num_threads=None, output_buffer_size=None, shuffle_files=None, hparams=None, preprocess=True, dataset_split=None, shard=None, partition_id=0, num_partitions=1): """Build a Dataset for this problem. Args: mode: tf.estimator.ModeKeys; determines which files to read from. data_dir: directory that contains data files. num_threads: int, number of threads to use for decode and preprocess Dataset.map calls. output_buffer_size: int, how many elements to prefetch in Dataset.map calls. shuffle_files: whether to shuffle input files. Default behavior (i.e. when shuffle_files=None) is to shuffle if mode == TRAIN. hparams: tf.contrib.training.HParams; hparams to be passed to Problem.preprocess_example and Problem.hparams. If None, will use a default set that is a no-op. preprocess: bool, whether to map the Dataset through Problem.preprocess_example. dataset_split: tf.estimator.ModeKeys + ["test"], which split to read data from (TRAIN:"-train", EVAL:"-dev", "test":"-test"). Defaults to mode. shard: int, if provided, will only read data from the specified shard. Returns: Dataset containing dict<feature name, Tensor>. """ if dataset_split or (mode in ["train", "eval"]): # In case when pathes to preprocessed files pointed out or if train mode # launched, we save preprocessed data first, and then create dataset from # that files. dataset_split = dataset_split or mode assert data_dir if not hasattr(hparams, "data_dir"): hparams.add_hparam("data_dir", data_dir) if not hparams.data_dir: hparams.data_dir = data_dir # Construct the Problem's hparams so that items within it are accessible _ = self.get_hparams(hparams) data_fields, data_items_to_decoders = self.example_reading_spec() if data_items_to_decoders is None: data_items_to_decoders = { field: tf.contrib.slim.tfexample_decoder.Tensor(field) for field in data_fields} is_training = mode == tf.estimator.ModeKeys.TRAIN data_filepattern = self.filepattern(data_dir, dataset_split, shard=shard) tf.logging.info("Reading data files from %s", data_filepattern) data_files = tf.contrib.slim.parallel_reader.get_data_files( data_filepattern) if shuffle_files or shuffle_files is None and is_training: random.shuffle(data_files) else: # In case when pathes to preprocessed files not pointed out, we create # dataset from generator object. eos_list = [] if EOS is None else [EOS] data_list = [] with tf.gfile.GFile(self.test_path, mode="r") as source_file: for line in source_file: if line: if "\t" in line: parts = line.split("\t", 1) source, target = parts[0].strip(), parts[1].strip() source_ints = self.source_vocab.encode(source) + eos_list target_ints = self.target_vocab.encode(target) + eos_list data_list.append({"inputs":source_ints, "targets":target_ints}) else: source_ints = self.source_vocab.encode(line) + eos_list data_list.append(generator_utils.to_example( {"inputs":source_ints})) gen = Gen(self.generator(self.test_path, self.source_vocab, self.target_vocab)) dataset = dataset_ops.Dataset.from_generator(gen, tf.string) preprocess = False def decode_record(record): """Serialized Example to dict of <feature name, Tensor>.""" decoder = tf.contrib.slim.tfexample_decoder.TFExampleDecoder( data_fields, data_items_to_decoders) decode_items = list(data_items_to_decoders) decoded = decoder.decode(record, items=decode_items) return dict(zip(decode_items, decoded)) def _preprocess(example): """Whether preprocess data into required format.""" example = self.preprocess_example(example, mode, hparams) self.maybe_reverse_features(example) self.maybe_copy_features(example) return example dataset = (tf.data.Dataset.from_tensor_slices(data_files) .interleave(lambda x: tf.data.TFRecordDataset(x).map(decode_record, num_parallel_calls=4), cycle_length=4, block_length=16)) if preprocess: dataset = dataset.map(_preprocess, num_parallel_calls=4) return dataset
def _create_example(pathuni): """Bulk of dataset processing. Converts str path to serialized tf.Example.""" path, uni, binary_fp = pathuni final = {} # print(path) #f = open('/home1/wangyz/magenta-master/data-anypair/all_paths_' + str(uni) +'.txt','a') #f.write(str(path) + '\n') # f.close() f = open('/home1/wangyz/magenta-master/data-anypair/all_paths_' + str(uni) + '.txt', 'r') lines = f.read().split('\n') idx = random.randint(0, len(lines)-2) print(uni, binary_fp) #source_path = list(lines[idx]) # print(ast.literal_eval(lines[idx])) source_path = ast.literal_eval(lines[idx]) # input() # zoom out path = svg_utils.zoom_out(path) source_path = svg_utils.zoom_out(source_path) # make clockwise path = svg_utils.canonicalize(path) source_path = svg_utils.canonicalize(source_path) # render path for training final['rendered'] = svg_utils.per_step_render(path, absolute=True) final['source_rendered'] = svg_utils.per_step_render( source_path, absolute=True) # make path relative path = svg_utils.make_relative(path) source_path = svg_utils.make_relative(source_path) # convert to vector vector = svg_utils.path_to_vector(path, categorical=True) source_vector = svg_utils.path_to_vector(source_path, categorical=True) # make simple vector vector = np.array(vector) source_vector = np.array(source_vector) vector = np.concatenate( [np.take(vector, [0, 4, 5, 9], axis=-1), vector[..., -6:]], axis=-1) source_vector = np.concatenate( [np.take(source_vector, [0, 4, 5, 9], axis=-1), source_vector[..., -6:]], axis=-1) # count some stats # print(np.shape(vector)) # print(np.shape(source_vector)) # input() final['seq_len'] = np.shape(vector)[0] final['source_seq_len'] = np.shape(source_vector)[0] final['class'] = int(svg_utils.map_uni_to_alphanum(uni)) final['binary_fp'] = str(binary_fp) # append eos vector = svg_utils.append_eos(vector.tolist(), True, 10) source_vector = svg_utils.append_eos(source_vector.tolist(), True, 10) # pad path to 51 (with eos) final['sequence'] = np.concatenate( (vector, np.zeros(((50 - final['seq_len']), 10))), 0) final['source_sequence'] = np.concatenate( (source_vector, np.zeros(((50 - final['source_seq_len']), 10))), 0) # make pure list: final['rendered'] = np.reshape(final['rendered'][..., 0], [64*64]).astype(np.float32).tolist() final['source_rendered'] = np.reshape(final['source_rendered'][..., 0], [64*64]).astype(np.float32).tolist() final['sequence'] = np.reshape(final['sequence'], [51*10]).astype(np.float32).tolist() final['source_sequence'] = np.reshape(final['source_sequence'], [51*10]).astype(np.float32).tolist() final['class'] = np.reshape(final['class'], [1]).astype(np.int64).tolist() final['seq_len'] = np.reshape(final['seq_len'], [1]).astype(np.int64).tolist() final['source_seq_len'] = np.reshape(final['source_seq_len'], [1]).astype(np.int64).tolist() return generator_utils.to_example(final).SerializeToString()