pydvl.valuation.samplers.permutation ¶

Permutation samplers draw permutations \(\sigma^N\) from the index set \(N\) uniformly at random and iterate through it returning the sets:

\[S_1 = \{\sigma^N_1\}, S_2 = \{\sigma^N_1, \sigma^N_2\}, S_3 = \{\sigma^N_1,\sigma^N_2, \sigma^N_3\}, ...\]

The probability of sampling a set¶

Read on below for the actual formula

This section describes the general case. However, because of how the samplers are used to compute marginals, the effective sampling probabilities are slightly different.

Let \(k\) be the size of a sampled set \(S\) and \(n=|N|\) the size of the index set. By the product rule:

\[p(S) = p(S \mid k) \ p(k).\]

Now, for a uniformly chosen permutation, every subset of size \(k\) appears as the prefix (the first \(k\) elements) with probability

\[ p (S \mid k) = \frac{k! (n - k) !}{n!} = \binom{n}{k}^{- 1}, \]

and, because we iterate from left to right, each size \(k\) is sampled with probability \(p(k) = 1/n.\) Hence:

\[ p(S) = \frac{1}{n} \binom{n}{k}^{- 1}. \]

The same argument applies to the DeterministicPermutationSampler and PermutationSampler, but also to AntitheticPermutationSampler. For the latter, note that the sampling process is symmetric.

The case of a fixed index when computing marginals¶

However, when computing marginal utilities, which is what the samplers are used for, the situation is slightly different since we update indices \(i\) sequentially. In Sampling strategies for semi-values a more convoluted argument is made, whereby one splits the permutation by the index \(i\). This ends up being similar to what we found above:

\[ p(S) = \frac{1}{n} \binom{n-1}{k}^{- 1}, \]

Therefore, log_weight() is valid, when computing marginal utilities.

References¶

Mitchell, Rory, Joshua Cooper, Eibe Frank, and Geoffrey Holmes. Sampling Permutations for Shapley Value Estimation. Journal of Machine Learning Research 23, no. 43 (2022): 1–46. ↩
Watson, Lauren, Zeno Kujawa, Rayna Andreeva, Hao-Tsung Yang, Tariq Elahi, and Rik Sarkar. Accelerated Shapley Value Approximation for Data Evaluation. arXiv, 9 November 2023. ↩

AntitheticPermutationSampler ¶

AntitheticPermutationSampler(
    truncation: TruncationPolicy | None = None,
    seed: Seed | None = None,
    batch_size: int = 1,
)

Bases: PermutationSampler

Samples permutations like PermutationSampler, but after each permutation, it returns the same permutation in reverse order.

This sampler was suggested in (Mitchell et al. 2022)¹

Batching

Even though this sampler supports batching, it is not recommended to use it since the PermutationEvaluationStrategy processes whole permutations in one go, effectively batching the computation of up to n-1 marginal utilities in one process.

PARAMETER	DESCRIPTION
`truncation`	A policy to stop the permutation early. TYPE: `TruncationPolicy \| None` DEFAULT: `None`
`seed`	Seed for the random number generator. TYPE: `Seed \| None` DEFAULT: `None`
`batch_size`	The number of samples (full permutations) to generate at once. TYPE: `int` DEFAULT: `1`

New in version 0.7.1

Source code in src/pydvl/valuation/samplers/permutation.py

def __init__(
    self,
    truncation: TruncationPolicy | None = None,
    seed: Seed | None = None,
    batch_size: int = 1,
):
    super().__init__(seed=seed, truncation=truncation, batch_size=batch_size)

interrupted `property` ¶

interrupted: bool

Whether the sampler has been interrupted.

len ¶

__len__() -> int

Returns the length of the current sample generation in generate_batches.

RAISES	DESCRIPTION
`TypeError`	if the sampler is infinite or generate_batches has not been called yet.

Source code in src/pydvl/valuation/samplers/base.py

def __len__(self) -> int:
    """Returns the length of the current sample generation in generate_batches.

    Raises:
        `TypeError`: if the sampler is infinite or
            [generate_batches][pydvl.valuation.samplers.IndexSampler.generate_batches]
            has not been called yet.
    """
    if self._len is None:
        raise TypeError(f"This {self.__class__.__name__} has no length")
    return self._len

