deepinv 0.1.0.dev0__py3-none-any.whl

deepinv/utils/plotting.py

@@ -0,0 +1,312 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from torchvision.utils import make_grid
+import wandb
+import math
+import torch
+import matplotlib.pyplot as plt
+from pathlib import Path
+from collections.abc import Iterable
+import matplotlib
+import shutil
+import torchvision.transforms as T
+import torchvision.transforms.functional as F
+
+matplotlib.rcParams.update({"font.size": 17})
+matplotlib.rcParams["lines.linewidth"] = 2
+from matplotlib.ticker import MaxNLocator
+
+plt.rcParams["text.usetex"] = True if shutil.which("latex") else False
+
+
+def resize_pad_square_tensor(tensor, size):
+    r"""
+    Resize a tensor BxCxWxH to a square tensor BxCxsizexsize with the same aspect ratio thanks to zero-padding.
+
+    :param torch.Tensor tensor: the tensor to resize.
+    :param int size: the new size.
+    :return torch.Tensor: the resized tensor.
+    """
+
+    class SquarePad:
+        def __call__(self, image):
+            W, H = image.size
+            print(W, H)
+            max_wh = np.max([W, H])
+            hp = int((max_wh - W) / 2)
+            vp = int((max_wh - H) / 2)
+            padding = (hp, vp, hp, vp)
+            return F.pad(image, padding, fill=0, padding_mode="constant")
+
+    transform = T.Compose([T.ToPILImage(), SquarePad(), T.Resize(size), T.ToTensor()])
+    return torch.stack([transform(el) for el in tensor])
+
+
+def torch2cpu(img):
+    if img.shape[1] == 2:  # for complex images (e.g. in MRI)
+        img = img.pow(2).sum(dim=1, keepdim=True).sqrt()
+
+    return (
+        img[0, :, :, :]
+        .clamp(min=0.0, max=1.0)
+        .detach()
+        .permute(1, 2, 0)
+        .squeeze()
+        .cpu()
+        .numpy()
+    )
+
+
+def tensor2uint(img):
+    img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy()
+    if img.ndim == 3:
+        img = np.transpose(img, (1, 2, 0))
+    return np.uint8((img * 255.0).round())
+
+
+def numpy2uint(img):
+    img = img.clip(0, 1)
+    return np.uint8((img * 255.0).round())
+
+
+def rescale_img(img, rescale_mode="min_max"):
+    if rescale_mode == "min_max":
+        img = (img - img.min()) / (img.max() - img.min())
+    elif rescale_mode == "clip":
+        img = img.clamp(min=0.0, max=1.0)
+    else:
+        raise ValueError("rescale_mode has to be either 'min_max' or 'clip'.")
+    return img
+
+
+def plot(
+    img_list,
+    titles=None,
+    save_dir=None,
+    tight=True,
+    max_imgs=4,
+    rescale_mode="min_max",
+    show=True,
+    return_fig=False,
+):
+    r"""
+    Plots a list of images.
+
+    The images should be of shape [B,C,H,W], where B is the batch size, C is the number of channels,
+    H is the height and W is the width. The images are plotted in a grid, where the number of rows is B
+    and the number of columns is the length of the list. If the B is bigger than max_imgs, only the first
+    batches are plotted.
+
+    Example usage:
+
+    ::
+        import torch
+        from deepinv.utils import plot
+        img = torch.rand(4, 3, 256, 256)
+        plot([img, img, img], titles=["img1", "img2", "img3"], save_dir="test.png")
+
+    :param list[torch.Tensor], torch.Tensor img_list: list of images to plot or single image.
+    :param list[str] titles: list of titles for each image, has to be same length as img_list.
+    :param str save_dir: path to save the plot.
+    :param bool tight: use tight layout.
+    :param int max_imgs: maximum number of images to plot.
+    :param str rescale_mode: rescale mode, either 'min_max' (images are linearly rescaled between 0 and 1 using their min and max values) or 'clip' (images are clipped between 0 and 1).
+    :param bool show: show the image plot.
+    :param bool return_fig: return the figure object.
+    """
+    if save_dir:
+        save_dir = Path(save_dir)
+        save_dir.mkdir(parents=True, exist_ok=True)
+
+    if isinstance(img_list, torch.Tensor):
+        img_list = [img_list]
+
+    if isinstance(titles, str):
+        titles = [titles]
+
+    imgs = []
+    for im in img_list:
+        col_imgs = []
+        for i in range(min(im.shape[0], max_imgs)):
+            if im.shape[1] == 2:  # for complex images
+                pimg = (
+                    im[i, :, :, :]
+                    .pow(2)
+                    .sum(dim=0)
+                    .sqrt()
+                    .unsqueeze(0)
+                    .type(torch.float32)
+                )
+            else:
+                pimg = im[i, :, :, :].type(torch.float32)
+            pimg = rescale_img(pimg, rescale_mode=rescale_mode)
+            col_imgs.append(pimg.detach().permute(1, 2, 0).squeeze().cpu().numpy())
+        imgs.append(col_imgs)
+
+    fig, axs = plt.subplots(
+        len(imgs[0]),
+        len(imgs),
+        figsize=(len(imgs) * 2, len(imgs[0]) * 2),
+        squeeze=False,
+    )
+
+    # plt.figure(figsize=(len(imgs) * 2, len(imgs[0]) * 2))
+    for i, row_imgs in enumerate(imgs):
+        for r, img in enumerate(row_imgs):
+            axs[r, i].imshow(img, cmap="gray")
+            if titles and r == 0:
+                axs[r, i].set_title(titles[i], size=9)
+            axs[r, i].axis("off")
+    if tight:
+        plt.subplots_adjust(hspace=0.01, wspace=0.05)
+    if save_dir:
+        plt.savefig(save_dir / "images.png", dpi=1200)
+        for i, row_imgs in enumerate(imgs):
+            for r, img in enumerate(row_imgs):
+                plt.imsave(
+                    save_dir / (titles[i] + "_" + str(r) + ".png"), img, cmap="gray"
+                )
+    if show:
+        plt.show()
+
+    if return_fig:
+        return fig
+
+
+def plot_curves(metrics, save_dir=None, show=True):
+    r"""
+    Plots the metrics of a Plug-and-Play algorithm.
+
+    :param dict metrics: dictionary of metrics to plot.
+    :param str save_dir: path to save the plot.
+    :param bool show: show the image plot.
+    """
+    if save_dir:
+        save_dir = Path(save_dir)
+        save_dir.mkdir(parents=True, exist_ok=True)
+    fig, axs = plt.subplots(
+        1, len(metrics.keys()), figsize=(6 * len(metrics.keys()), 4)
+    )
+    for i, metric_name in enumerate(metrics.keys()):
+        metric_val = metrics[metric_name]
+        if len(metric_val) > 0:
+            batch_size, n_iter = len(metric_val), len(metric_val[0])
+            axs[i].spines["right"].set_visible(False)
+            axs[i].spines["top"].set_visible(False)
+            if metric_name == "residual":
+                label = (
+                    r"Residual $\frac{||x_{k+1} - x_k||}{||x_k||}$"
+                    if plt.rcParams["text.usetex"]
+                    else "residual"
+                )
+                log_scale = True
+            elif metric_name == "psnr":
+                label = r"$PSNR(x_k)$" if plt.rcParams["text.usetex"] else "PSNR"
+                log_scale = False
+            elif metric_name == "cost":
+                label = r"$F(x_k)$" if plt.rcParams["text.usetex"] else "F"
+                log_scale = True
+            else:
+                label = metric_name
+                log_scale = False
+            for b in range(batch_size):
+                if not log_scale:
+                    axs[i].plot(metric_val[b], "-o", label=f"batch {b+1}")
+                else:
+                    axs[i].semilogy(metric_val[b], "-o", label=f"batch {b+1}")
+            axs[i].xaxis.set_major_locator(MaxNLocator(integer=True))
+            # axs[i].set_xlabel("iterations")
+            axs[i].set_title(label)
+            axs[i].legend()
+    plt.subplots_adjust(hspace=0.1)
+    if save_dir:
+        plt.savefig(save_dir / "curves.png")
+    if show:
+        plt.show()
+
+
+def wandb_imgs(imgs, captions, n_plot):
+    wandb_imgs = []
+    for i in range(len(imgs)):
+        wandb_imgs.append(
+            wandb.Image(
+                make_grid(imgs[i][:n_plot], nrow=int(math.sqrt(n_plot)) + 1),
+                caption=captions[i],
+            )
+        )
+    return wandb_imgs
+
+
+def wandb_plot_curves(metrics, batch_idx=0, step=0):
+    for metric_name, metric_val in zip(metrics.keys(), metrics.values()):
+        if len(metric_val) > 0:
+            batch_size, n_iter = len(metric_val), len(metric_val[0])
+            wandb.log(
+                {
+                    f"{metric_name} batch {batch_idx}": wandb.plot.line_series(
+                        xs=range(n_iter),
+                        ys=metric_val,
+                        keys=[f"image {j}" for j in range(batch_size)],
+                        title=f"{metric_name} batch {batch_idx}",
+                        xname="iteration",
+                    )
+                },
+                step=step,
+            )
+
+
+def plot_parameters(model, init_params=None, save_dir=None, show=True):
+    r"""
+    Plot the parameters of the model before and after training.
+    This can be used after training Unfolded optimization models.
+
+    :param torch.nn.Module model: the model whose parameters are plotted. The parameters are contained in the dictionary
+        ``params_algo`` attribute of the model.
+    :param dict init_params: the initial parameters of the model, before training. Defaults to ``None``.
+    :param str, Path save_dir: the directory where to save the plot. Defaults to ``None``.
+    :param show bool: whether to show the plot. Defaults to ``True``.
+    """
+
+    color = ["b", "g", "r", "c", "m", "y", "k", "w"]
+
+    fig, ax = plt.subplots(figsize=(7, 7))
+
+    for key, value in zip(init_params.keys(), init_params.values()):
+        if not isinstance(value, Iterable):
+            init_params[key] = [value]
+
+    def get_param(param):
+        if torch.is_tensor(param):
+            if len(param.shape) > 0:
+                return param[0].mean().item()
+            else:
+                return param.item()
+        else:
+            return param
+
+    for i, name_param in enumerate(model.params_algo):
+        value = [
+            get_param(model.params_algo[name_param][k])
+            for k in range(len(model.params_algo[name_param]))
+        ]
+        if init_params is not None and name_param in init_params:
+            value_init = [
+                get_param(init_params[name_param][k])
+                for k in range(len(init_params[name_param]))
+            ]
+            ax.plot(value_init, "--o", label="init. " + name_param, color=color[i])
+            ax.plot(value, "-o", label="learned " + name_param, color=color[i])
+
+    # Set labels and title
+    ax.set_facecolor("white")
+    ax.set_xticks(np.arange(len(value), step=5))
+    ax.set_xlabel("Layer index")
+    ax.set_ylabel("Value")
+    ax.grid(True, linestyle="-", alpha=0.5, color="lightgray")
+    ax.tick_params(color="lightgray")
+    ax.legend()
+
+    if show:
+        plt.show()
+    if save_dir:
+        plt.savefig(Path(save_dir) / "parameters.png")

