structrestore-3d 0.1.0a1__tar.gz

structrestore_3d-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Krishna Kant Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

structrestore_3d-0.1.0a1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: structrestore-3d
+Version: 0.1.0a1
+Summary: Auditable self-supervised 2.5D FIB-SEM restoration research prototype
+Author-email: Krishna Kant Gupta <krishnakant.gupta@bharatividyapeeth.edu>
+Project-URL: Homepage, https://github.com/krishnakantgupta-ai/StructRestore-3D
+Project-URL: Repository, https://github.com/krishnakantgupta-ai/StructRestore-3D
+Project-URL: Issues, https://github.com/krishnakantgupta-ai/StructRestore-3D/issues
+Keywords: FIB-SEM,electron microscopy,self-supervised learning,denoising
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=1.24
+Requires-Dist: scipy<2,>=1.10
+Requires-Dist: tifffile>=2023.7.10
+Requires-Dist: scikit-image<1,>=0.21
+Requires-Dist: matplotlib<4,>=3.7
+Requires-Dist: torch<3,>=2.2.2
+Dynamic: license-file
+
+# StructRestore-3D
+
+Self-Supervised Deep Learning for FIB-SEM Microscopy Restoration
+
+## Overview
+
+StructRestore-3D is a research prototype for investigating
+self-supervised restoration of three-dimensional FIB-SEM
+microscopy images while preserving cellular ultrastructure.
+
+## Implemented Models
+
+1. Single-slice convolutional neural network
+2. Plain 2.5D convolutional neural network
+3. Reliability-gated 2.5D convolutional neural network
+
+## Dataset
+
+EMPIAR-10311: HeLa FIB-SEM microscopy dataset.
+
+DOI: https://doi.org/10.6019/EMPIAR-10311
+
+## Features
+
+- Self-supervised model training
+- Masked-pixel reconstruction
+- Direct target-leakage auditing
+- Patch-quality diagnostics
+- Multi-slice inference
+- Quantitative benchmarking using PSNR and SSIM
+- Neighboring-section alignment analysis
+
+## Preliminary Results
+
+Six models were evaluated against noisy-input and conventional
+filtering baselines. The present models have not demonstrated
+superior denoising performance. Fine-structure preservation
+remains an important research challenge.
+
+## Requirements
+
+Python 3.12, PyTorch, NumPy, SciPy, tifffile,
+scikit-image and Matplotlib.
+
+## Author
+
+Dr. Krishna Kant Gupta
+
+Rajiv Gandhi Institute of Information Technology and Biotechnology
+
+Bharati Vidyapeeth (Deemed to be University), Pune, India
+
+## Research Status
+
+Preliminary proof of concept. Further validation is ongoing.

structrestore_3d-0.1.0a1/README.md

@@ -0,0 +1,55 @@
+# StructRestore-3D
+
+Self-Supervised Deep Learning for FIB-SEM Microscopy Restoration
+
+## Overview
+
+StructRestore-3D is a research prototype for investigating
+self-supervised restoration of three-dimensional FIB-SEM
+microscopy images while preserving cellular ultrastructure.
+
+## Implemented Models
+
+1. Single-slice convolutional neural network
+2. Plain 2.5D convolutional neural network
+3. Reliability-gated 2.5D convolutional neural network
+
+## Dataset
+
+EMPIAR-10311: HeLa FIB-SEM microscopy dataset.
+
+DOI: https://doi.org/10.6019/EMPIAR-10311
+
+## Features
+
+- Self-supervised model training
+- Masked-pixel reconstruction
+- Direct target-leakage auditing
+- Patch-quality diagnostics
+- Multi-slice inference
+- Quantitative benchmarking using PSNR and SSIM
+- Neighboring-section alignment analysis
+
+## Preliminary Results
+
+Six models were evaluated against noisy-input and conventional
+filtering baselines. The present models have not demonstrated
+superior denoising performance. Fine-structure preservation
+remains an important research challenge.
+
+## Requirements
+
+Python 3.12, PyTorch, NumPy, SciPy, tifffile,
+scikit-image and Matplotlib.
+
+## Author
+
+Dr. Krishna Kant Gupta
+
+Rajiv Gandhi Institute of Information Technology and Biotechnology
+
+Bharati Vidyapeeth (Deemed to be University), Pune, India
+
+## Research Status
+
+Preliminary proof of concept. Further validation is ongoing.