repr ¶

__repr__() -> str

FIXME: This is not a proper representation of the sampler.

Source code in src/pydvl/valuation/samplers/base.py

def __repr__(self) -> str:
    """FIXME: This is not a proper representation of the sampler."""
    return f"{self.__class__.__name__}"

complement_size ¶

complement_size(n: int) -> int

Size of the complement of an index wrt. set size n.

Required in certain coefficient computations. Even though we are sampling permutations, updates are always done per-index and the size of the complement is always \(n-1\).

Source code in src/pydvl/valuation/samplers/permutation.py

def complement_size(self, n: int) -> int:
    """Size of the complement of an index wrt. set size `n`.

    Required in certain coefficient computations. Even though we are sampling
    permutations, updates are always done per-index and the size of the complement
    is always $n-1$.
    """
    return n - 1

generate_batches ¶

generate_batches(indices: IndexSetT) -> BatchGenerator

Batches the samples and yields them.

Source code in src/pydvl/valuation/samplers/base.py

def generate_batches(self, indices: IndexSetT) -> BatchGenerator:
    """Batches the samples and yields them."""
    self._len = self.sample_limit(indices)

    # Create an empty generator if the indices are empty: `return` acts like a
    # `break`, and produces an empty generator.
    if len(indices) == 0:
        return

    self._interrupted = False
    self._n_samples = 0
    for batch in chunked(self.generate(indices), self.batch_size):
        self._n_samples += len(batch)
        yield batch
        if self._interrupted:
            break

interrupt ¶

interrupt()

Signals the sampler to stop generating samples after the current batch.

Source code in src/pydvl/valuation/samplers/base.py

def interrupt(self):
    """Signals the sampler to stop generating samples after the current batch."""
    self._interrupted = True

log_weight ¶

log_weight(n: int, subset_len: int) -> float

Log probability of sampling a set S from a set of size n-1.

See the module's documentation for details.

Source code in src/pydvl/valuation/samplers/permutation.py

def log_weight(self, n: int, subset_len: int) -> float:
    r"""Log probability of sampling a set S from a set of size **n-1**.

    See [the module's documentation][pydvl.valuation.samplers.permutation] for
    details.
    """
    if n > 0:
        return float(-np.log(n) - logcomb(n - 1, subset_len))
    return -np.inf

result_updater ¶

result_updater(result: ValuationResult) -> ResultUpdater[ValueUpdateT]

Returns an object that updates a valuation result with a value update.

Because we use log-space computation for numerical stability, the default result updater keeps track of several quantities required to maintain accurate running 1st and 2nd moments.

PARAMETER	DESCRIPTION
`result`	The result to update TYPE: `ValuationResult`

Returns: A callable object that updates the result with a value update

Source code in src/pydvl/valuation/samplers/base.py

def result_updater(self, result: ValuationResult) -> ResultUpdater[ValueUpdateT]:
    """Returns an object that updates a valuation result with a value update.

    Because we use log-space computation for numerical stability, the default result
    updater keeps track of several quantities required to maintain accurate running
    1st and 2nd moments.

    Args:
        result: The result to update
    Returns:
        A callable object that updates the result with a value update
    """
    return LogResultUpdater(result)

DeterministicPermutationSampler ¶

DeterministicPermutationSampler(
    *args,
    truncation: TruncationPolicy | None = None,
    batch_size: int = 1,
    **kwargs,
)

Bases: PermutationSamplerBase

Samples all n! permutations of the indices deterministically.

Batching

Even though this sampler supports batching, it is not recommended to use it since the PermutationEvaluationStrategy processes whole permutations in one go, effectively batching the computation of up to n-1 marginal utilities in one process.

Source code in src/pydvl/valuation/samplers/permutation.py

def __init__(
    self,
    *args,
    truncation: TruncationPolicy | None = None,
    batch_size: int = 1,
    **kwargs,
):
    super().__init__(batch_size=batch_size)
    self.truncation = truncation or NoTruncation()

interrupted `property` ¶

