Add average precision computation to pr curves if needed

src/batdetect2/data/predictions/raw.py

@@ -194,10 +194,10 @@ class RawFormatter(OutputFormatterProtocol[BatDetect2Prediction]):
                     detection_data.geometry.item()
                 )
             else:
-                start_time = detection_data.start_time
-                end_time = detection_data.end_time
-                low_freq = detection_data.low_freq
-                high_freq = detection_data.high_freq
+                start_time = detection_data.start_time.item()
+                end_time = detection_data.end_time.item()
+                low_freq = detection_data.low_freq.item()
+                high_freq = detection_data.high_freq.item()
                 geometry = data.BoundingBox.model_construct(
                     coordinates=[start_time, low_freq, end_time, high_freq]
                 )

src/batdetect2/evaluate/metrics/classification.py

@@ -29,6 +29,7 @@ __all__ = [
     "ClassificationMetric",
     "ClassificationMetricConfig",
     "build_classification_metric",
+    "compute_precision_recall_curves",
 ]
 
 

src/batdetect2/evaluate/metrics/common.py

@@ -52,6 +52,14 @@ def average_precision(
         num_positives=num_positives,
     )
 
+    # pascal 12 way
+    return _average_precision(recall, precision)
+
+
+def _average_precision(
+    recall: np.ndarray,
+    precision: np.ndarray,
+) -> float:
     # pascal 12 way
     mprec = np.hstack((0, precision, 0))
     mrec = np.hstack((0, recall, 1))
@@ -59,5 +67,4 @@ def average_precision(
         mprec[ii] = np.maximum(mprec[ii], mprec[ii + 1])
     inds = np.where(np.not_equal(mrec[1:], mrec[:-1]))[0] + 1
     ave_prec = ((mrec[inds] - mrec[inds - 1]) * mprec[inds]).sum()
-
     return ave_prec

src/batdetect2/evaluate/metrics/top_class.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from dataclasses import dataclass
 from typing import (
     Annotated,

src/batdetect2/evaluate/tasks/__init__.py

@@ -1,8 +1,9 @@
-from typing import Annotated, Optional, Union
+from typing import Annotated, Optional, Sequence, Union
 
 from pydantic import Field
+from soundevent import data
 
-from batdetect2.evaluate.tasks.base import tasks_registry
+from batdetect2.evaluate.tasks.base import BaseTaskConfig, tasks_registry
 from batdetect2.evaluate.tasks.classification import ClassificationTaskConfig
 from batdetect2.evaluate.tasks.clip_classification import (
     ClipClassificationTaskConfig,
@@ -11,11 +12,16 @@ from batdetect2.evaluate.tasks.clip_detection import ClipDetectionTaskConfig
 from batdetect2.evaluate.tasks.detection import DetectionTaskConfig
 from batdetect2.evaluate.tasks.top_class import TopClassDetectionTaskConfig
 from batdetect2.targets import build_targets
-from batdetect2.typing import EvaluatorProtocol, TargetProtocol
+from batdetect2.typing import (
+    BatDetect2Prediction,
+    EvaluatorProtocol,
+    TargetProtocol,
+)
 
 __all__ = [
     "TaskConfig",
     "build_task",
+    "evaluate_task",
 ]
 
 
@@ -37,3 +43,25 @@ def build_task(
 ) -> EvaluatorProtocol:
     targets = targets or build_targets()
     return tasks_registry.build(config, targets)
+
+
+def evaluate_task(
+    clip_annotations: Sequence[data.ClipAnnotation],
+    predictions: Sequence[BatDetect2Prediction],
+    task: Optional["str"] = None,
+    targets: Optional[TargetProtocol] = None,
+    config: Optional[Union[TaskConfig, dict]] = None,
+):
+    if isinstance(config, BaseTaskConfig):
+        task_obj = build_task(config, targets)
+        return task_obj.evaluate(clip_annotations, predictions)
+
+    if task is None:
+        raise ValueError(
+            "Task must be specified if a full config is not provided.",
+        )
+
+    config_class = tasks_registry.get_config_type(task)
+    config = config_class.model_validate(config or {})  # type: ignore
+    task_obj = build_task(config, targets)  # type: ignore
+    return task_obj.evaluate(clip_annotations, predictions)

src/batdetect2/models/blocks.py

@@ -174,6 +174,22 @@ class SelfAttention(nn.Module):
 
         return op
 
+    def compute_attention_weights(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.squeeze(2).permute(0, 2, 1)
+
+        key = torch.matmul(
+            x, self.key_fun.weight.T
+        ) + self.key_fun.bias.unsqueeze(0).unsqueeze(0)
+        query = torch.matmul(
+            x, self.query_fun.weight.T
+        ) + self.query_fun.bias.unsqueeze(0).unsqueeze(0)
+
+        kk_qq = torch.bmm(key, query.permute(0, 2, 1)) / (
+            self.temperature * self.att_dim
+        )
+        att_weights = F.softmax(kk_qq, 1)
+        return att_weights
+
 
 class ConvConfig(BaseConfig):
     """Configuration for a basic ConvBlock."""

src/batdetect2/plotting/metrics.py

@@ -5,6 +5,7 @@ import seaborn as sns
 from cycler import cycler
 from matplotlib import axes
 
+from batdetect2.evaluate.metrics.common import _average_precision
 from batdetect2.plotting.common import create_ax
 
 
@@ -80,15 +81,21 @@ def plot_pr_curves(
     figsize: Optional[Tuple[int, int]] = None,
     add_legend: bool = True,
     add_labels: bool = True,
+    include_ap: bool = False,
 ) -> axes.Axes:
     ax = create_ax(ax=ax, figsize=figsize)
     ax = set_default_style(ax)
 
     for name, (precision, recall, thresholds) in data.items():
+        label = name
+
+        if include_ap:
+            label += f" (AP={_average_precision(recall, precision):.2f})"
+
         ax.plot(
             recall,
             precision,
-            label=name,
+            label=label,
             markevery=_get_marker_positions(thresholds),
         )