From bdd5340809513754fba673e41a49119caa2dff6d Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Wed, 12 Jun 2024 11:25:30 +0200
Subject: [PATCH 1/7] Implement block-diagonal and Gauss-Newton approximation
 for ArnoldiInfluence, remove obsolete functions
 lanczos_low_rank_hessian_approximation, model_hessian_low_rank, rename
 parameter rank_estimate -> rank, hessian_regularization -> regularization

---
 src/pydvl/influence/torch/base.py             |  77 ++++-
 src/pydvl/influence/torch/functional.py       | 309 +++++++-----------
 .../torch/influence_function_model.py         | 170 +++-------
 src/pydvl/influence/torch/operator.py         |  48 ++-
 tests/influence/test_influence_calculator.py  |  10 +-
 tests/influence/torch/test_influence_model.py |  14 +-
 tests/influence/torch/test_util.py            |  26 +-
 7 files changed, 308 insertions(+), 346 deletions(-)

diff --git a/src/pydvl/influence/torch/base.py b/src/pydvl/influence/torch/base.py
index 40aa57140..f4ccbf580 100644
--- a/src/pydvl/influence/torch/base.py
+++ b/src/pydvl/influence/torch/base.py
@@ -3,7 +3,18 @@
 from abc import ABC, abstractmethod
 from collections import OrderedDict
 from dataclasses import dataclass
-from typing import Dict, Iterable, List, Optional, Tuple, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+)
 
 import torch
 from torch.func import functional_call
@@ -12,11 +23,14 @@
 from ..base_influence_function_model import ComposableInfluence
 from ..types import (
     Batch,
+    BatchType,
     BilinearForm,
     BlockMapper,
     GradientProvider,
+    GradientProviderType,
     Operator,
     OperatorGradientComposition,
+    TensorType,
 )
 from .util import (
     BlockMode,
@@ -27,6 +41,9 @@
     flatten_dimensions,
 )
 
+if TYPE_CHECKING:
+    from .operator import LowRankOperator
+
 
 @dataclass(frozen=True)
 class TorchBatch(Batch):
