saef-api / ai /sensor_model.py
m4az19's picture
Deploy SAHAB-1 backend and pretrained AI
124816b verified
Raw History Blame Contribute Delete
7.35 kB
"""Legacy optional PCA research model. The no-training mission route is documented
in docs/START_HERE.md and firmware/pretrained; it does not deploy this bootstrap.
Eight-feature PCA linear autoencoder, exported as immutable float32 C++ arrays.
PCA is a fitted, rank-constrained reconstruction model, not a hand-written safety
threshold. Its residual threshold is fitted on held-out nominal sessions. No tensor
runtime or PSRAM is needed for 8->3->8 matrix operations.
"""
import json
import hashlib
from pathlib import Path
import numpy as np
ROOT=Path(__file__).resolve().parents[1]
FEATURE_VERSION='sensor-features-1'
FEATURES=['battery_voltage_v','solar_voltage_v','solar_current_a','temperature_c',
'ldr_fraction','accel_norm_g','gyro_norm_dps','battery_current_a']
def features(sensors):
values=[sensors.get(k) for k in FEATURES[:5]]
for key in ('accel_g','gyro_dps'):
v=sensors.get(key)
values.append(float(np.linalg.norm(v)) if v is not None and len(v)==3 else None)
values.append(sensors.get('battery_current_a'))
if any(v is None for v in values):return None
x=np.asarray(values,dtype=np.float32)
return x if np.isfinite(x).all() else None
def load(path=None):
return json.loads(Path(path or ROOT/'models'/'onboard'/'sensor_model.json').read_text())
def infer(sensors,model=None):
model=model or load();x=features(sensors)
base={'model_version':model['version'],'feature_version':FEATURE_VERSION,
'training_domain':model['training_domain'],'inference_us':None}
if x is None:return {**base,'status':'insufficient_inputs','score':None,'category':'unavailable'}
mean=np.asarray(model['mean'],np.float32);scale=np.asarray(model['scale'],np.float32)
basis=np.asarray(model['basis'],np.float32)
z=(x-mean)/scale;reconstruction=(z@basis.T)@basis
score=float(np.mean((z-reconstruction)**2))
return {**base,'status':'ok','score':score,'category':'anomaly' if score>model['threshold'] else 'nominal'}
def synthetic_sessions():
"""Deterministic engineering assumptions, not recorded or operational sensor data.
Solar current follows light, panel voltage has a daylight knee, temperature
lags illumination, battery voltage follows a charge/load cycle. A stationary
platform sees gravity and low gyro rates. Session variation uses deterministic
periodic perturbations; faults are separate, interpretable held-out injections.
"""
rows=[]
for session in range(12):
for step in range(240):
t=step/239;sun=max(0,np.sin(np.pi*t))
ldr=np.clip(sun+.015*np.sin(step*.71+session),0,1)
solar_i=.65*sun*(.95+.04*np.sin(session+step*.13))
load=.18+.05*np.sin(step*.09+session)**2
battery_i=load-solar_i*.8
row=dict(zip(FEATURES,[3.65+.45*sun+.03*np.sin(step*.07+session),
5.4*sun/(sun+.12) if sun else 0,solar_i,25+12*sun+.8*np.sin(step*.02+session),
ldr,1+.008*np.sin(step*.11+session),.35+.15*np.sin(step*.17+session)**2,battery_i]))
rows.append({'session_id':f'{session:06d}','timestamp':f'{session:02d}:{step:03d}',
'label':'normal',**row})
return rows
def train(rows,domain,rank=3):
sessions=sorted({r['session_id'] for r in rows})
if len(sessions)<6:raise ValueError('At least six independent chronological recording sessions required')
n=len(sessions);train_ids=set(sessions[:int(n*.6)]);val_ids=set(sessions[int(n*.6):int(n*.8)]);test_ids=set(sessions[int(n*.8):])
def matrix(ids):return np.asarray([[float(r[k]) for k in FEATURES] for r in rows if r['session_id'] in ids and r['label']=='normal'],dtype=np.float64)
a,b,c=matrix(train_ids),matrix(val_ids),matrix(test_ids)
if min(map(len,(a,b,c)))<20 or not all(np.isfinite(x).all() for x in (a,b,c)):
raise ValueError('Each split needs >=20 complete finite normal examples')
mean=a.mean(0);scale=np.maximum(a.std(0),1e-3)
_,_,v=np.linalg.svd((a-mean)/scale,full_matrices=False);basis=v[:rank]
# Canonical component signs make regeneration stable across LAPACK implementations.
for row in basis:
if row[np.argmax(abs(row))]<0:row*=-1
residual=lambda x:np.mean((((x-mean)/scale)-(((x-mean)/scale)@basis.T)@basis)**2,axis=1)
threshold=float(np.quantile(residual(b),.99))
checksum=hashlib.sha256(json.dumps(rows,sort_keys=True).encode()).hexdigest()
return {'version':'sensor-pca-1-'+domain+'-'+checksum[:8],'dataset_sha256':checksum,'feature_version':FEATURE_VERSION,'features':FEATURES,'rank':rank,
'training_domain':domain,'mean':mean.astype('float32').tolist(),'scale':scale.astype('float32').tolist(),
'basis':basis.astype('float32').tolist(),'threshold':threshold,
'evaluation':{'split_unit':'chronological session; no session crosses splits','train_sessions':sorted(train_ids),
'validation_sessions':sorted(val_ids),'test_sessions':sorted(test_ids),'train_samples':len(a),'validation_samples':len(b),'test_samples':len(c),
'test_normal_false_positive_fraction':float(np.mean(residual(c)>threshold)),
'scope':'Synthetic assumptions only; no hardware accuracy established' if domain=='synthetic_bootstrap' else 'Recorded sessions; deployment-domain coverage still requires review'},
'runtime':'Portable float32 C++ linear autoencoder; no external tensor runtime',
'parameter_bytes_float32':int((mean.size+scale.size+basis.size+1)*4),
'scratch_bytes_float32':int((8+rank+8)*4),
'limitations':['Incomplete inputs skip inference; no zero imputation','Stationary engineering bootstrap is not an orbital dynamics model',
'Residual is not a probability','Season, component tolerances and operating modes require real recordings',
'Independent safety limits remain separate from learned anomaly inference']}
def export(model,output,header):
output=Path(output);header=Path(header);output.parent.mkdir(parents=True,exist_ok=True);header.parent.mkdir(parents=True,exist_ok=True)
output.write_text(json.dumps(model,indent=2)+'\n')
literal=lambda x:f'{float(x):.9e}f'
array=lambda name,x:f'static constexpr float {name}[{len(x)}] = {{'+','.join(map(literal,x))+'};\n'
text='#pragma once\n// Generated by ai/train_sensor_model.py. Synthetic bootstrap is NOT validated hardware AI.\nnamespace sensor_model {\n'
text+=f'static constexpr const char* VERSION = "{model["version"]}";\n'
text+=f'static constexpr const char* DOMAIN = "{model["training_domain"]}";\n'
text+=f'static constexpr int N=8, R={model["rank"]};\n'
text+=array('MEAN',model['mean'])+array('SCALE',model['scale'])+array('BASIS',np.asarray(model['basis']).ravel())
text+=f'static constexpr float THRESHOLD={literal(model["threshold"])};\n}}\n'
# A nonzero reconstruction witness catches broken parameter/order exports on boot.
raw=np.asarray(model['mean'],np.float32).copy();raw[3]+=5
sample={k:float(raw[i]) for i,k in enumerate(FEATURES[:5])}
sample.update(accel_g=[0.,0.,float(raw[5])],gyro_dps=[0.,0.,float(raw[6])],battery_current_a=float(raw[7]))
text=text[:-2]+array('SELF_TEST_RAW',raw)+f'static constexpr float SELF_TEST_SCORE={literal(infer(sample,model)["score"])};\n}}\n'
header.write_text(text)