示例#1
0
def test_select_features():
    my_file_struct = FileStruct(os.path.join("fixtures", "chirp.mp3"))
    feature = Features.select_features("pcp", my_file_struct, False, True)
    assert isinstance(feature, PCP)
    assert feature.feat_type == FeatureTypes.framesync

    feature = Features.select_features("mfcc", my_file_struct, False, False)
    assert isinstance(feature, MFCC)
    assert feature.feat_type == FeatureTypes.est_beatsync

    feature = Features.select_features("cqt", my_file_struct, True, False)
    assert isinstance(feature, CQT)
    assert feature.feat_type == FeatureTypes.ann_beatsync
示例#2
0
def test_select_features():
    my_file_struct = FileStruct(os.path.join("fixtures", "chirp.mp3"))
    feature = Features.select_features("pcp", my_file_struct, False, True)
    assert isinstance(feature, PCP)
    assert feature.feat_type == FeatureTypes.framesync

    feature = Features.select_features("mfcc", my_file_struct, False, False)
    assert isinstance(feature, MFCC)
    assert feature.feat_type == FeatureTypes.est_beatsync

    feature = Features.select_features("cqt", my_file_struct, True, False)
    assert isinstance(feature, CQT)
    assert feature.feat_type == FeatureTypes.ann_beatsync
示例#3
0
def compute_all_features(file_struct, framesync):
    """Computes all features for the given file."""
    for feature_id in msaf.features_registry:
        logging.info("Computing %s for file %s" % (feature_id,
                                                   file_struct.audio_file))
        feats = Features.select_features(feature_id, file_struct, False, framesync)
        feats.features
def process_track(file_struct,
                  boundaries_id,
                  labels_id,
                  config,
                  annotator_id=0):
    """Prepares the parameters, runs the algorithms, and saves results.

    Parameters
    ----------
    file_struct: `msaf.io.FileStruct`
        FileStruct containing the paths of the input files (audio file,
        features file, reference file, output estimation file).
    boundaries_id: str
        Identifier of the boundaries algorithm to use ("gt" for ground truth).
    labels_id: str
        Identifier of the labels algorithm to use (None for not labeling).
    config: dict
        Dictionary containing the custom parameters of the algorithms to use.
    annotator_id: int
        Annotator identificator in the ground truth.

    Returns
    -------
    est_times: np.array
        List of estimated times for the segment boundaries.
    est_labels: np.array
        List of all the labels associated segments.
    """
    logging.info("Segmenting %s" % file_struct.audio_file)

    # Get features
    config["features"] = Features.select_features(config["feature"],
                                                  file_struct,
                                                  config["annot_beats"],
                                                  config["framesync"])

    # Get estimations
    est_times, est_labels = run_algorithms(file_struct,
                                           boundaries_id,
                                           labels_id,
                                           config,
                                           annotator_id=annotator_id)

    # Save
    logging.info("Writing results in: %s" % file_struct.est_file)
    io.save_estimations(file_struct, est_times, est_labels, boundaries_id,
                        labels_id, **config)

    return est_times, est_labels
示例#5
0
文件: test_run.py 项目: urinieto/msaf
def test_no_gt_flat_bounds():
    """Make sure the results are empty if there is not ground truth found."""
    feature = "pcp"
    annot_beats = False
    framesync = False
    file_struct = msaf.io.FileStruct(audio_file)
    file_struct.features_file = msaf.config.features_tmp_file

    config = {}
    config["features"] = Features.select_features(
        feature, file_struct, annot_beats, framesync)
    est_times, est_labels = msaf.run.run_flat(file_struct, None, None,
                                              None, config, 0)
    assert(not est_times)
    assert(not est_labels)
示例#6
0
def test_no_gt_flat_bounds():
    """Make sure the results are empty if there is not ground truth found."""
    feature = "pcp"
    annot_beats = False
    framesync = False
    file_struct = msaf.io.FileStruct(audio_file)
    file_struct.features_file = msaf.config.features_tmp_file

    config = {}
    config["features"] = Features.select_features(feature, file_struct,
                                                  annot_beats, framesync)
    est_times, est_labels = msaf.run.run_flat(file_struct, None, None, None,
                                              config, 0)
    assert (not est_times)
    assert (not est_labels)
