def scatter_quant(): path = 'weimardb/midi_from_db_quant' quant = lsum( notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) path = 'weimardb/midi_from_db' db = lsum( notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) path = 'weimardb/midi_combined' comb = lsum( notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) path = 'weimardb/midi_from_ly' ly = lsum( notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) for note in ly: note.tick_abs = int(note.tick_abs * 2.5) note.resolution = 960 for lis in db, quant, ly, comb: for pos in 48, 64, 72: print(pos, sum(n.ticks_since_beat_quantised == pos for n in lis)) vec = np.array([[n.ticks_since_beat_quantised, n.duration_quantised] for n in comb]) plt.scatter(*vec.T) plt.yscale('log', basey=2) plt.show()
def weimar(model, song, choruses=3, order=5, epochs=None, callback=None): """ Train a model on the Weimar database of transcriptions and then run it on the specified chord progression. :param epochs: :param callback: to monitor training :param model: The name of the model: 'twolayer' or 'lstm'. :param song: The name of the chord progression to use for generation. Both the midi file and the text file containing the changes must exist with this name. The generation seed will be obtained from the beginning of the midi file. :param choruses: The number of choruses to generate :param order: """ from models import neural msg_callback = callback.set_text if callback else print changes = changes_from_file(song) model_name = model if model == 'neural': model = neural.OneLayer(changes, order) elif model.startswith('lstm'): model = neural.LSTM(changes, stateful=not model.endswith('stateless')) seed = notes_from_file(r"input/{}.mid".format(song))[:model.order] Note.default_resolution = seed[0].resolution metadata = weimar.load_metadata() training_set = list(itertools.chain(*((notes_from_file('weimardb/midi_combined/{}.mid'.format(song.name)), song.changes) for song in metadata))) if model.learn(*training_set, epochs=epochs, callback=callback): msg_callback("Generating notes...") model.add_past(*seed) melody = generate(seed, changes, model, None, choruses * changes.measures()) notes_to_file(add_chords(melody, changes), 'output/weimar_{}.mid'.format(model_name), msg_callback)
def turing(): """ Generate a Turing test """ from models import neural song = 'Eb_therewill' changes = changes_from_file(song) filename = "input/{}.mid".format(song) notes = notes_from_file(filename) Note.default_resolution = notes[0].resolution melody_generator = neural.LSTM(changes) train(notes, changes, melody_generator) melody_generator.add_past(*notes[:melody_generator.order]) melody = generate(notes[:melody_generator.order], changes, melody_generator, None, 6 * changes.measures()) melody = add_chords(melody, changes) num_choruses = notes[-1].measure // changes.measures() for i in range(5): # Write a chorus of human improvisation and a chorus of machine improvisation to file start = (i + 1) * changes.measures() end = (i + 2) * changes.measures() notes_to_file(extract_measures(melody, start, end), 'output/machine{}.mid'.format(i)) n = random.randint(2, num_choruses - 2) start = n * changes.measures() end = (n + 1) * changes.measures() notes_to_file( add_chords(extract_measures(notes, start, end), changes), 'output/man{}.mid'.format(i))
def pca(): """ Perform PCA on the MIDI file """ notes = notes_from_file('input/Eb_therewill.mid') data = np.array([[n.ticks_since_beat_quantised, n.duration_quantised, n.pitch] for n in notes]) cent = (data - data.T.mean(axis=1)).T c, s, l = princomp(cent) plt.plot(l) plt.show()
def weimar(): """ Check for correct relation of changes to MIDI """ Note.default_resolution = 960 metadata = weimar.load_metadata() for song in metadata: snl = song.name.lower() if 'therewill' in snl or 'singin' in snl or 'anthropo' in snl: notes = notes_from_file('weimardb/midi_combined/{}.mid'.format(song.name)) notes_to_file(add_chords(notes, song.changes), 'output/weimartest_{}.mid'.format(song.name))
def convert_song(song: SongMetadata): """ Combine the quantized and the unquantized MIDI files into one that aligns to measures but attempts to retain the original phrasing """ from file_handlers import notes_to_file from file_handlers import notes_from_file Note.default_resolution = 960 quantized = notes_from_file('weimardb/midi_from_db_quant/{}.mid'.format(song.name)) original = notes_from_file('weimardb/midi_from_db/{}.mid'.format(song.name)) lilypond = notes_from_file('weimardb/midi_from_ly/{}.mid'.format(song.name)) d = {} for n, m in zip(quantized, lilypond): if m.measure - n.measure not in d: d[m.measure - n.measure] = 1 else: d[m.measure - n.measure] += 1 if len(d) == 2: break meas_start = min(d.keys()) # type: int meas_size = Note.meter * Note.default_resolution meas_no = 0 a, b, c = [], [], [] # quantized measure, original measure, combined output lp = [] # lilypond measure: only needed for durations for q, o, l in zip(quantized, original, lilypond): if q.measure != meas_no: if len(a) > 1: r = (a[-1].tick_abs - a[0].tick_abs) / (b[-1].tick_abs - b[0].tick_abs) # stretch ratio a_m = (meas_no + 0.5) * meas_size # middle of quantized measure b_m = b[0].tick_abs + (a_m - a[0].tick_abs) / r # estimated middle of unquantized measure for a_j, b_j, l_j in zip(a, b, lp): n = Note() n.pitch = b_j.pitch n.resolution = b_j.resolution n.velocity = b_j.velocity n.tick_abs = int(a_m + r * (b_j.tick_abs - b_m)) + (meas_start * meas_size) n.duration = int(r * b_j.duration) or a_j.duration or l_j.duration c.append(n) else: c += a meas_no = q.measure a, b, lp = [], [], [] a.append(q) b.append(o) lp.append(l) notes_to_file(sorted(c, key=lambda p: p.tick_abs), 'weimardb/midi_combined/{}.mid'.format(song.name))
def scatter_quant(): path = 'weimardb/midi_from_db_quant' quant = lsum(notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) path = 'weimardb/midi_from_db' db = lsum(notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) path = 'weimardb/midi_combined' comb = lsum(notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) path = 'weimardb/midi_from_ly' ly = lsum(notes_from_file(os.path.join(path, file)) for file in os.listdir(path)) for note in ly: note.tick_abs = int(note.tick_abs * 2.5) note.resolution = 960 for lis in db, quant, ly, comb: for pos in 48, 64, 72: print(pos, sum(n.ticks_since_beat_quantised == pos for n in lis)) vec = np.array([[n.ticks_since_beat_quantised, n.duration_quantised] for n in comb]) plt.scatter(*vec.T) plt.yscale('log', basey=2) plt.show()
def pca(): """ Perform PCA on the MIDI file """ notes = notes_from_file('input/Eb_therewill.mid') data = np.array( [[n.ticks_since_beat_quantised, n.duration_quantised, n.pitch] for n in notes]) cent = (data - data.T.mean(axis=1)).T c, s, l = princomp(cent) plt.plot(l) plt.show()
def total_recall(): """ Test the code that drives generation by feeding it the training set as generated output """ song = 'Eb_therewill' model = TotalRecall() changes = changes_from_file(song) notes = notes_from_file(r"input/{}.mid".format(song)) Note.default_resolution = notes[0].resolution train(notes, changes, model) m = generate(notes[:model.order], changes, model, None, 4 * changes.measures()) notes_to_file(add_chords(m, changes), 'output/test.mid')
def scatter(): """ Create a scatter plot of durations vs position in beat """ song = 'Eb_therewill' notes = notes_from_file(r"input/{}.mid".format(song)) vec = np.array([[n.ticks_since_beat_quantised, n.duration_quantised] for n in notes]) with open('scatter.dat', 'w') as kf: for tsbq, dq in vec: if dq: # don't want 0 values exported for logarithmic plot print(tsbq, dq, file=kf) plt.scatter(*vec.T) plt.show()
def total_recall(): """ Test the code that drives generation by feeding it the training set as generated output """ song = 'Eb_therewill' model = TotalRecall() changes = changes_from_file(song) notes = notes_from_file(r"input/{}.mid".format(song)) Note.default_resolution = notes[0].resolution train(notes, changes, model) m = generate(notes[:model.order], changes, model, None, 4 * changes.measures()) notes_to_file(add_chords(m, changes), 'output/test.mid')
def weimar(): """ Check for correct relation of changes to MIDI """ Note.default_resolution = 960 metadata = weimar.load_metadata() for song in metadata: snl = song.name.lower() if 'therewill' in snl or 'singin' in snl or 'anthropo' in snl: notes = notes_from_file('weimardb/midi_combined/{}.mid'.format( song.name)) notes_to_file(add_chords(notes, song.changes), 'output/weimartest_{}.mid'.format(song.name))
def scatter(): """ Create a scatter plot of durations vs position in beat """ song = 'Eb_therewill' notes = notes_from_file(r"input/{}.mid".format(song)) vec = np.array([[n.ticks_since_beat_quantised, n.duration_quantised] for n in notes]) with open('scatter.dat', 'w') as kf: for tsbq, dq in vec: if dq: # don't want 0 values exported for logarithmic plot print(tsbq, dq, file=kf) plt.scatter(*vec.T) plt.show()
def single(model, song, choruses=3, order=5, epochs=None, callback=None): """ Train and run a model on the same chord progression. :param model: The name of the model: 'markov' or 'neural'. :param song: The name of the song. Both the midi file and the text file containing the changes must exist with this name. :param choruses: The number of choruses to generate :param order: :param epochs: :param callback: to monitor training """ from models import neural msg_callback = callback.set_text if callback else print # Read the chord changes from a text file changes = changes_from_file(song) # Read the training set from a MIDI file notes = notes_from_file(r"input/{}.mid".format(song)) Note.default_resolution = notes[0].resolution # Learn and generate melody_generator = None rhythm_generator = None if model == 'markov': melody_generator = markov.ChordAgnosticMelody(order) rhythm_generator = markov.Rhythm() elif model == 'neural': melody_generator = neural.OneLayer(changes, order) elif model.startswith('lstm'): melody_generator = neural.LSTM( changes, stateful=not model.endswith('stateless')) elif model == 'lasagne': melody_generator = neural.lasagne.OneLayer(changes, order) if train(notes, changes, melody_generator, rhythm_generator, callback=callback, epochs=epochs): if model != 'markov': melody_generator.add_past(*notes[:melody_generator.order]) msg_callback("Generating notes...") if rhythm_generator is None: rhythm_generator = melody_generator melody = generate( notes[:max(melody_generator.order, rhythm_generator.order)], changes, melody_generator, rhythm_generator, choruses * changes.measures()) # Write output file notes_to_file(add_chords(melody, changes), 'output/{}.mid'.format(model), msg_callback)
def weimar(model, song, choruses=3, order=5, epochs=None, callback=None): """ Train a model on the Weimar database of transcriptions and then run it on the specified chord progression. :param epochs: :param callback: to monitor training :param model: The name of the model: 'twolayer' or 'lstm'. :param song: The name of the chord progression to use for generation. Both the midi file and the text file containing the changes must exist with this name. The generation seed will be obtained from the beginning of the midi file. :param choruses: The number of choruses to generate :param order: """ from models import neural msg_callback = callback.set_text if callback else print changes = changes_from_file(song) model_name = model if model == 'neural': model = neural.OneLayer(changes, order) elif model.startswith('lstm'): model = neural.LSTM(changes, stateful=not model.endswith('stateless')) seed = notes_from_file(r"input/{}.mid".format(song))[:model.order] Note.default_resolution = seed[0].resolution metadata = weimar.load_metadata() training_set = list( itertools.chain(*((notes_from_file( 'weimardb/midi_combined/{}.mid'.format(song.name)), song.changes) for song in metadata))) if model.learn(*training_set, epochs=epochs, callback=callback): msg_callback("Generating notes...") model.add_past(*seed) melody = generate(seed, changes, model, None, choruses * changes.measures()) notes_to_file(add_chords(melody, changes), 'output/weimar_{}.mid'.format(model_name), msg_callback)
def fast_and_furious(stateful=True): """ Keras provides a choice of 3 implementations for recurrent layers. Find out which is the fastest. """ from models import neural song = 'Eb_therewill' changes = changes_from_file(song) notes = notes_from_file(r"input/{}.mid".format(song)) Note.default_resolution = notes[0].resolution model = neural.LSTM(changes, stateful=stateful) d = {} for i in [0, 1, 2]: print('implementation', i) t = time.time() model._implementation = i model.learn(notes, changes, epochs=1) d[i] = time.time() - t print(d)
def fast_and_furious(stateful=True): """ Keras provides a choice of 3 implementations for recurrent layers. Find out which is the fastest. """ from models import neural song = 'Eb_therewill' changes = changes_from_file(song) notes = notes_from_file(r"input/{}.mid".format(song)) Note.default_resolution = notes[0].resolution model = neural.LSTM(changes, stateful=stateful) d = {} for i in [0, 1, 2]: print('implementation', i) t = time.time() model._implementation = i model.learn(notes, changes, epochs=1) d[i] = time.time() - t print(d)
def single(model, song, choruses=3, order=5, epochs=None, callback=None): """ Train and run a model on the same chord progression. :param model: The name of the model: 'markov' or 'neural'. :param song: The name of the song. Both the midi file and the text file containing the changes must exist with this name. :param choruses: The number of choruses to generate :param order: :param epochs: :param callback: to monitor training """ from models import neural msg_callback = callback.set_text if callback else print # Read the chord changes from a text file changes = changes_from_file(song) # Read the training set from a MIDI file notes = notes_from_file(r"input/{}.mid".format(song)) Note.default_resolution = notes[0].resolution # Learn and generate melody_generator = None rhythm_generator = None if model == 'markov': melody_generator = markov.ChordAgnosticMelody(order) rhythm_generator = markov.Rhythm() elif model == 'neural': melody_generator = neural.OneLayer(changes, order) elif model.startswith('lstm'): melody_generator = neural.LSTM(changes, stateful=not model.endswith('stateless')) elif model == 'lasagne': melody_generator = neural.lasagne.OneLayer(changes, order) if train(notes, changes, melody_generator, rhythm_generator, callback=callback, epochs=epochs): if model != 'markov': melody_generator.add_past(*notes[:melody_generator.order]) msg_callback("Generating notes...") if rhythm_generator is None: rhythm_generator = melody_generator melody = generate(notes[:max(melody_generator.order, rhythm_generator.order)], changes, melody_generator, rhythm_generator, choruses * changes.measures()) # Write output file notes_to_file(add_chords(melody, changes), 'output/{}.mid'.format(model), msg_callback)
def turing(): """ Generate a Turing test """ from models import neural song = 'Eb_therewill' changes = changes_from_file(song) filename = "input/{}.mid".format(song) notes = notes_from_file(filename) Note.default_resolution = notes[0].resolution melody_generator = neural.LSTM(changes) train(notes, changes, melody_generator) melody_generator.add_past(*notes[:melody_generator.order]) melody = generate(notes[:melody_generator.order], changes, melody_generator, None, 6 * changes.measures()) melody = add_chords(melody, changes) num_choruses = notes[-1].measure // changes.measures() for i in range(5): # Write a chorus of human improvisation and a chorus of machine improvisation to file start = (i + 1) * changes.measures() end = (i + 2) * changes.measures() notes_to_file(extract_measures(melody, start, end), 'output/machine{}.mid'.format(i)) n = random.randint(2, num_choruses - 2) start = n * changes.measures() end = (n + 1) * changes.measures() notes_to_file(add_chords(extract_measures(notes, start, end), changes), 'output/man{}.mid'.format(i))
def back_to_the_future(): """ Find out how common it is that a later note has a smaller tick_abs """ song = 'Eb_therewill' notes = notes_from_file(r"input/{}.mid".format(song)) print(sum(n.tick_abs > m.tick_abs for n, m in nwise(notes, 2)))
def back_to_the_future(): """ Find out how common it is that a later note has a smaller tick_abs """ song = 'Eb_therewill' notes = notes_from_file(r"input/{}.mid".format(song)) print(sum(n.tick_abs > m.tick_abs for n, m in nwise(notes, 2)))