実験管理

• 1: 実験を作成する
• 2: 実験を設定する
• 3: プロジェクト
• 4: 実験管理の結果を見る
• 5: runs とは何ですか？
• 5.1: run をフィルタリングし検索する
• 5.2: run をフォークする
• 5.3: run を移動する
• 5.4: run を巻き戻す
• 5.5: run を再開
• 5.6: run を実験にまとめる
• 5.7: runs にタグでラベルを追加する
• 5.8: アラートを送信する
• 6: Jupyter ノートブックをトラッキングする
• 7: ログ オブジェクト と メディア
• 7.1: メディアとオブジェクトをログする
• 7.2: モデルをログする
• 7.3: ログ テーブル
• 7.4: ログサマリーメトリクス
• 7.5: ログ軸をカスタマイズする
• 7.6: 実験からプロットを作成して追跡する
• 7.7: 実験管理で CSV ファイルを追跡する
• 7.8: 分散トレーニング実験をログする
• 8: 実験を再現する
• 9: 実験管理の制限とパフォーマンス
• 10: データのインポートとエクスポート
• 11: 環境変数

Try in Colab Try in W&B

数行のコードで機械学習実験を追跡します。その後、インタラクティブなダッシュボードで結果をレビューしたり、Public APIを使用してプログラムからアクセスできるようにPythonにデータをエクスポートすることができます。

人気のあるフレームワークを使用している場合は、W&Bのインテグレーションを活用してください。PyTorch、Keras、またはScikitのようなフレームワークがあります。インテグレーションの完全なリストや、W&Bをコードに追加する方法については、インテグレーションガイドをご覧ください。

上の画像は、複数のRunsでメトリクスを確認および比較できるダッシュボードの例を示しています。

仕組み

数行のコードで機械学習実験を追跡します:

1. W&B Runを作成します。
2. 学習率やモデルタイプなどのハイパーパラメーターを辞書として設定（run.config）に保存します。
3. トレーニングループ中に正確性や損失などのメトリクスをログ（run.log()）します。
4. モデルの重みや予測のテーブルのようなRunの出力を保存します。

以下のコードは、一般的なW&B実験管理ワークフローを示しています:

# Run を開始します。
#
# このブロックから出ると、ログデータのアップロードが完了するのを待ちます。
# 例外が発生した場合、Run は失敗としてマークされます。
with wandb.init(entity="", project="my-project-name") as run:
  # モード入力とハイパーパラメーターを保存します。
  run.config.learning_rate = 0.01

  # 実験コードを実行します。
  for epoch in range(num_epochs):
    # トレーニングをします...

    # モデルのパフォーマンスを可視化するためのメトリクスを時間と共にログします。
    run.log({"loss": loss})

  # モデルの出力をアーティファクトとしてアップロードします。
  run.log_artifact(model)

始めましょう

あなたのユースケースに応じて、W&B Experimentsの開始に役立つ次のリソースを探索してください:

• W&Bクイックスタートを読んで、W&B Python SDKコマンドを使用してデータセットアーティファクトを作成、追跡、および利用するためのステップバイステップの概要を確認してください。
• このチャプターを探索して、以下を学びましょう:
  • 実験を作成する
  • 実験を設定する
  • 実験からデータをログする
  • 実験から結果を確認する
• W&B APIリファレンスガイド内のW&B Pythonライブラリを探索してください。

ベストプラクティスとヒント

実験とログのベストプラクティスとヒントについては、ベストプラクティス： 実験とログをご覧ください。

1 - 実験を作成する

W&B Python SDKを使用して、機械学習実験をトラックします。その後、インタラクティブなダッシュボードで結果を確認するか、データをPythonにエクスポートしてプログラムでアクセスできます（W&B Public APIを参照）。

このガイドでは、W&Bのビルディングブロックを使用してW&B Experimentを作成する方法を説明します。

W&B Experimentの作成方法

W&B Experimentを次の4つのステップで作成します：

1. W&B Runを初期化
2. ハイパーパラメータの辞書をキャプチャ
3. トレーニングループ内でメトリクスをログ
4. アーティファクトをW&Bにログ

W&B Runを初期化

wandb.init()を使用してW&B Runを作成します。

以下のスニペットは、“cat-classification”という名前のW&Bプロジェクトで、“My first experiment”という説明を持つrunを作成し、これを識別するのに役立てます。タグ“baseline”と“paper1”は、このrunが将来的な論文の出版を意図したベースライン実験であることを思い出すために含まれています。

import wandb

with wandb.init(
    project="cat-classification",
    notes="My first experiment",
    tags=["baseline", "paper1"],
) as run:
    ...

wandb.init()は、Runオブジェクトを返します。

ハイパーパラメータの辞書をキャプチャ

学習率やモデルタイプといったハイパーパラメータの辞書を保存します。設定でキャプチャしたモデル設定は、後で結果の整理やクエリに役立ちます。

