Update NetVLAD checkpoint paths and enhance .gitignore

- Changed paths in documentation and configuration files to reflect the new naming convention for the NetVLAD model, transitioning from `models/netvlad/netvlad.pt` to `models/net_vlad/net_vlad.pt`.
- Updated the `.gitignore` to include additional file types and directories related to input data and locally-generated evidence frames.
- Removed the old NetVLAD checkpoint file as part of the transition to the new naming scheme.

These changes ensure consistency across the project and improve the management of generated files.

tests/e2e/replay/conftest.py

@@ -608,15 +608,7 @@ def _build_replay_backbone_embedder(
             "DINOv2-VPR or NetVLAD per AZ-321)."
         )
 
-    host = HostCapabilities(
-        gpu_name="replay-e2e",
-        cuda_compute_capability=(0, 0),
-        cuda_runtime_version="0.0",
-        tensorrt_version="0.0",
-        host_arch="unknown",
-        host_os="linux",
-        driver_version="unknown",
-    )
+    host = HostCapabilities(sm=87, jetpack="6.2", trt="10.3")
     engine_cache_root = cache_root / "engines"
     engine_cache_root.mkdir(parents=True, exist_ok=True)
     request = EngineCompileRequest(
@@ -638,8 +630,14 @@ def _build_replay_backbone_embedder(
     first = results[0]
     spec = backbones[0]
     inference_runtime = build_inference_runtime(config)
-    engine_handle = inference_runtime.deserialize_engine(first.entry)
     descriptor_dim = _resolve_replay_descriptor_dim(config, spec)
+    # The c10 engine compiler treats backbones generically and does not
+    # know about c2_vpr's architecture registry. The c2_vpr factory
+    # would do this registration on its own create() path, but this
+    # fixture bypasses build_vpr_strategy. Register the strategy's
+    # NN architecture here so deserialize_engine can find it.
+    _register_replay_strategy_architecture(config, descriptor_dim)
+    engine_handle = inference_runtime.deserialize_engine(first.entry)
     return C7EngineBackboneEmbedder(
         inference_runtime=inference_runtime,
         engine_handle=engine_handle,
@@ -651,6 +649,33 @@ def _build_replay_backbone_embedder(
     )
 
 
+def _register_replay_strategy_architecture(
+    config: Any, descriptor_dim: int
+) -> None:
+    """Register c2_vpr's NN architecture with c7's registry.
+
+    Production runs go through ``vpr_factory.build_vpr_strategy`` which
+    invokes ``_register_strategy_architecture`` as a side effect before
+    the strategy is bound. The AZ-839 fixture pre-builds engines via
+    c10 directly (the operator pre-flight cache responsibility) and
+    skips ``build_vpr_strategy``, so the registration would never run.
+    Without this, ``InferenceRuntime.deserialize_engine`` raises
+    ``EngineDeserializeError: No architecture registered for
+    model_name='net_vlad'`` when looking up the factory by file stem.
+    """
+    block = config.components.get("c2_vpr") if config.components else None
+    strategy = getattr(block, "strategy", None) if block is not None else None
+    if strategy != "net_vlad":
+        return  # other strategies handle their own registration / no-op
+    from gps_denied_onboard.components.c2_vpr.net_vlad import (
+        MODEL_NAME,
+        architecture_factory,
+    )
+    from gps_denied_onboard.components.c7_inference import register_architecture
+
+    register_architecture(MODEL_NAME, architecture_factory(descriptor_dim))
+
+
 def _resolve_replay_descriptor_dim(config: Any, spec: Any) -> int:
     """Resolve the descriptor output dimension for the AZ-839 NetVLAD baseline.
 

tests/unit/c10_provisioning/test_az965_config_coercion.py

@@ -0,0 +1,109 @@
+"""AZ-965 — `C10ProvisioningConfig` coerces YAML-shaped backbones to dataclasses.
+
+YAML loaders (`config/loader.py::_replace_block` → `dataclasses.replace`)
+pass `backbones` as `list[dict]` because the generic loader path does
+not recursively construct nested dataclasses inside list/tuple fields.
+`C10ProvisioningConfig.__post_init__` must coerce each dict entry to a
+proper :class:`BackboneConfig` instance before downstream consumers
+iterate `backbone.model_name`. Similarly, `BackboneConfig.__post_init__`
+must coerce `expected_input_shape: list[int]` to `tuple[int, ...]`
+because PyYAML loads `[3, 480, 480]` as a list.
+"""
+
+from __future__ import annotations
+
+from gps_denied_onboard.components.c10_provisioning.config import (
+    BackboneConfig,
+    C10ProvisioningConfig,
+)
+
+
+def test_c10_provisioning_coerces_list_of_dicts_to_backbone_configs() -> None:
+    # Arrange — what the YAML loader produces for c10_provisioning.backbones
+    yaml_shaped_backbones = [
+        {
+            "model_name": "net_vlad",
+            "onnx_path": "/opt/models/net_vlad/net_vlad.pt",
+            "expected_input_shape": [3, 480, 480],
+            "input_name": "input",
+        },
+    ]
+
+    # Act
+    config = C10ProvisioningConfig(backbones=yaml_shaped_backbones)
+
+    # Assert
+    assert len(config.backbones) == 1
+    assert isinstance(config.backbones, tuple)
+    only = config.backbones[0]
+    assert isinstance(only, BackboneConfig)
+    assert only.model_name == "net_vlad"
+    assert only.onnx_path == "/opt/models/net_vlad/net_vlad.pt"
+    assert only.expected_input_shape == (3, 480, 480)
+    assert isinstance(only.expected_input_shape, tuple)
+    assert only.input_name == "input"
+
+
+def test_backbone_config_coerces_list_input_shape_to_tuple() -> None:
+    # Act
+    backbone = BackboneConfig(
+        model_name="net_vlad",
+        onnx_path="/opt/models/net_vlad/net_vlad.pt",
+        expected_input_shape=[3, 480, 480],  # type: ignore[arg-type]
+        input_name="input",
+    )
+
+    # Assert
+    assert isinstance(backbone.expected_input_shape, tuple)
+    assert backbone.expected_input_shape == (3, 480, 480)
+
+
+def test_c10_provisioning_passes_through_existing_backbone_configs() -> None:
+    # Arrange
+    existing = BackboneConfig(
+        model_name="net_vlad",
+        onnx_path="/opt/models/net_vlad/net_vlad.pt",
+        expected_input_shape=(3, 480, 480),
+        input_name="input",
+    )
+
+    # Act — coercion path must be idempotent for already-typed inputs
+    config = C10ProvisioningConfig(backbones=(existing,))
+
+    # Assert
+    assert config.backbones == (existing,)
+    assert config.backbones[0] is existing
+
+
+def test_c10_provisioning_coerces_mixed_dict_and_dataclass_entries() -> None:
+    # Arrange — partial migration shape (defensive)
+    existing = BackboneConfig(
+        model_name="ultra_vpr",
+        onnx_path="/opt/models/ultra_vpr/ultra_vpr.onnx",
+        expected_input_shape=(3, 224, 224),
+        input_name="input",
+    )
+    yaml_shaped = {
+        "model_name": "net_vlad",
+        "onnx_path": "/opt/models/net_vlad/net_vlad.pt",
+        "expected_input_shape": [3, 480, 480],
+        "input_name": "input",
+    }
+
+    # Act
+    config = C10ProvisioningConfig(backbones=[existing, yaml_shaped])
+
+    # Assert
+    assert len(config.backbones) == 2
+    assert config.backbones[0] is existing
+    assert isinstance(config.backbones[1], BackboneConfig)
+    assert config.backbones[1].model_name == "net_vlad"
+
+
+def test_c10_provisioning_empty_backbones_remains_empty_tuple() -> None:
+    # Act
+    config = C10ProvisioningConfig()
+
+    # Assert
+    assert config.backbones == ()
+    assert isinstance(config.backbones, tuple)