SigPy

https://sigpy.readthedocs.io/en/latest/
Admin
SigPy is a Python package for signal processing with emphasis on iterative methods, supporting...
Tokens:49,449
Snippets:438
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install SigPy for Developers

Source: https://sigpy.readthedocs.io/en/latest/index.html

Installs SigPy in editable mode for development and contributes to the source code. Also installs packages for running tests.

```bash
cd /path/to/sigpy
pip install -e .

pip install coverage ruff sphinx sphinx_rtd_theme black isort
```

--------------------------------

### App Run Method

Source: https://sigpy.readthedocs.io/en/latest/guide_iter.html

Demonstrates the basic usage of an App object, which wraps Linop, Prox, and Alg classes, by calling its run method to get the final output.

```python
>>> out = app.run()
```

--------------------------------

### Primal-Dual Hybrid Gradient Setup

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Configures the PrimalDualHybridGradient algorithm, including setting up proximal operators and step sizes (tau and sigma) based on the linear operator A and regularization parameters.

```python
if self.tau is None:
            if self.sigma is None:
                self.sigma = 1

            S = linop.Multiply(A.oshape, self.sigma)
            AHA = A.H * S * A
            max_eig = MaxEig(
                AHA,
                dtype=self.x.dtype,
                device=self.x_device,
                max_iter=self.max_power_iter,
                show_pbar=self.show_pbar,
            ).run()

            self.tau = 1 / max_eig
elif self.sigma is None:
            T = linop.Multiply(A.ishape, self.tau)
            AAH = A * T * A.H

            max_eig = MaxEig(
                AAH,
                dtype=self.x.dtype,
                device=self.x_device,
                max_iter=self.max_power_iter,
                show_pbar=self.show_pbar,
            ).run()

            self.sigma = 1 / max_eig
```

```python
self.alg = PrimalDualHybridGradient(
            proxfc,
            proxg,
            A,
            A.H,
            self.x,
            u,
            self.tau,
            self.sigma,
            gamma_primal=gamma_primal,
            gamma_dual=gamma_dual,
            max_iter=self.max_iter,
            tol=self.tol,
        )
```

--------------------------------

### Adaptive Array Creation with Device

Source: https://sigpy.readthedocs.io/en/latest/guide_basic.html

Use sigpy.Device.xp() to get the appropriate array module (NumPy or CuPy) based on the device ID. This allows for writing device-agnostic code.

```python
device = Device(id)
xp = device.xp  # Returns NumPy if id == -1, otherwise returns CuPy
with device:
   x = xp.array([1, 2, 3, 4])
```

--------------------------------

### Install SigPy via Pip

Source: https://sigpy.readthedocs.io/en/latest/index.html

Installs SigPy and optional dependencies for plotting, CUDA, and MPI support using pip.

```bash
pip install sigpy
# (optional for plot support) pip install matplotlib
# (optional for CUDA support) pip install cupy
# (optional for MPI support) pip install mpi4py
```

--------------------------------

### Install SigPy via Conda

Source: https://sigpy.readthedocs.io/en/latest/index.html

Installs SigPy and optional dependencies for plotting, CUDA, and MPI support using conda.

```bash
conda install -c frankong sigpy
# (optional for plot support) conda install matplotlib
# (optional for CUDA support) conda install cupy
# (optional for MPI support) conda install mpi4py
```

--------------------------------

### Get Algorithm

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Determines and retrieves the appropriate algorithm based on the specified solver or problem structure. Raises a ValueError for invalid solver names.

```python
def _get_alg(self):
        if self.solver is None:
            if self.proxg is None:
                self.solver = "ConjugateGradient"
            elif self.G is None:
                self.solver = "GradientMethod"
            else:
                self.solver = "PrimalDualHybridGradient"

        if self.solver == "ConjugateGradient":
            if self.proxg is not None:
                raise ValueError(
                    "ConjugateGradient cannot have proxg specified."
                )

            self._get_ConjugateGradient()
        elif self.solver == "GradientMethod":
            if self.G is not None:
                raise ValueError("GradientMethod cannot have G specified.")

            self._get_GradientMethod()
        elif self.solver == "PrimalDualHybridGradient":
            self._get_PrimalDualHybridGradient()
        elif self.solver == "ADMM":
            self._get_ADMM()
        else:
            raise ValueError(
                "Invalid solver: {solver}.".format(solver=self.solver)
            )
```

--------------------------------

### sigpy.get_device

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.get_device.html

Get the device associated with an input array.

```APIDOC
## sigpy.get_device

### Description
Get Device from input array.

### Parameters
#### Path Parameters
- **array** (array) - Required - Array.

### Returns
Device.
```

--------------------------------

### CPU Device Initialization and Usage

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.cpu_device.html

Demonstrates how to initialize and use the CPU device for computations. The Device object can be used as a context manager.

```APIDOC
## CPU Device

`sigpy.cpu_device` is a Device class that extends `cupy.Device`. 
- `id = -1` represents the CPU.
- `id > 0` represents the id-th GPU.

### Usage Example:
```python
>>> from sigpy import Device
>>> device = Device(-1) # Initialize CPU device
>>> xp = device.xp # Get the array module (numpy for CPU)
>>> with device:
>>>     x = xp.array([1, 2, 3])
>>>     x += 1
>>> print(x)
[2 3 4]
```

### Parameters:
#### id_or_device
- **type**: `int` or `Device` or `cupy.cuda.Device`
- **description**: `id = -1` represents CPU, and others represent the id-th GPUs.
```