with wandb.init(
    ...,
    config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
    ...

実験を設定する方法の詳細については、Configure Experimentsを参照してください。

トレーニングループ内でメトリクスをログ

run.log()を呼び出して、精度や損失といった各トレーニングステップに関するメトリクスをログします。

model, dataloader = get_model(), get_data()

for epoch in range(run.config.epochs):
    for batch in dataloader:
        loss, accuracy = model.training_step()
        run.log({"accuracy": accuracy, "loss": loss})

W&Bでログできるさまざまなデータタイプの詳細については、Log Data During Experimentsを参照してください。

アーティファクトをW&Bにログ

オプションでW&Bアーティファクトをログします。アーティファクトは、データセットやモデルのバージョン管理を容易にします。

# 任意のファイルまたはディレクトリを保存できます。この例では、モデルがONNXファイルを出力するsave()メソッドを持つと仮定しています。
model.save("path_to_model.onnx")
run.log_artifact("path_to_model.onnx", name="trained-model", type="model")

ArtifactsやRegistryでのモデルのバージョン管理について詳しく学んでください。

すべてをまとめる

前述のコードスニペットを使った完全なスクリプトは以下の通りです：

import wandb

with wandb.init(
    project="cat-classification",
    notes="",
    tags=["baseline", "paper1"],
    # runのハイパーパラメータを記録
    config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
    # モデルとデータをセットアップ
    model, dataloader = get_model(), get_data()

    # モデルのパフォーマンスを可視化するためにメトリクスをログしながらトレーニングを実行
    for epoch in range(run.config["epochs"]):
        for batch in dataloader:
            loss, accuracy = model.training_step()
            run.log({"accuracy": accuracy, "loss": loss})

    # 訓練済みモデルをアーティファクトとしてアップロード
    model.save("path_to_model.onnx")
    run.log_artifact("path_to_model.onnx", name="trained-model", type="model")

次のステップ：実験を可視化

W&Bダッシュボードを使用して、機械学習モデルの結果を整理し可視化する中央の場所として利用します。parallel coordinates plots、parameter importance analyzes、およびその他のようなリッチでインタラクティブなグラフを数クリックで構築します。

実験や特定runの表示方法についての詳細は、Visualize results from experimentsを参照してください。

ベストプラクティス

以下は、実験を作成する際に考慮すべきいくつかのガイドラインです：

1. Runを終了させる: wandb.init()をwith文で使用して、コードが完了したときや例外が発生したときにrunを自動的に終了させます。

   • Jupyterノートブックでは、Runオブジェクトを自分で管理する方が便利な場合があります。この場合、Runオブジェクトでfinish()を明示的に呼び出して完了をマークできます：

     # ノートブックセル内で：
     run = wandb.init()
     
     # 別のセルで：
     run.finish()
     

2. Config: ハイパーパラメータ、アーキテクチャー、データセット、およびモデルの再現に使用したい他のすべてのものをトラックします。これらは列に表示され、アプリ内で動的にrunをグループ化、並べ替え、およびフィルタリングするためにconfig列を使用します。
3. プロジェクト: プロジェクトは比較可能な一連の実験です。各プロジェクトは専用のダッシュボードページを持ち、異なるモデルバージョンを比較するrunの異なるグループを簡単にオンオフできます。
4. ノート: スクリプトから直接クイックコミットメッセージを設定します。ノートを編集し、W&Bアプリのrunのオーバービューセクションでアクセスします。
5. タグ: ベースラインrunとお気に入りのrunを識別します。タグを使用してrunをフィルタリングできます。タグは後で、プロジェクトのダッシュボードのオーバービューセクションで編集できます。
6. 実験を比較するために複数のrunセットを作成: 実験を比較するときは、メトリクスを比較しやすくするために複数のrunセットを作成します。runセットを同じグラフまたは一連のグラフでオンオフできます。

以下のコードスニペットは、上記のベストプラクティスを使用してW&B Experimentを定義する方法を示しています：

import wandb

config = {
    "learning_rate": 0.01,
    "momentum": 0.2,
    "architecture": "CNN",
    "dataset_id": "cats-0192",
}

with wandb.init(
    project="detect-cats",
    notes="tweak baseline",
    tags=["baseline", "paper1"],
    config=config,
) as run:
    ...

W&B Experimentを定義する際に利用可能なパラメータの詳細については、wandb.init APIドキュメントをAPIリファレンスガイドで参照してください。

2 - 実験を設定する

run の config プロパティを使用して、トレーニング設定を保存します:

• ハイパーパラメーター
• データセット名やモデルタイプなどの入力設定
• 実験のためのその他の独立変数

run.config プロパティを使用すると、実験を簡単に分析し、将来的に作業を再現できます。 W&B アプリで設定値ごとにグループ化し、さまざまな W&B Run の設定を比較し、各トレーニング設定が出力にどのように影響するかを評価できます。config プロパティは、複数の辞書のようなオブジェクトから構成できる辞書のようなオブジェクトです。

実験の設定を行う

設定は通常、トレーニングスクリプトの最初に定義されます。ただし、機械学習ワークフローは異なる場合があるため、トレーニングスクリプトの最初に設定を定義する必要はありません。

設定変数名にはピリオド (.) の代わりにダッシュ (-) またはアンダースコア (_) を使用してください。

スクリプトが run.config キーをルート以下でアクセスする場合は、属性アクセス構文 config.key.value の代わりに、辞書アクセス構文 ["key"]["value"] を使用してください。

以下のセクションでは、実験の設定を定義する一般的なシナリオをいくつか示します。

初期化時に設定を行う

wandb.init() API を呼び出して、バックグラウンドプロセスを生成し、W&B Run としてデータを同期してログに記録する際に、スクリプトの最初に辞書を渡します。

次に示すコードスニペットは、設定値を持つ Python の辞書を定義し、その辞書を引数として W&B Run を初期化する方法を示しています。

import wandb

# 設定辞書オブジェクトを定義する
config = {
    "hidden_layer_sizes": [32, 64],
    "kernel_sizes": [3],
    "activation": "ReLU",
    "pool_sizes": [2],
    "dropout": 0.5,
    "num_classes": 10,
}

# W&B を初期化する際に設定辞書を渡す
with wandb.init(project="config_example", config=config) as run:
    ...

ネストされた辞書を config として渡す場合、W&B はドットを使用して名前をフラットにします。

Python の他の辞書にアクセスする方法と同様に、辞書から値にアクセスすることができます:

# インデックス値としてキーを使用して値にアクセスする
hidden_layer_sizes = run.config["hidden_layer_sizes"]
kernel_sizes = run.config["kernel_sizes"]
activation = run.config["activation"]

# Python の辞書 get() メソッド
hidden_layer_sizes = run.config.get("hidden_layer_sizes")
kernel_sizes = run.config.get("kernel_sizes")
activation = run.config.get("activation")

argparse を使用して設定を行う

argparse オブジェクトで設定を行うことができます。argparse は、引数パーサの短縮形で、Python 3.2 以降の標準ライブラリモジュールであり、コマンドライン引数の柔軟性と強力さを活かしたスクリプトの記述を容易にします。

コマンドラインから起動されるスクリプトからの結果を追跡するのに便利です。

次の Python スクリプトは、実験設定を定義および設定するためのパーサーオブジェクトを定義する方法を示しています。train_one_epoch および evaluate_one_epoch 関数は、このデモの目的でトレーニングループをシミュレートするために提供されています:

# config_experiment.py
import argparse
import random

import numpy as np
import wandb


# トレーニングと評価デモのコード
def train_one_epoch(epoch, lr, bs):
    acc = 0.25 + ((epoch / 30) + (random.random() / 10))
    loss = 0.2 + (1 - ((epoch - 1) / 10 + random.random() / 5))
    return acc, loss


def evaluate_one_epoch(epoch):
    acc = 0.1 + ((epoch / 20) + (random.random() / 10))
    loss = 0.25 + (1 - ((epoch - 1) / 10 + random.random() / 6))
    return acc, loss


def main(args):
    # W&B Run を開始する
    with wandb.init(project="config_example", config=args) as run:
        # 設定辞書から値をアクセスして、
        # 可読性のために変数に格納する
        lr = run.config["learning_rate"]
        bs = run.config["batch_size"]
        epochs = run.config["epochs"]

        # トレーニングをシミュレートし、値を W&B にログする
        for epoch in np.arange(1, epochs):
            train_acc, train_loss = train_one_epoch(epoch, lr, bs)
            val_acc, val_loss = evaluate_one_epoch(epoch)

            run.log(
                {
                    "epoch": epoch,
                    "train_acc": train_acc,
                    "train_loss": train_loss,
                    "val_acc": val_acc,
                    "val_loss": val_loss,
                }
            )


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )

    parser.add_argument("-b", "--batch_size", type=int, default=32, help="バッチサイズ")
    parser.add_argument(
        "-e", "--epochs", type=int, default=50, help="トレーニングエポックの数"
    )
    parser.add_argument(
        "-lr", "--learning_rate", type=int, default=0.001, help="学習率"
    )

    args = parser.parse_args()
    main(args)

スクリプト全体で設定を行う

スクリプト全体で、設定オブジェクトにさらにパラメータを追加できます。次に示すコードスニペットでは、設定オブジェクトに新しいキーと値のペアを追加する方法を示しています:

import wandb

# 設定辞書オブジェクトを定義する
config = {
    "hidden_layer_sizes": [32, 64],
    "kernel_sizes": [3],
    "activation": "ReLU",
    "pool_sizes": [2],
    "dropout": 0.5,
    "num_classes": 10,
}

# W&B を初期化する際に設定辞書を渡す
with wandb.init(project="config_example", config=config) as run:
    # W&B を初期化した後に設定を更新する
    run.config["dropout"] = 0.2
    run.config.epochs = 4
    run.config["batch_size"] = 32

複数の値を一度に更新できます:

run.config.update({"lr": 0.1, "channels": 16})

Run終了後に設定を行う

W&B Public APIを使用して、完了済みの run の設定を更新できます。

API に対して、エンティティ、プロジェクト名、および run の ID を提供する必要があります。これらの詳細は Run オブジェクトや W&B App UI で確認できます:

with wandb.init() as run:
    ...

# Run オブジェクトから以下の値を見つけます。
# これが現在のスクリプトまたはノートブックから初期化された場合、または W&B アプリUIからそれらをコピーできます。
username = run.entity
project = run.project
run_id = run.id

# api.run() は wandb.init() と異なるタイプのオブジェクトを返すことに注意してください。
api = wandb.Api()
api_run = api.run(f"{username}/{project}/{run_id}")
api_run.config["bar"] = 32
api_run.update()

absl.FLAGS

absl flags を渡すこともできます。

flags.DEFINE_string("model", None, "model to run")  # name, default, help

run.config.update(flags.FLAGS)  # absl flags を設定に追加します

ファイルベースの設定

config-defaults.yaml という名前のファイルを run スクリプトと同じディレクトリーに配置すると、run はファイルに定義されたキーと値のペアを自動的に取得し、それを run.config に渡します。

以下のコードスニペットは、サンプルの config-defaults.yaml YAML ファイルを示しています:

batch_size:
  desc: サイズごとのミニバッチ
  value: 32

config-defaults.yaml から自動的に読み込まれたデフォルト値を、新しい値を wandb.init の config 引数で設定して上書きできます。たとえば:

import wandb

# 独自の値を渡して config-defaults.yaml を上書きします
with wandb.init(config={"epochs": 200, "batch_size": 64}) as run:
    ...

config-defaults.yaml 以外の設定ファイルを読み込むには、--configs command-line 引数を使用してファイルのパスを指定します:

python train.py --configs other-config.yaml

ファイルベースの設定のユースケースの例

Run のメタデータを含む YAML ファイルがあり、Python スクリプトでハイパーパラメーターの辞書を持っているとします。それらの両方をネストされた config オブジェクトに保存できます:

hyperparameter_defaults = dict(
    dropout=0.5,
    batch_size=100,
    learning_rate=0.001,
)

config_dictionary = dict(
    yaml=my_yaml_file,
    params=hyperparameter_defaults,
)

with wandb.init(config=config_dictionary) as run:
    ...

TensorFlow v1 フラグ

TensorFlow のフラグを wandb.config オブジェクトに直接渡すことができます。

with wandb.init() as run:
    run.config.epochs = 4

    flags = tf.app.flags
    flags.DEFINE_string("data_dir", "/tmp/data")
    flags.DEFINE_integer("batch_size", 128, "バッチサイズ")
    run.config.update(flags.FLAGS)  # TensorFlow のフラグを設定に追加します

3 - プロジェクト

A プロジェクト は、結果の可視化、実験の比較、アーティファクトの閲覧とダウンロード、オートメーションの作成などを行うための中央の場所です。

各プロジェクトには、サイドバーからアクセスできる次の項目が含まれています:

• Overview: プロジェクトのスナップショット
• Workspace: 個人の可視化サンドボックス
• Runs: プロジェクト内のすべての run を一覧表示するテーブル
• Automations: プロジェクトで設定されたオートメーション
• Sweeps: 自動探索と最適化
• Reports: メモ、run、およびグラフの保存されたスナップショット
• Artifacts: すべての run およびその run に関連するアーティファクトを含む

Overview タブ

• Project name: プロジェクトの名前。W&B は、指定したプロジェクトフィールド名で run を初期化するときにプロジェクトを作成します。右上隅の Edit ボタンを選択することで、いつでもプロジェクト名を変更できます。
• Description: プロジェクトの説明。
• Project visibility: プロジェクトの公開範囲。それにアクセスできる人を決定する公開設定です。詳細はプロジェクトの公開範囲を参照してください。
• Last active: このプロジェクトにデータが最後にログ記録された日時のタイムスタンプ
• Owner: このプロジェクトを所有するエンティティ
• Contributors: このプロジェクトに貢献するユーザーの数
• Total runs: このプロジェクトの総 run 数
• Total compute: プロジェクト内のすべての run 時間を合計して得られるトータル
• Undelete runs: ドロップダウンメニューをクリックし、「Undelete all runs」をクリックしてプロジェクト内の削除された run を復元します。
• Delete project: 右上隅のドットメニューをクリックしてプロジェクトを削除

ライブ例を見る

Workspace タブ

プロジェクトのワークスペースは、実験を比較するための個人的なサンドボックスを提供します。プロジェクトを使用して、比較できるモデルを整理し、異なるアーキテクチャー、ハイパーパラメーター、データセット、プロセッシングなどで同じ問題に取り組みます。

Runs Sidebar: プロジェクト内のすべての run のリスト。

• Dot menu: サイドバーの行にカーソルを合わせると、左側にメニューが表示されます。このメニューを使用して、run の名前を変更、run の削除、または active run の停止を行います。
• Visibility icon: グラフで run をオンまたはオフにするために目のアイコンをクリックします。
• Color: run の色を私たちのプリセットの1つまたはカスタムカラーに変更します。
• Search: 名前で run を検索します。これにより、プロットで表示される run もフィルタリングされます。
• Filter: サイドバーフィルターを使用して、表示される run のセットを絞り込みます。
• Group: 設定した列を選択して run を動的にグループ化します。例えば、アーキテクチャーでグループ化することができます。グループ化すると、プロットに平均値に沿った線が表示され、グラフ上のポイントの分散の地域を示す影が表示されます。
• Sort: 最小の損失や最大の精度を持つ run など、value で run をソートします。ソートは、どの run がグラフに表示されるかに影響します。
• Expand button: サイドバーを完全なテーブルに拡張します。
• Run count: 上部のかっこ内の数字は、プロジェクト内のすべての run 数です。数字 (N visualized) は、目のアイコンがオンになっていて、各プロットで可視化可能な run 数です。以下の例では、グラフは183 runのうち最初の10 runのみを表示しています。表示される run の最大数を増やすには、グラフを編集します。

Runs タブで列をピン止め、非表示、または順序を変更すると、Runs サイドバーにもこれらのカスタマイズが反映されます。

Panels layout: このスクラッチスペースを使用して、結果を探索し、チャートを追加および削除し、異なるメトリクスに基づいてモデルのバージョンを比較します。

ライブ例を見る

Add a section of panels

セクションのドロップダウンメニューをクリックし、「Add section」をクリックして、セクションを作成します。セクションの名前を変更したり、ドラッグして順序を再編成したり、セクションを展開または折りたたむことができます。

各セクションには右上隅にオプションがあります:

• Switch to custom layout: カスタムレイアウトでは、個々のパネルのサイズを変更できます。
• Switch to standard layout: 標準レイアウトでは、セクション内のすべてのパネルのサイズを一括で変更でき、ページネーションが利用できます。
• Add section: ドロップダウンメニューから上または下にセクションを追加するか、ページの下部のボタンをクリックして新しいセクションを追加します。
• Rename section: セクションのタイトルを変更します。
• Export section to report: このパネルのセクションを新しいレポートに保存します。
• Delete section: セクション全体とすべてのチャートを削除します。これは、ワークスペースバーのページ下部にあるアンドゥボタンで取り消すことができます。
• Add panel: プラスボタンをクリックしてセクションにパネルを追加します。

Move panels between sections

ドラッグアンドドロップしてセクションに整理します。また、パネルの右上隅にある「Move」ボタンをクリックしてセクションを選択し、パネルを移動します。

Resize panels

• Standard layout: すべてのパネルは同じサイズに保たれ、ページがあります。セクションの右下隅をクリックアンドドラッグして、セクションのサイズを変更します。
• Custom layout: 各パネルは個別にサイズが設定されており、ページはありません。

Search for metrics

ワークスペースの検索ボックスを使用してパネルを絞り込みます。この検索はパネルのタイトルに一致し、デフォルトでは表示されているメトリクスの名前となります。

Runs タブ

Runs タブを使用して、run をフィルタリング、グループ化、およびソートします。

次のタブには、Runs タブで実行できる一般的な操作がいくつか示されています。

• Customize columns
• Sort
• Filter
• Group

Runs タブは、プロジェクト内の run の詳細を表示します。デフォルトで多数の列が表示されます。

• すべての列を表示するには、ページを水平にスクロールします。
• 列の順序を変更するには、列を左右にドラッグします。
• 列をピン止めするには、列名にカーソルを合わせて、表示されるアクションメニュー ... をクリックし、次に Pin column をクリックします。ピン止めされた列は、ページの左側に、Name 列の後に表示されます。ピン止めされた列を取り除くには、Unpin column を選択します。
• 列を非表示にするには、列名にカーソルを合わせて、表示されるアクションメニュー ... をクリックし、次に Hide column をクリックします。現在非表示のすべての列を表示するには、Columns をクリックします。
• 複数の列を一度に表示、非表示、ピン止め、およびピン解除するには、Columns をクリックします。
  • 非表示の列の名前をクリックして表示します。
  • 表示列の名前をクリックして非表示にします。
  • 表示列の横のピンアイコンをクリックしてピン止めします。

Runs タブをカスタマイズすると、そのカスタマイズはWorkspace タブの Runs セレクタにも反映されます。

指定した列の値でテーブル内のすべての行をソートします。

1. 列タイトルにマウスをホバーします。ケバブメニューが表示されます（三つの垂直ドット）。
2. ケバブメニュー（三つの垂直ドット）を選択します。
3. Sort Asc または Sort Desc を選択して、行を昇順または降順にソートします。

上の画像は、val_acc というテーブル列のソートオプションを表示する方法を示しています。

ダッシュボードの左上の Filter ボタンを使って、式に基づいてすべての行をフィルタリングします。

Add filter を選択して、行に1つ以上のフィルターを追加します。3つのドロップダウンメニューが表示され、左から右にかけて、フィルターのタイプは次のようになります: 列名、演算子、および値

	列名	バイナリ関係	値
許可される値	String	=, ≠, ≤, ≥, IN, NOT IN,	整数, 浮動小数点数, 文字列, タイムスタンプ, null

式エディタは、オートコンプリートを使用して、列名と論理述語構造などの用語ごとのオプションのリストを表示します。複数の論理述部を使用して「ands」または「or」で式を組み合わせることができます（場合によっては括弧を使用します）。

上の画像は、`val_loss` 列に基づいたフィルターを示しています。このフィルターは、1以下の検証損失を持つ run を表示します。

特定の列の値で Group by ボタンを使い、すべての行をグループ化します。

デフォルトでは、これにより他の数値列がヒストグラムに変わり、グループ全体のその列の値の分布を示します。グループ化は、データ内の高レベルのパターンを理解するのに便利です。

Reports タブ

結果のスナップショットを一か所で確認し、チームと学びを共有します。

Sweeps タブ

スイープをプロジェクトから新たに開始します。

Artifacts タブ

プロジェクトに関連付けられたすべてのArtifactsをトレーニングデータセットや ファインチューンされたモデルからメトリクスやメディアのテーブルまで表示します。

Overview パネル

概要パネルでは、アーティファクトの名前やバージョン、変更を検出し重複を防止するために使用されるハッシュダイジェスト、作成日、およびエイリアスなど、アーティファクトに関するさまざまな高レベル情報を見つけることができます。ここでエイリアスを追加または削除し、バージョンおよびアーティファクト全体に対してメモを取ることができます。

Metadata パネル

メタデータパネルは、アーティファクトが構築されたときに提供されるメタデータへのアクセスを提供します。このメタデータには、アーティファクトを再構築するために必要な設定引数、詳細情報を見つけるためのURL、またはアーティファクトをログする際に生成されたメトリクスが含まれている場合があります。さらに、アーティファクトを生成する run の設定や、アーティファクトをログする際の履歴メトリクスを見ることができます。

Usage パネル

Usage パネルは、ウェブアプリの外部で、例えばローカルマシン上で使用するためにアーティファクトをダウンロードするためのコードスニペットを提供します。このセクションはまた、アーティファクトを出力した run 及びアーティファクトを入力として使用する run へのリンクも示しています。

Files パネル

ファイルパネルは、アーティファクトに関連付けられたファイルとフォルダを一覧表示します。W&B は特定のファイルを run 用に自動的にアップロードします。例えば、requirements.txt は run が使用した各ライブラリのバージョンを示し、wandb-metadata.json および wandb-summary.json は run に関する情報を含みます。他のファイルもアーティファクトやメディアなど、run の設定に応じてアップロードされる場合があります。このファイルツリーをナビゲートし、W&B ウェブアプリで直接内容を確認することができます。

Artifacts に関連付けられたテーブルは、このコンテキストでは特にリッチでインタラクティブです。Artifacts で Tables を使用する方法についての詳細はこちらから学べます。

Lineage パネル

リネージパネルは、プロジェクトに関連付けられたすべてのアーティファクトとそれらをお互いに接続する run を表示します。run タイプはブロックとして、アーティファクトは円として表示され、与えられたタイプの run が与えられたタイプのアーティファクトを消費または生成するときに矢印で示されます。左側の列で選択された特定のアーティファクトのタイプが強調表示されます。

個々のアーティファクトバージョンとそれらを接続する特定の run を表示するには、爆発切り替えをクリックしてください。

Action History Audit タブ

アクションヒストリー監査タブは、コレクションのすべてのエイリアスアクションとメンバーシップの変更を示しており、リソースの進化全体を監査できます。

Versions タブ

バージョン タブは、アーティファクトのすべてのバージョンと、バージョンがログ記録された時点での Run History の各数値のカラムを示しています。これにより、パフォーマンスを比較し、興味のあるバージョンを迅速に特定することができます。

プロジェクトにスターを付ける

プロジェクトにスターを付けると、そのプロジェクトを重要としてマークします。あなたとあなたのチームがスター付きで重要としてマークしたプロジェクトは、組織のホームページの上部に表示されます。

たとえば、次の画像では、zoo_experiment と registry_demo の 2 つのプロジェクトが重要としてマークされています。これらのプロジェクトは、組織のホームページの上部の スター付きプロジェクト セクション内に表示されています。

プロジェクトを重要としてマークする方法は2つあります: プロジェクトのオーバービュータブ内またはチームのプロファイルページ内です。

• Project overview
• Team profile

1. W&B App の https://wandb.ai/<team>/<project-name> で W&B プロジェクトに移動します。
2. プロジェクトサイドバーから Overview タブを選択します。
3. 右上隅の Edit ボタンの横にある星アイコンを選択します。

1. チームのプロファイルページにある https://wandb.ai/<team>/projects に移動します。
2. Projects タブを選択します。
3. スターを付けたいプロジェクトの横にマウスをホバーし、表示された星アイコンをクリックします。

たとえば、次の画像は “Compare_Zoo_Models” プロジェクトの横にある星アイコンを示しています。

組織名を左上隅のアプリ内でクリックし、プロジェクトが組織のランディングページに表示されることを確認します。

プロジェクトを削除する

プロジェクトを削除するには、オーバービュータブの右の三点リーダーをクリックします。

プロジェクトが空の場合は、右上のドロップダウンメニューをクリックして Delete project を選択し、削除できます。

プロジェクトにメモを追加する

プロジェクトにメモを追加するには、説明オーバービューまたはワークスペース内のマークダウンパネルとして行います。

プロジェクトに説明オーバービューを追加

ページに追加した説明は、プロファイルの Overview タブに表示されます。

1. W&B プロジェクトに移動
2. プロジェクトサイドバーから Overview タブを選択
3. 右上隅の Edit を選択
4. Description フィールドにメモを追加
5. Save ボタンを選択

ワークスペースに run のメモを追加

1. W&B プロジェクトに移動
2. プロジェクトサイドバーから Workspace タブを選択
3. 右上のコーナーから Add panels ボタンを選択
4. 表示されるモーダルから TEXT AND CODE ドロップダウンを選択
5. Markdown を選択
6. ワークスペース内に表示されるマークダウンパネルにメモを追加します。

4 - 実験管理の結果を見る

W&B ワークスペースは、チャートをカスタマイズしモデル結果を探索するための個人のサンドボックスです。W&B ワークスペースは テーブル と パネルセクション で構成されています:

• Tables: プロジェクトに記録されたすべてのRunがプロジェクトのテーブルに一覧表示されます。Runをオンオフしたり、色を変更したり、テーブルを拡張して各Runのノート、設定、およびサマリーメトリクスを表示することができます。
• Panel sections: 1つ以上の パネル を含むセクションです。新しいパネルを作成し、整理し、ワークスペースのスナップショットを保存するためにReportsにエクスポートすることができます。

Workspaceの種類

主に2つのWorkspaceカテゴリがあります: 個人用ワークスペース と 保存されたビュー です。

• 個人用ワークスペース: モデルとデータの可視化の詳細な分析のためのカスタマイズ可能なワークスペースです。ワークスペースの所有者のみが編集し、変更を保存できます。チームメイトは個人用ワークスペースを閲覧できますが、他の人の個人用ワークスペースには変更を加えることはできません。
• 保存されたビュー: 保存されたビューは、ワークスペースの協力的なスナップショットです。チームの誰もが保存されたワークスペースビューを閲覧、編集、保存することができます。保存されたワークスペースビューを使用して、実験、Runなどをレビューおよび議論します。

次の画像は、Cécile-parkerのチームメイトによって作成された複数の個人用ワークスペースを示しています。このプロジェクトには保存されたビューがありません:

保存されたワークスペースビュー

チームのコラボレーションを向上させるために、カスタマイズされたワークスペースビューを作成します。保存されたビューを作成して、チャートとデータの好みのセットアップを整理します。

新しい保存されたワークスペースビューを作成する

1. 個人用ワークスペースまたは保存されたビューに移動します。
2. ワークスペースを編集します。
3. ワークスペースの右上隅にある三つポチメニュー（三本の横線）をクリックし、新しいビューとして保存 をクリックします。

新しい保存されたビューはワークスペースナビゲーションメニューに表示されます。

保存されたワークスペースビューを更新する

保存された変更は、保存されたビューの以前の状態を上書きします。保存されていない変更は保持されません。W&Bで保存されたワークスペースビューを更新するには:

1. 保存されたビューに移動します。
2. ワークスペース内のチャートとデータに必要な変更を加えます。
3. 保存 ボタンをクリックして変更を確認します。

保存されたワークスペースビューを削除する

不要になった保存されたビューを削除します。

1. 削除したい保存済みビューに移動します。
2. ビューの右上隅にある三本の横線（…）を選択します。
3. ビューを削除 を選択します。
4. 削除を確認してワークスペースメニューからビューを削除します。

ワークスペースビューを共有する

ワークスペースのURLを直接共有することで、カスタマイズしたワークスペースをチームと共有します。ワークスペースプロジェクトにアクセスできるすべてのユーザーが、そのワークスペースの保存されたビューを見ることができます。

ワークスペースをプログラムで作成する

wandb-workspaces は、W&B のワークスペースとレポートをプログラムで操作するためのPythonライブラリです。

wandb-workspaces を使用してワークスペースをプログラムで定義します。wandb-workspaces は、W&B のワークスペースとレポートをプログラムで操作するためのPythonライブラリです。

ワークスペースのプロパティを定義できます、例:

• パネルのレイアウト、色、およびセクションの順序を設定します。
• ワークスペース設定としてデフォルトのX軸、セクションの順序、および折りたたみ状態を設定します。
• セクション内にパネルを追加してカスタマイズし、ワークスペースビューを整理します。
• URLを使用して既存のワークスペースを読み込み、変更します。
• 既存のワークスペースに変更を保存するか、新しいビューとして保存します。
• シンプルな式を使用してRunをプログラムでフィルタリング、グループ化、ソートします。
• 色や表示可否などの設定でRunの外観をカスタマイズします。
• ワークスペース間でビューをコピーして、インテグレーションと再利用を行います。

Workspace API をインストール

wandbに加えて、wandb-workspacesをインストールすることを確認してください:

pip install wandb wandb-workspaces

プログラムでワークスペースビューを定義し保存する

import wandb_workspaces.reports.v2 as wr

workspace = ws.Workspace(entity="your-entity", project="your-project", views=[...])
workspace.save()

既存のビューを編集する

existing_workspace = ws.Workspace.from_url("workspace-url")
existing_workspace.views[0] = ws.View(name="my-new-view", sections=[...])
existing_workspace.save()

ワークスペース 保存されたビュー を別のワークスペースにコピーする

old_workspace = ws.Workspace.from_url("old-workspace-url")
old_workspace_view = old_workspace.views[0]
new_workspace = ws.Workspace(entity="new-entity", project="new-project", views=[old_workspace_view])

new_workspace.save()

包括的なワークスペースAPIの例として、wandb-workspace examples を参照してください。エンドツーエンドのチュートリアルについては、Programmatic Workspaces チュートリアルを参照してください。

5 - runs とは何ですか？

W&B の run とは、W&B によってログ記録された単一の計算単位のことです。W&B の run をプロジェクト全体の原子要素として考えることができます。言い換えれば、各 run とは特定の計算の記録であり、モデルのトレーニング、結果のログ記録、ハイパーパラメータースイープなどを含みます。

run を開始する一般的なパターンには以下が含まれますが、これらに限定されません：

• モデルのトレーニング
• ハイパーパラメーターを変更して新しい実験を行う
• 異なるモデルで新しい機械学習実験を行う
• データやモデルを W&B Artifact としてログ記録する
• W&B Artifact をダウンロードする

W&B はあなたが作成した run を projects に保存します。W&B App UI 上でプロジェクトのワークスペース内の run とそのプロパティを表示できます。また、wandb.Api.Run オブジェクトを使用してプログラムで run のプロパティにアクセスすることも可能です。

run.log でログ記録したものは、その run に記録されます。次のコードスニペットを考えてみてください。

import wandb

run = wandb.init(entity="nico", project="awesome-project")
run.log({"accuracy": 0.9, "loss": 0.1})

最初の行は W&B Python SDK をインポートします。2 行目はエンティティ nico のプロジェクト awesome-project で run を初期化します。3 行目はその run に対するモデルの精度と損失をログ記録します。

ターミナル内で、W&B は次のように返します：

wandb: Syncing run earnest-sunset-1
wandb: ⭐️ View project at https://wandb.ai/nico/awesome-project
wandb: 🚀 View run at https://wandb.ai/nico/awesome-project/runs/1jx1ud12
wandb:                                                                                
wandb: 
wandb: Run history:
wandb: accuracy ▁
wandb:     loss ▁
wandb: 
wandb: Run summary:
wandb: accuracy 0.9
wandb:     loss 0.5
wandb: 
wandb: 🚀 View run earnest-sunset-1 at: https://wandb.ai/nico/awesome-project/runs/1jx1ud12
wandb: ⭐️ View project at: https://wandb.ai/nico/awesome-project
wandb: Synced 6 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)
wandb: Find logs at: ./wandb/run-20241105_111006-1jx1ud12/logs

