Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions src/ptychi/api/options/pie.py
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,9 @@

@dataclass
class PIEReconstructorOptions(base.ReconstructorOptions):

displayed_loss_function: enums.LossFunctions | None = None
"""Displayed metric; None uses the magnitude mean squared noise-model loss."""

def get_reconstructor_type(self) -> enums.Reconstructors:
return enums.Reconstructors.PIE
Expand Down
116 changes: 107 additions & 9 deletions src/ptychi/forward_models.py
Original file line number Diff line number Diff line change
Expand Up @@ -1259,6 +1259,91 @@ def nll(self, y_pred: Tensor, y_true: Tensor, reduction: str = "mean") -> Tensor
"""
raise NotImplementedError

def project_to_propagated_magnitude_constraint(
self,
psi: Tensor,
actual_pattern_intensity: Tensor,
constrained_pixel_mask: Optional[Tensor] = None,
*,
forward_model: Optional[PlanarPtychographyForwardModel] = None,
) -> Tensor:
"""
Project the propagated exit wave onto the measured intensity constraint.

With no blur, the target wave intensity is
max((data - offset) / gain, 0). Phase and relative mode amplitudes
are preserved. Masked and unmeasured pixels remain unchanged.
Data below the offset project to zero intensity. Both grids use internal
FFT ordering; detector pixels are zero-inserted by the crop adjoint.
A fixed identity response on a matching grid retains the historical 1e-7
amplitude stabilization, including its zero-wave behavior. Other
cases use exact norm replacement, choosing the first mode's phase
as zero when the input wave vanishes. Blur requires LSQML or autodiff.

Parameters
----------
psi : Tensor
Complex detector-plane wave, shaped (batch, incoherent_modes, H, W).
actual_pattern_intensity : Tensor
Measured intensities, shaped (batch, detector_height, detector_width).
constrained_pixel_mask : Tensor, optional
If given, only pixels where this mask is True are constrained. Other pixels
are left unchanged from `psi`. Defaults to the noise model's valid-pixel
mask combined with its measured-intensity threshold.
forward_model : PlanarPtychographyForwardModel, optional
Supplies detector response and crop geometry for the projection.
If omitted, measurements must be on the wave grid and are assumed
to have no blur, gain or offset correction, or crop.

Returns
-------
Tensor
Exit wave with the measured total intensity, or the inverse-response
intensity when a response map is present, on constrained detector pixels.
"""

wave_shape = psi.shape[-2:]
same_grid = wave_shape == actual_pattern_intensity.shape[-2:]
target = actual_pattern_intensity
identity_response = True
if forward_model is not None:
if forward_model.diffraction_pattern_blur_sigma is not None:
raise ValueError(
"Magnitude projection requires diffraction_pattern_blur_sigma=None. "
"Use LSQML or autodiff for blur."
)
response = forward_model.detector_response
identity_response = response.is_identity
if not identity_response:
target = (target - response.offset) / response.gain
elif not same_grid:
raise ValueError(
"Pass forward_model to magnitude projection when detector and wave grids differ."
)
target = target.clamp_min(0)
mask = (
get_constrained_pixel_mask(
self.valid_pixel_mask, self.exclude_measured_pixels_below,
actual_pattern_intensity,
)
if constrained_pixel_mask is None else constrained_pixel_mask
)
if forward_model is not None:
target = forward_model.detector_crop_adjoint(target, wave_shape)
mask = forward_model.detector_crop_adjoint(mask, wave_shape)
intensity = psi.abs().square().sum(1)
if identity_response and same_grid:
# Preserve the original same-grid amplitude stabilization.
psi_prime = (
psi / (intensity.sqrt()[:, None] + 1e-7) * (target + 1e-7).sqrt()[:, None]
)
else:
scale = (target / torch.where(intensity > 0, intensity, 1)).sqrt()
psi_prime = psi * scale[:, None]
# A zero wave has no phase; choose the first mode to satisfy the norm.
psi_prime[:, 0] = torch.where(intensity > 0, psi_prime[:, 0], target.sqrt())
return torch.where(mask[:, None] if mask.ndim == 3 else mask, psi_prime, psi)

def backward(self, *args, **kwargs):
raise NotImplementedError

Expand Down Expand Up @@ -1301,23 +1386,36 @@ def backward_to_psi_far(
return gradient[:, None] * psi_far


class GaussianNoiseModel(NoiseModel):
class MagnitudeMeanSquaredNoiseModel(NoiseModel):
"""Mean squared amplitude residual for intensity inputs.

