You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Chameleon/ptz_tracker_modular/model_class_contract.py

78 lines
3.4 KiB
Python

"""Pure metadata validation; this module does not load/deserialize model files."""
import ast
from dataclasses import dataclass
from pathlib import PurePath
from .alarm_eligibility import NAMES, sha
@dataclass(frozen=True)
class ModelContract:
sha256: str
suffix: str
names: tuple
role: str
metadata_source: str
task: str = ''
def normalize_names(raw):
if isinstance(raw, str):
if len(raw) > 4096:
raise ValueError('Excessive names metadata')
try:
tree = ast.parse(raw, mode='eval')
if isinstance(tree.body, ast.Dict):
keys = [ast.literal_eval(k) for k in tree.body.keys]
if len(set(keys)) != len(keys):
raise ValueError('Duplicate literal class IDs')
raw = ast.literal_eval(tree)
except (ValueError, SyntaxError, MemoryError, RecursionError) as exc:
raise ValueError('Invalid literal names metadata') from exc
if type(raw) in (list, tuple):
pairs = list(enumerate(raw))
elif type(raw) is dict:
pairs = []
for key, value in raw.items():
if type(key) is int:
index = key
elif type(key) is str and key.isdecimal() and str(int(key)) == key:
index = int(key)
else:
raise ValueError('Ambiguous class ID')
pairs.append((index, value))
else:
raise ValueError('Missing names metadata')
ids = [i for i, _ in pairs]
if (not pairs or len(set(ids)) != len(ids) or set(ids) != set(range(len(ids)))
or any(type(v) is not str or not v.strip() or v != v.strip() for _, v in pairs)):
raise ValueError('Non-contiguous/duplicate IDs or invalid labels')
names = tuple(v for _, v in sorted(pairs))
if len(set(names)) != len(names):
raise ValueError('Duplicate class labels')
return names
def validate_contract(path, actual_sha, expected_sha, raw_names, *, role, metadata_source, actual_task=None):
suffix = PurePath(path).suffix.lower()
supported = {'.pt': {'loaded_model.names', 'result.names'},
'.pth': {'loaded_model.names', 'result.names'},
'.onnx': {'onnx.metadata.names', 'result.names'},
'.engine': {'result.names'}}
if suffix not in supported or metadata_source not in supported[suffix]:
raise ValueError('Unsupported format or unverified metadata source')
if not sha(actual_sha) or actual_sha != expected_sha:
raise ValueError('Loaded artifact hash is not pinned')
expected_task = 'classify' if role == 'semantic_classifier' else 'detect'
if actual_task != expected_task:
raise ValueError('Model task must be independently verified, not inferred from class names')
names = normalize_names(raw_names)
if role == 'generic_detector' and names != ('airborne_object',):
raise ValueError('Generic detector must expose airborne_object only')
elif role == 'semantic_classifier' and set(names) != NAMES:
raise ValueError('Classifier must expose exactly the four reviewed semantic labels')
elif role not in ('generic_detector', 'semantic_classifier', 'legacy_display'):
raise ValueError('Unsupported model role')
# legacy_display preserves Fighter/drone numeric names; never upgrades their
# meaning to fixedwing_uav or to permission for unknown-object alarms.
return ModelContract(actual_sha, suffix, names, role, metadata_source, actual_task)