reflectorch 1.0.0__py3-none-any.whl

reflectorch/inference/multilayer_fitter.py

@@ -0,0 +1,171 @@
+from tqdm import trange
+
+from time import perf_counter
+
+import torch
+from torch import nn, Tensor
+
+from reflectorch.data_generation.reflectivity import kinematical_approximation
+from reflectorch.data_generation.priors.multilayer_structures import SimpleMultilayerSampler
+
+
+class MultilayerFit(object):
+    def __init__(self,
+                 q: Tensor,
+                 exp_curve: Tensor,
+                 params: Tensor,
+                 convert_func,
+                 scale_curve_func,
+                 min_bounds: Tensor,
+                 max_bounds: Tensor,
+                 optim_cls=None,
+                 lr: float = 5e-2,
+                 ):
+
+        self.q = q
+        self.scale_curve_func = scale_curve_func
+        self.scaled_exp_curve = self.scale_curve_func(torch.atleast_2d(exp_curve))
+        self.params_to_fit = nn.Parameter(params.clone())
+        self.convert_func = convert_func
+
+        self.min_bounds = min_bounds
+        self.max_bounds = max_bounds
+
+        optim_cls = optim_cls or torch.optim.Adam
+        self.optim = optim_cls([self.params_to_fit], lr)
+
+        self.best_loss = float('inf')
+        self.best_params, self.best_curve = None, None
+
+        self.get_best_solution()
+        self.losses = []
+
+    @classmethod
+    def from_prior_sampler(
+            cls,
+            q: Tensor,
+            exp_curve: Tensor,
+            prior_sampler: SimpleMultilayerSampler,
+            batch_size: int = 2 ** 13,
+            **kwargs
+    ):
+        _, scaled_params = prior_sampler.optimized_sample(batch_size)
+        params = prior_sampler.restore_params2parametrized(scaled_params)
+
+        return cls(
+            q.float(), exp_curve.float(), params.float(),
+            convert_func=get_convert_func(prior_sampler.multilayer_model),
+            scale_curve_func=_save_log, min_bounds=prior_sampler.min_bounds,
+            max_bounds=prior_sampler.max_bounds,
+            **kwargs
+        )
+
+    @classmethod
+    def from_prediction(
+            cls,
+            param: Tensor,
+            prior_sampler,
+            q: Tensor,
+            exp_curve: Tensor,
+            batch_size: int = 2 ** 13,
+            rel_bounds: float = 0.3,
+            **kwargs
+    ):
+
+        num_params = param.shape[-1]
+
+        deltas = prior_sampler.restore_params2parametrized(
+            (torch.rand(batch_size, num_params, device=param.device) * 2 - 1) * rel_bounds
+        ) - prior_sampler.min_bounds
+
+        deltas[0] = 0.
+
+        params = torch.atleast_2d(param) + deltas
+
+        return cls(
+            q.float(), exp_curve.float(), params.float(),
+            convert_func=get_convert_func(prior_sampler.multilayer_model),
+            scale_curve_func=_save_log, min_bounds=prior_sampler.min_bounds,
+            max_bounds=prior_sampler.max_bounds,
+            **kwargs
+        )
+
+    def get_clipped_params(self):
+        return torch.clamp(self.params_to_fit.detach().clone(), self.min_bounds, self.max_bounds)
+
+    def calc_loss(self, reduce=True, clip: bool = False):
+        if clip:
+            params = self.get_clipped_params()
+        else:
+            params = self.params_to_fit
+        curves = self.get_curves(params=params)
+        losses = ((self.scale_curve_func(curves) - self.scaled_exp_curve) ** 2)
+
+        if reduce:
+            return losses.sum()
+        else:
+            return losses.sum(-1)
+
+    def get_curves(self, params: Tensor = None):
+        if params is None:
+            params = self.params_to_fit
+        curves = kinematical_approximation(self.q, **self.convert_func(params))
+        return torch.atleast_2d(curves)
+
+    def run(self, num_iterations: int = 500, disable_tqdm: bool = False):
+        pbar = trange(num_iterations, disable=disable_tqdm)
+
+        for _ in pbar:
+            self.optim.zero_grad()
+            loss = self.calc_loss()
+            loss.backward()
+            self.optim.step()
+            self.losses.append(loss.item())
+            pbar.set_description(f'Loss = {loss.item():.2e}')
+
+    def clear(self):
+        self.losses.clear()
+
+    def run_fixed_time(self, time_limit: float = 2.):
+
+        start = perf_counter()
+
+        while True:
+            self.optim.zero_grad()
+            loss = self.calc_loss()
+            loss.backward()
+            self.optim.step()
+            self.losses.append(loss.item())
+            time_spent = perf_counter() - start
+
+            if time_spent > time_limit:
+                break
+
+    @torch.no_grad()
+    def get_best_solution(self, clip: bool = True):
+        losses = self.calc_loss(clip=clip, reduce=False)
+        idx = torch.argmin(losses)
+        best_loss = losses[idx].item()
+
+        if best_loss < self.best_loss:
+            best_curve = self.get_curves()[idx]
+            best_params = self.params_to_fit.detach()[idx].clone()
+            self.best_params, self.best_curve, self.best_loss = best_params, best_curve, best_loss
+
+        return self.best_params
+
+
+def get_convert_func(multilayer_model):
+    def func(params):
+        params = multilayer_model.to_standard_params(params)
+        return {
+            'thickness': params['thicknesses'],  # very useful transformation indeed ...
+            'roughness': params['roughnesses'],
+            'sld': params['slds'],
+        }
+
+    return func
+
+
+def _save_log(curves, eps: float = 1e-10):
+    return torch.log10(curves + eps)