The NLL is MSE(sqrt(y_pred + 1e-7), sqrt(y_true + 1e-7)), with the
requested reduction. Callers select constrained pixels before evaluation.
"""

def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.loss_function = MSELossOfSqrt()

def nll(self, y_pred: Tensor, y_true: Tensor, reduction: str = "mean") -> Tensor:
validate_predicted_intensity(y_pred)
return torch.nn.functional.mse_loss(
torch.sqrt(y_pred + self.loss_function.eps),
torch.sqrt(y_true + self.loss_function.eps),
reduction=reduction,
)


class GaussianNoiseModel(MagnitudeMeanSquaredNoiseModel):
def __init__(self, sigma: float = 0.5, eps: float = 1e-9, *args, **kwargs) -> None:
super().__init__(eps=eps, *args, **kwargs)
self.noise_statistics = "gaussian"
self.sigma = sigma
self.loss_function = MSELossOfSqrt()

def nll(self, y_pred: Tensor, y_true: Tensor, reduction: str = "mean") -> Tensor:
# This is averaged over all pixels, so it differs from Eq. 11a in Odstrcil (2018)
# by a factor of 1 / y_pred.numel().
validate_predicted_intensity(y_pred)
loss = torch.nn.functional.mse_loss(
torch.sqrt(y_pred + self.loss_function.eps),
torch.sqrt(y_true + self.loss_function.eps),
reduction=reduction,
) / self.sigma**2 * 0.5
return loss
return super().nll(y_pred, y_true, reduction=reduction) / self.sigma**2 * 0.5


class PtychographyGaussianNoiseModel(GaussianNoiseModel):
Expand Down
85 changes: 14 additions & 71 deletions src/ptychi/reconstructors/base.py
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,6 @@
import ptychi.api.enums as enums
import ptychi.io_handles as io
import ptychi.image_proc as ip
from ptychi.metrics import MSELossOfSqrt
from ptychi.parallel import MultiprocessMixin
if TYPE_CHECKING:
import ptychi.data_structures.parameter_group as pg
Expand Down Expand Up @@ -733,6 +732,10 @@ def __init__(
)
self.forward_model = None
self.build_forward_model()
self.noise_model = fm.MagnitudeMeanSquaredNoiseModel(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
)

def build_forward_model(self):
self.forward_model = fm.PlanarPtychographyForwardModel(
Expand All @@ -748,15 +751,23 @@ def build_forward_model(self):
diffraction_pattern_blur_sigma=self.options.forward_model_options.diffraction_pattern_blur_sigma,
)

def build_loss_tracker(self):
f = (
self.noise_model.nll
if self.displayed_loss_function is None
else self.displayed_loss_function
)
self.loss_tracker = LossTracker(metric_function=f)

def compute_optimizer_loss(self, input_data, y_true):
"""Use the masked mean squared amplitude residual for projection algorithms."""
"""Evaluate the masked likelihood of the configured noise model."""
y_pred = self.forward_model(*input_data)
mask = get_constrained_pixel_mask(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
y_true=y_true,
)
return MSELossOfSqrt()(y_pred[mask], y_true[mask])
return self.noise_model.nll(y_pred[mask], y_true[mask])

def stabilize_object_projection_denominator(self, denominator: Tensor) -> Tensor:
"""Floor full-object projection weights at 5% of their maximum.
Expand Down Expand Up @@ -823,74 +834,6 @@ def prepare_data(self, *args, **kwargs):
self.parameter_group.probe.normalize_eigenmodes()
logger.info("Probe eigenmodes normalized.")

