Si_2 multilevel random

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/photocurrent_mapping copy.py

@@ -0,0 +1,880 @@
+# %% [markdown]
+# # Plug-and-play ADMM for Photocurrent Mapping image reconstruction
+#
+# This notebook demonstrates Plug-and-Play (PnP) ADMM image reconstruction for
+# Photocurrent Mapping (PCM) data.
+#
+# Starting from a high-resolution current map of a CIGS solar cell, subsampled
+# PCM measurements are simulated using the `PhotocurrentMapOp` operator. Several
+# reconstruction methods are then compared:
+#
+# - Zero-filled pseudo-inverse reconstruction.
+# - Two compressed sensing baselines with a wavelet sparsity prior:
+#   FISTA with an $\ell_1$ penalty and SPGL1.
+# - PnP-ADMM with a pre-trained DRUNet denoiser as prior.
+#
+# The goal is not to optimise performance, but to illustrate how
+# classical sparse reconstruction methods and PnP can be combined with the LION
+# operators for PCM.
+
+
+# %% [markdown]
+# ## Setup
+
+# %% [markdown]
+# ### Device configuration
+#
+# Set the default device to a GPU if available. If multiple GPUs are present,
+# the desired GPU index can be specified here.
+
+# %%
+from __future__ import annotations
+from calendar import c
+from operator import inv
+
+from cv2 import add, log
+import test
+import torch
+from wandb import init
+
+device = torch.device("mps" if torch.backends.mps.is_available() else "cuda:0" if torch.cuda.is_available() else "cpu")
+torch.set_default_device(device)
+
+# %% [markdown]
+# ### Imports
+#
+# Import the required libraries, including LION operators and reconstruction algorithms for PCM.
+
+# %%
+from datetime import datetime
+from pathlib import Path
+from typing import Callable, Iterable
+
+import deepinv
+import matplotlib
+import matplotlib.pyplot as plt
+from matplotlib.colors import ListedColormap
+import numpy as np
+from jaxtyping import Float
+from torchmetrics.image import PeakSignalNoiseRatio, StructuralSimilarityIndexMeasure
+from functools import partial
+from tqdm import tqdm as std_tqdm
+
+from LION.classical_algorithms.fista import fista_l1
+from LION.classical_algorithms.spgl1_torch import spgl1_torch
+from LION.operators.Wavelet2D import Wavelet2D
+from LION.operators.CompositeOp import CompositeOp
+from LION.operators.DebiasOp import debias_ls
+
+# LION imports
+from LION.operators.PhotocurrentMapOp import PhotocurrentMapOp
+from LION.operators.uniform_random_sample import uniform_random_sample
+from LION.operators.multilevel_sample import multilevel_sample
+from LION.reconstructors.PnP import PnP
+
+# from LION.utils.scale import choose_measurement_scale_factor
+
+from plot_helper import PlotHelper
+
+
+# Use tqdm with dynamic column width that adapts to the terminal width
+tqdm = partial(std_tqdm, dynamic_ncols=True)
+tqdm_no_leave = partial(std_tqdm, dynamic_ncols=True, leave=False)
+
+GrayscaleImage2D = Float[torch.Tensor, "height width"]
+Measurement1D = Float[torch.Tensor, "num_measurements"]
+
+# %% [markdown]
+# ### Define the data file paths
+#
+# The example uses a single $256 \times 256$ current map of a CIGS solar cell
+# stored as a NumPy array. This image will serve as the ground truth in the
+# experiments.
+
+# %%
+data_dir = Path("data/photocurrent_data")
+# data_dir = Path("your/path/to/photocurrent_data")
+
+assert data_dir.exists(), f"Data directory {data_dir} does not exist."
+
+# # These images are provided with pixels in range [0, 1]
+# data_name, zoom, loc, loc1, loc2, roi = "CIGS_256x256", 2.5, "center left", 3, 4, (110, 210, 40, 40)  # (x, y, w, h)  with y increasing downwards
+# # data_name, zoom, loc, loc1, loc2, roi = "silicon_256x256", 2.5, "lower right", 2, 1, (194, 1, 60, 60)  # (x, y, w, h)  with y increasing downwards
+# # data_name, zoom, loc, loc1, loc2, roi = "silicon_512x512", 3, "lower right", 2, 1, (400, 5, 100, 100)  # (x, y, w, h)  with y increasing downwards
+# # data_name, zoom, loc, loc1, loc2, roi = "organic_256x256", 2.5, "lower left", 2, 1, (70, 5, 50, 50)  # (x, y, w, h)  with y increasing downwards
+# # data_name, zoom, loc, loc1, loc2, roi = "perovskite_256x256", 2.5, "upper left", 3, 4, (90, 190, 50, 50)  # (x, y, w, h)  with y increasing downwards
+# data_name = "example_" + data_name  # prefix with "example_"
+# is_out_of_distribution = False
+# clim = (0.0, 1.0)
+# inverses_sign = False
+# # R_high, R_low = 1.0, 0.0  # default for normalized images
+# is_out_of_distribution = False
+# factor = 1  # no scaling for normalized images
+
+# # This sample was provided in image form at 512x512 resolution but the pixels are real measured current values
+# data_name, zoom, loc, loc1, loc2, roi = "Si_256_512x512", 2.5, "lower left", 2, 1, (160, 60, 120, 120)
+# clim = (0.0, 3e-5)
+# inverses_sign = True
+# R_high = 1e-4
+# R_low = -5e-6
+# factor = 1e5  # to scale up the photocurrent values for better numerical stability in SPGL1
+
+# This sample was provided in image form at 512x512 resolution but the pixels are real measured current values
+data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_512x512", 2.5, "lower right", 2, 1, (322, 85, 100, 100)
+clim = (0.0, 1.5e-5)
+inverses_sign = True
+R_high = 2e-5
+R_low = -2e-6
+factor = 1e5  # to scale up the photocurrent values for better numerical stability in SPGL1
+
+if "256x256" in data_name:
+    J_order = 8  # J=8 => 2^8=256
+elif "512x512" in data_name:
+    J_order = 9  # J=9 => 2^9=512
+else:
+    raise ValueError(f"Unknown data_name {data_name}, cannot determine order_size.")
+
+# # # This is the same data as Si_256_512x512 but provided as measurement data and only up to 256x256 resolution
+# data_name, zoom, loc, loc1, loc2, roi = "Si_256_measurement_data", 2, "lower left", 2, 1, (80, 30, 60, 60)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_256_hadamard_measurement_vector", 2, "lower left", 2, 1, (80, 30, 60, 60)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_256_reconstructed_image", 2, "lower left", 2, 1, (80, 30, 60, 60)
+# clim = (0.0, 1e-6)
+# R_high = 1e-6
+# R_low = -1e-6
+# factor = 1e7  # to scale up the photocurrent values for better numerical stability in SPGL1
+# J_order = 8  # 2^8 x 2^8 = 256 x 256
+
+# # # This is the same data as Si_2_256_512x512 but provided as measurement data and only up to 256x256 resolution
+# data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_measurement_data", 2, "lower left", 2, 1, (32, 42, 50, 50)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_hadamard_measurement_vector", 2, "lower left", 2, 1, (32, 42, 50, 50)
+# # data_name, zoom, loc, loc1, loc2, roi = "Si_2_256_reconstructed_image", 2, "lower left", 2, 1, (32, 42, 50, 50)
+# clim = (0.0, 4e-7)
+# R_high = 1e-6
+# R_low = -1e-6
+# factor = 1e7  # to scale up the photocurrent values for better numerical stability in SPGL1
+# J_order = 8  # 2^8 x 2^8 = 256 x 256
+
+scale_eps = 1e-12
+is_out_of_distribution = True
+inverses_sign = True
+
+tests_scale_ground_truth = False
+
+data_filename = f"{data_name}.npy"
+print("Loading data file:", data_filename)
+assert (data_dir / data_filename).exists(), f"Data {data_filename} not found in {data_dir}."
+
+# data_type = "original_measurement_data"
+# data_type = "hadamard_measurement_vector"
+data_type = "image"
+print(f"The type of raw data is: {data_type}")
+
+noise_seed = 42
+noise_std = 0  # No noise
+# noise_std = 0.05  # standard deviation of additive homoscedastic Gaussian white noise added to measurements
+
+num_trials = 20
+num_trials_skip = 0
+
+runs_pnp_admm = True
+# pnp_admm_iters = 1
+# pnp_admm_iters = 20
+pnp_admm_iters = 50
+# pnp_admm_iters = 100
+# pnp_admm_iters = 150
+# pnp_admm_eta = 0.00001  # Undersampling artifacts may remain if eta is too small
+# pnp_admm_eta = 0.00005  # Could still work
+# pnp_admm_eta = 0.0001  # Could still work
+# pnp_admm_eta = 0.001
+# pnp_admm_eta = 0.005
+pnp_admm_eta = 0.01  # Generally good
+# pnp_admm_eta = 0.02
+# pnp_admm_eta = 0.03
+# pnp_admm_eta = 0.04
+# pnp_admm_eta = 0.05
+# pnp_admm_eta = 0.1
+# pnp_admm_eta = 1
+# pnp_admm_eta = 10
+# pnp_admm_eta = 20
+# pnp_admm_eta = 50
+# pnp_admm_eta = 100  # Got nan for 100% sampling?
+cg_iters = 20
+# cg_iters = 50
+cg_eps = 1e-20  # No real change compared to default, CG usually terminates quickly especially when measurements are small
+# drunet_sigma = 0.01  # noise level for DRUNet denoiser
+# drunet_sigma = 0.02  # noise level for DRUNet denoiser
+drunet_sigma = 0.05  # noise level for DRUNet denoiser
+# drunet_sigma = 0.1  # noise level for DRUNet denoiser
+
+runs_fista_l1 = False
+
+runs_spgl1 = True
+
+randomizing_scheme = "multilevel"
+# randomizing_scheme = "uniform"
+
+cmap_max = 0.8  # take only the lower 0-80% of afmhot, reduce brightness
+# cmap_max = 0.9  # take only the lower 0-90% of afmhot to avoid the white top
+# cmap_max = 1.0  # take all of afmhot
+adds_insets = True
+# adds_insets = False
+plot_helper = PlotHelper(
+    roi=roi,
+    zoom=zoom,
+    loc=loc,
+    show_rect=True,
+    cmap=ListedColormap(matplotlib.colormaps['afmhot'](np.linspace(
+        0.0,
+        cmap_max,
+        256,
+    ))),
+    clim=clim,
+    loc1=loc1,
+    loc2=loc2
+)
+
+# %% [markdown]
+# Define a general function to run the photocurrent mapping reconstruction using a reconstruction method.
+#
+# The helper function `run_pcm_demo`:
+#
+# - Builds the PCM operator and simulates subsampled measurements.
+# - Computes the zero-filled pseudo-inverse reconstruction.
+# - Runs a chosen reconstruction method given by `recon_fn`.
+# - Reports PSNR and SSIM for both reconstructions, displays and saves the images.
+
+
+# %% mystnb={"code_prompt_show": "Show utility details"} tags=["hide-cell"]
+def show_images_with_inset(
+    images: list[torch.Tensor],
+    fig_filepath: Path,
+    plot_helper: PlotHelper,
+    titles: list[str] | None = None,
+    suptitle: str | None = None,
+    adds_insets: bool = True,
+) -> None:
+    """Plot images."""
+    n_images = len(images)
+    fig, axes = plt.subplots(1, n_images, squeeze=False, figsize=(n_images * 4, 4))
+
+    for i in range(n_images):
+        img_np = images[i].squeeze().cpu().numpy()
+        ax: plt.Axes = axes[0][i]
+        if adds_insets:
+            plot_helper.add_zoom_inset(ax, img_np)
+        else:
+            ax.imshow(img_np, cmap=plot_helper.cmap, clim=plot_helper.clim)
+        ax.axis("off")
+        if titles:
+            ax.set_title(titles[i], fontsize=10)
+    if suptitle:
+        fig.subplots_adjust(bottom=0.18)
+        fig.text(0.5, 0.02, suptitle, ha="center", va="bottom", fontsize=16)
+    fig.savefig(fig_filepath, dpi=150)
+    plt.close(fig)
+
+
+def make_csv(method_name: str, log_dir: Path | str) -> None:
+    log_dir = Path(log_dir) / method_name
+    log_dir.mkdir(parents=True, exist_ok=True)
+    csv_path = log_dir / "metrics.csv"
+    with csv_path.open("w") as f:
+        f.write(
+            "sampling_percentage,  coarse_J,  "
+            "mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  "
+            "mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon\n"
+        )
+
+
+# %%
+def run_pcm_demo(
+    recon_description: str,
+    recon_fn: Callable[[PhotocurrentMapOp, Measurement1D, GrayscaleImage2D], GrayscaleImage2D],
+    ground_truth_image: GrayscaleImage2D,
+    method_name: str,
+    image_name: str,
+    J: int,  # image size will be 2^J x 2^J
+    sampling_ratio: float,
+    coarse_J: int,
+    measurement_vector: Measurement1D | None = None,
+    log_dir: Path | str = ".",
+    device: torch.device | str = "cuda:0",
+    seed: int = 0,
+):
+    zero_filled_dir = Path(log_dir) / "zero_filled"
+    zero_filled_dir.mkdir(parents=True, exist_ok=True)
+    masks_dir = Path(log_dir) / "masks"
+    masks_dir.mkdir(parents=True, exist_ok=True)
+
+    log_dir = Path(log_dir) / method_name
+    log_dir.mkdir(parents=True, exist_ok=True)
+    N = 1 << J
+    im_tensor = ground_truth_image.unsqueeze(0).unsqueeze(0)  # (1,1,H,W)
+
+    sampling_percentage = sampling_ratio * 100
+    in_order_measurements_percentage = (1 << (2 * coarse_J)) / (N * N) * 100
+    print()
+    print(f"Sampling rate: {sampling_percentage}%")
+    print(f"Coarse levels to keep: {coarse_J} ({in_order_measurements_percentage}%)")
+
+    rng = np.random.default_rng(seed)
+    num_samples = int(sampling_ratio * N * N)
+    if randomizing_scheme == "multilevel":
+        sampled_indices = multilevel_sample(
+            J=J, num_samples=num_samples, coarse_J=coarse_J, alpha=1.0, rng=rng
+        )
+    elif randomizing_scheme == "uniform":
+        sampled_indices = uniform_random_sample(
+            J=J, num_samples=num_samples, coarse_J=coarse_J, rng=rng
+        )
+    else:
+        raise ValueError(f"Unknown sampling_scheme {randomizing_scheme}.")
+    pcm_op = PhotocurrentMapOp(J=J, sampled_indices=sampled_indices, device=device)
+
+    if measurement_vector is not None:
+        print(f"Using provided measurement vector with shape {measurement_vector.shape}.")
+        y_subsampled_tensor_noiseless = measurement_vector[sampled_indices]
+    else:
+        y_subsampled_tensor_noiseless = pcm_op(im_tensor)
+
+    y_subsampled_tensor = y_subsampled_tensor_noiseless  # No noise
+
+    # noise_rng = torch.Generator(device=device)
+    # noise_rng.manual_seed(noise_seed)
+    # homoscedastic_noise = y_subsampled_tensor_noiseless.normal_(
+    #     mean=0.0, std=noise_std, generator=noise_rng
+    # )
+    # noise = homoscedastic_noise
+    # noise = torch.zeros_like(y_subsampled_tensor_noiseless)
+    # assert torch.equal(noise, torch.zeros_like(noise)), "Noise is not zero!"
+
+    # y_subsampled_tensor = y_subsampled_tensor_noiseless + noise
+
+    zero_filled_recon_tensor = (
+        pcm_op.pseudo_inv(y_subsampled_tensor).unsqueeze(0).unsqueeze(0)
+    )
+
+    recon_tensor = (
+        recon_fn(
+            pcm_op=pcm_op,
+            pcm_measurement=y_subsampled_tensor,
+            initial_image=zero_filled_recon_tensor.squeeze(),
+        )
+        .unsqueeze(0)
+        .unsqueeze(0)
+    )
+
+    data_range = (im_tensor.max() - im_tensor.min()).item()
+    psnr = PeakSignalNoiseRatio(data_range=data_range).to(device)
+    ssim = StructuralSimilarityIndexMeasure(data_range=data_range).to(device)
+
+    psnr_zero_filled = psnr(zero_filled_recon_tensor, im_tensor)
+    psnr_recon = psnr(recon_tensor, im_tensor)
+
+    ssim_zero_filled = ssim(zero_filled_recon_tensor, im_tensor)
+    ssim_recon = ssim(recon_tensor, im_tensor)
+
+    mse_zero_filled = torch.mean((zero_filled_recon_tensor - im_tensor) ** 2).item()
+    mse_recon = torch.mean((recon_tensor - im_tensor) ** 2).item()
+
+    pearson_corr_zero_filled = torch.corrcoef(torch.stack([zero_filled_recon_tensor.flatten(), im_tensor.flatten()]))[0,1].item()
+    pearson_corr_recon = torch.corrcoef(torch.stack([recon_tensor.flatten(), im_tensor.flatten()]))[0,1].item()
+
+    csv_path = log_dir / "metrics.csv"
+    with csv_path.open("a") as f:
+        f.write(
+            f"{sampling_percentage},  {coarse_J},  "
+            f"{mse_zero_filled},  {psnr_zero_filled},  {ssim_zero_filled},  {pearson_corr_zero_filled},  "
+            f"{mse_recon},  {psnr_recon},  {ssim_recon},  {pearson_corr_recon}\n"
+        )
+
+    filename = f"{image_name}_{method_name}_sample_{sampling_percentage}_percent_coarse_J={coarse_J}_{randomizing_scheme}_random"
+    zero_filled_filename = f"{image_name}_sample_{sampling_percentage}_percent_coarse_J={coarse_J}_{randomizing_scheme}_random"
+    recons_dir = log_dir / "recons"
+    recons_dir.mkdir(parents=True, exist_ok=True)
+    np.save(zero_filled_dir / f"{zero_filled_filename}.npy", zero_filled_recon_tensor.squeeze().cpu().numpy())
+    np.save(recons_dir / f"{filename}.npy", recon_tensor.squeeze().cpu().numpy())
+
+    mask_of_masks_np = np.zeros(N * N, dtype=bool)
+    mask_of_masks_np[sampled_indices] = True
+    np.save(masks_dir / f"sample_{sampling_percentage}_percent_coarse_J={coarse_J}_{randomizing_scheme}_random.npy", mask_of_masks_np.reshape(N, N))
+
+    images_dir = log_dir / "images"
+    images_dir.mkdir(parents=True, exist_ok=True)
+
+    show_images_with_inset(
+        [im_tensor, zero_filled_recon_tensor, recon_tensor],
+        fig_filepath=images_dir / f"{filename}.png",
+        plot_helper=plot_helper,
+        titles=[
+            "Original Image",
+            f"Inverse WHT (Zero-filled)\nPSNR: {psnr_zero_filled:.2f} dB, SSIM: {ssim_zero_filled:.4f}\nMSE: {mse_zero_filled:.3e}, Pearson Corr.: {pearson_corr_zero_filled:.4f}",
+            f"{recon_description}\nPSNR: {psnr_recon:.2f} dB, SSIM: {ssim_recon:.4f}\nMSE: {mse_recon:.3e}, Pearson Corr.: {pearson_corr_recon:.4f}",
+        ],
+        suptitle=(
+            f"PCM Reconstructions, J={J} ({N}x{N} image)\n"
+            + f"Sample {sampling_percentage:.2f}%, keep {coarse_J} coarse levels ({in_order_measurements_percentage}% here), the rest: {randomizing_scheme} random"
+        ),
+        adds_insets=adds_insets,
+    )
+
+# %%
+denoiser_DRUNet = deepinv.models.DRUNet(
+    pretrained="download", in_channels=1, out_channels=1, device=device
+)
+
+def run_pnp_admm(
+    pcm_op: PhotocurrentMapOp, pcm_measurement: Measurement1D, initial_image: GrayscaleImage2D
+) -> GrayscaleImage2D:
+    admm_iterations = pnp_admm_iters
+    admm_eta = pnp_admm_eta
+    cg_max_iter = cg_iters
+    _cg_eps = cg_eps
+    cg_rel_tol = 0.0
+
+    # print(
+    #     f"Running PnP-ADMM reconstruction: {admm_iterations} iterations, cg_max_iter={cg_max_iter}..."
+    # )
+
+    if is_out_of_distribution:
+        a = max(R_high - R_low, scale_eps)
+
+    # pcm_measurement = (pcm_measurement - R_low) / a if is_out_of_distribution else pcm_measurement
+
+    def denoiser_fn(x: GrayscaleImage2D) -> GrayscaleImage2D:
+        with torch.no_grad():
+            model_input = (x - R_low) / a if is_out_of_distribution else x
+            model_output = (
+                denoiser_DRUNet(model_input.unsqueeze(0).unsqueeze(0), sigma=drunet_sigma)
+                .squeeze(0)
+                .squeeze(0)
+            )
+            model_output = a * model_output + R_low if is_out_of_distribution else model_output
+            return model_output
+
+    pnp = PnP(physics=pcm_op, prior_fn=denoiser_fn, default_algorithm="ADMM")
+    recon = pnp.admm_algorithm(
+        measurement=pcm_measurement,
+        eta=admm_eta,
+        max_iter=admm_iterations,
+        cg_max_iter=cg_max_iter,
+        cg_eps=_cg_eps,
+        cg_rel_tol=cg_rel_tol,
+        prog_bar=tqdm,
+        # cg_prog_bar=tqdm,
+    )
+    # recon = pnp.forward_backward_splitting(
+    #     sino=pcm_measurement,
+    # )
+
+    return recon
+    # return a * recon + R_low if is_out_of_distribution else recon
+
+
+
+
+# %%
+def run_fista_l1(
+    pcm_op: PhotocurrentMapOp, pcm_measurement: Measurement1D, initial_image: GrayscaleImage2D
+) -> GrayscaleImage2D:
+
+    lam = 10  # Good for Daubechies 4 wavelet transform
+    # max_iter = 300
+    max_iter = 100
+    tol = 1e-5
+
+    debias_max_iter = 10
+    debias_support_tol = 1e-5
+    debias_tol = 1e-7
+
+    height, width = pcm_op.domain_shape
+    # Wavelet transform Psi
+    wavelet = Wavelet2D((height, width), wavelet_name="db4", device=device)
+    # Composite operator A = Phi Psi^{-1}
+    A_op = CompositeOp(wavelet, pcm_op, device=device)
+
+    # print("Running FISTA reconstruction: " f"{max_iter} iterations, lambda={lam}...")
+    w_hat = fista_l1(
+        op=A_op,
+        y=pcm_measurement,
+        lam=lam,
+        max_iter=max_iter,
+        tol=tol,
+        L=None,
+        verbose=False,
+        prog_bar=tqdm,
+    )
+
+    # Optional debiasing
+    # print(f"Running debiasing: {debias_max_iter} iterations...")
+    w_debias = debias_ls(
+        op=A_op,
+        y=pcm_measurement,
+        w=w_hat,
+        support_tol=debias_support_tol,
+        max_iter=debias_max_iter,
+        tol=debias_tol,
+        prog_bar=tqdm,
+    )
+
+    # Current map reconstruction
+    cs_result_tensor = wavelet.inverse(w_debias)
+
+    return cs_result_tensor
+
+
+
+# %%
+def run_spgl1(
+    pcm_op: PhotocurrentMapOp, pcm_measurement: Measurement1D, initial_image: GrayscaleImage2D
+) -> GrayscaleImage2D:
+
+    # max_iter = 1000
+    # max_iter = 200
+    max_iter = 100
+    # opt_tol = 1e-4
+    # bp_tol = 1e-6
+    # opt_tol = 1e-5
+    # bp_tol = 1e-7
+
+    debias_max_iter = 10
+    # debias_max_iter = 100
+    debias_support_tol = 1e-5
+    # debias_support_tol = 1e-6
+    # debias_support_tol = 1e-7
+    debias_tol = 1e-7
+
+    height, width = pcm_op.domain_shape
+    # Wavelet transform Psi
+    wavelet = Wavelet2D((height, width), wavelet_name="db4", device=device)
+    # Composite operator A = Phi Psi^{-1}
+    A_op = CompositeOp(wavelet, pcm_op, device=device)
+
+    # rhs_l2_norm = torch.linalg.norm(pcm_measurement).item()
+    # # relative_feasibility_tolerance = 1e-6
+    # relative_feasibility_tolerance = 1e-9
+    # absolute_feasibility_tolerance = relative_feasibility_tolerance * rhs_l2_norm
+
+    pcm_measurement = pcm_measurement * factor  # scale up
+
+    # print("Running SPGL1 reconstruction: " f"{max_iter} iterations ...")
+    w_hat, _ = spgl1_torch(
+        op=A_op,
+        y=pcm_measurement,
+        iter_lim=max_iter,
+        # opt_tol=absolute_feasibility_tolerance,
+        # bp_tol=relative_feasibility_tolerance,
+        verbosity=0,
+        # opt_tol=opt_tol,
+        # bp_tol=bp_tol,
+    )
+    # Optional debiasing
+    # print(f"Running debiasing: {debias_max_iter} iterations...")
+    w_debias = debias_ls(
+        op=A_op,
+        y=pcm_measurement,
+        w=w_hat,
+        support_tol=debias_support_tol,
+        max_iter=debias_max_iter,
+        tol=debias_tol,
+        prog_bar=tqdm,
+    )
+
+    # Current map reconstruction
+    cs_result_tensor = wavelet.inverse(w_debias)
+
+    cs_result_tensor = cs_result_tensor / factor  # scale back down
+
+    return cs_result_tensor
+
+
+def make_test_cases() -> list[tuple[float, int]]:
+    min_coarse_J = 0
+    # min_coarse_J = 5
+    # min_coarse_J = J_order - 3  # keep 1.5625% of in-order measurements at least
+    # (sampling_ratio, coarse_J)
+    test_cases = []
+    num_pixels = 1 << (2 * J_order)  # N*N
+    # for sampling_ in range(0, 9, 1):
+    #     sampling_ratio = (sampling_ + 1) / 100.0  # from 0.01 to 0.09
+    #     num_samples = int(sampling_ratio * num_pixels)
+    #     for coarse_J in range(min_coarse_J, J_order):  # from 0 to J_order-1 (not including J_order because that is 100% sampling)
+    #         if coarse_J > 0:
+    #             prev_num_coarse_samples = 1 << (2 * (coarse_J - 1))
+    #             if prev_num_coarse_samples >= num_samples:
+    #                 continue
+    #         test_cases.append((sampling_ratio, coarse_J))
+    for sampling_ in range(1, 10, 1):
+        sampling_ratio = sampling_ / 10.0  # from 0.1 to 0.9
+        test_cases.append((sampling_ratio, J_order - 2))  # keep the first J-2 coarse levels, i.e. 6.25% in-order measurements
+        num_samples = int(sampling_ratio * num_pixels)
+        # for coarse_J in range(min_coarse_J, J_order):  # from 0 to J_order-1 (not including J_order because that is 100% sampling)
+        #     if coarse_J > 0:
+        #         prev_num_coarse_samples = 1 << (2 * (coarse_J - 1))
+        #         if prev_num_coarse_samples >= num_samples:
+        #             continue
+        #     test_cases.append((sampling_ratio, coarse_J))
+    test_cases.append((1.0, J_order))  # 100% sampling
+
+    # # sampling_ratios = [0.1]
+    # sampling_ratios = [0.2]
+    # # # sampling_ratios = [0.25]
+    # # sampling_ratios = [0.5]
+    # # # sampling_ratios = [0.7]
+    # # # coarse_Js = [5]  # keep 2^{coarse_J} x 2^{coarse_J} in-order measurements
+    # # # coarse_Js = [7]  # keep 2^{coarse_J} x 2^{coarse_J} in-order measurements
+    # coarse_Js = list(range(0, J_order))
+    # test_cases = []
+    # test_cases += [
+    #     (sampling_ratio, coarse_J)
+    #     for sampling_ratio in sampling_ratios
+    #     for coarse_J in coarse_Js
+    # ]
+    # test_cases = [
+    # #     (0.3, 3),
+    #     # (0.2, 2),
+    #     (0.2, 6),
+    #     # (0.2, 8),
+    #     # (0.2, 7),
+    #     # (0.5, 6),
+    #     # (0.8, 6),
+    #     # (1.0, 6),
+    #     # (1.0, 7),
+    #     # (0.1, 8),
+    # ]
+
+    # test_cases = test_cases[80:]
+
+    test_cases.reverse()
+
+    return test_cases
+
+
+def run_experiments():
+    raw_data: GrayscaleImage2D | Measurement1D = np.load(data_dir / data_filename)
+    print(f"Raw data shape: {raw_data.shape}")
+    print(f"J_order: {J_order}")
+
+    if data_type == "image":
+        ground_truth_image: GrayscaleImage2D = torch.tensor(raw_data, dtype=torch.float32, device=device)
+        if inverses_sign:
+            ground_truth_image = -ground_truth_image
+        J_data = int(np.log2(ground_truth_image.shape[0]))
+        assert J_data == J_order, f"Data J ({J_data}) does not match expected J_order ({J_order})."
+        print(f"Ground truth image shape: {ground_truth_image.shape}")
+        measurement_vector = None
+    elif data_type == "hadamard_measurement_vector":
+        # Reconstruct the image from the Hadamard measurement vector
+        J_data = int(np.log2(raw_data.shape[0]) / 2)
+        assert J_data == J_order, f"Data J ({J_data}) does not match expected J_order ({J_order})."
+        measurement_vector = torch.tensor(raw_data, dtype=torch.float32, device=device)
+        if inverses_sign:
+            measurement_vector = -measurement_vector
+
+        index_of_max = torch.argmax(measurement_vector).item()
+        index_of_min = torch.argmin(measurement_vector).item()
+        print(f"Max value in measurement vector: {measurement_vector[index_of_max].item()} at index {index_of_max}")
+        print(f"Min value in measurement vector: {measurement_vector[index_of_min].item()} at index {index_of_min}")
+        exit()
+
+        pcm_op_full = PhotocurrentMapOp(J=J_order, device=device)
+        with torch.no_grad():
+            ground_truth_image = pcm_op_full.pseudo_inv(measurement_vector)
+        print(f"Reconstructed ground truth image shape from Hadamard measurement vector: {ground_truth_image.shape}")
+
+    elif data_type == "original_measurement_data":
+        # Make a 1D array with num_lines//2 elements,
+        # where each element is the sum of the measured current multiplied by the pattern index sign.
+        num_measurements = raw_data.shape[0]
+        assert num_measurements % 2 == 0, "Number of measurements should be even."
+
+        if inverses_sign:
+            raw_data[:, 1] = -raw_data[:, 1]
+
+        index_of_max_raw = np.argmax(raw_data[:, 1])
+        index_of_min_raw = np.argmin(raw_data[:, 1])
+        min_raw_value = raw_data[index_of_min_raw, 1]
+        max_raw_value = raw_data[index_of_max_raw, 1]
+        print(f"Max value in original measurement data: {max_raw_value} at index {index_of_max_raw}")
+        print(f"Min value in original measurement data: {min_raw_value} at index {index_of_min_raw}")
+        # exit()
+
+        sign_vector = np.round(np.sign(raw_data[:, 0]))
+        sign_vector[:2] = [1.0, -1.0]  # Ensure the first two patterns are +0 and -0
+
+        measurement_vector = torch.tensor((raw_data[:, 1] * sign_vector).reshape(-1, 2).sum(axis=1), dtype=torch.float32, device=device)
+
+        # index_of_max = torch.argmax(measurement_vector).item()
+        # index_of_min = torch.argmin(measurement_vector).item()
+        # min_value = measurement_vector[index_of_min].item()
+        # max_value = measurement_vector[index_of_max].item()
+        # print(f"Max value in measurement vector: {max_value} at index {index_of_max}")
+        # print(f"Min value in measurement vector: {min_value} at index {index_of_min}")
+        # exit()
+
+        pcm_op_full = PhotocurrentMapOp(J=J_order, device=device)
+        print(f"pcm_op_full domain shape: {pcm_op_full.domain_shape}, range shape: {pcm_op_full.range_shape}")
+        with torch.no_grad():
+            ground_truth_image = pcm_op_full.pseudo_inv(measurement_vector)
+        print(f"Reconstructed ground truth image shape from original measurement data: {ground_truth_image.shape}")
+
+    if tests_scale_ground_truth:
+        gt_min, gt_max = ground_truth_image.min().item(), ground_truth_image.max().item()
+        ground_truth_image = (ground_truth_image - gt_min) / (gt_max - gt_min)
+        print(f"Normalized ground truth image to [0, 1]. Min: {ground_truth_image.min().item()}, Max: {ground_truth_image.max().item()}")
+        measurement_vector = None
+
+    test_cases = make_test_cases()
+    # print(f"Total number of test cases: {len(test_cases)}")
+    # print(test_cases)
+    # for sampling_ratio, coarse_J in test_cases:
+    #     sampling_percentage = sampling_ratio * 100
+    #     coarse_percentage = (1<<(2*coarse_J))/(1<<(2*J_order))*100
+    #     print(f"Sampling: {sampling_percentage}%, coarse_J: {coarse_J} ({coarse_percentage}%)")
+    #     assert sampling_percentage >= coarse_percentage, (
+    #         "Sampling percentage must be larger than or equal to coarse percentage. "
+    #         f"Got sampling {sampling_percentage}% and coarse {coarse_percentage}%."
+    #     )
+    # return
+
+    # ### Set a directory to save logs and results
+    #
+    # Each run is stored in a separate subdirectory named with the current date and
+    # time, which makes it easier to keep track of different experiments.
+
+    current_datetime_str = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_log_dir = Path("pcm_demo_output") / f"{current_datetime_str}_{data_name}_{randomizing_scheme}_{num_trials}_trials"
+    experiment_log_dir.mkdir(parents=True, exist_ok=True)
+
+    for i_seed in tqdm(range(num_trials_skip, num_trials), desc="Running trials"):
+        print(f"\n=== Trial {i_seed} ===")
+        log_dir = experiment_log_dir / f"trial_{i_seed}"
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        # %% [markdown]
+        # ## First experiment: PnP-ADMM
+        #
+        # In this section the PCM PnP-ADMM algorithm is tested on the CIGS data.
+
+        # %% [markdown]
+        # Define the prior function using a pre-trained DRUNet denoiser and the
+        # corresponding Plug-and-Play ADMM solver.
+        #
+        # DRUNet is a deep convolutional denoiser proposed by:
+        #
+        # > Kai Zhang, Yawei Li, Wangmeng Zuo, Lei Zhang, Luc Van Gool, and
+        # > Radu Timofte, "Plug-and-Play Image Restoration with Deep Denoiser Prior,"
+        # > IEEE Transactions on Pattern Analysis and Machine Intelligence, 44(10),
+        # > 6360–6376, 2022.
+        #
+        # In the PnP-ADMM framework, the proximal step of a regulariser is replaced by
+        # an off-the-shelf denoiser. Here DRUNet acts as a powerful learned prior for
+        # the PCM inverse problem, while the data fidelity term is handled by ADMM.
+
+        # %%
+        if runs_pnp_admm:
+            method_name = f"pnp_admm_iters={pnp_admm_iters}_eta={pnp_admm_eta}_cg_iters={cg_iters}_drunet_sigma={drunet_sigma}"
+            make_csv(method_name=method_name, log_dir=log_dir)
+            # for delta_divided_by, subtract_from_J in tqdm(test_cases, desc="Running PnP-ADMM experiments"):
+            for sampling_ratio, coarse_J in tqdm(test_cases, desc="Running PnP-ADMM experiments"):
+                run_pcm_demo(
+                    recon_description=f"PnP-ADMM ({pnp_admm_iters} iters, η={pnp_admm_eta}, cg_iters={cg_iters}, σ={drunet_sigma})",
+                    recon_fn=run_pnp_admm,
+                    ground_truth_image=ground_truth_image,
+                    method_name=method_name,
+                    image_name=data_name,
+                    J=J_order,  # image size is 2^J x 2^J
+                    sampling_ratio=sampling_ratio,
+                    coarse_J=coarse_J,
+                    log_dir=log_dir,
+                    device=device,
+                    seed=i_seed,
+                )
+
+
+        # %% [markdown]
+        # The code above runs the PnP-ADMM reconstruction and compares it to the
+        # zero-filled pseudo-inverse.
+        #
+        # Although PnP-ADMM substantially improves PSNR and SSIM, it can smooth out
+        # fine-scale structures. In the context of defect detection, these small
+        # features can be crucial, so high PSNR and SSIM alone are not sufficient to
+        # guarantee that the reconstruction is fit for purpose.
+        #
+        # In the next sections, two compressed sensing baselines with a wavelet
+        # sparsity prior are explored and compared to the PnP-ADMM result.
+
+
+        # %% [markdown]
+        # ## Compressed sensing baseline: FISTA with wavelet sparsity
+        #
+        # This section applies FISTA with an $\ell_1$-penalty on wavelet coefficients
+        # as a classical compressed sensing baseline.
+        #
+        # Let $\Phi$ denote the PCM forward operator and $\Psi$ a 2D wavelet
+        # transform with inverse $\Psi^{-1}$. The composite operator
+        # $A = \Phi \Psi^{-1}$ acts on wavelet coefficients $w$.
+        # FISTA approximately solves the standard $\ell_1$-regularised problem
+        #
+        # $$
+        # \min_w \frac{1}{2} \lVert A w - y \rVert_2^2
+        #     + \lambda \lVert w \rVert_1,
+        # $$
+        #
+        # and the final current map is obtained as $x = \Psi^{-1} w$.
+        #
+        # An optional debiasing step is included at the end to reduce the bias induced
+        # by the $\ell_1$ penalty on the active support.
+
+        # %%
+        if runs_fista_l1:
+            make_csv(method_name="fista_l1", log_dir=log_dir)
+            for sampling_ratio, coarse_J in tqdm(test_cases, desc="Running FISTA-L1 experiments"):
+                run_pcm_demo(
+                    recon_description="FISTA-L1",
+                    recon_fn=run_fista_l1,
+                    ground_truth_image=ground_truth_image,
+                    method_name="fista_l1",
+                    image_name=data_name,
+                    J=J_order,  # image size is 2^J x 2^J
+                    sampling_ratio=sampling_ratio,
+                    coarse_J=coarse_J,
+                    log_dir=log_dir,
+                    device=device,
+                    seed=i_seed,
+                )
+
+        # %% [markdown]
+        # ## Compressed sensing baseline: SPGL1 with wavelet sparsity
+        #
+        # This section applies the SPGL1 algorithm as a second compressed sensing
+        # baseline, again using a wavelet sparsity prior in the same setting
+        # $A = \Phi \Psi^{-1}$.
+        #
+        # SPGL1 is a spectral projected gradient method that efficiently solves
+        # large-scale $\ell_1$-regularised problems and basis pursuit denoising
+        # formulations. In this example it is run with default parameters suitable
+        # for the PCM problem size, followed by the same optional debiasing step
+        # used for FISTA.
+
+        # %%
+        if runs_spgl1:
+            method_name = f"spgl1_factor={factor}"
+            make_csv(method_name=method_name, log_dir=log_dir)
+            for sampling_ratio, coarse_J in tqdm(test_cases, desc="Running SPGL1 experiments"):
+                run_pcm_demo(
+                    recon_description="SPGL1",
+                    recon_fn=run_spgl1,
+                    ground_truth_image=ground_truth_image,
+                    method_name=method_name,
+                    image_name=data_name,
+                    J=J_order,  # image size is 2^J x 2^J
+                    sampling_ratio=sampling_ratio,
+                    coarse_J=coarse_J,
+                    log_dir=log_dir,
+                    device=device,
+                    seed=i_seed,
+                )
+
+if __name__ == "__main__":
+    run_experiments()

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/summary_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05.csv

