cloak_noise

CloakNoiseLayer ¶

Bases: BaseNoiseLayer[ParameterWrapper, CloakStandardDeviationParameterization, Optional[PercentMasker]]

Stained Glass Transform that creates a stochastic re-representation of the input data.

Inspired by the Cloak algorithm defined in the paper: Not All Features Are Equal: Discovering Essential Features for Preserving Prediction Privacy.

Warning

The directly learned locs and rhos used by this class are prone to vanishing when trained with weight decay regularization. To avoid this, ensure that optimizer parameter group(s) containing locs or rhos are configured with weight_decay=0.0.

input_shape `property` ¶

input_shape: tuple[int, ...]

The shape of the expected input including its batch dimension.

mask `property` `writable` ¶

mask: Tensor | None

The mask to apply calculated from parameters of the stochastic transformation computed during the most recent call to forward.

mean `property` `writable` ¶

mean: Tensor

The means of the stochastic transformation computed during the most recent call to forward.

std `property` `writable` ¶

std: Tensor

The standard deviations of the stochastic transformation computed during the most recent call to forward.

call ¶

__call__(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> NoiseLayerOutput

Stochastically transform the input.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `False`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

getstate ¶

__getstate__() -> dict[str, Any]

Prepare a serializable copy of self.__dict__.

init ¶

__init__(input_shape: tuple[int, ...], scale: tuple[float, float] | Tensor = (0.0001, 2.0), shallow: float | Tensor = 1.0, percent_to_mask: float | Tensor | None = None, value_range: tuple[float | None, float | None] | None = None, locs_requires_grad: bool = True, rhos_requires_grad: bool = True, rhos_init: float = -4.0, seed: int | None = None) -> None

Construct a CloakNoiseLayer with the given parameters.

Parameters:

Name	Type	Description	Default
`input_shape`	`tuple[int, ...]`	The input shape of the layer.	required
`scale`	`tuple[float, float] \| Tensor`	Used to set bound on the min and max standard deviation of the stochastic transformation.	`(0.0001, 2.0)`
`shallow`	`float \| Tensor`	A temperature-like parameter which controls the spread of the parameterization function. Controls both the magnitude of parameterized standard deviations and their rate of change with respect to rhos.	`1.0`
`percent_to_mask`	`float \| Tensor \| None`	The percentage of the input to mask.	`None`
`value_range`	`tuple[float \| None, float \| None] \| None`	Minimum and maximum values of the range to clamp the output into.	`None`
`locs_requires_grad`	`bool`	Whether the locs parameters (related to the means of the transform) have their gradients tracked.	`True`
`rhos_requires_grad`	`bool`	Whether the rhos parameters (related to the standard deviations of the transform) have their gradients tracked.	`True`
`rhos_init`	`float`	The initial values for the rhos.	`-4.0`
`seed`	`int \| None`	Seed for the random number generator used to generate the stochastic transformation. If `None`, the global RNG state is used.	`None`

__init_subclass__ ¶

__init_subclass__() -> None

Set the default dtype to torch.float32 inside all subclass __init__ methods.

setstate ¶

__setstate__(state: dict[str, Any]) -> None

Restore from a serialized copy of self.__dict__.

forward ¶

forward(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> base.NoiseLayerOutput

Transform the input data.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `0`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

Returns:

Type	Description
`base.NoiseLayerOutput`	The transformed input data.

get_applied_transform_components_factory ¶

get_applied_transform_components_factory() -> Callable[[], dict[str, torch.Tensor]]

Create a function that returns the elements of the transform components ('mean' and 'std') applied during the most recent forward pass.

Specifically, the applied elements are those selected by the noise mask (if supplied) and standard deviation mask (if std_estimator.masker is not None). If no masks are used, all elements are returned.

The applied transform components are returned flattened.

This function is intended to be used to log histograms of the transform components.

Returns:

Type	Description
`Callable[[], dict[str, torch.Tensor]]`	A function that returns the the elements of the transform components applied during the most recent forward pass.

Examples:

>>> from torch import nn
>>> from stainedglass_core import model as sg_model, noise_layer as sg_noise_layer
>>> base_model = nn.Linear(20, 2)
>>> noisy_model = sg_model.NoisyModel(
...     sg_noise_layer.CloakNoiseLayer1,
...     base_model,
...     input_shape=(-1, 20),
... )
>>> get_applied_transform_components = (
...     noisy_model.noise_layer.get_applied_transform_components_factory()
... )
>>> input = torch.ones(1, 20)
>>> noise_mask = torch.tensor(5 * [False] + 15 * [True])
>>> output = base_model(input, noise_mask=noise_mask)
>>> applied_transform_components = get_applied_transform_components()
>>> applied_transform_components
{'mean': tensor(...), 'std': tensor(...)}
>>> {
...     component_name: component.shape
...     for component_name, component in applied_transform_components.items()
... }
{'mean': torch.Size([15]), 'std': torch.Size([15])}

get_transformed_output_factory ¶

get_transformed_output_factory() -> Callable[[], torch.Tensor]

Create a function that returns the transformed output from the most recent forward pass.

If super batching is active, only the transformed half of the super batch output is returned.

Returns:

Type	Description
`Callable[[], torch.Tensor]`	A function that returns the transformed output from the most recent forward pass.

Examples:

>>> from stainedglass_core import noise_layer as sg_noise_layer
>>> noise_layer = sg_noise_layer.CloakNoiseLayer1(input_shape=(-1, 3, 32, 32))
>>> get_transformed_output = noise_layer.get_transformed_output_factory()
>>> input = torch.ones(2, 3, 32, 32)
>>> output = noise_layer(input)
>>> transformed_output = get_transformed_output()
>>> assert output.output.equal(transformed_output)

initial_seed ¶

initial_seed() -> int

Return the initial seed of the CPU device's random number generator.

manual_seed ¶

manual_seed(seed: int) -> None

Seed each of the random number generators.

Parameters:

Name	Type	Description	Default
`seed`	`int`	The seed to set.	required

seed ¶

seed() -> None

Seed each of the random number generators using a non-deterministic random number.

CloakNoiseLayer1 ¶

Bases: CloakNoiseLayer

Stained Glass Transform that applies a stochastic re-representation of the input data without masking.

Inspired by the Cloak Step 1 algorithm defined in the paper: Not All Features Are Equal: Discovering Essential Features for Preserving Prediction Privacy

Warning

The directly learned locs and rhos used by this class are prone to vanishing when trained with weight decay regularization. To avoid this, ensure that optimizer parameter group(s) containing locs or rhos are configured with weight_decay=0.0.

Note

For maximum privacy preservation, Stained Glass Transform Step 1 should only be used to pre-train a Stained Glass Transform Step 2 (see CloakNoiseLayer2 or CloakNoiseLayer2_NoClip). First training a Step 1, then fine-tuning that transform with step 2 is a common recipe.

For a more convenient type Stained Glass Transform that requires only one step of training, see CloakNoiseLayerOneShot.

Note

In almost all cases, rhos_requires_grad should be True while training CloakNoiseLayer1.

input_shape `property` ¶

input_shape: tuple[int, ...]

The shape of the expected input including its batch dimension.

mask `property` `writable` ¶

mask: Tensor | None

The mask to apply calculated from parameters of the stochastic transformation computed during the most recent call to forward.

mean `property` `writable` ¶

mean: Tensor

The means of the stochastic transformation computed during the most recent call to forward.

std `property` `writable` ¶

std: Tensor

The standard deviations of the stochastic transformation computed during the most recent call to forward.

call ¶

__call__(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> NoiseLayerOutput

Stochastically transform the input.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `False`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

getstate ¶

__getstate__() -> dict[str, Any]

Prepare a serializable copy of self.__dict__.

init ¶

__init__(input_shape: tuple[int, ...], scale: tuple[float, float] | Tensor = (0.0001, 2.0), shallow: float | Tensor = 1.0, locs: bool = True, rhos: bool = True, rhos_init: float = -4.0, seed: int | None = None) -> None

Construct a CloakNoiseLayer1 with the given parameters.

Parameters:

Name	Type	Description	Default
`input_shape`	`tuple[int, ...]`	The input shape of the layer.	required
`scale`	`tuple[float, float] \| Tensor`	Used to set bound on the min and max standard deviation of the stochastic transformation.	`(0.0001, 2.0)`
`shallow`	`float \| Tensor`	A temperature-like parameter which controls the spread of the parameterization function. Controls both the magnitude of parameterized standard deviations and their rate of change with respect to rhos.	`1.0`
`locs`	`bool`	Whether the locs parameters (related to the means of the transform) have their gradients tracked.	`True`
`rhos`	`bool`	Whether the rhos parameters (related to the standard deviations of the transform) have their gradients tracked. Usually True.	`True`
`rhos_init`	`float`	The initial values for the rhos.	`-4.0`
`seed`	`int \| None`	Seed for the random number generator used to generate the stochastic transformation. If `None`, the global RNG state is used.	`None`

__init_subclass__ ¶

__init_subclass__() -> None

Set the default dtype to torch.float32 inside all subclass __init__ methods.

setstate ¶

__setstate__(state: dict[str, Any]) -> None

Restore from a serialized copy of self.__dict__.

forward ¶

forward(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> base.NoiseLayerOutput

Transform the input data.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `0`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

Returns:

Type	Description
`base.NoiseLayerOutput`	The transformed input data.

get_applied_transform_components_factory ¶

get_applied_transform_components_factory() -> Callable[[], dict[str, torch.Tensor]]

Create a function that returns the elements of the transform components ('mean' and 'std') applied during the most recent forward pass.

Specifically, the applied elements are those selected by the noise mask (if supplied) and standard deviation mask (if std_estimator.masker is not None). If no masks are used, all elements are returned.

The applied transform components are returned flattened.

This function is intended to be used to log histograms of the transform components.

Returns:

Type	Description
`Callable[[], dict[str, torch.Tensor]]`	A function that returns the the elements of the transform components applied during the most recent forward pass.

Examples:

>>> from torch import nn
>>> from stainedglass_core import model as sg_model, noise_layer as sg_noise_layer
>>> base_model = nn.Linear(20, 2)
>>> noisy_model = sg_model.NoisyModel(
...     sg_noise_layer.CloakNoiseLayer1,
...     base_model,
...     input_shape=(-1, 20),
... )
>>> get_applied_transform_components = (
...     noisy_model.noise_layer.get_applied_transform_components_factory()
... )
>>> input = torch.ones(1, 20)
>>> noise_mask = torch.tensor(5 * [False] + 15 * [True])
>>> output = base_model(input, noise_mask=noise_mask)
>>> applied_transform_components = get_applied_transform_components()
>>> applied_transform_components
{'mean': tensor(...), 'std': tensor(...)}
>>> {
...     component_name: component.shape
...     for component_name, component in applied_transform_components.items()
... }
{'mean': torch.Size([15]), 'std': torch.Size([15])}

get_transformed_output_factory ¶

get_transformed_output_factory() -> Callable[[], torch.Tensor]

Create a function that returns the transformed output from the most recent forward pass.

If super batching is active, only the transformed half of the super batch output is returned.

Returns:

Type	Description
`Callable[[], torch.Tensor]`	A function that returns the transformed output from the most recent forward pass.

Examples:

>>> from stainedglass_core import noise_layer as sg_noise_layer
>>> noise_layer = sg_noise_layer.CloakNoiseLayer1(input_shape=(-1, 3, 32, 32))
>>> get_transformed_output = noise_layer.get_transformed_output_factory()
>>> input = torch.ones(2, 3, 32, 32)
>>> output = noise_layer(input)
>>> transformed_output = get_transformed_output()
>>> assert output.output.equal(transformed_output)

initial_seed ¶

initial_seed() -> int

Return the initial seed of the CPU device's random number generator.

manual_seed ¶

manual_seed(seed: int) -> None

Seed each of the random number generators.

Parameters:

Name	Type	Description	Default
`seed`	`int`	The seed to set.	required

seed ¶

seed() -> None

Seed each of the random number generators using a non-deterministic random number.

CloakNoiseLayer2 ¶

Bases: CloakNoiseLayer

Stained Glass Transform that stochastically re-represents the input data with masking.

Inspired by the Cloak Step 2 algorithm defined in the paper: Not All Features Are Equal: Discovering Essential Features for Preserving Prediction Privacy

Warning

The directly learned locs and rhos used by this class are prone to vanishing when trained with weight decay regularization. To avoid this, ensure that optimizer parameter group(s) containing locs or rhos are configured with weight_decay=0.0.

Note

For maximum privacy preservation, Stained Glass Transform Step 2 should be pre-trained from a Stained Glass Transform Step 1. For a more convenient type of Stained Glass Transform that requires only one step of training, see CloakNoiseLayerOneShot.

Note

Masking is done using a static threshold on the learned standard deviation of the stochastic transformation. This threshold is calculated from percent_to_mask when loading a pre-trained transform layer. Consequently, continuing to train the stochastic transformation will not affect masking. For a variant of Cloak Step 2 that recalculates its masking using percent_to_mask on each call (i.e. the masking can change during training), see CloakNoiseLayerOneShot.

input_shape `property` ¶

input_shape: tuple[int, ...]

The shape of the expected input including its batch dimension.

mean `property` `writable` ¶

mean: Tensor

The means of the stochastic transformation computed during the most recent call to forward.

std `property` `writable` ¶

std: Tensor

The standard deviations of the stochastic transformation computed during the most recent call to forward.

call ¶

__call__(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> NoiseLayerOutput

Stochastically transform the input.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `False`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

getstate ¶

__getstate__() -> dict[str, Any]

Prepare a serializable copy of self.__dict__.

init ¶

__init__(input_shape: tuple[int, ...], percent_to_mask: float | Tensor, scale: tuple[float, float] | Tensor = (0.0001, 2.0), shallow: float | Tensor = 1.0, value_range: tuple[float | None, float | None] | None = (-1.0, 1.0), seed: int | None = None) -> None

Construct a CloakNoiseLayer2 with the given parameters.

Parameters:

Name	Type	Description	Default
`input_shape`	`tuple[int, ...]`	The input shape of the layer.	required
`scale`	`tuple[float, float] \| Tensor`	Used to set bound on the min and max standard deviation of the stochastic transformation.	`(0.0001, 2.0)`
`percent_to_mask`	`float \| Tensor`	The percentage of the outputs to mask.	required
`shallow`	`float \| Tensor`	A temperature-like parameter which controls the spread of the parameterization function. Controls both the magnitude of parameterized standard deviations and their rate of change with respect to rhos.	`1.0`
`value_range`	`tuple[float \| None, float \| None] \| None`	Minimum and maximum values of the range to clamp the output into.	`(-1.0, 1.0)`
`seed`	`int \| None`	Seed for the random number generator used to generate the stochastic transformation. If `None`, the global RNG state is used.	`None`

Note

Specifying percent_to_mask==0.0 with a NoClip variant of Cloak Step 2 is functionally equivalent to Cloak Step 1, as no masking occurs.

Note

In training mode, the threshold buffer is recalculated over the learned standard deviations of the stochastic transformation, and a new input mask is generated with each forward call. In eval mode, threshold is static, and the cached mask from the most recent mask calculation is used.

Raises:

Type	Description
`ValueError`	If `percent_to_mask` is not in [0, 1], inclusive.

Changed in version 0.10.0: `threshold` and `percent_threshold` parameters were removed in favor of `percent_to_mask`

__init_subclass__ ¶

__init_subclass__() -> None

Set the default dtype to torch.float32 inside all subclass __init__ methods.

setstate ¶

__setstate__(state: dict[str, Any]) -> None

Restore from a serialized copy of self.__dict__.

forward ¶

forward(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> base.NoiseLayerOutput

Transform the input data.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `0`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

Returns:

Type	Description
`base.NoiseLayerOutput`	The transformed input data.

get_applied_transform_components_factory ¶

get_applied_transform_components_factory() -> Callable[[], dict[str, torch.Tensor]]

Create a function that returns the elements of the transform components ('mean' and 'std') applied during the most recent forward pass.

Specifically, the applied elements are those selected by the noise mask (if supplied) and standard deviation mask (if std_estimator.masker is not None). If no masks are used, all elements are returned.

The applied transform components are returned flattened.

This function is intended to be used to log histograms of the transform components.

Returns:

Type	Description
`Callable[[], dict[str, torch.Tensor]]`	A function that returns the the elements of the transform components applied during the most recent forward pass.

Examples:

>>> from torch import nn
>>> from stainedglass_core import model as sg_model, noise_layer as sg_noise_layer
>>> base_model = nn.Linear(20, 2)
>>> noisy_model = sg_model.NoisyModel(
...     sg_noise_layer.CloakNoiseLayer1,
...     base_model,
...     input_shape=(-1, 20),
... )
>>> get_applied_transform_components = (
...     noisy_model.noise_layer.get_applied_transform_components_factory()
... )
>>> input = torch.ones(1, 20)
>>> noise_mask = torch.tensor(5 * [False] + 15 * [True])
>>> output = base_model(input, noise_mask=noise_mask)
>>> applied_transform_components = get_applied_transform_components()
>>> applied_transform_components
{'mean': tensor(...), 'std': tensor(...)}
>>> {
...     component_name: component.shape
...     for component_name, component in applied_transform_components.items()
... }
{'mean': torch.Size([15]), 'std': torch.Size([15])}

get_transformed_output_factory ¶

get_transformed_output_factory() -> Callable[[], torch.Tensor]

Create a function that returns the transformed output from the most recent forward pass.

If super batching is active, only the transformed half of the super batch output is returned.

Returns:

Type	Description
`Callable[[], torch.Tensor]`	A function that returns the transformed output from the most recent forward pass.

Examples:

>>> from stainedglass_core import noise_layer as sg_noise_layer
>>> noise_layer = sg_noise_layer.CloakNoiseLayer1(input_shape=(-1, 3, 32, 32))
>>> get_transformed_output = noise_layer.get_transformed_output_factory()
>>> input = torch.ones(2, 3, 32, 32)
>>> output = noise_layer(input)
>>> transformed_output = get_transformed_output()
>>> assert output.output.equal(transformed_output)

initial_seed ¶

initial_seed() -> int

Return the initial seed of the CPU device's random number generator.

manual_seed ¶

manual_seed(seed: int) -> None

Seed each of the random number generators.

Parameters:

Name	Type	Description	Default
`seed`	`int`	The seed to set.	required

seed ¶

seed() -> None

Seed each of the random number generators using a non-deterministic random number.

CloakNoiseLayer2_NoClip ¶

Bases: CloakNoiseLayer2

Stained Glass Transform that stochastically re-represents the input data with masking but without clipping.

Inspired by the Cloak Step 2 algorithm defined in the paper: Not All Features Are Equal: Discovering Essential Features for Preserving Prediction Privacy

Warning

The directly learned locs and rhos used by this class are prone to vanishing when trained with weight decay regularization. To avoid this, ensure that optimizer parameter group(s) containing locs or rhos are configured with weight_decay=0.0.

Note

For maximum privacy preservation, Stained Glass Transform Step 2 should be pre-trained from a Stained Glass Transform Step 1.

For a more convenient type Stained Glass Transform that requires only one step of training, see CloakNoiseLayerOneShot.

input_shape `property` ¶

input_shape: tuple[int, ...]

The shape of the expected input including its batch dimension.

mean `property` `writable` ¶

mean: Tensor

The means of the stochastic transformation computed during the most recent call to forward.

std `property` `writable` ¶

std: Tensor

The standard deviations of the stochastic transformation computed during the most recent call to forward.

call ¶

__call__(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> NoiseLayerOutput

Stochastically transform the input.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `False`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

getstate ¶

__getstate__() -> dict[str, Any]

Prepare a serializable copy of self.__dict__.

init ¶

__init__(input_shape: tuple[int, ...], percent_to_mask: float | Tensor, scale: tuple[float, float] | Tensor = (0.0001, 2.0), shallow: float | Tensor = 1.0, seed: int | None = None) -> None

Construct a CloakNoiseLayer2_NoClip with the given parameters.

Parameters:

Name	Type	Description	Default
`input_shape`	`tuple[int, ...]`	The input shape of the layer.	required
`scale`	`tuple[float, float] \| Tensor`	Used to set bound on the min and max standard deviation of the stochastic transformation.	`(0.0001, 2.0)`
`percent_to_mask`	`float \| Tensor`	The percentage of the outputs to mask.	required
`shallow`	`float \| Tensor`	A temperature-like parameter which controls the spread of the parameterization function. Controls both the magnitude of parameterized standard deviations and their rate of change with respect to rhos.	`1.0`
`seed`	`int \| None`	Seed for the random number generator used to generate the stochastic transformation. If `None`, the global RNG state is used.	`None`

Note

Specifying percent_to_mask==0.0 with a NoClip variant of Cloak Step 2 is functionally equivalent to Cloak Step 1, as no masking occurs.

Note

In training mode, the threshold buffer is recalculated over the learned standard deviations of the stochastic transformation, and a new input mask is generated with each forward call. In eval mode, threshold is static, and the cached mask from the most recent mask calculation is used.

Raises:

Type	Description
`ValueError`	If `percent_to_mask` is not in [0, 1], inclusive.

__init_subclass__ ¶

__init_subclass__() -> None

Set the default dtype to torch.float32 inside all subclass __init__ methods.

setstate ¶

__setstate__(state: dict[str, Any]) -> None

Restore from a serialized copy of self.__dict__.

forward ¶

forward(input: Tensor, noise_mask: Tensor | None = None, **kwargs: Any) -> base.NoiseLayerOutput

Transform the input data.

Parameters:

Name	Type	Description	Default
`input`	`Tensor`	The input to transform.	required
`noise_mask`	`Tensor \| None`	An optional mask that selects the elements of `input` to transform. Where the mask is `0`, the original `input` value is returned. Also used to select the elements of the sampled standard deviations to use to mask the `input`. If `None`, the entire `input` is transformed.	`None`
`**kwargs`	`Any`	Additional keyword arguments to the estimator modules.	required

Returns:

Type	Description
`base.NoiseLayerOutput`	The transformed input data.

get_applied_transform_components_factory ¶

get_applied_transform_components_factory() -> Callable[[], dict[str, torch.Tensor]]

Create a function that returns the elements of the transform components ('mean' and 'std') applied during the most recent forward pass.

Specifically, the applied elements are those selected by the noise mask (if supplied) and standard deviation mask (if std_estimator.masker is not None). If no masks are used, all elements are returned.

The applied transform components are returned flattened.

This function is intended to be used to log histograms of the transform components.

Returns:

Type	Description
`Callable[[], dict[str, torch.Tensor]]`	A function that returns the the elements of the transform components applied during the most recent forward pass.

Examples:

>>> from torch import nn
>>> from stainedglass_core import model as sg_model, noise_layer as sg_noise_layer
>>> base_model = nn.Linear(20, 2)
>>> noisy_model = sg_model.NoisyModel(
...     sg_noise_layer.CloakNoiseLayer1,
...     base_model,
...     input_shape=(-1, 20),
... )
>>> get_applied_transform_components = (
...     noisy_model.noise_layer.get_applied_transform_components_factory()
... )
>>> input = torch.ones(1, 20)
>>> noise_mask = torch.tensor(5 * [False] + 15 * [True])
>>> output = base_model(input, noise_mask=noise_mask)
>>> applied_transform_components = get_applied_transform_components()
>>> applied_transform_components
{'mean': tensor(...), 'std': tensor(...)}
>>> {
...     component_name: component.shape
...     for component_name, component in applied_transform_components.items()
... }
{'mean': torch.Size([15]), 'std': torch.Size([15])}

get_transformed_output_factory ¶

get_transformed_output_factory() -> Callable[[], torch.Tensor]

Create a function that returns the transformed output from the most recent forward pass.

If super batching is active, only the transformed half of the super batch output is returned.

Returns:

Type	Description
`Callable[[], torch.Tensor]`	A function that returns the transformed output from the most recent forward pass.

Examples:

>>> from stainedglass_core import noise_layer as sg_noise_layer
>>> noise_layer = sg_noise_layer.CloakNoiseLayer1(input_shape=(-1, 3, 32, 32))
>>> get_transformed_output = noise_layer.get_transformed_output_factory()
>>> input = torch.ones(2, 3, 32, 32)
>>> output = noise_layer(input)
>>> transformed_output = get_transformed_output()
>>> assert output.output.equal(transformed_output)

initial_seed ¶

initial_seed() -> int

Return the initial seed of the CPU device's random number generator.

manual_seed ¶

manual_seed(seed: int) -> None

Seed each of the random number generators.

Parameters:

Name	Type	Description	Default
`seed`	`int`	The seed to set.	required

seed ¶

seed() -> None

Seed each of the random number generators using a non-deterministic random number.

ParameterWrapper ¶

Bases: Module

Returns its weight irrespective of input.

This class is an torch.nn.Module wrapper for its torch.nn.parameter.Parameter weight. The original Cloak implementation used nn.Parameter directly, but this class allows for modular swapping with more complex Modules.

init ¶

__init__(size: tuple[int, ...]) -> None

Construct a ParameterWrapper with the given parameters.

Parameters:

Name	Type	Description	Default
`size`	`tuple[int, ...]`	The size of the weight tensor to create.	required

forward ¶

forward(*args: Any, **kwargs: Any) -> torch.Tensor

Return the weight irrespective of input.

Parameters:

Name	Type	Description	Default
`args`	`Any`	Unused positional arguments.	required
`kwargs`	`Any`	Unused keyword arguments.	required

Returns:

Type	Description
`torch.Tensor`	The weight tensor.

cloak_noise

CloakNoiseLayer ¶

input_shape property ¶

mask property writable ¶

mean property writable ¶

std property writable ¶

__call__ ¶

__getstate__ ¶

__init__ ¶

__init_subclass__ ¶

__setstate__ ¶

forward ¶

get_applied_transform_components_factory ¶

get_transformed_output_factory ¶

initial_seed ¶

manual_seed ¶

seed ¶

CloakNoiseLayer1 ¶

input_shape property ¶

mask property writable ¶

mean property writable ¶

std property writable ¶

__call__ ¶

__getstate__ ¶

__init__ ¶

__init_subclass__ ¶

__setstate__ ¶

forward ¶

get_applied_transform_components_factory ¶

get_transformed_output_factory ¶

initial_seed ¶

manual_seed ¶

seed ¶

CloakNoiseLayer2 ¶

input_shape property ¶

mean property writable ¶

std property writable ¶

__call__ ¶

__getstate__ ¶

__init__ ¶

__init_subclass__ ¶

__setstate__ ¶

forward ¶

get_applied_transform_components_factory ¶

get_transformed_output_factory ¶

initial_seed ¶

manual_seed ¶

seed ¶

CloakNoiseLayer2_NoClip ¶

input_shape property ¶

mean property writable ¶

std property writable ¶

__call__ ¶

__getstate__ ¶

__init__ ¶

__init_subclass__ ¶

__setstate__ ¶

forward ¶

get_applied_transform_components_factory ¶

get_transformed_output_factory ¶

initial_seed ¶

manual_seed ¶

seed ¶

ParameterWrapper ¶

__init__ ¶

forward ¶

input_shape `property` ¶

mask `property` `writable` ¶

mean `property` `writable` ¶

std `property` `writable` ¶

call ¶

getstate ¶

init ¶

setstate ¶

input_shape `property` ¶

mask `property` `writable` ¶

mean `property` `writable` ¶

std `property` `writable` ¶

call ¶

getstate ¶

init ¶

setstate ¶

input_shape `property` ¶

mean `property` `writable` ¶

std `property` `writable` ¶

call ¶

getstate ¶

init ¶

setstate ¶

input_shape `property` ¶

mean `property` `writable` ¶

std `property` `writable` ¶

call ¶

getstate ¶

init ¶

setstate ¶

init ¶