W&B がターミナルで返す URL は、W&B App UI 上で run のワークスペースにリダイレクトします。ワークスペースで生成されたパネルは単一のポイントに対応していることに注意してください。

単一時点でメトリクスをログ記録することはあまり有用ではないかもしれません。識別モデルのトレーニングの場合、定期的な間隔でメトリクスをログ記録することがより現実的です。以下のコードスニペットを考慮してください：

epochs = 10
lr = 0.01

run = wandb.init(
    entity="nico",
    project="awesome-project",
    config={
        "learning_rate": lr,
        "epochs": epochs,
    },
)

offset = random.random() / 5

# トレーニング run のシミュレーション
for epoch in range(epochs):
    acc = 1 - 2**-epoch - random.random() / (epoch + 1) - offset
    loss = 2**-epoch + random.random() / (epoch + 1) + offset
    print(f"epoch={epoch}, accuracy={acc}, loss={loss}")
    run.log({"accuracy": acc, "loss": loss})

これは次のような出力を返します：

wandb: Syncing run jolly-haze-4
wandb: ⭐️ View project at https://wandb.ai/nico/awesome-project
wandb: 🚀 View run at https://wandb.ai/nico/awesome-project/runs/pdo5110r
lr: 0.01
epoch=0, accuracy=-0.10070974957523078, loss=1.985328507123956
epoch=1, accuracy=0.2884687745057535, loss=0.7374362314407752
epoch=2, accuracy=0.7347387967382066, loss=0.4402409835486663
epoch=3, accuracy=0.7667969248039795, loss=0.26176963846423457
epoch=4, accuracy=0.7446848791003173, loss=0.24808611724405083
epoch=5, accuracy=0.8035095836268268, loss=0.16169791827329466
epoch=6, accuracy=0.861349032371624, loss=0.03432578493587426
epoch=7, accuracy=0.8794926436276016, loss=0.10331872172219471
epoch=8, accuracy=0.9424839917077272, loss=0.07767793473500445
epoch=9, accuracy=0.9584880427028566, loss=0.10531971149250456
wandb: 🚀 View run jolly-haze-4 at: https://wandb.ai/nico/awesome-project/runs/pdo5110r
wandb: Find logs at: wandb/run-20241105_111816-pdo5110r/logs

トレーニングスクリプトは run.log を10回呼び出します。スクリプトが run.log を呼び出すたびに、W&B はそのエポックの精度と損失をログ記録します。前述の出力から W&B が出力する URL を選択すると、その run のワークスペースに直接アクセスできます。

W&B は、シミュレーションしたトレーニングループを jolly-haze-4 という単一の run 内にキャプチャします。これは、スクリプトが wandb.init メソッドを一度だけ呼び出しているためです。

別の例として、スイープの際、W&B はあなたが指定したハイパーパラメーター探索空間を探索します。スイープが作成する各新しいハイパーパラメーターの組み合わせを、一意の run として実装します。

run を初期化する

W&B run は wandb.init() を使用して初期化します。次のコードスニペットは、W&B Python SDK をインポートして run を初期化する方法を示しています。

角括弧 (< >) で囲まれた値をあなた自身の値に置き換えるようにしてください：

import wandb

run = wandb.init(entity="<entity>", project="<project>")

run を初期化すると、W&B は指定したプロジェクトに対して run をログに記録します (wandb.init(project="<project>"))。プロジェクトがまだ存在しない場合、W&B は新しいプロジェクトを作成します。プロジェクトが既に存在する場合、W&B はそのプロジェクトに run を保存します。

W&B の各 run には、run ID という一意の識別子が付与されます。一意の ID を指定することができます し、または W&B がランダムに生成してくれる ことも可能です。

各 run には、人間が読めるrun 名 という一意でない識別子もあります。run の名前を指定することができますし、W&B にランダムに生成させることもできます。

たとえば、次のコードスニペットを考えてみてください：

import wandb

run = wandb.init(entity="wandbee", project="awesome-project")

このコードスニペットは次の出力を生成します：

🚀 View run exalted-darkness-6 at: 
https://wandb.ai/nico/awesome-project/runs/pgbn9y21
Find logs at: wandb/run-20241106_090747-pgbn9y21/logs

前のコードが id 引数を指定しなかったため、W&B は一意の run ID を作成します。ここで、nico は run を記録したエンティティであり、awesome-project は run が記録されるプロジェクトの名前、 exalted-darkness-6 は run の名前、pgbn9y21 は run ID です。

import wandb

run = wandb.init(entity="<entity>", project="<project>")
# トレーニングコード、ログ記録など
run.finish()

各 run には、run の現在のステータスを示す状態があります。可能な run 状態の完全なリストについては Run states を参照してください。

Run states

次の表は、run がとりうる可能な状態を示しています：

Unique run identifiers

Run ID は run のための一意の識別子です。デフォルトでは、新しい run を初期化する際に、W&B はランダムで一意の run ID を生成します。また、run を初期化する際に独自の一意の run ID を指定することもできます。

Autogenerated run IDs

run を初期化する際に run ID を指定しない場合、W&B はランダムな run ID を生成します。run の一意の ID は W&B App UI で確認できます。

1. https://wandb.ai/home の W&B App UI にアクセスします。
2. run を初期化した際に指定した W&B プロジェクトに移動します。
3. プロジェクトのワークスペース内で、 Runs タブを選択します。
4. Overview タブを選択します。

W&B は Run path フィールドに一意の run ID を表示します。run path はチーム名、プロジェクト名、run ID で構成されています。一意の ID は run path の最後の部分です。

たとえば、以下の画像では、一意の run ID は 9mxi1arc です：

Custom run IDs

id 引数をwandb.init メソッドに渡すことで、独自の run ID を指定することができます。

import wandb

run = wandb.init(entity="<project>", project="<project>", id="<run-id>")

run の一意の ID を使用して W&B App UI の run の概要ページに直接移動できます。次のセルは特定の run の URL パスを示しています：

https://wandb.ai/<entity>/<project>/<run-id>

ここで、角括弧 (< >) で囲まれた値は、エンティティ、プロジェクト、および run ID の実際の値のためのプレースホルダーです。

Name your run

run の名前は、人間が読める非一意の識別子です。

デフォルトでは、W&B は新しい run を初期化する際にランダムな run 名を生成します。run の名前はプロジェクトのワークスペース内およびrun の概要ページの上部に表示されます。

run の名前を指定するには、name 引数をwandb.init メソッドに渡します。

import wandb

run = wandb.init(entity="<project>", project="<project>", name="<run-name>")

run にメモを追加

特定の run に追加したメモは、run ページの Overview タブやプロジェクトページの run 一覧表に表示されます。

1. あなたの W&B プロジェクトに移動します。
2. プロジェクトのサイドバーから Workspace タブを選択します。
3. run セレクタからメモを追加したい run を選択します。
4. Overview タブを選択します。
5. Description フィールド隣の鉛筆アイコンを選択して、メモを追加します。

run を停止する

W&B App またはプログラムを使用して run を停止します。

• プログラムによって
• W&B App

1. run を初期化したターミナルまたはコードエディタに移動します。
2. Ctrl+D を押して run を停止します。

たとえば、前述の手順に従うと、ターミナルは次のような状態になるかもしれません：

KeyboardInterrupt
wandb: 🚀 View run legendary-meadow-2 at: https://wandb.ai/nico/history-blaster-4/runs/o8sdbztv
wandb: Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 1 other file(s)
wandb: Find logs at: ./wandb/run-20241106_095857-o8sdbztv/logs

W&B App UI に移動して run がもはやアクティブではないことを確認します：

1. run のログを記録していたプロジェクトに移動します。
2. run の名前を選択します。

停止した run の名前はターミナルまたはコードエディタの出力から見つけることができます。たとえば、前の例では、run の名前は legendary-meadow-2 です。

3. プロジェクトのサイドバーから **Overview** タブを選択します。

State フィールドの隣で、run の状態が running から Killed に変わります。

1. run のログを記録していたプロジェクトに移動します。
2. run セレクタ内で停止したい run を選択します。
3. プロジェクトのサイドバーから Overview タブを選択します。
4. State フィールドの隣の上部ボタンを選択します。

State フィールドの隣で、run の状態が running から Killed に変わります。

State fields を参照し、run の可能な状態の完全なリストを確認してください。

ログ記録された runs を見る

run の状態、run にログ記録されたアーティファクト、run 中に記録されたログファイルなど、特定の run に関する情報を表示します。

特定の run を表示するには：

1. https://wandb.ai/home の W&B App UI に移動します。

2. run を初期化した際に指定した W&B プロジェクトに移動します。

3. プロジェクトのサイドバー内で Workspace タブを選択します。

4. run セレクタ内で表示したい run をクリックするか、部分的な run 名を入力して一致する runs をフィルターします。

   デフォルトでは、長い run 名は読みやすくするために途中で切り詰められます。run 名を最初または最後で切り詰めるには、run リストの上部のアクション ... メニューをクリックし、Run name cropping を最初、途中、または最後で切り取るように設定します。

特定の run の URL パスの形式は次のとおりです：

https://wandb.ai/<team-name>/<project-name>/runs/<run-id>

ここで、角括弧 (< >) で囲まれた値は、チーム名、プロジェクト名、および run ID の実際の値のためのプレースホルダーです。

Overview タブ

プロジェクト内で特定の run 情報を知るために Overview タブを使用してください。

• Author: run を作成した W&B エンティティ。
• Command: run を初期化したコマンド。
• Description: 提供した run の説明。このフィールドは、run を作成する際に説明を指定しないと空になります。W&B App UI または Python SDK を使用して run に説明を追加できます。
• Duration: run が実際に計算を行っている時間またはデータをログ記録している時間。ただし、任意の中断または待機時間は含まれません。
• Git repository: run に関連付けられた git リポジトリ。このフィールドを見るためにはgit を有効にする必要があります。
• Host name: W&B が run を計算する場所。ローカルマシンで run を初期化した場合、マシンの名前が表示されます。
• Name: run の名前。
• OS: run を初期化するオペレーティングシステム。
• Python executable: run を開始するためのコマンド。
• Python version: run を作成する Python バージョンを指定します。
• Run path: entity/project/run-ID 形式で一意の run ID を識別します。
• Runtime: run の開始から終了までの総時間を測定します。run の壁時計時間であり、run が中断したりリソースを待っている間の時間も含まれますが、duration は含みません。
• Start time: run を初期化した時点のタイムスタンプ。
• State: run の状態。
• System hardware: W&B が run を計算するために使用するハードウェア。
• Tags: 文字列のリスト。タグは関連 run を一緒に整理したり、一時的なラベル（例：baseline や production）を適用するのに便利です。
• W&B CLI version: run コマンドをホストしたマシンにインストールされている W&B CLI バージョン。

W&B は概要セクションの下に次の情報を保存します：

• Artifact Outputs: run が生成したアーティファクトの出力。
• Config: wandb.configで保存された設定パラメータのリスト。
• Summary: wandb.log()で保存されたサマリーパラメータのリスト。デフォルトでは、W&B はこの値を最後にログ記録した値に設定します。

こちらでプロジェクトの概要の例を確認できます here。

Workspace タブ

Workspace タブを使用して、生成されたプロットやカスタムプロット、システムメトリクスなどの可視化を表示、検索、グループ化、および配置してください。

こちらでワークスペースの例を確認できます here

Runs タブ

Runs タブを使用して、run をフィルタリング、グループ化、並べ替えます。

Runs タブで実行できる一般的なアクションを以下のタブで示しています。

• カスタム列
• ソート
• フィルター
• グループ

Runs タブには、プロジェクト内の run の詳細が表示されます。デフォルトでは多くの列が表示されます。