@@ -0,0 +1,11 @@
+sampling_percentage,coarse_J,mse_zero_filled_mean,psnr_zero_filled_mean,ssim_zero_filled_mean,pearson_corr_zero_filled_mean,mse_recon_mean,psnr_recon_mean,ssim_recon_mean,pearson_corr_recon_mean,mse_zero_filled_std,psnr_zero_filled_std,ssim_zero_filled_std,pearson_corr_zero_filled_std,mse_recon_std,psnr_recon_std,ssim_recon_std,pearson_corr_recon_std,n
+10,7,4.577321377832732e-13,26.68581657409668,0.5460866749286651,0.9895228981971741,4.845509437483367e-13,26.447400093078613,0.4865678519010544,0.988940566778183,2.747539525363654e-15,0.026092503041383216,0.0013199002687654918,6.312568817230495e-05,3.2983797312515565e-14,0.29269311722074554,0.02064134573474785,0.0007512794805552735,10
+20,7,3.701732036133151e-13,27.60795154571533,0.5989194273948669,0.9915354907512665,2.336000777579741e-13,29.60731735229492,0.651189637184143,0.9946685671806336,3.137178442837653e-15,0.036877963295929725,0.003291659152569719,7.204569485275488e-05,2.285493507503449e-15,0.04241552477642319,0.0026020820495530027,5.235156779379575e-05,10
+30,7,2.8407859018701047e-13,28.758569145202635,0.6599215865135193,0.9935105800628662,9.785463576334549e-10,26.151208305358885,0.658670752152102,0.9009748857468367,6.724374142295714e-15,0.1026611100150391,0.0038833435245453725,0.00015412009880880437,3.0938871189990597e-09,15.025927068579044,0.23128292687349342,0.3006414085661137,10
+40,7,3.02571994965483e-12,28.22936267852783,0.6610260783694685,0.8957024264847859,1.2184251275016572e-13,32.43393173217773,0.8076106429100036,0.9972222805023193,8.951547507343075e-12,6.848601873335216,0.23050975130916138,0.3157464930463804,6.712630713554704e-16,0.023983961158662935,0.0013557775101712653,1.534089191895327e-05,10
+50,7,1.0804449443956553e-13,32.958594512939456,0.8253014922142029,0.9975368678569794,7.373676525596584e-14,34.61511154174805,0.882469254732132,0.9983198583126068,4.064335790921844e-15,0.16311467557816042,0.004631825630469115,9.275462146834108e-05,5.096559847829345e-16,0.02996912623934667,0.0006537278649821055,1.1559833870381693e-05,10
+60,7,2.0676279393857296e-14,40.161883163452146,0.9581916928291321,0.9995289802551269,1.2067793964031717e-10,29.65468578338623,0.7057826056610793,0.8856580778956413,2.3800359457929104e-15,0.483339894541071,0.005759792920088761,5.4174681710747504e-05,3.753420216591262e-10,15.973891429485397,0.40668936581470844,0.27689818761031554,10
+70,7,7.730195921680424e-25,144.40994262695312,0.9999943971633913,0.9999998807907104,1.2653307408892478e-11,36.36068525314331,0.8461538221687078,0.9363928645849228,0.0,0.0,0.0,0.0,3.975095970363456e-11,13.081019735288994,0.31815406959639686,0.1953170810180173,10
+80,7,3.4893476996707156e-12,130.75539054870606,0.9149058640003206,0.9013243473134935,1.0621505184722144e-07,35.41357192993164,0.888877101553021,0.901241070497781,1.1034286279226182e-11,43.17948499664643,0.26907356755807477,0.3120394351202002,3.3588145510902706e-07,25.43467270773195,0.31232103893057594,0.31160791422058937,10
+90,7,7.730195921680424e-25,144.40994262695312,0.9999943971633913,0.9999998807907104,6.351319216625248e-08,31.19661202430725,0.7974475137645356,0.8969505732413381,0.0,0.0,0.0,0.0,2.0083366773584134e-07,26.66382464056287,0.35078540704848477,0.3130660849483175,10
+100,9,7.730195921680424e-25,144.40994262695312,0.9999943971633913,0.9999998807907104,1.16154850514784e-13,55.861016273498535,0.9245381057262421,0.9982804000377655,0.0,0.0,0.0,0.0,2.7681096768110227e-13,15.668734542984403,0.16117876664214864,0.003721464893747097,10

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/summary_spgl1_factor=100000.0.csv

