patch_cloak

Modules:

Name	Description
`base`
`conv`	Utility functions for convolutional operations.
`sg_estimators`
`sg_loss`
`sg_maskers`
`sg_parameterizations`
`sg_utils`
`version`	Constants storing the version numbers for major changes to the codebase.

Classes:

Name	Description
`PatchCloakNoiseLayer`	Applies an input-dependent, additive, non-overlapping, convolutional stochastic transformation.
`PatchCloakNoiseLayer1`	Input-dependent, additive, vision Stained Glass Transform layer that segments input images into patches and generates
`PatchCloakNoiseLayer2`	Input-dependent, additive, vision Stained Glass Transform layer that segments input images into patches and generates a patch-wise
`PatchCloakNoiseLayer2_NoClip`	Input-dependent, additive, vision Stained Glass Transform layer that segments input images into patches and generates a patch-wise

PatchCloakNoiseLayer ¶

Bases: BaseNoiseLayer[Conv2d, CloakStandardDeviationParameterization, Optional[BatchwiseChannelwisePatchwisePercentMasker]]

Applies an input-dependent, additive, non-overlapping, convolutional stochastic transformation.

Methods:

Name	Description
`__call__`	Stochastically transform the input.
`__getstate__`	Prepare a serializable copy of `self.__dict__`.
`__init__`	Construct a Stained Glass Transform layer that generates stochastic transformations over patches of the input images.
`__init_subclass__`	Set the default dtype to `torch.float32` inside all subclass `__init__` methods.
`__setstate__`	Restore from a serialized copy of `self.__dict__`.
`forward`	Transform the input data.
`get_applied_transform_components_factory`	Create a function that returns the elements of the transform components (`'mean'` and `'std'`) applied during the most recent
`get_transformed_output_factory`	Create a function that returns the transformed output from the most recent forward pass.
`initial_seed`	Return the initial seed of the CPU device's random number generator.
`manual_seed`	Seed each of the random number generators.
`reset_parameters`	Reinitialize parameters and buffers.
`seed`	Seed each of the random number generators using a non-deterministic random number.

Attributes:

Name	Type	Description
`input_shape`	`tuple[int, ...]`	The shape of the expected input including its batch dimension.
`mask`	`Tensor \| None`	The mask to apply calculated from parameters of the stochastic transformation computed during the most recent call to forward.
`mean`	`Tensor`	The means of the stochastic transformation computed during the most recent call to forward.
`patch_size`	`tuple[int, int]`	The size of the patches to segment the input into.
`std`	`Tensor`	The standard deviations of the stochastic transformation computed during the most recent call to forward.

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.

patch_size `property` ¶

patch_size: tuple[int, int]

The size of the patches to segment the input into.

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, ...], patch_size: int | tuple[int, int], scale: tuple[float, float] = (0.0001, 2.0), shallow: float = 1.0, percent_to_mask: float | None = None, value_range: tuple[float | None, float | None] | None = None, padding_mode: Literal['constant', 'reflect', 'replicate', 'circular'] = 'constant', padding_value: float = 0.0, learn_locs_weights: bool = True, freeze_std_estimator: bool = True, seed: int | None = None) -> None

Construct a Stained Glass Transform layer that generates stochastic transformations over patches of the input images.

Parameters:

Name	Type	Description	Default
`input_shape` ¶	`tuple[int, ...]`	Shape of given inputs. The first dimension may be -1, meaning variable batch size.	required
`patch_size` ¶	`int \| tuple[int, int]`	Size of the patches to segment the input into. If an integer is given, a square patch is used.	required
`scale` ¶	`tuple[float, float]`	Minimum and maximum values of the range of standard deviations of the generated stochastic transformation.	`(0.0001, 2.0)`
`shallow` ¶	`float`	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 \| None`	The percentage of the outputs to mask per patch.	`None`
`value_range` ¶	`tuple[float \| None, float \| None] \| None`	Minimum and maximum values of the range to clamp the output into.	`None`
`padding_mode` ¶	`Literal['constant', 'reflect', 'replicate', 'circular']`	Type of padding. One of: constant, reflect, replicate, or circular. Defaults to constant.	`'constant'`
`padding_value` ¶	`float`	Fill value for constant padding.	`0.0`
`learn_locs_weights` ¶	`bool`	Whether to learn the weight parameters for the locs estimator. If `True`, only the weights will be learned, and the bias remains constant, otherwise weights are initialized to zero and only the bias is learned.	`True`
`freeze_std_estimator` ¶	`bool`	Whether to freeze the weight parameters for the std estimator. If `False`, this estimator will be trained simultaneously with masking and the locs estimator parameters.	`True`
`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

