Influence function model

This module implements several implementations of InfluenceFunctionModel utilizing PyTorch.

TorchInfluenceFunctionModel(model, loss)

Bases: InfluenceFunctionModel[Tensor, DataLoader], ABC

Abstract base class for influence computation related to torch models

Source code in src/pydvl/influence/torch/influence_function_model.py

def __init__(
    self,
    model: nn.Module,
    loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
):
    self.loss = loss
    self.model = model
    self._n_parameters = sum(
        [p.numel() for p in model.parameters() if p.requires_grad]
    )
    self._model_device = next(
        (p.device for p in model.parameters() if p.requires_grad)
    )
    self._model_params = {
        k: p.detach() for k, p in self.model.named_parameters() if p.requires_grad
    }
    super().__init__()

is_fitted abstractmethod property

Override this, to expose the fitting status of the instance.

fit(data) abstractmethod

Override this method to fit the influence function model to training data, e.g. pre-compute hessian matrix or matrix decompositions

PARAMETER	DESCRIPTION
data	TYPE: DataLoaderType

RETURNS	DESCRIPTION
	The fitted instance

Source code in src/pydvl/influence/base_influence_function_model.py

@abstractmethod
def fit(self, data: DataLoaderType):
    """
    Override this method to fit the influence function model to training data,
    e.g. pre-compute hessian matrix or matrix decompositions

    Args:
        data:

    Returns:
        The fitted instance
    """

