scratchkit 0.2.0__py3-none-any.whl

mlscratch/preprocessing/encoders.py

@@ -0,0 +1,140 @@
+r"""
+Categorical Encoders
+======================
+LabelEncoder
+-------------
+Maps a 1-D array of arbitrary hashable labels to integer codes
+``0..K-1`` (sorted) — typically used to encode a target column.
+
+OneHotEncoder
+--------------
+Maps each column of a 2-D categorical array independently to a block
+of binary indicator columns, one per observed category.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+FloatArray = NDArray[np.float64]
+
+
+class LabelEncoder:
+    """Encode a single 1-D array of labels as integers ``0..K-1``.
+
+    Attributes
+    ----------
+    classes_ : sorted unique labels seen during fit
+    """
+
+    def __init__(self) -> None:
+        self.classes_: NDArray | None = None
+
+    def fit(self, y: ArrayLike) -> LabelEncoder:
+        y_arr = np.asarray(y).flatten()
+        if y_arr.shape[0] == 0:
+            raise ValueError("y must not be empty.")
+        self.classes_ = np.unique(y_arr)
+        return self
+
+    def transform(self, y: ArrayLike) -> NDArray[np.int64]:
+        if self.classes_ is None:
+            raise RuntimeError("Call fit() before transform().")
+        y_arr = np.asarray(y).flatten()
+        label_to_idx = {label: i for i, label in enumerate(self.classes_)}
+        unseen = sorted(set(np.unique(y_arr).tolist()) - set(self.classes_.tolist()))
+        if unseen:
+            raise ValueError(f"y contains previously unseen labels: {unseen}")
+        return np.array([label_to_idx[v] for v in y_arr], dtype=np.int64)
+
+    def fit_transform(self, y: ArrayLike) -> NDArray[np.int64]:
+        return self.fit(y).transform(y)
+
+    def inverse_transform(self, y: ArrayLike) -> NDArray:
+        if self.classes_ is None:
+            raise RuntimeError("Call fit() before inverse_transform().")
+        y_arr = np.asarray(y, dtype=np.int64).flatten()
+        if np.any((y_arr < 0) | (y_arr >= self.classes_.size)):
+            raise ValueError("y contains codes outside the range of known classes.")
+        return self.classes_[y_arr]
+
+
+class OneHotEncoder:
+    """One-hot encode every column of a 2-D categorical array independently.
+
+    Parameters
+    ----------
+    drop_first : bool, default=False
+        If True, drop the first category of each column to avoid the
+        "dummy variable trap" (perfect multicollinearity for linear models).
+    handle_unknown : str, default='error'
+        ``'error'`` raises on categories not seen during fit;
+        ``'ignore'`` encodes them as an all-zero row.
+
+    Attributes
+    ----------
+    categories_ : list of per-column arrays of observed categories
+    """
+
+    def __init__(self, drop_first: bool = False, handle_unknown: str = "error") -> None:
+        if handle_unknown not in ("error", "ignore"):
+            raise ValueError("handle_unknown must be 'error' or 'ignore'.")
+        self.drop_first = drop_first
+        self.handle_unknown = handle_unknown
+        self.categories_: list[NDArray] | None = None
+        self.n_features_in_: int | None = None
+
+    def fit(self, X: ArrayLike) -> OneHotEncoder:
+        X_arr = np.asarray(X)
+        if X_arr.ndim == 1:
+            X_arr = X_arr.reshape(-1, 1)
+        self.n_features_in_ = X_arr.shape[1]
+        self.categories_ = [np.unique(X_arr[:, j]) for j in range(X_arr.shape[1])]
+        return self
+
+    def transform(self, X: ArrayLike) -> FloatArray:
+        if self.categories_ is None:
+            raise RuntimeError("Call fit() before transform().")
+        X_arr = np.asarray(X)
+        if X_arr.ndim == 1:
+            X_arr = X_arr.reshape(-1, 1)
+        if X_arr.shape[1] != self.n_features_in_:
+            raise ValueError(
+                f"X has {X_arr.shape[1]} columns but encoder was fit on {self.n_features_in_}."
+            )
+
+        blocks = []
+        for j, cats in enumerate(self.categories_):
+            start = 1 if self.drop_first else 0
+            col = X_arr[:, j]
+            cat_to_idx = {c: i for i, c in enumerate(cats)}
+            block = np.zeros((X_arr.shape[0], cats.size), dtype=np.float64)
+            for row, value in enumerate(col):
+                idx = cat_to_idx.get(value)
+                if idx is None:
+                    if self.handle_unknown == "error":
+                        raise ValueError(f"Unknown category {value!r} in column {j}.")
+                    continue
+                block[row, idx] = 1.0
+            blocks.append(block[:, start:])
+        return np.hstack(blocks)
+
+    def fit_transform(self, X: ArrayLike) -> FloatArray:
+        return self.fit(X).transform(X)
+
+    def get_feature_names(self, input_features: list[str] | None = None) -> list[str]:
+        """Return human-readable ``"<feature>_<category>"`` output column names."""
+        if self.categories_ is None:
+            raise RuntimeError("Call fit() before get_feature_names().")
+        prefixes = (
+            input_features
+            if input_features is not None
+            else [f"x{i}" for i in range(self.n_features_in_)]
+        )
+        names = []
+        for prefix, cats in zip(prefixes, self.categories_, strict=True):
+            start = 1 if self.drop_first else 0
+            for cat in cats[start:]:
+                names.append(f"{prefix}_{cat}")
+        return names

mlscratch/preprocessing/model_selection.py

@@ -0,0 +1,119 @@
+r"""
+Train/Test Splitting
+======================
+A minimal, dependency-free re-implementation of the classic
+``train_test_split`` utility, with optional stratification.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+
+def train_test_split(
+    *arrays: ArrayLike,
+    test_size: float | int = 0.25,
+    train_size: float | int | None = None,
+    shuffle: bool = True,
+    stratify: ArrayLike | None = None,
+    random_state: int | None = None,
+) -> list[np.ndarray]:
+    """Split one or more array-likes into random train/test subsets.
+
+    Parameters
+    ----------
+    *arrays : array-like
+        One or more arrays, all sharing the same length along axis 0
+        (e.g. ``X, y``).
+    test_size : float | int, default=0.25
+        Fraction in ``(0, 1)`` or an absolute sample count for the test split.
+    train_size : float | int | None, default=None
+        Complementary to ``test_size`` if given; otherwise inferred as
+        everything not in the test split.
+    shuffle : bool, default=True
+        Whether to shuffle before splitting (ignored if ``stratify`` is given,
+        which always shuffles within each class).
+    stratify : array-like | None, default=None
+        If given, the split preserves this array's class proportions.
+    random_state : int | None, default=None
+
+    Returns
+    -------
+    A flat list ``[arr1_train, arr1_test, arr2_train, arr2_test, ...]``,
+    in the same order as the inputs (mirrors scikit-learn's signature).
+    """
+    if len(arrays) == 0:
+        raise ValueError("At least one array is required.")
+    arrays_np = [np.asarray(a) for a in arrays]
+    n = arrays_np[0].shape[0]
+    for a in arrays_np[1:]:
+        if a.shape[0] != n:
+            raise ValueError("All input arrays must have the same first dimension.")
+
+    n_test = _resolve_size(test_size, n, "test_size")
+    n_train = _resolve_size(train_size, n, "train_size") if train_size is not None else n - n_test
+    if n_train + n_test > n:
+        raise ValueError("train_size + test_size exceeds the number of available samples.")
+    if n_train <= 0 or n_test <= 0:
+        raise ValueError("Both the train and test splits must contain at least one sample.")
+
+    rng = np.random.default_rng(random_state)
+
+    if stratify is not None:
+        strat = np.asarray(stratify).flatten()
+        if strat.shape[0] != n:
+            raise ValueError("stratify must have the same length as the input arrays.")
+        train_idx, test_idx = _stratified_indices(strat, n_train, n_test, rng)
+    else:
+        idx = np.arange(n)
+        if shuffle:
+            rng.shuffle(idx)
+        test_idx = idx[:n_test]
+        train_idx = idx[n_test : n_test + n_train]
+
+    result: list[np.ndarray] = []
+    for a in arrays_np:
+        result.append(a[train_idx])
+        result.append(a[test_idx])
+    return result
+
+
+def _resolve_size(size: float | int, n: int, name: str) -> int:
+    if isinstance(size, float):
+        if not (0.0 < size < 1.0):
+            raise ValueError(f"{name} as a float must be in (0, 1).")
+        return int(np.ceil(size * n))
+    if isinstance(size, (int, np.integer)):
+        if not (0 < size <= n):
+            raise ValueError(f"{name} as an int must be in (0, {n}].")
+        return int(size)
+    raise ValueError(f"{name} must be a float or an int.")
+
+
+def _stratified_indices(
+    strat: np.ndarray, n_train: int, n_test: int, rng: np.random.Generator
+) -> tuple[np.ndarray, np.ndarray]:
+    """Split indices class-by-class so train/test class proportions
+    approximately match the proportions of ``strat`` as a whole."""
+    classes, y_idx = np.unique(strat, return_inverse=True)
+    n = strat.shape[0]
+    train_parts, test_parts = [], []
+    for k in range(classes.size):
+        cls_idx = np.flatnonzero(y_idx == k)
+        rng.shuffle(cls_idx)
+        cls_n_test = min(cls_idx.size, max(1, int(round(n_test * cls_idx.size / n))))
+        test_parts.append(cls_idx[:cls_n_test])
+        train_parts.append(cls_idx[cls_n_test:])
+
+    train_idx = np.concatenate(train_parts)
+    test_idx = np.concatenate(test_parts)
+    rng.shuffle(train_idx)
+    rng.shuffle(test_idx)
+
+    # Trim to the exact requested sizes where the per-class rounding overshot.
+    if train_idx.size > n_train:
+        train_idx = train_idx[:n_train]
+    if test_idx.size > n_test:
+        test_idx = test_idx[:n_test]
+    return train_idx, test_idx