reflectorch/inference/multilayer_inference_model.py

@@ -0,0 +1,193 @@
+from typing import Tuple
+
+import torch
+from torch import Tensor
+import numpy as np
+
+from reflectorch.inference.inference_model import (
+    InferenceModel,
+)
+from reflectorch.data_generation.reflectivity import kinematical_approximation_np, abeles_np
+
+from reflectorch.data_generation.priors import (
+    MultilayerStructureParams,
+    SimpleMultilayerSampler,
+)
+from reflectorch.inference.record_time import print_time
+from reflectorch.inference.scipy_fitter import standard_refl_fit
+from reflectorch.inference.multilayer_fitter import MultilayerFit
+
+
+class MultilayerInferenceModel(InferenceModel):
+    def predict(self,
+                intensity: np.ndarray,
+                scattering_angle: np.ndarray,
+                attenuation: np.ndarray,
+                priors: np.ndarray = None,
+                preprocessing_parameters: dict = None,
+                polish: bool = True,
+                use_raw_q: bool = False,
+                **kwargs
+                ) -> dict:
+
+        with print_time("everything"):
+            with print_time("preprocess"):
+                preprocessed_dict = self.preprocess(
+                    intensity, scattering_angle, attenuation, **(preprocessing_parameters or {})
+                )
+
+            preprocessed_curve = preprocessed_dict["curve_interp"]
+
+            raw_curve, raw_q = preprocessed_dict["curve"], preprocessed_dict["q_values"]
+
+            with print_time("predict_from_preprocessed_curve"):
+                preprocessed_dict.update(self.predict_from_preprocessed_curve(
+                    preprocessed_curve, priors,
+                    raw_curve=(raw_curve if use_raw_q else None),
+                    raw_q=raw_q,
+                    polish=polish,
+                    use_raw_q=use_raw_q,
+                    **kwargs
+                ))
+
+            return preprocessed_dict
+
+    def predict_from_preprocessed_curve(self,
+                                        curve: np.ndarray,
+                                        priors: np.ndarray = None, *,  # ignore the priors so far
+                                        polish: bool = True,
+                                        raw_curve: np.ndarray = None,
+                                        raw_q: np.ndarray = None,
+                                        clip_prediction: bool = True,
+                                        use_raw_q: bool = False,
+                                        use_sampler: bool = False,
+                                        fitted_time_limit: float = 3.,
+                                        sampler_rel_bounds: float = 0.3,
+                                        polish_with_abeles: bool = False,
+                                        **kwargs
+                                        ) -> dict:
+
+        scaled_curve = self._scale_curve(curve)
+
+        predicted_params, parametrized = self._simple_prediction(scaled_curve)
+
+        if use_sampler:
+            parametrized: Tensor = self._sampler_solution(
+                curve, parametrized,
+                time_limit=fitted_time_limit,
+                rel_bounds=sampler_rel_bounds,
+            )
+
+        init_raw_q = raw_q
+
+        if raw_curve is None:
+            raw_curve = curve
+            raw_q = self.q.squeeze().cpu().numpy()
+            raw_q_t = self.q
+        else:
+            raw_q_t = torch.from_numpy(raw_q).to(self.q)
+
+        # if q_ratio != 1.:
+        #     predicted_params.scale_with_q(q_ratio)
+        #     raw_q = raw_q * q_ratio
+        #     raw_q_t = raw_q_t * q_ratio
+
+        prediction_dict = {
+            "params": parametrized.squeeze().cpu().numpy(),
+            "param_names": list(self._prior_sampler.multilayer_model.PARAMETER_NAMES),
+            "curve_predicted": predicted_params.reflectivity(raw_q_t).squeeze().cpu().numpy()
+        }
+
+        # sld_x_axis, sld_profile, _ = get_density_profiles(
+        #     predicted_params.thicknesses, predicted_params.roughnesses, predicted_params.slds, num=1024,
+        # )
+        #
+        # prediction_dict['sld_profile'] = sld_profile.squeeze().cpu().numpy()
+        # prediction_dict['sld_x_axis'] = sld_x_axis.squeeze().cpu().numpy()
+
+        if polish:
+            prediction_dict.update(self._polish_prediction(
+                raw_q, raw_curve, parametrized, q_values=init_raw_q, use_kinematical=True
+            ))
+        if polish_with_abeles:
+            prediction_dict.update(self._polish_prediction(
+                raw_q, raw_curve, parametrized, q_values=init_raw_q, use_kinematical=False
+            ))
+
+        return prediction_dict
+
+    def _simple_prediction(self, scaled_curve) -> Tuple[MultilayerStructureParams, Tensor]:
+        with torch.no_grad():
+            self.trainer.model.eval()
+            scaled_params = self.trainer.model(scaled_curve)
+
+        predicted_params, parametrized = self._restore_predicted_params(scaled_params)
+        return predicted_params, parametrized
+
+    def _restore_predicted_params(self, scaled_params: Tensor) -> Tuple[MultilayerStructureParams, Tensor]:
+        parametrized = self._prior_sampler.restore_params2parametrized(scaled_params)
+        predicted_params: MultilayerStructureParams = self._prior_sampler.restore_params(scaled_params)
+        return predicted_params, parametrized
+
+    @print_time
+    def _sampler_solution(
+            self,
+            curve: Tensor or np.ndarray,
+            predicted_params: Tensor,
+            batch_size: int = 2 ** 13,
+            time_limit: float = 3.,
+            rel_bounds: float = 0.3,
+    ) -> Tensor:
+
+        fit_obj = MultilayerFit.from_prediction(
+            predicted_params, self._prior_sampler, self.q, torch.as_tensor(curve).to(self.q),
+            batch_size=batch_size, rel_bounds=rel_bounds,
+        )
+
+        fit_obj.run_fixed_time(time_limit)
+
+        best_params = fit_obj.get_best_solution()
+
+        return best_params
+
+    @property
+    def _prior_sampler(self) -> SimpleMultilayerSampler:
+        return self.trainer.loader.prior_sampler
+
+    @print_time
+    def _polish_prediction(self,
+                           q: np.ndarray,
+                           curve: np.ndarray,
+                           predicted_params: Tensor,
+                           q_values: np.ndarray,
+                           use_kinematical: bool = True,
+                           ) -> dict:
+
+        params = predicted_params.squeeze().cpu().numpy()
+        polished_params_dict = {}
+
+        if use_kinematical:
+            refl_generator = kinematical_approximation_np
+        else:
+            refl_generator = abeles_np
+
+        try:
+            polished_params_arr, curve_polished = standard_refl_fit(
+                q, curve, params, restore_params_func=self._prior_sampler.restore_np_params,
+                refl_generator=refl_generator,
+                bounds=self._prior_sampler.get_np_bounds(),
+            )
+            params = self._prior_sampler.restore_np_params(polished_params_arr)
+            if q_values is None:
+                q_values = q
+            curve_polished = abeles_np(q_values, **params)
+
+        except Exception as err:
+            self.log.exception(err)
+            polished_params_arr = params
+            curve_polished = np.zeros_like(q)
+
+        polished_params_dict['params_polished'] = polished_params_arr
+        polished_params_dict['curve_polished'] = curve_polished
+
+        return polished_params_dict

