Journal

"""
Enregistrer un fichier CSV dans W&B sous forme de tableau.

Remplacez :
- les valeurs entre chevrons par les vôtres
- <name>.csv dans pd.read_csv() par le nom de votre fichier CSV
"""

import wandb
import pandas as pd

# Lire le CSV en tant qu'objet DataFrame (pandas)
dataframe = pd.read_csv("<name>.csv")

# Convertir le DataFrame en tableau W&B
table = wandb.Table(dataframe=dataframe)

# Démarrer un run W&B pour journaliser les données
with wandb.init(project="<project>") as run:

    # Journaliser le tableau pour le visualiser dans l'interface utilisateur W&B
    run.log({"<table_name>": table})

"""
Journaliser une métrique summary personnalisée dans W&B.
"""
import wandb
import random 

with wandb.init(project="<project>") as run:
    # Journaliser une métrique summary personnalisée avec une valeur entière aléatoire entre 1 et 10
    run.summary["<metric_name>"] = random.randint(1, 10)

"""
Enregistrez une métrique de synthèse personnalisée dans W&B.

Remplacez :
- les valeurs entre chevrons par les vôtres
- <summary_function_a> et <summary_function_b> dans run.define_metric() par
    l'une des valeurs suivantes : "max", "min", "last", "mean", "best" ou "none".
"""
import wandb
import random

with wandb.init() as run:
    # valeurs de synthèse summary_function_a et summary_function_b pour metric_name_a
    run.define_metric(name="<metric_name_a>", summary="<summary_function_a>")
    run.define_metric(name="<metric_name_a>", summary="<summary_function_b>")

    for i in range(10):
        log_dict = {
            "metric_name_a": random.uniform(0, 1 / (i + 1)),
        }
        run.log(log_dict)

"""
Télécharger et journaliser un artifact existant depuis une collection du registre W&B.
Remplacez les espaces réservés par le nom du registre, les noms de collection, l'entité,
le projet et la version réels.
"""
import wandb

# Construire le nom complet de l'artifact avec la version
registry_name = "<registry_name>"  # Spécifier le nom du registre
collection_name = "<collection_name>" # Spécifier le nom de la collection
version = 0 # Spécifier la version de l'artifact à utiliser
artifact_name_registry = f"wandb-registry-{registry_name}/{collection_name}:v{version}"

# Initialiser un run W&B dans une équipe et un projet différents
with wandb.init(entity="<entity>", project="<project>") as run:
    # Utiliser l'artifact du modèle depuis le registre
    registry_model = run.use_artifact(artifact_or_name=artifact_name_registry)

    # Télécharger le modèle dans un répertoire local
    local_model_path = registry_model.download()

"""
Log a histogram plot to W&B. 

Replace:
- values enclosed in angle brackets with your own
- [[1, 2], [2, 3]] in wandb.Table(data=) with your own 2D row-oriented array of values to plot

Pass a 2D row-oriented array of values to data (wandb.Table(data=)), with
column names specified in the `columns` parameter.
"""
import wandb

# Démarrer un nouveau run
with wandb.init(entity="<entity>", project="<project>") as run:
        
    # Créer un tableau avec les colonnes à tracer
    table = wandb.Table(data=[[1, 2], [2, 3]] , columns=["<a_column>", "<b_column>"])

    # Utiliser le tableau pour alimenter différents graphiques personnalisés
    histogram = wandb.plot.histogram(table, value='<b_column>', title='Histogram')

    # Enregistrer les tableaux personnalisés, qui apparaîtront dans les graphiques personnalisables dans l'interface utilisateur
    run.log({'histogram_1': histogram})

"""Initialise un run W&B et journalise les hyperparamètres."""
import wandb

config = {
    "learning_rate": 0.01,
    "batch_size": 32,
    "optimizer": "adam",
}

with wandb.init(project="<project>", config=config) as run:
    # Le code d'entraînement et de journalisation va ici
    pass

"""
Enregistrez un graphique en courbes dans W&B. 

Remplacez :
- les valeurs entre chevrons par les vôtres
- [[1, 2], [2, 3]] dans wandb.Table(data=) par votre propre tableau de valeurs 2D orienté par lignes à tracer

Passez un tableau de valeurs 2D orienté par lignes à data (wandb.Table(data=)), avec
les noms de colonnes spécifiés dans le paramètre `columns`.

Les noms de colonnes doivent correspondre aux paramètres x et y de la fonction de tracé `wandb.plot.line()`.
"""
import wandb

# Démarrer un nouveau run
with wandb.init(entity="<entity>", project="<project>") as run:
        
    # Créer un tableau avec les colonnes à tracer
    table = wandb.Table(data=[[1, 2], [2, 3]], columns=["<column_a>", "<column_b>"])

    # Utiliser le tableau pour remplir différents graphiques personnalisés
    line_plot = wandb.plot.line(table, x='<column_a>', y='<column_b>', title='<title>')
    
    # Enregistrer les tableaux personnalisés, qui apparaîtront dans les graphiques personnalisables de l'interface utilisateur
    run.log({'<line_plot>': line_plot})

"""Initialise un run W&B et journalise une métrique."""
import wandb

with wandb.init(project="<project>") as run:
    # Le code d'entraînement et de journalisation va ici

    # Exemple de journalisation d'une métrique
    run.log({"accuracy": 0.95})

"""
Enregistrez un nuage de points dans W&B. 

Remplacez :
- les valeurs entre chevrons par les vôtres
- [[1, 2], [2, 3]] dans wandb.Table(data=) par votre propre tableau de valeurs 2D orienté par lignes à tracer

Passez un tableau de valeurs 2D orienté par lignes à data (wandb.Table(data=)), avec
les noms de colonnes spécifiés dans le paramètre `columns`.

Les noms de colonnes doivent correspondre aux paramètres x et y de la fonction de tracé `wandb.plot.scatter()`.
"""
import wandb

# Démarrer un nouveau run
with wandb.init(entity="<entity>", project="<project>") as run:
        
    # Créer un tableau avec les colonnes à tracer
    table = wandb.Table(data=[[1, 2], [2, 3]], columns=["<a_column>", "<b_column>"])

    # Utiliser le tableau pour alimenter différents graphiques personnalisés
    scatter = wandb.plot.scatter(table, x='<a_column>', y='<b_column>', title='<title>')

    # Enregistrer des tableaux personnalisés, qui apparaîtront dans des graphiques personnalisables dans l'interface utilisateur
    run.log({'scatter_1': scatter})

"""
Enregistrer explicitement une métrique de synthèse dans W&B.
"""
import wandb
import random 

with wandb.init(project="<project>") as run:
    # Enregistrer une métrique de synthèse personnalisée avec une valeur entière aléatoire entre 1 et 10
    run.summary["<metric_name>"] = random.randint(1, 10)

"""
Enregistrer un tableau dans W&B.

Remplacer : 
- les valeurs entre chevrons par les vôtres
- [[1, 2], [2, 3]] dans wandb.Table(data=) par votre propre tableau de valeurs 2D orienté lignes à enregistrer
"""
import wandb

# Créer un objet tableau avec deux colonnes et deux lignes de données
my_table = wandb.Table(
    columns=["<a_column>", "<b_column>"],
    data=[[1, 2], [2, 3]],
    log_mode="<log_mode>"
    )

# Démarrer un nouveau run
with wandb.init(entity="<entity>", project="<project>") as run:
    # Enregistrer le tableau dans W&B
    run.log({"<table_name>": my_table})