mlscratch/preprocessing/polynomial.py

@@ -0,0 +1,105 @@
+r"""
+Polynomial Features
+=====================
+Expand the input features into all polynomial and interaction
+combinations up to a given degree. For ``degree=2`` and input
+features ``[a, b]``, the output (with bias) is::
+
+    [1, a, b, a^2, a*b, b^2]
+
+Used to let a linear model fit non-linear relationships in the
+original feature space.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from itertools import combinations, combinations_with_replacement
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+FloatArray = NDArray[np.float64]
+
+
+class PolynomialFeatures:
+    """Generate polynomial and interaction features up to ``degree``.
+
+    Parameters
+    ----------
+    degree : int, default=2
+    include_bias : bool, default=True
+        Whether to prepend a constant ``1`` column.
+    interaction_only : bool, default=False
+        If True, only products of *distinct* input features are
+        produced (no ``x_i^2``, ``x_i^3``, ... pure powers).
+
+    Attributes
+    ----------
+    powers_ : list of tuples
+        For each output column, the tuple of input-feature indices
+        multiplied together (an empty tuple is the bias column).
+    """
+
+    def __init__(
+        self, degree: int = 2, include_bias: bool = True, interaction_only: bool = False
+    ) -> None:
+        if degree < 1:
+            raise ValueError("degree must be >= 1.")
+        self.degree = degree
+        self.include_bias = include_bias
+        self.interaction_only = interaction_only
+        self.n_features_in_: int | None = None
+        self.powers_: list[tuple[int, ...]] | None = None
+
+    def fit(self, X: ArrayLike) -> PolynomialFeatures:
+        X_arr = np.asarray(X, dtype=np.float64)
+        if X_arr.ndim != 2:
+            raise ValueError("X must be a 2D array of shape (n_samples, n_features).")
+        self.n_features_in_ = X_arr.shape[1]
+
+        terms: list[tuple[int, ...]] = [()] if self.include_bias else []
+        combo_fn = combinations if self.interaction_only else combinations_with_replacement
+        for d in range(1, self.degree + 1):
+            terms.extend(combo_fn(range(self.n_features_in_), d))
+        self.powers_ = terms
+        return self
+
+    def transform(self, X: ArrayLike) -> FloatArray:
+        if self.powers_ is None:
+            raise RuntimeError("Call fit() before transform().")
+        X_arr = np.asarray(X, dtype=np.float64)
+        if X_arr.ndim != 2:
+            raise ValueError("X must be a 2D array of shape (n_samples, n_features).")
+        if X_arr.shape[1] != self.n_features_in_:
+            raise ValueError(
+                f"X has {X_arr.shape[1]} features but transformer was fit on {self.n_features_in_}."
+            )
+        out = np.empty((X_arr.shape[0], len(self.powers_)), dtype=np.float64)
+        for j, combo in enumerate(self.powers_):
+            out[:, j] = 1.0 if not combo else np.prod(X_arr[:, combo], axis=1)
+        return out
+
+    def fit_transform(self, X: ArrayLike) -> FloatArray:
+        return self.fit(X).transform(X)
+
+    def get_feature_names(self, input_features: list[str] | None = None) -> list[str]:
+        """Return human-readable names such as ``"x0 x1^2"`` for each output column."""
+        if self.powers_ is None:
+            raise RuntimeError("Call fit() before get_feature_names().")
+        names_in = (
+            input_features
+            if input_features is not None
+            else [f"x{i}" for i in range(self.n_features_in_)]
+        )
+        names = []
+        for combo in self.powers_:
+            if not combo:
+                names.append("1")
+                continue
+            counts = Counter(combo)
+            parts = [
+                f"{names_in[i]}^{c}" if c > 1 else names_in[i] for i, c in sorted(counts.items())
+            ]
+            names.append(" ".join(parts))
+        return names

mlscratch/preprocessing/scalers.py

@@ -0,0 +1,220 @@
+r"""
+Feature Scalers
+================
+Stateful, sklearn-style fit/transform preprocessors for rescaling
+feature columns prior to model fitting.
+
+StandardScaler
+---------------
+.. math::
+    x' = \frac{x - \mu}{\sigma}
+
+MinMaxScaler
+-------------
+.. math::
+    x' = \frac{x - x_{\min}}{x_{\max}-x_{\min}} \cdot (b-a) + a
+
+RobustScaler
+-------------
+Centres on the median and scales by the interquartile range, so it is
+not skewed by outliers the way StandardScaler's mean/std are.
+
+.. math::
+    x' = \frac{x - \mathrm{median}(x)}{Q_3(x) - Q_1(x)}
+
+Normalizer
+-----------
+Row-wise (per-sample) rescaling to a unit L1, L2, or max norm —
+stateless: every row is scaled independently of every other row, so
+``fit`` is a no-op kept only for API symmetry with the other
+transformers (and so it can be dropped into a uniform preprocessing
+pipeline).
+
+Complexity
+----------
+O(n d) fit and transform for all four transformers.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+FloatArray = NDArray[np.float64]
+_EPS = 1e-12
+
+
+def _validate_x(X: ArrayLike) -> FloatArray:
+    X_arr = np.asarray(X, dtype=np.float64)
+    if X_arr.ndim != 2:
+        raise ValueError("X must be a 2D array of shape (n_samples, n_features).")
+    return X_arr
+
+
+def _check_n_features(X_arr: FloatArray, expected: int) -> None:
+    if X_arr.shape[1] != expected:
+        raise ValueError(f"X has {X_arr.shape[1]} features but transformer was fit on {expected}.")
+
+
+class StandardScaler:
+    """Standardise features to zero mean and unit variance.
+
+    Parameters
+    ----------
+    with_mean : bool, default=True
+    with_std : bool, default=True
+
+    Attributes
+    ----------
+    mean_, scale_ : per-feature mean and standard deviation used to
+        transform (``scale_`` is floored at 1.0 for constant columns,
+        so they pass through as all-zero rather than producing NaNs).
+    """
+
+    def __init__(self, with_mean: bool = True, with_std: bool = True) -> None:
+        self.with_mean = with_mean
+        self.with_std = with_std
+        self.mean_: FloatArray | None = None
+        self.scale_: FloatArray | None = None
+        self.n_features_in_: int | None = None
+
+    def fit(self, X: ArrayLike) -> StandardScaler:
+        X_arr = _validate_x(X)
+        self.n_features_in_ = X_arr.shape[1]
+        self.mean_ = X_arr.mean(axis=0) if self.with_mean else np.zeros(X_arr.shape[1])
+        std = X_arr.std(axis=0) if self.with_std else np.ones(X_arr.shape[1])
+        self.scale_ = np.where(std > _EPS, std, 1.0)
+        return self
+
+    def transform(self, X: ArrayLike) -> FloatArray:
+        if self.mean_ is None:
+            raise RuntimeError("Call fit() before transform().")
+        X_arr = _validate_x(X)
+        _check_n_features(X_arr, self.n_features_in_)
+        return (X_arr - self.mean_) / self.scale_
+
+    def fit_transform(self, X: ArrayLike) -> FloatArray:
+        return self.fit(X).transform(X)
+
+    def inverse_transform(self, X: ArrayLike) -> FloatArray:
+        if self.mean_ is None:
+            raise RuntimeError("Call fit() before inverse_transform().")
+        X_arr = _validate_x(X)
+        _check_n_features(X_arr, self.n_features_in_)
+        return X_arr * self.scale_ + self.mean_
+
+
+class MinMaxScaler:
+    """Linearly rescale features into ``feature_range`` (default ``[0, 1]``)."""
+
+    def __init__(self, feature_range: tuple[float, float] = (0.0, 1.0)) -> None:
+        lo, hi = feature_range
+        if lo >= hi:
+            raise ValueError("feature_range must satisfy min < max.")
+        self.feature_range = feature_range
+        self.data_min_: FloatArray | None = None
+        self.data_max_: FloatArray | None = None
+        self.n_features_in_: int | None = None
+
+    def fit(self, X: ArrayLike) -> MinMaxScaler:
+        X_arr = _validate_x(X)
+        self.n_features_in_ = X_arr.shape[1]
+        self.data_min_ = X_arr.min(axis=0)
+        self.data_max_ = X_arr.max(axis=0)
+        return self
+
+    def transform(self, X: ArrayLike) -> FloatArray:
+        if self.data_min_ is None:
+            raise RuntimeError("Call fit() before transform().")
+        X_arr = _validate_x(X)
+        _check_n_features(X_arr, self.n_features_in_)
+        data_range = np.where(
+            self.data_max_ - self.data_min_ > _EPS, self.data_max_ - self.data_min_, 1.0
+        )
+        lo, hi = self.feature_range
+        return (X_arr - self.data_min_) / data_range * (hi - lo) + lo
+
+    def fit_transform(self, X: ArrayLike) -> FloatArray:
+        return self.fit(X).transform(X)
+
+    def inverse_transform(self, X: ArrayLike) -> FloatArray:
+        if self.data_min_ is None:
+            raise RuntimeError("Call fit() before inverse_transform().")
+        X_arr = _validate_x(X)
+        _check_n_features(X_arr, self.n_features_in_)
+        data_range = self.data_max_ - self.data_min_
+        lo, hi = self.feature_range
+        return (X_arr - lo) / (hi - lo) * data_range + self.data_min_
+
+
+class RobustScaler:
+    """Centre on the median and scale by the interquartile range (IQR),
+    so outliers (which inflate mean/std) don't dominate the scaling."""
+
+    def __init__(self, quantile_range: tuple[float, float] = (25.0, 75.0)) -> None:
+        q_min, q_max = quantile_range
+        if not (0.0 <= q_min < q_max <= 100.0):
+            raise ValueError("quantile_range must satisfy 0 <= q_min < q_max <= 100.")
+        self.quantile_range = quantile_range
+        self.center_: FloatArray | None = None
+        self.scale_: FloatArray | None = None
+        self.n_features_in_: int | None = None
+
+    def fit(self, X: ArrayLike) -> RobustScaler:
+        X_arr = _validate_x(X)
+        self.n_features_in_ = X_arr.shape[1]
+        self.center_ = np.median(X_arr, axis=0)
+        q_min, q_max = self.quantile_range
+        iqr = np.percentile(X_arr, q_max, axis=0) - np.percentile(X_arr, q_min, axis=0)
+        self.scale_ = np.where(iqr > _EPS, iqr, 1.0)
+        return self
+
+    def transform(self, X: ArrayLike) -> FloatArray:
+        if self.center_ is None:
+            raise RuntimeError("Call fit() before transform().")
+        X_arr = _validate_x(X)
+        _check_n_features(X_arr, self.n_features_in_)
+        return (X_arr - self.center_) / self.scale_
+
+    def fit_transform(self, X: ArrayLike) -> FloatArray:
+        return self.fit(X).transform(X)
+
+    def inverse_transform(self, X: ArrayLike) -> FloatArray:
+        if self.center_ is None:
+            raise RuntimeError("Call fit() before inverse_transform().")
+        X_arr = _validate_x(X)
+        _check_n_features(X_arr, self.n_features_in_)
+        return X_arr * self.scale_ + self.center_
+
+
+class Normalizer:
+    """Rescale each *row* (sample) independently to unit norm.
+
+    Parameters
+    ----------
+    norm : str, default='l2'
+        ``'l1'``, ``'l2'``, or ``'max'``.
+    """
+
+    def __init__(self, norm: str = "l2") -> None:
+        if norm not in ("l1", "l2", "max"):
+            raise ValueError("norm must be 'l1', 'l2', or 'max'.")
+        self.norm = norm
+
+    def fit(self, X: ArrayLike) -> Normalizer:
+        _validate_x(X)  # validate only; this transformer is stateless
+        return self
+
+    def transform(self, X: ArrayLike) -> FloatArray:
+        X_arr = _validate_x(X)
+        if self.norm == "l1":
+            norms = np.sum(np.abs(X_arr), axis=1)
+        elif self.norm == "l2":
+            norms = np.sqrt(np.sum(X_arr**2, axis=1))
+        else:
+            norms = np.max(np.abs(X_arr), axis=1)
+        norms = np.where(norms > _EPS, norms, 1.0)
+        return X_arr / norms[:, None]
+
+    def fit_transform(self, X: ArrayLike) -> FloatArray:
+        return self.fit(X).transform(X)