structrestore_3d-0.1.0a1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "structrestore-3d"
+version = "0.1.0a1"
+description = "Auditable self-supervised 2.5D FIB-SEM restoration research prototype"
+readme = "README.md"
+requires-python = ">=3.10,<3.13"
+authors = [{name = "Krishna Kant Gupta", email = "krishnakant.gupta@bharatividyapeeth.edu"}]
+keywords = ["FIB-SEM", "electron microscopy", "self-supervised learning", "denoising"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Image Processing",
+]
+dependencies = [
+    "numpy>=1.24,<3",
+    "scipy>=1.10,<2",
+    "tifffile>=2023.7.10",
+    "scikit-image>=0.21,<1",
+    "matplotlib>=3.7,<4",
+    "torch>=2.2.2,<3",
+]
+
+[project.urls]
+Homepage = "https://github.com/krishnakantgupta-ai/StructRestore-3D"
+Repository = "https://github.com/krishnakantgupta-ai/StructRestore-3D"
+Issues = "https://github.com/krishnakantgupta-ai/StructRestore-3D/issues"
+
+[project.scripts]
+structrestore3d = "structrestore3d.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["structrestore3d*"]

structrestore_3d-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

structrestore_3d-0.1.0a1/src/structrestore3d/__init__.py

@@ -0,0 +1,3 @@
+"""StructRestore-3D research prototype; methods are not yet validated denoisers."""
+
+__version__ = "0.1.0a1"

structrestore_3d-0.1.0a1/src/structrestore3d/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

