Skip to content

CCorATransformer

sknnr.transformers.CCorATransformer 

CCorATransformer(n_components: int | None = None)

Bases: ComponentReducerMixin, TransformerMixin, BaseEstimator

Transformer that performs Canonical Correlation Analysis (CCorA) (Hoteling, 1936). CCorA is a multivariate ordination technique that finds pairs of linear combinations of two variable sets such that the correlation between each pair is maximized.

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
n_components_ int

The number of components kept during transformation.
n_features_in_ int

Number of features seen during fit.
ordination_ CCorA

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

The projector matrix used to transform data.
scaler_ StandardScalerWithDOF

The scaler used to standardize the feature data.
References

Hotelling, H. (1936). Relations between two sets of variates. Biometrika, 28(3/4), 321–377.

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/_ccora_transformer.py 
54
55
56
57
58
59
60
61
62
63
64
65
def fit(self, X: DataLike, y: DataLike) -> Self:
    _, y_arr = validate_data(self, X=X, y=y, reset=True, multi_output=True)
    self.scaler_ = StandardScalerWithDOF(ddof=1).fit(X)

    if y_arr.ndim == 1:
        y_arr = y_arr.reshape(-1, 1)
    y_arr = StandardScalerWithDOF(ddof=1).fit_transform(y_arr)

    self.ordination_ = CCorA(self.scaler_.transform(X), y_arr)
    self.set_n_components()
    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/_ccora_transformer.py 
72
73
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/_ccora_transformer.py 
67
68
69
70
def transform(self, X: DataLike, y: None = None) -> NDArray[np.float64]:
    check_is_fitted(self)
    validate_data(self, X=X, reset=False, ensure_all_finite=True)
    return self.scaler_.transform(X) @ self.projector_