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.
78 lines
3.4 KiB
Python
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)
|