Passer au contenu principal

​
class Api

Utilisée pour interroger le serveur W&B. Exemples : 
import wandb

wandb.Api()

​
méthode Api.__init__

__init__(
    overrides: 'dict[str, Any] | None' = None,
    timeout: 'int | None' = None,
    api_key: 'str | None' = None
) → None
Initialiser l’API. Arguments :
  • overrides : 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.
  • timeout : 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é.
  • api_key : clé API à utiliser pour l’authentification. Si elle n’est pas fournie, la clé API de l’environnement ou de la configuration actuels sera utilisée. Une invite de saisie de clé API s’affiche si aucune n’est fournie ou configurée dans l’environnement.

​
propriété Api.client

Renvoie l’objet client. Retourne :
  • RetryingClient : Valeur de la propriété client.

​
propriété Api.default_entity

Renvoie l’entité W&B par défaut. Retourne :
  • str | None : La valeur de la propriété default_entity.

​
propriété Api.user_agent

Renvoie le user agent public de W&B. Retourne :
  • str : La valeur de la propriété user_agent.

​
propriété Api.viewer

Renvoie l’objet de l’utilisateur courant. Exceptions levées :
  • ValueError : Si les données de l’utilisateur courant ne peuvent pas être récupérées depuis W&B.
  • requests.RequestException : Si une erreur se produit lors de l’envoi de la requête GraphQL.
Retourne :
  • User : La valeur de la propriété viewer.

​
méthode Api.artifact

artifact(name: 'str', type: 'str | None' = None)
Renvoie un artefact unique. Arguments :
  • name: Le nom de l’artefact. Le nom d’un artefact ressemble à un chemin de fichier qui comprend, au minimum, le nom du projet dans lequel l’artefact a été enregistré, le nom de l’artefact, ainsi que la version ou l’alias de l’artefact. Vous pouvez facultativement ajouter en préfixe l’entité qui a enregistré l’artefact, suivie d’une barre oblique. Si aucune entité n’est spécifiée dans le nom, l’entité du run ou du paramètre d’API est utilisée.
  • type: Le type d’artefact à récupérer.
Retourne : Un objet Artifact. Exceptions levées :
  • ValueError: Si le nom de l’artefact n’est pas spécifié.
  • ValueError: Si le type d’artefact est spécifié mais ne correspond pas au type de l’artefact récupéré.
Exemples : Dans les extraits de code suivants, “entity”, “project”, “artifact”, “version” et “alias” sont des espaces réservés représentant respectivement votre entité W&B, le nom du projet dans lequel se trouve l’artefact, le nom de l’artefact et la version de l’artefact. 
import wandb

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

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

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

# Indiquer l'entité, le projet, le nom de l'artefact et une version spécifique de l'artefact
wandb.Api().artifact(name="entity/project/artifact:version")
Remarque :
Cette méthode est destinée à un usage externe uniquement. N’appelez pas api.artifact() dans le code du dépôt wandb.

​
méthode Api.artifact_collection

artifact_collection(type_name: 'str', name: 'str') → ArtifactCollection
Renvoie une collection d’artefacts unique pour un type donné. Vous pouvez utiliser l’objet ArtifactCollection renvoyé pour récupérer des informations sur des artefacts spécifiques de cette collection, entre autres. Arguments :
  • type_name: Le type de collection d’artefacts à récupérer.
  • name: Le nom d’une collection d’artefacts. Vous pouvez, facultativement, le faire précéder de l’entité qui a enregistré l’artefact, suivie d’une barre oblique.
Retourne : Un objet ArtifactCollection. Exemples : Dans l’extrait de code suivant, “type”, “entity”, “project” et “artifact_name” sont des espaces réservés représentant respectivement le type de collection, votre entité W&B, le nom du projet dans lequel se trouve l’artefact et le nom de l’artefact. 
import wandb

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

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

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

​
méthode Api.artifact_collection_exists

