wandb 0.18.5__py3-none-win_amd64.whl → 0.18.6__py3-none-win_amd64.whl

wandb/plot/roc_curve.py

@@ -1,40 +1,84 @@
-from typing import Optional
+from __future__ import annotations
+
+import numbers
+from typing import TYPE_CHECKING, Sequence
 
 import wandb
 from wandb import util
+from wandb.plot.custom_chart import plot_table
+from wandb.plot.utils import test_missing, test_types
 
-from .utils import test_missing, test_types
+if TYPE_CHECKING:
+    from wandb.plot.custom_chart import CustomChart
 
 
 def roc_curve(
-    y_true=None,
-    y_probas=None,
-    labels=None,
-    classes_to_plot=None,
-    title=None,
-    split_table: Optional[bool] = False,
-):
-    """Calculate and visualize receiver operating characteristic (ROC) scores.
-
-    Arguments:
-        y_true (arr): true sparse labels
-        y_probas (arr): Target scores, can either be probability estimates, confidence
-                         values, or non-thresholded measure of decisions.
-                         shape: (*y_true.shape, num_classes)
-        labels (list): Named labels for target variable (y). Makes plots easier to
-                        read by replacing target values with corresponding index.
-                        For example labels = ['dog', 'cat', 'owl'] all 0s are
-                        replaced by 'dog', 1s by 'cat'.
-        classes_to_plot (list): unique values of y_true to include in the plot
-        split_table (bool): If True, adds "Custom Chart Tables/" to the key of the table so that it's logged in a different section.
+    y_true: Sequence[numbers.Number],
+    y_probas: Sequence[Sequence[float]] | None = None,
+    labels: list[str] | None = None,
+    classes_to_plot: list[numbers.Number] | None = None,
+    title: str = "ROC Curve",
+    split_table: bool = False,
+) -> CustomChart:
+    """Constructs Receiver Operating Characteristic (ROC) curve chart.
+
+    Args:
+        y_true (Sequence[numbers.Number]): The true class labels (ground truth)
+            for the target variable. Shape should be (num_samples,).
+        y_probas (Sequence[Sequence[float]]): The predicted probabilities or
+            decision scores for each class. Shape should be (num_samples, num_classes).
+        labels (list[str]): Human-readable labels corresponding to the class
+            indices in `y_true`. For example, if `labels=['dog', 'cat']`,
+            class 0 will be displayed as 'dog' and class 1 as 'cat' in the plot.
+            If None, the raw class indices from `y_true` will be used.
+            Default is None.
+        classes_to_plot (list[numbers.Number]): A subset of unique class labels
+            to include in the ROC curve. If None, all classes in `y_true` will
+            be plotted. Default is None.
+        title (str): Title of the ROC curve plot. Default is "ROC Curve".
+        split_table (bool): Whether the table should be split into a separate
+            section in the W&B UI. If `True`, the table will be displayed in a
+            section named "Custom Chart Tables". Default is `False`.
 
     Returns:
