Download ai/sensor_model.py from m4az19/saef-api: direct link, hf CLI and curl.
- Browser
- Download file 7.35 kB
-
https://huggingface.co/spaces/m4az19/saef-api/resolve/main/ai/sensor_model.py
- Command line
-
hf download hf://spaces/m4az19/saef-api/ai/sensor_model.py
-
curl -L -o sensor_model.py https://huggingface.co/spaces/m4az19/saef-api/resolve/main/ai/sensor_model.py
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) | |