For estimators where we train the weights, we freeze their biases. We suspect that if both the biases and weights are trained together, the biases will converge faster than the weights, causing the weights to be trivial. This has not been verified experimentally. Our choices for initialization values and conditions subject to change in light of experimental evidence, and you are encouraged to challenge and improve our understanding of the effects of these choices.

__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 = noisy_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) -> None

Seed each of the random number generators.

Setting seed to None will destroy any existing generators.

Parameters:

Name	Type	Description	Default
`seed` ¶	`int \| None`	The seed to set.	required

reset_parameters ¶

reset_parameters() -> None

Reinitialize parameters and buffers.

This method is useful for initializing tensors created on the meta device.

seed ¶

seed() -> None

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

PatchCloakNoiseLayer1 ¶

Bases: PatchCloakNoiseLayer

Input-dependent, additive, vision Stained Glass Transform layer that segments input images into patches and generates a patch-wise stochastic transformation.

Note

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

Methods:

Name	Description
`__call__`	Stochastically transform the input.
`__getstate__`	Prepare a serializable copy of `self.__dict__`.
`__init__`	Construct a Stained Glass Transform layer that generates stochastic transformations over patches of the input images.
`__init_subclass__`	Set the default dtype to `torch.float32` inside all subclass `__init__` methods.
`__setstate__`	Restore from a serialized copy of `self.__dict__`.
`forward`	Transform the input data.
`get_applied_transform_components_factory`	Create a function that returns the elements of the transform components (`'mean'` and `'std'`) applied during the most recent
`get_transformed_output_factory`	Create a function that returns the transformed output from the most recent forward pass.
`initial_seed`	Return the initial seed of the CPU device's random number generator.
`manual_seed`	Seed each of the random number generators.
`reset_parameters`	Reinitialize parameters and buffers.
`seed`	Seed each of the random number generators using a non-deterministic random number.

Attributes:

Name	Type	Description
`input_shape`	`tuple[int, ...]`	The shape of the expected input including its batch dimension.
`mask`	`Tensor \| None`	The mask to apply calculated from parameters of the stochastic transformation computed during the most recent call to forward.
`mean`	`Tensor`	The means of the stochastic transformation computed during the most recent call to forward.
`patch_size`	`tuple[int, int]`	The size of the patches to segment the input into.
`std`	`Tensor`	The standard deviations of the stochastic transformation computed during the most recent call to forward.

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.

patch_size `property` ¶

patch_size: tuple[int, int]

The size of the patches to segment the input into.

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, ...], patch_size: int | tuple[int, int], scale: tuple[float, float], shallow: float = 1.0, padding_mode: Literal['constant', 'reflect', 'replicate', 'circular'] = 'constant', padding_value: float = 0.0, learn_locs_weights: bool = True, seed: int | None = None) -> None

Construct a Stained Glass Transform layer that generates stochastic transformations over patches of the input images.

Parameters:

Name	Type	Description	Default
`input_shape` ¶	`tuple[int, ...]`	The shape of the input tensor.	required
`patch_size` ¶	`int \| tuple[int, int]`	The size of the patches over which the stochastic transformation is estimated.	required
`scale` ¶	`tuple[float, float]`	The range of standard deviations of the stochastic transformation.	required
`shallow` ¶	`float`	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`
`padding_mode` ¶	`Literal['constant', 'reflect', 'replicate', 'circular']`	The padding mode to use when extracting patches.	`'constant'`
`padding_value` ¶	`float`	The value to use when padding the input.	`0.0`
`learn_locs_weights` ¶	`bool`	Whether to only learn the locs estimator weights or else to only learn the locs estimator bias.	`True`
`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 = noisy_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) -> None

