| """Digital surrogate studies for Iyeumaring M7 and M8. |
| |
| No measurements in this file are measurements of photonic/neuromorphic hardware. |
| Python elapsed times are host timings. Energy and accelerator latency are models. |
| Run: OPENBLAS_NUM_THREADS=1 python hardware_study.py --output . |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| from collections import deque |
| from dataclasses import dataclass, asdict |
| import json |
| from pathlib import Path |
| import platform |
| import time |
|
|
| import numpy as np |
|
|
|
|
| def ci(values, seed=941, samples=3000): |
| a = np.asarray(values, float) |
| rng = np.random.default_rng(seed) |
| b = a[rng.integers(len(a), size=(samples, len(a)))].mean(axis=1) |
| return {"mean": float(a.mean()), "median": float(np.median(a)), |
| "mean_ci95": [float(x) for x in np.quantile(b, [.025, .975])]} |
|
|
|
|
| def quantize(x, bits, low=-1.0, high=1.0): |
| levels = 2**bits - 1 |
| return np.round((np.clip(x, low, high)-low)/(high-low)*levels)/levels*(high-low)+low |
|
|
|
|
| def decompose_orthogonal(q): |
| """Real Givens decomposition; rotations are an abstract interferometer mesh. |
| |
| Logical all-to-all Givens connectivity is used, not a fabricated chip layout. |
| """ |
| a = np.asarray(q).copy() |
| rotations = [] |
| n = a.shape[0] |
| for j in range(n-1): |
| for i in range(n-1, j, -1): |
| theta = float(np.arctan2(a[i, j], a[j, j])) |
| c, s = np.cos(theta), np.sin(theta) |
| aj, ai = a[j].copy(), a[i].copy() |
| a[j], a[i] = c*aj+s*ai, -s*aj+c*ai |
| rotations.append((j, i, theta)) |
| return rotations, np.diag(a).copy() |
|
|
|
|
| def reconstruct_orthogonal(rotations, diagonal, phase_bits=None, drift_std=0., rng=None): |
| a = np.diag(diagonal) |
| for j, i, theta in reversed(rotations): |
| if phase_bits is not None: |
| theta = float(quantize(theta, phase_bits, -np.pi, np.pi)) |
| if drift_std: |
| theta += rng.normal(0., drift_std) |
| c, s = np.cos(theta), np.sin(theta) |
| aj, ai = a[j].copy(), a[i].copy() |
| a[j], a[i] = c*aj-s*ai, s*aj+c*ai |
| return a |
|
|
|
|
| def photonic_surrogate(seeds=range(12), inputs=256, m=64, n=32): |
| """Program W=U Sigma Vt, with angle/DAC/ADC quantization and readout noise.""" |
| rows = [] |
| for seed in seeds: |
| rng = np.random.default_rng(50000+seed) |
| w = rng.normal(size=(m,n)) |
| u, s, vt = np.linalg.svd(w, full_matrices=True) |
| s /= s.max() |
| sig = np.zeros((m,n)); sig[np.arange(n),np.arange(n)] = s |
| w = u@sig@vt |
| ru, du = decompose_orthogonal(u) |
| rv, dv = decompose_orthogonal(vt) |
| x = rng.normal(size=(n,inputs)); x /= np.linalg.norm(x,axis=0) |
| exact = w@x |
| exact_top = np.argmax(exact,axis=0) |
| margin = np.sort(exact,axis=0)[-1]-np.sort(exact,axis=0)[-2] |
| for bits, drift, read_std in [(6,.0005,.002),(8,.0005,.002),(10,.0005,.002),(8,.005,.01)]: |
| |
| |
| hrng = np.random.default_rng(100000+seed*100+bits+int(drift*1e6)) |
| uq = reconstruct_orthogonal(ru,du,bits,drift,hrng) |
| vq = reconstruct_orthogonal(rv,dv,bits,drift,hrng) |
| sq = quantize(s,8,0,1) |
| sigq = np.zeros((m,n)); sigq[np.arange(n),np.arange(n)]=sq |
| effective_w = uq@sigq@vq |
| noisy = effective_w@quantize(x,8) |
| |
| noisy += hrng.normal(0,read_std,size=noisy.shape) |
| adc_saturated_inputs = np.any(np.abs(noisy)>1.,axis=0) |
| noisy = quantize(noisy,8) |
| err = np.max(np.abs(noisy-exact),axis=0) |
| top = np.argmax(noisy,axis=0) |
| |
| |
| certified = margin > 2*err |
| |
| |
| |
| alpha = 1e-3 |
| matrix_error = np.linalg.norm(effective_w-w,axis=1)[:,None]*np.linalg.norm(x,axis=0)[None,:] |
| dac_error = np.abs(effective_w).sum(axis=1)[:,None]/255 |
| noise_envelope = read_std*np.sqrt(2*np.log(2*m*inputs/alpha)) |
| bound = matrix_error+dac_error+noise_envelope+1/255 |
| upper = noisy+bound |
| selected_lower = (noisy-bound)[top,np.arange(inputs)] |
| upper[top,np.arange(inputs)] = -np.inf |
| calibrated_certified = (selected_lower > upper.max(axis=0)) & ~adc_saturated_inputs |
| order = np.argsort(noisy,axis=0)[-4:] |
| top4 = np.any(order == exact_top[None,:],axis=0) |
| rows.append({"seed":seed,"phase_bits":bits,"drift_std_rad":drift, |
| "readout_std_normalized":read_std,"top1_agreement":float(np.mean(top==exact_top)), |
| "top4_recall":float(np.mean(top4)), |
| "relative_rmse":float(np.linalg.norm(noisy-exact)/np.linalg.norm(exact)), |
| "certified_fraction":float(np.mean(certified)), |
| "certificate_errors":int(np.sum(certified&(top!=exact_top))), |
| "calibrated_certified_fraction":float(np.mean(calibrated_certified)), |
| "calibrated_certificate_errors":int(np.sum(calibrated_certified&(top!=exact_top))), |
| "adc_saturated_inputs":int(adc_saturated_inputs.sum()), |
| "median_score_gap":float(np.median(margin))}) |
| groups=[] |
| for bits,drift,noise in [(6,.0005,.002),(8,.0005,.002),(10,.0005,.002),(8,.005,.01)]: |
| sel=[r for r in rows if r['phase_bits']==bits and r['drift_std_rad']==drift] |
| groups.append({"phase_bits":bits,"drift_std_rad":drift,"readout_std_normalized":noise, |
| **{k:ci([r[k] for r in sel]) for k in ['top1_agreement','top4_recall','relative_rmse','certified_fraction','calibrated_certified_fraction']}, |
| "certificate_errors":sum(r['certificate_errors'] for r in sel), |
| "calibrated_certificate_errors":sum(r['calibrated_certificate_errors'] for r in sel)}) |
| return {"dimensions":[m,n],"inputs_per_seed":inputs,"seeds":list(seeds), |
| "rows":rows,"summary":groups, |
| "certificate_note":"certified_fraction uses exact-reference error and is only a posteriori. calibrated_certified_fraction uses matrix perturbation/DAC/ADC bounds and a Gaussian union bound alpha=0.001 per 256-input block, conditional on exact calibration of the effective matrix; real calibration uncertainty must be added."} |
|
|
|
|
| @dataclass |
| class CostAssumptions: |
| digital_mac_per_second: float = 1e13 |
| digital_energy_per_mac_J: float = .5e-12 |
| digital_control_static_W: float = .5 |
| host_launch_s: float = 50e-9 |
| host_batch: int = 1024 |
| interface_s: float = 5e-9 |
| dac_s: float = 1e-9 |
| optical_propagation_s: float = .1e-9 |
| adc_s: float = 2e-9 |
| phase_program_s: float = 50e-6 |
| phase_program_energy_each_J: float = 1e-9 |
| calibration_s: float = 100e-6 |
| calibration_every_vectors: int = 100000 |
| calibration_energy_J: float = 10e-6 |
| dac_energy_each_J: float = 2e-12 |
| adc_energy_each_J: float = 5e-12 |
| io_energy_each_J: float = 2e-12 |
| memory_energy_each_J: float = 2e-12 |
| control_static_W: float = .5 |
| thermo_phase_static_each_W: float = .005 |
| low_static_phase_each_W: float = 1e-6 |
| photons_per_output: int = 100000 |
| wavelength_m: float = 1550e-9 |
| laser_wall_plug_efficiency: float = .2 |
| local_oscillator_multiplier: float = 10. |
| fixed_loss_dB: float = 6. |
| loss_per_mesh_stage_dB: float = .03 |
| memory_bandwidth_B_per_s: float = 512e9 |
|
|
|
|
| def hardware_costs(a=CostAssumptions()): |
| """Scenario calculation, NOT a hardware benchmark. All inputs explicit.""" |
| rows=[] |
| for m,n in [(64,32),(128,128),(512,512)]: |
| phases=(m*(m-1)+n*(n-1))//2 |
| loss_db=a.fixed_loss_dB+a.loss_per_mesh_stage_dB*(m+n) |
| eta=10**(-loss_db/10) |
| photon_energy=6.62607015e-34*299792458/a.wavelength_m |
| laser=a.photons_per_output*m*photon_energy*a.local_oscillator_multiplier/(eta*a.laser_wall_plug_efficiency) |
| for reuse in [100,10000,1000000]: |
| launch=a.host_launch_s/a.host_batch |
| memtime=2*(m*n/reuse+m+n)/a.memory_bandwidth_B_per_s |
| td=launch+max(m*n/a.digital_mac_per_second,memtime) |
| ed=(m*n*a.digital_energy_per_mac_J+m*n/reuse*a.memory_energy_each_J+ |
| (m+n)*a.io_energy_each_J+a.digital_control_static_W*td) |
| for mode,perphase in [('thermo_optic',a.thermo_phase_static_each_W),('low_static_hypothesis',a.low_static_phase_each_W)]: |
| po=a.control_static_W+phases*perphase |
| to=(launch+a.interface_s+a.dac_s+a.optical_propagation_s+a.adc_s+ |
| a.phase_program_s/reuse+a.calibration_s/a.calibration_every_vectors) |
| eo=(laser+n*a.dac_energy_each_J+m*a.adc_energy_each_J+po*to+ |
| phases*a.phase_program_energy_each_J/reuse+ |
| a.calibration_energy_J/a.calibration_every_vectors+ |
| (m+n)*a.io_energy_each_J) |
| rows.append({"shape":[m,n],"weight_reuse":reuse,"phase_mode":mode, |
| "phase_count":phases,"loss_dB":loss_db,"static_power_W":po, |
| "within_50W_static_envelope":po<=50, |
| "digital_time_ns":td*1e9,"optical_time_ns":to*1e9, |
| "modeled_speed_ratio_digital_over_optical":td/to, |
| "digital_energy_nJ":ed*1e9,"optical_energy_nJ":eo*1e9, |
| "modeled_energy_ratio_digital_over_optical":ed/eo}) |
| return {"status":"analytical scenario; assumptions not measurements or vendor specifications", |
| "assumptions":asdict(a),"rows":rows, |
| "omissions":["routing-layout feasibility","fan-out and wavelength-specific crosstalk", |
| "laser relative-intensity noise spectral model","full chip heat transport", |
| "nonlinear activation and optimizer cost","hardware-specific host synchronization"], |
| "loss_note":"Losses are scenario input, not a layout-extracted result. Effective loss is compensated in the ranking simulation; resulting readout noise is an independent normalized input."} |
|
|
|
|
| def delayed_data(seed,k,train=12000,test=3000,horizon=12,rho=.9): |
| rng=np.random.default_rng(200000+seed) |
| ids=rng.integers(k,size=train+test) |
| amplitudes=rng.choice([-1.,1.],size=train+test) |
| theta=rng.normal(size=k) |
| rewards=np.zeros(train+test) |
| hist=deque() |
| for t,(idx,amp) in enumerate(zip(ids,amplitudes)): |
| hist.append((t,int(idx),amp)) |
| if len(hist)>horizon:hist.popleft() |
| rewards[t]=sum((rho**(t-ti))*v*theta[j] for ti,j,v in hist)+rng.normal(0,.1) |
| return ids,amplitudes,rewards,theta,train |
|
|
|
|
| def dense_trace(ids,amplitudes,rewards,k,train,horizon=12,rho=.9,lr=.035): |
| w=np.zeros(k);e=np.zeros(k);errors=[] |
| start=time.perf_counter() |
| for t,(idx,amp,reward) in enumerate(zip(ids,amplitudes,rewards)): |
| e*=rho;e[idx]+=amp |
| if t>=horizon:e[ids[t-horizon]]-=rho**horizon*amplitudes[t-horizon] |
| delta=reward-w@e |
| if t<train:w+=lr*delta*e |
| else:errors.append(delta**2) |
| return w,np.asarray(errors),time.perf_counter()-start |
|
|
|
|
| def sparse_trace(ids,amplitudes,rewards,k,train,horizon=12,rho=.9,lr=.035): |
| w=np.zeros(k);e={};counts={};errors=[];max_active=0;active_sum=0 |
| start=time.perf_counter() |
| for t,(idx,amp,reward) in enumerate(zip(ids,amplitudes,rewards)): |
| idx=int(idx) |
| for j in e:e[j]*=rho |
| e[idx]=e.get(idx,0.)+amp;counts[idx]=counts.get(idx,0)+1 |
| if t>=horizon: |
| old=int(ids[t-horizon]);counts[old]-=1 |
| if counts[old]==0:del e[old];del counts[old] |
| else:e[old]-=rho**horizon*amplitudes[t-horizon] |
| delta=reward-sum(w[j]*v for j,v in e.items()) |
| if t<train: |
| for j,v in e.items():w[j]+=lr*delta*v |
| else:errors.append(delta**2) |
| max_active=max(max_active,len(e));active_sum+=len(e) |
| return w,np.asarray(errors),time.perf_counter()-start,max_active,active_sum/len(ids) |
|
|
|
|
| def immediate_bandit(ids,amplitudes,rewards,k,train,lr=.035): |
| w=np.zeros(k);errors=[] |
| start=time.perf_counter() |
| for t,(idx,amp,reward) in enumerate(zip(ids,amplitudes,rewards)): |
| delta=reward-w[idx]*amp |
| if t<train:w[idx]+=lr*delta*amp |
| else:errors.append(delta**2) |
| return w,np.asarray(errors),time.perf_counter()-start |
|
|
|
|
| def neuromorphic_study(seeds=range(8),dimensions=(256,4096,16384),train=12000,test=3000): |
| rows=[] |
| for k in dimensions: |
| for seed in seeds: |
| ids,amps,r,theta,nt=delayed_data(seed,k,train,test) |
| |
| if seed%2: |
| ws,es,ts,ma,aa=sparse_trace(ids,amps,r,k,nt) |
| wd,ed,td=dense_trace(ids,amps,r,k,nt) |
| else: |
| wd,ed,td=dense_trace(ids,amps,r,k,nt) |
| ws,es,ts,ma,aa=sparse_trace(ids,amps,r,k,nt) |
| wb,eb,tb=immediate_bandit(ids,amps,r,k,nt) |
| rows.append({"seed":seed,"candidate_fragments":k,"dense_trace_mse":float(ed.mean()), |
| "sparse_trace_mse":float(es.mean()),"immediate_bandit_mse":float(eb.mean()), |
| "dense_host_seconds":td,"sparse_host_seconds":ts,"immediate_host_seconds":tb, |
| "dense_over_sparse_host_speed_ratio":td/ts, |
| "max_weight_difference":float(np.max(np.abs(wd-ws))), |
| "max_squared_error_difference":float(np.max(np.abs(ed-es))), |
| "max_active_traces":ma,"mean_active_traces":aa, |
| "approx_trace_touch_ratio_dense_over_sparse":k/aa, |
| "dense_trace_storage_float64_bytes":8*k, |
| "sparse_trace_payload_float64_bytes":8*ma, |
| "weight_storage_float64_bytes_both":8*k}) |
| summary=[] |
| for k in dimensions: |
| sel=[r for r in rows if r['candidate_fragments']==k] |
| summary.append({"candidate_fragments":k, |
| **{key:ci([r[key] for r in sel]) for key in ['dense_trace_mse','sparse_trace_mse','immediate_bandit_mse','dense_over_sparse_host_speed_ratio','approx_trace_touch_ratio_dense_over_sparse']}, |
| "max_weight_difference":max(r['max_weight_difference'] for r in sel), |
| "max_squared_error_difference":max(r['max_squared_error_difference'] for r in sel)}) |
| return {"seeds":list(seeds),"train_events":train,"test_events":test,"horizon":12,"rho":.9, |
| "learning_rate":.035,"reward_noise_std":.1,"rows":rows,"summary":summary, |
| "baseline_note":"Dense and sparse are mathematically identical finite-horizon eligibility regression. Immediate bandit deliberately lacks delayed features and is a diagnostic baseline, not a competitive delayed-credit algorithm. No e-prop or BrainTrace reproduction is claimed."} |
|
|
|
|
| def self_tests(): |
| rng=np.random.default_rng(123) |
| q,_=np.linalg.qr(rng.normal(size=(13,13))) |
| rotations,diagonal=decompose_orthogonal(q) |
| qr=reconstruct_orthogonal(rotations,diagonal) |
| assert np.max(np.abs(q-qr))<1e-12 |
| assert np.max(np.abs(qr.T@qr-np.eye(13)))<1e-12 |
| ids,amps,r,_,nt=delayed_data(100,31,train=300,test=100) |
| wd,ed,_=dense_trace(ids,amps,r,31,nt) |
| ws,es,_,ma,_=sparse_trace(ids,amps,r,31,nt) |
| assert np.max(np.abs(wd-ws))<1e-12 |
| assert np.max(np.abs(ed-es))<1e-11 |
| assert ma<=12 |
| costs=hardware_costs() |
| assert all(r['digital_time_ns']>0 and r['optical_time_ns']>0 and r['optical_energy_nJ']>0 for r in costs['rows']) |
| return {"checks_passed":5,"max_mesh_reconstruction_error":float(np.max(np.abs(q-qr))), |
| "max_trace_weight_error":float(np.max(np.abs(wd-ws)))} |
|
|
|
|
| def main(): |
| p=argparse.ArgumentParser();p.add_argument('--output',default='.');p.add_argument('--quick',action='store_true') |
| args=p.parse_args();out=Path(args.output);out.mkdir(parents=True,exist_ok=True) |
| start=time.perf_counter() |
| tests=self_tests() |
| results={"environment":{"python":platform.python_version(),"numpy":np.__version__,"platform":platform.platform()}, |
| "self_tests":tests,"photonic":photonic_surrogate(seeds=range(3) if args.quick else range(12)), |
| "hardware_cost_model":hardware_costs(), |
| "neuromorphic":neuromorphic_study(seeds=range(2) if args.quick else range(8),train=2000 if args.quick else 12000,test=500 if args.quick else 3000)} |
| results['study_host_seconds']=time.perf_counter()-start |
| (out/'hardware_results.json').write_text(json.dumps(results,indent=2)) |
| print(json.dumps({"self_tests":tests,"photonic_summary":results['photonic']['summary'], |
| "neuromorphic_summary":results['neuromorphic']['summary'],"study_host_seconds":results['study_host_seconds']},indent=2)) |
|
|
|
|
| if __name__=='__main__':main() |
|
|