artifact_collection_exists(name: 'str', type: 'str') → bool
Indique si une collection d’artefacts existe dans un projet et une entité donnés. Arguments :
  • name: Nom d’une collection d’artefacts. Vous pouvez facultativement ajouter en préfixe l’entité qui a enregistré l’artefact, 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 surcharge, s’ils existent. Sinon, l’entité est extraite des paramètres utilisateur et le projet prendra par défaut la valeur “uncategorized”.
  • type: Le type de la collection d’artefacts.
Retourne : True si la collection d’artefacts existe, False sinon. Exemples : Dans l’extrait de code suivant, “type” et “collection_name” désignent respectivement le type de la collection d’artefacts et le nom de la collection. 
import wandb

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

​
méthode Api.artifact_collections

artifact_collections(
    project_name: 'str',
    type_name: 'str',
    per_page: 'int' = 50
) → ArtifactCollections
Renvoie une collection de collections d’artefacts correspondant aux critères. Arguments :
  • project_name: Le nom du projet à utiliser pour le filtrage.
  • type_name: Le nom du type d’artefact à utiliser pour le filtrage.
  • per_page: Définit la taille de page pour la pagination des requêtes. En général, il n’y a pas lieu de la modifier.
Retourne : Un objet itérable ArtifactCollections.

​
méthode Api.artifact_exists

artifact_exists(name: 'str', type: 'str | None' = None) → bool
Indique si une version d’artefact existe dans le projet et l’entité spécifiés. Arguments :
  • name : Le nom de l’artefact. Ajoutez l’entité et le projet de l’artefact en préfixe. Ajoutez la version ou l’alias de l’artefact après un deux-points. Si l’entité ou le projet n’est pas spécifié, W&B utilise les paramètres de substitution 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”.
  • type : Le type de l’artefact.
Retourne : True si la version de l’artefact existe, False sinon. Exemples : Dans l’extrait de code suivant, “entity”, “project”, “artifact”, “version” et “alias” sont des espaces réservés représentant respectivement votre entité W&B, le nom du projet dans lequel se trouve l’artefact, le nom de l’artefact et la version de l’artefact. 
import wandb

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

​
méthode Api.artifact_type

artifact_type(type_name: 'str', project: 'str | None' = None) → ArtifactType
Renvoie l’ArtifactType correspondant. Arguments :
  • type_name : Le nom du type d’artefact à récupérer.
  • project : Si indiqué, le nom d’un projet ou un chemin sur lequel appliquer un filtre.
Retourne : Un objet ArtifactType.

​
méthode Api.artifact_types

artifact_types(project: 'str | None' = None) → ArtifactTypes
Renvoie une collection des types d’artefact correspondants. Arguments :
  • project : le nom du projet ou le chemin sur lequel appliquer le filtre.
Retourne : Un objet ArtifactTypes itérable.

​
méthode Api.artifact_versions

artifact_versions(type_name, name, per_page=50)
Obsolète. Utilisez plutôt la méthode Api.artifacts(type_name, name) à la place.

​
méthode Api.artifacts

artifacts(
    type_name: 'str',
    name: 'str',
    per_page: 'int' = 50,
    tags: 'list[str] | None' = None
) → Artifacts
Renvoie une collection Artifacts. Arguments :
  • type_name : Le type d’artefacts à récupérer.
  • name : Le nom de la collection de l’artefact. Vous pouvez facultativement le faire précéder de l’entité qui a enregistré l’artefact, suivie d’une barre oblique.
  • per_page : Définit la taille de page pour la pagination des requêtes. En général, il n’est pas nécessaire de modifier ce paramètre.
  • tags : Renvoie uniquement les artefacts possédant toutes ces balises.
Retourne : Un objet Artifacts itérable. Exemples : Dans l’extrait de code suivant, “type”, “entity”, “project” et “artifact_name” sont des espaces réservés désignant respectivement le type d’artefact, l’entité W&B, le nom du projet dans lequel l’artefact a été enregistré et le nom de l’artefact. 
import wandb

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

​
méthode Api.automation

automation(name: 'str', entity: 'str | None' = None) → Automation
Renvoie la seule automatisation correspondant aux paramètres donnés. Arguments :
  • name: Le nom de l’automatisation à récupérer.
  • entity: L’entité dont il faut récupérer l’automatisation.
