wandb 0.18.2__py3-none-musllinux_1_2_x86_64.whl

wandb/integration/sklearn/plot/classifier.py

@@ -0,0 +1,329 @@
+"""Define plots for classification models built with scikit-learn."""
+
+from warnings import simplefilter
+
+import numpy as np
+from sklearn import naive_bayes
+
+import wandb
+import wandb.plot
+from wandb.integration.sklearn import calculate, utils
+
+from . import shared
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def classifier(
+    model,
+    X_train,  # noqa: N803
+    X_test,  # noqa: N803
+    y_train,
+    y_test,
+    y_pred,
+    y_probas,
+    labels,
+    is_binary=False,
+    model_name="Classifier",
+    feature_names=None,
+    log_learning_curve=False,
+):
+    """Generate all sklearn classifier plots supported by W&B.
+
+    The following plots are generated:
+        feature importances, confusion matrix, summary metrics,
+        class proportions, calibration curve, roc curve, precision-recall curve.
+
+    Should only be called with a fitted classifier (otherwise an error is thrown).
+
+    Arguments:
+        model: (classifier) Takes in a fitted classifier.
+        X_train: (arr) Training set features.
+        y_train: (arr) Training set labels.
+        X_test: (arr) Test set features.
+        y_test: (arr) Test set labels.
+        y_pred: (arr) Test set predictions by the model passed.
+        y_probas: (arr) Test set predicted probabilities by the model passed.
+        labels: (list) Named labels for target variable (y). Makes plots easier to
+                        read by replacing target values with corresponding index.
+                        For example if `labels=['dog', 'cat', 'owl']` all 0s are
+                        replaced by dog, 1s by cat.
+        is_binary: (bool) Is the model passed a binary classifier? Defaults to False
+        model_name: (str) Model name. Defaults to 'Classifier'
+        feature_names: (list) Names for features. Makes plots easier to read by
+                                replacing feature indexes with corresponding names.
+        log_learning_curve: (bool) Whether or not to log the learning curve.
+                                    Defaults to False.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+            under 'auto visualizations'.
+
+    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.termlog(f"\nPlotting {model_name}.")
+
+    if not isinstance(model, naive_bayes.MultinomialNB):
+        feature_importances(model, feature_names)
+        wandb.termlog("Logged feature importances.")
+
+    if log_learning_curve:
+        shared.learning_curve(model, X_train, y_train)
+        wandb.termlog("Logged learning curve.")
+
+    confusion_matrix(y_test, y_pred, labels)
+    wandb.termlog("Logged confusion matrix.")
+
+    shared.summary_metrics(model, X=X_train, y=y_train, X_test=X_test, y_test=y_test)
+    wandb.termlog("Logged summary metrics.")
+
+    class_proportions(y_train, y_test, labels)
+    wandb.termlog("Logged class proportions.")
+
+    if not isinstance(model, naive_bayes.MultinomialNB):
+        calibration_curve(model, X_train, y_train, model_name)
+        wandb.termlog("Logged calibration curve.")
+
+    roc(y_test, y_probas, labels)
+    wandb.termlog("Logged roc curve.")
+
+    precision_recall(y_test, y_probas, labels)
+    wandb.termlog("Logged precision-recall curve.")
+
+
+def roc(
+    y_true=None,
+    y_probas=None,
+    labels=None,
+    plot_micro=True,
+    plot_macro=True,
+    classes_to_plot=None,
+):
+    """Log the receiver-operating characteristic curve.
+
+    Arguments:
+        y_true: (arr) Test set labels.
+        y_probas: (arr) Test set predicted probabilities.
+        labels: (list) Named labels for target variable (y). Makes plots easier to
+                       read by replacing target values with corresponding index.
+                       For example if `labels=['dog', 'cat', 'owl']` all 0s are
+                       replaced by dog, 1s by cat.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_roc(y_true, y_probas, labels)
+    ```
+    """
+    roc_chart = wandb.plot.roc_curve(y_true, y_probas, labels, classes_to_plot)
+    wandb.log({"roc": roc_chart})
+
+
+def confusion_matrix(
+    y_true=None,
+    y_pred=None,
+    labels=None,
+    true_labels=None,
+    pred_labels=None,
+    normalize=False,
+):
+    """Log a confusion matrix to W&B.
+
+    Confusion matrices depict the pattern of misclassifications by a model.
+
+    Arguments:
+        y_true: (arr) Test set labels.
+        y_probas: (arr) Test set predicted probabilities.
+        labels: (list) Named labels for target variable (y). Makes plots easier to
+                       read by replacing target values with corresponding index.
+                       For example if `labels=['dog', 'cat', 'owl']` all 0s are
+                       replaced by dog, 1s by cat.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_confusion_matrix(y_true, y_probas, labels)
+    ```
+    """
+    y_true = np.asarray(y_true)
+    y_pred = np.asarray(y_pred)
+
+    not_missing = utils.test_missing(y_true=y_true, y_pred=y_pred)
+    correct_types = utils.test_types(y_true=y_true, y_pred=y_pred)
+
+    if not_missing and correct_types:
+        confusion_matrix_chart = calculate.confusion_matrix(
+            y_true,
+            y_pred,
+            labels,
+            true_labels,
+            pred_labels,
+            normalize,
+        )
+
+        wandb.log({"confusion_matrix": confusion_matrix_chart})
+
+
+def precision_recall(
+    y_true=None, y_probas=None, labels=None, plot_micro=True, classes_to_plot=None
+):
+    """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.
+
+    Arguments:
+        y_true: (arr) Test set labels.
+        y_probas: (arr) Test set predicted probabilities.
+        labels: (list) Named labels for target variable (y). Makes plots easier to
+                       read by replacing target values with corresponding index.
+                       For example if `labels=['dog', 'cat', 'owl']` all 0s are
+                       replaced by dog, 1s by cat.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_precision_recall(y_true, y_probas, labels)
+    ```
+    """
+    precision_recall_chart = wandb.plot.pr_curve(
+        y_true, y_probas, labels, classes_to_plot
+    )
+
+    wandb.log({"precision_recall": precision_recall_chart})
+
+
+def feature_importances(
+    model=None, feature_names=None, title="Feature Importance", max_num_features=50
+):
+    """Log a plot depicting the relative importance of each feature for a classifier's decisions.
+
+    Should only be called with a fitted classifier (otherwise an error is thrown).
+    Only works with classifiers that have a feature_importances_ attribute, like trees.
+
+    Arguments:
+        model: (clf) Takes in a fitted classifier.
+        feature_names: (list) Names for features. Makes plots easier to read by
+                              replacing feature indexes with corresponding names.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_feature_importances(model, ["width", "height", "length"])
+    ```
+    """
+    not_missing = utils.test_missing(model=model)
+    correct_types = utils.test_types(model=model)
+    model_fitted = utils.test_fitted(model)
+
+    if not_missing and correct_types and model_fitted:
+        feature_importance_chart = calculate.feature_importances(model, feature_names)
+        wandb.log({"feature_importances": feature_importance_chart})
+
+
+def class_proportions(y_train=None, y_test=None, labels=None):
+    """Plot the distribution of target classes in training and test sets.
+
+    Useful for detecting imbalanced classes.
+
+    Arguments:
+        y_train: (arr) Training set labels.
+        y_test: (arr) Test set labels.
+        labels: (list) Named labels for target variable (y). Makes plots easier to
+                       read by replacing target values with corresponding index.
+                       For example if `labels=['dog', 'cat', 'owl']` all 0s are
+                       replaced by dog, 1s by cat.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    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)
+
+        wandb.log({"class_proportions": class_proportions_chart})
+
+
+def calibration_curve(clf=None, X=None, y=None, clf_name="Classifier"):  # noqa: N803
+    """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
+    an argument, and by both its isotonic calibration and sigmoid calibrations.
+    The closer the calibration curves are to a diagonal the better.
+    A sine wave like curve represents an overfitted classifier, while a cosine
+    wave like curve represents an underfitted classifier.
+    By training isotonic and sigmoid calibrations of the model and comparing
+    their curves we can figure out whether the model is over or underfitting and
+    if so which calibration (sigmoid or isotonic) might help fix this.
+    For more details, see https://scikit-learn.org/stable/auto_examples/calibration/plot_calibration_curve.html.
+
+    Should only be called with a fitted classifier (otherwise an error is thrown).
+
+    Please note this function fits variations of the model on the training set when called.
+
+    Arguments:
+        clf: (clf) Takes in a fitted classifier.
+        X: (arr) Training set features.
+        y: (arr) Training set labels.
+        model_name: (str) Model name. Defaults to 'Classifier'
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_calibration_curve(clf, X, y, "RandomForestClassifier")
+    ```
+    """
+    not_missing = utils.test_missing(clf=clf, X=X, y=y)
+    correct_types = utils.test_types(clf=clf, X=X, y=y)
+    is_fitted = utils.test_fitted(clf)
+    if not_missing and correct_types and is_fitted:
+        y = np.asarray(y)
+        if y.dtype.char == "U" or not ((y == 0) | (y == 1)).all():
+            wandb.termwarn(
+                "This function only supports binary classification at the moment and therefore expects labels to be binary. Skipping calibration curve."
+            )
+            return
+
+        calibration_curve_chart = calculate.calibration_curves(clf, X, y, clf_name)
+
+        wandb.log({"calibration_curve": calibration_curve_chart})