--------------------------------

### App Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Initializes the App class, setting up the core algorithm and optional features like progress bar display and timing.

```python
def __init__(self, alg, show_pbar=True, leave_pbar=True, record_time=True):
        self.alg = alg
        self.show_pbar = show_pbar
        self.leave_pbar = leave_pbar
        self.record_time = record_time
        if self.record_time:
            self.time = [0]
```

--------------------------------

### L2 Constrained Minimization Initialization

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Initializes the L2ConstrainedMinimization application, setting up the optimization problem and algorithm parameters.

```python
    def __init__(
        self,
        A,
        y,
        proxg,
        eps,
        x=None,
        G=None,
        max_iter=100,
        tau=None,
        sigma=None,
        show_pbar=True,
    ):
        self.y = y
        self.x = x
        self.y_device = backend.get_device(y)
        if self.x is None:
            with self.y_device:
                self.x = self.y_device.xp.zeros(A.ishape, dtype=self.y.dtype)

        self.x_device = backend.get_device(self.x)
        if G is None:
            self.max_eig_app = MaxEig(
                A.N,
                dtype=self.x.dtype,
                device=self.x_device,
                show_pbar=show_pbar,
            )

            proxfc = prox.Conj(prox.L2Proj(A.oshape, eps, y=y))
        else:
            proxf1 = prox.L2Proj(A.oshape, eps, y=y)
            proxf2 = proxg
            proxfc = prox.Conj(prox.Stack([proxf1, proxf2]))
            proxg = prox.NoOp(A.ishape)
            A = linop.Vstack([A, G])

        if tau is None or sigma is None:
            max_eig = MaxEig(
                A.H * A,
                dtype=self.x.dtype,
                device=self.x_device,
                show_pbar=show_pbar,
            ).run()
            tau = 1
            sigma = 1 / max_eig

        with self.y_device:
            self.u = self.y_device.xp.zeros(A.oshape, dtype=self.y.dtype)

        alg = PrimalDualHybridGradient(
            proxfc,
            proxg,
            A,
            A.H,
            self.x,
            self.u,
            tau,
            sigma,
            max_iter=max_iter,
        )

        super().__init__(alg, show_pbar=show_pbar)
```

--------------------------------

### MaxEig Initialization

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Initializes the MaxEig App for computing the maximum eigenvalue of a linear operator using the PowerMethod algorithm.

```python
def __init__(
        self,
        A,
        dtype=float,
        device=backend.cpu_device,
        max_iter=30,
        show_pbar=True,
        leave_pbar=True,
    ):
        self.x = util.randn(A.ishape, dtype=dtype, device=device)
        alg = PowerMethod(A, self.x, max_iter=max_iter)
        super().__init__(alg, show_pbar=show_pbar, leave_pbar=leave_pbar)
```

--------------------------------

### Configure Conjugate Gradient Solver

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Sets up the Conjugate Gradient solver. It constructs the necessary linear operators and initial vectors for the algorithm. Raises a ValueError if proxg is specified.

```python
def _get_ConjugateGradient(self):
        AHA = self.A.N
        AHy = self.A.H(self.y)

        if self.lamda != 0:
            AHA += self.lamda * linop.Identity(self.x.shape)
            if self.z is not None:
                util.axpy(AHy, self.lamda, self.z)

        self.alg = ConjugateGradient(
            AHA, AHy, self.x, P=self.P, max_iter=self.max_iter, tol=self.tol
        )
```

--------------------------------

### App Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.App.html

Initializes an App object for a signal reconstruction application. It requires an Alg object and optionally accepts parameters to control the progress bar and time recording.

```APIDOC
class sigpy.app.App(alg, show_pbar=True, leave_pbar=True, record_time=True)

Initialize self. See help(type(self)) for accurate signature.
```

--------------------------------

### Gradient Method Initialization

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Initializes the GradientMethod optimizer with a gradient function, initial point, step size, and optional proximal operator and acceleration.

```python
self.alg = GradientMethod(
            gradf,
            self.x,
            self.alpha,
            proxg=self.proxg,
            max_iter=self.max_iter,
            accelerate=self.accelerate,
            tol=self.tol,
        )
```

--------------------------------

### Configure Gradient Method Solver

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Sets up the Gradient Method solver. It computes the gradient of the objective function. Raises a ValueError if G is specified.

```python
def _get_GradientMethod(self):
        with self.y_device:
            AHy = self.A.H(self.y)

        def gradf(x):
            with self.x_device:
                gradf_x = self.A.N(x) - AHy
                if self.lamda != 0:
                    if self.z is None:
                        util.axpy(gradf_x, self.lamda, x)
                    else:

```

--------------------------------

### AltMin Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.AltMin.html

Initializes the Alternating Minimization algorithm with two functions to minimize and a maximum number of iterations.

```APIDOC
## AltMin(min1, min2, max_iter=30)

### Description
Initializes the Alternating Minimization algorithm.

### Parameters
- **min1** (function) - Required - Function to minimize over variable 1.
- **min2** (function) - Required - Function to minimize over variable 2.
- **max_iter** (int) - Optional - Maximum number of iterations. Defaults to 30.
```