Exceptions levées :
  • ValueError: Si aucune ou plusieurs automatisations correspondent aux critères de recherche.
Exemples : 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’entité “my-team” : 
automation = api.automation(name="other-automation", entity="my-team")

​
méthode Api.automations

automations(
    entity: 'str | None' = None,
    name: 'str | None' = None,
    per_page: 'int' = 50
) → Iterator[Automation]
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é contient toutes les automatisations auxquelles l’utilisateur a accès. Arguments :
  • entity: L’entité pour laquelle récupérer les automatisations.
  • name: Le nom de l’automatisation à récupérer.
  • per_page: Le nombre d’automatisations à récupérer par page. La valeur par défaut est 50. Il n’y a généralement aucune raison de modifier ce paramètre.
Retourne : Une liste d’automatisations. 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

create_automation(
    obj: 'NewAutomation',
    fetch_existing: 'bool' = False,
    **kwargs: 'Unpack[WriteAutomationsKwargs]'
) → Automation
Créer une nouvelle automatisation. Arguments : obj: L’automatisation à créer. fetch_existing: Si la valeur est True et qu’une automatisation en conflit existe déjà, essayez de récupérer l’automatisation existante au lieu de générer une erreur. **kwargs: Toute valeur supplémentaire à attribuer à l’automatisation avant de la créer. Si elles sont fournies, elles remplaceront toutes les valeurs déjà définies pour l’automatisation :
  • name: Le nom de l’automatisation.
    • description: La description de l’automatisation.
    • enabled: Indique si l’automatisation est activée.
    • scope: La portée de l’automatisation.
    • event: L’événement qui déclenche l’automatisation.
    • action: L’action déclenchée par l’automatisation.
Retourne : L’automatisation enregistrée. Exemples : Créer une nouvelle automatisation nommée “my-automation” qui envoie une notification Slack lorsqu’un run au sein d’un projet spécifique enregistre 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="Envoyer un message Slack chaque fois que 'custom-metric' dépasse 10.",
)

​
méthode Api.create_custom_chart

create_custom_chart(
    entity: 'str',
    name: 'str',
    display_name: 'str',
    spec_type: "Literal['vega2']",
    access: "Literal['private', 'public']",
    spec: 'str | dict'
) → str
Créer un préréglage de graphique personnalisé et renvoyer son ID. Arguments :
  • entity : L’entité (utilisateur ou équipe) propriétaire du graphique
  • name : Identifiant unique du préréglage de graphique
  • display_name : Nom affiché dans l’interface utilisateur, lisible par l’utilisateur
  • spec_type : Type de spécification. Doit être “vega2” pour les spécifications Vega-Lite v2.
  • access : Niveau d’accès du graphique :
    • “private” : Le graphique est accessible uniquement à l’entité qui l’a créé
    • “public” : Le graphique est accessible publiquement
  • spec : La spécification Vega/Vega-Lite sous forme de dictionnaire ou de chaîne JSON
Retourne : L’ID du préréglage de graphique créé au format “entity/name” 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
Exemple : 
    import wandb

    api = wandb.Api()

    # Définir une spécification de graphique à barres simple
    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

create_project(name: 'str', entity: 'str') → None
Créer un nouveau projet. Arguments :
  • name: Le nom du nouveau projet.
  • entity: L’entité du nouveau projet.

​
méthode Api.create_registry

create_registry(
    name: 'str',
    visibility: "Literal['organization', 'restricted']",
    organization: 'str | None' = None,
    description: 'str | None' = None,
    artifact_types: 'list[str] | None' = None
) → Registry
Créer un nouveau registre. Arguments :
  • name: Le nom du registre. Il doit être unique au sein de l’organisation.
  • visibility: La visibilité du registre.
  • organization: Toute personne de l’organisation peut consulter ce registre. Vous pourrez modifier les rôles plus tard 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é.
  • organization: L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, l’organisation sera récupérée à partir de l’entité si celle-ci n’appartient qu’à une seule organisation.
  • description: La description du registre.
  • artifact_types: Les types d’artefact acceptés par le registre. Un type ne peut pas contenir
  • more than 128 characters and do not include characters /or ``:. S’ils ne sont pas spécifiés, tous les types sont acceptés. Les types autorisés ajoutés au registre ne pourront pas être supprimés par la suite.
