wandb 0.18.0__py3-none-macosx_10_13_x86_64.whl

wandb/filesync/upload_job.py

@@ -0,0 +1,142 @@
+import logging
+import os
+from typing import TYPE_CHECKING, Optional
+
+import wandb
+from wandb.sdk.lib.paths import LogicalPath
+
+if TYPE_CHECKING:
+    from wandb.filesync import dir_watcher, stats, step_upload
+    from wandb.sdk.internal import file_stream, internal_api
+
+
+logger = logging.getLogger(__name__)
+
+
+class UploadJob:
+    def __init__(
+        self,
+        stats: "stats.Stats",
+        api: "internal_api.Api",
+        file_stream: "file_stream.FileStreamApi",
+        silent: bool,
+        save_name: LogicalPath,
+        path: "dir_watcher.PathStr",
+        artifact_id: Optional[str],
+        md5: Optional[str],
+        copied: bool,
+        save_fn: Optional["step_upload.SaveFn"],
+        digest: Optional[str],
+    ) -> None:
+        """A file uploader.
+
+        Arguments:
+            push_function: function(save_name, actual_path) which actually uploads
+                the file.
+            save_name: string logical location of the file relative to the run
+                directory.
+            path: actual string path of the file to upload on the filesystem.
+        """
+        self._stats = stats
+        self._api = api
+        self._file_stream = file_stream
+        self.silent = silent
+        self.save_name = save_name
+        self.save_path = path
+        self.artifact_id = artifact_id
+        self.md5 = md5
+        self.copied = copied
+        self.save_fn = save_fn
+        self.digest = digest
+        super().__init__()
+
+    def run(self) -> None:
+        success = False
+        try:
+            self.push()
+            success = True
+        finally:
+            if self.copied and os.path.isfile(self.save_path):
+                os.remove(self.save_path)
+            if success:
+                self._file_stream.push_success(self.artifact_id, self.save_name)  # type: ignore
+
+    def push(self) -> None:
+        if self.save_fn:
+            # Retry logic must happen in save_fn currently
+            try:
+                deduped = self.save_fn(
+                    lambda _, t: self._stats.update_uploaded_file(self.save_path, t)
+                )
+            except Exception as e:
+                self._stats.update_failed_file(self.save_path)
+                logger.exception("Failed to upload file: %s", self.save_path)
+                wandb._sentry.exception(e)
+                message = str(e)
+                # TODO: this is usually XML, but could be JSON
+                if hasattr(e, "response"):
+                    message = e.response.content
+                wandb.termerror(
+                    f'Error uploading "{self.save_path}": {type(e).__name__}, {message}'
+                )
+                raise
+
+            if deduped:
+                logger.info("Skipped uploading %s", self.save_path)
+                self._stats.set_file_deduped(self.save_path)
+            else:
+                logger.info("Uploaded file %s", self.save_path)
+            return
+
+        if self.md5:
+            # This is the new artifact manifest upload flow, in which we create the
+            # database entry for the manifest file before creating it. This is used for
+            # artifact L0 files. Which now is only artifact_manifest.json
+            _, response = self._api.create_artifact_manifest(
+                self.save_name, self.md5, self.artifact_id
+            )
+            upload_url = response["uploadUrl"]
+            upload_headers = response["uploadHeaders"]
+        else:
+            # The classic file upload flow. We get a signed url and upload the file
+            # then the backend handles the cloud storage metadata callback to create the
+            # file entry. This flow has aged like a fine wine.
+            project = self._api.get_project()
+            _, upload_headers, result = self._api.upload_urls(project, [self.save_name])
+            file_info = result[self.save_name]
+            upload_url = file_info["uploadUrl"]
+
+        if upload_url is None:
+            logger.info("Skipped uploading %s", self.save_path)
+            self._stats.set_file_deduped(self.save_name)
+        else:
+            extra_headers = self._api._extra_http_headers
+            for upload_header in upload_headers:
+                key, val = upload_header.split(":", 1)
+                extra_headers[key] = val
+            # Copied from push TODO(artifacts): clean up
+            # If the upload URL is relative, fill it in with the base URL,
+            # since its a proxied file store like the on-prem VM.
+            if upload_url.startswith("/"):
+                upload_url = f"{self._api.api_url}{upload_url}"
+            try:
+                with open(self.save_path, "rb") as f:
+                    self._api.upload_file_retry(
+                        upload_url,
+                        f,
+                        lambda _, t: self.progress(t),
+                        extra_headers=extra_headers,
+                    )
+                logger.info("Uploaded file %s", self.save_path)
+            except Exception as e:
+                self._stats.update_failed_file(self.save_name)
+                logger.exception("Failed to upload file: %s", self.save_path)
+                wandb._sentry.exception(e)
+                if not self.silent:
+                    wandb.termerror(
+                        f'Error uploading "{self.save_name}": {type(e).__name__}, {e}'
+                    )
+                raise
+
+    def progress(self, total_bytes: int) -> None:
+        self._stats.update_uploaded_file(self.save_name, total_bytes)