influences(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

Compute the approximation of

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case.

PARAMETER	DESCRIPTION
x_test	model input to use in the gradient computations of \(H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
y_test	label tensor to compute gradients TYPE: Tensor
x	optional model input to use in the gradient computations \(\nabla_{theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))\), if None, use \(x=x_{\text{test}}\) TYPE: Optional[Tensor] DEFAULT: None
y	optional label tensor to compute gradients TYPE: Optional[Tensor] DEFAULT: None
mode	enum value of [InfluenceType][pydvl.influence.base_influence_model.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Compute the approximation of

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the case of up-weighting influence, resp.

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the perturbation type influence case.

    Args:
        x_test: model input to use in the gradient computations
            of $H^{-1}\nabla_{theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    t: torch.Tensor = super().influences(x_test, y_test, x, y, mode=mode)
    return t

influence_factors(x, y)

Compute approximation of

\[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

where the gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise inverse Hessian matrix vector products

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

    where the gradient is meant to be per sample of the batch $(x, y)$.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        Tensor representing the element-wise inverse Hessian matrix vector products

    """
    return super().influence_factors(x, y)

influences_from_factors(z_test_factors, x, y, mode=InfluenceMode.Up)

Computation of

\[ \langle z_{\text{test_factors}}, \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle z_{\text{test_factors}}, \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
z_test_factors	pre-computed tensor, approximating \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
x	model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\) TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
mode	enum value of [InfluenceType][pydvl.influence.twice_differentiable.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors(
    self,
    z_test_factors: torch.Tensor,
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The gradient is meant to be per sample
    of the batch $(x, y)$.

    Args:
         z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    if mode == InfluenceMode.Up:
        return (
            z_test_factors
            @ self._loss_grad(x.to(self.model_device), y.to(self.model_device)).T
        )
    elif mode == InfluenceMode.Perturbation:
        return torch.einsum(
            "ia,j...a->ij...",
            z_test_factors,
            self._flat_loss_mixed_grad(
                x.to(self.model_device), y.to(self.model_device)
            ),
        )
    else:
        raise UnsupportedInfluenceModeException(mode)

DirectInfluence(model, loss, hessian_regularization=0.0)

Bases: TorchInfluenceFunctionModel

Given a model and training data, it finds x such that \(Hx = b\), with \(H\) being the model hessian.

PARAMETER	DESCRIPTION
model	instance of torch.nn.Module. TYPE: Module
hessian_regularization	Regularization of the hessian. TYPE: float DEFAULT: 0.0

Source code in src/pydvl/influence/torch/influence_function_model.py

def __init__(
    self,
    model: nn.Module,
    loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
    hessian_regularization: float = 0.0,
):
    super().__init__(model, loss)
    self.hessian_regularization = hessian_regularization

influence_factors(x, y)

Compute approximation of

\[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

where the gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise inverse Hessian matrix vector products

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

    where the gradient is meant to be per sample of the batch $(x, y)$.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        Tensor representing the element-wise inverse Hessian matrix vector products

    """
    return super().influence_factors(x, y)

influences_from_factors(z_test_factors, x, y, mode=InfluenceMode.Up)

Computation of

\[ \langle z_{\text{test_factors}}, \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle z_{\text{test_factors}}, \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
z_test_factors	pre-computed tensor, approximating \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
x	model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\) TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
mode	enum value of [InfluenceType][pydvl.influence.twice_differentiable.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors(
    self,
    z_test_factors: torch.Tensor,
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The gradient is meant to be per sample
    of the batch $(x, y)$.

    Args:
         z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    if mode == InfluenceMode.Up:
        return (
            z_test_factors
            @ self._loss_grad(x.to(self.model_device), y.to(self.model_device)).T
        )
    elif mode == InfluenceMode.Perturbation:
        return torch.einsum(
            "ia,j...a->ij...",
            z_test_factors,
            self._flat_loss_mixed_grad(
                x.to(self.model_device), y.to(self.model_device)
            ),
        )
    else:
        raise UnsupportedInfluenceModeException(mode)

fit(data)

Compute the hessian matrix based on a provided dataloader

PARAMETER	DESCRIPTION
data	Instance of [torch.utils.data.Dataloader][] TYPE: DataLoader

RETURNS	DESCRIPTION
DirectInfluence	The fitted instance

Source code in src/pydvl/influence/torch/influence_function_model.py

def fit(self, data: DataLoader) -> DirectInfluence:
    """
    Compute the hessian matrix based on a provided dataloader

    Args:
        data: Instance of [torch.utils.data.Dataloader]
            [torch.utils.data.Dataloader]

    Returns:
        The fitted instance
    """
    self.hessian = hessian(self.model, self.loss, data)
    return self

influences(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

Compute approximation of

\[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle, \]

for the case of up-weighting influence, resp.

\[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The action of \(H^{-1}\) is achieved via a direct solver using torch.linalg.solve.

PARAMETER	DESCRIPTION
x_test	model input to use in the gradient computations of \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
y_test	label tensor to compute gradients TYPE: Tensor
x	optional model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\), if None, use \(x=x_{\text{test}}\) TYPE: Optional[Tensor] DEFAULT: None
y	optional label tensor to compute gradients TYPE: Optional[Tensor] DEFAULT: None
mode	enum value of [InfluenceType][pydvl.influence.base_influence_model.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	[torch.nn.Tensor][] representing the element-wise scalar products for the provided batch.

Source code in src/pydvl/influence/torch/influence_function_model.py

@log_duration
def influences(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
        f_{\theta}(x_{\text{test}})),
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle, \]

    for the case of up-weighting influence, resp.

    \[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
        f_{\theta}(x_{\text{test}})),
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The action of $H^{-1}$ is achieved
    via a direct solver using [torch.linalg.solve][torch.linalg.solve].

    Args:
        x_test: model input to use in the gradient computations of
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        [torch.nn.Tensor][torch.nn.Tensor] representing the element-wise
            scalar products for the provided batch.

    """
    return super().influences(x_test, y_test, x, y, mode=mode)

CgInfluence(model, loss, hessian_regularization=0.0, x0=None, rtol=1e-07, atol=1e-07, maxiter=None, progress=False)

Bases: TorchInfluenceFunctionModel

Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x such that \(Hx = b\), with \(H\) being the model hessian. For more info, see Conjugate Gradient.

PARAMETER	DESCRIPTION
model	Instance of torch.nn.Module. TYPE: Module
loss	A callable that takes the model's output and target as input and returns the scalar loss. TYPE: Callable[[Tensor, Tensor], Tensor]
hessian_regularization	Regularization of the hessian. TYPE: float DEFAULT: 0.0
x0	Initial guess for hvp. If None, defaults to b. TYPE: Optional[Tensor] DEFAULT: None
rtol	Maximum relative tolerance of result. TYPE: float DEFAULT: 1e-07
atol	Absolute tolerance of result. TYPE: float DEFAULT: 1e-07
maxiter	Maximum number of iterations. If None, defaults to 10*len(b). TYPE: Optional[int] DEFAULT: None
progress	If True, display progress bars. TYPE: bool DEFAULT: False

Source code in src/pydvl/influence/torch/influence_function_model.py

def __init__(
    self,
    model: nn.Module,
    loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
    hessian_regularization: float = 0.0,
    x0: Optional[torch.Tensor] = None,
    rtol: float = 1e-7,
    atol: float = 1e-7,
    maxiter: Optional[int] = None,
    progress: bool = False,
):
    super().__init__(model, loss)
    self.progress = progress
    self.maxiter = maxiter
    self.atol = atol
    self.rtol = rtol
    self.x0 = x0
    self.hessian_regularization = hessian_regularization

influence_factors(x, y)

Compute approximation of

\[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

where the gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise inverse Hessian matrix vector products

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

    where the gradient is meant to be per sample of the batch $(x, y)$.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        Tensor representing the element-wise inverse Hessian matrix vector products

    """
    return super().influence_factors(x, y)

influences_from_factors(z_test_factors, x, y, mode=InfluenceMode.Up)

Computation of

\[ \langle z_{\text{test_factors}}, \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle z_{\text{test_factors}}, \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
z_test_factors	pre-computed tensor, approximating \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
x	model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\) TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
mode	enum value of [InfluenceType][pydvl.influence.twice_differentiable.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors(
    self,
    z_test_factors: torch.Tensor,
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The gradient is meant to be per sample
    of the batch $(x, y)$.

    Args:
         z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    if mode == InfluenceMode.Up:
        return (
            z_test_factors
            @ self._loss_grad(x.to(self.model_device), y.to(self.model_device)).T
        )
    elif mode == InfluenceMode.Perturbation:
        return torch.einsum(
            "ia,j...a->ij...",
            z_test_factors,
            self._flat_loss_mixed_grad(
                x.to(self.model_device), y.to(self.model_device)
            ),
        )
    else:
        raise UnsupportedInfluenceModeException(mode)

influences(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

Compute approximation of

\[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle, \]

for the case of up-weighting influence, resp.

\[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The approximate action of \(H^{-1}\) is achieved via the [conjugate gradient method] (https://en.wikipedia.org/wiki/Conjugate_gradient_method).

PARAMETER	DESCRIPTION
x_test	model input to use in the gradient computations of \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
y_test	label tensor to compute gradients TYPE: Tensor
x	optional model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\), if None, use \(x=x_{\text{test}}\) TYPE: Optional[Tensor] DEFAULT: None
y	optional label tensor to compute gradients TYPE: Optional[Tensor] DEFAULT: None
mode	enum value of [InfluenceType][pydvl.influence.base_influence_model.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	[torch.nn.Tensor][] representing the element-wise scalar products for the provided batch.

Source code in src/pydvl/influence/torch/influence_function_model.py

@log_duration
def influences(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
        f_{\theta}(x_{\text{test}})),
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle, \]

    for the case of up-weighting influence, resp.

    \[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
        f_{\theta}(x_{\text{test}})),
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The approximate action of $H^{-1}$
    is achieved via the [conjugate gradient method]
    (https://en.wikipedia.org/wiki/Conjugate_gradient_method).

    Args:
        x_test: model input to use in the gradient computations of
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        [torch.nn.Tensor][torch.nn.Tensor] representing the element-wise
            scalar products for the provided batch.

    """
    return super().influences(x_test, y_test, x, y, mode=mode)

LissaInfluence(model, loss, hessian_regularization=0.0, maxiter=1000, dampen=0.0, scale=10.0, h0=None, rtol=0.0001, progress=False)

Bases: TorchInfluenceFunctionModel

Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively approximate the inverse Hessian. More precisely, it finds x s.t. \(Hx = b\), with \(H\) being the model's second derivative wrt. the parameters. This is done with the update

\[H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},\]

where \(I\) is the identity matrix, \(d\) is a dampening term and \(s\) a scaling factor that are applied to help convergence. For details, see Linear time Stochastic Second-Order Approximation (LiSSA)

PARAMETER	DESCRIPTION
model	instance of torch.nn.Module. TYPE: Module
hessian_regularization	Regularization of the hessian. TYPE: float DEFAULT: 0.0
maxiter	Maximum number of iterations. TYPE: int DEFAULT: 1000
dampen	Dampening factor, defaults to 0 for no dampening. TYPE: float DEFAULT: 0.0
scale	Scaling factor, defaults to 10. TYPE: float DEFAULT: 10.0
h0	Initial guess for hvp. TYPE: Optional[Tensor] DEFAULT: None
rtol	tolerance to use for early stopping TYPE: float DEFAULT: 0.0001
progress	If True, display progress bars. TYPE: bool DEFAULT: False

Source code in src/pydvl/influence/torch/influence_function_model.py

def __init__(
    self,
    model: nn.Module,
    loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
    hessian_regularization: float = 0.0,
    maxiter: int = 1000,
    dampen: float = 0.0,
    scale: float = 10.0,
    h0: Optional[torch.Tensor] = None,
    rtol: float = 1e-4,
    progress: bool = False,
):
    super().__init__(model, loss)
    self.maxiter = maxiter
    self.hessian_regularization = hessian_regularization
    self.progress = progress
    self.rtol = rtol
    self.h0 = h0
    self.scale = scale
    self.dampen = dampen

influence_factors(x, y)

Compute approximation of

\[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

where the gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise inverse Hessian matrix vector products

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

    where the gradient is meant to be per sample of the batch $(x, y)$.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        Tensor representing the element-wise inverse Hessian matrix vector products

    """
    return super().influence_factors(x, y)

influences(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

Compute the approximation of

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case.

PARAMETER	DESCRIPTION
x_test	model input to use in the gradient computations of \(H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
y_test	label tensor to compute gradients TYPE: Tensor
x	optional model input to use in the gradient computations \(\nabla_{theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))\), if None, use \(x=x_{\text{test}}\) TYPE: Optional[Tensor] DEFAULT: None
y	optional label tensor to compute gradients TYPE: Optional[Tensor] DEFAULT: None
mode	enum value of [InfluenceType][pydvl.influence.base_influence_model.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Compute the approximation of

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the case of up-weighting influence, resp.

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the perturbation type influence case.

    Args:
        x_test: model input to use in the gradient computations
            of $H^{-1}\nabla_{theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    t: torch.Tensor = super().influences(x_test, y_test, x, y, mode=mode)
    return t

influences_from_factors(z_test_factors, x, y, mode=InfluenceMode.Up)

Computation of

\[ \langle z_{\text{test_factors}}, \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle z_{\text{test_factors}}, \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
z_test_factors	pre-computed tensor, approximating \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
x	model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\) TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
mode	enum value of [InfluenceType][pydvl.influence.twice_differentiable.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors(
    self,
    z_test_factors: torch.Tensor,
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The gradient is meant to be per sample
    of the batch $(x, y)$.

    Args:
         z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    if mode == InfluenceMode.Up:
        return (
            z_test_factors
            @ self._loss_grad(x.to(self.model_device), y.to(self.model_device)).T
        )
    elif mode == InfluenceMode.Perturbation:
        return torch.einsum(
            "ia,j...a->ij...",
            z_test_factors,
            self._flat_loss_mixed_grad(
                x.to(self.model_device), y.to(self.model_device)
            ),
        )
    else:
        raise UnsupportedInfluenceModeException(mode)

ArnoldiInfluence(model, loss, hessian_regularization=0.0, rank_estimate=10, krylov_dimension=None, tol=1e-06, max_iter=None, eigen_computation_on_gpu=False)

Bases: TorchInfluenceFunctionModel

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. It employs the [implicitly restarted Arnoldi method] (https://en.wikipedia.org/wiki/Arnoldi_iteration) for computing a partial eigen decomposition, which is used fo the inversion i.e.

\[x = V D^{-1} V^T b\]

where \(D\) is a diagonal matrix with the top (in absolute value) rank_estimate eigenvalues of the Hessian and \(V\) contains the corresponding eigenvectors. For more information, see Arnoldi.

PARAMETER	DESCRIPTION
model	Instance of torch.nn.Module. The Hessian will be calculated with respect to this model's parameters.
hessian_regularization	Optional regularization parameter added to the Hessian-vector product for numerical stability. TYPE: float DEFAULT: 0.0
rank_estimate	The number of eigenvalues and corresponding eigenvectors to compute. Represents the desired rank of the Hessian approximation. TYPE: int DEFAULT: 10
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)). TYPE: Optional[int] DEFAULT: None
tol	The stopping criteria for the Lanczos algorithm. Ignored if low_rank_representation is provided. TYPE: float DEFAULT: 1e-06
max_iter	The maximum number of iterations for the Lanczos method. Ignored if low_rank_representation is provided. TYPE: Optional[int] DEFAULT: None
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. TYPE: bool DEFAULT: False

Source code in src/pydvl/influence/torch/influence_function_model.py

def __init__(
    self,
    model,
    loss,
    hessian_regularization: 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,
):

    super().__init__(model, loss)
    self.hessian_regularization = hessian_regularization
    self.rank_estimate = rank_estimate
    self.tol = tol
    self.max_iter = max_iter
    self.krylov_dimension = krylov_dimension
    self.eigen_computation_on_gpu = eigen_computation_on_gpu

influence_factors(x, y)

Compute approximation of

\[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

where the gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise inverse Hessian matrix vector products

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

    where the gradient is meant to be per sample of the batch $(x, y)$.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        Tensor representing the element-wise inverse Hessian matrix vector products

    """
    return super().influence_factors(x, y)

influences(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

Compute the approximation of

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case.

PARAMETER	DESCRIPTION
x_test	model input to use in the gradient computations of \(H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
y_test	label tensor to compute gradients TYPE: Tensor
x	optional model input to use in the gradient computations \(\nabla_{theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))\), if None, use \(x=x_{\text{test}}\) TYPE: Optional[Tensor] DEFAULT: None
y	optional label tensor to compute gradients TYPE: Optional[Tensor] DEFAULT: None
mode	enum value of [InfluenceType][pydvl.influence.base_influence_model.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Compute the approximation of

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the case of up-weighting influence, resp.

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the perturbation type influence case.

    Args:
        x_test: model input to use in the gradient computations
            of $H^{-1}\nabla_{theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    t: torch.Tensor = super().influences(x_test, y_test, x, y, mode=mode)
    return t

influences_from_factors(z_test_factors, x, y, mode=InfluenceMode.Up)

Computation of

\[ \langle z_{\text{test_factors}}, \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle z_{\text{test_factors}}, \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
z_test_factors	pre-computed tensor, approximating \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
x	model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\) TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
mode	enum value of [InfluenceType][pydvl.influence.twice_differentiable.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors(
    self,
    z_test_factors: torch.Tensor,
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The gradient is meant to be per sample
    of the batch $(x, y)$.

    Args:
         z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    if mode == InfluenceMode.Up:
        return (
            z_test_factors
            @ self._loss_grad(x.to(self.model_device), y.to(self.model_device)).T
        )
    elif mode == InfluenceMode.Perturbation:
        return torch.einsum(
            "ia,j...a->ij...",
            z_test_factors,
            self._flat_loss_mixed_grad(
                x.to(self.model_device), y.to(self.model_device)
            ),
        )
    else:
        raise UnsupportedInfluenceModeException(mode)

fit(data)

Fitting corresponds to the computation of the low rank decomposition

\[ V D^{-1} V^T \]

of the Hessian defined by the provided data loader.

PARAMETER	DESCRIPTION
data	Instance of [torch.utils.data.Dataloader][] TYPE: DataLoader

RETURNS	DESCRIPTION
ArnoldiInfluence	The fitted instance

Source code in src/pydvl/influence/torch/influence_function_model.py

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: Instance of [torch.utils.data.Dataloader][torch.utils.data.Dataloader]

    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,
    )
    self.low_rank_representation = low_rank_representation.to(self.model_device)
    return self

EkfacInfluence(model, update_diagonal=False, hessian_regularization=0.0, progress=False)

Bases: TorchInfluenceFunctionModel

Approximately solves the linear system Hx = b, where H is the Hessian of a model with the empirical categorical cross entropy as loss function and b is the given right-hand side vector. It employs the EK-FAC method [@george2018fast], which is based on the kronecker factorization of the Hessian first introduced in [@martens2015optimizing]. Contrary to the other influence function methods, this implementation can only be used for classification tasks with a cross entropy loss function. However, it is much faster than the other methods and can be used efficiently for very large datasets and models. For more information, see [Eigenvalue Corrected K-FAC][ekfac].

PARAMETER	DESCRIPTION
model	Instance of torch.nn.Module. TYPE: Module
update_diagonal	If True, the diagonal values in the ekfac representation are refitted from the training data after calculating the KFAC blocks. This provides a more accurate approximation of the Hessian, but it is computationally more expensive. TYPE: bool DEFAULT: False
hessian_regularization	Regularization of the hessian. TYPE: float DEFAULT: 0.0
progress	If True, display progress bars. TYPE: bool DEFAULT: False

Source code in src/pydvl/influence/torch/influence_function_model.py

def __init__(
    self,
    model: nn.Module,
    update_diagonal: bool = False,
    hessian_regularization: float = 0.0,
    progress: bool = False,
):

    super().__init__(model, torch.nn.functional.cross_entropy)
    self.hessian_regularization = hessian_regularization
    self.update_diagonal = update_diagonal
    self.active_layers = self._parse_active_layers()
    self.progress = progress

influence_factors(x, y)

Compute approximation of

\[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

where the gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise inverse Hessian matrix vector products

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    r"""
    Compute approximation of

    \[ H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x)) \]

    where the gradient is meant to be per sample of the batch $(x, y)$.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        Tensor representing the element-wise inverse Hessian matrix vector products

    """
    return super().influence_factors(x, y)

influences(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

Compute the approximation of

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})), \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case.

PARAMETER	DESCRIPTION
x_test	model input to use in the gradient computations of \(H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
y_test	label tensor to compute gradients TYPE: Tensor
x	optional model input to use in the gradient computations \(\nabla_{theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))\), if None, use \(x=x_{\text{test}}\) TYPE: Optional[Tensor] DEFAULT: None
y	optional label tensor to compute gradients TYPE: Optional[Tensor] DEFAULT: None
mode	enum value of [InfluenceType][pydvl.influence.base_influence_model.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Compute the approximation of

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the case of up-weighting influence, resp.

    \[
    \langle H^{-1}\nabla_{theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}})),
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle
    \]

    for the perturbation type influence case.

    Args:
        x_test: model input to use in the gradient computations
            of $H^{-1}\nabla_{theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    t: torch.Tensor = super().influences(x_test, y_test, x, y, mode=mode)
    return t

influences_from_factors(z_test_factors, x, y, mode=InfluenceMode.Up)

Computation of

\[ \langle z_{\text{test_factors}}, \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the case of up-weighting influence, resp.

\[ \langle z_{\text{test_factors}}, \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

for the perturbation type influence case. The gradient is meant to be per sample of the batch \((x, y)\).

PARAMETER	DESCRIPTION
z_test_factors	pre-computed tensor, approximating \(H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, f_{\theta}(x_{\text{test}}))\) TYPE: Tensor
x	model input to use in the gradient computations \(\nabla_{\theta}\ell(y, f_{\theta}(x))\), resp. \(\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))\) TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
mode	enum value of [InfluenceType][pydvl.influence.twice_differentiable.InfluenceType] TYPE: InfluenceMode DEFAULT: Up

RETURNS	DESCRIPTION
Tensor	Tensor representing the element-wise scalar products for the provided batch

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors(
    self,
    z_test_factors: torch.Tensor,
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> torch.Tensor:
    r"""
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case. The gradient is meant to be per sample
    of the batch $(x, y)$.

    Args:
         z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        Tensor representing the element-wise scalar products for the provided batch

    """
    if mode == InfluenceMode.Up:
        return (
            z_test_factors
            @ self._loss_grad(x.to(self.model_device), y.to(self.model_device)).T
        )
    elif mode == InfluenceMode.Perturbation:
        return torch.einsum(
            "ia,j...a->ij...",
            z_test_factors,
            self._flat_loss_mixed_grad(
                x.to(self.model_device), y.to(self.model_device)
            ),
        )
    else:
        raise UnsupportedInfluenceModeException(mode)

fit(data)

Compute the KFAC blocks for each layer of the model, using the provided data. It then creates an EkfacRepresentation object that stores the KFAC blocks for each layer, their eigenvalue decomposition and diagonal values.

Source code in src/pydvl/influence/torch/influence_function_model.py

def fit(self, data: DataLoader) -> EkfacInfluence:
    """
    Compute the KFAC blocks for each layer of the model, using the provided data.
    It then creates an EkfacRepresentation object that stores the KFAC blocks for
    each layer, their eigenvalue decomposition and diagonal values.
    """
    forward_x, grad_y = self._get_kfac_blocks(data)
    layers_evecs_a = {}
    layers_evect_g = {}
    layers_diags = {}
    for key in self.active_layers.keys():
        evals_a, evecs_a = torch.linalg.eigh(forward_x[key])
        evals_g, evecs_g = torch.linalg.eigh(grad_y[key])
        layers_evecs_a[key] = evecs_a
        layers_evect_g[key] = evecs_g
        layers_diags[key] = torch.kron(evals_g.view(-1, 1), evals_a.view(-1, 1))

    self.ekfac_representation = EkfacRepresentation(
        self.active_layers.keys(),
        self.active_layers.values(),
        layers_evecs_a.values(),
        layers_evect_g.values(),
        layers_diags.values(),
    )
    if self.update_diagonal:
        self._update_diag(data)
    return self

influences_by_layer(x_test, y_test, x=None, y=None, mode=InfluenceMode.Up)

    Compute the influence of the data on the test data for each layer of the model.

    Args:
        x_test: model input to use in the gradient computations of
            $H^{-1}

abla_{ heta} \ell(y_{ ext{test}}, f_{ heta}(x_{ ext{test}}))$ y_test: label tensor to compute gradients x: optional model input to use in the gradient computations $ abla_{ heta}\ell(y, f_{ heta}(x))$, resp. $ abla_{x} abla_{ heta}\ell(y, f_{ heta}(x))$, if None, use \(x=x_{ ext{test}}\) y: optional label tensor to compute gradients mode: enum value of [InfluenceType] [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        A dictionary containing the influence of the data on the test data for each
        layer of the model, with the layer name as key.

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_by_layer(
    self,
    x_test: torch.Tensor,
    y_test: torch.Tensor,
    x: Optional[torch.Tensor] = None,
    y: Optional[torch.Tensor] = None,
    mode: InfluenceMode = InfluenceMode.Up,
) -> Dict[str, torch.Tensor]:
    """
    Compute the influence of the data on the test data for each layer of the model.

    Args:
        x_test: model input to use in the gradient computations of
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
        y_test: label tensor to compute gradients
        x: optional model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            if None, use $x=x_{\text{test}}$
        y: optional label tensor to compute gradients
        mode: enum value of [InfluenceType]
            [pydvl.influence.base_influence_model.InfluenceType]

    Returns:
        A dictionary containing the influence of the data on the test data for each
        layer of the model, with the layer name as key.
    """
    if not self.is_fitted:
        raise ValueError(
            "Instance must be fitted before calling influence methods on it"
        )

    if x is None:

        if y is not None:
            raise ValueError(
                "Providing labels y, without providing model input x "
                "is not supported"
            )

        return self._symmetric_values_by_layer(
            x_test.to(self.model_device),
            y_test.to(self.model_device),
            mode,
        )

    if y is None:
        raise ValueError(
            "Providing model input x without providing labels y is not supported"
        )

    return self._non_symmetric_values_by_layer(
        x_test.to(self.model_device),
        y_test.to(self.model_device),
        x.to(self.model_device),
        y.to(self.model_device),
        mode,
    )

influence_factors_by_layer(x, y)

    Computes the approximation of

    \[H^{-1}

abla_{ heta} \ell(y, f_{ heta}(x))]

    for each layer of the model separately.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        A dictionary containing the influence factors for each layer of the model,
        with the layer name as key.

Source code in src/pydvl/influence/torch/influence_function_model.py

def influence_factors_by_layer(
    self,
    x: torch.Tensor,
    y: torch.Tensor,
) -> Dict[str, torch.Tensor]:
    """
    Computes the approximation of

    \[H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x))\]

    for each layer of the model separately.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients

    Returns:
        A dictionary containing the influence factors for each layer of the model,
        with the layer name as key.
    """
    if not self.is_fitted:
        raise ValueError(
            "Instance must be fitted before calling influence methods on it"
        )

    return self._solve_hvp_by_layer(
        self._loss_grad(x.to(self.model_device), y.to(self.model_device)),
        self.ekfac_representation,
        self.hessian_regularization,
    )

influences_from_factors_by_layer(z_test_factors, x, y, mode=InfluenceMode.Up)

    Computation of

    \[ \langle z_{  ext{test_factors}},

abla_{ heta} \ell(y, f_{ heta}(x)) angle ]

    for the case of up-weighting influence, resp.

    \[ \langle z_{  ext{test_factors}},

abla_{x} abla_{ heta} \ell(y, f_{ heta}(x)) angle ]

    for the perturbation type influence case for each layer of the model separately.
    The gradients are meant to be per sample of the batch $(x, y)$.

    Args:
        z_test_factors: pre-computed tensor, approximating
            $H^{-1}

abla_{ heta} \ell(y_{ ext{test}}, f_{ heta}(x_{ ext{test}}))$ x: model input to use in the gradient computations $ abla_{ heta}\ell(y, f_{ heta}(x))$, resp. $ abla_{x} abla_{ heta}\ell(y, f_{ heta}(x))$ y: label tensor to compute gradients mode: enum value of [InfluenceType] [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        A dictionary containing the influence of the data on the test data for each
        layer of the model, with the layer name as key.

Source code in src/pydvl/influence/torch/influence_function_model.py

def influences_from_factors_by_layer(
    self,
    z_test_factors: Dict[str, torch.Tensor],
    x: torch.Tensor,
    y: torch.Tensor,
    mode: InfluenceMode = InfluenceMode.Up,
) -> Dict[str, torch.Tensor]:
    """
    Computation of

    \[ \langle z_{\text{test_factors}},
        \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the case of up-weighting influence, resp.

    \[ \langle z_{\text{test_factors}},
        \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \]

    for the perturbation type influence case for each layer of the model separately.
    The gradients are meant to be per sample of the batch $(x, y)$.

    Args:
        z_test_factors: pre-computed tensor, approximating
            $H^{-1}\nabla_{\theta} \ell(y_{\text{test}},
                f_{\theta}(x_{\text{test}}))$
         x: model input to use in the gradient computations
            $\nabla_{\theta}\ell(y, f_{\theta}(x))$,
            resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$
         y: label tensor to compute gradients
         mode: enum value of [InfluenceType]
            [pydvl.influence.twice_differentiable.InfluenceType]

    Returns:
        A dictionary containing the influence of the data on the test data for each
        layer of the model, with the layer name as key.
    """
    if mode == InfluenceMode.Up:
        total_grad = self._loss_grad(
            x.to(self.model_device), y.to(self.model_device)
        )
        start_idx = 0
        influences = {}
        for layer_id, layer_z_test in z_test_factors.items():
            end_idx = start_idx + layer_z_test.shape[1]
            influences[layer_id] = layer_z_test @ total_grad[:, start_idx:end_idx].T
            start_idx = end_idx
        return influences
    elif mode == InfluenceMode.Perturbation:
        total_mixed_grad = self._flat_loss_mixed_grad(
            x.to(self.model_device), y.to(self.model_device)
        )
        start_idx = 0
        influences = {}
        for layer_id, layer_z_test in z_test_factors.items():
            end_idx = start_idx + layer_z_test.shape[1]
            influences[layer_id] = torch.einsum(
                "ia,j...a->ij...",
                layer_z_test,
                total_mixed_grad[:, start_idx:end_idx],
            )
            start_idx = end_idx
        return influences
    else:
        raise UnsupportedInfluenceModeException(mode)

explore_hessian_regularization(x, y, regularization_values)

Efficiently computes the influence for input x and label y for each layer of the model, for different values of the hessian regularization parameter. This is done by computing the gradient of the loss function for the input x and label y only once and then solving the Hessian Vector Product for each regularization value. This is useful for finding the optimal regularization value and for exploring how robust the influence values are to changes in the regularization value.

PARAMETER	DESCRIPTION
x	model input to use in the gradient computations TYPE: Tensor
y	label tensor to compute gradients TYPE: Tensor
regularization_values	list of regularization values to use TYPE: List[float]

RETURNS	DESCRIPTION
Dict[float, Dict[str, Tensor]]	A dictionary containing with keys being the regularization values and values
Dict[float, Dict[str, Tensor]]	being dictionaries containing the influences for each layer of the model,
Dict[float, Dict[str, Tensor]]	with the layer name as key.

Source code in src/pydvl/influence/torch/influence_function_model.py

def explore_hessian_regularization(
    self,
    x: torch.Tensor,
    y: torch.Tensor,
    regularization_values: List[float],
) -> Dict[float, Dict[str, torch.Tensor]]:
    """
    Efficiently computes the influence for input x and label y for each layer of the
    model, for different values of the hessian regularization parameter. This is done
    by computing the gradient of the loss function for the input x and label y only once
    and then solving the Hessian Vector Product for each regularization value. This is
    useful for finding the optimal regularization value and for exploring
    how robust the influence values are to changes in the regularization value.

    Args:
        x: model input to use in the gradient computations
        y: label tensor to compute gradients
        regularization_values: list of regularization values to use

    Returns:
        A dictionary containing with keys being the regularization values and values
        being dictionaries containing the influences for each layer of the model,
        with the layer name as key.
    """
    grad = self._loss_grad(x, y)
    influences_by_reg_value = {}
    for reg_value in regularization_values:
        reg_factors = self._solve_hvp_by_layer(
            grad, self.ekfac_representation, reg_value
        )
        values = {}
        start_idx = 0
        for layer_id, layer_fac in reg_factors.items():
            end_idx = start_idx + layer_fac.shape[1]
            values[layer_id] = layer_fac @ grad[:, start_idx:end_idx].T
            start_idx = end_idx
        influences_by_reg_value[reg_value] = values
    return influences_by_reg_value