• 表示されているすべての列を表示するには、ページを横にスクロールします。
• 列の順序を変更するには、列を左右にドラッグします。
• 列を固定するには、列名の上にカーソルを合わせ、表示されたアクションメニュー ... をクリックしてから Pin column をクリックします。固定された列はページの左側に近い位置に表示されます。固定列を解除するには、Unpin column を選択します。
• 列を非表示にするには、列名の上にカーソルを合わせ、表示されたアクションメニュー ... をクリックしてから Hide column をクリックします。現在非表示のすべての列を表示するには、Columns をクリックします。
• 一度に複数の列を表示、非表示、固定、または固定解除するには、Columns をクリックします。
  • 非表示の列の名前をクリックして表示します。
  • 表示されている列の名前をクリックして非表示にします。
  • 表示された列の横にあるピンアイコンをクリックして固定します。

Runs タブをカスタマイズすると、そのカスタマイズは Workspace タブ の Runs セレクタにも反映されます。

Table のある列の値で全行を並べ替えます。

1. 列タイトルにマウスを合わせます。ケバブメニュー（3つの垂直な点）が現れます。
2. ケバブメニュー（3つの垂直な点）を選択します。
3. 並べ替え指定を選択して、降順または昇順で行を並べ替える。

上記の画像は、val_acc と呼ばれる Table 列の並べ替えオプションを表示する方法を示しています。

フィルターボタン上の式を使用したすべての行のフィルタリング、ダッシュボード上部のフィルターボタンを使用できます。

行に1つ以上のフィルターを追加するには、Add filter を選択します。3 つのドロップダウンメニューが表示されます。左から右へのフィルタータイプは、列名、オペレーター、値に基づいています。る。

	列名	二項関係	値
受け入れ値	ストリング	=, ≠, ≤, ≥, IN, NOT IN,	整数、浮動小数点、ストリング、タイムスタンプ、null

行編集案では、列名と論理述語構造に基づいてオートコンプリートを行い、各項目のオプションを示します。複数の論理述語を使用して「and」または「or」（場合によっては括弧）で1つの式に接続できます。

上記の画像は、`val_loss` 列に基づいたフィルターを示しています。フィルターは、検証損失が1以下の run を表示します。

ダッシュボード上の Group by ボタンを使用して、特定の列の値で全行をグループ化します。

デフォルトでは、これにより他の数値列が、その列のグループ全体の値の分布を示すヒストグラムに変わります。グループ化は、データ内のより高水準のパターンを理解するのに役立ちます。

System タブ

System tab には、CPU 使用率、システムメモリ、ディスク I/O、ネットワークトラフィック、GPU 使用率など、特定の run に対して追跡されるシステムメトリクスが表示されます。

W&B が追跡するシステムメトリクスの完全なリストについては、System metrics を参照してください。

システムタブの例はこちらから見ることができます here。

Logs タブ

Log tab には、標準出力 (stdout) や標準エラー (stderr) などのコマンドラインに出力されたものが表示されます。

右上の「ダウンロード」ボタンを選択してログファイルをダウンロードします。

ログタブの例はこちらから見ることができます here.

Files タブ

Files tab を使用して、特定の run に関連付けられたファイル（モデルチェックポイント、検証セット例など）を表示してください。

ファイルタブの例はこちらから見ることができます here.

Artifacts タブ

Artifacts タブには、指定した run の入力および出力 Artifacts が一覧表示されます。

Artifacts タブの例はこちらから見ることができます here.

Run を削除する

W&B App を使用してプロジェクトから 1 つ以上の run を削除します。

1. 削除したい runs を含むプロジェクトに移動します。
2. プロジェクトのサイドバーから Runs タブを選択します。
3. 削除したい runs の横のチェックボックスを選択します。
4. テーブルの上部に表示される Delete ボタン（ゴミ箱アイコン）を選択します。
5. 表示されたモーダルで Delete を選択します。

Run を整理する

このセクションでは、グループとジョブタイプを使用して run を整理する方法についての手順を紹介します。 run をグループ（たとえば、実験名）に割り当て、ジョブタイプ（たとえば、前処理、トレーニング、評価、デバッグ）を指定することで、ワークフローを簡素化し、モデルの比較を改善できます。

Run にグループまたはジョブタイプを割り当てる

W&B の各 run は グループ と ジョブタイプ で分類できます：

• グループ：実験の広範なカテゴリで、run を整理およびフィルタリングするために使用されます。
• ジョブタイプ：run の機能で、preprocessing や training、evaluation のようなものです。

次のワークスペースの例では、Fashion-MNIST データセットからの増加するデータ量を使用してベースラインモデルをトレーニングしています。ワークスペースは使用されたデータ量を示すために色を使用します：

• 黄色から濃緑 は、ベースラインモデルのためのデータ量の増加を示しています。
• 薄い青から紫、マゼンタ は、追加パラメーターを持つより複雑な「ダブル」モデルのためのデータ量を示しています。

W&B のフィルタリングオプションや検索バーを使用して、次のような特定の条件に基づいて run を比較します：

• 同じデータセットに対するトレーニング。
• 同じテストセットに対する評価。

フィルターを適用する際、Table ビューは自動的に更新されます。これにより、モデル間のパフォーマンスの違い（たとえば、どのクラスが他のモデルと比べてはるかに難しいか）を特定することができます。

5.1 - run をフィルタリングし検索する

プロジェクトページを使用して、W&B にログされた run からインサイトを得ることができます。Workspace ページと Runs ページの両方で、run をフィルタリングおよび検索できます。

run をフィルタリングする

ステータス、タグ、またはその他のプロパティに基づいて、フィルター ボタンを使用して run をフィルタリングします。

タグで run をフィルタリングする

フィルター ボタンを使用して、タグに基づいて run をフィルタリングします。

正規表現で run をフィルタリングする

正規表現で望む結果が得られない場合は、タグを使用して Runs Table で run をフィルタリングすることができます。タグは run 作成時、または完了後に追加できます。一旦タグが run に追加されると、以下の gif に示されているように、タグ フィルターを追加できます。

run を検索する

指定した正規表現を使用して run を見つけるには、regex を使用します。検索ボックスにクエリを入力すると、ワークスペースのグラフで表示される run がフィルタリングされ、テーブルの行もフィルタリングされます。

run をグループ化する

1 つまたは複数の列（隠し列を含む）で run をグループ化するには:

1. 検索ボックスの下にある、罫線のついた紙のように見える Group ボタンをクリックします。
2. 結果をグループ化する 1 つ以上の列を選択します。
3. グループ化された各 run セットはデフォルトで折りたたまれています。展開するには、グループ名の横にある矢印をクリックします。

最小値と最大値で run を並べ替える

ログされたメトリクスの最小値または最大値で run テーブルを並べ替えます。これは、記録された最良または最悪の値を表示したい場合に特に便利です。

次の手順は、記録された最小値または最大値に基づいて特定のメトリクスで run テーブルを並べ替える方法を説明します：

1. 並べ替えたいメトリクスを含む列にマウスを合わせます。
2. ケバブ メニュー（三本の縦線）を選択します。
3. ドロップダウンから、Show min または Show max を選択します。
4. 同じドロップダウンから、Sort by asc または Sort by desc を選択して、それぞれ昇順または降順で並べ替えます。

run の終了時間を検索する

クライアントプロセスからの最後のハートビートをログする End Time という名前の列を提供します。このフィールドはデフォルトでは非表示になっています。

run テーブルを CSV にエクスポートする

すべての run、ハイパーパラメーター、およびサマリーメトリクスのテーブルを、ダウンロード ボタンを使用して CSV にエクスポートします。

5.2 - run をフォークする

run を初期化する際に fork_from を使用して、既存の W&B run から"フォーク"します。run をフォークすると、W&B はソース run の run ID と step を使用して新しい run を作成します。

run をフォークすることで、元の run に影響を与えずに、実験の特定のポイントから異なるパラメータやモデルを探索することができます。

フォークされた run を開始する

run をフォークするには、wandb.init()で fork_from 引数を使用し、フォーク元としてのソース run ID と step を指定します:

import wandb

# 後でフォークするための run を初期化
original_run = wandb.init(project="your_project_name", entity="your_entity_name")
# ... トレーニングやログを実行 ...
original_run.finish()

# 特定のステップから run をフォーク
forked_run = wandb.init(
    project="your_project_name",
    entity="your_entity_name",
    fork_from=f"{original_run.id}?_step=200",
)

不変の run ID を使用する

不変の run ID を使用して、特定の run への一貫性のある変更不可能な参照を保証します。ユーザーインターフェースから不変の run ID を取得するには、次の手順に従います:

1. Overview タブにアクセスする: ソース run のページで Overview タブ に移動します。

2. 不変の Run ID をコピーする: Overview タブの右上隅にある ... メニュー（三点ドット）をクリックします。ドロップダウンメニューから Copy Immutable Run ID オプションを選択します。

これらの手順を追うことで、フォークされた run に使用できる安定した変更不可能な run への参照を得ることができます。

フォークされた run から続行する

フォークされた run を初期化した後、新しい run にログを続行することができます。同じメトリクスをログすることで連続性を持たせ、新しいメトリクスを導入することも可能です。

例えば、次のコード例では、最初に run をフォークし、次にトレーニングステップ 200 からフォークされた run にメトリクスをログする方法を示しています:

import wandb
import math

# 最初の run を初期化し、いくつかのメトリクスをログ
run1 = wandb.init("your_project_name", entity="your_entity_name")
for i in range(300):
    run1.log({"metric": i})
run1.finish()

# 特定のステップから最初の run をフォークし、ステップ 200 からメトリクスをログ
run2 = wandb.init(
    "your_project_name", entity="your_entity_name", fork_from=f"{run1.id}?_step=200"
)

# 新しい run でログを続行
# 最初のいくつかのステップで、run1 からそのままメトリクスをログ
# ステップ 250 以降、スパイキーなパターンをログする
for i in range(200, 300):
    if i < 250:
        run2.log({"metric": i})  # スパイクなしで run1 からログを続行
    else:
        # ステップ 250 からスパイキーな振る舞いを導入
        subtle_spike = i + (2 * math.sin(i / 3.0))  # 微細なスパイキーパターンを適用
        run2.log({"metric": subtle_spike})
    # さらに、すべてのステップで新しいメトリクスをログ
    run2.log({"additional_metric": i * 1.1})
run2.finish()

5.3 - run を移動する

このページでは、run を別のプロジェクト間で、またはチーム内外、またはあるチームから別のチームへの移動方法を示します。現在の場所と新しい場所の両方で run へのアクセス権が必要です。

Runs タブをカスタマイズするには、Project page を参照してください。

プロジェクト間で run を移動する

run をあるプロジェクトから別のプロジェクトに移動するには:

1. 移動したい run を含むプロジェクトに移動します。
2. プロジェクトのサイドバーから Runs タブを選択します。
3. 移動したい run の横にあるチェックボックスを選択します。
4. テーブルの上にある Move ボタンを選択します。
5. ドロップダウンから移動先のプロジェクトを選択します。

チームに run を移動する

あなたがメンバーであるチームに run を移動するには:

1. 移動したい run を含むプロジェクトに移動します。
2. プロジェクトのサイドバーから Runs タブを選択します。
3. 移動したい run の横にあるチェックボックスを選択します。
4. テーブルの上にある Move ボタンを選択します。
5. ドロップダウンから移動先のチームとプロジェクトを選択します。

5.4 - run を巻き戻す

runを巻き戻す

runを巻き戻して、元のデータを失うことなくrunの履歴を修正または変更します。さらに、runを巻き戻すと、その時点から新しいデータをログすることができます。W&Bは、新しい履歴に基づく巻き戻し対象のrunのサマリーメトリクスを再計算します。これは以下の振る舞いを意味します:

• 履歴の切断: W&Bは巻き戻しポイントまで履歴を切断し、新しいデータのログを可能にします。
• サマリーメトリクス: 新しい履歴に基づいて再計算されます。
• 設定の保持: W&Bは元の設定を保持し、新しい設定をマージすることができます。

runを巻き戻すと、W&Bは指定されたステップにrunの状態をリセットし、元のデータを保持し、一貫したrun IDを維持します。これは次のことを意味します:

• runのアーカイブ: W&Bは元のrunをアーカイブします。runはRun Overview タブからアクセス可能です。
• アーティファクトの関連付け: アーティファクトを生成するrunと関連付けます。
• 不変のrun ID: 正確な状態からフォークするための一貫性が導入されます。
• 不変のrun IDをコピー: run管理を改善するために不変のrun IDをコピーするボタンがあります。

runを巻き戻す

resume_fromをwandb.init()と共に使用して、runの履歴を特定のステップまで「巻き戻し」ます。runの名前と巻き戻すステップを指定します:

import wandb
import math

# 最初のrunを初期化していくつかのメトリクスをログする
# your_project_nameとyour_entity_nameを置き換えてください!
run1 = wandb.init(project="your_project_name", entity="your_entity_name")
for i in range(300):
    run1.log({"metric": i})
run1.finish()

# 最初のrunの特定のステップから巻き戻してステップ200からメトリクスをログする
run2 = wandb.init(project="your_project_name", entity="your_entity_name", resume_from=f"{run1.id}?_step=200")

# 新しいrunでログを続ける
# 最初のいくつかのステップでは、run1からメトリクスをそのままログする
# ステップ250以降、尖ったパターンのログを開始する
for i in range(200, 300):
    if i < 250:
        run2.log({"metric": i, "step": i})  # スパイクなしでrun1からログを続行
    else:
        # ステップ250から尖った振る舞いを導入
        subtle_spike = i + (2 * math.sin(i / 3.0))  # subtleなスパイクパターンを適用
        run2.log({"metric": subtle_spike, "step": i})
    # さらに新しいメトリクスをすべてのステップでログ
    run2.log({"additional_metric": i * 1.1, "step": i})
run2.finish()

アーカイブされたrunを見る

runを巻き戻した後、W&B App UIでアーカイブされたrunを探索できます。以下のステップに従ってアーカイブされたrunを表示します:

1. Overviewタブにアクセスする: runのページでOverviewタブに移動します。このタブはrunの詳細と履歴を包括的に表示します。
2. Forked Fromフィールドを見つける: Overviewタブ内で、Forked Fromフィールドを見つけます。このフィールドは再開の履歴を記録します。Forked Fromフィールドにはソースrunへのリンクが含まれており、オリジナルのrunに遡り、全体の巻き戻し履歴を理解することができます。

Forked Fromフィールドを使用することで、アーカイブされた再開のツリーを簡単にナビゲートし、それぞれの巻き戻しの順序と起源についての洞察を得ることができます。

巻き戻されたrunからフォークする

巻き戻されたrunからフォークするには、wandb.init()のfork_from引数を使用し、ソースrun IDとフォークするソースrunのステップを指定します:

import wandb

# 特定のステップからrunをフォークする
forked_run = wandb.init(
    project="your_project_name",
    entity="your_entity_name",
    fork_from=f"{rewind_run.id}?_step=500",
)

# 新しいrunでログを続ける
for i in range(500, 1000):
    forked_run.log({"metric": i*3})
forked_run.finish()

5.5 - run を再開

実行が停止またはクラッシュした場合にどのように動作するべきかを指定します。実行を再開または自動的に再開するためには、その実行に関連付けられた一意の実行IDをidパラメータとして指定する必要があります。

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="<resume>")

W&Bがどのように対応するかを決定するために、次の引数の1つをresumeパラメータに渡します。各場合において、W&Bは最初に実行IDが既に存在するかを確認します。

resume="auto"を指定することで、W&Bが自動的にあなたの代わりに実行を再開しようとします。ただし、同じディレクトリーから実行を再開することを保証する必要があります。詳細は、実行を自動的に再開する設定を有効にするセクションを参照してください。

以下の例では、<>で囲まれた値をあなた自身のものに置き換えてください。

同じ実行IDを使用して実行を再開する

実行が停止、クラッシュ、または失敗した場合、同じ実行IDを使用して再開できます。これを行うには、実行を初期化し、以下を指定します。

• resumeパラメータを"must"に設定します（resume="must"）。
• 停止またはクラッシュした実行の実行IDを指定します。

以下のコードスニペットは、W&B Python SDKでこれを達成する方法を示しています。

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="must")

既存の実行を上書きせずに実行を再開する

停止またはクラッシュした実行を、既存の実行を上書きせずに再開します。これは、プロセスが正常に終了しない場合に特に役立ちます。次回W&Bを開始すると、W&Bは最後のステップからログを開始します。

W&Bで実行を初期化する場合、resumeパラメータを"allow"(resume="allow")で設定します。停止またはクラッシュした実行の実行IDを指定します。以下のコードスニペットは、W&B Python SDKでこれを達成する方法を示しています。

import wandb

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="allow")

実行を自動的に再開するように設定を有効にする

