Api - Weights & Biases Documentation

Classe wandb.Api

Utilisé pour envoyer des requêtes au serveur W&B.

overrides: 'dict[str, Any] | None' = None,
timeout: 'int | None' = None,
api_key: 'str | None' = None

Arguments

dict[str, Any] | None

Vous pouvez définir base_url si vous utilisez un serveur W&B autre que https://api.wandb.ai. Vous pouvez également définir des valeurs par défaut pour entity, project et run.

int | None

Délai d’expiration HTTP en secondes pour les requêtes API. S’il n’est pas spécifié, le délai d’expiration par défaut sera utilisé.

str | None

Clé API à utiliser pour l’authentification. Si elle n’est pas fournie, la clé API de l’Environnement actuel ou de la configuration sera utilisée. Demande une clé API si aucune n’est fournie ou configurée dans l’Environnement.

Exemples

import wandb

wandb.Api()

Propriétés

str | None

Renvoie l’entité W&B par défaut.

str

Renvoie l’agent utilisateur public de W&B.

User

Renvoie l’objet Viewer.

Méthodes

méthode Api.artifact()

(self,
name: 'str',
type: 'str | None' = None)

Renvoie un artifact unique.

Arguments

str

Le nom de l’artifact. Le nom d’un artifact ressemble à un chemin de fichier qui contient, au minimum, le nom du projet dans lequel l’artifact a été enregistré, le nom de l’artifact, ainsi que la version ou l’alias de l’artifact. Vous pouvez éventuellement ajouter en préfixe l’entité qui a enregistré l’artifact, suivie d’une barre oblique. Si aucune entité n’est spécifiée dans le nom, l’entité du run ou du paramètre de l’API est utilisée.

str | None

Le type d’artifact à récupérer.

Exceptions levées

ValueError: Si le nom de l’artifact n’est pas spécifié.
ValueError: Si le type d’artifact est spécifié, mais ne correspond pas au type de l’artifact récupéré.

Exemples

Dans les extraits de code suivants, « entity », « project », « artifact », « version » et « alias » sont des espaces réservés pour votre entité W&B, le nom du projet dans lequel se trouve l’artifact, le nom de l’artifact et la version de l’artifact, respectivement.

import wandb

# Spécifier le projet, le nom de l'artifact et l'alias de l'artifact
wandb.Api().artifact(name="project/artifact:alias")

# Spécifier le projet, le nom de l'artifact et une version spécifique de l'artifact
wandb.Api().artifact(name="project/artifact:version")

# Spécifier l'entité, le projet, le nom de l'artifact et l'alias de l'artifact
wandb.Api().artifact(name="entity/project/artifact:alias")

# Spécifier l'entité, le projet, le nom de l'artifact et une version spécifique de l'artifact
wandb.Api().artifact(name="entity/project/artifact:version")

méthode Api.artifact_collection()

self,
type_name: 'str',
name: 'str'

Renvoie une collection d’artifacts pour un type donné. Vous pouvez utiliser l’objet ArtifactCollection renvoyé pour récupérer des informations sur des artifacts spécifiques dans cette collection, entre autres.

Arguments

str

Le type de collection d’artifacts à récupérer.

str

Nom d’une collection d’artifacts. Vous pouvez éventuellement ajouter comme préfixe l’entité qui a enregistré l’artifact, suivie d’une barre oblique.

Exemples

Dans l’extrait de code ci-après, “type”, “entity”, “project” et “artifact_name” sont des valeurs fictives représentant respectivement le type de collection, votre entité W&B, le nom du projet dans lequel se trouve l’artifact et le nom de l’artifact.

import wandb

collections = wandb.Api().artifact_collection(
    type_name="type", name="entity/project/artifact_name"
)

# Obtenir le premier artifact de la collection
artifact_example = collections.artifacts()[0]

# Télécharger le contenu de l'artifact dans le répertoire racine spécifié.
artifact_example.download()

méthode Api.artifact_collection_exists()

self,
name: 'str',
type: 'str'

Indique si une collection d’artifacts existe dans un projet et une entité spécifiés.

Arguments

str

Nom d’une collection d’artifacts. Vous pouvez éventuellement ajouter comme préfixe l’entité qui a enregistré l’artifact, suivie d’une barre oblique. Si l’entité ou le projet n’est pas spécifié, déduisez la collection à partir des paramètres de substitution, s’ils existent. Sinon, l’entité est récupérée depuis les Paramètres utilisateur et le projet prendra par défaut la valeur “uncategorized”.

str

Le type de la collection d’artifacts.

Exemples :

Dans l’extrait de code ci-après, “type” et “collection_name” désignent respectivement le type de la collection d’artifacts et le nom de la collection.

import wandb

wandb.Api.artifact_collection_exists(type="type", name="collection_name")

méthode Api.artifact_collections()

self,
project_name: 'str',
type_name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None

Renvoie une collection de collections d’artifacts correspondantes.

Arguments

str