--------------------------------

### Using sigpy.Device as a Context Manager

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.Device.html

Demonstrates how to use a Device object as a context manager to perform operations on a specific device. The `xp` attribute provides access to the appropriate array module (NumPy or CuPy).

```python
device = Device(2)
xp = device.xp
with device:
    x = xp.array([1, 2, 3])
    x += 1
```

--------------------------------

### PrimalDualHybridGradient Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.PrimalDualHybridGradient.html

Initializes the PrimalDualHybridGradient algorithm with the necessary functions and parameters.

```APIDOC
## PrimalDualHybridGradient

### Description

Implements the primal-dual hybrid gradient algorithm for convex optimization problems.

### Parameters

- **proxfc** (function) - Function to compute the proximal operator of f^*.
- **proxg** (function) - Function to compute the proximal operator of g.
- **A** (function) - Function to compute the linear mapping.
- **AH** (function) - Function to compute the adjoint linear mapping of A.
- **x** (array) - Initial primal solution.
- **u** (array) - Initial dual solution.
- **tau** (float or array) - Primal step-size.
- **sigma** (float or array) - Dual step-size.
- **theta** (float, optional) - Parameter for the algorithm. Defaults to 1.
- **gamma_primal** (float, optional) - Strong convexity parameter of g. Defaults to 0.
- **gamma_dual** (float, optional) - Strong convexity parameter of f^*. Defaults to 0.
- **max_iter** (int, optional) - Maximum number of iterations. Defaults to 100.
- **tol** (float, optional) - Tolerance for stopping condition. Defaults to 0.
```

--------------------------------

### Linop Operations

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Linop.html

Demonstrates how to use Linop objects for linear operations, including matrix-vector products, adjoints, scaling, addition, subtraction, and composition.

```APIDOC
## Linop Usage Examples

### Description
Linop objects can be called like functions or multiplied with arrays to perform linear operations. Their adjoints, scaling, addition, subtraction, and composition are also supported.

### Example Operations
```python
# Assuming A is a Linop object and x is a NumPy/CuPy array
y = A * x  # Equivalent to y = A(x)
y = A(x)

# Adjoint operator
A_adjoint = A.H

# Scalar multiplication, addition, subtraction, composition
result1 = a * A + B
result2 = a * A * B
```

### Attributes
* **H**: Returns the adjoint linear operator.
* **N**: Returns the normal linear operator.
```

--------------------------------

### run Method

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.LinearLeastSquares.html

Executes the linear least squares optimization process.

```APIDOC
## run

### Description
Run the App.

### Method
(Implicitly called after initialization)

### Endpoint
N/A (Method call on an object instance)

### Parameters
None
```

--------------------------------

### Applying a Linear Operator

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Linop.html

Demonstrates two ways to apply a linear operator A to an input x. The output y can be on a different device.

```python
>>> y = A * x
>>> y = A(x)
```

--------------------------------

### SigPy App Initialization

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Details the initialization parameters for the SigPy App class, which serves as a base for various iterative algorithms.

```APIDOC
## __init__

### Description
Initializes the SigPy App with linear operators, measurement data, and algorithm-specific parameters.

### Parameters
- **A** (Linop): The linear operator representing the forward model.
- **y** (array_like): The measurement data.
- **x** (array_like, optional): The initial guess for the solution. Defaults to None.
- **proxg** (callable, optional): The proximal operator for the data fidelity term. Defaults to None.
- **lamda** (float, optional): Regularization parameter. Defaults to 0.
- **G** (Linop, optional): Linear operator for the regularization term. Defaults to None.
- **g** (callable, optional): The proximal operator for the regularization term. Defaults to None.
- **z** (array_like, optional): Auxiliary variable for ADMM. Defaults to None.
- **solver** (str, optional): The optimization solver to use. Options include 'ConjugateGradient', 'GradientMethod', 'PrimalDualHybridGradient', 'ADMM'. Defaults to None (auto-selected).
- **max_iter** (int, optional): Maximum number of iterations. Defaults to 100.
- **P** (Linop, optional): Preconditioner for ConjugateGradient. Defaults to None.
- **alpha** (float, optional): Step size for GradientMethod. Defaults to None.
- **max_power_iter** (int, optional): Maximum iterations for power method used in alpha calculation. Defaults to 30.
- **accelerate** (bool, optional): Toggle Nesterov acceleration for GradientMethod. Defaults to True.
- **tau** (float, optional): Primal step-size for PrimalDualHybridGradient. Defaults to None.
- **sigma** (float, optional): Dual step-size for PrimalDualHybridGradient. Defaults to None.
- **rho** (float, optional): Augmented Lagrangian parameter for ADMM. Defaults to 1.
- **max_cg_iter** (int, optional): Maximum CG iterations for ADMM. Defaults to 10.
- **tol** (float, optional): Tolerance for convergence. Defaults to 0.
- **save_objective_values** (bool, optional): Toggle saving objective values. Defaults to False.
- **show_pbar** (bool, optional): Toggle progress bar. Defaults to True.
- **leave_pbar** (bool, optional): Whether to leave the progress bar after completion. Defaults to True.
```

--------------------------------

### LinearLeastSquares Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.LinearLeastSquares.html

