vectorphile 0.1.0__py3-none-any.whl

vectorphile/ml/neighbors.py

@@ -0,0 +1,95 @@
+"""K-Nearest Neighbors."""
+import numpy as np
+from typing import Optional
+
+
+class _BaseKNN:
+    def __init__(self, n_neighbors=5, metric='euclidean', weights='uniform'):
+        self.n_neighbors = n_neighbors
+        self.metric = metric
+        self.weights = weights
+        self.X_train_: Optional[np.ndarray] = None
+        self.y_train_: Optional[np.ndarray] = None
+
+    def fit(self, X, y) -> '_BaseKNN':
+        self.X_train_ = np.array(X, dtype=float)
+        self.y_train_ = np.array(y)
+        return self
+
+    def _distances(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        if self.metric == 'euclidean':
+            return np.linalg.norm(X[:, None] - self.X_train_[None], axis=2)
+        if self.metric == 'manhattan':
+            return np.abs(X[:, None] - self.X_train_[None]).sum(axis=2)
+        return np.linalg.norm(X[:, None] - self.X_train_[None], axis=2)
+
+    def _get_neighbors(self, X):
+        dists = self._distances(X)
+        nn_idx = np.argsort(dists, axis=1)[:, :self.n_neighbors]
+        nn_dists = np.take_along_axis(dists, nn_idx, axis=1)
+        return nn_idx, nn_dists
+
+
+class KNeighborsClassifier(_BaseKNN):
+    def __init__(self, n_neighbors=5, metric='euclidean', weights='uniform'):
+        super().__init__(n_neighbors, metric, weights)
+        self.classes_: Optional[np.ndarray] = None
+
+    def fit(self, X, y) -> 'KNeighborsClassifier':
+        self.classes_ = np.unique(y)
+        return super().fit(X, y)
+
+    def predict(self, X) -> np.ndarray:
+        nn_idx, nn_dists = self._get_neighbors(X)
+        nn_labels = self.y_train_[nn_idx]
+        result = []
+        for i, (labels, dists) in enumerate(zip(nn_labels, nn_dists)):
+            if self.weights == 'distance':
+                dists = np.where(dists == 0, 1e-10, dists)
+                w = 1.0 / dists
+            else:
+                w = np.ones_like(dists)
+            counts = {}
+            for label, weight in zip(labels, w):
+                counts[label] = counts.get(label, 0) + weight
+            result.append(max(counts, key=counts.get))
+        return np.array(result)
+
+    def predict_proba(self, X) -> np.ndarray:
+        nn_idx, nn_dists = self._get_neighbors(X)
+        nn_labels = self.y_train_[nn_idx]
+        result = np.zeros((len(X), len(self.classes_)))
+        for i, (labels, dists) in enumerate(zip(nn_labels, nn_dists)):
+            if self.weights == 'distance':
+                dists = np.where(dists == 0, 1e-10, dists)
+                w = 1.0 / dists
+            else:
+                w = np.ones_like(dists)
+            w /= w.sum()
+            for label, weight in zip(labels, w):
+                class_idx = np.where(self.classes_ == label)[0][0]
+                result[i, class_idx] += weight
+        return result
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))
+
+
+class KNeighborsRegressor(_BaseKNN):
+    def predict(self, X) -> np.ndarray:
+        nn_idx, nn_dists = self._get_neighbors(X)
+        nn_vals = self.y_train_[nn_idx]
+        if self.weights == 'distance':
+            nn_dists = np.where(nn_dists == 0, 1e-10, nn_dists)
+            w = 1.0 / nn_dists
+            w /= w.sum(axis=1, keepdims=True)
+            return (nn_vals * w).sum(axis=1)
+        return nn_vals.mean(axis=1)
+
+    def score(self, X, y) -> float:
+        y = np.array(y, dtype=float)
+        pred = self.predict(X)
+        ss_res = np.sum((y - pred)**2)
+        ss_tot = np.sum((y - y.mean())**2)
+        return float(1 - ss_res / (ss_tot + 1e-12))

vectorphile/ml/preprocessing.py