@@ -0,0 +1,11 @@
+sampling_percentage,coarse_J,mse_zero_filled_mean,psnr_zero_filled_mean,ssim_zero_filled_mean,pearson_corr_zero_filled_mean,mse_recon_mean,psnr_recon_mean,ssim_recon_mean,pearson_corr_recon_mean,mse_zero_filled_std,psnr_zero_filled_std,ssim_zero_filled_std,pearson_corr_zero_filled_std,mse_recon_std,psnr_recon_std,ssim_recon_std,pearson_corr_recon_std,n
+10,7,4.577321377832732e-13,26.68581657409668,0.5460866749286651,0.9895228981971741,5.82104573961309e-13,25.642960357666016,0.4519068330526352,0.9867122232913971,2.747539525363654e-15,0.026092503041383216,0.0013199002687654918,6.312568817230495e-05,1.3779461329272844e-14,0.10386544028531298,0.003544217817835135,0.00031318145548103396,10
+20,7,3.701732036133151e-13,27.60795154571533,0.5989194273948669,0.9915354907512665,3.946614600880069e-13,27.329791641235353,0.5470067322254181,0.9909889101982117,3.137178442837653e-15,0.036877963295929725,0.003291659152569719,7.204569485275488e-05,3.793865860424568e-15,0.04152391913652081,0.0019400097135512753,8.710962745658316e-05,10
+30,7,2.8407859018701047e-13,28.758569145202635,0.6599215865135193,0.9935105800628662,2.780848251324186e-13,28.85048599243164,0.6403765976428986,0.9936553180217743,6.724374142295714e-15,0.1026611100150391,0.0038833435245453725,0.00015412009880880437,3.985722945295935e-15,0.061905243251344895,0.0027215038043735067,9.135344922038605e-05,10
+40,7,1.942462114551055e-13,30.41118106842041,0.7338571727275849,0.9955673038959503,1.8719070212077846e-13,30.569342422485352,0.7357475101947785,0.9957322597503662,7.364603991949776e-15,0.1663177374559864,0.00394871929847948,0.00016841050235307645,2.4153894702462406e-15,0.05608458635801661,0.0025137509123573567,5.525405795617248e-05,10
+50,7,1.0804449443956553e-13,32.958594512939456,0.8253014922142029,0.9975368678569794,1.1043225456807381e-13,32.86177215576172,0.8336114108562469,0.9974841058254242,4.064335790921844e-15,0.16311467557816042,0.004631825630469115,9.275462146834108e-05,2.341999863897953e-15,0.09157879797849544,0.0031880662095762576,5.336946513087681e-05,10
+60,7,2.0676279393857296e-14,40.161883163452146,0.9581916928291321,0.9995289802551269,3.735755364179128e-14,37.5685848236084,0.9460803687572479,0.999149477481842,2.3800359457929104e-15,0.483339894541071,0.005759792920088761,5.4174681710747504e-05,6.034717250176511e-16,0.07016379432548321,0.0008999243125858531,1.3713680403729624e-05,10
+70,7,7.730195921680424e-25,144.40994262695312,0.9999943971633913,0.9999998807907104,1.695522808118537e-14,41.000235366821286,0.9796806395053863,0.9996139705181122,0.0,0.0,0.0,0.0,4.517539947320165e-16,0.11730617684466839,0.00043715079433543253,1.0251661983246811e-05,10
+80,7,7.730195921680424e-25,144.40994262695312,0.9999943971633913,0.9999998807907104,1.3107117930073741e-14,42.117614364624025,0.9837720215320587,0.9997015476226807,0.0,0.0,0.0,0.0,2.706609651602817e-16,0.08907299027115084,0.000246311117329785,6.156697863173296e-06,10
+90,7,3.489347699670715e-12,130.75539054870606,0.9149058640003206,0.9013243473134935,3.49789726653368e-12,39.97458710670471,0.904051148891449,0.9997849133279588,1.103428627922618e-11,43.17948499664643,0.2690735675580747,0.31203943512020027,1.1031460250654693e-11,11.283053123889394,0.2652601518082523,6.422805739518929e-06,10
+100,9,3.489398353596214e-12,130.75538392066954,0.9149057507514955,0.899984955615946,3.4893983536037253e-12,121.54302430152893,0.914905768632889,0.9999998741679721,1.1034446461003185e-11,43.179505956338176,0.2690739256823043,0.3162749635635694,1.1034446461000548e-11,39.98729358536571,0.26907393196518703,1.986821496531797e-08,10

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_10.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5e851f8ceef9a75b8b96f4923a672d247471874d3615f0a3475d4712f6cb800
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_100.0_percent_coarse_J=9_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0acd32b99c7188ffb30eacfc6f0f0eae72734665c91e0c57c01f389ab059aaed
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_20.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a11dd9cc04298e850793b945609fd16175e542e042805f724caa34702b4f505b
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_30.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b617785a1e8ad22d3b947334e58003ea887b2b253f4aef69ad10f3f273a2c84
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_40.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:569db54687d9cc9c1e6a59d109d2ba5d9aa33223bca5b74a024395d9231d0393
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_50.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fac50c370666bc02d875531eac9a9708d2249ae2090aa0dd2bc8565021b8e858
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_60.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04c89c42326b4a96213d0d929c859f5746ffdaf4d3ec7663ac6a3ba40464aa69
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_70.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46395cf47a3d02e116fc00c58ba2ad7a7456c45d454f486ecb0783e08c41984f
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_80.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8ee6707303bc797db323c2d7b87d0f55c30ebfc6b3484110f24b3b7870614cb
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/masks/sample_90.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:602b361d3d5fc7e94d802bf80bf470c22cb3d34f59d3a8b6cc15b6be11fe01a8
+size 262272

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/metrics.csv

