Api - CoreWeave Docs

Classe wandb.Api

Permet d’interroger le 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 des requêtes API, en secondes. S’il n’est pas spécifié, le délai d’expiration par défaut est utilisé.

str | None

Clé API à utiliser pour l’authentification. Si aucune clé n’est fournie, la clé API définie dans l’environnement ou la configuration actuels est utilisée. Si aucune clé API n’est fournie ni configurée dans l’environnement, vous êtes invité à en saisir une.

Exemples

import wandb

wandb.Api()

Propriétés

str | None

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

str

Renvoie le user agent public de W&B.

User

Renvoie l’objet viewer.

Méthodes

méthode Api.artifact()

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

Renvoie un seul artifact.

str

Le nom de l’artifact. Le nom d’un artifact s’apparente à un chemin de fichier composé, au minimum, du nom du projet dans lequel l’artifact a été journalisé, du nom de l’artifact et de sa version ou de son alias. Vous pouvez également ajouter en préfixe l’entity qui a journalisé l’artifact, suivi d’une barre oblique. Si aucun entity n’est spécifié dans le nom, c’est l’entity défini dans les paramètres du run ou de l’API qui est utilisé.

str | None

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

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 à celui de l’artifact récupéré.

Dans les extraits de code suivants, “entity”, “project”, “artifact”, “version” et “alias” sont des espaces réservés qui désignent respectivement votre entity W&B, le nom du projet qui contient l’artifact, le nom de l’artifact et la version de l’artifact.

import wandb

# Indiquer le projet, le nom de l’artifact et son alias
wandb.Api().artifact(name="project/artifact:alias")

# Indiquer le projet, le nom de l’artifact et une version précise de celui-ci
wandb.Api().artifact(name="project/artifact:version")

# Indiquer l’entity, le projet, le nom de l’artifact et son alias
wandb.Api().artifact(name="entity/project/artifact:alias")

# Indiquer l’entity, le projet, le nom de l’artifact et une version précise de celui-ci
wandb.Api().artifact(name="entity/project/artifact:version")

méthode Api.artifact_collection()

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

Renvoie une seule collection d’artifacts, selon son type. Vous pouvez utiliser l’objet ArtifactCollection renvoyé pour récupérer des informations sur des artifacts précis de cette collection, entre autres.

str

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

str

Nom d’une collection d’artifacts. Vous pouvez le faire précéder de l’entity qui a journalisé l’artifact, suivi d’une barre oblique.

Dans l’extrait de code suivant, “type”, “entity”, “project” et “artifact_name” sont des espaces réservés qui désignent respectivement le type de collection, votre entity W&B, le nom du projet contenant 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 le projet et l’entity spécifiés.

str

Nom d’une collection d’artifacts. Vous pouvez éventuellement ajouter en préfixe l’entity qui a journalisé l’artifact, suivi d’une barre oblique. Si l’entity ou le projet n’est pas spécifié, la collection est déduite des paramètres redéfinis, s’ils existent. Sinon, l’entity est récupéré à partir des paramètres utilisateur et le projet prend par défaut la valeur « uncategorized ».

str

Type de la collection d’artifacts.

Dans l’extrait de code suivant, “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 un ensemble de collections d’artifacts correspondantes.

str

Le nom du projet à utiliser comme filtre.

str

Le nom du type d’artifact à utiliser comme filtre.

str | None

Chaîne facultative indiquant l’ordre de tri des résultats. Avec le préfixe ’+’, le tri est croissant (par défaut). Avec le préfixe ’-’, le tri est décroissant.

int

Définit la taille de page pour la pagination de la requête. En général, il n’y a aucune raison de modifier cette valeur.

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.

méthode Api.artifact_exists()

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

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

str

Le nom de l’artifact. Préfixez-le avec l’entity et le projet de l’artifact. Ajoutez à la fin la version ou l’alias de l’artifact, précédé de deux-points. Si l’entity ou le projet n’est pas spécifié, W&B utilise les paramètres redéfinis s’ils sont renseignés. Sinon, l’entity est récupéré depuis les paramètres utilisateur et le projet est défini sur « Uncategorized ».

str | None

Le type de l’artifact.

Dans les extraits de code suivants, “entity”, “project”, “artifact”, “version” et “alias” sont des espaces réservés représentant respectivement votre entity W&B, le nom du projet qui contient l’artifact, le nom de l’artifact et la version de l’artifact.

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.

str

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

str | None

Facultatif. Nom ou chemin du projet sur lequel filtrer.

méthode Api.artifact_types()

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

Renvoie une collection de types d’artifacts correspondants.

str | None

Nom ou chemin du projet à utiliser comme filtre.

str | None

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

méthode Api.artifact_versions()

