wandb 0.15.9__py3-none-any.whl → 0.15.11__py3-none-any.whl

wandb/integration/ultralytics/pose_utils.py

@@ -0,0 +1,92 @@
+from typing import Any, Optional
+
+import numpy as np
+from PIL import Image
+from ultralytics.engine.results import Results
+from ultralytics.models.yolo.pose import PosePredictor
+from ultralytics.utils.plotting import Annotator
+
+import wandb
+
+from .bbox_utils import get_boxes, get_ground_truth_bbox_annotations
+
+
+def annotate_keypoint_results(result: Results, visualize_skeleton: bool):
+    annotator = Annotator(np.ascontiguousarray(result.orig_img[:, :, ::-1]))
+    key_points = result.keypoints.data.numpy()
+    for idx in range(key_points.shape[0]):
+        annotator.kpts(key_points[idx], kpt_line=visualize_skeleton)
+    return annotator.im
+
+
+def annotate_keypoint_batch(image_path: str, keypoints: Any, visualize_skeleton: bool):
+    original_image = None
+    with Image.open(image_path) as original_image:
+        original_image = np.ascontiguousarray(original_image)
+        annotator = Annotator(original_image)
+        annotator.kpts(keypoints.numpy(), kpt_line=visualize_skeleton)
+        return annotator.im
+
+
+def plot_pose_predictions(
+    result: Results,
+    model_name: str,
+    visualize_skeleton: bool,
+    table: Optional[wandb.Table] = None,
+):
+    result = result.to("cpu")
+    boxes, mean_confidence_map = get_boxes(result)
+    prediction_image = wandb.Image(
+        annotate_keypoint_results(result, visualize_skeleton), boxes=boxes
+    )
+    table_row = [
+        model_name,
+        prediction_image,
+        len(boxes["predictions"]["box_data"]),
+        mean_confidence_map,
+        result.speed,
+    ]
+    if table is not None:
+        table.add_data(*table_row)
+        return table
+    return table_row
+
+
+def plot_pose_validation_results(
+    dataloader,
+    class_label_map,
+    model_name: str,
+    predictor: PosePredictor,
+    visualize_skeleton: bool,
+    table: wandb.Table,
+    max_validation_batches: int,
+    epoch: Optional[int] = None,
+) -> wandb.Table:
+    data_idx = 0
+    for batch_idx, batch in enumerate(dataloader):
+        for img_idx, image_path in enumerate(batch["im_file"]):
+            prediction_result = predictor(image_path)[0].to("cpu")
+            table_row = plot_pose_predictions(
+                prediction_result, model_name, visualize_skeleton
+            )
+            ground_truth_image = wandb.Image(
+                annotate_keypoint_batch(
+                    image_path, batch["keypoints"][img_idx], visualize_skeleton
+                ),
+                boxes={
+                    "ground-truth": {
+                        "box_data": get_ground_truth_bbox_annotations(
+                            img_idx, image_path, batch, class_label_map
+                        ),
+                        "class_labels": class_label_map,
+                    },
+                },
+            )
+            table_row = [data_idx, batch_idx, ground_truth_image] + table_row[1:]
+            table_row = [epoch] + table_row if epoch is not None else table_row
+            table_row = [model_name] + table_row
+            table.add_data(*table_row)
+            data_idx += 1
+        if batch_idx + 1 == max_validation_batches:
+            break
+    return table

wandb/integration/xgboost/xgboost.py

@@ -64,10 +64,10 @@ class WandbCallback(xgb.callback.TrainingCallback):
     Passing `WandbCallback` to XGBoost will:
 
     - log the booster model configuration to Weights & Biases
-    - log evaluation metrics collected by XGBoost, such as rmse, accuracy etc to Weights & Biases
+    - log evaluation metrics collected by XGBoost, such as rmse, accuracy etc. to Weights & Biases
     - log training metric collected by XGBoost (if you provide training data to eval_set)
     - log the best score and the best iteration
