deepinv 0.1.0.dev0__py3-none-any.whl

deepinv/unfolded/deep_equilibrium.py

@@ -0,0 +1,163 @@
+import torch
+from deepinv.optim.fixed_point import FixedPoint
+from deepinv.optim.optim_iterators import *
+from deepinv.unfolded.unfolded import BaseUnfold
+from deepinv.optim.optimizers import create_iterator
+from deepinv.optim.data_fidelity import L2
+
+
+class BaseDEQ(BaseUnfold):
+    r"""
+    Base class for deep equilibrium (DEQ) algorithms. Child of :class:`deepinv.unfolded.BaseUnfold`.
+
+    Enables to turn any fixed-point algorithm into a DEQ algorithm, i.e. an algorithm
+    that can be virtually unrolled infinitely leveraging the implicit function theorem.
+    The backward pass is performed using fixed point iterations to find solutions of the fixed-point equation
+
+    .. math::
+
+        \begin{equation}
+        v = \left(\frac{\partial \operatorname{FixedPoint}(x^\star)}{\partial x^\star} \right )^T v + u.
+        \end{equation}
+
+    where :math:`u` is the incoming gradient from the backward pass,
+    and :math:`x^\star` is the equilibrium point of the forward pass.
+
+    See `this tutorial <http://implicit-layers-tutorial.org/deep_equilibrium_models/>`_ for more details.
+
+    For now DEQ is only possible with PGD, HQS and GD optimization algorithms.
+
+    :param int max_iter_backward: Maximum number of backward iterations. Default: ``50``.
+    :param bool anderson_acceleration_backward: if True, the Anderson acceleration is used at iteration of fixed-point algorithm for computing the backward pass. Default: ``False``.
+    :param int history_size_backward: size of the history used for the Anderson acceleration for the backward pass. Default: ``5``.
+    :param float beta_anderson_acc_backward: momentum of the Anderson acceleration step for the backward pass. Default: ``1.0``.
+    :param float eps_anderson_acc_backward: regularization parameter of the Anderson acceleration step for the backward pass. Default: ``1e-4``.
+    """
+
+    def __init__(
+        self,
+        *args,
+        max_iter_backward=50,
+        anderson_acceleration_backward=False,
+        history_size_backward=5,
+        beta_anderson_acc_backward=1.0,
+        eps_anderson_acc_backward=1e-4,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.max_iter_backward = max_iter_backward
+        self.anderson_acceleration = anderson_acceleration_backward
+        self.history_size = history_size_backward
+        self.beta_anderson_acc = beta_anderson_acc_backward
+        self.eps_anderson_acc = eps_anderson_acc_backward
+
+    def forward(self, y, physics, x_gt=None, compute_metrics=False):
+        r"""
+        The forward pass of the DEQ algorithm. Compared to :class:`deepinv.unfolded.BaseUnfold`, the backward algorithm is performed using fixed point iterations.
+
+        :param torch.Tensor y: Input tensor.
+        :param deepinv.Physics physics: Physics object.
+        :param torch.Tensor x_gt: (optional) ground truth image, for plotting the PSNR across optim iterations.
+        :param bool compute_metrics: whether to compute the metrics or not. Default: ``False``.
+        :return: If ``compute_metrics`` is ``False``,  returns (:class:`torch.Tensor`) the output of the algorithm.
+                Else, returns (:class:`torch.Tensor`, dict) the output of the algorithm and the metrics.
+        """
+        with torch.no_grad():  # Perform the forward pass without gradient tracking
+            X, metrics = self.fixed_point(
+                y, physics, x_gt=x_gt, compute_metrics=compute_metrics
+            )
+        # Once, at the equilibrium point, performs one additional iteration with gradient tracking.
+        cur_data_fidelity = self.update_data_fidelity_fn(self.max_iter - 1)
+        cur_prior = self.update_prior_fn(self.max_iter - 1)
+        cur_params = self.update_params_fn(self.max_iter - 1)
+        x = self.fixed_point.iterator(
+            X, cur_data_fidelity, cur_prior, cur_params, y, physics
+        )["est"][0]
+        # Another iteration for jacobian computation via automatic differentiation.
+        x0 = x.clone().detach().requires_grad_()
+        f0 = self.fixed_point.iterator(
+            {"est": (x0,)}, cur_data_fidelity, cur_prior, cur_params, y, physics
+        )["est"][0]
+
+        # Add a backwards hook that takes the incoming backward gradient `X["est"][0]` and solves the fixed point equation
+        def backward_hook(grad):
+            class backward_iterator(OptimIterator):
+                def __init__(self, **kwargs):
+                    super().__init__(**kwargs)
+
+                def forward(self, X, *args, **kwargs):
+                    return {
+                        "est": (
+                            torch.autograd.grad(f0, x0, X["est"][0], retain_graph=True)[
+                                0
+                            ]
+                            + grad,
+                        )
+                    }
+
+            # Use the :class:`deepinv.optim.fixed_point.FixedPoint` class to solve the fixed point equation
+            def init_iterate_fn(y, physics, F_fn=None):
+                return {"est": (grad,)}  # initialize the fixed point algorithm.
+
+            backward_FP = FixedPoint(
+                backward_iterator(),
+                init_iterate_fn=init_iterate_fn,
+                max_iter=self.max_iter_backward,
+                check_conv_fn=self.check_conv_fn,
+                anderson_acceleration=self.anderson_acceleration,
+                history_size=self.history_size,
+                beta_anderson_acc=self.beta_anderson_acc,
+                eps_anderson_acc=self.eps_anderson_acc,
+            )
+            g = backward_FP({"est": (grad,)}, None)[0]["est"][0]
+            return g
+
+        if x.requires_grad:
+            x.register_hook(backward_hook)
+
+        if compute_metrics:
+            return x, metrics
+        else:
+            return x
+
+
+def DEQ_builder(
+    iteration,
+    params_algo={"lambda": 1.0, "stepsize": 1.0},
+    data_fidelity=L2(),
+    prior=None,
+    F_fn=None,
+    g_first=False,
+    **kwargs,
+):
+    r"""
+    Helper function for building an instance of the :meth:`BaseDEQ` class.
+
+    :param str, deepinv.optim.optim_iterators.OptimIterator iteration: either the name of the algorithm to be used,
+        or directly an optim iterator.
+        If an algorithm name (string), should be either ``"PGD"`` (proximal gradient descent), ``"ADMM"`` (ADMM),
+        ``"HQS"`` (half-quadratic splitting), ``"CP"`` (Chambolle-Pock) or ``"DRS"`` (Douglas Rachford).
+    :param dict params_algo: dictionary containing all the relevant parameters for running the algorithm,
+                            e.g. the stepsize, regularisation parameter, denoising standard deviation.
+                            Each value of the dictionary can be either Iterable (distinct value for each iteration) or
+                            a single float (same value for each iteration).
+                            Default: ``{"stepsize": 1.0, "lambda": 1.0}``. See :any:`optim-params` for more details.
+    :param list, deepinv.optim.DataFidelity: data-fidelity term.
+                            Either a single instance (same data-fidelity for each iteration) or a list of instances of
+                            :meth:`deepinv.optim.DataFidelity` (distinct data-fidelity for each iteration). Default: `None`.
+    :param list, deepinv.optim.Prior prior: regularization prior.
+                            Either a single instance (same prior for each iteration) or a list of instances of
+                            deepinv.optim.Prior (distinct prior for each iteration). Default: `None`.
+    :param callable F_fn: Custom user input cost function. default: None.
+    :param bool g_first: whether to perform the step on :math:`g` before that on :math:`f` before or not. default: False
+    :param kwargs: additional arguments to be passed to the :meth:`BaseUnfold` class.
+    """
+    iterator = create_iterator(iteration, prior=prior, F_fn=F_fn, g_first=g_first)
+    return BaseDEQ(
+        iterator,
+        has_cost=iterator.has_cost,
+        data_fidelity=data_fidelity,
+        prior=prior,
+        params_algo=params_algo,
+        **kwargs,
+    )

deepinv/unfolded/unfolded.py

@@ -0,0 +1,87 @@
+import torch
+import torch.nn as nn
+from deepinv.optim.optim_iterators import *
+from deepinv.optim.optimizers import BaseOptim, create_iterator
+
+
+class BaseUnfold(BaseOptim):
+    r"""
+    Base class for unfolded algorithms. Child of :class:`deepinv.optim.BaseOptim`.
+
+    Enables to turn any iterative optimization algorithm into an unfolded algorithm, i.e. an algorithm
+    that can be trained end-to-end, with learnable parameters. Recall that the algorithms have the
+    following form (see :meth:`deepinv.optim.optim_iterators.BaseIterator`):
+
+    .. math::
+        \begin{aligned}
+        z_{k+1} &= \operatorname{step}_f(x_k, z_k, y, A, \lambda, \gamma, ...)\\
+        x_{k+1} &= \operatorname{step}_g(x_k, z_k, y, A, \sigma, ...)
+        \end{aligned}
+
+    where :math:`\operatorname{step}_f` and :math:`\operatorname{step}_g` are learnable modules. 
+    These modules encompass trainable parameters of the algorithm (e.g. stepsize :math:`\gamma`, regularization parameter :math:`\lambda`, prior parameter (`g_param`) :math:`\sigma` ...)
+    as well as trainable priors (e.g. a deep denoiser).
+
+    :param list trainable_params: List of parameters to be trained. Each parameter should be a key of the ``params_algo`` dictionary for the :class:`deepinv.optim.optim_iterators.BaseIterator` class.
+                    This does not encompass the trainable weights of the prior module . 
+    :param torch.device device: Device on which to perform the computations. Default: `torch.device("cpu")`.
+    :param args:  Non-keyword arguments to be passed to the :class:`deepinv.optim.BaseOptim` class.
+    :param kwargs: Keyword arguments to be passed to the :class:`deepinv.optim.BaseOptim` class.
+    """
+
+    def __init__(self, *args, trainable_params=[], device="cpu", **kwargs):
+        super().__init__(*args, **kwargs)
+        # Each parameter in `init_params_algo` is a list, which is converted to a `nn.ParameterList` if they should be trained.
+        for param_key in trainable_params:
+            if param_key in self.init_params_algo.keys():
+                param_value = self.init_params_algo[param_key]
+                self.init_params_algo[param_key] = nn.ParameterList(
+                    [nn.Parameter(torch.tensor(el).to(device)) for el in param_value]
+                )
+        self.init_params_algo = nn.ParameterDict(self.init_params_algo)
+        self.params_algo = self.init_params_algo.copy()
+        # The prior (list of instances of :class:`deepinv.optim.Prior) is converted to a `nn.ModuleList` to be trainable.
+        self.prior = nn.ModuleList(self.prior)
+        self.data_fidelity = nn.ModuleList(self.data_fidelity)
+
+
+def unfolded_builder(
+    iteration,
+    params_algo={"lambda": 1.0, "stepsize": 1.0},
+    data_fidelity=None,
+    prior=None,
+    F_fn=None,
+    g_first=False,
+    **kwargs,
+):
+    r"""
+    Helper function for building an instance of the :meth:`BaseUnfold` class.
+
+    :param str, deepinv.optim.optim_iterators.OptimIterator iteration: either the name of the algorithm to be used,
+        or directly an optim iterator.
+        If an algorithm name (string), should be either ``"PGD"`` (proximal gradient descent), ``"ADMM"`` (ADMM),
+        ``"HQS"`` (half-quadratic splitting), ``"CP"`` (Chambolle-Pock) or ``"DRS"`` (Douglas Rachford).
+    :param dict params_algo: dictionary containing all the relevant parameters for running the algorithm,
+                            e.g. the stepsize, regularisation parameter, denoising standard deviation.
+                            Each value of the dictionary can be either Iterable (distinct value for each iteration) or
+                            a single float (same value for each iteration).
+                            Default: ``{"stepsize": 1.0, "lambda": 1.0}``. See :any:`optim-params` for more details.
+    :param list, deepinv.optim.DataFidelity: data-fidelity term.
+                            Either a single instance (same data-fidelity for each iteration) or a list of instances of
+                            :meth:`deepinv.optim.DataFidelity` (distinct data-fidelity for each iteration). Default: `None`.
+    :param list, deepinv.optim.Prior prior: regularization prior.
+                            Either a single instance (same prior for each iteration) or a list of instances of
+                            deepinv.optim.Prior (distinct prior for each iteration). Default: `None`.
+    :param callable F_fn: Custom user input cost function. default: None.
+    :param bool g_first: whether to perform the step on :math:`g` before that on :math:`f` before or not. default: False
+    :param kwargs: additional arguments to be passed to the :meth:`BaseUnfold` class.
+    """
+    iterator = create_iterator(iteration, prior=prior, F_fn=F_fn, g_first=g_first)
+    return BaseUnfold(
+        iterator,
+        has_cost=iterator.has_cost,
+        data_fidelity=data_fidelity,
+        prior=prior,
+        params_algo=params_algo,
+        **kwargs,
+    )

deepinv/utils/__init__.py

@@ -0,0 +1,17 @@
+from .logger import AverageMeter, ProgressMeter, get_timestamp
+from .nn import save_model, load_checkpoint, investigate_model
+from .metric import cal_psnr, cal_mse, cal_psnr_complex
+from .plotting import (
+    rescale_img,
+    plot,
+    torch2cpu,
+    plot_curves,
+    plot_parameters,
+    make_grid,
+    wandb_imgs,
+    wandb_plot_curves,
+    resize_pad_square_tensor,
+)
+from .demo import load_url_image
+from .nn import get_freer_gpu, TensorList, rand_like, zeros_like, randn_like, ones_like
+from .phantoms import RandomPhantomDataset, SheppLoganDataset

deepinv/utils/demo.py

@@ -0,0 +1,171 @@
+import requests
+import shutil
+import os
+import zipfile
+import torch
+import torchvision
+import numpy as np
+from torchvision import transforms
+from PIL import Image
+from io import BytesIO
+from tqdm import tqdm
+
+
+class MRIData(torch.utils.data.Dataset):
+    """fastMRI dataset (knee subset)."""
+
+    def __init__(
+        self, root_dir, train=True, sample_index=None, tag=900, transform=None
+    ):
+        x = torch.load(str(root_dir) + ".pt")
+        x = x.squeeze()
+        self.transform = transform
+
+        if train:
+            self.x = x[:tag]
+        else:
+            self.x = x[tag:, ...]
+
+        self.x = torch.stack([self.x, torch.zeros_like(self.x)], dim=1)
+
+        if sample_index is not None:
+            self.x = self.x[sample_index].unsqueeze(0)
+
+    def __getitem__(self, index):
+        x = self.x[index]
+
+        if self.transform is not None:
+            x = self.transform(x)
+
+        return x
+
+    def __len__(self):
+        return len(self.x)
+
+
+def get_git_root():
+    import git
+
+    git_repo = git.Repo(".", search_parent_directories=True)
+    git_root = git_repo.git.rev_parse("--show-toplevel")
+    return git_root
+
+
+def get_image_dataset_url(dataset_name, file_type="zip"):
+    return (
+        "https://huggingface.co/datasets/deepinv/images/resolve/main/"
+        + dataset_name
+        + "."
+        + file_type
+        + "?download=true"
+    )
+
+
+def get_degradation_url(file_name):
+    return (
+        "https://huggingface.co/datasets/deepinv/degradations/resolve/main/"
+        + file_name
+        + "?download=true"
+    )
+
+
+def get_image_url(file_name):
+    return (
+        "https://huggingface.co/datasets/deepinv/images/resolve/main/"
+        + file_name
+        + "?download=true"
+    )
+
+
+def load_dataset(
+    dataset_name, data_dir, transform, download=True, url=None, train=True
+):
+    dataset_dir = data_dir / dataset_name
+    if dataset_name == "fastmri_knee_singlecoil":
+        file_type = "pt"
+    else:
+        file_type = "zip"
+    if download and not dataset_dir.exists():
+        dataset_dir.mkdir(parents=True, exist_ok=True)
+        if url is None:
+            url = get_image_dataset_url(dataset_name, file_type)
+        response = requests.get(url, stream=True)
+        total_size_in_bytes = int(response.headers.get("content-length", 0))
+        block_size = 1024  # 1 Kibibyte
+        print("Downloading " + str(dataset_dir) + f".{file_type}")
+        progress_bar = tqdm(total=total_size_in_bytes, unit="iB", unit_scale=True)
+        with open(str(dataset_dir) + f".{file_type}", "wb") as file:
+            for data in response.iter_content(block_size):
+                progress_bar.update(len(data))
+                file.write(data)
+        progress_bar.close()
+
+        if file_type == "zip":
+            with zipfile.ZipFile(str(dataset_dir) + ".zip") as zip_ref:
+                zip_ref.extractall(str(data_dir))
+            # remove temp file
+            os.remove(str(dataset_dir) + f".{file_type}")
+            print(f"{dataset_name} dataset downloaded in {data_dir}")
+        else:
+            shutil.move(
+                str(dataset_dir) + f".{file_type}",
+                str(dataset_dir / dataset_name) + f".{file_type}",
+            )
+    if dataset_name == "fastmri_knee_singlecoil":
+        dataset = MRIData(
+            train=train, root_dir=dataset_dir / dataset_name, transform=transform
+        )
+    else:
+        dataset = torchvision.datasets.ImageFolder(
+            root=dataset_dir, transform=transform
+        )
+    return dataset
+
+
+def load_degradation(name, data_dir, index=0, download=True):
+    path = data_dir / name
+    if download and not path.exists():
+        data_dir.mkdir(parents=True, exist_ok=True)
+        url = get_degradation_url(name)
+        with requests.get(url, stream=True) as r:
+            with open(str(data_dir / name), "wb") as f:
+                shutil.copyfileobj(r.raw, f)
+        print(f"{name} degradation downloaded in {data_dir}")
+    deg = np.load(path, allow_pickle=True)
+    deg_torch = torch.from_numpy(deg[index])  # .unsqueeze(0).unsqueeze(0)
+    return deg_torch
+
+
+def load_url_image(
+    url=None, img_size=None, grayscale=False, resize_mode="crop", device="cpu"
+):
+    r"""
+
+    Load an image from a URL and return a torch.Tensor.
+
+    :param str url: URL of the image file.
+    :param int, tuple[int] img_size: Size of the image to return.
+    :param bool grayscale: Whether to convert the image to grayscale.
+    :param str resize_mode: If ``img_size`` is not None, options are ``"crop"`` or ``"resize"``.
+    :param str device: Device on which to load the image (gpu or cpu).
+    :return: :class:`torch.Tensor` containing the image.
+    """
+
+    response = requests.get(url)
+    img = Image.open(BytesIO(response.content))
+    transform_list = []
+    if img_size is not None:
+        if resize_mode == "crop":
+            transform_list.append(transforms.CenterCrop(img_size))
+        elif resize_mode == "resize":
+            transform_list.append(transforms.Resize(img_size))
+        else:
+            raise ValueError(
+                f"resize_mode must be either 'crop' or 'resize', got {resize_mode}"
+            )
+    if grayscale:
+        transform_list.append(transforms.Grayscale())
+    transform_list.append(transforms.ToTensor())
+    transform = transforms.Compose(transform_list)
+    x = transform(img).unsqueeze(0).to(device)
+    return x

deepinv/utils/logger.py

@@ -0,0 +1,93 @@
+import os
+import csv
+from datetime import datetime
+
+
+# utils
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+
+    def __init__(self, name, fmt=":f"):
+        self.name = name
+        self.fmt = fmt
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+    def __str__(self):
+        fmtstr = "{name}={avg" + self.fmt + "}"
+        return fmtstr.format(**self.__dict__)
+
+
+class ProgressMeter(object):
+    def __init__(self, num_epochs, meters, surfix="", prefix=""):
+        self.epoch_fmtstr = self._get_epoch_fmtstr(num_epochs)
+        self.meters = meters
+        self.surfix = surfix
+        self.prefix = prefix
+
+    def display(self, epoch):
+        entries = [self.surfix]
+        entries += [get_timestamp()]
+        entries += [self.epoch_fmtstr.format(epoch)]
+        entries += [str(meter) for meter in self.meters]
+        entries += [self.prefix]
+        print("\t".join(entries))
+
+    def _get_epoch_fmtstr(self, num_epochs):
+        num_digits = len(str(num_epochs // 1))
+        fmt = "{:" + str(num_digits) + "d}"
+        return "[" + fmt + "/" + fmt.format(num_epochs) + "]"
+
+
+# --------------------------------
+# logger
+# --------------------------------
+def get_timestamp():
+    return datetime.now().strftime("%y-%m-%d-%H:%M:%S")
+
+
+class LOG(object):
+    def __init__(self, filepath, filename, field_name):
+        self.filepath = filepath
+        self.filename = filename
+        self.field_name = field_name
+
+        self.logfile, self.logwriter = csv_log(
+            file_name=os.path.join(filepath, filename + ".csv"), field_name=field_name
+        )
+        self.logwriter.writeheader()
+
+    def record(self, *args):
+        dict = {}
+        for i in range(len(self.field_name)):
+            dict[self.field_name[i]] = args[i]
+        self.logwriter.writerow(dict)
+
+    def close(self):
+        self.logfile.close()
+
+    def print(self, msg):
+        logT(msg)
+
+
+def csv_log(file_name, field_name):
+    assert file_name is not None
+    assert field_name is not None
+    logfile = open(file_name, "w")
+    logwriter = csv.DictWriter(logfile, fieldnames=field_name)
+    return logfile, logwriter
+
+
+def logT(*args, **kwargs):
+    print(get_timestamp(), *args, **kwargs)

deepinv/utils/metric.py

@@ -0,0 +1,87 @@
+import torch
+
+
+def norm(a):
+    return a.pow(2).sum(dim=3).sum(dim=2).sqrt().unsqueeze(2).unsqueeze(3)
+
+
+def cal_angle(a, b):
+    norm_a = (a * a).flatten().sum().sqrt()
+    norm_b = (b * b).flatten().sum().sqrt()
+    angle = (a * b).flatten().sum() / (norm_a * norm_b)
+    angle = angle.acos() / 3.14159265359
+    return angle.detach().cpu().numpy()
+
+
+def cal_psnr(a, b, max_pixel=1, normalize=False):
+    r"""
+    Computes the peak signal-to-noise ratio (PSNR)
+
+    If the tensors have size (N, C, H, W), then the PSNR is computed as
+
+    .. math::
+        \text{PSNR} = \frac{20}{N} \log_{10} \frac{MAX_I}{\sqrt{\|a- b\|^2_2 / (CHW) }}
+
+    where :math:`MAX_I` is the maximum possible pixel value of the image (e.g. 1.0 for a
+    normalized image), and :math:`a` and :math:`b` are the estimate and reference images.
+
+    :param torch.Tensor a: tensor estimate
+    :param torch.Tensor b: tensor reference
+    :param float max_pixel: maximum pixel value
+    :param bool normalize: if ``True``, a is normalized to have the same norm as b.
+    """
+    with torch.no_grad():
+        if type(a) is list or type(a) is tuple:
+            a = a[0]
+            b = b[0]
+
+        if normalize:
+            an = a / norm(a) * norm(b)
+        else:
+            an = a
+
+        mse = (an - b).pow(2).reshape(an.shape[0], -1).mean(dim=1)
+        mse[mse == 0] = 1e-10
+        psnr = 20 * torch.log10(max_pixel / mse.sqrt())
+
+    return psnr.mean().detach().cpu().item()
+
+
+def cal_mse(a, b):
+    """Computes the mean squared error (MSE)"""
+    with torch.no_grad():
+        mse = torch.mean((a - b) ** 2)
+    return mse
+
+
+def cal_psnr_complex(a, b):
+    """
+    first permute the dimension, such that the last dimension of the tensor is 2 (real, imag)
+    :param a: shape [N,2,H,W]
+    :param b: shape [N,2,H,W]
+    :return: psnr value
+    """
+    a = complex_abs(a.permute(0, 2, 3, 1))
+    b = complex_abs(b.permute(0, 2, 3, 1))
+    return cal_psnr(a, b)
+
+
+def complex_abs(data):
+    """
+    Compute the absolute value of a complex valued input tensor.
+    Args:
+        data (torch.Tensor): A complex valued tensor, where the size of the final dimension
+            should be 2.
+    Returns:
+        torch.Tensor: Absolute value of data
+    """
+    assert data.size(-1) == 2
+    return (data**2).sum(dim=-1).sqrt()
+
+
+def norm_psnr(a, b, complex=False):
+    return cal_psnr(
+        (a - a.min()) / (a.max() - a.min()),
+        (b - b.min()) / (b.max() - b.min()),
+        complex=complex,
+    )