示例#7
0
文件: test_run.py 项目: urinieto/msaf
    def _test_run_msaf(bound_id, label_id, hier=False):
        config = msaf.io.get_configuration(feature, annot_beats, framesync,
                                           bound_id, label_id)
        config["hier"] = hier
        config["features"] = Features.select_features(
            feature, file_struct, annot_beats, framesync)
        est_times, est_labels = msaf.run.run_algorithms(
            file_struct, bound_id, label_id, config)

        # Take the first level if hierarchy algorithm
        if hier:
            est_times = est_times[0]
            est_labels = est_labels[0]

        npt.assert_almost_equal(est_times[0], 0.0, decimal=2)
        assert len(est_times) - 1 == len(est_labels)
        npt.assert_almost_equal(est_times[-1], config["features"].dur,
                                decimal=2)
示例#8
0
    def _test_run_msaf(bound_id, label_id, hier=False):
        config = msaf.io.get_configuration(feature, annot_beats, framesync,
                                           bound_id, label_id)
        config["hier"] = hier
        config["features"] = Features.select_features(feature, file_struct,
                                                      annot_beats, framesync)
        est_times, est_labels = msaf.run.run_algorithms(
            file_struct, bound_id, label_id, config)

        # Take the first level if hierarchy algorithm
        if hier:
            est_times = est_times[0]
            est_labels = est_labels[0]

        npt.assert_almost_equal(est_times[0], 0.0, decimal=2)
        assert len(est_times) - 1 == len(est_labels)
        npt.assert_almost_equal(est_times[-1],
                                config["features"].dur,
                                decimal=2)
示例#9
0
文件: run.py 项目: wangsix/msaf
def process_track(file_struct, boundaries_id, labels_id, config,
                  annotator_id=0):
    """Prepares the parameters, runs the algorithms, and saves results.

    Parameters
    ----------
    file_struct: `msaf.io.FileStruct`
        FileStruct containing the paths of the input files (audio file,
        features file, reference file, output estimation file).
    boundaries_id: str
        Identifier of the boundaries algorithm to use ("gt" for ground truth).
    labels_id: str
        Identifier of the labels algorithm to use (None for not labeling).
    config: dict
        Dictionary containing the custom parameters of the algorithms to use.
    annotator_id: int
        Annotator identificator in the ground truth.

    Returns
    -------
    est_times: np.array
        List of estimated times for the segment boundaries.
    est_labels: np.array
        List of all the labels associated segments.
    """
    logging.info("Segmenting %s" % file_struct.audio_file)

    # Get features
    config["features"] = Features.select_features(
        config["feature"], file_struct, config["annot_beats"],
        config["framesync"])

    # Get estimations
    est_times, est_labels = run_algorithms(file_struct,
                                           boundaries_id, labels_id, config,
                                           annotator_id=annotator_id)

    # Save
    logging.info("Writing results in: %s" % file_struct.est_file)
    io.save_estimations(file_struct, est_times, est_labels,
                        boundaries_id, labels_id, **config)

    return est_times, est_labels
