Transform Feature

feature

CLASS	DESCRIPTION
PretrainedFeatureExtractor	Feature extraction using a frozen pre-trained model.

Classes

PretrainedFeatureExtractor(model: torch.nn.Module)

Bases: Transformer

Feature extraction using a frozen pre-trained model.

Wraps a pre-trained neural network and extracts features without updating model weights. All parameters are frozen and the model is set to evaluation mode.

Useful for transfer learning scenarios where you want to: - Extract features from intermediate layers of pre-trained models - Use pre-trained embeddings as input to downstream tasks - Freeze encoder weights while training a decoder

PARAMETER	DESCRIPTION
model	Pre-trained model to use for feature extraction. Will be frozen and set to evaluation mode. TYPE: Module

ATTRIBUTE	DESCRIPTION
model	The frozen pre-trained model (registered as submodule). TYPE: Module

Examples:

Extract features from a pre-trained ResNet encoder

>>> import torch
>>> from spectre.transform import PretrainedFeatureExtractor
>>> # Create a simple pre-trained model
>>> pretrained_model = torch.nn.Sequential(
...     torch.nn.Linear(10, 20),
...     torch.nn.ReLU(),
...     torch.nn.Linear(20, 5),
... )
>>> extractor = PretrainedFeatureExtractor(pretrained_model)
>>> X = torch.randn(100, 10)
>>> features = extractor.transform(X)
>>> features.shape
torch.Size([100, 5])
>>> # Verify no gradients are computed
>>> features.requires_grad
False

Use in a pipeline with downstream model

>>> from spectre.core import Model
>>> extractor = PretrainedFeatureExtractor(pretrained_model)
>>> downstream = Model(in_features=5, out_features=3, multipliers=[1.0])
>>> # Features -> downstream model
>>> X = torch.randn(100, 10)
>>> features = extractor(X)
>>> output = downstream(features)
>>> output.shape
torch.Size([100, 3])

METHOD	DESCRIPTION
transform	Extract features without computing gradients.
inverse_transform	Inverse transform is not defined for feature extraction.
freeze	Freeze all model parameters (already done in init).
unfreeze	Unfreeze all model parameters.

Source code in spectre/transform/feature.py

def __init__(self, model: torch.nn.Module) -> None:
    super().__init__()

    if not isinstance(model, torch.nn.Module):
        raise TypeError(
            f"model must be torch.nn.Module, got {type(model).__name__}."
        )

    self.model = model
    self.model.eval()

    # Freeze all parameters
    for param in self.model.parameters():
        param.requires_grad = False

Functions

transform(X: torch.Tensor) -> torch.Tensor

Extract features without computing gradients.

PARAMETER	DESCRIPTION
X	Input data for feature extraction. TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Extracted features from the pre-trained model.

Notes

This method disables gradient computation using torch.no_grad(). The model remains in evaluation mode during the forward pass.

Source code in spectre/transform/feature.py

def transform(self, X: torch.Tensor) -> torch.Tensor:
    """
    Extract features without computing gradients.

    Parameters
    ----------
    X : torch.Tensor
        Input data for feature extraction.


    Returns
    -------
    torch.Tensor
        Extracted features from the pre-trained model.


    Notes
    -----
    This method disables gradient computation using `torch.no_grad()`.
    The model remains in evaluation mode during the forward pass.
    """
    with torch.no_grad():
        return self.model(X)

inverse_transform(X: torch.Tensor) -> torch.Tensor

Inverse transform is not defined for feature extraction.

Feature extraction from neural networks is generally not invertible as it involves non-linear transformations and information loss.

PARAMETER	DESCRIPTION
X	Extracted features. TYPE: Tensor

RETURNS	DESCRIPTION
Tensor	Not implemented.

RAISES	DESCRIPTION
NotImplementedError	Feature extraction is not invertible.

Source code in spectre/transform/feature.py

def inverse_transform(self, X: torch.Tensor) -> torch.Tensor:
    """
    Inverse transform is not defined for feature extraction.

    Feature extraction from neural networks is generally not invertible
    as it involves non-linear transformations and information loss.

    Parameters
    ----------
    X : torch.Tensor
        Extracted features.


    Returns
    -------
    torch.Tensor
        Not implemented.


    Raises
    ------
    NotImplementedError
        Feature extraction is not invertible.
    """
    raise NotImplementedError(
        "Feature extraction from neural networks is not invertible."
    )

freeze() -> None

Freeze all model parameters (already done in init).

This method is provided for convenience and explicit intent.

Source code in spectre/transform/feature.py

def freeze(self) -> None:
    """
    Freeze all model parameters (already done in __init__).

    This method is provided for convenience and explicit intent.
    """
    for param in self.model.parameters():
        param.requires_grad = False

unfreeze() -> None

Unfreeze all model parameters.

Enables gradient computation for all parameters, allowing the model to be fine-tuned if needed.

Notes

After unfreezing, you may want to set the model to training mode using self.model.train() depending on your use case.

Source code in spectre/transform/feature.py

def unfreeze(self) -> None:
    """
    Unfreeze all model parameters.

    Enables gradient computation for all parameters, allowing the
    model to be fine-tuned if needed.


    Notes
    -----
    After unfreezing, you may want to set the model to training mode
    using `self.model.train()` depending on your use case.
    """
    for param in self.model.parameters():
        param.requires_grad = True