@@ -0,0 +1,11 @@
+sampling_percentage,  coarse_J,  mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon
+100.0,  9,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  3.0571156500389107e-13,  28.438737869262695,  0.5635999441146851,  0.9932395219802856
+90.0,  7,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  6.495478085250233e-15,  45.16575241088867,  0.991489589214325,  0.9998520016670227
+80.0,  7,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  9.541985393013777e-15,  43.49546432495117,  0.9877846837043762,  0.9997828006744385
+70.0,  7,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  1.3766794304472148e-14,  41.903533935546875,  0.9826178550720215,  0.9996863603591919
+60.0,  7,  2.0914551286579236e-14,  40.087371826171875,  0.960663914680481,  0.9995233416557312,  3.035764727706697e-14,  38.469181060791016,  0.9550536870956421,  0.9993087649345398
+50.0,  7,  1.0774910965630907e-13,  32.96772003173828,  0.8285408020019531,  0.9975433945655823,  7.335294481200516e-14,  34.6376838684082,  0.8824563026428223,  0.9983285665512085
+40.0,  7,  1.9622423531959893e-13,  30.364330291748047,  0.7314146757125854,  0.995522141456604,  1.2193951360803257e-13,  32.43041229248047,  0.8069201707839966,  0.997219979763031
+30.0,  7,  2.790239556332147e-13,  28.8354434967041,  0.6602280139923096,  0.9936264157295227,  1.7191386118484142e-13,  30.938751220703125,  0.7327603101730347,  0.9960786700248718
+20.0,  7,  3.6522011543499433e-13,  27.666316986083984,  0.5997718572616577,  0.9916492104530334,  2.3175488221213736e-13,  29.641569137573242,  0.6515334248542786,  0.9947106838226318
+10.0,  7,  4.542611946323216e-13,  26.718807220458984,  0.5458469390869141,  0.9896026253700256,  4.694557459786197e-13,  26.575916290283203,  0.4909258186817169,  0.9892885088920593

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_10.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e855c1951a6081aae0a6dec52c6475c02cf94615860a56c871e1a88e436ddab1
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_100.0_percent_coarse_J=9_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b96fa0fda04020bbe61bfb1a2fa5951808327744e990703327f72dcaa155bf56
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_20.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9768eca66418858e48bd0db747e55ad5029de8597485acb8e823071427045fce
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_30.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4ad425549571e4294964dd5cdc49f21305ab4f5e29ca2fee5fcfd291ed9c439
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_40.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4514e035797f3bc4fdc6d62d148482f7b9fca3223f0b1933db5bc7bca16409d6
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_50.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9ee8ab767e0cc472e63487e409077d0c6c75c1aa54cf69e4fd3049b3eda19d0
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_60.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c2d773e4673c099d4576bdb0106e328654af2d580ecbe6598682346c10dab3d
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_70.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d1eef926e64c8a7c686d8bc81ce9828294dffe7d8bd9c1e54c7ac3819682a0a
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_80.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7581af3f400e8109fcc924fdaecb31e53b4ac4be53f83deebfb616341ce22693
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05/recons/Si_2_256_512x512_pnp_admm_iters=50_eta=0.01_cg_iters=20_drunet_sigma=0.05_sample_90.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:479be8031ec8a00d927710ca2eeffd5d846f52b07083a5e8a1eb87335111aaa2
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/spgl1_factor=100000.0/metrics.csv