示例#10
0
文件: test_run.py 项目: urinieto/msaf
def test_run_algorithms():
    """Test running all the algorithms."""
    bound_ids = msaf.io.get_all_boundary_algorithms()
    label_ids = msaf.io.get_all_label_algorithms()

    # Add ground truth to boundary id
    bound_ids += ["gt"]

    # Add None to labels
    label_ids += [None]

    # Config params
    feature = "pcp"
    annot_beats = False
    framesync = False
    file_struct = msaf.io.FileStruct(audio_file)
    file_struct.features_file = msaf.config.features_tmp_file

    # Running all algorithms on a file that is too short
    for bound_id in bound_ids:
        for label_id in label_ids:
            config = msaf.io.get_configuration(feature, annot_beats, framesync,
                                               bound_id, label_id)
            config["hier"] = False
            config["features"] = Features.select_features(
                feature, file_struct, annot_beats, framesync)
            est_times, est_labels = msaf.run.run_algorithms(
                file_struct, bound_id, label_id, config)
            assert len(est_times) == 2
            assert len(est_labels) == 1
            npt.assert_almost_equal(est_times[0], 0.0, decimal=2)
            npt.assert_almost_equal(est_times[-1], config["features"].dur,
                                    decimal=2)

    # Commpute and save features for long audio file
    file_struct = msaf.io.FileStruct(long_audio_file)
    file_struct.features_file = msaf.config.features_tmp_file

    def _test_run_msaf(bound_id, label_id, hier=False):
        config = msaf.io.get_configuration(feature, annot_beats, framesync,
                                           bound_id, label_id)
        config["hier"] = hier
        config["features"] = Features.select_features(
            feature, file_struct, annot_beats, framesync)
        est_times, est_labels = msaf.run.run_algorithms(
            file_struct, bound_id, label_id, config)

        # Take the first level if hierarchy algorithm
        if hier:
            est_times = est_times[0]
            est_labels = est_labels[0]

        npt.assert_almost_equal(est_times[0], 0.0, decimal=2)
        assert len(est_times) - 1 == len(est_labels)
        npt.assert_almost_equal(est_times[-1], config["features"].dur,
                                decimal=2)

    # Running all boundary algorithms on a relatively long file
    for bound_id in bound_ids:
        if bound_id == "gt":
            continue
        yield (_test_run_msaf, bound_id, None, False)

    # Combining boundaries with labels
    for bound_id in bound_ids:
        if bound_id == "gt" or bound_id == "example":
            continue
        for label_id in label_ids:
            yield (_test_run_msaf, bound_id, label_id, False)

    # Test the hierarchical algorithms
    hier_ids = ["olda", "scluster"]
    for hier_bounds_id in hier_ids:
        for hier_labels_id in hier_ids:
            if hier_labels_id == "olda":
                hier_labels_id = "fmc2d"
            yield (_test_run_msaf, hier_bounds_id, hier_labels_id, True)
示例#11
0
def test_global_compute_features():
    my_file_struct = FileStruct(os.path.join("fixtures", "chirp.mp3"))
    feats = Features(my_file_struct, 11025, 1024, FeatureTypes.framesync)
    feats.compute_features()
示例#12
0
def test_wrong_select_features():
    Features.select_features("cqt", None, True, True)
示例#13
0
文件: run.py 项目: wangsix/msaf
def process(in_path, annot_beats=False, feature="pcp", framesync=False,
            boundaries_id=msaf.config.default_bound_id,
            labels_id=msaf.config.default_label_id, hier=False,
            sonify_bounds=False, plot=False, n_jobs=4, annotator_id=0,
            config=None, out_bounds="out_bounds.wav", out_sr=22050):
    """Main process to segment a file or a collection of files.

    Parameters
    ----------
    in_path: str
        Input path. If a directory, MSAF will function in collection mode.
        If audio file, MSAF will be in single file mode.
    annot_beats: bool
        Whether to use annotated beats or not. Only available in collection
        mode.
    feature: str
        String representing the feature to be used (e.g. pcp, mfcc, tonnetz)
    framesync: str
        Whether to use framesync features or not (default: False -> beatsync)
    boundaries_id: str
        Identifier of the boundaries algorithm (use "gt" for groundtruth)
    labels_id: str
        Identifier of the labels algorithm (use None to not compute labels)
    hier : bool
        Whether to compute a hierarchical or flat segmentation.
    sonify_bounds: bool
        Whether to write an output audio file with the annotated boundaries
        or not (only available in Single File Mode).
    plot: bool
        Whether to plot the boundaries and labels against the ground truth.
    n_jobs: int
        Number of processes to run in parallel. Only available in collection
        mode.
    annotator_id: int
        Annotator identificator in the ground truth.
    config: dict
        Dictionary containing custom configuration parameters for the
        algorithms.  If None, the default parameters are used.
    out_bounds: str
        Path to the output for the sonified boundaries (only in single file
        mode, when sonify_bounds is True.
    out_sr : int
        Sampling rate for the sonified bounds.

    Returns
    -------
    results : list
        List containing tuples of (est_times, est_labels) of estimated
        boundary times and estimated labels.
        If labels_id is None, est_labels will be a list of -1.
    """
    # Seed random to reproduce results
    np.random.seed(123)

    # Set up configuration based on algorithms parameters
    if config is None:
        config = io.get_configuration(feature, annot_beats, framesync,
                                      boundaries_id, labels_id)
        config["features"] = None

    # Save multi-segment (hierarchical) configuration
    config["hier"] = hier
    if not os.path.exists(in_path):
        raise NoAudioFileError("File or directory does not exists, %s" %
                               in_path)
    if os.path.isfile(in_path):
        # Single file mode
        # Get (if they exitst) or compute features
        file_struct = msaf.io.FileStruct(in_path)

        # Use temporary file in single mode
        file_struct.features_file = msaf.config.features_tmp_file

        # Get features
        config["features"] = Features.select_features(
            feature, file_struct, annot_beats, framesync)

        # And run the algorithms
        est_times, est_labels = run_algorithms(file_struct, boundaries_id,
                                               labels_id, config,
                                               annotator_id=annotator_id)

        if sonify_bounds:
            logging.info("Sonifying boundaries in %s..." % out_bounds)
            audio_hq, sr = librosa.load(in_path, sr=out_sr)
            utils.sonify_clicks(audio_hq, est_times, out_bounds, out_sr)

        if plot:
            plotting.plot_one_track(file_struct, est_times, est_labels,
                                    boundaries_id, labels_id)

        # TODO: Only save if needed
        # Save estimations
        # msaf.utils.ensure_dir(os.path.dirname(file_struct.est_file))
        # io.save_estimations(file_struct, est_times, est_labels,
                            # boundaries_id, labels_id, **config)

        return est_times, est_labels
    else:
        # Collection mode
        file_structs = io.get_dataset_files(in_path)

        return Parallel(n_jobs=n_jobs)(delayed(process_track)(
            file_struct, boundaries_id, labels_id, config,
            annotator_id=annotator_id) for file_struct in file_structs[:])
