Base API¶

Core base classes shared across polyview modules.

Design contract for every subclass¶

__init__ stores hyperparameters only — no data, no fitting.
Every hyperparameter must be a keyword argument with a default.
Learned attributes are written as attr_ (trailing underscore), following sklearn convention, so check_is_fitted works.
Views are always passed as list[np.ndarray] (or a MultiViewDataset), never as a single array.

class polyview.base.BaseLateFusion(*args: Any, **kwargs: Any)¶

Bases: BaseEstimator

Base class for late-fusion estimators over per-view predictions.

Late-fusion estimators consume one 1-D prediction vector per view and return one fused 1-D prediction vector.

Example

>>> class MeanVote(BaseLateFusion):
...     def fit(self, preds_by_view, y=None):
...         return self
...     def predict(self, preds_by_view):
...         P = np.vstack([np.asarray(p, dtype=float) for p in preds_by_view])
...         return np.rint(P.mean(axis=0)).astype(int)
>>> preds = [np.array([0, 1, 1]), np.array([1, 1, 0])]
>>> MeanVote().fit_predict(preds)
array([0, 1, 0])

fit(preds_by_view: List[Iterable], y=None)¶

fit_predict(preds_by_view: List[Iterable], y=None) → numpy.ndarray¶

predict(preds_by_view: List[Iterable]) → numpy.ndarray¶

class polyview.base.BaseMultiView(*args: Any, **kwargs: Any)¶

Bases: BaseEstimator, ABC

Base class for all polyview estimators.

Inheriting from sklearn’s BaseEstimator gives every subclass: - get_params() / set_params() (introspection, Grid Search) - __repr__ (human-readable) - clone() compatibility (cross-validation)

Subclasses must implement fit(). They should not override get_params / set_params — those are auto-generated from the __init__ signature by sklearn.

Parameters:: n_views (int or None, default=None) – Expected number of views. When set, _validate_views() raises if the data has a different count. None means “accept any number of views ≥ 1”.

Example

>>> class DummyMV(BaseMultiView):
...     def fit(self, views, y=None):
...         self._validate_views(views)
...         self.is_fitted_ = True
...         return self
>>> X1 = np.random.rand(8, 3)
>>> X2 = np.random.rand(8, 5)
>>> DummyMV(n_views=2).fit([X1, X2]).is_fitted_
True

abstractmethod fit(views: List, y=None) → BaseMultiView¶

Fit the model from a list of views.

Parameters:

views (list of array-like of shape (n_samples, n_features_i))
y (ignored for unsupervised methods)

Return type:

self

class polyview.base.BaseMultiViewClusterer(*args: Any, **kwargs: Any)¶

Bases: BaseMultiView, MultiViewClusterMixin

Ready-to-subclass base for multi-view clustering algorithms.

Subclasses must implement fit(). After fitting, labels_ must be set as an attribute.

Example

>>> class MyClusterer(BaseMultiViewClusterer):
...     def __init__(self, n_clusters=2):
...         super().__init__()
...         self.n_clusters = n_clusters
...     def fit(self, views, y=None):
...         views = self._validate_views(views)
...         # ... clustering logic ...
...         self.labels_ = np.zeros(self.n_samples_, dtype=int)
...         return self

class polyview.base.BaseMultiViewEmbedder(*args: Any, **kwargs: Any)¶

Bases: BaseMultiView, MultiViewEmbedderMixin

Ready-to-subclass base for multi-view embedding methods.

Subclasses must implement fit() and transform(). Store the embedding in self.embedding_ after fitting.

Example

>>> class IdentityEmbedder(BaseMultiViewEmbedder):
...     def fit(self, views, y=None):
...         validated = self._validate_views(views)
...         self.embedding_ = validated[0]
...         return self
...     def transform(self, views):
...         validated = self._validate_views(views, reset=False)
...         return validated[0]

class polyview.base.BaseMultiViewTransformer(*args: Any, **kwargs: Any)¶

Bases: BaseMultiView, MultiViewTransformerMixin

Ready-to-subclass base for multi-view transformers.

Subclasses must implement fit() and transform().

Example

>>> class MyConcatTransformer(BaseMultiViewTransformer):
...     def fit(self, views, y=None):
...         self._validate_views(views)
...         return self
...     def transform(self, views):
...         validated = self._validate_views(views, reset=False)
...         return np.concatenate(validated, axis=1)

class polyview.base.MultiViewClusterMixin¶

Bases: object

Mixin for estimators that produce cluster labels.

Provides fit_predict and enforces that fit stores labels_ as a fitted attribute.

Example

>>> class ToyClusterer(MultiViewClusterMixin):
...     def fit(self, views, y=None):
...         self.labels_ = np.zeros(len(views[0]), dtype=int)
...         return self
>>> ToyClusterer().fit_predict([np.random.rand(4, 2)])
array([0, 0, 0, 0])

fit_predict(views: List, y=None) → numpy.ndarray¶

Fit and return cluster labels.

Parameters:

views (list of array-like)
y (ignored)

Returns:

labels

Return type:

ndarray of shape (n_samples,)

class polyview.base.MultiViewEmbedderMixin¶

Bases: MultiViewTransformerMixin

Mixin for estimators that produce a low-dimensional embedding.

Identical contract to MultiViewTransformerMixin but signals that the output is an embedding (not a feature transformation), so callers can make different downstream choices (e.g. skip PCA post-processing).

Subclasses should store the final embedding in embedding_.

Example

>>> class ToyEmbedder(MultiViewEmbedderMixin):
...     def fit(self, views, y=None):
...         self.embedding_ = np.asarray(views[0])
...         return self
...     def transform(self, views):
...         return np.asarray(views[0])
>>> emb = ToyEmbedder().fit([np.random.rand(3, 2)]).embedding_
>>> emb.shape
(3, 2)

property embedding_: numpy.ndarray¶

class polyview.base.MultiViewTransformerMixin¶

Bases: object

Mixin for estimators that implement transform.

Provides a default fit_transform that calls fit then transform — subclasses only need to implement both methods.

Example

>>> class AddOneTransformer(MultiViewTransformerMixin):
...     def fit(self, views, y=None):
...         return self
...     def transform(self, views):
...         return np.asarray(views[0]) + 1
>>> AddOneTransformer().fit_transform([np.array([[1.0], [2.0]])]).ravel()
array([2., 3.])

fit_transform(views: List, y=None) → numpy.ndarray¶

Fit and immediately transform.

Equivalent to self.fit(views, y).transform(views) but may be overridden for efficiency (e.g. CCA can reuse intermediate results).

Parameters:

views (list of array-like)
y (ignored)

Return type:

ndarray

abstractmethod transform(views: List) → numpy.ndarray¶

Apply the fitted transformation to views.

Parameters:: views (list of array-like)
Return type:: ndarray of shape (n_samples, n_components)