Initializes the LinearLeastSquares application. It solves the problem min_x 1/2 ||Ax - y||_2^2 + g(Gx) + lambda/2 ||x - z||_2^2. It supports multiple solvers like ConjugateGradient, GradientMethod, ADMM, and PrimalDualHybridGradient.

```APIDOC
## __init__

### Description
Initialize self. See help(type(self)) for accurate signature.

### Parameters
* **A** (Linop) – Forward linear operator.
* **y** (array) – Observation.
* **x** (array) – Solution.
* **proxg** (Prox) – Proximal operator of g.
* **lamda** (float) – l2 regularization parameter.
* **g** (None or function) – Regularization function. Only used for when save_objective_values is true.
* **G** (None or Linop) – Regularization linear operator.
* **z** (float or array) – Bias for l2 regularization.
* **solver** (str) – {‘ConjugateGradient’, ‘GradientMethod’, ‘PrimalDualHybridGradient’, ‘ADMM’}.
* **max_iter** (int) – Maximum number of iterations.
* **P** (Linop) – Preconditioner for ConjugateGradient.
* **alpha** (None or float) – Step size for GradientMethod.
* **accelerate** (bool) – Toggle Nesterov acceleration for GradientMethod.
* **max_power_iter** (int) – Maximum number of iterations for power method. Used for GradientMethod when alpha is not specified, and for PrimalDualHybridGradient when tau or sigma is not specified.
* **tau** (float) – Primal step-size for PrimalDualHybridGradient.
* **sigma** (float) – Dual step-size for PrimalDualHybridGradient.
* **rho** (float) – Augmented Lagrangian parameter for ADMM.
* **max_cg_iter** (int) – Maximum number of iterations for conjugate gradient in ADMM.
* **tol** (float) – Tolerance for convergence.
* **save_objective_values** (bool) – Toggle saving objective value.
* **show_pbar** (bool) – Toggle showing progress bar.
* **leave_pbar** (bool) – Toggle leaving progress bar after completion.
```

--------------------------------

### EspiritCalib Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.mri.app.EspiritCalib.html

Initializes the EspiritCalib class with k-space data and calibration parameters.

```APIDOC
## EspiritCalib

### Description
ESPIRiT calibration. Currently only supports outputting one set of maps.

### Parameters
* **ksp** (array) - k-space array of shape [num_coils, n_ndim, ..., n_1]
* **calib_width** (int) - Default: 24
* **thresh** (float) - Default: 0.02
* **kernel_width** (int) - Default: 6
* **crop** (float) - Default: 0.95
* **max_iter** (int) - Default: 100
* **device** (Device) - Default: <CPU Device>
* **output_eigenvalue** (bool) - Default: False
* **show_pbar** (bool) - Default: True

### Returns
ESPIRiT maps of the same shape as ksp.

### Return Type
array

### References
Martin Uecker, Peng Lai, Mark J. Murphy, Patrick Virtue, Michael Elad, John M. Pauly, Shreyas S. Vasanawala, and Michael Lustig ESPIRIT - An Eigenvalue Approach to Autocalibrating Parallel MRI: Where SENSE meets GRAPPA. Magnetic Resonance in Medicine, 71:990-1001 (2014)
```

--------------------------------

### ADMM Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.ADMM.html

Initializes the ADMM solver with functions to minimize the augmented Lagrangian with respect to x and z, initial values for primal and dual variables, and problem-specific matrices and vectors.

```APIDOC
## ADMM(minL_x, minL_z, x, z, u, A, B, c, max_iter=30)

### Description
Initializes the ADMM solver.

### Parameters
* **minL_x** (function) - A function that minimizes the augmented Lagrangian with respect to x.
* **minL_z** (function) - A function that minimizes the augmented Lagrangian with respect to z.
* **x** (array) - Initial value for the primal variable x.
* **z** (array) - Initial value for the primal variable z.
* **u** (array) - Initial value for the scaled dual variable.
* **A** (array) - Matrix A in the problem formulation.
* **B** (array) - Matrix B in the problem formulation.
* **c** (array) - Vector c in the problem formulation.
* **max_iter** (int) - Maximum number of iterations. Defaults to 30.
```

--------------------------------

### Linop Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Linop.html

Initializes a Linop object with specified input and output shapes. Optionally, a custom string representation can be provided.

```APIDOC
## Linop(oshape, ishape, repr_str=None)

### Description
Initializes a linear operator with given output and input shapes.

### Parameters
* **oshape** (tuple or int) - Output shape.
* **ishape** (tuple or int) - Input shape.
* **repr_str** (str or None, optional) - Custom string representation. Defaults to the class name.
```

--------------------------------

### ConjugateGradient Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.ConjugateGradient.html

Initializes the ConjugateGradient solver. This method sets up the solver with the linear operator, the right-hand side vector, an initial guess, and optional preconditioner and convergence parameters.

```APIDOC
## __init__(A, b, x[, P, max_iter, tol])

### Description
Initialize self. See help(type(self)) for accurate signature.

### Parameters
#### Path Parameters
- **A** (Linop or function) - Linop or function to compute A.
- **b** (array) - Observation.
- **x** (array) - Variable.
- **P** (function or None) - Preconditioner.
- **max_iter** (int) - Maximum number of iterations.
- **tol** (float) - Tolerance for stopping condition.
```