示例#14
0
def test_global_get_id():
    Features.get_id()
def process(in_path,
            annot_beats=False,
            feature="pcp",
            framesync=False,
            boundaries_id=msaf.config.default_bound_id,
            labels_id=msaf.config.default_label_id,
            hier=False,
            sonify_bounds=False,
            plot=False,
            n_jobs=4,
            annotator_id=0,
            config=None,
            out_bounds="out_bounds.wav",
            out_sr=22050,
            output_file=None):
    """Main process to segment a file or a collection of files.

    Parameters
    ----------
    in_path: str
        Input path. If a directory, MSAF will function in collection mode.
        If audio file, MSAF will be in single file mode.
    annot_beats: bool
        Whether to use annotated beats or not.
    feature: str
        String representing the feature to be used (e.g. pcp, mfcc, tonnetz)
    framesync: str
        Whether to use framesync features or not (default: False -> beatsync)
    boundaries_id: str
        Identifier of the boundaries algorithm (use "gt" for groundtruth)
    labels_id: str
        Identifier of the labels algorithm (use None to not compute labels)
    hier : bool
        Whether to compute a hierarchical or flat segmentation.
    sonify_bounds: bool
        Whether to write an output audio file with the annotated boundaries
        or not (only available in Single File Mode).
    plot: bool
        Whether to plot the boundaries and labels against the ground truth.
    n_jobs: int
        Number of processes to run in parallel. Only available in collection
        mode.
    annotator_id: int
        Annotator identificator in the ground truth.
    config: dict
        Dictionary containing custom configuration parameters for the
        algorithms.  If None, the default parameters are used.
    out_bounds: str
        Path to the output for the sonified boundaries (only in single file
        mode, when sonify_bounds is True.
    out_sr : int
        Sampling rate for the sonified bounds.

    Returns
    -------
    results : list
        List containing tuples of (est_times, est_labels) of estimated
        boundary times and estimated labels.
        If labels_id is None, est_labels will be a list of -1.
    """
    # Seed random to reproduce results
    np.random.seed(123)

    # Set up configuration based on algorithms parameters
    if config is None:
        config = io.get_configuration(feature, annot_beats, framesync,
                                      boundaries_id, labels_id)
        config["features"] = None

    # Save multi-segment (hierarchical) configuration
    config["hier"] = hier
    if not os.path.exists(in_path):
        raise NoAudioFileError("File or directory does not exists, %s" %
                               in_path)
    if os.path.isfile(in_path):
        # Single file mode
        # Get (if they exitst) or compute features
        file_struct = msaf.io.FileStruct(in_path)

        # Use temporary file in single mode
        file_struct.features_file = msaf.config.features_tmp_file

        # Get features
        config["features"] = Features.select_features(feature, file_struct,
                                                      annot_beats, framesync)

        # And run the algorithms
        est_times, est_labels = run_algorithms(file_struct,
                                               boundaries_id,
                                               labels_id,
                                               config,
                                               annotator_id=annotator_id)

        if sonify_bounds:
            logging.info("Sonifying boundaries in %s..." % out_bounds)
            audio_hq, sr = librosa.load(in_path, sr=out_sr)
            utils.sonify_clicks(audio_hq, est_times, out_bounds, out_sr)

        if plot:
            custom_plotting.plot_one_track(file_struct,
                                           est_times,
                                           est_labels,
                                           boundaries_id,
                                           labels_id,
                                           output_file=output_file)

        # TODO: Only save if needed
        # Save estimations
        msaf.utils.ensure_dir(os.path.dirname(file_struct.est_file))
        io.save_estimations(file_struct, est_times, est_labels, boundaries_id,
                            labels_id, **config)

        return est_times, est_labels
    else:
        # Collection mode
        file_structs = io.get_dataset_files(in_path)

        return Parallel(n_jobs=n_jobs)(
            delayed(process_track)(file_struct,
                                   boundaries_id,
                                   labels_id,
                                   config,
                                   annotator_id=annotator_id)
            for file_struct in file_structs[:])