deepinv-0.1.0.dev0.dist-info/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, deepinv
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deepinv-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.1
+Name: deepinv
+Version: 0.1.0.dev0
+Summary: Pytorch library for solving inverse problems with deep learning
+Author: Matthieu Terris, Samuel Hurault, Dongdong Chen
+Author-email: Julian Tachella <tachellajulian@gmail.com>
+License: BSD 3-Clause
+Project-URL: Homepage, https://deepinv.github.io/
+Project-URL: Source, https://github.com/deepinv/deepinv
+Project-URL: Tracker, https://github.com/deepinv/deepinv/issues
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: hdf5storage
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: einops
+Requires-Dist: wandb
+Requires-Dist: fastmri
+Provides-Extra: denoisers
+Requires-Dist: bm3d ; extra == 'denoisers'
+Requires-Dist: timm ; extra == 'denoisers'
+Provides-Extra: doc
+Requires-Dist: sphinx ; extra == 'doc'
+Requires-Dist: sphinx-gallery ; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
+Requires-Dist: sphinxemoji ; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: coverage ; extra == 'test'
+
+.. image:: https://github.com/deepinv/deepinv/raw/main/docs/source/figures/deepinv_logolarge.png
+   :width: 500px
+   :alt: deepinv logo
+   :align: center
+
+
+|Test Status| |Docs Status| |Python 3.6+| |codecov| |Black| |discord| |colab|
+
+
+Introduction
+------------
+Deep Inverse is an open-source pytorch library for solving imaging inverse problems using deep learning. The goal of ``deepinv`` is to accelerate the development of deep learning based methods for imaging inverse problems, by combining popular learning-based reconstruction approaches in a common and simplified framework, standarizing forward imaging models and simplifying the creation of imaging datasets.
+
+With ``deepinv`` you can:
+
+
+* Large collection of `predefined imaging operators <https://deepinv.github.io/deepinv/deepinv.physics.html>`_ (MRI, CT, deblurring, inpainting, etc.)
+* `Training losses <https://deepinv.github.io/deepinv/deepinv.loss.html>`_ for inverse problems (self-supervised learning, regularization, etc.).
+* Many `pretrained deep denoisers <https://deepinv.github.io/deepinv/deepinv.models.html>`_ which can be used for `plug-and-play restoration <https://deepinv.github.io/deepinv/deepinv.pnp.html>`_.
+* Framework for `building datasets <https://deepinv.github.io/deepinv/deepinv.datasets.html>`_ for inverse problems.
+* Easy-to-build `unfolded architectures <https://deepinv.github.io/deepinv/deepinv.unfolded.html>`_ (ADMM, forward-backward, deep equilibrium, etc.).
+* `Sampling algorithms <https://deepinv.github.io/deepinv/deepinv.sampling.html>`_ for uncertainty quantification (Langevin, diffusion, etc.).
+* A large number of well-explained `examples <https://deepinv.github.io/deepinv/auto_examples/index.html>`_, from basics to state-of-the-art methods.
+
+.. image:: https://github.com/deepinv/deepinv/raw/main/docs/source/figures/deepinv_schematic.png
+   :width: 1000px
+   :alt: deepinv schematic
+   :align: center
+
+
+Documentation
+-------------
+
+Read the documentation and examples at `https://deepinv.github.io <https://deepinv.github.io>`_.
+
+Install
+-------
+
+To install the latest stable release of ``deepinv``, you can simply do:
+
+.. code-block:: bash
+
+    pip install deepinv
+
+You can also install the latest version of ``deepinv`` directly from github:
+
+.. code-block:: bash
+
+    pip install git+https://github.com/deepinv/deepinv.git#egg=deepinv
+
+Getting Started
+---------------
+Try out the following plug-and-play image inpainting example:
+
+.. code-block:: python
+
+    import deepinv as dinv
+    from deepinv.utils import load_url_image
+
+    url = ("https://huggingface.co/datasets/deepinv/images/resolve/main/cameraman.png?download=true")
+    x = load_url_image(url=url, img_size=512, grayscale=True, device='cpu')
+
+    physics = dinv.physics.Inpainting((1, 512, 512), mask = 0.5, \
+                                       noise_model=dinv.physics.GaussianNoise(sigma=0.01))
+
+    data_fidelity = dinv.optim.data_fidelity.L2()
+    prior = dinv.optim.prior.PnP(denoiser=dinv.models.MedianFilter())
+    model = dinv.optim.optim_builder(iteration="HQS", prior=prior, data_fidelity=data_fidelity, \
+                                     params_algo={"stepsize": 1.0, "g_param": 0.1, "lambda": 2.})
+    y = physics(x)
+    x_hat = model(y, physics)
+    dinv.utils.plot([x, y, x_hat], ["signal", "measurement", "estimate"], rescale_mode='clip')
+
+
+Also try out `one of the examples <https://deepinv.github.io/deepinv/auto_examples/index.html>`_ to get started.
+
+Contributing
+------------
+
+DeepInverse is a community-driven project and welcomes contributions of all forms.
+We are ultimately aiming for a comprehensive library of inverse problems and deep learning,
+and we need your help to get there!
+The preferred way to contribute to ``deepinv`` is to fork the `main
+repository <https://github.com/deepinv/deepinv/>`_ on GitHub,
+then submit a "Pull Request" (PR). See our `contributing guide <https://deepinv.github.io/deepinv/deepinv.contributing.html>`_
+for more details.
+
+
+Finding help
+------------
+
+If you have any questions or suggestions, please join the conversation in our
+`Discord server <https://discord.gg/qBqY5jKw3p>`_. The recommended way to get in touch with the developers is to open an issue on the
+`issue tracker <https://github.com/deepinv/deepinv/issues>`_.
+
+
+.. |Black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+.. |Test Status| image:: https://github.com/deepinv/deepinv/actions/workflows/test.yml/badge.svg
+   :target: https://github.com/deepinv/deepinv/actions/workflows/test.yml
+.. |Docs Status| image:: https://github.com/deepinv/deepinv/actions/workflows/documentation.yml/badge.svg
+   :target: https://github.com/deepinv/deepinv/actions/workflows/documentation.yml
+.. |Python 3.6+| image:: https://img.shields.io/badge/python-3.6%2B-blue
+   :target: https://www.python.org/downloads/release/python-360/
+.. |codecov| image:: https://codecov.io/gh/deepinv/deepinv/branch/main/graph/badge.svg?token=77JRvUhQzh
+   :target: https://codecov.io/gh/deepinv/deepinv
+.. |discord| image:: https://dcbadge.vercel.app/api/server/qBqY5jKw3p?style=flat
+   :target: https://discord.gg/qBqY5jKw3p
+.. |colab| image:: https://colab.research.google.com/assets/colab-badge.svg
+   :target: https://colab.research.google.com/drive/1XhCO5S1dYN3eKm4NEkczzVU7ZLBuE42J