wandb/integration/sklearn/plot/clusterer.py

@@ -0,0 +1,146 @@
+"""Define plots for clustering models built with scikit-learn."""
+
+from warnings import simplefilter
+
+import pandas as pd
+import sklearn
+
+import wandb
+from wandb.integration.sklearn import calculate, utils
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def clusterer(model, X_train, cluster_labels, labels=None, model_name="Clusterer"):  # noqa: N803
+    """Generates all sklearn clusterer plots supported by W&B.
+
+    The following plots are generated:
+        elbow curve, silhouette plot.
+
+    Should only be called with a fitted clusterer (otherwise an error is thrown).
+
+    Arguments:
+        model: (clusterer) Takes in a fitted clusterer.
+        X_train: (arr) Training set features.
+        cluster_labels: (list) Names for cluster labels. Makes plots easier to read
+                            by replacing cluster indexes with corresponding names.
+        labels: (list) Named labels for target variable (y). Makes plots easier to
+                        read by replacing target values with corresponding index.
+                        For example if `labels=['dog', 'cat', 'owl']` all 0s are
+                        replaced by dog, 1s by cat.
+        model_name: (str) Model name. Defaults to 'Clusterer'
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_clusterer(kmeans, X, cluster_labels, labels, "KMeans")
+    ```
+    """
+    wandb.termlog(f"\nPlotting {model_name}.")
+    if isinstance(model, sklearn.cluster.KMeans):
+        elbow_curve(model, X_train)
+        wandb.termlog("Logged elbow curve.")
+
+        silhouette(model, X_train, cluster_labels, labels=labels, kmeans=True)
+
+    else:
+        silhouette(model, X_train, cluster_labels, kmeans=False)
+
+    wandb.termlog("Logged silhouette plot.")
+
+
+def elbow_curve(
+    clusterer=None,
+    X=None,  # noqa: N803
+    cluster_ranges=None,
+    n_jobs=1,
+    show_cluster_time=True,
+):
+    """Measures and plots variance explained as a function of the number of clusters.
+
+    Useful in picking the optimal number of clusters.
+
+    Should only be called with a fitted clusterer (otherwise an error is thrown).
+
+    Please note this function fits the model on the training set when called.
+
+    Arguments:
+        model: (clusterer) Takes in a fitted clusterer.
+        X: (arr) Training set features.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_elbow_curve(model, X_train)
+    ```
+    """
+    if not hasattr(clusterer, "n_clusters"):
+        wandb.termlog(
+            "n_clusters attribute not in classifier. Cannot plot elbow method."
+        )
+        return
+
+    not_missing = utils.test_missing(clusterer=clusterer)
+    correct_types = utils.test_types
+    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
+        )
+
+        wandb.log({"elbow_curve": elbow_curve_chart})
+
+
+def silhouette(
+    clusterer=None,
+    X=None,  # noqa: N803
+    cluster_labels=None,
+    labels=None,
+    metric="euclidean",
+    kmeans=True,
+):
+    """Measures & plots silhouette coefficients.
+
+    Silhouette coefficients near +1 indicate that the sample is far away from
+    the neighboring clusters. A value near 0 indicates that the sample is on or
+    very close to the decision boundary between two neighboring clusters and
+    negative values indicate that the samples might have been assigned to the wrong cluster.
+
+    Should only be called with a fitted clusterer (otherwise an error is thrown).
+
+    Please note this function fits the model on the training set when called.
+
+    Arguments:
+        model: (clusterer) Takes in a fitted clusterer.
+        X: (arr) Training set features.
+        cluster_labels: (list) Names for cluster labels. Makes plots easier to read
+                               by replacing cluster indexes with corresponding names.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_silhouette(model, X_train, ["spam", "not spam"])
+    ```
+    """
+    not_missing = utils.test_missing(clusterer=clusterer)
+    correct_types = utils.test_types(clusterer=clusterer)
+    is_fitted = utils.test_fitted(clusterer)
+
+    if not_missing and correct_types and is_fitted:
+        if isinstance(X, (pd.DataFrame)):
+            X = X.values  # noqa: N806
+        silhouette_chart = calculate.silhouette(
+            clusterer, X, cluster_labels, labels, metric, kmeans
+        )
+        wandb.log({"silhouette_plot": silhouette_chart})

