def __init__(self,
source_path,
style_path,
bars_per_segment=None,
warp=False):
self._seq_pipeline = NoteSequencePipeline(
source_seq=midi_io.midi_file_to_note_sequence(source_path),
style_seq=midi_io.midi_file_to_note_sequence(style_path),
bars_per_segment=bars_per_segment,
warp=warp)
def process(self, paths):
midi_path, wav_path_base = paths
if self._add_wav_glob:
wav_paths = tf.io.gfile.glob(wav_path_base + '*')
else:
wav_paths = [wav_path_base]
if midi_path:
base_ns = midi_io.midi_file_to_note_sequence(midi_path)
base_ns.filename = midi_path
else:
base_ns = music_pb2.NoteSequence()
for wav_path in wav_paths:
logging.info('Creating Example %s:%s', midi_path, wav_path)
wav_data = tf.io.gfile.GFile(wav_path, 'rb').read()
ns = copy.deepcopy(base_ns)
# Use base names.
ns.id = '%s:%s' % (wav_path.replace(
self._wav_dir, ''), midi_path.replace(self._midi_dir, ''))
Metrics.counter('create_example', 'read_midi_wav').inc()
example = audio_label_data_utils.create_example(
ns.id, ns, wav_data)
Metrics.counter('create_example', 'created_example').inc()
yield example
def generate_test_set():
"""Generate the test TFRecord."""
test_file_pairs = []
for directory in test_dirs:
path = os.path.join(FLAGS.input_dir, directory)
path = os.path.join(path, '*.wav')
wav_files = glob.glob(path)
# find matching mid files
for wav_file in wav_files:
base_name_root, _ = os.path.splitext(wav_file)
mid_file = base_name_root + '.mid'
test_file_pairs.append((wav_file, mid_file))
test_output_name = os.path.join(FLAGS.output_dir,
'maps_config2_test.tfrecord')
with tf.python_io.TFRecordWriter(test_output_name) as writer:
for idx, pair in enumerate(test_file_pairs):
print('{} of {}: {}'.format(idx, len(test_file_pairs), pair[0]))
# load the wav data and resample it.
samples = audio_io.load_audio(pair[0], FLAGS.sample_rate)
wav_data = audio_io.samples_to_wav_data(samples, FLAGS.sample_rate)
# load the midi data and convert to a notesequence
ns = midi_io.midi_file_to_note_sequence(pair[1])
example = audio_label_data_utils.create_example(
pair[0], ns, wav_data)
writer.write(example.SerializeToString())
return [filename_to_id(wav) for wav, _ in test_file_pairs]
def generate_train_set(exclude_ids):
"""Generate the train TFRecord."""
train_file_pairs = []
for directory in train_dirs:
path = os.path.join(FLAGS.input_dir, directory)
path = os.path.join(path, '*.wav')
wav_files = glob.glob(path)
# find matching mid files
for wav_file in wav_files:
base_name_root, _ = os.path.splitext(wav_file)
mid_file = base_name_root + '.mid'
if filename_to_id(wav_file) not in exclude_ids:
train_file_pairs.append((wav_file, mid_file))
train_output_name = os.path.join(FLAGS.output_dir,
'maps_config2_train.tfrecord')
with tf.python_io.TFRecordWriter(train_output_name) as writer:
for idx, pair in enumerate(train_file_pairs):
print('{} of {}: {}'.format(idx, len(train_file_pairs), pair[0]))
# load the wav data
wav_data = tf.gfile.Open(pair[0], 'rb').read()
# load the midi data and convert to a notesequence
ns = midi_io.midi_file_to_note_sequence(pair[1])
for example in audio_label_data_utils.process_record(
wav_data, ns, pair[0], FLAGS.min_length, FLAGS.max_length,
FLAGS.sample_rate):
writer.write(example.SerializeToString())
def load_midi_to_seq(root_dir, recursive=False):
print('Loading...')
if recursive:
return convert_midi_to_note_seq(root_dir)
else:
files = midi_file_paths_in_dir(root_dir)
return np.array([midi_io.midi_file_to_note_sequence(f) for f in files])
def convert_midi_to_note_seq(root_dir):
files = midi_file_paths_in_dir(root_dir)
dirs = [join(root_dir, f) for f in listdir(root_dir) if isdir(join(root_dir, f))]
note_seq_arr1 = np.array([])
for dir in dirs:
note_seq_arr1 = np.append(note_seq_arr1, convert_midi_to_note_seq(dir))
note_seq_arr2 = np.array([midi_io.midi_file_to_note_sequence(f) for f in files])
return np.append(note_seq_arr1, note_seq_arr2)
def get_primer_sequence(primer_file: str = None) -> NoteSequence:
""" Converts primer midi file to NoteSequence
Args:
primer_file: str: Path to a midi file (Default value = None)
Returns:
NoteSequence: A note sequence obtained from the input file
An empty NoteSequence is returned if no path is given
"""
if primer_file:
primer_sequence = midi_file_to_note_sequence(primer_file)
else:
primer_sequence = NoteSequence()
return primer_sequence
import shutil, os
dest_folder = '/home/sarantos/Documents/Music_AI/clean_midi_BM/'
for f in filepaths:
file = dataset_dir + '/' + f + '.mid'
shutil.copy(file, dest_folder)
#%%
dest_folder = '/home/sarantos/Documents/Music_AI/clean_midi_BM/'
midis = []
for root, subdirs, files in os.walk(dest_folder):
for idx, f in enumerate(tqdm(files)):
midis.append(midi_io.midi_file_to_note_sequence(dest_folder + '/' + f))
midis[idx].filename = f
#midis = [midi_io.midi_file_to_note_sequence(dest_folder + '/' + f) for f in tqdm(files)]
#%%
import copy
k = copy.deepcopy(midis[0])
instruments, bass_idxs, melody_idxs = get_instruments_from_NoteSequence(k)
#%%
import note_seq
from note_seq.protobuf import music_pb2
new_tune = note_seq.protobuf.music_pb2.NoteSequence()
# https://github.com/magenta/magenta/blob/master/magenta/pipelines/note_sequence_pipelines_test.py
def ceil_to(val, precision=3):
return np.round(val + 0.5 * 10**(-precision), precision)
#%%
#CHANGE ME BELOW
#maestro_dir = '/Users/nikolasborrel/github/maestro-v2.0.0_small/'
midi_path = '/home/sarantos/Documents/Music_AI/lmd_matched/A/A/A/TRAAAGR128F425B14B/1d9d16a9da90c090809c153754823c2b.mid'
#filename = 'unnormal_pen.mid'
#%%
#midi_path = maestro_dir + filename
k = midi_io.midi_file_to_note_sequence(midi_path)
#k_trans = loader.transpose_note_seqs_to_c([k])[0]
print(
f"Notes original pitch: {k.key_signatures[0]} \n{k.notes[0]}\n\n{k.notes[1]}"
)
print(
f"Notes transposed pitch: {k_trans.key_signatures[0]} \n{k_trans.notes[0]}\n\n{k_trans.notes[1]}"
) # key=[empty] means key=0 => C
note_seq_note_props = list(
map(
lambda x: (x.pitch, x.velocity, x.start_time, x.end_time,
ceil_to(x.end_time - x.start_time)), k.notes))
durations = note_seq_note_props[5]
# inspired by # - https://machinelearningmastery.com/prepare-text-data-deep-learning-keras/ # - https://www.kdnuggets.com/2020/03/tensorflow-keras-tokenization-text-data-prep.html from note_seq import midi_io from music_utils.tokenizer import MusicTokenizer from utils.hot_encoder import one_hot_encode_sequence from utils.tools import split_list #%% #PARAMS maestro_dir = '/Users/nikolasborrel/github/midi_data/maestro-v2.0.0/' filename = '2018/MIDI-Unprocessed_Chamber1_MID--AUDIO_07_R3_2018_wav--2.midi' midi_path = maestro_dir + filename one_piece_data = midi_io.midi_file_to_note_sequence(midi_path) notes_pieces = split_list(one_piece_data.notes,4,3) t = MusicTokenizer() t.fit_on_notes_pieces(notes_pieces) # summarize what was learned print(t.note_counts) print(t.piece_count) print(t.note_index) print(t.note_pieces) # integer encode documents - TODO #encoded_docs = t.texts_to_matrix(docs, mode='count') #print(encoded_docs)
"""
see polyphony_sequence_generator.py (in magenta.models.polyphone_rnn)
"""
input_file = '/Users/nikolasborrel/github/midi_data_out/melodies/piano_poly.mid'
out_file = '/Users/nikolasborrel/github/midi_data_out/melodies/piano_poly_out.mid'
out_file_trans = '/Users/nikolasborrel/github/midi_data_out/melodies/piano_poly_trans_out.mid'
out_file_pred = '/Users/nikolasborrel/github/midi_data_out/melodies/piano_poly_pred_out.mid'
min_note = 60
max_note = 72
transpose_to_key = 2
steps_per_quarter = 4 # default, resulting in 16th note quantization
note_seq_raw = midi_io.midi_file_to_note_sequence(input_file)
note_seq_quan = note_seq.quantize_note_sequence(note_seq_raw,
steps_per_quarter)
extracted_seqs, stats = polyphony_lib.extract_polyphonic_sequences(
note_seq_quan)
assert (len(extracted_seqs <= 1)
) # docs states that only one poly list are extracted
poly_seq = extracted_seqs[0]
print(poly_seq)
seq1 = poly_seq.to_sequence() #qpm=60.0
midi_io.sequence_proto_to_midi_file(seq1, out_file)
poly_encoder = encoder_decoder.OneHotEventSequenceEncoderDecoder(