deepinv-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,97 @@
+deepinv/__about__.py,sha256=w8__dQ5D_ge5R2CUQgFvMpcOR0AbIEvZRV3CurjDnZE,443
+deepinv/__init__.py,sha256=tXWYmAQ0qcZNMa2Czjc-5k4ufLLRTic4iy5MEFOCQgw,1173
+deepinv/training_utils.py,sha256=e9Q74q9i6CALe1X3puJYUa3NZJZunve5PMMvfYG87BI,21241
+deepinv/datasets/__init__.py,sha256=pTyi2rZw4QUs5l9GwSRjkoubrWXJd7EEvLs7HZfoV2o,57
+deepinv/datasets/datagenerator.py,sha256=dI2a0_Lfa28OMwxYQas89KEhIRgLUYSHvGTP1bmnVSI,8784
+deepinv/loss/__init__.py,sha256=ge4IWNAz7gPnzn2jml3byUj5OfHfQZY2qazL8QdsoA0,503
+deepinv/loss/ei.py,sha256=57nLB4b2YMuOCMiGap30me6WbuUpX0dq3riJG4DSULA,2681
+deepinv/loss/mc.py,sha256=uQa0p56f1TjzzxWi77o-2cEn-sFaCsUvRDwM8VWXviU,1306
+deepinv/loss/measplit.py,sha256=FJRanev2VDiPpn5uP_ATCcG3wayKZq7hvng3F3Kogu8,8170
+deepinv/loss/metric.py,sha256=X0kOzp1--PYR-QRfcO1bFS-P6iBCAQaXN-wQtP-n07E,3764
+deepinv/loss/moi.py,sha256=PC3YxSO02NCvIMt9MUrl5sQ53R6c4BZmssgMI8xQG2o,2306
+deepinv/loss/regularisers.py,sha256=RgaqpmNAOqas90CKwStVijSdrMvMH2QOoqbVr4W0rkY,5756
+deepinv/loss/score.py,sha256=C4D9O3JwAYQWJkCxzcWK1nU8Zc-kXdHByJ62dEI8iZ4,1222
+deepinv/loss/sup.py,sha256=T6dtt1fqqlNSho0dhPM7mMEGPoXbWlK86OlGdLTYUUg,1063
+deepinv/loss/sure.py,sha256=1rSyrjwNcnEmM-nrrzG_nxDh8rUGb80xavlAB9PP8hI,11893
+deepinv/loss/tv.py,sha256=7DEALAF4pIC1YQ2ztLOqJOqyobDS5gI5ykp4GS66SaA,1331
+deepinv/models/GSPnP.py,sha256=fquGK8wwcSO3FBTPp9bIdlUzXQgltW1UZFen4vYkttk,4377
+deepinv/models/PDNet.py,sha256=7mggqLQloPKdXjs936EjV7ewPXyQhyfh1cLsKlRHAAc,4217
+deepinv/models/__init__.py,sha256=lEk5q4pE3Ud1BtQ_JqGKuPnDmcdmNXQhb391mfVfIuU,561
+deepinv/models/ae.py,sha256=vySCaddG0HIWWDOj35rVnYt61o3xR7ynNvB0rjxI7RY,1253
+deepinv/models/artifactremoval.py,sha256=YMt8Vz4fgDlicT8DJffHN5D9kcjJ7WQKytvWrmX6Cnw,2081
+deepinv/models/bm3d.py,sha256=-7HIsb1NSc7GHMyB4Tpr8n39RglbSErp0jGyL_ww7BQ,1488
+deepinv/models/diffunet.py,sha256=4tpVcxBogsQh5tZ-TVu8IULeQHCuA2KY-_ZNcXOvjBo,35458
+deepinv/models/dip.py,sha256=teNyf9lvqt2D8WlCFZOCrVBv4SUmBHQednYH8gZKlLk,6731
+deepinv/models/dncnn.py,sha256=5z1AuA1hsa52KjVWvIDUQSZNYbPgHTduHbULuCsEchY,5304
+deepinv/models/drunet.py,sha256=oQtwZuxA-3hDm1iQ2qjWHkm9m2V7FUgF9LhhYbR-7_8,20515
+deepinv/models/equivariant.py,sha256=EmjW7tSdK0fBq8BAEHFgYPaMfbFoq9IortEhyQcXwZ4,5223
+deepinv/models/median.py,sha256=DToa-JD6tl_bzUBevIEjfgezsUO0_dHrkfpS90X_qkc,1838
+deepinv/models/scunet.py,sha256=vesyn2QC-i0TPMSOo4wZVclFpK5jcrPmVMXGOJ80Mg8,15946
+deepinv/models/swinir.py,sha256=aOLQB12ESV329Hxil7biL2TgAGpBwfDTnIQuVbkfcBI,41374
+deepinv/models/tgv.py,sha256=TifN7rRbXvkeQZlzT7eTMnErrfKDjyq2w2txZ80SETM,8935
+deepinv/models/tv.py,sha256=iFnunUbj8ZMyeUdQBSXG_vZ4r_f9NeehPxzEsx92w-c,4870
+deepinv/models/unet.py,sha256=VHCv-90KY8-jLC9Vz3YM4UejqwaLbVL3IwwGmfJUkTA,10671
+deepinv/models/utils.py,sha256=fWes8C8sNx-AWfKG6hcG2Ud1YB-nns2io7DTl9H-RU0,425
+deepinv/models/wavdict.py,sha256=u3sbWXuTKxrSNxhP4UIRjD9HeLT832gpDFQV72KYMSs,9035
+deepinv/optim/__init__.py,sha256=FzUNmtRF6ikAEQX6nBjw4u9loko50VhcXkqwJ9D8BH8,289
+deepinv/optim/data_fidelity.py,sha256=bx7n7jAkSw2waAJzd47m6SaRaWtteA3P72XOxn0oi9Q,23428
+deepinv/optim/fixed_point.py,sha256=h6enJ02a1Jbo-A9cmQge2snmr6SZr9yUSY_38cS4-uQ,12348
+deepinv/optim/optimizers.py,sha256=pDsgYK2taef7RpHydUdvPyUgnfsYypK-Hiuix-dUgHo,27210
+deepinv/optim/prior.py,sha256=GbSZATTydZUriSXK2YvwEzARkRqd7k5KTnT6yfhnzDo,10536
+deepinv/optim/utils.py,sha256=0iH5S3QXaVVoQdjzlcnmv1OA14W4VhbNXQE_35FcBR8,2413
+deepinv/optim/optim_iterators/__init__.py,sha256=VL4nhMnqlvZKRFoJ6JwGQETaNbgwDOOf4j9KPc93TVQ,343
+deepinv/optim/optim_iterators/admm.py,sha256=bz3_RoCHIt0xWEdyenHnjkYaV5-OKa6Cv_LNzBfnPRM,4626
+deepinv/optim/optim_iterators/drs.py,sha256=mw3QbNH1CXpJBqGtoiburWKxIo_xZv7E-6CVAuv6QqM,4479
+deepinv/optim/optim_iterators/gradient_descent.py,sha256=GFY_a-fnOoRP6QdoKz0NShAkVNOZfmJL7XVI4gf9sII,3346
+deepinv/optim/optim_iterators/hqs.py,sha256=BukQnb7uyDYgTmMMo1uIMGa3C1Qfu1wMWutbHQCtHtc,2502
+deepinv/optim/optim_iterators/optim_iterator.py,sha256=R-vWQ-xmAGWCnwtnSU-UaKlT0KemeGeoFYYRjxvL_Fw,6215
+deepinv/optim/optim_iterators/pgd.py,sha256=S_bqjLkhk5OomtPADkaOUUApotV867WJMYgDWUvTtmI,3059
+deepinv/optim/optim_iterators/primal_dual_CP.py,sha256=VqYsEkfKtrkTe5QCGI5v80osLANWqoMWzsdVYOP0mo8,6482
+deepinv/optim/optim_iterators/utils.py,sha256=DV0v8tIhMg61x3fCBmr_-fCrf6o1x0koIBgF17wjygk,652
+deepinv/physics/__init__.py,sha256=lFziroY4avj_oTc-VlmplZGsG9fJDsucbjP6KMRJB_U,576
+deepinv/physics/blur.py,sha256=oQtAm6lFfe8D2aYZdYGLJDJOsh7V4HEGqM3QkCBtqzs,18580
+deepinv/physics/compressed_sensing.py,sha256=xyn-y0wTj45I4ZlQdwurMLgon9xw4ShcyJOPS2_rTPc,6734
+deepinv/physics/forward.py,sha256=MOSZllqCBNZgAnAecMYbtKtkwKT_KRq1logMtjqdorM,19275
+deepinv/physics/haze.py,sha256=IAPPgvqfwcMxPHvD6bEZkrQDDsX8fqn_smuJkZLh_o8,2041
+deepinv/physics/inpainting.py,sha256=JZZbpC6T1u33PLiSTWm1CxkK0YlN4mN-5yvvFUJTAz4,1886
+deepinv/physics/lidar.py,sha256=NtxIVRwVOhPCZzR5dz5W569KULE4yThdOTVqHK_7YHo,4033
+deepinv/physics/mri.py,sha256=Tsgf3xRXNge8p1Vf39INab8MsoXtNZskUtW2rMo4pMA,10595
+deepinv/physics/noise.py,sha256=AKiJwyww79Kp-ifSGqZGMZAkWpC7aRIh6Od4CRhT_Rk,5128
+deepinv/physics/range.py,sha256=uRyVkdTRmj4fGps95v5ANXfFt7B5G3ZQzRUInNJa118,1377
+deepinv/physics/remote_sensing.py,sha256=io8nMunzTfpVqbi6R5m1SwJH90l-lQWKjsVUq_cSWc0,4211
+deepinv/physics/singlepixel.py,sha256=UwYRbADZBcr9Pz2KG5MHNAvIS1P94l18u0lKv2sGqbE,6951
+deepinv/physics/tomography.py,sha256=iac16rpYtkMdztRGzreJlVduNVy3NOTj0PQIPAvmNoM,10688
+deepinv/sampling/__init__.py,sha256=zjl6vOe5WbYOv4qN9SoOPAohWAQOhEWVasbgORuwXfQ,106
+deepinv/sampling/diffusion.py,sha256=ojpZpA_1l-OF4iAUeHpCrdFuPEyocoqLqEPzvbHI7Ps,25223
+deepinv/sampling/langevin.py,sha256=Jl-PdU45LXN3pZsKODjjQL-YU0QxAf5tL6VkycVps_M,19732
+deepinv/sampling/utils.py,sha256=XngAkD5bxOYWjWqWJ4j0USQsF4SSgfT7ObS5c3iGivI,796
+deepinv/tests/conftest.py,sha256=rRDUpRZJhB-DoPaLzBfE_n9-6epwWFZhCBOTBcx6MUQ,613
+deepinv/tests/test_loss.py,sha256=HeK3X2qHTQXerHub5U4-7yznf6LSY7cxLnxETAcBN-U,7894
+deepinv/tests/test_loss_train.py,sha256=OhWwygE3T_vDLFQj8RSH8rWnEkZOWJqUkJU7hL4lmmU,5408
+deepinv/tests/test_models.py,sha256=ilOifkKgss-QRX7LoQ9KoCyQ7T84dh8CAzeP5dsn8_8,12277
+deepinv/tests/test_optim.py,sha256=O-B3pab_j0YXmYecOd1yheUdn9y6QozB-ndyDD11B3U,22137
+deepinv/tests/test_physics.py,sha256=zwnARYFmT8SBSPuuqI-f5slOpHREvxc6_a1bFuiX-fY,10152
+deepinv/tests/test_sampling.py,sha256=uX2BGV3li8kq0fbxGuSD6ieyhYtTwBntFJ1I-jaNk1Y,4199
+deepinv/tests/test_unfolded.py,sha256=gQ_gyeGiTYTpAeL4YnAdxmSX0KUs0JkJ4_Y9XdT_2qI,5670
+deepinv/tests/test_utils.py,sha256=tKk2MzIdsfIrOLynmUH1CkxCR5H66kcV872jNunm0Bw,1701
+deepinv/tests/dummy_datasets/datasets.py,sha256=h8ZAOQ8E4IViVoPS7xrXdtjtvIpYttLcpSPtSMAQvq4,1730
+deepinv/transform/__init__.py,sha256=WpWFMIsmWgldzkgCe2bGLEowNJnuF6oRl5sASxrK4b0,52
+deepinv/transform/rotate.py,sha256=O8JKmXJxAJb4JLqavetINE7PxRrrvwauiPYFCbLQ31s,1238
+deepinv/transform/shift.py,sha256=4yCt_HiE9vwLwsav2wGYonc7F7DhYsuaPTvJDHSxBFU,765
+deepinv/unfolded/__init__.py,sha256=7qI4_I3JMqM4NJx703-FiPoU3DiXX3VcnsGVH1mR-_4,102
+deepinv/unfolded/deep_equilibrium.py,sha256=1uS3iTs_wbD0wuQ7tGu29ELW5K3b9O_-OcYRtHZAr-E,8074
+deepinv/unfolded/unfolded.py,sha256=X1mTbRiqWWAS5LBedotqP13-G47FtY4Hgv8lHIorxo4,4963
+deepinv/utils/__init__.py,sha256=PTtDkE1oys0E83IQlkmy6oK75Az-UqiIq36zq1Tn1mM,555
+deepinv/utils/demo.py,sha256=OmTtqwVM5ckzAupqEZLS78xX2YpJtFyr4eIdkXi6QbU,5386
+deepinv/utils/logger.py,sha256=B5wS8Q2j6taMUNREJjOsqEvd_Igk6xtnHjTtCOq8B2A,2459
+deepinv/utils/metric.py,sha256=qI28-1LppWHVeXM1m4LAEiuBoqieXouVT_qeNqJQZsI,2484
+deepinv/utils/nn.py,sha256=24xpuTlbw-CO-e0LHQUSo1xjVoIh_TQyF9rlQs1gJkc,6529
+deepinv/utils/optimization.py,sha256=VxBw3vkNDVGMXC_N2Cg65RJNV1rS1FcjnP43_PxIrn4,3702
+deepinv/utils/parameters.py,sha256=-CoD7vneBFbgQnqL2ccdwvs4nOK6OfvFLQpoH4QPdk0,1360
+deepinv/utils/phantoms.py,sha256=9bxl3Zsd7AQAWP3JKFy4R7VkC_BSeahbdNG-K3Uxhmc,4003
+deepinv/utils/plotting.py,sha256=Tt0yBu_eF1A5gMc9wO4ABrC7-E5rF6Bs09zNm-pC-tk,10560
+deepinv-0.1.0.dev0.dist-info/LICENSE,sha256=Up-MehfxmWSgdq040Ig_uPlexDvIiFdvgg1RQeEn8ME,1494
+deepinv-0.1.0.dev0.dist-info/METADATA,sha256=szfX8-Ga9YxDW1hBRZXFwiHLG2KSjOzw6BoXrDh4_-w,7176
+deepinv-0.1.0.dev0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+deepinv-0.1.0.dev0.dist-info/top_level.txt,sha256=ZwPaH-khG7KX_p-hgNQEL4gY4pz5UzV76VbOY7zVfSI,8
+deepinv-0.1.0.dev0.dist-info/RECORD,,

deepinv-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deepinv-0.1.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+deepinv