以下のコードスニペットは、Python SDKまたは環境変数を使用して実行を自動的に再開する方法を示します。

• W&B Python SDK
• シェルスクリプト

run = wandb.init(entity="<entity>", \ 
        project="<project>", id="<run ID>", resume="<resume>")

RUN_ID="$1"

WANDB_RESUME=allow WANDB_RUN_ID="$RUN_ID" python eval.py

sh run_experiment.sh akj172 

例えば、train.pyというPythonスクリプトをUsers/AwesomeEmployee/Desktop/ImageClassify/training/というディレクトリーで実行するとします。train.py内で、自動再開を有効にする実行が作成されます。次にトレーニングスクリプトが停止されたとします。この実行を再開するには、Users/AwesomeEmployee/Desktop/ImageClassify/training/内でtrain.pyスクリプトを再起動する必要があります。

中断可能なSweepsの実行を再開する

中断されたスイープ実行を自動的に再キューします。これは、スイープエージェントを停止の対象となる計算環境（SLURMジョブの中断可能なキュー、EC2スポットインスタンス、Google Cloud中断可能VMなど）で実行する場合に特に役立ちます。

mark_preempting関数を使用して、W&Bが中断されたスイープ実行を自動的に再キューできるようにします。以下のコードスニペットの例

run = wandb.init()  # 実行を初期化
run.mark_preempting()

以下の表は、スイープ実行の終了ステータスに基づいてW&Bが実行をどのように扱うかを概説しています。

5.6 - run を実験にまとめる

個々のジョブを実験としてグループ化するには、一意のグループ名を**wandb.init()**に渡します。

ユースケース

1. 分散トレーニング: 実験が異なるトレーニングや評価スクリプトに分割されている場合、グループ化を使用してそれらを一つの大きな全体として見ることができます。
2. 複数のプロセス: 複数の小さなプロセスを一つの実験としてグループ化します。
3. K-分割交差検証: 異なるランダムシードを持つrunをグループ化して、大きな実験を見ます。こちらがスイープとグループ化を使用したK-分割交差検証の例です。

グループ化を設定する方法は3つあります:

1. スクリプトでグループを設定する

オプションで group と job_type を wandb.init() に渡します。これにより、各実験に対して専用のグループページが作成され、個々のrunが含まれます。例: wandb.init(group="experiment_1", job_type="eval")

2. グループ環境変数を設定する

WANDB_RUN_GROUP を使用して、runのグループを環境変数として指定します。詳細はEnvironment Variablesをご覧ください。Groupはプロジェクト内で一意である必要があり、グループ内のすべてのrunで共有されます。wandb.util.generate_id() を使用して、すべてのプロセスで使用するための一意の8文字の文字列を生成することができます。例: os.environ["WANDB_RUN_GROUP"] = "experiment-" + wandb.util.generate_id()

3. UIでグループ化を切り替える

任意の設定列で動的にグループ化できます。例として、wandb.config を使用してバッチサイズまたは学習率をログすると、それらのハイパーパラメーターでWebアプリ内で動的にグループ化できます。

グループ化を伴う分散トレーニング

wandb.init()でグループ化を設定したと仮定すると、UIではデフォルトでrunがグループ化されます。テーブルの上部にあるGroupボタンをクリックして、これをオン・オフすることができます。こちらはグループ化を設定したサンプルコードから生成された例のプロジェクトです。サイドバーの各「グループ」行をクリックすると、その実験の専用グループページにアクセスできます。

上記のプロジェクトページから、左サイドバーでGroupをクリックすると、このような専用ページにアクセスできます。

UIでの動的なグループ化

任意の列でrunをグループ化できます。例として、ハイパーパラメーターでグループ化することができます。これがどのように見えるかの例です：

• サイドバー: runがエポック数でグループ化されています。
• グラフ: 各線はグループの平均を表し、陰影は分散を示します。この振る舞いはグラフ設定で変更できます。

グループ化をオフにする

グループ化ボタンをクリックし、グループフィールドをいつでもクリアすることで、テーブルとグラフをグループ化されていない状態に戻します。

グループ化グラフの設定

グラフの右上にある編集ボタンをクリックし、Advancedタブを選択して線と陰影を変更します。各グループの線には平均、最小、最大値を選択できます。陰影については無効にしたり、最小と最大、標準偏差、標準誤差を表示することができます。

5.7 - runs にタグでラベルを追加する

特定の特徴を持つ runs にタグを追加して、ログされたメトリクスやアーティファクトデータからは見えない情報をラベル付けできます。

たとえば、ある run のモデルが in_production であること、run が preemptible であること、この run が baseline を表していることなどを示すためにタグを追加できます。

1つまたは複数の runs にタグを追加する

プログラムによって、または対話的に runs にタグを追加します。

あなたのユースケースに基づいて、以下のタブからニーズに最も合ったものを選択してください。

• W&B Python SDK
• Public API
• Project page
• Run page

import wandb

run = wandb.init(
  entity="entity",
  project="<project-name>",
  tags=["tag1", "tag2"]
)

import wandb

run = wandb.init(
  entity="entity", 
  project="capsules", 
  tags=["debug"]
  )

# モデルをトレーニングするための Python ロジック

if current_loss < threshold:
    run.tags = run.tags + ("release_candidate",)

run = wandb.Api().run("{entity}/{project}/{run-id}")
run.tags.append("tag1")  # ここで run データに基づいてタグを選択できます
run.update()

1つまたは複数の runs からタグを削除する

W&B App の UI を使って、runs からタグを削除することもできます。

• Project page
• Run page

5.8 - アラートを送信する

run がクラッシュしたり、カスタムトリガーで Slack やメールでアラートを作成します。例えば、トレーニングループの勾配が膨らみ始めた場合（NaNを報告）や、ML パイプライン内のステップが完了した場合などです。アラートは、個人およびチームプロジェクトの両方を含む、run を初期化するすべての Projects に適用されます。

その後、Slack（またはメール）で W&B Alerts メッセージを確認します。

アラートの作成方法

アラートを設定するための主なステップは2つあります。

1. W&B の User Settings で Alerts をオンにする
2. コードに run.alert() を追加する
3. アラートが正しく設定されているか確認する

1. W&B User Settings でアラートをオンにする

User Settings の中で：

• Alerts セクションまでスクロールします
• Scriptable run alerts をオンにして run.alert() からのアラートを受け取ります
• Connect Slack を使用して、アラートを投稿する Slack チャンネルを選択します。アラートを非公開に保持するため、Slackbot チャンネルをお勧めします。
• Email は W&B にサインアップしたときに使用したメールアドレスに送られます。これらのアラートがフォルダに入り、受信トレイを埋めないようにメールにフィルターを設定することをお勧めします。

W&B Alerts を初めて設定する際、またはアラートの受け取り方を変更したい場合にのみ、これを行う必要があります。

2. コードに run.alert() を追加する

ノートブックや Python スクリプトのどこでトリガーしたいかに run.alert() をコードに追加します。

import wandb

run = wandb.init()
run.alert(title="High Loss", text="Loss is increasing rapidly")

3. Slack またはメールを確認する

アラートメッセージのために Slack またはメールをチェックします。受信していない場合は、User Settings で Scriptable Alerts 用のメールまたは Slack がオンになっていることを確認してください

例

このシンプルなアラートは、精度が閾値を下回ると警告を送信します。この例では、少なくとも 5 分おきにアラートを送信します。

import wandb
from wandb import AlertLevel

run = wandb.init()

if acc < threshold:
    run.alert(
        title="Low accuracy",
        text=f"Accuracy {acc} is below the acceptable threshold {threshold}",
        level=AlertLevel.WARN,
        wait_duration=300,
    )

ユーザーをタグ付けまたはメンションする方法

アットマーク @ に続けて Slack ユーザー ID を使用して、アラートのタイトルまたはテキストで自身または同僚をタグ付けします。Slack ユーザー ID は、彼らの Slack プロフィールページから見つけることができます。

run.alert(title="Loss is NaN", text=f"Hey <@U1234ABCD> loss has gone to NaN")

チームアラート

チーム管理者は、チームの設定ページでチーム用のアラートを設定できます：wandb.ai/teams/your-team。

チームアラートは、チームの全員に適用されます。W&B は、アラートを非公開に保持するために Slackbot チャンネルを使用することをお勧めします。

アラート送信先の Slack チャンネルを変更する

アラートの送信先を変更するには、Disconnect Slack をクリックして、再接続してください。再接続後、別の Slack チャンネルを選択します。

6 - Jupyter ノートブックをトラッキングする

W&B を Jupyter と組み合わせることで、ノートブックを離れることなくインタラクティブな可視化を実現できます。カスタム分析、実験管理、プロトタイプをすべて完全にログしながら結合します。

Jupyter ノートブックにおける W&B のユースケース

1. 反復実験: 実験を実行および再実行して、パラメータを調整し、すべての実行を手動でメモを取ることなく自動的に W&B に保存します。
2. コード保存: モデルを再現する際、ノートブックのどのセルが実行されたか、どの順序で実行されたかを知るのは難しいです。各実験のセル実行の記録を保存するために、設定ページでコード保存をオンにしてください。
3. カスタム分析: 実行が W&B にログされたら、APIからデータフレームを取得して、カスタム分析を行い、その結果を W&B にログしてレポートで保存し、共有できます。

ノートブックでの始め方

W&B をインストールしてアカウントをリンクするために、次のコードでノートブックを開始します：

!pip install wandb -qqq
import wandb
wandb.login()

次に、実験を設定してハイパーパラメーターを保存します：

wandb.init(
    project="jupyter-projo",
    config={
        "batch_size": 128,
        "learning_rate": 0.01,
        "dataset": "CIFAR-100",
    },
)

wandb.init() を実行した後、新しいセルを %%wandb から開始して、ノートブックでライブグラフを表示します。このセルを複数回実行すると、データは run に追加されます。

%%wandb

# ここにトレーニングループ

この例のノートブックで試してみてください。

ノートブックでライブ W&B インターフェイスを直接レンダリング

既存のダッシュボード、スイープ、またはレポートをノートブック内で直接表示することも可能です。%wandb マジックを使います：

# プロジェクトワークスペースを表示
%wandb USERNAME/PROJECT
# 単一の run を表示
%wandb USERNAME/PROJECT/runs/RUN_ID
# スイープを表示
%wandb USERNAME/PROJECT/sweeps/SWEEP_ID
# レポートを表示
%wandb USERNAME/PROJECT/reports/REPORT_ID
# 埋め込まれた iframe の高さを指定
%wandb USERNAME/PROJECT -h 2048

%%wandb または %wandb マジックの代替として、wandb.init() を実行した後、任意のセルを wandb.run で終わらせてインライングラフを表示するか、私たちの API から返された任意のレポート、スイープ、または run オブジェクトに ipython.display(...) を呼び出すこともできます。

# まず wandb.run を初期化
wandb.init()

# セルが wandb.run を出力すれば、ライブグラフが見られます
wandb.run

W&B における追加の Jupyter 機能

1. Colab における簡単な認証: Colab で最初に wandb.init を呼び出すと、ブラウザーで W&B にログインしている場合、ランタイムを自動的に認証します。run ページの Overviewタブに Colab へのリンクが表示されます。
2. Jupyter マジック: ダッシュボード、スイープ、レポートをノートブック内で直接表示する機能です。%wandb マジックはプロジェクト、スイープ、またはレポートへのパスを受け取り、W&B インターフェイスをノートブック内に直接レンダリングします。
3. Docker化された Jupyter のローンチ: wandb docker --jupyter を呼び出して、dockerコンテナを起動し、コードをマウントし、Jupyter がインストールされていることを確認し、ポート 8888 で起動します。
4. 順序を気にせずにセルを実行: デフォルトでは、次に wandb.init が呼び出されるまで run を finished としてマークしません。それにより、複数のセル（例: データを設定するセル、トレーニングするセル、テストするセル）を任意の順序で実行し、すべて同じ run にログできます。設定でコード保存をオンにすると、実行順序と状態で実行されたセルもログされ、最も非線形なパイプラインでさえ再現できます。Jupyter ノートブックで run を手動で完了としてマークするには、run.finish を呼び出してください。

import wandb

run = wandb.init()

# トレーニングスクリプトとログはここに

run.finish()

7 - ログ オブジェクト と メディア

W&B Python SDK を使用して、メトリクス、メディア、またはカスタムオブジェクトの辞書をステップにログします。W&B は各ステップごとにキーと値のペアを収集し、wandb.log() でデータをログするたびにそれらを統一された辞書に格納します。スクリプトからログされたデータは、wandb と呼ばれるディレクトリにローカルに保存され、その後 W&B クラウドまたは プライベートサーバー に同期されます。

デフォルトでは、wandb.log を呼び出すたびに新しい step になります。W&B は、チャートやパネルを作成する際にステップをデフォルトの x 軸として使用します。カスタムの x 軸を作成して使用するか、カスタムの要約メトリックをキャプチャすることも選択できます。詳細は、ログの軸をカスタマイズするを参照してください。

自動でログされるデータ

W&B は、W&B Experiment 中に次の情報を自動でログします：

• システムメトリクス: CPU と GPU の使用率、ネットワークなど。これらは run ページ のシステムタブに表示されます。GPU に関しては、nvidia-smi で取得されます。
• コマンドライン: stdout と stderr が取得され、run ページ のログタブに表示されます。

アカウントの Settings ページでコードの保存をオンにして、以下をログします：

• Git コミット: 最新の git コミットを取得し、run ページの overview タブに表示されます。コミットされていない変更がある場合は diff.patch ファイルも表示されます。
• 依存関係: requirements.txt ファイルがアップロードされ、run ページのファイルタブに表示されます。run 用に wandb ディレクトリに保存したファイルも含まれます。

特定の W&B API 呼び出しでログされるデータ

W&B を使用することで、ログしたいものを正確に決定できます。次に、よくログされるオブジェクトのリストを示します：

• Datasets: 画像や他のデータセットサンプルを W&B にストリームするためには、特にログする必要があります。
• Plots: グラフを追跡するために wandb.plot を wandb.log と一緒に使用します。詳細はログでのグラフを参照してください。
• Tables: wandb.Table を使用してデータをログし、W&B でビジュアライズおよびクエリを行います。詳細はログでのテーブルを参照してください。
• PyTorch 勾配: モデルの重みの勾配を UI にヒストグラムとして表示するために wandb.watch(model) を追加します。
• 設定情報: ハイパーパラメーター、データセットへのリンク、使用しているアーキテクチャーの名前などを設定パラメーターとしてログします。このように渡します：wandb.init(config=your_config_dictionary)。詳細はPyTorch インテグレーションページをご覧ください。
• メトリクス: wandb.log を使用してモデルのメトリクスを表示します。トレーニングループ内で精度や損失のようなメトリクスをログすると、UI にライブ更新グラフが表示されます。

一般的なワークフロー

1. 最高の精度を比較する: Runs 間でメトリクスの最高値を比較するには、そのメトリクスの要約値を設定します。デフォルトでは、各キーの最後にログした値が要約に設定されます。これは UI のテーブルで、要約メトリクスに基づいて run を並べ替えたりフィルタリングしたりするのに便利です。best の精度に基づいてテーブルまたは棒グラフで run を比較するのに役立ちます。例：wandb.run.summary["best_accuracy"] = best_accuracy
2. 複数のメトリクスを1つのチャートで表示: wandb.log の同じ呼び出し内で複数のメトリクスをログすると、例えばこうなります: wandb.log({"acc": 0.9, "loss": 0.1})。UI ではどちらもプロットすることができます。
3. x 軸をカスタマイズする: 同じログ呼び出しにカスタム x 軸を追加して、W&B ダッシュボードで別の軸に対してメトリクスを視覚化します。例：wandb.log({'acc': 0.9, 'epoch': 3, 'batch': 117})。特定のメトリクスに対するデフォルトの x 軸を設定するには、Run.define_metric() を使用してください。
4. リッチメディアとチャートをログする: wandb.log は、画像やビデオのようなメディアからtablesやchartsに至るまで、多様なデータタイプのログをサポートしています。

ベストプラクティスとヒント

Experiments やログのためのベストプラクティスとヒントについては、Best Practices: Experiments and Logging を参照してください。

7.1 - メディアとオブジェクトをログする

私たちは画像、ビデオ、音声などをサポートしています。リッチメディアをログして、結果を探索し、Run、Models、Datasetsを視覚的に比較しましょう。例やハウツーガイドは以下をご覧ください。

前提条件

W&B SDKを使用してメディアオブジェクトをログするためには、追加の依存関係をインストールする必要があるかもしれません。以下のコマンドを実行してこれらの依存関係をインストールできます：

