Add files using upload-large-folder tool

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb-0.25.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb-0.25.1.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: wandb
+Version: 0.25.1
+Summary: A CLI and library for interacting with the Weights & Biases API.
+Project-URL: Source, https://github.com/wandb/wandb
+Project-URL: Bug Reports, https://github.com/wandb/wandb/issues
+Project-URL: Documentation, https://docs.wandb.ai/
+Author-email: Weights & Biases <support@wandb.com>
+License: MIT License
+        
+        Copyright (c) 2021 Weights and Biases, Inc.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Go
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0.1
+Requires-Dist: eval-type-backport; python_version < '3.10'
+Requires-Dist: gitpython!=3.1.29,>=1.0.0
+Requires-Dist: packaging
+Requires-Dist: platformdirs
+Requires-Dist: protobuf!=5.28.0,!=5.29.0,<7,>4.21.0
+Requires-Dist: pydantic<3
+Requires-Dist: pyyaml
+Requires-Dist: requests<3,>=2.0.0
+Requires-Dist: sentry-sdk>=2.0.0
+Requires-Dist: typing-extensions<5,>=4.8
+Provides-Extra: aws
+Requires-Dist: boto3; extra == 'aws'
+Requires-Dist: botocore>=1.5.76; extra == 'aws'
+Provides-Extra: azure
+Requires-Dist: azure-identity; extra == 'azure'
+Requires-Dist: azure-storage-blob; extra == 'azure'
+Provides-Extra: gcp
+Requires-Dist: google-cloud-storage; extra == 'gcp'
+Provides-Extra: importers
+Requires-Dist: filelock; extra == 'importers'
+Requires-Dist: mlflow; extra == 'importers'
+Requires-Dist: polars<=1.2.1; extra == 'importers'
+Requires-Dist: rich; extra == 'importers'
+Requires-Dist: tenacity; extra == 'importers'
+Provides-Extra: kubeflow
+Requires-Dist: google-cloud-storage; extra == 'kubeflow'
+Requires-Dist: kubernetes; extra == 'kubeflow'
+Requires-Dist: minio; extra == 'kubeflow'
+Requires-Dist: sh; extra == 'kubeflow'
+Provides-Extra: launch
+Requires-Dist: awscli; extra == 'launch'
+Requires-Dist: azure-containerregistry; extra == 'launch'
+Requires-Dist: azure-identity; extra == 'launch'
+Requires-Dist: azure-storage-blob; extra == 'launch'
+Requires-Dist: boto3; extra == 'launch'
+Requires-Dist: botocore>=1.5.76; extra == 'launch'
+Requires-Dist: chardet; extra == 'launch'
+Requires-Dist: google-auth; extra == 'launch'
+Requires-Dist: google-cloud-aiplatform; extra == 'launch'
+Requires-Dist: google-cloud-artifact-registry; extra == 'launch'
+Requires-Dist: google-cloud-compute; extra == 'launch'
+Requires-Dist: google-cloud-storage; extra == 'launch'
+Requires-Dist: iso8601; extra == 'launch'
+Requires-Dist: jsonschema; extra == 'launch'
+Requires-Dist: kubernetes; extra == 'launch'
+Requires-Dist: kubernetes-asyncio; extra == 'launch'
+Requires-Dist: nbconvert; extra == 'launch'
+Requires-Dist: nbformat; extra == 'launch'
+Requires-Dist: optuna; extra == 'launch'
+Requires-Dist: pydantic; extra == 'launch'
+Requires-Dist: pyyaml>=6.0.0; extra == 'launch'
+Requires-Dist: tomli; extra == 'launch'
+Requires-Dist: tornado>=6.5.0; (python_version >= '3.9') and extra == 'launch'
+Requires-Dist: typing-extensions; extra == 'launch'
+Provides-Extra: media
+Requires-Dist: bokeh; extra == 'media'
+Requires-Dist: imageio>=2.28.1; extra == 'media'
+Requires-Dist: moviepy>=1.0.0; extra == 'media'
+Requires-Dist: numpy; extra == 'media'
+Requires-Dist: pillow; extra == 'media'
+Requires-Dist: plotly>=5.18.0; extra == 'media'
+Requires-Dist: rdkit; extra == 'media'
+Requires-Dist: soundfile; extra == 'media'
+Provides-Extra: models
+Requires-Dist: cloudpickle; extra == 'models'
+Provides-Extra: perf
+Requires-Dist: orjson; extra == 'perf'
+Provides-Extra: sweeps
+Requires-Dist: sweeps>=0.2.0; extra == 'sweeps'
+Provides-Extra: workspaces
+Requires-Dist: wandb-workspaces; extra == 'workspaces'
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="https://i.imgur.com/dQLeGCc.png" width="600" /><br><br>
+</div>
+
+<p align="center">
+<a href="https://pypi.python.org/pypi/wandb"><img src="https://img.shields.io/pypi/v/wandb" /></a>
+<a href="https://anaconda.org/conda-forge/wandb"><img src="https://img.shields.io/conda/vn/conda-forge/wandb" /></a>
+<a href="https://pypi.python.org/pypi/wandb"><img src="https://img.shields.io/pypi/pyversions/wandb" /></a>
+<a href="https://circleci.com/gh/wandb/wandb"><img src="https://img.shields.io/circleci/build/github/wandb/wandb/main" /></a>
+<a href="https://codecov.io/gh/wandb/wandb"><img src="https://img.shields.io/codecov/c/gh/wandb/wandb" /></a>
+</p>
+<p align='center'>
+<a href="https://colab.research.google.com/github/wandb/examples/blob/master/colabs/intro/Intro_to_Weights_%26_Biases.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" /></a>
+</p>
+
+Use W&B to build better models faster. Track and visualize all the pieces of your machine learning pipeline, from datasets to production machine learning models. Get started with W&B today, [sign up for a W&B account](https://wandb.com?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=readme)!
+
+<br>
+
+Building an LLM app? Track, debug, evaluate, and monitor LLM apps with [Weave](https://wandb.github.io/weave?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=readme), our new suite of tools for GenAI.
+
+&nbsp;
+
+# Documentation
+
+See the [W&B Developer Guide](https://docs.wandb.ai/?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=documentation) and [API Reference Guide](https://docs.wandb.ai/training/api-reference#api-overview?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=documentation) for a full technical description of the W&B platform.
+
+&nbsp;
+
+# Quickstart
+
+Install W&B to track, visualize, and manage machine learning experiments of any size.
+
+## Install the wandb library
+
+```shell
+pip install wandb
+```
+
+## Sign up and create an API key
+
+Sign up for a [W&B account](https://wandb.ai/login?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=quickstart). Optionally, use the `wandb login` CLI to configure an API key on your machine. You can skip this step -- W&B will prompt you for an API key the first time you use it.
+
+## Create a machine learning training experiment
+
+In your Python script or notebook, initialize a W&B run with `wandb.init()`.
+Specify hyperparameters and log metrics and other information to W&B.
+
+```python
+import wandb
+
+# Project that the run is recorded to
+project = "my-awesome-project"
+
+# Dictionary with hyperparameters
+config = {"epochs" : 1337, "lr" : 3e-4}
+
+# The `with` syntax marks the run as finished upon exiting the `with` block,
+# and it marks the run "failed" if there's an exception.
+#
+# In a notebook, it may be more convenient to write `run = wandb.init()`
+# and manually call `run.finish()` instead of using a `with` block.
+with wandb.init(project=project, config=config) as run:
+    # Training code here
+
+    # Log values to W&B with run.log()
+    run.log({"accuracy": 0.9, "loss": 0.1})
+```
+
+Visit [wandb.ai/home](https://wandb.ai/home) to view recorded metrics such as accuracy and loss and how they changed during each training step. Each run object appears in the Runs column with generated names.
+
+&nbsp;
+
+# Integrations
+
+W&B [integrates](https://docs.wandb.ai/models/integrations) with popular ML frameworks and libraries making it fast and easy to set up experiment tracking and data versioning inside existing projects.
+
+For developers adding W&B to a new framework, follow the [W&B Developer Guide](https://docs.wandb.ai/models/integrations/add-wandb-to-any-library).
+
+&nbsp;
+
+# W&B Hosting Options
+
+Weights & Biases is available in the cloud or installed on your private infrastructure. Set up a W&B Server in a production environment in one of three ways:
+
+1. [Multi-tenant Cloud](https://docs.wandb.ai/platform/hosting/hosting-options/multi_tenant_cloud?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=hosting): Fully managed platform deployed in W&B’s Google Cloud Platform (GCP) account in GCP’s North America regions.
+2. [Dedicated Cloud](https://docs.wandb.ai/platform/hosting/hosting-options/dedicated_cloud?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=hosting): Single-tenant, fully managed platform deployed in W&B’s AWS, GCP, or Azure cloud accounts. Each Dedicated Cloud instance has its own isolated network, compute and storage from other W&B Dedicated Cloud instances.
+3. [Self-Managed](https://docs.wandb.ai/platform/hosting/hosting-options/self-managed?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=hosting): Deploy W&B Server on your AWS, GCP, or Azure cloud account or within your on-premises infrastructure.
+
+See the [Hosting documentation](https://docs.wandb.ai/guides/hosting?utm_source=github&utm_medium=code&utm_campaign=wandb&utm_content=hosting) in the W&B Developer Guide for more information.
+
+&nbsp;
+
+# Python Version Support
+
+We are committed to supporting our minimum required Python version for _at least_ six months after its official end-of-life (EOL) date, as defined by the Python Software Foundation. You can find a list of Python EOL dates [here](https://devguide.python.org/versions/).
+
+When we discontinue support for a Python version, we will increment the library’s minor version number to reflect this change.
+
+&nbsp;
+
+# Contribution guidelines
+
+Weights & Biases ❤️ open source, and we welcome contributions from the community! See the [Contribution guide](https://github.com/wandb/wandb/blob/main/CONTRIBUTING.md) for more information on the development workflow and the internals of the wandb library. For wandb bugs and feature requests, visit [GitHub Issues](https://github.com/wandb/wandb/issues) or contact support@wandb.com.
+
+&nbsp;
+
+# W&B Community
+
+Be a part of the growing W&B Community and interact with the W&B team in our [Discord](https://wandb.me/discord). Stay connected with the latest ML updates and tutorials with [W&B Fully Connected](https://wandb.ai/fully-connected).
+
+&nbsp;
+
+# License
+
+[MIT License](https://github.com/wandb/wandb/blob/main/LICENSE)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb-0.25.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-manylinux_2_28_x86_64
+

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb-0.25.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+wandb = wandb.cli.cli:cli
+wb = wandb.cli.cli:cli

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb-0.25.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Weights and Biases, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/keras/__init__.py

@@ -0,0 +1,11 @@
+"""Tools for integrating `wandb` with [`Keras`](https://keras.io/)."""
+
+__all__ = (
+    "WandbCallback",
+    "WandbMetricsLogger",
+    "WandbModelCheckpoint",
+    "WandbEvalCallback",
+)
+
+from .callbacks import WandbEvalCallback, WandbMetricsLogger, WandbModelCheckpoint
+from .keras import WandbCallback  # TODO: legacy callback to be deprecated

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/keras/callbacks/__init__.py

@@ -0,0 +1,5 @@
+__all__ = ("WandbMetricsLogger", "WandbModelCheckpoint", "WandbEvalCallback")
+
+from .metrics_logger import WandbMetricsLogger
+from .model_checkpoint import WandbModelCheckpoint
+from .tables_builder import WandbEvalCallback

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/keras/callbacks/metrics_logger.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+import tensorflow as tf  # type: ignore
+from tensorflow.keras import callbacks
+
+import wandb
+from wandb.integration.keras.keras import patch_tf_keras
+from wandb.sdk.lib import telemetry
+
+LogStrategy = Literal["epoch", "batch"]
+
+
+patch_tf_keras()
+
+
+class WandbMetricsLogger(callbacks.Callback):
+    """Logger that sends system metrics to W&B.
+
+    `WandbMetricsLogger` automatically logs the `logs` dictionary that callback methods
+    take as argument to wandb.
+
+    This callback automatically logs the following to a W&B run page:
+    * system (CPU/GPU/TPU) metrics,
+    * train and validation metrics defined in `model.compile`,
+    * learning rate (both for a fixed value or a learning rate scheduler)
+
+    Notes:
+    If you resume training by passing `initial_epoch` to `model.fit` and you are using a
+    learning rate scheduler, make sure to pass `initial_global_step` to
+    `WandbMetricsLogger`. The `initial_global_step` is `step_size * initial_step`, where
+    `step_size` is number of training steps per epoch. `step_size` can be calculated as
+    the product of the cardinality of the training dataset and the batch size.
+
+    Args:
+        log_freq: ("epoch", "batch", or int) if "epoch", logs metrics
+            at the end of each epoch. If "batch", logs metrics at the end
+            of each batch. If an integer, logs metrics at the end of that
+            many batches. Defaults to "epoch".
+        initial_global_step: (int) Use this argument to correctly log the
+            learning rate when you resume training from some `initial_epoch`,
+            and a learning rate scheduler is used. This can be computed as
+            `step_size * initial_step`. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        log_freq: LogStrategy | int = "epoch",
+        initial_global_step: int = 0,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if wandb.run is None:
+            raise wandb.Error(
+                "You must call `wandb.init()` before WandbMetricsLogger()"
+            )
+
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras_metrics_logger = True
+
+        if log_freq == "batch":
+            log_freq = 1
+
+        self.logging_batch_wise = isinstance(log_freq, int)
+        self.log_freq: Any = log_freq if self.logging_batch_wise else None
+        self.global_batch = 0
+        self.global_step = initial_global_step
+
+        if self.logging_batch_wise:
+            # define custom x-axis for batch logging.
+            wandb.define_metric("batch/batch_step")
+            # set all batch metrics to be logged against batch_step.
+            wandb.define_metric("batch/*", step_metric="batch/batch_step")
+        else:
+            # define custom x-axis for epoch-wise logging.
+            wandb.define_metric("epoch/epoch")
+            # set all epoch-wise metrics to be logged against epoch.
+            wandb.define_metric("epoch/*", step_metric="epoch/epoch")
+
+    def _get_lr(self) -> float | None:
+        if isinstance(
+            self.model.optimizer.learning_rate,
+            (tf.Variable, tf.Tensor),
+        ) or (
+            hasattr(self.model.optimizer.learning_rate, "shape")
+            and self.model.optimizer.learning_rate.shape == ()
+        ):
+            return float(self.model.optimizer.learning_rate.numpy().item())
+        try:
+            return float(
+                self.model.optimizer.learning_rate(step=self.global_step).numpy().item()
+            )
+        except Exception as e:
+            wandb.termerror(f"Unable to log learning rate: {e}", repeat=False)
+            return None
+
+    def on_epoch_end(self, epoch: int, logs: dict[str, Any] | None = None) -> None:
+        """Called at the end of an epoch."""
+        logs = dict() if logs is None else {f"epoch/{k}": v for k, v in logs.items()}
+
+        logs["epoch/epoch"] = epoch
+
+        lr = self._get_lr()
+        if lr is not None:
+            logs["epoch/learning_rate"] = lr
+
+        wandb.log(logs)
+
+    def on_batch_end(self, batch: int, logs: dict[str, Any] | None = None) -> None:
+        self.global_step += 1
+        """An alias for `on_train_batch_end` for backwards compatibility."""
+        if self.logging_batch_wise and batch % self.log_freq == 0:
+            logs = {f"batch/{k}": v for k, v in logs.items()} if logs else {}
+            logs["batch/batch_step"] = self.global_batch
+
+            lr = self._get_lr()
+            if lr is not None:
+                logs["batch/learning_rate"] = lr
+
+            wandb.log(logs)
+
+            self.global_batch += self.log_freq
+
+    def on_train_batch_end(
+        self, batch: int, logs: dict[str, Any] | None = None
+    ) -> None:
+        """Called at the end of a training batch in `fit` methods."""
+        self.on_batch_end(batch, logs if logs else {})

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/keras/callbacks/model_checkpoint.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import os
+import string
+from typing import Any, Literal
+
+import tensorflow as tf  # type: ignore
+from tensorflow.keras import callbacks  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry
+from wandb.sdk.lib.paths import StrPath
+
+from ..keras import patch_tf_keras
+
+Mode = Literal["auto", "min", "max"]
+SaveStrategy = Literal["epoch"]
+
+patch_tf_keras()
+
+
+class WandbModelCheckpoint(callbacks.ModelCheckpoint):
+    """A checkpoint that periodically saves a Keras model or model weights.
+
+    Saved weights are uploaded to W&B as a `wandb.Artifact`.
+
+    Since this callback is subclassed from `tf.keras.callbacks.ModelCheckpoint`, the
+    checkpointing logic is taken care of by the parent callback. You can learn more
+    here: https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ModelCheckpoint
+
+    This callback is to be used in conjunction with training using `model.fit()` to save
+    a model or weights (in a checkpoint file) at some interval. The model checkpoints
+    will be logged as W&B Artifacts. You can learn more here:
+    https://docs.wandb.ai/guides/artifacts
+
+    This callback provides the following features:
+        - Save the model that has achieved "best performance" based on "monitor".
+        - Save the model at the end of every epoch regardless of the performance.
+        - Save the model at the end of epoch or after a fixed number of training batches.
+        - Save only model weights, or save the whole model.
+        - Save the model either in SavedModel format or in `.h5` format.
+
+    Args:
+        filepath: (Union[str, os.PathLike]) path to save the model file. `filepath`
+            can contain named formatting options, which will be filled by the value
+            of `epoch` and keys in `logs` (passed in `on_epoch_end`). For example:
+            if `filepath` is `model-{epoch:02d}-{val_loss:.2f}`, then the
+            model checkpoints will be saved with the epoch number and the
+            validation loss in the filename.
+        monitor: (str) The metric name to monitor. Default to "val_loss".
+        verbose: (int) Verbosity mode, 0 or 1. Mode 0 is silent, and mode 1
+            displays messages when the callback takes an action.
+        save_best_only: (bool) if `save_best_only=True`, it only saves when the model
+            is considered the "best" and the latest best model according to the
+            quantity monitored will not be overwritten. If `filepath` doesn't contain
+            formatting options like `{epoch}` then `filepath` will be overwritten by
+            each new better model locally. The model logged as an artifact will still be
+            associated with the correct `monitor`.  Artifacts will be uploaded
+            continuously and versioned separately as a new best model is found.
+        save_weights_only: (bool) if True, then only the model's weights will be saved.
+        mode: (Mode) one of {'auto', 'min', 'max'}. For `val_acc`, this should be `max`,
+            for `val_loss` this should be `min`, etc.
+        save_freq: (Union[SaveStrategy, int]) `epoch` or integer. When using `'epoch'`,
+            the callback saves the model after each epoch. When using an integer, the
+            callback saves the model at end of this many batches.
+            Note that when monitoring validation metrics such as `val_acc` or `val_loss`,
+            save_freq must be set to "epoch" as those metrics are only available at the
+            end of an epoch.
+        initial_value_threshold: (Optional[float]) Floating point initial "best" value of the metric
+            to be monitored.
+    """
+
+    def __init__(
+        self,
+        filepath: StrPath,
+        monitor: str = "val_loss",
+        verbose: int = 0,
+        save_best_only: bool = False,
+        save_weights_only: bool = False,
+        mode: Mode = "auto",
+        save_freq: SaveStrategy | int = "epoch",
+        initial_value_threshold: float | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(
+            filepath=filepath,
+            monitor=monitor,
+            verbose=verbose,
+            save_best_only=save_best_only,
+            save_weights_only=save_weights_only,
+            mode=mode,
+            save_freq=save_freq,
+            initial_value_threshold=initial_value_threshold,
+            **kwargs,
+        )
+        if wandb.run is None:
+            raise wandb.Error(
+                "You must call `wandb.init()` before `WandbModelCheckpoint()`"
+            )
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras_model_checkpoint = True
+
+        self.save_weights_only = save_weights_only
+
+        # User-friendly warning when trying to save the best model.
+        if self.save_best_only:
+            self._check_filepath()
+
+        self._is_old_tf_keras_version: bool | None = None
+
+    def on_train_batch_end(
+        self, batch: int, logs: dict[str, float] | None = None
+    ) -> None:
+        if self._should_save_on_batch(batch):
+            if self.is_old_tf_keras_version:
+                # Save the model and get filepath
+                self._save_model(epoch=self._current_epoch, logs=logs)
+                filepath = self._get_file_path(epoch=self._current_epoch, logs=logs)
+            else:
+                # Save the model and get filepath
+                self._save_model(epoch=self._current_epoch, batch=batch, logs=logs)
+                filepath = self._get_file_path(
+                    epoch=self._current_epoch, batch=batch, logs=logs
+                )
+            # Log the model as artifact
+            aliases = ["latest", f"epoch_{self._current_epoch}_batch_{batch}"]
+            self._log_ckpt_as_artifact(filepath, aliases=aliases)
+
+    def on_epoch_end(self, epoch: int, logs: dict[str, float] | None = None) -> None:
+        super().on_epoch_end(epoch, logs)
+        # Check if model checkpoint is created at the end of epoch.
+        if self.save_freq == "epoch":
+            # Get filepath where the model checkpoint is saved.
+            if self.is_old_tf_keras_version:
+                filepath = self._get_file_path(epoch=epoch, logs=logs)
+            else:
+                filepath = self._get_file_path(epoch=epoch, batch=None, logs=logs)
+            # Log the model as artifact
+            aliases = ["latest", f"epoch_{epoch}"]
+            self._log_ckpt_as_artifact(filepath, aliases=aliases)
+
+    def _log_ckpt_as_artifact(
+        self, filepath: str, aliases: list[str] | None = None
+    ) -> None:
+        """Log model checkpoint as  W&B Artifact."""
+        try:
+            assert wandb.run is not None
+            model_checkpoint_artifact = wandb.Artifact(
+                f"run_{wandb.run.id}_model", type="model"
+            )
+            if os.path.isfile(filepath):
+                model_checkpoint_artifact.add_file(filepath)
+            elif os.path.isdir(filepath):
+                model_checkpoint_artifact.add_dir(filepath)
+            else:
+                raise FileNotFoundError(f"No such file or directory {filepath}")
+            wandb.log_artifact(model_checkpoint_artifact, aliases=aliases or [])
+        except ValueError:
+            # This error occurs when `save_best_only=True` and the model
+            # checkpoint is not saved for that epoch/batch. Since TF/Keras
+            # is giving friendly log, we can avoid clustering the stdout.
+            pass
+
+    def _check_filepath(self) -> None:
+        placeholders = []
+        for tup in string.Formatter().parse(self.filepath):
+            if tup[1] is not None:
+                placeholders.append(tup[1])
+        if len(placeholders) == 0:
+            wandb.termwarn(
+                "When using `save_best_only`, ensure that the `filepath` argument "
+                "contains formatting placeholders like `{epoch:02d}` or `{batch:02d}`. "
+                "This ensures correct interpretation of the logged artifacts.",
+                repeat=False,
+            )
+
+    @property
+    def is_old_tf_keras_version(self) -> bool | None:
+        if self._is_old_tf_keras_version is None:
+            from packaging.version import parse
+
+            try:
+                if parse(tf.keras.__version__) < parse("2.6.0"):
+                    self._is_old_tf_keras_version = True
+                else:
+                    self._is_old_tf_keras_version = False
+            except AttributeError:
+                self._is_old_tf_keras_version = False
+
+        return self._is_old_tf_keras_version

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/keras/callbacks/tables_builder.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import abc
+from typing import Any
+
+from tensorflow.keras.callbacks import Callback  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry
+
+
+class WandbEvalCallback(Callback, abc.ABC):
+    """Abstract base class to build Keras callbacks for model prediction visualization.
+
+    You can build callbacks for visualizing model predictions `on_epoch_end`
+    that can be passed to `model.fit()` for classification, object detection,
+    segmentation, etc. tasks.
+
+    To use this, inherit from this base callback class and implement the
+    `add_ground_truth` and `add_model_prediction` methods.
+
+    The base class will take care of the following:
+    - Initialize `data_table` for logging the ground truth and
+        `pred_table` for predictions.
+    - The data uploaded to `data_table` is used as a reference for the
+        `pred_table`. This is to reduce the memory footprint. The `data_table_ref`
+        is a list that can be used to access the referenced data.
+        Check out the example below to see how it's done.
+    - Log the tables to W&B as W&B Artifacts.
+    - Each new `pred_table` is logged as a new version with aliases.
+
+    Example:
+        ```python
+        class WandbClfEvalCallback(WandbEvalCallback):
+            def __init__(self, validation_data, data_table_columns, pred_table_columns):
+                super().__init__(data_table_columns, pred_table_columns)
+
+                self.x = validation_data[0]
+                self.y = validation_data[1]
+
+            def add_ground_truth(self):
+                for idx, (image, label) in enumerate(zip(self.x, self.y)):
+                    self.data_table.add_data(idx, wandb.Image(image), label)
+
+            def add_model_predictions(self, epoch):
+                preds = self.model.predict(self.x, verbose=0)
+                preds = tf.argmax(preds, axis=-1)
+
+                data_table_ref = self.data_table_ref
+                table_idxs = data_table_ref.get_index()
+
+                for idx in table_idxs:
+                    pred = preds[idx]
+                    self.pred_table.add_data(
+                        epoch,
+                        data_table_ref.data[idx][0],
+                        data_table_ref.data[idx][1],
+                        data_table_ref.data[idx][2],
+                        pred,
+                    )
+
+
+        model.fit(
+            x,
+            y,
+            epochs=2,
+            validation_data=(x, y),
+            callbacks=[
+                WandbClfEvalCallback(
+                    validation_data=(x, y),
+                    data_table_columns=["idx", "image", "label"],
+                    pred_table_columns=["epoch", "idx", "image", "label", "pred"],
+                )
+            ],
+        )
+        ```
+
+    To have more fine-grained control, you can override the `on_train_begin` and
+    `on_epoch_end` methods. If you want to log the samples after N batched, you
+    can implement `on_train_batch_end` method.
+    """
+
+    def __init__(
+        self,
+        data_table_columns: list[str],
+        pred_table_columns: list[str],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if wandb.run is None:
+            raise wandb.Error(
+                "You must call `wandb.init()` first before using this callback."
+            )
+
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras_wandb_eval_callback = True
+
+        self.data_table_columns = data_table_columns
+        self.pred_table_columns = pred_table_columns
+
+    def on_train_begin(self, logs: dict[str, float] | None = None) -> None:
+        # Initialize the data_table
+        self.init_data_table(column_names=self.data_table_columns)
+        # Log the ground truth data
+        self.add_ground_truth(logs)
+        # Log the data_table as W&B Artifacts
+        self.log_data_table()
+
+    def on_epoch_end(self, epoch: int, logs: dict[str, float] | None = None) -> None:
+        # Initialize the pred_table
+        self.init_pred_table(column_names=self.pred_table_columns)
+        # Log the model prediction
+        self.add_model_predictions(epoch, logs)
+        # Log the pred_table as W&B Artifacts
+        self.log_pred_table()
+
+    @abc.abstractmethod
+    def add_ground_truth(self, logs: dict[str, float] | None = None) -> None:
+        """Add ground truth data to `data_table`.
+
+        Use this method to write the logic for adding validation/training data to
+        `data_table` initialized using `init_data_table` method.
+
+        Example:
+            ```python
+            for idx, data in enumerate(dataloader):
+                self.data_table.add_data(idx, data)
+            ```
+        This method is called once `on_train_begin` or equivalent hook.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__}.add_ground_truth")
+
+    @abc.abstractmethod
+    def add_model_predictions(
+        self, epoch: int, logs: dict[str, float] | None = None
+    ) -> None:
+        """Add a prediction from a model to `pred_table`.
+
+        Use this method to write the logic for adding model prediction for validation/
+        training data to `pred_table` initialized using `init_pred_table` method.
+
+        Example:
+            ```python
+            # Assuming the dataloader is not shuffling the samples.
+            for idx, data in enumerate(dataloader):
+                preds = model.predict(data)
+                self.pred_table.add_data(
+                    self.data_table_ref.data[idx][0],
+                    self.data_table_ref.data[idx][1],
+                    preds,
+                )
+            ```
+        This method is called `on_epoch_end` or equivalent hook.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__}.add_model_predictions")
+
+    def init_data_table(self, column_names: list[str]) -> None:
+        """Initialize the W&B Tables for validation data.
+
+        Call this method `on_train_begin` or equivalent hook. This is followed by adding
+        data to the table row or column wise.
+
+        Args:
+            column_names: (list) Column names for W&B Tables.
+        """
+        self.data_table = wandb.Table(columns=column_names, allow_mixed_types=True)
+
+    def init_pred_table(self, column_names: list[str]) -> None:
+        """Initialize the W&B Tables for model evaluation.
+
+        Call this method `on_epoch_end` or equivalent hook. This is followed by adding
+        data to the table row or column wise.
+
+        Args:
+            column_names: (list) Column names for W&B Tables.
+        """
+        self.pred_table = wandb.Table(columns=column_names)
+
+    def log_data_table(
+        self, name: str = "val", type: str = "dataset", table_name: str = "val_data"
+    ) -> None:
+        """Log the `data_table` as W&B artifact and call `use_artifact` on it.
+
+        This lets the evaluation table use the reference of already uploaded data
+        (images, text, scalar, etc.) without re-uploading.
+
+        Args:
+            name: (str) A human-readable name for this artifact, which is how you can
+                identify this artifact in the UI or reference it in use_artifact calls.
+                (default is 'val')
+            type: (str) The type of the artifact, which is used to organize and
+                differentiate artifacts. (default is 'dataset')
+            table_name: (str) The name of the table as will be displayed in the UI.
+                (default is 'val_data').
+        """
+        data_artifact = wandb.Artifact(name, type=type)
+        data_artifact.add(self.data_table, table_name)
+
+        # Calling `use_artifact` uploads the data to W&B.
+        assert wandb.run is not None
+        wandb.run.use_artifact(data_artifact)
+        data_artifact.wait()
+
+        # We get the reference table.
+        self.data_table_ref = data_artifact.get(table_name)
+
+    def log_pred_table(
+        self,
+        type: str = "evaluation",
+        table_name: str = "eval_data",
+        aliases: list[str] | None = None,
+    ) -> None:
+        """Log the W&B Tables for model evaluation.
+
+        The table will be logged multiple times creating new version. Use this
+        to compare models at different intervals interactively.
+
+        Args:
+            type: (str) The type of the artifact, which is used to organize and
+                differentiate artifacts. (default is 'evaluation')
+            table_name: (str) The name of the table as will be displayed in the UI.
+                (default is 'eval_data')
+            aliases: (List[str]) List of aliases for the prediction table.
+        """
+        assert wandb.run is not None
+        pred_artifact = wandb.Artifact(f"run_{wandb.run.id}_pred", type=type)
+        pred_artifact.add(self.pred_table, table_name)
+        wandb.run.log_artifact(pred_artifact, aliases=aliases or ["latest"])

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/keras/keras.py

@@ -0,0 +1,1084 @@
+"""keras init."""
+
+import logging
+import operator
+import os
+import shutil
+import sys
+from itertools import chain
+
+import numpy as np
+import tensorflow as tf
+import tensorflow.keras.backend as K  # noqa: N812
+
+import wandb
+from wandb.proto.wandb_telemetry_pb2 import Deprecated
+from wandb.sdk.integration_utils.data_logging import ValidationDataLogger
+from wandb.sdk.lib import telemetry
+from wandb.sdk.lib.deprecation import warn_and_record_deprecation
+from wandb.util import add_import_hook
+
+
+def _check_keras_version():
+    from keras import __version__ as keras_version
+    from packaging.version import parse
+
+    if parse(keras_version) < parse("2.4.0"):
+        wandb.termwarn(
+            f"Keras version {keras_version} is not fully supported. Required keras >= 2.4.0"
+        )
+
+
+def _can_compute_flops() -> bool:
+    """FLOPS computation is restricted to TF 2.x as it requires tf.compat.v1."""
+    from packaging.version import parse
+
+    return parse(tf.__version__) >= parse("2.0.0")
+
+
+if "keras" in sys.modules:
+    _check_keras_version()
+else:
+    add_import_hook("keras", _check_keras_version)
+
+
+logger = logging.getLogger(__name__)
+
+
+def is_dataset(data):
+    dataset_ops = wandb.util.get_module("tensorflow.python.data.ops.dataset_ops")
+    if dataset_ops and hasattr(dataset_ops, "DatasetV2"):
+        dataset_types = (dataset_ops.DatasetV2,)
+        if hasattr(dataset_ops, "DatasetV1"):
+            dataset_types = dataset_types + (dataset_ops.DatasetV1,)
+        return isinstance(data, dataset_types)
+    else:
+        return False
+
+
+def is_generator_like(data):
+    # Checks if data is a generator, Sequence, or Iterator.
+
+    types = (tf.keras.utils.Sequence,)
+    iterator_ops = wandb.util.get_module("tensorflow.python.data.ops.iterator_ops")
+    if iterator_ops:
+        types = types + (iterator_ops.Iterator,)
+        # EagerIterator was in tensorflow < 2
+        if hasattr(iterator_ops, "EagerIterator"):
+            types = types + (iterator_ops.EagerIterator,)
+        elif hasattr(iterator_ops, "IteratorV2"):
+            types = types + (iterator_ops.IteratorV2,)
+    return hasattr(data, "next") or hasattr(data, "__next__") or isinstance(data, types)
+
+
+def patch_tf_keras():  # noqa: C901
+    from packaging.version import parse
+    from tensorflow.python.eager import context
+
+    if parse("2.6.0") <= parse(tf.__version__) < parse("2.13.0"):
+        keras_engine = "keras.engine"
+        try:
+            from keras.engine import training
+            from keras.engine import training_arrays_v1 as training_arrays
+            from keras.engine import training_generator_v1 as training_generator
+        except (ImportError, AttributeError):
+            wandb.termerror("Unable to patch Tensorflow/Keras")
+            logger.exception("exception while trying to patch_tf_keras")
+            return
+    else:
+        keras_engine = "tensorflow.python.keras.engine"
+
+        from tensorflow.python.keras.engine import training
+
+        try:
+            from tensorflow.python.keras.engine import (
+                training_arrays_v1 as training_arrays,
+            )
+            from tensorflow.python.keras.engine import (
+                training_generator_v1 as training_generator,
+            )
+        except (ImportError, AttributeError):
+            try:
+                from tensorflow.python.keras.engine import (
+                    training_arrays,
+                    training_generator,
+                )
+            except (ImportError, AttributeError):
+                wandb.termerror("Unable to patch Tensorflow/Keras")
+                logger.exception("exception while trying to patch_tf_keras")
+                return
+
+    # Tensorflow 2.1
+    training_v2_1 = wandb.util.get_module("tensorflow.python.keras.engine.training_v2")
+    # Tensorflow 2.2
+    training_v2_2 = wandb.util.get_module(f"{keras_engine}.training_v1")
+
+    if training_v2_1:
+        old_v2 = training_v2_1.Loop.fit
+    elif training_v2_2:
+        old_v2 = training.Model.fit
+
+    old_arrays = training_arrays.fit_loop
+    old_generator = training_generator.fit_generator
+
+    def set_wandb_attrs(cbk, val_data):
+        if isinstance(cbk, WandbCallback):
+            if is_generator_like(val_data):
+                cbk.generator = val_data
+            elif is_dataset(val_data):
+                if context.executing_eagerly():
+                    cbk.generator = iter(val_data)
+                else:
+                    wandb.termwarn(
+                        "Found a validation dataset in graph mode, can't patch Keras."
+                    )
+            elif isinstance(val_data, tuple) and isinstance(val_data[0], tf.Tensor):
+                # Graph mode dataset generator
+                def gen():
+                    while True:
+                        yield K.get_session().run(val_data)
+
+                cbk.generator = gen()
+            else:
+                cbk.validation_data = val_data
+
+    def new_arrays(*args, **kwargs):
+        cbks = kwargs.get("callbacks", [])
+        val_inputs = kwargs.get("val_inputs")
+        val_targets = kwargs.get("val_targets")
+        # TODO: these could be generators, why index 0?
+        if val_inputs and val_targets:
+            for cbk in cbks:
+                set_wandb_attrs(cbk, (val_inputs[0], val_targets[0]))
+        return old_arrays(*args, **kwargs)
+
+    def new_generator(*args, **kwargs):
+        cbks = kwargs.get("callbacks", [])
+        val_data = kwargs.get("validation_data")
+        if val_data:
+            for cbk in cbks:
+                set_wandb_attrs(cbk, val_data)
+        return old_generator(*args, **kwargs)
+
+    def new_v2(*args, **kwargs):
+        cbks = kwargs.get("callbacks", [])
+        val_data = kwargs.get("validation_data")
+        if val_data:
+            for cbk in cbks:
+                set_wandb_attrs(cbk, val_data)
+        return old_v2(*args, **kwargs)
+
+    training_arrays.orig_fit_loop = old_arrays
+    training_arrays.fit_loop = new_arrays
+    training_generator.orig_fit_generator = old_generator
+    training_generator.fit_generator = new_generator
+    wandb.patched["keras"].append([f"{keras_engine}.training_arrays", "fit_loop"])
+    wandb.patched["keras"].append(
+        [f"{keras_engine}.training_generator", "fit_generator"]
+    )
+
+    if training_v2_1:
+        training_v2_1.Loop.fit = new_v2
+        wandb.patched["keras"].append(
+            ["tensorflow.python.keras.engine.training_v2.Loop", "fit"]
+        )
+    elif training_v2_2:
+        training.Model.fit = new_v2
+        wandb.patched["keras"].append([f"{keras_engine}.training.Model", "fit"])
+
+
+def _array_has_dtype(array):
+    return hasattr(array, "dtype")
+
+
+def _update_if_numeric(metrics, key, values):
+    if not _array_has_dtype(values):
+        _warn_not_logging(key)
+        return
+
+    if not is_numeric_array(values):
+        _warn_not_logging_non_numeric(key)
+        return
+
+    metrics[key] = wandb.Histogram(values)
+
+
+def is_numeric_array(array):
+    return np.issubdtype(array.dtype, np.number)
+
+
+def _warn_not_logging_non_numeric(name):
+    wandb.termwarn(
+        f"Non-numeric values found in layer: {name}, not logging this layer",
+        repeat=False,
+    )
+
+
+def _warn_not_logging(name):
+    wandb.termwarn(
+        f"Layer {name} has undetermined datatype not logging this layer",
+        repeat=False,
+    )
+
+
+tf_logger = tf.get_logger()
+
+patch_tf_keras()
+
+
+### For gradient logging ###
+
+
+def _get_custom_optimizer_parent_class():
+    from packaging.version import parse
+
+    if parse(tf.__version__) >= parse("2.9.0"):
+        custom_optimizer_parent_class = tf.keras.optimizers.legacy.Optimizer
+    else:
+        custom_optimizer_parent_class = tf.keras.optimizers.Optimizer
+
+    return custom_optimizer_parent_class
+
+
+_custom_optimizer_parent_class = _get_custom_optimizer_parent_class()
+
+
+class _CustomOptimizer(_custom_optimizer_parent_class):
+    def __init__(self):
+        super().__init__(name="CustomOptimizer")
+        self._resource_apply_dense = tf.function(self._resource_apply_dense)
+        self._resource_apply_sparse = tf.function(self._resource_apply_sparse)
+
+    def _resource_apply_dense(self, grad, var):
+        var.assign(grad)
+
+    # this needs to be implemented to prevent a NotImplementedError when
+    # using Lookup layers.
+    def _resource_apply_sparse(self, grad, var, indices):
+        pass
+
+    def get_config(self):
+        return super().get_config()
+
+
+class _GradAccumulatorCallback(tf.keras.callbacks.Callback):
+    """Accumulates gradients during a fit() call when used in conjunction with the CustomOptimizer above."""
+
+    def set_model(self, model):
+        super().set_model(model)
+        self.og_weights = model.get_weights()
+        self.grads = [np.zeros(tuple(w.shape)) for w in model.trainable_weights]
+
+    def on_batch_end(self, batch, logs=None):
+        for g, w in zip(self.grads, self.model.trainable_weights):
+            g += w.numpy()
+        self.model.set_weights(self.og_weights)
+
+    def get_grads(self):
+        return [g.copy() for g in self.grads]
+
+
+###
+
+
+class WandbCallback(tf.keras.callbacks.Callback):
+    """`WandbCallback` automatically integrates keras with wandb.
+
+    Example:
+        ```python
+        model.fit(
+            X_train,
+            y_train,
+            validation_data=(X_test, y_test),
+            callbacks=[WandbCallback()],
+        )
+        ```
+
+    `WandbCallback` will automatically log history data from any
+    metrics collected by keras: loss and anything passed into `keras_model.compile()`.
+
+    `WandbCallback` will set summary metrics for the run associated with the "best" training
+    step, where "best" is defined by the `monitor` and `mode` attributes.  This defaults
+    to the epoch with the minimum `val_loss`. `WandbCallback` will by default save the model
+    associated with the best `epoch`.
+
+    `WandbCallback` can optionally log gradient and parameter histograms.
+
+    `WandbCallback` can optionally save training and validation data for wandb to visualize.
+
+    Args:
+        monitor: (str) name of metric to monitor.  Defaults to `val_loss`.
+        mode: (str) one of {`auto`, `min`, `max`}.
+            `min` - save model when monitor is minimized
+            `max` - save model when monitor is maximized
+            `auto` - try to guess when to save the model (default).
+        save_model:
+            True - save a model when monitor beats all previous epochs
+            False - don't save models
+        save_graph: (boolean) if True save model graph to wandb (default to True).
+        save_weights_only: (boolean) if True, then only the model's weights will be
+            saved (`model.save_weights(filepath)`), else the full model
+            is saved (`model.save(filepath)`).
+        log_weights: (boolean) if True save histograms of the model's layer's weights.
+        log_gradients: (boolean) if True log histograms of the training gradients
+        training_data: (tuple) Same format `(X,y)` as passed to `model.fit`.  This is needed
+            for calculating gradients - this is mandatory if `log_gradients` is `True`.
+        validation_data: (tuple) Same format `(X,y)` as passed to `model.fit`.  A set of data
+            for wandb to visualize.  If this is set, every epoch, wandb will
+            make a small number of predictions and save the results for later visualization. In case
+            you are working with image data, please also set `input_type` and `output_type` in order
+            to log correctly.
+        generator: (generator) a generator that returns validation data for wandb to visualize.  This
+            generator should return tuples `(X,y)`.  Either `validate_data` or generator should
+            be set for wandb to visualize specific data examples. In case you are working with image data,
+            please also set `input_type` and `output_type` in order to log correctly.
+        validation_steps: (int) if `validation_data` is a generator, how many
+            steps to run the generator for the full validation set.
+        labels: (list) If you are visualizing your data with wandb this list of labels
+            will convert numeric output to understandable string if you are building a
+            multiclass classifier.  If you are making a binary classifier you can pass in
+            a list of two labels ["label for false", "label for true"].  If `validate_data`
+            and generator are both false, this won't do anything.
+        predictions: (int) the number of predictions to make for visualization each epoch, max
+            is 100.
+        input_type: (string) type of the model input to help visualization. can be one of:
+            (`image`, `images`, `segmentation_mask`, `auto`).
+        output_type: (string) type of the model output to help visualization. can be one of:
+            (`image`, `images`, `segmentation_mask`, `label`).
+        log_evaluation: (boolean) if True, save a Table containing validation data and the
+            model's predictions at each epoch. See `validation_indexes`,
+            `validation_row_processor`, and `output_row_processor` for additional details.
+        class_colors: ([float, float, float]) if the input or output is a segmentation mask,
+            an array containing an rgb tuple (range 0-1) for each class.
+        log_batch_frequency: (integer) if None, callback will log every epoch.
+            If set to integer, callback will log training metrics every `log_batch_frequency`
+            batches.
+        log_best_prefix: (string) if None, no extra summary metrics will be saved.
+            If set to a string, the monitored metric and epoch will be prepended with this value
+            and stored as summary metrics.
+        validation_indexes: ([wandb.data_types._TableLinkMixin]) an ordered list of index keys to associate
+            with each validation example.  If log_evaluation is True and `validation_indexes` is provided,
+            then a Table of validation data will not be created and instead each prediction will
+            be associated with the row represented by the `TableLinkMixin`. The most common way to obtain
+            such keys are is use `Table.get_index()` which will return a list of row keys.
+        validation_row_processor: (Callable) a function to apply to the validation data, commonly used to visualize the data.
+            The function will receive an `ndx` (int) and a `row` (dict). If your model has a single input,
+            then `row["input"]` will be the input data for the row. Else, it will be keyed based on the name of the
+            input slot. If your fit function takes a single target, then `row["target"]` will be the target data for the row. Else,
+            it will be keyed based on the name of the output slots. For example, if your input data is a single ndarray,
+            but you wish to visualize the data as an Image, then you can provide `lambda ndx, row: {"img": wandb.Image(row["input"])}`
+            as the processor. Ignored if log_evaluation is False or `validation_indexes` are present.
+        output_row_processor: (Callable) same as `validation_row_processor`, but applied to the model's output. `row["output"]` will contain
+            the results of the model output.
+        infer_missing_processors: (bool) Determines if `validation_row_processor` and `output_row_processor`
+            should be inferred if missing. Defaults to True. If `labels` are provided, we will attempt to infer classification-type
+            processors where appropriate.
+        log_evaluation_frequency: (int) Determines the frequency which evaluation results will be logged. Default 0 (only at the end of training).
+            Set to 1 to log every epoch, 2 to log every other epoch, and so on. Has no effect when log_evaluation is False.
+        compute_flops: (bool) Compute the FLOPs of your Keras Sequential or Functional model in GigaFLOPs unit.
+    """
+
+    def __init__(
+        self,
+        monitor="val_loss",
+        verbose=0,
+        mode="auto",
+        save_weights_only=False,
+        log_weights=False,
+        log_gradients=False,
+        save_model=True,
+        training_data=None,
+        validation_data=None,
+        labels=None,
+        predictions=36,
+        generator=None,
+        input_type=None,
+        output_type=None,
+        log_evaluation=False,
+        validation_steps=None,
+        class_colors=None,
+        log_batch_frequency=None,
+        log_best_prefix="best_",
+        save_graph=True,
+        validation_indexes=None,
+        validation_row_processor=None,
+        prediction_row_processor=None,
+        infer_missing_processors=True,
+        log_evaluation_frequency=0,
+        compute_flops=False,
+        **kwargs,
+    ):
+        if wandb.run is None:
+            raise wandb.Error("You must call wandb.init() before WandbCallback()")
+
+        warn_and_record_deprecation(
+            feature=Deprecated(keras_callback=True),
+            message=(
+                "WandbCallback is deprecated and will be removed in a future release. "
+                "Please use the WandbMetricsLogger, WandbModelCheckpoint, and WandbEvalCallback "
+                "callbacks instead. "
+                "See https://docs.wandb.ai/guides/integrations/keras for more information."
+            ),
+        )
+
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras = True
+        self.validation_data = None
+        # This is kept around for legacy reasons
+        if validation_data is not None:
+            if is_generator_like(validation_data):
+                generator = validation_data
+            else:
+                self.validation_data = validation_data
+        if labels is None:
+            labels = []
+        self.labels = labels
+        self.predictions = min(predictions, 100)
+
+        self.monitor = monitor
+        self.verbose = verbose
+        self.save_weights_only = save_weights_only
+        self.save_graph = save_graph
+
+        wandb.save("model-best.h5")
+        self.filepath = os.path.join(wandb.run.dir, "model-best.h5")
+        self.save_model = save_model
+        if save_model:
+            warn_and_record_deprecation(
+                feature=Deprecated(keras_callback__save_model=True),
+                message=(
+                    "The save_model argument by default saves the model in the HDF5 format that cannot save "
+                    "custom objects like subclassed models and custom layers. This behavior will be deprecated "
+                    "in a future release in favor of the SavedModel format. Meanwhile, the HDF5 model is saved "
+                    "as W&B files and the SavedModel as W&B Artifacts."
+                ),
+            )
+
+        self.save_model_as_artifact = True
+        self.log_weights = log_weights
+        self.log_gradients = log_gradients
+        self.training_data = training_data
+        self.generator = generator
+        self._graph_rendered = False
+
+        data_type = kwargs.get("data_type")
+        if data_type is not None:
+            warn_and_record_deprecation(
+                feature=Deprecated(keras_callback__data_type=True),
+                message=(
+                    "The data_type argument of wandb.keras.WandbCallback is deprecated "
+                    "and will be removed in a future release. Please use input_type instead.\n"
+                    "Setting input_type = data_type."
+                ),
+            )
+            input_type = data_type
+        self.input_type = input_type
+        self.output_type = output_type
+        self.log_evaluation = log_evaluation
+        self.validation_steps = validation_steps
+        self.class_colors = np.array(class_colors) if class_colors is not None else None
+        self.log_batch_frequency = log_batch_frequency
+        self.log_best_prefix = log_best_prefix
+        self.compute_flops = compute_flops
+
+        self._prediction_batch_size = None
+
+        if self.log_gradients:
+            if int(tf.__version__.split(".")[0]) < 2:
+                raise Exception("Gradient logging requires tensorflow 2.0 or higher.")
+            if self.training_data is None:
+                raise ValueError(
+                    "training_data argument is required for gradient logging."
+                )
+            if isinstance(self.training_data, (list, tuple)):
+                if len(self.training_data) != 2:
+                    raise ValueError("training data must be a tuple of length two")
+                self._training_data_x, self._training_data_y = self.training_data
+            else:
+                self._training_data_x = (
+                    self.training_data
+                )  # generator, tf.data.Dataset etc
+                self._training_data_y = None
+
+        # From Keras
+        if mode not in ["auto", "min", "max"]:
+            wandb.termwarn(
+                f"WandbCallback mode {mode} is unknown, fallback to auto mode."
+            )
+            mode = "auto"
+
+        if mode == "min":
+            self.monitor_op = operator.lt
+            self.best = float("inf")
+        elif mode == "max":
+            self.monitor_op = operator.gt
+            self.best = float("-inf")
+        else:
+            if "acc" in self.monitor or self.monitor.startswith("fmeasure"):
+                self.monitor_op = operator.gt
+                self.best = float("-inf")
+            else:
+                self.monitor_op = operator.lt
+                self.best = float("inf")
+        # Get the previous best metric for resumed runs
+        previous_best = wandb.run.summary.get(f"{self.log_best_prefix}{self.monitor}")
+        if previous_best is not None:
+            self.best = previous_best
+
+        self._validation_data_logger = None
+        self._validation_indexes = validation_indexes
+        self._validation_row_processor = validation_row_processor
+        self._prediction_row_processor = prediction_row_processor
+        self._infer_missing_processors = infer_missing_processors
+        self._log_evaluation_frequency = log_evaluation_frequency
+        self._model_trained_since_last_eval = False
+
+    def _build_grad_accumulator_model(self):
+        inputs = self.model.inputs
+        outputs = self.model(inputs)
+        grad_acc_model = tf.keras.models.Model(inputs, outputs)
+        grad_acc_model.compile(loss=self.model.loss, optimizer=_CustomOptimizer())
+
+        # make sure magic doesn't think this is a user model
+        grad_acc_model._wandb_internal_model = True
+
+        self._grad_accumulator_model = grad_acc_model
+        self._grad_accumulator_callback = _GradAccumulatorCallback()
+
+    def _implements_train_batch_hooks(self):
+        return self.log_batch_frequency is not None
+
+    def _implements_test_batch_hooks(self):
+        return self.log_batch_frequency is not None
+
+    def _implements_predict_batch_hooks(self):
+        return self.log_batch_frequency is not None
+
+    def set_params(self, params):
+        self.params = params
+
+    def set_model(self, model):
+        super().set_model(model)
+        if self.input_type == "auto" and len(model.inputs) == 1:
+            self.input_type = wandb.util.guess_data_type(
+                model.inputs[0].shape, risky=True
+            )
+        if self.input_type and self.output_type is None and len(model.outputs) == 1:
+            self.output_type = wandb.util.guess_data_type(model.outputs[0].shape)
+        if self.log_gradients:
+            self._build_grad_accumulator_model()
+
+    def _attempt_evaluation_log(self, commit=True):
+        if self.log_evaluation and self._validation_data_logger:
+            try:
+                if not self.model:
+                    wandb.termwarn("WandbCallback unable to read model from trainer")
+                else:
+                    self._validation_data_logger.log_predictions(
+                        predictions=self._validation_data_logger.make_predictions(
+                            self.model.predict
+                        ),
+                        commit=commit,
+                    )
+                    self._model_trained_since_last_eval = False
+            except Exception as e:
+                wandb.termwarn("Error during prediction logging for epoch: " + str(e))
+
+    def on_epoch_end(self, epoch, logs=None):
+        if logs is None:
+            logs = {}
+        if self.log_weights:
+            wandb.log(self._log_weights(), commit=False)
+
+        if self.log_gradients:
+            wandb.log(self._log_gradients(), commit=False)
+
+        if self.input_type in (
+            "image",
+            "images",
+            "segmentation_mask",
+        ) or self.output_type in ("image", "images", "segmentation_mask"):
+            if self.generator:
+                self.validation_data = next(self.generator)
+            if self.validation_data is None:
+                wandb.termwarn(
+                    "No validation_data set, pass a generator to the callback."
+                )
+            elif self.validation_data and len(self.validation_data) > 0:
+                wandb.log(
+                    {"examples": self._log_images(num_images=self.predictions)},
+                    commit=False,
+                )
+
+        if (
+            self._log_evaluation_frequency > 0
+            and epoch % self._log_evaluation_frequency == 0
+        ):
+            self._attempt_evaluation_log(commit=False)
+
+        wandb.log({"epoch": epoch}, commit=False)
+        wandb.log(logs, commit=True)
+
+        self.current = logs.get(self.monitor)
+        if self.current and self.monitor_op(self.current, self.best):
+            if self.log_best_prefix:
+                wandb.run.summary[f"{self.log_best_prefix}{self.monitor}"] = (
+                    self.current
+                )
+                wandb.run.summary["{}{}".format(self.log_best_prefix, "epoch")] = epoch
+                if self.verbose and not self.save_model:
+                    wandb.termlog(
+                        f"Epoch {epoch:05d}: {self.monitor} improved from {self.best:.5f} to {self.current:.5f}"
+                    )
+            if self.save_model:
+                self._save_model(epoch)
+
+            if self.save_model and self.save_model_as_artifact:
+                self._save_model_as_artifact(epoch)
+
+            self.best = self.current
+
+    # This is what keras used pre tensorflow.keras
+    def on_batch_begin(self, batch, logs=None):
+        pass
+
+    # This is what keras used pre tensorflow.keras
+    def on_batch_end(self, batch, logs=None):
+        if self.save_graph and not self._graph_rendered:
+            # Couldn't do this in train_begin because keras may still not be built
+            wandb.run.summary["graph"] = wandb.Graph.from_keras(self.model)
+            self._graph_rendered = True
+
+        if self.log_batch_frequency and batch % self.log_batch_frequency == 0:
+            wandb.log(logs, commit=True)
+
+    def on_train_batch_begin(self, batch, logs=None):
+        self._model_trained_since_last_eval = True
+
+    def on_train_batch_end(self, batch, logs=None):
+        if self.save_graph and not self._graph_rendered:
+            # Couldn't do this in train_begin because keras may still not be built
+            wandb.run.summary["graph"] = wandb.Graph.from_keras(self.model)
+            self._graph_rendered = True
+
+        if self.log_batch_frequency and batch % self.log_batch_frequency == 0:
+            wandb.log(logs, commit=True)
+
+    def on_test_begin(self, logs=None):
+        pass
+
+    def on_test_end(self, logs=None):
+        pass
+
+    def on_test_batch_begin(self, batch, logs=None):
+        pass
+
+    def on_test_batch_end(self, batch, logs=None):
+        pass
+
+    def on_train_begin(self, logs=None):
+        if self.log_evaluation:
+            try:
+                validation_data = None
+                if self.validation_data:
+                    validation_data = self.validation_data
+                elif self.generator:
+                    if not self.validation_steps:
+                        wandb.termwarn(
+                            "WandbCallback is unable to log validation data. "
+                            "When using a generator for validation_data, you must pass validation_steps"
+                        )
+                    else:
+                        x = None
+                        y_true = None
+                        for _ in range(self.validation_steps):
+                            bx, by_true = next(self.generator)
+                            if x is None:
+                                x, y_true = bx, by_true
+                            else:
+                                x, y_true = (
+                                    np.append(x, bx, axis=0),
+                                    np.append(y_true, by_true, axis=0),
+                                )
+                        validation_data = (x, y_true)
+                else:
+                    wandb.termwarn(
+                        "WandbCallback is unable to read validation_data from trainer "
+                        "and therefore cannot log validation data. Ensure Keras is properly "
+                        "patched by calling `from wandb.keras import WandbCallback` at the top of your script."
+                    )
+                if validation_data:
+                    self._validation_data_logger = ValidationDataLogger(
+                        inputs=validation_data[0],
+                        targets=validation_data[1],
+                        indexes=self._validation_indexes,
+                        validation_row_processor=self._validation_row_processor,
+                        prediction_row_processor=self._prediction_row_processor,
+                        class_labels=self.labels,
+                        infer_missing_processors=self._infer_missing_processors,
+                    )
+            except Exception as e:
+                wandb.termwarn(
+                    "Error initializing ValidationDataLogger in WandbCallback. "
+                    f"Skipping logging validation data. Error: {str(e)}"
+                )
+
+        if self.compute_flops and _can_compute_flops():
+            try:
+                wandb.summary["GFLOPs"] = self.get_flops()
+            except Exception:
+                logger.exception("Error computing FLOPs")
+                wandb.termwarn("Unable to compute FLOPs for this model.")
+
+    def on_train_end(self, logs=None):
+        if self._model_trained_since_last_eval:
+            self._attempt_evaluation_log()
+
+    def on_predict_begin(self, logs=None):
+        pass
+
+    def on_predict_end(self, logs=None):
+        pass
+
+    def on_predict_batch_begin(self, batch, logs=None):
+        pass
+
+    def on_predict_batch_end(self, batch, logs=None):
+        pass
+
+    def _logits_to_captions(self, logits):
+        if logits[0].shape[-1] == 1:
+            # Scalar output from the model
+            # TODO: handle validation_y
+            if len(self.labels) == 2:
+                # User has named true and false
+                captions = [
+                    self.labels[1] if logits[0] > 0.5 else self.labels[0]
+                    for logit in logits
+                ]
+            else:
+                if len(self.labels) != 0:
+                    wandb.termwarn(
+                        "keras model is producing a single output, "
+                        'so labels should be a length two array: ["False label", "True label"].'
+                    )
+                captions = [logit[0] for logit in logits]
+        else:
+            # Vector output from the model
+            # TODO: handle validation_y
+            labels = np.argmax(np.stack(logits), axis=1)
+
+            if len(self.labels) > 0:
+                # User has named the categories in self.labels
+                captions = []
+                for label in labels:
+                    try:
+                        captions.append(self.labels[label])
+                    except IndexError:
+                        captions.append(label)
+            else:
+                captions = labels
+        return captions
+
+    def _masks_to_pixels(self, masks):
+        # if its a binary mask, just return it as grayscale instead of picking the argmax
+        if len(masks[0].shape) == 2 or masks[0].shape[-1] == 1:
+            return masks
+        class_colors = (
+            self.class_colors
+            if self.class_colors is not None
+            else np.array(wandb.util.class_colors(masks[0].shape[2]))
+        )
+        imgs = class_colors[np.argmax(masks, axis=-1)]
+        return imgs
+
+    def _log_images(self, num_images=36):
+        validation_X = self.validation_data[0]  # noqa: N806
+        validation_y = self.validation_data[1]
+
+        validation_length = len(validation_X)
+
+        if validation_length > num_images:
+            # pick some data at random
+            indices = np.random.choice(validation_length, num_images, replace=False)
+        else:
+            indices = range(validation_length)
+
+        test_data = []
+        test_output = []
+        for i in indices:
+            test_example = validation_X[i]
+            test_data.append(test_example)
+            test_output.append(validation_y[i])
+
+        if self.model.stateful:
+            predictions = self.model.predict(np.stack(test_data), batch_size=1)
+            self.model.reset_states()
+        else:
+            predictions = self.model.predict(
+                np.stack(test_data), batch_size=self._prediction_batch_size
+            )
+            if len(predictions) != len(test_data):
+                self._prediction_batch_size = 1
+                predictions = self.model.predict(
+                    np.stack(test_data), batch_size=self._prediction_batch_size
+                )
+
+        if self.input_type == "label":
+            if self.output_type in ("image", "images", "segmentation_mask"):
+                captions = self._logits_to_captions(test_data)
+                output_image_data = (
+                    self._masks_to_pixels(predictions)
+                    if self.output_type == "segmentation_mask"
+                    else predictions
+                )
+                reference_image_data = (
+                    self._masks_to_pixels(test_output)
+                    if self.output_type == "segmentation_mask"
+                    else test_output
+                )
+                output_images = [
+                    wandb.Image(data, caption=captions[i], grouping=2)
+                    for i, data in enumerate(output_image_data)
+                ]
+                reference_images = [
+                    wandb.Image(data, caption=captions[i])
+                    for i, data in enumerate(reference_image_data)
+                ]
+                return list(chain.from_iterable(zip(output_images, reference_images)))
+        elif self.input_type in ("image", "images", "segmentation_mask"):
+            input_image_data = (
+                self._masks_to_pixels(test_data)
+                if self.input_type == "segmentation_mask"
+                else test_data
+            )
+            if self.output_type == "label":
+                # we just use the predicted label as the caption for now
+                captions = self._logits_to_captions(predictions)
+                return [
+                    wandb.Image(data, caption=captions[i])
+                    for i, data in enumerate(test_data)
+                ]
+            elif self.output_type in ("image", "images", "segmentation_mask"):
+                output_image_data = (
+                    self._masks_to_pixels(predictions)
+                    if self.output_type == "segmentation_mask"
+                    else predictions
+                )
+                reference_image_data = (
+                    self._masks_to_pixels(test_output)
+                    if self.output_type == "segmentation_mask"
+                    else test_output
+                )
+                input_images = [
+                    wandb.Image(data, grouping=3)
+                    for i, data in enumerate(input_image_data)
+                ]
+                output_images = [
+                    wandb.Image(data) for i, data in enumerate(output_image_data)
+                ]
+                reference_images = [
+                    wandb.Image(data) for i, data in enumerate(reference_image_data)
+                ]
+                return list(
+                    chain.from_iterable(
+                        zip(input_images, output_images, reference_images)
+                    )
+                )
+            else:
+                # unknown output, just log the input images
+                return [wandb.Image(img) for img in test_data]
+        elif self.output_type in ("image", "images", "segmentation_mask"):
+            # unknown input, just log the predicted and reference outputs without captions
+            output_image_data = (
+                self._masks_to_pixels(predictions)
+                if self.output_type == "segmentation_mask"
+                else predictions
+            )
+            reference_image_data = (
+                self._masks_to_pixels(test_output)
+                if self.output_type == "segmentation_mask"
+                else test_output
+            )
+            output_images = [
+                wandb.Image(data, grouping=2)
+                for i, data in enumerate(output_image_data)
+            ]
+            reference_images = [
+                wandb.Image(data) for i, data in enumerate(reference_image_data)
+            ]
+            return list(chain.from_iterable(zip(output_images, reference_images)))
+
+    def _log_weights(self):
+        metrics = {}
+        for layer in self.model.layers:
+            weights = layer.get_weights()
+            if len(weights) == 1:
+                _update_if_numeric(
+                    metrics, "parameters/" + layer.name + ".weights", weights[0]
+                )
+            elif len(weights) == 2:
+                _update_if_numeric(
+                    metrics, "parameters/" + layer.name + ".weights", weights[0]
+                )
+                _update_if_numeric(
+                    metrics, "parameters/" + layer.name + ".bias", weights[1]
+                )
+        return metrics
+
+    def _log_gradients(self):
+        # Suppress callback warnings grad accumulator
+        og_level = tf_logger.level
+        tf_logger.setLevel("ERROR")
+
+        self._grad_accumulator_model.fit(
+            self._training_data_x,
+            self._training_data_y,
+            verbose=0,
+            callbacks=[self._grad_accumulator_callback],
+        )
+        tf_logger.setLevel(og_level)
+        weights = self.model.trainable_weights
+        grads = self._grad_accumulator_callback.grads
+        metrics = {}
+        for weight, grad in zip(weights, grads):
+            metrics["gradients/" + weight.name.split(":")[0] + ".gradient"] = (
+                wandb.Histogram(grad)
+            )
+        return metrics
+
+    def _log_dataframe(self):
+        x, y_true, y_pred = None, None, None
+
+        if self.validation_data:
+            x, y_true = self.validation_data[0], self.validation_data[1]
+            y_pred = self.model.predict(x)
+        elif self.generator:
+            if not self.validation_steps:
+                wandb.termwarn(
+                    "when using a generator for validation data with dataframes, "
+                    "you must pass validation_steps. skipping"
+                )
+                return None
+
+            for _ in range(self.validation_steps):
+                bx, by_true = next(self.generator)
+                by_pred = self.model.predict(bx)
+                if x is None:
+                    x, y_true, y_pred = bx, by_true, by_pred
+                else:
+                    x, y_true, y_pred = (
+                        np.append(x, bx, axis=0),
+                        np.append(y_true, by_true, axis=0),
+                        np.append(y_pred, by_pred, axis=0),
+                    )
+
+        if self.input_type in ("image", "images") and self.output_type == "label":
+            return wandb.image_categorizer_dataframe(
+                x=x, y_true=y_true, y_pred=y_pred, labels=self.labels
+            )
+        elif (
+            self.input_type in ("image", "images")
+            and self.output_type == "segmentation_mask"
+        ):
+            return wandb.image_segmentation_dataframe(
+                x=x,
+                y_true=y_true,
+                y_pred=y_pred,
+                labels=self.labels,
+                class_colors=self.class_colors,
+            )
+        else:
+            wandb.termwarn(
+                f"unknown dataframe type for input_type={self.input_type} and output_type={self.output_type}"
+            )
+            return None
+
+    def _save_model(self, epoch):
+        if wandb.run.disabled:
+            return
+        if self.verbose > 0:
+            wandb.termlog(
+                f"Epoch {epoch:05d}: {self.monitor} improved from {self.best:.5f} to {self.current:.5f}, "
+                f"saving model to {self.filepath}"
+            )
+
+        try:
+            if self.save_weights_only:
+                self.model.save_weights(self.filepath, overwrite=True)
+            else:
+                self.model.save(self.filepath, overwrite=True)
+        # Was getting `RuntimeError: Unable to create link` in TF 1.13.1
+        # also saw `TypeError: can't pickle _thread.RLock objects`
+        except (ImportError, RuntimeError, TypeError, AttributeError):
+            logger.exception("Error saving model in the h5py format")
+            wandb.termerror(
+                "Can't save model in the h5py format. The model will be saved as "
+                "as an W&B Artifact in the 'tf' format."
+            )
+
+    def _save_model_as_artifact(self, epoch):
+        if wandb.run.disabled:
+            return
+
+        # Save the model in the SavedModel format.
+        # TODO: Replace this manual artifact creation with the `log_model` method
+        # after `log_model` is released from beta.
+        self.model.save(self.filepath[:-3], overwrite=True, save_format="tf")
+
+        # Log the model as artifact.
+        name = wandb.util.make_artifact_name_safe(f"model-{wandb.run.name}")
+        model_artifact = wandb.Artifact(name, type="model")
+        model_artifact.add_dir(self.filepath[:-3])
+        wandb.run.log_artifact(model_artifact, aliases=["latest", f"epoch_{epoch}"])
+
+        # Remove the SavedModel from wandb dir as we don't want to log it to save memory.
+        shutil.rmtree(self.filepath[:-3])
+
+    def get_flops(self) -> float:
+        """Calculate FLOPS [GFLOPs] for a tf.keras.Model or tf.keras.Sequential model in inference mode.
+
+        It uses tf.compat.v1.profiler under the hood.
+        """
+        if not hasattr(self, "model"):
+            raise wandb.Error("self.model must be set before using this method.")
+
+        if not isinstance(
+            self.model, (tf.keras.models.Sequential, tf.keras.models.Model)
+        ):
+            raise TypeError(
+                "Calculating FLOPS is only supported for "
+                "`tf.keras.Model` and `tf.keras.Sequential` instances."
+            )
+
+        from tensorflow.python.framework.convert_to_constants import (
+            convert_variables_to_constants_v2_as_graph,
+        )
+
+        # Compute FLOPs for one sample
+        batch_size = 1
+        inputs = [
+            tf.TensorSpec([batch_size] + inp.shape[1:], inp.dtype)
+            for inp in self.model.inputs
+        ]
+
+        # convert tf.keras model into frozen graph to count FLOPs about operations used at inference
+        real_model = tf.function(self.model).get_concrete_function(inputs)
+        frozen_func, _ = convert_variables_to_constants_v2_as_graph(real_model)
+
+        # Calculate FLOPs with tf.profiler
+        run_meta = tf.compat.v1.RunMetadata()
+        opts = (
+            tf.compat.v1.profiler.ProfileOptionBuilder(
+                tf.compat.v1.profiler.ProfileOptionBuilder().float_operation()
+            )
+            .with_empty_output()
+            .build()
+        )
+
+        flops = tf.compat.v1.profiler.profile(
+            graph=frozen_func.graph, run_meta=run_meta, cmd="scope", options=opts
+        )
+
+        # convert to GFLOPs
+        return (flops.total_float_ops / 1e9) / 2

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/kfp/__init__.py

@@ -0,0 +1,6 @@
+__all__ = ["wandb_log", "unpatch_kfp"]
+
+from .kfp_patch import patch_kfp, unpatch_kfp
+from .wandb_logging import wandb_log
+
+patch_kfp()

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/kfp/helpers.py

@@ -0,0 +1,28 @@
+import json
+
+
+def add_wandb_visualization(run, mlpipeline_ui_metadata_path):
+    """NOTE: To use this, you must modify your component to have an output called `mlpipeline_ui_metadata_path` AND call `wandb.init` yourself inside that component.
+
+    Example usage:
+
+    def my_component(..., mlpipeline_ui_metadata_path: OutputPath()):
+        import wandb
+        from wandb.integration.kfp.helpers import add_wandb_visualization
+
+        with wandb.init() as run:
+            add_wandb_visualization(run, mlpipeline_ui_metadata_path)
+
+            ... # the rest of your code here
+    """
+
+    def get_iframe_html(run):
+        return f'<iframe src="{run.url}?kfp=true" style="border:none;width:100%;height:100%;min-width:900px;min-height:600px;"></iframe>'
+
+    iframe_html = get_iframe_html(run)
+    metadata = {
+        "outputs": [{"type": "markdown", "storage": "inline", "source": iframe_html}]
+    }
+
+    with open(mlpipeline_ui_metadata_path, "w") as metadata_file:
+        json.dump(metadata, metadata_file)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/kfp/kfp_patch.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import inspect
+import itertools
+import textwrap
+from collections.abc import Mapping
+from typing import Callable
+
+import wandb
+
+try:
+    from kfp import __version__ as kfp_version
+    from kfp.components import structures
+    from kfp.components._components import _create_task_factory_from_component_spec
+    from kfp.components._python_op import _func_to_component_spec
+    from packaging.version import parse
+
+    MIN_KFP_VERSION = "1.6.1"
+
+    if parse(kfp_version) < parse(MIN_KFP_VERSION):
+        wandb.termwarn(
+            f"Your version of kfp {kfp_version} may not work.  This integration requires kfp>={MIN_KFP_VERSION}"
+        )
+
+except ImportError:
+    wandb.termerror("kfp not found!  Please `pip install kfp`")
+
+from .wandb_logging import wandb_log
+
+decorator_code = inspect.getsource(wandb_log)
+wandb_logging_extras = f"""
+import typing
+from typing import NamedTuple
+
+import collections
+from collections import namedtuple
+
+import kfp
+from kfp import components
+from kfp.components import InputPath, OutputPath
+
+import wandb
+
+{decorator_code}
+"""
+
+
+def full_path_exists(full_func):
+    def get_parent_child_pairs(full_func):
+        components = full_func.split(".")
+        parents, children = [], []
+        for i, _ in enumerate(components[:-1], 1):
+            parent = ".".join(components[:i])
+            child = components[i]
+            parents.append(parent)
+            children.append(child)
+        return zip(parents, children)
+
+    for parent, child in get_parent_child_pairs(full_func):
+        module = wandb.util.get_module(parent)
+        if not module or not hasattr(module, child) or getattr(module, child) is None:
+            return False
+    return True
+
+
+def patch(module_name, func):
+    module = wandb.util.get_module(module_name)
+    success = False
+
+    full_func = f"{module_name}.{func.__name__}"
+    if not full_path_exists(full_func):
+        wandb.termerror(
+            f"Failed to patch {module_name}.{func.__name__}!  Please check if this package/module is installed!"
+        )
+    else:
+        wandb.patched.setdefault(module.__name__, [])
+        # if already patched, do not patch again
+        if [module, func.__name__] not in wandb.patched[module.__name__]:
+            setattr(module, f"orig_{func.__name__}", getattr(module, func.__name__))
+            setattr(module, func.__name__, func)
+            wandb.patched[module.__name__].append([module, func.__name__])
+        success = True
+
+    return success
+
+
+def unpatch(module_name):
+    if module_name in wandb.patched:
+        for module, func in wandb.patched[module_name]:
+            setattr(module, func, getattr(module, f"orig_{func}"))
+        wandb.patched[module_name] = []
+
+
+def unpatch_kfp():
+    unpatch("kfp.components")
+    unpatch("kfp.components._python_op")
+    unpatch("wandb.integration.kfp")
+
+
+def patch_kfp():
+    to_patch = [
+        (
+            "kfp.components",
+            create_component_from_func,
+        ),
+        (
+            "kfp.components._python_op",
+            create_component_from_func,
+        ),
+        (
+            "kfp.components._python_op",
+            _get_function_source_definition,
+        ),
+        ("kfp.components._python_op", strip_type_hints),
+    ]
+
+    successes = []
+    for module_name, func in to_patch:
+        success = patch(module_name, func)
+        successes.append(success)
+    if not all(successes):
+        wandb.termerror(
+            "Failed to patch one or more kfp functions.  Patching @wandb_log decorator to no-op."
+        )
+        patch("wandb.integration.kfp", wandb_log)
+
+
+def wandb_log(
+    func=None,
+    # /,  # py38 only
+    log_component_file=True,
+):
+    """Wrap a standard python function and log to W&B.
+
+    NOTE: Because patching failed, this decorator is a no-op.
+    """
+    from functools import wraps
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    if func is None:
+        return decorator
+    else:
+        return decorator(func)
+
+
+def _get_function_source_definition(func: Callable) -> str:
+    """Get the source code of a function.
+
+    This function is modified from KFP.  The original source is below:
+    https://github.com/kubeflow/pipelines/blob/b6406b02f45cdb195c7b99e2f6d22bf85b12268b/sdk/python/kfp/components/_python_op.py#L300-L319.
+    """
+    func_code = inspect.getsource(func)
+
+    # Function might be defined in some indented scope (e.g. in another
+    # function). We need to handle this and properly dedent the function source
+    # code
+    func_code = textwrap.dedent(func_code)
+    func_code_lines = func_code.split("\n")
+
+    # For wandb, allow decorators (so we can use the @wandb_log decorator)
+    func_code_lines = itertools.dropwhile(
+        lambda x: not (x.startswith(("def", "@wandb_log"))),
+        func_code_lines,
+    )
+
+    if not func_code_lines:
+        raise ValueError(
+            f'Failed to dedent and clean up the source of function "{func.__name__}". '
+            "It is probably not properly indented."
+        )
+
+    return "\n".join(func_code_lines)
+
+
+def create_component_from_func(
+    func: Callable,
+    output_component_file: str | None = None,
+    base_image: str | None = None,
+    packages_to_install: list[str] | None = None,
+    annotations: Mapping[str, str] | None = None,
+):
+    '''Convert a Python function to a component and returns a task factory.
+
+    The returned task factory accepts arguments and returns a task object.
+
+    This function is modified from KFP.  The original source is below:
+    https://github.com/kubeflow/pipelines/blob/b6406b02f45cdb195c7b99e2f6d22bf85b12268b/sdk/python/kfp/components/_python_op.py#L998-L1110.
+
+    Args:
+        func: The python function to convert
+        base_image: Optional. Specify a custom Docker container image to use in the component. For lightweight components, the image needs to have python 3.5+. Default is the python image corresponding to the current python environment.
+        output_component_file: Optional. Write a component definition to a local file. The produced component file can be loaded back by calling :code:`load_component_from_file` or :code:`load_component_from_uri`.
+        packages_to_install: Optional. List of [versioned] python packages to pip install before executing the user function.
+        annotations: Optional. Allows adding arbitrary key-value data to the component specification.
+
+    Returns:
+        A factory function with a strongly-typed signature taken from the python function.
+        Once called with the required arguments, the factory constructs a task instance that can run the original function in a container.
+
+    Examples:
+        The function name and docstring are used as component name and description. Argument and return annotations are used as component input/output types::
+
+            def add(a: float, b: float) -> float:
+                """Return sum of two arguments"""
+                return a + b
+
+
+            # add_op is a task factory function that creates a task object when given arguments
+            add_op = create_component_from_func(
+                func=add,
+                base_image="python:3.7",  # Optional
+                output_component_file="add.component.yaml",  # Optional
+                packages_to_install=["pandas==0.24"],  # Optional
+            )
+
+            # The component spec can be accessed through the .component_spec attribute:
+            add_op.component_spec.save("add.component.yaml")
+
+            # The component function can be called with arguments to create a task:
+            add_task = add_op(1, 3)
+
+            # The resulting task has output references, corresponding to the component outputs.
+            # When the function only has a single anonymous return value, the output name is "Output":
+            sum_output_ref = add_task.outputs["Output"]
+
+            # These task output references can be passed to other component functions, constructing a computation graph:
+            task2 = add_op(sum_output_ref, 5)
+
+
+        :code:`create_component_from_func` function can also be used as decorator::
+
+            @create_component_from_func
+            def add_op(a: float, b: float) -> float:
+                """Return sum of two arguments"""
+                return a + b
+
+        To declare a function with multiple return values, use the :code:`NamedTuple` return annotation syntax::
+
+            from typing import NamedTuple
+
+
+            def add_multiply_two_numbers(a: float, b: float) -> NamedTuple(
+                "Outputs", [("sum", float), ("product", float)]
+            ):
+                """Return sum and product of two arguments"""
+                return (a + b, a * b)
+
+
+            add_multiply_op = create_component_from_func(add_multiply_two_numbers)
+
+            # The component function can be called with arguments to create a task:
+            add_multiply_task = add_multiply_op(1, 3)
+
+            # The resulting task has output references, corresponding to the component outputs:
+            sum_output_ref = add_multiply_task.outputs["sum"]
+
+            # These task output references can be passed to other component functions, constructing a computation graph:
+            task2 = add_multiply_op(sum_output_ref, 5)
+
+        Bigger data should be read from files and written to files.
+        Use the :py:class:`kfp.components.InputPath` parameter annotation to tell the system that the function wants to consume the corresponding input data as a file. The system will download the data, write it to a local file and then pass the **path** of that file to the function.
+        Use the :py:class:`kfp.components.OutputPath` parameter annotation to tell the system that the function wants to produce the corresponding output data as a file. The system will prepare and pass the **path** of a file where the function should write the output data. After the function exits, the system will upload the data to the storage system so that it can be passed to downstream components.
+
+        You can specify the type of the consumed/produced data by specifying the type argument to :py:class:`kfp.components.InputPath` and :py:class:`kfp.components.OutputPath`. The type can be a python type or an arbitrary type name string. :code:`OutputPath('CatBoostModel')` means that the function states that the data it has written to a file has type :code:`CatBoostModel`. :code:`InputPath('CatBoostModel')` means that the function states that it expect the data it reads from a file to have type 'CatBoostModel'. When the pipeline author connects inputs to outputs the system checks whether the types match.
+        Every kind of data can be consumed as a file input. Conversely, bigger data should not be consumed by value as all value inputs pass through the command line.
+
+        Example of a component function declaring file input and output::
+
+            def catboost_train_classifier(
+                training_data_path: InputPath(
+                    "CSV"
+                ),  # Path to input data file of type "CSV"
+                trained_model_path: OutputPath(
+                    "CatBoostModel"
+                ),  # Path to output data file of type "CatBoostModel"
+                number_of_trees: int = 100,  # Small output of type "Integer"
+            ) -> NamedTuple(
+                "Outputs",
+                [
+                    ("Accuracy", float),  # Small output of type "Float"
+                    ("Precision", float),  # Small output of type "Float"
+                    ("JobUri", "URI"),  # Small output of type "URI"
+                ],
+            ):
+                """Train CatBoost classification model"""
+                ...
+
+                return (accuracy, precision, recall)
+    '''
+    core_packages = ["wandb", "kfp"]
+
+    if not packages_to_install:
+        packages_to_install = core_packages
+    else:
+        packages_to_install += core_packages
+
+    component_spec = _func_to_component_spec(
+        func=func,
+        extra_code=wandb_logging_extras,
+        base_image=base_image,
+        packages_to_install=packages_to_install,
+    )
+    if annotations:
+        component_spec.metadata = structures.MetadataSpec(
+            annotations=annotations,
+        )
+
+    if output_component_file:
+        component_spec.save(output_component_file)
+
+    return _create_task_factory_from_component_spec(component_spec)
+
+
+def strip_type_hints(source_code: str) -> str:
+    """Strip type hints from source code.
+
+    This function is modified from KFP.  The original source is below:
+    https://github.com/kubeflow/pipelines/blob/b6406b02f45cdb195c7b99e2f6d22bf85b12268b/sdk/python/kfp/components/_python_op.py#L237-L248.
+    """
+    # For wandb, do not strip type hints
+
+    #     try:
+    #         return _strip_type_hints_using_lib2to3(source_code)
+    #     except Exception as ex:
+    #         print('Error when stripping type annotations: ' + str(ex))
+
+    #     try:
+    #         return _strip_type_hints_using_strip_hints(source_code)
+    #     except Exception as ex:
+    #         print('Error when stripping type annotations: ' + str(ex))
+
+    return source_code

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/kfp/wandb_logging.py

@@ -0,0 +1,182 @@
+def wandb_log(  # noqa: C901
+    func=None,
+    # /,  # py38 only
+    log_component_file=True,
+):
+    """Wrap a standard python function and log to W&B."""
+    import json
+    import os
+    from functools import wraps
+    from inspect import Parameter, signature
+
+    from kfp import components
+    from kfp.components import (
+        InputArtifact,
+        InputBinaryFile,
+        InputPath,
+        InputTextFile,
+        OutputArtifact,
+        OutputBinaryFile,
+        OutputPath,
+        OutputTextFile,
+    )
+
+    import wandb
+    from wandb.sdk.lib import telemetry as wb_telemetry
+
+    output_types = (OutputArtifact, OutputBinaryFile, OutputPath, OutputTextFile)
+    input_types = (InputArtifact, InputBinaryFile, InputPath, InputTextFile)
+
+    def isinstance_namedtuple(x):
+        t = type(x)
+        b = t.__bases__
+        if len(b) != 1 or b[0] is not tuple:
+            return False
+        f = getattr(t, "_fields", None)
+        if not isinstance(f, tuple):
+            return False
+        return all(isinstance(n, str) for n in f)
+
+    def get_iframe_html(run):
+        return f'<iframe src="{run.url}?kfp=true" style="border:none;width:100%;height:100%;min-width:900px;min-height:600px;"></iframe>'
+
+    def get_link_back_to_kubeflow():
+        wandb_kubeflow_url = os.getenv("WANDB_KUBEFLOW_URL")
+        return f"{wandb_kubeflow_url}/#/runs/details/{{workflow.uid}}"
+
+    def log_input_scalar(name, data, run=None):
+        run.config[name] = data
+        wandb.termlog(f"Setting config: {name} to {data}")
+
+    def log_input_artifact(name, data, type, run=None):
+        artifact = wandb.Artifact(name, type=type)
+        artifact.add_file(data)
+        run.use_artifact(artifact)
+        wandb.termlog(f"Using artifact: {name}")
+
+    def log_output_scalar(name, data, run=None):
+        if isinstance_namedtuple(data):
+            for k, v in zip(data._fields, data):
+                run.log({f"{func.__name__}.{k}": v})
+        else:
+            run.log({name: data})
+
+    def log_output_artifact(name, data, type, run=None):
+        artifact = wandb.Artifact(name, type=type)
+        artifact.add_file(data)
+        run.log_artifact(artifact)
+        wandb.termlog(f"Logging artifact: {name}")
+
+    def _log_component_file(func, run=None):
+        name = func.__name__
+        output_component_file = f"{name}.yml"
+        components._python_op.func_to_component_file(func, output_component_file)
+        artifact = wandb.Artifact(name, type="kubeflow_component_file")
+        artifact.add_file(output_component_file)
+        run.log_artifact(artifact)
+        wandb.termlog(f"Logging component file: {output_component_file}")
+
+    # Add `mlpipeline_ui_metadata_path` to signature to show W&B run in "ML Visualizations tab"
+    sig = signature(func)
+    no_default = []
+    has_default = []
+
+    for param in sig.parameters.values():
+        if param.default is param.empty:
+            no_default.append(param)
+        else:
+            has_default.append(param)
+
+    new_params = tuple(
+        (
+            *no_default,
+            Parameter(
+                "mlpipeline_ui_metadata_path",
+                annotation=OutputPath(),
+                kind=Parameter.POSITIONAL_OR_KEYWORD,
+            ),
+            *has_default,
+        )
+    )
+    new_sig = sig.replace(parameters=new_params)
+    new_anns = {param.name: param.annotation for param in new_params}
+    if "return" in func.__annotations__:
+        new_anns["return"] = func.__annotations__["return"]
+
+    def decorator(func):
+        input_scalars = {}
+        input_artifacts = {}
+        output_scalars = {}
+        output_artifacts = {}
+
+        for name, ann in func.__annotations__.items():
+            if name == "return":
+                output_scalars[name] = ann
+            elif isinstance(ann, output_types):
+                output_artifacts[name] = ann
+            elif isinstance(ann, input_types):
+                input_artifacts[name] = ann
+            else:
+                input_scalars[name] = ann
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            bound = new_sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+
+            mlpipeline_ui_metadata_path = bound.arguments["mlpipeline_ui_metadata_path"]
+            del bound.arguments["mlpipeline_ui_metadata_path"]
+
+            with wandb.init(
+                job_type=func.__name__,
+                group="{{workflow.annotations.pipelines.kubeflow.org/run_name}}",
+            ) as run:
+                # Link back to the kfp UI
+                kubeflow_url = get_link_back_to_kubeflow()
+                run.notes = kubeflow_url
+                run.config["LINK_TO_KUBEFLOW_RUN"] = kubeflow_url
+
+                iframe_html = get_iframe_html(run)
+                metadata = {
+                    "outputs": [
+                        {
+                            "type": "markdown",
+                            "storage": "inline",
+                            "source": iframe_html,
+                        }
+                    ]
+                }
+
+                with open(mlpipeline_ui_metadata_path, "w") as metadata_file:
+                    json.dump(metadata, metadata_file)
+
+                if log_component_file:
+                    _log_component_file(func, run=run)
+
+                for name, _ in input_scalars.items():
+                    log_input_scalar(name, kwargs[name], run)
+
+                for name, ann in input_artifacts.items():
+                    log_input_artifact(name, kwargs[name], ann.type, run)
+
+                with wb_telemetry.context(run=run) as tel:
+                    tel.feature.kfp_wandb_log = True
+
+                result = func(*bound.args, **bound.kwargs)
+
+                for name, _ in output_scalars.items():
+                    log_output_scalar(name, result, run)
+
+                for name, ann in output_artifacts.items():
+                    log_output_artifact(name, kwargs[name], ann.type, run)
+
+            return result
+
+        wrapper.__signature__ = new_sig
+        wrapper.__annotations__ = new_anns
+        return wrapper
+
+    if func is None:
+        return decorator
+    else:
+        return decorator(func)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/langchain/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("WandbTracer",)
+
+from .wandb_tracer import WandbTracer

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/langchain/wandb_tracer.py

@@ -0,0 +1,49 @@
+"""This module contains an integration with the LangChain library.
+
+Specifically, it exposes a `WandbTracer` class that can be used to stream
+LangChain activity to W&B. The intended usage pattern is to call
+`tracer = WandbTracer()` at the top of the script/notebook, and call
+`tracer.finish()` at the end of the script/notebook.
+ This will stream all LangChain activity to W&B.
+
+Technical Note:
+LangChain is in very rapid development - meaning their APIs and schemas are actively changing.
+As a matter of precaution, any call to LangChain apis, or use of their returned data is wrapped
+in a try/except block. This is to ensure that if a breaking change is introduced, the W&B
+integration will not break user code. The one exception to the rule is at import time. If
+LangChain is not installed, or the symbols are not in the same place, the appropriate error
+will be raised when importing this module.
+"""
+
+from packaging import version
+
+import wandb.util
+from wandb.proto.wandb_telemetry_pb2 import Deprecated
+from wandb.sdk.lib.deprecation import warn_and_record_deprecation
+
+langchain = wandb.util.get_module(
+    name="langchain",
+    required="To use the LangChain WandbTracer you need to have the `langchain` python "
+    "package installed. Please install it with `pip install langchain`.",
+)
+
+if version.parse(langchain.__version__) < version.parse("0.0.188"):
+    raise ValueError(
+        "The Weights & Biases Langchain integration does not support versions 0.0.187 and lower. "
+        "To ensure proper functionality, please use version 0.0.188 or higher."
+    )
+
+# isort: off
+from langchain.callbacks.tracers import WandbTracer  # noqa: E402
+
+
+class WandbTracer(WandbTracer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        warn_and_record_deprecation(
+            feature=Deprecated(langchain_tracer=True),
+            message="This feature is deprecated and has been moved to `langchain`. Enable tracing by setting "
+            "LANGCHAIN_WANDB_TRACING=true in your environment. See the documentation at "
+            "https://python.langchain.com/docs/ecosystem/integrations/agent_with_wandb_tracing for guidance. "
+            "Replace your current import with `from langchain.callbacks.tracers import WandbTracer`.",
+        )

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/lightgbm/__init__.py

@@ -0,0 +1,239 @@
+"""W&B callback for lightgbm.
+
+Really simple callback to get logging for each tree
+
+Example usage:
+
+param_list = [("eta", 0.08), ("max_depth", 6), ("subsample", 0.8), ("colsample_bytree", 0.8), ("alpha", 8), ("num_class", 10)]
+config.update(dict(param_list))
+lgb = lgb.train(param_list, d_train, callbacks=[wandb_callback()])
+"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable
+
+import lightgbm  # type: ignore
+from lightgbm import Booster
+
+import wandb
+from wandb.sdk.lib import telemetry as wb_telemetry
+
+MINIMIZE_METRICS = [
+    "l1",
+    "l2",
+    "rmse",
+    "mape",
+    "huber",
+    "fair",
+    "poisson",
+    "gamma",
+    "binary_logloss",
+]
+
+MAXIMIZE_METRICS = ["map", "auc", "average_precision"]
+
+
+if TYPE_CHECKING:
+    from typing import Any, NamedTuple, Union
+
+    # Note: upstream lightgbm has this defined incorrectly
+    _EvalResultTuple = Union[
+        tuple[str, str, float, bool], tuple[str, str, float, bool, float]
+    ]
+
+    class CallbackEnv(NamedTuple):
+        model: Any
+        params: dict
+        iteration: int
+        begin_interation: int
+        end_iteration: int
+        evaluation_result_list: list[_EvalResultTuple]
+
+
+def _define_metric(data: str, metric_name: str) -> None:
+    """Capture model performance at the best step.
+
+    instead of the last step, of training in your `wandb.summary`
+    """
+    if "loss" in str.lower(metric_name):
+        wandb.define_metric(f"{data}_{metric_name}", summary="min")
+    elif str.lower(metric_name) in MINIMIZE_METRICS:
+        wandb.define_metric(f"{data}_{metric_name}", summary="min")
+    elif str.lower(metric_name) in MAXIMIZE_METRICS:
+        wandb.define_metric(f"{data}_{metric_name}", summary="max")
+
+
+def _checkpoint_artifact(
+    model: "Booster", iteration: int, aliases: "list[str]"
+) -> None:
+    """Upload model checkpoint as W&B artifact."""
+    # NOTE: type ignore required because wandb.run is improperly inferred as None type
+    model_name = f"model_{wandb.run.id}"  # type: ignore
+    model_path = Path(wandb.run.dir) / f"model_ckpt_{iteration}.txt"  # type: ignore
+
+    model.save_model(model_path, num_iteration=iteration)
+
+    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: "Booster") -> None:
+    """Log feature importance."""
+    feat_imps = model.feature_importance()
+    feats = model.feature_name()
+    fi_data = [[feat, feat_imp] for feat, feat_imp in zip(feats, feat_imps)]
+    table = wandb.Table(data=fi_data, columns=["Feature", "Importance"])
+    wandb.log(
+        {
+            "Feature Importance": wandb.plot.bar(
+                table, "Feature", "Importance", title="Feature Importance"
+            )
+        },
+        commit=False,
+    )
+
+
+class _WandbCallback:
+    """Internal class to handle `wandb_callback` logic.
+
+    This callback is adapted form the LightGBM's `_RecordEvaluationCallback`.
+    """
+
+    def __init__(self, log_params: bool = True, define_metric: bool = True) -> None:
+        self.order = 20
+        self.before_iteration = False
+        self.log_params = log_params
+        self.define_metric_bool = define_metric
+
+    def _init(self, env: "CallbackEnv") -> None:
+        with wb_telemetry.context() as tel:
+            tel.feature.lightgbm_wandb_callback = True
+
+        # log the params as W&B config.
+        if self.log_params:
+            wandb.config.update(env.params)
+
+        # use `define_metric` to set the wandb summary to the best metric value.
+        for item in env.evaluation_result_list:
+            if self.define_metric_bool:
+                if len(item) == 4:
+                    data_name, eval_name = item[:2]
+                    _define_metric(data_name, eval_name)
+                else:
+                    data_name, eval_name = item[1].split()
+                    _define_metric(data_name, f"{eval_name}-mean")
+                    _define_metric(data_name, f"{eval_name}-stdv")
+
+    def __call__(self, env: "CallbackEnv") -> None:
+        if env.iteration == env.begin_iteration:  # type: ignore
+            self._init(env)
+
+        for item in env.evaluation_result_list:
+            if len(item) == 4:
+                data_name, eval_name, result = item[:3]
+                wandb.log(
+                    {data_name + "_" + eval_name: result},
+                    commit=False,
+                )
+            else:
+                data_name, eval_name = item[1].split()
+                res_mean = item[2]
+                res_stdv = item[4]
+                wandb.log(
+                    {
+                        data_name + "_" + eval_name + "-mean": res_mean,
+                        data_name + "_" + eval_name + "-stdv": res_stdv,
+                    },
+                    commit=False,
+                )
+
+        # call `commit=True` to log the data as a single W&B step.
+        wandb.log({"iteration": env.iteration}, commit=True)
+
+
+def wandb_callback(log_params: bool = True, define_metric: bool = True) -> Callable:
+    """Automatically integrates LightGBM with wandb.
+
+    Args:
+        log_params: (boolean) if True (default) logs params passed to lightgbm.train as W&B config
+        define_metric: (boolean) if True (default) capture model performance at the best step, instead of the last step, of training in your `wandb.summary`
+
+    Passing `wandb_callback` to LightGBM will:
+      - log params passed to lightgbm.train as W&B config (default).
+      - log evaluation metrics collected by LightGBM, such as rmse, accuracy etc to Weights & Biases
+      - Capture the best metric in `wandb.summary` when `define_metric=True` (default).
+
+    Use `log_summary` as an extension of this callback.
+
+    Example:
+        ```python
+        params = {
+            "boosting_type": "gbdt",
+            "objective": "regression",
+        }
+        gbm = lgb.train(
+            params,
+            lgb_train,
+            num_boost_round=10,
+            valid_sets=lgb_eval,
+            valid_names=("validation"),
+            callbacks=[wandb_callback()],
+        )
+        ```
+    """
+    return _WandbCallback(log_params, define_metric)
+
+
+def log_summary(
+    model: Booster, feature_importance: bool = True, save_model_checkpoint: bool = False
+) -> None:
+    """Log useful metrics about lightgbm model after training is done.
+
+    Args:
+        model: (Booster) is an instance of lightgbm.basic.Booster.
+        feature_importance: (boolean) if True (default), logs the feature importance plot.
+        save_model_checkpoint: (boolean) if True saves the best model and upload as W&B artifacts.
+
+    Using this along with `wandb_callback` will:
+
+    - log `best_iteration` and `best_score` as `wandb.summary`.
+    - log feature importance plot.
+    - save and upload your best trained model to Weights & Biases Artifacts (when `save_model_checkpoint = True`)
+
+    Example:
+        ```python
+        params = {
+            "boosting_type": "gbdt",
+            "objective": "regression",
+        }
+        gbm = lgb.train(
+            params,
+            lgb_train,
+            num_boost_round=10,
+            valid_sets=lgb_eval,
+            valid_names=("validation"),
+            callbacks=[wandb_callback()],
+        )
+
+        log_summary(gbm)
+        ```
+    """
+    if wandb.run is None:
+        raise wandb.Error("You must call wandb.init() before WandbCallback()")
+
+    if not isinstance(model, Booster):
+        raise wandb.Error("Model should be an instance of lightgbm.basic.Booster")
+
+    wandb.run.summary["best_iteration"] = model.best_iteration
+    wandb.run.summary["best_score"] = model.best_score
+
+    # Log feature importance
+    if feature_importance:
+        _log_feature_importance(model)
+
+    if save_model_checkpoint:
+        _checkpoint_artifact(model, model.best_iteration, aliases=["best"])
+
+    with wb_telemetry.context() as tel:
+        tel.feature.lightgbm_log_summary = True

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/lightning/fabric/__init__.py

@@ -0,0 +1,3 @@
+from wandb.integration.lightning.fabric.logger import WandbLogger
+
+__all__ = ("WandbLogger",)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/lightning/fabric/logger.py

@@ -0,0 +1,764 @@
+from __future__ import annotations
+
+import os
+from argparse import Namespace
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from packaging import version
+from typing_extensions import override
+
+import wandb
+from wandb import Artifact
+from wandb.sdk.lib import telemetry
+
+try:
+    import lightning
+    import torch.nn as nn
+    from lightning.fabric.loggers.logger import Logger, rank_zero_experiment
+    from lightning.fabric.utilities.exceptions import MisconfigurationException
+    from lightning.fabric.utilities.logger import (
+        _add_prefix,
+        _convert_params,
+        _sanitize_callable_params,
+    )
+    from lightning.fabric.utilities.rank_zero import rank_zero_only, rank_zero_warn
+    from lightning.fabric.utilities.types import _PATH
+    from torch import Tensor
+    from torch.nn import Module
+
+    if version.parse(lightning.__version__) > version.parse("2.1.3"):
+        wandb.termwarn(
+            """This integration is tested and supported for lightning Fabric 2.1.3.
+            Please report any issues to https://github.com/wandb/wandb/issues with the tag `lightning-fabric`.""",
+            repeat=False,
+        )
+
+    if TYPE_CHECKING:
+        from lightning.pytorch.callbacks.model_checkpoint import ModelCheckpoint
+
+except ImportError as e:
+    wandb.Error(e)
+
+
+class WandbLogger(Logger):
+    r"""Log using `Weights and Biases <https://docs.wandb.ai/integrations/lightning>`_.
+
+    **Installation and set-up**
+
+    Install with pip:
+
+    .. code-block:: bash
+
+        pip install wandb
+
+    Create a `WandbLogger` instance:
+
+    .. code-block:: python
+
+        from lightning.fabric.loggers import WandbLogger
+
+        wandb_logger = WandbLogger(project="MNIST")
+
+    Pass the logger instance to the `Trainer`:
+
+    .. code-block:: python
+
+        trainer = Trainer(logger=wandb_logger)
+
+    A new W&B run will be created when training starts if you have not created one manually before with `wandb.init()`.
+
+    **Log metrics**
+
+    Log from :class:`~lightning.pytorch.core.LightningModule`:
+
+    .. code-block:: python
+
+        class LitModule(LightningModule):
+            def training_step(self, batch, batch_idx):
+                self.log("train/loss", loss)
+
+    Use directly wandb module:
+
+    .. code-block:: python
+
+        wandb.log({"train/loss": loss})
+
+    **Log hyper-parameters**
+
+    Save :class:`~lightning.pytorch.core.LightningModule` parameters:
+
+    .. code-block:: python
+
+        class LitModule(LightningModule):
+            def __init__(self, *args, **kwarg):
+                self.save_hyperparameters()
+
+    Add other config parameters:
+
+    .. code-block:: python
+
+        # add one parameter
+        wandb_logger.experiment.config["key"] = value
+
+        # add multiple parameters
+        wandb_logger.experiment.config.update({key1: val1, key2: val2})
+
+        # use directly wandb module
+        wandb.config["key"] = value
+        wandb.config.update()
+
+    **Log gradients, parameters and model topology**
+
+    Call the `watch` method for automatically tracking gradients:
+
+    .. code-block:: python
+
+        # log gradients and model topology
+        wandb_logger.watch(model)
+
+        # log gradients, parameter histogram and model topology
+        wandb_logger.watch(model, log="all")
+
+        # change log frequency of gradients and parameters (100 steps by default)
+        wandb_logger.watch(model, log_freq=500)
+
+        # do not log graph (in case of errors)
+        wandb_logger.watch(model, log_graph=False)
+
+    The `watch` method adds hooks to the model which can be removed at the end of training:
+
+    .. code-block:: python
+
+        wandb_logger.experiment.unwatch(model)
+
+    **Log model checkpoints**
+
+    Log model checkpoints at the end of training:
+
+    .. code-block:: python
+
+        wandb_logger = WandbLogger(log_model=True)
+
+    Log model checkpoints as they get created during training:
+
+    .. code-block:: python
+
+        wandb_logger = WandbLogger(log_model="all")
+
+    Custom checkpointing can be set up through :class:`~lightning.pytorch.callbacks.ModelCheckpoint`:
+
+    .. code-block:: python
+
+        # log model only if `val_accuracy` increases
+        wandb_logger = WandbLogger(log_model="all")
+        checkpoint_callback = ModelCheckpoint(monitor="val_accuracy", mode="max")
+        trainer = Trainer(logger=wandb_logger, callbacks=[checkpoint_callback])
+
+    `latest` and `best` aliases are automatically set to easily retrieve a model checkpoint:
+
+    .. code-block:: python
+
+        # reference can be retrieved in artifacts panel
+        # "VERSION" can be a version (ex: "v2") or an alias ("latest or "best")
+        checkpoint_reference = "USER/PROJECT/MODEL-RUN_ID:VERSION"
+
+        # download checkpoint locally (if not already cached)
+        run = wandb.init(project="MNIST")
+        artifact = run.use_artifact(checkpoint_reference, type="model")
+        artifact_dir = artifact.download()
+
+        # load checkpoint
+        model = LitModule.load_from_checkpoint(Path(artifact_dir) / "model.ckpt")
+
+    **Log media**
+
+    Log text with:
+
+    .. code-block:: python
+
+        # using columns and data
+        columns = ["input", "label", "prediction"]
+        data = [["cheese", "english", "english"], ["fromage", "french", "spanish"]]
+        wandb_logger.log_text(key="samples", columns=columns, data=data)
+
+        # using a pandas DataFrame
+        wandb_logger.log_text(key="samples", dataframe=my_dataframe)
+
+    Log images with:
+
+    .. code-block:: python
+
+        # using tensors, numpy arrays or PIL images
+        wandb_logger.log_image(key="samples", images=[img1, img2])
+
+        # adding captions
+        wandb_logger.log_image(
+            key="samples", images=[img1, img2], caption=["tree", "person"]
+        )
+
+        # using file path
+        wandb_logger.log_image(key="samples", images=["img_1.jpg", "img_2.jpg"])
+
+    More arguments can be passed for logging segmentation masks and bounding boxes. Refer to
+    `Image Overlays documentation <https://docs.wandb.ai/guides/track/log/media#image-overlays>`_.
+
+    **Log Tables**
+
+    `W&B Tables <https://docs.wandb.ai/guides/tables/visualize-tables>`_ can be used to log,
+    query and analyze tabular data.
+
+    They support any type of media (text, image, video, audio, molecule, html, etc) and are great for storing,
+    understanding and sharing any form of data, from datasets to model predictions.
+
+    .. code-block:: python
+
+        columns = ["caption", "image", "sound"]
+        data = [
+            ["cheese", wandb.Image(img_1), wandb.Audio(snd_1)],
+            ["wine", wandb.Image(img_2), wandb.Audio(snd_2)],
+        ]
+        wandb_logger.log_table(key="samples", columns=columns, data=data)
+
+
+    **Downloading and Using Artifacts**
+
+    To download an artifact without starting a run, call the ``download_artifact``
+    function on the class:
+
+    .. code-block:: python
+
+        artifact_dir = wandb_logger.download_artifact(artifact="path/to/artifact")
+
+    To download an artifact and link it to an ongoing run call the ``download_artifact``
+    function on the logger instance:
+
+    .. code-block:: python
+
+        class MyModule(LightningModule):
+            def any_lightning_module_function_or_hook(self):
+                self.logger.download_artifact(artifact="path/to/artifact")
+
+    To link an artifact from a previous run you can use ``use_artifact`` function:
+
+    .. code-block:: python
+
+        wandb_logger.use_artifact(artifact="path/to/artifact")
+
+    See Also:
+        - `Demo in Google Colab <http://wandb.me/lightning>`__ with hyperparameter search and model logging
+        - `W&B Documentation <https://docs.wandb.ai/integrations/lightning>`__
+
+    Args:
+        name: Display name for the run.
+        save_dir: Path where data is saved.
+        version: Sets the version, mainly used to resume a previous run.
+        offline: Run offline (data can be streamed later to wandb servers).
+        dir: Same as save_dir.
+        id: Same as version.
+        anonymous: Enables or explicitly disables anonymous logging.
+        project: The name of the project to which this run will belong. If not set, the environment variable
+            `WANDB_PROJECT` will be used as a fallback. If both are not set, it defaults to ``'lightning_logs'``.
+        log_model: Log checkpoints created by :class:`~lightning.pytorch.callbacks.ModelCheckpoint`
+            as W&B artifacts. `latest` and `best` aliases are automatically set.
+
+            * if ``log_model == 'all'``, checkpoints are logged during training.
+            * if ``log_model == True``, checkpoints are logged at the end of training, except when
+              `~lightning.pytorch.callbacks.ModelCheckpoint.save_top_k` ``== -1``
+              which also logs every checkpoint during training.
+            * if ``log_model == False`` (default), no checkpoint is logged.
+
+        prefix: A string to put at the beginning of metric keys.
+        experiment: WandB experiment object. Automatically set when creating a run.
+        checkpoint_name: Name of the model checkpoint artifact being logged.
+        log_checkpoint_on: When to log model checkpoints as W&B artifacts. Only used if ``log_model`` is ``True``.
+            Options: ``"success"``, ``"all"``. Default: ``"success"``.
+        \**kwargs: Arguments passed to :func:`wandb.init` like `entity`, `group`, `tags`, etc.
+
+    Raises:
+        ModuleNotFoundError:
+            If required WandB package is not installed on the device.
+        MisconfigurationException:
+            If both ``log_model`` and ``offline`` is set to ``True``.
+
+    """
+
+    LOGGER_JOIN_CHAR = "-"
+
+    def __init__(
+        self,
+        name: str | None = None,
+        save_dir: _PATH = ".",
+        version: str | None = None,
+        offline: bool = False,
+        dir: _PATH | None = None,
+        id: str | None = None,
+        anonymous: bool | None = None,
+        project: str | None = None,
+        log_model: Literal["all"] | bool = False,
+        experiment: wandb.Run | None = None,
+        prefix: str = "",
+        checkpoint_name: str | None = None,
+        log_checkpoint_on: Literal["success"] | Literal["all"] = "success",
+        **kwargs: Any,
+    ) -> None:
+        if offline and log_model:
+            raise MisconfigurationException(
+                f"Providing log_model={log_model} and offline={offline} is an invalid configuration"
+                " since model checkpoints cannot be uploaded in offline mode.\n"
+                "Hint: Set `offline=False` to log your model."
+            )
+
+        super().__init__()
+        self._offline = offline
+        self._log_model = log_model
+        self._prefix = prefix
+        self._experiment = experiment
+        self._logged_model_time: dict[str, float] = {}
+        self._checkpoint_callback: ModelCheckpoint | None = None
+
+        # paths are processed as strings
+        if save_dir is not None:
+            save_dir = os.fspath(save_dir)
+        elif dir is not None:
+            dir = os.fspath(dir)
+
+        project = project or os.environ.get("WANDB_PROJECT", "lightning_fabric_logs")
+
+        # set wandb init arguments
+        self._wandb_init: dict[str, Any] = {
+            "name": name,
+            "project": project,
+            "dir": save_dir or dir,
+            "id": version or id,
+            "resume": "allow",
+            "anonymous": ("allow" if anonymous else None),
+        }
+        self._wandb_init.update(**kwargs)
+        # extract parameters
+        self._project = self._wandb_init.get("project")
+        self._save_dir = self._wandb_init.get("dir")
+        self._name = self._wandb_init.get("name")
+        self._id = self._wandb_init.get("id")
+        self._checkpoint_name = checkpoint_name
+        self._log_checkpoint_on = log_checkpoint_on
+
+    def __getstate__(self) -> dict[str, Any]:
+        # Hack: If the 'spawn' launch method is used, the logger will get pickled and this `__getstate__` gets called.
+        # We create an experiment here in the main process, and attach to it in the worker process.
+        # Using wandb-service, we persist the same experiment even if multiple `Trainer.fit/test/validate` calls
+        # are made.
+        _ = self.experiment
+
+        state = self.__dict__.copy()
+        # args needed to reload correct experiment
+        if self._experiment is not None:
+            state["_id"] = getattr(self._experiment, "id", None)
+            state["_attach_id"] = getattr(self._experiment, "_attach_id", None)
+            state["_name"] = self._experiment.name
+
+        # cannot be pickled
+        state["_experiment"] = None
+        return state
+
+    @property
+    @rank_zero_experiment
+    def experiment(self) -> wandb.Run:
+        r"""Actual wandb object.
+
+        To use wandb features in your :class:`~lightning.pytorch.core.LightningModule`, do the
+        following.
+
+        Example::
+
+        .. code-block:: python
+
+            self.logger.experiment.some_wandb_function()
+
+        """
+        if self._experiment is None:
+            if self._offline:
+                os.environ["WANDB_MODE"] = "dryrun"
+
+            attach_id = getattr(self, "_attach_id", None)
+            if wandb.run is not None:
+                # wandb process already created in this instance
+                rank_zero_warn(
+                    "There is a wandb run already in progress and newly created instances of `WandbLogger` will reuse"
+                    " this run. If this is not desired, call `wandb.finish()` before instantiating `WandbLogger`."
+                )
+                self._experiment = wandb.run
+            elif attach_id is not None and hasattr(wandb, "_attach"):
+                # attach to wandb process referenced
+                self._experiment = wandb._attach(attach_id)
+            else:
+                # create new wandb process
+                self._experiment = wandb.init(**self._wandb_init)
+
+                # define default x-axis
+                if isinstance(self._experiment, wandb.Run) and getattr(
+                    self._experiment, "define_metric", None
+                ):
+                    self._experiment.define_metric("trainer/global_step")
+                    self._experiment.define_metric(
+                        "*", step_metric="trainer/global_step", step_sync=True
+                    )
+
+        self._experiment._label(repo="lightning_fabric_logger")  # pylint: disable=protected-access
+        with telemetry.context(run=self._experiment) as tel:
+            tel.feature.lightning_fabric_logger = True
+        return self._experiment
+
+    def watch(
+        self,
+        model: nn.Module,
+        log: str = "gradients",
+        log_freq: int = 100,
+        log_graph: bool = True,
+    ) -> None:
+        self.experiment.watch(model, log=log, log_freq=log_freq, log_graph=log_graph)
+
+    @override
+    @rank_zero_only
+    def log_hyperparams(self, params: dict[str, Any] | Namespace) -> None:  # type: ignore[override]
+        params = _convert_params(params)
+        params = _sanitize_callable_params(params)
+        self.experiment.config.update(params, allow_val_change=True)
+
+    @override
+    @rank_zero_only
+    def log_metrics(
+        self, metrics: Mapping[str, float], step: int | None = None
+    ) -> None:
+        assert rank_zero_only.rank == 0, "experiment tried to log from global_rank != 0"
+
+        metrics = _add_prefix(metrics, self._prefix, self.LOGGER_JOIN_CHAR)
+        if step is not None:
+            self.experiment.log(dict(metrics, **{"trainer/global_step": step}))
+        else:
+            self.experiment.log(metrics)
+
+    @rank_zero_only
+    def log_table(
+        self,
+        key: str,
+        columns: list[str] | None = None,
+        data: list[list[Any]] | None = None,
+        dataframe: Any = None,
+        step: int | None = None,
+    ) -> None:
+        """Log a Table containing any object type (text, image, audio, video, molecule, html, etc).
+
+        Can be defined either with `columns` and `data` or with `dataframe`.
+
+        """
+        metrics = {key: wandb.Table(columns=columns, data=data, dataframe=dataframe)}
+        self.log_metrics(metrics, step)
+
+    @rank_zero_only
+    def log_text(
+        self,
+        key: str,
+        columns: list[str] | None = None,
+        data: list[list[str]] | None = None,
+        dataframe: Any = None,
+        step: int | None = None,
+    ) -> None:
+        """Log text as a Table.
+
+        Can be defined either with `columns` and `data` or with `dataframe`.
+
+        """
+        self.log_table(key, columns, data, dataframe, step)
+
+    @rank_zero_only
+    def log_html(
+        self, key: str, htmls: list[Any], step: int | None = None, **kwargs: Any
+    ) -> None:
+        """Log html files.
+
+        Optional kwargs are lists passed to each html (ex: inject).
+
+        """
+        if not isinstance(htmls, list):
+            raise TypeError(f'Expected a list as "htmls", found {type(htmls)}')
+        n = len(htmls)
+        for k, v in kwargs.items():
+            if len(v) != n:
+                raise ValueError(f"Expected {n} items but only found {len(v)} for {k}")
+        kwarg_list = [{k: kwargs[k][i] for k in kwargs} for i in range(n)]
+
+        metrics = {
+            key: [wandb.Html(html, **kwarg) for html, kwarg in zip(htmls, kwarg_list)]
+        }
+        self.log_metrics(metrics, step)  # type: ignore[arg-type]
+
+    @rank_zero_only
+    def log_image(
+        self, key: str, images: list[Any], step: int | None = None, **kwargs: Any
+    ) -> None:
+        """Log images (tensors, numpy arrays, PIL Images or file paths).
+
+        Optional kwargs are lists passed to each image (ex: caption, masks, boxes).
+
+        """
+        if not isinstance(images, list):
+            raise TypeError(f'Expected a list as "images", found {type(images)}')
+        n = len(images)
+        for k, v in kwargs.items():
+            if len(v) != n:
+                raise ValueError(f"Expected {n} items but only found {len(v)} for {k}")
+        kwarg_list = [{k: kwargs[k][i] for k in kwargs} for i in range(n)]
+
+        metrics = {
+            key: [wandb.Image(img, **kwarg) for img, kwarg in zip(images, kwarg_list)]
+        }
+        self.log_metrics(metrics, step)  # type: ignore[arg-type]
+
+    @rank_zero_only
+    def log_audio(
+        self, key: str, audios: list[Any], step: int | None = None, **kwargs: Any
+    ) -> None:
+        r"""Log audios (numpy arrays, or file paths).
+
+        Args:
+            key: The key to be used for logging the audio files
+            audios: The list of audio file paths, or numpy arrays to be logged
+            step: The step number to be used for logging the audio files
+            \**kwargs: Optional kwargs are lists passed to each ``Wandb.Audio`` instance (ex: caption, sample_rate).
+
+        Optional kwargs are lists passed to each audio (ex: caption, sample_rate).
+
+        """
+        if not isinstance(audios, list):
+            raise TypeError(f'Expected a list as "audios", found {type(audios)}')
+        n = len(audios)
+        for k, v in kwargs.items():
+            if len(v) != n:
+                raise ValueError(f"Expected {n} items but only found {len(v)} for {k}")
+        kwarg_list = [{k: kwargs[k][i] for k in kwargs} for i in range(n)]
+
+        metrics = {
+            key: [
+                wandb.Audio(audio, **kwarg) for audio, kwarg in zip(audios, kwarg_list)
+            ]
+        }
+        self.log_metrics(metrics, step)  # type: ignore[arg-type]
+
+    @rank_zero_only
+    def log_video(
+        self, key: str, videos: list[Any], step: int | None = None, **kwargs: Any
+    ) -> None:
+        """Log videos (numpy arrays, or file paths).
+
+        Args:
+            key: The key to be used for logging the video files
+            videos: The list of video file paths, or numpy arrays to be logged
+            step: The step number to be used for logging the video files
+            **kwargs: Optional kwargs are lists passed to each Wandb.Video instance (ex: caption, fps, format).
+
+        Optional kwargs are lists passed to each video (ex: caption, fps, format).
+
+        """
+        if not isinstance(videos, list):
+            raise TypeError(f'Expected a list as "videos", found {type(videos)}')
+        n = len(videos)
+        for k, v in kwargs.items():
+            if len(v) != n:
+                raise ValueError(f"Expected {n} items but only found {len(v)} for {k}")
+        kwarg_list = [{k: kwargs[k][i] for k in kwargs} for i in range(n)]
+
+        metrics = {
+            key: [
+                wandb.Video(video, **kwarg) for video, kwarg in zip(videos, kwarg_list)
+            ]
+        }
+        self.log_metrics(metrics, step)  # type: ignore[arg-type]
+
+    @property
+    @override
+    def save_dir(self) -> str | None:
+        """Gets the save directory.
+
+        Returns:
+            The path to the save directory.
+
+        """
+        return self._save_dir
+
+    @property
+    @override
+    def name(self) -> str | None:
+        """The project name of this experiment.
+
+        Returns:
+            The name of the project the current experiment belongs to. This name is not the same as `wandb.Run`'s
+            name. To access wandb's internal experiment name, use ``logger.experiment.name`` instead.
+
+        """
+        return self._project
+
+    @property
+    @override
+    def version(self) -> str | None:
+        """Gets the id of the experiment.
+
+        Returns:
+            The id of the experiment if the experiment exists else the id given to the constructor.
+
+        """
+        # don't create an experiment if we don't have one
+        return self._experiment.id if self._experiment else self._id
+
+    @property
+    def log_dir(self) -> str | None:
+        """Gets the save directory.
+
+        Returns:
+            The path to the save directory.
+
+        """
+        return self.save_dir
+
+    @property
+    def group_separator(self) -> str:
+        """Return the default separator used by the logger to group the data into subfolders."""
+        return self.LOGGER_JOIN_CHAR
+
+    @property
+    def root_dir(self) -> str | None:
+        """Return the root directory.
+
+        Return the root directory where all versions of an experiment get saved, or `None` if the logger does not
+        save data locally.
+        """
+        return self.save_dir.parent if self.save_dir else None
+
+    def log_graph(self, model: Module, input_array: Tensor | None = None) -> None:
+        """Record model graph.
+
+        Args:
+            model: the model with an implementation of ``forward``.
+            input_array: input passes to `model.forward`
+
+        This is a noop function and does not perform any operation.
+        """
+        return
+
+    @override
+    def after_save_checkpoint(self, checkpoint_callback: ModelCheckpoint) -> None:
+        # log checkpoints as artifacts
+        if (
+            self._log_model == "all"
+            or self._log_model is True
+            and checkpoint_callback.save_top_k == -1
+        ):
+            # TODO: Replace with new Fabric Checkpoints system
+            self._scan_and_log_pytorch_checkpoints(checkpoint_callback)
+        elif self._log_model is True:
+            self._checkpoint_callback = checkpoint_callback
+
+    @staticmethod
+    @rank_zero_only
+    def download_artifact(
+        artifact: str,
+        save_dir: _PATH | None = None,
+        artifact_type: str | None = None,
+        use_artifact: bool | None = True,
+    ) -> str:
+        """Downloads an artifact from the wandb server.
+
+        Args:
+            artifact: The path of the artifact to download.
+            save_dir: The directory to save the artifact to.
+            artifact_type: The type of artifact to download.
+            use_artifact: Whether to add an edge between the artifact graph.
+
+        Returns:
+            The path to the downloaded artifact.
+
+        """
+        if wandb.run is not None and use_artifact:
+            artifact = wandb.run.use_artifact(artifact)
+        else:
+            api = wandb.Api()
+            artifact = api.artifact(artifact, type=artifact_type)
+
+        save_dir = None if save_dir is None else os.fspath(save_dir)
+        return artifact.download(root=save_dir)
+
+    def use_artifact(self, artifact: str, artifact_type: str | None = None) -> Artifact:
+        """Logs to the wandb dashboard that the mentioned artifact is used by the run.
+
+        Args:
+            artifact: The path of the artifact.
+            artifact_type: The type of artifact being used.
+
+        Returns:
+            wandb Artifact object for the artifact.
+
+        """
+        return self.experiment.use_artifact(artifact, type=artifact_type)
+
+    @override
+    @rank_zero_only
+    def save(self) -> None:
+        """Save log data."""
+        self.experiment.log({}, commit=True)
+
+    @override
+    @rank_zero_only
+    def finalize(self, status: str) -> None:
+        if self._log_checkpoint_on == "success" and status != "success":
+            # Currently, checkpoints only get logged on success
+            return
+        # log checkpoints as artifacts
+        if (
+            self._checkpoint_callback
+            and self._experiment is not None
+            and self._log_checkpoint_on in ["success", "all"]
+        ):
+            self._scan_and_log_pytorch_checkpoints(self._checkpoint_callback)
+
+    def _scan_and_log_pytorch_checkpoints(
+        self, checkpoint_callback: ModelCheckpoint
+    ) -> None:
+        from lightning.pytorch.loggers.utilities import _scan_checkpoints
+
+        # get checkpoints to be saved with associated score
+        checkpoints = _scan_checkpoints(checkpoint_callback, self._logged_model_time)
+
+        # log iteratively all new checkpoints
+        for t, p, s, _ in checkpoints:
+            metadata = {
+                "score": s.item() if isinstance(s, Tensor) else s,
+                "original_filename": Path(p).name,
+                checkpoint_callback.__class__.__name__: {
+                    k: getattr(checkpoint_callback, k)
+                    for k in [
+                        "monitor",
+                        "mode",
+                        "save_last",
+                        "save_top_k",
+                        "save_weights_only",
+                        "_every_n_train_steps",
+                    ]
+                    # ensure it does not break if `ModelCheckpoint` args change
+                    if hasattr(checkpoint_callback, k)
+                },
+            }
+            if not self._checkpoint_name:
+                self._checkpoint_name = f"model-{self.experiment.id}"
+            artifact = wandb.Artifact(
+                name=self._checkpoint_name, type="model", metadata=metadata
+            )
+            artifact.add_file(p, name="model.ckpt")
+            aliases = (
+                ["latest", "best"]
+                if p == checkpoint_callback.best_model_path
+                else ["latest"]
+            )
+            self.experiment.log_model(artifact, aliases=aliases)
+            # remember logged models - timestamp needed in case filename didn't change (lastkckpt or custom name)
+            self._logged_model_time[p] = t

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/metaflow/__init__.py

@@ -0,0 +1,9 @@
+"""W&B Integration for Metaflow.
+
+Defines a custom step and flow decorator `wandb_log` that automatically logs
+flow parameters and artifacts to W&B.
+"""
+
+from .metaflow import wandb_log, wandb_track, wandb_use
+
+__all__ = ["wandb_log", "wandb_track", "wandb_use"]

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/metaflow/data_pandas.py

@@ -0,0 +1,74 @@
+"""Support for Pandas datatypes.
+
+May raise MissingDependencyError on import.
+"""
+
+from __future__ import annotations
+
+from typing_extensions import Any, TypeIs
+
+import wandb
+
+from . import errors
+
+try:
+    import pandas as pd
+except ImportError as e:
+    warning = (
+        "`pandas` not installed >>"
+        " @wandb_log(datasets=True) may not auto log your dataset!"
+    )
+    raise errors.MissingDependencyError(warning=warning) from e
+
+
+def is_dataframe(data: Any) -> TypeIs[pd.DataFrame]:
+    """Returns whether the data is a Pandas DataFrame."""
+    return isinstance(data, pd.DataFrame)
+
+
+def use_dataframe(
+    name: str,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a dependency on a DataFrame input.
+
+    Args:
+        name: Name of the input.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "datasets"
+    assert run
+
+    wandb.termlog(f"Using artifact: {name} (Pandas DataFrame)")
+    run.use_artifact(f"{name}:latest")
+    return None
+
+
+def track_dataframe(
+    name: str,
+    data: pd.DataFrame,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a DataFrame output as an artifact.
+
+    Args:
+        name: The output's name.
+        data: The output's value.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "pd.DataFrame"
+    assert run
+
+    artifact = wandb.Artifact(name, type="dataset")
+    with artifact.new_file(f"{name}.parquet", "wb") as f:
+        data.to_parquet(f, engine="pyarrow")
+
+    wandb.termlog(f"Logging artifact: {name} (Pandas DataFrame)")
+    run.log_artifact(artifact)
+    return None

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/metaflow/data_pytorch.py

@@ -0,0 +1,75 @@
+"""Support for PyTorch datatypes.
+
+May raise MissingDependencyError on import.
+"""
+
+from __future__ import annotations
+
+from typing_extensions import Any, TypeIs
+
+import wandb
+
+from . import errors
+
+try:
+    import torch
+    import torch.nn as nn
+except ImportError as e:
+    warning = (
+        "`torch` (PyTorch) not installed >>"
+        " @wandb_log(models=True) may not auto log your model!"
+    )
+    raise errors.MissingDependencyError(warning=warning) from e
+
+
+def is_nn_module(data: Any) -> TypeIs[nn.Module]:
+    """Returns whether the data is a PyTorch nn.Module."""
+    return isinstance(data, nn.Module)
+
+
+def use_nn_module(
+    name: str,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a dependency on a PyTorch model input.
+
+    Args:
+        name: Name of the input.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "models"
+    assert run
+
+    wandb.termlog(f"Using artifact: {name} (PyTorch nn.Module)")
+    run.use_artifact(f"{name}:latest")
+    return None
+
+
+def track_nn_module(
+    name: str,
+    data: nn.Module,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a PyTorch model output as an artifact.
+
+    Args:
+        name: The output's name.
+        data: The output's value.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "nn.Module"
+    assert run
+
+    artifact = wandb.Artifact(name, type="model")
+    with artifact.new_file(f"{name}.pkl", "wb") as f:
+        torch.save(data, f)
+
+    wandb.termlog(f"Logging artifact: {name} (PyTorch nn.Module)")
+    run.log_artifact(artifact)
+    return None

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/metaflow/data_sklearn.py

@@ -0,0 +1,76 @@
+"""Support for sklearn datatypes.
+
+May raise MissingDependencyError on import.
+"""
+
+from __future__ import annotations
+
+import pickle
+
+from typing_extensions import Any, TypeIs
+
+import wandb
+
+from . import errors
+
+try:
+    from sklearn.base import BaseEstimator
+except ImportError as e:
+    warning = (
+        "`sklearn` not installed >>"
+        " @wandb_log(models=True) may not auto log your model!"
+    )
+    raise errors.MissingDependencyError(warning=warning) from e
+
+
+def is_estimator(data: Any) -> TypeIs[BaseEstimator]:
+    """Returns whether the data is an sklearn BaseEstimator."""
+    return isinstance(data, BaseEstimator)
+
+
+def use_estimator(
+    name: str,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log a dependency on an sklearn estimator.
+
+    Args:
+        name: Name of the input.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "models"
+    assert run
+
+    wandb.termlog(f"Using artifact: {name} (sklearn BaseEstimator)")
+    run.use_artifact(f"{name}:latest")
+    return None
+
+
+def track_estimator(
+    name: str,
+    data: BaseEstimator,
+    run: wandb.Run | None,
+    testing: bool = False,
+) -> str | None:
+    """Log an sklearn estimator output as an artifact.
+
+    Args:
+        name: The output's name.
+        data: The output's value.
+        run: The run to update.
+        testing: True in unit tests.
+    """
+    if testing:
+        return "BaseEstimator"
+    assert run
+
+    artifact = wandb.Artifact(name, type="model")
+    with artifact.new_file(f"{name}.pkl", "wb") as f:
+        pickle.dump(data, f)
+
+    wandb.termlog(f"Logging artifact: {name} (sklearn BaseEstimator)")
+    run.log_artifact(artifact)
+    return None

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/metaflow/errors.py

@@ -0,0 +1,13 @@
+import wandb
+
+
+class MissingDependencyError(Exception):
+    """An optional dependency is missing."""
+
+    def __init__(self, *args: object, warning: str) -> None:
+        super().__init__(*args)
+        self._wb_warning = warning
+
+    def warn(self) -> None:
+        """Print a warning for the problem."""
+        wandb.termwarn(self._wb_warning)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/metaflow/metaflow.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import inspect
+import pickle
+from functools import wraps
+from pathlib import Path
+
+import wandb
+from wandb.sdk.lib import telemetry as wb_telemetry
+
+from . import errors
+
+try:
+    from metaflow import current
+except ImportError as e:
+    raise Exception(
+        "Error: `metaflow` not installed >> This integration requires metaflow!"
+        " To fix, please `pip install -Uqq metaflow`"
+    ) from e
+
+
+try:
+    from . import data_pandas
+except errors.MissingDependencyError as e:
+    e.warn()
+    data_pandas = None
+
+try:
+    from . import data_pytorch
+except errors.MissingDependencyError as e:
+    e.warn()
+    data_pytorch = None
+
+try:
+    from . import data_sklearn
+except errors.MissingDependencyError as e:
+    e.warn()
+    data_sklearn = None
+
+
+class ArtifactProxy:
+    def __init__(self, flow):
+        # do this to avoid recursion problem with __setattr__
+        self.__dict__.update(
+            {
+                "flow": flow,
+                "inputs": {},
+                "outputs": {},
+                "base": set(dir(flow)),
+                "params": {p: getattr(flow, p) for p in current.parameter_names},
+            }
+        )
+
+    def __setattr__(self, key, val):
+        self.outputs[key] = val
+        return setattr(self.flow, key, val)
+
+    def __getattr__(self, key):
+        if key not in self.base and key not in self.outputs:
+            self.inputs[key] = getattr(self.flow, key)
+        return getattr(self.flow, key)
+
+
+def _track_scalar(
+    name: str,
+    data: dict | list | set | str | int | float | bool,
+    run,
+    testing: bool = False,
+) -> str | None:
+    if testing:
+        return "scalar"
+
+    run.log({name: data})
+    return None
+
+
+def _track_path(
+    name: str,
+    data: Path,
+    run,
+    testing: bool = False,
+) -> str | None:
+    if testing:
+        return "Path"
+
+    artifact = wandb.Artifact(name, type="dataset")
+    if data.is_dir():
+        artifact.add_dir(data)
+    elif data.is_file():
+        artifact.add_file(data)
+    run.log_artifact(artifact)
+    wandb.termlog(f"Logging artifact: {name} ({type(data)})")
+    return None
+
+
+def _track_generic(
+    name: str,
+    data,
+    run,
+    testing: bool = False,
+) -> str | None:
+    if testing:
+        return "generic"
+
+    artifact = wandb.Artifact(name, type="other")
+    with artifact.new_file(f"{name}.pkl", "wb") as f:
+        pickle.dump(data, f)
+    run.log_artifact(artifact)
+    wandb.termlog(f"Logging artifact: {name} ({type(data)})")
+    return None
+
+
+def wandb_track(
+    name: str,
+    data,
+    datasets: bool = False,
+    models: bool = False,
+    others: bool = False,
+    run: wandb.Run | None = None,
+    testing: bool = False,
+) -> str | None:
+    """Track data as wandb artifacts based on type and flags."""
+    # Check for pandas DataFrame
+    if data_pandas and data_pandas.is_dataframe(data) and datasets:
+        return data_pandas.track_dataframe(name, data, run, testing)
+
+    # Check for PyTorch Module
+    if data_pytorch and data_pytorch.is_nn_module(data) and models:
+        return data_pytorch.track_nn_module(name, data, run, testing)
+
+    # Check for scikit-learn BaseEstimator
+    if data_sklearn and data_sklearn.is_estimator(data) and models:
+        return data_sklearn.track_estimator(name, data, run, testing)
+
+    # Check for Path objects
+    if isinstance(data, Path) and datasets:
+        return _track_path(name, data, run, testing)
+
+    # Check for scalar types
+    if isinstance(data, (dict, list, set, str, int, float, bool)):
+        return _track_scalar(name, data, run, testing)
+
+    # Generic fallback
+    if others:
+        return _track_generic(name, data, run, testing)
+
+    # No action taken
+    return None
+
+
+def wandb_use(
+    name: str,
+    data,
+    datasets: bool = False,
+    models: bool = False,
+    others: bool = False,
+    run=None,
+    testing: bool = False,
+) -> str | None:
+    """Use wandb artifacts based on data type and flags."""
+    # Skip scalar types - nothing to use
+    if isinstance(data, (dict, list, set, str, int, float, bool)):
+        return None
+
+    try:
+        # Check for pandas DataFrame
+        if data_pandas and data_pandas.is_dataframe(data) and datasets:
+            return data_pandas.use_dataframe(name, run, testing)
+
+        # Check for PyTorch Module
+        elif data_pytorch and data_pytorch.is_nn_module(data) and models:
+            return data_pytorch.use_nn_module(name, run, testing)
+
+        # Check for scikit-learn BaseEstimator
+        elif data_sklearn and data_sklearn.is_estimator(data) and models:
+            return data_sklearn.use_estimator(name, run, testing)
+
+        # Check for Path objects
+        elif isinstance(data, Path) and datasets:
+            return _use_path(name, data, run, testing)
+
+        # Generic fallback
+        elif others:
+            return _use_generic(name, data, run, testing)
+
+        else:
+            return None
+
+    except wandb.CommError:
+        wandb.termwarn(
+            f"This artifact ({name}, {type(data)}) does not exist in the wandb datastore!"
+            " If you created an instance inline (e.g. sklearn.ensemble.RandomForestClassifier),"
+            " then you can safely ignore this. Otherwise you may want to check your internet connection!"
+        )
+        return None
+
+
+def _use_path(
+    name: str,
+    data: Path,
+    run,
+    testing: bool = False,
+) -> str | None:
+    if testing:
+        return "datasets"
+
+    run.use_artifact(f"{name}:latest")
+    wandb.termlog(f"Using artifact: {name} ({type(data)})")
+    return None
+
+
+def _use_generic(
+    name: str,
+    data,
+    run,
+    testing: bool = False,
+) -> str | None:
+    if testing:
+        return "others"
+
+    run.use_artifact(f"{name}:latest")
+    wandb.termlog(f"Using artifact: {name} ({type(data)})")
+    return None
+
+
+def coalesce(*arg):
+    return next((a for a in arg if a is not None), None)
+
+
+def wandb_log(
+    func=None,
+    /,
+    datasets: bool = False,
+    models: bool = False,
+    others: bool = False,
+    settings: wandb.Settings | None = None,
+):
+    """Automatically log parameters and artifacts to W&B.
+
+    This decorator can be applied to a flow, step, or both:
+
+    - Decorating a step enables or disables logging within that step
+    - Decorating a flow is equivalent to decorating all steps
+    - Decorating a step after decorating its flow overwrites the flow decoration
+
+    Args:
+        func: The step method or flow class to decorate.
+        datasets: Whether to log `pd.DataFrame` and `pathlib.Path`
+            types. Defaults to False.
+        models: Whether to log `nn.Module` and `sklearn.base.BaseEstimator`
+            types. Defaults to False.
+        others: If `True`, log anything pickle-able. Defaults to False.
+        settings: Custom settings to pass to `wandb.init`.
+            If `run_group` is `None`, it is set to `{flow_name}/{run_id}`.
+            If `run_job_type` is `None`, it is set to `{run_job_type}/{step_name}`.
+    """
+
+    @wraps(func)
+    def decorator(func):
+        # If you decorate a class, apply the decoration to all methods in that class
+        if inspect.isclass(func):
+            cls = func
+            for attr in cls.__dict__:
+                if callable(getattr(cls, attr)) and not hasattr(attr, "_base_func"):
+                    setattr(cls, attr, decorator(getattr(cls, attr)))
+            return cls
+
+        # prefer the earliest decoration (i.e. method decoration overrides class decoration)
+        if hasattr(func, "_base_func"):
+            return func
+
+        @wraps(func)
+        def wrapper(self, *args, settings=settings, **kwargs):
+            if not isinstance(settings, wandb.sdk.wandb_settings.Settings):
+                settings = wandb.Settings()
+
+            settings.update_from_dict(
+                {
+                    "run_group": coalesce(
+                        settings.run_group, f"{current.flow_name}/{current.run_id}"
+                    ),
+                    "run_job_type": coalesce(settings.run_job_type, current.step_name),
+                }
+            )
+
+            with wandb.init(settings=settings) as run:
+                with wb_telemetry.context(run=run) as tel:
+                    tel.feature.metaflow = True
+                proxy = ArtifactProxy(self)
+                run.config.update(proxy.params)
+                func(proxy, *args, **kwargs)
+
+                for name, data in proxy.inputs.items():
+                    wandb_use(
+                        name,
+                        data,
+                        datasets=datasets,
+                        models=models,
+                        others=others,
+                        run=run,
+                    )
+
+                for name, data in proxy.outputs.items():
+                    wandb_track(
+                        name,
+                        data,
+                        datasets=datasets,
+                        models=models,
+                        others=others,
+                        run=run,
+                    )
+
+        wrapper._base_func = func
+
+        # Add for testing visibility
+        wrapper._kwargs = {
+            "datasets": datasets,
+            "models": models,
+            "others": others,
+            "settings": settings,
+        }
+        return wrapper
+
+    if func is None:
+        return decorator
+    else:
+        return decorator(func)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/openai/__init__.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/openai/fine_tuning.py

@@ -0,0 +1,482 @@
+from __future__ import annotations
+
+import base64
+import datetime
+import io
+import json
+import os
+import re
+import tempfile
+import time
+from typing import Any
+
+from packaging.version import parse
+
+import wandb
+from wandb import util
+from wandb.data_types import Table
+from wandb.sdk.lib import telemetry
+
+openai = util.get_module(
+    name="openai",
+    required="This integration requires `openai`. To install, please run `pip install openai`",
+    lazy=False,
+)
+
+if parse(openai.__version__) < parse("1.12.0"):
+    raise wandb.Error(
+        f"This integration requires openai version 1.12.0 and above. Your current version is {openai.__version__} "
+        "To fix, please `pip install -U openai`"
+    )
+
+from openai import OpenAI  # noqa: E402
+from openai.types.fine_tuning import FineTuningJob  # noqa: E402
+from openai.types.fine_tuning.fine_tuning_job import (  # noqa: E402
+    Error,
+    Hyperparameters,
+)
+
+np = util.get_module(
+    name="numpy",
+    required="`numpy` not installed >> This integration requires numpy!  To fix, please `pip install numpy`",
+    lazy=False,
+)
+
+pd = util.get_module(
+    name="pandas",
+    required="`pandas` not installed >> This integration requires pandas!  To fix, please `pip install pandas`",
+    lazy=False,
+)
+
+
+class WandbLogger:
+    """Log OpenAI fine-tunes to [Weights & Biases](https://wandb.me/openai-docs)."""
+
+    _wandb_api: wandb.Api | None = None
+    _logged_in: bool = False
+    openai_client: OpenAI | None = None
+    _run: wandb.Run | None = None
+
+    @classmethod
+    def sync(
+        cls,
+        fine_tune_job_id: str | None = None,
+        openai_client: OpenAI | None = None,
+        num_fine_tunes: int | None = None,
+        project: str = "OpenAI-Fine-Tune",
+        entity: str | None = None,
+        overwrite: bool = False,
+        wait_for_job_success: bool = True,
+        log_datasets: bool = True,
+        model_artifact_name: str = "model-metadata",
+        model_artifact_type: str = "model",
+        **kwargs_wandb_init: dict[str, Any],
+    ) -> str:
+        """Sync fine-tunes to Weights & Biases.
+
+        :param fine_tune_job_id: The id of the fine-tune (optional)
+        :param openai_client: Pass the `OpenAI()` client (optional)
+        :param num_fine_tunes: Number of most recent fine-tunes to log when an fine_tune_job_id is not provided. By default, every fine-tune is synced.
+        :param project: Name of the project where you're sending runs. By default, it is "GPT-3".
+        :param entity: Username or team name where you're sending runs. By default, your default entity is used, which is usually your username.
+        :param overwrite: Forces logging and overwrite existing wandb run of the same fine-tune.
+        :param wait_for_job_success: Waits for the fine-tune to be complete and then log metrics to W&B. By default, it is True.
+        :param model_artifact_name: Name of the model artifact that is logged
+        :param model_artifact_type: Type of the model artifact that is logged
+        """
+        if openai_client is None:
+            openai_client = OpenAI()
+        cls.openai_client = openai_client
+
+        if fine_tune_job_id:
+            wandb.termlog("Retrieving fine-tune job...")
+            fine_tune = openai_client.fine_tuning.jobs.retrieve(
+                fine_tuning_job_id=fine_tune_job_id
+            )
+            fine_tunes = [fine_tune]
+        else:
+            # get list of fine_tune to log
+            fine_tunes = openai_client.fine_tuning.jobs.list()
+            if not fine_tunes or fine_tunes.data is None:
+                wandb.termwarn("No fine-tune has been retrieved")
+                return
+            # Select the `num_fine_tunes` from the `fine_tunes.data` list.
+            # If `num_fine_tunes` is None, it selects all items in the list (from start to end).
+            # If for example, `num_fine_tunes` is 5, it selects the last 5 items in the list.
+            # Note that the last items in the list are the latest fine-tune jobs.
+            fine_tunes = fine_tunes.data[
+                -num_fine_tunes if num_fine_tunes is not None else None :
+            ]
+
+        # log starting from oldest fine_tune
+        show_individual_warnings = (
+            fine_tune_job_id is not None or num_fine_tunes is not None
+        )
+        fine_tune_logged = []
+        for fine_tune in fine_tunes:
+            fine_tune_id = fine_tune.id
+            # check run with the given `fine_tune_id` has not been logged already
+            run_path = f"{project}/{fine_tune_id}"
+            if entity is not None:
+                run_path = f"{entity}/{run_path}"
+            wandb_run = cls._get_wandb_run(run_path)
+            if wandb_run:
+                wandb_status = wandb_run.summary.get("status")
+                if show_individual_warnings:
+                    if wandb_status == "succeeded" and not overwrite:
+                        wandb.termwarn(
+                            f"Fine-tune {fine_tune_id} has already been logged successfully at {wandb_run.url}. "
+                            "Use `overwrite=True` if you want to overwrite previous run"
+                        )
+                    elif wandb_status != "succeeded" or overwrite:
+                        if wandb_status != "succeeded":
+                            wandb.termwarn(
+                                f"A run for fine-tune {fine_tune_id} was previously created but didn't end successfully"
+                            )
+                        wandb.termlog(
+                            f"A new wandb run will be created for fine-tune {fine_tune_id} and previous run will be overwritten"
+                        )
+                        overwrite = True
+                if wandb_status == "succeeded" and not overwrite:
+                    return
+
+            # check if the user has not created a wandb run externally
+            if wandb.run is None:
+                cls._run = wandb.init(
+                    job_type="fine-tune",
+                    project=project,
+                    entity=entity,
+                    name=fine_tune_id,
+                    id=fine_tune_id,
+                    **kwargs_wandb_init,
+                )
+            else:
+                # if a run exits - created externally
+                cls._run = wandb.run
+
+            if wait_for_job_success:
+                fine_tune = cls._wait_for_job_success(fine_tune)
+
+            cls._log_fine_tune(
+                fine_tune,
+                project,
+                entity,
+                overwrite,
+                show_individual_warnings,
+                log_datasets,
+                model_artifact_name,
+                model_artifact_type,
+                **kwargs_wandb_init,
+            )
+
+        if not show_individual_warnings and not any(fine_tune_logged):
+            wandb.termwarn("No new successful fine-tunes were found")
+
+        return "🎉 wandb sync completed successfully"
+
+    @classmethod
+    def _wait_for_job_success(cls, fine_tune: FineTuningJob) -> FineTuningJob:
+        wandb.termlog("Waiting for the OpenAI fine-tuning job to finish training...")
+        wandb.termlog(
+            "To avoid blocking, you can call `WandbLogger.sync` with `wait_for_job_success=False` after OpenAI training completes."
+        )
+        while True:
+            if fine_tune.status == "succeeded":
+                wandb.termlog(
+                    "Fine-tuning finished, logging metrics, model metadata, and run metadata to Weights & Biases"
+                )
+                return fine_tune
+            if fine_tune.status == "failed":
+                wandb.termwarn(
+                    f"Fine-tune {fine_tune.id} has failed and will not be logged"
+                )
+                return fine_tune
+            if fine_tune.status == "cancelled":
+                wandb.termwarn(
+                    f"Fine-tune {fine_tune.id} was cancelled and will not be logged"
+                )
+                return fine_tune
+            time.sleep(10)
+            fine_tune = cls.openai_client.fine_tuning.jobs.retrieve(
+                fine_tuning_job_id=fine_tune.id
+            )
+
+    @classmethod
+    def _log_fine_tune(
+        cls,
+        fine_tune: FineTuningJob,
+        project: str,
+        entity: str | None,
+        overwrite: bool,
+        show_individual_warnings: bool,
+        log_datasets: bool,
+        model_artifact_name: str,
+        model_artifact_type: str,
+        **kwargs_wandb_init: dict[str, Any],
+    ):
+        fine_tune_id = fine_tune.id
+        status = fine_tune.status
+
+        with telemetry.context(run=cls._run) as tel:
+            tel.feature.openai_finetuning = True
+
+        # check run completed successfully
+        if status != "succeeded":
+            if show_individual_warnings:
+                wandb.termwarn(
+                    f'Fine-tune {fine_tune_id} has the status "{status}" and will not be logged'
+                )
+            return
+
+        # check results are present
+        try:
+            results_id = fine_tune.result_files[0]
+            try:
+                encoded_results = cls.openai_client.files.content(
+                    file_id=results_id
+                ).read()
+                results = base64.b64decode(encoded_results).decode("utf-8")
+            except Exception:
+                # attempt to read as text, works for older jobs
+                results = cls.openai_client.files.content(file_id=results_id).text
+        except openai.NotFoundError:
+            if show_individual_warnings:
+                wandb.termwarn(
+                    f"Fine-tune {fine_tune_id} has no results and will not be logged"
+                )
+            return
+
+        # update the config
+        cls._run.config.update(cls._get_config(fine_tune))
+
+        # log results
+        df_results = pd.read_csv(io.StringIO(results))
+        for _, row in df_results.iterrows():
+            metrics = {k: v for k, v in row.items() if not np.isnan(v)}
+            step = metrics.pop("step")
+            if step is not None:
+                step = int(step)
+            cls._run.log(metrics, step=step)
+        fine_tuned_model = fine_tune.fine_tuned_model
+        if fine_tuned_model is not None:
+            cls._run.summary["fine_tuned_model"] = fine_tuned_model
+
+        # training/validation files and fine-tune details
+        cls._log_artifacts(
+            fine_tune,
+            project,
+            entity,
+            log_datasets,
+            overwrite,
+            model_artifact_name,
+            model_artifact_type,
+        )
+
+        # mark run as complete
+        cls._run.summary["status"] = "succeeded"
+
+        cls._run.finish()
+        return True
+
+    @classmethod
+    def _ensure_logged_in(cls):
+        if not cls._logged_in:
+            if wandb.login():
+                cls._logged_in = True
+            else:
+                raise Exception(
+                    "It appears you are not currently logged in to Weights & Biases. "
+                    "Please run `wandb login` in your terminal or `wandb.login()` in a notebook. "
+                    "Create a new API key at https://wandb.ai/settings and store it securely."
+                )
+
+    @classmethod
+    def _get_wandb_run(cls, run_path: str):
+        cls._ensure_logged_in()
+        try:
+            if cls._wandb_api is None:
+                cls._wandb_api = wandb.Api()
+            return cls._wandb_api.run(run_path)
+        except Exception:
+            return None
+
+    @classmethod
+    def _get_wandb_artifact(cls, artifact_path: str):
+        cls._ensure_logged_in()
+        try:
+            if cls._wandb_api is None:
+                cls._wandb_api = wandb.Api()
+            return cls._wandb_api.artifact(artifact_path)
+        except Exception:
+            return None
+
+    @classmethod
+    def _get_config(cls, fine_tune: FineTuningJob) -> dict[str, Any]:
+        config = dict(fine_tune)
+        config["result_files"] = config["result_files"][0]
+        if config.get("created_at"):
+            config["created_at"] = datetime.datetime.fromtimestamp(
+                config["created_at"]
+            ).strftime("%Y-%m-%d %H:%M:%S")
+        if config.get("finished_at"):
+            config["finished_at"] = datetime.datetime.fromtimestamp(
+                config["finished_at"]
+            ).strftime("%Y-%m-%d %H:%M:%S")
+        if config.get("hyperparameters"):
+            config["hyperparameters"] = cls.sanitize(config["hyperparameters"])
+        if config.get("error"):
+            config["error"] = cls.sanitize(config["error"])
+        return config
+
+    @classmethod
+    def _unpack_hyperparameters(cls, hyperparameters: Hyperparameters):
+        # `Hyperparameters` object is not unpacking properly using `vars` or `__dict__`,
+        # vars(hyperparameters) return {n_epochs: n} only.
+        hyperparams = {}
+        try:
+            hyperparams["n_epochs"] = hyperparameters.n_epochs
+            hyperparams["batch_size"] = hyperparameters.batch_size
+            hyperparams["learning_rate_multiplier"] = (
+                hyperparameters.learning_rate_multiplier
+            )
+        except Exception:
+            # If unpacking fails, return the object to be logged as config
+            return None
+
+        return hyperparams
+
+    @staticmethod
+    def sanitize(input: Any) -> dict | list | str:
+        valid_types = [bool, int, float, str]
+        if isinstance(input, (Hyperparameters, Error)):
+            return dict(input)
+        if isinstance(input, dict):
+            return {
+                k: v if type(v) in valid_types else str(v) for k, v in input.items()
+            }
+        elif isinstance(input, list):
+            return [v if type(v) in valid_types else str(v) for v in input]
+        else:
+            return str(input)
+
+    @classmethod
+    def _log_artifacts(
+        cls,
+        fine_tune: FineTuningJob,
+        project: str,
+        entity: str | None,
+        log_datasets: bool,
+        overwrite: bool,
+        model_artifact_name: str,
+        model_artifact_type: str,
+    ) -> None:
+        if log_datasets:
+            wandb.termlog("Logging training/validation files...")
+            # training/validation files
+            training_file = fine_tune.training_file if fine_tune.training_file else None
+            validation_file = (
+                fine_tune.validation_file if fine_tune.validation_file else None
+            )
+            for file, prefix, artifact_type in (
+                (training_file, "train", "training_files"),
+                (validation_file, "valid", "validation_files"),
+            ):
+                if file is not None:
+                    cls._log_artifact_inputs(
+                        file, prefix, artifact_type, project, entity, overwrite
+                    )
+
+        # fine-tune details
+        fine_tune_id = fine_tune.id
+        artifact = wandb.Artifact(
+            model_artifact_name,
+            type=model_artifact_type,
+            metadata=dict(fine_tune),
+        )
+
+        with artifact.new_file("model_metadata.json", mode="w", encoding="utf-8") as f:
+            dict_fine_tune = dict(fine_tune)
+            dict_fine_tune["hyperparameters"] = cls.sanitize(
+                dict_fine_tune["hyperparameters"]
+            )
+            dict_fine_tune["error"] = cls.sanitize(dict_fine_tune["error"])
+            dict_fine_tune = cls.sanitize(dict_fine_tune)
+            json.dump(dict_fine_tune, f, indent=2)
+        cls._run.log_artifact(
+            artifact,
+            aliases=["latest", fine_tune_id],
+        )
+
+    @classmethod
+    def _log_artifact_inputs(
+        cls,
+        file_id: str | None,
+        prefix: str,
+        artifact_type: str,
+        project: str,
+        entity: str | None,
+        overwrite: bool,
+    ) -> None:
+        # get input artifact
+        artifact_name = f"{prefix}-{file_id}"
+        # sanitize name to valid wandb artifact name
+        artifact_name = re.sub(r"[^a-zA-Z0-9_\-.]", "_", artifact_name)
+        artifact_alias = file_id
+        artifact_path = f"{project}/{artifact_name}:{artifact_alias}"
+        if entity is not None:
+            artifact_path = f"{entity}/{artifact_path}"
+        artifact = cls._get_wandb_artifact(artifact_path)
+
+        # create artifact if file not already logged previously
+        if artifact is None or overwrite:
+            # get file content
+            try:
+                file_content = cls.openai_client.files.content(file_id=file_id)
+            except openai.NotFoundError:
+                wandb.termerror(
+                    f"File {file_id} could not be retrieved. Make sure you have OpenAI permissions to download training/validation files"
+                )
+                return
+
+            artifact = wandb.Artifact(artifact_name, type=artifact_type)
+            with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
+                tmp_file.write(file_content.content)
+                tmp_file_path = tmp_file.name
+            artifact.add_file(tmp_file_path, file_id)
+            os.unlink(tmp_file_path)
+
+            # create a Table
+            try:
+                table, n_items = cls._make_table(file_content.text)
+                # Add table to the artifact.
+                artifact.add(table, file_id)
+                # Add the same table to the workspace.
+                cls._run.log({f"{prefix}_data": table})
+                # Update the run config and artifact metadata
+                cls._run.config.update({f"n_{prefix}": n_items})
+                artifact.metadata["items"] = n_items
+            except Exception as e:
+                wandb.termerror(
+                    f"Issue saving {file_id} as a Table to Artifacts, exception:\n  '{e}'"
+                )
+        else:
+            # log number of items
+            cls._run.config.update({f"n_{prefix}": artifact.metadata.get("items")})
+
+        cls._run.use_artifact(artifact, aliases=["latest", artifact_alias])
+
+    @classmethod
+    def _make_table(cls, file_content: str) -> tuple[Table, int]:
+        table = wandb.Table(columns=["role: system", "role: user", "role: assistant"])
+
+        df = pd.read_json(io.StringIO(file_content), orient="records", lines=True)
+        for _idx, message in df.iterrows():
+            messages = message.messages
+            assert len(messages) == 3
+            table.add_data(
+                messages[0]["content"],
+                messages[1]["content"],
+                messages[2]["content"],
+            )
+
+        return table, len(df)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/openai/openai.py

@@ -0,0 +1,22 @@
+import logging
+
+from wandb.sdk.integration_utils.auto_logging import AutologAPI
+
+from .resolver import OpenAIRequestResponseResolver
+
+logger = logging.getLogger(__name__)
+
+
+autolog = AutologAPI(
+    name="OpenAI",
+    symbols=(
+        "Edit.create",
+        "Completion.create",
+        "ChatCompletion.create",
+        "Edit.acreate",
+        "Completion.acreate",
+        "ChatCompletion.acreate",
+    ),
+    resolver=OpenAIRequestResponseResolver(),
+    telemetry_feature="openai_autolog",
+)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/openai/resolver.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import datetime
+import io
+import logging
+from collections.abc import Sequence
+from dataclasses import asdict, dataclass
+from typing import Any
+
+import wandb
+from wandb.sdk.data_types import trace_tree
+from wandb.sdk.integration_utils.auto_logging import Response
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UsageMetrics:
+    elapsed_time: float = None
+    prompt_tokens: int = None
+    completion_tokens: int = None
+    total_tokens: int = None
+
+
+@dataclass
+class Metrics:
+    usage: UsageMetrics = None
+    stats: wandb.Table = None
+    trace: trace_tree.WBTraceTree = None
+
+
+usage_metric_keys = {f"usage/{k}" for k in asdict(UsageMetrics())}
+
+
+class OpenAIRequestResponseResolver:
+    def __init__(self):
+        self.define_metrics_called = False
+
+    def __call__(
+        self,
+        args: Sequence[Any],
+        kwargs: dict[str, Any],
+        response: Response,
+        start_time: float,  # pass to comply with the protocol, but use response["created"] instead
+        time_elapsed: float,
+    ) -> dict[str, Any] | None:
+        request = kwargs
+
+        if not self.define_metrics_called:
+            # define metrics on first call
+            for key in usage_metric_keys:
+                wandb.define_metric(key, step_metric="_timestamp")
+            self.define_metrics_called = True
+
+        try:
+            if response.get("object") == "edit":
+                return self._resolve_edit(request, response, time_elapsed)
+            elif response.get("object") == "text_completion":
+                return self._resolve_completion(request, response, time_elapsed)
+            elif response.get("object") == "chat.completion":
+                return self._resolve_chat_completion(request, response, time_elapsed)
+            else:
+                # todo: properly treat failed requests
+                logger.info(
+                    f"Unsupported OpenAI response object: {response.get('object')}"
+                )
+        except Exception as e:
+            logger.warning(f"Failed to resolve request/response: {e}")
+        return None
+
+    @staticmethod
+    def results_to_trace_tree(
+        request: dict[str, Any],
+        response: Response,
+        results: list[trace_tree.Result],
+        time_elapsed: float,
+    ) -> trace_tree.WBTraceTree:
+        """Converts the request, response, and results into a trace tree.
+
+        params:
+            request: The request dictionary
+            response: The response object
+            results: A list of results object
+            time_elapsed: The time elapsed in seconds
+        returns:
+            A wandb trace tree object.
+        """
+        start_time_ms = int(round(response["created"] * 1000))
+        end_time_ms = start_time_ms + int(round(time_elapsed * 1000))
+        span = trace_tree.Span(
+            name=f"{response.get('model', 'openai')}_{response['object']}_{response.get('created')}",
+            attributes=dict(response),  # type: ignore
+            start_time_ms=start_time_ms,
+            end_time_ms=end_time_ms,
+            span_kind=trace_tree.SpanKind.LLM,
+            results=results,
+        )
+        model_obj = {"request": request, "response": response, "_kind": "openai"}
+        return trace_tree.WBTraceTree(root_span=span, model_dict=model_obj)
+
+    def _resolve_edit(
+        self,
+        request: dict[str, Any],
+        response: Response,
+        time_elapsed: float,
+    ) -> dict[str, Any]:
+        """Resolves the request and response objects for `openai.Edit`."""
+        request_str = (
+            f"\n\n**Instruction**: {request['instruction']}\n\n"
+            f"**Input**: {request['input']}\n"
+        )
+        choices = [
+            f"\n\n**Edited**: {choice['text']}\n" for choice in response["choices"]
+        ]
+
+        return self._resolve_metrics(
+            request=request,
+            response=response,
+            request_str=request_str,
+            choices=choices,
+            time_elapsed=time_elapsed,
+        )
+
+    def _resolve_completion(
+        self,
+        request: dict[str, Any],
+        response: Response,
+        time_elapsed: float,
+    ) -> dict[str, Any]:
+        """Resolves the request and response objects for `openai.Completion`."""
+        request_str = f"\n\n**Prompt**: {request['prompt']}\n"
+        choices = [
+            f"\n\n**Completion**: {choice['text']}\n" for choice in response["choices"]
+        ]
+
+        return self._resolve_metrics(
+            request=request,
+            response=response,
+            request_str=request_str,
+            choices=choices,
+            time_elapsed=time_elapsed,
+        )
+
+    def _resolve_chat_completion(
+        self,
+        request: dict[str, Any],
+        response: Response,
+        time_elapsed: float,
+    ) -> dict[str, Any]:
+        """Resolves the request and response objects for `openai.Completion`."""
+        prompt = io.StringIO()
+        for message in request["messages"]:
+            prompt.write(f"\n\n**{message['role']}**: {message['content']}\n")
+        request_str = prompt.getvalue()
+
+        choices = [
+            f"\n\n**{choice['message']['role']}**: {choice['message']['content']}\n"
+            for choice in response["choices"]
+        ]
+
+        return self._resolve_metrics(
+            request=request,
+            response=response,
+            request_str=request_str,
+            choices=choices,
+            time_elapsed=time_elapsed,
+        )
+
+    def _resolve_metrics(
+        self,
+        request: dict[str, Any],
+        response: Response,
+        request_str: str,
+        choices: list[str],
+        time_elapsed: float,
+    ) -> dict[str, Any]:
+        """Resolves the request and response objects for `openai.Completion`."""
+        results = [
+            trace_tree.Result(
+                inputs={"request": request_str},
+                outputs={"response": choice},
+            )
+            for choice in choices
+        ]
+        metrics = self._get_metrics_to_log(request, response, results, time_elapsed)
+        return self._convert_metrics_to_dict(metrics)
+
+    @staticmethod
+    def _get_usage_metrics(response: Response, time_elapsed: float) -> UsageMetrics:
+        """Gets the usage stats from the response object."""
+        if response.get("usage"):
+            usage_stats = UsageMetrics(**response["usage"])
+        else:
+            usage_stats = UsageMetrics()
+        usage_stats.elapsed_time = time_elapsed
+        return usage_stats
+
+    def _get_metrics_to_log(
+        self,
+        request: dict[str, Any],
+        response: Response,
+        results: list[Any],
+        time_elapsed: float,
+    ) -> Metrics:
+        model = response.get("model") or request.get("model")
+        usage_metrics = self._get_usage_metrics(response, time_elapsed)
+
+        usage = []
+        for result in results:
+            row = {
+                "request": result.inputs["request"],
+                "response": result.outputs["response"],
+                "model": model,
+                "start_time": datetime.datetime.fromtimestamp(response["created"]),
+                "end_time": datetime.datetime.fromtimestamp(
+                    response["created"] + time_elapsed
+                ),
+                "request_id": response.get("id", None),
+                "api_type": response.get("api_type", "openai"),
+                "session_id": wandb.run.id,
+            }
+            row.update(asdict(usage_metrics))
+            usage.append(row)
+        usage_table = wandb.Table(
+            columns=list(usage[0].keys()),
+            data=[(item.values()) for item in usage],
+        )
+
+        trace = self.results_to_trace_tree(request, response, results, time_elapsed)
+
+        metrics = Metrics(stats=usage_table, trace=trace, usage=usage_metrics)
+        return metrics
+
+    @staticmethod
+    def _convert_metrics_to_dict(metrics: Metrics) -> dict[str, Any]:
+        """Converts metrics to a dict."""
+        metrics_dict = {
+            "stats": metrics.stats,
+            "trace": metrics.trace,
+        }
+        usage_stats = {f"usage/{k}": v for k, v in asdict(metrics.usage).items()}
+        metrics_dict.update(usage_stats)
+        return metrics_dict

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/prodigy/__init__.py

@@ -0,0 +1,3 @@
+from .prodigy import upload_dataset
+
+__all__ = ["upload_dataset"]

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/prodigy/prodigy.py

@@ -0,0 +1,284 @@
+"""Prodigy integration for W&B.
+
+User can upload Prodigy annotated datasets directly
+from the local database to W&B in Tables format.
+
+Example usage:
+
+```python
+import wandb
+from wandb.integration.prodigy import upload_dataset
+
+run = wandb.init(project="prodigy")
+upload_dataset("name_of_dataset")
+wandb.finish()
+```
+"""
+
+import base64
+import collections.abc
+import io
+import urllib
+from copy import deepcopy
+
+import pandas as pd
+from PIL import Image
+
+import wandb
+from wandb import util
+from wandb.plot.utils import test_missing
+from wandb.sdk.lib import telemetry as wb_telemetry
+
+
+def named_entity(docs):
+    """Create a named entity visualization.
+
+    Taken from https://github.com/wandb/wandb/blob/main/wandb/plots/named_entity.py.
+    """
+    spacy = util.get_module(
+        "spacy",
+        required="part_of_speech requires the spacy library, install with `pip install spacy`",
+    )
+
+    util.get_module(
+        "en_core_web_md",
+        required="part_of_speech requires `en_core_web_md` library, install with `python -m spacy download en_core_web_md`",
+    )
+
+    # Test for required packages and missing & non-integer values in docs data
+    if test_missing(docs=docs):
+        html = spacy.displacy.render(
+            docs, style="ent", page=True, minify=True, jupyter=False
+        )
+        wandb_html = wandb.Html(html)
+        return wandb_html
+
+
+def merge(dict1, dict2):
+    """Return a new dictionary by merging two dictionaries recursively."""
+    result = deepcopy(dict1)
+
+    for key, value in dict2.items():
+        if isinstance(value, collections.abc.Mapping):
+            result[key] = merge(result.get(key, {}), value)
+        else:
+            result[key] = deepcopy(dict2[key])
+
+    return result
+
+
+def get_schema(list_data_dict, struct, array_dict_types):
+    """Get a schema of the dataset's structure and data types."""
+    # Get the structure of the JSON objects in the database
+    # This is similar to getting a JSON schema but with slightly different format
+    for _i, item in enumerate(list_data_dict):
+        # If the list contains dict objects
+        for k, v in item.items():
+            # Check if key already exists in template
+            if k not in struct:
+                if isinstance(v, list):
+                    if len(v) > 0 and isinstance(v[0], list):
+                        # nested list structure
+                        struct[k] = type(v)  # type list
+                    elif len(v) > 0 and not (isinstance(v[0], (list, dict))):
+                        # list of singular values
+                        struct[k] = type(v)  # type list
+                    else:
+                        # list of dicts
+                        array_dict_types.append(
+                            k
+                        )  # keep track of keys that are type list[dict]
+                        struct[k] = {}
+                        struct[k] = get_schema(v, struct[k], array_dict_types)
+                elif isinstance(v, dict):
+                    struct[k] = {}
+                    struct[k] = get_schema([v], struct[k], array_dict_types)
+                else:
+                    struct[k] = type(v)
+            else:
+                # Get the value of struct[k] which is the current template
+                # Find new keys and then merge the two templates together
+                cur_struct = struct[k]
+                if isinstance(v, list):
+                    if len(v) > 0 and isinstance(v[0], list):
+                        # nested list coordinate structure
+                        # if the value in the item is currently None, then update
+                        if v is not None:
+                            struct[k] = type(v)  # type list
+                    elif len(v) > 0 and not (isinstance(v[0], (list, dict))):
+                        # single list with values
+                        # if the value in the item is currently None, then update
+                        if v is not None:
+                            struct[k] = type(v)  # type list
+                    else:
+                        array_dict_types.append(
+                            k
+                        )  # keep track of keys that are type list[dict]
+                        struct[k] = {}
+                        struct[k] = get_schema(v, struct[k], array_dict_types)
+                        # merge cur_struct and struct[k], remove duplicates
+                        struct[k] = merge(struct[k], cur_struct)
+                elif isinstance(v, dict):
+                    struct[k] = {}
+                    struct[k] = get_schema([v], struct[k], array_dict_types)
+                    # merge cur_struct and struct[k], remove duplicates
+                    struct[k] = merge(struct[k], cur_struct)
+                else:
+                    # if the value in the item is currently None, then update
+                    if v is not None:
+                        struct[k] = type(v)
+
+    return struct
+
+
+def standardize(item, structure, array_dict_types):
+    """Standardize all rows/entries in dataset to fit the schema.
+
+    Will look for missing values and fill it in so all rows have
+    the same items and structure.
+    """
+    for k, v in structure.items():
+        if k not in item:
+            # If the structure/field does not exist
+            if isinstance(v, dict) and (k not in array_dict_types):
+                # If key k is of type dict, and not not a type list[dict]
+                item[k] = {}
+                standardize(item[k], v, array_dict_types)
+            elif isinstance(v, dict) and (k in array_dict_types):
+                # If key k is of type dict, and is actually of type list[dict],
+                # just treat as a list and set to None by default
+                item[k] = None
+            else:
+                # Assign a default type
+                item[k] = v()
+        else:
+            # If the structure/field already exists and is a list or dict
+            if isinstance(item[k], list):
+                # ignore if item is a nested list structure or list of non-dicts
+                condition = (
+                    not (len(item[k]) > 0 and isinstance(item[k][0], list))
+                ) and (
+                    not (
+                        len(item[k]) > 0 and not (isinstance(item[k][0], (list, dict)))
+                    )
+                )
+                if condition:
+                    for sub_item in item[k]:
+                        standardize(sub_item, v, array_dict_types)
+            elif isinstance(item[k], dict):
+                standardize(item[k], v, array_dict_types)
+
+
+def create_table(data):
+    """Create a W&B Table.
+
+    - Create/decode images from URL/Base64
+    - Uses spacy to translate NER span data to visualizations.
+    """
+    # create table object from columns
+    table_df = pd.DataFrame(data)
+    columns = list(table_df.columns)
+    if ("spans" in table_df.columns) and ("text" in table_df.columns):
+        columns.append("spans_visual")
+    if "image" in columns:
+        columns.append("image_visual")
+    main_table = wandb.Table(columns=columns)
+
+    # Convert to dictionary format to maintain order during processing
+    matrix = table_df.to_dict(orient="records")
+
+    # Import en_core_web_md if exists
+    en_core_web_md = util.get_module(
+        "en_core_web_md",
+        required="part_of_speech requires `en_core_web_md` library, install with `python -m spacy download en_core_web_md`",
+    )
+    nlp = en_core_web_md.load(disable=["ner"])
+
+    # Go through each individual row
+    for _i, document in enumerate(matrix):
+        # Text NER span visualizations
+        if ("spans_visual" in columns) and ("text" in columns):
+            # Add visuals for spans
+            document["spans_visual"] = None
+            doc = nlp(document["text"])
+            ents = []
+            if ("spans" in document) and (document["spans"] is not None):
+                for span in document["spans"]:
+                    if ("start" in span) and ("end" in span) and ("label" in span):
+                        charspan = doc.char_span(
+                            span["start"], span["end"], span["label"]
+                        )
+                        ents.append(charspan)
+                doc.ents = ents
+                document["spans_visual"] = named_entity(docs=doc)
+
+        # Convert image link to wandb Image
+        if "image" in columns:
+            # Turn into wandb image
+            document["image_visual"] = None
+            if ("image" in document) and (document["image"] is not None):
+                isurl = urllib.parse.urlparse(document["image"]).scheme in (
+                    "http",
+                    "https",
+                )
+                isbase64 = ("data:" in document["image"]) and (
+                    ";base64" in document["image"]
+                )
+                if isurl:
+                    # is url
+                    try:
+                        im = Image.open(urllib.request.urlopen(document["image"]))
+                        document["image_visual"] = wandb.Image(im)
+                    except urllib.error.URLError:
+                        wandb.termwarn(f"Image URL {document['image']} is invalid.")
+                        document["image_visual"] = None
+                elif isbase64:
+                    # is base64 uri
+                    imgb64 = document["image"].split("base64,")[1]
+                    try:
+                        msg = base64.b64decode(imgb64)
+                        buf = io.BytesIO(msg)
+                        im = Image.open(buf)
+                        document["image_visual"] = wandb.Image(im)
+                    except base64.binascii.Error:
+                        wandb.termwarn(f"Base64 string {document['image']} is invalid.")
+                        document["image_visual"] = None
+                else:
+                    # is data path
+                    document["image_visual"] = wandb.Image(document["image"])
+
+        # Create row and append to table
+        values_list = list(document.values())
+        main_table.add_data(*values_list)
+    return main_table
+
+
+def upload_dataset(dataset_name):
+    """Upload dataset from local database to Weights & Biases.
+
+    Args:
+        dataset_name: The name of the dataset in the Prodigy database.
+    """
+    # Check if wandb.init has been called
+    if wandb.run is None:
+        raise ValueError("You must call wandb.init() before upload_dataset()")
+
+    with wb_telemetry.context(run=wandb.run) as tel:
+        tel.feature.prodigy = True
+
+    prodigy_db = util.get_module(
+        "prodigy.components.db",
+        required="`prodigy` library is required but not installed. Please see https://prodi.gy/docs/install",
+    )
+    # Retrieve and upload prodigy dataset
+    database = prodigy_db.connect()
+    data = database.get_dataset(dataset_name)
+
+    array_dict_types = []
+    schema = get_schema(data, {}, array_dict_types)
+
+    for i, _d in enumerate(data):
+        standardize(data[i], schema, array_dict_types)
+    table = create_table(data)
+    wandb.log({dataset_name: table})
+    wandb.termlog(f"Prodigy dataset `{dataset_name}` uploaded.")

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sacred/__init__.py

@@ -0,0 +1,117 @@
+import warnings
+
+import numpy
+from sacred.dependencies import get_digest
+from sacred.observers import RunObserver
+
+import wandb
+
+
+class WandbObserver(RunObserver):
+    """Log sacred experiment data to W&B.
+
+    Args:
+        Accepts all the arguments accepted by wandb.init().
+
+        name — A display name for this run, which shows up in the UI and is editable, doesn't have to be unique
+        notes — A multiline string description associated with the run
+        config — a dictionary-like object to set as initial config
+        project — the name of the project to which this run will belong
+        tags — a list of strings to associate with this run as tags
+        dir — the path to a directory where artifacts will be written (default: ./wandb)
+        entity — the team posting this run (default: your username or your default team)
+        job_type — the type of job you are logging, e.g. eval, worker, ps (default: training)
+        save_code — save the main python or notebook file to wandb to enable diffing (default: editable from your settings page)
+        group — a string by which to group other runs; see Grouping
+        reinit — Shorthand for the reinit setting that defines what to do when `wandb.init()` is called while a run is active. See the setting's documentation.
+        id — A unique ID for this run primarily used for Resuming. It must be globally unique, and if you delete a run you can't reuse the ID. Use the name field for a descriptive, useful name for the run. The ID cannot contain special characters.
+        resume — if set to True, the run auto resumes; can also be a unique string for manual resuming; see Resuming (default: False)
+        anonymous — can be "allow", "never", or "must". This enables or explicitly disables anonymous logging. (default: never)
+        force — whether to force a user to be logged into wandb when running a script (default: False)
+        magic — (bool, dict, or str, optional): magic configuration as bool, dict, json string, yaml filename. If set to True will attempt to auto-instrument your script. (default: None)
+        sync_tensorboard — A boolean indicating whether or not copy all TensorBoard logs wandb; see Tensorboard (default: False)
+        monitor_gym — A boolean indicating whether or not to log videos generated by OpenAI Gym; see Ray Tune (default: False)
+        allow_val_change — whether to allow wandb.config values to change, by default we throw an exception if config values are overwritten. (default: False)
+
+    Examples:
+        Create sacred experiment::
+        from wandb.sacred import WandbObserver
+        ex.observers.append(WandbObserver(project='sacred_test',
+                                                name='test1'))
+        @ex.config
+        def cfg():
+            C = 1.0
+            gamma = 0.7
+        @ex.automain
+        def run(C, gamma, _run):
+            iris = datasets.load_iris()
+            per = permutation(iris.target.size)
+            iris.data = iris.data[per]
+            iris.target = iris.target[per]
+            clf = svm.SVC(C, 'rbf', gamma=gamma)
+            clf.fit(iris.data[:90],
+                    iris.target[:90])
+            return clf.score(iris.data[90:],
+                                iris.target[90:])
+    """
+
+    def __init__(self, **kwargs):
+        self.run = wandb.init(**kwargs)
+        self.resources = {}
+
+    def started_event(
+        self, ex_info, command, host_info, start_time, config, meta_info, _id
+    ):
+        # TODO: add the source code file
+        # TODO: add dependencies and metadata.
+        self.__update_config(config)
+
+    def completed_event(self, stop_time, result):
+        if result:
+            if not isinstance(result, tuple):
+                result = (
+                    result,
+                )  # transform single result to tuple so that both single & multiple results use same code
+
+            for i, r in enumerate(result):
+                if isinstance(r, (float, int)):
+                    wandb.log({f"result_{i}": float(r)})
+                elif isinstance(r, dict):
+                    wandb.log(r)
+                elif isinstance(r, object):
+                    artifact = wandb.Artifact(f"result_{i}.pkl", type="result")
+                    artifact.add_file(r)
+                    self.run.log_artifact(artifact)
+                elif isinstance(r, numpy.ndarray):
+                    wandb.log({f"result_{i}": wandb.Image(r)})
+                else:
+                    warnings.warn(
+                        f"logging results does not support type '{type(r)}' results. Ignoring this result",
+                        stacklevel=2,
+                    )
+
+    def artifact_event(self, name, filename, metadata=None, content_type=None):
+        if content_type is None:
+            content_type = "file"
+        artifact = wandb.Artifact(name, type=content_type)
+        artifact.add_file(filename)
+        self.run.log_artifact(artifact)
+
+    def resource_event(self, filename):
+        """TODO: Maintain resources list."""
+        if filename not in self.resources:
+            md5 = get_digest(filename)
+            self.resources[filename] = md5
+
+    def log_metrics(self, metrics_by_name, info):
+        for metric_name, metric_ptr in metrics_by_name.items():
+            for _step, value in zip(metric_ptr["steps"], metric_ptr["values"]):
+                if isinstance(value, numpy.ndarray):
+                    wandb.log({metric_name: wandb.Image(value)})
+                else:
+                    wandb.log({metric_name: value})
+
+    def __update_config(self, config):
+        for k, v in config.items():
+            self.run.config[k] = v
+        self.run.config["resources"] = []

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sagemaker/__init__.py

@@ -0,0 +1,14 @@
+"""wandb integration sagemaker module."""
+
+from .auth import sagemaker_auth
+from .config import is_using_sagemaker, parse_sm_config
+from .resources import parse_sm_secrets, set_global_settings, set_run_id
+
+__all__ = [
+    "sagemaker_auth",
+    "is_using_sagemaker",
+    "parse_sm_config",
+    "parse_sm_secrets",
+    "set_global_settings",
+    "set_run_id",
+]

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sagemaker/auth.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from wandb import env
+from wandb.sdk import wandb_setup
+from wandb.sdk.lib import wbauth
+
+
+def sagemaker_auth(
+    overrides: dict[str, Any] | None = None,
+    path: str = ".",
+    api_key: str | None = None,
+) -> None:
+    """Write a secrets.env file with the W&B ApiKey and any additional secrets passed.
+
+    Args:
+        overrides: Additional environment variables to write to secrets.env
+        path: The path to write the secrets file.
+    """
+    overrides = overrides or dict()
+
+    api_key = (
+        overrides.get(env.API_KEY, None)
+        or api_key
+        or wandb_setup.singleton().settings.api_key
+        or wbauth.read_netrc_auth(host=wandb_setup.singleton().settings.base_url)
+    )
+
+    if api_key is None:
+        raise ValueError(
+            "Can't find W&B API key, set the WANDB_API_KEY env variable"
+            + " or run `wandb login`"
+        )
+
+    overrides[env.API_KEY] = api_key
+    with open(os.path.join(path, "secrets.env"), "w") as file:
+        for k, v in overrides.items():
+            file.write(f"{k}={v}\n")

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sagemaker/config.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import warnings
+from typing import Any
+
+from . import files as sm_files
+
+
+def is_using_sagemaker() -> bool:
+    """Returns whether we're in a SageMaker environment."""
+    return (
+        os.path.exists(sm_files.SM_PARAM_CONFIG)  #
+        or "SM_TRAINING_ENV" in os.environ
+    )
+
+
+def parse_sm_config() -> dict[str, Any]:
+    """Parses SageMaker configuration.
+
+    Returns:
+        A dictionary of SageMaker config keys/values
+        or an empty dict if not found.
+        SM_TRAINING_ENV is a json string of the
+        training environment variables set by SageMaker
+        and is only available when running in SageMaker,
+        but not in local mode.
+        SM_TRAINING_ENV is set by the SageMaker container and
+        contains arguments such as hyperparameters
+        and arguments passed to the training job.
+    """
+    conf = {}
+
+    if os.path.exists(sm_files.SM_PARAM_CONFIG):
+        conf["sagemaker_training_job_name"] = os.getenv("TRAINING_JOB_NAME")
+
+        # Hyperparameter searches quote configs...
+        with open(sm_files.SM_PARAM_CONFIG) as fid:
+            for key, val in json.load(fid).items():
+                cast = val.strip('"')
+                if re.match(r"^-?[\d]+$", cast):
+                    cast = int(cast)
+                elif re.match(r"^-?[.\d]+$", cast):
+                    cast = float(cast)
+                conf[key] = cast
+
+    if env := os.environ.get("SM_TRAINING_ENV"):
+        try:
+            conf.update(json.loads(env))
+        except json.JSONDecodeError:
+            warnings.warn(
+                "Failed to parse SM_TRAINING_ENV not valid JSON string",
+                stacklevel=2,
+            )
+
+    return conf

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sagemaker/files.py

@@ -0,0 +1,2 @@
+SM_PARAM_CONFIG = "/opt/ml/input/config/hyperparameters.json"
+SM_SECRETS = "secrets.env"

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sagemaker/resources.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import os
+import secrets
+import socket
+import string
+
+import wandb
+
+from . import config
+from . import files as sm_files
+
+
+def set_run_id(run_settings: wandb.Settings) -> bool:
+    """Set a run ID and group when using SageMaker.
+
+    Returns whether the ID and group were updated.
+    """
+    # Added in https://github.com/wandb/wandb/pull/3290.
+    #
+    # Prevents SageMaker from overriding the run ID configured
+    # in environment variables. Note, however, that it will still
+    # override a run ID passed explicitly to `wandb.init()`.
+    if os.getenv("WANDB_RUN_ID"):
+        return False
+
+    run_group = os.getenv("TRAINING_JOB_NAME")
+    if not run_group:
+        return False
+
+    alphanumeric = string.ascii_lowercase + string.digits
+    random = "".join(secrets.choice(alphanumeric) for _ in range(6))
+
+    host = os.getenv("CURRENT_HOST", socket.gethostname())
+
+    run_settings.run_id = f"{run_group}-{random}-{host}"
+    run_settings.run_group = run_group
+    return True
+
+
+def set_global_settings(settings: wandb.Settings) -> None:
+    """Set global W&B settings based on the SageMaker environment."""
+    if env := parse_sm_secrets():
+        settings.update_from_env_vars(env)
+
+    # The SageMaker config may contain an API key, in which case it
+    # takes precedence over the value in the secrets. It's unclear
+    # whether this is by design, or by accident; we keep it for
+    # backward compatibility for now.
+    sm_config = config.parse_sm_config()
+    if api_key := sm_config.get("wandb_api_key"):
+        settings.api_key = api_key
+
+
+def parse_sm_secrets() -> dict[str, str]:
+    """We read our api_key from secrets.env in SageMaker."""
+    env_dict = dict()
+    # Set secret variables
+    if os.path.exists(sm_files.SM_SECRETS):
+        for line in open(sm_files.SM_SECRETS):
+            key, val = line.strip().split("=", 1)
+            env_dict[key] = val
+    return env_dict

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sb3/__init__.py

@@ -0,0 +1,3 @@
+from .sb3 import WandbCallback
+
+__all__ = ["WandbCallback"]

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sb3/sb3.py

@@ -0,0 +1,151 @@
+"""W&B callback for sb3.
+
+Really simple callback to get logging for each tree
+
+Example usage:
+
+```python
+import gym
+from stable_baselines3 import PPO
+from stable_baselines3.common.monitor import Monitor
+from stable_baselines3.common.vec_env import DummyVecEnv, VecVideoRecorder
+import wandb
+from wandb.integration.sb3 import WandbCallback
+
+
+config = {
+    "policy_type": "MlpPolicy",
+    "total_timesteps": 25000,
+    "env_name": "CartPole-v1",
+}
+run = wandb.init(
+    project="sb3",
+    config=config,
+    sync_tensorboard=True,  # auto-upload sb3's tensorboard metrics
+    monitor_gym=True,  # auto-upload the videos of agents playing the game
+    save_code=True,  # optional
+)
+
+
+def make_env():
+    env = gym.make(config["env_name"])
+    env = Monitor(env)  # record stats such as returns
+    return env
+
+
+env = DummyVecEnv([make_env])
+env = VecVideoRecorder(
+    env, "videos", record_video_trigger=lambda x: x % 2000 == 0, video_length=200
+)
+model = PPO(config["policy_type"], env, verbose=1, tensorboard_log=f"runs")
+model.learn(
+    total_timesteps=config["total_timesteps"],
+    callback=WandbCallback(
+        model_save_path=f"models/{run.id}",
+        gradient_save_freq=100,
+        log="all",
+    ),
+)
+```
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Literal
+
+from stable_baselines3.common.callbacks import BaseCallback  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry as wb_telemetry
+
+logger = logging.getLogger(__name__)
+
+
+class WandbCallback(BaseCallback):
+    """Callback for logging experiments to Weights and Biases.
+
+    Log SB3 experiments to Weights and Biases
+        - Added model tracking and uploading
+        - Added complete hyperparameters recording
+        - Added gradient logging
+        - Note that `wandb.init(...)` must be called before the WandbCallback can be used.
+
+    Args:
+        verbose: The verbosity of sb3 output
+        model_save_path: Path to the folder where the model will be saved, The default value is `None` so the model is not logged
+        model_save_freq: Frequency to save the model
+        gradient_save_freq: Frequency to log gradient. The default value is 0 so the gradients are not logged
+        log: What to log. One of "gradients", "parameters", or "all".
+    """
+
+    def __init__(
+        self,
+        verbose: int = 0,
+        model_save_path: str | None = None,
+        model_save_freq: int = 0,
+        gradient_save_freq: int = 0,
+        log: Literal["gradients", "parameters", "all"] | None = "all",
+    ) -> None:
+        super().__init__(verbose)
+        if wandb.run is None:
+            raise wandb.Error("You must call wandb.init() before WandbCallback()")
+        with wb_telemetry.context() as tel:
+            tel.feature.sb3 = True
+        self.model_save_freq = model_save_freq
+        self.model_save_path = model_save_path
+        self.gradient_save_freq = gradient_save_freq
+        if log not in ["gradients", "parameters", "all", None]:
+            wandb.termwarn(
+                "`log` must be one of `None`, 'gradients', 'parameters', or 'all', "
+                "falling back to 'all'"
+            )
+            log = "all"
+        self.log = log
+        # Create folder if needed
+        if self.model_save_path is not None:
+            os.makedirs(self.model_save_path, exist_ok=True)
+            self.path = os.path.join(self.model_save_path, "model.zip")
+        else:
+            assert self.model_save_freq == 0, (
+                "to use the `model_save_freq` you have to set the `model_save_path` parameter"
+            )
+
+    def _init_callback(self) -> None:
+        d = {}
+        if "algo" not in d:
+            d["algo"] = type(self.model).__name__
+        for key in self.model.__dict__:
+            if key in wandb.config:
+                continue
+            if type(self.model.__dict__[key]) in [float, int, str]:
+                d[key] = self.model.__dict__[key]
+            else:
+                d[key] = str(self.model.__dict__[key])
+        if self.gradient_save_freq > 0:
+            wandb.watch(
+                self.model.policy,
+                log_freq=self.gradient_save_freq,
+                log=self.log,
+            )
+        wandb.config.setdefaults(d)
+
+    def _on_step(self) -> bool:
+        if (
+            self.model_save_freq > 0
+            and self.model_save_path is not None
+            and self.n_calls % self.model_save_freq == 0
+        ):
+            self.save_model()
+        return True
+
+    def _on_training_end(self) -> None:
+        if self.model_save_path is not None:
+            self.save_model()
+
+    def save_model(self) -> None:
+        self.model.save(self.path)
+        wandb.save(self.path, base_path=self.model_save_path)
+        if self.verbose > 1:
+            logger.info(f"Saving model checkpoint to {self.path}")

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/__init__.py

@@ -0,0 +1,37 @@
+"""Create informative charts for scikit-learn models and log them to W&B."""
+
+from .plot import (
+    plot_calibration_curve,
+    plot_class_proportions,
+    plot_classifier,
+    plot_clusterer,
+    plot_confusion_matrix,
+    plot_elbow_curve,
+    plot_feature_importances,
+    plot_learning_curve,
+    plot_outlier_candidates,
+    plot_precision_recall,
+    plot_regressor,
+    plot_residuals,
+    plot_roc,
+    plot_silhouette,
+    plot_summary_metrics,
+)
+
+__all__ = [
+    "plot_classifier",
+    "plot_clusterer",
+    "plot_regressor",
+    "plot_summary_metrics",
+    "plot_learning_curve",
+    "plot_feature_importances",
+    "plot_class_proportions",
+    "plot_calibration_curve",
+    "plot_roc",
+    "plot_precision_recall",
+    "plot_confusion_matrix",
+    "plot_elbow_curve",
+    "plot_silhouette",
+    "plot_residuals",
+    "plot_outlier_candidates",
+]

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/calculate/__init__.py

@@ -0,0 +1,32 @@
+"""Calculates and formats metrics and charts for introspecting sklearn models.
+
+The functions in these modules are designed to be called by functions from the
+plot submodule that have been exported into the namespace of the wandb.sklearn
+submodule, rather than being called directly.
+"""
+
+from .calibration_curves import calibration_curves
+from .class_proportions import class_proportions
+from .confusion_matrix import confusion_matrix
+from .decision_boundaries import decision_boundaries
+from .elbow_curve import elbow_curve
+from .feature_importances import feature_importances
+from .learning_curve import learning_curve
+from .outlier_candidates import outlier_candidates
+from .residuals import residuals
+from .silhouette import silhouette
+from .summary_metrics import summary_metrics
+
+__all__ = [
+    "calibration_curves",
+    "class_proportions",
+    "confusion_matrix",
+    "decision_boundaries",
+    "elbow_curve",
+    "feature_importances",
+    "learning_curve",
+    "outlier_candidates",
+    "residuals",
+    "silhouette",
+    "summary_metrics",
+]

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/calculate/calibration_curves.py

@@ -0,0 +1,125 @@
+from warnings import simplefilter
+
+import numpy as np
+import sklearn
+from sklearn import model_selection, naive_bayes
+from sklearn.calibration import CalibratedClassifierCV
+from sklearn.linear_model import LogisticRegression
+
+import wandb
+from wandb.integration.sklearn import utils
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def calibration_curves(clf, X, y, clf_name):  # noqa: N803
+    # ComplementNB (introduced in 0.20.0) requires non-negative features
+    if int(sklearn.__version__.split(".")[1]) >= 20 and isinstance(
+        clf, naive_bayes.ComplementNB
+    ):
+        X = X - X.min()  # noqa:N806
+
+    # Calibrated with isotonic calibration
+    isotonic = CalibratedClassifierCV(clf, cv=2, method="isotonic")
+
+    # Calibrated with sigmoid calibration
+    sigmoid = CalibratedClassifierCV(clf, cv=2, method="sigmoid")
+
+    # Logistic regression with no calibration as baseline
+    lr = LogisticRegression(C=1.0)
+
+    model_column = []  # color
+    frac_positives_column = []  # y axis
+    mean_pred_value_column = []  # x axis
+    hist_column = []  # barchart y
+    edge_column = []  # barchart x
+
+    # Add curve for perfectly calibrated model
+    # format: model, fraction_of_positives, mean_predicted_value
+    model_column.append("Perfectly calibrated")
+    frac_positives_column.append(0)
+    mean_pred_value_column.append(0)
+    hist_column.append(0)
+    edge_column.append(0)
+    model_column.append("Perfectly calibrated")
+    hist_column.append(0)
+    edge_column.append(0)
+    frac_positives_column.append(1)
+    mean_pred_value_column.append(1)
+
+    x_train, x_test, y_train, y_test = model_selection.train_test_split(
+        X, y, test_size=0.9, random_state=42
+    )
+
+    # Add curve for LogisticRegression baseline and other models
+
+    models = [lr, isotonic, sigmoid]
+    names = ["Logistic", f"{clf_name} Isotonic", f"{clf_name} Sigmoid"]
+
+    for model, name in zip(models, names):
+        model.fit(x_train, y_train)
+        if hasattr(model, "predict_proba"):
+            prob_pos = model.predict_proba(x_test)[:, 1]
+        else:  # use decision function
+            prob_pos = model.decision_function(x_test)
+            prob_pos = (prob_pos - prob_pos.min()) / (prob_pos.max() - prob_pos.min())
+
+        hist, edges = np.histogram(prob_pos, bins=10, density=False)
+        frac_positives, mean_pred_value = sklearn.calibration.calibration_curve(
+            y_test, prob_pos, n_bins=10
+        )
+
+        # format: model, fraction_of_positives, mean_predicted_value
+        num_entries = len(frac_positives)
+        for i in range(num_entries):
+            hist_column.append(hist[i])
+            edge_column.append(edges[i])
+            model_column.append(name)
+            frac_positives_column.append(utils.round_3(frac_positives[i]))
+            mean_pred_value_column.append(utils.round_3(mean_pred_value[i]))
+            if utils.check_against_limit(
+                i,
+                "calibration_curve",
+                utils.chart_limit - 2,
+            ):
+                break
+
+    table = make_table(
+        model_column,
+        frac_positives_column,
+        mean_pred_value_column,
+        hist_column,
+        edge_column,
+    )
+    chart = wandb.visualize("wandb/calibration/v1", table)
+
+    return chart
+
+
+def make_table(
+    model_column,
+    frac_positives_column,
+    mean_pred_value_column,
+    hist_column,
+    edge_column,
+):
+    columns = [
+        "model",
+        "fraction_of_positives",
+        "mean_predicted_value",
+        "hist_dict",
+        "edge_dict",
+    ]
+
+    data = list(
+        zip(
+            model_column,
+            frac_positives_column,
+            mean_pred_value_column,
+            hist_column,
+            edge_column,
+        )
+    )
+
+    return wandb.Table(columns=columns, data=data)

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/calculate/class_proportions.py

@@ -0,0 +1,66 @@
+from warnings import simplefilter
+
+import numpy as np
+from sklearn.utils.multiclass import unique_labels
+
+import wandb
+from wandb.integration.sklearn import utils
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def class_proportions(y_train, y_test, labels):
+    # Get the unique values from the dataset
+    targets = (y_train,) if y_test is None else (y_train, y_test)
+    class_ids = np.array(unique_labels(*targets))
+
+    # Compute the class counts
+    counts_train = np.array([(y_train == c).sum() for c in class_ids])
+    counts_test = np.array([(y_test == c).sum() for c in class_ids])
+
+    class_column, dataset_column, count_column = make_columns(
+        class_ids, counts_train, counts_test
+    )
+
+    if labels is not None and isinstance(class_column[0], (int, np.integer)):
+        class_column = get_named_labels(labels, class_column)
+
+    table = make_table(class_column, dataset_column, count_column)
+    chart = wandb.visualize("wandb/class_proportions/v1", table)
+
+    return chart
+
+
+def make_table(class_column, dataset_column, count_column):
+    columns = ["class", "dataset", "count"]
+    data = list(zip(class_column, dataset_column, count_column))
+
+    return wandb.Table(data=data, columns=columns)
+
+
+def make_columns(class_ids, counts_train, counts_test):
+    class_column, dataset_column, count_column = [], [], []
+
+    for i in range(len(class_ids)):
+        # add class counts from training set
+        class_column.append(class_ids[i])
+        dataset_column.append("train")
+        count_column.append(counts_train[i])
+        # add class counts from test set
+        class_column.append(class_ids[i])
+        dataset_column.append("test")
+        count_column.append(counts_test[i])
+
+        if utils.check_against_limit(
+            i,
+            "class_proportions",
+            utils.chart_limit,
+        ):
+            break
+
+    return class_column, dataset_column, count_column
+
+
+def get_named_labels(labels, numeric_labels):
+    return np.array([labels[num_label] for num_label in numeric_labels])

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/calculate/confusion_matrix.py

@@ -0,0 +1,93 @@
+import itertools
+from warnings import simplefilter
+
+import numpy as np
+from sklearn import metrics
+from sklearn.utils.multiclass import unique_labels
+
+import wandb
+
+from .. import utils
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def validate_labels(*args, **kwargs):  # FIXME
+    raise AssertionError()
+
+
+def confusion_matrix(
+    y_true=None,
+    y_pred=None,
+    labels=None,
+    true_labels=None,
+    pred_labels=None,
+    normalize=False,
+):
+    """Compute the confusion matrix to evaluate the performance of a classification.
+
+    Called by plot_confusion_matrix to visualize roc curves. Please use the function
+    plot_confusion_matrix() if you wish to visualize your confusion matrix.
+    """
+    cm = metrics.confusion_matrix(y_true, y_pred)
+
+    if labels is None:
+        classes = unique_labels(y_true, y_pred)
+    else:
+        classes = np.asarray(labels)
+
+    if normalize:
+        cm = cm.astype("float") / cm.sum(axis=1)[:, np.newaxis]
+        cm = np.around(cm, decimals=2)
+        cm[np.isnan(cm)] = 0.0
+
+    if true_labels is None:
+        true_classes = classes
+    else:
+        validate_labels(classes, true_labels, "true_labels")
+
+        true_label_indexes = np.in1d(classes, true_labels)
+
+        true_classes = classes[true_label_indexes]
+        cm = cm[true_label_indexes]
+
+    if pred_labels is None:
+        pred_classes = classes
+    else:
+        validate_labels(classes, pred_labels, "pred_labels")
+
+        pred_label_indexes = np.in1d(classes, pred_labels)
+
+        pred_classes = classes[pred_label_indexes]
+        cm = cm[:, pred_label_indexes]
+
+    table = make_table(cm, pred_classes, true_classes, labels)
+    chart = wandb.visualize("wandb/confusion_matrix/v1", table)
+
+    return chart
+
+
+def make_table(cm, pred_classes, true_classes, labels):
+    data, count = [], 0
+    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
+        if labels is not None and (
+            isinstance(pred_classes[i], int) or isinstance(pred_classes[0], np.integer)
+        ):
+            pred = labels[pred_classes[i]]
+            true = labels[true_classes[j]]
+        else:
+            pred = pred_classes[i]
+            true = true_classes[j]
+        data.append([pred, true, cm[i, j]])
+        count += 1
+        if utils.check_against_limit(
+            count,
+            "confusion_matrix",
+            utils.chart_limit,
+        ):
+            break
+
+    table = wandb.Table(columns=["Predicted", "Actual", "Count"], data=data)
+
+    return table

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/calculate/decision_boundaries.py

@@ -0,0 +1,40 @@
+from warnings import simplefilter
+
+import wandb
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def decision_boundaries(
+    decision_boundary_x,
+    decision_boundary_y,
+    decision_boundary_color,
+    train_x,
+    train_y,
+    train_color,
+    test_x,
+    test_y,
+    test_color,
+):
+    x_dict, y_dict, color_dict = [], [], []
+    for i in range(min(len(decision_boundary_x), 100)):
+        x_dict.append(decision_boundary_x[i])
+        y_dict.append(decision_boundary_y[i])
+        color_dict.append(decision_boundary_color)
+    for i in range(300):
+        x_dict.append(test_x[i])
+        y_dict.append(test_y[i])
+        color_dict.append(test_color[i])
+    for i in range(min(len(train_x), 600)):
+        x_dict.append(train_x[i])
+        y_dict.append(train_y[i])
+        color_dict.append(train_color[i])
+
+    return wandb.visualize(
+        "wandb/decision_boundaries/v1",
+        wandb.Table(
+            columns=["x", "y", "color"],
+            data=[[x_dict[i], y_dict[i], color_dict[i]] for i in range(len(x_dict))],
+        ),
+    )

miniconda3/envs/ladir/lib/python3.10/site-packages/wandb/integration/sklearn/calculate/elbow_curve.py

@@ -0,0 +1,55 @@
+import time
+from warnings import simplefilter
+
+import numpy as np
+from joblib import Parallel, delayed
+from sklearn.base import clone
+
+import wandb
+
+# ignore all future warnings
+simplefilter(action="ignore", category=FutureWarning)
+
+
+def elbow_curve(clusterer, X, cluster_ranges, n_jobs, show_cluster_time):  # noqa: N803
+    if cluster_ranges is None:
+        cluster_ranges = range(1, 10, 2)
+    else:
+        cluster_ranges = sorted(cluster_ranges)
+
+    clfs, times = _compute_results_parallel(n_jobs, clusterer, X, cluster_ranges)
+
+    clfs = np.absolute(clfs)
+
+    table = make_table(cluster_ranges, clfs, times)
+    chart = wandb.visualize("wandb/elbow/v1", table)
+
+    return chart
+
+
+def make_table(cluster_ranges, clfs, times):
+    columns = ["cluster_ranges", "errors", "clustering_time"]
+
+    data = list(zip(cluster_ranges, clfs, times))
+
+    table = wandb.Table(columns=columns, data=data)
+
+    return table
+
+
+def _compute_results_parallel(n_jobs, clusterer, x, cluster_ranges):
+    parallel_runner = Parallel(n_jobs=n_jobs)
+    _cluster_scorer = delayed(_clone_and_score_clusterer)
+    results = parallel_runner(_cluster_scorer(clusterer, x, i) for i in cluster_ranges)
+
+    clfs, times = zip(*results)
+
+    return clfs, times
+
+
+def _clone_and_score_clusterer(clusterer, x, n_clusters):
+    start = time.time()
+    clusterer = clone(clusterer)
+    clusterer.n_clusters = n_clusters
+
+    return clusterer.fit(x).score(x), time.time() - start