interrupted: bool

Whether the sampler has been interrupted.

skip_indices `property` `writable` ¶

skip_indices: IndexSetT

Indices being skipped in the sampler. The exact behaviour will be sampler-dependent, so that setting this property is disabled by default.

len ¶

__len__() -> int

Returns the length of the current sample generation in generate_batches.

RAISES	DESCRIPTION
`TypeError`	if the sampler is infinite or generate_batches has not been called yet.

Source code in src/pydvl/valuation/samplers/base.py

def __len__(self) -> int:
    """Returns the length of the current sample generation in generate_batches.

    Raises:
        `TypeError`: if the sampler is infinite or
            [generate_batches][pydvl.valuation.samplers.IndexSampler.generate_batches]
            has not been called yet.
    """
    if self._len is None:
        raise TypeError(f"This {self.__class__.__name__} has no length")
    return self._len

repr ¶

__repr__() -> str

FIXME: This is not a proper representation of the sampler.

Source code in src/pydvl/valuation/samplers/base.py

def __repr__(self) -> str:
    """FIXME: This is not a proper representation of the sampler."""
    return f"{self.__class__.__name__}"

complement_size ¶

complement_size(n: int) -> int

Size of the complement of an index wrt. set size n.

Required in certain coefficient computations. Even though we are sampling permutations, updates are always done per-index and the size of the complement is always \(n-1\).

Source code in src/pydvl/valuation/samplers/permutation.py

def complement_size(self, n: int) -> int:
    """Size of the complement of an index wrt. set size `n`.

    Required in certain coefficient computations. Even though we are sampling
    permutations, updates are always done per-index and the size of the complement
    is always $n-1$.
    """
    return n - 1

generate_batches ¶

generate_batches(indices: IndexSetT) -> BatchGenerator

Batches the samples and yields them.

Source code in src/pydvl/valuation/samplers/base.py

def generate_batches(self, indices: IndexSetT) -> BatchGenerator:
    """Batches the samples and yields them."""
    self._len = self.sample_limit(indices)

    # Create an empty generator if the indices are empty: `return` acts like a
    # `break`, and produces an empty generator.
    if len(indices) == 0:
        return

    self._interrupted = False
    self._n_samples = 0
    for batch in chunked(self.generate(indices), self.batch_size):
        self._n_samples += len(batch)
        yield batch
        if self._interrupted:
            break

interrupt ¶

interrupt()

Signals the sampler to stop generating samples after the current batch.

Source code in src/pydvl/valuation/samplers/base.py

def interrupt(self):
    """Signals the sampler to stop generating samples after the current batch."""
    self._interrupted = True

log_weight ¶

log_weight(n: int, subset_len: int) -> float

Log probability of sampling a set S from a set of size n-1.

See the module's documentation for details.

Source code in src/pydvl/valuation/samplers/permutation.py

def log_weight(self, n: int, subset_len: int) -> float:
    r"""Log probability of sampling a set S from a set of size **n-1**.

    See [the module's documentation][pydvl.valuation.samplers.permutation] for
    details.
    """
    if n > 0:
        return float(-np.log(n) - logcomb(n - 1, subset_len))
    return -np.inf

result_updater ¶

result_updater(result: ValuationResult) -> ResultUpdater[ValueUpdateT]

Returns an object that updates a valuation result with a value update.

Because we use log-space computation for numerical stability, the default result updater keeps track of several quantities required to maintain accurate running 1st and 2nd moments.

PARAMETER	DESCRIPTION
`result`	The result to update TYPE: `ValuationResult`

Returns: A callable object that updates the result with a value update

Source code in src/pydvl/valuation/samplers/base.py

def result_updater(self, result: ValuationResult) -> ResultUpdater[ValueUpdateT]:
    """Returns an object that updates a valuation result with a value update.

    Because we use log-space computation for numerical stability, the default result
    updater keeps track of several quantities required to maintain accurate running
    1st and 2nd moments.

    Args:
        result: The result to update
    Returns:
        A callable object that updates the result with a value update
    """
    return LogResultUpdater(result)

PermutationEvaluationStrategy ¶

