def app(msd_ids: List[str]):
start = timeit.default_timer()
# Cleanup the output directory
shutil.rmtree(args.path_output_dir, ignore_errors=True)
# Starts the threads
with Pool(args.pool_size) as pool:
manager = Manager()
counter = AtomicCounter(manager, len(msd_ids))
print("START")
results = pool.starmap(process, zip(msd_ids, cycle([counter])))
results = [result for result in results if result]
print("END")
results_percentage = len(results) / len(msd_ids) * 100
print(f"Number of tracks: {len(MSD_SCORE_MATCHES)}, "
f"number of tracks in sample: {len(msd_ids)}, "
f"number of results: {len(results)} "
f"({results_percentage:.2f}%)")
# Creates an histogram for the piano lengths
pm_pianos_list = [result["pm_pianos"] for result in results]
pm_piano_lengths = [
pm_piano.get_end_time() for pm_pianos in pm_pianos_list
for pm_piano in pm_pianos
]
#plt.figure(num=None, figsize=(10, 8), dpi=500)
plt.hist(pm_piano_lengths, bins=100, color="darkmagenta")
plt.title('Piano lengths')
plt.ylabel('length (sec)')
plt.show()
stop = timeit.default_timer()
print("Time: ", stop - start)
def app(msd_ids: List[str]):
start = timeit.default_timer()
# Starts the threads
with Pool(args.pool_size) as pool:
manager = Manager()
counter = AtomicCounter(manager, len(msd_ids))
print("START")
results = pool.starmap(process, zip(msd_ids, cycle([counter])))
results = [result for result in results if result]
print("END")
results_percentage = len(results) / len(msd_ids) * 100
print(f"Number of tracks: {len(MSD_SCORE_MATCHES)}, "
f"number of tracks in sample: {len(msd_ids)}, "
f"number of results: {len(results)} "
f"({results_percentage:.2f}%)")
# Creates a bar chart for the most common artists
artists = [result["artist"] for result in results]
most_common_artists = Counter(artists).most_common(25)
print(f"Most common artists: {most_common_artists}")
plot_bars(most_common_artists, "Artist song count")
stop = timeit.default_timer()
print("Time: ", stop - start)
def app(msd_ids: List[str]):
start = timeit.default_timer()
# Starts the threads
with Pool(args.pool_size) as pool:
manager = Manager()
counter = AtomicCounter(manager, len(msd_ids))
print("START")
results = pool.starmap(process, zip(msd_ids, cycle([counter])))
results = [result for result in results if result]
print("END")
results_percentage = len(results) / len(msd_ids) * 100
print(f"Number of tracks: {len(MSD_SCORE_MATCHES)}, "
f"number of tracks in sample: {len(msd_ids)}, "
f"number of results: {len(results)} "
f"({results_percentage:.2f}%)")
# Creates a bar chart for the most common artists
artists = [result["artist"] for result in results]
most_common_artists = Counter(artists).most_common(25)
print(f"Most common artists: {most_common_artists}")
plt.figure(num=None, figsize=(10, 8), dpi=500)
plt.bar([artist for artist, _ in most_common_artists],
[count for _, count in most_common_artists],
color=[color.name for color in colors if color.name != "lavender"])
plt.title("Artist song count")
plt.xticks(rotation=30, horizontalalignment="right")
plt.ylabel("count")
plt.show()
stop = timeit.default_timer()
print("Time: ", stop - start)
def app(msd_ids: List[str]):
start = timeit.default_timer()
# Starts the threads
with Pool(args.pool_size) as pool:
manager = Manager()
counter = AtomicCounter(manager, len(msd_ids))
print("START")
results = pool.starmap(process, zip(msd_ids, cycle([counter])))
results = [result for result in results if result]
print("END")
results_percentage = len(results) / len(msd_ids) * 100
print(f"Number of tracks: {len(MSD_SCORE_MATCHES)}, "
f"number of tracks in sample: {len(msd_ids)}, "
f"number of results: {len(results)} "
f"({results_percentage:.2f}%)")
# Finds which tags matches and count the results
tags = []
unique_tags = set()
for result in results:
result_tags = result["tags"]
matching_tags = [tag for tag in result_tags if tag in TAGS]
if matching_tags:
joined_tag = "+".join(matching_tags)
tags.append(joined_tag)
unique_tags.add(joined_tag)
match_percentage = len(tags) / len(results) * 100
print(f"Number of results: {len(results)}, "
f"number of matched tags: {len(tags)} "
f"({match_percentage:.2f}%)")
# Creates a bar chart for the most common tags
most_common_tags = Counter(tags).most_common()
plot_bars(most_common_tags, "Tags count for " + ",".join(TAGS))
# plt.figure(num=None, figsize=(10, 8), dpi=500)
# plt.bar([tag for tag, _ in most_common_tags],
# [count for _, count in most_common_tags],
# color=[color.name for color in colors
# if color.name != "lavender"])
# plt.title("Tags count for " + ",".join(TAGS))
# plt.xticks(rotation=30, horizontalalignment="right")
# plt.ylabel("count")
# plt.show()
stop = timeit.default_timer()
print("Time: ", stop - start)
def app(msd_ids: List[str]):
start = timeit.default_timer()
# Cleanup the output directory
shutil.rmtree(args.path_output_dir, ignore_errors=True)
# Starts the threads
with Pool(args.pool_size) as pool:
manager = Manager()
counter = AtomicCounter(manager, len(msd_ids))
print("START")
results = pool.starmap(process, zip(msd_ids, cycle([counter])))
results = [result for result in results if result]
print("END")
results_percentage = len(results) / len(msd_ids) * 100
print(f"Number of tracks: {len(MSD_SCORE_MATCHES)}, "
f"number of tracks in sample: {len(msd_ids)}, "
f"number of results: {len(results)} "
f"({results_percentage:.2f}%)")
# Creates an histogram for the piano lengths
pm_pianos_list = [result["pm_pianos"] for result in results]
pm_piano_lengths = [
pm_piano.get_end_time() for pm_pianos in pm_pianos_list
for pm_piano in pm_pianos
]
plt.figure(num=None, figsize=(10, 8), dpi=500)
plt.hist(pm_piano_lengths, bins=100, color="darkmagenta")
plt.title('Piano lengths')
plt.ylabel('length (sec)')
plt.show()
# Creates a bar chart for the tags
tags_list = [result["tags"] for result in results]
tags = [tag for tags in tags_list for tag in tags]
most_common_tags = Counter(tags).most_common()
plt.figure(num=None, figsize=(10, 8), dpi=500)
plt.bar([tag for tag, _ in most_common_tags],
[count for _, count in most_common_tags],
color=[color.name for color in colors if color.name != "lavender"])
plt.title("Tags count for " + ",".join(TAGS))
plt.xticks(rotation=30, horizontalalignment="right")
plt.ylabel("count")
plt.show()
stop = timeit.default_timer()
print("Time: ", stop - start)
def app(midi_paths: List[str]):
start = timeit.default_timer()
# Cleanup the output directory
shutil.rmtree(args.path_output_dir, ignore_errors=True)
# Starts the threads
with Pool(args.pool_size) as pool:
manager = Manager()
counter = AtomicCounter(manager, len(midi_paths), 1000)
print("START")
results = pool.starmap(process, zip(midi_paths, cycle([counter])))
results = [result for result in results if result]
print("END")
results_percentage = len(results) / len(midi_paths) * 100
print(f"Number of tracks: {len(MIDI_PATHS)}, "
f"number of tracks in sample: {len(midi_paths)}, "
f"number of results: {len(results)} "
f"({results_percentage:.2f}%)")
# Creates an histogram for the drum lengths
pm_drums = [result["pm_drums"] for result in results]
pm_drums_lengths = [pm.get_end_time() for pm in pm_drums]
plt.figure(num=None, figsize=(10, 8), dpi=500)
plt.hist(pm_drums_lengths, bins=100, color="darkmagenta")
plt.title('Drums lengths')
plt.ylabel('length (sec)')
plt.show()
# Creates an histogram for the bass drums on beat
bass_drums_on_beat = [result["bass_drums_on_beat"] for result in results]
plt.figure(num=None, figsize=(10, 8), dpi=500)
plt.hist(bass_drums_on_beat, bins=100, color="darkmagenta")
plt.title('Bass drums on beat')
plt.ylabel('count')
plt.show()
stop = timeit.default_timer()
print("Time: ", stop - start)
