pyod 3.6.2__tar.gz → 3.6.4__tar.gz

{pyod-3.6.2/pyod.egg-info → pyod-3.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyod
-Version: 3.6.2
+Version: 3.6.4
 Summary: A Python library for anomaly detection across tabular, time series, graph, text, image, and audio data. 61 detectors, benchmark-backed ADEngine orchestration, and an agentic workflow for AI agents.
 Author-email: Yue Zhao <yzhao062@gmail.com>
 License-Expression: BSD-2-Clause
@@ -72,12 +72,21 @@ Requires-Dist: librosa>=0.10; extra == "all"
 Requires-Dist: soundfile; extra == "all"
 Dynamic: license-file
 
+.. image:: https://raw.githubusercontent.com/yzhao062/pyod/master/brand/pyod-icon.svg
+   :target: https://pyod.dev
+   :alt: PyOD Ecosystem
+   :width: 84px
+
 Python Outlier Detection (PyOD) 3
 ==================================
 
 **PyOD 3: Agentic Anomaly Detection At Scale**
 
-|badge_pypi| |badge_anaconda| |badge_docs| |badge_stars| |badge_forks| |badge_downloads| |badge_testing| |badge_coverage| |badge_maintainability| |badge_license| |badge_benchmark|
+|badge_website| |badge_pypi| |badge_anaconda| |badge_docs| |badge_stars| |badge_forks| |badge_downloads| |badge_testing| |badge_coverage| |badge_maintainability| |badge_license| |badge_benchmark|
+
+.. |badge_website| image:: https://img.shields.io/badge/website-pyod.dev-990000
+   :target: https://pyod.dev
+   :alt: Website
 
 .. |badge_pypi| image:: https://img.shields.io/pypi/v/pyod.svg?color=brightgreen
    :target: https://pypi.org/project/pyod/
@@ -155,8 +164,8 @@ Then pick the activation path that matches your agent stack:
 
 .. code-block:: bash
 
-    # 1. Claude Code / Claude Desktop / Codex — enables the od-expert skill
-    pyod install skill              # Claude Code / Desktop: user-global (~/.claude/skills/)
+    # 1. Claude Code / Codex — enables the od-expert skill
+    pyod install skill              # Claude Code: user-global (~/.claude/skills/)
     pyod install skill --project    # Codex: project-local (./skills/, Codex has no user-global dir)
 
     # 2. Any MCP-compatible LLM — requires the optional mcp extra
@@ -795,6 +804,16 @@ More detailed instructions for running examples can be found in `examples direct
 
 
        from pyod.models.knn import KNN   # kNN detector
+       from pyod.utils.data import generate_data
+
+       contamination = 0.1  # percentage of outliers
+       n_train = 200  # number of training points
+       n_test = 100  # number of testing points
+
+       # generate sample data
+       X_train, X_test, y_train, y_test = generate_data(
+           n_train=n_train, n_test=n_test, n_features=2,
+           contamination=contamination, random_state=42)
 
        # train kNN detector
        clf_name = 'KNN'
@@ -832,14 +851,16 @@ More detailed instructions for running examples can be found in `examples direct
 
 
        On Training Data:
-       KNN ROC:1.0, precision @ rank n:1.0
+       KNN ROC:0.9992, precision @ rank n:0.95
 
        On Test Data:
-       KNN ROC:0.9989, precision @ rank n:0.9
+       KNN ROC:1.0, precision @ rank n:1.0
 
    .. code-block:: python
 
 
+       from pyod.utils.example import visualize
+
        visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
            y_test_pred, show_figure=True, save_figure=False)
 

{pyod-3.6.2 → pyod-3.6.4}/README.rst

@@ -1,9 +1,18 @@
+.. image:: https://raw.githubusercontent.com/yzhao062/pyod/master/brand/pyod-icon.svg
+   :target: https://pyod.dev
+   :alt: PyOD Ecosystem
+   :width: 84px
+
 Python Outlier Detection (PyOD) 3
 ==================================
 
 **PyOD 3: Agentic Anomaly Detection At Scale**
 