-        Nothing. To see plots, go to your W&B run page then expand the 'media' tab
-            under 'auto visualizations'.
+        CustomChart: A custom chart object that can be logged to W&B. To log the
+            chart, pass it to `wandb.log()`.
+
+    Raises:
+        wandb.Error: If numpy, pandas, or scikit-learn are not found.
 
     Example:
         ```
-        wandb.log({'roc-curve': wandb.plot.roc_curve(y_true, y_probas, labels)})
+        import numpy as np
+        import wandb
+
+        # Simulate a medical diagnosis classification problem with three diseases
+        n_samples = 200
+        n_classes = 3
+
+        # True labels: assign "Diabetes", "Hypertension", or "Heart Disease" to
+        # each sample
+        disease_labels = ["Diabetes", "Hypertension", "Heart Disease"]
+        # 0: Diabetes, 1: Hypertension, 2: Heart Disease
+        y_true = np.random.choice([0, 1, 2], size=n_samples)
+
+        # Predicted probabilities: simulate predictions, ensuring they sum to 1
+        # for each sample
+        y_probas = np.random.dirichlet(np.ones(n_classes), size=n_samples)
+
+        # Specify classes to plot (plotting all three diseases)
+        classes_to_plot = [0, 1, 2]
+
+        # Initialize a W&B run and log a ROC curve plot for disease classification
+        with wandb.init(project="medical_diagnosis") as run:
+            roc_plot = wandb.plot.roc_curve(
+                y_true=y_true,
+                y_probas=y_probas,
+                labels=disease_labels,
+                classes_to_plot=classes_to_plot,
+                title="ROC Curve for Disease Classification",
+            )
+            run.log({"roc-curve": roc_plot})
         ```
     """
     np = util.get_module(
@@ -66,8 +110,8 @@ def roc_curve(
     if classes_to_plot is None:
         classes_to_plot = classes
 
-    fpr = dict()
-    tpr = dict()
+    fpr = {}
+    tpr = {}
     indices_to_plot = np.where(np.isin(classes, classes_to_plot))[0]
     for i in indices_to_plot:
         if labels is not None and (
@@ -87,12 +131,11 @@ def roc_curve(
             "fpr": np.hstack(list(fpr.values())),
             "tpr": np.hstack(list(tpr.values())),
         }
-    )
-    df = df.round(3)
+    ).round(3)
 
     if len(df) > wandb.Table.MAX_ROWS:
         wandb.termwarn(
-            "wandb uses only %d data points to create the plots." % wandb.Table.MAX_ROWS
+            f"wandb uses only {wandb.Table.MAX_ROWS} data points to create the plots."
         )
         # different sampling could be applied, possibly to ensure endpoints are kept
         df = sklearn_utils.resample(
@@ -103,13 +146,15 @@ def roc_curve(
             stratify=df["class"],
         ).sort_values(["fpr", "tpr", "class"])
 
-    table = wandb.Table(dataframe=df)
-    title = title or "ROC"
-    return wandb.plot_table(
-        "wandb/area-under-curve/v0",
-        table,
-        {"x": "fpr", "y": "tpr", "class": "class"},
-        {
+    return plot_table(
+        data_table=wandb.Table(dataframe=df),
+        vega_spec_name="wandb/area-under-curve/v0",
+        fields={
+            "x": "fpr",
+            "y": "tpr",
+            "class": "class",
+        },
+        string_fields={
             "title": title,
             "x-axis-title": "False positive rate",
             "y-axis-title": "True positive rate",

wandb/plot/scatter.py

@@ -1,32 +1,65 @@
-from typing import Optional
+from __future__ import annotations
 
-import wandb
+from typing import TYPE_CHECKING
 
+from wandb.plot.custom_chart import plot_table
 
-def scatter(table, x, y, title=None, split_table: Optional[bool] = False):
-    """Construct a scatter plot.
+if TYPE_CHECKING:
+    import wandb
+    from wandb.plot.custom_chart import CustomChart
 
-    Arguments:
-        table (wandb.Table): Table of data.
-        x (string): Name of column to as for x-axis values.
-        y (string): Name of column to as for y-axis values.
-        title (string): Plot title.
-        split_table (bool): If True, adds "Custom Chart Tables/" to the key of the table so that it's logged in a different section.
 
-    Returns:
-        A plot object, to be passed to wandb.log()
+def scatter(
+    table: wandb.Table,
+    x: str,
+    y: str,
+    title: str = "",
+    split_table: bool = False,
+) -> CustomChart:
+    """Constructs a scatter plot from a wandb.Table of data.
+
+    Args:
+        table (wandb.Table): The W&B Table containing the data to visualize.
+        x (str): The name of the column used for the x-axis.
+        y (str): The name of the column used for the y-axis.
+        title (str): The title of the scatter chart.
+        split_table (bool): Whether the table should be split into a separate section
+            in the W&B UI. If `True`, the table will be displayed in a section named
+            "Custom Chart Tables". Default is `False`.
 
+    Returns:
+        CustomChart: A custom chart object that can be logged to W&B. To log the
+            chart, pass it to `wandb.log()`.
     Example:
         ```
-        data = [[i, random.random() + math.sin(i / 10)] for i in range(100)]
-        table = wandb.Table(data=data, columns=["step", "height"])
-        wandb.log({'scatter-plot1': wandb.plot.scatter(table, "step", "height")})
+        import math
+        import random
+        import wandb
+
+        # Simulate temperature variations at different altitudes over time
+        data = [
+            [i, random.uniform(-10, 20) - 0.005 * i + 5 * math.sin(i / 50)] for i in range(300)
+        ]
+
+        # Create W&B table with altitude (m) and temperature (°C) columns
+        table = wandb.Table(data=data, columns=["altitude (m)", "temperature (°C)"])
+
+        # Initialize W&B run and log the scatter plot
+        with wandb.init(project="temperature-altitude-scatter") as run:
+            # Create and log the scatter plot
+            scatter_plot = wandb.plot.scatter(
+                table=table,
+                x="altitude (m)",
+                y="temperature (°C)",
+                title="Altitude vs Temperature",
+            )
+            run.log({"altitude-temperature-scatter": scatter_plot})
         ```
     """