-    - save and upload your trained model to to Weights & Biases Artifacts (when `log_model = True`)
+    - save and upload your trained model to Weights & Biases Artifacts (when `log_model = True`)
     - log feature importance plot when `log_feature_importance=True` (default).
     - Capture the best eval metric in `wandb.summary` when `define_metric=True` (default).
 
@@ -81,6 +81,7 @@ class WandbCallback(xgb.callback.TrainingCallback):
             alpha=10,
             n_estimators=10,
             tree_method="hist",
+            callbacks=[WandbCallback()],
         )
 
         xg_reg = xgb.XGBRegressor(**bst_params)
@@ -88,7 +89,6 @@ class WandbCallback(xgb.callback.TrainingCallback):
             X_train,
             y_train,
             eval_set=[(X_test, y_test)],
-            callbacks=[WandbCallback()],
         )
         ```
     """

wandb/integration/yolov8/__init__.py

@@ -1,7 +0,0 @@
-"""Tools for integrating `wandb` with [`ultralytics YOLOv8`](https://docs.ultralytics.com/).
-
-YOLOv8 is a computer vision framework for training and deploying YOLOv8 models.
-"""
-__all__ = ("add_callbacks",)
-
-from .yolov8 import add_callbacks

wandb/integration/yolov8/yolov8.py

@@ -16,8 +16,11 @@ class WandbCallback:
     Usage:
     ```python
     from wandb.integration.yolov8.yolov8 import WandbCallback
+
     model = YOLO("yolov8n.pt")
-    wandb_logger = WandbCallback(model,)
+    wandb_logger = WandbCallback(
+        model,
+    )
     for event, callback_fn in wandb_logger.callbacks.items():
         model.add_callback(event, callback_fn)
     ```
@@ -222,9 +225,16 @@ def add_callbacks(
     Usage:
     ```python
     from wandb.integration.yolov8 import add_callbacks as add_wandb_callbacks
+
     model = YOLO("yolov8n.pt")
-    add_wandb_callbacks(model,)
-    model.train(data="coco128.yaml", epochs=3, imgsz=640,)
+    add_wandb_callbacks(
+        model,
+    )
+    model.train(
+        data="coco128.yaml",
+        epochs=3,
+        imgsz=640,
+    )
     ```
     """
     wandb.termwarn(
@@ -234,6 +244,15 @@ def add_callbacks(
         """,
         repeat=False,
     )
+    wandb.termwarn(
+        """This wandb callback is no longer functional and would be deprecated in the near future.
+        We recommend you to use the updated callback using `from wandb.integration.ultralytics import add_wandb_callback`.
+        The updated callback is tested and supported for ultralytics 8.0.167 and above.
+        You can refer to https://docs.wandb.ai/guides/integrations/ultralytics for the updated documentation.
+        Please report any issues to https://github.com/wandb/wandb/issues with the tag `yolov8`.
+        """,
+        repeat=False,
+    )
 
     if RANK in [-1, 0]:
         wandb_logger = WandbCallback(

wandb/old/settings.py

@@ -1,4 +1,5 @@
 import configparser
+import getpass
 import os
 import tempfile
 from typing import Any, Optional
@@ -124,6 +125,12 @@ class Settings:
         # if not writable, fall back to a temp directory
         if not os.access(default_config_dir, os.W_OK):
             default_config_dir = os.path.join(tempfile.gettempdir(), ".config", "wandb")
+        # if not writable (if tempdir is shared, for example), try creating a subdir
+        if not os.access(default_config_dir, os.W_OK):
+            username = getpass.getuser()
+            default_config_dir = os.path.join(
+                tempfile.gettempdir(), username, ".config", "wandb"
+            )
 
         config_dir = os.environ.get(env.CONFIG_DIR, default_config_dir)
         os.makedirs(config_dir, exist_ok=True)

wandb/plot/line_series.py

@@ -69,7 +69,6 @@ def line_series(
 
     if keys is not None:
         assert len(keys) == len(ys), "Number of keys and y-lines must match"
-
     data = [
         [x, f"key_{i}" if keys is None else keys[i], y]
         for i, (xx, yy) in enumerate(zip(xs, ys))