Retourne : Un objet registre. 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

create_run(
    run_id: 'str | None' = None,
    project: 'str | None' = None,
    entity: 'str | None' = None
) → public.Run
Créer un nouveau run. Arguments :
  • run_id: ID à attribuer au run. S’il n’est pas spécifié, W&B crée un ID aléatoire.
  • project: Projet dans lequel enregistrer le run. Si aucun projet n’est spécifié, le run est enregistré dans un projet appelé “Uncategorized”.
  • entity: Entité propriétaire du projet. Si aucune entité n’est spécifiée, le run est enregistré dans l’entité par défaut.
Retourne : Le Run nouvellement créé.

​
méthode Api.create_run_queue

create_run_queue(
    name: 'str',
    type: 'public.RunQueueResourceType',
    entity: 'str | None' = None,
    prioritization_mode: 'public.RunQueuePrioritizationMode | None' = None,
    config: 'dict | None' = None,
    template_variables: 'dict | None' = None
) → public.RunQueue
Créer une nouvelle file d’attente de run dans W&B Launch. Arguments :
  • name: Nom de la file d’attente à créer
  • type: Type de ressource à utiliser pour la file d’attente. L’une des valeurs suivantes : “local-container”, “local-process”, “kubernetes”, “sagemaker” ou “gcp-vertex”.
  • entity: Nom de l’entité dans laquelle créer la file d’attente. Si None, utiliser l’entité configurée ou l’entité par défaut.
  • prioritization_mode: Version de priorisation à utiliser. Soit “V0”, soit None.
  • config: Configuration de ressource par défaut à utiliser pour la file d’attente. Utiliser Handlebars (par ex. {{var}}) pour spécifier des variables de template.
  • template_variables: Un dictionnaire de schémas de variables de template à utiliser avec la configuration.
Retourne : Le RunQueue nouvellement créé. Exceptions levées : ValueError si l’un des paramètres n’est pas valide, wandb.Error en cas d’erreur d’API wandb

​
méthode Api.create_team

create_team(team: 'str', admin_username: 'str | None' = None) → Team
Créer une nouvelle équipe. Arguments :
  • team: Le nom de l’équipe
  • admin_username: Nom d’utilisateur de l’administrateur de l’équipe. Par défaut, il s’agit de l’utilisateur actuel.
Retourne : Un objet Team.

​
méthode Api.create_user

create_user(email: 'str', admin: 'bool | None' = False) → User
Créer un nouvel utilisateur. Arguments :
  • email: L’adresse e-mail de l’utilisateur.
  • admin: Définit l’utilisateur comme administrateur global de l’instance.
Retourne : Un objet User.

​
méthode Api.delete_automation

delete_automation(obj: 'Automation | str') → Literal[True]
Supprime une automatisation. Arguments :
  • obj : l’automatisation à supprimer, ou son ID.
Retourne : True si l’automatisation a été supprimée avec succès.

​
méthode Api.flush

flush()
Videz le cache local. L’objet api conserve un cache local des runs. Ainsi, si l’état du run peut changer pendant l’exécution de votre script, vous devez vider le cache local avec api.flush() afin d’obtenir les dernières valeurs associées à l’exécution.

​
méthode Api.from_path

from_path(path: 'str')
Renvoie un run, un balayage, un projet ou un rapport à partir d’un chemin. Arguments :
  • path : Le chemin du projet, du run, du balayage ou du rapport
Retourne : Une instance Project, Run, Sweep ou BetaReport. Exceptions levées : wandb.Error si le chemin n’est pas valide ou si l’objet n’existe pas. Exemples : Dans les extraits de code suivants, “project”, “team”, “run_id”, “sweep_id” et “report_name” sont des valeurs de substitution représentant respectivement le projet, l’équipe, l’ID du run, l’ID du balayage 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