@@ -0,0 +1,11 @@
+sampling_percentage,  coarse_J,  mse_zero_filled,  psnr_zero_filled,  ssim_zero_filled,  pearson_corr_zero_filled,  mse_recon,  psnr_recon,  ssim_recon,  pearson_corr_recon
+100.0,  9,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  3.4893983535955186e-11,  7.864355564117432,  0.1491079330444336,  nan
+90.0,  7,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  9.214441140442328e-15,  43.64717102050781,  0.9882020950317383,  0.9997900128364563
+80.0,  7,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  1.3256311264084504e-14,  42.067630767822266,  0.9836277961730957,  0.9996981024742126
+70.0,  7,  7.730195921680424e-25,  144.40994262695312,  0.9999943971633911,  0.9999998807907104,  1.6987554077177794e-14,  40.99055099487305,  0.9795687794685364,  0.9996131062507629
+60.0,  7,  2.0914551286579236e-14,  40.087371826171875,  0.960663914680481,  0.9995233416557312,  3.688636039406862e-14,  37.62320327758789,  0.946416974067688,  0.9991602897644043
+50.0,  7,  1.0774910965630907e-13,  32.96772003173828,  0.8285408020019531,  0.9975433945655823,  1.1306613875413166e-13,  32.75853729248047,  0.8297638893127441,  0.9974240660667419
+40.0,  7,  1.9622423531959893e-13,  30.364330291748047,  0.7314146757125854,  0.995522141456604,  1.8995054010609302e-13,  30.505456924438477,  0.7319666147232056,  0.9956692457199097
+30.0,  7,  2.790239556332147e-13,  28.8354434967041,  0.6602280139923096,  0.9936264157295227,  2.772539413765235e-13,  28.86308479309082,  0.638703465461731,  0.9936745762825012
+20.0,  7,  3.6522011543499433e-13,  27.666316986083984,  0.5997718572616577,  0.9916492104530334,  3.896490877348946e-13,  27.38512420654297,  0.5480653047561646,  0.9911035299301147
+10.0,  7,  4.542611946323216e-13,  26.718807220458984,  0.5458469390869141,  0.9896026253700256,  5.561751146437866e-13,  25.839744567871094,  0.45401573181152344,  0.9873018860816956

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/spgl1_factor=100000.0/recons/Si_2_256_512x512_spgl1_factor=100000.0_sample_10.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:738403f92348064aa4e048b9adc88b408fa65bad5979ec0f19910c642822d303
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/spgl1_factor=100000.0/recons/Si_2_256_512x512_spgl1_factor=100000.0_sample_100.0_percent_coarse_J=9_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:237809b58aed9551781870761b25cd67a990f8af292ea8253c3e1315617cc09b
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/spgl1_factor=100000.0/recons/Si_2_256_512x512_spgl1_factor=100000.0_sample_20.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef597f9490aeb99349b6d047995a63cad0a817cba8dc51b98b46c1829127e813
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/spgl1_factor=100000.0/recons/Si_2_256_512x512_spgl1_factor=100000.0_sample_30.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50216d3cfb90a1c9e2c234b59f996b4f70e33ee1dd24ab5b28fd89a16cf82018
+size 1048704

20260116_170524_Si_2_256_512x512_multilevel_20_trials_pnp_and_spgl1/trial_0/spgl1_factor=100000.0/recons/Si_2_256_512x512_spgl1_factor=100000.0_sample_40.0_percent_coarse_J=7_multilevel_random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63ce9f9226880c6cd89c0c220681d1855e9209db1e4a8edba12a8931364be9b3
+size 1048704