-    return wandb.plot_table(
-        "wandb/scatter/v0",
-        table,
-        {"x": x, "y": y},
-        {"title": title},
+    return plot_table(
+        data_table=table,
+        vega_spec_name="wandb/scatter/v0",
+        fields={"x": x, "y": y},
+        string_fields={"title": title},
         split_table=split_table,
     )

wandb/plot/viz.py

@@ -1,118 +1,36 @@
-from typing import Any, Dict, Optional, Tuple
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
 
 from wandb.data_types import Table
 from wandb.errors import Error
 
 
-class Visualize:
-    def __init__(self, id: str, data: Table) -> None:
-        self._id = id
-        self._data = data
-
-    def get_config_value(self, key: str) -> Dict[str, Any]:
-        return {
-            "id": self._id,
-            "historyFieldSettings": {"x-axis": "_step", "key": key},
-        }
-
-    @staticmethod
-    def get_config_key(key: str) -> Tuple[str, str, str]:
-        return "_wandb", "viz", key
+@dataclass
+class VisualizeSpec:
+    name: str
+    key: str = ""
 
     @property
-    def value(self) -> Table:
-        return self._data
-
-
-class CustomChart:
-    def __init__(
-        self,
-        id: str,
-        data: Table,
-        fields: Dict[str, Any],
-        string_fields: Dict[str, Any],
-        split_table: Optional[bool] = False,
-    ) -> None:
-        self._id = id
-        self._data = data
-        self._fields = fields
-        self._string_fields = string_fields
-        self._split_table = split_table
-
-    def get_config_value(
-        self,
-        panel_type: str,
-        query: Dict[str, Any],
-    ) -> Dict[str, Any]:
+    def config_value(self) -> dict[str, Any]:
         return {
-            "panel_type": panel_type,
-            "panel_config": {
-                "panelDefId": self._id,
-                "fieldSettings": self._fields,
-                "stringSettings": self._string_fields,
-                "transform": {"name": "tableWithLeafColNames"},
-                "userQuery": query,
-            },
-        }
-
-    @staticmethod
-    def get_config_key(key: str) -> Tuple[str, str, str]:
-        return "_wandb", "visualize", key
-
-    @staticmethod
-    def user_query(table_key: str) -> Dict[str, Any]:
-        return {
-            "queryFields": [
-                {
-                    "name": "runSets",
-                    "args": [{"name": "runSets", "value": "${runSets}"}],
-                    "fields": [
-                        {"name": "id", "fields": []},
-                        {"name": "name", "fields": []},
-                        {"name": "_defaultColorIndex", "fields": []},
-                        {
-                            "name": "summaryTable",
-                            "args": [{"name": "tableKey", "value": table_key}],
-                            "fields": [],
-                        },
-                    ],
-                }
-            ],
+            "id": self.name,
+            "historyFieldSettings": {"x-axis": "_step", "key": self.key},
         }
 
     @property
-    def table(self) -> Table:
-        return self._data
+    def config_key(self) -> tuple[str, str, str]:
+        return ("_wandb", "viz", self.key)
 
-    @property
-    def fields(self) -> Dict[str, Any]:
-        return self._fields
-
-    @property
-    def string_fields(self) -> Dict[str, Any]:
-        return self._string_fields
 
+@dataclass
+class Visualize:
+    table: Table
+    spec: VisualizeSpec
 
-def custom_chart(
-    vega_spec_name: str,
-    data_table: Table,
-    fields: Dict[str, Any],
-    string_fields: Optional[Dict[str, Any]] = None,
-    split_table: Optional[bool] = False,
-) -> CustomChart:
-    if string_fields is None:
-        string_fields = {}
-    if not isinstance(data_table, Table):
-        raise Error(
-            f"Expected `data_table` to be `wandb.Table` type, instead got {type(data_table).__name__}"
-        )
-    return CustomChart(
-        id=vega_spec_name,
-        data=data_table,
-        fields=fields,
-        string_fields=string_fields,
-        split_table=split_table,
-    )
+    def set_key(self, key: str) -> None:
+        self.spec.key = key
 
 
 def visualize(id: str, value: Table) -> Visualize:
@@ -120,4 +38,4 @@ def visualize(id: str, value: Table) -> Visualize:
         raise Error(
             f"Expected `value` to be `wandb.Table` type, instead got {type(value).__name__}"
         )
-    return Visualize(id=id, data=value)
+    return Visualize(table=value, spec=VisualizeSpec(name=id))