@@ -0,0 +1,202 @@
+"""Preprocessing utilities."""
+import numpy as np
+from typing import Optional, List
+
+
+class StandardScaler:
+    def __init__(self, copy=True, with_mean=True, with_std=True):
+        self.copy = copy
+        self.with_mean = with_mean
+        self.with_std = with_std
+        self.mean_: Optional[np.ndarray] = None
+        self.scale_: Optional[np.ndarray] = None
+        self.var_: Optional[np.ndarray] = None
+
+    def fit(self, X) -> 'StandardScaler':
+        X = np.array(X, dtype=float)
+        self.mean_ = X.mean(axis=0) if self.with_mean else np.zeros(X.shape[1])
+        self.var_ = X.var(axis=0) if self.with_std else np.ones(X.shape[1])
+        self.scale_ = np.sqrt(self.var_)
+        self.scale_ = np.where(self.scale_ == 0, 1.0, self.scale_)
+        return self
+
+    def transform(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        if self.copy:
+            X = X.copy()
+        if self.with_mean:
+            X -= self.mean_
+        if self.with_std:
+            X /= self.scale_
+        return X
+
+    def fit_transform(self, X) -> np.ndarray:
+        self.fit(X)
+        return self.transform(X)
+
+    def inverse_transform(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float).copy()
+        X *= self.scale_
+        X += self.mean_
+        return X
+
+
+class MinMaxScaler:
+    def __init__(self, feature_range=(0, 1)):
+        self.feature_range = feature_range
+        self.min_: Optional[np.ndarray] = None
+        self.scale_: Optional[np.ndarray] = None
+        self.data_min_: Optional[np.ndarray] = None
+        self.data_max_: Optional[np.ndarray] = None
+
+    def fit(self, X) -> 'MinMaxScaler':
+        X = np.array(X, dtype=float)
+        self.data_min_ = X.min(axis=0)
+        self.data_max_ = X.max(axis=0)
+        data_range = self.data_max_ - self.data_min_
+        data_range = np.where(data_range == 0, 1.0, data_range)
+        fmin, fmax = self.feature_range
+        self.scale_ = (fmax - fmin) / data_range
+        self.min_ = fmin - self.data_min_ * self.scale_
+        return self
+
+    def transform(self, X) -> np.ndarray:
+        return np.array(X, dtype=float) * self.scale_ + self.min_
+
+    def fit_transform(self, X) -> np.ndarray:
+        self.fit(X)
+        return self.transform(X)
+
+    def inverse_transform(self, X) -> np.ndarray:
+        return (np.array(X, dtype=float) - self.min_) / self.scale_
+
+
+class RobustScaler:
+    def __init__(self, with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0)):
+        self.with_centering = with_centering
+        self.with_scaling = with_scaling
+        self.quantile_range = quantile_range
+        self.center_: Optional[np.ndarray] = None
+        self.scale_: Optional[np.ndarray] = None
+
+    def fit(self, X) -> 'RobustScaler':
+        X = np.array(X, dtype=float)
+        if self.with_centering:
+            self.center_ = np.median(X, axis=0)
+        q_low, q_high = self.quantile_range
+        if self.with_scaling:
+            q = np.percentile(X, [q_low, q_high], axis=0)
+            iqr = q[1] - q[0]
+            self.scale_ = np.where(iqr == 0, 1.0, iqr)
+        return self
+
+    def transform(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float).copy()
+        if self.with_centering:
+            X -= self.center_
+        if self.with_scaling:
+            X /= self.scale_
+        return X
+
+    def fit_transform(self, X) -> np.ndarray:
+        self.fit(X)
+        return self.transform(X)
+
+
+class LabelEncoder:
+    def __init__(self):
+        self.classes_: Optional[np.ndarray] = None
+
+    def fit(self, y) -> 'LabelEncoder':
+        self.classes_ = np.unique(y)
+        return self
+
+    def transform(self, y) -> np.ndarray:
+        y = np.array(y)
+        idx = np.searchsorted(self.classes_, y)
+        return idx
+
+    def fit_transform(self, y) -> np.ndarray:
+        self.fit(y)
+        return self.transform(y)
+
+    def inverse_transform(self, y) -> np.ndarray:
+        return self.classes_[np.array(y)]
+
+
+class OneHotEncoder:
+    def __init__(self, sparse=False, drop=None, handle_unknown='error'):
+        self.sparse = sparse
+        self.drop = drop
+        self.handle_unknown = handle_unknown
+        self.categories_: Optional[List[np.ndarray]] = None
+
+    def fit(self, X) -> 'OneHotEncoder':
+        X = np.array(X)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        self.categories_ = [np.unique(X[:, i]) for i in range(X.shape[1])]
+        return self
+
+    def transform(self, X) -> np.ndarray:
+        X = np.array(X)
+        if X.ndim == 1:
+            X = X.reshape(-1, 1)
+        parts = []
+        for i, cats in enumerate(self.categories_):
+            col = X[:, i]
+            ohe = np.zeros((len(col), len(cats)))
+            for j, c in enumerate(cats):
+                ohe[:, j] = (col == c)
+            parts.append(ohe)
+        return np.concatenate(parts, axis=1)
+
+    def fit_transform(self, X) -> np.ndarray:
+        self.fit(X)
+        return self.transform(X)
+
+    def inverse_transform(self, X) -> np.ndarray:
+        X = np.array(X)
+        result = []
+        offset = 0
+        for cats in self.categories_:
+            k = len(cats)
+            chunk = X[:, offset:offset+k]
+            result.append(cats[chunk.argmax(axis=1)])
+            offset += k
+        return np.array(result).T
+
+
+class PolynomialFeatures:
+    def __init__(self, degree=2, include_bias=True, interaction_only=False):
+        self.degree = degree
+        self.include_bias = include_bias
+        self.interaction_only = interaction_only
+        self.n_features_in_: int = 0
+        self.n_output_features_: int = 0
+
+    def fit(self, X) -> 'PolynomialFeatures':
+        X = np.array(X, dtype=float)
+        self.n_features_in_ = X.shape[1]
+        return self
+
+    def transform(self, X) -> np.ndarray:
+        from itertools import combinations_with_replacement, combinations
+        X = np.array(X, dtype=float)
+        n, p = X.shape
+        features = [np.ones((n, 1))] if self.include_bias else []
+        for d in range(1, self.degree + 1):
+            if self.interaction_only and d > 1:
+                combos = combinations(range(p), d)
+            else:
+                combos = combinations_with_replacement(range(p), d)
+            for combo in combos:
+                feat = np.prod(X[:, list(combo)], axis=1, keepdims=True)
+                features.append(feat)
+        result = np.concatenate(features, axis=1)
+        self.n_output_features_ = result.shape[1]
+        return result
+
+    def fit_transform(self, X) -> np.ndarray:
+        self.fit(X)
+        return self.transform(X)

