birdnet-analyzer 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

birdnet_analyzer/playground.py

@@ -0,0 +1,5 @@
+if __name__ == "__main__":
+    from birdnet_analyzer import train
+
+    p = r"C:\Users\johau\data\custom_classifier\train_data_small"
+    train(p)

birdnet_analyzer/search/__init__.py

@@ -1,3 +1,3 @@
-from birdnet_analyzer.search.core import search
-
-__all__ = ["search"]
+from birdnet_analyzer.search.core import search
+
+__all__ = ["search"]

birdnet_analyzer/search/__main__.py

@@ -1,3 +1,3 @@
-from birdnet_analyzer.search.cli import main
-
-main()
+from birdnet_analyzer.search.cli import main
+
+main()

birdnet_analyzer/search/cli.py

@@ -1,12 +1,11 @@
-import birdnet_analyzer.utils as utils
-
-
-@utils.runtime_error_handler
-def main():
-    import birdnet_analyzer.cli as cli
-    from birdnet_analyzer import search
-
-    parser = cli.search_parser()
-    args = parser.parse_args()
-
-    search(**vars(args))
+from birdnet_analyzer import utils
+
+
+@utils.runtime_error_handler
+def main():
+    from birdnet_analyzer import cli, search
+
+    parser = cli.search_parser()
+    args = parser.parse_args()
+
+    search(**vars(args))

birdnet_analyzer/search/core.py

