def testToNoteSequenceMultipleChunksWithChords(self):
sequence = copy.deepcopy(self.sequence)
testing_lib.add_track_to_sequence(sequence, 0, [
(64, 100, 0, 2),
(60, 100, 0, 4),
(67, 100, 2, 4),
(62, 100, 4, 6),
(59, 100, 4, 8),
(67, 100, 6, 8),
])
testing_lib.add_track_to_sequence(sequence,
1, [
(40, 100, 0, 0.125),
(50, 100, 0, 0.125),
(50, 100, 2, 2.125),
(40, 100, 4, 4.125),
(50, 100, 4, 4.125),
(50, 100, 6, 6.125),
],
is_drum=True)
testing_lib.add_chords_to_sequence(sequence, [('C', 0), ('G', 4)])
converter = data_hierarchical.MultiInstrumentPerformanceConverter(
hop_size_bars=4,
chunk_size_bars=2,
chord_encoding=note_seq.MajorMinorChordOneHotEncoding())
tensors = converter.to_tensors(sequence)
self.assertEqual(1, len(tensors.outputs))
sequences = converter.from_tensors(tensors.outputs, tensors.controls)
self.assertEqual(1, len(sequences))
self.assertProtoEquals(sequence, sequences[0])
def testExtractChordsForMelodiesCoincidentChords(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
music_testing_lib.add_track_to_sequence(
self.note_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
music_testing_lib.add_chords_to_sequence(
self.note_sequence,
[('C', 2), ('G7', 6), ('E13', 8), ('Cmaj7', 8)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
melodies, _ = melody_pipelines.extract_melodies(
quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, stats = chord_pipelines.extract_chords_for_melodies(
quantized_sequence, melodies)
expected = [[NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7'],
['Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7']]
stats_dict = dict((stat.name, stat) for stat in stats)
self.assertIsNone(chord_progressions[0])
self.assertEqual(expected,
[list(chords) for chords in chord_progressions[1:]])
self.assertEqual(stats_dict['coincident_chords'].count, 1)
def testExtractChordsForMelodies(self):
music_testing_lib.add_track_to_sequence(self.note_sequence,
0, [(12, 100, 2, 4),
(11, 1, 6, 11)])
music_testing_lib.add_track_to_sequence(self.note_sequence,
1, [(12, 127, 2, 4),
(14, 50, 6, 8),
(50, 100, 33, 37),
(52, 100, 34, 37)])
music_testing_lib.add_chords_to_sequence(self.note_sequence,
[('C', 2), ('G7', 6),
('Cmaj7', 33)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
melodies, _ = melody_pipelines.extract_melodies(
quantized_sequence,
min_bars=1,
gap_bars=2,
min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chord_pipelines.extract_chords_for_melodies(
quantized_sequence, melodies)
expected = [[
NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7', 'G7', 'G7',
'G7'
], [NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7'],
['G7', 'Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7']]
self.assertEqual(expected,
[list(chords) for chords in chord_progressions])
def testEventListChordsWithMelodies(self):
note_sequence = music_pb2.NoteSequence(ticks_per_quarter=220)
note_sequence.tempos.add(qpm=60.0)
testing_lib.add_chords_to_sequence(note_sequence,
[('N.C.', 0), ('C', 2), ('G7', 6)])
note_sequence.total_time = 8.0
melodies = [
melodies_lib.Melody([60, -2, -2, -1],
start_step=0,
steps_per_quarter=1,
steps_per_bar=4),
melodies_lib.Melody([62, -2, -2, -1],
start_step=4,
steps_per_quarter=1,
steps_per_bar=4),
]
quantized_sequence = sequences_lib.quantize_note_sequence(
note_sequence, steps_per_quarter=1)
chords = chords_lib.event_list_chords(quantized_sequence, melodies)
expected_chords = [[NO_CHORD, NO_CHORD, 'C', 'C'],
['C', 'C', 'G7', 'G7']]
self.assertEqual(expected_chords, chords)
def testExtractLeadSheetFragments(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, .5, 1), (11, 1, 1.5, 2.75)])
music_testing_lib.add_track_to_sequence(
self.note_sequence, 1,
[(12, 127, .5, 1), (14, 50, 1.5, 2),
(50, 100, 8.25, 9.25), (52, 100, 8.5, 9.25)])
music_testing_lib.add_chords_to_sequence(
self.note_sequence,
[('C', .5), ('G7', 1.5), ('Cmaj7', 8.25)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
lead_sheets, _ = lead_sheet_pipelines.extract_lead_sheet_fragments(
quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True, require_chords=True)
melodies, _ = melody_pipelines.extract_melodies(
quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chord_pipelines.extract_chords_for_melodies(
quantized_sequence, melodies)
self.assertEqual(list(melodies),
list(lead_sheet.melody for lead_sheet in lead_sheets))
self.assertEqual(list(chord_progressions),
list(lead_sheet.chords for lead_sheet in lead_sheets))
def testExtractLeadSheetFragmentsNoChords(self):
music_testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
music_testing_lib.add_track_to_sequence(
self.note_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
music_testing_lib.add_chords_to_sequence(
self.note_sequence,
[('C', 2), ('G7', 6), (NO_CHORD, 10)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, steps_per_quarter=1)
lead_sheets, stats = lead_sheet_pipelines.extract_lead_sheet_fragments(
quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True, require_chords=True)
melodies, _ = melody_pipelines.extract_melodies(
quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chord_pipelines.extract_chords_for_melodies(
quantized_sequence, melodies)
stats_dict = dict((stat.name, stat) for stat in stats)
# Last lead sheet should be rejected for having no chords.
self.assertEqual(list(melodies[:2]),
list(lead_sheet.melody for lead_sheet in lead_sheets))
self.assertEqual(list(chord_progressions[:2]),
list(lead_sheet.chords for lead_sheet in lead_sheets))
self.assertEqual(stats_dict['empty_chord_progressions'].count, 1)
def testExtractChords(self):
music_testing_lib.add_chords_to_sequence(
self.note_sequence, [('C', 2), ('G7', 6), ('F', 8)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
quantized_sequence.total_quantized_steps = 10
chord_progressions, _ = chord_pipelines.extract_chords(quantized_sequence)
expected = [[NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7', 'F', 'F']]
self.assertEqual(expected, [list(chords) for chords in chord_progressions])
def testFromQuantizedNoteSequenceWithCoincidentChords(self):
testing_lib.add_chords_to_sequence(
self.note_sequence,
[('Am', 4), ('D7', 8), ('G13', 12), ('Csus', 12)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
chords = chords_lib.ChordProgression()
with self.assertRaises(chords_lib.CoincidentChordsError):
chords.from_quantized_sequence(
quantized_sequence, start_step=0, end_step=16)
def testFromQuantizedNoteSequenceWithinSingleChord(self):
testing_lib.add_chords_to_sequence(
self.note_sequence, [('F', 0), ('Gm', 8)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
chords = chords_lib.ChordProgression()
chords.from_quantized_sequence(
quantized_sequence, start_step=4, end_step=6)
expected = ['F'] * 2
self.assertEqual(expected, list(chords))
def testExtractChordsAllTranspositions(self):
music_testing_lib.add_chords_to_sequence(
self.note_sequence, [('C', 1)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
quantized_sequence.total_quantized_steps = 2
chord_progressions, _ = chord_pipelines.extract_chords(
quantized_sequence, all_transpositions=True)
expected = list(zip([NO_CHORD] * 12, ['Gb', 'G', 'Ab', 'A', 'Bb', 'B',
'C', 'Db', 'D', 'Eb', 'E', 'F']))
self.assertEqual(expected, [tuple(chords) for chords in chord_progressions])
def testFromQuantizedNoteSequence(self):
testing_lib.add_chords_to_sequence(
self.note_sequence,
[('Am', 4), ('D7', 8), ('G13', 12), ('Csus', 14)])
quantized_sequence = sequences_lib.quantize_note_sequence(
self.note_sequence, self.steps_per_quarter)
chords = chords_lib.ChordProgression()
chords.from_quantized_sequence(
quantized_sequence, start_step=0, end_step=16)
expected = [NO_CHORD, NO_CHORD, NO_CHORD, NO_CHORD,
'Am', 'Am', 'Am', 'Am', 'D7', 'D7', 'D7', 'D7',
'G13', 'G13', 'Csus', 'Csus']
self.assertEqual(expected, list(chords))
def testAddChordsToSequence(self):
note_sequence = music_pb2.NoteSequence(ticks_per_quarter=220)
note_sequence.tempos.add(qpm=60.0)
testing_lib.add_chords_to_sequence(
note_sequence, [('N.C.', 0), ('C', 2), ('G7', 6)])
note_sequence.total_time = 8.0
expected_sequence = copy.deepcopy(note_sequence)
del note_sequence.text_annotations[:]
chords = [NO_CHORD, 'C', 'C', 'G7']
chord_times = [0.0, 2.0, 4.0, 6.0]
chords_lib.add_chords_to_sequence(note_sequence, chords, chord_times)
self.assertEqual(expected_sequence, note_sequence)
def testLeadSheetExtractor(self):
note_sequence = common_testing_lib.parse_test_proto(
music_pb2.NoteSequence, """
time_signatures: {
numerator: 4
denominator: 4}
tempos: {
qpm: 60}""")
music_testing_lib.add_track_to_sequence(note_sequence,
0, [(12, 100, 2, 4),
(11, 1, 6, 7)])
music_testing_lib.add_track_to_sequence(note_sequence,
1, [(12, 127, 2, 4),
(14, 50, 6, 8)])
music_testing_lib.add_chords_to_sequence(note_sequence, [('Cm7', 2),
('F9', 4),
('G7b9', 6)])
quantized_sequence = sequences_lib.quantize_note_sequence(
note_sequence, steps_per_quarter=1)
expected_melody_events = [[
NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 11
], [
NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 14, NO_EVENT
]]
expected_chord_events = [[
NO_CHORD, NO_CHORD, 'Cm7', 'Cm7', 'F9', 'F9', 'G7b9'
], [NO_CHORD, NO_CHORD, 'Cm7', 'Cm7', 'F9', 'F9', 'G7b9', 'G7b9']]
expected_lead_sheets = []
for melody_events, chord_events in zip(expected_melody_events,
expected_chord_events):
melody = melodies_lib.Melody(melody_events,
steps_per_quarter=1,
steps_per_bar=4)
chords = chords_lib.ChordProgression(chord_events,
steps_per_quarter=1,
steps_per_bar=4)
lead_sheet = lead_sheets_lib.LeadSheet(melody, chords)
expected_lead_sheets.append(lead_sheet)
unit = lead_sheet_pipelines.LeadSheetExtractor(
min_bars=1,
min_unique_pitches=1,
gap_bars=1,
all_transpositions=False)
self._unit_transform_test(unit, quantized_sequence,
expected_lead_sheets)
def testEncodeNoteSequence(self):
encoder = music_encoders.TextChordsEncoder(steps_per_quarter=1)
ns = note_seq.NoteSequence()
ns.tempos.add(qpm=60)
testing_lib.add_chords_to_sequence(ns, [('C', 1), ('Dm', 3),
('Bdim', 4)])
ns.total_time = 5.0
ids = encoder.encode_note_sequence(ns)
expected_ids = [
2, # no-chord
3, # C major
3, # C major
17, # D minor
50 # B diminished
]
self.assertEqual(expected_ids, ids)
def testEncodeNoteSequence(self):
encoder = music_encoders.CompositeScoreEncoder([
music_encoders.TextChordsEncoder(steps_per_quarter=4),
music_encoders.TextMelodyEncoder(steps_per_quarter=4,
min_pitch=21,
max_pitch=108)
])
ns = note_seq.NoteSequence()
ns.tempos.add(qpm=60)
testing_lib.add_chords_to_sequence(ns, [('C', 0.5), ('Dm', 1.0)])
testing_lib.add_track_to_sequence(ns, 0, [(60, 127, 0.0, 0.25),
(62, 127, 0.25, 0.75),
(64, 127, 1.25, 2.0)])
chord_ids, melody_ids = zip(*encoder.encode_note_sequence(ns))
expected_chord_ids = [
2, # no-chord
2, # no-chord
3, # C major
3, # C major
17, # D minor
17, # D minor
17, # D minor
17 # D minor
]
expected_melody_ids = [
43, # ON(60)
45, # ON(62)
2, # HOLD(62)
3, # OFF(62)
2, # REST
47, # ON(64)
2, # HOLD(64)
2 # HOLD(64)
]
self.assertEqual(expected_chord_ids, list(chord_ids))
self.assertEqual(expected_melody_ids, list(melody_ids))
def testChordsExtractor(self):
note_sequence = common_testing_lib.parse_test_proto(
music_pb2.NoteSequence,
"""
time_signatures: {
numerator: 4
denominator: 4}
tempos: {
qpm: 60}""")
music_testing_lib.add_chords_to_sequence(
note_sequence, [('C', 2), ('Am', 4), ('F', 5)])
quantized_sequence = sequences_lib.quantize_note_sequence(
note_sequence, steps_per_quarter=1)
quantized_sequence.total_quantized_steps = 8
expected_events = [[NO_CHORD, NO_CHORD, 'C', 'C', 'Am', 'F', 'F', 'F']]
expected_chord_progressions = []
for events_list in expected_events:
chords = chords_lib.ChordProgression(
events_list, steps_per_quarter=1, steps_per_bar=4)
expected_chord_progressions.append(chords)
unit = chord_pipelines.ChordsExtractor(all_transpositions=False)
self._unit_transform_test(unit, quantized_sequence,
expected_chord_progressions)