wandb/integration/sklearn/plot/regressor.py

@@ -0,0 +1,121 @@
+"""Define plots for regression models built with scikit-learn."""
+
+from warnings import simplefilter
+
+import numpy as np
+
+import wandb
+from wandb.integration.sklearn import calculate, utils
+
+from . import shared
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def regressor(model, X_train, X_test, y_train, y_test, model_name="Regressor"):  # noqa: N803
+    """Generates all sklearn regressor plots supported by W&B.
+
+    The following plots are generated:
+        learning curve, summary metrics, residuals plot, outlier candidates.
+
+    Should only be called with a fitted regressor (otherwise an error is thrown).
+
+    Arguments:
+        model: (regressor) Takes in a fitted regressor.
+        X_train: (arr) Training set features.
+        y_train: (arr) Training set labels.
+        X_test: (arr) Test set features.
+        y_test: (arr) Test set labels.
+        model_name: (str) Model name. Defaults to 'Regressor'
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+            under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, "Ridge")
+    ```
+    """
+    wandb.termlog(f"\nPlotting {model_name}.")
+
+    shared.summary_metrics(model, X_train, y_train, X_test, y_test)
+    wandb.termlog("Logged summary metrics.")
+
+    shared.learning_curve(model, X_train, y_train)
+    wandb.termlog("Logged learning curve.")
+
+    outlier_candidates(model, X_train, y_train)
+    wandb.termlog("Logged outlier candidates.")
+
+    residuals(model, X_train, y_train)
+    wandb.termlog("Logged residuals.")
+
+
+def outlier_candidates(regressor=None, X=None, y=None):  # noqa: N803
+    """Measures a datapoint's influence on regression model via cook's distance.
+
+    Instances with high influences could potentially be outliers.
+
+    Should only be called with a fitted regressor (otherwise an error is thrown).
+
+    Please note this function fits the model on the training set when called.
+
+    Arguments:
+        model: (regressor) Takes in a fitted regressor.
+        X: (arr) Training set features.
+        y: (arr) Training set labels.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_outlier_candidates(model, X, y)
+    ```
+    """
+    is_missing = utils.test_missing(regressor=regressor, X=X, y=y)
+    correct_types = utils.test_types(regressor=regressor, X=X, y=y)
+    is_fitted = utils.test_fitted(regressor)
+
+    if is_missing and correct_types and is_fitted:
+        y = np.asarray(y)
+
+        outliers_chart = calculate.outlier_candidates(regressor, X, y)
+        wandb.log({"outlier_candidates": outliers_chart})
+
+
+def residuals(regressor=None, X=None, y=None):  # noqa: N803
+    """Measures and plots the regressor's predicted value against the residual.
+
+    The marginal distribution of residuals is also calculated and plotted.
+
+    Should only be called with a fitted regressor (otherwise an error is thrown).
+
+    Please note this function fits variations of the model on the training set when called.
+
+    Arguments:
+        regressor: (regressor) Takes in a fitted regressor.
+        X: (arr) Training set features.
+        y: (arr) Training set labels.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_residuals(model, X, y)
+    ```
+    """
+    not_missing = utils.test_missing(regressor=regressor, X=X, y=y)
+    correct_types = utils.test_types(regressor=regressor, X=X, y=y)
+    is_fitted = utils.test_fitted(regressor)
+
+    if not_missing and correct_types and is_fitted:
+        y = np.asarray(y)
+
+        residuals_chart = calculate.residuals(regressor, X, y)
+        wandb.log({"residuals": residuals_chart})

