singlebehaviorlab 2.3.3__tar.gz → 2.3.5__tar.gz

{singlebehaviorlab-2.3.3/singlebehaviorlab.egg-info → singlebehaviorlab-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: singlebehaviorlab
-Version: 2.3.3
+Version: 2.3.5
 Summary: Behavioral sequencing and phenotyping with lightweight task specific adaptation
 Author: Almir Aljovic
 Maintainer: Almir Aljovic
@@ -34,11 +34,11 @@ License-File: LICENSE
 Requires-Dist: PyQt6==6.11.0
 Requires-Dist: PyQt6-WebEngine==6.11.0
 Requires-Dist: PyYAML==6.0.3
-Requires-Dist: numpy==2.2.6
+Requires-Dist: numpy<3,>=2.1
 Requires-Dist: h5py==3.14.0
 Requires-Dist: opencv-python==4.13.0.92
 Requires-Dist: Pillow==12.1.1
-Requires-Dist: scipy==1.15.3
+Requires-Dist: scipy<2,>=1.14
 Requires-Dist: eva-decord==0.6.1
 Requires-Dist: scikit-learn==1.7.2
 Requires-Dist: pandas==2.3.3

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "singlebehaviorlab"
-version = "2.3.3"
+version = "2.3.5"
 description = "Behavioral sequencing and phenotyping with lightweight task specific adaptation"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -16,11 +16,11 @@ dependencies = [
     "PyQt6==6.11.0",
     "PyQt6-WebEngine==6.11.0",
     "PyYAML==6.0.3",
-    "numpy==2.2.6",
+    "numpy>=2.1,<3",
     "h5py==3.14.0",
     "opencv-python==4.13.0.92",
     "Pillow==12.1.1",
-    "scipy==1.15.3",
+    "scipy>=1.14,<2",
     "eva-decord==0.6.1",
     "scikit-learn==1.7.2",
     "pandas==2.3.3",

singlebehaviorlab-2.3.5/singlebehaviorlab/backend/embedding_refine.py

@@ -0,0 +1,48 @@
+"""Clip-level embedding refinement via label propagation."""
+
+from __future__ import annotations
+
+import numpy as np
+from typing import Optional
+
+__all__ = ["refine_clip_predictions"]
+
+
+def refine_clip_predictions(
+    clip_labels: np.ndarray,
+    clip_embeddings: np.ndarray,
+    clip_confidences: np.ndarray,
+    confidence_threshold: float = 0.7,
+    seed_labels: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """Refine per-clip predictions using label propagation on clip embeddings.
+
+    When seed_labels is provided, those are used as hard seeds and all other
+    clips are unlabeled. Otherwise, high-confidence clips seed the graph.
+    """
+    from sklearn.semi_supervised import LabelSpreading
+
+    N = len(clip_labels)
+    if N < 4 or clip_embeddings.shape[0] != N:
+        return clip_labels.copy()
+
+    if seed_labels is not None and len(seed_labels) == N:
+        labels_for_propagation = seed_labels.copy()
+    else:
+        labels_for_propagation = clip_labels.copy()
+        labels_for_propagation[clip_confidences < confidence_threshold] = -1
+
+    n_labeled = int(np.sum(labels_for_propagation >= 0))
+    if n_labeled < 2 or n_labeled == N:
+        return clip_labels.copy()
+
+    n_neighbors = min(7, N - 1)
+    lp = LabelSpreading(kernel="knn", n_neighbors=n_neighbors, max_iter=30, alpha=0.2)
+    lp.fit(clip_embeddings, labels_for_propagation)
+    propagated = lp.transduction_
+
+    result = clip_labels.copy()
+    unlabeled = labels_for_propagation < 0
+    result[unlabeled] = propagated[unlabeled]
+
+    return result

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/backend/inference.py

@@ -186,6 +186,8 @@ def run_inference_on_video(
         multi_scale=multi_scale,
     )
     model.load_head(model_path)
+    if hasattr(model, "frame_head") and model.frame_head is not None:
+        model.frame_head.use_ovr = True
 
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model.to(device)
@@ -225,13 +227,13 @@ def run_inference_on_video(
         frame_output = getattr(model, "_frame_output", None)
         if frame_output is not None:
             f_logits = frame_output[0]
-            batch_frame_probs = torch.softmax(f_logits, dim=-1).detach().cpu().numpy()
+            batch_frame_probs = torch.sigmoid(f_logits).detach().cpu().numpy()
             for b_i in range(batch_frame_probs.shape[0]):
                 clip_frame_probabilities.append(batch_frame_probs[b_i].tolist())
         else:
             clip_frame_probabilities.extend([] for _ in batch_clips)
 
-        probs = torch.softmax(logits, dim=1)
+        probs = torch.sigmoid(logits)
         preds = torch.argmax(probs, dim=1)
         confs = torch.max(probs, dim=1)[0]
         predictions.extend(int(p) for p in preds.cpu().numpy().tolist())
@@ -269,10 +271,6 @@ def run_inference_on_video(
                 agg_probs[f_start:f_end] += probs_arr[t][np.newaxis, :] * w
                 agg_counts[f_start:f_end] += w
         agg_probs = agg_probs / np.maximum(agg_counts, 1.0)
-        covered = agg_counts.squeeze(-1) > 0
-        row_sums = agg_probs[covered].sum(axis=1, keepdims=True)
-        safe_sums = np.maximum(row_sums, 1e-8)
-        agg_probs[covered] = agg_probs[covered] / safe_sums
         aggregated_frame_probs = agg_probs
 
     res_entry: dict[str, Any] = {

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/backend/model.py

@@ -555,10 +555,7 @@ class DilatedTemporalHead(nn.Module):
             x_conv = x.transpose(1, 2)  # [B, tcn_in, T_pooled]
             stage_logits = self.stage1(x_conv)
             for refine in self.refine_stages:
-                if self.use_ovr:
-                    refine_in = torch.sigmoid(stage_logits)
-                else:
-                    refine_in = torch.softmax(stage_logits, dim=1)
+                refine_in = torch.sigmoid(stage_logits)
                 stage_logits = stage_logits + refine(refine_in)
 
             stage_logits_pooled = stage_logits

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/backend/train.py

@@ -1100,7 +1100,7 @@ def _run_augmentation_ablation_eval(
     from .augmentations import ClipAugment
 
     aug_opts = config.get("augmentation_options") or {}
-    use_ovr = config.get("use_ovr", False)
+    use_ovr = config.get("use_ovr", True)
 
     # Map of augmentation toggle names → ClipAugment kwargs that isolate that aug
     aug_toggles = {
@@ -1395,7 +1395,7 @@ def train_model(
             log_fn(f"Creating data loaders (batch_size={config['batch_size']})...")
         
         use_weighted_sampler = config.get("use_weighted_sampler", False)
-        use_ovr = config.get("use_ovr", False)
+        use_ovr = config.get("use_ovr", True)
         _confusion_warmup_pct = float(config.get("confusion_sampler_warmup_pct", 0.2))
         sampler = None
         batch_sampler = None

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/backend/training_runner.py

@@ -120,7 +120,7 @@ def _build_backend_train_config(
         "crop_jitter_strength": float(cfg.get("crop_jitter_strength", 0.15)),
         "emb_aug_versions": int(cfg.get("emb_aug_versions", 1)),
         "clip_length": int(cfg.get("clip_length", 16)),
-        "use_ovr": bool(cfg.get("use_ovr", False)),
+        "use_ovr": bool(cfg.get("use_ovr", True)),
         "ovr_label_smoothing": float(cfg.get("ovr_label_smoothing", 0.05)),
         "use_asl": bool(cfg.get("use_asl", False)),
         "asl_gamma_neg": float(cfg.get("asl_gamma_neg", 2.0)),

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/gui/analysis_widget.py

@@ -842,7 +842,7 @@ class AnalysisWidget(QWidget):
                     if i < len(clip_starts):
                         end_frame_exclusive = int(clip_starts[i])
                     else:
-                        end_frame_exclusive = start_frame + (clip_length * frame_interval)
+                        end_frame_exclusive = start_frame + (clip_length - 1) * frame_interval + 1
                         if total_frames > 0:
                             end_frame_exclusive = min(end_frame_exclusive, total_frames)
                     duration_frames = max(0, end_frame_exclusive - start_frame)

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/gui/attention_export.py

@@ -305,7 +305,7 @@ def export_attention_heatmap_video(widget):
 def _find_clip_for_frame(frame_idx, clip_starts, clip_length, frame_interval):
     """Find which clip index covers the given video frame."""
     for i in range(len(clip_starts) - 1, -1, -1):
-        clip_end = clip_starts[i] + clip_length * frame_interval
+        clip_end = clip_starts[i] + (clip_length - 1) * frame_interval + 1
         if clip_starts[i] <= frame_idx < clip_end:
             return i
     return None

{singlebehaviorlab-2.3.3 → singlebehaviorlab-2.3.5}/singlebehaviorlab/gui/inference_popups.py

@@ -2,7 +2,8 @@
 
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QComboBox,
-    QGroupBox, QMessageBox, QSizePolicy, QSpinBox,
+    QGroupBox, QMessageBox, QSizePolicy, QSpinBox, QCheckBox,
+    QDoubleSpinBox, QFormLayout,
 )
 from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtGui import QImage, QPixmap
@@ -949,3 +950,142 @@ class FrameSegmentPopupDialog(QDialog):
         if hasattr(self, '_play_timer') and self._play_timer.isActive():
             self._play_timer.stop()
         super().closeEvent(event)
+
+
+class PostprocessingDialog(QDialog):
+    """Settings dialog for inference postprocessing controls."""
+
+    def __init__(self, parent_widget):
+        super().__init__(parent_widget)
+        self.setWindowTitle("Postprocessing Settings")
+        self.setMinimumWidth(420)
+        self._w = parent_widget
+        layout = QVBoxLayout(self)
+
+        # --- Basic ---
+        basic = QGroupBox("Basic")
+        bl = QVBoxLayout()
+
+        ref_row = QHBoxLayout()
+        self._embed_refine = QCheckBox("Embedding refinement")
+        self._embed_refine.setToolTip(
+            "Use clip-level embeddings to correct low-confidence predictions\n"
+            "via label propagation. Seeds the top N% most confident clips per class."
+        )
+        ref_row.addWidget(self._embed_refine)
+        ref_row.addWidget(QLabel("Top %:"))
+        self._embed_refine_pct = QSpinBox()
+        self._embed_refine_pct.setRange(1, 50)
+        self._embed_refine_pct.setValue(10)
+        self._embed_refine_pct.setSuffix("%")
+        self._embed_refine_pct.setToolTip("Percentage of most confident clips per class to use as seeds.")
+        ref_row.addWidget(self._embed_refine_pct)
+        bl.addLayout(ref_row)
+
+        self._show_all = QCheckBox("Show all classes (overlapping)")
+        self._show_all.setToolTip(
+            "When enabled, every class above its threshold is shown independently\n"
+            "(no mutual exclusivity). When disabled, only the top-1 class is shown."
+        )
+        bl.addWidget(self._show_all)
+
+        self._show_per_clip = QCheckBox("Show per clip")
+        self._show_per_clip.setToolTip(
+            "Show raw per-clip predictions instead of frame-aggregated segments.\n"
+            "Useful for visually verifying individual clip boundaries and predictions."
+        )
+        bl.addWidget(self._show_per_clip)
+
+        basic.setLayout(bl)
+        layout.addWidget(basic)
+
+        # --- Thresholds ---
+        thresh = QGroupBox("Thresholds")
+        tl = QVBoxLayout()
+        thr_row = QHBoxLayout()
+        self._ignore_low = QCheckBox("Ignore low-confidence")
+        thr_row.addWidget(self._ignore_low)
+        thr_row.addWidget(QLabel("Default τ:"))
+        self._ignore_spin = QDoubleSpinBox()
+        self._ignore_spin.setDecimals(2)
+        self._ignore_spin.setRange(0.0, 1.0)
+        self._ignore_spin.setSingleStep(0.05)
+        thr_row.addWidget(self._ignore_spin)
+        self._per_class_thresh_btn = QPushButton("Per-class τ…")
+        self._per_class_thresh_btn.clicked.connect(
+            lambda: self._w._open_per_class_thresholds_dialog()
+        )
+        thr_row.addWidget(self._per_class_thresh_btn)
+        tl.addLayout(thr_row)
+        thresh.setLayout(tl)
+        layout.addWidget(thresh)
+
+        # --- Decoding ---
+        dec = QGroupBox("Decoding")
+        dl = QVBoxLayout()
+        vit_row = QHBoxLayout()
+        self._viterbi = QCheckBox("Viterbi decode")
+        self._viterbi.setToolTip(
+            "Inference-only sequence decoding on merged frame probabilities.\n"
+            "OvR models use binary per-class Viterbi."
+        )
+        vit_row.addWidget(self._viterbi)
+        vit_row.addWidget(QLabel("Switch penalty:"))
+        self._viterbi_penalty = QDoubleSpinBox()
+        self._viterbi_penalty.setDecimals(2)
+        self._viterbi_penalty.setRange(0.0, 5.0)
+        self._viterbi_penalty.setSingleStep(0.05)
+        vit_row.addWidget(self._viterbi_penalty)
+        dl.addLayout(vit_row)
+        dec.setLayout(dl)
+        layout.addWidget(dec)
+
+        # --- Cleanup ---
+        cleanup = QGroupBox("Cleanup")
+        cl = QVBoxLayout()
+        self._per_class_seg_btn = QPushButton("Per-class segment rules…")
+        self._per_class_seg_btn.setToolTip(
+            "Set smooth window, gap fill, and minimum segment length per behavior class."
+        )
+        self._per_class_seg_btn.clicked.connect(
+            lambda: self._w._open_per_class_segment_rules_dialog()
+        )
+        cl.addWidget(self._per_class_seg_btn)
+        cleanup.setLayout(cl)
+        layout.addWidget(cleanup)
+
+        # --- Buttons ---
+        btn_row = QHBoxLayout()
+        btn_row.addStretch()
+        apply_btn = QPushButton("Apply")
+        apply_btn.clicked.connect(self._apply)
+        btn_row.addWidget(apply_btn)
+        close_btn = QPushButton("Close")
+        close_btn.clicked.connect(self.close)
+        btn_row.addWidget(close_btn)
+        layout.addLayout(btn_row)
+
+        self._load_from_widget()
+
+    def _load_from_widget(self):
+        w = self._w
+        self._embed_refine.setChecked(w.embedding_refine_check.isChecked())
+        self._embed_refine_pct.setValue(int(w.embedding_refine_threshold.value()))
+        self._show_all.setChecked(w.ovr_show_all_check.isChecked())
+        self._show_per_clip.setChecked(not w.frame_aggregation_check.isChecked())
+        self._ignore_low.setChecked(w.use_ignore_threshold_check.isChecked())
+        self._ignore_spin.setValue(w.ignore_threshold_spin.value())
+        self._viterbi.setChecked(w.use_viterbi_check.isChecked())
+        self._viterbi_penalty.setValue(w.viterbi_switch_penalty_spin.value())
+
+    def _apply(self):
+        w = self._w
+        w.embedding_refine_check.setChecked(self._embed_refine.isChecked())
+        w.embedding_refine_threshold.setValue(float(self._embed_refine_pct.value()))
+        w.ovr_show_all_check.setChecked(self._show_all.isChecked())
+        w.frame_aggregation_check.setChecked(not self._show_per_clip.isChecked())
+        w.use_ignore_threshold_check.setChecked(self._ignore_low.isChecked())
+        w.ignore_threshold_spin.setValue(self._ignore_spin.value())
+        w.use_viterbi_check.setChecked(self._viterbi.isChecked())
+        w.viterbi_switch_penalty_spin.setValue(self._viterbi_penalty.value())
+        w._on_embedding_refine_changed()