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.
85 lines
4.0 KiB
Python
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
|