pip install wandb[media]

画像

画像をログして、入力、出力、フィルター重み、活性化状態などを追跡しましょう。

画像はNumPy配列、PIL画像、またはファイルシステムから直接ログできます。

ステップごとに画像をログするたびに、UIに表示するために保存されます。画像パネルを拡大し、ステップスライダーを使用して異なるステップの画像を確認します。これにより、トレーニング中にモデルの出力がどのように変化するかを比較しやすくなります。

• 配列を画像としてログする
• PIL Imagesをログする
• ファイルから画像をログする

images = wandb.Image(image_array, caption="Top: Output, Bottom: Input")

wandb.log({"examples": images})

images = [PIL.Image.fromarray(image) for image in image_array]

wandb.log({"examples": [wandb.Image(image) for image in images]})

im = PIL.fromarray(...)
rgb_im = im.convert("RGB")
rgb_im.save("myimage.jpg")

wandb.log({"example": wandb.Image("myimage.jpg")})

画像オーバーレイ

• セグメンテーションマスク
• バウンディングボックス

セマンティックセグメンテーションマスクをログし、W&B UIを通じて（不透明度の変更、時間経過による変化の確認など）それらと対話します。

オーバーレイをログするには、wandb.Imageのmasksキーワード引数に以下のキーと値を持つ辞書を提供する必要があります：

• 画像マスクを表す2つのキーのうちの1つ：
  • "mask_data"：各ピクセルの整数クラスラベルを含む2D NumPy配列
  • "path"：（文字列）保存された画像マスクファイルへのパス
• "class_labels"：（オプション）画像マスク内の整数クラスラベルを可読クラス名にマッピングする辞書

複数のマスクをログするには、以下のコードスニペットのように、複数のキーを含むマスク辞書をログします。

ライブ例を参照してください

サンプルコード

mask_data = np.array([[1, 2, 2, ..., 2, 2, 1], ...])

class_labels = {1: "tree", 2: "car", 3: "road"}

mask_img = wandb.Image(
    image,
    masks={
        "predictions": {"mask_data": mask_data, "class_labels": class_labels},
        "ground_truth": {
            # ...
        },
        # ...
    },
)

画像にバウンディングボックスをログし、UIで異なるセットのボックスを動的に可視化するためにフィルターや切り替えを使用します。

ライブ例を参照してください

バウンディングボックスをログするには、wandb.Imageのboxesキーワード引数に以下のキーと値を持つ辞書を提供する必要があります：

• box_data：各ボックス用の辞書リスト。ボックス辞書形式は以下に説明します。
  • position：ボックスの位置とサイズを表す辞書で、以下で説明する2つの形式のいずれか。すべてのボックスが同じ形式を使用する必要はありません。
    • オプション 1: {"minX", "maxX", "minY", "maxY"}。各ボックスの次元の上下限を定義する座標セットを提供します。
    • オプション 2: {"middle", "width", "height"}。middle座標を[x,y]として、widthとheightをスカラーとして指定します。
  • class_id：ボックスのクラス識別を表す整数。以下のclass_labelsキーを参照。
  • scores：スコアの文字列ラベルと数値の辞書。UIでボックスをフィルタリングするために使用できます。
  • domain：ボックス座標の単位/形式を指定してください。この値を"pixel"に設定してください。ボックス座標が画像の次元内の整数のようにピクセル空間で表されている場合、デフォルトで、domainは画像の割合/百分率として表され、0から1までの浮動小数点数として解釈されます。
  • box_caption：（オプション）このボックス上に表示されるラベルテキストとしての文字列
• class_labels：（オプション）class_idを文字列にマッピングする辞書。デフォルトではclass_0、class_1などのクラスラベルを生成します。

この例をチェックしてください：

class_id_to_label = {
    1: "car",
    2: "road",
    3: "building",
    # ...
}

img = wandb.Image(
    image,
    boxes={
        "predictions": {
            "box_data": [
                {
                    # デフォルトの相対/小数領域で表現された1つのボックス
                    "position": {"minX": 0.1, "maxX": 0.2, "minY": 0.3, "maxY": 0.4},
                    "class_id": 2,
                    "box_caption": class_id_to_label[2],
                    "scores": {"acc": 0.1, "loss": 1.2},
                    # ピクセル領域で表現された別のボックス
                    # （説明目的のみ、すべてのボックスは同じ領域/形式である可能性が高い）
                    "position": {"middle": [150, 20], "width": 68, "height": 112},
                    "domain": "pixel",
                    "class_id": 3,
                    "box_caption": "a building",
                    "scores": {"acc": 0.5, "loss": 0.7},
                    # ...
                    # 必要に応じて多くのボックスをログします
                }
            ],
            "class_labels": class_id_to_label,
        },
        # 意味のあるボックスのグループごとに一意のキーネームでログします
        "ground_truth": {
            # ...
        },
    },
)

wandb.log({"driving_scene": img})

テーブル内の画像オーバーレイ

• セグメンテーションマスク
• バウンディングボックス

テーブル内でセグメンテーションマスクをログするには、テーブルの各行に対してwandb.Imageオブジェクトを提供する必要があります。

以下のコードスニペットに例があります：

table = wandb.Table(columns=["ID", "Image"])

for id, img, label in zip(ids, images, labels):
    mask_img = wandb.Image(
        img,
        masks={
            "prediction": {"mask_data": label, "class_labels": class_labels}
            # ...
        },
    )

    table.add_data(id, img)

wandb.log({"Table": table})

テーブル内でバウンディングボックス付き画像をログするには、テーブルの各行にwandb.Imageオブジェクトを提供する必要があります。

以下のコードスニペットに例があります：

table = wandb.Table(columns=["ID", "Image"])

for id, img, boxes in zip(ids, images, boxes_set):
    box_img = wandb.Image(
        img,
        boxes={
            "prediction": {
                "box_data": [
                    {
                        "position": {
                            "minX": box["minX"],
                            "minY": box["minY"],
                            "maxX": box["maxX"],
                            "maxY": box["maxY"],
                        },
                        "class_id": box["class_id"],
                        "box_caption": box["caption"],
                        "domain": "pixel",
                    }
                    for box in boxes
                ],
                "class_labels": class_labels,
            }
        },
    )

ヒストグラム

• 基本ヒストグラムログ
• 柔軟なヒストグラムログ
• Summary内のヒストグラム

リスト、配列、テンソルなどの数字のシーケンスが最初の引数として提供されると、自動的にnp.histogramを呼んでヒストグラムを構築します。すべての配列/テンソルはフラット化されます。num_binsキーワード引数を使用して64ビンのデフォルト設定を上書きできます。最大サポートビン数は512です。

UIでは、トレーニングステップがx軸に、メトリック値がy軸に、色で表現されたカウントでヒストグラムがプロットされ、トレーニング中にログされたヒストグラムを比較しやすくしています。詳細については、このパネルの"Summary内のヒストグラム"タブを参照してください。

wandb.log({"gradients": wandb.Histogram(grads)})

もっと制御したい場合は、np.histogramを呼び出し、その返されたタプルをnp_histogramキーワード引数に渡します。

np_hist_grads = np.histogram(grads, density=True, range=(0.0, 1.0))
wandb.log({"gradients": wandb.Histogram(np_hist_grads)})

wandb.run.summary.update(  # Summaryにのみある場合、Overviewタブにのみ表示されます
    {"final_logits": wandb.Histogram(logits)}
)

ファイルを形式 'obj', 'gltf', 'glb', 'babylon', 'stl', 'pts.json' でログすれば、runが終了した際にUIでそれらをレンダリングします。

wandb.log(
    {
        "generated_samples": [
            wandb.Object3D(open("sample.obj")),
            wandb.Object3D(open("sample.gltf")),
            wandb.Object3D(open("sample.glb")),
        ]
    }
)

ライブ例を見る

Summary内にあるヒストグラムは、Run PageのOverviewタブに表示されます。履歴にある場合、Chartsタブで時間経過によるビンのヒートマップをプロットします。

3D可視化

point_cloud = np.array([[0, 0, 0, COLOR]])

wandb.log({"point_cloud": wandb.Object3D(point_cloud)})

point_list = [
    [
        2566.571924017235, # x
        746.7817289698219, # y
        -15.269245470863748,# z
        76.5, # red
        127.5, # green
        89.46617199365393 # blue
    ],
    [ 2566.592983606823, 746.6791987335685, -15.275803826279521, 76.5, 127.5, 89.45471117247024 ],
    [ 2566.616361739416, 746.4903185513501, -15.28628929674075, 76.5, 127.5, 89.41336375503832 ],
    [ 2561.706014951675, 744.5349468458361, -14.877496818222781, 76.5, 127.5, 82.21868245418283 ],
    [ 2561.5281847916694, 744.2546118233013, -14.867862032341005, 76.5, 127.5, 81.87824684536432 ],
    [ 2561.3693562897465, 744.1804761656741, -14.854129178142523, 76.5, 127.5, 81.64137897587152 ],
    [ 2561.6093071504515, 744.0287526628543, -14.882135189841177, 76.5, 127.5, 81.89871499537098 ],
    # ... and so on
]

run.log({"my_first_point_cloud": wandb.Object3D.from_point_cloud(
     points = point_list,
     boxes = [{
         "corners": [
                [ 2601.2765123137915, 767.5669506323393, -17.816764802288663 ],
                [ 2599.7259021588347, 769.0082337923552, -17.816764802288663 ],
                [ 2599.7259021588347, 769.0082337923552, -19.66876480228866 ],
                [ 2601.2765123137915, 767.5669506323393, -19.66876480228866 ],
                [ 2604.8684867834395, 771.4313904894723, -17.816764802288663 ],
                [ 2603.3178766284827, 772.8726736494882, -17.816764802288663 ],
                [ 2603.3178766284827, 772.8726736494882, -19.66876480228866 ],
                [ 2604.8684867834395, 771.4313904894723, -19.66876480228866 ]
        ],
         "color": [0, 0, 255], # バウンディングボックスのRGB色
         "label": "car", # バウンディングボックスに表示される文字列
         "score": 0.6 # バウンディングボックスに表示される数値
     }],
     vectors = [
        {"start": [0, 0, 0], "end": [0.1, 0.2, 0.5], "color": [255, 0, 0]}, # 色は任意
     ],
     point_cloud_type = "lidar/beta",
)})

run.log({"my_cloud_from_file": wandb.Object3D.from_file(
     "./my_point_cloud.pts.json"
)})

{
    "boxes": [
        {
            "color": [
                0,
                255,
                0
            ],
            "score": 0.35,
            "label": "My label",
            "corners": [
                [
                    2589.695869075582,
                    760.7400443552185,
                    -18.044831294622487
                ],
                [
                    2590.719039645323,
                    762.3871153874499,
                    -18.044831294622487
                ],
                [
                    2590.719039645323,
                    762.3871153874499,
                    -19.54083129462249
                ],
                [
                    2589.695869075582,
                    760.7400443552185,
                    -19.54083129462249
                ],
                [
                    2594.9666662674313,
                    757.4657929961453,
                    -18.044831294622487
                ],
                [
                    2595.9898368371723,
                    759.1128640283766,
                    -18.044831294622487
                ],
                [
                    2595.9898368371723,
                    759.1128640283766,
                    -19.54083129462249
                ],
                [
                    2594.9666662674313,
                    757.4657929961453,
                    -19.54083129462249
                ]
            ]
        }
    ],
    "points": [
        [
            2566.571924017235,
            746.7817289698219,
            -15.269245470863748,
            76.5,
            127.5,
            89.46617199365393
        ],
        [
            2566.592983606823,
            746.6791987335685,
            -15.275803826279521,
            76.5,
            127.5,
            89.45471117247024
        ],
        [
            2566.616361739416,
            746.4903185513501,
            -15.28628929674075,
            76.5,
            127.5,
            89.41336375503832
        ]
    ],
    "type": "lidar/beta"
}

run.log({"my_cloud_from_numpy_xyz": wandb.Object3D.from_numpy(
     np.array(  
        [
            [0.4, 1, 1.3], # x, y, z
            [1, 1, 1], 
            [1.2, 1, 1.2]
        ]
    )
)})

run.log({"my_cloud_from_numpy_cat": wandb.Object3D.from_numpy(
     np.array(  
        [
            [0.4, 1, 1.3, 1], # x, y, z, カテゴリ 
            [1, 1, 1, 1], 
            [1.2, 1, 1.2, 12], 
            [1.2, 1, 1.3, 12], 
            [1.2, 1, 1.4, 12], 
            [1.2, 1, 1.5, 12], 
            [1.2, 1, 1.6, 11], 
            [1.2, 1, 1.7, 11], 
        ]
    )
)})

run.log({"my_cloud_from_numpy_rgb": wandb.Object3D.from_numpy(
     np.array(  
        [
            [0.4, 1, 1.3, 255, 0, 0], # x, y, z, r, g, b 
            [1, 1, 1, 0, 255, 0], 
            [1.2, 1, 1.3, 0, 255, 255],
            [1.2, 1, 1.4, 0, 255, 255],
            [1.2, 1, 1.5, 0, 0, 255],
            [1.2, 1, 1.1, 0, 0, 255],
            [1.2, 1, 0.9, 0, 0, 255],
        ]
    )
)})

wandb.log({"protein": wandb.Molecule("6lu7.pdb")})

resveratrol = rdkit.Chem.MolFromSmiles("Oc1ccc(cc1)C=Cc1cc(O)cc(c1)O")

wandb.log(
    {
        "resveratrol": wandb.Molecule.from_rdkit(resveratrol),
        "green fluorescent protein": wandb.Molecule.from_rdkit("2b3p.mol"),
        "acetaminophen": wandb.Molecule.from_smiles("CC(=O)Nc1ccc(O)cc1"),
    }
)

wandb.log({"example": wandb.Image(...)})
# または複数の画像
wandb.log({"example": [wandb.Image(...) for img in images]})

wandb.log({"example": wandb.Video("myvideo.mp4")})

molecule = rdkit.Chem.MolFromSmiles("CC(=O)O")
rdkit.Chem.AllChem.Compute2DCoords(molecule)
rdkit.Chem.AllChem.GenerateDepictionMatching2DStructure(molecule, molecule)
pil_image = rdkit.Chem.Draw.MolToImage(molecule, size=(300, 300))

wandb.log({"acetic_acid": wandb.Image(pil_image)})

wandb.log({"whale songs": wandb.Audio(np_array, caption="OooOoo", sample_rate=32)})

wandb.log({"video": wandb.Video(numpy_array_or_path_to_video, fps=4, format="gif")})

columns = ["Text", "Predicted Sentiment", "True Sentiment"]
# メソッド 1
data = [["I love my phone", "1", "1"], ["My phone sucks", "0", "-1"]]
table = wandb.Table(data=data, columns=columns)
wandb.log({"examples": table})

# メソッド 2
table = wandb.Table(columns=columns)
table.add_data("I love my phone", "1", "1")
table.add_data("My phone sucks", "0", "-1")
wandb.log({"examples": table})

table = wandb.Table(dataframe=my_dataframe)

wandb.log({"custom_file": wandb.Html(open("some.html"))})
wandb.log({"custom_string": wandb.Html('<a href="https://mysite">Link</a>')})

wandb.log({"custom_file": wandb.Html(open("some.html"), inject=False)})

7.2 - モデルをログする

モデルをログする

以下のガイドでは、W&B run にモデルをログし、それと対話する方法を説明します。

モデルを run にログする

log_model を使用して、指定したディレクトリ内にコンテンツを含むモデルアーティファクトをログします。 log_model メソッドは、結果のモデルアーティファクトを W&B run の出力としてもマークします。

モデルを W&B run の入力または出力としてマークすると、モデルの依存関係とモデルの関連付けを追跡できます。W&B アプリ UI 内でモデルのリネージを確認します。詳細については、Artifacts チャプターの アーティファクトグラフを探索して移動する ページを参照してください。

モデルファイルが保存されているパスを path パラメータに指定します。パスには、ローカルファイル、ディレクトリ、または s3://bucket/path などの外部バケットへの 参照 URI を指定できます。

<> 内に囲まれた値を自分のもので置き換えることを忘れないでください。

import wandb

W&B run を初期化

run = wandb.init(project="", entity="")

モデルをログする

run.log_model(path="", name="")

オプションで、name パラメータにモデルアーティファクトの名前を指定できます。name が指定されていない場合、W&B は入力パスのベース名に run ID をプレフィックスとして使用して名前を生成します。

