File size: 5,471 Bytes
32d1b4a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | """Exact CSS marginals, with soft conditioning on the complementary syndrome."""
import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
os.environ['OPENBLAS_NUM_THREADS']='1'
from pathlib import Path
import collections,time
import numpy as np
import stim
import jax
import jax.numpy as jnp
from exact import parse_errors,make_plan,make_decoder,make_marginals_fb
def save_state(path,state):
flat={k:v for k,v in state.items() if k not in ['on','off']}
for which in ['on','off']:
flat.update({which+'__'+k:v for k,v in state[which].items()})
np.savez(path,**flat)
def load_state(path):
flat=dict(np.load(path,allow_pickle=False));state={'on':{},'off':{}}
for k,v in flat.items():
if '__' in k:
which,key=k.split('__',1);state[which][key]=v
else:state[k]=v
return state
def build(dem):
coords=dem.get_detector_coordinates()
first={tuple(c[:2]) for c in coords.values() if c[-1]==0}
on=[d for d,c in coords.items() if tuple(c[:2]) in first]
off=[d for d,c in coords.items() if tuple(c[:2]) not in first]
maps=[{d:i for i,d in enumerate(ds)} for ds in [on,off]]
errors=parse_errors(dem)
groups=[{},{}]
orig_p=[];orig_group=[[],[]]
for ds,l,p in errors:
orig_p.append(p)
for k,idx in enumerate(maps):
key=tuple(sorted(idx[d] for d in ds if d in idx)),l if k==0 else 0
if not key[0] and not key[1]:
orig_group[k].append(-1)
continue
if key not in groups[k]:groups[k][key]=[len(groups[k]),1.]
groups[k][key][1]*=1-2*p
orig_group[k].append(groups[k][key][0])
plans=[]
for k,g in enumerate(groups):
sub=stim.DetectorErrorModel()
for (ds,l),(_,bias) in g.items():
sub.append('error',[(1-bias)/2],[stim.target_relative_detector_id(d) for d in ds]+([stim.target_logical_observable_id(0)] if l else []))
for d,i in maps[k].items():sub.append('detector',coords[d],[stim.target_relative_detector_id(i)])
plan=make_plan(sub)
if k==1:
# No logical observable is tracked in the complementary partition.
assert np.all((plan['masks'] & 1)==0)
plan['masks'] >>= 1
plan['width'] -= 1
plans.append(plan)
# Relate each original error to its complementary parity's likelihood gradient.
step_from_source={int(v):i for i,v in enumerate(plans[1]['source_indices']) if v>=0}
offstep=np.array([step_from_source.get(g,0) for g in orig_group[1]],np.int32)
p=np.array(orig_p,np.float32)
offp=plans[1]['probabilities'][offstep]
coeff=p*(1-p)*(1-2*offp)/(1-2*p)
coeff[np.array(orig_group[1])<0]=0
members=[[] for _ in groups[0]]
for i,g in enumerate(orig_group[0]):
if g>=0:members[g].append(i)
size=max(map(len,members))
member_array=np.array([m+[len(p)]*(size-len(m)) for m in members],np.int32)
return {'on':plans[0],'off':plans[1],'on_indices':np.array(on,np.int32),'off_indices':np.array(off,np.int32),
'p':p,'coeff':coeff,'offstep':offstep,'members':member_array}
class ConditionalDecoder:
def __init__(self, state, batch=128):
self.state=state;self.batch=batch
self.marginals=make_marginals_fb(int(state['off']['width']))
self.decode=make_decoder(int(state['on']['width']))
self.args=[jax.device_put(state['off'][k]) for k in ['probabilities','masks','measured']]
self.onargs=[jax.device_put(state['on'][k]) for k in ['masks','measured']]
p,coeff,offstep,members=[jnp.asarray(state[k]) for k in ['p','coeff','offstep','members']]
src=jnp.asarray(state['on']['source_indices'])
@jax.jit
def probabilities(grad,strength):
q=jnp.clip(p[None,:]+strength*coeff[None,:]*grad[:,offstep],1e-7,1-1e-7)
q=jnp.pad(q,((0,0),(0,1)))
bias=jnp.prod(1-2*q[:,members],axis=-1)
v=(1-bias)/2
return jnp.where(src[:,None]>=0,v[:,jnp.maximum(src,0)].T,0)
self.probabilities=probabilities
def predict(self,dets,strengths=(0.,0.5,1.)):
outputs=[[] for s in strengths]
for start in range(0,len(dets),self.batch):
n=min(self.batch,len(dets)-start)
ds=np.pad(dets[start:start+n],((0,self.batch-n),(0,0)))
logz,grad=self.marginals(ds[:,self.state['off_indices']],*self.args)
for i,strength in enumerate(strengths):
probabilities=self.probabilities(grad,strength)
result=self.decode(ds[:,self.state['on_indices']],probabilities,*self.onargs)
outputs[i].append(np.asarray(result)[:n])
return np.stack([np.concatenate(v) for v in outputs],axis=1)
if __name__=='__main__':
import sys
path=Path(sys.argv[1]);n=int(sys.argv[2]) if len(sys.argv)>2 else 512
t=time.time();dem=stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem');state=build(dem)
print('plan',time.time()-t,'widths',state['on']['width'],state['off']['width'],flush=True)
arrays=np.load(path/'arrays.npz');dets=np.unpackbits(arrays['detectors'][:n],axis=1,count=dem.num_detectors,bitorder='little')
decoder=ConditionalDecoder(state,batch=128)
for trial in range(2):
t=time.time();p=decoder.predict(dets);print('trial',trial,'seconds',time.time()-t,'failure',np.mean((p>=.5)!=arrays['labels'][:n,None],axis=0),'range',p.min(),p.max(),flush=True)
|