Le nom du projet à filtrer.

str

Le nom du type d’artifact à filtrer.

str | None

Chaîne facultative permettant de spécifier l’ordre des résultats. Avec le préfixe ’+’, les résultats sont triés par ordre croissant (par défaut). Avec le préfixe ’-’, ils sont triés par ordre décroissant.

int

Définit le nombre d’éléments par page pour la pagination des requêtes. Il est généralement inutile de modifier cette valeur.

str | None

Curseur de pagination permettant de reprendre une requête précédente, capturé depuis l’attribut .cursor d’un paginateur précédent.

méthode Api.artifact_exists()

self,
name: 'str',
type: 'str | None' = None

Indique si une version d’artifact existe dans le projet et l’entité spécifiés.

Arguments

str

Le nom de l’artifact. Ajoutez l’entité et le projet de l’artifact en préfixe. Ajoutez la version ou l’alias de l’artifact après un deux-points. Si l’entité ou le projet n’est pas spécifié, W&B utilise les paramètres d’override s’ils sont renseignés. Sinon, l’entité est récupérée à partir des paramètres utilisateur et le projet est défini sur “Uncategorized”.

str | None

Le type d’artifact.

Exemples

Dans les extraits de code qui suivent, “entity”, “project”, “artifact”, “version” et “alias” sont des espaces réservés pour votre entité W&B, le nom du projet dans lequel se trouve l’artifact, le nom de l’artifact et la version de l’artifact, respectivement.

import wandb

wandb.Api().artifact_exists("entity/project/artifact:version")
wandb.Api().artifact_exists("entity/project/artifact:alias")

méthode Api.artifact_type()

self,
type_name: 'str',
project: 'str | None' = None

Renvoie l’ArtifactType correspondant.

Arguments

str

Le nom du type d’artifact à récupérer.

str | None

Si fourni, le nom d’un projet ou un chemin à utiliser comme filtre.

méthode Api.artifact_types()

self,
project: 'str | None' = None,
start: 'str | None' = None

Renvoie une collection de types d’artifact correspondants.

Arguments

str | None

Le nom du projet ou le chemin à utiliser pour le filtrage.

str | None

Curseur de pagination pour reprendre une requête précédente, capturé depuis l’attribut .cursor d’un paginateur précédent.

méthode Api.artifact_versions()

(self, type_name, name, per_page=50)

Obsolète. Utilisez la méthode Api.artifacts(type_name, name) à la place.

Arguments

_empty

Aucune description fournie.

_empty

Aucune description fournie.

_empty

Aucune description fournie.

méthode Api.artifacts()

self,
type_name: 'str',
name: 'str',
order: 'str | None' = None,
per_page: 'int' = 50,
tags: 'list[str] | None' = None,
start: 'str | None' = None

Renvoie une collection Artifacts.

Arguments

str

Le type d’artifacts à récupérer.

str

Le nom de la collection de l’artifact. Vous pouvez éventuellement ajouter en préfixe l’entité ayant enregistré l’artifact, suivie d’une barre oblique.

str | None

Chaîne facultative permettant de spécifier l’ordre des résultats. Préfixée par « + », elle trie par ordre croissant (par défaut). Préfixée par « - », elle trie par ordre décroissant.

int

Définit la taille de page pour la pagination des requêtes. Il n’est généralement pas nécessaire de modifier cette valeur.

list[str] | None

Renvoyer uniquement les artifacts comportant tous ces tags.

str | None

Curseur de pagination permettant de reprendre une requête antérieure, récupéré depuis l’attribut .cursor d’un paginateur précédent.

Exemples

Dans l’extrait de code ci-après, “type”, “entity”, “project” et “artifact_name” sont des paramètres fictifs représentant respectivement le type d’artifact, l’entité W&B, le nom du projet dans lequel l’artifact a été enregistré et le nom de l’artifact.

import wandb

wandb.Api().artifacts(type_name="type", name="entity/project/artifact_name")

Mettez l’itération en pause et reprenez-la plus tard à partir de la même position en enregistrant le .cursor du paginateur et en le passant à start= :

from itertools import islice

import wandb

api = wandb.Api()

# Consommer la première page de résultats, puis sauvegarder le curseur.
page_size = 10
artifacts = api.artifacts(
    type_name="type",
    name="entity/project/artifact_name",
    per_page=page_size,
)
first_page = list(islice(artifacts, page_size))

saved_cursor = artifacts.cursor

# Plus tard (par exemple dans un nouveau processus), reprendre l'itération à partir du curseur sauvegardé.
remaining_artifacts = api.artifacts(
    type_name="type",
    name="entity/project/artifact_name",
    per_page=page_size,
    start=saved_cursor,
)

méthode Api.automation()

self,
name: 'str', *,
entity: 'str | None' = None

Renvoie la seule automatisation correspondant aux paramètres.

Arguments

str

Nom de l’automatisation à récupérer.

str | None

Entité pour laquelle récupérer l’automatisation.

