Skip to content

CCATransformer

sknnr.transformers.CCATransformer 

CCATransformer(n_components: int | None = None)

Bases: ComponentReducerMixin, TransformerMixin, BaseEstimator

Transformer that performs Canonical Correspondence Analysis (CCA) (ter Braak, 1986). CCA is a constrained ordination technique that finds linear combinations of features that best explain variation in the target variables.

Parameters:

Name Type Description Default
n_components int

Number of components to keep during transformation. If None, all components are kept. If n_components is greater than the number of available components, an error will be raised.

 None

Attributes:

Name Type Description
env_center_ ndarray of shape (n_features,)

The center of the environmental (feature) data used for standardizing features during transformation.
n_components_ int

The number of components kept during transformation.
n_features_in_ int

Number of features seen during fit.
ordination_ CCA

The fitted CCA ordination object.
projector_ ndarray of shape (n_features, n_components_)

The projector matrix used to transform data.
References

ter Braak, C.J.F. 1986. Canonical correspondence analysis: a new eigenvector technique for multivariate direct gradient analysis. Ecology, 67: 1167–1179.

Source code in src/sknnr/transformers/_base.py 
77
78
def __init__(self, n_components: int | None = None):
    self.n_components = n_components

Attributes

n_components instance-attribute 

n_components = n_components

ordination_ instance-attribute 

ordination_: Ordination

Functions

fit 

fit(X: DataLike, y: DataLike) -> Self
Source code in src/sknnr/transformers/_cca_transformer.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def fit(self, X: DataLike, y: DataLike) -> Self:
    X_arr = validate_data(
        self,
        X=X,
        reset=True,
        dtype=FLOAT_DTYPES,
        ensure_all_finite=True,
        ensure_min_features=2,
        ensure_min_samples=1,
    )
    y = np.asarray(y)
    if len(y.shape) < 2:
        raise ValueError("`y` must be a 2D array.")

    self.ordination_ = CCA(X_arr, y)
    self.set_n_components()
    self.env_center_ = self.ordination_.env_center
    self.projector_ = self.ordination_.projector(n_components=self.n_components_)
    return self

fit_transform 

fit_transform(X: DataLike, y: DataLike) -> NDArray[float64]
Source code in src/sknnr/transformers/_cca_transformer.py 
89
90
def fit_transform(self, X: DataLike, y: DataLike) -> NDArray[np.float64]:
    return self.fit(X, y).transform(X)

get_feature_names_out 

get_feature_names_out() -> NDArray[object_]
Source code in src/sknnr/transformers/_base.py 
80
81
82
83
84
85
86
87
88
def get_feature_names_out(self) -> NDArray[np.object_]:
    check_is_fitted(self, "n_components_")
    return np.asarray(
        [
            f"{self.ordination_.__class__.__name__.lower()}{i}"
            for i in range(self.n_components_)
        ],
        dtype=object,
    )

set_n_components 

set_n_components() -> None
Source code in src/sknnr/transformers/_base.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def set_n_components(self) -> None:
    n_components = (
        self.n_components
        if self.n_components is not None
        else self.ordination_.max_components
    )
    if not 0 <= n_components <= self.ordination_.max_components:
        raise ValueError(
            f"n_components={n_components} must be between 0 and "
            f"{self.ordination_.max_components}"
        )
    self.n_components_ = n_components

transform 

transform(X: DataLike, y: None = None) -> NDArray[float64]
Source code in src/sknnr/transformers/_cca_transformer.py 
76
77
78
79
80
81
82
83
84
85
86
87
def transform(self, X: DataLike, y: None = None) -> NDArray[np.float64]:
    check_is_fitted(self)
    X_arr = validate_data(
        self,
        X=X,
        reset=False,
        dtype=FLOAT_DTYPES,
        ensure_all_finite=True,
        ensure_min_features=2,
        ensure_min_samples=1,
    )
    return (X_arr - self.env_center_) @ self.projector_