reflectorch/inference/preprocess_exp/__init__.py

@@ -0,0 +1,7 @@
+from reflectorch.inference.preprocess_exp.preprocess import (
+    standard_preprocessing,
+    StandardPreprocessing,
+)
+from reflectorch.inference.preprocess_exp.interpolation import interp_reflectivity
+from reflectorch.inference.preprocess_exp.attenuation import apply_attenuation_correction
+from reflectorch.inference.preprocess_exp.footprint import apply_footprint_correction

reflectorch/inference/preprocess_exp/attenuation.py

@@ -0,0 +1,36 @@
+import numpy as np
+
+
+def apply_attenuation_correction(
+        intensity: np.ndarray,
+        attenuation: np.ndarray,
+        scattering_angle: np.ndarray = None,
+        correct_discontinuities: bool = True
+) -> np.ndarray:
+    """Applies attenuation correction to experimental reflectivity curves
+
+    Args:
+        intensity (np.ndarray): intensities of an experimental reflectivity curve
+        attenuation (np.ndarray): attenuation factors for each measured point
+        scattering_angle (np.ndarray, optional): scattering angles of the measured points. Defaults to None.
+        correct_discontinuities (bool, optional): whether to correct discontinuities in the measured curves. Defaults to True.
+
+    Returns:
+        np.ndarray: the corrected reflectivity curve
+    """
+    intensity = intensity / attenuation
+    if correct_discontinuities:
+        if scattering_angle is None:
+            raise ValueError("correct_discontinuities options requires scattering_angle, but scattering_angle is None.")
+        intensity = apply_discontinuities_correction(intensity, scattering_angle)
+    return intensity
+
+
+def apply_discontinuities_correction(intensity: np.ndarray, scattering_angle: np.ndarray) -> np.ndarray:
+    intensity = intensity.copy()
+    diff_angle = np.diff(scattering_angle)
+    for i in range(len(diff_angle)):
+        if diff_angle[i] == 0:
+            factor = intensity[i] / intensity[i + 1]
+            intensity[(i + 1):] *= factor
+    return intensity

