Upload compute_cost.py with huggingface_hub

compute_cost.py

@@ -0,0 +1,287 @@
+import argparse
+import os
+import math
+import numpy as np
+import pandas as pd
+
+from typing import Iterable, Dict, List, Optional
+
+CLASSES = ['Speech', 'Shout', 'Chainsaw', 'Jackhammer', 'Lawn Mower', 'Power Drill', 'Dog Bark', 'Rooster Crow', 'Horn Honk', 'Siren']
+
+COST_MATRIX = {
+    "Speech":         {"TP": 0,  "FP": 1,  "TN": 0, "FN": 5},
+    "Dog Bark":       {"TP": 0,  "FP": 1,  "TN": 0, "FN": 5},
+    "Rooster Crow":   {"TP": 0,  "FP": 1,  "TN": 0, "FN": 5},
+    "Shout":          {"TP": 0,  "FP": 2,  "TN": 0, "FN": 10},
+    "Lawn Mower":     {"TP": 0,  "FP": 3,  "TN": 0, "FN": 15},
+    "Chainsaw":       {"TP": 0,  "FP": 3,  "TN": 0, "FN": 15},
+    "Jackhammer":     {"TP": 0,  "FP": 3,  "TN": 0, "FN": 15},
+    "Power Drill":    {"TP": 0,  "FP": 3,  "TN": 0, "FN": 15},
+    "Horn Honk":      {"TP": 0,  "FP": 3,  "TN": 0, "FN": 15},
+    "Siren":          {"TP": 0,  "FP": 3,  "TN": 0, "FN": 15},
+}
+
+def check_dataframe(data_frame, dataset_path):
+    """
+    Validates the integrity of a predictions or ground truth DataFrame.
+
+    Parameters:
+    ----------
+    predictions_df : pandas.DataFrame
+        A DataFrame containing model predictions or the ground truth.
+        It must include columns:
+        - 'filename': Name of the audio file (e.g., "xyz.wav")
+        - 'onset': Onset times or frame indices
+        - One column for each class in the global `CLASSES` list
+
+    dataset_path : str
+        Path to the root of the dataset directory. It must contain a
+        subdirectory 'audio_features' with `.npz` files for each audio file.
+
+    Raises:
+    ------
+    AssertionError:
+        If any of the following checks fail:
+        - The dataset or audio_features directory doesn't exist
+        - The DataFrame is missing required columns
+        - Expected feature files are missing
+        - Number of predictions doesn't match the number of expected timesteps
+
+    Example:
+    -------
+    check_dataframe(predicted_df, "MLPC2025_dataset")
+    """
+    audio_features_path = os.path.join(dataset_path, "audio_features")
+    assert os.path.exists(dataset_path), f"Dataset path '{dataset_path}' does not exist."
+    assert os.path.exists(audio_features_path), f"Audio features path '{audio_features_path}' does not exist."
+
+    required_columns = set(CLASSES + ["filename", "onset"])
+    missing_columns = required_columns - set(data_frame.columns)
+    assert not missing_columns, f"Missing columns in predictions_df: {missing_columns}"
+
+    assert ((data_frame["onset"] / 1.2) % 1).apply(lambda x: np.isclose(x, 0, atol=0.1)).all(), "Not all values are divisible by 1.2."
+    assert data_frame[CLASSES].isin([0, 1]).all().all(), "Not all predictions are 0 or 1."
+
+    for filename in data_frame["filename"].unique():
+        file_id = os.path.splitext(filename)[0]
+        feature_file = os.path.join(audio_features_path, f"{file_id}.npz")
+
+        assert os.path.exists(feature_file), f"Feature file '{feature_file}' does not exist."
+
+        embeddings = np.load(feature_file)["embeddings"]
+        expected_timesteps = math.ceil(len(embeddings) / 10)
+        actual_timesteps = len(data_frame[data_frame["filename"] == filename])
+
+        assert actual_timesteps == expected_timesteps, (
+            f"Mismatch in timesteps for '{filename}': expected {expected_timesteps}, found {actual_timesteps}."
+        )
+
+
+def total_cost(predictions_df, ground_truth_df):
+    """
+    Computes total cost of predictions based on a cost matrix for TP, FP, TN, and FN
+    for each class in a multilabel classification problem.
+
+    Parameters:
+    ----------
+    predictions_df : pandas.DataFrame
+        DataFrame containing predicted binary labels (0 or 1) for each class in CLASSES.
+
+    ground_truth_df : pandas.DataFrame
+        DataFrame containing ground truth binary labels for each class in CLASSES.
+
+    Returns:
+    -------
+    total_cost_value : float
+        Total cost across all classes and samples.
+
+    metrics_per_class : dict
+        Dictionary with TP, FP, TN, FN counts and cost per class.
+    """
+
+    # Align rows by filename and onset
+    merged = predictions_df.merge(
+        ground_truth_df,
+        on=["filename", "onset"],
+        suffixes=("_pred", "_true"),
+        how="inner",
+        validate="one_to_one"
+    )
+
+    if merged.shape[0] != predictions_df.shape[0]:
+        raise ValueError("Mismatch in alignment between prediction and ground truth rows")
+
+    metrics_per_class = {}
+
+    for cls in CLASSES:
+        y_pred = predictions_df[cls].astype(int)
+        y_true = ground_truth_df[cls].astype(int)
+
+        TP = ((y_pred == 1) & (y_true == 1)).mean() * 50
+        FP = ((y_pred == 1) & (y_true == 0)).mean() * 50
+        TN = ((y_pred == 0) & (y_true == 0)).mean() * 50
+        FN = ((y_pred == 0) & (y_true == 1)).mean() * 50
+
+        cost = (
+            COST_MATRIX[cls]["TP"] * TP +
+            COST_MATRIX[cls]["FP"] * FP +
+            COST_MATRIX[cls]["TN"] * TN +
+            COST_MATRIX[cls]["FN"] * FN
+        )
+
+        metrics_per_class[cls] = {
+            "TP": TP, "FP": FP, "TN": TN, "FN": FN, "cost": cost
+        }
+
+    return sum([metrics_per_class[c]["cost"] for c in metrics_per_class]), metrics_per_class
+
+
+def aggregate_targets(arr: np.ndarray, f: int = 10) -> np.ndarray:
+    """
+    Aggregates frame-level ground truths into segment-level by taking the max over fixed-size chunks.
+
+    Parameters:
+    ----------
+    arr : np.ndarray
+        Array of shape (N, D) where N is the number of frames, D is number of classes.
+
+    f : int
+        Aggregation factor (number of frames per chunk).
+
+    Returns:
+    -------
+    np.ndarray
+        Aggregated labels of shape (ceil(N/f), D)
+    """
+    N, D = arr.shape
+    full_chunks = N // f
+    remainder = N % f
+
+    # Aggregate full chunks
+    aggregated = arr[:full_chunks * f].reshape(full_chunks, f, D).max(axis=1)
+
+    # Handle leftover frames
+    if remainder > 0:
+        tail = arr[full_chunks * f:].max(axis=0, keepdims=True)
+        aggregated = np.vstack([aggregated, tail])
+
+    return aggregated
+
+
+def get_ground_truth_df(filenames: Iterable[str], dataset_path: str) -> pd.DataFrame:
+    """
+    Loads and aggregates ground truth labels for an arbitrary list of files.
+
+    Parameters:
+    ----------
+    filenames : Iterable[str]
+        List or array of filenames (e.g., from a subset of metadata.csv) to process.
+
+    dataset_path : str
+        Path to dataset containing the 'labels/' folder with .npz files.
+
+    Returns:
+    -------
+    pd.DataFrame
+        DataFrame with columns: ["filename", "onset"] + CLASSES
+    """
+    rows = []
+
+    for fname in filenames:
+        base = os.path.splitext(fname)[0]
+        label_path = os.path.join(dataset_path, 'labels', f"{base}_labels.npz")
+        assert os.path.exists(label_path), f"Missing label file: {label_path}"
+
+        y = np.load(label_path)
+        class_matrix = np.stack([y[cls].mean(-1) for cls in CLASSES], axis=1)
+        aggregated = aggregate_targets(class_matrix)
+
+        for i, row in enumerate(aggregated):
+            onset = round(i * 1.2, 1)
+            binary_labels = (row > 0).astype(int).tolist()
+            rows.append([fname, onset] + binary_labels)
+
+    return pd.DataFrame(data=rows, columns=["filename", "onset"] + CLASSES)
+
+
+def get_segment_prediction_df(
+    predictions: Dict[str, Dict[str, np.ndarray]],
+    class_names: Optional[List[str]] = None
+) -> pd.DataFrame:
+    """
+    Aggregates frame-level predictions into fixed-length segments for a set of files.
+
+    Parameters:
+    ----------
+    predictions : Dict[str, Dict[str, np.ndarray]]
+        Dictionary mapping each filename to another dictionary of class-wise frame-level predictions.
+        Each class prediction is a 1D NumPy array of shape (T,), where T is time.
+
+    class_names : List[str], optional
+        List of class names to include in the output. If None, uses keys from the first file's prediction dict.
+
+    Returns:
+    -------
+    pd.DataFrame
+        DataFrame with columns: ["filename", "onset"] + class_names.
+        Each row represents a segment and contains aggregated predictions for that segment.
+    """
+    if class_names is None:
+        class_names = list(next(iter(predictions.values())).keys())
+
+    rows = []
+
+    for filename, class_preds in predictions.items():
+        # Collect and stack predictions into shape (T, num_classes)
+        frame_matrix = np.stack([class_preds[cls] for cls in class_names], axis=1)
+
+        # Aggregate over fixed-length segments
+        aggregated = aggregate_targets(frame_matrix, f=10)
+
+        for seg_idx, segment in enumerate(aggregated):
+            onset = round(seg_idx * 1.2, 1)
+            rows.append([filename, onset] + segment.tolist())
+
+    return pd.DataFrame(rows, columns=["filename", "onset"] + class_names)
+
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Compute total cost for environmental noise predictions.")
+
+    parser.add_argument(
+        "--dataset_path",
+        type=str,
+        required=True,
+        help="Path to the root directory of the dataset (must contain 'audio_features/')."
+    )
+
+    parser.add_argument(
+        "--ground_truth_csv",
+        type=str,
+        default=None,
+        help="Path to the CSV file containing the ground truth labels."
+    )
+
+    parser.add_argument(
+        "--predictions_csv",
+        type=str,
+        required=True,
+        help="Path to the CSV file containing the predicted labels."
+    )
+
+    args = parser.parse_args()
+
+    df_pred = pd.read_csv(args.predictions_csv)
+    check_dataframe(df_pred, dataset_path=args.dataset_path)
+    print("Predictions CSV formated correctly.")
+
+    if args.ground_truth_csv is not None:
+        df_gt = pd.read_csv(args.ground_truth_csv)
+        check_dataframe(df_gt, dataset_path=args.dataset_path)
+        print("Ground truth CSV formated correctly.")
+
+        total, breakdown = total_cost(df_pred, df_gt)
+
+        print("Total cost:", total)