PermutationEvaluationStrategy(
    sampler: PermutationSamplerBase,
    utility: UtilityBase,
    coefficient: SemivalueCoefficient | None,
)

Bases: EvaluationStrategy[PermutationSamplerBase, ValueUpdate]

Computes marginal values for permutation sampling schemes.

This strategy iterates over permutations from left to right, computing the marginal utility wrt. the previous one at each step to save computation.

The TruncationPolicy of the sampler is copied and reset for each permutation in a batch.

Source code in src/pydvl/valuation/samplers/permutation.py

def __init__(
    self,
    sampler: PermutationSamplerBase,
    utility: UtilityBase,
    coefficient: SemivalueCoefficient | None,
):
    super().__init__(utility, coefficient)
    self.truncation = copy(sampler.truncation)
    self.truncation.reset(utility)  # Perform initial setup (e.g. total_utility)

PermutationSampler ¶

PermutationSampler(
    truncation: TruncationPolicy | None = None,
    seed: Seed | None = None,
    batch_size: int = 1,
)

Bases: StochasticSamplerMixin, PermutationSamplerBase

Samples permutations of indices.

Batching

Even though this sampler supports batching, it is not recommended to use it since the PermutationEvaluationStrategy processes whole permutations in one go, effectively batching the computation of up to n-1 marginal utilities in one process.

PARAMETER	DESCRIPTION
`truncation`	A policy to stop the permutation early. TYPE: `TruncationPolicy \| None` DEFAULT: `None`
`seed`	Seed for the random number generator. TYPE: `Seed \| None` DEFAULT: `None`
`batch_size`	The number of samples (full permutations) to generate at once. TYPE: `int` DEFAULT: `1`

Source code in src/pydvl/valuation/samplers/permutation.py

def __init__(
    self,
    truncation: TruncationPolicy | None = None,
    seed: Seed | None = None,
    batch_size: int = 1,
):
    super().__init__(seed=seed, truncation=truncation, batch_size=batch_size)

interrupted `property` ¶

interrupted: bool

Whether the sampler has been interrupted.

len ¶

__len__() -> int

Returns the length of the current sample generation in generate_batches.

RAISES	DESCRIPTION
`TypeError`	if the sampler is infinite or generate_batches has not been called yet.

Source code in src/pydvl/valuation/samplers/base.py

def __len__(self) -> int:
    """Returns the length of the current sample generation in generate_batches.

    Raises:
        `TypeError`: if the sampler is infinite or
            [generate_batches][pydvl.valuation.samplers.IndexSampler.generate_batches]
            has not been called yet.
    """
    if self._len is None:
        raise TypeError(f"This {self.__class__.__name__} has no length")
    return self._len

repr ¶

__repr__() -> str

FIXME: This is not a proper representation of the sampler.

Source code in src/pydvl/valuation/samplers/base.py

def __repr__(self) -> str:
    """FIXME: This is not a proper representation of the sampler."""
    return f"{self.__class__.__name__}"

complement_size ¶

complement_size(n: int) -> int

Size of the complement of an index wrt. set size n.

Required in certain coefficient computations. Even though we are sampling permutations, updates are always done per-index and the size of the complement is always \(n-1\).

Source code in src/pydvl/valuation/samplers/permutation.py

def complement_size(self, n: int) -> int:
    """Size of the complement of an index wrt. set size `n`.

    Required in certain coefficient computations. Even though we are sampling
    permutations, updates are always done per-index and the size of the complement
    is always $n-1$.
    """
    return n - 1

generate ¶

generate(indices: IndexSetT) -> SampleGenerator

Generates the permutation samples.

PARAMETER	DESCRIPTION
`indices`	The indices to sample from. If empty, no samples are generated. If skip_indices is set, these indices are removed from the set before generating the permutation. TYPE: `IndexSetT`

Source code in src/pydvl/valuation/samplers/permutation.py

