birdnet-analyzer 2.0.0__py3-none-any.whl

birdnet_analyzer/segments/utils.py

@@ -0,0 +1,394 @@
+"""Extract segments from audio files based on BirdNET detections.
+
+Can be used to save the segments of the audio files for each detection.
+"""
+
+import os
+
+import numpy as np
+
+import birdnet_analyzer.audio as audio
+import birdnet_analyzer.config as cfg
+import birdnet_analyzer.utils as utils
+
+# Set numpy random seed
+np.random.seed(cfg.RANDOM_SEED)
+SCRIPT_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+def detect_rtype(line: str):
+    """Detects the type of result file.
+
+    Args:
+        line: First line of text.
+
+    Returns:
+        Either "table", "kaleidoscope", "csv" or "audacity".
+    """
+    if line.lower().startswith("selection"):
+        return "table"
+    # elif line.lower().startswith("filepath"):
+    #     return "r"
+    elif line.lower().startswith("indir"):
+        return "kaleidoscope"
+    elif line.lower().startswith("start (s)"):
+        return "csv"
+    else:
+        return "audacity"
+
+
+def get_header_mapping(line: str) -> dict:
+    """
+    Parses a header line and returns a mapping of column names to their indices.
+
+    Args:
+        line (str): A string representing the header line of a file.
+
+    Returns:
+        dict: A dictionary where the keys are column names and the values are their respective indices.
+    """
+    rtype = detect_rtype(line)
+
+    if rtype == "table" or rtype == "audacity":
+        sep = "\t"
+    else:
+        sep = ","
+
+    cols = line.split(sep)
+
+    mapping = {}
+
+    for i, col in enumerate(cols):
+        mapping[col] = i
+
+    return mapping
+
+
+def parse_folders(apath: str, rpath: str, allowed_result_filetypes: list[str] = ["txt", "csv"]) -> list[dict]:
+    """Read audio and result files.
+
+    Reads all audio files and BirdNET output inside directory recursively.
+
+    Args:
+        apath (str): Path to search for audio files.
+        rpath (str): Path to search for result files.
+        allowed_result_filetypes (list[str]): List of extensions for the result files.
+
+    Returns:
+        list[dict]: A list of {"audio": path_to_audio, "result": path_to_result }.
+    """
+    data = {}
+    apath = apath.replace("/", os.sep).replace("\\", os.sep)
+    rpath = rpath.replace("/", os.sep).replace("\\", os.sep)
+
+    # Check if combined selection table is present and read that.
+    if os.path.exists(os.path.join(rpath, cfg.OUTPUT_RAVEN_FILENAME)):
+        # Read combined Raven selection table
+        rfile = os.path.join(rpath, cfg.OUTPUT_RAVEN_FILENAME)
+        data["combined"] = {"isCombinedFile": True, "result": rfile}
+    elif os.path.exists(os.path.join(rpath, cfg.OUTPUT_CSV_FILENAME)):
+        rfile = os.path.join(rpath, cfg.OUTPUT_CSV_FILENAME)
+        data["combined"] = {"isCombinedFile": True, "result": rfile}
+    elif os.path.exists(os.path.join(rpath, cfg.OUTPUT_KALEIDOSCOPE_FILENAME)):
+        rfile = os.path.join(rpath, cfg.OUTPUT_KALEIDOSCOPE_FILENAME)
+        data["combined"] = {"isCombinedFile": True, "result": rfile}
+    else:
+        # Get all audio files
+        for root, _, files in os.walk(apath):
+            for f in files:
+                if f.rsplit(".", 1)[-1].lower() in cfg.ALLOWED_FILETYPES and not f.startswith("."):
+                    table_key = os.path.join(root.strip(apath), f.rsplit(".", 1)[0])
+                    data[table_key] = {"audio": os.path.join(root, f), "result": ""}
+
+        # Get all result files
+        for root, _, files in os.walk(rpath):
+            for f in files:
+                if f.rsplit(".", 1)[-1] in allowed_result_filetypes and ".BirdNET." in f:
+                    table_key = os.path.join(root.strip(rpath), f.split(".BirdNET.", 1)[0])
+                    if table_key in data:
+                        data[table_key]["result"] = os.path.join(root, f)
+
+    # Convert to list
+    flist = [f for f in data.values() if f["result"]]
+
+    print(f"Found {len(flist)} audio files with valid result file.")
+
+    return flist
+
+
+def parse_files(flist: list[dict], max_segments=100):
+    """
+    Parses a list of files to extract and organize bird call segments by species.
+
+    Args:
+        flist (list[dict]): A list of dictionaries, each containing 'audio' and 'result' file paths.
+                            Optionally, a dictionary can have 'isCombinedFile' set to True to indicate
+                            that it is a combined result file.
+        max_segments (int, optional): The maximum number of segments to retain per species. Defaults to 100.
+    Returns:
+        list[tuple]: A list of tuples where each tuple contains an audio file path and a list of segments
+                     associated with that audio file.
+    Raises:
+        KeyError: If the dictionaries in flist do not contain the required keys ('audio' and 'result').
+    Example:
+        flist = [
+            {"audio": "path/to/audio1.wav", "result": "path/to/result1.csv"},
+            {"audio": "path/to/audio2.wav", "result": "path/to/result2.csv"}
+        ]
+        segments = parseFiles(flist, max_segments=50)
+    """
+    species_segments: dict[str, list] = {}
+
+    is_combined_rfile = len(flist) == 1 and flist[0].get("isCombinedFile", False)
+
+    if is_combined_rfile:
+        rfile = flist[0]["result"]
+        segments = find_segments_from_combined(rfile)
+
+        # Parse segments by species
+        for s in segments:
+            if s["species"] not in species_segments:
+                species_segments[s["species"]] = []
+
+            species_segments[s["species"]].append(s)
+    else:
+        for f in flist:
+            # Paths
+            afile = f["audio"]
+            rfile = f["result"]
+
+            # Get all segments for result file
+            segments = find_segments(afile, rfile)
+
+            # Parse segments by species
+            for s in segments:
+                if s["species"] not in species_segments:
+                    species_segments[s["species"]] = []
+
+                species_segments[s["species"]].append(s)
+
+    # Shuffle segments for each species and limit to max_segments
+    for s in species_segments:
+        np.random.shuffle(species_segments[s])
+        species_segments[s] = species_segments[s][:max_segments]
+
+    # Make dict of segments per audio file
+    segments: dict[str, list] = {}
+    seg_cnt = 0
+
+    for s in species_segments:
+        for seg in species_segments[s]:
+            if seg["audio"] not in segments:
+                segments[seg["audio"]] = []
+
+            segments[seg["audio"]].append(seg)
+            seg_cnt += 1
+
+    print(f"Found {seg_cnt} segments in {len(segments)} audio files.")
+
+    # Convert to list
+    flist = [tuple(e) for e in segments.items()]
+
+    return flist
+
+
+def find_segments_from_combined(rfile: str) -> list[dict]:
+    """Extracts the segments from a combined results file
+
+    Args:
+        rfile (str): Path to the result file.
+
+    Returns:
+        list[dict]: A list of dicts in the form of
+        {"audio": afile, "start": start, "end": end, "species": species, "confidence": confidence}
+    """
+    segments: list[dict] = []
+
+    # Open and parse result file
+    lines = utils.read_lines(rfile)
+
+    # Auto-detect result type
+    rtype = detect_rtype(lines[0])
+
+    if rtype == "audacity":
+        raise Exception("Audacity files are not supported for combined results.")
+
+    # Get mapping from the header column
+    header_mapping = get_header_mapping(lines[0])
+
+    # Get start and end times based on rtype
+    confidence = 0
+    start = end = 0.0
+    species = ""
+    afile = ""
+
+    for i, line in enumerate(lines):
+        if rtype == "table" and i > 0:
+            d = line.split("\t")
+            file_offset = float(d[header_mapping["File Offset (s)"]])
+            start = file_offset
+            end = file_offset + (float(d[header_mapping["End Time (s)"]]) - float(d[header_mapping["Begin Time (s)"]]))
+            species = d[header_mapping["Common Name"]]
+            confidence = float(d[header_mapping["Confidence"]])
+            afile = d[header_mapping["Begin Path"]].replace("/", os.sep).replace("\\", os.sep)
+
+        elif rtype == "kaleidoscope" and i > 0:
+            d = line.split(",")
+            start = float(d[header_mapping["OFFSET"]])
+            end = float(d[header_mapping["DURATION"]]) + start
+            species = d[header_mapping["scientific_name"]]
+            confidence = float(d[header_mapping["confidence"]])
+            in_dir = d[header_mapping["INDIR"]]
+            folder = d[header_mapping["FOLDER"]]
+            in_file = d[header_mapping["IN FILE"]]
+            afile = os.path.join(in_dir, folder, in_file).replace("/", os.sep).replace("\\", os.sep)
+
+        elif rtype == "csv" and i > 0:
+            d = line.split(",")
+            start = float(d[header_mapping["Start (s)"]])
+            end = float(d[header_mapping["End (s)"]])
+            species = d[header_mapping["Common name"]]
+            confidence = float(d[header_mapping["Confidence"]])
+            afile = d[header_mapping["File"]].replace("/", os.sep).replace("\\", os.sep)
+
+        # Check if confidence is high enough and label is not "nocall"
+        if confidence >= cfg.MIN_CONFIDENCE and species.lower() != "nocall" and afile:
+            segments.append({"audio": afile, "start": start, "end": end, "species": species, "confidence": confidence})
+
+    return segments
+
+
+def find_segments(afile: str, rfile: str):
+    """Extracts the segments for an audio file from the results file
+
+    Args:
+        afile: Path to the audio file.
+        rfile: Path to the result file.
+
+    Returns:
+        A list of dicts in the form of
+        {"audio": afile, "start": start, "end": end, "species": species, "confidence": confidence}
+    """
+    segments: list[dict] = []
+
+    # Open and parse result file
+    lines = utils.read_lines(rfile)
+
+    # Auto-detect result type
+    rtype = detect_rtype(lines[0])
+
+    # Get mapping from the header column
+    header_mapping = get_header_mapping(lines[0])
+
+    # Get start and end times based on rtype
+    confidence = 0
+    start = end = 0.0
+    species = ""
+
+    for i, line in enumerate(lines):
+        if rtype == "table" and i > 0:
+            d = line.split("\t")
+            start = float(d[header_mapping["Begin Time (s)"]])
+            end = float(d[header_mapping["End Time (s)"]])
+            species = d[header_mapping["Common Name"]]
+            confidence = float(d[header_mapping["Confidence"]])
+
+        elif rtype == "audacity":
+            d = line.split("\t")
+            start = float(d[0])
+            end = float(d[1])
+            species = d[2].split(", ")[1]
+            confidence = float(d[-1])
+
+        elif rtype == "kaleidoscope" and i > 0:
+            d = line.split(",")
+            start = float(d[header_mapping["OFFSET"]])
+            end = float(d[header_mapping["DURATION"]]) + start
+            species = d[header_mapping["scientific_name"]]
+            confidence = float(d[header_mapping["confidence"]])
+
+        elif rtype == "csv" and i > 0:
+            d = line.split(",")
+            start = float(d[header_mapping["Start (s)"]])
+            end = float(d[header_mapping["End (s)"]])
+            species = d[header_mapping["Common name"]]
+            confidence = float(d[header_mapping["Confidence"]])
+
+        # Check if confidence is high enough and label is not "nocall"
+        if confidence >= cfg.MIN_CONFIDENCE and species.lower() != "nocall":
+            segments.append({"audio": afile, "start": start, "end": end, "species": species, "confidence": confidence})
+
+    return segments
+
+
+def extract_segments(item: tuple[tuple[str, list[dict]], float, dict[str]]):
+    """
+    Extracts audio segments from a given audio file based on provided segment information.
+    Args:
+        item (tuple): A tuple containing:
+            - A tuple with:
+                - A string representing the path to the audio file.
+                - A list of dictionaries, each containing segment information with keys "start", "end", "species", "confidence", and "audio".
+            - A float representing the segment length.
+            - A dictionary containing configuration settings.
+    Returns:
+        bool: True if segments were successfully extracted, False otherwise.
+    Raises:
+        Exception: If there is an error opening the audio file or extracting segments.
+    """
+    # Paths and config
+    afile = item[0][0]
+    segments = item[0][1]
+    seg_length = item[1]
+    cfg.set_config(item[2])
+
+    # Status
+    print(f"Extracting segments from {afile}")
+
+    try:
+        # Open audio file
+        sig, rate = audio.open_audio_file(afile, cfg.SAMPLE_RATE, speed=cfg.AUDIO_SPEED)
+    except Exception as ex:
+        print(f"Error: Cannot open audio file {afile}", flush=True)
+        utils.write_error_log(ex)
+
+        return
+
+    # Extract segments
+    for seg_cnt, seg in enumerate(segments, 1):
+        try:
+            # Get start and end times
+            start = int((seg["start"] * rate) / cfg.AUDIO_SPEED)
+            end = int((seg["end"] * rate) / cfg.AUDIO_SPEED)
+
+            offset = max(0, ((seg_length * rate) - (end - start)) // 2)
+            start = max(0, start - offset)
+            end = min(len(sig), end + offset)
+
+            # Make sure segment is long enough
+            if end > start:
+                # Get segment raw audio from signal
+                seg_sig = sig[int(start) : int(end)]
+
+                # Make output path
+                outpath = os.path.join(cfg.OUTPUT_PATH, seg["species"])
+                os.makedirs(outpath, exist_ok=True)
+
+                # Save segment
+                seg_name = "{:.3f}_{}_{}_{:.1f}s_{:.1f}s.wav".format(
+                    seg["confidence"],
+                    seg_cnt,
+                    seg["audio"].rsplit(os.sep, 1)[-1].rsplit(".", 1)[0],
+                    seg["start"],
+                    seg["end"],
+                )
+                seg_path = os.path.join(outpath, seg_name)
+                audio.save_signal(seg_sig, seg_path, rate)
+
+        except Exception as ex:
+            # Write error log
+            print(f"Error: Cannot extract segments from {afile}.", flush=True)
+            utils.write_error_log(ex)
+            return False
+
+    return True

birdnet_analyzer/species/__init__.py

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

birdnet_analyzer/species/__main__.py

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

birdnet_analyzer/species/cli.py

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

birdnet_analyzer/species/core.py

@@ -0,0 +1,35 @@
+from typing import Literal
+
+
+def species(
+    output: str,
+    *,
+    lat: float = -1,
+    lon: float = -1,
+    week: int = -1,
+    sf_thresh: float = 0.03,
+    sortby: Literal["freq", "alpha"] = "freq",
+):
+    """
+    Retrieves and processes species data based on the provided parameters.
+    Args:
+        output (str): The output directory or file path where the results will be stored.
+        lat (float, optional): Latitude of the location for species filtering. Defaults to -1 (no filtering by location).
+        lon (float, optional): Longitude of the location for species filtering. Defaults to -1 (no filtering by location).
+        week (int, optional): Week of the year for species filtering. Defaults to -1 (no filtering by time).
+        sf_thresh (float, optional): Species frequency threshold for filtering. Defaults to 0.03.
+        sortby (Literal["freq", "alpha"], optional): Sorting method for the species list.
+            "freq" sorts by frequency, and "alpha" sorts alphabetically. Defaults to "freq".
+    Raises:
+        FileNotFoundError: If the required model files are not found.
+        ValueError: If invalid parameters are provided.
+    Notes:
+        This function ensures that the required model files exist before processing.
+        It delegates the main processing to the `run` function from `birdnet_analyzer.species.utils`.
+    """
+    from birdnet_analyzer.species.utils import run
+    from birdnet_analyzer.utils import ensure_model_exists
+
+    ensure_model_exists()
+
+    run(output, lat, lon, week, sf_thresh, sortby)

birdnet_analyzer/species/utils.py

@@ -0,0 +1,75 @@
+"""Module for predicting a species list.
+
+Can be used to predict a species list using coordinates and weeks.
+"""
+
+import os
+
+import birdnet_analyzer.config as cfg
+import birdnet_analyzer.model as model
+import birdnet_analyzer.utils as utils
+
+
+def get_species_list(lat: float, lon: float, week: int, threshold=0.05, sort=False) -> list[str]:
+    """Predict a species list.
+
+    Uses the model to predict the species list for the given coordinates and filters by threshold.
+
+    Args:
+        lat: The latitude.
+        lon: The longitude.
+        week: The week of the year [1-48]. Use -1 for year-round.
+        threshold: Only values above or equal to threshold will be shown.
+        sort: If the species list should be sorted.
+
+    Returns:
+        A list of all eligible species.
+    """
+    # Extract species from model
+    pred = model.explore(lat, lon, week)
+
+    # Make species list
+    slist = [p[1] for p in pred if p[0] >= threshold]
+
+    return sorted(slist) if sort else slist
+
+
+def run(output_path, lat, lon, week, threshold, sortby):
+    """
+    Generates a species list for a given location and time, and saves it to the specified output path.
+    Args:
+        output_path (str): The path where the species list will be saved. If it's a directory, the list will be saved as "species_list.txt" inside it.
+        lat (float): Latitude of the location.
+        lon (float): Longitude of the location.
+        week (int): Week of the year (1-52) for which the species list is generated.
+        threshold (float): Threshold for location filtering.
+        sortby (str): Sorting criteria for the species list. Can be "freq" for frequency or any other value for alphabetical sorting.
+    Returns:
+        None
+    """
+    # Load eBird codes, labels
+    cfg.LABELS = utils.read_lines(cfg.LABELS_FILE)
+
+    # Set output path
+    cfg.OUTPUT_PATH = output_path
+
+    if os.path.isdir(cfg.OUTPUT_PATH):
+        cfg.OUTPUT_PATH = os.path.join(cfg.OUTPUT_PATH, "species_list.txt")
+
+    # Set config
+    cfg.LATITUDE, cfg.LONGITUDE, cfg.WEEK = lat, lon, week
+    cfg.LOCATION_FILTER_THRESHOLD = threshold
+
+    print(f"Getting species list for {cfg.LATITUDE}/{cfg.LONGITUDE}, Week {cfg.WEEK}...", end="", flush=True)
+
+    # Get species list
+    species_list = get_species_list(
+        cfg.LATITUDE, cfg.LONGITUDE, cfg.WEEK, cfg.LOCATION_FILTER_THRESHOLD, False if sortby == "freq" else True
+    )
+
+    print(f"Done. {len(species_list)} species on list.", flush=True)
+
+    # Save species list
+    with open(cfg.OUTPUT_PATH, "w") as f:
+        for s in species_list:
+            f.write(s + "\n")

birdnet_analyzer/train/__init__.py

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

birdnet_analyzer/train/__main__.py

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

birdnet_analyzer/train/cli.py

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

birdnet_analyzer/train/core.py

@@ -0,0 +1,113 @@
+from typing import Literal
+
+
+def train(
+    input: str,
+    output: str = "checkpoints/custom/Custom_Classifier",
+    test_data: str = None,
+    *,
+    crop_mode: Literal["center", "first", "segments"] = "center",
+    overlap: float = 0.0,
+    epochs: int = 50,
+    batch_size: int = 32,
+    val_split: float = 0.2,
+    learning_rate: float = 0.0001,
+    use_focal_loss: bool = False,
+    focal_loss_gamma: float = 2.0,
+    focal_loss_alpha: float = 0.25,
+    hidden_units: int = 0,
+    dropout: float = 0.0,
+    label_smoothing: bool = False,
+    mixup: bool = False,
+    upsampling_ratio: float = 0.0,
+    upsampling_mode: Literal["repeat", "mean", "smote"] = "repeat",
+    model_format: Literal["tflite", "raven", "both"] = "tflite",
+    model_save_mode: Literal["replace", "append"] = "replace",
+    cache_mode: Literal["load", "save"] | None = None,
+    cache_file: str = "train_cache.npz",
+    threads: int = 1,
+    fmin: float = 0.0,
+    fmax: float = 15000.0,
+    audio_speed: float = 1.0,
+    autotune: bool = False,
+    autotune_trials: int = 50,
+    autotune_executions_per_trial: int = 1,
+):
+    """
+    Trains a custom classifier model using the BirdNET-Analyzer framework.
+    Args:
+        input (str): Path to the training data directory.
+        test_data (str, optional): Path to the test data directory. Defaults to None. If not specified, a validation split will be used.
+        output (str, optional): Path to save the trained model. Defaults to "checkpoints/custom/Custom_Classifier".
+        crop_mode (Literal["center", "first", "segments", "smart"], optional): Mode for cropping audio samples. Defaults to "center".
+        overlap (float, optional): Overlap ratio for audio segments. Defaults to 0.0.
+        epochs (int, optional): Number of training epochs. Defaults to 50.
+        batch_size (int, optional): Batch size for training. Defaults to 32.
+        val_split (float, optional): Fraction of data to use for validation. Defaults to 0.2.
+        learning_rate (float, optional): Learning rate for the optimizer. Defaults to 0.0001.
+        use_focal_loss (bool, optional): Whether to use focal loss for training. Defaults to False.
+        focal_loss_gamma (float, optional): Gamma parameter for focal loss. Defaults to 2.0.
+        focal_loss_alpha (float, optional): Alpha parameter for focal loss. Defaults to 0.25.
+        hidden_units (int, optional): Number of hidden units in the model. Defaults to 0.
+        dropout (float, optional): Dropout rate for regularization. Defaults to 0.0.
+        label_smoothing (bool, optional): Whether to use label smoothing. Defaults to False.
+        mixup (bool, optional): Whether to use mixup data augmentation. Defaults to False.
+        upsampling_ratio (float, optional): Ratio for upsampling underrepresented classes. Defaults to 0.0.
+        upsampling_mode (Literal["repeat", "mean", "smote"], optional): Mode for upsampling. Defaults to "repeat".
+        model_format (Literal["tflite", "raven", "both"], optional): Format to save the trained model. Defaults to "tflite".
+        model_save_mode (Literal["replace", "append"], optional): Save mode for the model. Defaults to "replace".
+        cache_mode (Literal["load", "save"] | None, optional): Cache mode for training data. Defaults to None.
+        cache_file (str, optional): Path to the cache file. Defaults to "train_cache.npz".
+        threads (int, optional): Number of CPU threads to use. Defaults to 1.
+        fmin (float, optional): Minimum frequency for bandpass filtering. Defaults to 0.0.
+        fmax (float, optional): Maximum frequency for bandpass filtering. Defaults to 15000.0.
+        audio_speed (float, optional): Speed factor for audio playback. Defaults to 1.0.
+        autotune (bool, optional): Whether to use hyperparameter autotuning. Defaults to False.
+        autotune_trials (int, optional): Number of trials for autotuning. Defaults to 50.
+        autotune_executions_per_trial (int, optional): Number of executions per autotuning trial. Defaults to 1.
+    Returns:
+        None
+    """
+    from birdnet_analyzer.train.utils import train_model
+    import birdnet_analyzer.config as cfg
+    from birdnet_analyzer.utils import ensure_model_exists
+
+    ensure_model_exists()
+
+    # Config
+    cfg.TRAIN_DATA_PATH = input
+    cfg.TEST_DATA_PATH = test_data
+    cfg.SAMPLE_CROP_MODE = crop_mode
+    cfg.SIG_OVERLAP = overlap
+    cfg.CUSTOM_CLASSIFIER = output
+    cfg.TRAIN_EPOCHS = epochs
+    cfg.TRAIN_BATCH_SIZE = batch_size
+    cfg.TRAIN_VAL_SPLIT = val_split
+    cfg.TRAIN_LEARNING_RATE = learning_rate
+    cfg.TRAIN_WITH_FOCAL_LOSS = use_focal_loss if use_focal_loss is not None else cfg.TRAIN_WITH_FOCAL_LOSS
+    cfg.FOCAL_LOSS_GAMMA = focal_loss_gamma
+    cfg.FOCAL_LOSS_ALPHA = focal_loss_alpha
+    cfg.TRAIN_HIDDEN_UNITS = hidden_units
+    cfg.TRAIN_DROPOUT = dropout
+    cfg.TRAIN_WITH_LABEL_SMOOTHING = label_smoothing if label_smoothing is not None else cfg.TRAIN_WITH_LABEL_SMOOTHING
+    cfg.TRAIN_WITH_MIXUP = mixup if mixup is not None else cfg.TRAIN_WITH_MIXUP
+    cfg.UPSAMPLING_RATIO = upsampling_ratio
+    cfg.UPSAMPLING_MODE = upsampling_mode
+    cfg.TRAINED_MODEL_OUTPUT_FORMAT = model_format
+    cfg.TRAINED_MODEL_SAVE_MODE = model_save_mode
+    cfg.TRAIN_CACHE_MODE = cache_mode
+    cfg.TRAIN_CACHE_FILE = cache_file
+    cfg.TFLITE_THREADS = 1
+    cfg.CPU_THREADS = threads
+
+    cfg.BANDPASS_FMIN = fmin
+    cfg.BANDPASS_FMAX = fmax
+
+    cfg.AUDIO_SPEED = audio_speed
+
+    cfg.AUTOTUNE = autotune
+    cfg.AUTOTUNE_TRIALS = autotune_trials
+    cfg.AUTOTUNE_EXECUTIONS_PER_TRIAL = autotune_executions_per_trial
+
+    # Train model
+    train_model()