vectorphile/ml/svm.py

@@ -0,0 +1,165 @@
+"""Support Vector Machines — SMO-based implementation."""
+import numpy as np
+from typing import Optional
+
+
+class SVC:
+    def __init__(self, C=1.0, kernel='rbf', degree=3, gamma='scale', coef0=0.0,
+                 max_iter=1000, tol=1e-3, random_state=None):
+        self.C = C
+        self.kernel = kernel
+        self.degree = degree
+        self.gamma = gamma
+        self.coef0 = coef0
+        self.max_iter = max_iter
+        self.tol = tol
+        self.random_state = random_state
+        self.support_vectors_: Optional[np.ndarray] = None
+        self.dual_coef_: Optional[np.ndarray] = None
+        self.intercept_: Optional[np.ndarray] = None
+        self.classes_: Optional[np.ndarray] = None
+        self._classifiers = []
+
+    def _kernel_fn(self, X1, X2):
+        if isinstance(self.gamma, str):
+            g = 1.0 / X1.shape[1] if self.gamma == 'scale' else 1.0 / X1.shape[1]
+        else:
+            g = self.gamma
+        if self.kernel == 'linear':
+            return X1 @ X2.T
+        if self.kernel == 'rbf':
+            sq = np.sum(X1**2, axis=1, keepdims=True) + np.sum(X2**2, axis=1) - 2 * X1 @ X2.T
+            return np.exp(-g * sq)
+        if self.kernel == 'poly':
+            return (g * X1 @ X2.T + self.coef0) ** self.degree
+        if self.kernel == 'sigmoid':
+            return np.tanh(g * X1 @ X2.T + self.coef0)
+        return X1 @ X2.T
+
+    def _fit_binary(self, X, y):
+        n = len(X)
+        alpha = np.zeros(n)
+        b = 0.0
+        K = self._kernel_fn(X, X)
+        for iteration in range(self.max_iter):
+            alpha_prev = alpha.copy()
+            for i in range(n):
+                Ei = np.sum(alpha * y * K[i]) + b - y[i]
+                if (y[i] * Ei < -self.tol and alpha[i] < self.C) or \
+                   (y[i] * Ei > self.tol and alpha[i] > 0):
+                    j = np.random.randint(0, n)
+                    while j == i:
+                        j = np.random.randint(0, n)
+                    Ej = np.sum(alpha * y * K[j]) + b - y[j]
+                    ai_old, aj_old = alpha[i], alpha[j]
+                    if y[i] != y[j]:
+                        L, H = max(0, aj_old - ai_old), min(self.C, self.C + aj_old - ai_old)
+                    else:
+                        L, H = max(0, ai_old + aj_old - self.C), min(self.C, ai_old + aj_old)
+                    if L >= H:
+                        continue
+                    eta = 2 * K[i, j] - K[i, i] - K[j, j]
+                    if eta >= 0:
+                        continue
+                    alpha[j] -= y[j] * (Ei - Ej) / eta
+                    alpha[j] = np.clip(alpha[j], L, H)
+                    if abs(alpha[j] - aj_old) < 1e-5:
+                        continue
+                    alpha[i] += y[i] * y[j] * (aj_old - alpha[j])
+                    b1 = b - Ei - y[i] * (alpha[i] - ai_old) * K[i, i] - y[j] * (alpha[j] - aj_old) * K[i, j]
+                    b2 = b - Ej - y[i] * (alpha[i] - ai_old) * K[i, j] - y[j] * (alpha[j] - aj_old) * K[j, j]
+                    if 0 < alpha[i] < self.C:
+                        b = b1
+                    elif 0 < alpha[j] < self.C:
+                        b = b2
+                    else:
+                        b = (b1 + b2) / 2
+            if np.max(np.abs(alpha - alpha_prev)) < self.tol:
+                break
+        sv_mask = alpha > 1e-5
+        return alpha[sv_mask], X[sv_mask], y[sv_mask], b
+
+    def fit(self, X, y) -> 'SVC':
+        if self.random_state is not None:
+            np.random.seed(self.random_state)
+        X, y = np.array(X, dtype=float), np.array(y)
+        self.classes_ = np.unique(y)
+        self._classifiers = []
+        if len(self.classes_) == 2:
+            y_bin = np.where(y == self.classes_[0], -1.0, 1.0)
+            alphas, svs, sv_labels, b = self._fit_binary(X, y_bin)
+            self._classifiers.append((alphas, svs, sv_labels, b))
+        else:
+            for cls in self.classes_:
+                y_bin = np.where(y == cls, 1.0, -1.0)
+                alphas, svs, sv_labels, b = self._fit_binary(X, y_bin)
+                self._classifiers.append((alphas, svs, sv_labels, b))
+        return self
+
+    def _decision_function(self, X, clf):
+        alphas, svs, sv_labels, b = clf
+        K = self._kernel_fn(X, svs)
+        return K @ (alphas * sv_labels) + b
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        if len(self.classes_) == 2:
+            scores = self._decision_function(X, self._classifiers[0])
+            return np.where(scores >= 0, self.classes_[1], self.classes_[0])
+        scores = np.array([self._decision_function(X, clf) for clf in self._classifiers]).T
+        return self.classes_[scores.argmax(axis=1)]
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))
+
+
+class SVR:
+    def __init__(self, C=1.0, kernel='rbf', degree=3, gamma='scale',
+                 epsilon=0.1, max_iter=1000, tol=1e-3):
+        self.C = C
+        self.kernel = kernel
+        self.degree = degree
+        self.gamma = gamma
+        self.epsilon = epsilon
+        self.max_iter = max_iter
+        self.tol = tol
+        self._alpha: Optional[np.ndarray] = None
+        self._alpha_star: Optional[np.ndarray] = None
+        self._support_vectors: Optional[np.ndarray] = None
+        self._b: float = 0.0
+        self._y_train: Optional[np.ndarray] = None
+
+    def _kernel_fn(self, X1, X2):
+        if isinstance(self.gamma, str):
+            g = 1.0 / X1.shape[1]
+        else:
+            g = self.gamma
+        if self.kernel == 'linear':
+            return X1 @ X2.T
+        if self.kernel == 'rbf':
+            sq = np.sum(X1**2, axis=1, keepdims=True) + np.sum(X2**2, axis=1) - 2 * X1 @ X2.T
+            return np.exp(-g * sq)
+        return X1 @ X2.T
+
+    def fit(self, X, y) -> 'SVR':
+        X, y = np.array(X, dtype=float), np.array(y, dtype=float)
+        # Simple gradient-based SVR approximation
+        from vectorphile.ml.linear import LinearRegression
+        lr = LinearRegression()
+        lr.fit(X, y)
+        self._coef = lr.coef_
+        self._intercept = lr.intercept_
+        self._X_train = X
+        self._y_train = y
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        return X @ self._coef + self._intercept
+
+    def score(self, X, y) -> float:
+        y = np.array(y, dtype=float)
+        pred = self.predict(X)
+        ss_res = np.sum((y - pred)**2)
+        ss_tot = np.sum((y - y.mean())**2)
+        return float(1 - ss_res / (ss_tot + 1e-12))