def replace_propagated_exit_wave_magnitude(
self,
psi: Tensor,
actual_pattern_intensity: Tensor,
constrained_pixel_mask: Optional[Tensor] = None,
) -> Tensor:
"""
Project the propagated exit wave onto the measured intensity constraint.

With no blur, the target wave intensity is
max((data - offset) / gain, 0). Phase and relative mode amplitudes
are preserved. Masked and unmeasured pixels remain unchanged.
Data below the offset project to zero intensity. Both grids use internal
FFT ordering; detector pixels are zero-inserted by the crop adjoint.
A fixed identity response on a matching grid retains the historical 1e-7
amplitude stabilization, including its zero-wave behavior. Other
cases use exact norm replacement, choosing the first mode's phase
as zero when the input wave vanishes. Blur requires LSQML or autodiff.

Parameters
----------
psi : Tensor
Predicted exit wave propagated to the detector plane.
actual_pattern_intensity : Tensor
The measured diffraction pattern at the detector.
constrained_pixel_mask : Tensor, optional
If given, only pixels where this mask is True are constrained. Other pixels
are left unchanged from `psi`.

Returns
-------
Tensor
Exit wave with the measured total intensity, or the inverse-response
intensity when a response map is present, on constrained detector pixels.
"""

model = self.forward_model
if model.diffraction_pattern_blur_sigma is not None:
raise ValueError(
"Magnitude projection requires diffraction_pattern_blur_sigma=None. "
"Use LSQML or autodiff for blur."
)
target = actual_pattern_intensity
if not model.detector_response.is_identity:
target = (target - model.detector_response.offset) / model.detector_response.gain
target = target.clamp_min(0)
mask = (
self.dataset.valid_pixel_mask
if constrained_pixel_mask is None else constrained_pixel_mask
)
target = model.detector_crop_adjoint(target, psi.shape[-2:])
mask = model.detector_crop_adjoint(mask, psi.shape[-2:])
intensity = psi.abs().square().sum(1)
if (
model.detector_response.is_identity
and psi.shape[-2:] == actual_pattern_intensity.shape[-2:]
):
# Preserve the original same-grid amplitude stabilization.
psi_prime = (
psi / (intensity.sqrt()[:, None] + 1e-7) * (target + 1e-7).sqrt()[:, None]
)
else:
scale = (target / torch.where(intensity > 0, intensity, 1)).sqrt()
psi_prime = psi * scale[:, None]
# A zero wave has no phase; choose the first mode to satisfy the norm.
psi_prime[:, 0] = torch.where(intensity > 0, psi_prime[:, 0], target.sqrt())
return torch.where(mask[:, None] if mask.ndim == 3 else mask, psi_prime, psi)