def generate(self, indices: IndexSetT) -> SampleGenerator:
    """Generates the permutation samples.

    Args:
        indices: The indices to sample from. If empty, no samples are generated. If
            [skip_indices][pydvl.valuation.samplers.base.IndexSampler.skip_indices]
            is set, these indices are removed from the set before generating the
            permutation.
    """
    if len(indices) == 0:
        return
    while True:
        _indices = np.setdiff1d(indices, self.skip_indices)
        yield Sample(None, self._rng.permutation(_indices))

generate_batches ¶

generate_batches(indices: IndexSetT) -> BatchGenerator

Batches the samples and yields them.

Source code in src/pydvl/valuation/samplers/base.py

def generate_batches(self, indices: IndexSetT) -> BatchGenerator:
    """Batches the samples and yields them."""
    self._len = self.sample_limit(indices)

    # Create an empty generator if the indices are empty: `return` acts like a
    # `break`, and produces an empty generator.
    if len(indices) == 0:
        return

    self._interrupted = False
    self._n_samples = 0
    for batch in chunked(self.generate(indices), self.batch_size):
        self._n_samples += len(batch)
        yield batch
        if self._interrupted:
            break

interrupt ¶

interrupt()

Signals the sampler to stop generating samples after the current batch.

Source code in src/pydvl/valuation/samplers/base.py

def interrupt(self):
    """Signals the sampler to stop generating samples after the current batch."""
    self._interrupted = True

log_weight ¶

log_weight(n: int, subset_len: int) -> float

Log probability of sampling a set S from a set of size n-1.

See the module's documentation for details.

Source code in src/pydvl/valuation/samplers/permutation.py

def log_weight(self, n: int, subset_len: int) -> float:
    r"""Log probability of sampling a set S from a set of size **n-1**.

    See [the module's documentation][pydvl.valuation.samplers.permutation] for
    details.
    """
    if n > 0:
        return float(-np.log(n) - logcomb(n - 1, subset_len))
    return -np.inf

result_updater ¶

result_updater(result: ValuationResult) -> ResultUpdater[ValueUpdateT]

Returns an object that updates a valuation result with a value update.

Because we use log-space computation for numerical stability, the default result updater keeps track of several quantities required to maintain accurate running 1st and 2nd moments.

PARAMETER	DESCRIPTION
`result`	The result to update TYPE: `ValuationResult`

Returns: A callable object that updates the result with a value update

Source code in src/pydvl/valuation/samplers/base.py

def result_updater(self, result: ValuationResult) -> ResultUpdater[ValueUpdateT]:
    """Returns an object that updates a valuation result with a value update.

    Because we use log-space computation for numerical stability, the default result
    updater keeps track of several quantities required to maintain accurate running
    1st and 2nd moments.

    Args:
        result: The result to update
    Returns:
        A callable object that updates the result with a value update
    """
    return LogResultUpdater(result)

PermutationSamplerBase ¶

PermutationSamplerBase(
    *args,
    truncation: TruncationPolicy | None = None,
    batch_size: int = 1,
    **kwargs,
)

Bases: IndexSampler, ABC

Base class for permutation samplers.

Source code in src/pydvl/valuation/samplers/permutation.py

def __init__(
    self,
    *args,
    truncation: TruncationPolicy | None = None,
    batch_size: int = 1,
    **kwargs,
):
    super().__init__(batch_size=batch_size)
    self.truncation = truncation or NoTruncation()

interrupted `property` ¶

interrupted: bool

Whether the sampler has been interrupted.

skip_indices `property` `writable` ¶

skip_indices: IndexSetT

Indices being skipped in the sampler. The exact behaviour will be sampler-dependent, so that setting this property is disabled by default.

len ¶

__len__() -> int

Returns the length of the current sample generation in generate_batches.

RAISES	DESCRIPTION
`TypeError`	if the sampler is infinite or generate_batches has not been called yet.

Source code in src/pydvl/valuation/samplers/base.py

def __len__(self) -> int:
    """Returns the length of the current sample generation in generate_batches.

    Raises:
        `TypeError`: if the sampler is infinite or
            [generate_batches][pydvl.valuation.samplers.IndexSampler.generate_batches]
            has not been called yet.
    """
    if self._len is None:
        raise TypeError(f"This {self.__class__.__name__} has no length")
    return self._len

repr ¶

__repr__() -> str