log_model の詳細については、API リファレンスガイドを参照してください。

import os
import wandb
from tensorflow import keras
from tensorflow.keras import layers

config = {"optimizer": "adam", "loss": "categorical_crossentropy"}

# W&B run を初期化
run = wandb.init(entity="charlie", project="mnist-experiments", config=config)

# ハイパーパラメーター
loss = run.config["loss"]
optimizer = run.config["optimizer"]
metrics = ["accuracy"]
num_classes = 10
input_shape = (28, 28, 1)

# トレーニング アルゴリズム
model = keras.Sequential(
    [
        layers.Input(shape=input_shape),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation="softmax"),
    ]
)

# トレーニング用のモデルを設定
model.compile(loss=loss, optimizer=optimizer, metrics=metrics)

# モデルを保存
model_filename = "model.h5"
local_filepath = "./"
full_path = os.path.join(local_filepath, model_filename)
model.save(filepath=full_path)

# モデルを W&B run にログする
run.log_model(path=full_path, name="MNIST")
run.finish()

View run different-surf-5 at: https://wandb.ai/charlie/mnist-experiments/runs/wlby6fuw
Synced 5 W&B file(s), 0 media file(s), 1 artifact file(s) and 0 other file(s)
Find logs at: ./wandb/run-20231206_103511-wlby6fuw/logs

ログされたモデルをダウンロードして使用する

以前に W&B run にログされたモデルファイルにアクセスしてダウンロードするには、use_model 関数を使用します。

取得したいモデルファイルが保存されているモデルアーティファクトの名前を指定します。提供した名前は、既存のログされたモデルアーティファクトの名前と一致している必要があります。

最初に log_model でファイルをログした際に name を定義しなかった場合、割り当てられたデフォルト名は、入力パスのベース名にrun ID をプレフィックスとして付けたものになります。

<> 内に囲まれた他の値を自分のもので置き換えることを忘れないでください。

import wandb

# run を初期化
run = wandb.init(project="<your-project>", entity="<your-entity>")

# モデルにアクセスしてダウンロードする。ダウンロードされたアーティファクトのパスが返されます
downloaded_model_path = run.use_model(name="<your-model-name>")

use_model 関数は、ダウンロードされたモデルファイルのパスを返します。このパスを追跡して、後でこのモデルにリンクしたい場合に備えてください。上記のコードスニペットでは、返されたパスが downloaded_model_path という変数に保存されています。

import wandb

entity = "luka"
project = "NLP_Experiments"
alias = "latest"  # モデルバージョンのセマンティックなニックネームまたは識別子
model_artifact_name = "fine-tuned-model"

# run を初期化
run = wandb.init(project=project, entity=entity)
# モデルにアクセスしてダウンロードする。ダウンロードされたアーティファクトのパスが返されます
downloaded_model_path = run.use_model(name = f"{model_artifact_name}:{alias}") 

use_model API リファレンスガイドでは、利用可能なパラメータや返り値の型についての詳細情報が記載されています。

モデルを W&B モデルレジストリにログしリンクする

link_model メソッドを使用して、モデルファイルを W&B run にログし、それを W&B モデルレジストリ にリンクします。登録されたモデルが存在しない場合、W&B は registered_model_name パラメータにあなたが提供した名前で新しいものを作成します。

モデルをリンクすることは、他のチームメンバーが視聴および利用できる中央集権的なチームのリポジトリにモデルを「ブックマーク」または「公開」することに類似しています。

モデルをリンクすると、そのモデルは Registry に重複されることも、プロジェクトから移動してレジストリに入れられることもありません。リンクされたモデルは、プロジェクト内の元のモデルへのポインターです。

Registry を使用して、タスクごとに最高のモデルを整理したり、モデルのライフサイクルを管理したり、MLライフサイクル全体での追跡や監査を容易にしたり、Webhooks やジョブでの下流アクションを自動化 することができます。

Registered Model は、Model Registry にリンクされたモデルバージョンのコレクションまたはフォルダーです。登録されたモデルは通常、単一のモデリングユースケースまたはタスクの候補モデルを表します。

以下のコードスニペットは、link_model API を使用してモデルをリンクする方法を示しています。<> 内に囲まれた他の値を自分のもので置き換えることを忘れないでください。

import wandb

run = wandb.init(entity="<your-entity>", project="<your-project>")
run.link_model(path="<path-to-model>", registered_model_name="<registered-model-name>")
run.finish()

link_model API リファレンスガイドでは、オプションのパラメータに関する詳細情報が記載されています。

registered-model-name が Model Registry 内に既に存在する登録済みのモデル名と一致する場合、そのモデルはその登録済みモデルにリンクされます。そのような登録済みモデルが存在しない場合、新しいものが作成され、そのモデルが最初にリンクされます。

例えば、既に Model Registry に “Fine-Tuned-Review-Autocompletion"という名前の登録済みモデルが存在し、いくつかのモデルバージョンが既にリンクされていると仮定します: v0, v1, v2。link_model を registered-model-name="Fine-Tuned-Review-Autocompletion"を使用して呼び出した場合、新しいモデルは既存の登録済みモデルに v3 としてリンクされます。この名前の登録済みモデルが存在しない場合、新しいものが作成され、新しいモデルが v0 としてリンクされます。

import wandb

path = "/local/dir/model.pt"
registered_model_name = "Fine-Tuned-Review-Autocompletion"

run = wandb.init(project="llm-evaluation", entity="noa")
run.link_model(path=path, registered_model_name=registered_model_name)
run.finish()

7.3 - ログ テーブル

1. テーブルを作成する
2. データを追加する
3. データを取得する
4. テーブルを保存する

テーブルを作成する

Table（テーブル）を定義するには、各データ行に表示したい列を指定します。各行はトレーニングデータセットの単一の項目、トレーニング中の特定のステップやエポック、テスト項目でのモデルの予測、モデルが生成したオブジェクトなどです。各列には固定の型があり、数値、テキスト、ブール値、画像、ビデオ、オーディオなどがあります。あらかじめ型を指定する必要はありません。各列に名前を付け、その型のデータのみをその列のインデックスに渡してください。より詳細な例については、このレポート を参照してください。

wandb.Table コンストラクタを次の2つの方法のいずれかで使用します：

1. 行のリスト: 名前付きの列とデータの行をログに記録します。例えば、次のコードスニペットは 2 行 3 列のテーブルを生成します：

wandb.Table(columns=["a", "b", "c"], data=[["1a", "1b", "1c"], ["2a", "2b", "2c"]])

2. Pandas DataFrame: wandb.Table(dataframe=my_df) を使用して DataFrame をログに記録します。列の名前は DataFrame から抽出されます。

既存の配列またはデータフレームから

# モデルが4つの画像で予測を返したと仮定します
# 次のフィールドが利用可能です:
# - 画像ID
# - 画像ピクセル（wandb.Image() でラップ）
# - モデルの予測ラベル
# - 正解ラベル
my_data = [
    [0, wandb.Image("img_0.jpg"), 0, 0],
    [1, wandb.Image("img_1.jpg"), 8, 0],
    [2, wandb.Image("img_2.jpg"), 7, 1],
    [3, wandb.Image("img_3.jpg"), 1, 1],
]

# 対応する列で wandb.Table() を作成
columns = ["id", "image", "prediction", "truth"]
test_table = wandb.Table(data=my_data, columns=columns)

データを追加する

Tables は可変です。スクリプトが実行中に最大 200,000 行までテーブルにデータを追加できます。テーブルにデータを追加する方法は2つあります：

1. 行を追加する: table.add_data("3a", "3b", "3c")。新しい行はリストとして表現されないことに注意してください。行がリスト形式の場合は * を使ってリストを位置引数に展開します: table.add_data(*my_row_list)。行にはテーブルの列数と同じ数のエントリが含まれている必要があります。
2. 列を追加する: table.add_column(name="col_name", data=col_data)。col_data の長さは現在のテーブルの行数と同じである必要があります。ここで col_data はリストデータや NumPy NDArray でも構いません。

データを段階的に追加する

このコードサンプルは、次第に W&B テーブルを作成し、データを追加する方法を示しています。信頼度スコアを含む事前定義された列でテーブルを定義し、推論中に行ごとにデータを追加します。また、run を再開するときにテーブルにデータを段階的に追加することもできます。

# 各ラベルの信頼度スコアを含むテーブルの列を定義
columns = ["id", "image", "guess", "truth"]
for digit in range(10):  # 各数字 (0-9) に対する信頼度スコア列を追加
    columns.append(f"score_{digit}")

# 定義された列でテーブルを初期化
test_table = wandb.Table(columns=columns)

# テストデータセットを通過し、データを行ごとにテーブルに追加
# 各行は画像 ID、画像、予測されたラベル、正解ラベル、信頼度スコアを含みます
for img_id, img in enumerate(mnist_test_data):
    true_label = mnist_test_data_labels[img_id]  # 正解ラベル
    guess_label = my_model.predict(img)  # 予測ラベル
    test_table.add_data(
        img_id, wandb.Image(img), guess_label, true_label
    )  # テーブルに行データを追加

Run を再開した際にデータを追加

再開した Run において、既存のテーブルをアーティファクトから読み込み、最後のデータ行を取得して、更新されたメトリクスを追加することで W&B テーブルを段階的に更新できます。次に、互換性を保つためにテーブルを再初期化し、更新されたバージョンを W&B に再度ログに記録します。

# アーティファクトから既存のテーブルを読み込む
best_checkpt_table = wandb.use_artifact(table_tag).get(table_name)

# 再開のためにテーブルの最後のデータ行を取得
best_iter, best_metric_max, best_metric_min = best_checkpt_table.data[-1]

# 必要に応じて最高のメトリクスを更新

# テーブルに更新されたデータを追加
best_checkpt_table.add_data(best_iter, best_metric_max, best_metric_min)

# 更新されたデータでテーブルを再初期化し、互換性を確保
best_checkpt_table = wandb.Table(
    columns=["col1", "col2", "col3"], data=best_checkpt_table.data
)

# 更新されたテーブルを Weights & Biases にログする
wandb.log({table_name: best_checkpt_table})

データを取得する

データが Table にあるとき、列または行ごとにアクセスできます：

1. 行イテレータ: ユーザーは Table の行イテレータを利用して、for ndx, row in table.iterrows(): ... のようにデータの行を効率的に反復処理できます。
2. 列を取得する: ユーザーは table.get_column("col_name") を使用してデータの列を取得できます。convert_to="numpy" を渡すと、列を NumPy のプリミティブ NDArray に変換できます。これは、列に wandb.Image などのメディアタイプが含まれている場合に、基になるデータに直接アクセスするのに便利です。

テーブルを保存する

スクリプトでモデルの予測のテーブルなどのデータを生成した後、それを W&B に保存して結果をリアルタイムで視覚化します。

Run にテーブルをログする

wandb.log() を使用してテーブルを Run に保存します：

run = wandb.init()
my_table = wandb.Table(columns=["a", "b"], data=[["1a", "1b"], ["2a", "2b"]])
run.log({"table_key": my_table})

同じキーにテーブルがログに記録されるたびに、新しいバージョンのテーブルが作成され、バックエンドに保存されます。これにより、複数のトレーニングステップにわたって同じテーブルをログに記録し、モデルの予測がどのように向上するかを確認したり、異なる Run 間でテーブルを比較したりすることができます。同じテーブルに最大 200,000 行までログに記録できます。

プログラムによるテーブルへのアクセス

バックエンドでは、Tables は Artifacts として保存されています。特定のバージョンにアクセスする場合は、artifact API を使用して行うことができます：

with wandb.init() as run:
    my_table = run.use_artifact("run-<run-id>-<table-name>:<tag>").get("<table-name>")

Artifacts の詳細については、デベロッパーガイドの Artifacts チャプター を参照してください。

テーブルを視覚化する

この方法でログに記録されたテーブルは、Run ページと Project ページの両方でワークスペースに表示されます。詳細については、テーブルの視覚化と分析 を参照してください。

アーティファクトテーブル

artifact.add() を使用して、テーブルをワークスペースの代わりに Run の Artifacts セクションにログします。これは、データセットを1回ログに記録し、今後の Run のために参照したい場合に役立ちます。

run = wandb.init(project="my_project")
# 各重要なステップのために wandb Artifact を作成
test_predictions = wandb.Artifact("mnist_test_preds", type="predictions")

# [上記のように予測データを構築]
test_table = wandb.Table(data=data, columns=columns)
test_predictions.add(test_table, "my_test_key")
run.log_artifact(test_predictions)

画像データを使用した artifact.add() の詳細な例については、この Colab を参照してください: 画像データを使った artifact.add() の詳細な例 また Artifacts と Tables を使ったバージョン管理と重複排除データの例 に関してはこのレポートを参照してください。

アーティファクトテーブルを結合する

wandb.JoinedTable(table_1, table_2, join_key) を使用して、ローカルに構築したテーブルや他のアーティファクトから取得したテーブルを結合できます。

以前にアーティファクトコンテキストでログに記録した2つのテーブルを結合するには、アーティファクトからそれらを取得し、新しいテーブルに結合した結果を格納します。この例では、'original_songs' という名前のオリジナルの曲のテーブルと 'synth_songs' という名前の同じ曲の合成バージョンのテーブルを結合する方法を示しています。以下のコード例は 2 つのテーブルを "song_id" で結合し、結果のテーブルを新しい W&B テーブルとしてアップロードします：

import wandb

run = wandb.init(project="my_project")

# オリジナルの曲のテーブルを取得
orig_songs = run.use_artifact("original_songs:latest")
orig_table = orig_songs.get("original_samples")

# 合成曲のテーブルを取得
synth_songs = run.use_artifact("synth_songs:latest")
synth_table = synth_songs.get("synth_samples")

# "song_id" でテーブルを結合
join_table = wandb.JoinedTable(orig_table, synth_table, "song_id")
join_at = wandb.Artifact("synth_summary", "analysis")

# テーブルをアーティファクトに追加し W&B にログする
join_at.add(join_table, "synth_explore")
run.log_artifact(join_at)

このチュートリアルを読むと、異なるアーティファクトオブジェクトに保存された 2 つのテーブルを組み合わせる方法の例が示されています。

7.4 - ログサマリーメトリクス

時間とともに変化する値に加えて、モデルや前処理ステップを要約する単一の値を追跡することも重要です。この情報を W&B Run の summary 辞書にログします。Run の summary 辞書は numpy 配列、PyTorch テンソル、TensorFlow テンソルを扱うことができます。値がこれらのタイプのいずれかの場合、バイナリファイルにテンソル全体を保存し、メトリクスを summary オブジェクトに保存します。たとえば最小値、平均、分散、パーセンタイルなどです。

最後に wandb.log でログされた値は、自動的に W&B Run の summary 辞書に設定されます。summary メトリクス辞書が変更されると、以前の値は失われます。

次のコードスニペットは、W&B にカスタムの summary メトリクスを提供する方法を示しています。

wandb.init(config=args)

best_accuracy = 0
for epoch in range(1, args.epochs + 1):
    test_loss, test_accuracy = test()
    if test_accuracy > best_accuracy:
        wandb.summary["best_accuracy"] = test_accuracy
        best_accuracy = test_accuracy

トレーニングが完了した後、既存の W&B Run の summary 属性を更新することができます。W&B Public API を使用して、summary 属性を更新してください。

api = wandb.Api()
run = api.run("username/project/run_id")
run.summary["tensor"] = np.random.random(1000)
run.summary.update()

summary メトリクスをカスタマイズする

カスタム summary メトリクスは、トレーニングにおける最良のステップでのモデルのパフォーマンスを wandb.summary にキャプチャするのに便利です。たとえば、最終的な値の代わりに、最大精度や最小損失値をキャプチャしたいかもしれません。

デフォルトでは、summary は履歴からの最終的な値を使用します。summary メトリクスをカスタマイズするには、define_metric の中に summary 引数を渡します。以下の値を受け付けます。

• "min"
• "max"
• "mean"
• "best"
• "last"
• "none"

"best" を使用するには、任意の objective 引数を "minimize" または "maximize" に設定する必要があります。

次の例は、損失と精度の最小値と最大値を summary に追加する方法を示しています。

import wandb
import random

random.seed(1)
wandb.init()

# 損失の最小値および最大値を summary に追加
wandb.define_metric("loss", summary="min")
wandb.define_metric("loss", summary="max")

# 精度の最小値および最大値を summary に追加
wandb.define_metric("acc", summary="min")
wandb.define_metric("acc", summary="max")

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

