statgpu 0.1.0__py3-none-any.whl

statgpu/unsupervised/_minibatch_nmf.py

@@ -0,0 +1,252 @@
+"""Mini-batch non-negative matrix factorization."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import numpy as np
+
+from statgpu._base import BaseEstimator
+from statgpu._config import Device
+from statgpu.unsupervised._utils import backend_random_normal, check_2d_array, reject_sparse, scalar_to_float
+
+
+class MiniBatchNMF(BaseEstimator):
+    """Dense mini-batch NMF with multiplicative updates and Frobenius loss."""
+
+    def __init__(
+        self,
+        n_components: Optional[int] = None,
+        init: str = "random",
+        batch_size: int = 1024,
+        max_iter: int = 200,
+        tol: float = 1e-4,
+        random_state: Optional[int] = None,
+        device: Union[str, Device] = Device.AUTO,
+        n_jobs: Optional[int] = None,
+    ):
+        super().__init__(device=device, n_jobs=n_jobs)
+        self.n_components = n_components
+        self.init = init
+        self.batch_size = batch_size
+        self.max_iter = max_iter
+        self.tol = tol
+        self.random_state = random_state
+
+    def _validate_params(self, n_samples: int, n_features: int):
+        if self.n_components is None:
+            n_components = min(n_samples, n_features)
+        else:
+            if not isinstance(self.n_components, (int, np.integer)) or int(self.n_components) < 1:
+                raise ValueError("n_components must be None or a positive integer")
+            n_components = int(self.n_components)
+        if self.init != "random":
+            raise NotImplementedError("MiniBatchNMF v1 only supports init='random'")
+        if not isinstance(self.batch_size, (int, np.integer)) or int(self.batch_size) < 1:
+            raise ValueError("batch_size must be a positive integer")
+        if not isinstance(self.max_iter, (int, np.integer)) or int(self.max_iter) < 1:
+            raise ValueError("max_iter must be a positive integer")
+        if float(self.tol) < 0.0:
+            raise ValueError("tol must be non-negative")
+        return n_components
+
+    def _check_nonnegative(self, backend, X):
+        if scalar_to_float(backend.min(X)) < 0.0:
+            raise ValueError("MiniBatchNMF input X must be non-negative")
+
+    def _init_matrix(self, backend, shape, scale, seed):
+        return backend.abs(backend_random_normal(backend, seed, size=shape, scale=scale)) + 1e-8
+
+    def _init_components(self, backend, X, n_components):
+        mean = max(scalar_to_float(backend.mean(X)), np.finfo(np.float64).eps)
+        scale = np.sqrt(mean / float(n_components))
+        return self._init_matrix(backend, (n_components, X.shape[1]), scale, self.random_state)
+
+    def _init_w(self, backend, X, seed=None):
+        mean = max(scalar_to_float(backend.mean(X)), np.finfo(np.float64).eps)
+        scale = np.sqrt(mean / float(self.n_components_))
+        if seed is None:
+            seed = self.random_state
+        return self._init_matrix(backend, (X.shape[0], self.n_components_), scale, seed)
+
+    def _init_w_from_data(self, backend, X, H, eps):
+        numerator = backend.matmul(X, H.T)
+        denominator = backend.reshape(backend.sum(H * H, axis=1) + eps, (1, H.shape[0]))
+        return backend.maximum(numerator / denominator, eps)
+
+    def _update_h(self, backend, X, W, H, eps):
+        numerator = backend.matmul(W.T, X)
+        denominator = backend.matmul(backend.matmul(W.T, W), H) + eps
+        return H * numerator / denominator
+
+    def _update_h_from_stats(self, backend, H, A, B, eps):
+        denominator = backend.matmul(A, H) + eps
+        return H * B / denominator
+
+    def _update_h_from_stats_steps(self, backend, H, A, B, eps, n_steps):
+        for _ in range(int(n_steps)):
+            H = self._update_h_from_stats(backend, H, A, B, eps)
+        return H
+
+    def _update_w(self, backend, X, W, H, eps):
+        numerator = backend.matmul(X, H.T)
+        denominator = backend.matmul(W, backend.matmul(H, H.T)) + eps
+        return W * numerator / denominator
+
+    def _fit_batch_w(self, backend, X, H, n_steps):
+        eps = np.finfo(np.float64).eps
+        W = self._init_w_from_data(backend, X, H, eps)
+        for _ in range(int(n_steps)):
+            W = self._update_w(backend, X, W, H, eps)
+        return W
+
+    def _batch_stats(self, backend, X, W):
+        return backend.matmul(W.T, W), backend.matmul(W.T, X)
+
+    def _reconstruction_error(self, backend, X, W, H):
+        residual = X - backend.matmul(W, H)
+        return scalar_to_float(backend.sqrt(backend.sum(residual * residual)))
+
+    def _reconstruction_error_from_stats(self, backend, x_sq, A, B, H):
+        cross = backend.sum(B * H)
+        quadratic = backend.sum(backend.matmul(A, H) * H)
+        value = backend.maximum(x_sq - 2.0 * cross + quadratic, 0.0)
+        return scalar_to_float(backend.sqrt(value))
+
+    def partial_fit(self, X, y=None):
+        reject_sparse(X, "MiniBatchNMF")
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        self._check_nonnegative(backend, X_arr)
+        n_samples, n_features = X_arr.shape
+        if not getattr(self, "_fitted", False):
+            n_components = self._validate_params(n_samples, n_features)
+            self.n_components_ = int(n_components)
+            self.n_features_in_ = int(n_features)
+            self.components_ = self._init_components(backend, X_arr, n_components)
+            self.n_iter_ = 0
+            self._n_batches_seen_ = 0
+            self._A_accum = backend.zeros((self.n_components_, self.n_components_), dtype=backend.float64)
+            self._B_accum = backend.zeros((self.n_components_, self.n_features_in_), dtype=backend.float64)
+            self._backend_name = backend.name
+            self._fitted = True
+        elif n_features != self.n_features_in_:
+            raise ValueError(f"X has {n_features} features, expected {self.n_features_in_}")
+
+        eps = np.finfo(np.float64).eps
+        W = self._fit_batch_w(backend, X_arr, self.components_, n_steps=3)
+        A_batch, B_batch = self._batch_stats(backend, X_arr, W)
+        self._A_accum = self._A_accum + A_batch
+        self._B_accum = self._B_accum + B_batch
+        self._n_batches_seen_ = int(self._n_batches_seen_) + 1
+        self.components_ = self._update_h_from_stats_steps(
+            backend, self.components_, self._A_accum, self._B_accum, eps, n_steps=3
+        )
+        self.n_iter_ = int(self.n_iter_) + 1
+        self.reconstruction_err_ = self._reconstruction_error(backend, X_arr, W, self.components_)
+        return self
+
+    def fit(self, X, y=None):
+        reject_sparse(X, "MiniBatchNMF")
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        self._check_nonnegative(backend, X_arr)
+        n_samples, n_features = X_arr.shape
+        n_components = self._validate_params(n_samples, n_features)
+        self.n_components_ = int(n_components)
+        self.n_features_in_ = int(n_features)
+        self.components_ = self._init_components(backend, X_arr, n_components)
+        self.n_iter_ = 0
+        self._n_batches_seen_ = 0
+        self._backend_name = backend.name
+        self._fitted = True
+        batch_size = min(int(self.batch_size), n_samples)
+        eps = np.finfo(np.float64).eps
+        previous_delta = None
+        last_A = None
+        last_B = None
+        for epoch in range(1, int(self.max_iter) + 1):
+            A_epoch = backend.zeros((self.n_components_, self.n_components_), dtype=backend.float64)
+            B_epoch = backend.zeros((self.n_components_, self.n_features_in_), dtype=backend.float64)
+            for start in range(0, n_samples, batch_size):
+                X_batch = X_arr[start : start + batch_size]
+                W_batch = self._fit_batch_w(backend, X_batch, self.components_, n_steps=3)
+                A_batch, B_batch = self._batch_stats(backend, X_batch, W_batch)
+                A_epoch = A_epoch + A_batch
+                B_epoch = B_epoch + B_batch
+                self._n_batches_seen_ = int(self._n_batches_seen_) + 1
+
+            old_components = self.components_
+            new_components = self._update_h_from_stats_steps(
+                backend, old_components, A_epoch, B_epoch, eps, n_steps=3
+            )
+            delta = scalar_to_float(backend.xp.linalg.norm(new_components - old_components) / (backend.xp.linalg.norm(old_components) + eps))
+            self.components_ = new_components
+            self.n_iter_ = int(epoch)
+            last_A = A_epoch
+            last_B = B_epoch
+            if previous_delta is not None and delta <= float(self.tol):
+                break
+            previous_delta = delta
+        else:
+            epoch = int(self.max_iter)
+        self.n_iter_ = int(epoch)
+        if last_A is None or last_B is None:
+            W_full = self.transform(X_arr)
+            self.reconstruction_err_ = self._reconstruction_error(backend, X_arr, W_full, self.components_)
+            self._A_accum = backend.zeros((self.n_components_, self.n_components_), dtype=backend.float64)
+            self._B_accum = backend.zeros((self.n_components_, self.n_features_in_), dtype=backend.float64)
+        else:
+            self.reconstruction_err_ = self._reconstruction_error_from_stats(
+                backend, backend.sum(X_arr * X_arr), last_A, last_B, self.components_
+            )
+            self._A_accum = backend.copy(last_A)
+            self._B_accum = backend.copy(last_B)
+        return self
+
+    def transform(self, X):
+        self._check_is_fitted()
+        reject_sparse(X, "MiniBatchNMF")
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        self._check_nonnegative(backend, X_arr)
+        if X_arr.shape[1] != self.n_features_in_:
+            raise ValueError(f"X has {X_arr.shape[1]} features, expected {self.n_features_in_}")
+        eps = np.finfo(np.float64).eps
+        W = self._init_w_from_data(backend, X_arr, self.components_, eps)
+        n_steps = max(100, min(300, int(self.max_iter) * 5))
+        for _ in range(n_steps):
+            W = self._update_w(backend, X_arr, W, self.components_, eps)
+        return W
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X, y=y).transform(X)
+
+    def inverse_transform(self, X):
+        self._check_is_fitted()
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        if X_arr.shape[1] != self.n_components_:
+            raise ValueError(f"X has {X_arr.shape[1]} components, expected {self.n_components_}")
+        return backend.matmul(X_arr, self.components_)
+
+    def predict(self, X):
+        return self.transform(X)
+
+    def get_params(self, deep=True):
+        params = super().get_params(deep=deep)
+        params.update(
+            {
+                "n_components": self.n_components,
+                "init": self.init,
+                "batch_size": self.batch_size,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "random_state": self.random_state,
+            }
+        )
+        return params

statgpu/unsupervised/_nmf.py

@@ -0,0 +1,190 @@
+"""Non-negative matrix factorization."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import numpy as np
+
+from statgpu._base import BaseEstimator
+from statgpu._config import Device
+from statgpu.unsupervised._utils import (
+    backend_random_normal,
+    check_2d_array,
+    draw_random_seed,
+    reject_sparse,
+    scalar_to_float,
+)
+
+
+class NMF(BaseEstimator):
+    """NMF with multiplicative updates and Frobenius loss."""
+
+    def __init__(
+        self,
+        n_components: Optional[int] = None,
+        init: str = "random",
+        solver: str = "mu",
+        beta_loss: str = "frobenius",
+        max_iter: int = 200,
+        tol: float = 1e-4,
+        random_state: Optional[int] = None,
+        device: Union[str, Device] = Device.AUTO,
+        n_jobs: Optional[int] = None,
+    ):
+        super().__init__(device=device, n_jobs=n_jobs)
+        self.n_components = n_components
+        self.init = init
+        self.solver = solver
+        self.beta_loss = beta_loss
+        self.max_iter = max_iter
+        self.tol = tol
+        self.random_state = random_state
+
+    def _validate_params(self, n_samples: int, n_features: int):
+        if self.n_components is None:
+            n_components = min(n_samples, n_features)
+        else:
+            if not isinstance(self.n_components, (int, np.integer)) or int(self.n_components) < 1:
+                raise ValueError("n_components must be None or a positive integer")
+            n_components = int(self.n_components)
+        if self.init != "random":
+            raise NotImplementedError("NMF v1 only supports init='random'")
+        if self.solver != "mu":
+            raise NotImplementedError("NMF v1 only supports solver='mu'")
+        if self.beta_loss != "frobenius":
+            raise NotImplementedError("NMF v1 only supports beta_loss='frobenius'")
+        if not isinstance(self.max_iter, (int, np.integer)) or int(self.max_iter) < 1:
+            raise ValueError("max_iter must be a positive integer")
+        if float(self.tol) < 0.0:
+            raise ValueError("tol must be non-negative")
+        return n_components
+
+    def _check_nonnegative(self, backend, X):
+        if scalar_to_float(backend.min(X)) < 0.0:
+            raise ValueError("NMF input X must be non-negative")
+
+    def _init_factors(self, backend, X, n_components, seed):
+        eps = np.finfo(np.float64).eps
+        rng = np.random.default_rng(draw_random_seed(seed))
+        if X.shape[0] >= n_components:
+            indices = rng.choice(int(X.shape[0]), size=int(n_components), replace=False)
+            indices = backend.asarray(indices, dtype=backend.int64)
+            H = backend.maximum(X[indices], eps) + 1e-8
+        else:
+            mean = max(scalar_to_float(backend.mean(X)), np.finfo(np.float64).eps)
+            scale = np.sqrt(mean / float(n_components))
+            H = backend.abs(backend_random_normal(backend, seed, size=(n_components, X.shape[1]), scale=scale)) + 1e-8
+        W = self._init_w_from_data(backend, X, H, eps)
+        return W, H
+
+    def _init_w_from_data(self, backend, X, H, eps):
+        numerator = backend.matmul(X, H.T)
+        denominator = backend.reshape(backend.sum(H * H, axis=1) + eps, (1, H.shape[0]))
+        return backend.maximum(numerator / denominator, eps)
+
+    def _reconstruction_error(self, backend, X, W, H):
+        residual = X - backend.matmul(W, H)
+        return scalar_to_float(backend.sqrt(backend.sum(residual * residual)))
+
+    def _update_h(self, backend, X, W, H, eps):
+        numerator = backend.matmul(W.T, X)
+        denominator = backend.matmul(backend.matmul(W.T, W), H) + eps
+        H *= numerator
+        H /= denominator
+        return H
+
+    def _update_w(self, backend, X, W, H, eps):
+        numerator = backend.matmul(X, H.T)
+        denominator = backend.matmul(W, backend.matmul(H, H.T)) + eps
+        W *= numerator
+        W /= denominator
+        return W
+
+    def fit(self, X, y=None):
+        reject_sparse(X, "NMF")
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        self._check_nonnegative(backend, X_arr)
+        n_samples, n_features = X_arr.shape
+        n_components = self._validate_params(n_samples, n_features)
+
+        W, H = self._init_factors(backend, X_arr, n_components, self.random_state)
+        eps = np.finfo(np.float64).eps
+        previous_error = None
+        error = None
+        n_iter = 0
+        if backend.name == "numpy":
+            error_check_interval = 10
+        else:
+            # GPU/torch backends check less frequently than CPU to reduce host-sync
+            # overhead while still preserving tol-based early stopping.
+            error_check_interval = max(1, min(25, int(self.max_iter) // 5))
+        for n_iter in range(1, int(self.max_iter) + 1):
+            W = self._update_w(backend, X_arr, W, H, eps)
+            H = self._update_h(backend, X_arr, W, H, eps)
+            if n_iter % error_check_interval == 0 or n_iter == int(self.max_iter):
+                error = self._reconstruction_error(backend, X_arr, W, H)
+                if previous_error is not None:
+                    if abs(previous_error - error) / max(previous_error, eps) <= float(self.tol):
+                        break
+                previous_error = error
+
+        if error is None:
+            error = self._reconstruction_error(backend, X_arr, W, H)
+
+        self.components_ = H
+        self._fit_W = W
+        self.reconstruction_err_ = float(error if error is not None else 0.0)
+        self.n_iter_ = int(n_iter)
+        self.n_components_ = int(n_components)
+        self.n_features_in_ = int(n_features)
+        self._backend_name = backend.name
+        self._fitted = True
+        return self
+
+    def transform(self, X):
+        self._check_is_fitted()
+        reject_sparse(X, "NMF")
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        self._check_nonnegative(backend, X_arr)
+        if X_arr.shape[1] != self.n_features_in_:
+            raise ValueError(f"X has {X_arr.shape[1]} features, expected {self.n_features_in_}")
+        eps = np.finfo(np.float64).eps
+        W = self._init_w_from_data(backend, X_arr, self.components_, eps)
+        for _ in range(int(self.max_iter)):
+            W = self._update_w(backend, X_arr, W, self.components_, eps)
+        return W
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X, y=y)._fit_W
+
+    def inverse_transform(self, X):
+        self._check_is_fitted()
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        if X_arr.shape[1] != self.n_components_:
+            raise ValueError(f"X has {X_arr.shape[1]} components, expected {self.n_components_}")
+        return backend.matmul(X_arr, self.components_)
+
+    def predict(self, X):
+        return self.transform(X)
+
+    def get_params(self, deep=True):
+        params = super().get_params(deep=deep)
+        params.update(
+            {
+                "n_components": self.n_components,
+                "init": self.init,
+                "solver": self.solver,
+                "beta_loss": self.beta_loss,
+                "max_iter": self.max_iter,
+                "tol": self.tol,
+                "random_state": self.random_state,
+            }
+        )
+        return params

statgpu/unsupervised/_pca.py

@@ -0,0 +1,189 @@
+"""Principal component analysis."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import numpy as np
+
+from statgpu._base import BaseEstimator
+from statgpu._config import Device
+from statgpu.unsupervised._utils import backend_random_normal, check_2d_array, scalar_to_float, svd_flip_components
+
+
+class PCA(BaseEstimator):
+    """
+    Principal component analysis with NumPy, CuPy, or Torch backends.
+
+    Parameters
+    ----------
+    n_components : int or None, default=None
+        Number of components to keep. ``None`` keeps all components.
+    svd_solver : {'auto', 'full', 'covariance', 'randomized'}, default='auto'
+        Solver used for the decomposition. ``'auto'`` uses covariance/eigh
+        when ``n_samples >= n_features`` and full SVD otherwise. ``'randomized'``
+        computes an approximate truncated SVD and is useful when only a small
+        number of components is needed.
+    whiten : bool, default=False
+        When True, scale transformed components to unit variance.
+    copy : bool, default=True
+        Kept for sklearn-style API compatibility. Inputs are not modified.
+    device : {'auto', 'cpu', 'cuda', 'torch'}, default='auto'
+        Compute device.
+    """
+
+    def __init__(
+        self,
+        n_components: Optional[int] = None,
+        svd_solver: str = "auto",
+        whiten: bool = False,
+        copy: bool = True,
+        random_state: Optional[int] = None,
+        n_oversamples: int = 10,
+        iterated_power: int = 2,
+        device: Union[str, Device] = Device.AUTO,
+        n_jobs: Optional[int] = None,
+    ):
+        super().__init__(device=device, n_jobs=n_jobs)
+        self.n_components = n_components
+        self.svd_solver = svd_solver
+        self.whiten = whiten
+        self.copy = copy
+        self.random_state = random_state
+        self.n_oversamples = n_oversamples
+        self.iterated_power = iterated_power
+
+    def _validate_params(self, n_samples: int, n_features: int):
+        if self.svd_solver not in ("auto", "full", "covariance", "randomized"):
+            raise ValueError("svd_solver must be one of: 'auto', 'full', 'covariance', 'randomized'")
+        if not isinstance(self.n_oversamples, (int, np.integer)) or int(self.n_oversamples) < 0:
+            raise ValueError("n_oversamples must be a non-negative integer")
+        if not isinstance(self.iterated_power, (int, np.integer)) or int(self.iterated_power) < 0:
+            raise ValueError("iterated_power must be a non-negative integer")
+        max_components = min(n_samples, n_features)
+        if self.n_components is None:
+            n_components = max_components
+        else:
+            if not isinstance(self.n_components, (int, np.integer)):
+                raise ValueError("n_components must be None or a positive integer")
+            n_components = int(self.n_components)
+            if n_components < 1 or n_components > max_components:
+                raise ValueError(
+                    f"n_components must be in [1, {max_components}] for the input shape"
+                )
+        solver = self.svd_solver
+        if solver == "auto":
+            solver = "covariance" if n_samples >= n_features else "full"
+        return n_components, solver
+
+    def _randomized_svd(self, backend, X_centered, n_components: int):
+        n_samples, n_features = X_centered.shape
+        n_random = min(n_features, n_components + int(self.n_oversamples))
+        omega = backend_random_normal(backend, self.random_state, size=(n_features, n_random))
+        Q, _ = backend.qr(backend.matmul(X_centered, omega))
+        for _ in range(int(self.iterated_power)):
+            Q, _ = backend.qr(backend.matmul(X_centered.T, Q))
+            Q, _ = backend.qr(backend.matmul(X_centered, Q))
+        B = backend.matmul(Q.T, X_centered)
+        _, singular_values_all, vh = backend.svd(B, full_matrices=False)
+        return singular_values_all[:n_components], svd_flip_components(backend, vh[:n_components])
+
+    def fit(self, X, y=None):
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        n_samples, n_features = X_arr.shape
+        if n_samples < 2:
+            raise ValueError("PCA requires at least two samples")
+
+        n_components, solver = self._validate_params(n_samples, n_features)
+        mean = backend.mean(X_arr, axis=0, keepdims=False)
+
+        if solver == "covariance":
+            gram = backend.matmul(X_arr.T, X_arr)
+            mean_col = backend.reshape(mean, (n_features, 1))
+            cov = (gram - float(n_samples) * backend.matmul(mean_col, mean_col.T)) / float(n_samples - 1)
+            eigenvalues, eigenvectors = backend.eigh(cov)
+            order = backend.flip(backend.argsort(eigenvalues, axis=0), axis=0)
+            eigenvalues = eigenvalues[order]
+            eigenvectors = eigenvectors[:, order]
+            explained_variance = backend.maximum(eigenvalues[:n_components], 0.0)
+            components = eigenvectors[:, :n_components].T
+            components = svd_flip_components(backend, components)
+            singular_values = backend.sqrt(explained_variance * float(n_samples - 1))
+            total_var = backend.sum(backend.diag(cov))
+        elif solver == "randomized":
+            X_centered = X_arr - mean
+            singular_values, components = self._randomized_svd(backend, X_centered, n_components)
+            explained_variance = (singular_values ** 2) / float(n_samples - 1)
+            total_var = backend.sum(X_centered * X_centered) / float(n_samples - 1)
+        else:
+            X_centered = X_arr - mean
+            _, singular_values_all, vh = backend.svd(X_centered, full_matrices=False)
+            components = svd_flip_components(backend, vh[:n_components])
+            singular_values = singular_values_all[:n_components]
+            explained_variance = (singular_values ** 2) / float(n_samples - 1)
+            total_var = backend.sum(X_centered * X_centered) / float(n_samples - 1)
+
+        if scalar_to_float(total_var) > 0.0:
+            explained_variance_ratio = explained_variance / total_var
+        else:
+            explained_variance_ratio = explained_variance * 0.0
+
+        self.components_ = components
+        self.mean_ = mean
+        self.explained_variance_ = explained_variance
+        self.explained_variance_ratio_ = explained_variance_ratio
+        self.singular_values_ = singular_values
+        self.n_components_ = int(n_components)
+        self.n_features_in_ = int(n_features)
+        self._backend_name = backend.name
+        self._fitted = True
+        return self
+
+    def transform(self, X):
+        self._check_is_fitted()
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        check_2d_array(X_arr)
+        if X_arr.shape[1] != self.n_features_in_:
+            raise ValueError(f"X has {X_arr.shape[1]} features, expected {self.n_features_in_}")
+        X_transformed = backend.matmul(X_arr - self.mean_, self.components_.T)
+        if self.whiten:
+            scale = backend.sqrt(self.explained_variance_)
+            X_transformed = X_transformed / scale
+        return X_transformed
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X, y=y).transform(X)
+
+    def inverse_transform(self, X):
+        self._check_is_fitted()
+        backend = self._get_backend()
+        X_arr = backend.asarray(X, dtype=backend.float64)
+        if getattr(X_arr, "ndim", None) != 2:
+            raise ValueError("X must be a 2D array")
+        if X_arr.shape[1] != self.n_components_:
+            raise ValueError(f"X has {X_arr.shape[1]} components, expected {self.n_components_}")
+        if self.whiten:
+            X_arr = X_arr * backend.sqrt(self.explained_variance_)
+        return backend.matmul(X_arr, self.components_) + self.mean_
+
+    def predict(self, X):
+        """Alias for transform, provided for BaseEstimator compatibility."""
+        return self.transform(X)
+
+    def get_params(self, deep=True):
+        params = super().get_params(deep=deep)
+        params.update(
+            {
+                "n_components": self.n_components,
+                "svd_solver": self.svd_solver,
+                "whiten": self.whiten,
+                "copy": self.copy,
+                "random_state": self.random_state,
+                "n_oversamples": self.n_oversamples,
+                "iterated_power": self.iterated_power,
+            }
+        )
+        return params