--------------------------------

### ADMM Initialization

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Initializes the ADMM algorithm with the primal and dual update functions, variables, linear operators, and regularization parameters.

```python
self.alg = ADMM(
            minL_x, minL_v, self.x, v, u, G, -I_v, 0, max_iter=self.max_iter
        )
```

--------------------------------

### GradientMethod Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.GradientMethod.html

Initializes the GradientMethod with the gradient function, initial variable, step size, and optional proximal operator and acceleration.

```APIDOC
## GradientMethod(gradf, x, alpha[, proxg, accelerate, max_iter, tol])

### Description
Initializes the GradientMethod class.

### Parameters
* **gradf** (function) - Function to compute the gradient of the objective function.
* **x** (array) - The variable to optimize over.
* **alpha** (float or None) - The step size. If None, backtracking line-search is used.
* **proxg** (Prox or function, optional) - The proximal operator for the composite term. Defaults to None.
* **accelerate** (bool, optional) - Whether to use Nesterov acceleration. Defaults to False.
* **max_iter** (int, optional) - Maximum number of iterations. Defaults to 100.
* **tol** (float, optional) - Tolerance for the stopping condition. Defaults to 0.
```

--------------------------------

### __init__

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Add.html

Initializes the Add linear operator. This is the constructor for the class.

```APIDOC
## __init__

### Description
Initialize self. See help(type(self)) for accurate signature.

### Parameters
#### linops
- **linops** (list of Linops) - Required - Input linear operators.
```

--------------------------------

### MaxEig Summarize Method

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Updates the progress bar postfix with the current maximum eigenvalue estimate.

```python
def _summarize(self):
        if self.show_pbar:
            self.pbar.set_postfix(max_eig="{0:.2E}".format(self.alg.max_eig))
```

--------------------------------

### JsenseRecon Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.mri.app.JsenseRecon.html

Initializes the JSenseRecon object with k-space measurements and various reconstruction parameters.

```APIDOC
## JSenseRecon(y, mps_ker_width=16, ksp_calib_width=24, lamda=0, device=<CPU Device>, comm=None, weights=None, coord=None, img_shape=None, grd_shape=None, max_iter=10, max_inner_iter=10, normalize=True, show_pbar=True)

### Description
Initializes the JSenseRecon object for JSENSE/NLINV reconstruction.

### Parameters
* **y** (array) - k-space measurements.
* **mps_ker_width** (int) - sensitivity maps kernel width. Defaults to 16.
* **ksp_calib_width** (int) - k-space calibration width. Defaults to 24.
* **lamda** (float) - regularization parameter. Defaults to 0.
* **device** (Device) - device to perform reconstruction. Defaults to CPU Device.
* **comm** (None) - Communication object (for distributed computing).
* **weights** (float or array) - weights for data consistency.
* **coord** (None or array) - coordinates.
* **img_shape** (None or list) - Image shape.
* **grd_shape** (None or list) - Shape of grid.
* **max_iter** (int) - Maximum number of iterations. Defaults to 10.
* **max_inner_iter** (int) - Maximum number of inner iterations. Defaults to 10.
* **normalize** (bool) - Whether to normalize the reconstruction. Defaults to True.
* **show_pbar** (bool) - Whether to show a progress bar. Defaults to True.
```

--------------------------------

### sigpy.Communicator.__init__

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.Communicator.html

Initializes the Communicator. This sets up the communication channels for distributed operations.

```APIDOC
## __init__ 

### Description
Initialize self. See help(type(self)) for accurate signature.

### Method
__init__
```

--------------------------------

### Linop Operations

Source: https://sigpy.readthedocs.io/en/latest/guide_iter.html

Demonstrates common operations on a Linop object, such as adjoint, composition, addition, and stacking.

```python
>>> A.H  # adjoint
>>> A.H * A  # compose
>>> A.H * A + lamda * I  # addition and scalar multiplication
>>> Hstack([A, B])  # horizontal stack
>>> Vstack([A, B])  # vertical stack
>>> Diag([A, B])  # diagonal stack
```

--------------------------------

### MaxEig Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.MaxEig.html

Initializes the MaxEig app with a linear operator and optional parameters like data type, device, maximum iterations, and progress bar settings.

```APIDOC
## MaxEig Class

### Description
Computes the maximum eigenvalue of a Hermitian linear operator.

### Parameters
- **A** (Linop) - Required - The Hermitian linear operator.
- **dtype** (Dtype) - Optional - The data type for computations. Defaults to `float`.
- **device** (Device) - Optional - The device to perform computations on. Defaults to CPU.
- **max_iter** (int) - Optional - The maximum number of iterations for the algorithm. Defaults to 30.
- **show_pbar** (bool) - Optional - Whether to display a progress bar. Defaults to `True`.
- **leave_pbar** (bool) - Optional - Whether to leave the progress bar on the screen after completion. Defaults to `True`.

### Methods
- **__init__(A, dtype=<class 'float'>, device=<CPU Device>, max_iter=30, show_pbar=True, leave_pbar=True)**: Initializes the MaxEig object.
- **run()**: Executes the eigenvalue computation.

### Attributes
- **x** (int): The eigenvector corresponding to the largest eigenvalue.

### Output
- **max_eig** (int): The largest eigenvalue of the operator A.
```