(self, type_name, name, per_page=50)

Obsolète. Utilisez plutôt la méthode Api.artifacts(type_name, name).

_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.

str

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

str

Le nom de la collection de l’artifact. Vous pouvez éventuellement le préfixer de l’entity qui a journalisé l’artifact, suivie d’une barre oblique.

str | None

Chaîne facultative indiquant l’ordre de tri des résultats. Avec le préfixe ’+’, le tri est croissant (par défaut). Avec le préfixe ’-’, le tri est décroissant.

int

Définit la taille de page pour la pagination de la requête. En règle générale, il n’y a aucune raison de modifier cette valeur.

list[str] | None

Renvoie uniquement les artifacts qui possèdent 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.

Dans l’extrait de code suivant, “type”, “entity”, “project” et “artifact_name” sont des espaces réservés qui désignent respectivement le type d’artifact, l’entity W&B, le nom du projet dans lequel l’artifact a été journalisé et le nom de l’artifact.

import wandb

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

Pour interrompre l’itération et la reprendre plus tard au même endroit, enregistrez le .cursor du paginateur, puis transmettez-le via start= :

from itertools import islice

import wandb

api = wandb.Api()

# Parcourir la première page de résultats, puis enregistrer 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 enregistré.
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 l’unique automatisation correspondant aux paramètres.

str

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

str | None

L’entity dont récupérer l’automatisation.

ValueError : si aucune automatisation ne correspond aux critères de recherche, ou si plusieurs y correspondent.

Obtenir une automatisation existante nommée “my-automation” :

import wandb

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

Obtenir une automatisation existante nommée “other-automation” dans l’entity “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 indiqués. Si aucun paramètre n’est fourni, l’itérateur renvoyé contiendra toutes les Automatisations auxquelles l’utilisateur a accès.

str | None

L’entity dont vous souhaitez 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. Valeur par défaut : 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 antérieure, obtenu à partir de l’attribut .cursor d’un paginateur précédent.

Récupérer toutes les automatisations existantes de l’entity “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ée une nouvelle automatisation.

NewAutomation

L’automatisation à créer.

bool

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

Unpack[WriteAutomationsKwargs]

Aucune description fournie.

Créez une automatisation nommée “my-automation” qui envoie une notification Slack lorsqu’un run d’un projet donné 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 de 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ée un préréglage de graphique personnalisé et renvoie son ID.

str