mlscratch/reinforcement/__init__.py

@@ -0,0 +1,59 @@
+"""
+mlscratch.reinforcement
+========================
+From-scratch implementations of Reinforcement Learning algorithms.
+Pure numpy — no PyTorch, TensorFlow, or gym dependency required.
+
+Algorithms
+----------
+QLearning                   – Tabular Q-Learning (Watkins & Dayan, 1992)
+DoubleQLearning             – Double Q-Learning (van Hasselt, 2010)
+LinearQLearning             – Q-Learning with linear function approximation
+DQN                         – Deep Q-Network with Double DQN + Dueling + PER
+DuelingMLP                  – Dueling network architecture (stand-alone)
+DDPG                        – Deep Deterministic Policy Gradient
+TD3                         – Twin Delayed DDPG (Fujimoto et al., 2018)
+PPO                         – Proximal Policy Optimization (clip & KL variants)
+SAC                         – Soft Actor-Critic with auto-entropy tuning
+
+Shared utilities (mlscratch.reinforcement.utils)
+-------------------------------------------------
+GridWorld                   – Tabular grid-world environment
+ContinuousEnv               – 1-D point-mass continuous control environment
+DiscreteEnv                 – Discrete-action wrapper for ContinuousEnv
+ReplayBuffer                – Uniform experience replay
+PrioritizedReplayBuffer     – Prioritised experience replay (sum-tree)
+MLP                         – Pure-numpy MLP with Adam + backprop
+OrnsteinUhlenbeckNoise      – Temporally-correlated exploration noise
+GaussianNoise               – i.i.d. Gaussian exploration noise
+"""
+
+from .q_learning import QLearning, DoubleQLearning, LinearQLearning   # noqa: F401
+from .dqn import DQN, DuelingMLP                                       # noqa: F401
+from .ddpg import DDPG, TD3                                            # noqa: F401
+from .ppo import PPO                                                    # noqa: F401
+from .sac import SAC                                                    # noqa: F401
+from .utils import (                                                    # noqa: F401
+    GridWorld,
+    ContinuousEnv,
+    DiscreteEnv,
+    ReplayBuffer,
+    PrioritizedReplayBuffer,
+    MLP,
+    OrnsteinUhlenbeckNoise,
+    GaussianNoise,
+)
+
+__all__ = [
+    # Q-Learning family
+    "QLearning", "DoubleQLearning", "LinearQLearning",
+    # Deep RL
+    "DQN", "DuelingMLP",
+    "DDPG", "TD3",
+    "PPO",
+    "SAC",
+    # Environments & utilities
+    "GridWorld", "ContinuousEnv", "DiscreteEnv",
+    "ReplayBuffer", "PrioritizedReplayBuffer",
+    "MLP", "OrnsteinUhlenbeckNoise", "GaussianNoise",
+]