wandb 0.13.10__py3-none-any.whl → 0.14.0__py3-none-any.whl

wandb/sdk/wandb_setup.py

@@ -15,18 +15,25 @@ import logging
 import os
 import sys
 import threading
-from typing import Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import wandb
 
 from . import wandb_manager, wandb_settings
 from .lib import config_util, server, tracelog
 
+Settings = Union["wandb.sdk.wandb_settings.Settings", Dict[str, Any]]
+
+Logger = Union[logging.Logger, "_EarlyLogger"]
+
+if TYPE_CHECKING:
+    from . import wandb_run
+
 # logger will be configured to be either a standard logger instance or _EarlyLogger
-logger = None
+logger: Optional[Logger] = None
 
 
-def _set_logger(log_object):
+def _set_logger(log_object: Logger) -> None:
     """Configure module logger."""
     global logger
     logger = log_object
@@ -35,35 +42,36 @@ def _set_logger(log_object):
 class _EarlyLogger:
     """Early logger which captures logs in memory until logging can be configured."""
 
-    def __init__(self):
-        self._log = []
-        self._exception = []
+    def __init__(self) -> None:
+        self._log: List[tuple] = []
+        self._exception: List[tuple] = []
         # support old warn() as alias of warning()
         self.warn = self.warning
 
-    def debug(self, msg, *args, **kwargs):
+    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((logging.DEBUG, msg, args, kwargs))
 