-|badge_pypi| |badge_anaconda| |badge_docs| |badge_stars| |badge_forks| |badge_downloads| |badge_testing| |badge_coverage| |badge_maintainability| |badge_license| |badge_benchmark|
+|badge_website| |badge_pypi| |badge_anaconda| |badge_docs| |badge_stars| |badge_forks| |badge_downloads| |badge_testing| |badge_coverage| |badge_maintainability| |badge_license| |badge_benchmark|
+
+.. |badge_website| image:: https://img.shields.io/badge/website-pyod.dev-990000
+   :target: https://pyod.dev
+   :alt: Website
 
 .. |badge_pypi| image:: https://img.shields.io/pypi/v/pyod.svg?color=brightgreen
    :target: https://pypi.org/project/pyod/
@@ -81,8 +90,8 @@ Then pick the activation path that matches your agent stack:
 
 .. code-block:: bash
 
-    # 1. Claude Code / Claude Desktop / Codex — enables the od-expert skill
-    pyod install skill              # Claude Code / Desktop: user-global (~/.claude/skills/)
+    # 1. Claude Code / Codex — enables the od-expert skill
+    pyod install skill              # Claude Code: user-global (~/.claude/skills/)
     pyod install skill --project    # Codex: project-local (./skills/, Codex has no user-global dir)
 
     # 2. Any MCP-compatible LLM — requires the optional mcp extra
@@ -721,6 +730,16 @@ More detailed instructions for running examples can be found in `examples direct
 
 
        from pyod.models.knn import KNN   # kNN detector
+       from pyod.utils.data import generate_data
+
+       contamination = 0.1  # percentage of outliers
+       n_train = 200  # number of training points
+       n_test = 100  # number of testing points
+
+       # generate sample data
+       X_train, X_test, y_train, y_test = generate_data(
+           n_train=n_train, n_test=n_test, n_features=2,
+           contamination=contamination, random_state=42)
 
        # train kNN detector
        clf_name = 'KNN'
@@ -758,14 +777,16 @@ More detailed instructions for running examples can be found in `examples direct
 
 
        On Training Data:
-       KNN ROC:1.0, precision @ rank n:1.0
+       KNN ROC:0.9992, precision @ rank n:0.95
 
        On Test Data:
-       KNN ROC:0.9989, precision @ rank n:0.9
+       KNN ROC:1.0, precision @ rank n:1.0
 
    .. code-block:: python
 
 
+       from pyod.utils.example import visualize
+
        visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
            y_test_pred, show_figure=True, save_figure=False)
 

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/abod.py

@@ -106,7 +106,7 @@ class ABOD(BaseDetector):
         the proportion of outliers in the data set. Used when fitting to
         define the threshold on the decision function.
 
-    n_neighbors : int, optional (default=10)
+    n_neighbors : int, optional (default=5)
         Number of neighbors to use by default for k neighbors queries.
 
     method: str, optional (default='fast')
@@ -155,7 +155,7 @@ class ABOD(BaseDetector):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/alad.py

@@ -43,7 +43,7 @@ class ALAD(BaseDetector):
         Activation function to use for hidden layers in encoder and decoder
         (i.e. generator).
 
-    epochs : int, optional (default=500)
+    epochs : int, optional (default=200)
         Number of epochs to train the model.
 
     batch_size : int, optional (default=32)
@@ -52,6 +52,9 @@ class ALAD(BaseDetector):
     dropout_rate : float in (0., 1), optional (default=0.2)
         The dropout to be used across all layers.
 
+    latent_dim : int, optional (default=2)
+        Dimensionality of the latent space.
+
     dec_layers : list, optional (default=[5,10,25])
         List that indicates the number of nodes per hidden layer for the d
         ecoder network.
@@ -77,25 +80,31 @@ class ALAD(BaseDetector):
         discriminator_xz.
         Thus, [10,10] indicates 2 hidden layers having each 10 nodes.
 
-    learning_rate_gen: float in (0., 1), optional (default=0.001)
+    learning_rate_gen: float in (0., 1), optional (default=0.0001)
         learning rate of training the encoder and decoder
 
-    learning_rate_disc: float in (0., 1), optional (default=0.001)
+    learning_rate_disc: float in (0., 1), optional (default=0.0001)
         learning rate of training the discriminators
 
     add_recon_loss: bool optional (default=False)
         add an extra loss for encoder and decoder based on the reconstruction
         error
 
