def _check_extract_examples(input_ns, path, input_number):
"""Make sure each input returns exactly one example from the converter."""
tensors = config.data_converter.to_tensors(input_ns).outputs
if not tensors:
print(
'MusicVAE configs have very specific input requirements. Could not '
'extract any valid inputs from `%s`. Try another MIDI file.' % path)
sys.exit()
elif len(tensors) > 1:
basename = os.path.join(
FLAGS.output_dir,
'%s_input%d-extractions_%s-*-of-%03d.mid' %
(FLAGS.config, input_number, date_and_time, len(tensors)))
for i, ns in enumerate(config.data_converter.to_notesequences(tensors)):
mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i))
print(
'%d valid inputs extracted from `%s`. Outputting these potential '
'inputs as `%s`. Call script again with one of these instead.' %
(len(tensors), path, basename))
sys.exit()
babyshark = mm.midi_file_to_note_sequence('./mid/babyshark.mid')
babyshark = mm.extract_subsequence(babyshark, 0, 8)
babyshark.ticks_per_quarter = 0
babyshark.time_signatures.pop()
babyshark.key_signatures.pop()
babyshark.tempos.pop()
babyshark.tempos.add(qpm=60)
for note in babyshark.notes:
if note.pitch < 60:
note.pitch = 60
note.instrument = 0
note.is_drum = False
# This gives us a list of sequences.
note_sequences = music_vae.interpolate(twinkle_twinkle,
babyshark,
num_steps=num_steps,
length=8)
# Concatenate them into one long sequence, with the start and
# end sequences at each end.
interp_seq = mm.sequences_lib.concatenate_sequences(note_sequences)
mm.play_sequence(interp_seq, synth=mm.fluidsynth)
mm.plot_sequence(interp_seq)
mm.sequence_proto_to_midi_file(interp_seq, 'twinkle_shark.mid')
import magenta.music as mm
babyshark = mm.midi_file_to_note_sequence('./mid/babyshark_full.mid')
# truncate @ 14 seconds
babyshark = mm.extract_subsequence(babyshark, 14, 14 + 8.5)
babyshark = mm.extract_subsequence(babyshark, 0, 8)
babyshark.ticks_per_quarter = 0
babyshark.time_signatures.pop()
babyshark.key_signatures.pop()
babyshark.tempos.pop()
babyshark.tempos.add(qpm=60)
for note in babyshark.notes:
if note.pitch < 60:
note.pitch = 60
note.instrument = 0
note.is_drum = False
mm.sequence_proto_to_midi_file(babyshark, './mid/babyshark.mid')
# Decode to NoteSequence.
midi_filename = decode(
sample_ids,
encoder=unconditional_encoders['targets'])
unconditional_ns = mm.midi_file_to_note_sequence(midi_filename)
# Play and plot.
mm.play_sequence(
unconditional_ns,
synth=mm.fluidsynth, sample_rate=SAMPLE_RATE, sf2_path=SF2_PATH)
mm.plot_sequence(unconditional_ns)
#@title Download Performance as MIDI
#@markdown Download generated performance as MIDI (optional).
mm.sequence_proto_to_midi_file(
unconditional_ns, '/tmp/unconditional.mid')
files.download('/tmp/unconditional.mid')
#@title Choose Priming Sequence
#@markdown Here you can choose a priming sequence to be continued
#@markdown by the model. We have provided a few, or you can
#@markdown upload your own MIDI file.
#@markdown
#@markdown Set `max_primer_seconds` below to trim the primer to a
#@markdown fixed number of seconds (this will have no effect if
#@markdown the primer is already shorter than `max_primer_seconds`).
filenames = {
'C major arpeggio': '/content/primers/c_major_arpeggio.mid',
'C major scale': '/content/primers/c_major_scale.mid',
'Clair de Lune': '/content/primers/clair_de_lune.mid',
# Bundle TODO describe
notebook_utils.download_bundle(BUNDLE_NAME, BUNDLE_DIR)
bundle = sequence_generator_bundle.read_bundle_file(
os.path.join(BUNDLE_DIR, BUNDLE_NAME))
# Generator TODO describe
generator_map = melody_rnn_sequence_generator.get_generator_map()
generator = generator_map[MODEL_NAME](checkpoint=None, bundle=bundle)
generator.initialize()
# Generator options TODO describe
generator_options = generator_pb2.GeneratorOptions()
generator_options.args["temperature"].float_value = TEMPERATURE
# TODO is this unused?
generate_section = generator_options.generate_sections.add(start_time=0,
end_time=30)
# Generate the sequence TODO describe
sequence = generator.generate(music_pb2.NoteSequence(), generator_options)
# Outputs the midi file TODO describe
midi_file = sequence_proto_to_midi_file(sequence, MIDI_FILE)
midi_file_pretty = sequence_proto_to_pretty_midi(sequence)
# https://stackoverflow.com/questions/6030087/play-midi-files-in-python
# Outputs the plot file TODO describe
plot = plot_sequence(sequence, False)
output_file(PLOT_FILE)
show(plot)
def gen_chords():
form = ChordForm()
print("Chords CHOICES from form:" + str(form.chord_1.choices))
form.chord_2.choices = [(chord_id, chord_name)
for chord_id, chord_name in form.chord_1.choices]
form.chord_3.choices = [(chord_id, chord_name)
for chord_id, chord_name in form.chord_1.choices]
form.chord_4.choices = [(chord_id, chord_name)
for chord_id, chord_name in form.chord_1.choices]
if form.validate_on_submit():
chord_1 = form.chord_1.data
chord_2 = form.chord_2.data
chord_3 = form.chord_3.data
chord_4 = form.chord_4.data
chords = [chord_1, chord_2, chord_3, chord_4]
num_bars = form.num_bars.data
temperature = form.temperature.data
config = configs.CONFIG_MAP['hier-multiperf_vel_1bar_med_chords']
weight_name = 'model_chords_fb64.ckpt'
model = TrainedModel(config,
batch_size=BATCH_SIZE,
checkpoint_dir_or_path=os.path.join(
app.root_path, 'content', weight_name))
z1 = np.random.normal(size=[Z_SIZE])
z2 = np.random.normal(size=[Z_SIZE])
z = np.array([slerp(z1, z2, t) for t in np.linspace(0, 1, num_bars)])
seqs = [
model.decode(length=TOTAL_STEPS,
z=z[i:i + 1, :],
temperature=temperature,
c_input=chord_encoding(chords[i % 4]))[0]
for i in range(num_bars)
]
trim_sequences(seqs)
fix_instruments_for_concatenation(seqs)
prog_interp_ns = concatenate_sequences(seqs)
f_ext = '.mid'
random_hex = secrets.token_hex(8)
music_fn = random_hex + f_ext
music_mp3 = random_hex + ".mp3"
#Save music to disk
mm.sequence_proto_to_midi_file(prog_interp_ns, music_fn)
### Move audio to a specified path
source_path = "/home/pratheesh/Flask_Blog/" + music_mp3
destination_path = os.path.join(app.root_path, 'static/music',
music_mp3)
cmd_to_wav = "fluidsynth -F " + random_hex + ".wav /usr/share/sounds/sf2/FluidR3_GM.sf2 " + music_fn
print(cmd_to_wav)
os.system(cmd_to_wav)
cmd_to_mp3 = "lame --preset standard " + random_hex + ".wav " + random_hex + ".mp3"
print(cmd_to_mp3)
os.system(cmd_to_mp3)
#shutil.move(source_path, destination_path)
#os.replace(source_path, destination_path)
print("moving file")
os.rename(source_path, destination_path)
os.remove(music_fn)
os.remove(random_hex + ".wav")
music_file = url_for('static', filename='music/' + music_mp3)
return render_template('music_output.html', music_file=music_file)
return render_template('gen_chords.html', form=form)
def make_music(extracted_bpm):
BUNDLE_DIR = '/Users/engrbundle/Desktop/MusicGeneration/MusicVAE/'
MODEL_DIR = 'hierdec-trio_16bar.tar'
flags = {}
flags[
"output_dir"] = "/Users/engrbundle/Desktop/TeamBeatIt/BeatIt/magentabackend/output"
flags["config"] = "hierdec-trio_16bar"
flags[
"checkpoint_file"] = "/Users/engrbundle/Desktop/TeamBeatIt/BeatIt/server/flaskTests/hierdec-trio_16bar.tar"
flags["mode"] = "sample"
# flags["input_midi_1"] =
# flags["input_midi_2"] =
flags["num_outputs"] = 1
flags["max_batch_size"] = 2
flags["temperature"] = 1.4
sequence_list = mv_gen.main_program(os.path.join(BUNDLE_DIR, MODEL_DIR),
flags)
sequence = sequence_list[0]
ratio = 120 / extracted_bpm
#Base QPM: 120
sequence.tempos[0].qpm = int(round(120 * ratio))
#qpm / 60 * (number of measures = 16)
# 120 quarter notes a minute
# 30 full notes a minute
# .5 full notes a seconds
# 1 full note every 2 seconds
# 16 full notes in 32 seconds
# 90 / 60 * 16 = 24 seconds
print("Total time ", sequence.total_time)
print(dir(sequence))
test = "C Bb F G C Bb F G"
# test = "C B7 Em C B7 Em C B7 C" sad
# Create backing chord progression from flags.
raw_chords = test.split()
#Base steps_per_chord = 32
steps_per_chord = int(round(32 * ratio))
repeated_chords = [
chord for chord in raw_chords for _ in range(steps_per_chord)
]
backing_chords = mm.ChordProgression(repeated_chords)
print(dir(sequence))
total_seconds = sequence.total_time
CHORD_SYMBOL = music_pb2.NoteSequence.TextAnnotation.CHORD_SYMBOL
# Add the backing chords to the input sequence.
#Base backing_qpm = 60
chord_qpm = int(round(60 * ratio))
chord_sequence = backing_chords.to_sequence(sequence_start_time=0.0,
qpm=chord_qpm)
for text_annotation in chord_sequence.text_annotations:
if text_annotation.annotation_type == CHORD_SYMBOL:
chord = sequence.text_annotations.add()
chord.CopyFrom(text_annotation)
# input_sequence.total_time = len(backing_chords) * seconds_per_step
for note in sequence.notes:
if note.is_drum and note.program == 0: #Changing to new drum
note.is_drum = True
note.instrument = 2
if note.pitch == 51:
note.velocity = 0
elif note.program == 0 and note.instrument == 0 and not note.is_drum: #Changing from piano to space void
note.velocity = 0
elif note.instrument == 1 and note.program == 33:
note.velocity = 0
elif note.program == 87:
print("This is a fifth")
CHORD_VELOCITY = 50
renderer = mm.BasicChordRenderer(velocity=CHORD_VELOCITY)
renderer.render(sequence)
mm.sequence_proto_to_midi_file(
sequence,
'/Users/engrbundle/Desktop/TeamBeatIt/BeatIt/server/musicvae.mid')
print("New sequence was made")
test = subprocess.Popen(
["timidity", "musicvae.mid", "-Ow", "-o", "musicvae.wav"],
stdout=subprocess.PIPE)
output = test.communicate()[0]
print("Was run!!")
print("Midi file has been generated")
def seq_to_midi_file(self, seq, output_file):
melody = mm.Melody(events=seq.tolist())
note_sequence = melody.to_sequence(qpm=80.0)
mm.sequence_proto_to_midi_file(note_sequence, output_file)
return seq
model = TrainedModel(config,
batch_size=min(FLAGS.max_batch_size, FLAGS.num_outputs),
checkpoint_dir_or_path=checkpoint_dir_or_path)
"""
Encodes a collection of NoteSequences into latent vectors.
Args:
note_sequences: A collection of NoteSequence objects to encode.
assert_same_length: Whether to raise an AssertionError if all of the
extracted sequences are not the same length.
Returns:
The encoded `z`, `mu`, and `sigma` values. (as tuple)
"""
logging.info('Encoding...')
#_, mu, _ = model.encode([input_1, input_2])
z, mu, sigma = model.encode([input_1])
#z = np.array([ # z = collection of latent vectors to decode
# _slerp(mu[0], mu[1], t) for t in np.linspace(0, 1, FLAGS.num_outputs)]) #Spherical linear interpolation
results = model.decode(length=config.hparams.max_seq_len,
z=z,
temperature=FLAGS.temperature)
basename = os.path.join(
FLAGS.output_dir, '%s_%s_%s-*-of-%03d.mid' %
(FLAGS.config, FLAGS.mode, date_and_time, FLAGS.num_outputs))
logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename)
for i, ns in enumerate(results):
mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i))
logging.info('Done.')
def run(config_map):
'''
Load model params, save config file and start trainer.
Args:
config_map: Dictionary mapping configuration name to Config object.
Raises:
ValueError: if required flags are missing or invalid.
'''
date_and_time = time.strftime('%Y-%m-%d_%H%M%S')
if FLAGS.run_dir is None == FLAGS.checkpoint_file is None:
raise ValueError(
'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.'
)
if FLAGS.output_dir is None:
raise ValueError('`--output_dir` is required.')
tf.gfile.MakeDirs(FLAGS.output_dir)
if FLAGS.example_midi_dir is None:
raise ValueError('example_midi_dir is required.')
if FLAGS.config not in config_map:
raise ValueError('Invalid config name: %s' % FLAGS.config)
config = config_map[FLAGS.config]
config.data_converter.max_tensors_per_item = None
config_midime = MidiMeConfig
if FLAGS.config_midime is not None:
update(config_midime, FLAGS.config_midime)
logging.info('Loading model...')
if FLAGS.run_dir:
checkpoint_dir_or_path = os.path.expanduser(
os.path.join(FLAGS.run_dir, 'train'))
else:
checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file)
model = TrainedModel(config,
batch_size=min(FLAGS.max_batch_size,
FLAGS.num_outputs),
checkpoint_dir_or_path=checkpoint_dir_or_path)
example_sequences = []
example_midi_dir = os.path.expanduser(FLAGS.example_midi_dir)
files_in_dir = tf.gfile.ListDirectory(os.path.join(example_midi_dir))
for file_in_dir in files_in_dir:
full_file_path = os.path.join(example_midi_dir, file_in_dir)
try:
example_sequences.append(
mm.midi_file_to_note_sequence(full_file_path))
except:
raise ValueError('%s' % full_file_path)
trimSilence(example_sequences)
for i in example_sequences:
i.tempos[0].time = 0
del i.tempos[1:]
chunks = getChunks(example_sequences, config.hparams.max_seq_len)
latent = model.encode(chunks)[0]
midime = train_model(latent, config_midime)
s = midime.sample(FLAGS.num_outputs)
samples = model.decode(s, config.hparams.max_seq_len)
basename = os.path.join(
FLAGS.output_dir, '%s_%s-*-of-%03d.mid' %
(FLAGS.config, date_and_time, FLAGS.num_outputs))
logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename)
for i, ns in enumerate(samples):
mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i))
logging.info('Done.')
def work_on_midi():
sequence_from_midi = mm.midi_file_to_note_sequence("/Users/wushaobo/Downloads/POP1.mid")
gen_sequence = generate_sequence(sequence_from_midi)
mm.sequence_proto_to_midi_file(gen_sequence, "./output_generated_sequence.mid")
# Teapot song
# and the AI composed notes via the Music VAE model
# The amount of sequences, including the start and end ones, to generate.
num_steps = 8;
# The list of sequence and it's length.
note_sequences = music_vae.interpolate(
teapot, # twinkle_twinkle
twinkle_twinkle, #teapot
num_steps=num_steps,
length=32)
# Concatenate into one long sequence, with the start and
# end sequences at each end.
interp_seq = mm.sequences_lib.concatenate_sequences(note_sequences)
# This is a colab utility method that plays the NoteSequence
# For the fully composed AI music via the Music VAE model
mm.play_sequence(interp_seq, synth=mm.fluidsynth)
# This is a colab utility method that visualizes the NoteSequence
# For the fully composed AI music via the Music VAE model
mm.plot_sequence(interp_seq)
# This creates a file called `drums_sample_output.mid`, containing the drums solo we've been using.
mm.sequence_proto_to_midi_file(interp_seq, 'interp_seq_sample_output.mid')
# This is a colab utility method to download that file. In your Python script, you
# would just write it to disk.
files.download('interp_seq_sample_output.mid')
def sequence2mid(self):
if hasattr(self, 'sequence'):
mm.sequence_proto_to_midi_file(self.sequence, 'model.mid')
else:
print("No sequence exists.")
def run(config_map):
"""Load model params, save config file and start trainer.
Args:
config_map: Dictionary mapping configuration name to Config object.
Raises:
ValueError: if required flags are missing or invalid.
"""
date_and_time = time.strftime('%Y-%m-%d_%H%M%S')
if (FLAGS.run_dir is None) == (FLAGS.checkpoint_file is None):
raise ValueError(
'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.'
)
if FLAGS.output_dir is None:
raise ValueError('`--output_dir` is required.')
tf.gfile.MakeDirs(FLAGS.output_dir)
if FLAGS.mode != 'sample' and FLAGS.mode != 'interpolate':
raise ValueError('Invalid value for `--mode`: %s' % FLAGS.mode)
if FLAGS.config not in config_map:
raise ValueError('Invalid config name: %s' % FLAGS.config)
config = config_map[FLAGS.config]
config.data_converter.max_tensors_per_item = None
if FLAGS.mode == 'interpolate':
if FLAGS.input_midi_1 is None or FLAGS.input_midi_2 is None:
raise ValueError(
'`--input_midi_1` and `--input_midi_2` must be specified in '
'`interpolate` mode.')
input_midi_1 = os.path.expanduser(FLAGS.input_midi_1)
input_midi_2 = os.path.expanduser(FLAGS.input_midi_2)
if not os.path.exists(input_midi_1):
raise ValueError('Input MIDI 1 not found: %s' % FLAGS.input_midi_1)
if not os.path.exists(input_midi_2):
raise ValueError('Input MIDI 2 not found: %s' % FLAGS.input_midi_2)
input_1 = mm.midi_file_to_note_sequence(input_midi_1)
input_2 = mm.midi_file_to_note_sequence(input_midi_2)
def _check_extract_examples(input_ns, path, input_number):
"""Make sure each input returns exactly one example from the converter."""
tensors = config.data_converter.to_tensors(input_ns).outputs
if not tensors:
print(
'MusicVAE configs have very specific input requirements. Could not '
'extract any valid inputs from `%s`. Try another MIDI file.'
% path)
sys.exit()
elif len(tensors) > 1:
basename = os.path.join(
FLAGS.output_dir,
'%s_input%d-extractions_%s-*-of-%03d.mid' %
(FLAGS.config, input_number, date_and_time, len(tensors)))
for i, ns in enumerate(
config.data_converter.from_tensors(tensors)):
mm.sequence_proto_to_midi_file(
ns, basename.replace('*', '%03d' % i))
print(
'%d valid inputs extracted from `%s`. Outputting these potential '
'inputs as `%s`. Call script again with one of these instead.'
% (len(tensors), path, basename))
sys.exit()
logging.info(
'Attempting to extract examples from input MIDIs using config `%s`...',
FLAGS.config)
_check_extract_examples(input_1, FLAGS.input_midi_1, 1)
_check_extract_examples(input_2, FLAGS.input_midi_2, 2)
logging.info('Loading model...')
if FLAGS.run_dir:
checkpoint_dir_or_path = os.path.expanduser(
os.path.join(FLAGS.run_dir, 'train'))
else:
checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file)
model = TrainedModel(config,
batch_size=min(FLAGS.max_batch_size,
FLAGS.num_outputs),
checkpoint_dir_or_path=checkpoint_dir_or_path)
if FLAGS.mode == 'interpolate':
logging.info('Interpolating...')
_, mu, _ = model.encode([input_1, input_2])
z = np.array([
_slerp(mu[0], mu[1], t)
for t in np.linspace(0, 1, FLAGS.num_outputs)
])
results = model.decode(length=config.hparams.max_seq_len,
z=z,
temperature=FLAGS.temperature)
elif FLAGS.mode == 'sample':
logging.info('Sampling...')
results = model.sample(n=FLAGS.num_outputs,
length=config.hparams.max_seq_len,
temperature=FLAGS.temperature)
basename = os.path.join(
FLAGS.output_dir, '%s_%s_%s-*-of-%03d.mid' %
(FLAGS.config, FLAGS.mode, date_and_time, FLAGS.num_outputs))
logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename)
for i, ns in enumerate(results):
mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i))
logging.info('Done.')
def save_midi(self, audio_tensor, path):
note_seq = self._config.data_converter.to_items([audio_tensor])[0]
music.sequence_proto_to_midi_file(note_seq, path)
last_end_time = max(
n.end_time
for n in input_sequence.notes) if input_sequence.notes else 0
qpm = input_sequence.tempos[0].qpm
seconds_per_step = 60.0 / qpm / rnn_model.steps_per_quarter
start_time = last_end_time + seconds_per_step
generation_seconds = num_steps * seconds_per_step
generator_options.generate_sections.add(start_time=start_time,
end_time=start_time +
generation_seconds)
sequence = rnn_model.generate(input_sequence, generator_options)
return sequence
def _init_generator():
bundle_file = mm.sequence_generator_bundle.read_bundle_file(
'./lib/drum_kit_rnn.mag')
generator_map = drums_rnn_sequence_generator.get_generator_map()
generator = generator_map['drum_kit'](bundle=bundle_file)
return generator
random_sequence = build_note_sequence()
gen_sequence = generate_sequence(random_sequence)
mm.sequence_proto_to_midi_file(gen_sequence, "./output_generated_sequence.mid")
def note_sequence_to_midi_file(note_sequence, path):
"""
Save <note_sequence> to .midi file at <path>
"""
create_dir_if_not_exists(path)
mm.sequence_proto_to_midi_file(note_sequence, path)
def download(note_sequence, filename):
mm.sequence_proto_to_midi_file(note_sequence, filename)
teapot = music_pb2.NoteSequence()
teapot.notes.add(pitch=69, start_time=0, end_time=0.5, velocity=80)
teapot.notes.add(pitch=71, start_time=0.5, end_time=1, velocity=80)
teapot.notes.add(pitch=73, start_time=1, end_time=1.5, velocity=80)
teapot.notes.add(pitch=74, start_time=1.5, end_time=2, velocity=80)
teapot.notes.add(pitch=76, start_time=2, end_time=2.5, velocity=80)
teapot.notes.add(pitch=81, start_time=3, end_time=4, velocity=80)
teapot.notes.add(pitch=78, start_time=4, end_time=5, velocity=80)
teapot.notes.add(pitch=81, start_time=5, end_time=6, velocity=80)
teapot.notes.add(pitch=76, start_time=6, end_time=8, velocity=80)
teapot.total_time = 8
teapot.tempos.add(qpm=60)
mm.sequence_proto_to_midi_file(teapot, 'drums_sample_output.mid')
# Import dependencies.
from magenta.models.melody_rnn import melody_rnn_sequence_generator
from magenta.protobuf import generator_pb2
from magenta.protobuf import music_pb2
# Initialize the model.
mm.notebook_utils.download_bundle('basic_rnn.mag', '/content/')
bundle = mm.sequence_generator_bundle.read_bundle_file(
'/content/basic_rnn.mag')
generator_map = melody_rnn_sequence_generator.get_generator_map()
melody_rnn = generator_map['basic_rnn'](checkpoint=None, bundle=bundle)
melody_rnn.initialize()
print("INITIALIZATION COMPLETE")
def run(config_map):
"""Load model params, save config file and start trainer.
Args:
config_map: Dictionary mapping configuration name to Config object.
Raises:
ValueError: if required flags are missing or invalid.
"""
date_and_time = time.strftime('%Y-%m-%d_%H%M%S')
if FLAGS.run_dir is None == FLAGS.checkpoint_file is None:
raise ValueError(
'Exactly one of `--run_dir` or `--checkpoint_file` must be specified.')
if FLAGS.output_dir is None:
raise ValueError('`--output_dir` is required.')
tf.gfile.MakeDirs(FLAGS.output_dir)
if FLAGS.mode != 'sample' and FLAGS.mode != 'interpolate':
raise ValueError('Invalid value for `--mode`: %s' % FLAGS.mode)
if FLAGS.config not in config_map:
raise ValueError('Invalid config name: %s' % FLAGS.config)
config = config_map[FLAGS.config]
config.data_converter.max_tensors_per_item = None
if FLAGS.mode == 'interpolate':
if FLAGS.input_midi_1 is None or FLAGS.input_midi_2 is None:
raise ValueError(
'`--input_midi_1` and `--input_midi_2` must be specified in '
'`interpolate` mode.')
input_midi_1 = os.path.expanduser(FLAGS.input_midi_1)
input_midi_2 = os.path.expanduser(FLAGS.input_midi_2)
if not os.path.exists(input_midi_1):
raise ValueError('Input MIDI 1 not found: %s' % FLAGS.input_midi_1)
if not os.path.exists(input_midi_2):
raise ValueError('Input MIDI 2 not found: %s' % FLAGS.input_midi_2)
input_1 = mm.midi_file_to_note_sequence(input_midi_1)
input_2 = mm.midi_file_to_note_sequence(input_midi_2)
def _check_extract_examples(input_ns, path, input_number):
"""Make sure each input returns exactly one example from the converter."""
tensors = config.data_converter.to_tensors(input_ns).outputs
if not tensors:
print(
'MusicVAE configs have very specific input requirements. Could not '
'extract any valid inputs from `%s`. Try another MIDI file.' % path)
sys.exit()
elif len(tensors) > 1:
basename = os.path.join(
FLAGS.output_dir,
'%s_input%d-extractions_%s-*-of-%03d.mid' %
(FLAGS.config, input_number, date_and_time, len(tensors)))
for i, ns in enumerate(config.data_converter.to_notesequences(tensors)):
mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i))
print(
'%d valid inputs extracted from `%s`. Outputting these potential '
'inputs as `%s`. Call script again with one of these instead.' %
(len(tensors), path, basename))
sys.exit()
logging.info(
'Attempting to extract examples from input MIDIs using config `%s`...',
FLAGS.config)
_check_extract_examples(input_1, FLAGS.input_midi_1, 1)
_check_extract_examples(input_2, FLAGS.input_midi_2, 2)
logging.info('Loading model...')
if FLAGS.run_dir:
checkpoint_dir_or_path = os.path.expanduser(
os.path.join(FLAGS.run_dir, 'train'))
else:
checkpoint_dir_or_path = os.path.expanduser(FLAGS.checkpoint_file)
model = TrainedModel(
config, batch_size=min(FLAGS.max_batch_size, FLAGS.num_outputs),
checkpoint_dir_or_path=checkpoint_dir_or_path)
if FLAGS.mode == 'interpolate':
logging.info('Interpolating...')
_, mu, _ = model.encode([input_1, input_2])
z = np.array([
_slerp(mu[0], mu[1], t) for t in np.linspace(0, 1, FLAGS.num_outputs)])
results = model.decode(
length=config.hparams.max_seq_len,
z=z,
temperature=FLAGS.temperature)
elif FLAGS.mode == 'sample':
logging.info('Sampling...')
results = model.sample(
n=FLAGS.num_outputs,
length=config.hparams.max_seq_len,
temperature=FLAGS.temperature)
basename = os.path.join(
FLAGS.output_dir,
'%s_%s_%s-*-of-%03d.mid' %
(FLAGS.config, FLAGS.mode, date_and_time, FLAGS.num_outputs))
logging.info('Outputting %d files as `%s`...', FLAGS.num_outputs, basename)
for i, ns in enumerate(results):
mm.sequence_proto_to_midi_file(ns, basename.replace('*', '%03d' % i))
logging.info('Done.')
def preprocess_samples(samples, frame_size, frame_time, spectrogram, prefix,
data_dir):
num = 0
for audio, sequence in samples:
num += 1
frames, frame_num = audio2frame(audio, frame_size, spectrogram)
mm.sequence_proto_to_midi_file(
sequence, os.path.join(data_dir, '%s_%i.mid' % (prefix, num)))
# calulate how many note for each pitch in this sample
statistics = np.zeros((cfg.PITCH_NUM), dtype=int)
for note in sequence.notes:
statistics[cfg.INDEX_DICT[note.pitch]] += 1
# Sort the notes by start_time and end_time to do a sweep
notes = [[note.start_time, note.end_time, cfg.INDEX_DICT[note.pitch]]
for note in sequence.notes]
notes_dict = dict(zip(list(range(len(notes))), notes))
start_dict = {}
end_dict = {}
for i in notes_dict:
start_time = notes_dict[i][0]
end_time = notes_dict[i][1]
start_dict.setdefault(start_time, set()).add(i)
end_dict.setdefault(end_time, set()).add(i)
start_times = sorted(start_dict.keys())
end_times = sorted(end_dict.keys())
# Generate activation and onset matrix
last_time = end_times[-1]
t, l, r = 0, 0, 0
status = set()
activation = np.zeros((frame_num, cfg.PITCH_NUM), dtype=int)
onset = np.zeros((frame_num, cfg.PITCH_NUM), dtype=int)
for i in range(frame_num):
st = i * frame_time / 1000.0
ed = (i + 1) * frame_time / 1000.0
while l < len(start_times
) and start_times[l] >= st and start_times[l] < ed:
note_list = start_dict[start_times[l]]
status.update(note_list)
l += 1
for j in note_list:
onset[i, notes_dict[j][2]] = 1
for j in status:
activation[i, notes_dict[j][2]] = 1
while r < len(
end_times) and end_times[r] >= st and end_times[r] < ed:
note_list = end_dict[end_times[r]]
status = status - note_list
r += 1
'''
if frame_num > 200:
utils.plot_matrix(onset.T)
assert(False)
'''
# Save the sample to a file
sample = {
'Audio': audio,
'Frames': frames,
'Activation': activation,
'Onset': onset,
'Sequence': parse_sequence(sequence),
'Statistics': statistics
}
with open(os.path.join(data_dir, '%s_%i.pickle' % (prefix, num)),
'wb') as f:
pickle.dump(sample, f)