示例#16
0
def test_global_compute_features():
    my_file_struct = FileStruct(os.path.join("fixtures", "chirp.mp3"))
    feats = Features(my_file_struct, 11025, 1024, FeatureTypes.framesync)
    feats.compute_features()
示例#17
0
def test_run_algorithms():
    """Test running all the algorithms."""
    bound_ids = msaf.io.get_all_boundary_algorithms()
    label_ids = msaf.io.get_all_label_algorithms()

    # Add ground truth to boundary id
    bound_ids += ["gt"]

    # Add None to labels
    label_ids += [None]

    # Config params
    feature = "pcp"
    annot_beats = False
    framesync = False
    file_struct = msaf.io.FileStruct(audio_file)
    file_struct.features_file = msaf.config.features_tmp_file

    # Running all algorithms on a file that is too short
    for bound_id in bound_ids:
        for label_id in label_ids:
            print("bound_id: %s,\tlabel_id: %s" % (bound_id, label_id))
            config = msaf.io.get_configuration(feature, annot_beats, framesync,
                                               bound_id, label_id)
            config["hier"] = False
            config["features"] = Features.select_features(
                feature, file_struct, annot_beats, framesync)
            est_times, est_labels = msaf.run.run_algorithms(
                file_struct, bound_id, label_id, config)
            assert len(est_times) == 2
            assert len(est_labels) == 1
            npt.assert_almost_equal(est_times[0], 0.0, decimal=2)
            npt.assert_almost_equal(est_times[-1],
                                    config["features"].dur,
                                    decimal=2)

    # Commpute and save features for long audio file
    file_struct = msaf.io.FileStruct(long_audio_file)
    file_struct.features_file = msaf.config.features_tmp_file

    def _test_run_msaf(bound_id, label_id, hier=False):
        print("bound_id: %s,\tlabel_id: %s" % (bound_id, label_id))
        config = msaf.io.get_configuration(feature, annot_beats, framesync,
                                           bound_id, label_id)
        config["hier"] = hier
        config["features"] = Features.select_features(feature, file_struct,
                                                      annot_beats, framesync)
        est_times, est_labels = msaf.run.run_algorithms(
            file_struct, bound_id, label_id, config)

        # Take the first level if hierarchy algorithm
        if hier:
            est_times = est_times[0]
            est_labels = est_labels[0]

        npt.assert_almost_equal(est_times[0], 0.0, decimal=2)
        assert len(est_times) - 1 == len(est_labels)
        npt.assert_almost_equal(est_times[-1],
                                config["features"].dur,
                                decimal=2)

    # Running all boundary algorithms on a relatively long file
    # Combining boundaries with labels
    for bound_id in bound_ids:
        if bound_id == "gt":
            continue
        for label_id in label_ids:
            yield (_test_run_msaf, bound_id, label_id, False)

    # Test the hierarchical algorithms
    hier_ids = ["olda", "scluster"]
    for hier_bounds_id in hier_ids:
        for hier_labels_id in hier_ids:
            if hier_labels_id == "olda":
                hier_labels_id = "fmc2d"
            yield (_test_run_msaf, hier_bounds_id, hier_labels_id, True)
示例#18
0
def test_global_get_id():
    Features.get_id()
示例#19
0
def test_wrong_select_features():
    Features.select_features("cqt", None, True, True)