Seed each of the random number generators.

Setting seed to None will destroy any existing generators.

Parameters:

Name	Type	Description	Default
`seed` ¶	`int \| None`	The seed to set.	required

reset_parameters ¶

reset_parameters() -> None

Reinitialize parameters and buffers.

This method is useful for initializing tensors created on the meta device.

seed ¶

seed() -> None

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

PatchCloakNoiseLayer2 ¶

Bases: PatchCloakNoiseLayer

Input-dependent, additive, vision Stained Glass Transform layer that segments input images into patches and generates a patch-wise stochastic transformation with masking and clipping. Use after training a PatchCloakNoiseLayer1.

Note

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

Methods:

Name	Description
`__call__`	Stochastically transform the input.
`__getstate__`	Prepare a serializable copy of `self.__dict__`.
`__init__`	Create Stained Glass Transform to generate a stochastic transformation over patches of the input images.
`__init_subclass__`	Set the default dtype to `torch.float32` inside all subclass `__init__` methods.
`__setstate__`	Restore from a serialized copy of `self.__dict__`.
`forward`	Transform the input data.
`get_applied_transform_components_factory`	Create a function that returns the elements of the transform components (`'mean'` and `'std'`) applied during the most recent
`get_transformed_output_factory`	Create a function that returns the transformed output from the most recent forward pass.
`initial_seed`	Return the initial seed of the CPU device's random number generator.
`manual_seed`	Seed each of the random number generators.
`reset_parameters`	Reinitialize parameters and buffers.
`seed`	Seed each of the random number generators using a non-deterministic random number.

Attributes:

Name	Type	Description
`input_shape`	`tuple[int, ...]`	The shape of the expected input including its batch dimension.
`mask`	`Tensor \| None`	The mask to apply calculated from parameters of the stochastic transformation computed during the most recent call to forward.
`mean`	`Tensor`	The means of the stochastic transformation computed during the most recent call to forward.
`patch_size`	`tuple[int, int]`	The size of the patches to segment the input into.
`std`	`Tensor`	The standard deviations of the stochastic transformation computed during the most recent call to forward.

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.

patch_size `property` ¶

patch_size: tuple[int, int]

The size of the patches to segment the input into.

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, ...], patch_size: int | tuple[int, int], scale: tuple[float, float], percent_to_mask: float, shallow: float = 1.0, value_range: tuple[float | None, float | None] = (-1.0, 1.0), padding_mode: Literal['constant', 'reflect', 'replicate', 'circular'] = 'constant', padding_value: float = 0.0, learn_locs_weights: bool = True, freeze_std_estimator: bool = True, seed: int | None = None) -> None

Create Stained Glass Transform to generate a stochastic transformation over patches of the input images.

Parameters:

Name	Type	Description	Default
`input_shape` ¶	`tuple[int, ...]`	Shape of given inputs. The first dimension may be -1, meaning variable batch size.	required
`patch_size` ¶	`int \| tuple[int, int]`	Size of the patches to segment the input into. If an integer is given, a square patch is used.	required
`scale` ¶	`tuple[float, float]`	Minimum and maximum values of the range of standard deviations of the generated stochastic transformation.	required
`percent_to_mask` ¶	`float`	The percentage of the outputs to mask per patch.	required
`shallow` ¶	`float`	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]`	Minimum and maximum values of the range to clamp the output into.	`(-1.0, 1.0)`
`padding_mode` ¶	`Literal['constant', 'reflect', 'replicate', 'circular']`	Type of padding. One of: constant, reflect, replicate, or circular. Defaults to constant.	`'constant'`
`padding_value` ¶	`float`	Fill value for constant padding.	`0.0`
`learn_locs_weights` ¶	`bool`	Whether to learn the weight parameters for the locs estimator. If `True`, only the weights will be learned, and the bias remains constant, otherwise weights are initialized to zero and only the bias is learned.	`True`
`freeze_std_estimator` ¶	`bool`	Whether to freeze the weight parameters for the std estimator. If `False`, this estimator will be trained simultaneously with masking and the locs estimator parameters.	`True`
`seed` ¶	`int \| None`	Seed for the random number generator used to generate the stochastic transformation. If `None`, the global RNG state is used.	`None`

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 = noisy_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) -> None

Seed each of the random number generators.

Setting seed to None will destroy any existing generators.

Parameters:

Name	Type	Description	Default
`seed` ¶	`int \| None`	The seed to set.	required

reset_parameters ¶

reset_parameters() -> None

Reinitialize parameters and buffers.

This method is useful for initializing tensors created on the meta device.

seed ¶

seed() -> None

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

PatchCloakNoiseLayer2_NoClip ¶

Bases: PatchCloakNoiseLayer

Input-dependent, additive, vision Stained Glass Transform layer that segments input images into patches and generates a patch-wise stochastic transformation with masking. Use after training a PatchCloakNoiseLayer1.

Note

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

Methods:

Name	Description
`__call__`	Stochastically transform the input.
`__getstate__`	Prepare a serializable copy of `self.__dict__`.
`__init__`	Create Stained Glass Transform to generate a stochastic transformation over patches of the input images.
`__init_subclass__`	Set the default dtype to `torch.float32` inside all subclass `__init__` methods.
`__setstate__`	Restore from a serialized copy of `self.__dict__`.
`forward`	Transform the input data.
`get_applied_transform_components_factory`	Create a function that returns the elements of the transform components (`'mean'` and `'std'`) applied during the most recent
`get_transformed_output_factory`	Create a function that returns the transformed output from the most recent forward pass.
`initial_seed`	Return the initial seed of the CPU device's random number generator.
`manual_seed`	Seed each of the random number generators.
`reset_parameters`	Reinitialize parameters and buffers.
`seed`	Seed each of the random number generators using a non-deterministic random number.

Attributes:

Name	Type	Description
`input_shape`	`tuple[int, ...]`	The shape of the expected input including its batch dimension.
`mask`	`Tensor \| None`	The mask to apply calculated from parameters of the stochastic transformation computed during the most recent call to forward.
`mean`	`Tensor`	The means of the stochastic transformation computed during the most recent call to forward.
`patch_size`	`tuple[int, int]`	The size of the patches to segment the input into.
`std`	`Tensor`	The standard deviations of the stochastic transformation computed during the most recent call to forward.

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.

patch_size `property` ¶

patch_size: tuple[int, int]

The size of the patches to segment the input into.

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, ...], patch_size: int | tuple[int, int], scale: tuple[float, float], percent_to_mask: float, shallow: float = 1.0, padding_mode: Literal['constant', 'reflect', 'replicate', 'circular'] = 'constant', padding_value: float = 0.0, learn_locs_weights: bool = True, freeze_std_estimator: bool = True, seed: int | None = None) -> None

Create Stained Glass Transform to generate a stochastic transformation over patches of the input images.

Parameters:

Name	Type	Description	Default
`input_shape` ¶	`tuple[int, ...]`	Shape of given inputs. The first dimension may be -1, meaning variable batch size.	required
`patch_size` ¶	`int \| tuple[int, int]`	Size of the patches to segment the input into. If an integer is given, a square patch is used.	required
`scale` ¶	`tuple[float, float]`	Minimum and maximum values of the range of standard deviations of the generated stochastic transformation.	required
`percent_to_mask` ¶	`float`	The percentage of the outputs to mask per patch.	required
`shallow` ¶	`float`	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`
`padding_mode` ¶	`Literal['constant', 'reflect', 'replicate', 'circular']`	Type of padding. One of: constant, reflect, replicate, or circular. Defaults to constant.	`'constant'`
`padding_value` ¶	`float`	Fill value for constant padding.	`0.0`
`learn_locs_weights` ¶	`bool`	Whether to learn the weight parameters for the locs estimator. If `True`, only the weights will be learned, and the bias remains constant, otherwise weights are initialized to zero and only the bias is learned.	`True`
`freeze_std_estimator` ¶	`bool`	Whether to freeze the weight parameters for the std estimator. If `True`, this estimator will be trained simultaneously with masking and the locs estimator parameters.	`True`
`seed` ¶	`int \| None`	Seed for the random number generator used to generate the stochastic transformation. If `None`, the global RNG state is used.	`None`

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 = noisy_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) -> None