wandb/integration/sklearn/plot/shared.py

@@ -0,0 +1,91 @@
+"""Define plots used by multiple sklearn model classes."""
+
+from warnings import simplefilter
+
+import numpy as np
+
+import wandb
+from wandb.integration.sklearn import calculate, utils
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def summary_metrics(model=None, X=None, y=None, X_test=None, y_test=None):  # noqa: N803
+    """Logs a chart depicting summary metrics for a model.
+
+    Should only be called with a fitted model (otherwise an error is thrown).
+
+    Arguments:
+        model: (clf or reg) Takes in a fitted regressor or classifier.
+        X: (arr) Training set features.
+        y: (arr) Training set labels.
+        X_test: (arr) Test set features.
+        y_test: (arr) Test set labels.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_summary_metrics(model, X_train, y_train, X_test, y_test)
+    ```
+    """
+    not_missing = utils.test_missing(
+        model=model, X=X, y=y, X_test=X_test, y_test=y_test
+    )
+    correct_types = utils.test_types(
+        model=model, X=X, y=y, X_test=X_test, y_test=y_test
+    )
+    model_fitted = utils.test_fitted(model)
+
+    if not_missing and correct_types and model_fitted:
+        metrics_chart = calculate.summary_metrics(model, X, y, X_test, y_test)
+        wandb.log({"summary_metrics": metrics_chart})
+
+
+def learning_curve(
+    model=None,
+    X=None,  # noqa: N803
+    y=None,
+    cv=None,
+    shuffle=False,
+    random_state=None,
+    train_sizes=None,
+    n_jobs=1,
+    scoring=None,
+):
+    """Logs a plot depicting model performance against dataset size.
+
+    Please note this function fits the model to datasets of varying sizes when called.
+
+    Arguments:
+        model: (clf or reg) Takes in a fitted regressor or classifier.
+        X: (arr) Dataset features.
+        y: (arr) Dataset labels.
+
+    For details on the other keyword arguments, see the documentation for
+    `sklearn.model_selection.learning_curve`.
+
+    Returns:
+        None: To see plots, go to your W&B run page then expand the 'media' tab
+              under 'auto visualizations'.
+
+    Example:
+    ```python
+    wandb.sklearn.plot_learning_curve(model, X, y)
+    ```
+    """
+    not_missing = utils.test_missing(model=model, X=X, y=y)
+    correct_types = utils.test_types(model=model, X=X, y=y)
+    if not_missing and correct_types:
+        if train_sizes is None:
+            train_sizes = np.linspace(0.1, 1.0, 5)
+        y = np.asarray(y)
+
+        learning_curve_chart = calculate.learning_curve(
+            model, X, y, cv, shuffle, random_state, train_sizes, n_jobs, scoring
+        )
+
+        wandb.log({"learning_curve": learning_curve_chart})