--------------------------------

### sigpy.linop.Resize

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Resize.html

Initializes a Resize linear operator.

```APIDOC
class sigpy.linop.Resize(oshape, ishape, ishift=None, oshift=None)

    Resize linear operator.

    Parameters:
        oshape (tuple of int): Output shape.
        ishape (tuple of int): Input shape
        ishift (tuple of int, optional): Input shift.
        oshift (tuple of int, optional): Output shift.

    __init__(oshape, ishape[, ishift, oshift])
        Initialize self. See help(type(self)) for accurate signature.

    apply(input)
        Apply linear operation on input.

    Attributes:
        H (LinearOperator): Return adjoint linear operator.
        N (LinearOperator): Return normal linear operator.
```

--------------------------------

### Initialize SigPy Solver

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Initializes a SigPy solver with various parameters. The solver type is automatically determined if not specified, based on the availability of proxg and G.

```python
def __init__(
        self,
        A,
        y,
        x=None,
        proxg=None,
        lamda=0,
        G=None,
        g=None,
        z=None,
        solver=None,
        max_iter=100,
        P=None,
        alpha=None,
        max_power_iter=30,
        accelerate=True,
        tau=None,
        sigma=None,
        rho=1,
        max_cg_iter=10,
        tol=0,
        save_objective_values=False,
        show_pbar=True,
        leave_pbar=True,
    ):
        self.A = A
        self.y = y
        self.x = x
        self.proxg = proxg
        self.lamda = lamda
        self.G = G
        self.g = g
        self.z = z
        self.solver = solver
        self.max_iter = max_iter
        self.P = P
        self.alpha = alpha
        self.max_power_iter = max_power_iter
        self.accelerate = accelerate
        self.tau = tau
        self.sigma = sigma
        self.rho = rho
        self.max_cg_iter = max_cg_iter
        self.tol = tol
        self.save_objective_values = save_objective_values
        self.show_pbar = show_pbar
        self.leave_pbar = leave_pbar

        self.y_device = backend.get_device(y)
        if self.x is None:
            with self.y_device:
                self.x = self.y_device.xp.zeros(A.ishape, dtype=y.dtype)

        self.x_device = backend.get_device(self.x)
        self._get_alg()
        if self.save_objective_values:
            self.objective_values = [self.objective()]

        super().__init__(self.alg, show_pbar=show_pbar, leave_pbar=leave_pbar)
```

--------------------------------

### SDMM Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.SDMM.html

Initializes the SDMM algorithm. This class solves optimization problems of the form min ||Ax - d||^2 + lambda * ||x||^2 subject to ||L_i * x||^2 < c_i.

```APIDOC
## SDMM(A, d, lam, L, c, mu, rho, rho_max, rho_norm, eps_pri=1e-05, eps_dual=0.01, c_max=None, c_norm=None, max_cg_iter=30, max_iter=1000)

### Description
Initializes the SDMM algorithm. This class solves optimization problems of the form min ||Ax - d||^2 + lambda * ||x||^2 subject to ||L_i * x||^2 < c_i.

### Parameters
* **A** (Linop) - A system matrix Linop.
* **d** (array) - Observation data.
* **lam** (float) - Scaling parameter for the regularization term.
* **L** (list of arrays) - List of constraint linear operator arrays. If not used, provide an empty list.
* **c** (list of floats) - List of constraints, constraining the L2 norm of L_i * x.
* **mu** (float) - Proximal scaling factor.
* **rho** (list of floats) - List of L scaling parameters, each corresponding to one L constraint linear array.
* **rho_max** (float) - Maximum constraint scaling parameter (used if c_max is provided).
* **rho_norm** (float) - Norm constraint scaling parameter (used if c_norm is provided).
* **eps_pri** (float, optional) - Primal variable error tolerance. Defaults to 1e-05.
* **eps_dual** (float, optional) - Dual variable error tolerance. Defaults to 0.01.
* **c_max** (float, optional) - Maximum value constraint. Defaults to None.
* **c_norm** (float, optional) - Norm constraint. Defaults to None.
* **max_cg_iter** (int, optional) - Maximum number of unconstrained CG iterations per SDMM iteration. Defaults to 30.
* **max_iter** (int, optional) - Maximum number of SDMM iterations. Defaults to 1000.
```

--------------------------------

### EspiritCalib.run

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.mri.app.EspiritCalib.html

Executes the ESPIRiT calibration process.

```APIDOC
## run()

### Description
Run the App.

### Method
run()
```

--------------------------------

### Output Retrieval

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Returns the optimized solution vector x.

```python
    def _output(self):
        return self.x
```

--------------------------------

### App Run Method

Source: https://sigpy.readthedocs.io/en/latest/_modules/sigpy/app.html

Executes the iterative algorithm wrapped by the App, with optional progress bar and timing.

```python
def run(self):
        """Run the App."""
        if self.show_pbar:
            if self.__class__.__name__ == "App":
                name = self.alg.__class__.__name__
            else:
                name = self.__class__.__name__

            self.pbar = tqdm(
                total=self.alg.max_iter, desc=name, leave=self.leave_pbar
            )

        while not self.alg.done():
            if self.record_time:
                start_time = time.time()

            self._pre_update()
            self.alg.update()
            self._post_update()

            if self.record_time:
                self.time.append(self.time[-1] + time.time() - start_time)

            self._summarize()
            if self.show_pbar:
                self.pbar.update()
                self.pbar.refresh()

        if self.show_pbar:
            self.pbar.close()

        return self._output()
```