Exceptions levées

ValueError: Si aucune ou plusieurs automatisations correspondent aux critères de recherche.

Exemples

Récupérer une automatisation existante nommée “my-automation” :

import wandb

api = wandb.Api()
automation = api.automation(name="my-automation")

Obtenez l’automatisation existante nommée “other-automation” dans l’entité “my-team”:

automation = api.automation(name="other-automation", entity="my-team")

méthode Api.automations()

self,
entity: 'str | None' = None, *,
name: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None

Renvoie un itérateur sur toutes les automatisations correspondant aux paramètres donnés. Si aucun paramètre n’est fourni, l’itérateur renvoyé contiendra toutes les automatisations auxquelles l’utilisateur a accès.

Arguments

str | None

L’entité dont récupérer les automatisations.

str | None

Le nom de l’automatisation à récupérer.

int

Le nombre d’automatisations à récupérer par page. La valeur par défaut est 50. Il n’est généralement pas nécessaire de modifier cette valeur.

str | None

Curseur de pagination permettant de reprendre une requête précédente, obtenu à partir de l’attribut .cursor d’un paginateur précédent.

Exemples

Récupérez toutes les automatisations existantes pour l’entité “my-team” :

import wandb

api = wandb.Api()
automations = api.automations(entity="my-team")

méthode Api.create_automation()

self,
obj: 'NewAutomation', *,
fetch_existing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'

Créer une nouvelle automatisation.

Arguments

NewAutomation

L’automatisation à créer.

bool

Si True et qu’une automatisation en conflit existe déjà, tentez de récupérer l’automatisation existante au lieu de lever une erreur.

Unpack[WriteAutomationsKwargs]

Aucune description fournie.

Exemples

Créer une nouvelle automatisation nommée “my-automation” qui envoie une notification Slack lorsqu’un run d’un projet spécifique journalise une métrique dépassant un seuil personnalisé :

import wandb
from wandb.automations import OnRunMetric, RunEvent, SendNotification

api = wandb.Api()

project = api.project("my-project", entity="my-team")

# Utiliser la première intégration Slack pour l'équipe
slack_hook = next(api.slack_integrations(entity="my-team"))

event = OnRunMetric(
    scope=project,
    filter=RunEvent.metric("custom-metric") > 10,
)
action = SendNotification.from_integration(slack_hook)

automation = api.create_automation(
    event >> action,
    name="my-automation",
    description="Send a Slack message whenever 'custom-metric' exceeds 10.",
)

méthode Api.create_custom_chart()

self,
entity: 'str',
name: 'str',
display_name: 'str',
spec_type: "Literal['vega2']",
access: "Literal['private', 'public']",
spec: 'str | dict'

Créez un préréglage de graphique personnalisé et renvoyez son ID.

Arguments

str

L’entité (utilisateur ou équipe) propriétaire du graphique

str

Identifiant unique du préréglage de graphique

str

Nom lisible affiché dans l’interface utilisateur

Literal['vega2']

Type de spécification. Doit être « vega2 » pour les spécifications Vega-Lite v2.

Literal['private', 'public']

Niveau d’accès au graphique :

“private” : le graphique est accessible uniquement à l’entité qui l’a créé
“public” : le graphique est accessible publiquement

str | dict

Spécification Vega/Vega-Lite sous forme de dictionnaire ou de chaîne JSON

Exceptions levées

wandb.Error: Si la création du graphique échoue
UnsupportedError: Si le serveur ne prend pas en charge les graphiques personnalisés

Exemples

    import wandb

    api = wandb.Api()

    # Définir une spécification simple de graphique à barres
    vega_spec = {
        "$schema": "https://vega.github.io/schema/vega-lite/v6.json",
        "mark": "bar",
        "data": {"name": "wandb"},
        "encoding": {
            "x": {"field": "${field:x}", "type": "ordinal"},
            "y": {"field": "${field:y}", "type": "quantitative"},
        },
    }

    # Créer le graphique personnalisé
    chart_id = api.create_custom_chart(
        entity="my-team",
        name="my-bar-chart",
        display_name="My Custom Bar Chart",
        spec_type="vega2",
        access="private",
        spec=vega_spec,
    )

    # Utiliser avec wandb.plot_table()
    chart = wandb.plot_table(
        vega_spec_name=chart_id,
        data_table=my_table,
        fields={"x": "category", "y": "value"},
    )

méthode Api.create_project()

self,
name: 'str',
entity: 'str'

Créer un nouveau projet.

Arguments

str

Le nom du nouveau projet.

str

L’entité du nouveau projet.

méthode Api.create_registry()

self,
name: 'str',
visibility: "Literal['organization', 'restricted']",
organization: 'str | None' = None,
description: 'str | None' = None,
artifact_types: 'list[str] | None' = None

Créer un nouveau registre.

Arguments

str

Le nom du registre. Le nom doit être unique au sein de l’organisation.

Literal['organization', 'restricted']