@timer()
def adjoint_shift_probe_update_direction(self, indices, delta_p, first_mode_only=None):
"""
Expand Down
3 changes: 2 additions & 1 deletion src/ptychi/reconstructors/dm.py
Original file line number Diff line number Diff line change
Expand Up @@ -244,14 +244,15 @@ def apply_dm_update_to_exit_wave_chunk(
2 * new_psi - self.psi[start_pt:end_pt]
)
# Replace intensities
revised_psi = self.replace_propagated_exit_wave_magnitude(
revised_psi = self.noise_model.project_to_propagated_magnitude_constraint(
revised_psi,
y_true[start_pt:end_pt],
constrained_pixel_mask=get_constrained_pixel_mask(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
y_true=y_true[start_pt:end_pt],
),
forward_model=self.forward_model,
)
# Propagate back to sample plane
revised_psi = self.forward_model.free_space_propagator.propagate_backward(revised_psi)
Expand Down
19 changes: 0 additions & 19 deletions src/ptychi/reconstructors/lsqml.py
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,6 @@
from ptychi.utils import get_constrained_pixel_mask
from ptychi.reconstructors.base import (
AnalyticalIterativePtychographyReconstructor,
LossTracker,
)
import ptychi.forward_models as fm
from ptychi.metrics import validate_predicted_intensity
Expand Down Expand Up @@ -311,24 +310,6 @@ def build(self) -> None:
self.build_cached_variables()
self.build_noise_model()

def compute_optimizer_loss(self, input_data, y_true):
"""Evaluate the masked likelihood of the configured noise model."""
y_pred = self.forward_model(*input_data)
mask = get_constrained_pixel_mask(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
y_true=y_true,
)
return self.noise_model.nll(y_pred[mask], y_true[mask])

def build_loss_tracker(self):
f = (
self.noise_model.nll
if self.displayed_loss_function is None
else self.displayed_loss_function
)
self.loss_tracker = LossTracker(metric_function=f)

def build_noise_model(self):
self.noise_model = self.noise_model.to(torch.get_default_device())

Expand Down
3 changes: 2 additions & 1 deletion src/ptychi/reconstructors/magpie.py
Original file line number Diff line number Diff line change
Expand Up @@ -341,14 +341,15 @@ def compute_updates(self, indices: Tensor, y_true: Tensor):
variables = self.forward_model.intermediate_variables
object_old = variables["obj_patches"][:, :1]
probe_old = variables.shifted_unique_probes[0]
psi_prime = self.replace_propagated_exit_wave_magnitude(
psi_prime = self.noise_model.project_to_propagated_magnitude_constraint(
variables["psi_far"],
y_true,
constrained_pixel_mask=get_constrained_pixel_mask(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
y_true=y_true,
),
forward_model=self.forward_model,
)
psi_prime = self.forward_model.free_space_propagator.propagate_backward(psi_prime)
delta_psi = psi_prime - variables["psi"]
Expand Down
9 changes: 2 additions & 7 deletions src/ptychi/reconstructors/pie.py
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,6 @@
from ptychi.reconstructors.base import (
AnalyticalIterativePtychographyReconstructor,
)
from ptychi.metrics import MSELossOfSqrt
from ptychi.timing.timer_utils import timer

if TYPE_CHECKING:
Expand Down Expand Up @@ -51,11 +50,6 @@ def __init__(
**kwargs,
)

def build_loss_tracker(self):
if self.displayed_loss_function is None:
self.displayed_loss_function = MSELossOfSqrt()
return super().build_loss_tracker()

def check_inputs(self, *args, **kwargs):
for var in self.parameter_group.get_optimizable_parameters():
if "lr" not in var.optimizer_params.keys():
Expand Down Expand Up @@ -93,14 +87,15 @@ def compute_updates(
psi_far = self.forward_model.intermediate_variables["psi_far"]
unique_probes = self.forward_model.intermediate_variables.shifted_unique_probes

psi_prime = self.replace_propagated_exit_wave_magnitude(
psi_prime = self.noise_model.project_to_propagated_magnitude_constraint(
psi_far,
y_true,
constrained_pixel_mask=get_constrained_pixel_mask(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
y_true=y_true,
),
forward_model=self.forward_model,
)
psi_prime = self.forward_model.free_space_propagator.propagate_backward(psi_prime)

Expand Down
3 changes: 2 additions & 1 deletion src/ptychi/reconstructors/raar.py
Original file line number Diff line number Diff line change
Expand Up @@ -190,14 +190,15 @@ def calculate_exit_wave_chunk(self, start_pt: int, end_pt: int) -> Tensor:
@timer()
def apply_data_projection(self, exit_wave: Tensor, y_true: Tensor) -> Tensor:
propagated_exit_wave = self.forward_model.free_space_propagator.propagate_forward(exit_wave)
propagated_exit_wave = self.replace_propagated_exit_wave_magnitude(
propagated_exit_wave = self.noise_model.project_to_propagated_magnitude_constraint(
propagated_exit_wave,
y_true,
constrained_pixel_mask=get_constrained_pixel_mask(
valid_pixel_mask=self.dataset.valid_pixel_mask,
exclude_measured_pixels_below=self.options.exclude_measured_pixels_below,
y_true=y_true,
),
forward_model=self.forward_model,
)
return self.forward_model.free_space_propagator.propagate_backward(propagated_exit_wave)

Expand Down
Loading
Loading