--------------------------------

### NewtonsMethod Class

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.NewtonsMethod.html

Initializes Newton's Method with gradient, inverse Hessian, and initial guess. Supports backtracking line search.

```APIDOC
## class sigpy.alg.NewtonsMethod

### Description
Newton's Method implementation for optimization.

### Parameters
- **gradf** (function) - A function `gradf(x)` that returns the gradient of the objective function at `x`.
- **inv_hessf** (function) - A function `inv_hessf(x)` that returns a function representing the inverse Hessian of the objective function at `x`. The returned function takes a vector `y` and returns the product of the inverse Hessian and `y`.
- **x** (any) - The initial guess for the solution.
- **beta** (scalar, optional) - Backtracking line search factor. Defaults to 1 (no backtracking).
- **f** (function or None, optional) - The objective function to compute for backtracking line-search. Defaults to None.
- **max_iter** (int, optional) - Maximum number of iterations. Defaults to 10.
- **tol** (float, optional) - Tolerance for the stopping condition. Defaults to 0.
```

--------------------------------

### sigpy.linop.ToDevice

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.ToDevice.html

Initializes the ToDevice linear operator. This operator is designed to move data between specified input and output devices.

```APIDOC
## class sigpy.linop.ToDevice

### Description
Move input between devices.

### Parameters
* **shape** (tuple of ints) - Input/output shape.
* **odevice** (Device) - Output device.
* **idevice** (Device) - Input device.

### Methods
#### __init__
Initialize self. See help(type(self)) for accurate signature.

#### apply
Apply linear operation on input.

### Attributes
#### H
Return adjoint linear operator.

#### N
Return normal linear operator.
```

--------------------------------

### BlocksToArray.__init__

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.BlocksToArray.html

Initializes the BlocksToArray operator.

```APIDOC
## __init__(oshape, blk_shape, blk_strides)

Initialize self. See help(type(self)) for accurate signature.
```

--------------------------------

### PowerMethod Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.PowerMethod.html

Initializes the PowerMethod class with a linear mapping, an initial vector, and optional parameters for normalization and maximum iterations.

```APIDOC
## PowerMethod(A, x, norm_func=None, max_iter=30)

### Description
Power method to estimate maximum eigenvalue and eigenvector.

### Parameters
* **A** (Linop or function) - Function to a hermitian linear mapping.
* **x** (array) - Variable to optimize over.
* **norm_func** (function, optional) - Function to normalize the vector. Defaults to None.
* **max_iter** (int, optional) - Maximum number of iterations. Defaults to 30.
```

--------------------------------

### sigpy.linop.Add

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Add.html

Initializes the Add linear operator by taking a list of linear operators as input. The addition is performed element-wise.

```APIDOC
## sigpy.linop.Add

### Description
Addition of linear operators. Input and output shapes and devices must match.

### Parameters
#### linops
- **linops** (list of Linops) - Required - Input linear operators.

### Returns
- **Linop** - The result of adding all input linear operators.
```

--------------------------------

### Running an App Object

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.App.html

The standard way to execute an App object is by calling its run() method. This method executes the underlying Alg object with additional features like a progress bar.

```python
>>> app.run()

```

--------------------------------

### Device Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.Device.html

Initializes a Device object. The id_or_device parameter can be an integer representing a GPU ID (positive integers) or CPU (id = -1), or another Device or cupy.cuda.Device object.

```APIDOC
## Device Class

### Description
Device class. This class extends cupy.Device, with id > 0 representing the id_th GPU, and id = -1 representing CPU. cupy must be installed to use GPUs.

### Parameters
#### Parameters
- **id_or_device** (int or Device or cupy.cuda.Device) - Required - id > 0 represents the corresponding GPUs, and id = -1 represents CPU.

### Attributes
#### xp
numpy or cupy module for the device.

### Methods
#### __init__
Initialize self. See help(type(self)) for accurate signature.

#### use
Use computing device.
```

--------------------------------

### SenseRecon Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.mri.app.SenseRecon.html

Initializes the SenseRecon object for SENSE reconstruction. It takes k-space measurements, sensitivity maps, and optional regularization parameters.

```APIDOC
## SenseRecon

### Description
Performs SENSE Reconstruction considering the problem min||PFSx - y||^2 + lambda*||x||^2.

### Parameters
- **y** (array) - k-space measurements.
- **mps** (array) - sensitivity maps.
- **lamda** (float, optional) - regularization parameter. Defaults to 0.
- **weights** (float or array, optional) - weights for data consistency.
- **tseg** (None or Dictionary, optional) - parameters for time-segmented off-resonance correction. Parameters are ‘b0’ (array), ‘dt’ (float), ‘lseg’ (int), and ‘n_bins’ (int).
- **coord** (None or array, optional) - coordinates.
- **device** (Device, optional) - device to perform reconstruction. Defaults to CPU Device.
- **coil_batch_size** (int, optional) - batch size to process coils. Only affects memory usage.
- **comm** (Communicator, optional) - communicator for distributed computing.
- **show_pbar** (bool, optional) - whether to show progress bar. Defaults to True.
- **transp_nufft** (bool, optional) - whether to use transposed NUFFT. Defaults to False.
- ****kwargs** - Other optional arguments.

### Methods
- `__init__(y, mps[, lamda, weights, tseg, coord, device, coil_batch_size, comm, show_pbar, transp_nufft, **kwargs])` - Initialize self.
- `objective()` - Computes the objective function.
- `run()` - Runs the SENSE reconstruction.
```