+    add_disc_zz_loss : bool, optional (default=True)
+        If True, include the latent-space discriminator loss.
+
     lambda_recon_loss: float in (0., 1), optional (default=0.1)
         if ``add_recon_loss= True``, the reconstruction loss gets multiplied
         by ``lambda_recon_loss`` and added to the total loss for the generator
          (i.e. encoder and decoder).
 
-    preprocessing : bool, optional (default=True)
+    spectral_normalization : bool, optional (default=False)
+        If True, apply spectral normalization to discriminator layers.
+
+    preprocessing : bool, optional (default=False)
         If True, apply standardization on the data.
 
-    verbose : int, optional (default=1)
+    verbose : int, optional (default=0)
         Verbosity mode.
         - 0 = silent
         - 1 = progress bar
@@ -124,7 +133,7 @@ class ALAD(BaseDetector):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/anogan.py

@@ -114,7 +114,6 @@ class AnoGAN(BaseDetector):
     output_activation : str, optional (default=None)
         Activation function to use for output layer.
 
-
     activation_hidden : str, optional (default='tanh')
         Activation function to use for output layer.
 
@@ -127,6 +126,9 @@ class AnoGAN(BaseDetector):
     dropout_rate : float in (0., 1), optional (default=0.2)
         The dropout to be used across all layers.
 
+    latent_dim_G : int, optional (default=2)
+        Dimensionality of the generator's latent space.
+
     G_layers : list, optional (default=[20,10,3,10,20])
         List that indicates the number of nodes per hidden layer for the
         generator. Thus, [10,10] indicates 2 hidden layers having each 10 nodes.
@@ -136,28 +138,26 @@ class AnoGAN(BaseDetector):
         discriminator. Thus, [10,10] indicates 2 hidden layers having each 10
         nodes.
 
-
-    learning_rate: float in (0., 1), optional (default=0.001)
+    learning_rate : float in (0., 1), optional (default=0.001)
         learning rate of training the network
 
-    index_D_layer_for_recon_error: int, optional (default = 1)
+    index_D_layer_for_recon_error : int, optional (default = 1)
         This is the index of the hidden layer in the discriminator for which
         the reconstruction error will be determined between query sample and
         the sample created from the latent space.
 
-    learning_rate_query: float in (0., 1), optional (default=0.001)
+    learning_rate_query : float in (0., 1), optional (default=0.01)
         learning rate for the backpropagation steps needed to find a point in
         the latent space of the generator that approximate the query sample
 
-
-    epochs_query: int, optional (default=20) 
+    epochs_query : int, optional (default=20) 
         Number of epochs to approximate the query sample in the latent space
         of the generator
 
-    preprocessing : bool, optional (default=True)
+    preprocessing : bool, optional (default=False)
         If True, apply standardization on the data.
 
-    verbose : int, optional (default=1)
+    verbose : int, optional (default=0)
         Verbosity mode.
         - 0 = silent
         - 1 = progress bar
@@ -167,6 +167,9 @@ class AnoGAN(BaseDetector):
         the proportion of outliers in the data set. When fitting this is used
         to define the threshold on the decision function.
 
+    device : str, torch.device or None, optional (default=None)
+        Device used for computation. If None, use the PyTorch default device.
+
     Attributes
     ----------
 
@@ -182,7 +185,7 @@ class AnoGAN(BaseDetector):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/auto_encoder.py

@@ -111,7 +111,7 @@ class AutoEncoder(BaseDeepLearningDetector):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/base.py

@@ -50,7 +50,7 @@ class BaseDetector(BaseEstimator, metaclass=abc.ABCMeta):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/base_dl.py

@@ -92,11 +92,11 @@ class BaseDeepLearningDetector(BaseDetector):
         - 1 = progress bar
         - 2 = one line per epoch.
 
-    optimizer_params : dict, optional (default=None)
+    optimizer_params : dict, optional (default={})
         Additional parameters for the optimizer.
         For example, `optimizer_params={'weight_decay': 1e-4}`.
 