integrations(
    entity: 'str | None' = None,
    per_page: 'int' = 50
) → Iterator[Integration]
Renvoie un itérateur de toutes les intégrations d’une entité. Arguments :
  • entity : L’entité (par ex. le nom de l’é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.
  • per_page : Nombre d’intégrations à récupérer par page. La valeur par défaut est de 50. Il n’y a généralement aucune raison de modifier ce paramètre.
Génère :
  • Iterator[SlackIntegration | WebhookIntegration] : Un itérateur des intégrations prises en charge.

​
méthode Api.job

job(name: 'str | None', path: 'str | None' = None) → public.Job
Renvoie un objet Job. Arguments :
  • name : Le nom du job.
  • path : Le chemin racine depuis lequel télécharger l’artefact du job.
Retourne : Un objet Job.

​
méthode Api.list_jobs

list_jobs(entity: 'str', project: 'str') → list[dict[str, Any]]
Renvoie une liste de jobs, le cas échéant, pour l’entité et le projet spécifiés. Arguments :
  • entity : L’entité des jobs répertoriés.
  • project : Le projet des jobs répertoriés.
Retourne : Une liste des jobs correspondants.

​
méthode Api.project

project(name: 'str', entity: 'str | None' = None) → public.Project
Renvoie le Project portant le nom indiqué (et l’entité, si elle est fournie). Arguments :
  • name : Le nom du projet.
  • entity : Nom de l’entité demandée. Si None, utilise par défaut l’entité transmise à Api. S’il n’existe aucune entité par défaut, une ValueError est levée.
Retourne : Un objet Project.

​
méthode Api.projects

projects(entity: 'str | None' = None, per_page: 'int' = 200) → public.Projects
Obtenir les projets pour une entité donnée. Arguments :
  • entity : Nom de l’entité demandée. Si None, l’entité par défaut transmise à Api sera utilisée. S’il n’existe pas d’entité par défaut, une ValueError est levée.
  • per_page : 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.
Retourne : Un objet Projects, qui est une collection itérable d’objets Project.

​
méthode Api.queued_run

queued_run(
    entity: 'str',
    project: 'str',
    queue_name: 'str',
    run_queue_item_id: 'str',
    project_queue=None,
    priority=None
)
Renvoie un run en file d’attente correspondant au chemin. Analyse les chemins au format entity/project/queue_id/run_queue_item_id.

​
méthode Api.registries

registries(
    organization: 'str | None' = None,
    filter: 'dict[str, Any] | None' = None,
    per_page: 'int' = 100
) → Registries
Renvoie un itérateur lazy d’objets Registry. Utilisez cet itérateur pour rechercher et filtrer des registres, des collections ou des versions d’artefact dans le registre de votre organisation. Arguments :
  • organization: (str, facultatif) L’organisation du registre à récupérer. Si elle n’est pas spécifiée, utilisez l’organisation définie dans les paramètres de l’utilisateur.
  • filter: (dict, facultatif) Filtre de type MongoDB à appliquer à chaque objet de l’itérateur de registre lazy. 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
  • per_page: Définit la taille de page pour la pagination des requêtes.
Retourne : Un itérateur lazy d’objets Registry. 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"}})
Trouver 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"})
Trouver toutes les versions d’artefact dans les registres dont le nom de collection contient “my_collection” et dont la version a l’alias “best” 
api.registries().collections(
    filter={"name": {"$regex": "my_collection"}}
).versions(filter={"alias": "best"})
Trouver toutes les versions d’artefact dans les registres contenant “model” et portant le tag “prod” ou l’alias “best” 
api.registries(filter={"name": {"$regex": "model"}}).versions(
    filter={"$or": [{"tag": "prod"}, {"alias": "best"}]}
)

​
méthode Api.registry

registry(name: 'str', organization: 'str | None' = None) → Registry
Renvoie le registre correspondant à un nom de registre. Arguments :
  • name: Le nom du registre. Il s’agit du nom sans le préfixe wandb-registry-.
  • organization: L’organisation du registre. Si aucune organisation n’est définie dans les paramètres, l’organisation sera récupérée à partir de l’entité si celle-ci n’appartient qu’à une seule organisation.
Retourne : Un objet de registre. 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

reports(
    path: 'str' = '',
    name: 'str | None' = None,
    per_page: 'int' = 50
) → public.Reports
Récupère les rapports pour un chemin de projet donné. Remarque : l’API wandb.Api.reports() est en version bêta et changera probablement dans de futures versions. Arguments :
  • path : Chemin vers le projet dans lequel se trouve le rapport. Spécifiez l’entité qui a créé le projet comme préfixe, suivi d’un slash.
  • name : Nom du rapport demandé.
  • per_page : Définit la taille de page pour la pagination des requêtes. Il n’y a généralement aucune raison de le modifier.
Retourne : Un objet Reports, qui est une collection itérable d’objets BetaReport. Exemples : 
import wandb

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

​
méthode Api.run

run(path='')
Renvoie un run unique en analysant le chemin au format entity/project/run_id. Arguments :
  • path : Chemin du run au format entity/project/run_id. Si api.entity est défini, ce chemin peut être au format project/run_id et, si api.project est défini, il peut simplement s’agir de l’ID du run.
Retourne : Un objet Run.

​
méthode Api.run_queue

run_queue(entity: 'str', name: 'str')
Renvoie la RunQueue nommée de l’entité. Voir Api.create_run_queue pour plus d’informations sur la création d’une file d’attente de run.

​
méthode Api.runs

runs(
    path: 'str | None' = None,
    filters: 'dict[str, Any] | None' = None,
    order: 'str' = '+created_at',
    per_page: 'int' = 50,
    include_sweeps: 'bool' = True,
    lazy: 'bool' = True
)
Renvoie un objet Runs, qui itère de manière lazy sur des 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 regrouper des runs associés.
  • host : le nom d’hôte où 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 d’utilisateur de l’utilisateur à l’origine du run
De plus, 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 filtrages plus complexes, vous pouvez utiliser des 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 :
  • path : (str) chemin vers le projet, doit être sous la forme : “entity/project”
  • filters : (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"} permettrait de trouver des runs dont l’entrée de configuration du nom d’expérience est définie sur “foo”
  • order : (str) L’ordre peut être created_at, heartbeat_at, config.*.value ou summary_metrics.*. Si vous faites précéder l’ordre d’un +, l’ordre est croissant (par défaut). Si vous faites précéder l’ordre d’un -, l’ordre est décroissant. L’ordre par défaut est run.created_at, du plus ancien au plus récent.
  • per_page : (int) Définit la taille de page pour la pagination des requêtes.
  • include_sweeps : (bool) Indique s’il faut inclure les runs de balayage dans les résultats.
  • lazy : (bool) Indique s’il faut utiliser le chargement lazy pour de meilleures performances. Lorsque la valeur est 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 la valeur sur False pour charger l’ensemble des données dès le départ.
Retourne : Un objet Runs, qui est une collection itérable d’objets Run. Exemples : 
import wandb
from wandb.apis.public import Api

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

# Trouver les runs dans le projet où config.experiment_name est défini à "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
# (les ancres ne sont pas prises en charge)
Api.runs(
    path="my_entity/project",
    filters={"config.experiment_name": {"$regex": "b.*"}},
)

# Trouver les runs dans le projet où le nom de l'exécution correspond à une regex
# (les ancres ne sont pas prises en charge)
Api.runs(
    path="my_entity/project", filters={"display_name": {"$regex": "^foo.*"}}
)

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

​
méthode Api.slack_integrations

slack_integrations(
    entity: 'str | None' = None,
    per_page: 'int' = 50
) → Iterator[SlackIntegration]
Renvoie un itérateur d’intégrations Slack pour une entité. Arguments :
  • entity: L’entité (par ex. le nom de l’é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.
  • per_page: Nombre d’intégrations à récupérer par page. La valeur par défaut est de 50. En général, il n’est pas nécessaire de modifier ce paramètre.
Génère :
  • Iterator[SlackIntegration]: Un itérateur d’intégrations Slack.
Exemples : 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")
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

sweep(path='')
Renvoie un balayage en analysant un chemin au format entity/project/sweep_id. Arguments :
  • path : 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.
Retourne : Un objet Sweep.

​
méthode Api.sync_tensorboard

sync_tensorboard(root_dir, run_id=None, project=None, entity=None)
Synchroniser un répertoire local contenant des fichiers tfevent avec wandb.

​
méthode Api.team

team(team: 'str') → Team
Renvoie le Team correspondant au nom indiqué. Arguments :
  • team: Le nom de l’équipe.
Retourne : Un objet Team.

​
méthode Api.update_automation

update_automation(
    obj: 'Automation',
    create_missing: 'bool' = False,
    **kwargs: 'Unpack[WriteAutomationsKwargs]'
) → Automation
Mettez à jour une automatisation existante. Arguments :
  • obj : L’automatisation à mettre à jour. Elle doit déjà exister. create_missing (bool) : Si True et que l’automatisation n’existe pas, créez-la. **kwargs : Toute valeur supplémentaire à attribuer à l’automatisation avant sa mise à jour. Si elles sont fournies, elles remplaceront les valeurs éventuellement déjà définies pour l’automatisation :
    • name : Le nom de l’automatisation.
    • description : La description de l’automatisation.
    • enabled : Indique si l’automatisation est activée.
    • scope : La portée de l’automatisation.
    • event : L’événement qui déclenche l’automatisation.
    • action : L’action déclenchée par l’automatisation.
Retourne : L’automatisation mise à jour. 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)
OU 
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

upsert_run_queue(
    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 runs dans W&B Launch. Arguments :
  • name: Nom de la file d’attente à créer
  • entity: Nom facultatif de l’entité pour laquelle créer la file d’attente. Si None, utiliser l’entité configurée ou l’entité par défaut.
  • resource_config: Configuration de ressources par défaut, facultative, à utiliser pour la file d’attente. Utilisez la syntaxe Handlebars (par ex. {{var}}) pour spécifier des variables de modèle.
  • resource_type: Type de ressource à utiliser pour la file d’attente. L’une des valeurs suivantes : “local-container”, “local-process”, “kubernetes”, “sagemaker” ou “gcp-vertex”.
  • template_variables: Dictionnaire de schémas de variables de modèle à utiliser avec la configuration.
  • external_links: Dictionnaire facultatif de liens externes à utiliser avec la file d’attente.
  • prioritization_mode: Version de priorisation facultative à utiliser. Soit “V0”, soit None
Retourne : Le RunQueue créé ou mis à jour. Exceptions levées : ValueError si l’un des paramètres n’est pas valide, wandb.Error en cas d’erreur de l’API wandb

​
méthode Api.user

user(username_or_email: 'str') → User | None
Renvoie un utilisateur correspondant à un nom d’utilisateur ou à une adresse e-mail. Cette fonction ne fonctionne que pour les administrateurs locaux. Utilisez api.viewer pour obtenir votre propre objet utilisateur. Arguments :
  • username_or_email: Le nom d’utilisateur ou l’adresse e-mail de l’utilisateur.
Retourne : Un objet User ou None si aucun utilisateur n’est trouvé.

​
méthode Api.users

users(username_or_email: 'str') → list[User]
Renvoie tous les utilisateurs correspondant à une requête partielle sur le nom d’utilisateur ou l’adresse e-mail. Cette fonction fonctionne seulement pour les administrateurs locaux. Utilisez api.viewer pour obtenir votre propre objet utilisateur. Arguments :
  • username_or_email: Le préfixe ou le suffixe de l’utilisateur que vous souhaitez trouver.
Retourne : Un tableau d’objets User.

​
méthode Api.webhook_integrations

webhook_integrations(
    entity: 'str | None' = None,
    per_page: 'int' = 50
) → Iterator[WebhookIntegration]
Renvoie un itérateur d’intégrations webhook pour une entité. Arguments :
  • entity : L’entité (par ex. le nom de l’é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.
  • per_page : Nombre d’intégrations à récupérer par page. La valeur par défaut est 50. En général, il n’est pas nécessaire de modifier ce paramètre.
Génère :
  • Iterator[WebhookIntegration] : Un itérateur d’intégrations webhook.
Exemples : 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")
Trouvez 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")
]