@@ -1,78 +1,78 @@
-from typing import Literal
-
-
-def search(
-    output: str,
-    database: str,
-    queryfile: str,
-    *,
-    n_results: int = 10,
-    score_function: Literal["cosine", "euclidean", "dot"] = "cosine",
-    crop_mode: Literal["center", "first", "segments"] = "center",
-    overlap: float = 0.0,
-):
-    """
-    Executes a search query on a given database and saves the results as audio files.
-    Args:
-        output (str): Path to the output directory where the results will be saved.
-        database (str): Path to the database file to search in.
-        queryfile (str): Path to the query file containing the search input.
-        n_results (int, optional): Number of top results to return. Defaults to 10.
-        score_function (Literal["cosine", "euclidean", "dot"], optional):
-            Scoring function to use for similarity calculation. Defaults to "cosine".
-        crop_mode (Literal["center", "first", "segments"], optional):
-            Mode for cropping audio segments. Defaults to "center".
-        overlap (float, optional): Overlap ratio for audio segments. Defaults to 0.0.
-    Raises:
-        ValueError: If the database does not contain the required settings metadata.
-    Notes:
-        - The function creates the output directory if it does not exist.
-        - It retrieves metadata from the database to configure the search, including
-          bandpass filter settings and audio speed.
-        - The results are saved as audio files in the specified output directory, with
-          filenames containing the score, source file name, and time offsets.
-    Returns:
-        None
-    """
-    import os
-
-    import birdnet_analyzer.audio as audio
-    import birdnet_analyzer.config as cfg
-    from birdnet_analyzer.search.utils import get_search_results
-
-    # Create output folder
-    if not os.path.exists(output):
-        os.makedirs(output)
-
-    # Load the database
-    db = get_database(database)
-
-    try:
-        settings = db.get_metadata("birdnet_analyzer_settings")
-    except:
-        raise ValueError("No settings present in database.")
-
-    fmin = settings["BANDPASS_FMIN"]
-    fmax = settings["BANDPASS_FMAX"]
-    audio_speed = settings["AUDIO_SPEED"]
-
-    # Execute the search
-    results = get_search_results(queryfile, db, n_results, audio_speed, fmin, fmax, score_function, crop_mode, overlap)
-
-    # Save the results
-    for i, r in enumerate(results):
-        embedding_source = db.get_embedding_source(r.embedding_id)
-        file = embedding_source.source_id
-        filebasename = os.path.basename(file)
-        filebasename = os.path.splitext(filebasename)[0]
-        offset = embedding_source.offsets[0] * audio_speed
-        duration = cfg.SIG_LENGTH * audio_speed
-        sig, rate = audio.open_audio_file(file, offset=offset, duration=duration, sample_rate=None)
-        result_path = os.path.join(output, f"{file[4]:.5f}_{filebasename}_{offset}_{offset + duration}.wav")
-        audio.save_signal(sig, result_path, rate)
-
-
-def get_database(database_path):
-    from perch_hoplite.db import sqlite_usearch_impl
-
-    return sqlite_usearch_impl.SQLiteUsearchDB.create(database_path).thread_split()
+from typing import Literal
+
+
+def search(
+    output: str,
+    database: str,
+    queryfile: str,
+    *,
+    n_results: int = 10,
+    score_function: Literal["cosine", "euclidean", "dot"] = "cosine",
+    crop_mode: Literal["center", "first", "segments"] = "center",
+    overlap: float = 0.0,
+):
+    """
+    Executes a search query on a given database and saves the results as audio files.
+    Args:
+        output (str): Path to the output directory where the results will be saved.
+        database (str): Path to the database file to search in.
+        queryfile (str): Path to the query file containing the search input.
+        n_results (int, optional): Number of top results to return. Defaults to 10.
+        score_function (Literal["cosine", "euclidean", "dot"], optional):
+            Scoring function to use for similarity calculation. Defaults to "cosine".
+        crop_mode (Literal["center", "first", "segments"], optional):
+            Mode for cropping audio segments. Defaults to "center".
+        overlap (float, optional): Overlap ratio for audio segments. Defaults to 0.0.
+    Raises:
+        ValueError: If the database does not contain the required settings metadata.
+    Notes:
+        - The function creates the output directory if it does not exist.
+        - It retrieves metadata from the database to configure the search, including
+          bandpass filter settings and audio speed.
+        - The results are saved as audio files in the specified output directory, with
+          filenames containing the score, source file name, and time offsets.
+    Returns:
+        None
+    """
+    import os
+
+    import birdnet_analyzer.config as cfg
+    from birdnet_analyzer import audio
+    from birdnet_analyzer.search.utils import get_search_results
+
+    # Create output folder
+    if not os.path.exists(output):
+        os.makedirs(output)
+
+    # Load the database
+    db = get_database(database)
+
+    try:
+        settings = db.get_metadata("birdnet_analyzer_settings")
+    except KeyError as e:
+        raise ValueError("No settings present in database.") from e
+
+    fmin = settings["BANDPASS_FMIN"]
+    fmax = settings["BANDPASS_FMAX"]
+    audio_speed = settings["AUDIO_SPEED"]
+
+    # Execute the search
+    results = get_search_results(queryfile, db, n_results, audio_speed, fmin, fmax, score_function, crop_mode, overlap)
+
+    # Save the results
+    for r in results:
+        embedding_source = db.get_embedding_source(r.embedding_id)
+        file = embedding_source.source_id
+        filebasename = os.path.basename(file)
+        filebasename = os.path.splitext(filebasename)[0]
+        offset = embedding_source.offsets[0] * audio_speed
+        duration = cfg.SIG_LENGTH * audio_speed
+        sig, rate = audio.open_audio_file(file, offset=offset, duration=duration, sample_rate=None)
+        result_path = os.path.join(output, f"{file[4]:.5f}_{filebasename}_{offset}_{offset + duration}.wav")
+        audio.save_signal(sig, result_path, rate)
+
+
+def get_database(database_path):
+    from perch_hoplite.db import sqlite_usearch_impl
+
+    return sqlite_usearch_impl.SQLiteUsearchDB.create(database_path).thread_split()

birdnet_analyzer/search/utils.py