wandb/integration/catboost/__init__.py

@@ -0,0 +1,5 @@
+"""W&B callback for CatBoost."""
+
+from .catboost import WandbCallback, log_summary
+
+__all__ = ["log_summary", "WandbCallback"]

wandb/integration/catboost/catboost.py

@@ -0,0 +1,178 @@
+"""catboost init."""
+
+from pathlib import Path
+from types import SimpleNamespace
+from typing import List, Union
+
+from catboost import CatBoostClassifier, CatBoostRegressor  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry as wb_telemetry
+
+
+class WandbCallback:
+    """`WandbCallback` automatically integrates CatBoost with wandb.
+
+    Arguments:
+        - metric_period: (int) if you are passing `metric_period` to your CatBoost model please pass the same value here (default=1).
+
+    Passing `WandbCallback` to CatBoost will:
+    - log training and validation metrics at every `metric_period`
+    - log iteration at every `metric_period`
+
+    Example:
+        ```
+        train_pool = Pool(train[features], label=train["label"], cat_features=cat_features)
+        test_pool = Pool(test[features], label=test["label"], cat_features=cat_features)
+
+        model = CatBoostRegressor(
+            iterations=100,
+            loss_function="Cox",
+            eval_metric="Cox",
+        )
+
+        model.fit(
+            train_pool,
+            eval_set=test_pool,
+            callbacks=[WandbCallback()],
+        )
+        ```
+    """
+
+    def __init__(self, metric_period: int = 1):
+        if wandb.run is None:
+            raise wandb.Error("You must call `wandb.init()` before `WandbCallback()`")
+
+        with wb_telemetry.context() as tel:
+            tel.feature.catboost_wandb_callback = True
+
+        self.metric_period: int = metric_period
+
+    def after_iteration(self, info: SimpleNamespace) -> bool:
+        if info.iteration % self.metric_period == 0:
+            for data, metric in info.metrics.items():
+                for metric_name, log in metric.items():
+                    # todo: replace with wandb.run._log once available
+                    wandb.log({f"{data}-{metric_name}": log[-1]}, commit=False)
+            # todo: replace with wandb.run._log once available
+            wandb.log({f"iteration@metric-period-{self.metric_period}": info.iteration})
+
+        return True
+
+
+def _checkpoint_artifact(
+    model: Union[CatBoostClassifier, CatBoostRegressor], aliases: List[str]
+) -> None:
+    """Upload model checkpoint as W&B artifact."""
+    if wandb.run is None:
+        raise wandb.Error(
+            "You must call `wandb.init()` before `_checkpoint_artifact()`"
+        )
+
+    model_name = f"model_{wandb.run.id}"
+    # save the model in the default `cbm` format
+    model_path = Path(wandb.run.dir) / "model"
+
+    model.save_model(model_path)
+
+    model_artifact = wandb.Artifact(name=model_name, type="model")
+    model_artifact.add_file(str(model_path))
+    wandb.log_artifact(model_artifact, aliases=aliases)
+
+
+def _log_feature_importance(
+    model: Union[CatBoostClassifier, CatBoostRegressor],
+) -> None:
+    """Log feature importance with default settings."""
+    if wandb.run is None:
+        raise wandb.Error(
+            "You must call `wandb.init()` before `_checkpoint_artifact()`"
+        )
+
+    feat_df = model.get_feature_importance(prettified=True)
+
+    fi_data = [
+        [feat, feat_imp]
+        for feat, feat_imp in zip(feat_df["Feature Id"], feat_df["Importances"])
+    ]
+    table = wandb.Table(data=fi_data, columns=["Feature", "Importance"])
+    # todo: replace with wandb.run._log once available
+    wandb.log(
+        {
+            "Feature Importance": wandb.plot.bar(
+                table, "Feature", "Importance", title="Feature Importance"
+            )
+        },
+        commit=False,
+    )
+
+
+def log_summary(
+    model: Union[CatBoostClassifier, CatBoostRegressor],
+    log_all_params: bool = True,
+    save_model_checkpoint: bool = False,
+    log_feature_importance: bool = True,
+) -> None:
+    """`log_summary` logs useful metrics about catboost model after training is done.
+
+    Arguments:
+        model: it can be CatBoostClassifier or CatBoostRegressor.
+        log_all_params: (boolean) if True (default) log the model hyperparameters as W&B config.
+        save_model_checkpoint: (boolean) if True saves the model upload as W&B artifacts.
+        log_feature_importance: (boolean) if True (default) logs feature importance as W&B bar chart using the default setting of `get_feature_importance`.
+
+    Using this along with `wandb_callback` will:
+
+    - save the hyperparameters as W&B config,
+    - log `best_iteration` and `best_score` as `wandb.summary`,
+    - save and upload your trained model to Weights & Biases Artifacts (when `save_model_checkpoint = True`)
+    - log feature importance plot.
+
+    Example:
+        ```python
+        train_pool = Pool(train[features], label=train["label"], cat_features=cat_features)
+        test_pool = Pool(test[features], label=test["label"], cat_features=cat_features)
+
+        model = CatBoostRegressor(
+            iterations=100,
+            loss_function="Cox",
+            eval_metric="Cox",
+        )
+
+        model.fit(
+            train_pool,
+            eval_set=test_pool,
+            callbacks=[WandbCallback()],
+        )
+
+        log_summary(model)
+        ```
+    """
+    if wandb.run is None:
+        raise wandb.Error("You must call `wandb.init()` before `log_summary()`")
+
+    if not (isinstance(model, (CatBoostClassifier, CatBoostRegressor))):
+        raise wandb.Error(
+            "Model should be an instance of CatBoostClassifier or CatBoostRegressor"
+        )
+
+    with wb_telemetry.context() as tel:
+        tel.feature.catboost_log_summary = True
+
+    # log configs
+    params = model.get_all_params()
+    if log_all_params:
+        wandb.config.update(params)
+
+    # log best score and iteration
+    wandb.run.summary["best_iteration"] = model.get_best_iteration()
+    wandb.run.summary["best_score"] = model.get_best_score()
+
+    # log model
+    if save_model_checkpoint:
+        aliases = ["best"] if params["use_best_model"] else ["last"]
+        _checkpoint_artifact(model, aliases=aliases)
+
+    # Feature importance
+    if log_feature_importance:
+        _log_feature_importance(model)

wandb/integration/cohere/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("autolog",)
+
+from .cohere import autolog

wandb/integration/cohere/cohere.py

@@ -0,0 +1,21 @@
+import logging
+
+from wandb.sdk.integration_utils.auto_logging import AutologAPI
+
+from .resolver import CohereRequestResponseResolver
+
+logger = logging.getLogger(__name__)
+
+
+autolog = AutologAPI(
+    name="Cohere",
+    symbols=(
+        "Client.generate",
+        "Client.chat",
+        "Client.classify",
+        "Client.summarize",
+        "Client.rerank",
+    ),
+    resolver=CohereRequestResponseResolver(),
+    telemetry_feature="cohere_autolog",
+)