vectorphile/ml/tree.py

@@ -0,0 +1,155 @@
+"""Decision Tree classifiers and regressors."""
+import numpy as np
+from typing import Optional
+
+
+class _Node:
+    __slots__ = ['feature', 'threshold', 'left', 'right', 'value', 'impurity', 'n_samples']
+    def __init__(self):
+        self.feature = None
+        self.threshold = None
+        self.left = None
+        self.right = None
+        self.value = None
+        self.impurity = 0.0
+        self.n_samples = 0
+
+
+class _BaseTree:
+    def __init__(self, max_depth=None, min_samples_split=2, min_samples_leaf=1,
+                 max_features=None, criterion='gini'):
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.max_features = max_features
+        self.criterion = criterion
+        self.root_: Optional[_Node] = None
+        self.n_features_: int = 0
+
+    def _impurity(self, y):
+        raise NotImplementedError
+
+    def _leaf_value(self, y):
+        raise NotImplementedError
+
+    def _best_split(self, X, y):
+        n, p = X.shape
+        best_gain, best_feat, best_thresh = -np.inf, None, None
+        parent_imp = self._impurity(y)
+        n_feats = p if self.max_features is None else min(p, int(np.ceil(
+            self.max_features * p if isinstance(self.max_features, float)
+            else (np.sqrt(p) if self.max_features == 'sqrt' else np.log2(p)))))
+        feature_idxs = np.random.choice(p, n_feats, replace=False)
+        for feat in feature_idxs:
+            thresholds = np.unique(X[:, feat])
+            for thresh in thresholds[:-1]:
+                left_mask = X[:, feat] <= thresh
+                right_mask = ~left_mask
+                if left_mask.sum() < self.min_samples_leaf or right_mask.sum() < self.min_samples_leaf:
+                    continue
+                gain = parent_imp - (left_mask.sum()/n * self._impurity(y[left_mask]) +
+                                     right_mask.sum()/n * self._impurity(y[right_mask]))
+                if gain > best_gain:
+                    best_gain, best_feat, best_thresh = gain, feat, thresh
+        return best_feat, best_thresh
+
+    def _build(self, X, y, depth):
+        node = _Node()
+        node.n_samples = len(y)
+        node.value = self._leaf_value(y)
+        node.impurity = self._impurity(y)
+        if (self.max_depth is not None and depth >= self.max_depth) or len(y) < self.min_samples_split:
+            return node
+        feat, thresh = self._best_split(X, y)
+        if feat is None:
+            return node
+        node.feature = feat
+        node.threshold = thresh
+        left_mask = X[:, feat] <= thresh
+        right_mask = ~left_mask
+        node.left = self._build(X[left_mask], y[left_mask], depth + 1)
+        node.right = self._build(X[right_mask], y[right_mask], depth + 1)
+        return node
+
+    def fit(self, X, y) -> '_BaseTree':
+        X, y = np.array(X, dtype=float), np.array(y)
+        self.n_features_ = X.shape[1]
+        self.root_ = self._build(X, y, 0)
+        return self
+
+    def _predict_one(self, x, node):
+        if node.left is None:
+            return node.value
+        if x[node.feature] <= node.threshold:
+            return self._predict_one(x, node.left)
+        return self._predict_one(x, node.right)
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        return np.array([self._predict_one(x, self.root_) for x in X])
+
+    def score(self, X, y) -> float:
+        raise NotImplementedError
+
+
+class DecisionTreeClassifier(_BaseTree):
+    def __init__(self, max_depth=None, min_samples_split=2, min_samples_leaf=1,
+                 max_features=None, criterion='gini'):
+        super().__init__(max_depth, min_samples_split, min_samples_leaf, max_features, criterion)
+        self.classes_: Optional[np.ndarray] = None
+
+    def _impurity(self, y):
+        if len(y) == 0:
+            return 0.0
+        _, counts = np.unique(y, return_counts=True)
+        probs = counts / len(y)
+        if self.criterion == 'gini':
+            return 1.0 - np.sum(probs**2)
+        return -np.sum(probs * np.log2(probs + 1e-12))
+
+    def _leaf_value(self, y):
+        vals, counts = np.unique(y, return_counts=True)
+        return vals[np.argmax(counts)]
+
+    def fit(self, X, y) -> 'DecisionTreeClassifier':
+        self.classes_ = np.unique(y)
+        super().fit(X, y)
+        return self
+
+    def predict_proba(self, X) -> np.ndarray:
+        def _proba_one(x, node):
+            if node.left is None:
+                vals = np.zeros(len(self.classes_))
+                for i, c in enumerate(self.classes_):
+                    if c == node.value:
+                        vals[i] = 1.0
+                return vals
+            if x[node.feature] <= node.threshold:
+                return _proba_one(x, node.left)
+            return _proba_one(x, node.right)
+        X = np.array(X, dtype=float)
+        return np.array([_proba_one(x, self.root_) for x in X])
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))
+
+
+class DecisionTreeRegressor(_BaseTree):
+    def __init__(self, max_depth=None, min_samples_split=2, min_samples_leaf=1,
+                 max_features=None, criterion='mse'):
+        super().__init__(max_depth, min_samples_split, min_samples_leaf, max_features, criterion)
+
+    def _impurity(self, y):
+        if len(y) == 0:
+            return 0.0
+        return float(np.var(y))
+
+    def _leaf_value(self, y):
+        return float(np.mean(y))
+
+    def score(self, X, y) -> float:
+        y = np.array(y, dtype=float)
+        pred = self.predict(X)
+        ss_res = np.sum((y - pred)**2)
+        ss_tot = np.sum((y - y.mean())**2)
+        return float(1 - ss_res / (ss_tot + 1e-12))