@@ -1,111 +1,107 @@
-import numpy as np
-from perch_hoplite.db import brutalism
-from perch_hoplite.db.search_results import SearchResult
-from scipy.spatial.distance import euclidean
-
-import birdnet_analyzer.audio as audio
-import birdnet_analyzer.config as cfg
-import birdnet_analyzer.model as model
-
-
-def cosine_sim(a, b):
-    if a.ndim == 2:
-        return np.array([cosine_sim(a[i], b) for i in range(a.shape[0])])
-    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
-
-
-def euclidean_scoring(a, b):
-    if a.ndim == 2:
-        return np.array([euclidean_scoring(a[i], b) for i in range(a.shape[0])])
-    return euclidean(a, b)
-
-
-def euclidean_scoring_inverse(a, b):
-    return -euclidean_scoring(a, b)
-
-
-def get_query_embedding(queryfile_path):
-    """
-    Extracts the embedding for a query file. Reads only the first 3 seconds
-    Args:
-        queryfile_path: The path to the query file.
-    Returns:
-        The query embedding.
-    """
-
-    # Load audio
-    sig, rate = audio.open_audio_file(
-        queryfile_path,
-        duration=cfg.SIG_LENGTH * cfg.AUDIO_SPEED if cfg.SAMPLE_CROP_MODE == "first" else None,
-        fmin=cfg.BANDPASS_FMIN,
-        fmax=cfg.BANDPASS_FMAX,
-        speed=cfg.AUDIO_SPEED,
-    )
-
-    # Crop query audio
-    if cfg.SAMPLE_CROP_MODE == "center":
-        sig_splits = [audio.crop_center(sig, rate, cfg.SIG_LENGTH)]
-    elif cfg.SAMPLE_CROP_MODE == "first":
-        sig_splits = [audio.split_signal(sig, rate, cfg.SIG_LENGTH, cfg.SIG_OVERLAP, cfg.SIG_MINLEN)[0]]
-    else:
-        sig_splits = audio.split_signal(sig, rate, cfg.SIG_LENGTH, cfg.SIG_OVERLAP, cfg.SIG_MINLEN)
-
-    samples = sig_splits
-    data = np.array(samples, dtype="float32")
-    query = model.embeddings(data)
-    return query
-
-
-def get_search_results(
-    queryfile_path, db, n_results, audio_speed, fmin, fmax, score_function: str, crop_mode, crop_overlap
-):
-    # Set bandpass frequency range
-    cfg.BANDPASS_FMIN = max(0, min(cfg.SIG_FMAX, int(fmin)))
-    cfg.BANDPASS_FMAX = max(cfg.SIG_FMIN, min(cfg.SIG_FMAX, int(fmax)))
-    cfg.AUDIO_SPEED = max(0.01, audio_speed)
-    cfg.SAMPLE_CROP_MODE = crop_mode
-    cfg.SIG_OVERLAP = max(0.0, min(2.9, float(crop_overlap)))
-
-    # Get query embedding
-    query_embeddings = get_query_embedding(queryfile_path)
-
-    # Set score function
-    if score_function == "cosine":
-        score_fn = cosine_sim
-    elif score_function == "dot":
-        score_fn = np.dot
-    elif score_function == "euclidean":
-        score_fn = euclidean_scoring_inverse  # TODO: this is a bit hacky since the search function expects the score to be high for similar embeddings
-    else:
-        raise ValueError("Invalid score function. Choose 'cosine', 'euclidean' or 'dot'.")
-
-    db_embeddings_count = db.count_embeddings()
-
-    if n_results > db_embeddings_count - 1:
-        n_results = db_embeddings_count - 1
-
-    scores_by_embedding_id = {}
-
-    for embedding in query_embeddings:
-        results, scores = brutalism.threaded_brute_search(db, embedding, n_results, score_fn)
-        sorted_results = results.search_results
-
-        if score_function == "euclidean":
-            for result in sorted_results:
-                result.sort_score *= -1
-
-        for result in sorted_results:
-            if result.embedding_id not in scores_by_embedding_id:
-                scores_by_embedding_id[result.embedding_id] = []
-            scores_by_embedding_id[result.embedding_id].append(result.sort_score)
-
-    results = []
-
-    for embedding_id, scores in scores_by_embedding_id.items():
-        results.append(SearchResult(embedding_id, np.sum(scores) / len(query_embeddings)))
-
-    reverse = score_function != "euclidean"
-
-    results.sort(key=lambda x: x.sort_score, reverse=reverse)
-
-    return results[0:n_results]
+import numpy as np
+from perch_hoplite.db import brutalism
+from perch_hoplite.db.search_results import SearchResult
+from scipy.spatial.distance import euclidean
+
+import birdnet_analyzer.config as cfg
+from birdnet_analyzer import audio, model
+
+
+def cosine_sim(a, b):
+    if a.ndim == 2:
+        return np.array([cosine_sim(a[i], b) for i in range(a.shape[0])])
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+
+def euclidean_scoring(a, b):
+    if a.ndim == 2:
+        return np.array([euclidean_scoring(a[i], b) for i in range(a.shape[0])])
+    return euclidean(a, b)
+
+
+def euclidean_scoring_inverse(a, b):
+    return -euclidean_scoring(a, b)
+
+
+def get_query_embedding(queryfile_path):
+    """
+    Extracts the embedding for a query file. Reads only the first 3 seconds
+    Args:
+        queryfile_path: The path to the query file.
+    Returns:
+        The query embedding.
+    """
+
+    # Load audio
+    sig, rate = audio.open_audio_file(
+        queryfile_path,
+        duration=cfg.SIG_LENGTH * cfg.AUDIO_SPEED if cfg.SAMPLE_CROP_MODE == "first" else None,
+        fmin=cfg.BANDPASS_FMIN,
+        fmax=cfg.BANDPASS_FMAX,
+        speed=cfg.AUDIO_SPEED,
+    )
+
+    # Crop query audio
+    if cfg.SAMPLE_CROP_MODE == "center":
+        sig_splits = [audio.crop_center(sig, rate, cfg.SIG_LENGTH)]
+    elif cfg.SAMPLE_CROP_MODE == "first":
+        sig_splits = [audio.split_signal(sig, rate, cfg.SIG_LENGTH, cfg.SIG_OVERLAP, cfg.SIG_MINLEN)[0]]
+    else:
+        sig_splits = audio.split_signal(sig, rate, cfg.SIG_LENGTH, cfg.SIG_OVERLAP, cfg.SIG_MINLEN)
+
+    samples = sig_splits
+    data = np.array(samples, dtype="float32")
+
+    return model.embeddings(data)
+
+
+def get_search_results(
+    queryfile_path, db, n_results, audio_speed, fmin, fmax, score_function: str, crop_mode, crop_overlap
+):
+    # Set bandpass frequency range
+    cfg.BANDPASS_FMIN = max(0, min(cfg.SIG_FMAX, int(fmin)))
+    cfg.BANDPASS_FMAX = max(cfg.SIG_FMIN, min(cfg.SIG_FMAX, int(fmax)))
+    cfg.AUDIO_SPEED = max(0.01, audio_speed)
+    cfg.SAMPLE_CROP_MODE = crop_mode
+    cfg.SIG_OVERLAP = max(0.0, min(2.9, float(crop_overlap)))
+
+    # Get query embedding
+    query_embeddings = get_query_embedding(queryfile_path)
+
+    # Set score function
+    if score_function == "cosine":
+        score_fn = cosine_sim
+    elif score_function == "dot":
+        score_fn = np.dot
+    elif score_function == "euclidean":
+        score_fn = euclidean_scoring_inverse  # TODO: this is a bit hacky since the search function expects the score to be high for similar embeddings
+    else:
+        raise ValueError("Invalid score function. Choose 'cosine', 'euclidean' or 'dot'.")
+
+    db_embeddings_count = db.count_embeddings()
+    n_results = min(n_results, db_embeddings_count - 1)
+    scores_by_embedding_id = {}
+
+    for embedding in query_embeddings:
+        results, scores = brutalism.threaded_brute_search(db, embedding, n_results, score_fn)
+        sorted_results = results.search_results
+
+        if score_function == "euclidean":
+            for result in sorted_results:
+                result.sort_score *= -1
+
+        for result in sorted_results:
+            if result.embedding_id not in scores_by_embedding_id:
+                scores_by_embedding_id[result.embedding_id] = []
+            scores_by_embedding_id[result.embedding_id].append(result.sort_score)
+
+    results = []
+
+    for embedding_id, scores in scores_by_embedding_id.items():
+        results.append(SearchResult(embedding_id, np.sum(scores) / len(query_embeddings)))
+
+    reverse = score_function != "euclidean"
+
+    results.sort(key=lambda x: x.sort_score, reverse=reverse)
+
+    return results[0:n_results]