-    def info(self, msg, *args, **kwargs):
+    def info(self, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((logging.INFO, msg, args, kwargs))
 
-    def warning(self, msg, *args, **kwargs):
+    def warning(self, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((logging.WARNING, msg, args, kwargs))
 
-    def error(self, msg, *args, **kwargs):
+    def error(self, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((logging.ERROR, msg, args, kwargs))
 
-    def critical(self, msg, *args, **kwargs):
+    def critical(self, msg: str, *args: Any, **kwargs: Any) -> None:
         self._log.append((logging.CRITICAL, msg, args, kwargs))
 
-    def exception(self, msg, *args, **kwargs):
-        self._exception.append(msg, args, kwargs)
+    def exception(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._exception.append((msg, args, kwargs))
 
-    def log(self, level, msg, *args, **kwargs):
-        self._log.append(level, msg, args, kwargs)
+    def log(self, level: str, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log.append((level, msg, args, kwargs))
 
-    def _flush(self):
+    def _flush(self) -> None:
         assert self is not logger
+        assert logger is not None
         for level, msg, args, kwargs in self._log:
             logger.log(level, msg, *args, **kwargs)
         for msg, args, kwargs in self._exception:
@@ -79,18 +87,18 @@ class _WandbSetup__WandbSetup:  # noqa: N801
     def __init__(
         self,
         pid: int,
-        settings: Union["wandb_settings.Settings", Dict[str, Any], None] = None,
+        settings: Optional[Settings] = None,
         environ: Optional[Dict[str, Any]] = None,
-    ):
+    ) -> None:
         self._environ = environ or dict(os.environ)
-        self._sweep_config = None
-        self._config = None
-        self._server = None
-        self._manager = None
+        self._sweep_config: Optional[Dict[str, Any]] = None
+        self._config: Optional[Dict[str, Any]] = None
+        self._server: Optional[server.Server] = None
+        self._manager: Optional[wandb_manager._Manager] = None
         self._pid = pid
 
         # keep track of multiple runs, so we can unwind with join()s
-        self._global_run_stack = []
+        self._global_run_stack: List["wandb_run.Run"] = []
 
         # TODO(jhr): defer strict checks until settings are fully initialized
         #            and logging is ready
@@ -111,9 +119,9 @@ class _WandbSetup__WandbSetup:  # noqa: N801
 
     def _settings_setup(
         self,
-        settings: Union["wandb_settings.Settings", Dict[str, Any], None] = None,
+        settings: Optional[Settings] = None,
         early_logger: Optional[_EarlyLogger] = None,
-    ):
+    ) -> "wandb_settings.Settings":
         s = wandb_settings.Settings()
         s._apply_base(pid=self._pid, _logger=early_logger)
         s._apply_config_files(_logger=early_logger)
@@ -132,7 +140,8 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         return s
 
     def _update(
-        self, settings: Union["wandb_settings.Settings", Dict[str, Any], None] = None
+        self,
+        settings: Optional[Settings] = None,
     ) -> None:
         if settings is None:
             return
@@ -145,7 +154,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             self._settings.update(settings, source=wandb_settings.Source.SETUP)
         # self._settings.freeze()
 
-    def _update_user_settings(self, settings=None):
+    def _update_user_settings(self, settings: Optional[Settings] = None) -> None:
         settings = settings or self._settings
         # Get rid of cached results to force a refresh.
         self._server = None
@@ -155,18 +164,18 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             self._settings._apply_user(user_settings)
             # self._settings.freeze()
 
-    def _early_logger_flush(self, new_logger):
+    def _early_logger_flush(self, new_logger: Logger) -> None:
         if not self._early_logger:
             return
         _set_logger(new_logger)
         # self._settings._clear_early_logger()
         self._early_logger._flush()
 
-    def _get_logger(self):
+    def _get_logger(self) -> Optional[Logger]:
         return logger
 
     @property
-    def settings(self):
+    def settings(self) -> "wandb_settings.Settings":
         return self._settings
 
     def _get_entity(self) -> Optional[str]:
@@ -174,6 +183,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             return None
         if self._server is None:
             self._load_viewer()
+        assert self._server is not None
         entity = self._server._viewer.get("entity")
         return entity
 
@@ -182,27 +192,33 @@ class _WandbSetup__WandbSetup:  # noqa: N801
             return None
         if self._server is None:
             self._load_viewer()
+        assert self._server is not None
         username = self._server._viewer.get("username")
         return username
 
     def _get_teams(self) -> List[str]:
         if self._settings and self._settings._offline:
-            return None
+            return []
         if self._server is None:
             self._load_viewer()
+        assert self._server is not None
         teams = self._server._viewer.get("teams")
         if teams:
             teams = [team["node"]["name"] for team in teams["edges"]]
         return teams or []
 
-    def _load_viewer(self, settings=None) -> None:
+    def _load_viewer(self, settings: Optional[Settings] = None) -> None:
         if self._settings and self._settings._offline:
             return
+        if isinstance(settings, dict):
+            settings = wandb_settings.Settings(**settings)
         s = server.Server(settings=settings)
         s.query_with_timeout()
         self._server = s
 
-    def _load_user_settings(self, settings=None) -> Optional[Dict[str, Any]]:
+    def _load_user_settings(
+        self, settings: Optional[Settings] = None
+    ) -> Optional[Dict[str, Any]]:
         if self._server is None:
             self._load_viewer(settings=settings)
 
@@ -221,7 +237,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
 
         return user_settings
 
-    def _check(self):
+    def _check(self) -> None:
         if hasattr(threading, "main_thread"):
             if threading.current_thread() is not threading.main_thread():
                 pass
@@ -230,7 +246,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         if getattr(sys, "frozen", False):
             print("frozen, could be trouble")
 
-    def _setup(self):
+    def _setup(self) -> None:
         self._setup_manager()
 
         sweep_path = self._settings.sweep_param_path
@@ -242,8 +258,7 @@ class _WandbSetup__WandbSetup:  # noqa: N801
         # if config_paths was set, read in config dict
         if self._settings.config_paths:
             # TODO(jhr): handle load errors, handle list of files
-            config_paths = self._settings.config_paths.split(",")
-            for config_path in config_paths:
+            for config_path in self._settings.config_paths:
                 config_dict = config_util.dict_from_config_file(config_path)
                 if config_dict is None:
                     continue
@@ -252,12 +267,12 @@ class _WandbSetup__WandbSetup:  # noqa: N801
                 else:
                     self._config = config_dict
 
-    def _teardown(self, exit_code: Optional[int] = None):
+    def _teardown(self, exit_code: Optional[int] = None) -> None:
         exit_code = exit_code or 0
         self._teardown_manager(exit_code=exit_code)
 
     def _setup_manager(self) -> None:
-        if not self._settings._require_service:
+        if self._settings._disable_service:
             return
         self._manager = wandb_manager._Manager(settings=self._settings)
 
@@ -280,35 +295,40 @@ class _WandbSetup:
 
     _instance: Optional["_WandbSetup__WandbSetup"] = None
 
-    def __init__(self, settings=None) -> None:
+    def __init__(self, settings: Optional[Settings] = None) -> None:
         pid = os.getpid()
         if _WandbSetup._instance and _WandbSetup._instance._pid == pid:
             _WandbSetup._instance._update(settings=settings)
             return
         _WandbSetup._instance = _WandbSetup__WandbSetup(settings=settings, pid=pid)
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         return getattr(self._instance, name)
 
 
-def _setup(settings=None, _reset: bool = False) -> Optional["_WandbSetup"]:
-    """Setup library context."""
+def _setup(
+    settings: Optional[Settings] = None,
+    _reset: bool = False,
+) -> Optional["_WandbSetup"]:
+    """Set up library context."""
     if _reset:
         setup_instance = _WandbSetup._instance
         if setup_instance:
             setup_instance._teardown()
         _WandbSetup._instance = None
-        return
+        return None
     wl = _WandbSetup(settings=settings)
     return wl
 
 
-def setup(settings=None) -> Optional["_WandbSetup"]:
+def setup(
+    settings: Optional[Settings] = None,
+) -> Optional["_WandbSetup"]:
     ret = _setup(settings=settings)
     return ret
 
 
-def teardown(exit_code=None):
+def teardown(exit_code: Optional[int] = None) -> None:
     setup_instance = _WandbSetup._instance
     if setup_instance:
         setup_instance._teardown(exit_code=exit_code)

wandb/sdk/wandb_summary.py

@@ -12,8 +12,10 @@ def _get_dict(d):
 
 
 class SummaryDict(metaclass=abc.ABCMeta):
-    """dict-like which wraps all nested dictionaries in a SummarySubDict,
-    and triggers self._root._callback on property changes."""
+    """dict-like wrapper for the nested dictionaries in a SummarySubDict.
+
+    Triggers self._root._callback on property changes.
+    """
 
     @abc.abstractmethod
     def _as_dict(self):
@@ -73,8 +75,7 @@ class SummaryDict(metaclass=abc.ABCMeta):
 
 
 class Summary(SummaryDict):
-    """
-    Tracks single values for each metric for each run.
+    """Track single values for each metric for each run.
 
     By default, a metric's summary is the last value of its History.
 
@@ -99,10 +100,10 @@ class Summary(SummaryDict):
 
         best_accuracy = 0
         for epoch in range(1, args.epochs + 1):
-        test_loss, test_accuracy = test()
-        if (test_accuracy > best_accuracy):
-            wandb.run.summary["best_accuracy"] = test_accuracy
-            best_accuracy = test_accuracy
+            test_loss, test_accuracy = test()
+            if test_accuracy > best_accuracy:
+                wandb.run.summary["best_accuracy"] = test_accuracy
+                best_accuracy = test_accuracy
         ```
     """
 
@@ -128,8 +129,10 @@ class Summary(SummaryDict):
 
 
 class SummarySubDict(SummaryDict):
-    """Non-root node of the summary data structure. Contains a path to itself
-    from the root."""
+    """Non-root node of the summary data structure.
+
+    Contains a path to itself from the root.
+    """
 
     _items: t.Dict
     _parent: SummaryDict

wandb/sdk/wandb_sweep.py

@@ -44,7 +44,7 @@ def sweep(
       sweep: dict, SweepConfig, or callable. The sweep configuration
         (or configuration generator). If a dict or SweepConfig,
         should conform to the W&B sweep config specification
-        (https://docs.wandb.ai/guides/sweeps/configuration). If a
+        (https://docs.wandb.ai/guides/sweeps/define-sweep-configuration). If a
         callable, should take no arguments and return a dict that
         conforms to the W&B sweep config spec.
       entity: str (optional). An entity is a username or team name
@@ -67,17 +67,15 @@ def sweep(
         <!--yeadoc-test:one-parameter-sweep-->
         ```python
         import wandb
+
         sweep_configuration = {
             "name": "my-awesome-sweep",
             "metric": {"name": "accuracy", "goal": "maximize"},
             "method": "grid",
-            "parameters": {
-                "a": {
-                    "values": [1, 2, 3, 4]
-                }
-            }
+            "parameters": {"a": {"values": [1, 2, 3, 4]}},
         }
 
+
         def my_train_func():
             # read the current value of parameter "a" from wandb.config
             wandb.init()
@@ -85,13 +83,13 @@ def sweep(
 
             wandb.log({"a": a, "accuracy": a + 1})
 
+
         sweep_id = wandb.sweep(sweep_configuration)
 
         # run the sweep
         wandb.agent(sweep_id, function=my_train_func)
         ```
     """
-
     if callable(sweep):
         sweep = sweep()
     """Sweep create for controller api and jupyter (eventually for cli)."""
@@ -128,6 +126,7 @@ def controller(
     Usage:
         ```python
         import wandb
+
         tuner = wandb.controller(...)
         print(tuner.sweep_config)
         print(tuner.sweep_id)

wandb/sdk/wandb_watch.py

@@ -25,7 +25,7 @@ def watch(
     idx: Optional[int] = None,
     log_graph: bool = False,
 ):
-    """Hooks into the torch model to collect gradients and the topology.
+    """Hook into the torch model to collect gradients and the topology.
 
     Should be extended to accept arbitrary ML models.
 

wandb/sklearn/calculate/confusion_matrix.py

@@ -24,7 +24,7 @@ def confusion_matrix(
     pred_labels=None,
     normalize=False,
 ):
-    """Computes the confusion matrix to evaluate the performance of a classification.
+    """Compute the confusion matrix to evaluate the performance of a classification.
 
     Called by plot_confusion_matrix to visualize roc curves. Please use the function
     plot_confusion_matrix() if you wish to visualize your confusion matrix.

wandb/sklearn/calculate/learning_curve.py

@@ -21,7 +21,7 @@ def learning_curve(
     n_jobs=1,
     scoring=None,
 ):
-    """Trains model on datasets of varying size and generates plot of score vs size.
+    """Train model on datasets of varying size and generates plot of score vs size.
 
     Called by plot_learning_curve to visualize learning curve. Please use the function
     plot_learning_curve() if you wish to visualize your learning curves.

wandb/sklearn/calculate/summary_metrics.py

@@ -11,7 +11,7 @@ simplefilter(action="ignore", category=FutureWarning)
 
 
 def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
-    """Calculates summary metrics for both regressors and classifiers.
+    """Calculate summary metrics for both regressors and classifiers.
 
     Called by plot_summary_metrics to visualize metrics. Please use the function
     plot_summary_metrics() if you wish to visualize your summary metrics.
@@ -23,7 +23,6 @@ def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
     y_pred = model.predict(X_test)
 
     if sklearn.base.is_classifier(model):
-
         accuracy_score = sklearn.metrics.accuracy_score(y_test, y_pred)
         metrics["accuracy_score"] = accuracy_score
 
@@ -37,7 +36,6 @@ def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):
         metrics["f1_score"] = f1_score
 
     elif sklearn.base.is_regressor(model):
-
         mae = sklearn.metrics.mean_absolute_error(y_test, y_pred)
         metrics["mae"] = mae
 

wandb/sklearn/plot/__init__.py

@@ -1,4 +1,4 @@
-"""Creates and logs charts introspecting models built with scikit-learn to W&B."""
+"""Create and logs charts introspecting models built with scikit-learn to W&B."""
 from .classifier import calibration_curve as plot_calibration_curve
 from .classifier import class_proportions as plot_class_proportions
 from .classifier import classifier as plot_classifier

wandb/sklearn/plot/classifier.py

@@ -1,4 +1,4 @@
-"""Defines plots for classification models built with scikit-learn."""
+"""Define plots for classification models built with scikit-learn."""
 from warnings import simplefilter
 
 import numpy as np
@@ -28,7 +28,7 @@ def classifier(
     feature_names=None,
     log_learning_curve=False,
 ):
-    """Generates all sklearn classifier plots supported by W&B.
+    """Generate all sklearn classifier plots supported by W&B.
 
     The following plots are generated:
         feature importances, confusion matrix, summary metrics,
@@ -61,9 +61,19 @@ def classifier(
 
     Example:
     ```python
-        wandb.sklearn.plot_classifier(model, X_train, X_test, y_train, y_test, y_pred, y_probas,
-                                      ['cat', 'dog'], False, RandomForest',
-                                      ['barks', 'drools, 'plays_fetch', 'breed'])
+    wandb.sklearn.plot_classifier(
+        model,
+        X_train,
+        X_test,
+        y_train,
+        y_test,
+        y_pred,
+        y_probas,
+        ["cat", "dog"],
+        False,
+        "RandomForest",
+        ["barks", "drools", "plays_fetch", "breed"],
+    )
     ```
     """
     wandb.termlog("\nPlotting %s." % model_name)
@@ -104,7 +114,7 @@ def roc(
     plot_macro=True,
     classes_to_plot=None,
 ):
-    """Logs the receiver-operating characteristic curve.
+    """Log the receiver-operating characteristic curve.
 
     Arguments:
         y_true: (arr) Test set labels.
@@ -120,7 +130,7 @@ def roc(
 
     Example:
     ```python
-        wandb.sklearn.plot_roc(y_true, y_probas, labels)
+    wandb.sklearn.plot_roc(y_true, y_probas, labels)
     ```
     """
     roc_chart = wandb.plots.roc.roc(
@@ -137,7 +147,7 @@ def confusion_matrix(
     pred_labels=None,
     normalize=False,
 ):
-    """Logs a confusion matrix to W&B.
+    """Log a confusion matrix to W&B.
 
     Confusion matrices depict the pattern of misclassifications by a model.
 
@@ -155,7 +165,7 @@ def confusion_matrix(
 
     Example:
     ```python
-        wandb.sklearn.plot_confusion_matrix(y_true, y_probas, labels)
+    wandb.sklearn.plot_confusion_matrix(y_true, y_probas, labels)
     ```
     """
     y_true = np.asarray(y_true)
@@ -180,7 +190,7 @@ def confusion_matrix(
 def precision_recall(
     y_true=None, y_probas=None, labels=None, plot_micro=True, classes_to_plot=None
 ):
-    """Logs a precision-recall curve to W&B.
+    """Log a precision-recall curve to W&B.
 
     Precision-recall curves depict the tradeoff between positive predictive value (precision)
     and true positive rate (recall) as the threshold of a classifier is shifted.
@@ -199,7 +209,7 @@ def precision_recall(
 
     Example:
     ```python
-        wandb.sklearn.plot_precision_recall(y_true, y_probas, labels)
+    wandb.sklearn.plot_precision_recall(y_true, y_probas, labels)
     ```
     """
     precision_recall_chart = wandb.plots.precision_recall(
@@ -212,7 +222,7 @@ def precision_recall(
 def feature_importances(
     model=None, feature_names=None, title="Feature Importance", max_num_features=50
 ):
-    """Logs a plot depicting the relative importance of each feature for a classifier's decisions.
+    """Log a plot depicting the relative importance of each feature for a classifier's decisions.
 
     Should only be called with a fitted classifer (otherwise an error is thrown).
     Only works with classifiers that have a feature_importances_ attribute, like trees.
@@ -228,7 +238,7 @@ def feature_importances(
 
     Example:
     ```python
-        wandb.sklearn.plot_feature_importances(model, ['width', 'height, 'length'])
+    wandb.sklearn.plot_feature_importances(model, ["width", "height", "length"])
     ```
     """
     not_missing = utils.test_missing(model=model)
@@ -241,7 +251,7 @@ def feature_importances(
 
 
 def class_proportions(y_train=None, y_test=None, labels=None):
-    """Plots the distribution of target classses in training and test sets.
+    """Plot the distribution of target classses in training and test sets.
 
     Useful for detecting imbalanced classes.
 
@@ -259,13 +269,12 @@ def class_proportions(y_train=None, y_test=None, labels=None):
 
     Example:
     ```python
-        wandb.sklearn.plot_class_proportions(y_train, y_test, ['dog', 'cat', 'owl'])
+    wandb.sklearn.plot_class_proportions(y_train, y_test, ["dog", "cat", "owl"])
     ```
     """
     not_missing = utils.test_missing(y_train=y_train, y_test=y_test)
     correct_types = utils.test_types(y_train=y_train, y_test=y_test)
     if not_missing and correct_types:
-
         y_train, y_test = np.array(y_train), np.array(y_test)
         class_proportions_chart = calculate.class_proportions(y_train, y_test, labels)
 
@@ -273,7 +282,7 @@ def class_proportions(y_train=None, y_test=None, labels=None):
 
 
 def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):
-    """Logs a plot depicting how well-calibrated the predicted probabilities of a classifier are.
+    """Log a plot depicting how well-calibrated the predicted probabilities of a classifier are.
 
     Also suggests how to calibrate an uncalibrated classifier. Compares estimated predicted
     probabilities by a baseline logistic regression model, the model passed as
@@ -302,7 +311,7 @@ def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):
 
     Example:
     ```python
-        wandb.sklearn.plot_calibration_curve(clf, X, y, 'RandomForestClassifier')
+    wandb.sklearn.plot_calibration_curve(clf, X, y, "RandomForestClassifier")
     ```
     """
     not_missing = utils.test_missing(clf=clf, X=X, y=y)

wandb/sklearn/plot/clusterer.py

@@ -1,4 +1,4 @@
-"""Defines plots for clustering models built with scikit-learn."""
+"""Define plots for clustering models built with scikit-learn."""
 from warnings import simplefilter
 
 import pandas as pd
@@ -36,7 +36,7 @@ def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer
 
     Example:
     ```python
-        wandb.sklearn.plot_clusterer(kmeans, X, cluster_labels, labels, 'KMeans')
+    wandb.sklearn.plot_clusterer(kmeans, X, cluster_labels, labels, "KMeans")
     ```
     """
     wandb.termlog("\nPlotting %s." % model_name)
@@ -73,7 +73,7 @@ def elbow_curve(
 
     Example:
     ```python
-        wandb.sklearn.plot_elbow_curve(model, X_train)
+    wandb.sklearn.plot_elbow_curve(model, X_train)
     ```
     """
     if not hasattr(clusterer, "n_clusters"):
@@ -87,7 +87,6 @@ def elbow_curve(
     is_fitted = utils.test_fitted(clusterer)
 
     if not_missing and correct_types and is_fitted:
-
         elbow_curve_chart = calculate.elbow_curve(
             clusterer, X, cluster_ranges, n_jobs, show_cluster_time
         )
@@ -126,7 +125,7 @@ def silhouette(
 
     Example:
     ```python
-        wandb.sklearn.plot_silhouette(model, X_train, ['spam', 'not spam'])
+    wandb.sklearn.plot_silhouette(model, X_train, ["spam", "not spam"])
     ```
     """
     not_missing = utils.test_missing(clusterer=clusterer)

wandb/sklearn/plot/regressor.py

@@ -1,4 +1,4 @@
-"""Defines plots for regression models built with scikit-learn."""
+"""Define plots for regression models built with scikit-learn."""
 from warnings import simplefilter
 
 import numpy as np
@@ -34,7 +34,7 @@ def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):
 
     Example:
     ```python
-        wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, 'Ridge')
+    wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, "Ridge")
     ```
     """
     wandb.termlog("\nPlotting %s." % model_name)
@@ -72,7 +72,7 @@ def outlier_candidates(regressor=None, X=None, y=None):
 
     Example:
     ```python
-        wandb.sklearn.plot_outlier_candidates(model, X, y)
+    wandb.sklearn.plot_outlier_candidates(model, X, y)
     ```
     """
     is_missing = utils.test_missing(regressor=regressor, X=X, y=y)
@@ -106,7 +106,7 @@ def residuals(regressor=None, X=None, y=None):
 
     Example:
     ```python
-        wandb.sklearn.plot_residuals(model, X, y)
+    wandb.sklearn.plot_residuals(model, X, y)
     ```
     """
     not_missing = utils.test_missing(regressor=regressor, X=X, y=y)