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 split_audio_and_label_data.process_record(
wav_data, ns, pair[0], FLAGS.min_length, FLAGS.max_length,
FLAGS.sample_rate):
writer.write(example.SerializeToString())
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_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 = split_audio_and_label_data.create_example(pair[0], ns, wav_data)
writer.write(example.SerializeToString())
return [filename_to_id(wav) for wav, _ in test_file_pairs]
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_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 midi_file_to_notesequence(path):
sequence = midi_io.midi_file_to_note_sequence(path)
text_path = path[:-4] + '.txt'
with open(text_path, 'w') as f:
f.write(str(sequence))
with open(text_path, 'r') as f:
content = f.readlines()
return sequence, content
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 pair in test_file_pairs:
print(pair)
# 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])
velocities = [note.velocity for note in ns.notes]
velocity_max = np.max(velocities)
velocity_min = np.min(velocities)
new_velocity_tuple = music_pb2.VelocityRange(
min=velocity_min, max=velocity_max)
example = tf.train.Example(features=tf.train.Features(feature={
'id':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[pair[0]]
)),
'sequence':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[ns.SerializeToString()]
)),
'audio':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[wav_data]
)),
'velocity_range':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_velocity_tuple.SerializeToString()]
)),
}))
writer.write(example.SerializeToString())
return [filename_to_id(wav) for wav, _ in test_file_pairs]
def extractPitch(self, song):
seq = midi_io.midi_file_to_note_sequence(song)
qseq = sequences_lib.quantize_note_sequence(seq, 1)
melodies, stats = melody_pipelines.extract_melodies(qseq)
rounded_pitches = []
for mel in list(melodies[0]):
while (mel > 71):
mel = mel - 12
while (mel < 60):
mel = mel + 12
rounded_pitches.append(mel)
return rounded_pitches
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 pair in test_file_pairs:
print(pair)
# 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])
velocities = [note.velocity for note in ns.notes]
velocity_max = np.max(velocities)
velocity_min = np.min(velocities)
new_velocity_tuple = music_pb2.VelocityRange(min=velocity_min,
max=velocity_max)
example = tf.train.Example(features=tf.train.Features(
feature={
'id':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[pair[0]])),
'sequence':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[ns.SerializeToString()])),
'audio':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[wav_data])),
'velocity_range':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_velocity_tuple.SerializeToString()])),
}))
writer.write(example.SerializeToString())
return [filename_to_id(wav) for wav, _ in test_file_pairs]
def process(self, paths):
wav_path, midi_path = paths
if midi_path:
if FLAGS.use_midi_stems:
base_ns = note_sequence_from_directory(
os.path.dirname(midi_path))
else:
base_ns = midi_io.midi_file_to_note_sequence(midi_path)
base_ns.filename = midi_path
else:
base_ns = music_pb2.NoteSequence()
logging.info('Creating Example %s:%s', midi_path, wav_path)
if FLAGS.convert_flac:
samples, sr = librosa.load(wav_path, FLAGS.sample_rate)
wav_data = audio_io.samples_to_wav_data(samples, sr)
else:
wav_data = tf.io.gfile.GFile(wav_path, 'rb').read()
ns = copy.deepcopy(base_ns)
# Use base names.
ns.id = '%s:%s' % (wav_path, midi_path)
Metrics.counter('create_example', 'read_midi_wav').inc()
if FLAGS.max_length > 0:
split_examples = audio_label_data_utils.process_record(
wav_data,
ns,
ns.id,
min_length=FLAGS.min_length,
max_length=FLAGS.max_length,
sample_rate=FLAGS.sample_rate,
load_audio_with_librosa=False)
for example in split_examples:
Metrics.counter('split_wav', 'split_example').inc()
yield example
else:
example = audio_label_data_utils.create_example(
ns.id, ns, wav_data)
Metrics.counter('create_example', 'created_example').inc()
yield example
def convert_midi_to_ly(midi_input_path, ly_output_path, num_notes=-1):
"""
Given a midi file, produces the score as lilypond_code and saves it to a file.
Args:
midi_input_path: Path to input midi file.
ly_output_path: Path to output lilypond code file.
"""
note_seq = midi_io.midi_file_to_note_sequence(midi_input_path)
if num_notes == -1:
num_notes = len(note_seq.notes)
parsed_notes = get_note_pitch_names_and_lengths(note_seq, num_notes)
lilypond_code = note_sequence_to_lilypond_code(parsed_notes)
print (lilypond_code)
with open(ly_output_path, 'w+') as f:
f.write(lilypond_code)
def note_sequence_from_directory(dir):
midis = tf.io.gfile.glob(f'{dir}/MIDI/*.mid')
multi_sequence = None
for i, midi in enumerate(midis):
sequence = midi_io.midi_file_to_note_sequence(midi)
if multi_sequence is None:
multi_sequence = sequence
else:
for note in sequence.notes:
note.instrument = i
for pitch_bend in sequence.pitch_bends:
pitch_bend.instrument = i
for control_change in sequence.control_changes:
control_change.instrument = i
for instrument_info in sequence.instrument_infos:
instrument_info.instrument = i
multi_sequence.notes.extend(sequence.notes)
multi_sequence.pitch_bends.extend(sequence.pitch_bends)
multi_sequence.control_changes.extend(sequence.control_changes)
multi_sequence.instrument_infos.extend(sequence.instrument_infos)
multi_sequence.total_time = max(multi_sequence.total_time,
sequence.total_time)
return multi_sequence
def __init__(self, filename=None, sf2_path=None):
"""A wrapper class around the magenta midi wrapper that goes around pretty_midi
filename: The class will attampt to load the midi file in the specified filename
sf2_path: If the class is intended to be used for midi rendering,
The soundfont file can be loaded here. If left None, the file will
be loaded on first call to render. The soundfont file will be
loaded and shared across all instances of the class. If a new
filename is specified, the new one will be loaded.
"""
if filename is None:
self.sequence = music_pb2.NoteSequence()
self.duration = 0
self.start_first = 0
else:
self.sequence = midi_io.midi_file_to_note_sequence(filename)
self.duration = self.sequence.notes[-1].end_time
self.start_first = self.sequence.notes[0].start_time
self.prev_octave = 4
if sf2_path is not None:
note_sequence._init_fluidsynth(sf2_path, fs=44100)
note_sequence.sf_path = sf2_path
def midi_to_seq(midi):
seq = midi_io.midi_file_to_note_sequence(midi)
seq = sequences_lib.apply_sustain_control_changes(seq)
return seq
"""
Convert MIDI to synthesized waveform (sinusoidal, 1D tensor output out as .wav)
"""
from magenta.music import midi_io, midi_synth
from scipy.io.wavfile import write
from sys import argv
import glob
# assert len(argv) > 2, 'usage: midi_to_wav.py [path_to_midi] [out_fn] [path_to_sf]'
# args = [arg for arg in argv]
midi_dir_path = argv[1] if len(argv) > 1 else '/home/jason/midi-gen'
sample_rate = int(argv[2]) if len(argv) > 2 else 44100
print('Sample rate:', sample_rate)
print('Path:', midi_dir_path)
path = midi_dir_path + '/*.mid'
midi_files = [fn for fn in glob.glob(path)]
for midi in midi_files:
note_seq = midi_io.midi_file_to_note_sequence(midi)
wav = midi_synth.fluidsynth(note_seq, sample_rate)
out_fn = midi[:-4] + '.wav'
print('Out file:', out_fn)
write(out_fn, sample_rate, wav)
exit(0)
def get_note_sequences_from_midi_files(midiFiles):
allNoteSequences = []
for file in midiFiles:
noteSeq = mmm.midi_file_to_note_sequence(file)
allNoteSequences.append(noteSeq)
return allNoteSequences
def midi_from_file(file_name):
'''Returns a note sequence structure loaded from the specified file name'''
return midi_io.midi_file_to_note_sequence(file_name)
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 pair in train_file_pairs:
print(pair)
# load the wav data
wav_data = tf.gfile.Open(pair[0], 'rb').read()
samples = audio_io.wav_data_to_samples(wav_data, FLAGS.sample_rate)
samples = librosa.util.normalize(samples, norm=np.inf)
# load the midi data and convert to a notesequence
ns = midi_io.midi_file_to_note_sequence(pair[1])
splits = find_split_points(ns, samples, FLAGS.sample_rate,
FLAGS.min_length, FLAGS.max_length)
velocities = [note.velocity for note in ns.notes]
velocity_max = np.max(velocities)
velocity_min = np.min(velocities)
new_velocity_tuple = music_pb2.VelocityRange(min=velocity_min,
max=velocity_max)
for start, end in zip(splits[:-1], splits[1:]):
if end - start < FLAGS.min_length:
continue
new_ns = sequences_lib.extract_subsequence(ns, start, end)
new_wav_data = audio_io.crop_wav_data(wav_data,
FLAGS.sample_rate, start,
end - start)
example = tf.train.Example(features=tf.train.Features(
feature={
'id':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[pair[0]])),
'sequence':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_ns.SerializeToString()])),
'audio':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_wav_data])),
'velocity_range':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_velocity_tuple.SerializeToString()])),
}))
writer.write(example.SerializeToString())
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 pair in train_file_pairs:
print(pair)
# load the wav data
wav_data = tf.gfile.Open(pair[0], 'rb').read()
samples = audio_io.wav_data_to_samples(wav_data, FLAGS.sample_rate)
samples = librosa.util.normalize(samples, norm=np.inf)
# load the midi data and convert to a notesequence
ns = midi_io.midi_file_to_note_sequence(pair[1])
splits = find_split_points(ns, samples, FLAGS.sample_rate,
FLAGS.min_length, FLAGS.max_length)
velocities = [note.velocity for note in ns.notes]
velocity_max = np.max(velocities)
velocity_min = np.min(velocities)
new_velocity_tuple = music_pb2.VelocityRange(
min=velocity_min, max=velocity_max)
for start, end in zip(splits[:-1], splits[1:]):
if end - start < FLAGS.min_length:
continue
new_ns = sequences_lib.extract_subsequence(ns, start, end)
new_wav_data = audio_io.crop_wav_data(wav_data, FLAGS.sample_rate,
start, end - start)
example = tf.train.Example(features=tf.train.Features(feature={
'id':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[pair[0]]
)),
'sequence':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_ns.SerializeToString()]
)),
'audio':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_wav_data]
)),
'velocity_range':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[new_velocity_tuple.SerializeToString()]
)),
}))
writer.write(example.SerializeToString())