structrestore_3d-0.1.0a1/src/structrestore3d/audit_masking.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Read-only audit of StructRestore-3D masking, split, and neighbor dependence.
+Run from project root. Does not train or overwrite checkpoints.
+"""
+import argparse, csv, json, sys, random
+from pathlib import Path
+import numpy as np
+import tifffile
+import torch
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument('--input',default='data/raw')
+    ap.add_argument('--script',default='scripts/structrestore_25d.py')
+    ap.add_argument('--checkpoint',default='results/25d_gated/model.pt')
+    ap.add_argument('--patch',type=int,default=128)
+    ap.add_argument('--samples',type=int,default=100)
+    ap.add_argument('--out',default='results/masking_audit')
+    a=ap.parse_args()
+    torch.set_num_threads(2)
+    random.seed(42); np.random.seed(42); torch.manual_seed(42)
+    out=Path(a.out);out.mkdir(parents=True,exist_ok=True)
+    files=sorted(Path(a.input).glob('slice_*.tif'))
+    assert len(files)>=7, 'Expected at least seven TIFF slices'
+    train,test=files[:-4],files[-4:]
+    print('Training slices:',[f.name for f in train])
+    print('Held-out slices:',[f.name for f in test])
+    print('Filename overlap:',bool(set(train)&set(test)))
+    print('Adjacent train/test boundary:',train[-1].name,'/',test[0].name)
+    print('CAUTION: Adjacent sections are not biologically independent.')
+    print('CAUTION: Noisy neighboring sections can reveal central pixel structure; not a strict blind-spot model.')
+    import importlib.util
+    spec=importlib.util.spec_from_file_location('audit_model',a.script)
+    module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
+    ck=torch.load(a.checkpoint,map_location='cpu',weights_only=True)
+    model=module.Net25D(ck['mode'],ck['width'])
+    model.load_state_dict(ck['state_dict']);model.eval()
+    print('Checkpoint mode:',ck['mode'],'width:',ck['width'])
+    # Check center masking: selected target pixels must differ from corrupted center in most cases.
+    ims=[tifffile.memmap(str(f)) for f in train]
+    rows=[]
+    with torch.inference_mode():
+        for i in range(a.samples):
+            z=random.randrange(1,len(ims)-1)
+            h,w=ims[z].shape
+            y=random.randrange(h-a.patch+1);x=random.randrange(w-a.patch+1)
+            arr=np.stack([np.asarray(ims[j][y:y+a.patch,x:x+a.patch],dtype=np.float32)/255
+                          for j in (z-1,z,z+1)])
+            tensor=torch.from_numpy(arr.copy())[None]
+            corrupted,target,mask=module.corrupt_center(tensor)
+            m=mask.numpy()[0,0]
+            original=target.numpy()[0,0]
+            changed=(corrupted[:,1:2].numpy()[0,0]!=original)
+            selected=int(m.sum())
+            changed_count=int((changed&m).sum())
+            rows.append(dict(sample=i,z=z,masked=selected,changed=changed_count,
+                             masked_unchanged=selected-changed_count,
+                             patch_std=float(original.std()),
+                             patch_mean=float(original.mean()),
+                             masked_target_var=float(original[m].var()) if selected else 0.0))
+    with (out/'patch_audit.csv').open('w',newline='') as f:
+        w=csv.DictWriter(f,fieldnames=rows[0].keys());w.writeheader();w.writerows(rows)
+    total_mask=sum(r['masked'] for r in rows)
+    unchanged=sum(r['masked_unchanged'] for r in rows)
+    print(f'Masked target pixels unchanged after replacement: {unchanged}/{total_mask} ({unchanged/max(1,total_mask):.2%})')
+    print('Patch std: min/median/max:',*[round(v,5) for v in
+          (min(r['patch_std'] for r in rows),np.median([r['patch_std'] for r in rows]),max(r['patch_std'] for r in rows))])
+    # Counterfactual probe: keep corrupted center fixed, change only neighboring channels.
+    # Measures neighbor dependence, NOT proof of leakage or restoration quality.
+    z=5;h,w=ims[z].shape;y=(h-a.patch)//2;x=(w-a.patch)//2
+    arr=np.stack([np.asarray(ims[j][y:y+a.patch,x:x+a.patch],dtype=np.float32)/255
+                  for j in (z-1,z,z+1)])
+    base=torch.from_numpy(arr.copy())[None]
+    corrupted,target,mask=module.corrupt_center(base)
+    with torch.inference_mode():
+        baseline=model(corrupted)
+        zero=corrupted.clone();zero[:,0]=0;zero[:,2]=0
+        same=corrupted.clone();same[:,0]=same[:,1];same[:,2]=same[:,1]
+        swap=corrupted.clone();swap[:,0],swap[:,2]=corrupted[:,2].clone(),corrupted[:,0].clone()
+        delta_zero=(model(zero)-baseline).abs().mean().item()
+        delta_same=(model(same)-baseline).abs().mean().item()
+        delta_swap=(model(swap)-baseline).abs().mean().item()
+    print('Neighbor counterfactual mean |output change|:')
+    print('  zero neighbors:',round(delta_zero,6))
+    print('  copy corrupted center into neighbors:',round(delta_same,6))
+    print('  swap neighbors:',round(delta_swap,6))
+    report={
+      'checkpoint':str(a.checkpoint),'mode':ck['mode'],
+      'train_files':[f.name for f in train],'heldout_files':[f.name for f in test],
+      'filename_overlap':bool(set(train)&set(test)),
+      'masked_pixels':total_mask,'masked_pixels_unchanged':unchanged,
+      'masked_unchanged_fraction':unchanged/max(1,total_mask),
+      'patch_std_min':min(r['patch_std'] for r in rows),
+      'patch_std_median':float(np.median([r['patch_std'] for r in rows])),
+      'neighbor_probe_mean_abs_change':{'zero':delta_zero,'copy_center':delta_same,'swap':delta_swap},
+      'limitations':[
+       'This is a code and behavior audit, not proof of no information leakage.',
+       'Adjacent slice channels remain unmasked; correlated neighboring pixels can reveal central structure.',
+       'Random neighboring-pixel replacement can equal the target by chance.',
+       'Training/test adjacent sections are not independent specimens.',
+       'No retraining or performance assessment is performed.'
+      ]}
+    (out/'audit.json').write_text(json.dumps(report,indent=2))
+    print('Saved:',out/'audit.json',out/'patch_audit.csv')
+if __name__=='__main__': main()

structrestore_3d-0.1.0a1/src/structrestore3d/cli.py

@@ -0,0 +1,64 @@
+"""Command-line dispatcher for the existing StructRestore-3D research scripts.
+
+All data and checkpoint paths are relative to the shell working directory.
+"""
+from pathlib import Path
+import runpy
+import sys
+
+from . import __version__
+
+# Command -> packaged script name, positional arguments prepended for existing CLI.
+COMMANDS = {
+    "audit-v1": ("train_v1_audited", ["audit"]),
+    "train-v1": ("train_v1_audited", ["train"]),
+    "compare": ("compare_v0_v1", []),
+    "diagnose": ("diagnose_v1_inference", []),
+    "mask-audit": ("audit_masking", []),
+    "train-single-v0": ("train_fullres", []),
+    "train-25d-v0": ("structrestore_25d", []),
+    "train-baseline": ("train_baseline", []),
+    "infer-baseline": ("infer_baseline", []),
+    "validate-25d": ("validate_25d", []),
+    "register-probe": ("step29_registration_probe", []),
+}
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help", "help"):
+        print(f"StructRestore-3D {__version__} (experimental research software)")
+        print("Usage: structrestore3d COMMAND [OPTIONS]")
+        print("Commands:")
+        for command in COMMANDS:
+            print(f"  {command}")
+        print("\nExample: structrestore3d audit-v1")
+        print("Run 'structrestore3d train-v1 --help' for training arguments.")
+        print("All image data and trained model checkpoints must be supplied separately.")
+        return 0
+    if sys.argv[1] in ("-V", "--version", "version"):
+        print(__version__)
+        return 0
+    command = sys.argv[1]
+    if command not in COMMANDS:
+        print(f"Unknown command: {command!r}; run structrestore3d --help", file=sys.stderr)
+        return 2
+    script, prefix = COMMANDS[command]
+    script_path = Path(__file__).resolve().parent / f"{script}.py"
+    if not script_path.is_file():
+        print(f"The packaged script {script} is missing. Run python tools/sync_package.py before building.", file=sys.stderr)
+        return 1
+    # Original research scripts import their siblings as top-level modules.
+    # Keep backward compatibility without altering the user's scripts.
+    package_dir = str(script_path.parent)
+    if package_dir not in sys.path:
+        sys.path.insert(0, package_dir)
+    arguments = sys.argv[2:]
+    if command == "mask-audit" and "--script" not in arguments:
+        arguments += ["--script", str(script_path.parent / "structrestore_25d.py")]
+    sys.argv = [str(script_path), *prefix, *arguments]
+    runpy.run_path(str(script_path), run_name="__main__")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

structrestore_3d-0.1.0a1/src/structrestore3d/compare_v0_v1.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""Step 27: controlled V0 vs V1 EM FIB-SEM added-noise stress test.
+
+Reference: original *naturally noisy* TIFF, NOT verified clean ground truth.
+V1: masked-partition prediction: each pixel is inferred ONLY while concealed
+     at the same pixel coordinate in all input sections, avoiding unmasked
+     inference mismatch. Masked pixels are given independent uniform filler.
+V0: native inference exactly as originally used. Comparisons confound training
+     changes and inference protocols; not causal architecture ablations.
+No files in existing results directories are written or altered.
+"""
+import argparse, csv, json, sys, time
+from pathlib import Path
+import numpy as np
+import tifffile
+import torch
+from scipy.ndimage import gaussian_filter, median_filter
+from skimage.metrics import structural_similarity, peak_signal_noise_ratio
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+# Loads existing project architectures without modifying source or checkpoints.
+SCRIPT_DIR=Path(__file__).resolve().parent
+if SCRIPT_DIR.name!='scripts' and (SCRIPT_DIR/'scripts').is_dir():
+    SCRIPT_DIR=SCRIPT_DIR/'scripts'
+sys.path.insert(0,str(SCRIPT_DIR))
+from train_fullres import TinyCNN
+from structrestore_25d import Net25D
+from train_v1_audited import Model as V1Model
+
+DEFAULT_PATHS={
+  'v0_single':'results/baseline_fullres/baseline.pt',
+  'v0_plain':'results/25d_plain/model.pt',
+  'v0_gated':'results/25d_gated/model.pt',
+  'v1_single':'results/v1_single/model.pt',
+  'v1_plain':'results/v1_plain/model.pt',
+  'v1_gated':'results/v1_gated/model.pt',
+}
+
+def load_models(paths,dev):
+    models={}
+    for key,path in paths.items():
+        ck=torch.load(path,map_location='cpu',weights_only=True)
+        mode=key.split('_')[1]
+        if key.startswith('v0'):
+            net=TinyCNN(width=int(ck.get('width',32))) if mode=='single' else Net25D(mode,int(ck.get('width',32)))
+            if mode!='single' and ck.get('mode')!=mode:raise ValueError(f'V0 mode mismatch: {key}: {ck.get("mode")}')
+        else:
+            if ck.get('mode')!=mode:raise ValueError(f'V1 mode mismatch: {key}: {ck.get("mode")}')
+            net=V1Model(mode,int(ck.get('width',32)))
+        net.load_state_dict(ck['state_dict'],strict=True)
+        models[key]=net.to(dev).eval()
+        print('Loaded',key, '<-',path,flush=True)
+    return models
+
+def v0_predict(model,mode,stack,dev,pad):
+    arr=stack[1:2] if mode=='single' else stack
+    with torch.inference_mode():
+        inp=torch.from_numpy(np.ascontiguousarray(arr[None])).to(dev)
+        out=model(inp).clamp(0,1)[0,0].cpu().numpy()
+    return out[pad:-pad,pad:-pad]
+
+def masked_partition_v1(model,stack,dev,pad,groups,rng):
+    """Predict every pixel *once* under a disjoint random ~5% mask partition.
+
+    Independent uniform replacement for each masked channel matches training
+    mask value distribution. All channels use exactly the same boolean mask.
+    """
+    _,h,w=stack.shape
+    group_ids=rng.integers(0,groups,size=(h,w),dtype=np.uint8 if groups<=256 else np.int16)
+    output=np.empty((h-2*pad,w-2*pad),dtype=np.float32)
+    counts=np.zeros(output.shape,dtype=np.uint8)
+    base=torch.from_numpy(np.ascontiguousarray(stack[None])).to(dev)
+    with torch.inference_mode():
+        for g in range(groups):
+            selected=(group_ids==g)
+            if not np.any(selected[pad:-pad,pad:-pad]):continue
+            mask=torch.from_numpy(selected[None,None]).to(dev)
+            # Draw filler per channel independently, as in V1 training.
+            filler=torch.rand_like(base)
+            masked=torch.where(mask.expand_as(base),filler,base)
+            prediction=model(masked).clamp(0,1)[0,0].cpu().numpy()[pad:-pad,pad:-pad]
+            interior=selected[pad:-pad,pad:-pad]
+            output[interior]=prediction[interior]
+            counts[interior]+=1
+    if not np.all(counts==1):raise RuntimeError('Mask partitions did not cover each interior pixel exactly once')
+    return output
+
+def calc_metrics(ref,img):
+    img=np.clip(img,0,1).astype(np.float32)
+    gy,gx=np.gradient(ref)
+    py,px=np.gradient(img)
+    return {'psnr':float(peak_signal_noise_ratio(ref,img,data_range=1.0)),
+            'ssim':float(structural_similarity(ref,img,data_range=1.0)),
+            'edge_rmse':float(np.sqrt(np.mean((gy-py)**2+(gx-px)**2)))}
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--input',default='data/raw')
+    p.add_argument('--out',default='results/v0_v1_comparison')
+    p.add_argument('--crop',type=int,default=256,help='Central output crop width; extra 16px context used')
+    p.add_argument('--trials',type=int,default=2)
+    p.add_argument('--sigmas',type=float,nargs='+',default=[0.05,0.10])
+    p.add_argument('--groups',type=int,default=20,help='V1 disjoint random mask groups, 20 ~ 5%% masked per pass')
+    p.add_argument('--seed',type=int,default=2026)
+    p.add_argument('--models-root',default='.',help='Project root containing model checkpoints')
+    args=p.parse_args()
+    pad=16
+    if args.crop<64 or args.trials<1 or args.groups<2 or args.groups>255 or any(not 0<s<0.5 for s in args.sigmas):
+        p.error('Require crop>=64, trials>=1, 2<=groups<=255 and 0<sigma<0.5')
+    files=sorted(Path(args.input).glob('slice_*.tif'))
+    if len(files)!=16:raise ValueError(f'Expected 16 original TIFFs; found {len(files)}')
+    paths={k:Path(args.models_root)/v for k,v in DEFAULT_PATHS.items()}
+    missing=[str(f) for f in paths.values() if not f.is_file()]
+    if missing:raise FileNotFoundError('Missing checkpoints: '+', '.join(missing))
+    out=Path(args.out)
+    if out.exists() and any(out.iterdir()):
+        raise FileExistsError(f'Output directory is not empty: {out}. Use new --out to avoid overwriting experiments.')
+    out.mkdir(parents=True,exist_ok=True)
+    dev=torch.device('mps' if torch.backends.mps.is_available() else 'cpu')
+    print('Device:',dev,flush=True)
+    models=load_models(paths,dev)
+    rng=np.random.default_rng(args.seed)
+    rows=[];figure_done=False
+    # Require both context sections to belong to the four held-out slices.
+    for z in (13,14):
+        ims=[tifffile.memmap(str(files[j])) for j in (z-1,z,z+1)]
+        h,w=ims[1].shape;side=args.crop
+        if min(h,w)<side+2*pad:raise ValueError('Image too small for crop and 16px halo')
+        centers=[(h//4,w//4),(h//2,w//2),(3*h//4,3*w//4)]
+        for region,(cy,cx) in enumerate(centers):
+            y=max(pad,min(h-side-pad,cy-side//2))
+            x=max(pad,min(w-side-pad,cx-side//2))
+            stack=np.stack([np.asarray(im[y-pad:y+side+pad,x-pad:x+side+pad],dtype=np.float32)/255 for im in ims])
+            reference=stack[1,pad:-pad,pad:-pad].copy()
+            for sigma in args.sigmas:
+                for trial in range(args.trials):
+                    noisy=np.clip(stack+rng.normal(0,sigma,stack.shape).astype(np.float32),0,1)
+                    noisy_center=noisy[1,pad:-pad,pad:-pad]
+                    candidates={'added_noise':noisy_center,
+                                'gaussian_0p8':gaussian_filter(noisy_center,0.8),
+                                'median_3x3':median_filter(noisy_center,size=3)}
+                    times={k:0.0 for k in candidates}
+                    # SHARE one mask assignment and filler across the three V1 networks:
+                    # reset torch generator before each call so masks/filler match.
+                    # This probe is repeatable on CPU and MPS within each run.
+                    rng_state=rng.bit_generator.state
+                    for key,model in models.items():
+                        start=time.perf_counter()
+                        if key.startswith('v0'):
+                            candidates[key]=v0_predict(model,key.split('_')[1],noisy,dev,pad)
+                        else:
+                            rng.bit_generator.state=rng_state
+                            torch.manual_seed(args.seed+100000*z+1000*region+100*trial+int(round(100*sigma)))
+                            candidates[key]=masked_partition_v1(model,noisy,dev,pad,args.groups,rng)
+                        times[key]=time.perf_counter()-start
+                    # Advance RNG state by exactly one V1 mask draw for next noise trial.
+                    for name,img in candidates.items():
+                        m=calc_metrics(reference,img)
+                        rows.append({'slice':f'slice_{z:04d}','region':region,'sigma':sigma,
+                                     'trial':trial,'method':name,'seconds':round(times[name],5),**m})
+                    if not figure_done:
+                        fig,axes=plt.subplots(3,3,figsize=(12,12),constrained_layout=True)
+                        ordered=[('Reference (native noise)',reference),('Added noise',noisy_center),
+                                 ('Gaussian 0.8',candidates['gaussian_0p8']),
+                                 ('V0 single',candidates['v0_single']),('V0 plain',candidates['v0_plain']),
+                                 ('V0 gated',candidates['v0_gated']),('V1 single',candidates['v1_single']),
+                                 ('V1 plain',candidates['v1_plain']),('V1 gated',candidates['v1_gated'])]
+                        for ax,(name,img) in zip(axes.ravel(),ordered):
+                            ax.imshow(img,cmap='gray',vmin=0,vmax=1,interpolation='nearest')
+                            ax.set_title(name);ax.axis('off')
+                        fig.suptitle(f'Added noise sigma {sigma} | {files[z].stem} | region {region}; reference is NOT clean')
+                        fig.savefig(out/'comparison.png',dpi=140)
+                        plt.close(fig);figure_done=True
+        print('Finished',files[z].stem,flush=True)
+    methods=['added_noise','gaussian_0p8','median_3x3']+list(DEFAULT_PATHS)
+    with (out/'per_trial.csv').open('w',newline='') as f:
+        writer=csv.DictWriter(f,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)
+    summary=[]
+    for sigma in args.sigmas:
+        for method in methods:
+            subset=[r for r in rows if r['sigma']==sigma and r['method']==method]
+            r={'sigma':sigma,'method':method,'n_correlated_evaluations':len(subset)}
+            for metric in ['psnr','ssim','edge_rmse','seconds']:
+                vals=np.array([v[metric] for v in subset],dtype=np.float64)
+                r[metric+'_mean']=round(float(vals.mean()),6)
+                r[metric+'_sd']=round(float(vals.std(ddof=1)),6) if len(vals)>1 else 0.
+            summary.append(r)
+    with (out/'summary.csv').open('w',newline='') as f:
+        writer=csv.DictWriter(f,fieldnames=list(summary[0]));writer.writeheader();writer.writerows(summary)
+    metadata={'experiment':'V0 vs V1 / added-noise stress test','device':str(dev),'seed':args.seed,
+      'train_test_boundary':'train slices 0000-0011, heldout 0012-0015',
+      'evaluated_slice_centers':['slice_0013','slice_0014'],
+      'slice_context_always_heldout':True,'crop':args.crop,'trials':args.trials,
+      'sigmas':args.sigmas,'v1_mask_groups':args.groups,
+      'checkpoints':{k:str(v) for k,v in paths.items()},
+      'limitations':[
+         'Original FIB-SEM reference retains unknown native noise; it is NOT clean ground truth.',
+         'Metrics assess fidelity to original after extra simulated noise, not removal of native noise.',
+         'V1 inference predicts every pixel once while directly masked using random disjoint partitions; V0 uses native unmasked inference.',
+         'V1 changes training masking and patch sampling plus inference procedure: not a causal isolation of any one change.',
+         'No independent biological specimens; slices, patches and noise replicates are correlated.',
+         'Edge RMSE is gradient fidelity to noisy original, not verified membrane-preservation accuracy.',
+         'Models were trained on native noisy images; extra Gaussian noise is an out-of-distribution stress test.'
+      ]}
+    (out/'metadata.json').write_text(json.dumps(metadata,indent=2))
+    print('\nMEAN METRICS: high PSNR/SSIM is better; low edge_RMSE is better',flush=True)
+    for r in summary:
+        print(f"sigma={r['sigma']:.2f} {r['method']:<14} PSNR={r['psnr_mean']:6.2f}  SSIM={r['ssim_mean']:.4f}  edge_RMSE={r['edge_rmse_mean']:.4f}",flush=True)
+    print('\nSaved:',out/'summary.csv',out/'per_trial.csv',out/'comparison.png',out/'metadata.json',flush=True)
+
+if __name__=='__main__':main()