FIXME: This is not a proper representation of the sampler.

Source code in src/pydvl/valuation/samplers/base.py

def __repr__(self) -> str:
    """FIXME: This is not a proper representation of the sampler."""
    return f"{self.__class__.__name__}"

complement_size ¶

complement_size(n: int) -> int

Size of the complement of an index wrt. set size n.

Required in certain coefficient computations. Even though we are sampling permutations, updates are always done per-index and the size of the complement is always \(n-1\).

Source code in src/pydvl/valuation/samplers/permutation.py

def complement_size(self, n: int) -> int:
    """Size of the complement of an index wrt. set size `n`.

    Required in certain coefficient computations. Even though we are sampling
    permutations, updates are always done per-index and the size of the complement
    is always $n-1$.
    """
    return n - 1

generate `abstractmethod` ¶

generate(indices: IndexSetT) -> SampleGenerator

Generates single samples.

IndexSampler.generate_batches() will batch these samples according to the batch size set upon construction.

PARAMETER	DESCRIPTION
`indices`	TYPE: `IndexSetT`

YIELDS	DESCRIPTION
`SampleGenerator`	A tuple (idx, subset) for each sample.

Source code in src/pydvl/valuation/samplers/base.py

@abstractmethod
def generate(self, indices: IndexSetT) -> SampleGenerator:
    """Generates single samples.

    `IndexSampler.generate_batches()` will batch these samples according to the
    batch size set upon construction.

    Args:
        indices:

    Yields:
        A tuple (idx, subset) for each sample.
    """
    ...

generate_batches ¶

generate_batches(indices: IndexSetT) -> BatchGenerator

Batches the samples and yields them.

Source code in src/pydvl/valuation/samplers/base.py

def generate_batches(self, indices: IndexSetT) -> BatchGenerator:
    """Batches the samples and yields them."""
    self._len = self.sample_limit(indices)

    # Create an empty generator if the indices are empty: `return` acts like a
    # `break`, and produces an empty generator.
    if len(indices) == 0:
        return

    self._interrupted = False
    self._n_samples = 0
    for batch in chunked(self.generate(indices), self.batch_size):
        self._n_samples += len(batch)
        yield batch
        if self._interrupted:
            break

interrupt ¶

interrupt()

Signals the sampler to stop generating samples after the current batch.

Source code in src/pydvl/valuation/samplers/base.py

def interrupt(self):
    """Signals the sampler to stop generating samples after the current batch."""
    self._interrupted = True

log_weight ¶

log_weight(n: int, subset_len: int) -> float

Log probability of sampling a set S from a set of size n-1.

See the module's documentation for details.

Source code in src/pydvl/valuation/samplers/permutation.py

def log_weight(self, n: int, subset_len: int) -> float:
    r"""Log probability of sampling a set S from a set of size **n-1**.

    See [the module's documentation][pydvl.valuation.samplers.permutation] for
    details.
    """
    if n > 0:
        return float(-np.log(n) - logcomb(n - 1, subset_len))
    return -np.inf

result_updater ¶

result_updater(result: ValuationResult) -> ResultUpdater[ValueUpdateT]

Returns an object that updates a valuation result with a value update.

Because we use log-space computation for numerical stability, the default result updater keeps track of several quantities required to maintain accurate running 1st and 2nd moments.

PARAMETER	DESCRIPTION
`result`	The result to update TYPE: `ValuationResult`

Returns: A callable object that updates the result with a value update

Source code in src/pydvl/valuation/samplers/base.py

def result_updater(self, result: ValuationResult) -> ResultUpdater[ValueUpdateT]:
    """Returns an object that updates a valuation result with a value update.

    Because we use log-space computation for numerical stability, the default result
    updater keeps track of several quantities required to maintain accurate running
    1st and 2nd moments.

    Args:
        result: The result to update
    Returns:
        A callable object that updates the result with a value update
    """
    return LogResultUpdater(result)

sample_limit `abstractmethod` ¶

sample_limit(indices: IndexSetT) -> int | None

Number of samples that can be generated from the indices.

PARAMETER	DESCRIPTION
`indices`	The indices used in the sampler. TYPE: `IndexSetT`

