opensportslib 0.3.0.dev7__tar.gz → 0.3.0.dev9__tar.gz

{opensportslib-0.3.0.dev7/opensportslib.egg-info → opensportslib-0.3.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev7
+Version: 0.3.0.dev9
 Summary: OpenSportsLib is the professional library, designed for advanced video understanding in sports. It provides state-of-the-art tools for action recognition, spotting, retrieval, and captioning, making it ideal for researchers, analysts, and developers working with sports video data.
 Author: Jeet Vora
 Requires-Python: >=3.12

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/apis/base_task_model.py

@@ -10,7 +10,12 @@ from abc import ABC, abstractmethod
 from typing import Any
 
 from opensportslib.core.config.accessors import get_component_name_by_kind
-from opensportslib.core.utils.config import expand, load_config_omega, fetch_and_merge_config_from_HF
+from opensportslib.core.utils.config import (
+    expand,
+    load_config_omega,
+    fetch_and_merge_config_from_HF,
+    resolve_inference_class_metadata,
+)
 
 
 class BaseTaskModel(ABC):
@@ -29,6 +34,7 @@ class BaseTaskModel(ABC):
 
         if weights is not None:
             self.config = fetch_and_merge_config_from_HF(self.config, weights, merge_policy="compatibility")
+            self.config = resolve_inference_class_metadata(self.config)
             self.last_loaded_weights = weights
             self.best_checkpoint = weights
 

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/apis/classification.py

@@ -15,7 +15,7 @@ from opensportslib.core.config.accessors import (
     get_system_seed,
     get_system_use_seed,
 )
-from opensportslib.core.utils.config import expand
+from opensportslib.core.utils.config import expand, resolve_inference_class_metadata
 
 
 def _is_tracking_graph_modality(modality):
@@ -269,6 +269,7 @@ class ClassificationModel(BaseTaskModel):
         test_set = self._resolve_split_path("test", test_set)
 
         self.config = resolve_config_omega(self.config, weights=weights)
+        self.config = resolve_inference_class_metadata(self.config)
         logging.info("Configuration:")
         logging.info(self.config)
 
@@ -335,6 +336,7 @@ class ClassificationModel(BaseTaskModel):
         test_set = self._resolve_split_path("test", test_set)
 
         self.config = resolve_config_omega(self.config, weights=weights)
+        self.config = resolve_inference_class_metadata(self.config)
         logging.info("Configuration:")
         logging.info(self.config)
         if predictions is None:

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/apis/localization.py

@@ -18,7 +18,7 @@ from opensportslib.core.config.accessors import (
     set_loader_backend,
     get_model_family,
 )
-from opensportslib.core.utils.config import expand
+from opensportslib.core.utils.config import expand, resolve_inference_class_metadata
 from opensportslib.core.config.loader import _dali_available
 
 
@@ -276,6 +276,7 @@ class LocalizationModel(BaseTaskModel):
         self._set_split_path("valid_data_frames", valid_set)
 
         self.config = resolve_config_omega(self.config, weights=weights)
+        self.config = resolve_inference_class_metadata(self.config)
         effective_weights = weights if weights is not None else self.last_loaded_weights
         self._adapt_hf_backend_for_device(effective_weights)
         check_config(self.config, split="train")
@@ -389,9 +390,11 @@ class LocalizationModel(BaseTaskModel):
         self._set_split_path("test", test_set)
 
         self.config = resolve_config_omega(self.config, weights=weights)
+        self.config = resolve_inference_class_metadata(self.config)
         effective_weights = weights if weights is not None else self.last_loaded_weights
         self._adapt_hf_backend_for_device(effective_weights)
         check_config(self.config, split="test")
+        self.config = resolve_inference_class_metadata(self.config)
         self.config.infer_split = whether_infer_split(get_split_cfg(self.config, "test"))
 
         init_wandb(
@@ -459,9 +462,11 @@ class LocalizationModel(BaseTaskModel):
         test_set = self._resolve_split_path("test", test_set)
         self._set_split_path("test", test_set)
         self.config = resolve_config_omega(self.config, weights=weights)
+        self.config = resolve_inference_class_metadata(self.config)
         effective_weights = weights if weights is not None else self.last_loaded_weights
         self._adapt_hf_backend_for_device(effective_weights)
         check_config(self.config, split="test")
+        self.config = resolve_inference_class_metadata(self.config)
         self.config.infer_split = whether_infer_split(get_split_cfg(self.config, "test"))
 
         init_wandb(

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/configs/vqa/default.yaml

@@ -15,16 +15,16 @@ SYSTEM:
 
 DATA:
   common:
-    dataset_name: OSL-XFoul
-    data_root: /home/vorajv/dataset/OSL-XFoul
-    feature_index: /home/vorajv/dataset/OSL-XFoul/feature_index.json
-    prediction_index: /home/vorajv/dataset/OSL-XFoul/prediction_index.json
+    dataset_name: dataset_name
+    data_root: ./dataset/dataset_name
+    feature_index: ./dataset/feature_index.json
+    prediction_index: ./dataset/prediction_index.json
     runtime:
       loader_backend: opencv
     splits:
       train:
-        annotation_path: /home/vorajv/dataset/OSL-XFoul/train.json
-        source_path: /home/vorajv/dataset/OSL-XFoul
+        annotation_path: ./dataset//train.json
+        source_path: ./dataset/
         dataloader:
           batch_size: 1
           shuffle: true
@@ -33,8 +33,8 @@ DATA:
           mp_context: spawn
           persistent_workers: false
       valid:
-        annotation_path: /home/vorajv/dataset/OSL-XFoul/valid.json
-        source_path: /home/vorajv/dataset/OSL-XFoul
+        annotation_path: ./dataset/valid.json
+        source_path: ./dataset/
         dataloader:
           batch_size: 1
           shuffle: false
@@ -43,8 +43,8 @@ DATA:
           mp_context: spawn
           persistent_workers: false
       test:
-        annotation_path: /home/vorajv/dataset/OSL-XFoul/test.json
-        source_path: /home/vorajv/dataset/OSL-XFoul
+        annotation_path: ./dataset/test.json
+        source_path: ./dataset/
         dataloader:
           batch_size: 1
           shuffle: false

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/configs/vqa/qwen.yaml

@@ -10,7 +10,7 @@ MODEL:
         provider: opensportslib
         name: xvars_clip_features
       load:
-        weights_path: /home/vorajv/X-VARS/weights/14_model.pth.tar
+        weights_path: OpenSportsLab/trained-clip-vit-large-patch14
       params:
         feature_source: indexed_or_raw_clip
         vision_tower: openai/clip-vit-large-patch14

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/configs/vqa/qwen3_vl_native.yaml

@@ -1,6 +1,6 @@
 SYSTEM:
   paths:
-    save_dir: ./checkpoints_vqa_qwen3_vl_native
+    save_dir: ./checkpoints_vqa_qwen3_vl
   gpu:
     count: 4
     id: null

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/configs/vqa/qwen_lora.yaml

@@ -1,6 +1,6 @@
 SYSTEM:
   paths:
-    save_dir: ./checkpoints_vqa_qwen_lora
+    save_dir: ./checkpoints_vqa_qwen
   gpu:
     count: 4
 
@@ -12,7 +12,7 @@ MODEL:
         provider: opensportslib
         name: xvars_clip_features
       load:
-        weights_path: /home/vorajv/X-VARS/weights/14_model.pth.tar
+        weights_path: OpenSportsLab/trained-clip-vit-large-patch14
       params:
         feature_source: indexed_or_raw_clip
         vision_tower: openai/clip-vit-large-patch14

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/configs/vqa/xvars.yaml

@@ -1,6 +1,6 @@
 SYSTEM:
   paths:
-    save_dir: ./checkpoints_vqa_lora
+    save_dir: ./checkpoints_vqa_xvars_lora
   gpu:
     count: 4
 
@@ -10,9 +10,9 @@ MODEL:
       kind: encoder
       source:
         provider: opensportslib
-      # XVARS-trained classifier weights to load into that architecture
+      # X-VARS visual checkpoint: local file path or HF model repo ID.
       load:
-        weights_path: /home/vorajv/X-VARS/weights/14_model.pth.tar
+        weights_path: OpenSportsLab/trained-clip-vit-large-patch14
       params:
         # CLIP architecture and image processor to instantiate.
         feature_source: indexed_or_raw_clip
@@ -31,7 +31,7 @@ MODEL:
       source:
         provider: opensportslib
       params:
-        repo_id: /home/vorajv/X-VARS/weights/base_model_videoChatGPT
+        repo_id: OpenSportsLab/base_model_videoChatGPT
       overrides: {}
   metadata:
     backend: xvars_videochatgpt

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/core/config/accessors.py

@@ -194,6 +194,12 @@ def get_data_num_classes(cfg: Any, default: int = 0) -> int:
     if classes:
         return len(classes)
 
+    data = _as_dict(getattr(cfg, "DATA", None))
+    common = _as_dict(data.get("common"))
+    common_num_classes = common.get("num_classes")
+    if common_num_classes is not None:
+        return int(common_num_classes)
+
     input_cfg = get_input_cfg(cfg)
     params = _as_dict(input_cfg.get("params"))
     num_classes = params.get("num_classes")
@@ -222,8 +228,47 @@ def set_data_classes(cfg: Any, classes: list[str]) -> None:
     common = _ensure_child(data, "common")
     if isinstance(common, dict):
         common["classes"] = list(classes)
+        common["num_classes"] = len(classes)
     else:
         setattr(common, "classes", list(classes))
+        setattr(common, "num_classes", len(classes))
+
+
+def set_data_num_classes(cfg: Any, num_classes: int | None) -> None:
+    if num_classes is None:
+        return
+
+    data = getattr(cfg, "DATA", None)
+    if data is None:
+        data = SimpleNamespace()
+        setattr(cfg, "DATA", data)
+
+    common = _ensure_child(data, "common")
+    if isinstance(common, dict):
+        common["num_classes"] = int(num_classes)
+    else:
+        setattr(common, "num_classes", int(num_classes))
+
+
+def get_data_runtime(cfg: Any) -> dict[str, Any]:
+    data = _as_dict(getattr(cfg, "DATA", None))
+    common = _as_dict(data.get("common"))
+    runtime = _as_dict(common.get("runtime"))
+    return runtime
+
+
+def set_data_runtime_value(cfg: Any, key: str, value: Any) -> None:
+    data = getattr(cfg, "DATA", None)
+    if data is None:
+        data = SimpleNamespace()
+        setattr(cfg, "DATA", data)
+
+    common = _ensure_child(data, "common")
+    runtime = _ensure_child(common, "runtime")
+    if isinstance(runtime, dict):
+        runtime[key] = value
+    else:
+        setattr(runtime, key, value)
 
 
 def get_input_cfg(cfg: Any, input_name: str | None = None) -> dict[str, Any]:

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/core/trainer/classification_trainer.py

@@ -1219,6 +1219,11 @@ class Trainer_Classification:
             sid = item["id"]
             gt_label = item["labels"]["action"]["label"]
             if gt_label not in exclude_labels:
+                if gt_label not in label_to_idx:
+                    raise ValueError(
+                        "Ground-truth label is not present in the resolved inference class list: "
+                        f"{gt_label!r}."
+                    )
                 gt_dict[sid] = label_to_idx[gt_label]
 
         preds = []
@@ -1230,6 +1235,11 @@ class Trainer_Classification:
                 continue
 
             pred_label = item["labels"]["action"]["label"]
+            if pred_label not in label_to_idx:
+                raise ValueError(
+                    "Predicted label is not present in the resolved inference class list: "
+                    f"{pred_label!r}."
+                )
 
             preds.append(label_to_idx[pred_label])
             labels.append(gt_dict[sid])

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/core/utils/config.py

@@ -2,11 +2,20 @@ import os
 import re
 import json
 import gzip
+import logging
 try:
     import yaml
 except ModuleNotFoundError:  # pragma: no cover - runtime compatibility
     import yaml_compat as yaml
 
+from opensportslib.core.config.accessors import (
+    get_data_classes,
+    get_data_num_classes,
+    get_data_runtime,
+    set_data_classes,
+    set_data_num_classes,
+    set_data_runtime_value,
+)
 from opensportslib.core.config import (
     load_config as _load_config,
     load_config_omega as _load_config_omega,
@@ -225,6 +234,108 @@ def is_local_path(p):
     )
 
 
+def _extract_class_metadata(data_section):
+    if not isinstance(data_section, dict):
+        return None, None
+
+    common = data_section.get("common", {}) if isinstance(data_section.get("common", {}), dict) else {}
+    classes = common.get("classes")
+    if classes is not None:
+        classes = list(classes)
+
+    num_classes = common.get("num_classes")
+    if num_classes is None:
+        inputs = data_section.get("inputs", {})
+        if isinstance(inputs, dict):
+            for input_cfg in inputs.values():
+                if not isinstance(input_cfg, dict):
+                    continue
+                params = input_cfg.get("params", {})
+                if isinstance(params, dict) and params.get("num_classes") is not None:
+                    num_classes = params.get("num_classes")
+                    break
+
+    if num_classes is None and classes is not None:
+        num_classes = len(classes)
+
+    return classes, num_classes
+
+
+def _cache_pretrained_class_metadata(target_dict, loaded_dict):
+    if not isinstance(target_dict, dict) or not isinstance(loaded_dict, dict):
+        return
+
+    loaded_data = loaded_dict.get("DATA", {})
+    pretrained_classes, pretrained_num_classes = _extract_class_metadata(loaded_data)
+    if pretrained_classes is None and pretrained_num_classes is None:
+        return
+
+    data = target_dict.setdefault("DATA", {})
+    if not isinstance(data, dict):
+        return
+    common = data.setdefault("common", {})
+    if not isinstance(common, dict):
+        return
+    runtime = common.setdefault("runtime", {})
+    if not isinstance(runtime, dict):
+        return
+
+    if pretrained_classes is not None:
+        runtime["pretrained_classes"] = list(pretrained_classes)
+    if pretrained_num_classes is not None:
+        runtime["pretrained_num_classes"] = int(pretrained_num_classes)
+
+
+def resolve_inference_class_metadata(cfg):
+    runtime = get_data_runtime(cfg)
+    pretrained_classes = runtime.get("pretrained_classes")
+    pretrained_num_classes = runtime.get("pretrained_num_classes")
+
+    local_classes = get_data_classes(cfg)
+    local_num_classes = get_data_num_classes(cfg, default=0)
+
+    chosen_classes = None
+    chosen_num_classes = None
+    source = None
+
+    if pretrained_classes:
+        chosen_classes = list(pretrained_classes)
+        chosen_num_classes = len(chosen_classes)
+        source = "model"
+        if local_classes and list(local_classes) != chosen_classes:
+            logging.warning(
+                "Inference class mismatch: local config classes differ from pretrained model classes. "
+                "Using pretrained model classes."
+            )
+    elif pretrained_num_classes is not None:
+        chosen_num_classes = int(pretrained_num_classes)
+        source = "model"
+        if local_num_classes and int(local_num_classes) != chosen_num_classes:
+            logging.warning(
+                "Inference class-count mismatch: local config num_classes=%s, pretrained model num_classes=%s. "
+                "Using pretrained model class count.",
+                local_num_classes,
+                chosen_num_classes,
+            )
+    elif local_classes:
+        chosen_classes = list(local_classes)
+        chosen_num_classes = len(chosen_classes)
+        source = "local"
+    elif local_num_classes:
+        chosen_num_classes = int(local_num_classes)
+        source = "local"
+    else:
+        source = "annotation"
+
+    if chosen_classes is not None:
+        set_data_classes(cfg, chosen_classes)
+    if chosen_num_classes is not None:
+        set_data_num_classes(cfg, chosen_num_classes)
+    set_data_runtime_value(cfg, "inference_class_source", source)
+    set_data_runtime_value(cfg, "inference_model_classes_authoritative", source == "model")
+    return cfg
+
+
 def fetch_and_merge_config_from_HF(
     target_config, weights, hf_token=None, merge_policy="full"
 ):
@@ -275,6 +386,7 @@ def fetch_and_merge_config_from_HF(
         loaded_dict = namespace_to_dict(loaded_cfg)
 
         _warn_critical_config_conflicts(target_dict, loaded_dict)
+        _cache_pretrained_class_metadata(target_dict, loaded_dict)
 
         if merge_policy == "compatibility":
             # Keep local runtime config as source of truth. Pull only compatibility-
@@ -315,8 +427,6 @@ def fetch_and_merge_config_from_HF(
 
 
 def _warn_critical_config_conflicts(target_dict, loaded_dict):
-    import logging
-
     local_data = target_dict.get("DATA", {}) if isinstance(target_dict, dict) else {}
     hf_data = loaded_dict.get("DATA", {}) if isinstance(loaded_dict, dict) else {}
 
@@ -335,7 +445,7 @@ def _warn_critical_config_conflicts(target_dict, loaded_dict):
     ):
         logging.warning(
             "Config mismatch: DATA.num_classes local=%s hf=%s. "
-            "Keeping local runtime config values.",
+            "Inference may use pretrained model class metadata.",
             local_num_classes,
             hf_num_classes,
         )
@@ -355,9 +465,12 @@ def _warn_critical_config_conflicts(target_dict, loaded_dict):
     ):
         logging.warning(
             "Config mismatch: DATA.classes differs between local and HF config. "
-            "Keeping local runtime config values.",
+            "Inference may use pretrained model classes.",
         )
 
+
+fetch_and_merge_pretrained_config = fetch_and_merge_config_from_HF
+
 def save_config(config_obj, path):
     """Save the configuration object to a YAML file."""
     from omegaconf import DictConfig, OmegaConf

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/core/utils/hf_runtime.py

@@ -234,12 +234,16 @@ def has_peft_adapter_artifacts(adapter_path: str | None) -> bool:
 
 def load_peft_adapter_if_available(model, adapter_path: str | None):
     """Load a PEFT adapter into a model when real adapter artifacts exist."""
-    if not has_peft_adapter_artifacts(adapter_path):
+    if not adapter_path:
+        return model, "not_found"
+    is_local_dir = os.path.isdir(adapter_path)
+    if is_local_dir and not has_peft_adapter_artifacts(adapter_path):
         return model, "not_found"
     if not optional_package_available("peft"):
         logger.warning(
-            "PEFT adapter artifacts found but optional dependency 'peft' is not installed; "
-            "continuing with base decoder."
+            "PEFT adapter requested but optional dependency 'peft' is not installed; "
+            "continuing with base decoder. adapter_path=%s",
+            adapter_path,
         )
         return model, "missing_peft"
 

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/datasets/classification_dataset.py

@@ -13,6 +13,7 @@ label mapping, and class-weight computation.
 
 import os
 import random
+import logging
 
 import numpy as np
 import torch
@@ -27,16 +28,19 @@ from opensportslib.core.config.accessors import (
     get_component_provider_by_kind,
     get_data_classes,
     get_data_modality,
+    get_data_runtime,
     get_data_augmentations,
     get_data_params,
     get_data_sampling,
     set_data_classes,
+    set_data_num_classes,
     get_data_transform,
     get_split_source_path,
 )
 
 
 H5_TRACKING_MODALITIES = {"player_centroids_h5", "player_joints_h5", "tracking_h5"}
+logger = logging.getLogger(__name__)
 
 
 # -------------------------------------------------------------
@@ -145,14 +149,34 @@ class ClassificationDataset(Dataset):
 
         # invert to id -> name and propagate into the config so
         # downstream components (metrics, logging) can look it up.
-        self.label_map = {v: k for k, v in self.label_map.items()}
-        set_data_classes(self.config, list(self.label_map.values()))
+        annotation_label_map = {v: k for k, v in self.label_map.items()}
+        runtime = get_data_runtime(self.config)
+        inference_source = str(runtime.get("inference_class_source") or "").strip().lower()
+        configured_classes = list(get_data_classes(self.config))
+        configured_label_map = {idx: name for idx, name in enumerate(configured_classes)}
+
+        if split in {"test", "infer"} and inference_source in {"model", "local"} and configured_classes:
+            self.label_map = configured_label_map
+            set_data_num_classes(self.config, len(configured_classes))
+
+            annotation_classes = [annotation_label_map[idx] for idx in sorted(annotation_label_map.keys())]
+            if annotation_classes != configured_classes:
+                logger.warning(
+                    "Inference annotation labels differ from resolved %s classes. "
+                    "Using resolved runtime classes for predictions.",
+                    inference_source,
+                )
+                for sample in self.samples:
+                    sample.pop("label", None)
+            self.has_labels = len(self.samples) > 0 and "label" in self.samples[0]
+        else:
+            self.label_map = annotation_label_map
+            set_data_classes(self.config, list(self.label_map.values()))
+            self.has_labels = len(self.samples) > 0 and "label" in self.samples[0]
 
         print(len(get_data_classes(self.config)), "classes:", get_data_classes(self.config))
         print("Label Map : ", self.label_map)
 
-        self.has_labels = len(self.samples) > 0 and "label" in self.samples[0]
-
     # -- Sampling / loss weights ------------------------------------------
 
     def _normalized_label_tensor(self):

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/datasets/vqa_dataset.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import os
 import pickle
 import random
@@ -22,6 +23,8 @@ from opensportslib.core.config.accessors import (
 from opensportslib.models.utils.vqa_prediction_priors import build_prediction_prior_text
 from opensportslib.models.utils.xvars_clip_index import load_feature_index, load_prediction_index, validate_xvars_feature_tensor
 
+logger = logging.getLogger(__name__)
+
 
 class VQADataset(Dataset):
     """Flatten VQA annotations into single question-answer training samples."""
@@ -66,16 +69,18 @@ class VQADataset(Dataset):
         feature_source = get_vqa_feature_source(config, default="indexed")
         if not self.native_vl and feature_backend != "xvars_clip":
             raise ValueError(f"Unsupported VQA feature backend '{feature_backend}'. Expected 'xvars_clip'.")
-        require_feature_index = (not self.native_vl) and feature_source in {"indexed", ""}
-        if require_feature_index and not feature_index_path:
+        strict_feature_index = (not self.native_vl) and feature_source in {"indexed", ""}
+        fallback_feature_index = (not self.native_vl) and feature_source in {"indexed_or_raw", "indexed_or_raw_clip"}
+        if strict_feature_index and not feature_index_path:
             raise ValueError("Missing required config key DATA.common.feature_index for VQA xvars_clip mode.")
         self.feature_source = feature_source
         self.feature_mode = get_vqa_xvars_feature_mode(config, default="strict_xvars")
         self.expected_feature_tokens = get_xvars_train_video_token_len(config)
-        self.feature_index = (
-            load_feature_index(os.path.abspath(os.path.expanduser(feature_index_path)), split=split)
-            if feature_index_path
-            else {}
+        self.feature_index = self._load_feature_index(
+            feature_index_path,
+            split=split,
+            strict=strict_feature_index,
+            allow_missing=fallback_feature_index,
         )
         self.prediction_index = (
             load_prediction_index(os.path.abspath(os.path.expanduser(prediction_index_path)), split=split)
@@ -94,7 +99,7 @@ class VQADataset(Dataset):
             frame_paths = self._resolve_frame_paths(item, source_root)
 
             feature_candidates = self.feature_index.get(item_id_str, [])
-            if require_feature_index and not feature_candidates:
+            if strict_feature_index and not feature_candidates:
                 raise ValueError(
                     f"Missing feature index entry for sample id '{item_id_str}'. "
                     "Provide DATA.common.feature_index mapping with feature_paths or feature_dir/path."
@@ -136,6 +141,43 @@ class VQADataset(Dataset):
                     "Expected video_path, frame_paths, or video_frames."
                 )
 
+    def _load_feature_index(
+        self,
+        feature_index_path: str,
+        *,
+        split: str,
+        strict: bool,
+        allow_missing: bool,
+    ) -> dict[str, list[str]]:
+        if not feature_index_path:
+            return {}
+
+        resolved_path = os.path.abspath(os.path.expanduser(feature_index_path))
+        if allow_missing and not os.path.exists(resolved_path):
+            logger.warning(
+                "VQA feature index unavailable; falling back to raw-video extraction | "
+                "feature_source=%s | split=%s | feature_index=%s",
+                self.feature_source,
+                split,
+                resolved_path,
+            )
+            return {}
+
+        try:
+            return load_feature_index(resolved_path, split=split)
+        except Exception:
+            if strict or not allow_missing:
+                raise
+            logger.warning(
+                "VQA feature index unreadable; falling back to raw-video extraction | "
+                "feature_source=%s | split=%s | feature_index=%s",
+                self.feature_source,
+                split,
+                resolved_path,
+                exc_info=True,
+            )
+            return {}
+
     def __len__(self) -> int:
         return len(self.samples)
 

{opensportslib-0.3.0.dev7 → opensportslib-0.3.0.dev9}/opensportslib/models/base/qwen_xvars.py

@@ -482,7 +482,7 @@ class QwenXVarsModel(nn.Module):
                         self.raw_extractor = XVarsStrictRawVideoFeatureExtractor(
                             weights_path=self.vision_weights_path,
                             vision_tower=self.vision_tower_name,
-                            prefer_cuda=get_hf_prefer_cuda(config, hf_cfg),
+                            prefer_cuda=get_hf_prefer_cuda(self.config, hf_cfg),
                             start_frame=self.strict_sampling_cfg.get("start_frame"),
                             end_frame=self.strict_sampling_cfg.get("end_frame"),
                             input_fps=self.strict_sampling_cfg.get("input_fps"),
@@ -492,7 +492,7 @@ class QwenXVarsModel(nn.Module):
                     else:
                         self.raw_extractor = XVarsRawVideoFeatureExtractor(
                             vision_tower=self.vision_tower_name,
-                            prefer_cuda=get_hf_prefer_cuda(config, hf_cfg),
+                            prefer_cuda=get_hf_prefer_cuda(self.config, hf_cfg),
                         )
                 if isinstance(self.raw_extractor, XVarsStrictRawVideoFeatureExtractor):
                     features, classifier_prior = self.raw_extractor.extract_with_prior(video_path)