wandb 0.20.2rc20250616__py3-none-any.whl → 0.21.0__py3-none-any.whl

wandb/plot/line_series.py

@@ -20,18 +20,18 @@ def line_series(
     """Constructs a line series chart.
 
     Args:
-        xs (Iterable[Iterable] | Iterable): Sequence of x values. If a singular
+        xs: Sequence of x values. If a singular
             array is provided, all y values are plotted against that x array. If
             an array of arrays is provided, each y value is plotted against the
             corresponding x array.
-        ys (Iterable[Iterable]): Sequence of y values, where each iterable represents
+        ys: Sequence of y values, where each iterable represents
             a separate line series.
-        keys (Iterable[str]): Sequence of keys for labeling each line series. If
+        keys: Sequence of keys for labeling each line series. If
             not provided, keys will be automatically generated as "line_1",
             "line_2", etc.
-        title (str): Title of the chart.
-        xname (str): Label for the x-axis.
-        split_table (bool): Whether the table should be split into a separate section
+        title: Title of the chart.
+        xname: Label for the x-axis.
+        split_table: 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`.
 
@@ -40,103 +40,100 @@ def line_series(
             chart, pass it to `wandb.log()`.
 
     Examples:
-        1. Logging a single x array where all y series are plotted against
-           the same x values:
-
-        ```
-        import wandb
-
-        # Initialize W&B run
-        with wandb.init(project="line_series_example") as run:
-            # x values shared across all y series
-            xs = list(range(10))
-
-            # Multiple y series to plot
-            ys = [
-                [i for i in range(10)],  # y = x
-                [i**2 for i in range(10)],  # y = x^2
-                [i**3 for i in range(10)],  # y = x^3
-            ]
-
-            # Generate and log the line series chart
-            line_series_chart = wandb.plot.line_series(
-                xs,
-                ys,
-                title="title",
-                xname="step",
-            )
-            run.log({"line-series-single-x": line_series_chart})
-        ```
-
-        In this example, a single `xs` series (shared x-values) is used for all
-        `ys` series. This results in each y-series being plotted against the
-        same x-values (0-9).
-
-        2. Logging multiple x arrays where each y series is plotted against
-           its corresponding x array:
-
-        ```python
-        import wandb
-
-        # Initialize W&B run
-        with wandb.init(project="line_series_example") as run:
-            # Separate x values for each y series
-            xs = [
-                [i for i in range(10)],  # x for first series
-                [2 * i for i in range(10)],  # x for second series (stretched)
-                [3 * i for i in range(10)],  # x for third series (stretched more)
-            ]
-
-            # Corresponding y series
-            ys = [
-                [i for i in range(10)],  # y = x
-                [i**2 for i in range(10)],  # y = x^2
-                [i**3 for i in range(10)],  # y = x^3
-            ]
-
-            # Generate and log the line series chart
-            line_series_chart = wandb.plot.line_series(
-                xs, ys, title="Multiple X Arrays Example", xname="Step"
-            )
-            run.log({"line-series-multiple-x": line_series_chart})
-        ```
-
-        In this example, each y series is plotted against its own unique x series.
-        This allows for more flexibility when the x values are not uniform across
-        the data series.
-
-        3. Customizing line labels using `keys`:
-
-        ```python
-        import wandb
-
-        # Initialize W&B run
-        with wandb.init(project="line_series_example") as run:
-            xs = list(range(10))  # Single x array
-            ys = [
-                [i for i in range(10)],  # y = x
-                [i**2 for i in range(10)],  # y = x^2
-                [i**3 for i in range(10)],  # y = x^3
-            ]
-
-            # Custom labels for each line
-            keys = ["Linear", "Quadratic", "Cubic"]
-
-            # Generate and log the line series chart
-            line_series_chart = wandb.plot.line_series(
-                xs,
-                ys,
-                keys=keys,  # Custom keys (line labels)
-                title="Custom Line Labels Example",
-                xname="Step",
-            )
-            run.log({"line-series-custom-keys": line_series_chart})
-        ```
-
-        This example shows how to provide custom labels for the lines using
-        the `keys` argument. The keys will appear in the legend as "Linear",
-        "Quadratic", and "Cubic".
-
+    Logging a single x array where all y series are plotted against the same x values:
+
+    ```python
+    import wandb
+
+    # Initialize W&B run
+    with wandb.init(project="line_series_example") as run:
+        # x values shared across all y series
+        xs = list(range(10))
+
+        # Multiple y series to plot
+        ys = [
+            [i for i in range(10)],  # y = x
+            [i**2 for i in range(10)],  # y = x^2
+            [i**3 for i in range(10)],  # y = x^3
+        ]
+
+        # Generate and log the line series chart
+        line_series_chart = wandb.plot.line_series(
+            xs,
+            ys,
+            title="title",
+            xname="step",
+        )
+        run.log({"line-series-single-x": line_series_chart})
+    ```
+
+    In this example, a single `xs` series (shared x-values) is used for all
+    `ys` series. This results in each y-series being plotted against the
+    same x-values (0-9).
+
+    Logging multiple x arrays where each y series is plotted against its corresponding x array:
+
+    ```python
+    import wandb
+
+    # Initialize W&B run
+    with wandb.init(project="line_series_example") as run:
+        # Separate x values for each y series
+        xs = [
+            [i for i in range(10)],  # x for first series
+            [2 * i for i in range(10)],  # x for second series (stretched)
+            [3 * i for i in range(10)],  # x for third series (stretched more)
+        ]
+
+        # Corresponding y series
+        ys = [
+            [i for i in range(10)],  # y = x
+            [i**2 for i in range(10)],  # y = x^2
+            [i**3 for i in range(10)],  # y = x^3
+        ]
+
+        # Generate and log the line series chart
+        line_series_chart = wandb.plot.line_series(
+            xs, ys, title="Multiple X Arrays Example", xname="Step"
+        )
+        run.log({"line-series-multiple-x": line_series_chart})
+    ```
+
+    In this example, each y series is plotted against its own unique x series.
+    This allows for more flexibility when the x values are not uniform across
+    the data series.
+
+    Customizing line labels using `keys`:
+
+    ```python
+    import wandb
+
+    # Initialize W&B run
+    with wandb.init(project="line_series_example") as run:
+        xs = list(range(10))  # Single x array
+        ys = [
+            [i for i in range(10)],  # y = x
+            [i**2 for i in range(10)],  # y = x^2
+            [i**3 for i in range(10)],  # y = x^3
+        ]
+
+        # Custom labels for each line
+        keys = ["Linear", "Quadratic", "Cubic"]
+
+        # Generate and log the line series chart
+        line_series_chart = wandb.plot.line_series(
+            xs,
+            ys,
+            keys=keys,  # Custom keys (line labels)
+            title="Custom Line Labels Example",
+            xname="Step",
+        )
+        run.log({"line-series-custom-keys": line_series_chart})
+    ```
+
+    This example shows how to provide custom labels for the lines using
+    the `keys` argument. The keys will appear in the legend as "Linear",
+    "Quadratic", and "Cubic".
     """
     # If xs is a single array, repeat it for each y in ys
     if not isinstance(xs[0], Iterable) or isinstance(xs[0], (str, bytes)):

wandb/plot/pr_curve.py

@@ -34,24 +34,24 @@ def pr_curve(
     a model's performance.
 
     Args:
-        y_true (Iterable): True binary labels. The shape should be (`num_samples`,).
-        y_probas (Iterable): Predicted scores or probabilities for each class.
+        y_true: True binary labels. The shape should be (`num_samples`,).
+        y_probas: Predicted scores or probabilities for each class.
             These can be probability estimates, confidence scores, or non-thresholded
             decision values. The shape should be (`num_samples`, `num_classes`).
-        labels (list[str] | None): Optional list of class names to replace
+        labels: Optional list of class names to replace
             numeric values in `y_true` for easier plot interpretation.
             For example, `labels = ['dog', 'cat', 'owl']` will replace 0 with
             'dog', 1 with 'cat', and 2 with 'owl' in the plot. If not provided,
             numeric values from `y_true` will be used.
-        classes_to_plot (list | None): Optional list of unique class values from
+        classes_to_plot: Optional list of unique class values from
             y_true to be included in the plot. If not specified, all unique
             classes in y_true will be plotted.
-        interp_size (int): Number of points to interpolate recall values. The
+        interp_size: Number of points to interpolate recall values. The
             recall values will be fixed to `interp_size` uniformly distributed
             points in the range [0, 1], and the precision will be interpolated
             accordingly.
-        title (str): Title of the plot. Defaults to "Precision-Recall Curve".
-        split_table (bool): Whether the table should be split into a separate section
+        title: Title of the plot. Defaults to "Precision-Recall Curve".
+        split_table: 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`.
 
@@ -60,34 +60,35 @@ def pr_curve(
             chart, pass it to `wandb.log()`.
 
     Raises:
-        wandb.Error: If numpy, pandas, or scikit-learn is not installed.
+        wandb.Error: If NumPy, pandas, or scikit-learn is not installed.
 
 
     Example:
-        ```
-        import wandb
-
-        # Example for spam detection (binary classification)
-        y_true = [0, 1, 1, 0, 1]  # 0 = not spam, 1 = spam
-        y_probas = [
-            [0.9, 0.1],  # Predicted probabilities for the first sample (not spam)
-            [0.2, 0.8],  # Second sample (spam), and so on
-            [0.1, 0.9],
-            [0.8, 0.2],
-            [0.3, 0.7],
-        ]
-
-        labels = ["not spam", "spam"]  # Optional class names for readability
-
-        with wandb.init(project="spam-detection") as run:
-            pr_curve = wandb.plot.pr_curve(
-                y_true=y_true,
-                y_probas=y_probas,
-                labels=labels,
-                title="Precision-Recall Curve for Spam Detection",
-            )
-            run.log({"pr-curve": pr_curve})
-        ```
+
+    ```python
+    import wandb
+
+    # Example for spam detection (binary classification)
+    y_true = [0, 1, 1, 0, 1]  # 0 = not spam, 1 = spam
+    y_probas = [
+        [0.9, 0.1],  # Predicted probabilities for the first sample (not spam)
+        [0.2, 0.8],  # Second sample (spam), and so on
+        [0.1, 0.9],
+        [0.8, 0.2],
+        [0.3, 0.7],
+    ]
+
+    labels = ["not spam", "spam"]  # Optional class names for readability
+
+    with wandb.init(project="spam-detection") as run:
+        pr_curve = wandb.plot.pr_curve(
+            y_true=y_true,
+            y_probas=y_probas,
+            labels=labels,
+            title="Precision-Recall Curve for Spam Detection",
+        )
+        run.log({"pr-curve": pr_curve})
+    ```
     """
     np = util.get_module(
         "numpy",

wandb/plot/roc_curve.py

@@ -23,20 +23,20 @@ def roc_curve(
     """Constructs Receiver Operating Characteristic (ROC) curve chart.
 
     Args:
-        y_true (Sequence[numbers.Number]): The true class labels (ground truth)
+        y_true: The true class labels (ground truth)
             for the target variable. Shape should be (num_samples,).
-        y_probas (Sequence[Sequence[float]]): The predicted probabilities or
+        y_probas: 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
+        labels: 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
+        classes_to_plot: 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
+        title: Title of the ROC curve plot. Default is "ROC Curve".
+        split_table: 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`.
 
@@ -48,38 +48,38 @@ def roc_curve(
         wandb.Error: If numpy, pandas, or scikit-learn are not found.
 
     Example:
-        ```
-        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})
-        ```
+    ```python
+    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(
         "numpy",

wandb/plot/scatter.py

@@ -19,11 +19,11 @@ def scatter(
     """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
+        table: The W&B Table containing the data to visualize.
+        x: The name of the column used for the x-axis.
+        y: The name of the column used for the y-axis.
+        title: The title of the scatter chart.
+        split_table: 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`.
 
@@ -31,31 +31,31 @@ def scatter(
         CustomChart: A custom chart object that can be logged to W&B. To log the
             chart, pass it to `wandb.log()`.
     Example:
-        ```
-        import math
-        import random
-        import wandb
+    ```python
+    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)
-        ]
+    # 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)"])
+    # 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})
-        ```
+    # 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 plot_table(
         data_table=table,