@@ -244,7 +261,7 @@ def flat_mixed_grads(self, batch: TorchBatch) -> torch.Tensor:
 
 
 class OperatorBilinearForm(
-    BilinearForm[torch.Tensor, TorchBatch, TorchGradientProvider]
+    BilinearForm[torch.Tensor, TorchBatch, TorchGradientProvider],
 ):
     r"""
     Base class for bilinear forms based on an instance of
@@ -257,7 +274,7 @@ class OperatorBilinearForm(
 
     def __init__(
         self,
-        operator: "TensorOperator",
+        operator: TorchOperatorType,
     ):
         self.operator = operator
 
@@ -406,6 +423,60 @@ def _aggregate_grads(left: torch.Tensor, right: torch.Tensor):
         return torch.einsum("i..., j... -> ij", left, right)
 
 
+class LowRankBilinearForm(OperatorBilinearForm):
+    def __init__(self, operator: "LowRankOperator"):
+        super().__init__(operator)
+
+    def grads_inner_prod(
+        self,
+        left: TorchBatch,
+        right: Optional[TorchBatch],
+        gradient_provider: TorchGradientProvider,
+    ) -> torch.Tensor:
+        r"""
+        Computes the gradient inner product of two batches of data, i.e.
+
+        $$ \langle \nabla_{\omega}\ell(\omega, \text{left.x}, \text{left.y}),
+        \nabla_{\omega}\ell(\omega, \text{right.x}, \text{right.y}) \rangle_{B}$$
+
+        where $\nabla_{\omega}\ell(\omega, \cdot, \cdot)$ is represented by the
+        `gradient_provider` and the expression must be understood sample-wise.
+
+        Args:
+            left: The first batch for gradient and inner product computation
+            right: The second batch for gradient and inner product computation,
+                optional; if not provided, the inner product will use the gradient
+                computed for `left` for both arguments.
+            gradient_provider: The gradient provider to compute the gradients.
+
+        Returns:
+            A tensor representing the inner products of the per-sample gradients
+        """
+        op = cast("LowRankOperator", self.operator)
+
+        if op.exact:
+            return super().grads_inner_prod(left, right, gradient_provider)
+
+        projections = op.low_rank_representation.projections
+        eigen_vals = op.low_rank_representation.eigen_vals
+        regularization = op.regularization
+
+        if regularization is not None:
+            eigen_vals = eigen_vals + regularization
+
+        left_grads = gradient_provider.jacobian_prod(left, projections.t())
+        inverse_regularized_eigenvalues = 1.0 / eigen_vals
+
+        if right is None:
+            right_grads = left_grads
+        else:
+            right_grads = gradient_provider.jacobian_prod(right, projections.t())
+
+        right_grads = right_grads * inverse_regularized_eigenvalues.unsqueeze(-1)
+
+        return torch.einsum("ij, ik -> jk", left_grads, right_grads)
+
+
 OperatorBilinearFormType = TypeVar(
     "OperatorBilinearFormType", bound=OperatorBilinearForm
 )
diff --git a/src/pydvl/influence/torch/functional.py b/src/pydvl/influence/torch/functional.py
index bb9859995..26741d80c 100644
--- a/src/pydvl/influence/torch/functional.py
+++ b/src/pydvl/influence/torch/functional.py
@@ -55,12 +55,13 @@
     "create_per_sample_gradient_function",
     "create_matrix_jacobian_product_function",
     "create_per_sample_mixed_derivative_function",
-    "model_hessian_low_rank",
     "LowRankProductRepresentation",
     "randomized_nystroem_approximation",
     "model_hessian_nystroem_approximation",
     "create_batch_loss_function",
     "hvp",
+    "operator_spectral_approximation",
+    "operator_nystroem_approximation",
 ]
 
 
@@ -708,204 +709,6 @@ def __post_init__(self):
             raise ValueError("eigen_vals and projections must be on the same device.")
 
 
-def lanzcos_low_rank_hessian_approx(
-    hessian_vp: Callable[[torch.Tensor], torch.Tensor],
-    matrix_shape: Tuple[int, int],
-    hessian_perturbation: float = 0.0,
-    rank_estimate: int = 10,
-    krylov_dimension: Optional[int] = None,
-    tol: float = 1e-6,
-    max_iter: Optional[int] = None,
-    device: Optional[torch.device] = None,
-    eigen_computation_on_gpu: bool = False,
-    torch_dtype: Optional[torch.dtype] = None,
-) -> LowRankProductRepresentation:
-    r"""
-    Calculates a low-rank approximation of the Hessian matrix of a scalar-valued
-    function using the implicitly restarted Lanczos algorithm, i.e.:
-
-    \[ H_{\text{approx}} = V D V^T\]
-
-    where \(D\) is a diagonal matrix with the top (in absolute value) `rank_estimate`
-    eigenvalues of the Hessian and \(V\) contains the corresponding eigenvectors.
-
-    Args:
-        hessian_vp: A function that takes a vector and returns the product of
-            the Hessian of the loss function.
-        matrix_shape: The shape of the matrix, represented by the hessian vector
-            product.
-        hessian_perturbation: Regularization parameter added to the
-            Hessian-vector product for numerical stability.
-        rank_estimate: The number of eigenvalues and corresponding eigenvectors
-            to compute. Represents the desired rank of the Hessian approximation.
-        krylov_dimension: The number of Krylov vectors to use for the Lanczos
-            method. If not provided, it defaults to
-            \( \min(\text{model.n_parameters},
-                \max(2 \times \text{rank_estimate} + 1, 20)) \).
-        tol: The stopping criteria for the Lanczos algorithm, which stops when
-            the difference in the approximated eigenvalue is less than `tol`.
-            Defaults to 1e-6.
-        max_iter: The maximum number of iterations for the Lanczos method. If
-            not provided, it defaults to \( 10 \cdot \text{model.n_parameters}\).
-        device: The device to use for executing the hessian vector product.
-        eigen_computation_on_gpu: If True, tries to execute the eigen pair
-            approximation on the provided device via [cupy](https://cupy.dev/)
-            implementation. Ensure that either your model is small enough, or you
-            use a small rank_estimate to fit your device's memory. If False, the
-            eigen pair approximation is executed on the CPU with scipy's wrapper to
-            ARPACK.
-        torch_dtype: If not provided, the current torch default dtype is used for
-            conversion to torch.
-
-    Returns:
-        [LowRankProductRepresentation]
-            [pydvl.influence.torch.functional.LowRankProductRepresentation]
-            instance that contains the top (up until rank_estimate) eigenvalues
-            and corresponding eigenvectors of the Hessian.
-    """
-
-    torch_dtype = torch.get_default_dtype() if torch_dtype is None else torch_dtype
-
-    if eigen_computation_on_gpu:
-        try:
-            import cupy as cp
-            from cupyx.scipy.sparse.linalg import LinearOperator, eigsh
-            from torch.utils.dlpack import from_dlpack, to_dlpack
-        except ImportError as e:
-            raise ImportError(
-                f"Try to install missing dependencies or set eigen_computation_on_gpu "
-                f"to False: {e}"
-            )
-
-        if device is None:
-            raise ValueError(
-                "Without setting an explicit device, cupy is not supported"
-            )
-
-        def to_torch_conversion_function(x: cp.NDArray) -> torch.Tensor:
-            return from_dlpack(x.toDlpack()).to(torch_dtype)
-
-        def mv(x):
-            x = to_torch_conversion_function(x)
-            y = hessian_vp(x) + hessian_perturbation * x
-            return cp.from_dlpack(to_dlpack(y))
-
-    else:
-        from scipy.sparse.linalg import LinearOperator, eigsh
-
-        def mv(x):
-            x_torch = torch.as_tensor(x, device=device, dtype=torch_dtype)
-            y = (
-                (hessian_vp(x_torch) + hessian_perturbation * x_torch)
-                .detach()
-                .cpu()
-                .numpy()
-            )
-            return y
-
-        to_torch_conversion_function = partial(torch.as_tensor, dtype=torch_dtype)
-
-    try:
-        eigen_vals, eigen_vecs = eigsh(
-            LinearOperator(matrix_shape, matvec=mv),
-            k=rank_estimate,
-            maxiter=max_iter,
-            tol=tol,
-            ncv=krylov_dimension,
-            return_eigenvectors=True,
-        )
-
-    except ArpackNoConvergence as e:
-        logger.warning(
-            f"ARPACK did not converge for parameters {max_iter=}, {tol=}, "
-            f"{krylov_dimension=}, {rank_estimate=}. \n "
-            f"Returning the best approximation found so far. "
-            f"Use those with care or modify parameters.\n Original error: {e}"
-        )
-
-        eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors
-
-    eigen_vals = to_torch_conversion_function(eigen_vals)
-    eigen_vecs = to_torch_conversion_function(eigen_vecs)
-
-    return LowRankProductRepresentation(eigen_vals, eigen_vecs)
-
-
-def model_hessian_low_rank(
-    model: torch.nn.Module,
-    loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
-    training_data: DataLoader,
-    hessian_perturbation: float = 0.0,
-    rank_estimate: int = 10,
-    krylov_dimension: Optional[int] = None,
-    tol: float = 1e-6,
-    max_iter: Optional[int] = None,
-    eigen_computation_on_gpu: bool = False,
-    precompute_grad: bool = False,
-) -> LowRankProductRepresentation:
-    r"""
-    Calculates a low-rank approximation of the Hessian matrix of the model's
-    loss function using the implicitly restarted Lanczos algorithm, i.e.
-
-    \[ H_{\text{approx}} = V D V^T\]
-
-    where \(D\) is a diagonal matrix with the top (in absolute value) `rank_estimate`
-    eigenvalues of the Hessian and \(V\) contains the corresponding eigenvectors.
-
-
-    Args:
-        model: A PyTorch model instance. The Hessian will be calculated with respect to
-            this model's parameters.
-        loss : A callable that computes the loss.
-        training_data: A DataLoader instance that provides the model's training data.
-            Used in calculating the Hessian-vector products.
-        hessian_perturbation: Optional regularization parameter added to the
-            Hessian-vector product for numerical stability.
-        rank_estimate: The number of eigenvalues and corresponding eigenvectors to
-            compute. Represents the desired rank of the Hessian approximation.
-        krylov_dimension: The number of Krylov vectors to use for the Lanczos method.
-            If not provided, it defaults to min(model.n_parameters,
-                max(2*rank_estimate + 1, 20)).
-        tol: The stopping criteria for the Lanczos algorithm,
-            which stops when the difference in the approximated eigenvalue is less than
-            `tol`. Defaults to 1e-6.
-        max_iter: The maximum number of iterations for the Lanczos method.
-            If not provided, it defaults to 10*model.n_parameters.
-        eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation
-            on the provided device via cupy implementation.
-            Make sure, that either your model is small enough or you use a
-            small rank_estimate to fit your device's memory.
-            If False, the eigen pair approximation is executed on the CPU by
-            scipy wrapper to ARPACK.
-        precompute_grad: If True, the full data gradient is precomputed and kept
-            in memory, which can speed up the hessian vector product computation.
-            Set this to False, if you can't afford to keep the full computation graph
-            in memory.
-
-    Returns:
-        [LowRankProductRepresentation]
-            [pydvl.influence.torch.functional.LowRankProductRepresentation]
-            instance that contains the top (up until rank_estimate) eigenvalues
-            and corresponding eigenvectors of the Hessian.
-    """
-    raw_hvp = create_hvp_function(
-        model, loss, training_data, use_average=True, precompute_grad=precompute_grad
-    )
-    n_params = sum([p.numel() for p in model.parameters() if p.requires_grad])
-    device = next(model.parameters()).device
-    return lanzcos_low_rank_hessian_approx(
-        hessian_vp=raw_hvp,
-        matrix_shape=(n_params, n_params),
-        hessian_perturbation=hessian_perturbation,
-        rank_estimate=rank_estimate,
-        krylov_dimension=krylov_dimension,
-        tol=tol,
-        max_iter=max_iter,
-        device=device,
-        eigen_computation_on_gpu=eigen_computation_on_gpu,
-    )
-
-
 def randomized_nystroem_approximation(
     mat_mat_prod: Union[torch.Tensor, Callable[[torch.Tensor], torch.Tensor]],
     input_dim: int,
@@ -1093,3 +896,111 @@ def mat_mat_prod(x: torch.Tensor):
         shift_func=shift_func,
         mat_vec_device=operator.device,
     )
+
+
+def operator_spectral_approximation(
+    operator: "TensorOperator",
+    rank: int = 10,
+    krylov_dimension: Optional[int] = None,
+    tol: float = 1e-6,
+    max_iter: Optional[int] = None,
+    eigen_computation_on_gpu: bool = False,
+):
+    r"""
+    Calculates a low-rank approximation of an operator $H$ using the implicitly
+    restarted Lanczos algorithm, i.e.:
+
+    \[ H_{\text{approx}} = V D V^T\]
+
+    where \(D\) is a diagonal matrix with the top (in absolute value) `rank`
+    eigenvalues of the Hessian and \(V\) contains the corresponding eigenvectors.
+
+    Args:
+        operator: The operator to approximate.
+        rank: The number of eigenvalues and corresponding eigenvectors
+            to compute. Represents the desired rank of the Hessian approximation.
+        krylov_dimension: The number of Krylov vectors to use for the Lanczos
+            method. If not provided, it defaults to
+            \( \min(\text{model.n_parameters},
+                \max(2 \times \text{rank_estimate} + 1, 20)) \).
+        tol: The stopping criteria for the Lanczos algorithm, which stops when
+            the difference in the approximated eigenvalue is less than `tol`.
+            Defaults to 1e-6.
+        max_iter: The maximum number of iterations for the Lanczos method. If
+            not provided, it defaults to \( 10 \cdot \text{model.n_parameters}\).
+        eigen_computation_on_gpu: If True, tries to execute the eigen pair
+            approximation on the provided device via [cupy](https://cupy.dev/)
+            implementation. Ensure that either your model is small enough, or you
+            use a small rank_estimate to fit your device's memory. If False, the
+            eigen pair approximation is executed on the CPU with scipy's wrapper to
+            ARPACK.
+
+    Returns:
+        [LowRankProductRepresentation]
+            [pydvl.influence.torch.functional.LowRankProductRepresentation]
+            instance that contains the top (up until rank_estimate) eigenvalues
+            and corresponding eigenvectors of the Hessian.
+    """
+
+    if operator.input_size == 1:
+        # in the trivial case, return early
+        eigen_vec = torch.ones((1, 1), dtype=operator.dtype, device=operator.device)
+        eigen_val = operator.apply(eigen_vec).squeeze()
+        return LowRankProductRepresentation(eigen_val, eigen_vec)
+
+    torch_dtype = operator.dtype
+
+    if eigen_computation_on_gpu:
+        try:
+            import cupy as cp
+            from cupyx.scipy.sparse.linalg import LinearOperator, eigsh
+            from torch.utils.dlpack import from_dlpack, to_dlpack
+        except ImportError as e:
+            raise ImportError(
+                f"Try to install missing dependencies or set eigen_computation_on_gpu "
+                f"to False: {e}"
+            )
+
+        def to_torch_conversion_function(x: cp.NDArray) -> torch.Tensor:
+            return from_dlpack(x.toDlpack()).to(torch_dtype)
+
+        def mv(x):
+            x = to_torch_conversion_function(x)
+            y = operator.apply(x)
+            return cp.from_dlpack(to_dlpack(y))
+
+    else:
+        from scipy.sparse.linalg import LinearOperator, eigsh
+
+        def mv(x):
+            x_torch = torch.as_tensor(x, device=operator.device, dtype=torch_dtype)
+            y = operator.apply(x_torch).detach().cpu().numpy()
+            return y
+
+        to_torch_conversion_function = partial(torch.as_tensor, dtype=torch_dtype)
+
+    try:
+        matrix_shape = (operator.input_size, operator.input_size)
+        eigen_vals, eigen_vecs = eigsh(
+            LinearOperator(matrix_shape, matvec=mv),
+            k=min(rank, operator.input_size - 1),
+            maxiter=max_iter,
+            tol=tol,
+            ncv=krylov_dimension,
+            return_eigenvectors=True,
+        )
+
+    except ArpackNoConvergence as e:
+        logger.warning(
+            f"ARPACK did not converge for parameters {max_iter=}, {tol=}, "
+            f"{krylov_dimension=}, {rank=}. \n "
+            f"Returning the best approximation found so far. "
+            f"Use those with care or modify parameters.\n Original error: {e}"
+        )
+
+        eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors
+
+    eigen_vals = to_torch_conversion_function(eigen_vals)
+    eigen_vecs = to_torch_conversion_function(eigen_vecs)
+
+    return LowRankProductRepresentation(eigen_vals, eigen_vecs)
diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py
index f1f7e1c61..3ece8d149 100644
--- a/src/pydvl/influence/torch/influence_function_model.py
+++ b/src/pydvl/influence/torch/influence_function_model.py
@@ -34,17 +34,13 @@
     HessianBatchOperation,
 )
 from .functional import (
-    LowRankProductRepresentation,
-    create_batch_hvp_function,
     create_hvp_function,
-    create_matrix_jacobian_product_function,
     create_per_sample_gradient_function,
     create_per_sample_mixed_derivative_function,
     gauss_newton,
     hessian,
-    model_hessian_low_rank,
-    model_hessian_nystroem_approximation,
     operator_nystroem_approximation,
+    operator_spectral_approximation,
 )
 from .operator import (
     DirectSolveOperator,
@@ -915,7 +911,7 @@ def is_thread_safe(self) -> bool:
         return False
 
 
-class ArnoldiInfluence(TorchInfluenceFunctionModel):
+class ArnoldiInfluence(TorchComposableInfluence[LowRankOperator]):
     r"""
     Solves the linear system Hx = b, where H is the Hessian of the model's loss function
     and b is the given right-hand side vector.
@@ -935,155 +931,89 @@ class ArnoldiInfluence(TorchInfluenceFunctionModel):
             this model's parameters.
         loss: A callable that takes the model's output and target as input and returns
               the scalar loss.
-        hessian_regularization: Optional regularization parameter added
-            to the Hessian-vector product for numerical stability.
-        rank_estimate: The number of eigenvalues and corresponding eigenvectors
+        regularization: The regularization parameter. In case a dictionary is provided,
+            the keys must be a subset of the block identifiers.
+        rank: The number of eigenvalues and corresponding eigenvectors
             to compute. Represents the desired rank of the Hessian approximation.
         krylov_dimension: The number of Krylov vectors to use for the Lanczos method.
             Defaults to min(model's number of parameters,
-            max(2 times rank_estimate + 1, 20)).
+            max(2 times rank + 1, 20)).
         tol: The stopping criteria for the Lanczos algorithm.
-            Ignored if `low_rank_representation` is provided.
         max_iter: The maximum number of iterations for the Lanczos method.
-            Ignored if `low_rank_representation` is provided.
         eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation
             on the model's device
             via a cupy implementation. Ensure the model size or rank_estimate
             is appropriate for device memory.
             If False, the eigen pair approximation is executed on the CPU by the scipy
             wrapper to ARPACK.
-        precompute_grad: If True, the full data gradient is precomputed and kept
-            in memory, which can speed up the hessian vector product computation.
-            Set this to False, if you can't afford to keep the full computation graph
-            in memory.
+        use_woodbury: If True, uses the [Sherman–Morrison–Woodbury
+            formula](https://en.wikipedia.org/wiki/Woodbury_matrix_identity) for the
+            computation of the inverse action, which is more precise but needs
+            additional computation.
     """
 
-    low_rank_representation: LowRankProductRepresentation
-
     def __init__(
         self,
         model: nn.Module,
         loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
-        hessian_regularization: float = 0.0,
-        rank_estimate: int = 10,
+        regularization: Optional[Union[float, Dict[str, Optional[float]]]] = None,
+        rank: int = 10,
         krylov_dimension: Optional[int] = None,
         tol: float = 1e-6,
         max_iter: Optional[int] = None,
         eigen_computation_on_gpu: bool = False,
-        precompute_grad: bool = False,
+        block_structure: Union[BlockMode, OrderedDict[str, List[str]]] = BlockMode.FULL,
+        second_order_mode: SecondOrderMode = SecondOrderMode.HESSIAN,
+        use_woodbury: bool = False,
     ):
-        super().__init__(model, loss)
-        self.hessian_regularization = hessian_regularization
-        self.rank_estimate = rank_estimate
+        super().__init__(model, block_structure, regularization)
+        self.use_woodbury = use_woodbury
+        self.second_order_mode = second_order_mode
+        self.loss = loss
+        self.rank = rank
         self.tol = tol
         self.max_iter = max_iter
         self.krylov_dimension = krylov_dimension
         self.eigen_computation_on_gpu = eigen_computation_on_gpu
-        self.precompute_grad = precompute_grad
-
-    @property
-    def is_fitted(self):
-        try:
-            return self.low_rank_representation is not None
-        except AttributeError:
-            return False
-
-    @log_duration(log_level=logging.INFO)
-    def fit(self, data: DataLoader) -> ArnoldiInfluence:
-        r"""
-        Fitting corresponds to the computation of the low rank decomposition
 
-        \[ V D^{-1} V^T \]
-
-        of the Hessian defined by the provided data loader.
-
-        Args:
-            data: The data to compute the Hessian with.
-
-        Returns:
-            The fitted instance.
-
-        """
-        low_rank_representation = model_hessian_low_rank(
-            self.model,
-            self.loss,
-            data,
-            hessian_perturbation=0.0,  # regularization is applied, when computing values
-            rank_estimate=self.rank_estimate,
-            krylov_dimension=self.krylov_dimension,
-            tol=self.tol,
-            max_iter=self.max_iter,
-            eigen_computation_on_gpu=self.eigen_computation_on_gpu,
-            precompute_grad=self.precompute_grad,
-        )
-        self.low_rank_representation = low_rank_representation.to(self.model_device)
+    def with_regularization(
+        self, regularization: Union[float, Dict[str, Optional[float]]]
+    ) -> TorchComposableInfluence:
+        self._regularization_dict = self._build_regularization_dict(regularization)
+        for k, reg in self._regularization_dict.items():
+            self.block_mapper.composable_block_dict[k].op.regularization = reg
         return self
 
-    def _non_symmetric_values(
+    def _create_block(
         self,
-        x_test: torch.Tensor,
-        y_test: torch.Tensor,
-        x: torch.Tensor,
-        y: torch.Tensor,
-        mode: InfluenceMode = InfluenceMode.Up,
-    ) -> torch.Tensor:
-        if mode == InfluenceMode.Up:
-            mjp = create_matrix_jacobian_product_function(
-                self.model, self.loss, self.low_rank_representation.projections.T
-            )
-            left = mjp(self.model_params, x_test, y_test)
-
-            inverse_regularized_eigenvalues = 1.0 / (
-                self.low_rank_representation.eigen_vals + self.hessian_regularization
-            )
-
-            right = mjp(
-                self.model_params, x, y
-            ) * inverse_regularized_eigenvalues.unsqueeze(-1)
-            values = torch.einsum("ij, ik -> jk", left, right)
-        elif mode == InfluenceMode.Perturbation:
-            factors = self.influence_factors(x_test, y_test)
-            values = self.influences_from_factors(factors, x, y, mode=mode)
-        else:
-            raise UnsupportedInfluenceModeException(mode)
-        return values
-
-    def _symmetric_values(
-        self, x: torch.Tensor, y: torch.Tensor, mode: InfluenceMode
-    ) -> torch.Tensor:
-        if mode == InfluenceMode.Up:
-            left = create_matrix_jacobian_product_function(
-                self.model, self.loss, self.low_rank_representation.projections.T
-            )(self.model_params, x, y)
-            inverse_regularized_eigenvalues = 1.0 / (
-                self.low_rank_representation.eigen_vals + self.hessian_regularization
+        block_params: Dict[str, torch.nn.Parameter],
+        data: DataLoader,
+        regularization: Optional[float],
+    ) -> TorchOperatorGradientComposition:
+        gp = TorchGradientProvider(self.model, self.loss, restrict_to=block_params)
+        op: Union[HessianOperator, GaussNewtonOperator]
+        if self.second_order_mode is SecondOrderMode.GAUSS_NEWTON:
+            op = GaussNewtonOperator(
+                self.model, self.loss, data, restrict_to=block_params
             )
-            right = left * inverse_regularized_eigenvalues.unsqueeze(-1)
-            values = torch.einsum("ij, ik -> jk", left, right)
-        elif mode == InfluenceMode.Perturbation:
-            factors = self.influence_factors(x, y)
-            values = self.influences_from_factors(factors, x, y, mode=mode)
         else:
-            raise UnsupportedInfluenceModeException(mode)
-        return values
-
-    @log_duration
-    def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor:
-        inverse_regularized_eigenvalues = 1.0 / (
-            self.low_rank_representation.eigen_vals + self.hessian_regularization
+            op = HessianOperator(self.model, self.loss, data, restrict_to=block_params)
+        low_rank_representation = operator_spectral_approximation(
+            op,
+            self.rank,
+            krylov_dimension=self.krylov_dimension,
+            tol=self.tol,
+            max_iter=self.max_iter,
+            eigen_computation_on_gpu=self.eigen_computation_on_gpu,
         )
-
-        projected_rhs = self.low_rank_representation.projections.t() @ rhs.t()
-        result = self.low_rank_representation.projections @ (
-            projected_rhs * inverse_regularized_eigenvalues.unsqueeze(-1)
+        low_rank_op = LowRankOperator(
+            low_rank_representation, regularization, exact=self.use_woodbury
         )
+        return TorchOperatorGradientComposition(low_rank_op, gp)
 
-        return result.t()
-
-    def to(self, device: torch.device):
-        if self.is_fitted:
-            self.low_rank_representation = self.low_rank_representation.to(device)
-        return super().to(device)
+    @property
+    def is_thread_safe(self) -> bool:
+        return False
 
 
 class EkfacInfluence(TorchInfluenceFunctionModel):
diff --git a/src/pydvl/influence/torch/operator.py b/src/pydvl/influence/torch/operator.py
index 42bc07dfd..9b52330c3 100644
--- a/src/pydvl/influence/torch/operator.py
+++ b/src/pydvl/influence/torch/operator.py
@@ -6,7 +6,13 @@
 from torch.utils.data import DataLoader
 from tqdm import tqdm
 
-from .base import TensorDictOperator, TensorOperator, TorchBatch
+from .base import (
+    LowRankBilinearForm,
+    OperatorBilinearForm,
+    TensorDictOperator,
+    TensorOperator,
+    TorchBatch,
+)
 from .batch_operation import (
     BatchOperationType,
     ChunkAveraging,
@@ -498,7 +504,7 @@ class LowRankOperator(TensorOperator):
     def __init__(
         self,
         low_rank_representation: LowRankProductRepresentation,
-        regularization: float,
+        regularization: Optional[float] = None,
         exact: bool = True,
     ):
 
@@ -525,6 +531,10 @@ def regularization(self, value: float):
             raise ValueError("regularization must be non-negative")
         self._regularization = value
 
+    @property
+    def low_rank_representation(self) -> LowRankProductRepresentation:
+        return self._low_rank_representation
+
     @property
     def device(self):
         return self._low_rank_representation.device
@@ -565,3 +575,37 @@ def _apply_to_mat(self, mat: torch.Tensor) -> torch.Tensor:
     def input_size(self) -> int:
         result: int = self._low_rank_representation.projections.shape[0]
         return result
+
+    def as_bilinear_form(self) -> LowRankBilinearForm:
+        return LowRankBilinearForm(self)
+
+
+class MatrixOperator(TensorOperator):
+    """
+    A simple wrapper for a [torch.Tensor][torch.Tensor] acting as a matrix mapping.
+    """
+
+    def __init__(self, matrix: torch.Tensor):
+        self.matrix = matrix
+
+    @property
+    def device(self):
+        return self.matrix.device
+
+    @property
+    def dtype(self):
+        return self.matrix.dtype
+
+    def to(self, device: torch.device):
+        self.matrix = self.matrix.to(device)
+
+    def _apply_to_vec(self, vec: torch.Tensor) -> torch.Tensor:
+        return self._apply_to_mat(vec.unsqueeze(dim=0))
+
+    def _apply_to_mat(self, mat: torch.Tensor) -> torch.Tensor:
+        return self.matrix @ mat.t()
+
+    @property
+    def input_size(self) -> int:
+        result: int = self.matrix.shape[-1]
+        return result
diff --git a/tests/influence/test_influence_calculator.py b/tests/influence/test_influence_calculator.py
index dea5551e6..221cb746d 100644
--- a/tests/influence/test_influence_calculator.py
+++ b/tests/influence/test_influence_calculator.py
@@ -48,7 +48,7 @@
         lambda model, loss, train_dataLoader, hessian_reg: ArnoldiInfluence(
             model,
             loss,
-            hessian_regularization=hessian_reg,
+            regularization=hessian_reg,
         ).fit(train_dataLoader),
     ],
     ids=["cg", "direct", "arnoldi"],
@@ -79,7 +79,7 @@ def influence_model(model_and_data, test_case, influence_factory):
         lambda model, loss, train_dataLoader, hessian_reg: ArnoldiInfluence(
             model,
             loss,
-            hessian_regularization=hessian_reg,
+            regularization=hessian_reg,
         ).fit(train_dataLoader),
         lambda model, loss, train_dataLoader, hessian_reg: NystroemSketchInfluence(
             model,
@@ -170,7 +170,7 @@ def test_dask_influence_nn(
     inf_model = ArnoldiInfluence(
         model,
         test_case.loss,
-        hessian_regularization=test_case.hessian_reg,
+        regularization=test_case.hessian_reg,
     ).fit(train_dataloader)
 
     converter = TorchNumpyConverter()
@@ -274,7 +274,7 @@ def test_thread_safety_violation_error(
     inf_model = ArnoldiInfluence(
         model,
         test_case.loss,
-        hessian_regularization=test_case.hessian_reg,
+        regularization=test_case.hessian_reg,
     )
     with pytest.raises(ThreadSafetyViolationError):
         DaskInfluenceCalculator(
@@ -294,7 +294,7 @@ def test_sequential_calculator(model_and_data, test_case, mocker):
     inf_model = ArnoldiInfluence(
         model,
         test_case.loss,
-        hessian_regularization=test_case.hessian_reg,
+        regularization=test_case.hessian_reg,
     ).fit(train_dataloader)
 
     seq_calculator = SequentialInfluenceCalculator(inf_model)
diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py
index e2c1057d3..409c0f27c 100644
--- a/tests/influence/torch/test_influence_model.py
+++ b/tests/influence/torch/test_influence_model.py
@@ -562,9 +562,8 @@ def test_influences_lissa(
         lambda model, loss, hessian_reg, rank: ArnoldiInfluence(
             model,
             loss,
-            hessian_regularization=hessian_reg,
-            rank_estimate=rank,
-            precompute_grad=True,
+            regularization=hessian_reg,
+            rank=rank,
         ),
         lambda model, loss, hessian_reg, rank: NystroemSketchInfluence(
             model, loss, regularization=hessian_reg, rank=rank
@@ -844,6 +843,13 @@ def test_influences_cg(
     partial(
         NystroemSketchInfluence, rank=10, second_order_mode=SecondOrderMode.GAUSS_NEWTON
     ),
+    partial(ArnoldiInfluence, rank=10, use_woodbury=True),
+    partial(
+        ArnoldiInfluence,
+        rank=10,
+        second_order_mode=SecondOrderMode.GAUSS_NEWTON,
+        use_woodbury=True,
+    ),
 ]
 
 
@@ -897,7 +903,7 @@ def test_composable_influence(
         x_test, y_test, x_train, y_train, mode=test_case.mode
     )
 
-    threshold = 1 - 1e-3
+    threshold = 1 - 1e-4
     check_correlation(
         direct_influences.reshape(-1), infl_values.reshape(-1), corr_val=threshold
     )
diff --git a/tests/influence/torch/test_util.py b/tests/influence/torch/test_util.py
index a1b782a8c..e0610dd79 100644
--- a/tests/influence/torch/test_util.py
+++ b/tests/influence/torch/test_util.py
@@ -4,6 +4,8 @@
 import numpy as np
 import pytest
 
+from pydvl.influence.torch.operator import MatrixOperator
+
 torch = pytest.importorskip("torch")
 import torch.nn
 from numpy.typing import NDArray
@@ -14,7 +16,7 @@
 from pydvl.influence.torch.functional import (
     create_batch_hvp_function,
     create_hvp_function,
-    lanzcos_low_rank_hessian_approx,
+    operator_spectral_approximation,
 )
 from pydvl.influence.torch.util import (
     BlockMode,
@@ -160,17 +162,15 @@ def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int
     [astuple(tp) for tp in test_parameters],
     indirect=["model_data"],
 )
-def test_lanzcos_low_rank_hessian_approx(
+def test_operator_spectral_approximation(
     model_data, batch_size: int, rank_estimate, regularization
 ):
     _, _, _, vec, H_analytical = model_data
-
     reg_H_analytical = H_analytical + regularization * torch.eye(H_analytical.shape[0])
-    low_rank_approx = lanzcos_low_rank_hessian_approx(
-        lambda z: reg_H_analytical @ z,
-        reg_H_analytical.shape,
-        rank_estimate=rank_estimate,
-    )
+
+    op = MatrixOperator(reg_H_analytical)
+
+    low_rank_approx = operator_spectral_approximation(op, rank=rank_estimate)
     approx_result = low_rank_approx.projections @ (
         torch.diag_embed(low_rank_approx.eigen_vals)
         @ (low_rank_approx.projections.t() @ vec.t())
@@ -179,15 +179,15 @@ def test_lanzcos_low_rank_hessian_approx(
 
 
 @pytest.mark.torch
-def test_lanzcos_low_rank_hessian_approx_exception():
+def test_operator_spectral_approximation_exception():
     """
-    In case cuda is not available, and cupy is not installed, the call should raise an import exception
+    In case cuda is not available, and cupy is not installed, the call should raise an
+    import exception
     """
+    op = MatrixOperator(torch.randn(3, 3))
     if not torch.cuda.is_available():
         with pytest.raises(ImportError):
-            lanzcos_low_rank_hessian_approx(
-                lambda x: x, (3, 3), eigen_computation_on_gpu=True
-            )
+            operator_spectral_approximation(op, rank=2, eigen_computation_on_gpu=True)
 
 
 @pytest.mark.parametrize(

From d5d1585f75f3287d0268f8bbb14e88098ee0814e Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Thu, 13 Jun 2024 14:07:47 +0200
Subject: [PATCH 2/7] Update usage of ArnolidInfluence in notebook

---
 notebooks/influence_wine.ipynb | 66 +++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb
index b4735dcfd..c95397353 100644
--- a/notebooks/influence_wine.ipynb
+++ b/notebooks/influence_wine.ipynb
@@ -272,7 +272,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "48f669980b6d49a08c84fcd250dd5287",
+       "model_id": "2d32133485e7424c8079260a4424c5bd",
        "version_major": 2,
        "version_minor": 0
       },
@@ -334,7 +334,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -524,7 +524,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -571,8 +571,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Average influence of corrupted points:  -1.0840776\n",
-      "Average influence of other points:  0.11192768\n"
+      "Average influence of corrupted points:  -1.0535696\n",
+      "Average influence of other points:  0.1073237\n"
      ]
     }
    ],
@@ -638,7 +638,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -792,7 +792,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Percentage error of Cg over direct method:38.18922936916351 %\n"
+      "Percentage error of Cg over direct method:441.115665435791 %\n"
      ]
     }
    ],
@@ -818,7 +818,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -862,8 +862,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson Correlation Cg vs direct 0.9978821390094573\n",
-      "Spearman Correlation Cg vs direct 0.9946595460614153\n"
+      "Pearson Correlation Cg vs direct 0.9976865200148308\n",
+      "Spearman Correlation Cg vs direct 0.9938836687910925\n"
      ]
     }
    ],
@@ -918,9 +918,9 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Lissa iteration: 100%|██████████| 1000/1000 [00:04<00:00, 206.59it/s]\n",
+      "Lissa iteration: 100%|██████████| 1000/1000 [00:02<00:00, 422.55it/s]\n",
       "Reached max number of iterations 1000 without achieving the desired tolerance 0.0001.\n",
-      " Achieved max residual 9149.03 % and 8.06354 % mean residual\n"
+      " Achieved max residual 8248.55 % and 9.40670 % mean residual\n"
      ]
     }
    ],
@@ -956,7 +956,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Percentage error of Lissa over direct method:119.32581663131714 %\n"
+      "Percentage error of Lissa over direct method:639.6753311157227 %\n"
      ]
     }
    ],
@@ -982,7 +982,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -1026,8 +1026,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson Correlation Lissa vs direct 0.9875324674899437\n",
-      "Spearman Correlation Lissa vs direct 0.9758067360253924\n"
+      "Pearson Correlation Lissa vs direct 0.9981059078064134\n",
+      "Spearman Correlation Lissa vs direct 0.9948812252815075\n"
      ]
     }
    ],
@@ -1080,8 +1080,8 @@
     "arnoldi_influence_model = ArnoldiInfluence(\n",
     "    nn_model,\n",
     "    F.cross_entropy,\n",
-    "    rank_estimate=30,\n",
-    "    hessian_regularization=0.1,\n",
+    "    rank=30,\n",
+    "    regularization=0.1,\n",
     ")\n",
     "arnoldi_influence_model = arnoldi_influence_model.fit(training_data_loader)\n",
     "arnoldi_train_influences = arnoldi_influence_model.influences(\n",
@@ -1108,7 +1108,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Percentage error of Arnoldi over direct method:40.1591956615448 %\n"
+      "Percentage error of Arnoldi over direct method:416.15233421325684 %\n"
      ]
     }
    ],
@@ -1134,7 +1134,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -1178,8 +1178,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson Correlation Arnoldi vs direct 0.9913769850406638\n",
-      "Spearman Correlation Arnoldi vs direct 0.9818122276242538\n"
+      "Pearson Correlation Arnoldi vs direct 0.9877956269724696\n",
+      "Spearman Correlation Arnoldi vs direct 0.9754641408670681\n"
      ]
     }
    ],
@@ -1234,7 +1234,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Encountered error in cholesky decomposition: linalg.cholesky: The factorization could not be completed because the input is not positive-definite (the leading minor of order 16 is not positive-definite)..\n",
+      "Encountered error in cholesky decomposition: linalg.cholesky: The factorization could not be completed because the input is not positive-definite (the leading minor of order 17 is not positive-definite)..\n",
       " Increasing shift by smallest eigenvalue and re-compute\n"
      ]
     }
@@ -1271,7 +1271,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Percentage error of Nyström over direct method:106.66680335998535 %\n"
+      "Percentage error of Nyström over direct method:961.7160797119141 %\n"
      ]
     }
    ],
@@ -1297,7 +1297,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -1341,8 +1341,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson Correlation Nyström vs direct 0.9951186619181842\n",
-      "Spearman Correlation Nyström vs direct 0.9858830642114014\n"
+      "Pearson Correlation Nyström vs direct 0.9964113434116059\n",
+      "Spearman Correlation Nyström vs direct 0.9900848930649672\n"
      ]
     }
    ],
@@ -1422,7 +1422,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Percentage error of EK-FAC over direct method:1995.9354400634766 %\n"
+      "Percentage error of EK-FAC over direct method:19627.71759033203 %\n"
      ]
     }
    ],
@@ -1456,7 +1456,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x800 with 1 Axes>"
       ]
@@ -1508,8 +1508,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson Correlation EK-FAC vs direct 0.9595030844711058\n",
-      "Spearman Correlation EK-FAC vs direct 0.8974028264100562\n"
+      "Pearson Correlation EK-FAC vs direct 0.959103428045871\n",
+      "Spearman Correlation EK-FAC vs direct 0.8893014585485051\n"
      ]
     }
    ],
@@ -1550,8 +1550,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Pearson Correlation EK-FAC vs direct - top-20 influences 0.9891339337484283\n",
-      "Spearman Correlation EK-FAC vs direct - top-20 influences 0.9593984962406013\n"
+      "Pearson Correlation EK-FAC vs direct - top-20 influences 0.9892283817509515\n",
+      "Spearman Correlation EK-FAC vs direct - top-20 influences 0.9729323308270676\n"
      ]
     }
    ],

From ed974895cb54b3f95b41611907965243c898723e Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Thu, 13 Jun 2024 14:13:32 +0200
Subject: [PATCH 3/7] Update CHANGELOG

---
 CHANGELOG.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 928434111..a44b96fe7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,9 @@
 - Extend `NystroemSketchInfluence` with block-diagonal and Gauss-Newton 
   approximation
   [PR #596](https://github.com/aai-institute/pyDVL/pull/596)
+- Extend `ArnoldiInfluence` with block-diagonal and Gauss-Newton
+  approximation
+  [PR #598](https://github.com/aai-institute/pyDVL/pull/598)
   
 ## Changed
 
@@ -37,6 +40,14 @@
     to `regularization` and change the type annotation to allow
     for block-wise regularization parameters
     [PR #596](https://github.com/aai-institute/pyDVL/pull/596)
+  - Renaming of parameters of `ArnoldiInfluence`,
+    `hessian_regularization` -> `regularization` (modify type annotation),
+    `rank_estimate` -> `rank`
+    [PR #598](https://github.com/aai-institute/pyDVL/pull/598)
+  - Remove functions remove obsolete functions 
+    `lanczos_low_rank_hessian_approximation`, `model_hessian_low_rank`
+    from `influence.torch.functional`
+    [PR #598](https://github.com/aai-institute/pyDVL/pull/598)
 
 ## 0.9.2 - 🏗  Bug fixes, logging improvement
 

From 56d0df89e5b82149075a4941623d0d8f583863fc Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Thu, 13 Jun 2024 14:15:51 +0200
Subject: [PATCH 4/7] Update documentation about ArnoldiInfluence

---
 docs/influence/influence_function_model.md | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md
index 36047a860..e496d45e4 100644
--- a/docs/influence/influence_function_model.md
+++ b/docs/influence/influence_function_model.md
@@ -118,12 +118,18 @@ from pydvl.influence.torch import ArnoldiInfluence
 if_model = ArnoldiInfluence(
     model,
     loss,
-    hessian_regularization=0.0,
-    rank_estimate=10,
+    regularization=0.0,
+    rank=10,
     tol=1e-6,
+    block_structure=BlockMode.FULL,
+    second_order_mode=SecondOrderMode.HESSIAN
 )
 if_model.fit(train_loader)
 ```
+This implementation is capable of using a block-matrix
+approximation, see
+[Block-diagonal approximation](#block-diagonal-approximation), and can handle
+[Gauss-Newton approximation](#gauss-newton-approximation).
 
 ### Eigenvalue Corrected K-FAC
 

From d9a66f605bba7b894a8febae4006758db4736320 Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Thu, 13 Jun 2024 15:26:34 +0200
Subject: [PATCH 5/7] Refactor n_parameters of TorchComposableInfluence to be
 callable before fit

---
 src/pydvl/influence/torch/base.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/pydvl/influence/torch/base.py b/src/pydvl/influence/torch/base.py
index f4ccbf580..8cfdda401 100644
--- a/src/pydvl/influence/torch/base.py
+++ b/src/pydvl/influence/torch/base.py
@@ -724,7 +724,11 @@ def block_names(self) -> List[str]:
 
     @property
     def n_parameters(self):
-        return sum(block.op.input_size for _, block in self.block_mapper.items())
+        return sum(
+            param.numel()
+            for block in self.parameter_dict.values()
+            for param in block.values()
+        )
 
     @abstractmethod
     def with_regularization(

From fd041b425caecacf2ad520665cf7ef3ab2ecb787 Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Thu, 13 Jun 2024 19:47:47 +0200
Subject: [PATCH 6/7] Refactor LowRankBilinearForm, add class docstring, rename
 variables inside of method for better readability

---
 src/pydvl/influence/torch/base.py | 33 ++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/src/pydvl/influence/torch/base.py b/src/pydvl/influence/torch/base.py
index 8cfdda401..7ae0c7006 100644
--- a/src/pydvl/influence/torch/base.py
+++ b/src/pydvl/influence/torch/base.py
@@ -424,6 +424,21 @@ def _aggregate_grads(left: torch.Tensor, right: torch.Tensor):
 
 
 class LowRankBilinearForm(OperatorBilinearForm):
+    r"""
+    Specialized bilinear form for operators of the type
+
+    $$ \operatorname{Op}(b) = V D^{-1}V^Tb.$$
+
+    It computes the expressions
+
+    $$ \langle \operatorname{Op}(\nabla_{\theta} \ell(z, \theta)),
+        \nabla_{\theta} \ell(z^{\prime}, \theta) \rangle =
+        \langle V\nabla_{\theta} \ell(z, \theta),
+        D^{-1}V\nabla_{\theta} \ell(z^{\prime}, \theta) \rangle$$
+
+    in an efficient way using [torch.autograd][torch.autograd] functionality.
+    """
+
     def __init__(self, operator: "LowRankOperator"):
         super().__init__(operator)
 
@@ -457,24 +472,24 @@ def grads_inner_prod(
         if op.exact:
             return super().grads_inner_prod(left, right, gradient_provider)
 
-        projections = op.low_rank_representation.projections
-        eigen_vals = op.low_rank_representation.eigen_vals
+        V = op.low_rank_representation.projections
+        D = op.low_rank_representation.eigen_vals.clone()
         regularization = op.regularization
 
         if regularization is not None:
-            eigen_vals = eigen_vals + regularization
+            D += regularization
 
-        left_grads = gradient_provider.jacobian_prod(left, projections.t())
-        inverse_regularized_eigenvalues = 1.0 / eigen_vals
+        V_left = gradient_provider.jacobian_prod(left, V.t())
+        D_inv = 1.0 / D
 
         if right is None:
-            right_grads = left_grads
+            V_right = V_left
         else:
-            right_grads = gradient_provider.jacobian_prod(right, projections.t())
+            V_right = gradient_provider.jacobian_prod(right, V.t())
 
-        right_grads = right_grads * inverse_regularized_eigenvalues.unsqueeze(-1)
+        V_right = V_right * D_inv.unsqueeze(-1)
 
-        return torch.einsum("ij, ik -> jk", left_grads, right_grads)
+        return torch.einsum("ij, ik -> jk", V_left, V_right)
 
 
 OperatorBilinearFormType = TypeVar(

From 4f18ddd3f9d622c73564082ac99b3b97c29290bd Mon Sep 17 00:00:00 2001
From: Kristof Schroeder <kristof_schroeder@web.de>
Date: Thu, 20 Jun 2024 13:26:11 +0200
Subject: [PATCH 7/7] Improve error messsage, convert a logging to a warning

---
 src/pydvl/influence/torch/functional.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/pydvl/influence/torch/functional.py b/src/pydvl/influence/torch/functional.py
index 26741d80c..f07cc3983 100644
--- a/src/pydvl/influence/torch/functional.py
+++ b/src/pydvl/influence/torch/functional.py
@@ -26,6 +26,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from dataclasses import dataclass
 from functools import partial
 from typing import TYPE_CHECKING, Callable, Dict, Optional, Tuple, Union
@@ -957,7 +958,9 @@ def operator_spectral_approximation(
             from torch.utils.dlpack import from_dlpack, to_dlpack
         except ImportError as e:
             raise ImportError(
-                f"Try to install missing dependencies or set eigen_computation_on_gpu "
+                "Missing cupy, check the installation instructions "
+                "at https://docs.cupy.dev/en/stable/install.html "
+                "or set eigen_computation_on_gpu "
                 f"to False: {e}"
             )
 
@@ -991,7 +994,7 @@ def mv(x):
         )
 
     except ArpackNoConvergence as e:
-        logger.warning(
+        warnings.warn(
             f"ARPACK did not converge for parameters {max_iter=}, {tol=}, "
             f"{krylov_dimension=}, {rank=}. \n "
             f"Returning the best approximation found so far. "