|
for n in range(1000): |
|
sampled_data = ds.__getitem__(n) |
|
|
|
a = deepcopy(sampled_data['note_event_segments']) |
|
b = deepcopy(sampled_data['note_event_segments']) |
|
|
|
for (note_events, tie_note_events, start_time) in list(zip(*b.values())): |
|
note_events = pitch_shift_note_events(note_events, 2) |
|
tie_note_events = pitch_shift_note_events(tie_note_events, 2) |
|
|
|
|
|
for i, (note_events, tie_note_events, start_time) in enumerate(list(zip(*b.values()))): |
|
for j, ne in enumerate(note_events): |
|
if ne.is_drum is False: |
|
if ne.pitch != a['note_events'][i][j].pitch + 2: |
|
print(i, j) |
|
assert ne.pitch == a['note_events'][i][j].pitch + 2 |
|
|
|
for k, tne in enumerate(tie_note_events): |
|
assert tne.pitch == a['tie_note_events'][i][k].pitch + 2 |
|
|
|
print('test {} passed'.format(n)) |
|
|
|
|
|
def assert_note_events_almost_equal(actual_note_events, |
|
predicted_note_events, |
|
ignore_time=False, |
|
ignore_activity=True, |
|
delta=5.1e-3): |
|
""" |
|
Asserts that the given lists of Note instances are equal up to a small |
|
floating-point tolerance, similar to `assertAlmostEqual` of `unittest`. |
|
Tolerance is 5e-3 by default, which is 5 ms for 100 ticks-per-second. |
|
|
|
If `ignore_time` is True, then the time field is ignored. (useful for |
|
comparing tie note events, default is False) |
|
|
|
If `ignore_activity` is True, then the activity field is ignored (default |
|
is True). |
|
""" |
|
assert len(actual_note_events) == len(predicted_note_events) |
|
for j, (actual_note_event, |
|
predicted_note_event) in enumerate(zip(actual_note_events, predicted_note_events)): |
|
if ignore_time is False: |
|
assert abs(actual_note_event.time - predicted_note_event.time) <= delta |
|
assert actual_note_event.is_drum == predicted_note_event.is_drum |
|
if actual_note_event.is_drum is False and predicted_note_event.is_drum is False: |
|
assert actual_note_event.program == predicted_note_event.program |
|
assert actual_note_event.pitch == predicted_note_event.pitch |
|
assert actual_note_event.velocity == predicted_note_event.velocity |
|
if ignore_activity is False: |
|
assert actual_note_event.activity == predicted_note_event.activity |
|
|
|
|
|
cache_old = deepcopy(dict(ds.cache)) |
|
for n in range(500): |
|
sampled_data = ds.__getitem__(n) |
|
cache_new = ds.cache |
|
cnt = 0 |
|
for k, v in cache_new.items(): |
|
if k in cache_old: |
|
cnt += 1 |
|
assert (cache_new[k]['programs'] == cache_old[k]['programs']).all() |
|
assert (cache_new[k]['is_drum'] == cache_old[k]['is_drum']).all() |
|
assert (cache_new[k]['has_stems'] == cache_old[k]['has_stems']) |
|
assert (cache_new[k]['has_unannotated'] == cache_old[k]['has_unannotated']) |
|
assert (cache_new[k]['audio_array'] == cache_old[k]['audio_array']).all() |
|
|
|
for nes_new, nes_old in zip(cache_new[k]['note_event_segments']['note_events'], |
|
cache_old[k]['note_event_segments']['note_events']): |
|
assert_note_events_almost_equal(nes_new, nes_old) |
|
|
|
for tnes_new, tnes_old in zip(cache_new[k]['note_event_segments']['tie_note_events'], |
|
cache_old[k]['note_event_segments']['tie_note_events']): |
|
assert_note_events_almost_equal(tnes_new, tnes_old, ignore_time=True) |
|
|
|
for s_new, s_old in zip(cache_new[k]['note_event_segments']['start_times'], |
|
cache_old[k]['note_event_segments']['start_times']): |
|
assert s_new == s_old |
|
cache_old = deepcopy(dict(ds.cache)) |
|
print(n, cnt) |
|
|