La visibilité du registre. organization: Toute personne appartenant à l’organisation peut consulter ce registre. Vous pourrez modifier les rôles ultérieurement depuis les paramètres de l’interface utilisateur. restricted: Seuls les membres invités via l’interface utilisateur peuvent accéder à ce registre. Le partage public est désactivé.

str | None

L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, l’organisation sera récupérée depuis l’entité si celle-ci n’appartient qu’à une seule organisation.

str | None

La description du registre.

list[str] | None

Les types d’artifact acceptés par le registre. Un type ne doit pas dépasser 128 caractères ni inclure les caractères / ou :. Si ce paramètre n’est pas spécifié, tous les types sont acceptés. Les types autorisés ajoutés au registre ne peuvent pas être supprimés par la suite.

Exemples

import wandb

api = wandb.Api()
registry = api.create_registry(
    name="my-registry",
    visibility="restricted",
    organization="my-org",
    description="This is a test registry",
    artifact_types=["model"],
)

méthode Api.create_run()

self, *,
run_id: 'str | None' = None,
project: 'str | None' = None,
entity: 'str | None' = None

Créer un nouveau run.

Arguments

str | None

L’ID à attribuer au run. S’il n’est pas spécifié, W&B génère un ID aléatoire.

str | None

Le projet dans lequel enregistrer le run. Si aucun projet n’est spécifié, le run est enregistré dans un projet appelé “Uncategorized”.

str | None

L’entité propriétaire du projet. Si aucune entité n’est spécifiée, le run est enregistré dans l’entité par défaut.

méthode Api.create_run_queue()

self,
name: 'str',
type: 'public.RunQueueResourceType',
entity: 'str | None' = None,
prioritization_mode: 'public.RunQueuePrioritizationMode | None' = None,
config: 'dict | None' = None,
template_variables: 'dict | None' = None

Créer une nouvelle file d’attente de run dans W&B Launch.

Arguments

str

Nom de la file d’attente à créer

public.RunQueueResourceType

Type de ressource à utiliser pour la file d’attente. Valeurs possibles : “local-container”, “local-process”, “kubernetes”, “sagemaker” ou “gcp-vertex”.

str | None

Nom de l’entité dans laquelle créer la file d’attente. Si None, utilisez l’entité configurée ou l’entité par défaut.

public.RunQueuePrioritizationMode | None

Version de priorisation à utiliser : “V0” ou None.

dict | None

Configuration par défaut des ressources à utiliser pour la file d’attente. Utilisez Handlebars (par exemple, {{var}}) pour spécifier des variables de modèle.

dict | None

Dictionnaire de schémas de variables de modèle à utiliser avec la configuration.

méthode Api.create_team()

self,
team: 'str',
admin_username: 'str | None' = None

Créer une nouvelle équipe. Pour les utilisateurs de W&B Cloud mutualisé, définissez l’organisation API par défaut dans vos Paramètres utilisateur de l’interface utilisateur W&B avant d’appeler create_team(). Ce paramètre détermine l’organisation à laquelle la nouvelle équipe appartiendra.

Arguments

str

Le nom de l’équipe.

str | None

Le nom d’utilisateur de l’administrateur de l’équipe. Par défaut, il s’agit de l’utilisateur actuel.

méthode Api.create_user()

self,
email: 'str',
admin: 'bool | None' = False

Créer un nouvel utilisateur.

Arguments

str

L’adresse e-mail de l’utilisateur.

bool | None

Définit l’utilisateur comme administrateur global de l’instance.

méthode Api.delete_automation()

self,
obj: 'Automation | str'

Supprime une automatisation.

Arguments

Automation | str

L’automatisation à supprimer, ou son ID.

méthode Api.flush()

(self)

Videz le cache local. L’objet api conserve un cache local des runs. Si l’état du run est susceptible de changer pendant l’exécution de votre script, vous devez donc effacer le cache local avec api.flush() pour obtenir les dernières valeurs associées au run.

méthode Api.from_path()

(self,
path: 'str')

Renvoyer un run, un balayage, un projet ou un rapport à partir d’un chemin.

Arguments

str

Le chemin vers le projet, le run, le balayage ou le rapport

Exemples

Dans les extraits de code qui suivent, “project”, “team”, “run_id”, “sweep_id”, et “report_name” sont des espaces réservés désignant respectivement le projet, la équipe, le run ID, le sweep ID et le nom d’un rapport spécifique.

import wandb

api = wandb.Api()

project = api.from_path("project")
team_project = api.from_path("team/project")
run = api.from_path("team/project/runs/run_id")
sweep = api.from_path("team/project/sweeps/sweep_id")
report = api.from_path("team/project/reports/report_name")

méthode Api.integrations()

self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None

Renvoyer un itérateur sur toutes les intégrations d’une entité.

Arguments

str | None