L’entity (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 n’est accessible qu’à l’entity qui l’a créé
“public” : le graphique est accessible publiquement

str | dict

La spécification Vega/Vega-Lite, sous forme de dictionnaire ou de chaîne JSON

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

    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 le graphique 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ée un nouveau projet.

str

Le nom du nouveau projet.

str

L’entity 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.

str

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

Literal['organization', 'restricted']

La visibilité du registre. organization : tous les membres de l’organisation peuvent consulter ce registre. Vous pourrez modifier leurs rôles ultérieurement dans 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, elle est récupérée à partir de l’entity, à condition que celle-ci n’appartienne qu’à une seule organisation.

str | None

La description du registre.

list[str] | None

Les types d’artifacts acceptés par le registre. Un type ne doit pas dépasser 128 caractères ni contenir les caractères / ou :. Si aucun type n’est spécifié, tous les types sont acceptés. Une fois ajoutés au registre, les types autorisés ne peuvent plus être supprimés.

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ée un nouveau run.

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 journaliser le run. Si aucun projet n’est spécifié, le run est journalisé dans un projet nommé « Uncategorized ».

str | None

L’entity propriétaire du projet. Si aucune entity n’est spécifiée, le run est journalisé dans l’entity 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ée une nouvelle file d’attente de run dans W&B Launch.

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’entity dans lequel créer la file d’attente. Si la valeur est None, l’entity configuré ou l’entity par défaut est utilisé.

public.RunQueuePrioritizationMode | None

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

dict | None

Configuration de ressources par défaut à utiliser pour la file d’attente. Utilisez la syntaxe handlebars (par ex. {{var}}) pour définir 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ée une nouvelle équipe. Si vous utilisez le Cloud mutualisé W&B, définissez l’organisation API par défaut dans vos paramètres utilisateur de l’interface W&B avant d’appeler create_team(). Ce paramètre détermine l’organisation à laquelle la nouvelle équipe sera rattachée.

str

Le nom de l’équipe.

str | None

Nom d’utilisateur de l’administrateur de l’équipe. Par défaut, l’utilisateur actuel.

méthode Api.create_user()

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

Crée un nouvel utilisateur.

str

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'

Supprimer une automatisation.

Automation | str

L’automatisation à supprimer ou son ID.

méthode Api.flush()

(self)

Vide le cache local. L’objet api conserve un cache local des runs. Si l’état du run est susceptible d’être modifié 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')

Renvoie un run, un sweep, un projet ou un rapport à partir d’un chemin.

str

Le chemin d’accès au projet, au run, au sweep ou au rapport

Dans les extraits de code suivants, “project”, “team”, “run_id”, “sweep_id” et “report_name” sont des espaces réservés qui désignent respectivement le projet, l’équipe, l’ID du run, l’ID du sweep et le nom d’un rapport donné.

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

Renvoie un itérateur sur toutes les intégrations d’une entity.

str | None

L’entity (par exemple, le nom de l’équipe) pour lequel récupérer les intégrations. Si aucune valeur n’est fournie, l’entity par défaut de l’utilisateur est utilisé.

int

Nombre d’intégrations à récupérer par page. Valeur par défaut : 50. En règle générale, il n’y a aucune raison de modifier cette valeur.

str | None

Aucune description fournie.

méthode Api.job()

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

Renvoie un objet Job.

str | None

Le nom du job.

str | None

Le chemin racine dans lequel télécharger l’artifact du job.

méthode Api.list_jobs()

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

Renvoie la liste des jobs, le cas échéant, pour l’entity et le projet spécifiés.

str

L’entity des jobs répertoriés.

str

Le projet des jobs répertoriés.

méthode Api.organization()

self,
name: 'str | None' = None

Renvoie l’Organization correspondante.

str | None

Le nom de l’organisation. S’il est omis, cette méthode tente de déterminer et de renvoyer l’organisation par défaut actuelle.

méthode Api.project()

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

Renvoie le Project portant le nom indiqué (et appartenant à l’entity indiquée, le cas échéant).

str

Le nom du projet.

str | None

Nom de l’entity demandé. Si la valeur est None, l’entity par défaut transmis à Api est utilisé. En l’absence d’entity par défaut, une ValueError est levée.

méthode Api.projects()

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

Obtenir les projets d’un entity donné.

str | None

Nom de l’entity demandé. Si la valeur est None, l’entity par défaut transmis à Api est utilisé. En l’absence d’entity par défaut, une ValueError est levée.

int

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

méthode Api.queued_run()

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

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

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 paresseux d’objets Registry. Utilisez l’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 à la demande 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 avoir à récupérer le reste.

str | None

L’organisation du registre à récupérer. Si elle n’est pas spécifiée, l’organisation définie dans les paramètres de l’utilisateur est utilisée.

dict[str, Any] | None

Filtre facultatif de style MongoDB à appliquer à chaque objet de l’itérateur paresseux de registres. Les champs disponibles pour filtrer les registres sont name, description, created_at et updated_at. Les champs disponibles pour filtrer les collections sont name, tag, description, created_at et updated_at. Les champs disponibles pour filtrer les versions sont tag, alias, created_at, updated_at et metadata.

str | None

String facultative indiquant l’ordre de tri des résultats. Avec le préfixe « + », le tri est croissant (par défaut). Avec le préfixe « - », le tri est décroissant.

int

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

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.

Trouver tous les registres dont le nom contient « model »

import wandb

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

Trouver, dans les registres, toutes les collections nommées “my_collection” et portant le tag “my_tag”

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

Trouver, dans les registres, toutes les versions d’artifact dont le nom de collection contient “my_collection” et qui possèdent l’alias “best”

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

Trouver toutes les versions d’artifact dans les registres dont le nom contient “model” et qui ont le tag “prod” ou l’alias “best”

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

Suspendez l’itération et reprenez-la plus tard au même endroit en enregistrant le .cursor du paginateur, puis en le transmettant via start= :

from itertools import islice

import wandb

api = wandb.Api()

# Parcourir la première page de résultats, puis enregistrer 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 enregistré.
remaining_registries = api.registries(per_page=page_size, start=saved_cursor)

méthode Api.registry()

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

Renvoie un registre à partir de son nom.

str

Le nom du registre, sans le préfixe wandb-registry-.

str | None

L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, l’organisation est déduite de l’entity, à condition que celle-ci n’appartienne qu’à une seule organisation.

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 reports pour un chemin de projet donné. Remarque : l’API wandb.Api.reports() est en version bêta et sera probablement modifiée dans les prochaines versions.

str

Chemin du projet contenant le rapport. Indiquez en préfixe l’entity 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. En général, il n’y a aucune raison de modifier cette valeur.

import wandb

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

méthode Api.run()

self,
path: 'str' = ''

Renvoie un run unique en analysant un chemin au format entity/project/run_id.

str

Chemin du run, au format entity/project/run_id. Si api.entity est défini, le chemin peut prendre la forme project/run_id, et si api.project est défini, il peut se limiter au run_id.

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

méthode Api.run_queue()

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

Renvoie la RunQueue portant le nom indiqué pour l’entity. Voir Api.create_run_queue pour plus d’informations sur la création d’une file d’attente de run.

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 manière différée sur des objets Run. Vous pouvez filtrer sur les champs suivants :

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 d’exécution totale du run, en secondes.
group : le nom du groupe utilisé pour regrouper des runs liés.
host : le nom d’hôte de la machine sur laquelle le run a été exécuté.
jobType : le type de job ou l’objectif 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 de l’utilisateur qui a lancé le run

Vous pouvez également filtrer sur les éléments de la configuration de run ou des métriques de synthèse, comme 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

str | None

(str) chemin vers le projet, au format : “entity/project”

dict[str, Any] | None

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

str

(str) L’ordre de tri peut être created_at, heartbeat_at, config.*.value ou summary_metrics.*. Si vous le préfixez par un +, le tri est croissant (par défaut). Si vous le préfixez par 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 immédiatement l’objet sweep dans chaque résultat de run.

bool

(bool) Indique s’il faut utiliser le chargement différé pour améliorer les performances. Lorsque la valeur est True (par défaut), seules les métadonnées essentielles du run sont chargées au départ. Les champs volumineux comme config, summaryMetrics et systemMetrics sont chargés à la demande, lors de leur premier accès. Définissez la valeur sur False pour charger l’ensemble des données dès le départ.

import wandb
from wandb.apis.public import Api

# Trouver les runs du projet dont config.experiment_name est défini sur "foo"
Api.runs(path="my_entity/project", filters={"config.experiment_name": "foo"})

# Trouver les runs du projet dont config.experiment_name est 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 du projet dont 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 syntaxe RE2 de Google : https://github.com/google/re2/wiki/Syntax

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

# Trouver les runs du projet, triés par ordre croissant de perte
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 sur les intégrations Slack d’une entity.

str | None

L’entity (par exemple, le nom d’une équipe) pour lequel récupérer les intégrations. S’il n’est pas fourni, l’entity par défaut de l’utilisateur est utilisé.

int

Nombre d’intégrations à récupérer par page. Valeur par défaut : 50. En règle générale, il n’y a aucune raison de modifier cette valeur.

str | None

Aucune description fournie.

Obtenir 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")

Trouver 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='')