--------------------------------

### App.run

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.App.html

Runs the iterative signal reconstruction application. This method executes the core algorithm with any configured features like progress bars.

```APIDOC
run()

Run the App.
```

--------------------------------

### AltMin Methods

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.AltMin.html

Provides methods for controlling the alternating minimization process.

```APIDOC
## done()

### Description
Return whether the algorithm is done.

### Method
`done()`
```

```APIDOC
## update()

### Description
Perform one update step of the alternating minimization algorithm.

### Method
`update()`
```

--------------------------------

### Run MaxEig Computation

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.app.MaxEig.html

Executes the maximum eigenvalue computation using the initialized MaxEig object.

```APIDOC
## Run Method

### Description
Runs the maximum eigenvalue computation for the initialized linear operator.

### Method
`run()`

### Returns
- **max_eig** (int): The largest eigenvalue found.
```

--------------------------------

### Import Libraries

Source: https://sigpy.readthedocs.io/en/latest/guide_basic.html

Import necessary libraries for NumPy, CuPy, and SigPy operations.

```python
import numpy as np
import cupy as cp
import sigpy as sp
```

--------------------------------

### PrimalDualHybridGradient Methods

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.alg.PrimalDualHybridGradient.html

Provides methods to control and execute the PrimalDualHybridGradient algorithm.

```APIDOC
## done()

### Description

Return whether the algorithm is done.

## update()

### Description

Perform one update step of the algorithm.
```

--------------------------------

### NUFFT Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.NUFFT.html

Initializes the NUFFT linear operator with specified parameters.

```APIDOC
## NUFFT

### Description
NUFFT linear operator.

### Parameters
- **ishape** (tuple of int) - Input shape.
- **coord** (array) - Coordinates, with values [-ishape / 2, ishape / 2]
- **oversamp** (float) - Oversampling factor.
- **width** (float) - Kernel width.
- **toeplitz** (bool) - Use toeplitz PSF to evaluate normal operator.

### Methods
#### __init__
Initialize self. See help(type(self)) for accurate signature.

#### apply
Apply linear operation on input.

### Attributes
#### H
Return adjoint linear operator.

#### N
Return normal linear operator.
```

--------------------------------

### JsenseRecon.run

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.mri.app.JsenseRecon.html

Executes the JSENSE/NLINV reconstruction process.

```APIDOC
## run()

### Description
Runs the JSENSE/NLINV reconstruction App.

### Method
run()
```

--------------------------------

### sigpy.alg.AltMin

Source: https://sigpy.readthedocs.io/en/latest/core_alg.html

Alternating minimization.

```APIDOC
## sigpy.alg.AltMin

### Description
Alternating minimization.

### Class
sigpy.alg.AltMin
```

--------------------------------

### Create Array on GPU 1

Source: https://sigpy.readthedocs.io/en/latest/guide_basic.html

Use sigpy.Device to specify the computing device for array creation. This context manager ensures operations within it run on the specified device.

```python
with sp.Device(1):
    x_on_gpu1 = cp.array([1, 2, 3, 4])
```

--------------------------------

### Tile Class Initialization

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Tile.html

Initializes the Tile linear operator with a specified output shape and axes to tile.

```APIDOC
## Tile(oshape, axes)

### Description
Initializes the Tile linear operator.

### Parameters
#### Path Parameters
- **oshape** (tuple of ints) - Required - Output shape.
- **axes** (tuple of ints) - Required - Axes to tile.

### Method
__init__
```

--------------------------------

### sigpy.alg.NewtonsMethod

Source: https://sigpy.readthedocs.io/en/latest/core_alg.html

Newton’s Method.

```APIDOC
## sigpy.alg.NewtonsMethod

### Description
Newton’s Method.

### Class
sigpy.alg.NewtonsMethod
```

--------------------------------

### Device Usage as a Context Manager

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.Device.html

The Device object can be used as a context manager to ensure operations are performed on the specified device. The .xp attribute provides access to the appropriate array module (numpy or cupy).

```APIDOC
>>> device = Device(2)
>>> xp = device.xp  # xp is cupy.
>>> with device:
>>>     x = xp.array([1, 2, 3])
>>>     x += 1
```

--------------------------------

### Tile.apply

Source: https://sigpy.readthedocs.io/en/latest/generated/sigpy.linop.Tile.html

Applies the Tile linear operation to an input.

```APIDOC
## apply(input)

### Description
Apply linear operation on input.

### Parameters
#### Path Parameters
- **input** (any) - Required - The input to apply the operation on.

### Method
apply
```

--------------------------------

### sigpy.alg.GradientMethod

Source: https://sigpy.readthedocs.io/en/latest/core_alg.html

First order gradient method.

```APIDOC
## sigpy.alg.GradientMethod

### Description
First order gradient method.

### Class
sigpy.alg.GradientMethod
```
Tokens:
Raw