reflectorch/inference/preprocess_exp/cut_with_q_ratio.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+from reflectorch.utils import angle_to_q
+
+
+def cut_curve(q: np.ndarray, curve: np.ndarray, max_q: float, max_angle: float, wavelength: float):
+    """Cuts an experimental reflectivity curve at a maximum q position
+
+    Args:
+        q (np.ndarray): the array of q points
+        curve (np.ndarray): the experimental reflectivity curve
+        max_q (float): the maximum q value at which the curve is cut
+        max_angle (float): the maximum scattering angle at which the curve is cut; only used if max_q is not provided
+        wavelength (float): the wavelength of the beam
+
+    Returns:
+        tuple: the q array after cutting, the reflectivity curve after cutting, and the ratio between the maximum q after cutting and before cutting
+    """
+    if max_angle is None and max_q is None:
+        q_ratio = 1.
+    else:
+        if max_q is None:
+            max_q = angle_to_q(max_angle, wavelength)
+
+        q_ratio = max_q / q.max()
+
+        if q_ratio < 1.:
+            idx = np.argmax(q > max_q)
+            q = q[:idx] / q_ratio
+            curve = curve[:idx]
+    return q, curve, q_ratio

reflectorch/inference/preprocess_exp/footprint.py

@@ -0,0 +1,81 @@
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+import numpy as np
+from scipy.special import erf
+
+__all__ = [
+    "apply_footprint_correction",
+    "remove_footprint_correction",
+    "BEAM_SHAPE",
+]
+
+
+BEAM_SHAPE = Literal["gauss", "box"]
+
+
+def apply_footprint_correction(
+    intensity: np.ndarray,
+    scattering_angle: np.ndarray,
+    beam_width: float,
+    sample_length: float,
+    beam_shape: BEAM_SHAPE = "gauss",
+) -> np.ndarray:
+    """Applies footprint correction to an experimental reflectivity curve
+
+    Args:
+        intensity (np.ndarray): reflectivity curve
+        scattering_angle (np.ndarray): array of scattering angles
+        beam_width (float): the beam width
+        sample_length (float): the sample length
+        beam_shape (BEAM_SHAPE, optional): the shape of the beam, either "gauss" or "box". Defaults to "gauss".
+
+    Returns:
+        np.ndarray: the footprint corrected reflectivity curve
+    """
+    factors = _get_factors_by_beam_shape(
+        scattering_angle, beam_width, sample_length, beam_shape
+    )
+    return intensity.copy() * factors
+
+
+def remove_footprint_correction(
+    intensity: np.ndarray,
+    scattering_angle: np.ndarray,
+    beam_width: float,
+    sample_length: float,
+    beam_shape: BEAM_SHAPE = "gauss",
+):
+    factors = _get_factors_by_beam_shape(
+        scattering_angle, beam_width, sample_length, beam_shape
+    )
+    return intensity.copy() / factors
+
+
+def _get_factors_by_beam_shape(
+    scattering_angle: np.ndarray, beam_width: float, sample_length: float, beam_shape: BEAM_SHAPE
+):
+    if beam_shape == "gauss":
+        return gaussian_factors(scattering_angle, beam_width, sample_length)
+    elif beam_shape == "box":
+        return box_factors(scattering_angle, beam_width, sample_length)
+    else:
+        raise ValueError("invalid beam shape")
+
+
+def box_factors(scattering_angle, beam_width, sample_length):
+    max_angle = 2 * np.arcsin(beam_width / sample_length) / np.pi * 180
+    ratios = beam_footprint_ratio(scattering_angle, beam_width, sample_length)
+    ones = np.ones_like(scattering_angle)
+    return np.where(scattering_angle < max_angle, ones * ratios, ones)
+
+
+def gaussian_factors(scattering_angle, beam_width, sample_length):
+    ratio = beam_footprint_ratio(scattering_angle, beam_width, sample_length)
+    return 1 / erf(np.sqrt(np.log(2)) / ratio)
+
+
+def beam_footprint_ratio(scattering_angle, beam_width, sample_length):
+    return beam_width / sample_length / np.sin(scattering_angle / 2 * np.pi / 180)