summary メトリクスを閲覧する

Run の Overview ページまたはプロジェクトの runs テーブルで summary 値を表示することができます。

• Run Overview
• Run Table
• W&B Public API

1. W&B アプリに移動します。
2. Workspace タブを選択します。
3. runs のリストから、summary 値をログした run の名前をクリックします。
4. Overview タブを選択します。
5. Summary セクションで summary 値を表示します。

1. W&B アプリに移動します。
2. Runs タブを選択します。
3. runs テーブル内で、summary 値の名前に基づいて列内の summary 値を表示することができます。

W&B Public API を使用して、run の summary 値を取得することができます。

次のコード例は、W&B Public API と pandas を使用して特定の run にログされた summary 値を取得する方法の一例を示しています。

import wandb
import pandas

entity = "<your-entity>"
project = "<your-project>"
run_name = "<your-run-name>" # summary 値を持つ run の名前

all_runs = []

for run in api.runs(f"{entity}/{project_name}"):
  print("Fetching details for run: ", run.id, run.name)
  run_data = {
            "id": run.id,
            "name": run.name,
            "url": run.url,
            "state": run.state,
            "tags": run.tags,
            "config": run.config,
            "created_at": run.created_at,
            "system_metrics": run.system_metrics,
            "summary": run.summary,
            "project": run.project,
            "entity": run.entity,
            "user": run.user,
            "path": run.path,
            "notes": run.notes,
            "read_only": run.read_only,
            "history_keys": run.history_keys,
            "metadata": run.metadata,
        }
  all_runs.append(run_data)
  
# DataFrame に変換  
df = pd.DataFrame(all_runs)

# 列名（run）に基づいて行を取得し、辞書に変換
df[df['name']==run_name].summary.reset_index(drop=True).to_dict()

7.5 - ログ軸をカスタマイズする

define_metric を使用してカスタム x 軸を設定します。 カスタム x 軸は、トレーニング中に過去の異なるタイムステップに非同期でログを記録する必要がある場合に便利です。たとえば、RL ではエピソードごとの報酬やステップごとの報酬を追跡する場合に役立ちます。

Google Colab で define_metric を試す →

軸をカスタマイズする

デフォルトでは、すべてのメトリクスは同じ x 軸に対してログが記録されます。これは、 W&B 内部の step です。時には、以前のステップにログを記録したい場合や、別の x 軸を使用したい場合があります。

以下は、デフォルトのステップの代わりにカスタムの x 軸メトリクスを設定する例です。

import wandb

wandb.init()
# カスタム x 軸メトリクスを定義
wandb.define_metric("custom_step")
# どのメトリクスがそれに対してプロットされるかを定義
wandb.define_metric("validation_loss", step_metric="custom_step")

for i in range(10):
    log_dict = {
        "train_loss": 1 / (i + 1),
        "custom_step": i**2,
        "validation_loss": 1 / (i + 1),
    }
    wandb.log(log_dict)

x 軸はグロブを使用して設定することもできます。現在、文字列のプレフィックスを持つグロブのみが使用可能です。次の例では、プレフィックス "train/" を持つすべてのログされたメトリクスを、x 軸 "train/step" にプロットします:

import wandb

wandb.init()
# カスタム x 軸メトリクスを定義
wandb.define_metric("train/step")
# 他のすべての train/ メトリクスをこのステップに使用するように設定
wandb.define_metric("train/*", step_metric="train/step")

for i in range(10):
    log_dict = {
        "train/step": 2**i,  # W&B 内部ステップと指数的な成長
        "train/loss": 1 / (i + 1),  # x 軸は train/step
        "train/accuracy": 1 - (1 / (1 + i)),  # x 軸は train/step
        "val/loss": 1 / (1 + i),  # x 軸は内部 wandb ステップ
    }
    wandb.log(log_dict)

7.6 - 実験からプロットを作成して追跡する

Using the methods in wandb.plot, you can track charts with wandb.log, including charts that change over time during training. To learn more about our custom charting framework, check out this guide.

Basic charts

これらのシンプルなチャートにより、メトリクスと結果の基本的な可視化を簡単に構築できます。

• Line
• Scatter
• Bar
• Histogram
• Multi-line

wandb.plot.line()

カスタムなラインプロット、任意の軸上で順序付けられたポイントのリストをログします。

data = [[x, y] for (x, y) in zip(x_values, y_values)]
table = wandb.Table(data=data, columns=["x", "y"])
wandb.log(
    {
        "my_custom_plot_id": wandb.plot.line(
            table, "x", "y", title="Custom Y vs X Line Plot"
        )
    }
)

これは任意の2次元軸に曲線をログするために使用できます。二つの値のリストをプロットする場合、リスト内の値の数は正確に一致する必要があります。例えば、それぞれのポイントはxとyを持っている必要があります。

See in the app

Run the code

wandb.plot.scatter()

カスタムな散布図をログします—任意の軸xとy上のポイント（x, y）のリスト。

data = [[x, y] for (x, y) in zip(class_x_scores, class_y_scores)]
table = wandb.Table(data=data, columns=["class_x", "class_y"])
wandb.log({"my_custom_id": wandb.plot.scatter(table, "class_x", "class_y")})

これは任意の2次元軸に散布ポイントをログするために使用できます。二つの値のリストをプロットする場合、リスト内の値の数は正確に一致する必要があります。例えば、それぞれのポイントはxとyを持っている必要があります。

See in the app

Run the code

wandb.plot.bar()

カスタムな棒グラフをログします—数行でバーとしてラベル付けされた値のリストをネイティブに：

data = [[label, val] for (label, val) in zip(labels, values)]
table = wandb.Table(data=data, columns=["label", "value"])
wandb.log(
    {
        "my_bar_chart_id": wandb.plot.bar(
            table, "label", "value", title="Custom Bar Chart"
        )
    }
)

これは任意の棒グラフをログするために使用できます。リスト内のラベルと値の数は正確に一致する必要があります。それぞれのデータポイントは両方を持たなければなりません。

See in the app

Run the code

wandb.plot.histogram()

カスタムなヒストグラムをログします—発生のカウント/頻度でリスト内の値をビンへソートします—数行でネイティブに。予測信頼度スコア（scores）のリストがあって、その分布を可視化したいとします。

data = [[s] for s in scores]
table = wandb.Table(data=data, columns=["scores"])
wandb.log({"my_histogram": wandb.plot.histogram(table, "scores", title="Histogram")})

これは任意のヒストグラムをログするために使用できます。dataはリストのリストで、行と列の2次元配列をサポートすることを意図しています。

See in the app

Run the code

wandb.plot.line_series()

複数の線、または複数の異なるx-y座標ペアのリストを一つの共有x-y軸上にプロットします：

wandb.log(
    {
        "my_custom_id": wandb.plot.line_series(
            xs=[0, 1, 2, 3, 4],
            ys=[[10, 20, 30, 40, 50], [0.5, 11, 72, 3, 41]],
            keys=["metric Y", "metric Z"],
            title="Two Random Metrics",
            xname="x units",
        )
    }
)

xとyのポイントの数は正確に一致する必要があることに注意してください。複数のy値のリストに合ったx値のリストを一つ提供することも、または各y値のリストに対して個別のx値のリストを提供することもできます。

See in the app

Model evaluation charts

これらのプリセットチャートは、wandb.plotメソッド内蔵で、スクリプトからチャートを直接ログして、UIで正確に確認したい情報をすぐに把握できます。

• Precision-recall curves
• ROC curves
• Confusion matrix

wandb.plot.pr_curve()

Precision-Recall curve を1行で作成します：

wandb.log({"pr": wandb.plot.pr_curve(ground_truth, predictions)})

コードが以下のものにアクセスできるときに、これをログできます：

• 一連の例に対するモデルの予測スコア（predictions）
• それらの例に対応する正解ラベル（ground_truth）
• （オプションで）ラベル/クラス名のリスト（labels=["cat", "dog", "bird"...] で、ラベルインデックスが0はcat、1はdog、2はbirdを意味するなど）
• （オプションで）プロットで可視化するラベルのサブセット

See in the app

Run the code

wandb.plot.roc_curve()

ROC curve を1行で作成します：

wandb.log({"roc": wandb.plot.roc_curve(ground_truth, predictions)})

コードが以下のものにアクセスできるときに、これをログできます：

• 一連の例に対するモデルの予測スコア（predictions）
• それらの例に対応する正解ラベル（ground_truth）
• （オプションで）ラベル/クラス名のリスト（labels=["cat", "dog", "bird"...] で、ラベルインデックスが0はcat、1はdog、2はbirdを意味するなど）
• （オプションで）プロットで可視化するラベルのサブセット（まだリスト形式）

See in the app

Run the code

wandb.plot.confusion_matrix()

マルチクラスの混同行列 を1行で作成します：

cm = wandb.plot.confusion_matrix(
    y_true=ground_truth, preds=predictions, class_names=class_names
)

wandb.log({"conf_mat": cm})

コードが以下のものにアクセスできるときに、これをログできます：

• 一連の例に対するモデルの予測ラベル（preds）または正規化された確率スコア（probs）。確率は（例の数、クラスの数）という形でなければなりません。確率または予測のどちらでも良いですが両方を提供することはできません。
• それらの例に対応する正解ラベル（y_true）
• 文字列のラベル/クラス名のフルリスト（例：class_names=["cat", "dog", "bird"] で、インデックス0がcat、1がdog、2がbirdである場合）

​See in the app​

​Run the code

Interactive custom charts

完全なカスタマイズを行う場合、内蔵のCustom Chart presetを調整するか、新しいプリセットを作成し、チャートを保存します。チャートIDを使用して、そのカスタムプリセットに直接スクリプトからデータをログします。

# 作成したい列を持つテーブルを作成
table = wandb.Table(data=data, columns=["step", "height"])

# テーブルの列からチャートのフィールドへマップ
fields = {"x": "step", "value": "height"}

# 新しいカスタムチャートプリセットにテーブルを使用
# 自分の保存したチャートプリセットを使用するには、vega_spec_nameを変更
# タイトルを編集するには、string_fieldsを変更
my_custom_chart = wandb.plot_table(
    vega_spec_name="carey/new_chart",
    data_table=table,
    fields=fields,
    string_fields={"title": "Height Histogram"},
)

Run the code

Matplotlib and Plotly plots

W&BのCustom Chartsをwandb.plotで使用する代わりに、matplotlibやPlotlyで生成されたチャートをログすることができます。

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4])
plt.ylabel("some interesting numbers")
wandb.log({"chart": plt})

matplotlibプロットまたは図オブジェクトをwandb.log()に渡すだけです。デフォルトでは、プロットをPlotlyプロットに変換します。プロットを画像としてログしたい場合はwandb.Imageにプロットを渡すことができます。Plotlyチャートを直接受け入れることもできます。

Log custom HTML to W&B Tables

W&Bでは、PlotlyやBokehからインタラクティブなチャートをHTMLとしてログし、Tablesに追加することをサポートしています。

Log Plotly figures to Tables as HTML

インタラクティブなPlotlyチャートをwandb TablesにHTML形式でログできます。

import wandb
import plotly.express as px

# 新しいrunを初期化
run = wandb.init(project="log-plotly-fig-tables", name="plotly_html")

# テーブルを作成
table = wandb.Table(columns=["plotly_figure"])

# Plotly図のパスを作成
path_to_plotly_html = "./plotly_figure.html"

# 例のPlotly図
fig = px.scatter(x=[0, 1, 2, 3, 4], y=[0, 1, 4, 9, 16])

# Plotly図をHTMLに書き込み
# auto_playをFalseに設定すると、アニメーション付きのPlotlyチャートが自動的にテーブル内で再生されないようにします
fig.write_html(path_to_plotly_html, auto_play=False)

# Plotly図をHTMLファイルとしてTableに追加
table.add_data(wandb.Html(path_to_plotly_html))

# Tableをログ
run.log({"test_table": table})
wandb.finish()

Log Bokeh figures to Tables as HTML

インタラクティブなBokehチャートをwandb TablesにHTML形式でログできます。

from scipy.signal import spectrogram
import holoviews as hv
import panel as pn
from scipy.io import wavfile
import numpy as np
from bokeh.resources import INLINE

hv.extension("bokeh", logo=False)
import wandb


def save_audio_with_bokeh_plot_to_html(audio_path, html_file_name):
    sr, wav_data = wavfile.read(audio_path)
    duration = len(wav_data) / sr
    f, t, sxx = spectrogram(wav_data, sr)
    spec_gram = hv.Image((t, f, np.log10(sxx)), ["Time (s)", "Frequency (hz)"]).opts(
        width=500, height=150, labelled=[]
    )
    audio = pn.pane.Audio(wav_data, sample_rate=sr, name="Audio", throttle=500)
    slider = pn.widgets.FloatSlider(end=duration, visible=False)
    line = hv.VLine(0).opts(color="white")
    slider.jslink(audio, value="time", bidirectional=True)
    slider.jslink(line, value="glyph.location")
    combined = pn.Row(audio, spec_gram * line, slider).save(html_file_name)


html_file_name = "audio_with_plot.html"
audio_path = "hello.wav"
save_audio_with_bokeh_plot_to_html(audio_path, html_file_name)

wandb_html = wandb.Html(html_file_name)
run = wandb.init(project="audio_test")
my_table = wandb.Table(columns=["audio_with_plot"], data=[[wandb_html], [wandb_html]])
run.log({"audio_table": my_table})
run.finish()

7.7 - 実験管理で CSV ファイルを追跡する

W&B Python ライブラリを使用して、CSV ファイルをログし、W&B ダッシュボードで可視化します。W&B ダッシュボードは、機械学習モデルからの結果を整理し可視化する中心的な場所です。これは、W&B にログされていない以前の機械学習実験の情報を含む CSV ファイルやデータセットを含む CSV ファイルがある場合に特に便利です。

データセットの CSV ファイルをインポートしてログする

W&B Artifacts を使用することをお勧めします。CSV ファイルの内容を再利用しやすくするためです。

1. まず、CSV ファイルをインポートします。以下のコードスニペットでは、iris.csv ファイル名をあなたの CSV ファイル名に置き換えてください:

import wandb
import pandas as pd

# CSV を新しい DataFrame に読み込む
new_iris_dataframe = pd.read_csv("iris.csv")

2. CSV ファイルを W&B Table に変換し、W&B ダッシュボードを利用します。

# DataFrame を W&B Table に変換
iris_table = wandb.Table(dataframe=new_iris_dataframe)

3. 次に、W&B Artifact を作成し、テーブルを Artifact に追加します:

# テーブルを Artifact に追加し、行制限を 200,000 に増やし、再利用しやすくする
iris_table_artifact = wandb.Artifact("iris_artifact", type="dataset")
iris_table_artifact.add(iris_table, "iris_table")

# データを保存するために、生の CSV ファイルを Artifact 内にログする
iris_table_artifact.add_file("iris.csv")

W&B Artifacts についての詳細は、Artifacts チャプターを参照してください。

4. 最後に、wandb.init を使用して W&B で追跡しログするために新しい W&B Run を開始します:

# データをログするために W&B run を開始
run = wandb.init(project="tables-walkthrough")

# テーブルをログして run で可視化
run.log({"iris": iris_table})

# そして行制限を増やすためにアーティファクトとしてログ!
run.log_artifact(iris_table_artifact)

wandb.init() API は新しいバックグラウンドプロセスを開始し、データを Run にログし、デフォルトで wandb.ai に同期します。W&B ワークスペースダッシュボードでライブの可視化を表示します。以下の画像はコードスニペットのデモの出力を示しています。

以下は、前述のコードスニペットを含む完全なスクリプトです:

import wandb
import pandas as pd

# CSV を新しい DataFrame に読み込む
new_iris_dataframe = pd.read_csv("iris.csv")

# DataFrame を W&B Table に変換
iris_table = wandb.Table(dataframe=new_iris_dataframe)

# テーブルを Artifact に追加し、行制限を 200,000 に増やし、再利用しやすくする
iris_table_artifact = wandb.Artifact("iris_artifact", type="dataset")
iris_table_artifact.add(iris_table, "iris_table")

# データを保存するために、生の CSV ファイルを Artifact 内にログする
iris_table_artifact.add_file("iris.csv")

# データをログするために W&B run を開始
run = wandb.init(project="tables-walkthrough")

# テーブルをログして run で可視化
run.log({"iris": iris_table})

# そして行制限を増やすためにアーティファクトとしてログ!
run.log_artifact(iris_table_artifact)

# run を終了する (ノートブックで便利)
run.finish()