RETURNS	DESCRIPTION
`int \| None`	The maximum number of samples that will be generated, or `None` if the number of samples is infinite.

Source code in src/pydvl/valuation/samplers/base.py

@abstractmethod
def sample_limit(self, indices: IndexSetT) -> int | None:
    """Number of samples that can be generated from the indices.

    Args:
        indices: The indices used in the sampler.

    Returns:
        The maximum number of samples that will be generated, or  `None` if the
            number of samples is infinite.
    """
    ...

TruncationPolicy ¶

TruncationPolicy()

Bases: ABC

A policy for deciding whether to stop computation of a batch of samples

Statistics are kept on the total number of calls and truncations as n_calls and n_truncations respectively.

ATTRIBUTE	DESCRIPTION
`n_calls`	Number of calls to the policy. TYPE: `int`
`n_truncations`	Number of truncations made by the policy. TYPE: `int`

Todo

Because the policy objects are copied to the workers, the statistics are not accessible from the coordinating process. We need to add methods for this.

Source code in src/pydvl/valuation/samplers/truncation.py

def __init__(self) -> None:
    self.n_calls: int = 0
    self.n_truncations: int = 0

call ¶

__call__(idx: IndexT, score: float, batch_size: int) -> bool

Check whether the computation should be interrupted.

PARAMETER	DESCRIPTION
`idx`	Position in the batch currently being computed. TYPE: `IndexT`
`score`	Last utility computed. TYPE: `float`
`batch_size`	Size of the batch being computed. TYPE: `int`

RETURNS	DESCRIPTION
`bool`	`True` if the computation should be interrupted.

Source code in src/pydvl/valuation/samplers/truncation.py

def __call__(self, idx: IndexT, score: float, batch_size: int) -> bool:
    """Check whether the computation should be interrupted.

    Args:
        idx: Position in the batch currently being computed.
        score: Last utility computed.
        batch_size: Size of the batch being computed.

    Returns:
        `True` if the computation should be interrupted.
    """

    ret = self._check(idx, score, batch_size)
    self.n_calls += 1
    self.n_truncations += 1 if ret else 0
    return ret

reset `abstractmethod` ¶

reset(utility: UtilityBase)

(Re)set the policy to a state ready for a new permutation.

Source code in src/pydvl/valuation/samplers/truncation.py

@abstractmethod
def reset(self, utility: UtilityBase):
    """(Re)set the policy to a state ready for a new permutation."""
    ...

pydvl.valuation.samplers.permutation ¶

The probability of sampling a set¶

The case of a fixed index when computing marginals¶

References¶

AntitheticPermutationSampler ¶

interrupted property ¶

__len__ ¶

__repr__ ¶

complement_size ¶

generate_batches ¶

interrupt ¶

log_weight ¶

result_updater ¶

DeterministicPermutationSampler ¶

interrupted property ¶

skip_indices property writable ¶

__len__ ¶

__repr__ ¶

complement_size ¶

generate_batches ¶

interrupt ¶

log_weight ¶

result_updater ¶

PermutationEvaluationStrategy ¶

PermutationSampler ¶

interrupted property ¶

__len__ ¶

__repr__ ¶

complement_size ¶

generate ¶

generate_batches ¶

interrupt ¶

log_weight ¶

result_updater ¶

PermutationSamplerBase ¶

interrupted property ¶

skip_indices property writable ¶

__len__ ¶

__repr__ ¶

complement_size ¶

generate abstractmethod ¶

generate_batches ¶

interrupt ¶

log_weight ¶

result_updater ¶

sample_limit abstractmethod ¶

TruncationPolicy ¶

__call__ ¶

reset abstractmethod ¶

interrupted `property` ¶

len ¶

repr ¶

interrupted `property` ¶

skip_indices `property` `writable` ¶

len ¶

repr ¶

interrupted `property` ¶

len ¶

repr ¶

interrupted `property` ¶

skip_indices `property` `writable` ¶

len ¶

repr ¶

generate `abstractmethod` ¶

sample_limit `abstractmethod` ¶

call ¶

reset `abstractmethod` ¶