reflectorch/inference/preprocess_exp/interpolation.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+def interp_reflectivity(q_interp, q, reflectivity, min_value: float = 1e-10):
+    """Interpolate data on a base 10 logarithmic scale
+
+    Args:
+        q_interp (array-like): reciprocal space points used for the interpolation
+        q (array-like): reciprocal space points of the measured reflectivity curve
+        reflectivity (array-like): reflectivity curve measured at the points ``q``
+        min_value (float, optional): minimum intensity of the reflectivity curve. Defaults to 1e-10.
+
+    Returns:
+        array-like: interpolated reflectivity curve
+    """
+    return 10 ** np.interp(q_interp, q, np.log10(np.clip(reflectivity, min_value, None)))

reflectorch/inference/preprocess_exp/normalize.py

@@ -0,0 +1,21 @@
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+import numpy as np
+from numpy import ndarray
+
+NORMALIZE_MODE = Literal["first", "max", "incoming_intensity"]
+
+
+def intensity2reflectivity(intensity: ndarray, mode: NORMALIZE_MODE, incoming_intensity=None) -> np.ndarray:
+    if mode == "first":
+        return intensity / intensity[0]
+    if mode == "max":
+        return intensity / intensity.max()
+    if mode == "incoming_intensity":
+        if incoming_intensity is None:
+            raise ValueError("incoming_intensity is None")
+        return intensity / incoming_intensity
+    raise ValueError(f"Unknown mode {mode}")