L’entité (par ex. le nom d’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas fournie, l’entité par défaut de l’utilisateur sera utilisée.

int

Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de la modifier.

str | None

Aucune description fournie.

méthode Api.job()

self,
name: 'str | None',
path: 'str | None' = None

Renvoyer un objet Job.

Arguments

str | None

Le nom du job.

str | None

Le chemin racine à partir duquel télécharger l’artifact du job.

méthode Api.list_jobs()

self,
entity: 'str',
project: 'str'

Renvoyer une liste de jobs, s’il y en a, pour l’entité et le projet indiqués.

Arguments

str

L’entité associée aux jobs listés.

str

Le projet associé aux jobs listés.

méthode Api.organization()

self,
name: 'str | None' = None

Renvoyer l’Organisation correspondante.

Arguments

str | None

Nom de l’organisation. Si ce paramètre est omis, cette méthode tente de déterminer et de renvoyer l’organisation par défaut courante.

méthode Api.project()

self,
name: 'str',
entity: 'str | None' = None

Renvoyer le projet portant le nom indiqué (et l’entité, si elle est renseignée).

Arguments

str

Le nom du projet.

str | None

Nom de l’entité demandée. Si None, utilise l’entité par défaut transmise à Api. S’il n’y a pas d’entité par défaut, lève une ValueError.

méthode Api.projects()

self,
entity: 'str | None' = None,
per_page: 'int' = 200

Récupère les projets pour une entité donnée.

Arguments

str | None

Nom de l’entité demandée. Si None, utilise l’entité par défaut transmise à Api. S’il n’y a pas d’entité par défaut, lève une ValueError.

int

Définit la taille de page pour la pagination des requêtes. En général, il n’est pas nécessaire de la modifier.

méthode Api.queued_run()

(self,
entity: 'str',
project: 'str',
queue_name: 'str',
run_queue_item_id: 'str', project_queue=None, priority=None)

Renvoyer un seul run en file d’attente à partir du chemin. Analyse les chemins au format entity/project/queue_id/run_queue_item_id.

Arguments

str

Aucune description fournie.

str

Aucune description fournie.

str

Aucune description fournie.

str

Aucune description fournie.

_empty

Aucune description fournie.

_empty

Aucune description fournie.

méthode Api.registries()

self,
organization: 'str | None' = None,
filter: 'dict[str, Any] | None' = None,
order: 'str | None' = None,
per_page: 'int' = 100,
start: 'str | None' = None

Renvoie un itérateur différé d’objets Registry. Utilisez cet itérateur pour rechercher et filtrer des registres, des collections, ou des versions d’artifact dans le registre de votre organisation. Les résultats sont récupérés de manière différée au fil de l’itération, vous pouvez donc vous arrêter après n’importe quel nombre d’ éléments — par exemple, avec :func:itertools.islice — sans demander le reste.

Arguments

str | None

Organisation du registre à récupérer. Si elle n’est pas spécifiée, utilisez l’organisation indiquée dans les paramètres de l’utilisateur.

dict[str, Any] | None

Filtre de type MongoDB à appliquer à chaque objet de l’itérateur différé du registre. Les champs disponibles pour filtrer les registres sont name, description, created_at, updated_at. Les champs disponibles pour filtrer les collections sont name, tag, description, created_at, updated_at Les champs disponibles pour filtrer les versions sont tag, alias, created_at, updated_at, metadata

str | None

Chaîne facultative permettant de spécifier l’ordre des résultats. Si elle est préfixée par ’+’, le tri est croissant (par défaut). Si elle est préfixée par ’-’, le tri est décroissant.

int

Définit la taille de page pour la pagination des requêtes.

str | None

Curseur de pagination pour reprendre une requête précédente, capturé à partir de l’attribut .cursor d’un paginateur précédent.

Exemples

Trouver tous les registres dont le nom contient “model”

import wandb

api = wandb.Api()  # spécifiez une organisation si votre entité appartient à plusieurs organisations
api.registries(filter={"name": {"$regex": "model"}})

Recherchez toutes les collections dans les registres portant le nom “my_collection” et le tag “my_tag”

api.registries().collections(filter={"name": "my_collection", "tag": "my_tag"})

Rechercher toutes les versions d’artifact dans les registres dont le nom de collection contient “my_collection” et dont une version porte l’alias “best”

api.registries().collections(
    filter={"name": {"$regex": "my_collection"}}
).versions(filter={"alias": "best"})

Trouvez toutes les versions d’artifact dans les registres qui contiennent “model” et qui portent le tag “prod” ou l’alias “best”

api.registries(filter={"name": {"$regex": "model"}}).versions(
    filter={"$or": [{"tag": "prod"}, {"alias": "best"}]}
)

Mettez l’itération en pause et reprenez-la plus tard à la même position en enregistrant le .cursor du paginateur et en le passant à start= :

from itertools import islice

import wandb

api = wandb.Api()

# Consommer la première page de résultats, puis sauvegarder le curseur.
page_size = 10
registries = api.registries(per_page=page_size)
first_page = list(islice(registries, page_size))

saved_cursor = registries.cursor

# Plus tard (par exemple dans un nouveau processus), reprendre l'itération à partir du curseur sauvegardé.
remaining_registries = api.registries(per_page=page_size, start=saved_cursor)

méthode Api.registry()

self,
name: 'str',
organization: 'str | None' = None

Renvoyer un registre à partir de son nom.

Arguments

str

Le nom du registre. Il ne contient pas le préfixe wandb-registry-.

str | None

Exemples

Récupérer et mettre à jour un registre

import wandb

api = wandb.Api()
registry = api.registry(name="my-registry", organization="my-org")
registry.description = "This is an updated description"
registry.save()

méthode Api.reports()

self,
path: 'str' = '',
name: 'str | None' = None,
per_page: 'int' = 50

Obtenir les rapports pour un chemin de projet donné. Remarque : l’API wandb.Api.reports() est en version bêta et changera probablement dans de prochaines versions.

Arguments

str

Chemin vers le projet dans lequel se trouve le rapport. Indiquez en préfixe l’entité qui a créé le projet, suivie d’une barre oblique.

str | None

Nom du rapport demandé.

int

Définit la taille de page pour la pagination des requêtes. Il n’y a généralement aucune raison de modifier cette valeur.

Exemples

import wandb

wandb.Api.reports("entity/project")

méthode Api.run()

self,
path: 'str' = ''

Renvoyer un run unique en interprétant le chemin au format entity/project/run_id.

Arguments

str

Chemin du run au format entity/project/run_id. Si api.entity est défini, il peut être au format project/run_id, et si api.project est défini, il peut simplement s’agir du run_id.

Exceptions levées

RunNotFoundError : Si une run est introuvable ou si ses données ne peuvent pas être chargées.

méthode Api.run_queue()

(self,
entity: 'str',
name: 'str')

Renvoyer la RunQueue nommée associée à l’entité. Voir Api.create_run_queue pour plus d’informations sur la façon de créer une file d’attente de run.

Arguments

str

Aucune description fournie.

str

Aucune description fournie.

méthode Api.runs()

(self,
path: 'str | None' = None,
filters: 'dict[str, Any] | None' = None,
order: 'str' = '+created_at',
per_page: 'int' = 50,
include_sweeps: 'bool' = False,
lazy: 'bool' = True)

Renvoie un objet Runs, qui itère de façon différée sur les objets Run. Les champs sur lesquels vous pouvez filtrer incluent :

createdAt : l’horodatage de création du run. (au format ISO 8601, par ex. “2023-01-01T12:00:00Z”)
displayName : le nom d’affichage lisible du run. (par ex. “eager-fox-1”)
duration : la durée totale d’exécution du run en secondes.
group : le nom du groupe utilisé pour organiser des runs associés.
host : le nom d’hôte sur lequel le run a été exécuté.
jobType : le type de job ou le rôle du run.
name : l’identifiant unique du run. (par ex. “a1b2cdef”)
state : l’état actuel du run.
tags : les tags associés au run.
username : le nom d’utilisateur de l’utilisateur ayant lancé le run

En outre, vous pouvez filtrer sur des éléments de la configuration du run ou des métriques de résumé, par exemple config.experiment_name, summary_metrics.loss, etc. Pour des filtres plus complexes, vous pouvez utiliser les opérateurs de requête MongoDB. Pour plus de détails, voir : https://docs.mongodb.com/manual/reference/operator/query Les opérations suivantes sont prises en charge :

$and
$or
$nor
$eq
$ne
$gt
$gte
$lt
$lte
$in
$nin
$exists
$regex

Arguments

str | None

(str) chemin vers le projet, doit être de la forme : “entity/project”

dict[str, Any] | None

(dict) requêtes pour des runs spécifiques à l’aide du langage de requête MongoDB. Vous pouvez filtrer sur des propriétés du run telles que config.key, summary_metrics.key, state, entity, createdAt, etc. Par exemple : {"config.experiment_name": "foo"} trouverait les runs dont l’entrée de configuration pour le nom de l’expérience est définie sur “foo”

str

(str) L’ordre peut être created_at, heartbeat_at, config.*.value ou summary_metrics.*. Si vous faites précéder l’ordre d’un +, le tri est croissant (par défaut). Si vous faites précéder l’ordre d’un -, le tri est décroissant. L’ordre par défaut est run.created_at, du plus ancien au plus récent.

int

(int) Définit la taille de page pour la pagination des requêtes.

bool

(bool) Indique s’il faut récupérer de manière anticipée l’objet balayage dans chaque résultat de run.

bool

(bool) Indique s’il faut utiliser le chargement différé pour de meilleures performances. Quand True (par défaut), seules les métadonnées essentielles du run sont chargées initialement. Les champs volumineux comme config, summaryMetrics et systemMetrics sont chargés à la demande lors de l’accès. Définissez cette option sur False pour charger toutes les données d’emblée.

Exemples

import wandb
from wandb.apis.public import Api

# Trouver les runs dans le projet où config.experiment_name a été défini sur "foo"
Api.runs(path="my_entity/project", filters={"config.experiment_name": "foo"})

# Trouver les runs dans le projet où config.experiment_name a été défini sur "foo" ou "bar"
Api.runs(
    path="my_entity/project",
    filters={
        "$or": [
            {"config.experiment_name": "foo"},
            {"config.experiment_name": "bar"},
        ]
    },
)

# Trouver les runs dans le projet où config.experiment_name correspond à une expression régulière
Api.runs(
    path="my_entity/project",
    filters={"config.experiment_name": {"$regex": "b.*"}},
)

Remarque : Les expressions régulières utilisent la synthttps://github.com/google/re2/wiki/Syntaxaxe RE2 de Google

# Trouver les runs dans le projet dont le nom correspond à une expression régulière
Api.runs(
    path="my_entity/project", filters={"display_name": {"$regex": "^foo.*"}}
)

# Trouver les runs du projet triés par perte croissante
Api.runs(path="my_entity/project", order="+summary_metrics.loss")

méthode Api.slack_integrations()

self, *,
entity: 'str | None' = None,
per_page: 'int' = 50,
start: 'str | None' = None

Renvoie un itérateur d’intégrations Slack pour une entité.

Arguments

str | None

L’entité (par ex. le nom d’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas fournie, l’entité par défaut de l’utilisateur sera utilisée.

int

Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de la modifier.

str | None

Aucune description fournie.

Exemples

Obtenez toutes les intégrations Slack enregistrées pour l’équipe “my-team” :

import wandb

api = wandb.Api()
slack_integrations = api.slack_integrations(entity="my-team")

Trouvez uniquement les intégrations Slack qui publient dans des canaux dont le nom commence par “team-alerts-” :

slack_integrations = api.slack_integrations(entity="my-team")
team_alert_integrations = [
    ig
    for ig in slack_integrations
    if ig.channel_name.startswith("team-alerts-")
]

méthode Api.sweep()

(self, path='')

Renvoyer un balayage en analysant un chemin au format entity/project/sweep_id.

Arguments

_empty

Chemin vers le balayage au format entity/project/sweep_id. Si api.entity est défini, ce chemin peut être au format project/sweep_id et, si api.project est défini, il peut simplement s’agir de sweep_id.

méthode Api.sync_tensorboard()

(self, root_dir, run_id=None, project=None, entity=None)

Synchroniser un répertoire local contenant des fichiers tfevent avec wandb.

Arguments

_empty

Aucune description n’est fournie.

_empty

Aucune description n’est fournie.

_empty

Aucune description n’est fournie.

_empty

Aucune description n’est fournie.

méthode Api.team()

self,
team: 'str'

Renvoyer le Team correspondant au nom fourni.

Arguments

str

Le nom de l’équipe.

méthode Api.update_automation()

self,
obj: 'Automation', *,
create_missing: 'bool' = False, **kwargs: 'Unpack[WriteAutomationsKwargs]'

Mettez à jour une automatisation existante.

Arguments

Automation

L’automatisation à mettre à jour. Il doit s’agir d’une automatisation existante.

bool

Si True et que l’automatisation n’existe pas, créez-la.

Unpack[WriteAutomationsKwargs]

Aucune description fournie.

Exemples

Désactivez et modifiez la description d’une automatisation existante (“my-automation”) :

import wandb

api = wandb.Api()

automation = api.automation(name="my-automation")
automation.enabled = False
automation.description = "Kept for reference, but no longer used."

updated_automation = api.update_automation(automation)

import wandb

api = wandb.Api()

automation = api.automation(name="my-automation")

updated_automation = api.update_automation(
    automation,
    enabled=False,
    description="Kept for reference, but no longer used.",
)

méthode Api.upsert_run_queue()

(self,
name: 'str',
resource_config: 'dict',
resource_type: 'public.RunQueueResourceType',
entity: 'str | None' = None,
template_variables: 'dict | None' = None,
external_links: 'dict | None' = None,
prioritization_mode: 'public.RunQueuePrioritizationMode | None' = None)

Crée ou met à jour une file d’attente de run dans W&B Launch.

Arguments

str

Nom de la file d’attente à créer

dict

Configuration de ressources par défaut facultative à utiliser pour la file d’attente. Utilisez Handlebars (par ex. {{var}}) pour spécifier des variables de modèle.

public.RunQueueResourceType

Type de ressource à utiliser pour la file d’attente. L’un des suivants : “local-container”, “local-process”, “kubernetes”, “sagemaker” ou “gcp-vertex”.

str | None

Nom facultatif de l’entité pour laquelle créer la file d’attente. Si None, utilisez l’entité configurée ou l’entité par défaut.

dict | None

Dictionnaire de schémas de variables de modèle à utiliser avec la configuration.

dict | None

Dictionnaire facultatif de liens externes à utiliser avec la file d’attente.

public.RunQueuePrioritizationMode | None

Version facultative de la priorisation à utiliser : “V0” ou None.

méthode Api.user()

self,
username_or_email: 'str'

Renvoyer un utilisateur à partir d’un nom d’utilisateur ou d’une adresse e-mail. Cette fonction ne fonctionne que pour les administrateurs locaux. Utilisez api.viewer pour récupérer votre propre objet utilisateur.

Arguments

str

Le nom d’utilisateur ou l’adresse e-mail de l’utilisateur.

méthode Api.users()

self,
username_or_email: 'str'

Renvoyer tous les utilisateurs à partir d’une requête partielle sur un nom d’utilisateur ou une adresse e-mail. Cette fonction fonctionne uniquement pour les administrateurs locaux. Utilisez api.viewer pour obtenir votre propre objet utilisateur.

Arguments

str

Le préfixe ou le suffixe de l’utilisateur que vous souhaitez trouver.

méthode Api.webhook_integrations()

self,
entity: 'str | None' = None, *,
per_page: 'int' = 50,
start: 'str | None' = None

Renvoie un itérateur d’intégrations webhook pour une entité.

Arguments

str | None

L’entité (par ex. le nom d’équipe) pour laquelle récupérer les intégrations. Si elle n’est pas fournie, l’entité par défaut de l’utilisateur sera utilisée.

int

Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’y a aucune raison de la modifier.

str | None

Aucune description fournie.

Exemples

Obtenez toutes les intégrations webhook enregistrées pour l’équipe “my-team” :

import wandb

api = wandb.Api()
webhook_integrations = api.webhook_integrations(entity="my-team")

Recherchez uniquement les intégrations webhook qui envoient des requêtes à “https://my-fake-url.com”:

webhook_integrations = api.webhook_integrations(entity="my-team")
my_webhooks = [
    ig
    for ig in webhook_integrations
    if ig.url_endpoint.startswith("https://my-fake-url.com")
]

​Classe wandb.Api

​Arguments

​Exemples

​Propriétés

​Méthodes

​méthode Api.artifact()

Arguments

Exceptions levées

Exemples

​méthode Api.artifact_collection()

Arguments

Exemples

​méthode Api.artifact_collection_exists()

Arguments

Exemples :

​méthode Api.artifact_collections()

Arguments

​méthode Api.artifact_exists()

Arguments

Exemples

​méthode Api.artifact_type()

Arguments

​méthode Api.artifact_types()

Arguments

​méthode Api.artifact_versions()

Arguments

​méthode Api.artifacts()

Arguments

Exemples

​méthode Api.automation()

Arguments

Exceptions levées

Exemples

​méthode Api.automations()

Arguments

Exemples

​méthode Api.create_automation()

Arguments

Exemples

​méthode Api.create_custom_chart()

Arguments

Exceptions levées

Exemples

​méthode Api.create_project()

Arguments

​méthode Api.create_registry()

Arguments

Exemples

​méthode Api.create_run()

Arguments

​méthode Api.create_run_queue()

Arguments

​méthode Api.create_team()

Arguments

​méthode Api.create_user()

Arguments

​méthode Api.delete_automation()

Arguments

​méthode Api.flush()

​méthode Api.from_path()

Arguments

Exemples

​méthode Api.integrations()

Arguments

​méthode Api.job()

Arguments

​méthode Api.list_jobs()

Arguments

​méthode Api.organization()

Arguments

​méthode Api.project()

Arguments

​méthode Api.projects()

Arguments

​méthode Api.queued_run()

Arguments

​méthode Api.registries()

Arguments

Exemples

​méthode Api.registry()

Classe wandb.Api

Arguments

Exemples

Propriétés

Méthodes

méthode Api.artifact()

méthode Api.artifact_collection()

méthode Api.artifact_collection_exists()

méthode Api.artifact_collections()

méthode Api.artifact_exists()

méthode Api.artifact_type()

méthode Api.artifact_types()

méthode Api.artifact_versions()

méthode Api.artifacts()

méthode Api.automation()

méthode Api.automations()

méthode Api.create_automation()

méthode Api.create_custom_chart()

méthode Api.create_project()

méthode Api.create_registry()

méthode Api.create_run()

méthode Api.create_run_queue()

méthode Api.create_team()

méthode Api.create_user()

méthode Api.delete_automation()

méthode Api.flush()

méthode Api.from_path()

méthode Api.integrations()

méthode Api.job()

méthode Api.list_jobs()

méthode Api.organization()

méthode Api.project()

méthode Api.projects()

méthode Api.queued_run()

méthode Api.registries()

méthode Api.registry()

méthode Api.reports()

méthode Api.run()

méthode Api.run_queue()

méthode Api.runs()

méthode Api.slack_integrations()

méthode Api.sweep()

méthode Api.sync_tensorboard()

méthode Api.team()

méthode Api.update_automation()

méthode Api.upsert_run_queue()

méthode Api.user()

méthode Api.users()

méthode Api.webhook_integrations()