title={Two data sets for tempo estimation and key detection in electronic dance music annotated from user corrections},
author={Knees, Peter and Faraldo P{\'e}rez, {\'A}ngel and Boyer, Herrera and Vogl, Richard and B{\"o}ck, Sebastian and H{\"o}rschl{\"a}ger, Florian and Le Goff, Mickael and others},
booktitle={Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR); 2015 Oct 26-30; M{\'a}laga, Spain.[M{\'a}laga]: International Society for Music Information Retrieval, 2015. p. 364-70.},
year={2015},
organization={International Society for Music Information Retrieval (ISMIR)},
}
@inproceedings{SchreiberM18a_Tempo_ISMIR,
author={Hendrik Schreiber and Meinard M{\"u}ller},
title={A Crowdsourced Experiment for Tempo Estimation of Electronic Dance Music},
booktitle={Proceedings of the International Conference on Music Information Retrieval ({ISMIR})},
address={Paris, France},
year={2018},
url-pdf={http://www.tagtraum.com/download/2018_schreiber_tempo_giantsteps.pdf},
}"""
DATA = utils.LargeData("giantsteps_tempo_index.json")
REMOTES = {
"annotations":
download_utils.RemoteFileMetadata(
filename=
"giantsteps-tempo-dataset-0b7d47ba8cae59d3535a02e3db69e2cf6d0af5bb.zip",
url=
"https://github.com/GiantSteps/giantsteps-tempo-dataset/archive/0b7d47ba8cae59d3535a02e3db69e2cf6d0af5bb.zip",
checksum="8fdafbaf505fe3f293bd912c92b72ac8",
destination_dir="",
)
}
DOWNLOAD_INFO = """
Unfortunately the audio files of the Giant Steps Tempo dataset are not available
for download. If you have the Giant Steps audio dataset, place the contents into
"annotator_2_id": line[3],
"duration": duration,
"title": line[7],
"artist": line[8],
"annotator_1_time": line[10],
"annotator_2_time": line[11],
"class": line[14],
"genre": line[15],
}
metadata_index["data_home"] = data_home
return metadata_index
DATA = utils.LargeData("salami_index.json", _load_metadata)
class Track(core.Track):
"""salami Track class
Args:
track_id (str): track id of the track
Attributes:
annotator_1_id (str): number that identifies annotator 1
annotator_1_time (str): time that the annotator 1 took to complete the annotation
annotator_2_id (str): number that identifies annotator 1
annotator_2_time (str): time that the annotator 1 took to complete the annotation
artist (str): song artist
audio_path (str): path to the audio file
import os
import numpy as np
import mirdata.utils as utils
import mirdata.download_utils as download_utils
import mirdata.jams_utils as jams_utils
DATASET_DIR = 'Beatles'
ANNOTATIONS_REMOTE = download_utils.RemoteFileMetadata(
filename='The Beatles Annotations.tar.gz',
url='http://isophonics.net/files/annotations/The%20Beatles%20Annotations.tar.gz',
checksum='62425c552d37c6bb655a78e4603828cc',
destination_dir='annotations',
)
DATA = utils.LargeData('beatles_index.json')
class Track(object):
"""Beatles track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
track_id (str): track id
audio_path (str): track audio path
title (str): title of the track
beats (BeatData): beat annotation
'contains_strings': tf_dict[line[4]],
'contains_brass': tf_dict[line[5]],
'only_strings': tf_dict[line[6]],
'only_winds': tf_dict[line[7]],
'only_brass': tf_dict[line[8]],
'composer': id_split[0],
'work': '-'.join(id_split[1:-1]),
'excerpt': id_split[-1][2:],
}
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('orchset_index.json', _load_metadata)
class Track(track.Track):
"""orchset Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
alternating_melody (bool): True if the melody alternates between instruments
audio_path_mono (str): path to the mono audio file
audio_path_stereo (str): path to the stereo audio file
composer (str): the work's composer
import os
import librosa
from mirdata import download_utils
from mirdata import utils
DATASET_DIR = "GTZAN-Genre"
DATASET_REMOTE = download_utils.RemoteFileMetadata(
filename="genres.tar.gz",
url="http://opihi.cs.uvic.ca/sound/genres.tar.gz",
checksum="5b3d6dddb579ab49814ab86dba69e7c7",
destination_dir="gtzan_genre",
)
DATA = utils.LargeData("gtzan_genre_index.json")
class Track(object):
"""GTZAN-Genre track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets/GuitarSet`
Attributes:
track_id (str): track id
genre (str): annotated genre
audio_path (str): absolute audio path
"""
def _load_metadata(data_home):
metadata_path = os.path.join(data_home, 'medleydb_melody_metadata.json')
if not os.path.exists(metadata_path):
logging.info('Metadata file {} not found.'.format(metadata_path))
return None
with open(metadata_path, 'r') as fhandle:
metadata = json.load(fhandle)
metadata['data_home'] = data_home
return metadata
DATA = utils.LargeData('medleydb_melody_index.json', _load_metadata)
class Track(track.Track):
"""medleydb_melody Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
artist (str): artist
audio_path (str): path to the audio file
genre (str): genre
is_excerpt (bool): True if the track is an excerpt
AUDIO_MIX_REMOTE = download_utils.RemoteFileMetadata(
filename='audio_mono-pickup_mix.zip',
url=
'https://zenodo.org/record/3371780/files/audio_mono-pickup_mix.zip?download=1',
checksum='aecce79f425a44e2055e46f680e10f6a',
destination_dir='audio_mono-pickup_mix',
)
_STYLE_DICT = {
'Jazz': 'Jazz',
'BN': 'Bossa Nova',
'Rock': 'Rock',
'SS': 'Singer-Songwriter',
'Funk': 'Funk',
}
_GUITAR_STRINGS = ['E', 'A', 'D', 'G', 'B', 'e']
DATA = utils.LargeData('guitarset_index.json')
class Track(track.Track):
"""guitarset Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_hex_cln_path (str): path to the debleeded hex wave file
audio_hex_path (str): path to the original hex wave file
audio_mic_path (str): path to the mono wave via microphone
audio_mix_path (str): path to the mono wave via downmixing hex pickup
DATASET_DIR = 'DALI'
def _load_metadata(data_home):
metadata_path = os.path.join(data_home, os.path.join('dali_metadata.json'))
if not os.path.exists(metadata_path):
logging.info('Metadata file {} not found.'.format(metadata_path))
return None
with open(metadata_path, 'r') as fhandle:
metadata_index = json.load(fhandle)
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('dali_index.json', _load_metadata)
class Track(track.Track):
"""DALI melody Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
album (str): the track's album
annotation_path (str): path to the track's annotation file
artist (str): the track's artist
audio_path (str): path to the track's audio file
'suffix': line[1],
'track_number': line[2],
'category': line[3],
'sub_category': line[4],
'title': line[5],
'composer': line[6],
'artist': line[7],
'duration': _duration_to_sec(line[8]),
}
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('rwc_genre_index.json', _load_metadata)
class Track(object):
"""RWC Genre Track class
Args:
track_id (str): Track id of the Track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
track_id (str): Track id
audio_path (str): Audio path of this Track
piece_number (str): Piece number of this Track, [1-100]
suffix (str): M01-M09
filename="audio_mono-pickup_mix.zip",
url=
"https://zenodo.org/record/3371780/files/audio_mono-pickup_mix.zip?download=1",
checksum="aecce79f425a44e2055e46f680e10f6a",
destination_dir="audio_mono-pickup_mix",
),
}
_STYLE_DICT = {
"Jazz": "Jazz",
"BN": "Bossa Nova",
"Rock": "Rock",
"SS": "Singer-Songwriter",
"Funk": "Funk",
}
_GUITAR_STRINGS = ["E", "A", "D", "G", "B", "e"]
DATA = utils.LargeData("guitarset_index.json")
class Track(core.Track):
"""guitarset Track class
Args:
track_id (str): track id of the track
Attributes:
audio_hex_cln_path (str): path to the debleeded hex wave file
audio_hex_path (str): path to the original hex wave file
audio_mic_path (str): path to the mono wave via microphone
audio_mix_path (str): path to the mono wave via downmixing hex pickup
jams_path (str): path to the jams file
mode (str): one of ['solo', 'comp']
'piece_number': line[0],
'suffix': line[1],
'track_number': line[2],
'title': line[3],
'artist': line[4],
'duration': _duration_to_sec(line[5]),
'variation': line[6],
'instruments': line[7],
}
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('rwc_jazz_index.json', _load_metadata)
class Track(track.Track):
"""rwc_jazz Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
artist (str): Artist name
audio_path (str): path of the audio file
beats_path (str): path of the beat annotation file
duration (float): Duration of the track in seconds
url=
'https://zenodo.org/record/1290750/files/IRMAS-TestingData-Part2.zip?download=1',
checksum='afb0c8ea92f34ee653693106be95c895',
destination_dir=None,
),
'testing_data_3':
download_utils.RemoteFileMetadata(
filename='IRMAS-TestingData-Part3.zip',
url=
'https://zenodo.org/record/1290750/files/IRMAS-TestingData-Part3.zip?download=1',
checksum='9b3fb2d0c89cdc98037121c25bd5b556',
destination_dir=None,
),
}
DATA = utils.LargeData('irmas_index.json')
INST_DICT = [
'cel',
'cla',
'flu',
'gac',
'gel',
'org',
'pia',
'sax',
'tru',
'vio',
'voi',
]
metadata = dict()
metadata['data_home'] = data_home
for i, j in zip(indexes, range(len(artists))):
metadata[i] = {
'musicBrainzID': identifiers[j],
'artist': artists[j],
'title': titles[j],
'release': releases[j],
'duration': durations[j],
}
return metadata
DATA = utils.LargeData('cante100_index.json', _load_metadata)
class Track(core.Track):
"""cante100 track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets/cante100`
Attributes:
track_id (str): track id
identifier (str): musicbrainz id of the track
artist (str): performing artists
title (str): title of the track song
def _load_metadata(data_home):
metadata_path = os.path.join(data_home, 'medleydb_pitch_metadata.json')
if not os.path.exists(metadata_path):
logging.info('Metadata file {} not found.'.format(metadata_path))
return None
with open(metadata_path, 'r') as fhandle:
metadata = json.load(fhandle)
metadata['data_home'] = data_home
return metadata
DATA = utils.LargeData('medleydb_pitch_index.json', _load_metadata)
class Track(track.Track):
"""medleydb_pitch Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
artist (str): artist
audio_path (str): path to the audio file
genre (str): genre
instrument (str): instrument of the track
'piece_number': line[0],
'suffix': line[1],
'track_number': line[2],
'title': line[3],
'composer': line[4],
'artist': line[5],
'duration': _duration_to_sec(line[6]),
'category': line[7],
}
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('rwc_classical_index.json', _load_metadata)
class Track(track.Track):
"""rwc_classical Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
artist (str): the track's artist
audio_path (str): path of the audio file
beats_path (str): path of the beat annotation file
category (str): One of 'Symphony', 'Concerto', 'Orchestral',
year = {2013}
}"""
REMOTES = {
"remote_data":
download_utils.RemoteFileMetadata(
filename="mridangam_stroke_1.5.zip",
url=
"https://zenodo.org/record/4068196/files/mridangam_stroke_1.5.zip?download=1",
checksum="39af55b2476b94c7946bec24331ec01a", # the md5 checksum
destination_dir=
None, # relative path for where to unzip the data, or None
),
}
DATA = utils.LargeData("mridangam_stroke_index.json")
STROKE_DICT = {
"bheem",
"cha",
"dheem",
"dhin",
"num",
"ta",
"tha",
"tham",
"thi",
"thom",
}
TONIC_DICT = {"B", "C", "C#", "D", "D#", "E"}
# load metadata however makes sense for your dataset
with open(metadata_path, 'r') as fhandle:
raw_metadata = json.load(fhandle)
metadata = {}
for mdata in raw_metadata:
track_id = mdata['midi_filename'].split('.')[0]
metadata[track_id] = mdata
metadata['data_home'] = data_home
return metadata
DATA = utils.LargeData('maestro_index.json', _load_metadata)
class Track(track.Track):
"""MAESTRO Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_path (str): Path to the track's audio file
canonical_composer (str): Composer of the piece, standardized on a
single spelling for a given name.
canonical_title (str): Title of the piece. Not guaranteed to be
return None
with open(id_map_path, 'r') as fhandle:
reader = csv.reader(fhandle, delimiter='\t')
singer_map = {}
for line in reader:
if line[0] == 'singer':
continue
singer_map[line[1]] = line[0]
singer_map['data_home'] = data_home
return singer_map
DATA = utils.LargeData('ikala_index.json', _load_metadata)
class Track(track.Track):
"""ikala Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_path (str): path to the track's audio file
f0_path (str): path to the track's f0 annotation file
lyrics_path (str): path to the track's lyric annotation file
section (str): section. Either 'verse' or 'chorus'
'track_number': line[2],
'title': line[3],
'artist': line[4],
'singer_information': line[5],
'duration': _duration_to_sec(line[6]),
'tempo': line[7],
'instruments': line[8],
'drum_information': line[9],
}
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('rwc_popular_index.json', _load_metadata)
class Track(object):
"""RWC Popular Track class
Args:
track_id (str): Track id of the Track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
track_id (str): Track id
audio_path (str): Audio path of this Track
piece_number (str): Piece number of this Track, [1-50]
suffix (str): M01-M04
checksum="62425c552d37c6bb655a78e4603828cc",
destination_dir="annotations",
)
}
DOWNLOAD_INFO = """
Unfortunately the audio files of the Beatles dataset are not available
for download. If you have the Beatles dataset, place the contents into
a folder called Beatles with the following structure:
> Beatles/
> annotations/
> audio/
and copy the Beatles folder to {}
"""
DATA = utils.LargeData("beatles_index.json")
class Track(core.Track):
"""Beatles track class
Args:
track_id (str): track id of the track
Attributes:
audio_path (str): track audio path
beats_path (str): beat annotation path
chords_path (str): chord annotation path
keys_path (str): key annotation path
sections_path (str): sections annotation path
title (str): title of the track
'annotator_2_id': line[3],
'duration': duration,
'title': line[7],
'artist': line[8],
'annotator_1_time': line[10],
'annotator_2_time': line[11],
'class': line[14],
'genre': line[15],
}
metadata_index['data_home'] = data_home
return metadata_index
DATA = utils.LargeData('salami_index.json', _load_metadata)
class Track(track.Track):
"""salami Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
annotator_1_id (str): number that identifies annotator 1
annotator_1_time (str): time that the annotator 1 took to complete the annotation
annotator_2_id (str): number that identifies annotator 1
annotator_2_time (str): time that the annotator 1 took to complete the annotation
"style": str(style),
"tempo": int(bpm),
"beat_type": str(beat_type),
"time_signature": str(time_signature),
"midi_filename": str(midi_filename),
"audio_filename": str(audio_filename),
"duration": float(duration),
"split": str(split),
}
metadata_index["data_home"] = data_home
return metadata_index
DATA = utils.LargeData("groove_midi_index.json", _load_metadata)
class Track(core.Track):
"""Groove MIDI Track class
Args:
track_id (str): track id of the track
Attributes:
drummer (str): Drummer id of the track (ex. 'drummer1')
session (str): Type of session (ex. 'session1', 'eval_session')
track_id (str): track id of the track (ex. 'drummer1/eval_session/1')
style (str): Style (genre, groove type) of the track (ex. 'funk/groove1')
tempo (int): Track tempo in beats per minute (ex. 138)
beat_type (str): Whether the track is a beat or a fill (ex. 'beat')
"""
def _load_metadata(data_home):
metadata_path = os.path.join(data_home, os.path.join("dali_metadata.json"))
if not os.path.exists(metadata_path):
logging.info("Metadata file {} not found.".format(metadata_path))
return None
with open(metadata_path, "r") as fhandle:
metadata_index = json.load(fhandle)
metadata_index["data_home"] = data_home
return metadata_index
DATA = utils.LargeData("dali_index.json", _load_metadata)
class Track(core.Track):
"""DALI melody Track class
Args:
track_id (str): track id of the track
Attributes:
album (str): the track's album
annotation_path (str): path to the track's annotation file
artist (str): the track's artist
audio_path (str): path to the track's audio file
audio_url (str): youtube ID
dataset_version (int): dataset annotation version
filename='keys.zip',
url='https://zenodo.org/record/1095691/files/keys.zip?download=1',
checksum='775b7d17e009f5818544cf505b6a96fd',
destination_dir='.',
),
'metadata':
download_utils.RemoteFileMetadata(
filename='original_metadata.zip',
url=
'https://zenodo.org/record/1095691/files/original_metadata.zip?download=1',
checksum='54181e0f34c35d9720439750d0b08091',
destination_dir='.',
),
}
DATA = utils.LargeData('giantsteps_key_index.json')
class Track(track.Track):
"""giantsteps_key track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_path (str): track audio path
keys_path (str): key annotation path
metadata_path (str): sections annotation path
title (str): title of the track
filename="original_metadata.zip",
url=
"https://zenodo.org/record/1101082/files/original_metadata.zip?download=1",
checksum="bb3e3ac1fe5dee7600ef2814accdf8f8",
destination_dir=".",
),
"audio":
download_utils.RemoteFileMetadata(
filename="audio.zip",
url="https://zenodo.org/record/1101082/files/audio.zip?download=1",
checksum="f490ee6c23578482d6fcfa11b82636a1",
destination_dir=".",
),
}
DATA = utils.LargeData("beatport_key_index.json")
class Track(core.Track):
"""beatport_key track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored.
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_path (str): track audio path
keys_path (str): key annotation path
metadata_path (str): sections annotation path
title (str): title of the track
track_id (str): track id
"""
next(csv_reader)
for row in csv_reader:
subset, instrument_str, instrument_id, song_id, track_id = row
metadata_index[str(track_id)] = {
"subset": str(subset),
"instrument": str(instrument_str),
"instrument_id": int(instrument_id),
"song_id": int(song_id),
}
metadata_index["data_home"] = data_home
return metadata_index
DATA = utils.LargeData("medley_solos_db_index.json", _load_metadata)
class Track(track.Track):
"""medley_solos_db Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_path (str): path to the track's audio file
instrument (str): instrument encoded by its English name
instrument_id (int): instrument encoded as an integer
song_id (int): song encoded as an integer
def _load_metadata(metadata_path):
if not os.path.exists(metadata_path):
logging.info('Metadata file {} not found.'.format(metadata_path))
return None
with open(metadata_path) as f:
metadata = json.load(f)
data_home = metadata_path.split('/' + metadata_path.split('/')[-3])[0]
metadata['track_id'] = (str(metadata_path.split('/')[-3]) + '_' +
str(metadata_path.split('/')[-2]))
metadata['data_home'] = data_home
return metadata
DATA = utils.LargeData('saraga_index.json', _load_metadata)
class Track(core.Track):
"""Saraga Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Common attributes:
iam_style (str): flag to identify if track belongs to hindustani or carnatic collection
title (str): Title of the piece in the track
mbid (str): MusicBrainz ID of the track
album_artists (list, dicts): list of dicts containing the album artists present in the track and its mbid
"Pitch": row[7],
"Pitch ID": int(row[8]),
"Dynamics": row[9],
"Dynamics ID": int(row[10]),
"Instance ID": int(row[11]),
"Resampled": (row[13] == "TRUE"),
}
if len(row[12]) > 0:
metadata_index[key]["String ID"] = int(float(row[12]))
metadata_index["data_home"] = data_home
return metadata_index
DATA = utils.LargeData("tinysol_index.json", _load_metadata)
class Track(track.Track):
"""tinysol Track class
Args:
track_id (str): track id of the track
data_home (str): Local path where the dataset is stored. default=None
If `None`, looks for the data in the default directory, `~/mir_datasets`
Attributes:
audio_path (str): path of the audio file
dynamics (str): dynamics abbreviation. Ex: pp, mf, ff, etc.
dynamics_id (int): pp=0, p=1, mf=2, f=3, ff=4
family (str): instrument family encoded by its English name
return None
with open(id_map_path, "r") as fhandle:
reader = csv.reader(fhandle, delimiter="\t")
singer_map = {}
for line in reader:
if line[0] == "singer":
continue
singer_map[line[1]] = line[0]
singer_map["data_home"] = data_home
return singer_map
DATA = utils.LargeData("ikala_index.json", _load_metadata)
class Track(core.Track):
"""ikala Track class
Args:
track_id (str): track id of the track
Attributes:
audio_path (str): path to the track's audio file
f0_path (str): path to the track's f0 annotation file
lyrics_path (str): path to the track's lyric annotation file
section (str): section. Either 'verse' or 'chorus'
singer_id (str): singer id
song_id (str): song id of the track