reflectorch/inference/preprocess_exp/preprocess.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+from reflectorch.inference.preprocess_exp.interpolation import interp_reflectivity
+from reflectorch.inference.preprocess_exp.footprint import apply_footprint_correction, BEAM_SHAPE
+from reflectorch.inference.preprocess_exp.normalize import intensity2reflectivity, NORMALIZE_MODE
+from reflectorch.inference.preprocess_exp.attenuation import apply_attenuation_correction
+from reflectorch.inference.preprocess_exp.cut_with_q_ratio import cut_curve
+from reflectorch.utils import angle_to_q
+
+
+def standard_preprocessing(
+        intensity: np.ndarray,
+        scattering_angle: np.ndarray,
+        attenuation: np.ndarray,
+        q_interp: np.ndarray,
+        wavelength: float,
+        beam_width: float,
+        sample_length: float,
+        min_intensity: float = 1e-10,
+        beam_shape: BEAM_SHAPE = "gauss",
+        normalize_mode: NORMALIZE_MODE = "max",
+        incoming_intensity: float = None,
+        max_q: float = None,  # if provided, max_angle is ignored
+        max_angle: float = None,
+) -> dict:
+    """Preprocesses a raw experimental reflectivity curve by applying attenuation correction, footprint correction, cutting at a maximum q value and interpolation
+
+    Args:
+        intensity (np.ndarray): array of intensities of the reflectivity curve
+        scattering_angle (np.ndarray): array of scattering angles
+        attenuation (np.ndarray): attenuation factors for each measured point
+        q_interp (np.ndarray): reciprocal space points used for the interpolation
+        wavelength (float): the wavelength of the beam
+        beam_width (float): the beam width
+        sample_length (float): the sample length
+        min_intensity (float, optional): intensities lower than this value are removed. Defaults to 1e-10.
+        beam_shape (BEAM_SHAPE, optional): the shape of the beam, either "gauss" or "box". Defaults to "gauss".
+        normalize_mode (NORMALIZE_MODE, optional): normalization mode, either "first", "max" or "incoming_intensity". Defaults to "max".
+        incoming_intensity (float, optional): array of intensities for the "incoming_intensity" normalization. Defaults to None.
+        max_q (float, optional): the maximum q value at which the curve is cut. Defaults to None.
+        max_angle (float, optional): the maximum scattering angle at which the curve is cut; only used if max_q is not provided. Defaults to None.
+
+    Returns:
+        dict: dictionary containing the interpolated reflectivity curve, the curve before interpolation, the q values before interpolation, the q values after interpolation and the q ratio of the cutting
+    """
+    intensity = apply_attenuation_correction(
+        intensity,
+        attenuation,
+        scattering_angle,
+    )
+
+    intensity = apply_footprint_correction(
+        intensity, scattering_angle, beam_width=beam_width, sample_length=sample_length, beam_shape=beam_shape
+    )
+
+    curve = intensity2reflectivity(intensity, normalize_mode, incoming_intensity)
+
+    curve, scattering_angle = remove_low_statistics(curve, scattering_angle, thresh=min_intensity)
+
+    q = angle_to_q(scattering_angle, wavelength)
+
+    q, curve, q_ratio = cut_curve(q, curve, max_q, max_angle, wavelength)
+
+    curve_interp = interp_reflectivity(q_interp, q, curve)
+
+    assert np.all(np.isfinite(curve_interp))
+    assert np.all(np.isfinite(curve))
+    assert np.all(np.isfinite(q))
+    assert np.all(np.isfinite(q_interp))
+    assert np.all(curve > 0.)
+    assert np.all(curve_interp > 0.)
+
+    return {
+        "curve_interp": curve_interp, "curve": curve, "q_values": q, "q_interp": q_interp, "q_ratio": q_ratio,
+    }
+
+
+def remove_low_statistics(curve, scattering_angle, thresh: float = 1e-7):
+    indices = (curve > thresh) & np.isfinite(curve)
+    return curve[indices], scattering_angle[indices]
+
+
+@dataclass
+class StandardPreprocessing:
+    q_interp: np.ndarray = None
+    wavelength: float = 1.
+    beam_width: float = None
+    sample_length: float = None
+    beam_shape: BEAM_SHAPE = "gauss"
+    normalize_mode: NORMALIZE_MODE = "max"
+    incoming_intensity: float = None
+
+    def preprocess(self,
+                   intensity: np.ndarray,
+                   scattering_angle: np.ndarray,
+                   attenuation: np.ndarray,
+                   **kwargs
+                   ) -> dict:
+        attrs = self._get_updated_attrs(**kwargs)
+        return standard_preprocessing(
+            intensity,
+            scattering_angle,
+            attenuation,
+            **attrs
+        )
+
+    __call__ = preprocess
+
+    def set_parameters(self, **kwargs) -> None:
+        for k, v in kwargs.items():
+            if k in self.__annotations__:
+                setattr(self, k, v)
+            else:
+                raise KeyError(f'Unknown parameter {k}.')
+
+    def _get_updated_attrs(self, **kwargs):
+        current_attrs = {k: getattr(self, k) for k in self.__annotations__.keys()}
+        current_attrs.update(kwargs)
+        return current_attrs