def parse(self) -> Sequence[_InstanceMetadata]:
if not self.can_parse():
raise IOError("unable to parse the ComParE 2020 USOMS-e dataset at {}".format(self._basedir))
meta_list = []
metadata = self._metadata()
for file in sorted(self._audio_dir.glob("*.*")):
#use the following line in order to attach the categorical arousal labels
#label_nominal = metadata.loc[metadata["filename_audio"] == file.name]["A_cat"]
#use the following line in order to attach the categorical valence labels
label_nominal = metadata.loc[metadata["filename_audio"] == file.name]["V_cat"]
# test labels are '?'
if all(l != '?' for l in label_nominal):
label_nominal = label_nominal.iloc[0]
else:
label_nominal = None
instance_metadata = _InstanceMetadata(
path=file,
filename=file.name,
label_nominal=label_nominal,
label_numeric=None, # inferred from label map
cv_folds=[],
partition=Partition.TRAIN if file.name.startswith("train") else Partition.DEVEL if file.name.startswith(
"devel") else Partition.TEST
)
self.log.debug("parsed instance %s: label = %s", file.name, label_nominal)
meta_list.append(instance_metadata)
def parse(self) -> Sequence[_InstanceMetadata]:
if not self.can_parse():
raise IOError(
"unable to parse the ComParE 2020 Mask dataset at {}".format(
self._basedir))
meta_list = []
metadata = self._metadata()
for file in sorted(self._audio_dir.glob("*.wav")):
label_nominal = metadata.loc[metadata["file_name"] ==
file.name]["label"]
# test labels are '?'
if all(l != '?' for l in label_nominal):
label_nominal = label_nominal.iloc[0]
else:
label_nominal = None
instance_metadata = _InstanceMetadata(
path=file,
filename=file.name,
label_nominal=str(label_nominal),
label_numeric=None, # inferred from label map
cv_folds=[],
partition=Partition.TRAIN
if file.name.startswith("train") else Partition.DEVEL
if file.name.startswith("devel") else Partition.TEST)
self.log.debug("parsed instance %s: label = %s", file.name,
label_nominal)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
if not self.can_parse():
raise IOError("unable to parse dataset at {}".format(self._basedir))
meta_list = []
metadata = self._metadata()
inverse_label_map = dict(map(reversed, self.label_map.items()))
for file in sorted(self._audio_dir.glob("*.*")):
label_numeric = float(metadata.loc[metadata["file_name"] == file.name]["label"])
# test labels are missing and parsed as NaN
if not math.isnan(label_numeric):
label_numeric = int(label_numeric)
else:
label_numeric = None
instance_metadata = _InstanceMetadata(
path=file,
filename=file.name,
label_nominal=None if label_numeric is None else inverse_label_map[label_numeric],
label_numeric=None, # inferred from label map
cv_folds=[],
partition=Partition.TRAIN if file.name.startswith("train") else Partition.TEST
)
self.log.debug("parsed instance %s: label = %s", file.name, label_numeric)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
"""
meta_list = []
for file in self._basedir.rglob("*.wav"): # type: Path
filename = str(file.relative_to(self._basedir))
instance_metadata = _InstanceMetadata(path=file,
filename=filename,
label_nominal=None,
label_numeric=None,
cv_folds=[],
partition=None)
self.log.debug("parsed instance %s", filename)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
For each instance, metadata is computed and stored in an _InstanceMetadata object. Instances are parsed in the
order in which they appear in the meta.txt file.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
Raises
------
IOError
If the data set cannot be parsed
"""
if not self.can_parse():
raise IOError("unable to parse DCASE dataset at {}".format(
self._basedir))
metadata = self._metadata()
cv_setup = self._cv_setup()
meta_list = []
for index, row in metadata.iterrows():
filename = row[0]
label_nominal = row[1]
if label_nominal not in _DCASE_LABEL_MAP:
raise IOError(
"invalid label for DCASE data: {}".format(label_nominal))
cv_folds = []
for fold_metadata in cv_setup:
cv_folds.append(Split.TRAIN if filename in
fold_metadata.iloc[:,
0].values else Split.VALID)
instance_metadata = _InstanceMetadata(
path=self._basedir / filename,
filename=str(Path(filename).name),
label_nominal=label_nominal,
label_numeric=None,
cv_folds=cv_folds,
partition=None)
self.log.debug("parsed instance %s: label = %s", filename,
label_nominal)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
meta_list = []
for file in _get_audio_paths(self._filelist):
instance_metadata = _InstanceMetadata(path=file,
filename=file.stem,
label_nominal=None,
label_numeric=None,
cv_folds=[],
partition=None)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
For each instance, metadata is computed and stored in an _InstanceMetadata object. Instances are parsed in order
of train partition, development partition, test partition, and in alphabetical order by nominal label and
filename within partitions.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
Raises
------
IOError
If the data set cannot be parsed
"""
if not self.can_parse():
raise IOError("unable to parse dataset at {}".format(
self._basedir))
meta_list = []
existing_dirs = [(partition, partition_dir)
for (partition,
partition_dir) in list(self._dirs.items())
if partition_dir.exists()]
for partition, partition_dir in sorted(existing_dirs,
key=lambda x: x[1]):
for class_dir in sorted(partition_dir.glob("*")):
for file in sorted(class_dir.glob("*.*")):
filename = "{}/{}/{}".format(partition_dir.name,
class_dir.name, file.name)
instance_metadata = _InstanceMetadata(
path=file,
filename=filename,
label_nominal=class_dir.name,
label_numeric=None,
cv_folds=[],
partition=partition)
self.log.debug("parsed instance %s: label = %s", filename,
class_dir.name)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
For each instance, metadata is computed and stored in an _InstanceMetadata object. Instances are parsed in order
of increasing fold number, and in alphabetical order by nominal label and filename within folds.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
Raises
------
IOError
If the data set cannot be parsed
"""
if not self.can_parse():
raise IOError("unable to parse dataset at {}".format(
self._basedir))
meta_list = []
for fold in range(self.num_folds):
fold_dir = self._basedir / ("fold_%d" % (fold + 1))
cv_folds = [Split.TRAIN] * self.num_folds
cv_folds[fold] = Split.VALID
for class_dir in sorted(fold_dir.glob("*")):
for file in sorted(class_dir.glob("*.*")):
filename = "{}/{}/{}".format(fold_dir.name, class_dir.name,
file.name)
instance_metadata = _InstanceMetadata(
path=file,
filename=filename,
label_nominal=class_dir.name,
label_numeric=None,
cv_folds=cv_folds,
partition=None)
self.log.debug("parsed instance %s: label = %s", filename,
class_dir.name)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
For each instance, metadata is computed and stored in an _InstanceMetadata object. Instances are parsed in the
order of the class directories, and in alphabetical order within class directories.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
Raises
------
IOError
If the data set cannot be parsed
"""
if not self.can_parse():
raise IOError("unable to parse ESC dataset at {}".format(
self._basedir))
meta_list = []
for class_dir in self._class_dirs:
label_nominal = class_dir.name[6:]
for ogg_file in class_dir.glob("*.ogg"):
cv_folds = [Split.TRAIN] * self.num_folds
index = int(ogg_file.name[-5]) - 1
if index >= self.num_folds:
continue
cv_folds[index] = Split.VALID
instance_metadata = _InstanceMetadata(
path=ogg_file,
filename=str(ogg_file.name),
label_nominal=label_nominal,
label_numeric=None,
cv_folds=cv_folds,
partition=None)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
For each instance, metadata is computed and stored in an _InstanceMetadata object. Instances are parsed in the
order in which they appear in the metadata/UrbanSound8K.csv file.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
Raises
------
IOError
If the data set cannot be parsed
"""
if not self.can_parse():
raise IOError("Unable to parse UrbanSound8K data set at {}".format(
self._basedir))
meta_list = []
for _, row in self._metadata().iterrows():
filename = row.loc[_ColumnNames.FILENAME]
path = self._basedir / "audio" / (
"fold%d" % row.loc[_ColumnNames.CV_FOLD]) / filename
cv_folds = [Split.TRAIN] * 10
cv_folds[row.loc[_ColumnNames.CV_FOLD] - 1] = Split.VALID
label_nominal = row.loc[_ColumnNames.LABEL_NOMINAL]
instance_metadata = _InstanceMetadata(path=path,
filename=filename,
label_nominal=label_nominal,
label_numeric=None,
cv_folds=cv_folds,
partition=None)
self.log.debug("parsed instance %s: label = %s", filename,
label_nominal)
meta_list.append(instance_metadata)
return meta_list
def parse(self) -> Sequence[_InstanceMetadata]:
"""
Parses the instances contained in this data set.
For each instance, metadata is computed and stored in an _InstanceMetadata object. Instances are parsed in the
order of the class directories, and in alphabetical order within class directories.
Returns
-------
list of _InstanceMetadata
A list of _InstanceMetadata containing one entry for each parsed audio file
Raises
------
IOError
If the data set cannot be parsed
"""
if not self.can_parse():
raise IOError("unable to parse Koe dataset at {}".format(self._basedir))
meta_list = []
for sid, filename, label, label_enum, fold in self._data:
filepath = Path(os.path.join(self._basedir, filename))
cv_folds = [Split.TRAIN] * self._numfolds
cv_folds[fold] = Split.VALID
instance_metadata = _InstanceMetadata(path=filepath,
filename=str(filename),
label_nominal=label,
label_numeric=label_enum,
cv_folds=cv_folds,
partition=None)
meta_list.append(instance_metadata)
return meta_list
