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/inspection_startup.py

85 lines
4.0 KiB
Python

"""Opt-in server entry point for UNKNOWN using locally pinned PyTorch weights."""
import asyncio
import hashlib
from pathlib import Path
import time
from . import config, state, visual_control
from .inspection_bridge import InspectionBridge
from .inspection_handoff import Handoff, configure
from .model_class_contract import normalize_names, validate_contract
from .unknown_inspection import Settings
def _file_sha(path):
with path.open('rb') as file:
return hashlib.file_digest(file, 'sha256').hexdigest()
def _load_model(yolo, path, expected, role):
path = Path(path)
if not path.is_absolute() or path.suffix.lower() != '.pt' or not path.is_file():
raise ValueError(f'{role} requires an absolute local .pt checkpoint')
digest = _file_sha(path)
if digest != expected:
raise ValueError(f'{role} checkpoint SHA mismatch')
model = yolo(str(path)) # Read task from the checkpoint, never force it.
if _file_sha(path) != digest:
raise ValueError(f'{role} checkpoint changed while loading')
return model, validate_contract(path, digest, expected, model.names, role=role,
metadata_source='loaded_model.names', actual_task=model.task)
class ServerInspection(Handoff):
def __init__(self, bridge, detector, classifier, *, authorize):
super().__init__(bridge, camera_epoch=lambda camera: id(config.CAMERA_CONFIG.get(camera)),
latest_visual=visual_control.latest, authorize=authorize)
self.detector = detector
self.classifier = classifier
def detect(self, frames):
return self.detector(frames, verbose=False, conf=self.bridge.settings.proposal_min,
imgsz=int(config.INFER_IMGSZ), max_det=64)
def classify(self, crop):
result, = self.classifier(crop, verbose=False)
names = normalize_names(result.names)
if names != self.bridge.classifier.names:
raise ValueError('Classifier output labels differ from the loaded checkpoint')
scores = result.probs.data.detach().cpu().tolist()
if len(scores) != len(names):
raise ValueError('Classifier output count differs from the loaded checkpoint')
return tuple(zip(names, scores))
async def recognition_loop(self):
while True:
if not await asyncio.to_thread(self.bridge.crops.run_one, self.classify, clock=time.monotonic):
await asyncio.sleep(.01)
def configure_runtime():
from ultralytics import YOLO
from .postprocess import _inspection_alarm_ready, postprocess_control
settings = getattr(config, 'UNKNOWN_INSPECTION_SETTINGS', None)
cameras = tuple(getattr(config, 'UNKNOWN_INSPECTION_CAMERAS', ()))
authorize = getattr(config, 'UNKNOWN_INSPECTION_AUTHORIZE', None)
quality = getattr(config, 'UNKNOWN_INSPECTION_OCCLUDED', None)
if (not isinstance(settings, Settings) or not settings.enabled or not visual_control.enabled()
or not cameras or len(set(cameras)) != len(cameras)
or not set(cameras) <= set(config.PTZ_CAM_IDS)
or not callable(authorize) or not callable(quality)):
raise RuntimeError('UNKNOWN requires calibrated settings, PTZ allowlist, authorization and quality providers')
detector, proposal = _load_model(YOLO, config.UNKNOWN_INSPECTION_PROPOSAL_PATH,
settings.proposal_sha, 'generic_detector')
classifier, semantics = _load_model(YOLO, config.UNKNOWN_INSPECTION_CLASSIFIER_PATH,
settings.classifier_sha, 'semantic_classifier')
bridge = InspectionBridge(settings=settings, cameras=cameras, proposal_contract=proposal,
classifier_contract=semantics, owner=visual_control.owner, control_lock=visual_control.control_lock,
controller=postprocess_control, alarm_ready=_inspection_alarm_ready,
state_provider=lambda camera: state.ptz_states.get(camera, {}), clock=time.monotonic,
quality=quality)
handoff = ServerInspection(bridge, detector, classifier, authorize=authorize)
configure(handoff)
return handoff