Renvoie un sweep en analysant le chemin au format entity/project/sweep_id.

_empty

Chemin du sweep, au format entity/project/sweep_id. Si api.entity est défini, le chemin peut prendre la forme project/sweep_id ; si api.project est défini, il peut se limiter au sweep_id.

méthode Api.sync_tensorboard()

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

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

_empty

Aucune description fournie.

_empty

Aucune description fournie.

_empty

Aucune description fournie.

_empty

Aucune description fournie.

méthode Api.team()

self,
team: 'str'

Renvoie l’objet Team correspondant au nom indiqué.

str

Le nom de l’équipe.

méthode Api.update_automation()

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

Met à jour une automatisation existante.

Automation

L’automatisation à mettre à jour. Elle doit déjà exister.

bool

Si True et que l’automatisation n’existe pas, celle-ci est créée.

Unpack[WriteAutomationsKwargs]

Aucune description fournie.

Désactiver une automatisation existante (“my-automation”) et modifier sa description :

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.

str

Nom de la file d’attente à créer

dict

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

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 facultatif de l’entity dans lequel créer la file d’attente. Si la valeur est None, l’entity configuré ou l’entity par défaut est utilisé.

dict | None

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

dict | None

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

public.RunQueuePrioritizationMode | None

Version facultative du mode de priorisation à utiliser. Soit “V0”, soit None

méthode Api.user()

self,
username_or_email: 'str'

Renvoie un utilisateur à partir d’un nom d’utilisateur ou d’une adresse e-mail. Cette fonction n’est disponible que pour les administrateurs locaux. Utilisez api.viewer pour obtenir votre propre objet utilisateur.

str

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

méthode Api.users()

self,
username_or_email: 'str'

Renvoie tous les utilisateurs correspondant à une requête sur un nom d’utilisateur ou une adresse e-mail partiel. Cette fonction n’est disponible que pour les administrateurs locaux. Utilisez api.viewer pour obtenir votre propre objet utilisateur.

str

Le préfixe ou le suffixe de l’utilisateur à rechercher.

méthode Api.webhook_integrations()

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

Renvoie un itérateur sur les intégrations webhook d’un entity.

str | None

L’entity (par exemple, le nom de l’équipe) pour lequel récupérer les intégrations. S’il n’est pas fourni, l’entity par défaut de l’utilisateur est utilisé.

int

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

str | None

Aucune description fournie.

Obtenir 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")

Trouver 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()

​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()

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()