-    criterion_params : dict, optional (default=None)
+    criterion_params : dict, optional (default={})
         Additional parameters for the criterion.
         For example, `criterion_params={'reduction': 'sum'}`.
     """

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/cblof.py

@@ -91,6 +91,11 @@ class CBLOF(BaseDetector):
         number generator; If None, the random number generator is the
         RandomState instance used by `np.random`.
 
+    n_jobs : int, optional (default=1)
+        Accepted for API compatibility but currently unused: the value is
+        neither stored on the estimator nor forwarded to the clustering
+        step, so ``get_params()`` reports ``None`` for it and ``clone()``
+        does not carry it over. See issue #713.
 
     Attributes
     ----------
@@ -126,7 +131,7 @@ class CBLOF(BaseDetector):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/cd.py

@@ -150,7 +150,7 @@ class CD(BaseDetector):
        a modified z-score (based on the median absolute deviation) greater
        than this value will be classified as outliers.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/cof.py

@@ -68,7 +68,7 @@ class COF(BaseDetector):
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
 
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/copod.py

@@ -79,7 +79,7 @@ class COPOD(BaseDetector):
         ``n_samples * contamination`` most abnormal samples in
         ``decision_scores_``. The threshold is calculated for generating
         binary outlier labels.
-    labels_ : int, either 0 or 1
+    labels_ : numpy array of shape (n_samples,)
         The binary labels of the training data. 0 stands for inliers
         and 1 for outliers/anomalies. It is generated by applying
         ``threshold_`` on ``decision_scores_``.

{pyod-3.6.2 → pyod-3.6.4}/pyod/models/deep_svdd.py

@@ -6,6 +6,8 @@
 # License: BSD 2 clause
 
 
+import copy
+
 import numpy as np
 
 try:
@@ -65,9 +67,11 @@ class InnerDeepSVDD(nn.Module):
     dropout_rate : float in (0., 1), optional (default=0.2)
         The dropout to be used across all layers.
 
-    l2_regularizer : float in (0., 1), optional (default=0.1)
-        The regularization strength of activity_regularizer
-        applied on each layer. By default, l2 regularizer is used. See
+    l2_regularizer : float in (0., 1), optional (default=0.5e-6)
+        Weight decay passed to the optimizer (L2 regularization on the
+        network weights). The default matches the reference Deep SVDD
+        implementation; larger values push the weights toward zero and can
+        collapse the hypersphere.
     """
 
     def __init__(self, n_features, use_ae,
@@ -85,20 +89,14 @@ class InnerDeepSVDD(nn.Module):
         self.model = self._build_model()
 
     def _init_c(self, X_norm, eps=0.1):
-        intermediate_output = {}
-        hook_handle = self.model._modules.get(
-            'net_output').register_forward_hook(
-            lambda module, input, output: intermediate_output.update(
-                {'net_output': output})
-        )
-        output = self.model(X_norm)
-
-        out = intermediate_output['net_output']
-        hook_handle.remove()
-
-        self.c = torch.mean(out, dim=0)
+        # The center must live in the same representation space used by the
+        # loss. In particular, include the activation after ``net_output``.
+        self.eval()
+        with torch.no_grad():
+            self.c = torch.mean(self.model(X_norm), dim=0)
         self.c[(torch.abs(self.c) < eps) & (self.c < 0)] = -eps
         self.c[(torch.abs(self.c) < eps) & (self.c > 0)] = eps
+        return self.c
 
     def _build_model(self):
         layers = nn.Sequential()
@@ -153,15 +151,29 @@ class DeepSVDD(BaseDetector):
         data by calculating the distance from center
         See :cite:`ruff2018deepsvdd` for details.
 
+        This one-class objective works best when the fitting samples are
+        predominantly normal; PyOD fits it unsupervised on contaminated data,
+        so accuracy can trail a clean one-class setup. With ``use_ae=True``
+        the hypersphere distance and the anomaly scores are computed from the
+        decoder reconstructions; the encoder's latent layer remains an
+        intermediate activation.
+
         Parameters
         ----------
         n_features: int, 
             Number of features in the input data.
 
-        c: float, optional (default='forwad_nn_pass')
-            Deep SVDD center, the default will be calculated based on network
-            initialization first forward pass. To get repeated results set
-            random_state if c is set to None.
+        c: float, numpy array, or torch tensor, optional (default=None)
+            Hypersphere center, kept as configuration and never overwritten by
+            ``fit``. When None (the default) the center is initialized from the
+            first forward pass of the freshly built network; set
+            ``random_state`` for repeatable results. A scalar is expanded to
+            the network output width; a vector must match that width, which is
+            ``hidden_neurons[-1]`` normally and ``n_features`` when
+            ``use_ae=True``. The value must be finite and not all zeros: an
+            all-zero center is the trivial solution of the Deep SVDD objective
+            for a bias-free network and collapses the hypersphere. The fitted
+            center is exposed as ``c_``.
 
         use_ae: bool, optional (default=False)
             The AutoEncoder type of DeepSVDD it reverse neurons from hidden_neurons
@@ -184,6 +196,9 @@ class DeepSVDD(BaseDetector):
             String (name of optimizer) or optimizer instance.
             See https://keras.io/optimizers/
 
+        learning_rate : float, optional (default=1e-4)
+            Learning rate used by the optimizer.
+
         epochs : int, optional (default=100)
             Number of epochs to train the model.
 
@@ -193,10 +208,11 @@ class DeepSVDD(BaseDetector):
         dropout_rate : float in (0., 1), optional (default=0.2)
             The dropout to be used across all layers.
 
-        l2_regularizer : float in (0., 1), optional (default=0.1)
-            The regularization strength of activity_regularizer
-            applied on each layer. By default, l2 regularizer is used. See
-            https://keras.io/regularizers/
+        l2_regularizer : float in (0., 1), optional (default=0.5e-6)
+            Weight decay passed to the optimizer (L2 regularization on the
+            network weights). The default matches the reference Deep SVDD
+            implementation; larger values push the weights toward zero and
+            can collapse the hypersphere.
 
         validation_size : float in (0., 1), optional (default=0.1)
             The percentage of data to be used for validation.
@@ -204,6 +220,9 @@ class DeepSVDD(BaseDetector):
         preprocessing : bool, optional (default=True)
             If True, apply standardization on the data.
 
+        verbose : int, optional (default=1)
+            Verbosity mode.
+
         random_state : random_state: int, RandomState instance or None, optional
             (default=None)
             If int, random_state is the seed used by the random
@@ -230,19 +249,27 @@ class DeepSVDD(BaseDetector):
             ``decision_scores_``. The threshold is calculated for generating
             binary outlier labels.
 
-        labels_ : int, either 0 or 1
+        labels_ : numpy array of shape (n_samples,)
             The binary labels of the training data. 0 stands for inliers
             and 1 for outliers/anomalies. It is generated by applying
             ``threshold_`` on ``decision_scores_``.
+
+        c_ : torch tensor of shape (output_width,)
+            The fitted hypersphere center actually used by the training
+            objective and by ``decision_function``. Either the center
+            initialized from the data (when ``c`` is None) or a validated
+            copy of the user-supplied ``c``.
         """
 
     def __init__(self, n_features, c=None, use_ae=False, hidden_neurons=None,
                  hidden_activation='relu',
                  output_activation='sigmoid', optimizer='adam', epochs=100,
                  batch_size=32,
-                 dropout_rate=0.2, l2_regularizer=0.1, validation_size=0.1,
+                 dropout_rate=0.2, l2_regularizer=0.5e-6,
+                 validation_size=0.1,
                  preprocessing=True,
-                 verbose=1, random_state=None, contamination=0.1):
+                 verbose=1, random_state=None, contamination=0.1,
+                 learning_rate=1e-4):
         super(DeepSVDD, self).__init__(contamination=contamination)
 
         self.n_features = n_features
@@ -252,6 +279,7 @@ class DeepSVDD(BaseDetector):
         self.hidden_activation = hidden_activation
         self.output_activation = output_activation
         self.optimizer = optimizer
+        self.learning_rate = learning_rate
         self.epochs = epochs
         self.batch_size = batch_size
         self.dropout_rate = dropout_rate
@@ -315,9 +343,40 @@ class DeepSVDD(BaseDetector):
                                     dropout_rate=self.dropout_rate,
                                     l2_regularizer=self.l2_regularizer)
         X_norm = torch.tensor(X_norm, dtype=torch.float32)
+        # ``c`` is a constructor parameter and must stay untouched so that
+        # get_params/clone round-trip and a refit re-initializes the center
+        # for the freshly built network. The fitted center lives in ``c_``.
         if self.c is None:
-            self.c = 0.0
-            self.model_._init_c(X_norm)
+            center = self.model_._init_c(X_norm)
+        else:
+            center = torch.as_tensor(self.c, dtype=X_norm.dtype,
+                                     device=X_norm.device)
+
+        # The center must match the width of whatever ``forward()`` returns:
+        # the decoder reconstruction under use_ae, else the final embedding.
+        output_width = (self.n_features if self.use_ae
+                        else self.hidden_neurons[-1])
+        if center.ndim == 0:
+            center = center.repeat(output_width)
+        elif center.ndim != 1 or center.numel() != output_width:
+            raise ValueError(
+                f'DeepSVDD: c must be a scalar or a vector of length '
+                f'{output_width}, got shape {tuple(center.shape)}.')
+        if not torch.isfinite(center).all():
+            raise ValueError('DeepSVDD: c must contain only finite values.')
+        if not torch.any(center != 0):
+            # An all-zero center is the trivial solution of the Deep SVDD
+            # objective for a bias-free network (Ruff et al., ICML 2018,
+            # Proposition 1): all-zero weights map every input to it, so
+            # training would converge to a collapsed hypersphere.
+            raise ValueError(
+                'DeepSVDD: the hypersphere center is all zeros, which makes '
+                'the trivial all-zero-weights solution optimal and collapses '
+                'the hypersphere. Pass c=None to initialize the center from '
+                'the data, or supply a non-zero center.')
+        # clone() so a mutable user-supplied array/tensor cannot alias (and
+        # later mutate) the fitted center.
+        self.c_ = center.detach().clone()
 
         # Predict on X itself and calculate the reconstruction error as
         # the outlier scores. Noted X_norm was shuffled has to recreate
@@ -334,32 +393,43 @@ class DeepSVDD(BaseDetector):
         best_loss = float('inf')
         best_model_dict = None
 
-        optimizer = optimizer_dict[self.optimizer](self.model_.parameters(),
-                                                   weight_decay=self.l2_regularizer)
-        w_d = 1e-6 * sum(
-            [torch.linalg.norm(w) for w in self.model_.parameters()])
-
+        optimizer = optimizer_dict[self.optimizer](
+            self.model_.parameters(), lr=self.learning_rate,
+            weight_decay=self.l2_regularizer)
         for epoch in range(self.epochs):
             self.model_.train()
             epoch_loss = 0
             for batch_x, _ in dataloader:
                 optimizer.zero_grad()
                 outputs = self.model_(batch_x)
-                dist = torch.sum((outputs - self.c) ** 2, dim=-1)
+                dist = torch.sum((outputs - self.c_) ** 2, dim=-1)
+                # L2 regularization term, recomputed every step so that it
+                # is part of the current batch's computation graph
+                w_d = 1e-6 * sum(
+                    [torch.linalg.norm(w) for w in self.model_.parameters()])
                 if self.use_ae:
                     loss = torch.mean(dist) + w_d + torch.mean(
                         torch.square(outputs - batch_x))
                 else:
                     loss = torch.mean(dist) + w_d
 
-                # loss.backward()
+                loss.backward()
                 optimizer.step()
                 epoch_loss += loss.item()
-                if epoch_loss < best_loss:
-                    best_loss = epoch_loss
-                    best_model_dict = self.model_.state_dict()
+            # keep the best performing model across epochs (epoch_loss is the
+            # accumulated loss over the whole epoch, so this must run after
+            # the batch loop, not inside it)
+            if epoch_loss < best_loss:
+                best_loss = epoch_loss
+                # state_dict() returns references to the live parameters, so
+                # a later optimizer.step() would mutate this snapshot in
+                # place and leave the final weights here instead of the best
+                # ones. Copy it.
+                best_model_dict = copy.deepcopy(self.model_.state_dict())
             print(f"Epoch {epoch + 1}/{self.epochs}, Loss: {epoch_loss}")
         self.best_model_dict = best_model_dict
+        if self.best_model_dict is not None:
+            self.model_.load_state_dict(self.best_model_dict)
 
         self.decision_scores_ = self.decision_function(X)
         self._process_decision_scores()
@@ -394,6 +464,6 @@ class DeepSVDD(BaseDetector):
         self.model_.eval()
         with torch.no_grad():
             outputs = self.model_(X_norm)
-            dist = torch.sum((outputs - self.c) ** 2, dim=-1)
+            dist = torch.sum((outputs - self.c_) ** 2, dim=-1)
         anomaly_scores = dist.numpy()
         return anomaly_scores