| """Learned calibrated ensemble of matching and constrained logical-coset matching.""" |
| from pathlib import Path |
| import json |
| import numpy as np |
| import pymatching |
| import stim |
| from scipy.special import expit |
|
|
|
|
| def match_features(dem, packed, rounds): |
| dets = np.unpackbits(packed, axis=1, count=dem.num_detectors, bitorder='little') |
| m = pymatching.Matching.from_detector_error_model(dem, enable_correlations=True) |
| plain, wp = m.decode_batch(dets, return_weights=True) |
| corr, wc = m.decode_batch(dets, return_weights=True, enable_correlations=True) |
| |
| |
| cd = stim.DetectorErrorModel() |
| for instruction in dem.flattened(): |
| if instruction.type != 'error': |
| continue |
| targets = [stim.target_relative_detector_id(dem.num_detectors) |
| if t.is_logical_observable_id() else t |
| for t in instruction.targets_copy()] |
| cd.append('error', instruction.args_copy(), targets) |
| cm = pymatching.Matching.from_detector_error_model(cd) |
| augmented = np.pad(dets, ((0, 0), (0, 1))) |
| _, w0 = cm.decode_batch(augmented, return_weights=True) |
| augmented[:, -1] = 1 |
| _, w1 = cm.decode_batch(augmented, return_weights=True) |
| gap = np.clip(w0 - w1, -20, 20) |
| s0, s1 = plain[:, 0].astype(np.float64)*2-1, corr[:, 0].astype(np.float64)*2-1 |
| density = dets.mean(axis=1) |
| r = np.log1p(rounds)/np.log(26) |
| return np.stack([np.ones(len(dets)), gap, s0, s1, s1*abs(gap), |
| gap*density, s1*density, gap*r, s1*r, |
| s0*density, s0*r, s0*s1], axis=1).astype(np.float32) |
|
|
|
|
| def predict_features(x, state): |
| return expit((x/state['scale']) @ state['coef']).astype(np.float32) |
|
|
|
|
| def infer_condition(task): |
| package, inputs, output, row, config = task |
| package, inputs, output = map(Path, (package, inputs, output)) |
| |
| with np.load(inputs/row['arrays'], allow_pickle=False) as a: |
| packed, ids = a['detectors'], a['sample_ids'] |
| record = config['conditions'][row['name']] |
| dem = stim.DetectorErrorModel.from_file(package/record['dem']) |
| with np.load(package/config['groups'][row['group']], allow_pickle=False) as a: |
| state = dict(a) |
| probabilities = np.empty(len(ids), dtype=np.float32) |
| for start in range(0, len(ids), 8192): |
| end = min(start+8192, len(ids)) |
| x = match_features(dem, packed[start:end], row['rounds']) |
| probabilities[start:end] = predict_features(x, state) |
| np.savez(output/f"{row['name']}.npz", sample_ids=ids, probabilities=probabilities) |
| return row['name'] |
|
|
|
|
| def main(): |
| import sys, os |
| from concurrent.futures import ProcessPoolExecutor |
| package = Path(__file__).resolve().parent |
| inputs, output = map(Path, sys.argv[1:3]) |
| manifest = json.loads((inputs/'manifest.json').read_text()) |
| if manifest['schema'] != 'surface-code-decoding-input/v1': |
| raise ValueError('Unsupported input schema') |
| config = json.loads((package/'model_config.json').read_text()) |
| output.mkdir(exist_ok=True, parents=True) |
| tasks = [(str(package), str(inputs), str(output), row, config) for row in manifest['conditions']] |
| workers = min(int(os.environ.get('QEC_WORKERS', '16')), len(tasks)) |
| with ProcessPoolExecutor(max_workers=workers) as pool: |
| for name in pool.map(infer_condition, tasks): |
| print(name, flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