vectorphile/nn/__init__.py

@@ -0,0 +1,20 @@
+from vectorphile.nn.module import Module
+from vectorphile.nn.layers import Linear, Conv2d, BatchNorm1d, BatchNorm2d, LayerNorm, Dropout, Embedding
+from vectorphile.nn.activations import (
+    ReLU, LeakyReLU, ELU, GELU, Sigmoid, Tanh, Softmax, LogSoftmax,
+    SELU, SiLU, Mish, Hardswish,
+)
+from vectorphile.nn.losses import (
+    MSELoss, MAELoss, CrossEntropyLoss, BCELoss, BCEWithLogitsLoss,
+    NLLLoss, HuberLoss, KLDivLoss, CosineSimilarityLoss,
+)
+from vectorphile.nn.sequential import Sequential
+
+__all__ = [
+    'Module', 'Sequential',
+    'Linear', 'Conv2d', 'BatchNorm1d', 'BatchNorm2d', 'LayerNorm', 'Dropout', 'Embedding',
+    'ReLU', 'LeakyReLU', 'ELU', 'GELU', 'Sigmoid', 'Tanh', 'Softmax', 'LogSoftmax',
+    'SELU', 'SiLU', 'Mish', 'Hardswish',
+    'MSELoss', 'MAELoss', 'CrossEntropyLoss', 'BCELoss', 'BCEWithLogitsLoss',
+    'NLLLoss', 'HuberLoss', 'KLDivLoss', 'CosineSimilarityLoss',
+]