birdnet_analyzer/segments/__init__.py

@@ -1,3 +1,3 @@
-from birdnet_analyzer.segments.core import segments
-
-__all__ = ["segments"]
+from birdnet_analyzer.segments.core import segments
+
+__all__ = ["segments"]

birdnet_analyzer/segments/__main__.py

@@ -1,3 +1,3 @@
-from birdnet_analyzer.segments.cli import main
-
-main()
+from birdnet_analyzer.segments.cli import main
+
+main()

birdnet_analyzer/segments/cli.py

@@ -1,14 +1,13 @@
-from birdnet_analyzer.utils import runtime_error_handler
-
-
-@runtime_error_handler
-def main():
-    import birdnet_analyzer.cli as cli
-    from birdnet_analyzer import segments
-
-    # Parse arguments
-    parser = cli.segments_parser()
-
-    args = parser.parse_args()
-
-    segments(**vars(args))
+from birdnet_analyzer.utils import runtime_error_handler
+
+
+@runtime_error_handler
+def main():
+    from birdnet_analyzer import cli, segments
+
+    # Parse arguments
+    parser = cli.segments_parser()
+
+    args = parser.parse_args()
+
+    segments(**vars(args))

birdnet_analyzer/segments/core.py

@@ -1,78 +1,81 @@
-def segments(
-    input: str,
-    output: str | None = None,
-    results: str | None = None,
-    *,
-    min_conf: float = 0.25,
-    max_segments: int = 100,
-    audio_speed: float = 1.0,
-    seg_length: float = 3.0,
-    threads: int = 1,
-):
-    """
-    Processes audio files to extract segments based on detection results.
-    Args:
-        input (str): Path to the input folder containing audio files.
-        output (str | None, optional): Path to the output folder where segments will be saved.
-            If not provided, the input folder will be used as the output folder. Defaults to None.
-        results (str | None, optional): Path to the folder containing detection result files.
-            If not provided, the input folder will be used. Defaults to None.
-        min_conf (float, optional): Minimum confidence threshold for detections to be considered.
-            Defaults to 0.25.
-        max_segments (int, optional): Maximum number of segments to extract per audio file.
-            Defaults to 100.
-        audio_speed (float, optional): Speed factor for audio processing. Defaults to 1.0.
-        seg_length (float, optional): Length of each audio segment in seconds. Defaults to 3.0.
-        threads (int, optional): Number of CPU threads to use for parallel processing.
-            Defaults to 1.
-    Returns:
-        None
-    Notes:
-        - The function uses multiprocessing for parallel processing if `threads` is greater than 1.
-        - On Windows, due to the lack of `fork()` support, configuration items are passed to each
-          process explicitly.
-        - It is recommended to use this function on Linux for better performance.
-    """
-    from multiprocessing import Pool
-
-    import birdnet_analyzer.config as cfg
-
-    from birdnet_analyzer.segments.utils import extract_segments, parse_folders, parse_files  # noqa: E402
-
-    cfg.INPUT_PATH = input
-
-    if not output:
-        cfg.OUTPUT_PATH = cfg.INPUT_PATH
-    else:
-        cfg.OUTPUT_PATH = output
-
-    results = results if results else cfg.INPUT_PATH
-
-    # Parse audio and result folders
-    cfg.FILE_LIST = parse_folders(input, results)
-
-    # Set number of threads
-    cfg.CPU_THREADS = threads
-
-    # Set confidence threshold
-    cfg.MIN_CONFIDENCE = min_conf
-
-    # Parse file list and make list of segments
-    cfg.FILE_LIST = parse_files(cfg.FILE_LIST, max_segments)
-
-    # Set audio speed
-    cfg.AUDIO_SPEED = audio_speed
-
-    # Add config items to each file list entry.
-    # We have to do this for Windows which does not
-    # support fork() and thus each process has to
-    # have its own config. USE LINUX!
-    flist = [(entry, seg_length, cfg.get_config()) for entry in cfg.FILE_LIST]
-
-    # Extract segments
-    if cfg.CPU_THREADS < 2:
-        for entry in flist:
-            extract_segments(entry)
-    else:
-        with Pool(cfg.CPU_THREADS) as p:
-            p.map(extract_segments, flist)
+def segments(
+    audio_input: str,
+    output: str | None = None,
+    results: str | None = None,
+    *,
+    min_conf: float = 0.25,
+    max_segments: int = 100,
+    audio_speed: float = 1.0,
+    seg_length: float = 3.0,
+    threads: int = 1,
+):
+    """
+    Processes audio files to extract segments based on detection results.
+    Args:
+        audio_input (str): Path to the input folder containing audio files.
+        output (str | None, optional): Path to the output folder where segments will be saved.
+            If not provided, the input folder will be used as the output folder. Defaults to None.
+        results (str | None, optional): Path to the folder containing detection result files.
+            If not provided, the input folder will be used. Defaults to None.
+        min_conf (float, optional): Minimum confidence threshold for detections to be considered.
+            Defaults to 0.25.
+        max_segments (int, optional): Maximum number of segments to extract per audio file.
+            Defaults to 100.
+        audio_speed (float, optional): Speed factor for audio processing. Defaults to 1.0.
+        seg_length (float, optional): Length of each audio segment in seconds. Defaults to 3.0.
+        threads (int, optional): Number of CPU threads to use for parallel processing.
+            Defaults to 1.
+    Returns:
+        None
+    Notes:
+        - The function uses multiprocessing for parallel processing if `threads` is greater than 1.
+        - On Windows, due to the lack of `fork()` support, configuration items are passed to each
+          process explicitly.
+        - It is recommended to use this function on Linux for better performance.
+    """
+    from multiprocessing import Pool
+
+    import birdnet_analyzer.config as cfg
+    from birdnet_analyzer.segments.utils import (
+        extract_segments,
+        parse_files,
+        parse_folders,
+    )
+
+    cfg.INPUT_PATH = audio_input
+
+    if not output:
+        cfg.OUTPUT_PATH = cfg.INPUT_PATH
+    else:
+        cfg.OUTPUT_PATH = output
+
+    results = results if results else cfg.INPUT_PATH
+
+    # Parse audio and result folders
+    cfg.FILE_LIST = parse_folders(audio_input, results)
+
+    # Set number of threads
+    cfg.CPU_THREADS = threads
+
+    # Set confidence threshold
+    cfg.MIN_CONFIDENCE = min_conf
+
+    # Parse file list and make list of segments
+    cfg.FILE_LIST = parse_files(cfg.FILE_LIST, max_segments)
+
+    # Set audio speed
+    cfg.AUDIO_SPEED = audio_speed
+
+    # Add config items to each file list entry.
+    # We have to do this for Windows which does not
+    # support fork() and thus each process has to
+    # have its own config. USE LINUX!
+    flist = [(entry, seg_length, cfg.get_config()) for entry in cfg.FILE_LIST]
+
+    # Extract segments
+    if cfg.CPU_THREADS < 2:
+        for entry in flist:
+            extract_segments(entry)
+    else:
+        with Pool(cfg.CPU_THREADS) as p:
+            p.map(extract_segments, flist)