Seed each of the random number generators.

Setting seed to None will destroy any existing generators.

Parameters:

Name	Type	Description	Default
`seed` ¶	`int \| None`	The seed to set.	required

reset_parameters ¶

reset_parameters() -> None

Reinitialize parameters and buffers.

This method is useful for initializing tensors created on the meta device.

seed ¶

seed() -> None

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

patch_cloak

PatchCloakNoiseLayer ¶

input_shape property ¶

mask property writable ¶

mean property writable ¶

patch_size property ¶

std property writable ¶

__call__ ¶

input ¶

noise_mask ¶

**kwargs ¶

__getstate__ ¶

__init__ ¶

input_shape ¶

patch_size ¶

scale ¶

shallow ¶

percent_to_mask ¶

value_range ¶

padding_mode ¶

padding_value ¶

learn_locs_weights ¶

freeze_std_estimator ¶

seed ¶

__init_subclass__ ¶

__setstate__ ¶

forward ¶

input ¶

noise_mask ¶

**kwargs ¶

get_applied_transform_components_factory ¶

get_transformed_output_factory ¶

initial_seed ¶

manual_seed ¶

seed ¶

reset_parameters ¶

seed ¶

PatchCloakNoiseLayer1 ¶

input_shape property ¶

mask property writable ¶

mean property writable ¶

patch_size property ¶

std property writable ¶

__call__ ¶

input ¶

noise_mask ¶

**kwargs ¶

__getstate__ ¶

__init__ ¶

input_shape ¶

patch_size ¶

scale ¶

shallow ¶

padding_mode ¶

padding_value ¶

learn_locs_weights ¶

seed ¶

__init_subclass__ ¶

__setstate__ ¶

forward ¶

input ¶

noise_mask ¶

**kwargs ¶

get_applied_transform_components_factory ¶

get_transformed_output_factory ¶

initial_seed ¶

manual_seed ¶

seed ¶

reset_parameters ¶

seed ¶

PatchCloakNoiseLayer2 ¶

input_shape property ¶

mask property writable ¶

mean property writable ¶

patch_size property ¶

std property writable ¶

__call__ ¶

input ¶

noise_mask ¶

**kwargs ¶

input_shape `property` ¶

mask `property` `writable` ¶

mean `property` `writable` ¶

patch_size `property` ¶

std `property` `writable` ¶

call ¶

`input` ¶

`noise_mask` ¶

`**kwargs` ¶

getstate ¶

init ¶

`input_shape` ¶

`patch_size` ¶

`scale` ¶

`shallow` ¶

`percent_to_mask` ¶

`value_range` ¶

`padding_mode` ¶

`padding_value` ¶

`learn_locs_weights` ¶

`freeze_std_estimator` ¶

`seed` ¶

setstate ¶

`input` ¶

`noise_mask` ¶

`**kwargs` ¶

`seed` ¶

input_shape `property` ¶

mask `property` `writable` ¶

mean `property` `writable` ¶

patch_size `property` ¶

std `property` `writable` ¶

call ¶

`input` ¶

`noise_mask` ¶

`**kwargs` ¶

getstate ¶

init ¶

`input_shape` ¶

`patch_size` ¶

`scale` ¶

`shallow` ¶

`padding_mode` ¶

`padding_value` ¶

`learn_locs_weights` ¶

`seed` ¶

setstate ¶

`input` ¶

`noise_mask` ¶

`**kwargs` ¶

`seed` ¶

input_shape `property` ¶

mask `property` `writable` ¶

mean `property` `writable` ¶

patch_size `property` ¶

std `property` `writable` ¶

call ¶

`input` ¶

`noise_mask` ¶

`**kwargs` ¶

getstate ¶

init ¶

`input_shape` ¶

`patch_size` ¶

`scale` ¶

`percent_to_mask` ¶

`shallow` ¶

`value_range` ¶

`padding_mode` ¶

`padding_value` ¶

`learn_locs_weights` ¶

`freeze_std_estimator` ¶

`seed` ¶

setstate ¶

`input` ¶

`noise_mask` ¶

`**kwargs` ¶

`seed` ¶

input_shape `property` ¶

mask `property` `writable` ¶