これは、このセクションの複数ページの印刷可能なビューです。 印刷するには、ここをクリックしてください.
W&B Models は、モデルを整理し、生産性とコラボレーションを向上させ、プロダクション規模での機械学習を提供したい機械学習エンジニアのための SoR です。
W&B Models を使用すると、次のことが可能です:
機械学習エンジニアは、実験をトラッキングして視覚化し、モデルのバージョンとリネージを管理し、ハイパーパラメーターを最適化するための ML SoR として W&B Models に依存しています。
数行のコードで機械学習実験を追跡します。その後、インタラクティブなダッシュボードで結果をレビューしたり、Public APIを使用してプログラムからアクセスできるようにPythonにデータをエクスポートすることができます。
人気のあるフレームワークを使用している場合は、W&Bのインテグレーションを活用してください。PyTorch、Keras、またはScikitのようなフレームワークがあります。インテグレーションの完全なリストや、W&Bをコードに追加する方法については、インテグレーションガイドをご覧ください。
上の画像は、複数のRunsでメトリクスを確認および比較できるダッシュボードの例を示しています。
数行のコードで機械学習実験を追跡します:
run.config）に保存します。run.log()）します。以下のコードは、一般的な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 Python SDKを使用して、機械学習実験をトラックします。その後、インタラクティブなダッシュボードで結果を確認するか、データをPythonにエクスポートしてプログラムでアクセスできます（W&B Public APIを参照）。
このガイドでは、W&Bのビルディングブロックを使用してW&B Experimentを作成する方法を説明します。
W&B Experimentを次の4つのステップで作成します：
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オブジェクトを返します。
wandb.init()を呼び出したときにプロジェクトが既に存在している場合、Runは既存のプロジェクトに追加されます。例えば、既に“cat-classification”という名前のプロジェクトがある場合、そのプロジェクトは既存のままで削除されず、新しい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アーティファクトをログします。アーティファクトは、データセットやモデルのバージョン管理を容易にします。
# 任意のファイルまたはディレクトリを保存できます。この例では、モデルが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を参照してください。
以下は、実験を作成する際に考慮すべきいくつかのガイドラインです：
wandb.init()をwith文で使用して、コードが完了したときや例外が発生したときにrunを自動的に終了させます。
Jupyterノートブックでは、Runオブジェクトを自分で管理する方が便利な場合があります。この場合、Runオブジェクトでfinish()を明示的に呼び出して完了をマークできます：
# ノートブックセル内で：
run = wandb.init()
# 別のセルで：
run.finish()
以下のコードスニペットは、上記のベストプラクティスを使用して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リファレンスガイドで参照してください。
run の config プロパティを使用して、トレーニング設定を保存します:
run.config プロパティを使用すると、実験を簡単に分析し、将来的に作業を再現できます。 W&B アプリで設定値ごとにグループ化し、さまざまな W&B Run の設定を比較し、各トレーニング設定が出力にどのように影響するかを評価できます。config プロパティは、複数の辞書のようなオブジェクトから構成できる辞書のようなオブジェクトです。
run.config ではなく run.log を使用してください。設定は通常、トレーニングスクリプトの最初に定義されます。ただし、機械学習ワークフローは異なる場合があるため、トレーニングスクリプトの最初に設定を定義する必要はありません。
設定変数名にはピリオド (.) の代わりにダッシュ (-) またはアンダースコア (_) を使用してください。
スクリプトが 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 は、引数パーサの短縮形で、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})
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.FLAGSabsl 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 のフラグを 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 のフラグを設定に追加します
A プロジェクト は、結果の可視化、実験の比較、アーティファクトの閲覧とダウンロード、オートメーションの作成などを行うための中央の場所です。
各プロジェクトには、サイドバーからアクセスできる次の項目が含まれています:
プロジェクトのワークスペースは、実験を比較するための個人的なサンドボックスを提供します。プロジェクトを使用して、比較できるモデルを整理し、異なるアーキテクチャー、ハイパーパラメーター、データセット、プロセッシングなどで同じ問題に取り組みます。
Runs Sidebar: プロジェクト内のすべての run のリスト。
Runs タブで列をピン止め、非表示、または順序を変更すると、Runs サイドバーにもこれらのカスタマイズが反映されます。
Panels layout: このスクラッチスペースを使用して、結果を探索し、チャートを追加および削除し、異なるメトリクスに基づいてモデルのバージョンを比較します。
セクションのドロップダウンメニューをクリックし、「Add section」をクリックして、セクションを作成します。セクションの名前を変更したり、ドラッグして順序を再編成したり、セクションを展開または折りたたむことができます。
各セクションには右上隅にオプションがあります:
ドラッグアンドドロップしてセクションに整理します。また、パネルの右上隅にある「Move」ボタンをクリックしてセクションを選択し、パネルを移動します。
ワークスペースの検索ボックスを使用してパネルを絞り込みます。この検索はパネルのタイトルに一致し、デフォルトでは表示されているメトリクスの名前となります。
Runs タブを使用して、run をフィルタリング、グループ化、およびソートします。
次のタブには、Runs タブで実行できる一般的な操作がいくつか示されています。
Runs タブは、プロジェクト内の run の詳細を表示します。デフォルトで多数の列が表示されます。
... をクリックし、次に Pin column をクリックします。ピン止めされた列は、ページの左側に、Name 列の後に表示されます。ピン止めされた列を取り除くには、Unpin column を選択します。... をクリックし、次に Hide column をクリックします。現在非表示のすべての列を表示するには、Columns をクリックします。Runs タブをカスタマイズすると、そのカスタマイズはWorkspace タブの Runs セレクタにも反映されます。
指定した列の値でテーブル内のすべての行をソートします。
上の画像は、val_acc というテーブル列のソートオプションを表示する方法を示しています。
ダッシュボードの左上の Filter ボタンを使って、式に基づいてすべての行をフィルタリングします。
Add filter を選択して、行に1つ以上のフィルターを追加します。3つのドロップダウンメニューが表示され、左から右にかけて、フィルターのタイプは次のようになります: 列名、演算子、および値
| 列名 | バイナリ関係 | 値 | |
|---|---|---|---|
| 許可される値 | String | =, ≠, ≤, ≥, IN, NOT IN, | 整数, 浮動小数点数, 文字列, タイムスタンプ, null |
式エディタは、オートコンプリートを使用して、列名と論理述語構造などの用語ごとのオプションのリストを表示します。複数の論理述部を使用して「ands」または「or」で式を組み合わせることができます（場合によっては括弧を使用します）。
上の画像は、`val_loss` 列に基づいたフィルターを示しています。このフィルターは、1以下の検証損失を持つ run を表示します。
特定の列の値で Group by ボタンを使い、すべての行をグループ化します。
デフォルトでは、これにより他の数値列がヒストグラムに変わり、グループ全体のその列の値の分布を示します。グループ化は、データ内の高レベルのパターンを理解するのに便利です。
結果のスナップショットを一か所で確認し、チームと学びを共有します。
スイープをプロジェクトから新たに開始します。
プロジェクトに関連付けられたすべてのArtifactsをトレーニングデータセットや ファインチューンされたモデルからメトリクスやメディアのテーブルまで表示します。
概要パネルでは、アーティファクトの名前やバージョン、変更を検出し重複を防止するために使用されるハッシュダイジェスト、作成日、およびエイリアスなど、アーティファクトに関するさまざまな高レベル情報を見つけることができます。ここでエイリアスを追加または削除し、バージョンおよびアーティファクト全体に対してメモを取ることができます。
メタデータパネルは、アーティファクトが構築されたときに提供されるメタデータへのアクセスを提供します。このメタデータには、アーティファクトを再構築するために必要な設定引数、詳細情報を見つけるためのURL、またはアーティファクトをログする際に生成されたメトリクスが含まれている場合があります。さらに、アーティファクトを生成する run の設定や、アーティファクトをログする際の履歴メトリクスを見ることができます。
Usage パネルは、ウェブアプリの外部で、例えばローカルマシン上で使用するためにアーティファクトをダウンロードするためのコードスニペットを提供します。このセクションはまた、アーティファクトを出力した run 及びアーティファクトを入力として使用する run へのリンクも示しています。
ファイルパネルは、アーティファクトに関連付けられたファイルとフォルダを一覧表示します。W&B は特定のファイルを run 用に自動的にアップロードします。例えば、requirements.txt は run が使用した各ライブラリのバージョンを示し、wandb-metadata.json および wandb-summary.json は run に関する情報を含みます。他のファイルもアーティファクトやメディアなど、run の設定に応じてアップロードされる場合があります。このファイルツリーをナビゲートし、W&B ウェブアプリで直接内容を確認することができます。
Artifacts に関連付けられたテーブルは、このコンテキストでは特にリッチでインタラクティブです。Artifacts で Tables を使用する方法についての詳細はこちらから学べます。
リネージパネルは、プロジェクトに関連付けられたすべてのアーティファクトとそれらをお互いに接続する run を表示します。run タイプはブロックとして、アーティファクトは円として表示され、与えられたタイプの run が与えられたタイプのアーティファクトを消費または生成するときに矢印で示されます。左側の列で選択された特定のアーティファクトのタイプが強調表示されます。
個々のアーティファクトバージョンとそれらを接続する特定の run を表示するには、爆発切り替えをクリックしてください。
アクションヒストリー監査タブは、コレクションのすべてのエイリアスアクションとメンバーシップの変更を示しており、リソースの進化全体を監査できます。
バージョン タブは、アーティファクトのすべてのバージョンと、バージョンがログ記録された時点での Run History の各数値のカラムを示しています。これにより、パフォーマンスを比較し、興味のあるバージョンを迅速に特定することができます。
プロジェクトにスターを付けると、そのプロジェクトを重要としてマークします。あなたとあなたのチームがスター付きで重要としてマークしたプロジェクトは、組織のホームページの上部に表示されます。
たとえば、次の画像では、zoo_experiment と registry_demo の 2 つのプロジェクトが重要としてマークされています。これらのプロジェクトは、組織のホームページの上部の スター付きプロジェクト セクション内に表示されています。
プロジェクトを重要としてマークする方法は2つあります: プロジェクトのオーバービュータブ内またはチームのプロファイルページ内です。
https://wandb.ai/<team>/<project-name> で W&B プロジェクトに移動します。
https://wandb.ai/<team>/projects に移動します。たとえば、次の画像は “Compare_Zoo_Models” プロジェクトの横にある星アイコンを示しています。
組織名を左上隅のアプリ内でクリックし、プロジェクトが組織のランディングページに表示されることを確認します。
プロジェクトを削除するには、オーバービュータブの右の三点リーダーをクリックします。
プロジェクトが空の場合は、右上のドロップダウンメニューをクリックして Delete project を選択し、削除できます。
プロジェクトにメモを追加するには、説明オーバービューまたはワークスペース内のマークダウンパネルとして行います。
ページに追加した説明は、プロファイルの Overview タブに表示されます。
W&B ワークスペースは、チャートをカスタマイズしモデル結果を探索するための個人のサンドボックスです。W&B ワークスペースは テーブル と パネルセクション で構成されています:
主に2つのWorkspaceカテゴリがあります: 個人用ワークスペース と 保存されたビュー です。
次の画像は、Cécile-parkerのチームメイトによって作成された複数の個人用ワークスペースを示しています。このプロジェクトには保存されたビューがありません:
チームのコラボレーションを向上させるために、カスタマイズされたワークスペースビューを作成します。保存されたビューを作成して、チャートとデータの好みのセットアップを整理します。
新しい保存されたビューはワークスペースナビゲーションメニューに表示されます。
保存された変更は、保存されたビューの以前の状態を上書きします。保存されていない変更は保持されません。W&Bで保存されたワークスペースビューを更新するには:
不要になった保存されたビューを削除します。
ワークスペースのURLを直接共有することで、カスタマイズしたワークスペースをチームと共有します。ワークスペースプロジェクトにアクセスできるすべてのユーザーが、そのワークスペースの保存されたビューを見ることができます。
wandb-workspaces は、W&B のワークスペースとレポートをプログラムで操作するためのPythonライブラリです。
wandb-workspaces を使用してワークスペースをプログラムで定義します。wandb-workspaces は、W&B のワークスペースとレポートをプログラムで操作するためのPythonライブラリです。
ワークスペースのプロパティを定義できます、例:
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 チュートリアルを参照してください。
W&B の run とは、W&B によってログ記録された単一の計算単位のことです。W&B の run をプロジェクト全体の原子要素として考えることができます。言い換えれば、各 run とは特定の計算の記録であり、モデルのトレーニング、結果のログ記録、ハイパーパラメータースイープなどを含みます。
run を開始する一般的なパターンには以下が含まれますが、これらに限定されません：
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 として実装します。
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 を保存します。
Uncategorized というプロジェクトに保存します。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 です。
run の末尾で run.finish() を指定して run を終了したことを示してください。これにより、run がプロジェクトに正しくログ記録され、バックグラウンドで継続されないようにするのに役立ちます。
import wandb
run = wandb.init(entity="<entity>", project="<project>")
# トレーニングコード、ログ記録など
run.finish()
各 run には、run の現在のステータスを示す状態があります。可能な run 状態の完全なリストについては Run states を参照してください。
次の表は、run がとりうる可能な状態を示しています：
| 状態 | 説明 |
|---|---|
| Finished | Run が終了し、完全にデータを同期した、または wandb.finish() を呼び出した |
| Failed | Run が終了し、非ゼロの終了ステータス |
| Crashed | Run は内部プロセスでハートビートを送信するのを停止しました（マシンがクラッシュした場合など） |
| Running | Run がまだ実行中で、最近ハートビートを送信している |
Run ID は run のための一意の識別子です。デフォルトでは、新しい run を初期化する際に、W&B はランダムで一意の run ID を生成します。また、run を初期化する際に独自の一意の run ID を指定することもできます。
run を初期化する際に run ID を指定しない場合、W&B はランダムな run ID を生成します。run の一意の ID は W&B App UI で確認できます。
W&B は Run path フィールドに一意の run ID を表示します。run path はチーム名、プロジェクト名、run ID で構成されています。一意の ID は run path の最後の部分です。
たとえば、以下の画像では、一意の run ID は 9mxi1arc です：
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 の実際の値のためのプレースホルダーです。
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 ページの Overview タブやプロジェクトページの run 一覧表に表示されます。
W&B App またはプログラムを使用して run を停止します。
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 がもはやアクティブではないことを確認します：
legendary-meadow-2 です。State フィールドの隣で、run の状態が running から Killed に変わります。
State フィールドの隣で、run の状態が running から Killed に変わります。
State fields を参照し、run の可能な状態の完全なリストを確認してください。
run の状態、run にログ記録されたアーティファクト、run 中に記録されたログファイルなど、特定の run に関する情報を表示します。
特定の run を表示するには：
https://wandb.ai/home の W&B App UI に移動します。
run を初期化した際に指定した W&B プロジェクトに移動します。
プロジェクトのサイドバー内で Workspace タブを選択します。
run セレクタ内で表示したい run をクリックするか、部分的な run 名を入力して一致する runs をフィルターします。
デフォルトでは、長い run 名は読みやすくするために途中で切り詰められます。run 名を最初または最後で切り詰めるには、run リストの上部のアクション ... メニューをクリックし、Run name cropping を最初、途中、または最後で切り取るように設定します。
特定の run の URL パスの形式は次のとおりです：
https://wandb.ai/<team-name>/<project-name>/runs/<run-id>
ここで、角括弧 (< >) で囲まれた値は、チーム名、プロジェクト名、および run ID の実際の値のためのプレースホルダーです。
プロジェクト内で特定の run 情報を知るために Overview タブを使用してください。
entity/project/run-ID 形式で一意の run ID を識別します。baseline や production）を適用するのに便利です。W&B は概要セクションの下に次の情報を保存します：
wandb.configで保存された設定パラメータのリスト。wandb.log()で保存されたサマリーパラメータのリスト。デフォルトでは、W&B はこの値を最後にログ記録した値に設定します。
こちらでプロジェクトの概要の例を確認できます here。
Workspace タブを使用して、生成されたプロットやカスタムプロット、システムメトリクスなどの可視化を表示、検索、グループ化、および配置してください。
こちらでワークスペースの例を確認できます here
Runs タブを使用して、run をフィルタリング、グループ化、並べ替えます。
Runs タブで実行できる一般的なアクションを以下のタブで示しています。
Runs タブには、プロジェクト内の run の詳細が表示されます。デフォルトでは多くの列が表示されます。
... をクリックしてから Pin column をクリックします。固定された列はページの左側に近い位置に表示されます。固定列を解除するには、Unpin column を選択します。... をクリックしてから Hide column をクリックします。現在非表示のすべての列を表示するには、Columns をクリックします。Runs タブをカスタマイズすると、そのカスタマイズは Workspace タブ の Runs セレクタにも反映されます。
Table のある列の値で全行を並べ替えます。
上記の画像は、val_acc と呼ばれる Table 列の並べ替えオプションを表示する方法を示しています。
フィルターボタン上の式を使用したすべての行のフィルタリング、ダッシュボード上部のフィルターボタンを使用できます。
行に1つ以上のフィルターを追加するには、Add filter を選択します。3 つのドロップダウンメニューが表示されます。左から右へのフィルタータイプは、列名、オペレーター、値に基づいています。る。
| 列名 | 二項関係 | 値 | |
|---|---|---|---|
| 受け入れ値 | ストリング | =, ≠, ≤, ≥, IN, NOT IN, | 整数、浮動小数点、ストリング、タイムスタンプ、null |
行編集案では、列名と論理述語構造に基づいてオートコンプリートを行い、各項目のオプションを示します。複数の論理述語を使用して「and」または「or」（場合によっては括弧）で1つの式に接続できます。
上記の画像は、`val_loss` 列に基づいたフィルターを示しています。フィルターは、検証損失が1以下の run を表示します。
ダッシュボード上の Group by ボタンを使用して、特定の列の値で全行をグループ化します。
デフォルトでは、これにより他の数値列が、その列のグループ全体の値の分布を示すヒストグラムに変わります。グループ化は、データ内のより高水準のパターンを理解するのに役立ちます。
Log tab には、標準出力 (stdout) や標準エラー (stderr) などのコマンドラインに出力されたものが表示されます。
右上の「ダウンロード」ボタンを選択してログファイルをダウンロードします。
ログタブの例はこちらから見ることができます here.
Files tab を使用して、特定の run に関連付けられたファイル（モデルチェックポイント、検証セット例など）を表示してください。
ファイルタブの例はこちらから見ることができます here.
Artifacts タブには、指定した run の入力および出力 Artifacts が一覧表示されます。
Artifacts タブの例はこちらから見ることができます here.
W&B App を使用してプロジェクトから 1 つ以上の run を削除します。
このセクションでは、グループとジョブタイプを使用して run を整理する方法についての手順を紹介します。 run をグループ（たとえば、実験名）に割り当て、ジョブタイプ（たとえば、前処理、トレーニング、評価、デバッグ）を指定することで、ワークフローを簡素化し、モデルの比較を改善できます。
W&B の各 run は グループ と ジョブタイプ で分類できます：
preprocessing や training、evaluation のようなものです。次のワークスペースの例では、Fashion-MNIST データセットからの増加するデータ量を使用してベースラインモデルをトレーニングしています。ワークスペースは使用されたデータ量を示すために色を使用します：
W&B のフィルタリングオプションや検索バーを使用して、次のような特定の条件に基づいて run を比較します：
フィルターを適用する際、Table ビューは自動的に更新されます。これにより、モデル間のパフォーマンスの違い（たとえば、どのクラスが他のモデルと比べてはるかに難しいか）を特定することができます。
プロジェクトページを使用して、W&B にログされた run からインサイトを得ることができます。Workspace ページと Runs ページの両方で、run をフィルタリングおよび検索できます。
ステータス、タグ、またはその他のプロパティに基づいて、フィルター ボタンを使用して run をフィルタリングします。
フィルター ボタンを使用して、タグに基づいて run をフィルタリングします。
正規表現で望む結果が得られない場合は、タグを使用して Runs Table で run をフィルタリングすることができます。タグは run 作成時、または完了後に追加できます。一旦タグが run に追加されると、以下の gif に示されているように、タグ フィルターを追加できます。
指定した正規表現を使用して run を見つけるには、regex を使用します。検索ボックスにクエリを入力すると、ワークスペースのグラフで表示される run がフィルタリングされ、テーブルの行もフィルタリングされます。
1 つまたは複数の列（隠し列を含む）で run をグループ化するには:
ログされたメトリクスの最小値または最大値で run テーブルを並べ替えます。これは、記録された最良または最悪の値を表示したい場合に特に便利です。
次の手順は、記録された最小値または最大値に基づいて特定のメトリクスで run テーブルを並べ替える方法を説明します：
クライアントプロセスからの最後のハートビートをログする End Time という名前の列を提供します。このフィールドはデフォルトでは非表示になっています。
すべての run、ハイパーパラメーター、およびサマリーメトリクスのテーブルを、ダウンロード ボタンを使用して CSV にエクスポートします。
run を初期化する際に fork_from を使用して、既存の W&B run から"フォーク"します。run をフォークすると、W&B はソース run の run ID と step を使用して新しい run を作成します。
run をフォークすることで、元の run に影響を与えずに、実験の特定のポイントから異なるパラメータやモデルを探索することができます。
wandb SDK バージョン >= 0.16.5 が必要ですdefine_metric()で定義された非単調なステップを使用してフォークポイントを設定することはできません。これは、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 への一貫性のある変更不可能な参照を保証します。ユーザーインターフェースから不変の run ID を取得するには、次の手順に従います:
Overview タブにアクセスする: ソース run のページで Overview タブ に移動します。
不変の Run ID をコピーする: Overview タブの右上隅にある ... メニュー（三点ドット）をクリックします。ドロップダウンメニューから Copy Immutable Run ID オプションを選択します。
これらの手順を追うことで、フォークされた 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()
フォークは、あなたの run を管理し実験する上でより多くの柔軟性を提供することにより、巻き戻しを補完します。
run をフォークする際、W&B は特定のポイントで run から新しいブランチを作成し、異なるパラメータやモデルを試みることができます。
run を巻き戻す際、W&B は run 履歴自体を修正または変更することができます。
このページでは、run を別のプロジェクト間で、またはチーム内外、またはあるチームから別のチームへの移動方法を示します。現在の場所と新しい場所の両方で run へのアクセス権が必要です。
wandb artifact get SDK コマンドや Api.artifact API を使用してアーティファクトをダウンロードしてから、wandb artifact put や Api.artifact API を使用して、run の新しい場所にアップロードします。Runs タブをカスタマイズするには、Project page を参照してください。
run をあるプロジェクトから別のプロジェクトに移動するには:
あなたがメンバーであるチームに run を移動するには:
runを巻き戻すオプションはプライベートプレビューです。この機能へのアクセスをリクエストするには、W&Bサポート(support@wandb.com)までお問い合わせください。
現在、W&Bがサポートしていないもの:
0.17.1 が必要です。define_metric()で定義された非単調ステップを使用することはできません。runを巻き戻して、元のデータを失うことなくrunの履歴を修正または変更します。さらに、runを巻き戻すと、その時点から新しいデータをログすることができます。W&Bは、新しい履歴に基づく巻き戻し対象のrunのサマリーメトリクスを再計算します。これは以下の振る舞いを意味します:
runを巻き戻すと、W&Bは指定されたステップにrunの状態をリセットし、元のデータを保持し、一貫したrun IDを維持します。これは次のことを意味します:
フォークは巻き戻しと補完し合います。
runからフォークすると、W&Bは特定のポイントでrunを分岐させて異なるパラメータやモデルを試します。
runを巻き戻すと、W&Bは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を巻き戻した後、W&B App UIでアーカイブされたrunを探索できます。以下のステップに従ってアーカイブされたrunを表示します:
Forked Fromフィールドを見つけます。このフィールドは再開の履歴を記録します。Forked Fromフィールドにはソースrunへのリンクが含まれており、オリジナルのrunに遡り、全体の巻き戻し履歴を理解することができます。Forked Fromフィールドを使用することで、アーカイブされた再開のツリーを簡単にナビゲートし、それぞれの巻き戻しの順序と起源についての洞察を得ることができます。
巻き戻された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()
実行が停止またはクラッシュした場合にどのように動作するべきかを指定します。実行を再開または自動的に再開するためには、その実行に関連付けられた一意の実行IDをidパラメータとして指定する必要があります。
run = wandb.init(entity="<entity>", \
project="<project>", id="<run ID>", resume="<resume>")
W&Bがどのように対応するかを決定するために、次の引数の1つをresumeパラメータに渡します。各場合において、W&Bは最初に実行IDが既に存在するかを確認します。
| 引数 | 説明 | 実行IDが存在する場合 | 実行IDが存在しない場合 | ユースケース |
|---|---|---|---|---|
"must" |
W&Bは実行IDで指定された実行を再開する必要があります。 | 同じ実行IDで実行を再開します。 | W&Bがエラーを発生させます。 | 同じ実行IDを使用する必要がある実行を再開します。 |
"allow" |
実行IDが存在する場合、W&Bが実行を再開することを許可します。 | 同じ実行IDで実行を再開します。 | 指定された実行IDで新しい実行を初期化します。 | 既存の実行を上書きせずに実行を再開します。 |
"never" |
実行IDで指定された実行をW&Bが再開することを許可しない。 | W&Bがエラーを発生させます。 | 指定された実行IDで新しい実行を初期化します。 |
resume="auto"を指定することで、W&Bが自動的にあなたの代わりに実行を再開しようとします。ただし、同じディレクトリーから実行を再開することを保証する必要があります。詳細は、実行を自動的に再開する設定を有効にするセクションを参照してください。
以下の例では、<>で囲まれた値をあなた自身のものに置き換えてください。
実行が停止、クラッシュ、または失敗した場合、同じ実行IDを使用して再開できます。これを行うには、実行を初期化し、以下を指定します。
resumeパラメータを"must"に設定します（resume="must"）。以下のコードスニペットは、W&B Python SDKでこれを達成する方法を示しています。
run = wandb.init(entity="<entity>", \
project="<project>", id="<run ID>", resume="must")
複数のプロセスが同じidを同時に使用すると予期しない結果が発生します。
複数プロセスの管理方法については、分散トレーニング実験のログを参照してください。
停止またはクラッシュした実行を、既存の実行を上書きせずに再開します。これは、プロセスが正常に終了しない場合に特に役立ちます。次回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または環境変数を使用して実行を自動的に再開する方法を示します。
以下のコードスニペットは、Python SDKでW&B実行IDを指定する方法を示しています。
<>で囲まれた値をあなた自身のものに置き換えてください。
run = wandb.init(entity="<entity>", \
project="<project>", id="<run ID>", resume="<resume>")
次の例は、bashスクリプトでW&B WANDB_RUN_ID変数を指定する方法を示しています。
RUN_ID="$1"
WANDB_RESUME=allow WANDB_RUN_ID="$RUN_ID" python eval.py
ターミナル内で、W&B実行IDと共にシェルスクリプトを実行できます。次のコードスニペットは実行ID akj172を渡します。
sh run_experiment.sh akj172
例えば、train.pyというPythonスクリプトをUsers/AwesomeEmployee/Desktop/ImageClassify/training/というディレクトリーで実行するとします。train.py内で、自動再開を有効にする実行が作成されます。次にトレーニングスクリプトが停止されたとします。この実行を再開するには、Users/AwesomeEmployee/Desktop/ImageClassify/training/内でtrain.pyスクリプトを再起動する必要があります。
WANDB_RUN_ID環境変数を指定するか、W&B Python SDKで実行IDを渡します。実行IDの詳細は、“What are runs?“ページのカスタム実行IDセクションを参照してください。中断されたスイープ実行を自動的に再キューします。これは、スイープエージェントを停止の対象となる計算環境（SLURMジョブの中断可能なキュー、EC2スポットインスタンス、Google Cloud中断可能VMなど）で実行する場合に特に役立ちます。
mark_preempting関数を使用して、W&Bが中断されたスイープ実行を自動的に再キューできるようにします。以下のコードスニペットの例
run = wandb.init() # 実行を初期化
run.mark_preempting()
以下の表は、スイープ実行の終了ステータスに基づいてW&Bが実行をどのように扱うかを概説しています。
| ステータス | 振る舞い |
|---|---|
| ステータスコード0 | 実行は成功裏に終了したと見なされ、再キューされません。 |
| 非ゼロステータス | W&Bは自動的に実行をスイープに関連付けられたランキューに追加します。 |
| ステータスなし | 実行はスイープランキューに追加されます。スイープエージェントは、キューが空になるまでランキューから実行を消費します。キューが空になると、スイープキューはスイープ検索アルゴリズムに基づいて新しい実行の生成を再開します。 |
個々のジョブを実験としてグループ化するには、一意のグループ名を**wandb.init()**に渡します。
グループ化を設定する方法は3つあります:
オプションで group と job_type を wandb.init() に渡します。これにより、各実験に対して専用のグループページが作成され、個々のrunが含まれます。例: wandb.init(group="experiment_1", job_type="eval")
WANDB_RUN_GROUP を使用して、runのグループを環境変数として指定します。詳細はEnvironment Variablesをご覧ください。Groupはプロジェクト内で一意である必要があり、グループ内のすべてのrunで共有されます。wandb.util.generate_id() を使用して、すべてのプロセスで使用するための一意の8文字の文字列を生成することができます。例: os.environ["WANDB_RUN_GROUP"] = "experiment-" + wandb.util.generate_id()
任意の設定列で動的にグループ化できます。例として、wandb.config を使用してバッチサイズまたは学習率をログすると、それらのハイパーパラメーターでWebアプリ内で動的にグループ化できます。
wandb.init()でグループ化を設定したと仮定すると、UIではデフォルトでrunがグループ化されます。テーブルの上部にあるGroupボタンをクリックして、これをオン・オフすることができます。こちらはグループ化を設定したサンプルコードから生成された例のプロジェクトです。サイドバーの各「グループ」行をクリックすると、その実験の専用グループページにアクセスできます。
上記のプロジェクトページから、左サイドバーでGroupをクリックすると、このような専用ページにアクセスできます。
任意の列でrunをグループ化できます。例として、ハイパーパラメーターでグループ化することができます。これがどのように見えるかの例です：
グループ化ボタンをクリックし、グループフィールドをいつでもクリアすることで、テーブルとグラフをグループ化されていない状態に戻します。
グラフの右上にある編集ボタンをクリックし、Advancedタブを選択して線と陰影を変更します。各グループの線には平均、最小、最大値を選択できます。陰影については無効にしたり、最小と最大、標準偏差、標準誤差を表示することができます。
特定の特徴を持つ runs にタグを追加して、ログされたメトリクスやアーティファクトデータからは見えない情報をラベル付けできます。
たとえば、ある run のモデルが in_production であること、run が preemptible であること、この run が baseline を表していることなどを示すためにタグを追加できます。
プログラムによって、または対話的に runs にタグを追加します。
あなたのユースケースに基づいて、以下のタブからニーズに最も合ったものを選択してください。
run が作成されるときにタグを追加できます:
import wandb
run = wandb.init(
entity="entity",
project="<project-name>",
tags=["tag1", "tag2"]
)
run を初期化した後でもタグを更新できます。たとえば、特定のメトリクスが事前に定義されたしきい値を超えた場合、タグを更新する方法を示すコードスニペットです:
import wandb
run = wandb.init(
entity="entity",
project="capsules",
tags=["debug"]
)
# モデルをトレーニングするための Python ロジック
if current_loss < threshold:
run.tags = run.tags + ("release_candidate",)
run を作成した後、Public APIを使用してタグを更新することができます。例:
run = wandb.Api().run("{entity}/{project}/{run-id}")
run.tags.append("tag1") # ここで run データに基づいてタグを選択できます
run.update()
このメソッドは、同じタグまたは複数のタグを大量の runs にタグ付けするのに最も適しています。
このメソッドは、1つの run に手動でタグを適用するのに最も適しています。
W&B App の UI を使って、runs からタグを削除することもできます。
このメソッドは、大量の runs からタグを削除するのに最も適しています。
run がクラッシュしたり、カスタムトリガーで Slack やメールでアラートを作成します。例えば、トレーニングループの勾配が膨らみ始めた場合（NaNを報告）や、ML パイプライン内のステップが完了した場合などです。アラートは、個人およびチームプロジェクトの両方を含む、run を初期化するすべての Projects に適用されます。
その後、Slack（またはメール）で W&B Alerts メッセージを確認します。
以下のガイドは、マルチテナントクラウドでのアラートにのみ適用されます。
プライベートクラウドまたは W&B 専用クラウドで W&B Server を使用している場合は、Slack アラートの設定についてはこちらのドキュメントを参照してください。
アラートを設定するための主なステップは2つあります。
run.alert() を追加するUser Settings の中で：
run.alert() からのアラートを受け取りますW&B Alerts を初めて設定する際、またはアラートの受け取り方を変更したい場合にのみ、これを行う必要があります。
run.alert() を追加するノートブックや Python スクリプトのどこでトリガーしたいかに run.alert() をコードに追加します。
import wandb
run = wandb.init()
run.alert(title="High Loss", text="Loss is increasing rapidly")
アラートメッセージのために 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 チャンネルを使用することをお勧めします。
アラートの送信先を変更するには、Disconnect Slack をクリックして、再接続してください。再接続後、別の Slack チャンネルを選択します。
W&B を Jupyter と組み合わせることで、ノートブックを離れることなくインタラクティブな可視化を実現できます。カスタム分析、実験管理、プロトタイプをすべて完全にログしながら結合します。
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
# ここにトレーニングループ
この例のノートブックで試してみてください。
既存のダッシュボード、スイープ、またはレポートをノートブック内で直接表示することも可能です。%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
wandb.init を呼び出すと、ブラウザーで W&B にログインしている場合、ランタイムを自動的に認証します。run ページの Overviewタブに Colab へのリンクが表示されます。%wandb マジックはプロジェクト、スイープ、またはレポートへのパスを受け取り、W&B インターフェイスをノートブック内に直接レンダリングします。wandb docker --jupyter を呼び出して、dockerコンテナを起動し、コードをマウントし、Jupyter がインストールされていることを確認し、ポート 8888 で起動します。wandb.init が呼び出されるまで run を finished としてマークしません。それにより、複数のセル（例: データを設定するセル、トレーニングするセル、テストするセル）を任意の順序で実行し、すべて同じ run にログできます。設定でコード保存をオンにすると、実行順序と状態で実行されたセルもログされ、最も非線形なパイプラインでさえ再現できます。Jupyter ノートブックで run を手動で完了としてマークするには、run.finish を呼び出してください。import wandb
run = wandb.init()
# トレーニングスクリプトとログはここに
run.finish()
W&B Python SDK を使用して、メトリクス、メディア、またはカスタムオブジェクトの辞書をステップにログします。W&B は各ステップごとにキーと値のペアを収集し、wandb.log() でデータをログするたびにそれらを統一された辞書に格納します。スクリプトからログされたデータは、wandb と呼ばれるディレクトリにローカルに保存され、その後 W&B クラウドまたは プライベートサーバー に同期されます。
step に異なる値をログした場合、W&B はすべての収集されたキーと値をメモリに書き込みます。デフォルトでは、wandb.log を呼び出すたびに新しい step になります。W&B は、チャートやパネルを作成する際にステップをデフォルトの x 軸として使用します。カスタムの x 軸を作成して使用するか、カスタムの要約メトリックをキャプチャすることも選択できます。詳細は、ログの軸をカスタマイズするを参照してください。
wandb.log() を使用して、各 step の連続する値をログします: 0, 1, 2, といった具合です。特定の履歴ステップに書き込むことは不可能です。W&B は「現在」と「次」のステップにのみ書き込みます。W&B は、W&B Experiment 中に次の情報を自動でログします：
nvidia-smi で取得されます。アカウントの Settings ページでコードの保存をオンにして、以下をログします：
diff.patch ファイルも表示されます。requirements.txt ファイルがアップロードされ、run ページのファイルタブに表示されます。run 用に wandb ディレクトリに保存したファイルも含まれます。W&B を使用することで、ログしたいものを正確に決定できます。次に、よくログされるオブジェクトのリストを示します：
wandb.plot を wandb.log と一緒に使用します。詳細はログでのグラフを参照してください。wandb.Table を使用してデータをログし、W&B でビジュアライズおよびクエリを行います。詳細はログでのテーブルを参照してください。wandb.watch(model) を追加します。wandb.init(config=your_config_dictionary)。詳細はPyTorch インテグレーションページをご覧ください。wandb.log を使用してモデルのメトリクスを表示します。トレーニングループ内で精度や損失のようなメトリクスをログすると、UI にライブ更新グラフが表示されます。wandb.run.summary["best_accuracy"] = best_accuracywandb.log の同じ呼び出し内で複数のメトリクスをログすると、例えばこうなります: wandb.log({"acc": 0.9, "loss": 0.1})。UI ではどちらもプロットすることができます。wandb.log({'acc': 0.9, 'epoch': 3, 'batch': 117})。特定のメトリクスに対するデフォルトの x 軸を設定するには、Run.define_metric() を使用してください。wandb.log は、画像やビデオのようなメディアからtablesやchartsに至るまで、多様なデータタイプのログをサポートしています。Experiments やログのためのベストプラクティスとヒントについては、Best Practices: Experiments and Logging を参照してください。
私たちは画像、ビデオ、音声などをサポートしています。リッチメディアをログして、結果を探索し、Run、Models、Datasetsを視覚的に比較しましょう。例やハウツーガイドは以下をご覧ください。
W&B SDKを使用してメディアオブジェクトをログするためには、追加の依存関係をインストールする必要があるかもしれません。以下のコマンドを実行してこれらの依存関係をインストールできます：
pip install wandb[media]
画像をログして、入力、出力、フィルター重み、活性化状態などを追跡しましょう。
画像はNumPy配列、PIL画像、またはファイルシステムから直接ログできます。
ステップごとに画像をログするたびに、UIに表示するために保存されます。画像パネルを拡大し、ステップスライダーを使用して異なるステップの画像を確認します。これにより、トレーニング中にモデルの出力がどのように変化するかを比較しやすくなります。
配列を手動で画像として構築する際に、make_grid from torchvisionを使用するなど、配列を直接提供します。
配列はPillowを使用してpngに変換されます。
images = wandb.Image(image_array, caption="Top: Output, Bottom: Input")
wandb.log({"examples": images})
最後の次元が1の場合はグレースケール、3の場合はRGB、4の場合はRGBAと仮定します。配列が浮動小数点数を含む場合、それらを0から255の整数に変換します。異なる方法で画像を正規化したい場合は、modeを手動で指定するか、"Logging PIL Images"タブで説明されているように、単にPIL.Imageを提供することができます。
配列から画像への変換を完全に制御するために、PIL.Imageを自分で構築し、直接提供してください。
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キーワード引数に以下のキーと値を持つ辞書を提供する必要があります：
"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つの形式のいずれか。すべてのボックスが同じ形式を使用する必要はありません。
{"minX", "maxX", "minY", "maxY"}。各ボックスの次元の上下限を定義する座標セットを提供します。{"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,
}
},
)
リスト、配列、テンソルなどの数字のシーケンスが最初の引数として提供されると、自動的に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ポイントクラウドとバウンディングボックスを持つLidarシーンをログします。レンダリングするポイントの座標と色を含むNumPy配列を渡します。
point_cloud = np.array([[0, 0, 0, COLOR]])
wandb.log({"point_cloud": wandb.Object3D(point_cloud)})
:::info W&B UIはデータを30万ポイントに制限します。 :::
色のスキームに柔軟性を持たせるために、3つの異なるデータ形式のNumPy配列がサポートされています。
[[x, y, z], ...] nx3[[x, y, z, c], ...] nx4, cは範囲[1, 14]内のカテゴリ （セグメンテーションに便利）[[x, y, z, r, g, b], ...] nx6 | r,g,b は赤、緑、青のカラー チャネルに対して範囲[0,255]の値このスキーマを使用して、Pythonオブジェクトを定義し、以下に示すように the from_point_cloud method に渡すことができます。
pointsは、単純なポイントクラウドレンダラーで上記に示されたのと同じフォーマットを使用してレンダリングするポイントの座標と色を含むNumPy配列です。boxesは3つの属性を持つPython辞書のNumPy配列です：
corners - 8つのコーナーのリストlabel - ボックスにレンダリングされるラベルを表す文字列 (オプション)color - ボックスの色を表すrgb値score - バウンディングボックスに表示される数値で、表示するバウンディングボックスのフィルタリングに使用できます（例：score > 0.75のバウンディングボックスのみを表示する）。(オプション)typeはレンダリングされるシーンタイプを表す文字列です。現在サポートされている値はlidar/betaのみです。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",
)})
ポイントクラウドを表示するとき、Controlキーを押しながらマウスを使用すると、内部空間を移動できます。
the from_file method を使用して、ポイントクラウドデータが満載のJSONファイルをロードできます。
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"
}
上記で定義された配列フォーマットを使用して、numpy配列を直接 the from_numpy method でポイントクラウドを定義できます。
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")})
分子データはpdb、pqr、mmcif、mcif、cif、sdf、sd、gro、mol2、mmtf.のいずれかの10のファイル形式でログできます。
W&Bはまた、SMILES文字列、rdkitのmolファイル、rdkit.Chem.rdchem.Molオブジェクトからの分子データのログをサポートします。
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"),
}
)
runが終了すると、UIで分子の3D可視化と対話できるようになります。
wandb.Imageはnumpy配列やPILImageのインスタンスをデフォルトでPNGに変換します。
wandb.log({"example": wandb.Image(...)})
# または複数の画像
wandb.log({"example": [wandb.Image(...) for img in images]})
ビデオはwandb.Video データ型を使用してログします：
wandb.log({"example": wandb.Video("myvideo.mp4")})
現在、メディアブラウザでビデオを見ることができます。 プロジェクトワークスペース、runワークスペース、またはレポートに移動し、Add visualization をクリックしてリッチメディアパネルを追加します。
wandb.Imageデータ型とrdkitを使用して分子の2Dビューをログできます:
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)})
W&Bは、さまざまな他のメディアタイプのログもサポートしています。
wandb.log({"whale songs": wandb.Audio(np_array, caption="OooOoo", sample_rate=32)})
1ステップあたりの最大100のオーディオクリップをログできます。詳細な使い方については、audio-fileを参照してください。
wandb.log({"video": wandb.Video(numpy_array_or_path_to_video, fps=4, format="gif")})
numpy配列が供給された場合、時間、チャンネル、幅、高さの順であると仮定します。 デフォルトでは4fpsのgif画像を作成します（numpyオブジェクトを渡す場合、ffmpegとmoviepy pythonライブラリが必要です）。 サポートされているフォーマットは、"gif"、"mp4"、"webm"、そして"ogg"です。wandb.Video に文字列を渡すと、ファイルが存在し、wandbにアップロードする前にサポートされたフォーマットであることを確認します。 BytesIOオブジェクトを渡すと、指定されたフォーマットを拡張子とする一時ファイルを作成します。
W&BのRunとProjectページで、メディアセクションにビデオが表示されます。
詳細な使い方については、video-fileを参照してください。
wandb.Tableを使用して、UIに表示するテーブルにテキストをログします。デフォルトで、列ヘッダーは["Input", "Output", "Expected"]です。最適なUIパフォーマンスを確保するために、デフォルトで最大行数は10,000に設定されています。ただし、ユーザーはwandb.Table.MAX_ROWS = {DESIRED_MAX}を使用して明示的に上限を超えることができます。
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})
また、pandas DataFrameオブジェクトを渡すこともできます。
table = wandb.Table(dataframe=my_dataframe)
詳細な使い方については、stringを参照してください。
wandb.log({"custom_file": wandb.Html(open("some.html"))})
wandb.log({"custom_string": wandb.Html('<a href="https://mysite">Link</a>')})
カスタムHTMLは任意のキーでログ可能で、runページ上にHTMLパネルを接続します。デフォルトではスタイルが注入されます。デフォルトスタイルをオフにするには、inject=Falseを渡します。
wandb.log({"custom_file": wandb.Html(open("some.html"), inject=False)})
詳細な使い方については、html-fileを参照してください。
以下のガイドでは、W&B run にモデルをログし、それと対話する方法を説明します。
以下の API は、実験管理ワークフローの一環としてモデルを追跡するのに便利です。このページに記載されている API を使用して、run にモデルをログし、メトリクス、テーブル、メディア、その他のオブジェクトにアクセスします。
モデル以外にも、データセットやプロンプトなど、シリアライズされたデータの異なるバージョンを作成し追跡したい場合は、W&B Artifacts を使用することをお勧めします。
W&B Artifacts や高度なバージョン管理ユースケースの詳細については、Artifacts ドキュメントをご覧ください。
log_model を使用して、指定したディレクトリ内にコンテンツを含むモデルアーティファクトをログします。 log_model メソッドは、結果のモデルアーティファクトを W&B run の出力としてもマークします。
モデルを W&B run の入力または出力としてマークすると、モデルの依存関係とモデルの関連付けを追跡できます。W&B アプリ UI 内でモデルのリネージを確認します。詳細については、Artifacts チャプターの アーティファクトグラフを探索して移動する ページを参照してください。
モデルファイルが保存されているパスを path パラメータに指定します。パスには、ローカルファイル、ディレクトリ、または s3://bucket/path などの外部バケットへの 参照 URI を指定できます。
<> 内に囲まれた値を自分のもので置き換えることを忘れないでください。
import wandb
run = wandb.init(project="
run.log_model(path="
オプションで、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()
ユーザーが log_model を呼び出したとき、MNISTという名前のモデルアーティファクトが作成され、ファイル model.h5 がモデルアーティファクトに追加されました。あなたのターミナルまたはノートブックは、モデルがログされた run に関する情報を見つける場所についての情報を出力します。
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 という変数に保存されています。
たとえば、以下のコードスニペットでは、ユーザーが use_model API を呼び出しています。彼らは取得したいモデルアーティファクトの名前を指定し、またバージョン/エイリアスも提供しています。そして、API から返されるパスを 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 リファレンスガイドでは、利用可能なパラメータや返り値の型についての詳細情報が記載されています。
link_model メソッドは、現在のところレガシー 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 としてリンクされます。
例えば、以下のコードスニペットでは、モデルファイルをログし、登録済みのモデル名 "Fine-Tuned-Review-Autocompletion"にモデルをリンクする方法を示しています。
これを行うために、ユーザーは link_model API を呼び出します。API を呼び出す際に、モデルの内容を示すローカルファイルパス (path) と、リンクするための登録済みモデルの名前 (registered_model_name) を提供します。
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()
wandb.Table を使って、データをログに記録し W&B で視覚化・クエリできるようにします。このガイドでは次のことを学びます：
Table（テーブル）を定義するには、各データ行に表示したい列を指定します。各行はトレーニングデータセットの単一の項目、トレーニング中の特定のステップやエポック、テスト項目でのモデルの予測、モデルが生成したオブジェクトなどです。各列には固定の型があり、数値、テキスト、ブール値、画像、ビデオ、オーディオなどがあります。あらかじめ型を指定する必要はありません。各列に名前を付け、その型のデータのみをその列のインデックスに渡してください。より詳細な例については、このレポート を参照してください。
wandb.Table コンストラクタを次の2つの方法のいずれかで使用します：
wandb.Table(columns=["a", "b", "c"], data=[["1a", "1b", "1c"], ["2a", "2b", "2c"]])
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つあります：
table.add_data("3a", "3b", "3c")。新しい行はリストとして表現されないことに注意してください。行がリスト形式の場合は * を使ってリストを位置引数に展開します: table.add_data(*my_row_list)。行にはテーブルの列数と同じ数のエントリが含まれている必要があります。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 において、既存のテーブルをアーティファクトから読み込み、最後のデータ行を取得して、更新されたメトリクスを追加することで 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 にあるとき、列または行ごとにアクセスできます：
for ndx, row in table.iterrows(): ... のようにデータの行を効率的に反復処理できます。table.get_column("col_name") を使用してデータの列を取得できます。convert_to="numpy" を渡すと、列を NumPy のプリミティブ NDArray に変換できます。これは、列に wandb.Image などのメディアタイプが含まれている場合に、基になるデータに直接アクセスするのに便利です。スクリプトでモデルの予測のテーブルなどのデータを生成した後、それを W&B に保存して結果をリアルタイムで視覚化します。
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 行までログに記録できます。
200,000 行以上をログに記録するには、以下のように制限をオーバーライドできます：
wandb.Table.MAX_ARTIFACT_ROWS = X
ただし、これにより UI でのクエリの速度低下などのパフォーマンス問題が発生する可能性があります。
バックエンドでは、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) を使用して、ローカルに構築したテーブルや他のアーティファクトから取得したテーブルを結合できます。
| 引数 | 説明 |
|---|---|
| table_1 | (str, wandb.Table, ArtifactEntry) アーティファクト内の wandb.Table へのパス、テーブルオブジェクト、または ArtifactEntry |
| table_2 | (str, wandb.Table, ArtifactEntry) アーティファクト内の wandb.Table へのパス、テーブルオブジェクト、または ArtifactEntry |
| join_key | (str, [str, str]) 結合を行うキーまたはキーのリスト |
以前にアーティファクトコンテキストでログに記録した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 つのテーブルを組み合わせる方法の例が示されています。
時間とともに変化する値に加えて、モデルや前処理ステップを要約する単一の値を追跡することも重要です。この情報を 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 メトリクスは、トレーニングにおける最良のステップでのモデルのパフォーマンスを 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)
Run の Overview ページまたはプロジェクトの runs テーブルで 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()
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)
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.
これらのシンプルなチャートにより、メトリクスと結果の基本的な可視化を簡単に構築できます。
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を持っている必要があります。
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を持っている必要があります。
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"
)
}
)
これは任意の棒グラフをログするために使用できます。リスト内のラベルと値の数は正確に一致する必要があります。それぞれのデータポイントは両方を持たなければなりません。
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次元配列をサポートすることを意図しています。
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値のリストを提供することもできます。
これらのプリセットチャートは、wandb.plotメソッド内蔵で、スクリプトからチャートを直接ログして、UIで正確に確認したい情報をすぐに把握できます。
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を意味するなど）
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を意味するなど）
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である場合）
完全なカスタマイズを行う場合、内蔵の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"},
)
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チャートを直接受け入れることもできます。
fig = plt.figure()として保存してから、wandb.logでfigをログできます。W&Bでは、PlotlyやBokehからインタラクティブなチャートをHTMLとしてログし、Tablesに追加することをサポートしています。
インタラクティブな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()
インタラクティブな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()
W&B Python ライブラリを使用して、CSV ファイルをログし、W&B ダッシュボードで可視化します。W&B ダッシュボードは、機械学習モデルからの結果を整理し可視化する中心的な場所です。これは、W&B にログされていない以前の機械学習実験の情報を含む CSV ファイルやデータセットを含む CSV ファイルがある場合に特に便利です。
W&B Artifacts を使用することをお勧めします。CSV ファイルの内容を再利用しやすくするためです。
iris.csv ファイル名をあなたの CSV ファイル名に置き換えてください: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 Artifacts についての詳細は、Artifacts チャプターを参照してください。
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()
場合によっては、実験の詳細が CSV ファイルにあることがあります。そのような CSV ファイルに共通する詳細には次のようなものがあります:
| 実験 | モデル名 | ノート | タグ | 層の数 | 最終トレイン精度 | 最終評価精度 | トレーニング損失 |
|---|---|---|---|---|---|---|---|
| 実験 1 | mnist-300-layers | トレーニングデータに過剰適合 | [latest] | 300 | 0.99 | 0.90 | [0.55, 0.45, 0.44, 0.42, 0.40, 0.39] |
| 実験 2 | mnist-250-layers | 現行の最良モデル | [prod, best] | 250 | 0.95 | 0.96 | [0.55, 0.45, 0.44, 0.42, 0.40, 0.39] |
| 実験 3 | mnist-200-layers | ベースラインモデルより悪かったため、デバッグ必要 | [debug] | 200 | 0.76 | 0.70 | [0.55, 0.45, 0.44, 0.42, 0.40, 0.39] |
| … | … | … | … | … | … | … | |
| 実験 N | mnist-X-layers | ノート | … | … | … | … | […, …] |
W&B は実験の CSV ファイルを受け取り、W&B 実験 Run に変換することができます。次のコードスニペットとコードスクリプトで、実験の CSV ファイルをインポートしてログする方法を示しています:
"experiments.csv" を CSV ファイル名に置き換えてください:import wandb
import pandas as pd
FILENAME = "experiments.csv"
loaded_experiment_df = pd.read_csv(FILENAME)
PROJECT_NAME = "Converted Experiments"
EXPERIMENT_NAME_COL = "Experiment"
NOTES_COL = "Notes"
TAGS_COL = "Tags"
CONFIG_COLS = ["Num Layers"]
SUMMARY_COLS = ["Final Train Acc", "Final Val Acc"]
METRIC_COLS = ["Training Losses"]
# 作業を容易にするための Pandas DataFrame のフォーマット
for i, row in loaded_experiment_df.iterrows():
run_name = row[EXPERIMENT_NAME_COL]
notes = row[NOTES_COL]
tags = row[TAGS_COL]
config = {}
for config_col in CONFIG_COLS:
config[config_col] = row[config_col]
metrics = {}
for metric_col in METRIC_COLS:
metrics[metric_col] = row[metric_col]
summaries = {}
for summary_col in SUMMARY_COLS:
summaries[summary_col] = row[summary_col]
wandb.init()を使用して W&B で追跡し、ログするための新しい W&B Run を開始します:run = wandb.init(
project=PROJECT_NAME, name=run_name, tags=tags, notes=notes, config=config
)
実験が進行するにつれて、メトリクスのすべてのインスタンスをログし、W&B で表示、クエリ、および分析可能にすることをお勧めするかもしれません。これを実現するには、run.log() コマンドを使用します:
run.log({key: val})
また、run の結果を定義するために最終的なサマリーメトリクスをオプションでログすることもできます。これを実現するには、W&B define_metric API を使用します。この例では、run.summary.update() によりサマリーメトリクスを run に追加します:
run.summary.update(summaries)
サマリーメトリクスの詳細については、Log Summary Metricsを参照してください。
以下は、上記のサンプルテーブルを W&B ダッシュボードに変換する完全な例のスクリプトです:
FILENAME = "experiments.csv"
loaded_experiment_df = pd.read_csv(FILENAME)
PROJECT_NAME = "Converted Experiments"
EXPERIMENT_NAME_COL = "Experiment"
NOTES_COL = "Notes"
TAGS_COL = "Tags"
CONFIG_COLS = ["Num Layers"]
SUMMARY_COLS = ["Final Train Acc", "Final Val Acc"]
METRIC_COLS = ["Training Losses"]
for i, row in loaded_experiment_df.iterrows():
run_name = row[EXPERIMENT_NAME_COL]
notes = row[NOTES_COL]
tags = row[TAGS_COL]
config = {}
for config_col in CONFIG_COLS:
config[config_col] = row[config_col]
metrics = {}
for metric_col in METRIC_COLS:
metrics[metric_col] = row[metric_col]
summaries = {}
for summary_col in SUMMARY_COLS:
summaries[summary_col] = row[summary_col]
run = wandb.init(
project=PROJECT_NAME, name=run_name, tags=tags, notes=notes, config=config
)
for key, val in metrics.items():
if isinstance(val, list):
for _val in val:
run.log({key: _val})
else:
run.log({key: val})
run.summary.update(summaries)
run.finish()
分散トレーニングでは、複数の GPU を使ってモデルが並列にトレーニングされます。W&B は、分散トレーニング実験をトラッキングするための2つのパターンをサポートしています。
wandb.init）、実験をログします（wandb.log）。これは PyTorch Distributed Data Parallel（DDP）クラスを使った分散トレーニング実験のログに一般的なソリューションです。ユーザーは他のプロセスからメインのロギングプロセスにデータを送るために、多重処理キュー（または他の通信プリミティブ）を使用することもあります。wandb.init）、実験をログします（wandb.log）。各プロセスは実質的に別々の実験です。W&B を初期化する際に、group パラメータを使用して共有実験を定義し、W&B App UI のログした値を一緒にグループ化します。次に示す例は、PyTorch DDP を使って単一のマシン上で2つの GPU でメトリクスを W&B でトラッキングする方法を示しています。PyTorch DDP（torch.nn の DistributedDataParallel）は、分散トレーニングのための人気のあるライブラリです。基本的な原則はどの分散トレーニングセットアップにも適用されますが、実装の詳細は異なる場合があります。
log-dpp.py の Python スクリプトを参照してください。この方法では、ランク 0 のプロセスのみをトラッキングします。この方法を実装するには、ランク 0 のプロセス内で W&B を初期化し（wandb.init）、W&B Run を開始し、メトリクスをログ（wandb.log）します。この方法はシンプルで堅牢ですが、他のプロセスからモデルメトリクス（例えば、ロス値や各バッチからの入力）をログしません。使用状況やメモリなどのシステムメトリクスは、すべての GPU に利用可能な情報であるため、引き続きログされます。
サンプル Python スクリプト (log-ddp.py) では、ランクが 0 かどうかを確認します。そのためには、まず torch.distributed.launch を使って複数のプロセスを開始します。次に、--local_rank コマンドライン引数を使用してランクを確認します。ランクが 0 に設定されている場合、train() 関数内で条件付きで wandb ロギングを設定します。Python スクリプト内では、次のように確認します。
if __name__ == "__main__":
# 引数を取得
args = parse_args()
if args.local_rank == 0: # メインプロセスでのみ
# wandb run を初期化
run = wandb.init(
entity=args.entity,
project=args.project,
)
# DDP でモデルをトレーニング
train(args, run)
else:
train(args)
W&B App UI を探索して、単一プロセスからトラッキングされたメトリクスの ダッシュボードの例 をご覧ください。ダッシュボードは、両方の GPU に対してトラッキングされた温度や使用率などのシステムメトリクスを表示します。
しかし、エポックとバッチサイズの関数としてのロス値は、単一の GPU からのみログされました。
この方法では、ジョブ内の各プロセスをトラッキングし、各プロセスから個別に wandb.init() と wandb.log() を呼び出します。トレーニングの終了時には wandb.finish() を呼び出して、run が完了したことを示し、すべてのプロセスが正常に終了するようにすることをお勧めします。
この方法では、さらに多くの情報がログにアクセス可能になりますが、W&B App UI に複数の W&B Runs が報告されます。複数の実験にわたって W&B Runs を追跡するのが困難になる可能性があります。これを軽減するために、W&B を初期化する際に group パラメータに値を与えて、どの W&B Run がどの実験に属しているかを追跡します。実験でのトレーニングと評価の W&B Runs の追跡方法の詳細については、Group Runs を参照してください。
以下の Python コードスニペットは、W&B を初期化する際に group パラメータを設定する方法を示しています。
if __name__ == "__main__":
# 引数を取得
args = parse_args()
# run を初期化
run = wandb.init(
entity=args.entity,
project=args.project,
group="DDP", # 実験のすべての run を1つのグループに
)
# DDP でモデルをトレーニング
train(args, run)
W&B App UI を探索して、複数のプロセスからトラッキングされたメトリクスの ダッシュボードの例 をご覧ください。左側のサイドバーに 2 つの W&B Runs が組み合わされたものが示されています。グループをクリックして、その実験専用のグループページを表示します。専用のグループページには、各プロセスから別々にログされたメトリクスが表示されます。
前の画像は W&B App UI ダッシュボードを示しています。サイドバーには2つの実験が表示されています。1つは「null」とラベル付けされ、黄色のボックスで囲まれた2つ目は「DPP」と呼ばれます。グループを展開すると（[Group] ドロップダウンを選択）、その実験に関連する W&B Runs を見ることができます。
W&B と分散トレーニングを使用する場合、2つの一般的な問題に遭遇することがあります。
wandb プロセスが、分散トレーニングからの多重処理と干渉するためにハングすることがあります。wandb プロセスがいつ終了する必要があるかを知らない場合、ハングすることがあります。Python スクリプトの最後に wandb.finish() API を呼び出して、W&B に Run が終了したことを通知します。wandb.finish() API はデータのアップロードを完了し、W&B の終了を引き起こします。wandb service を使用して、分散ジョブの信頼性を向上させることをお勧めします。上記のトレーニングの問題は、wandb service が利用できない W&B SDK のバージョンで一般的に見られます。
お使いのバージョンの W&B SDK に応じて、すでにデフォルトで W&B Service が有効になっているかもしれません。
W&B SDK バージョン 0.13.0 以上のバージョンでは、W&B Service がデフォルトで有効です。
W&B SDK バージョン 0.12.5 以上の場合は、Python スクリプトを修正して W&B Service を有効にします。wandb.require メソッドを使用し、メイン関数内で文字列 "service" を渡します。
if __name__ == "__main__":
main()
def main():
wandb.require("service")
# スクリプトの残りがここに来る
最適な体験のために、最新バージョンへのアップグレードをお勧めします。
W&B SDK 0.12.4 以下
W&B SDK バージョン 0.12.4 以下を使用する場合は、マルチスレッドを代わりに使用するために、WANDB_START_METHOD 環境変数を "thread" に設定します。
以下のコードスニペットは、高度な分散ユースケースの一般的なメソッドを示しています。
ワークスレッドを生成するプロセス内で W&B Run を開始する場合は、メイン関数で wandb.setup() メソッドを使用します。
import multiprocessing as mp
def do_work(n):
run = wandb.init(config=dict(n=n))
run.log(dict(this=n * n))
def main():
wandb.setup()
pool = mp.Pool(processes=4)
pool.map(do_work, range(4))
if __name__ == "__main__":
main()
W&B Run オブジェクトを引数として渡して、プロセス間で W&B Runs を共有します。
def do_work(run):
run.log(dict(this=1))
def main():
run = wandb.init()
p = mp.Process(target=do_work, kwargs=dict(run=run))
p.start()
p.join()
if __name__ == "__main__":
main()
実験を再現し、チームメンバーが作成した結果を検証して確認します。
実験を再現する前に、以下の事項に注意する必要があります：
実験を再現するには：
続けるには、指定されたハッシュで実験のコードをダウンロードするか、実験のリポジトリ全体をクローンします。
実験の Python スクリプトまたはノートブックをダウンロードします：
チームメイトが実験を作成するときに使用した GitHub リポジトリをクローンします。以下の手順で行います：
git clone https://github.com/your-repo.git && cd your-repo
git checkout -b "<run-name>" 0123456789012345678901234567890123456789
左のナビゲーションバーで Files を選択します。
requirements.txt ファイルをダウンロードし、作業ディレクトリーに保存します。このディレクトリーには、クローンした GitHub リポジトリまたはダウンロードした Python スクリプトまたはノートブックが含まれている必要があります。
（推奨）Python 仮想環境を作成します。
requirements.txt ファイルに指定された要件をインストールします。
pip install -r requirements.txt
これでコードと依存関係が揃ったので、スクリプトまたはノートブックを実行して実験を再現できます。リポジトリをクローンした場合は、スクリプトまたはノートブックが置かれているディレクトリーに移動する必要があるかもしれません。そうでなければ、作業ディレクトリーからスクリプトまたはノートブックを実行できます。
Python ノートブックをダウンロードした場合、ノートブックをダウンロードしたディレクトリーに移動して、以下のコマンドをターミナルで実行します:
jupyter notebook
Python スクリプトをダウンロードした場合、スクリプトをダウンロードしたディレクトリーに移動して、ターミナルで以下のコマンドを実行してください。<>で囲まれた値を自分のものに置き換えます：
python <your-script-name>.py
ページをW&Bで速く、応答性を高めるために、以下の推奨範囲内でログを記録してください。
wandb.log を使用して実験のメトリクスを追跡します。ログに記録されたメトリクスは、チャートを生成し、テーブルに表示されます。ログに記録されるデータが多すぎると、アプリケーションが遅くなる可能性があります。
より速いパフォーマンスのために、プロジェクト内の異なるメトリクスの合計数を10,000未満に抑えてください。
import wandb
wandb.log(
{
"a": 1, # "a" は異なるメトリクスです
"b": {
"c": "hello", # "b.c" は異なるメトリクスです
"d": [1, 2, 3], # "b.d" は異なるメトリクスです
},
}
)
ワークスペースが突然遅くなった場合、最近のRunsが意図せず何千もの新しいメトリクスを記録していないか確認してください。もしそのような場合があれば、それらのRunsを削除し、望ましいメトリクスでそれらを再作成することを検討してください。
単一のログに記録された値のサイズを1 MB未満に、単一の wandb.log コールの合計サイズを25 MB未満に制限してください。この制限は wandb.Media の型（ wandb.Image 、 wandb.Audio など）には適用されません。
# ❌ 推奨されません
wandb.log({"wide_key": range(10000000)})
# ❌ 推奨されません
with open("large_file.json", "r") as f:
large_data = json.load(f)
wandb.log(large_data)
広い値は、広い値を持つメトリクスだけでなく、run内のすべてのメトリクスのプロットの読み込み時間に影響を与える可能性があります。
記録するメトリクスに応じたログ頻度を選択してください。一つの目安として、メトリクスが広ければ、その分頻度を減らしてログを記録する必要があります。W&Bの推奨は次の通りです：
# 合計100万ステップのトレーニングループ
for step in range(1000000):
# ❌ 推奨されません
wandb.log(
{
"scalar": step, # 100,000スカラー
"media": wandb.Image(...), # 100,000画像
"histogram": wandb.Histogram(...), # 100,000ヒストグラム
}
)
# ✅ 推奨されます
if step % 1000 == 0:
wandb.log(
{
"histogram": wandb.Histogram(...), # 10,000ヒストグラム
},
commit=False,
)
if step % 200 == 0:
wandb.log(
{
"media": wandb.Image(...), # 50,000画像
},
commit=False,
)
if step % 100 == 0:
wandb.log(
{
"scalar": step, # 100,000スカラー
},
commit=True,
) # ステップごとにまとめてメトリクスをコミットします
runの設定の合計サイズを10 MB未満に制限してください。大きな値をログに記録すると、プロジェクトワークスペースとRunsテーブルの操作が遅くなる可能性があります。
# ✅ 推奨されます
wandb.init(
config={
"lr": 0.1,
"batch_size": 32,
"epochs": 4,
}
)
# ❌ 推奨されません
wandb.init(
config={
"steps": range(10000000),
}
)
# ❌ 推奨されません
with open("large_config.json", "r") as f:
large_config = json.load(f)
wandb.init(config=large_config)
読み込み時間を短縮するために、1つのプロジェクトでのRunsの総数を次のように抑えてください：
これらの閾値を超えるRunの数は、プロジェクトのワークスペースやRunsテーブルの操作を遅くする可能性があります。特に次のRunsをグループ化する際や、Run中に大量の異なるメトリクスを収集する際に影響を与えます。メトリクスの数セクションも参照してください。
チームが頻繁に同じRunsセットにアクセスする場合、たとえば最近のRunsセットなど、使用頻度が低いRunsを一括で新しい「アーカイブ」プロジェクトに移動することを考慮してください。動作中のプロジェクトに小さなRunsセットだけを残してください。
このセクションでは、ワークスペースのパフォーマンスを最適化するためのヒントを紹介します。
デフォルトでは、ワークスペースは 自動 で、ログに記録された各キーの標準パネルを生成します。もし、大きなプロジェクトのワークスペースに多くのログされたキーのパネルが含まれている場合、ワークスペースの読み込みと使用が遅くなることがあります。パフォーマンスを向上させるために、次のことができます：
ワークスペースの設定方法の詳細については、パネルを参照してください。
ワークスペースに何百ものセクションがあると、パフォーマンスが低下する可能性があります。メトリクスの高レベルなグループ化に基づいてセクションを作成し、メトリクスごとに1つのセクションを持つアンチパターンを避けることを考慮してください。
あまりにも多くのセクションがあり、パフォーマンスが低下していると感じた場合、プレフィックスではなくサフィックスによってセクションを作成するワークスペースの設定を検討してください。これにより、セクションが少なくなり、パフォーマンスが向上する可能性があります。
1つのRunで5,000から100,000のメトリクスをログに記録する場合、W&Bでは手動ワークスペースの使用をお勧めします。手動モードでは、異なるメトリクスセットを探索する際に、まとめてパネルを追加および削除することが容易です。より集中されたプロットセットにより、ワークスペースの読み込みが速くなります。プロットされていないメトリクスも通常どおり収集および保存されます。
ワークスペースを手動モードにリセットするには、ワークスペースのアクション ... メニューをクリックし、ワークスペースをリセットをクリックします。ワークスペースのリセットは、Runに保存されたメトリクスに影響を与えません。ワークスペースの管理についての詳細はこちらをご覧ください。
1つのRunでアップロードされるファイルの総数を1,000以下に抑えてください。多くのファイルをログに記録する必要がある場合は、W&B Artifactsを使用できます。1つのRunで1,000ファイルを超えると、Runページの動作が遅くなる可能性があります。
レポートは、パネル、テキスト、メディアの任意の配置の自由な組み合わせで構成されており、洞察を容易に同僚と共有することができます。
対照的に、ワークスペースは、数十から数十万のRunsにわたる数十から数百のメトリクスの高密度で性能の高い分析を可能にします。ワークスペースは、Reportsと比較してキャッシュ、クエリ、および読み込み機能が最適化されています。ワークスペースは主に分析に使用されるプロジェクト、または20以上のプロットを一緒に表示する必要がある場合に推奨されます。
Pythonスクリプトのパフォーマンスが低下する理由はいくつかあります：
wandb.log を呼び出すこと。これは、 wandb.log が呼び出されるたびにトレーニングループに小さな遅延が追加されるためです。W&Bはレート制限以外の制限を主張しません。W&B Python SDKは、制限を超えるリクエストに対して指数関数的な「バックオフ」と「リトライ」を自動的に完了します。W&B Python SDKは、コマンドラインで「ネットワーク障害」と応答します。無償アカウントの場合、W&Bは合理的な閾値を超える使用が極端な場合に連絡することがあります。
W&B SaaSクラウドAPIは、システムの整合性を保ち、利用可能性を確保するためにレート制限を実施しています。この対策により、共有インフラストラクチャで利用可能なリソースを特定のユーザーが独占することを防ぎ、サービスがすべてのユーザーにとってアクセス可能であることを保証します。いくつかの理由で、レート制限が低くなることがあります。
前述の表では、レート制限HTTPヘッダーについて説明しています：
| ヘッダー名 | 説明 |
|---|---|
| RateLimit-Limit | 時間枠ごとに利用可能なクォータの量（0から1000の範囲でスケール） |
| RateLimit-Remaining | 現在のレート制限ウィンドウでのクォータの量（0から1000の範囲でスケール） |
| RateLimit-Reset | 現在のクォータがリセットされるまでの秒数 |
あなたのスクリプトの wandb.log の呼び出しは、トレーニングデータをW&Bに記録するためのメトリクスログAPIを使用します。このAPIは、オンラインまたはオフライン同期を通じて利用されます。いずれの場合でも、ローリング時間枠でのレート制限クォータ制限を課しています。これには、合計リクエストサイズとリクエストレート（時間内のリクエスト数）に対する制限が含まれます。
W&Bは、W&Bプロジェクトごとにレート制限を適用します。したがって、1つのチームに3つのプロジェクトがある場合、各プロジェクトには独自のレート制限クォータがあります。Teams and Enterprise plansのユーザーは、無料プランのユーザーよりも高いレート制限を持っています。
メトリクスログAPIを使用中にレート制限に達すると、標準出力にエラーを示す関連メッセージが表示されます。
レート制限を超えると、 run.finish() がレート制限がリセットされるまで遅れる可能性があります。これを避けるために、以下の戦略を検討してください：
if epoch % 5 == 0: # 5エポックごとにメトリクスをログ
wandb.log({"acc": accuracy, "loss": loss})
wandb sync <run-file-path> コマンドを使用してデータを手動で同期することができます。詳細については wandb sync リファレンスを参照してください。W&B モデル UI と SDK のパブリック APIは、データのクエリと修正のためにサーバーにGraphQLリクエストを行います。SaaSクラウドのすべてのGraphQLリクエストに対して、W&Bは認証されていないリクエストに対してIPアドレスごと、認証されたリクエストに対してユーザーごとにレート制限を適用します。制限は、固定された時間枠内のリクエストレート（1秒あたりのリクエスト）に基づいており、あなたのプライシングプランがデフォルトの制限を決定します。プロジェクトパスを指定する関連SDKリクエスト（レポート、Runs、Artifactsなど）については、W&Bはプロジェクトごとにレート制限を適用し、データベースクエリ時間で測定します。
Teams and Enterprise plansのユーザーは、無料プランのユーザーよりも高いレート制限を受け取ります。 W&B Models SDKのパブリックAPIを使用しているときにレート制限に達した場合、標準出力にエラーを示す関連メッセージが表示されます。
W&B Models SDKのパブリックAPIを使用して大量のデータを取得している場合、リクエストの間に少なくとも1秒待機することを検討してください。 429ステータスコードを受け取ったり、応答ヘッダーで RateLimit-Remaining=0 が表示された場合は、 RateLimit-Reset に指定された秒数を待機してからリトライしてください。
W&Bアプリはメモリを大量に使用する可能性があり、Chromeでのパフォーマンスが最も高くなります。コンピューターのメモリに応じて、W&Bが3つ以上のタブでアクティブであるとパフォーマンスが低下する可能性があります。予想外にパフォーマンスが遅い場合、他のタブやアプリケーションを閉じることを検討してください。
W&Bはパフォーマンスを重視しており、すべてのラグ報告を調査します。調査を迅速に進めるために、読み込み時間の遅さを報告するときに、キーのメトリクスとパフォーマンスイベントをキャプチャするW&Bの組み込みパフォーマンスロガーを呼び出すことを検討してください。遅くなっているページにURLパラメータ &PERF_LOGGING を追加し、コンソールの出力をアカウントチームまたはサポートチームと共有してください。
データをエクスポートまたはインポートするには、W&B パブリックAPIを使用します。
W&B は、MLFlow からのデータのインポートをサポートしており、実験、runs、アーティファクト、メトリクス、その他のメタデータを含みます。
依存関係をインストール：
# 注意: これは py38+ が必要です
pip install wandb[importers]
W&B にログインします。初めてログインする場合は、表示されるプロンプトに従ってください。
wandb login
既存の MLFlow サーバーからすべての run をインポートします:
from wandb.apis.importers.mlflow import MlflowImporter
importer = MlflowImporter(mlflow_tracking_uri="...")
runs = importer.collect_runs()
importer.import_runs(runs)
デフォルトでは、importer.collect_runs() は MLFlow サーバーからすべての run を収集します。特定のサブセットをアップロードしたい場合は、自分で runs イテラブルを構築し、それをインポーターに渡すことができます。
import mlflow
from wandb.apis.importers.mlflow import MlflowRun
client = mlflow.tracking.MlflowClient(mlflow_tracking_uri)
runs: Iterable[MlflowRun] = []
for run in mlflow_client.search_runs(...):
runs.append(MlflowRun(run, client))
importer.import_runs(runs)
Databricks MLFlow からインポートする場合、最初にDatabricks CLI を設定することが必要です。
前のステップで mlflow-tracking-uri="databricks" を設定します。
アーティファクトのインポートをスキップするには、artifacts=False を渡します:
importer.import_runs(runs, artifacts=False)
特定の W&B エンティティとプロジェクトにインポートするには、Namespace を渡します:
from wandb.apis.importers import Namespace
importer.import_runs(runs, namespace=Namespace(entity, project))
パブリックAPIを使用して、W&B に保存したデータをエクスポートまたは更新します。このAPIを使用する前に、スクリプトからデータをログします。詳細はクイックスタートを確認してください。
パブリックAPIのユースケース
wandb.init(job_type="analysis") のように新しい分析 run を作成し、結果を記録して学びを同期できます。利用可能な関数の詳細については、生成されたリファレンスドキュメントを参照してください。
APIキーは、マシンをW&Bに認証します。ユーザープロフィールからAPIキーを生成できます。
パブリックAPIを使用するには、しばしば <entity>/<project>/<run_id> という形式の run パスが必要になります。アプリUIでrunページを開き、Overviewタブをクリックしてrunパスを取得します。
完了済みまたはアクティブな run からデータをダウンロードします。一般的な用途には、カスタム分析のために Jupyter ノートブックにデータフレームをダウンロードしたり、カスタムロジックを使用して自動化された環境で利用したりすることが含まれます。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run オブジェクトで最もよく使用される属性は次のとおりです:
| 属性 | 意味 |
|---|---|
run.config |
run の設定情報を保持する辞書。トレーニング run のハイパーパラメーターや、データセットアーティファクトを作成するためのrun に使用する前処理メソッドなどが含まれます。これらはrun の入力と考えてください。 |
run.history() |
モデルがトレーニングされている間に変化する値を保存することを意図した辞書のリスト。wandb.log() コマンドはこのオブジェクトに追記します。 |
run.summary |
run の結果を総括した情報の辞書。これには精度や損失のようなスカラー値や大きなファイルが含まれます。デフォルトでは、wandb.log()がログされた時系列の最終値をサマリーに設定します。サマリーの内容は直接設定することもできます。サマリーはrun の出力と考えてください。 |
過去の runs データも変更したり更新したりすることができます。デフォルトでは、APIオブジェクトのインスタンス1つにつき、すべてのネットワークリクエストがキャッシュされます。実行中のスクリプトでリアルタイム情報が必要な場合、api.flush() を呼び出して更新された値を取得してください。
以下のrunに対して:
n_epochs = 5
config = {"n_epochs": n_epochs}
run = wandb.init(project=project, config=config)
for n in range(run.config.get("n_epochs")):
run.log(
{"val": random.randint(0, 1000), "loss": (random.randint(0, 1000) / 1000.00)}
)
run.finish()
これは上記のrunオブジェクトの属性に対する異なる出力です。
run.config{"n_epochs": 5}
run.history() _step val loss _runtime _timestamp
0 0 500 0.244 4 1644345412
1 1 45 0.521 4 1644345412
2 2 240 0.785 4 1644345412
3 3 31 0.305 4 1644345412
4 4 525 0.041 4 1644345412
run.summary{
"_runtime": 4,
"_step": 4,
"_timestamp": 1644345412,
"_wandb": {"runtime": 3},
"loss": 0.041,
"val": 525,
}
デフォルトの history メソッドは、メトリクスを固定されたサンプル数（デフォルトは500）にサンプリングします。大規模なrunのすべてのデータをエクスポートしたい場合は、run.scan_history() メソッドを使用してください。詳細はAPIリファレンスを参照してください。
このサンプルスクリプトはプロジェクトを検索し、CSVにrun の名前、設定、サマリーステータスを出力します。 <entity> と <project> をそれぞれあなたのW&Bエンティティとプロジェクト名に置き換えてください。
import pandas as pd
import wandb
api = wandb.Api()
entity, project = "<entity>", "<project>"
runs = api.runs(entity + "/" + project)
summary_list, config_list, name_list = [], [], []
for run in runs:
# .summary には、精度のようなメトリクスの出力キー/値が含まれています。
# ._json_dict を呼び出して大きなファイルを省略します
summary_list.append(run.summary._json_dict)
# .config にはハイパーパラメーターが含まれています。
# _ で始まる特別な値は削除します。
config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})
# .name は、run の人間が読み取り可能な名前です。
name_list.append(run.name)
runs_df = pd.DataFrame(
{"summary": summary_list, "config": config_list, "name": name_list}
)
runs_df.to_csv("project.csv")
W&B API は、api.runs() を使用してプロジェクト内の runs を横断してクエリを実行する方法も提供しています。最も一般的なユースケースはカスタム分析のために runs データをエクスポートすることです。クエリインターフェースは MongoDB が使用するもの と同じです。
runs = api.runs(
"username/project",
{"$or": [{"config.experiment_name": "foo"}, {"config.experiment_name": "bar"}]},
)
print(f"Found {len(runs)} runs")
api.runs を呼び出すと、反復可能でリストのように動作する Runs オブジェクトが返されます。デフォルトでは、オブジェクトは要求に応じて1回に50のrunを順番にロードしますが、per_page キーワード引数を使用してページごとにロードする数を変更できます。
api.runs はorderキーワード引数も受け取ります。デフォルトの順序は -created_at です。昇順にするには +created_at を指定してください。設定やサマリーの値でソートすることもできます。例えば、summary.val_acc または config.experiment_name です。
W&B サーバーと話す際にエラーが発生すると、wandb.CommErrorが発生します。元の例外は exc 属性を通じて調査できます。
UIでは、runをクリックし、その run ページの Overview タブをクリックして最新の git コミットを見ることができます。それはまた、ファイル wandb-metadata.json の中にあります。パブリックAPIを使用して、run.commitを使用して git ハッシュを取得できます。
wandb.init() を呼び出した後、スクリプトからランダム run IDまたは人間読み書き可能なrun名にアクセスできます。
wandb.run.idwandb.run.namerun の識別子を効果的に設定する方法について考えている場合、以下を推奨します：
wandb.init(notes="your notes here") で設定できます。一般的なエクスポートパターンについては、APIの例を確認してください。また、カスタムプロットや拡張されたrunテーブルでダウンロードボタンをクリックして、ブラウザからCSVをダウンロードすることもできます。
この例では、wandb.log({"accuracy": acc})で保存されたrunのタイムスタンプと精度を出力します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
if run.state == "finished":
for i, row in run.history().iterrows():
print(row["_timestamp"], row["accuracy"])
MongoDBクエリ言語を使用してフィルターできます。
runs = api.runs(
"<entity>/<project>",
{"$and": [{"created_at": {"$lt": "YYYY-MM-DDT##", "$gt": "YYYY-MM-DDT##"}}]},
)
run から特定のメトリクスを取り出すには、keys 引数を使用します。run.history() の場合、デフォルトのサンプル数は500です。特定のメトリクスを含まないログステップは、出力データフレームで NaN として表示されます。keys 引数を使用すると、APIは指定したメトリックキーを含むステップをより頻繁にサンプリングします。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
if run.state == "finished":
for i, row in run.history(keys=["accuracy"]).iterrows():
print(row["_timestamp"], row["accuracy"])
これは run1 と run2 の間で異なる設定パラメーターを出力します。
import pandas as pd
import wandb
api = wandb.Api()
# `<entity>`, `<project>`, `<run_id>` で置き換える
run1 = api.run("<entity>/<project>/<run_id>")
run2 = api.run("<entity>/<project>/<run_id>")
df = pd.DataFrame([run1.config, run2.config]).transpose()
df.columns = [run1.name, run2.name]
print(df[df[run1.name] != df[run2.name]])
出力：
c_10_sgd_0.025_0.01_long_switch base_adam_4_conv_2fc
batch_size 32 16
n_conv_layers 5 4
optimizer rmsprop adam
この例では、以前のrunの精度を 0.9 に設定します。また、numpy_array のヒストグラムに以前のrunの精度ヒストグラムを変更します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run.summary["accuracy"] = 0.9
run.summary["accuracy_histogram"] = wandb.Histogram(numpy_array)
run.summary.update()
この例ではテーブル内のサマリー列の名前を変更します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run.summary["new_name"] = run.summary["old_name"]
del run.summary["old_name"]
run.summary.update()
この例では設定のひとつを更新します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run.config["key"] = updated_value
run.update()
以下のスニペットは、システムリソースの消費を見つけ、それらをCSVに保存します。
import wandb
run = wandb.Api().run("<entity>/<project>/<run_id>")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
history からデータを取得するとき、デフォルトでは500ポイントにサンプリングされます。run.scan_history()を使用すると全てのログデータポイントが取得できます。以下は、historyでログされたすべての loss データポイントをダウンロードする例です。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
history = run.scan_history()
losses = [row["loss"] for row in history]
メトリクスがバックエンドでゆっくりと取得されている場合やAPIリクエストがタイムアウトしている場合、scan_history でページサイズを下げて、個々のリクエストがタイムアウトしないようにすることができます。デフォルトのページサイズは500なので、どのサイズが最適か試してみてください。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run.scan_history(keys=sorted(cols), page_size=100)
このスクリプトは、プロジェクト内のrunを取得し、その名前、設定、およびサマリーステータスを含むデータフレームとCSVを生成します。 <entity> と <project> をそれぞれあなたのW&Bエンティティとプロジェクト名に置き換えます。
import pandas as pd
import wandb
api = wandb.Api()
entity, project = "<entity>", "<project>"
runs = api.runs(entity + "/" + project)
summary_list, config_list, name_list = [], [], []
for run in runs:
# .summary には、精度のようなメトリクスの出力キー/値が含まれています。
# ._json_dict を呼び出して大きなファイルを省略します
summary_list.append(run.summary._json_dict)
# .config にはハイパーパラメーターが含まれています。
# _ で始まる特別な値は削除します。
config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})
# .name は、run の人間が読み取り可能な名前です。
name_list.append(run.name)
runs_df = pd.DataFrame(
{"summary": summary_list, "config": config_list, "name": name_list}
)
runs_df.to_csv("project.csv")
このコードスニペットは、run が作成された時間を取得します。
import wandb
api = wandb.Api()
run = api.run("entity/project/run_id")
start_time = run.created_at
以下のコードスニペットは、選択したファイルを完了したrunにアップロードします。
import wandb
api = wandb.Api()
run = api.run("entity/project/run_id")
run.upload_file("file_name.extension")
これは、cifar プロジェクトの run ID uxte44z7 に関連付けられたファイル “model-best.h5” を見つけ、ローカルに保存します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run.file("model-best.h5").download()
これはrunに関連付けられたすべてのファイルを見つけ、ローカルに保存します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
for file in run.files():
file.download()
このスニペットは特定のスイープに関連するすべてのrunをダウンロードします。
import wandb
api = wandb.Api()
sweep = api.sweep("<entity>/<project>/<sweep_id>")
sweep_runs = sweep.runs
次のスニペットは、与えられたスイープから最高のrun を取得します。
import wandb
api = wandb.Api()
sweep = api.sweep("<entity>/<project>/<sweep_id>")
best_run = sweep.best_run()
best_run は、スイープの設定の metric パラメータで定義されたメトリクスが最高のrunです。
このスニペットは、runでmodel.h5にモデルファイルを保存したスイープから、最高の検証精度を持つモデルファイルをダウンロードします。
import wandb
api = wandb.Api()
sweep = api.sweep("<entity>/<project>/<sweep_id>")
runs = sorted(sweep.runs, key=lambda run: run.summary.get("val_acc", 0), reverse=True)
val_acc = runs[0].summary.get("val_acc", 0)
print(f"Best run {runs[0].name} with {val_acc}% val accuracy")
runs[0].file("model.h5").download(replace=True)
print("Best model saved to model-best.h5")
このスニペットは、runの特定の拡張子を持つファイルを削除します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
extension = ".png"
files = run.files()
for file in files:
if file.name.endswith(extension):
file.delete()
このスニペットは、run のすべてのシステムリソース消費メトリクスのデータフレームを生成し、CSVに保存します。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
サマリーメトリクスを更新する辞書を渡すことができます。
summary.update({"key": val})
各runは、runの概要ページでそれを開始したコマンドをキャプチャします。このコマンドを API から取得するには次のように実行できます。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
meta = json.load(run.file("wandb-metadata.json").download())
program = ["python"] + [meta["program"]] + meta["args"]
スクリプトを自動化された環境で実行するとき、スクリプトの実行前またはスクリプト内で設定された環境変数を使って wandb を制御できます。
# これは秘密であり、バージョン管理にチェックインするべきではありません
WANDB_API_KEY=$YOUR_API_KEY
# 名前とメモはオプションです
WANDB_NAME="My first run"
WANDB_NOTES="Smaller learning rate, more regularization."
# wandb/settingsファイルをチェックインしない場合にのみ必要です
WANDB_ENTITY=$username
WANDB_PROJECT=$project
# スクリプトをクラウドに同期したくなければ
os.environ["WANDB_MODE"] = "offline"
# Sweep IDの追跡をRunオブジェクトと関連クラスに追加
os.environ["WANDB_SWEEP_ID"] = "b05fq58z"
これらのオプションの環境変数を使用して、リモートマシンでの認証をセットアップすることができます。
| 変数名 | 使用法 |
|---|---|
| WANDB_ANONYMOUS | allow, never, または must に設定して、ユーザーが秘密のURLで匿名のrunsを作成できるようにします。 |
| WANDB_API_KEY | あなたのアカウントに関連付けられた認証キーを設定します。キーは設定ページで確認できます。このキーは、リモートマシンで wandb login が実行されていない場合に設定する必要があります。 |
| WANDB_BASE_URL | wandb/localを使用している場合、この環境変数を http://YOUR_IP:YOUR_PORT に設定してください。 |
| WANDB_CACHE_DIR | これはデフォルトで ~/.cache/wandb に設定されています。この環境変数を使用してこの場所を上書きすることができます。 |
| WANDB_CONFIG_DIR | これはデフォルトで ~/.config/wandb に設定されています。この環境変数を使用してこの場所を上書きすることができます。 |
| WANDB_CONFIG_PATHS | カンマで区切られたyamlファイルのリストをwandb.configにロードします。configを参照してください。 |
| WANDB_CONSOLE | stdout / stderr ロギングを無効にする場合はこれを “off” に設定します。これが機能する環境では、デフォルトで “on” に設定されています。 |
| WANDB_DATA_DIR | ステージングアーティファクトがアップロードされる場所。デフォルトの場所はプラットフォームに依存し、platformdirs Pythonパッケージからの user_data_dir の値を使用します。 |
| WANDB_DIR | すべての生成されたファイルを wandb ディレクトリーではなくここに保存するために絶対パスを設定します。このディレクトリーが存在しており、プロセスが実行されるユーザーが書き込めることを確認してください。この設定は、ダウンロードされたアーティファクトの場所には影響しません、それらの場所を設定するには代わりに WANDB_ARTIFACT_DIR を使用してください。 |
| WANDB_ARTIFACT_DIR | すべてのダウンロードされたアーティファクトを artifacts ディレクトリーではなくここに保存するために絶対パスを設定します。このディレクトリーが存在しており、プロセスが実行されるユーザーが書き込めることを確認してください。この設定は、生成されたメタデータファイルの場所には影響しません、それらの場所を設定するには代わりに WANDB_DIR を使用してください。 |
| WANDB_DISABLE_GIT | gitリポジトリをプローブし、最新のコミット / 差分をキャプチャするのを防ぎます。 |
| WANDB_DISABLE_CODE | ノートブックやgit差分の保存を防ぐためにtrueに設定します。gitリポジトリ内にいる場合、依然として現在のコミットを保存します。 |
| WANDB_DOCKER | dockerイメージのダイジェストを設定してrunsの復元を有効にします。これはwandb dockerコマンドで自動的に設定されます。イメージダイジェストを取得するには wandb docker my/image/name:tag --digest を実行します。 |
| WANDB_ENTITY | あなたのrunに関連付けられたentityです。トレーニングスクリプトのディレクトリーで wandb init を実行した場合、wandb という名前のディレクトリーが作成され、デフォルトのentityが保存され、ソース管理にチェックインされます。このファイルを作成したくない場合やファイルを上書きしたい場合、環境変数を使用できます。 |
| WANDB_ERROR_REPORTING | wandbが致命的なエラーをエラートラッキングシステムにログするのを防ぎたい場合はfalseに設定します。 |
| WANDB_HOST | システムが提供するホスト名を使用せずにwandbインターフェースで表示したいホスト名を設定します。 |
| WANDB_IGNORE_GLOBS | 無視するファイルのグロブのカンマ区切りリストを設定します。これらのファイルはクラウドに同期されません。 |
| WANDB_JOB_NAME | wandb が作成するジョブに対する名前を指定します。 |
| WANDB_JOB_TYPE | ジョブタイプを指定します。「トレーニング」や「評価」など、異なるタイプのrunsを示します。詳細についてはgroupingを参照してください。 |
| WANDB_MODE | “offline” に設定すると、wandbはrunメタデータをローカルに保存し、サーバーに同期しなくなります。disabled に設定すると、wandbは完全にオフになります。 |
| WANDB_NAME | あなたのrunの人間が読める名前。設定されていない場合、ランダムに生成されます。 |
| WANDB_NOTEBOOK_NAME | jupyterで実行されている場合、この変数でノートブックの名前を設定できます。これを自動検出しようとします。 |
| WANDB_NOTES | あなたのrunに関する長いメモ。Markdownが許可されており、UIで後で編集できます。 |
| WANDB_PROJECT | あなたのrunに関連付けられたプロジェクトです。これも wandb init で設定できますが、環境変数は値を上書きします。 |
| WANDB_RESUME | デフォルトでは never に設定されています。auto に設定すると、wandbは自動的に失敗したrunsを再開します。must に設定すると、開始時に必ずrunが存在するように強制します。常に独自のユニークなIDを生成したい場合、allow に設定して常に WANDB_RUN_ID を設定してください。 |
| WANDB_RUN_GROUP | 自動的にrunsをまとめるためのexperiment nameを指定します。詳細についてはgroupingを参照してください。 |
| WANDB_RUN_ID | スクリプトの単一runに対応する、グローバルにユニークな文字列（プロジェクトごとに）を設定します。64文字以内でなければなりません。すべての非単語文字はダッシュに変換されます。失敗時の既存のrunを再開するために使用できます。 |
| WANDB_SILENT | wandbログステートメントを黙らせるために true に設定します。これを設定すると、すべてのログが WANDB_DIR/debug.log に書き込まれます。 |
| WANDB_SHOW_RUN | あなたのオペレーティングシステムがサポートしていれば、runのURLを自動的にブラウザで開くために true に設定します。 |
| WANDB_SWEEP_ID | Run オブジェクトおよび関連クラスにSweep IDの追跡を追加し、UIに表示します。 |
| WANDB_TAGS | runに適用されるタグのカンマ区切りリスト。 |
| WANDB_USERNAME | runに関連付けられたあなたのチームメンバーのユーザー名。これは、サービスアカウントAPIキーと共に使用して、自動化されたrunsをあなたのチームのメンバーに帰属させることができます。 |
| WANDB_USER_EMAIL | runに関連付けられたあなたのチームメンバーのメール。これはサービスアカウントAPIキーと共に使用して、自動化されたrunsをあなたのチームのメンバーに帰属させることができます。 |
Singularityでコンテナを実行している場合、上記の変数に SINGULARITYENV_ をプレフィックスとしてつけて環境変数を渡すことができます。Singularity環境変数に関する詳細はこちらで確認できます。
AWSでバッチジョブを実行している場合、W&Bのクレデンシャルでマシンを認証するのは簡単です。設定ページからAPIキーを取得し、AWSバッチジョブ仕様で WANDB_API_KEY 環境変数を設定します。
W&B Tables を使用して、表形式のデータを視覚化し、クエリを実行します。 例:
上の画像は、セマンティックセグメンテーションとカスタムメトリクスを含むテーブルを示しています。このテーブルはこちらの W&B ML Course のサンプルプロジェクト で見ることができます。
Table は、各列が単一のデータ型を持つデータの 2 次元グリッドです。Tables はプリミティブ型と数値型、さらに入れ子リスト、辞書、およびリッチメディア型をサポートします。
数行のコードでテーブルをログします:
wandb.init(): run を作成して結果を追跡します。wandb.Table(): 新しいテーブルオブジェクトを作成します。
columns: 列の名前を設定します。data: テーブルの内容を設定します。run.log(): テーブルをログして W&B に保存します。import wandb
run = wandb.init(project="table-test")
my_table = wandb.Table(columns=["a", "b"], data=[["a1", "b1"], ["a2", "b2"]])
run.log({"Table Name": my_table})
The following クイックスタート では、データ テーブルをログし、データを視覚化し、データをクエリする方法を示します。
以下のボタンを選択して、PyTorch クイックスタートの MNIST データの例のプロジェクト を試してください。
W&B を使用してテーブルをログします。新しいテーブルを作成するか、Pandas の Dataframe を渡すことができます。
新しい Table を作成してログするには、次を使用します:
wandb.init(): run を作成して結果を追跡します。wandb.Table(): 新しいテーブル オブジェクトを作成します。
columns: カラム名を設定します。data: 各行の内容を設定します。run.log(): テーブルをログし、W&B に保存します。例はこちらです:
import wandb
run = wandb.init(project="table-test")
# 新しいテーブルを作成してログします。
my_table = wandb.Table(columns=["a", "b"], data=[["a1", "b1"], ["a2", "b2"]])
run.log({"Table Name": my_table})
Pandas Dataframe を wandb.Table() に渡して、新しいテーブルを作成します。
import wandb
import pandas as pd
df = pd.read_csv("my_data.csv")
run = wandb.init(project="df-table")
my_table = wandb.Table(dataframe=df)
wandb.log({"Table Name": my_table})
サポートされているデータ型の詳細については、W&B API リファレンス ガイドの wandb.Table を参照してください。
ワークスペースで結果のテーブルを表示します。
この例では、my_table がキー "Table Name" の下にログされています。
複数の W&B Runs のサンプル テーブルをログし、プロジェクト ワークスペースで結果を比較します。この 例のワークスペース では、複数の異なるバージョンから同じテーブルに行を結合する方法を示しています。
モデルの結果を探索し評価するためにテーブルのフィルタ、ソート、グループ化の機能を使用してください。
W&B Tables をカスタマイズして、機械学習モデルの性能に関する質問に答え、データを分析するなどの操作を行いましょう。
データを対話的に探索して、以下のことができます。
W&B Tables には以下の振る舞いがあります:
現在の W&B Table ビューを保存する方法については、ビューを保存するを参照してください。
マージされたビューまたは並列ビューで2つのテーブルを比較します。以下の画像は、MNISTデータのテーブル比較を示しています。
2つのテーブルを比較する手順:
以下の画像では、5 エポック後の各MNIST検証データにおけるモデルの予測を示しています（対話型の例はこちらを参照）。
最初は、両方のテーブルが一緒にマージされた状態が表示されます。選択した最初のテーブルはインデックス0で青色のハイライトがあり、2つ目のテーブルはインデックス1で黄色のハイライトがあります。ここでマージされたテーブルのライブ例を表示することができます。
マージされたビューから、以下の操作を行うことができます。
2つのテーブルを並べて表示するには、最初のドロップダウンを「Merge Tables: Table」から「List of: Table」に変更し、「Page size」をそれに応じて更新します。ここで選択された最初のテーブルは左側にあり、2つ目のテーブルは右側にあります。さらに、「Vertical」チェックボックスをクリックして、これらのテーブルを縦に比較することもできます。
テーブルを時間で比較したり、モデルバリアントを比較することもできます。
各トレーニングの意味のあるステップに対してアーティファクトにテーブルを記録し、トレーニング時間を通じてモデルの性能を分析します。たとえば、各検証ステップの終了時、毎50エポックのトレーニング後、またはパイプラインに意味を持つ任意の頻度でテーブルを記録できます。モデル予測の変更を可視化するために、並列ビューを使用します。
トレーニング時間を通じて予測を可視化するより詳細なウォークスルーについては、このレポートおよびこの対話型ノートブックの例を参照してください。
2つの異なるモデルで同じステップでログされた2つのアーティファクトバージョンを比較して、異なる設定（ハイパーパラメーター、基本アーキテクチャーなど）全体でのモデル性能を分析します。
たとえば、baselineと新しいモデルバリアント2x_layers_2x_lrの予測を比較します。この場合、最初の畳み込み層が32から64に、2番目が128から256に、学習率が0.001から0.002に倍増します。このライブ例から、並列ビューを使用して、1エポック後（左タブ）と5エポック後（右タブ）の誤った予測にフィルターをかけます。
runワークスペース、プロジェクトワークスペース、またはレポート内で操作したテーブルは、ビュー状態を自動的に保存します。テーブル操作を適用し、その後ブラウザを閉じても、次にテーブルに戻ったときに最後に表示された設定が保持されます。
特定の状態でワークスペースからテーブルを保存するには、W&B Report にエクスポートします。レポートにテーブルをエクスポートするには:
これらのレポートは、W&B Tables のさまざまなユースケースを強調しています:
すべての W&B Artifacts 同様に、Tables は pandas データフレームに変換して、データのエクスポートを簡単に行うことができます。
table を artifact に変換するまず、テーブルをアーティファクトに変換する必要があります。これを行う最も簡単な方法は artifact.get(table, "table_name") を使用することです：
# 新しいテーブルを作成してログします。
with wandb.init() as r:
artifact = wandb.Artifact("my_dataset", type="dataset")
table = wandb.Table(
columns=["a", "b", "c"], data=[(i, i * 2, 2**i) for i in range(10)]
)
artifact.add(table, "my_table")
wandb.log_artifact(artifact)
# 作成したアーティファクトを使用してテーブルを取得します。
with wandb.init() as r:
artifact = r.use_artifact("my_dataset:latest")
table = artifact.get("my_table")
artifact をデータフレームに変換する次に、テーブルをデータフレームに変換します：
# 前のコード例から続けて：
df = table.get_dataframe()
現在、データフレームがサポートする任意のメソッドを使用してエクスポートできます：
# テーブルデータを .csv に変換
df.to_csv("example.csv", encoding="utf-8")
artifacts に関する リファレンスドキュメント をチェックしてください。以下のセクションでは、テーブルの使用方法の一部を紹介します。
モデルのトレーニングまたは評価中にメトリクスやリッチメディアをログに記録し、それをクラウドに同期された永続的なデータベース、またはホスティングインスタンスで結果を視覚化します。
たとえば、このテーブルをご覧ください。写真データセットのバランスの取れた分割を示しています。
テーブルを表示、ソート、フィルタ、グループ化、結合、クエリして、データとモデルのパフォーマンスを理解します。静的ファイルを閲覧したり、分析スクリプトを再実行する必要はありません。
たとえば、このレポートをご覧ください。スタイルが転送されたオーディオについて。
異なるトレーニングエポック、データセット、ハイパーパラメーターの選択、モデルアーキテクチャーなど、さまざまな結果を迅速に比較します。
たとえば、このテーブルを確認してください。同じテスト画像で2つのモデルを比較しています。
特定のステップでの特定の予測を視覚化するためにズームインします。ズームアウトして集計統計を確認し、エラーのパターンを識別し、改善の機会を理解します。このツールは、単一のモデルトレーニングからのステップを比較したり、異なるモデルバージョンの結果を比較するために使用されます。
たとえば、1回とその後5回のエポック後のMNISTデータセットでの結果を分析する例のテーブルをご覧ください。
以下では、W&B Tablesを使用した実際のW&Bプロジェクトの例を紹介します。
このレポートを読み、このcolabに従うか、このアーティファクトコンテキストを探り、CNNがiNaturalistの写真から10種類の生物（植物、鳥、昆虫など）を識別する方法を見てみてください。
ティンバー転送に関するこのレポートでオーディオテーブルと対話します。録音されたクジラの歌と同じメロディをバイオリンやトランペットのような楽器で合成したバージョンを比較できます。このcolabで自分の曲を録音し、その合成バージョンをW&Bで探索することもできます。
トレーニングデータや生成された出力からテキストサンプルを閲覧し、関連するフィールドで動的にグループ化し、モデルバリエーションや実験設定に合わせて評価を整えます。Markdownとしてテキストをレンダリングするか、ビジュアル差分モードを使用してテキストを比較します。このレポートでシェイクスピアを生成するためのシンプルな文字ベースのRNNを探ります。
モデルを理解するためにトレーニング中にログに記録されたビデオを閲覧および集約します。ここに、RLエージェントが副作用を最小化しようとするためのSafeLife ベンチマークを使用した初期の例があります。
バージョン管理とデータの重複排除を使用して表形式データを分割および前処理する方法に関するレポートを参照してください。
セマンティックセグメンテーションのためのTablesをログに記録し、さまざまなモデルを比較する対話型ノートブックとライブ例です。このTableで自分のクエリを試してみてください。
W&B Sweeps を使用してハイパーパラメータ検索を自動化し、豊富でインタラクティブな実験管理を視覚化します。ベイズ、グリッド検索、ランダムなどの一般的な検索メソッドから選択して、ハイパーパラメータ空間を探索できます。スイープを 1 台以上のマシンにわたってスケールし、並列化します。
2 つの W&B CLI コマンドで sweep を作成します:
wandb sweep --project <propject-name> <path-to-config file>
wandb agent <sweep-ID>
ユースケースに応じて、W&B Sweeps の開始に役立つ次のリソースを探索してください:
ステップバイステップのビデオについては、こちらをご覧ください: Tune Hyperparameters Easily with W&B Sweeps.
このページでは、スイープを定義、初期化、および実行する方法を示します。主に4つのステップがあります。
以下のコードを Jupyter ノートブックまたは Python スクリプトにコピーして貼り付けてください。
# W&B Python ライブラリをインポートして W&B にログインする
import wandb
wandb.login()
# 1: 目的/トレーニング関数を定義する
def objective(config):
score = config.x**3 + config.y
return score
def main():
wandb.init(project="my-first-sweep")
score = objective(wandb.config)
wandb.log({"score": score})
# 2: 探索空間を定義する
sweep_configuration = {
"method": "random",
"metric": {"goal": "minimize", "name": "score"},
"parameters": {
"x": {"max": 0.1, "min": 0.01},
"y": {"values": [1, 3, 7]},
},
}
# 3: スイープを開始する
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
wandb.agent(sweep_id, function=main, count=10)
以下のセクションでは、そのコードサンプルの各ステップを分解し、説明します。
wandb.config からハイパーパラメーターの値を取り込み、それを使用してモデルをトレーニングし、メトリクスを返すトレーニング関数を定義します。
オプションとして、W&B Run の出力を保存したいプロジェクトの名前（wandb.init内のproject パラメータ）を指定します。プロジェクトが指定されていない場合、Run は「Uncategorized」プロジェクトに入ります。
# 1: 目的/トレーニング関数を定義する
def objective(config):
score = config.x**3 + config.y
return score
def main():
wandb.init(project="my-first-sweep")
score = objective(wandb.config)
wandb.log({"score": score})
探索するハイパーパラメーターを辞書で指定します。設定オプションについては、スイープ設定を定義するを参照してください。
次の例では、ランダム検索（'method':'random'）を使用するスイープ設定を示しています。スイープは、バッチサイズ、エポック、および学習率の設定にリストされているランダムな値を無作為に選択します。
W&Bは、"goal": "minimize"が関連付けられているときに metric キーで指定されたメトリクスを最小化します。この場合、W&Bはメトリクス score（"name": "score"）を最小化するように最適化します。
# 2: 探索空間を定義する
sweep_configuration = {
"method": "random",
"metric": {"goal": "minimize", "name": "score"},
"parameters": {
"x": {"max": 0.1, "min": 0.01},
"y": {"values": [1, 3, 7]},
},
}
W&Bは、クラウド（標準）またはローカル（ローカル）で複数のマシンを横断してスイープを管理するために、Sweep Controller を使用します。Sweep Controller についての詳細は、ローカルで探索と停止のアルゴリズムを確認するを参照してください。
スイープを初期化すると、スイープ識別番号が返されます。
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
スイープの初期化に関する詳細は、スイープを初期化するを参照してください。
スイープを開始するには、wandb.agent APIコールを使用します。
wandb.agent(sweep_id, function=main, count=10)
プロジェクトを開くと、W&Bアプリダッシュボードでライブ結果を確認できます。数回のクリックで豊富なインタラクティブグラフを構築します。例えば、並列座標プロット、パラメータの重要度解析、およびその他です。
結果の視覚化方法に関する詳細は、スイープ結果を視覚化するを参照してください。サンプルのダッシュボードについては、このスイーププロジェクトを参照してください。
ターミナルで Ctrl+C を押して、現在のランを停止します。もう一度押すと、エージェントが終了します。
W&B Python SDKをスクリプトやJupyterノートブックに追加する方法は数多くあります。以下は、W&B Python SDKを独自のコードに統合するための「ベストプラクティス」の例です。
次のPythonスクリプトのコードを持っているとしましょう。main という関数を定義し、典型的なトレーニングループを模倣します。各エポックごとに、トレーニングおよび検証データセットに対して精度と損失が計算されます。この例の目的のために値はランダムに生成されます。
ハイパーパラメーター値を格納するための辞書 config を定義しました。セルの最後に、モックトレーニングコードを実行するために main 関数を呼び出します。
import random
import numpy as np
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
# ハイパーパラメーター値を含む設定変数
config = {"lr": 0.0001, "bs": 16, "epochs": 5}
def main():
# 固定値を定義する代わりに `wandb.config` から値を定義していることに注意
lr = config["lr"]
bs = config["bs"]
epochs = config["epochs"]
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)
print("epoch: ", epoch)
print("training accuracy:", train_acc, "training loss:", train_loss)
print("validation accuracy:", val_acc, "training loss:", val_loss)
以下のコード例は、W&B Python SDKをコードに追加する方法を示しています。CLIでW&B Sweepジョブを開始する場合、CLIタブを探索したいでしょう。JupyterノートブックやPythonスクリプト内でW&B Sweepジョブを開始する場合、Python SDKタブを探索してください。
W&B Sweepを作成するために、コード例に以下を追加しました:
batch_size), エポック (epochs), および学習率 (lr) のハイパーパラメーターが各スイープで変化します。スイープ設定の作成方法についての詳細は、Define sweep configurationを参照してください。wandb.sweepに渡します。これによりスイープが初期化され、スイープID (sweep_id) が返されます。スイープの初期化方法についての詳細は、Initialize sweepsを参照してください。wandb.init() APIを使用して、データを同期およびログ化しながら、バックグラウンドプロセスを生成して W&B Run として実行します。wandb.config から値を定義します。wandb.log を使用して最適化したいメトリクスをログします。設定で定義されたメトリクスを必ずログしてください。この例では、設定辞書 (sweep_configuration) で val_acc を最大化するスイープを定義しました。wandb.agent API呼び出しを使用してスイープを開始します。スイープID、スイープが実行する関数の名前 (function=main)、および試行する最大run数を4に設定します (count=4)。W&B Sweepの開始方法についての詳細は、Start sweep agentsを参照してください。import wandb
import numpy as np
import random
# スイープ設定を定義
sweep_configuration = {
"method": "random",
"name": "sweep",
"metric": {"goal": "maximize", "name": "val_acc"},
"parameters": {
"batch_size": {"values": [16, 32, 64]},
"epochs": {"values": [5, 10, 15]},
"lr": {"max": 0.1, "min": 0.0001},
},
}
# 設定を渡してスイープを初期化します。
# (オプション) プロジェクト名を指定
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
# `wandb.config` からハイパーパラメーターを受け取り、
# モデルをトレーニングしてメトリクスを返すトレーニング関数を定義
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():
run = wandb.init()
# 固定値を定義する代わりに `wandb.config`
# から値を定義していることに注意
lr = wandb.config.lr
bs = wandb.config.batch_size
epochs = wandb.config.epochs
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)
wandb.log(
{
"epoch": epoch,
"train_acc": train_acc,
"train_loss": train_loss,
"val_acc": val_acc,
"val_loss": val_loss,
}
)
# スイープジョブを開始
wandb.agent(sweep_id, function=main, count=4)
W&B Sweepを作成するために、最初にYAML設定ファイルを作成します。設定ファイルにはスイープが探索するハイパーパラメーターを含んでいます。次の例では、バッチサイズ (batch_size), エポック (epochs), および学習率 (lr) のハイパーパラメーターが各スイープで変化します。
# config.yaml
program: train.py
method: random
name: sweep
metric:
goal: maximize
name: val_acc
parameters:
batch_size:
values: [16,32,64]
lr:
min: 0.0001
max: 0.1
epochs:
values: [5, 10, 15]
W&B Sweep設定の作成方法についての詳細は、Define sweep configurationを参照してください。
YAMLファイルで program のキーにPythonスクリプトの名前を必ず指定してください。
次に、コード例に以下を追加します:
wandb) と PyYAML (yaml) をインポートします。PyYAMLはYAML設定ファイルを読み込むために使用します。wandb.init() APIを使用して、データを同期およびログ化しながら、バックグラウンドプロセスを生成して W&B Run として実行します。configパラメーターに設定オブジェクトを渡します。wandb.config からハイパーパラメーター値を定義します。wandb.log を使用して最適化したいメトリクスをログします。設定で定義されたメトリクスを必ずログしてください。この例では、設定辞書 (sweep_configuration) で val_acc を最大化するスイープを定義しました。import wandb
import yaml
import random
import numpy as np
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():
# 標準のハイパーパラメーターをセットアップします
with open("./config.yaml") as file:
config = yaml.load(file, Loader=yaml.FullLoader)
run = wandb.init(config=config)
# 固定値を定義する代わりに `wandb.config`
# から値を定義していることに注意
lr = wandb.config.lr
bs = wandb.config.batch_size
epochs = wandb.config.epochs
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)
wandb.log(
{
"epoch": epoch,
"train_acc": train_acc,
"train_loss": train_loss,
"val_acc": val_acc,
"val_loss": val_loss,
}
)
# メイン関数を呼び出します。
main()
CLIに移動します。CLI内で、スイープエージェントが試行する最大run数を設定します。これは任意のステップです。次の例では最大回数を5に設定しています。
NUM=5
次に、wandb sweep コマンドを使用してスイープを初期化します。YAMLファイルの名前を指定します。プロジェクトフラグ（--project）のためにプロジェクト名を指定することもできます:
wandb sweep --project sweep-demo-cli config.yaml
これによりスイープIDが返されます。スイープの初期化方法についての詳細は、Initialize sweepsを参照してください。
スイープIDをコピーし、次のコードスニペットの sweepID を置き換えて、wandb agent コマンドでスイープジョブを開始します:
wandb agent --count $NUM your-entity/sweep-demo-cli/sweepID
スイープジョブの開始方法についての詳細は、Start sweep jobsを参照してください。
スイープ設定で指定したメトリクスを明示的にW&Bにログすることを確認してください。スイープのメトリクスをサブディレクトリ内でログしないでください。
例えば、以下の擬似コードを考えてみてください。ユーザーが検証損失 ("val_loss": loss) をログしたいとします。まず、ユーザーは辞書に値を渡しますが、wandb.log に渡される辞書は辞書内のキーと値のペアに明示的にアクセスしていません:
# W&B Pythonライブラリをインポートし、W&Bにログイン
import wandb
import random
def train():
offset = random.random() / 5
acc = 1 - 2**-epoch - random.random() / epoch - offset
loss = 2**-epoch + random.random() / epoch + offset
val_metrics = {"val_loss": loss, "val_acc": acc}
return val_metrics
def main():
wandb.init(entity="<entity>", project="my-first-sweep")
val_metrics = train()
# 不正確。辞書内のキーと値のペアに明示的にアクセスする必要があります。
# 次のコードブロックでメトリクスを正しくログする方法を参照してください。
wandb.log({"val_loss": val_metrics})
sweep_configuration = {
"method": "random",
"metric": {"goal": "minimize", "name": "val_loss"},
"parameters": {
"x": {"max": 0.1, "min": 0.01},
"y": {"values": [1, 3, 7]},
},
}
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
wandb.agent(sweep_id, function=main, count=10)
代わりに、Python辞書内でキーと値のペアに明示的にアクセスしてください。例えば、次のコードは wandb.log メソッドに辞書を渡す際にキーと値のペアを指定しています:
# W&B Pythonライブラリをインポートし、W&Bにログイン
import wandb
import random
def train():
offset = random.random() / 5
acc = 1 - 2**-epoch - random.random() / epoch - offset
loss = 2**-epoch + random.random() / epoch + offset
val_metrics = {"val_loss": loss, "val_acc": acc}
return val_metrics
def main():
wandb.init(entity="<entity>", project="my-first-sweep")
val_metrics = train()
wandb.log({"val_loss", val_metrics["val_loss"]})
sweep_configuration = {
"method": "random",
"metric": {"goal": "minimize", "name": "val_loss"},
"parameters": {
"x": {"max": 0.1, "min": 0.01},
"y": {"values": [1, 3, 7]},
},
}
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
wandb.agent(sweep_id, function=main, count=10)
A W&B Sweep は、ハイパーパラメータの値を探索するための戦略と、それを評価するコードを組み合わせたものです。この戦略はすべてのオプションを試すというシンプルなものから、ベイズ最適化やハイパーバンド（BOHB）のように複雑なものまであります。
Sweep configuration を Python 辞書 または YAML ファイルで定義します。Sweep configuration をどのように定義するかは、あなたが sweep をどのように管理したいかによって異なります。
以下のガイドでは、sweep configuration のフォーマット方法について説明します。Sweep configuration options で、トップレベルの sweep configuration キーの包括的なリストをご覧ください。
両方のスイープ設定フォーマットオプション (YAML および Python 辞書) は、キーと値のペアおよびネストされた構造を利用します。
スイープ設定内でトップレベルキーを使用して、sweep 検索の特性を定義します。たとえば、スイープの名前（name キー）、検索するパラメータ（parameters キー）、パラメータ空間を検索する方法（method キー）、その他があります。
例えば、以下のコードスニペットは、YAML ファイルと Python 辞書の両方で定義された同じスイープ設定を示しています。スイープ設定内には、program、name、method、metric、および parameters という5つのトップレベルキーが指定されています。
スイープをコマンドライン (CLI) からインタラクティブに管理したい場合、YAML ファイルでスイープ設定を定義します。
program: train.py
name: sweepdemo
method: bayes
metric:
goal: minimize
name: validation_loss
parameters:
learning_rate:
min: 0.0001
max: 0.1
batch_size:
values: [16, 32, 64]
epochs:
values: [5, 10, 15]
optimizer:
values: ["adam", "sgd"]
Python スクリプトまたは Jupyter ノートブックでトレーニングアルゴリズムを定義する場合は、Python 辞書データ構造でスイープを定義します。
以下のコードスニペットは、sweep_configuration という変数名でスイープ設定を格納します：
sweep_configuration = {
"name": "sweepdemo",
"method": "bayes",
"metric": {"goal": "minimize", "name": "validation_loss"},
"parameters": {
"learning_rate": {"min": 0.0001, "max": 0.1},
"batch_size": {"values": [16, 32, 64]},
"epochs": {"values": [5, 10, 15]},
"optimizer": {"values": ["adam", "sgd"]},
},
}
トップレベルの parameters キーの中に、以下のキーがネストされています：learning_rate、batch_size、epoch、および optimizer。指定したネストされたキーごとに、1つ以上の値、分布、確率などを提供できます。詳細については、Sweep configuration options の parameters セクションを参照してください。
Sweep configurations はネストされたパラメータをサポートします。ネストされたパラメータを区切るには、トップレベルのパラメータ名の下に追加の parameters キーを使用します。スイープ設定は多層ネストをサポートします。
ベイズまたはランダムなハイパーパラメータ検索を使用する場合、確率分布を指定します。各ハイパーパラメータについて：
parameters キーを作成します。parameters キーの中に次のものをネストします：
distribution キーのために使用したい分布を指定します。ハイパーパラメータ名の下に distribution キーと値のペアをネストします。スイープ設定で定義されたネストされたパラメータは、W&B run 設定で指定されたキーを上書きします。
例として、次の設定で train.py Python スクリプト（行1-2で確認可能）で W&B run を初期化するとします。次に、sweep_configuration（行4-13）の辞書でスイープ設定を定義します。その後、スイープ設定辞書を wandb.sweep に渡してスイープ設定を初期化します（行16を確認）。
def main():
run = wandb.init(config={"nested_param": {"manual_key": 1}})
sweep_configuration = {
"top_level_param": 0,
"nested_param": {
"learning_rate": 0.01,
"double_nested_param": {"x": 0.9, "y": 0.8},
},
}
# Initialize sweep by passing in config.
sweep_id = wandb.sweep(sweep=sweep_configuration, project="<project>")
# Start sweep job.
wandb.agent(sweep_id, function=main, count=4)
W&B run が初期化されたときに渡された nested_param.manual_key はアクセスできません。run.config は、スイープ設定辞書で定義されたキーと値のペアのみを持っています。
次のテンプレートには、パラメータを構成し、検索制約を指定する方法を示しています。hyperparameter_name をあなたのハイパーパラメータの名前と、<> 内の任意の値で置き換えます。
program: <insert>
method: <insert>
parameter:
hyperparameter_name0:
value: 0
hyperparameter_name1:
values: [0, 0, 0]
hyperparameter_name:
distribution: <insert>
value: <insert>
hyperparameter_name2:
distribution: <insert>
min: <insert>
max: <insert>
q: <insert>
hyperparameter_name3:
distribution: <insert>
values:
- <list_of_values>
- <list_of_values>
- <list_of_values>
early_terminate:
type: hyperband
s: 0
eta: 0
max_iter: 0
command:
- ${Command macro}
- ${Command macro}
- ${Command macro}
- ${Command macro}
program: train.py
method: random
metric:
goal: minimize
name: loss
parameters:
batch_size:
distribution: q_log_uniform_values
max: 256
min: 32
q: 8
dropout:
values: [0.3, 0.4, 0.5]
epochs:
value: 1
fc_layer_size:
values: [128, 256, 512]
learning_rate:
distribution: uniform
max: 0.1
min: 0
optimizer:
values: ["adam", "sgd"]
sweep_config = {
"method": "random",
"metric": {"goal": "minimize", "name": "loss"},
"parameters": {
"batch_size": {
"distribution": "q_log_uniform_values",
"max": 256,
"min": 32,
"q": 8,
},
"dropout": {"values": [0.3, 0.4, 0.5]},
"epochs": {"value": 1},
"fc_layer_size": {"values": [128, 256, 512]},
"learning_rate": {"distribution": "uniform", "max": 0.1, "min": 0},
"optimizer": {"values": ["adam", "sgd"]},
},
}
program: train.py
method: bayes
metric:
goal: minimize
name: val_loss
parameters:
dropout:
values: [0.15, 0.2, 0.25, 0.3, 0.4]
hidden_layer_size:
values: [96, 128, 148]
layer_1_size:
values: [10, 12, 14, 16, 18, 20]
layer_2_size:
values: [24, 28, 32, 36, 40, 44]
learn_rate:
values: [0.001, 0.01, 0.003]
decay:
values: [1e-5, 1e-6, 1e-7]
momentum:
values: [0.8, 0.9, 0.95]
epochs:
value: 27
early_terminate:
type: hyperband
s: 2
eta: 3
max_iter: 27
以下のタブで early_terminate の最小または最大のイテレーション回数を指定する方法を示します：
この例のブラケットは [3, 3*eta, 3*eta*eta, 3*eta*eta*eta] で、結果として [3, 9, 27, 81] になります。
early_terminate:
type: hyperband
min_iter: 3
この例のブラケットは [27/eta, 27/eta/eta] で、[9, 3] になります。
early_terminate:
type: hyperband
max_iter: 27
s: 2
program: main.py
metric:
name: val_loss
goal: minimize
method: bayes
parameters:
optimizer.config.learning_rate:
min: !!float 1e-5
max: 0.1
experiment:
values: [expt001, expt002]
optimizer:
values: [sgd, adagrad, adam]
command:
- ${env}
- ${interpreter}
- ${program}
- ${args_no_hyphens}
/usr/bin/env python train.py --param1=value1 --param2=value2
python train.py --param1=value1 --param2=value2
以下のタブで一般的なコマンドマクロを指定する方法を示します：
{$interpreter} マクロを削除し、値を明示的に提供して Python インタプリタをハードコードします。例えば、以下のコードスニペットはその方法を示しています：
command:
- ${env}
- python3
- ${program}
- ${args}
次の例では、sweep configuration のパラメータで指定されていないコマンドライン引数を追加する方法を示します：
command:
- ${env}
- ${interpreter}
- ${program}
- "--config"
- "your-training-config.json"
- ${args}
あなたのプログラムが引数パースを使用しない場合、すべての引数を渡すのを避け、wandb.init がスイープパラメータを自動的に wandb.config に取り込むことを利用できます：
command:
- ${env}
- ${interpreter}
- ${program}
ツールのように引数を渡すコマンドを変更できます Hydra が期待する方法です。詳細については、Hydra with W&B を参照してください。
command:
- ${env}
- ${interpreter}
- ${program}
- ${args_no_hyphens}
スイープ設定は、ネストされたキーと値のペアで構成されます。スイープ設定内のトップレベルのキーを使用して、スイープ検索の特性を定義します。例えば、検索するパラメータ（parameter キー）、パラメータ空間を検索するための方法論（method キー）などがあります。
以下のテーブルはトップレベルのスイープ設定キーとその簡単な説明を示しています。各キーについての詳細情報は、該当するセクションを参照してください。
| トップレベルキー | 説明 |
|---|---|
program |
（必須）実行するトレーニングスクリプト |
entity |
このスイープのエンティティ |
project |
このスイープのプロジェクト |
description |
スイープのテキスト説明 |
name |
W&B UIに表示されるスイープの名前。 |
method |
（必須）検索戦略 |
metric |
最適化するメトリック（特定の検索戦略と停止基準でのみ使用） |
parameters |
（必須）検索するパラメータの範囲 |
early_terminate |
任意の早期停止基準 |
command |
トレーニングスクリプトに引数を渡して呼び出すためのコマンド構造 |
run_cap |
このスイープの最大 run 数 |
スイープ設定の構造については、スイープ設定の構造を参照してください。
metricmetric トップレベルスイープ設定キーを使用して、最適化するメトリックの名前、目標、そして対象のメトリックを指定します。
| キー | 説明 |
|---|---|
name |
最適化するメトリックの名前。 |
goal |
minimize または maximize のいずれか（デフォルトは minimize）。 |
target |
最適化するメトリックの目標値。このスイープは、指定した目標値に run が到達した場合や到達する場合、新しい run を作成しません。アクティブなエージェントが run を実行中の場合（runがターゲットに到達した場合）、エージェントが新しい run を作成するのを停止する前に、run が完了するのを待ちます。 |
parametersYAML ファイルまたは Python スクリプト内で、parameters をトップレベルキーとして指定します。parameters キーの中に、最適化したいハイパーパラメータの名前を提供します。一般的なハイパーパラメーターには、学習率、バッチサイズ、エポック数、オプティマイザーなどがあります。あなたのスイープ設定で定義された各ハイパーパラメータに対して、1つ以上の検索制約を指定します。
以下のテーブルは、サポートされているハイパーパラメータ検索制約を示しています。ハイパーパラメータとユースケースに基づいて、以下のサーチ制約のいずれかを使用して、スイープエージェントに検索する場所（分布の場合）または何を（value、valuesなど）検索または使用するかを指示します。
| 検索制約 | 説明 |
|---|---|
values |
このハイパーパラメータのすべての有効な値を指定します。gridと互換性があります。 |
value |
このハイパーパラメータの単一の有効な値を指定します。gridと互換性があります。 |
distribution |
確率 分布 を指定します。この表の後の注記ではデフォルト値に関する情報について説明しています。 |
probabilities |
randomを使用する際に、valuesのそれぞれの要素を選択する確率を指定します。 |
min, max |
（intまたはfloat）最大値と最小値。intの場合、int_uniform で分布されたハイパーパラメータ用。floatの場合、uniformで分布されたハイパーパラメータ用。 |
mu |
( float ) normal または lognormal で分布されたハイパーパラメータの平均パラメータ。 |
sigma |
( float ) normal または lognormal で分布されたハイパーパラメータの標準偏差パラメータ。 |
q |
( float ) 量子化されたハイパーパラメーターの量子化ステップサイズ。 |
parameters |
ルートレベルのパラメーター内に他のパラメーターをネストします。 |
W&B は、distribution が指定されていない場合、以下の条件に基づいて以下の分布を設定します：
categorical：valuesが指定された場合int_uniform：maxとminが整数として指定された場合uniform：maxとminが浮動小数点数として指定された場合constant：valueにセットを提供した場合methodmethodキーを使用して、ハイパーパラメータ検索戦略を指定します。選択できるハイパーパラメーター検索戦略は、グリッド検索、ランダム検索、およびベイズ探索です。
ハイパーパラメータのすべての組み合わせを反復します。グリッド検索は、各反復で使用するハイパーパラメータ値のセットに対して無知な決定を下します。グリッド検索は計算的に高コストになる可能性があります。
グリッド検索は、連続的な検索空間内を検索している場合、永遠に実行されます。
分布に基づいて、各反復でランダムかつ無知なハイパーパラメータ値のセットを選択します。ランダム検索は、コマンドラインやあなたの python スクリプト、または W&B アプリUI でプロセスを停止しない限り、永遠に実行されます。
ランダム(method: random)検索を選択した場合、metricキーで分布空間を指定します。
ランダム検索とグリッド検索とは対照的に、ベイズモデルを使用して情報に基づく決定を行います。ベイズ最適化は、確率モデルを使用して、代理関数の値をテストする反復プロセスを経て、どの値を使用するかを決定します。ベイズ探索は、少数の連続的なパラメータに対して効果的ですが、スケールがうまくいかないことがあります。ベイズ探索に関する詳細情報は、ベイズ最適化の入門書を参照してください。
ベイズ探索は、コマンドラインやあなたの python スクリプト、または W&B アプリUI でプロセスを停止しない限り、永遠に実行されます。
parameter キー内で、ハイパーパラメーターの名前をネストします。次に、distributionキーを指定し、値の分布を指定します。
以下のテーブルでは、W&B がサポートする分布を示しています。
distributionキーの値 |
説明 |
|---|---|
constant |
定数分布。使用する定数値（value）を指定する必要があります。 |
categorical |
カテゴリ分布。このハイパーパラメータのすべての有効な値（values）を指定する必要があります。 |
int_uniform |
整数上の離散一様分布。max と min を整数として指定する必要があります。 |
uniform |
連続一様分布。max と min を浮動小数点数として指定する必要があります。 |
q_uniform |
量子化一様分布。X が一様である場合、round(X / q) * q を返します。q はデフォルトで 1。 |
log_uniform |
対数一様分布。exp(min) と exp(max) の間で X を返し、自然対数が min と max の間で一様に分布。 |
log_uniform_values |
対数一様分布。min と max の間で X を返し、log(X) が log(min) と log(max) の間で一様に分布。 |
q_log_uniform |
量子化対数一様分布。X が log_uniform である場合、round(X / q) * q を返します。q はデフォルトで 1。 |
q_log_uniform_values |
量子化対数一様分布。X が log_uniform_values である場合、round(X / q) * q を返します。q はデフォルトで 1。 |
inv_log_uniform |
逆対数一様分布。X を返し、log(1/X) が min と max の間で一様に分布。 |
inv_log_uniform_values |
逆対数一様分布。X を返し、log(1/X) が log(1/max) と log(1/min) の間で一様に分布。 |
normal |
正規分布。返される値は平均 mu（デフォルト 0）と標準偏差 sigma（デフォルト 1）で通常に分布。 |
q_normal |
量子化正規分布。X が normal である場合、round(X / q) * q を返します。q はデフォルトで 1。 |
log_normal |
対数正規分布。X の自然対数 log(X) が平均 mu（デフォルト 0）と標準偏差 sigma（デフォルト 1）で通常に分布する値 X を返します。 |
q_log_normal |
量子化対数正規分布。X が log_normal である場合、round(X / q) * q を返します。q はデフォルトで 1。 |
early_terminate実行のパフォーマンスが悪い場合に停止させるために早期終了（early_terminate）を使用します。早期終了が発生した場合、W&B は現在の run を停止し、新しいハイパーパラメータの値のセットで新しい run を作成します。
early_terminate を使用する場合、停止アルゴリズムを指定する必要があります。スイープ設定内で early_terminate 内に type キーをネストします。Hyperband ハイパーパラメータ最適化は、プログラムが停止すべきか、先に進むべきかを、bracketsと呼ばれるあらかじめ設定されたイテレーション数で評価します。
W&B run が bracket に到達したとき、sweep はその run のメトリックを過去に報告されたすべてのメトリック値と比較します。run のメトリック値が高すぎる場合（目標が最小化の場合）、または run のメトリックが低すぎる場合（目標が最大化の場合）、sweep は run を終了します。
ベースの反復数に基づいて bracket が設定されます。bracket の数は、最適化するメトリックをログした回数に対応します。反復はステップ、エポック、またはその中間に対応することができます。ステップカウンタの数値は bracket 計算に使用されません。
min_iter または max_iter のいずれかを指定してください。| キー | 説明 |
|---|---|
min_iter |
最初の bracket の反復を指定 |
max_iter |
最大反復数を指定。 |
s |
bracket の合計数を指定（ max_iter に必要） |
eta |
bracket 倍数スケジュールを指定（デフォルト： 3）。 |
strict |
より厳格にオリジナルの Hyperband 論文に従って run を厳しく削減する「strict」モードを有効にします。デフォルトでは false。 |
commandcommand キー内のネストされた値を使用して、形式と内容を修正できます。ファイル名などの固定コンポーネントを直接含めることができます。
/usr/bin/env は環境に基づいて OS が正しい Python インタープリターを選択することを保証します。W&B は、コマンドの可変コンポーネントのために次のマクロをサポートしています：
| コマンドマクロ | 説明 |
|---|---|
${env} |
Unix システムでは /usr/bin/env、Windows では省略されます。 |
${interpreter} |
python に展開されます。 |
${program} |
スイープ設定 program キーで指定されたトレーニングスクリプトファイル名。 |
${args} |
--param1=value1 --param2=value2 の形式でのハイパーパラメーターとその値。 |
${args_no_boolean_flags} |
ハイパーパラメータとその値が --param1=value1 の形式であるが、ブールパラメータは True の場合を --boolean_flag_param の形にし、False の場合は省略します。 |
${args_no_hyphens} |
param1=value1 param2=value2 の形式でのハイパーパラメータとその値。 |
${args_json} |
JSON としてエンコードされたハイパーパラメーターとその値。 |
${args_json_file} |
JSON としてエンコードされたハイパーパラメータとその値を含むファイルへのパス。 |
${envvar} |
環境変数を渡す方法。${envvar:MYENVVAR} __ は MYENVVAR 環境変数の値に展開されます。 __ |
W&B は、Sweep Controller を使用して、クラウド (標準)、ローカル (ローカル) の 1 台以上のマシンで スイープを管理します。run が完了すると、sweep controller は新しい run を実行するための新しい指示を発行します。これらの指示は、実際に run を実行する agents によって受け取られます。典型的な W&B Sweep では、controller は W&B サーバー上に存在し、agents は_あなたの_マシン上に存在します。
以下のコードスニペットは、CLI、および Jupyter Notebook や Python スクリプト内でスイープを初期化する方法を示しています。
wandb.init) は、W&B Sweep を初期化するときに提供する Project 名 (wandb.sweep) と一致している必要があります。W&B SDK を使用してスイープを初期化します。スイープ設定辞書を sweep パラメータに渡します。オプションで、W&B Run の出力を保存したい Project の名前を Project パラメータ (project) に指定することができます。Project が指定されていない場合は、run は「Uncategorized」Project に置かれます。
import wandb
# スイープ設定の例
sweep_configuration = {
"method": "random",
"name": "sweep",
"metric": {"goal": "maximize", "name": "val_acc"},
"parameters": {
"batch_size": {"values": [16, 32, 64]},
"epochs": {"values": [5, 10, 15]},
"lr": {"max": 0.1, "min": 0.0001},
},
}
sweep_id = wandb.sweep(sweep=sweep_configuration, project="project-name")
wandb.sweep 関数はスイープ ID を返します。スイープ ID には entity 名と Project 名が含まれます。スイープ ID をメモしておいてください。
W&B CLI を使用してスイープを初期化します。設定ファイルの名前を指定します。オプションで、project フラグに Project の名前を指定することができます。Project が指定されていない場合、W&B Run は「Uncategorized」Project に配置されます。
wandb sweep コマンドを使用してスイープを初期化します。次のコード例は、sweeps_demo Project のスイープを初期化し、config.yaml ファイルを設定に使用しています。
wandb sweep --project sweeps_demo config.yaml
このコマンドはスイープ ID を出力します。スイープ ID には entity 名と Project 名が含まれます。スイープ ID をメモしておいてください。
W&B Sweep を 1 台以上のマシン上の 1 台以上のエージェントで開始します。W&B Sweep エージェントは、ハイパーパラメーターを取得するために W&B Sweep を初期化したときにローンンチされた W&B サーバーにクエリを送り、それらを使用してモデル トレーニングを実行します。
W&B Sweep エージェントを開始するには、W&B Sweep を初期化したときに返された W&B Sweep ID を指定します。W&B Sweep ID の形式は次のとおりです。
entity/project/sweep_ID
ここで:
Jupyter ノートブックまたは Python スクリプト内で W&B Sweep エージェントを開始する場合、W&B Sweep が実行する関数の名前を指定します。
次のコードスニペットは、W&B でエージェントを開始する方法を示しています。ここでは、既に設定ファイルを持っており、W&B Sweep を初期化済みであると仮定しています。設定ファイルを定義する方法について詳しくは、Define sweep configuration を参照してください。
sweep agent コマンドを使用してスイープを開始します。スイープを初期化するときに返されたスイープ ID を指定します。以下のコードスニペットをコピーして貼り付け、sweep_id をスイープ ID に置き換えてください:
wandb agent sweep_id
W&B Python SDK ライブラリを使用してスイープを開始します。スイープを初期化するときに返されたスイープ ID を指定します。さらに、スイープが実行する関数の名前も指定します。
wandb.agent(sweep_id=sweep_id, function=function_name)
オプションで、Sweep agent が試みるべき W&B Runs の数を指定します。以下のコードスニペットは、Jupyter ノートブック、Python スクリプト内で最大の W&B Runs 数を設定する方法を示しています。
まず、スイープを初期化します。詳細は Initialize sweeps を参照してください。
sweep_id = wandb.sweep(sweep_config)
次にスイープジョブを開始します。スイープ初期化から生成されたスイープ ID を提供します。試行する run の最大数を設定するために count パラメータに整数値を渡します。
sweep_id, count = "dtzl1o7u", 10
wandb.agent(sweep_id, count=count)
wandb.teardown() を呼び出す必要があります。まず、wandb sweep コマンドでスイープを初期化します。詳細は Initialize sweeps を参照してください。
wandb sweep config.yaml
試行する run の最大数を設定するために、count フラグに整数値を渡します。
NUM=10
SWEEPID="dtzl1o7u"
wandb agent --count $NUM $SWEEPID
W&B スイープエージェントをマルチコアまたはマルチ GPU マシンで並列化しましょう。始める前に、W&B スイープが初期化されていることを確認してください。W&B スイープの初期化方法についての詳細は、Initialize sweepsをご覧ください。
ユースケースに応じて、以下のタブを参照し、CLI や Jupyter ノートブック内で W&B スイープエージェントを並列化する方法を学びましょう。
wandb agent コマンドを使用して、ターミナルで W&B スイープエージェントを複数の CPU に渡って並列化します。sweep を初期化したときに返されたスイープ ID を提供してください。
sweep_id をあなたのスイープ ID に置き換えます:wandb agent sweep_id
W&B Python SDK ライブラリを使用して、Jupyter ノートブック内で W&B スイープエージェントを複数の CPU に渡って並列化します。sweep を初期化したときに返されたスイープ ID を確認してください。さらに、スイープが実行する関数の名前を function パラメータに提供します。
sweep_id という変数にスイープ ID が保存されていて、関数の名前が function_name である場合、以下のコードスニペットを複数の Jupyter ノートブックに貼り付けることができます:wandb.agent(sweep_id=sweep_id, function=function_name)
CUDA Toolkit を使用して、ターミナルで W&B スイープエージェントを複数の GPU に渡って並列化するための手順に従ってください。
CUDA_VISIBLE_DEVICES を使用して使用する GPU インスタンスを指定します（wandb agent）。CUDA_VISIBLE_DEVICES に使用する GPU インスタンスに対応する整数値を割り当てます。例えば、ローカルマシンに 2 つの NVIDIA GPU があると仮定します。ターミナルウィンドウを開き、CUDA_VISIBLE_DEVICES を 0（CUDA_VISIBLE_DEVICES=0）に設定します。以下の例で、sweep_ID を初期化したときに返された W&B スイープ ID に置き換えます:
ターミナル 1
CUDA_VISIBLE_DEVICES=0 wandb agent sweep_ID
2 番目のターミナルウィンドウを開きます。CUDA_VISIBLE_DEVICES を 1（CUDA_VISIBLE_DEVICES=1）に設定します。次のコードスニペットで言及された sweep_ID に同じ W&B スイープ ID を貼り付けます:
ターミナル 2
CUDA_VISIBLE_DEVICES=1 wandb agent sweep_ID
Visualize の結果を W&B Sweeps の W&B App UI で確認しましょう。https://wandb.ai/home にアクセスして、W&B App UI に移動します。W&B Sweep を初期化した際に指定したプロジェクトを選択します。プロジェクトのworkspaceにリダイレクトされます。左側のパネルから Sweep アイコン （ほうきのアイコン）を選択します。 Sweep UI で、リストから Sweep の名前を選択します。
デフォルトでは、W&B は W&B Sweep ジョブを開始すると、パラレル座標プロット、パラメータの重要度プロット、そして散布図を自動的に作成します。
パラレル座標チャートは、多数のハイパーパラメーターとモデルメトリクスの関係を一目で要約します。パラレル座標プロットの詳細については、パラレル座標 を参照してください。
左の散布図は、Sweep の間に生成された W&B Runs を比較します。散布図の詳細については、散布図 を参照してください。
右のパラメータの重要度プロットは、メトリクスの望ましい値と高度に相関するハイパーパラメーターをリストアップします。パラメータの重要度プロットの詳細については、パラメータの重要度 を参照してください。
自動で使用される従属と独立の値（x と y 軸）を変更できます。各パネル内には Edit panel という鉛筆のアイコンがあります。Edit panel を選択します。モデルが表示されます。そのモデル内で、グラフの振る舞いを変更することができます。
すべてのデフォルトの W&B 可視化オプションの詳細については、パネル を参照してください。W&B Sweep の一部ではない W&B Runs からプロットを作成する方法については、Data Visualization docs を参照してください。
W&B Sweep を CLI で一時停止、再開、キャンセルすることができます。W&B Sweep を一時停止すると、新しい W&B Runs を再開するまで実行しないよう W&B エージェントに指示します。Sweep を再開すると、エージェントに新しい W&B Run の実行を続けるよう指示します。W&B Sweep を停止すると、W&B Sweep エージェントに新しい W&B Run の作成や実行を停止するように指示します。W&B Sweep をキャンセルすると、現在実行中の W&B Run を強制終了し、新しい Runs の実行を停止するよう Sweep エージェントに指示します。
それぞれの場合に、W&B Sweep を初期化したときに生成された W&B Sweep ID を指定します。新しいターミナルウィンドウを開いて、以下のコマンドを実行します。新しいターミナルウィンドウを開くと、現在のターミナルウィンドウに W&B Sweep が出力ステートメントを表示している場合でも、コマンドをより簡単に実行できます。
スイープを一時停止、再開、およびキャンセルするための次のガイダンスを使用してください。
W&B Sweep を一時的に停止して新しい W&B Run の実行を一時停止します。wandb sweep --pause コマンドを使用して W&B Sweep を一時停止します。一時停止したい W&B Sweep ID を指定します。
wandb sweep --pause entity/project/sweep_ID
一時停止している W&B Sweep を wandb sweep --resume コマンドで再開します。再開したい W&B Sweep ID を指定します。
wandb sweep --resume entity/project/sweep_ID
W&B スイープを完了し、新しい W&B Runs の実行を停止し、現在実行中の Runs が終了するのを待ちます。
wandb sweep --stop entity/project/sweep_ID
すべての実行中の run を強制終了し、新しい run の実行を停止するためにスイープをキャンセルします。wandb sweep --cancel コマンドを使用して W&B Sweep をキャンセルします。キャンセルしたい W&B Sweep ID を指定します。
wandb sweep --cancel entity/project/sweep_ID
CLI コマンドオプションの全リストについては、wandb sweep CLI リファレンスガイドを参照してください。
単一のターミナルから複数のエージェントにわたって W&B Sweep を一時停止、再開、停止、またはキャンセルします。たとえば、マルチコアマシンを持っていると仮定します。W&B Sweep を初期化した後、ターミナルウィンドウを新たに開き、各新しいターミナルに Sweep ID をコピーします。
任意のターミナル内で、wandb sweep CLI コマンドを使用して W&B Sweep を一時停止、再開、停止、またはキャンセルします。たとえば、以下のコードスニペットは、CLI を使用して複数のエージェントにわたって W&B Sweep を一時停止する方法を示しています。
wandb sweep --pause entity/project/sweep_ID
--resume フラグと共に Sweep ID を指定して、エージェントにわたって Sweep を再開します。
wandb sweep --resume entity/project/sweep_ID
W&B エージェントを並列化する方法の詳細については、Parallelize agents を参照してください。
ハイパーパラメータコントローラは、デフォルトでウェイト＆バイアスによってクラウドサービスとしてホストされています。W&Bエージェントはコントローラと通信して、トレーニングに使用する次のパラメータセットを決定します。コントローラは、どのrunを停止するかを決定するための早期停止アルゴリズムの実行も担当しています。
ローカルコントローラ機能により、ユーザーはアルゴリズムをローカルで検索および停止することができます。ローカルコントローラは、ユーザーにコードを検査および操作する能力を与え、問題のデバッグやクラウドサービスに組み込むことができる新機能の開発を可能にします。
始める前に、W&B SDK (wandb) をインストールする必要があります。次のコマンドをコマンドラインに入力してください：
pip install wandb sweeps
以下の例では、既に設定ファイルとPythonスクリプトまたはJupyterノートブックで定義されたトレーニングループがあることを前提としています。設定ファイルの定義方法についての詳細は、Define sweep configuration を参照してください。
通常、W&Bがホストするクラウドサービスのハイパーパラメータコントローラを使用する際と同様に、スイープを初期化します。ローカルコントローラをW&Bスイープジョブ用に使用することを示すために、コントローラフラグ (controller) を指定します：
wandb sweep --controller config.yaml
または、スイープを初期化することと、ローカルコントローラを使用することを指定することを2つのステップに分けることもできます。
ステップを分けるには、まず次のキーと値をスイープのYAML設定ファイルに追加します：
controller:
type: local
次に、スイープを初期化します：
wandb sweep config.yaml
スイープを初期化した後、wandb controller を使用してコントローラを開始します：
# wandb sweep コマンドが sweep_id を出力します
wandb controller {user}/{entity}/{sweep_id}
ローカルコントローラを使用することを指定した後、スイープを実行するために1つ以上のSweepエージェントを開始します。通常のW&Bスイープを開始するのと同じようにしてください。Start sweep agents を参照してください。
wandb sweep sweep_ID
以下のコードスニペットは、W&B Python SDKを使用してローカルコントローラを指定し、使用する方法を示しています。
Python SDKでコントローラを使用する最も簡単な方法は、wandb.controller メソッドにスイープIDを渡すことです。次に、戻りオブジェクトの run メソッドを使用してスイープジョブを開始します：
sweep = wandb.controller(sweep_id)
sweep.run()
コントローラループをより詳細に制御したい場合：
import wandb
sweep = wandb.controller(sweep_id)
while not sweep.done():
sweep.print_status()
sweep.step()
time.sleep(5)
パラメータの提供に関してさらに詳細なコントロールが必要な場合：
import wandb
sweep = wandb.controller(sweep_id)
while not sweep.done():
params = sweep.search()
sweep.schedule(params)
sweep.print_status()
コードですべてのスイープを指定したい場合は、次のように実装できます：
import wandb
sweep = wandb.controller()
sweep.configure_search("grid")
sweep.configure_program("train-dummy.py")
sweep.configure_controller(type="local")
sweep.configure_parameter("param1", value=3)
sweep.create()
sweep.run()
状態 (State)、作成時間 (Created)、スイープを開始したエンティティ (Creator)、完了した run の数 (Run count)、スイープの計算にかかった時間 (Compute time) が Sweeps UI に表示されます。スイープが作成する予想 run の数 (Est. Runs) は、離散探索空間でグリッド検索を行うと提供されます。インターフェースからスイープをクリックして、一時停止、再開、停止、または終了させることもできます。
Li, Lisha, et al. “Hyperband: A novel bandit-based approach to hyperparameter optimization.” The Journal of Machine Learning Research 18.1 (2017): 6765-6816.
次の W&B Reports では、W&B Sweeps を使用したハイパーパラメータ最適化を探るプロジェクトの例を紹介しています。
次のハウツーガイドでは、W&B を使用して現実世界の問題を解決する方法を示しています：
W&B はオープンソースを推奨し、コミュニティからの貢献を歓迎します。GitHub リポジトリは https://github.com/wandb/sweeps で見つけることができます。W&B オープンソース リポジトリへの貢献方法については、W&B GitHub Contribution guidelines を参照してください。
一般的なエラーメッセージのトラブルシューティングには、提案されたガイダンスを参照してください。
CommError, Run does not exist および ERROR Error uploadingこれら2つのエラーメッセージが返される場合、W&B Run ID が定義されている可能性があります。例えば、Jupyter Notebooks や Python スクリプトのどこかに類似のコードスニペットが定義されているかもしれません。
wandb.init(id="some-string")
W&B Sweeps では Run ID を設定することはできません。なぜなら、W&B が作成する Runs には、W&B が自動的にランダムで一意の ID を生成するからです。
W&B Run IDs は、プロジェクト内で一意である必要があります。
テーブルやグラフに表示するカスタム名を設定したい場合は、W&B を初期化するときに name パラメータに名前を渡すことをお勧めします。例えば：
wandb.init(name="a helpful readable run name")
Cuda out of memoryこのエラーメッセージが表示される場合は、プロセスベースの実行を使用するようにコードをリファクタリングしてください。具体的には、コードを Python スクリプトに書き換えてください。また、W&B Python SDK ではなく CLI から W&B Sweep Agent を呼び出してください。
例として、コードを train.py という名の Python スクリプトに書き直すとします。その際、トレーニングスクリプト (train.py) の名前を YAML Sweep 設定ファイル (config.yaml の例) に追加します。
program: train.py
method: bayes
metric:
name: validation_loss
goal: maximize
parameters:
learning_rate:
min: 0.0001
max: 0.1
optimizer:
values: ["adam", "sgd"]
次に、Python スクリプト train.py に以下を追加します。
if _name_ == "_main_":
train()
CLI に移動して、wandb sweep を使用して W&B Sweep を初期化します。
wandb sweep config.yaml
返された W&B Sweep ID をメモします。次に、 Sweep のジョブを CLI で wandb agent を使用して開始します。Python SDK (wandb.agent) ではなく、CLI を使用します。次のコードスニペットでは、sweep_ID を前のステップで返された Sweep ID に置き換えてください。
wandb agent sweep_ID
anaconda 400 errorこのエラーは通常、最適化しているメトリックをログしていない場合に発生します。
wandb: ERROR Error while calling W&B API: anaconda 400 error:
{"code": 400, "message": "TypeError: bad operand type for unary -: 'NoneType'"}
YAML ファイルやネストされた辞書内で、最適化する「metric」 というキーを指定します。このメトリックをログ (wandb.log) することを確認してください。また、Python スクリプトや Jupyter Notebook 内で最適化するように定義した exact なメトリック名を必ず使用してください。設定ファイルについての詳細は、Define sweep configuration を参照してください。
このチュートリアルでは、既存の W&B プロジェクトからスイープジョブを作成する方法を説明します。PyTorch の畳み込みニューラルネットワークを用いて画像を分類するために Fashion MNIST dataset を使用します。必要なコードとデータセットは、W&B のリポジトリにあります：https://github.com/wandb/examples/tree/master/examples/pytorch/pytorch-cnn-fashion
この W&B ダッシュボード で結果を探索してください。
最初にベースラインを作成します。W&B の GitHub リポジトリから PyTorch MNIST データセットの例モデルをダウンロードします。次に、モデルをトレーニングします。そのトレーニングスクリプトは examples/pytorch/pytorch-cnn-fashion ディレクトリーにあります。
git clone https://github.com/wandb/examples.gitcd examples/pytorch/pytorch-cnn-fashionpython train.pyオプションとして、W&B アプリ UI ダッシュボードで例を探索します。
あなたのプロジェクトページから、サイドバーの Sweep tab を開き、Create Sweep を選択します。
自動生成された設定は、完了した run に基づいてスイープする値を推測します。試したいハイパーパラメーターの範囲を指定するために設定を編集します。スイープをローンチすると、ホストされた W&B スイープサーバー上で新しいプロセスが開始されます。この集中サービスは、トレーニングジョブを実行しているエージェント（機械）を調整します。
次に、ローカルでエージェントをローンチします。作業を分散してスイープジョブをより早く終わらせたい場合は、最大20のエージェントを異なるマシンで並行してローンチすることができます。エージェントは、次に試すパラメータのセットを出力します。
これで、スイープを実行しています。以下の画像は、例のスイープジョブが実行されているときのダッシュボードがどのように見えるかを示しています。例のプロジェクトページを見る →
以前にログした既存の run を使用して新しいスイープをローンチします。
スイープはサーバー上に設定されます。run を開始するために、1つ以上のエージェントをローンチするだけです。
ワークスペースパネルの可視化機能を使用して ログされたデータ をキーごとに探り、ハイパーパラメーターと出力メトリクスの関係を可視化することなどができます。
W&B Projects は2つの異なるワークスペースモードをサポートしています。ワークスペース名の横のアイコンがそのモードを示しています。
| アイコン | ワークスペースモード |
|---|---|
 |
Automated workspaces はプロジェクト内でログされたすべてのキーに対して自動的にパネルを生成します。自動ワークスペースを選ぶ理由:
|
 |
Manual workspaces は最初は空白で、ユーザーによって意図的に追加されたパネルのみが表示されます。手動ワークスペースを選ぶ理由:
|
ワークスペースがパネルを生成する方法を変更するには、ワークスペースをリセットするを行います。
ワークスペースのリセット手順:
... をクリックします。ワークスペースレイアウトを設定するには、ワークスペースの上部近くにある Settings をクリックし、次に Workspace layout をクリックします。
ワークスペース内のラインプロットのデフォルトを設定するには、Line plots を参照してください。
セクションのレイアウトを設定するには、その歯車アイコンをクリックし、次に Display preferences をクリックします。
全画面表示モードでは、run 選択が表示され、パネルは通常の1000バケツではなく、10,000バケツでの完全な精度のサンプリングモードプロットを使用します。
全画面表示モードでパネルを表示するには:
... をクリックし、次に全画面ボタンをクリックします。これはビューファインダーまたは四角の四隅を示すアウトラインのように見えます。
全画面表示モードからパネルのワークスペースに戻るには、ページ上部の左向き矢印をクリックします。
このセクションでは、ワークスペースにパネルを追加するさまざまな方法を示します。
パネルをワークスペースに一度に1つずつ、グローバルまたはセクションレベルで追加できます。
... メニューをクリックし、次に + Add panels をクリックします。
Quick add を使用して、選択した各キーに対して自動的にパネルを追加できます。これをグローバルまたはセクションレベルで行うことができます。
... メニューをクリック、Add panels をクリックし、それから Quick add をクリックします。このセクションでは、リンクを使ってパネルを共有する方法を示します。
リンクを使ってパネルを共有するには、次のどちらかを行います:
... をクリックし、Copy panel URL を選択します。ユーザーまたはチームにリンクを共有します。リンクにアクセスすると、そのパネルは 全画面モード で開きます。
全画面表示モードからパネルのワークスペースに戻るには、ページ上部の左向き矢印をクリックします。
特定の状況、たとえば オートメーションを作成する場合などに、パネルの全画面URLを含めると便利です。このセクションでは、パネルの全画面URLの形式を示します。以下の例では、ブラケット内の entity, project, panel, section 名を置き換えてください。
https://wandb.ai/<ENTITY_NAME>/<PROJECT_NAME>?panelDisplayName=<PANEL_NAME>&panelSectionName=<SECTON_NAME>
同じセクション内の複数のパネルが同じ名前を持つ場合、このURLはその名前を持つ最初のパネルを開きます。
ウェブサイトにパネルを埋め込んだり、ソーシャルメディアで共有するには、そのパネルがリンクを持つ誰でも閲覧できる状態でなければなりません。プロジェクトがプライベートであれば、そのプロジェクトのメンバーのみがパネルを閲覧できます。プロジェクトが公開されていれば、リンクを持つ誰でもそのパネルを閲覧できます。
ソーシャルメディアでパネルを埋め込んで共有するコードを取得する手順:
... をクリックします。単一のパネルをスタンドアロンのレポートとしてメールする手順:
... をクリックします。パネルを共有する場合とは異なり、受信者はこのレポートからワークスペースにアクセスできません。
パネルを編集する手順:
異なるセクションにパネルを移動するには、パネルのドラッグハンドルを使用します。リストから新しいセクションを選択するには:
... メニューをクリックします。また、ドラッグハンドルを使用して、セクション内のパネルを並べ替えることもできます。
パネルを複製する手順:
... メニューをクリックします。必要に応じて、複製したパネルを カスタマイズ または 移動 することができます。
パネルを削除する手順:
... メニューを選択します。手動ワークスペースからすべてのパネルを削除するには、そのアクション ... メニューをクリックし、Clear all panels をクリックします。
自動または手動ワークスペースからすべてのパネルを削除するには、ワークスペースをリセットします。Automatic を選択すると、デフォルトのパネルセットから開始します。Manual を選択すると、パネルのない空のワークスペースから開始します。
デフォルトでは、ワークスペース内のセクションはキーのログ階層を反映しています。ただし、手動ワークスペースでは、一度パネルを追加し始めるとセクションが表示されます。
セクションを追加するには、最後のセクションの後に Add section をクリックします。
既存のセクションの前または後に新しいセクションを追加するには、セクションのアクション ... メニューをクリックし、New section below または New section above をクリックします。
多くのパネルを持つセクションは、Standard grid レイアウトを使用している場合デフォルトでページ分割されます。ページに表示されるパネルの数は、パネルの設定とセクション内のパネルのサイズによります。
... メニューをクリックします。セクションのレイアウトを変更するには、Layout grid セクションで Standard grid または Custom grid を選択します。<X> は表示中のパネル数、<Y> はパネルの合計数です。... メニューをクリックし、Layout grid セクションで Custom grid を選択します。... メニューをクリックします。ワークスペースを自動ワークスペースにリセットすると、削除されたすべてのパネルが再び表示されます。
セクション名を変更するには、そのアクション ... メニューから Rename section をクリックします。
セクションを削除するには、その ... メニューをクリックして Delete section をクリックします。これにより、セクションとそのパネルも削除されます。
ラインプロットは、wandb.log() でメトリクスを時間経過とともにプロットするとデフォルトで表示されます。複数のラインを同じプロットで比較したり、カスタム軸を計算したり、ラベルをリネームしたりするために、チャート設定をカスタマイズできます。
このセクションでは、個々のラインプロットパネル、セクション内のすべてのラインプロットパネル、またはワークスペース内のすべてのラインプロットパネルの設定を編集する方法を紹介します。
wandb.log() の呼び出しで y 軸と一緒にログを取るようにしてください。個々のラインプロットの設定は、セクションまたはワークスペースのラインプロット設定を上書きします。ラインプロットをカスタマイズするには:
次の設定をラインプロットに設定できます:
データ: プロットのデータ表示の詳細を設定します。
wandb.log() が呼び出されるたびに増加し、モデルからログされたトレーニングステップの数を反映することになっています。グルーピング: プロット内で run をどのようにグループ化し集計するかを設定します。
チャート: パネル、X軸、Y軸のタイトルを指定し、凡例を表示または非表示に設定し、その位置を設定します。
凡例: パネルの凡例の外観をカスタマイズします、もし有効化されている場合。
式: パネルにカスタム計算式を追加します。
${summary:value} です。ワークスペースの設定を上書きして、セクション内のすべてのラインプロットのデフォルトの設定をカスタマイズするには:
ワークスペース内のすべてのラインプロットのデフォルト設定をカスタマイズするには:
各 データ 設定の詳細については、前述のセクション 個別のラインプロット を参照してください。
各 表示設定 セクションの詳細については、ワークスペース表示設定 を参照してください。ワークスペースレベルで、ラインプロットのデフォルト ズーム 振る舞いを構成できます。この設定は、x 軸キーが一致するラインプロット間でズームの同期を制御します。デフォルトでは無効です。
複数の異なる実験があり、その値の平均をプロットで見たい場合は、テーブルのグルーピング機能を使用できます。runテーブルの上部で “グループ化” をクリックし、“すべて” を選択してグラフに平均値を表示します。
以下は平均化する前のグラフの例です:
次の画像は、グループ化されたラインを使用して run における平均値を示すグラフです。
wandb.log を使用して、PyTorch テンソルを含む NaN 値をラインプロットでプロットすることもできます。例えば:
wandb.log({"test": [..., float("nan"), ...]})
時々、run のデフォルトの色が比較には適していないことがあります。この問題を解決するために、wandb は手動で色を変更できる2つの方法を提供しています。
各 run は初期化時にデフォルトでランダムな色が割り当てられます。
どの色をクリックすると、手動で選択できるカラーパレットが表示されます。
実験がかかった絶対時間を見たい場合や、実験が実行された日を見たい場合は、x 軸を切り替えることができます。ここでは、ステップから相対時間、そして壁時間に切り替える例を示します。
詳細設定タブでさまざまなプロットスタイルをクリックすると、エリアプロットまたはパーセンテージエリアプロットを取得できます。
直線をクリックしてドラッグすると垂直および水平方向に同時にズームします。これにより、x軸とy軸のズームが変更されます。
この簡単なトグルでラインプロットの凡例をオフにできます:
折れ線グラフのX軸を、W&B.logで記録した任意の値に設定できます。ただし、それが常に数値として記録されている必要があります。
Y軸の変数は、wandb.logで記録した任意の値に設定できます。ただし、数値、数値の配列、または数値のヒストグラムを記録している必要があります。変数に対して1500点以上を記録した場合、W&Bは1500点にサンプリングします。
プロットのXとYの最大値と最小値を変更できます。
X範囲のデフォルトは、X軸の最小値から最大値までです。
Y範囲のデフォルトは、メトリクスの最小値と0からメトリクスの最大値までです。
デフォルトでは、10 runまたはrunのグループのみがプロットされます。runは、runsテーブルまたはrunセットの上位から取得されるため、runsテーブルやrunセットを並べ替えると、表示されるrunを変更できます。
チャートの凡例を制御して、任意のrunに対して記録した任意のconfig値やrunのメタデータ、例えば作成日時やrunを作成したユーザーを表示できます。
例:
${run:displayName} - ${config:dropout} は、各runの凡例名を royal-sweep - 0.5 のようにします。ここで royal-sweep はrun名で、0.5 は dropout という名前のconfigパラメータです。
グラフにカーソルを合わせたときにクロスヘアで特定の点の値を表示するために、[[ ]] 内に値を設定できます。例えば \[\[ $x: $y ($original) ]] は “2: 3 (2.9)” のように表示されます。
[[ ]] 内でサポートされる値は以下の通りです：
| 値 | 意味 |
|---|---|
${x} |
X値 |
${y} |
Y値（平滑化調整を含む） |
${original} |
平滑化調整を含まないY値 |
${mean} |
グループ化されたrunの平均 |
${stddev} |
グループ化されたrunの標準偏差 |
${min} |
グループ化されたrunの最小値 |
${max} |
グループ化されたrunの最大値 |
${percent} |
全体のパーセント（積み上げ面チャート用） |
全てのrunをグループ化するか、個々の変数でグループをすることができます。また、テーブル内部でグループ化することによってグループを有効にすると、そのグループは自動的にグラフに反映されます。
スムージング係数を0から1の間で設定できます。0はスムージングなし、1は最大スムージングを意味します。詳細はスムージング係数の設定についてを参照してください。
デフォルトのプロットの最小値と最大値のスケールから外れ値を除外するようにプロットをリスケールします。この設定がプロットに与える影響は、プロットのサンプリングモードに依存します。
式の表現を使用して、1-accuracyのようにメトリクスから派生した値をプロットできます。現在、単一のメトリクスをプロットしている場合にのみ機能します。+、-、*、/、%といった簡単な算術式、および**を使用してべき乗を行うことができます。
折れ線グラフのスタイルを選択します。
折れ線プロット：
面プロット：
パーセンテージエリアプロット：
Use point aggregation methods within your line plots for improved data visualization accuracy and performance. There are two types of point aggregation modes: full fidelity and random sampling. W&B uses full fidelity mode by default.
Full fidelity modeを使用すると、W&Bはデータポイントの数に基づいてx軸を動的なバケットに分割します。そして、それぞれのバケット内の最小、最大、平均値を計算し、線プロットのポイント集約をレンダリングします。
フルフィデリティモードを使用する際のポイント集約の3つの主な利点は次のとおりです:
線プロットの周囲に影付きのエリアを使って最小値と最大値を表示または非表示にします。
次の画像は、青い線プロットを示しています。薄い青の影付きエリアは各バケットの最小値と最大値を表しています。
線プロットで最小値と最大値をレンダリングする方法は3通りあります:
デフォルトでは、最小値と最大値は影付きエリアとして表示されません。影付きエリアオプションの1つを表示するには、以下の手順に従ってください:
データセットの特定の領域を分析し、極値やスパイクなどの重要なポイントを見逃さないようにします。線プロットをズームインすると、W&Bは各バケット内の最小、最大、および平均値を計算するために使用されるバケットサイズを調整します。
W&Bはデフォルトでx軸を1000のバケットに動的に分割します。各バケットに対し、W&Bは以下の値を計算します:
W&Bは、すべてのプロットでデータの完全な表現を保持し、極値を含める方法でバケット内の値をプロットします。1,000ポイント以下にズームインすると、フルフィデリティモードは追加の集約なしにすべてのデータポイントをレンダリングします。
線プロットをズームインするには、次の手順に従います:
Line Plot Groupingを使用すると、W&Bは選択されたモードに基づいて以下を適用します:
Random samplingはラインプロットをレンダリングするために1,500のランダムにサンプリングされたポイントを使用します。大量のデータポイントがある場合、パフォーマンスの理由でランダムサンプリングが有用です。
デフォルトでは、W&Bはフルフィデリティモードを使用します。ランダムサンプリングを有効にするには、次の手順に従います:
W&B Run APIを使用して、run中にログされたメトリクスの完全な履歴にアクセスできます。次の例は、特定のrunから損失値を取得し処理する方法を示しています:
# W&B APIを初期化
run = api.run("l2k2/examples-numpy-boston/i0wt6xua")
# 'Loss'メトリクスの履歴を取得
history = run.scan_history(keys=["Loss"])
# 履歴から損失値を抽出
losses = [row["Loss"] for row in history]
W&B は 3 つのタイプの平滑化をサポートしています:
これらが インタラクティブな W&B レポートでどのように動作するかをご覧ください。
指数平滑化は、時系列データを指数的に減衰させることで、過去のデータポイントの重みを滑らかにする手法です。範囲は 0 から 1 です。背景については 指数平滑化 をご覧ください。時系列の初期値がゼロに偏らないようにするためのデバイアス項が追加されています。
EMA アルゴリズムは、線上の点の密度（x 軸範囲の単位当たりの y 値の数）を考慮に入れます。これにより、異なる特性を持つ複数の線を同時に表示する際に、一貫した平滑化が可能になります。
これが内部でどのように動作するかのサンプルコードです:
const smoothingWeight = Math.min(Math.sqrt(smoothingParam || 0), 0.999);
let lastY = yValues.length > 0 ? 0 : NaN;
let debiasWeight = 0;
return yValues.map((yPoint, index) => {
const prevX = index > 0 ? index - 1 : 0;
// VIEWPORT_SCALE は結果をチャートの x 軸範囲にスケーリングします
const changeInX =
((xValues[index] - xValues[prevX]) / rangeOfX) * VIEWPORT_SCALE;
const smoothingWeightAdj = Math.pow(smoothingWeight, changeInX);
lastY = lastY * smoothingWeightAdj + yPoint;
debiasWeight = debiasWeight * smoothingWeightAdj + 1;
return lastY / debiasWeight;
});
これがアプリ内でどのように見えるかはこちらをご覧ください in the app:
ガウス平滑化（またはガウスカーネル平滑化）は、標準偏差が平滑化パラメータとして指定されるガウス分布に対応する重みを用いてポイントの加重平均を計算します。入力 x 値ごとに平滑化された値が計算されます。
ガウス平滑化は、TensorBoard の振る舞いと一致させる必要がない場合の標準的な選択肢です。指数移動平均とは異なり、ポイントは前後の値に基づいて平滑化されます。
これがアプリ内でどのように見えるかはこちらをご覧ください in the app:
移動平均は、与えられた x 値の前後のウィンドウ内のポイントの平均でそのポイントを置き換える平滑化アルゴリズムです。詳細は “Boxcar Filter” を参照してください https://en.wikipedia.org/wiki/Moving_average。移動平均のために選択されたパラメータは、Weights and Biases に移動平均で考慮するポイントの数を伝えます。
ポイントが x 軸上で不均一に配置されている場合は、ガウス平滑化を検討してください。
次の画像は、アプリ内での移動アプリの表示例を示しています in the app:
TensorBoard EMA アルゴリズムは、同じチャート上で一貫したポイント密度を持たない複数の線を正確に平滑化することができないため、非推奨とされました。
指数移動平均は、TensorBoard の平滑化アルゴリズムと一致するように実装されています。範囲は 0 から 1 です。背景については 指数平滑化 をご覧ください。時系列の初期値がゼロに偏らないようにするためのデバイアス項が追加されています。
これが内部でどのように動作するかのサンプルコードです:
data.forEach(d => {
const nextVal = d;
last = last * smoothingWeight + (1 - smoothingWeight) * nextVal;
numAccum++;
debiasWeight = 1.0 - Math.pow(smoothingWeight, numAccum);
smoothedData.push(last / debiasWeight);
これがアプリ内でどのように見えるかはこちらをご覧ください in the app:
すべての平滑化アルゴリズムはサンプリングされたデータで実行されます。つまり、1500 ポイント以上をログに記録した場合、平滑化アルゴリズムはサーバーからポイントがダウンロードされた後に実行されます。平滑化アルゴリズムの目的は、データ内のパターンを迅速に見つけることです。多くのログを持つメトリクスに対して正確な平滑化された値が必要な場合は、API を介してメトリクスをダウンロードし、自分自身の平滑化メソッドを実行する方が良いかもしれません。
デフォルトでは、オリジナルの非平滑化データを背景として薄い線で表示します。この表示をオフにするには、Show Original トグルをクリックしてください。
棒グラフは、矩形のバーでカテゴリカルデータを表示し、縦または横にプロットできます。全てのログされた値が長さ1の場合、wandb.log() を使用するとデフォルトで棒グラフが表示されます。
チャートの設定をカスタマイズして、表示する run の最大数を制限したり、任意の設定で run をグループ化したり、ラベルの名前を変更したりできます。
Box または Violin プロットを作成して、多くの要約統計量を1つのチャートタイプに組み合わせることもできます。
大規模なハイパーパラメーターとモデルメトリクスの関係を一目で要約できるのがパラレル座標チャートです。
wandb.config からのさまざまなハイパーパラメーターと wandb.log からのメトリクス。パネルを設定するには、パネルの右上にある編集ボタンをクリックします。
このページでは、W&B で散布図を使用する方法を示します。
散布図を使用して、複数の runs を比較し、実験のパフォーマンスを視覚化します。
次の例では、異なるモデルの数週間にわたる実験による検証精度を表示する散布図を示しています。ツールチップには、バッチサイズ、ドロップアウト、および軸の値が含まれています。また、検証精度のランニング平均を示す線も表示されます。
W&B UI で散布図を作成するには：
... をクリックします。x および y 軸を設定します。必要に応じて、軸の最大および最小範囲を設定するか、z 軸を追加してください。デフォルトでは、W&Bは最新のgitコミットハッシュのみを保存します。UIで実験間のコードを動的に比較するためのより多くのコード機能を有効にできます。
wandb バージョン 0.8.28 から、W&Bは wandb.init() を呼び出すメインのトレーニングファイルからコードを保存することができます。
コード保存を有効にすると、W&Bは wandb.init() を呼び出したファイルからコードを保存します。追加のライブラリコードを保存するには、以下の3つのオプションがあります:
wandb.init を呼び出した後に wandb.run.log_code(".") を呼び出すimport wandb
wandb.init()
wandb.run.log_code(".")
code_dir を設定して wandb.init に設定オブジェクトを渡すimport wandb
wandb.init(settings=wandb.Settings(code_dir="."))
これにより、現在のディレクトリーおよびすべてのサブディレクトリー内のPythonソースコードファイルがアーティファクトとしてキャプチャされます。保存されるソースコードファイルの種類と場所をより詳細に制御するには、リファレンスドキュメントを参照してください。
コード保存をプログラム的に設定する以外に、W&Bアカウントの設定でこの機能を切り替えることもできます。これを有効にすると、アカウントに関連付けられているすべてのチームでコード保存が有効になります。
デフォルトでは、W&Bはすべてのチームでコード保存を無効にします。
異なるW&B runで使用されたコードを比較する:
W&BはJupyterノートブックセッションで実行されたコードの履歴を保存します。Jupyter内でwandb.init() を呼び出すと、W&Bは現在のセッションで実行されたコードの履歴を含むJupyterノートブックを自動的に保存するフックを追加します。
これは、セッションで実行されたセルと、iPythonの表示メソッドを呼び出して作成された出力を表示します。これにより、指定されたrunのJupyter内でどのコードが実行されたかを正確に確認することができます。可能な場合、W&Bはノートブックの最新バージョンも保存し、コードディレクトリー内で見つけることができます。
ハイパーパラメーターがどのようにメトリクスの望ましい値の予測に役立ったか、また高い相関があったかを発見しましょう。
相関 とは、ハイパーパラメーターと選択されたメトリクスの線形相関を意味します（この場合は val_loss）。したがって、高い相関はハイパーパラメーターの値が高いとき、メトリクスの値も高くなり、その逆もまた然りであることを示します。相関は注目すべき素晴らしいメトリクスですが、入力間の二次の相互作用を捉えることはできず、非常に異なる範囲の入力を比較することが煩雑になる可能性があります。
そのため、W&Bは 重要度 メトリクスも計算します。W&Bはハイパーパラメーターを入力として、ランダムフォレストをトレーニングし、メトリクスをターゲット出力として、ランダムフォレストの特徴重要度値をレポートします。
この手法のアイデアは、Jeremy Howard との会話からインスピレーションを受け、Fast.aiにおいてハイパーパラメータースペースを探るためのランダムフォレストの特徴重要度の使用を推進してきたことから生まれました。W&Bはこの分析の背後にある動機を学ぶために、この講義 （およびこれらのノート）をチェックすることを強くお勧めします。
ハイパーパラメーター重要度パネルは、高い相関のハイパーパラメーター間の複雑な相互作用を解きほぐします。そして、モデルのパフォーマンスを予測する上で、どのハイパーパラメーターが最も重要であるかを示すことによって、ハイパーパラメーターの探索を調整するのに役立ちます。
パラメーターマネージャーを使用して、表示および非表示のパラメーターを手動で設定できます。
このパネルは、トレーニングスクリプト内で wandb.config オブジェクトに渡されたすべてのパラメーターを表示します。次に、これらのconfigパラメーターの特徴重要度と、それが選択されたモデルメトリクス（この場合は val_loss）との相関を示します。
重要度列は、選択したメトリクスを予測する際に、各ハイパーパラメーターがどの程度役立ったかを示します。多数のハイパーパラメーターを調整し始めて、それらの中からさらなる探索の価値があるものを特定するためにこのプロットを使用するシナリオを想像してみてください。その後の Sweeps は、最も重要なハイパーパラメーターに限定し、より良いモデルをより速く、安価に見つけることができます。
上記の画像では、epochs, learning_rate, batch_size と weight_decay がかなり重要であることがわかります。
相関は、個々のハイパーパラメーターとメトリクスの値との間の線形関係を捉えます。これにより、SGDオプティマイザーなどのハイパーパラメーターの使用と val_loss 間に有意な関係があるかどうかという問題に答えます（この場合、答えは「はい」です）。相関値は-1から1の範囲であり、正の値は正の線形相関を、負の値は負の線形相関を示し、0の値は相関がないことを示します。一般的に、どちらの方向でも0.7を超える値は強い相関を示します。
このグラフを使用して、メトリクスと高い相関のある値（この場合は確率的勾配降下法やadamを選択し、rmspropやnadamよりも優先することがあります）をさらに調査したり、より多くのエポックでトレーニングしたりすることができます。
重要度と相関の違いは、重要度がハイパーパラメーター間の相互作用を考慮に入れる一方で、相関は個々のハイパーパラメーターがメトリクスに与える影響のみを測定するという事実から生じます。第二に、相関は線形関係のみを捉えるのに対し、重要度はより複雑な関係を捉えることができます。
見てわかるように、重要度と相関はどちらもハイパーパラメーターがモデルのパフォーマンスにどのように影響するかを理解するための強力なツールです。
Run Comparer を使用して、異なる run 間でメトリクスがどのように異なるかを確認します。
diff only オプションを切り替えて、 run 間で値が同じ行を非表示にします。
weave-plot を追加してください。クエリパネルを使用してデータをクエリし、インタラクティブに視覚化します。
ワークスペースまたはレポート内にクエリを追加します。
Add panel をクリックします。Query panel を選択します。
/Query panel と入力して選択します。
または、一連の Runs とクエリを関連付けることができます。
/Panel grid と入力して選択します。Add panel ボタンをクリックします。Query panel を選択します。クエリ式を使用して、W&Bに保存されたデータ、例えば Runs、Artifacts、Models、Tables などをクエリします。
W&B Tableをクエリしたいとします。トレーニングコード内で "cifar10_sample_table" という名前のテーブルをログします:
import wandb
wandb.log({"cifar10_sample_table":<MY_TABLE>})
クエリパネル内でテーブルをクエリするには次のようにします:
runs.summary["cifar10_sample_table"]
これを分解すると:
runs は、ワークスペースに Query Panel があるときに自動的に Query Panel Expressions に注入される変数です。その値は、その特定のワークスペースに表示される Runs のリストです。Run内の利用可能な異なる属性についてはこちらをお読みください。summary は、Run の Summary オブジェクトを返す操作です。Opsは マップされる ため、この操作はリスト内の各 Run に適用され、その結果として Summary オブジェクトのリストが生成されます。["cifar10_sample_table"] は Pick 操作（角括弧で示され）、predictions というパラメータを持ちます。Summary オブジェクトは辞書またはマップのように動作するため、この操作は各 Summary オブジェクトから predictions フィールドを選択します。インタラクティブに独自のクエリの書き方を学ぶには、こちらのレポートを参照してください。
パネルの左上コーナーにあるギアアイコンを選択してクエリ設定を展開します。これにより、ユーザーはパネルのタイプと結果パネルのパラメータを設定できます。
最後に、クエリ結果パネルは、選択したクエリパネル、設定によって設定された構成に基づいて、データをインタラクティブに表示する形式でクエリ式の結果をレンダリングします。次の画像は、同じデータのテーブルとプロットを示しています。
次に、クエリパネル内で行える一般的な操作を示します。
列オプションからソートします:
クエリ内で直接、または左上隅のフィルターボタンを使用してフィルターできます（2枚目の画像）。
マップ操作はリストを反復し、データ内の各要素に関数を適用します。これは、パネルクエリを使用して直接行うことも、列オプションから新しい列を挿入することによって行うこともできます。
クエリを使用してまたは列オプションからグループ化できます。
連結操作により、2つのテーブルを連結し、パネル設定から連結または結合できます。
クエリ内でテーブルを直接結合することも可能です。次のクエリ式を考えてみてください:
project("luis_team_test", "weave_example_queries").runs.summary["short_table_0"].table.rows.concat.join(\
project("luis_team_test", "weave_example_queries").runs.summary["short_table_1"].table.rows.concat,\
(row) => row["Label"],(row) => row["Label"], "Table1", "Table2",\
"false", "false")
左のテーブルは次のように生成されます:
project("luis_team_test", "weave_example_queries").\
runs.summary["short_table_0"].table.rows.concat.join
右のテーブルは次のように生成されます:
project("luis_team_test", "weave_example_queries").\
runs.summary["short_table_1"].table.rows.concat
ここで:
(row) => row["Label"] は各テーブルのセレクタであり、結合する列を決定します"Table1" と "Table2" は、結合された各テーブルの名前ですtrue と false は、左および右の内/外部結合設定ですクエリパネルを使用して runs オブジェクトにアクセスします。Runオブジェクトは、実験の記録を保存します。詳細については、こちらのレポートのセクションを参照してくださいが、簡単な概要として、runs オブジェクトには以下が含まれます:
summary: Runの結果を要約する情報の辞書です。精度や損失のようなスカラーや、大きなファイルを含むことができます。デフォルトでは、wandb.log()は記録された時系列の最終的な値をsummaryに設定します。直接summaryの内容を設定することもできます。summaryはRunの出力と考えてください。history: モデルがトレーニング中に変化する値を格納するための辞書のリストです。コマンド wandb.log() はこのオブジェクトに追加します。config: Runの設定情報を含む辞書で、トレーニングランのハイパーパラメーターやデータセットアーティファクトを作成するランの前処理方法などが含まれます。これらはRunの「入力」として考えてください。
Artifacts は W&B の中核概念です。これは、バージョン管理された名前付きファイルやディレクトリーのコレクションです。Artifacts を使用して、モデルの重み、データセット、およびその他のファイルやディレクトリーを追跡します。Artifacts は W&B に保存され、他の runs でダウンロードまたは使用できます。詳細と例は、こちらのセクションのレポートで確認できます。Artifacts は通常、project オブジェクトからアクセスします:
project.artifactVersion(): プロジェクト内の特定の名前とバージョンのアーティファクトバージョンを返しますproject.artifact(""): プロジェクト内の特定の名前のアーティファクトを返します。その後、.versions を使用してこのアーティファクトのすべてのバージョンのリストを取得できますproject.artifactType(): プロジェクト内の特定の名前の artifactType を返します。その後、.artifacts を使用して、このタイプを持つすべてのアーティファクトのリストを取得できますproject.artifactTypes: プロジェクト内のすべてのアーティファクトタイプのリストを返します
Embeddings はオブジェクト（人物、画像、投稿、単語など）を数字のリストで表現するために使用されます。これを ベクトル と呼ぶこともあります。機械学習やデータサイエンスのユースケースでは、Embeddings は様々な手法を用いて生成でき、幅広いアプリケーションで利用されます。このページでは、読者が Embeddings に精通しており、W&B 内でそれらを視覚的に分析することに関心があることを前提としています。
W&B を使用すると、wandb.Table クラスを使用して Embeddings をログできます。以下は、5 次元からなる 3 つの Embeddings の例です。
import wandb
wandb.init(project="embedding_tutorial")
embeddings = [
# D1 D2 D3 D4 D5
[0.2, 0.4, 0.1, 0.7, 0.5], # embedding 1
[0.3, 0.1, 0.9, 0.2, 0.7], # embedding 2
[0.4, 0.5, 0.2, 0.2, 0.1], # embedding 3
]
wandb.log(
{"embeddings": wandb.Table(columns=["D1", "D2", "D3", "D4", "D5"], data=embeddings)}
)
wandb.finish()
上記のコードを実行すると、W&B ダッシュボードにデータを含む新しいテーブルが作成されます。右上のパネルセレクタから 2D Projection を選択して Embeddings を 2 次元でプロットすることができます。デフォルトで賢明な設定が自動的に選択されますが、設定メニューから簡単に上書きできます。この例では、利用可能な 5 つの数値次元をすべて自動的に使用しています。
上記の例では Embeddings の基本的なログ方法を示しましたが、通常はもっと多くの次元とサンプルを扱います。UCI の手書き数字データセット UCI ML hand-written digits datasetを使って、SciKit-Learn を通じて提供される MNIST 数字データセットを考えてみましょう。このデータセットには 64 次元を持つ 1797 のレコードが含まれています。この問題は10クラスの分類ユースケースです。また、可視化のために入力データを画像に変換することもできます。
import wandb
from sklearn.datasets import load_digits
wandb.init(project="embedding_tutorial")
# データセットをロードする
ds = load_digits(as_frame=True)
df = ds.data
# "target" カラムを作成する
df["target"] = ds.target.astype(str)
cols = df.columns.tolist()
df = df[cols[-1:] + cols[:-1]]
# "image" カラムを作成する
df["image"] = df.apply(
lambda row: wandb.Image(row[1:].values.reshape(8, 8) / 16.0), axis=1
)
cols = df.columns.tolist()
df = df[cols[-1:] + cols[:-1]]
wandb.log({"digits": df})
wandb.finish()
上記のコードを実行した後、再び UI にテーブルが表示されます。 2D Projection を選択することで、Embedding の定義、色付け、アルゴリズム（PCA, UMAP, t-SNE）、アルゴリズムのパラメータ、さらにはオーバーレイ（この場合、点の上にマウスを置くと画像が表示されます）の設定を行うことができます。この特定のケースでは、すべて「スマートデフォルト」が設定されており、2D Projection をクリックするだけで非常に類似したものが見えるはずです。(この例を試してみてください)。
Embeddings はさまざまなフォーマットでログすることができます:
list[int], list[float], または np.ndarray にすることができます。int または float が受け入れられます。
さらに、他のすべてのテーブルと同様に、テーブルを構築する方法について多くのオプションがあります:
wandb.Table(dataframe=df) を使用してwandb.Table(data=[...], columns=[...]) を使用してtable.add_data(...) を使ってテーブルに行を追加します。table.add_col("col_name", ...)table.add_computed_columns(lambda row, ndx: {"embedding": model.predict(row)})2D Projection を選択した後、ギアアイコンをクリックしてレンダリング設定を編集できます。上記のカラムの選択に加えて、興味のあるアルゴリズム（および必要なパラメータ）を選ぶことができます。以下に、UMAP と t-SNE の各パラメータが表示されています。
W&Bプロジェクトでカスタムチャートを作成しましょう。任意のデータテーブルをログし、自由に可視化できます。フォント、色、ツールチップの詳細をVegaの力でコントロールしましょう。
wandb.plot_table()で呼び出します。
期待したデータが表示されない場合、選択した Runs に求めている列がログされていない可能性があります。チャートを保存し、Runsテーブルに戻って、選択した Runs を目のアイコンで確認してください。
W&Bにはスクリプトから直接ログできるいくつかの組み込みチャートプリセットがあります。これらには、ラインプロット、スキャッタープロット、バーチャート、ヒストグラム、PR曲線、ROC曲線が含まれます。
wandb.plot.line()
カスタムラインプロットをログします — 任意の軸xとy上の接続され順序付けされた点（x,y）のリストです。
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次元上に曲線をログします。もし2つのlistの値を互いにプロットする場合、listの値の数が完全に一致している必要があります（例えば、各点はxとyを持たなければなりません）。
例のレポートを確認するか、例のGoogle Colabノートブックを試すことができます。
wandb.plot.scatter()
カスタムスキャッタープロットをログします — 任意の軸xとy上の点（x, y）のリストです。
data = [[x, y] for (x, y) in zip(class_x_prediction_scores, class_y_prediction_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次元上にスキャッターポイントをログするためにこれを使うことができます。もし2つのlistの値を互いにプロットする場合、listの値の数が完全に一致している必要があります（例えば、各点はxとyを持たなければなりません）。
例のレポートを確認するか、例のGoogle Colabノートブックを試すことができます。
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"
)
}
)
任意のバーチャートをログするためにこれを使用することができます。list内のラベルと値の数は完全に一致している必要があります（例えば、各データポイントが両方を持つ必要があります）。
例のレポートを確認するか、例のGoogle Colabノートブックを試すことができます。
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=None)})
任意のヒストグラムをログするためにこれを使用することができます。注意として、 data は list of lists であり、2次元配列の行と列をサポートすることを意図しています。
例のレポートを確認するか、例のGoogle Colabノートブックを試すことができます。
wandb.plot.pr_curve()
Precision-Recall curve を1行で作成します。
plot = wandb.plot.pr_curve(ground_truth, predictions, labels=None, classes_to_plot=None)
wandb.log({"pr": plot})
コードが次にアクセス可能なときにこれをログできます:
predictions) の一群の例ground_truth)labels=["cat", "dog", "bird"...] ラベルインデックス0はcat、1番目はdog、2番目はbird…)
例のレポートを確認するか、例のGoogle Colabノートブックを試すことができます。
wandb.plot.roc_curve()
ROC curve を1行で作成します。
plot = wandb.plot.roc_curve(
ground_truth, predictions, labels=None, classes_to_plot=None
)
wandb.log({"roc": plot})
コードが次にアクセス可能なときにこれをログできます:
predictions) の一群の例ground_truth)labels=["cat", "dog", "bird"...] ラベルインデックス0はcat、1番目はdog、2番目はbird…)
例のレポートを確認するか、例のGoogle Colabノートブックを試すことができます。
組み込みプリセットを調整するか新しいプリセットを作成し、チャートを保存します。チャートIDを使ってそのカスタムプリセットに直接スクリプトからデータをログします。例のGoogle Colabノートブックを試す。
# プロットする列を持つテーブルを作成します
table = wandb.Table(data=data, columns=["step", "height"])
# テーブルの列からチャートのフィールドへのマッピング
fields = {"x": "step", "value": "height"}
# 新しいカスタムチャートプリセットを埋めるためにテーブルを使用
# 保存した自身のチャートプリセットを使用するには、vega_spec_nameを変更します
my_custom_chart = wandb.plot_table(
vega_spec_name="carey/new_chart",
data_table=table,
fields=fields,
)
スクリプトから次のデータタイプをログし、カスタムチャートで使用できます。
wandb.config にキーとしてログされた名前付きフィールドを含みます。例えば: wandb.config.learning_rate = 0.0001wandb.log({"val_acc" : 0.8})。トレーニング中に wandb.log() を使用してキーに複数回書き込んだ場合、サマリーはそのキーの最終的な値に設定されます。history フィールドを通じてクエリに利用可能です。wandb.Table() を使用してそのデータを保存し、それをカスタムパネルでクエリします。historyTable をクエリします。 wandb.Table() の呼び出しごとまたはカスタムチャートのログごとに、そのステップにおける履歴に新しいテーブルが作成されます。wandb.Table() を使ってデータを2次元配列としてログします。一般的にこのテーブルの各行は一つのデータポイントを表し、各列はプロットしたい各データポイントの関連フィールド/次元を示しています。カスタムパネルを設定する際、 wandb.log() に渡された名前付きキー（以下の custom_data_table）を通じてテーブル全体にアクセスでき、個別のフィールドには列の名前（x, y, z）を通じてアクセスできます。実験のさまざまなタイムステップでテーブルをログすることができます。各テーブルの最大サイズは10,000行です。例のGoogle Colabを試す。
# データのカスタムテーブルをログする
my_custom_data = [[x1, y1, z1], [x2, y2, z2]]
wandb.log(
{"custom_data_table": wandb.Table(data=my_custom_data, columns=["x", "y", "z"])}
)
新しいカスタムチャートを追加して開始し、次にクエリを編集して表示可能な Runs からデータを選択します。クエリはGraphQLを使用して、実行での設定、サマリー、履歴フィールドからデータを取得します。
右上のChartを選択してデフォルトプリセットから始めましょう。次に、Chart fieldsを選択してクエリから引き出したデータをチャートの対応するフィールドにマッピングします。
次の画像は、メトリックをどのように選択し、それを下のバーチャートフィールドにマッピングするかの一例を示しています。
パネルの上部にあるEditをクリックしてVega編集モードに入ります。ここでは、Vega仕様を定義して、UIでインタラクティブなチャートを作成することができます。チャートの任意の面を変更できます。例えば、タイトルを変更したり、異なるカラー スキームを選択したり、曲線を接続された線ではなく一連の点として表示したりできます。また、Vega変換を使用して値の配列をヒストグラムにビン分けするなど、データ自体にも変更を加えることができます。パネルプレビューはインタラクティブに更新されるため、Vega仕様やクエリを編集している間に変更の効果を確認できます。Vegaのドキュメントとチュートリアルを参照してください。
フィールド参照
W&Bからチャートにデータを引き込むには、Vega仕様のどこにでも"${field:<field-name>}" 形式のテンプレート文字列を追加します。これによりChart Fieldsエリアにドロップダウンが作成され、ユーザーがクエリ結果の列を選択してVegaにマップできます。
フィールドのデフォルト値を設定するには、この構文を使用します:"${field:<field-name>:<placeholder text>}"
モーダルの下部にあるボタンで、特定の可視化パネルに変更を適用します。または、プロジェクト内の他の場所で使用するためにVega仕様を保存できます。使い回しができるチャート定義を保存するには、Vegaエディタの上部にあるSave asをクリックしてプリセットに名前を付けます。
カスタムチャートを使用して、パネルに読み込むデータとその可視化を制御します。
まず、スクリプトにデータをログします。ハイパーパラメーターのようなトレーニングの開始時に設定される単一のポイントには wandb.config を使用します。時間の経過に伴う複数のポイントには wandb.log() を使用し、wandb.Table() でカスタムの2D配列をログします。ログされたキーごとに最大10,000データポイントのログを推奨します。
# データのカスタムテーブルをログする
my_custom_data = [[x1, y1, z1], [x2, y2, z2]]
wandb.log(
{"custom_data_table": wandb.Table(data=my_custom_data, columns=["x", "y", "z"])}
)
データテーブルをログするための短い例のノートブック を試してみてください。次のステップでカスタムチャートを設定します。生成されたチャートが ライブレポート でどのように見えるか確認できます。
データを視覚化するためにログしたら、プロジェクトページに移動し、新しいパネルを追加するために + ボタンをクリックし、Custom Chart を選びます。このワークスペース で案内に従うことができます。
summary をクリックして historyTable を選択し、run 履歴からデータを引き出す新しいクエリを設定します。wandb.Table() をログしたキーを入力します。上記のコードスニペットでは my_custom_table でした。例のノートブック では、キーは pr_curve と roc_curve です。これらの列がクエリに読み込まれたので、Vega フィールドのドロップダウンメニューで選択オプションとして利用可能です：
見た目はかなり良いですが、散布図から折れ線グラフに切り替えたいと思います。組み込みチャートの Vega スペックを変更するために Edit をクリックします。このワークスペース で案内に従うことができます。
Vega スペックを更新して可視化をカスタマイズしました：
これを別の場所で使用できるプリセットとして保存するには、ページ上部の Save as をクリックします。結果は次の通り、ROC 曲線と共に次のようになります：
ヒストグラムは、数値の分布を可視化し、大きなデータセットを理解するのに役立ちます。コンポジットヒストグラムは、同じビンにまたがる複数の分布を示し、異なるモデルまたはモデル内の異なるクラス間で2つ以上のメトリクスを比較することができます。ドライブシーンのオブジェクトを検出するセマンティックセグメンテーションモデルの場合、精度最適化と Intersection over union (IOU) の効果を比較したり、異なるモデルが車（データの大きく一般的な領域）と交通標識（より小さく一般的でない領域）をどれだけよく検出するかを知りたいかもしれません。デモ Colab では、生命体の10クラスのうち2つのクラスの信頼スコアを比較できます。
カスタム合成ヒストグラムパネルのバージョンを作成するには：
summaryTable フィールドを追加し、対応する ’tableKey’ を class_scores に設定して、run でログした wandb.Table を取得します。これにより、 wandb.Table のクラススコアとしてログされた列を使用して、ドロップダウン メニューから2つのヒストグラムビンセット (red_bins と blue_bins) を埋めることができます。私の例では、赤ビン の動物クラスの予測スコアと青ビン の植物の予測スコアを選びました。私の非常に短い実験の結果は次のようになりました：1,000エポックで1,000エグゼンプルだけでトレーニングすると、モデルはほとんどの画像が植物でないことに非常に自信を持ち、どの画像が動物かについては非常に不確かです。
Within a given workspace page there are three different setting levels: workspaces, sections, and panels. ワークスペース設定 は、ワークスペース全体に適用されます。セクション設定 は、セクション内のすべてのパネルに適用されます。パネル設定 は、個々のパネルに適用されます。
ワークスペース設定は、すべてのセクションとそれらのセクション内のすべてのパネルに適用されます。編集できるワークスペース設定は次の2種類です: Workspace layout と Line plots。Workspace layouts はワークスペースの構造を決定し、Line plots 設定はワークスペース内のラインプロットのデフォルト設定を制御します。
このワークスペースの全体的な構造に適用される設定を編集するには:
ワークスペースのレイアウトを設定して、ワークスペースの全体的な構造を定義します。これには、セクションのロジックとパネルの配置が含まれます。
ワークスペースレイアウトオプションページでは、ワークスペースがパネルを自動か手動で生成するかが表示されます。ワークスペースのパネル生成モードを調整するには、Panels を参照してください。
この表は、各ワークスペースのレイアウトオプションについて説明しています。
| ワークスペース設定 | 説明 |
|---|---|
| 検索中に空のセクションを非表示 | パネルを検索するときにパネルを含まないセクションを非表示にします。 |
| パネルをアルファベット順に並べ替え | ワークスペース内のパネルをアルファベット順に並べ替えます。 |
| セクションの組織化 | 既存のすべてのセクションとパネルを削除し、新しいセクション名で再配置します。また、新しく配置されたセクションを最初または最後のプレフィックスでグループ化します。 |
ワークスペースのLine plots設定を変更して、ラインプロットのグローバルデフォルトとカスタムルールを設定します。
Line plots 設定内で編集できる主要な設定は2つあります: Data と Display preferences。Data タブには次の設定が含まれています:
| ラインプロット設定 | 説明 |
|---|---|
| X軸 | ラインプロットのx軸のスケール。x軸はデフォルトで Step に設定されています。x軸オプションのリストは次の表を参照してください。 |
| 範囲 | x軸に表示する最小値と最大値の設定。 |
| 平滑化 | ラインプロットの平滑化を変更します。平滑化の詳細については、Smooth line plots を参照してください。 |
| 異常値 | 異常値を除外するためにプロットの最小スケールと最大スケールを再設定します。 |
| ポイント集計方法 | Data Visualization の精度とパフォーマンスを向上させます。詳細については、Point aggregation を参照してください。 |
| 最大の runs またはグループの数 | ラインプロットに表示する最大の runs またはグループ数を制限します。 |
Step 以外にも、x軸には他のオプションがあります:
| X軸オプション | 説明 |
|---|---|
| 相対時間 (Wall) | プロセスが開始してからのタイムスタンプ。例えば、run を開始して次の日にその run を再開したとします。その場合、記録されたポイントは24時間後です。 |
| 相対時間 (Process) | 実行中のプロセス内のタイムスタンプ。例えば、run を開始して10秒間続け、その後次の日に再開したとします。その場合、記録されたポイントは10秒です。 |
| ウォールタイム | グラフで最初の run が開始してから経過した時間（分）。 |
| Step | wandb.log() を呼び出すたびに増加します。 |
Display preferences タブ内で、以下の設定を切り替えることができます:
| ディスプレイ設定 | 説明 |
|---|---|
| すべてのパネルから凡例を削除 | パネルの凡例を削除します |
| ツールチップ内でカラード run 名を表示 | ツールチップ内で run をカラードテキストとして表示します |
| コンパニオンチャートツールチップで、ハイライトされた run のみを表示 | チャートツールチップ内でハイライトされた run のみを表示します |
| ツールチップ内に表示される run の数 | ツールチップ内で表示される run の数を表示します |
| プライマリチャートのツールチップにフル run 名を表示 | チャートツールチップで run のフルネームを表示します |
セクション設定は、そのセクション内のすべてのパネルに適用されます。ワークスペースセクション内では、パネルをソートしたり、並べ替えたり、セクション名を変更したりできます。
セクション設定を変更するには、セクションの右上隅にある3つの水平ドット (…) を選択します。
ドロップダウンから、セクション全体に適用される次の設定を編集できます:
| セクション設定 | 説明 |
|---|---|
| セクションの名前を変更 | セクションの名前を変更します |
| パネルを A-Z に並べ替え | セクション内のパネルをアルファベット順に並べ替えます |
| パネルを並べ替え | セクション内でパネルを手動で並べ替えるために、パネルを選択してドラッグします |
以下のアニメーションは、セクション内でパネルを並べ替える方法を示しています:
個々のパネルの設定をカスタマイズして、同じプロットで複数のラインを比較したり、カスタム軸を計算したり、ラベルを変更したりすることができます。パネルの設定を編集するには:
パネルに適用できる設定の完全なリストについては、Edit line panel settings を参照してください。
あなたの個別のユーザーアカウント内で編集できるのは、プロフィール写真、表示名、地理的な位置、経歴情報、アカウントに関連付けられたメール、および run のアラート管理です。また、設定ページを使用して GitHub リポジトリをリンクしたり、アカウントを削除したりできます。詳細はユーザー設定をご覧ください。
チーム設定ページを使用して、新しいメンバーをチームに招待または削除したり、チームの run のアラートを管理したり、プライバシー設定を変更したり、ストレージ使用量を表示および管理したりできます。チーム設定の詳細については、チーム設定をご覧ください。
ナビゲートして、 ユーザープロフィールページに移動し、右上のユーザーアイコンを選択します。 ドロップダウンメニューから、Settings を選択します。
Profile セクションでは、アカウント名と所属機関を管理および変更できます。オプションで、経歴、所在地、個人や所属機関のウェブサイトのリンクを追加したり、プロフィール画像をアップロードしたりできます。
イントロを編集するには、プロフィールの上部にある Edit をクリックします。 開く WYSIWYG エディターは Markdown をサポートしています。
/ を入力し、リストから Markdown を選択できます。@weights_biases アカウントのフォローバッジを X に追加するには、HTML の <img> タグを含む Markdown スタイルのリンクを追加します。そのバッジ画像にリンクさせます。
<img> タグでは、width、height、またはその両方を指定できます。どちらか一方だけを指定すると、画像の比率は維持されます。
Team セクションで新しいチームを作成します。 新しいチームを作成するには、New team ボタンを選択し、次の情報を提供します。
Beta Features セクションでは、開発中の新製品の楽しいアドオンやプレビューをオプションで有効にできます。有効にしたいベータ機能の横にある切り替えスイッチを選択します。
Runs がクラッシュしたり、終了したり、カスタムアラートを設定した際に通知を受け取ります。wandb.alert() を使用して電子メールまたは Slack 経由で通知を受け取ります。受け取りたいアラートイベントタイプの横にあるスイッチを切り替えます。
アラートの設定と管理方法の詳細については、Send alerts with wandb.alert を参照してください。
個人の Github アカウントを接続します。 Github アカウントを接続するには：
アカウントを削除するには、Delete Account ボタンを選択します。
Storage セクションでは、Weights and Biases サーバーにおけるアカウントの総メモリ使用量について説明しています。 デフォルトのストレージプランは 100GB です。ストレージと料金の詳細については、Pricing ページをご覧ください。
ナビゲートして ユーザー プロフィール ページ へ行き、右上隅の ユーザー アイコン を選択します。ドロップダウンから Billing を選択するか、Settings を選択してから Billing タブを選択してください。
プランの詳細 セクションは、あなたの組織の現在のプラン、料金、制限、使用状況を要約します。
ここから、プランを比較したり、営業と話をすることができます。
このセクションでは現在の使用状況を視覚的に要約し、今後の使用料金を表示します。使用量の月ごとの詳細を知るには、個々のタイルで View usage をクリックしてください。カレンダー月、チーム、プロジェクトごとの使用量をエクスポートするには、Export CSV をクリックしてください。
有料プランを使用している組織の場合、管理者は特定のしきい値に達したときに 1 回の請求期間ごとに 電子メールでアラートを受け取ります。billing admin である場合は組織の制限を増やす方法の詳細情報と、そうでない場合の billing admin への連絡方法を提供します。Pro plan では、billing admin のみが使用状況アラートを受け取ります。
これらのアラートは設定可能ではなく、以下の場合に送信されます：
使用状況や請求に関する質問については、アカウントチームまたはサポートにお問い合わせください。
このセクションでは、組織に登録されている支払い方法を表示します。支払い方法を追加していない場合、プランをアップグレードするか、有料ストレージを追加するときに追加を求められます。
このセクションでは、現在の billing admin を表示します。billing admin は組織の管理者であり、すべての請求関連メールを受信し、支払い方法を表示および管理することができます。
billing admin を変更するか、追加の users に役割を割り当てるには：
クレジットカードによる支払いを行う場合、このセクションでは月ごとの請求書を表示できます。
チームの設定を変更します。メンバー、アバター、通知、プライバシー、利用状況を含みます。組織の管理者およびチームの管理者は、チームの設定を表示および編集できます。
メンバーセクションでは、保留中の招待と、チームに参加する招待を受け入れたメンバーのリストを表示します。各メンバーのリストには、メンバーの名前、ユーザー名、メール、チームの役割、および Models や Weave へのアクセス権限が表示されます。これらは組織から継承されます。標準のチーム役割 Admin、Member、View-only から選択できます。組織が カスタムロールの作成をしている場合、カスタムロールを割り当てることもできます。
チームの作成、管理、およびチームのメンバーシップと役割の管理についての詳細は、Add and Manage Teams を参照してください。新しいメンバーを招待できる人や、チームの他のプライバシー設定を設定するには、プライバシー を参照してください。
Avatar セクションに移動して画像をアップロードすることで、アバターを設定します。
run がクラッシュしたり、完了したり、カスタムアラートを設定したりしたときにチームに通知します。チームは、メールまたは Slack を通じてアラートを受け取ることができます。
受け取りたいイベントタイプの横にあるスイッチを切り替えます。Weights and Biases はデフォルトで以下のイベントタイプオプションを提供します:
アラートの設定と管理についての詳細は、wandb.alert を使用したアラートの送信 を参照してください。
Slack の送信先を設定し、チームのオートメーションが、新しいアーティファクトが作成されたときや、run のメトリックが設定された閾値に達したときなどに Registry やプロジェクトでイベントが発生すると通知を送信できるようにします。Slack オートメーションの作成を参照してください。
This feature is available for all Enterprise licenses.
チームのオートメーションが、新しいアーティファクトが作成されたときや、run のメトリックが設定された閾値に達したときなどに Registry やプロジェクトでイベントが発生すると動作するようにウェブフックを設定します。Webhook オートメーションの作成を参照してください。
This feature is available for all Enterprise licenses.
Privacy セクションに移動してプライバシー設定を変更します。プライバシー設定を変更できるのは組織の管理者のみです。
Usage セクションでは、チームが Weights and Biases サーバーで消費した合計メモリ使用量について説明します。デフォルトのストレージプランは100GBです。ストレージと価格についての詳細は、Pricing ページを参照してください。
Storage セクションでは、チームのデータに対して使用されるクラウドストレージバケットの設定を説明します。詳細は Secure Storage Connector を参照するか、セルフホスティングしている場合は W&B Server ドキュメントをチェックしてください。
Add, delete, manage email types and primary email addresses in your W&B プロファイル 設定 ページ. Select your profile icon in the upper right corner of the W&B ダッシュボード. From the dropdown, select 設定. Within the 設定 ページ, scroll down to the Emails ダッシュボード:
プライマリーメール は 😎 絵文字でマークされています。プライマリーメール は、W&B アカウントを作成する際に提供したメールで自動的に定義されます。
Weights And Biases アカウント に関連付けられている プライマリーメール を変更するには、ケバブ ドロップダウン を選択します:
+ Add Email を選択して、メールを追加します。これにより、Auth0 ページに移動します。新しいメールの資格情報を入力するか、シングル サインオン (SSO) を使用して接続できます。
ケバブ ドロップダウン を選択し、Delete Emails を選択して、W&B アカウント に登録されているメールを削除します
ログイン メソッド 列には、アカウントに関連付けられているログイン メソッド が表示されます。
W&B アカウントを作成すると、確認メールがアカウント に送信されます。メール アドレス を確認するまで、メール アカウント は確認されていないと見なされます。未確認のメールは赤で表示されます。
元の確認メールがメール アカウントに送信されていない場合、もう一度メール アドレスでログインを試みて、2 回目の確認メールを取得してください。
アカウントのログインの問題がある場合は、support@wandb.com にお問い合わせください。
W&B Teams を使用して、あなたの ML チームのための中心的なワークスペースを作り、モデルをより迅速に構築しましょう。
あなたのチームのプロフィールページをカスタマイズして、イントロダクションを示したり、公開されているまたはチームメンバーに表示されるレポートやプロジェクトを見せることができます。レポート、プロジェクト、外部リンクを提示します。
チーム管理者はチーム設定ページを開き、去るメンバーの名前の横にある削除ボタンをクリックします。チームにログされている run はユーザーが去った後も留まります。
同僚をチームに招待するときにチームの役割を選択します。以下のチームの役割オプションがあります：
チームメンバーは自分が作成した run のみを削除できます。メンバー A と B がいるとします。メンバー B が team B のプロジェクトからメンバー A が所有する別のプロジェクトに run を移動します。メンバー A は、メンバー B がメンバー A のプロジェクトに移動した run を削除できません。管理者は、チームメンバーによって作成された run およびスイープ run を管理できます。
チーム設定では、チームとそのメンバーのための設定を管理できます。これらの特権により、W&B 内でチームを効果的に監督および整理できます。
| 権限 | 閲覧のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| チームメンバーを追加 | X | ||
| チームメンバーを削除 | X | ||
| チーム設定を管理 | X |
以下の表は、特定のチーム全体で適用されるすべてのプロジェクトに関連する権限を示しています。
| 権限 | 閲覧のみ | チームメンバー | レジストリ管理者 | チーム管理者 |
|---|---|---|---|---|
| エイリアスを追加する | X | X | X | |
| モデルをレジストリに追加する | X | X | X | |
| レジストリ内のモデルを閲覧する | X | X | X | X |
| モデルをダウンロードする | X | X | X | X |
| レジストリ管理者を追加または削除する | X | X | ||
| 保護されたエイリアスを追加または削除する | X |
保護されたエイリアスの詳細については、レジストリアクセス制御 を参照してください。
レポート権限は、レポートの作成、閲覧、編集へのアクセスを許可します。以下の表は、特定のチーム全体でのすべてのレポートに適用される権限を列挙しています。
| 権限 | 閲覧のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| レポートを閲覧する | X | X | X |
| レポートを作成する | X | X | |
| レポートを編集する | X (チームメンバーは自分のレポートのみ編集できます) | X | |
| レポートを削除する | X (チームメンバーは自分のレポートのみ編集できます) | X |
以下の表は、特定のチーム全体でのすべての実験に適用される権限を示しています。
| 権限 | 閲覧のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| 実験のメタデータを閲覧する（履歴メトリクス、システムメトリクス、ファイル、およびログを含む） | X | X | X |
| 実験パネルとワークスペースを編集する | X | X | |
| 実験をログする | X | X | |
| 実験を削除する | X (チームメンバーは自分が作成した実験のみ削除できます) | X | |
| 実験を停止する | X (チームメンバーは自分が作成した実験のみ停止できます) | X |
以下の表は、特定のチーム全体でのすべてのアーティファクトに適用される権限を示しています。
| 権限 | 閲覧のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| アーティファクトを閲覧する | X | X | X |
| アーティファクトを作成する | X | X | |
| アーティファクトを削除する | X | X | |
| メタデータを編集する | X | X | |
| エイリアスを編集する | X | X | |
| エイリアスを削除する | X | X | |
| アーティファクトをダウンロードする | X | X |
システム権限を使用して、チームとそのメンバーを作成および管理し、システム設定を調整します。これらの特権により、W&B インスタンスを効果的に管理および維持することができます。
| 権限 | 閲覧のみ | チームメンバー | チーム管理者 | システム管理者 |
|---|---|---|---|---|
| システム設定を設定する | X | |||
| チームを作成/削除する | X |
Open プロジェクトの可視性に設定されている場合にのみプロジェクトにログできます。W&B プランの詳細については、価格ページを参照してください。ダッシュボード UI または Export API を利用して、いつでもすべてのデータをダウンロードできます。
チーム設定ページで、すべてのチームプロジェクトのプライバシー設定を見ることができます：
app.wandb.ai/teams/your-team-name
チームレベルの安全なストレージコネクタにより、チームは自分たちのクラウドストレージバケットを W&B とともに使用できます。これは、非常に機密性の高いデータまたは厳しいコンプライアンス要件を持つチームにとって、データアクセス制御およびデータ分離を向上させます。安全なストレージコネクタ を参照してください。
If you are approaching or exceeding your storage limit, there are multiple paths forward to manage your data. The path that’s best for you will depend on your account type and your current project setup.
W&B は、ストレージ消費を最適化するためのさまざまなメソッドを提供しています:
ストレージ制限以下に留めるためにデータを削除することも選択できます。これを行う方法はいくつかあります:
このページでは、W&B SDKによって追跡されるシステムメトリクスについての詳細情報を提供します。
wandb は、15秒ごとに自動的にシステムメトリクスをログに記録します。プロセスによるCPU使用率を、利用可能なCPU数で正規化したものです。
W&Bは、このメトリクスに cpu タグを割り当てます。
プロセスによって利用されるスレッドの数です。
W&Bは、このメトリクスに proc.cpu.threads タグを割り当てます。
デフォルトでは、/ パスの使用状況メトリクスが収集されます。監視するパスを設定するには、次の設定を使用します：
run = wandb.init(
settings=wandb.Settings(
x_stats_disk_paths=("/System/Volumes/Data", "/home", "/mnt/data"),
),
)
指定されたパスに対するシステム全体のディスク使用率をパーセントで表します。
W&Bは、このメトリクスに disk.{path}.usagePercent タグを割り当てます。
指定されたパスに対するシステム全体のディスク使用量をギガバイト（GB）で表します。 アクセス可能なパスがサンプリングされ、各パスのディスク使用量（GB）がサンプルに追加されます。
W&Bは、このメトリクスに disk.{path}.usageGB タグを割り当てます。
システム全体のディスク読み込み量をメガバイト（MB）で示します。最初のサンプルが取られた時点で初期ディスク読み込みバイト数が記録されます。その後のサンプルは、現在の読み込みバイト数と初期値との差を計算します。
W&Bは、このメトリクスに disk.in タグを割り当てます。
システム全体のディスク書き込み量をメガバイト（MB）で示します。最初のサンプルが取られた時点で初期ディスク書き込みバイト数が記録されます。その後のサンプルは、現在の書き込みバイト数と初期値との差を計算します。
W&Bは、このメトリクスに disk.out タグを割り当てます。
プロセスのためのメモリResident Set Size (RSS)をメガバイト（MB）で表します。RSSは、プロセスによって占有されるメモリの一部であり、主記憶（RAM）に保持されるものです。
W&Bは、このメトリクスに proc.memory.rssMB タグを割り当てます。
プロセスのメモリ使用率を、利用可能なメモリ全体に対するパーセントで示します。
W&Bは、このメトリクスに proc.memory.percent タグを割り当てます。
システム全体のメモリ使用率を、利用可能なメモリ全体に対するパーセントで表します。
W&Bは、このメトリクスに memory_percent タグを割り当てます。
システム全体の利用可能なメモリをメガバイト（MB）で示します。
W&Bは、このメトリクスに proc.memory.availableMB タグを割り当てます。
ネットワーク上で送信されたバイトの合計を示します。 最初にメトリクスが初期化された際に、送信されたバイトの初期値が記録されます。その後のサンプルでは、現在の送信バイト数と初期値との差を計算します。
W&Bは、このメトリクスに network.sent タグを割り当てます。
ネットワーク上で受信されたバイトの合計を示します。 ネットワーク送信と同様に、メトリクスが最初に初期化された際に、受信されたバイトの初期値が記録されます。後続のサンプルでは、現在の受信バイト数と初期値との差を計算します。
W&Bは、このメトリクスに network.recv タグを割り当てます。
以下に説明するメトリクスに加え、プロセスおよびその子孫が特定のGPUを使用する場合、W&Bは対応するメトリクスを gpu.process.{gpu_index}.{metric_name} としてキャプチャします。
各GPUのGPUメモリ利用率をパーセントで表します。
W&Bは、このメトリクスに gpu.{gpu_index}.memory タグを割り当てます。
各GPUの全利用可能メモリに対するGPUメモリの割り当てをパーセントで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.memoryAllocated タグを割り当てます。
各GPUのGPUメモリ割り当てをバイト単位で指定します。
W&Bは、このメトリクスに gpu.{gpu_index}.memoryAllocatedBytes タグを割り当てます。
各GPUのGPU利用率をパーセントで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.gpu タグを割り当てます。
各GPUの温度を摂氏で示します。
W&Bは、このメトリクスに gpu.{gpu_index}.temp タグを割り当てます。
各GPUの電力使用量をワットで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.powerWatts タグを割り当てます。
各GPUの電力容量に対する電力使用をパーセントで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.powerPercent タグを割り当てます。
GPUのストリーミングマルチプロセッサ (SM) のクロックスピードをMHzで表します。このメトリクスは、計算タスクを担当するGPUコア内のプロセッシング速度を示唆しています。
W&Bは、このメトリクスに gpu.{gpu_index}.smClock タグを割り当てます。
GPUメモリのクロックスピードをMHzで表します。これは、GPUメモリと処理コア間のデータ転送速度に影響を与えます。
W&Bは、このメトリクスに gpu.{gpu_index}.memoryClock タグを割り当てます。
GPUでのグラフィックスレンダリング操作の基本クロックスピードをMHzで示します。このメトリクスは、可視化またはレンダリングタスク中のパフォーマンスを反映することが多いです。
W&Bは、このメトリクスに gpu.{gpu_index}.graphicsClock タグを割り当てます。
W&Bが自動的にエラーチェックプロトコルを使用して訂正する、GPU上のメモリエラーのカウントを追跡します。これにより、回復可能なハードウェアの問題を示します。
W&Bは、このメトリクスに gpu.{gpu_index}.correctedMemoryErrors タグを割り当てます。
W&Bが訂正しない、GPU上のメモリエラーのカウントを追跡します。これにより、処理の信頼性に影響を与える可能性がある回復不可能なエラーを示します。
W&Bは、このメトリクスに gpu.{gpu_index}.unCorrectedMemoryErrors タグを割り当てます。
GPUのビデオエンコーダの利用率をパーセントで表し、エンコーディングタスク（例えばビデオレンダリング）が実行されているときの負荷を示します。
W&Bは、このメトリクスに gpu.{gpu_index}.encoderUtilization タグを割り当てます。
W&Bは、AMDが提供する rocm-smi ツールの出力からメトリクスを抽出します（rocm-smi -a --json）。
ROCm 6.x (最新) および 5.x フォーマットがサポートされています。AMD ROCm ドキュメンテーションでROCmフォーマットの詳細を確認できます。新しいフォーマットにはより詳細が含まれています。
各AMD GPUデバイスのGPU利用率をパーセントで表します。
W&Bは、このメトリクスに gpu.{gpu_index}.gpu タグを割り当てます。
各AMD GPUデバイスの全利用可能メモリに対するGPUメモリの割り当てをパーセントで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.memoryAllocated タグを割り当てます。
各AMD GPUデバイスの温度を摂氏で示します。
W&Bは、このメトリクスに gpu.{gpu_index}.temp タグを割り当てます。
各AMD GPUデバイスの電力使用量をワットで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.powerWatts タグを割り当てます。
各AMD GPUデバイスの電力容量に対する電力使用をパーセントで示します。
W&Bは、このメトリクスに gpu.{gpu_index}.powerPercent をこのメトリクスに割り当てます。
特にARM Mac上のApple GPUデバイスにおけるGPU利用率をパーセントで示します。
W&Bは、このメトリクスに gpu.0.gpu タグを割り当てます。
ARM Mac上のApple GPUデバイスにおける全利用可能メモリに対するGPUメモリの割り当てをパーセントで示します。
W&Bは、このメトリクスに gpu.0.memoryAllocated タグを割り当てます。
ARM Mac上のApple GPUデバイスの温度を摂氏で示します。
W&Bは、このメトリクスに gpu.0.temp タグを割り当てます。
ARM Mac上のApple GPUデバイスの電力使用量をワットで示します。
W&Bは、このメトリクスに gpu.0.powerWatts タグを割り当てます。
ARM Mac上のApple GPUデバイスの電力容量に対する電力使用をパーセントで示します。
W&Bは、このメトリクスに gpu.0.powerPercent タグを割り当てます。
Graphcore IPU（インテリジェンスポロセッシングユニット）は、機械知能タスクのために特別に設計されたユニークなハードウェアアクセラレータです。
これらのメトリクスは、特定のIPUデバイスのさまざまな統計を表します。各メトリクスには、デバイスID（device_id）とメトリクスキー（metric_key）があり、それを識別します。W&Bは、このメトリクスに ipu.{device_id}.{metric_key} タグを割り当てます。
メトリクスは、Graphcore の gcipuinfo バイナリと相互作用する専用の gcipuinfo ライブラリを使用して抽出されます。sample メソッドは、プロセスID（pid）に関連する各IPUデバイスのこれらのメトリクスを取得します。時間の経過とともに変化するメトリクスまたはデバイスのメトリクスが最初に取得されたときにのみログに記録され、冗長なデータのログを回避します。
各メトリクスに対して、メトリクスの値をその生の文字列表現から抽出するために parse_metric メソッドが使用されます。メトリクスは、複数のサンプルを通じて aggregate メソッドを使用して集計されます。
利用可能なメトリクスとその単位は次のとおりです：
average board temp (C)): IPUボードの温度を摂氏で示します。average die temp (C)): IPUダイの温度を摂氏で示します。clock (MHz)): IPUのクロックスピードをMHzで示します。ipu power (W)): IPUの電力消費量をワットで示します。ipu utilisation (%)): IPUの利用率をパーセントで示します。ipu utilisation (session) (%)): 現在のセッションに特化したIPU利用率をパーセントで示します。speed (GT/s)): データ転送速度をGiga-transfers毎秒で示します。テンソルプロセッシングユニット（TPU）は、Googleによって開発されたASIC（アプリケーション特定統合回路）で、機械学習のワークロードを加速するために使用されます。
各TPUコアあたりの現在の高帯域幅メモリ使用量をバイト単位で示します。
W&Bは、このメトリクスに tpu.{tpu_index}.memoryUsageBytes タグを割り当てます。
各TPUコアあたりの現在の高帯域幅メモリ使用率をパーセントで示します。
W&Bは、このメトリクスに tpu.{tpu_index}.memoryUsageBytes タグを割り当てます。
TPUデバイスごとのTensorCoreデューティサイクルのパーセントです。サンプル期間中、アクセラレータTensorCoreが積極的に処理していた時間の割合を追跡します。大きな値は、より良いTensorCoreの利用率を意味します。
W&Bは、このメトリクスに tpu.{tpu_index}.dutyCycle タグを割り当てます。
AWS Trainiumは、機械学習ワークロードの高速化に焦点を当てた、AWSが提供する特殊なハードウェアプラットフォームです。AWSの neuron-monitor ツールを使用して、AWS Trainiumメトリクスをキャプチャします。
各ニューロンコアごとの利用率をパーセントで示します。
W&Bは、このメトリクスに trn.{core_index}.neuroncore_utilization タグを割り当てます。
ホストの総メモリ消費量をバイト単位で示します。
W&Bは、このメトリクスに trn.host_total_memory_usage タグを割り当てます。
ニューロンデバイス上の総メモリ使用量をバイト単位で示します。
W&Bは、このメトリクスに trn.neuron_device_total_memory_usage) タグを割り当てます。
以下はホストのメモリ使用量の内訳です：
trn.host_total_memory_usage.application_memory): アプリケーションによって使用されるメモリ。trn.host_total_memory_usage.constants): 定数に使用されるメモリ。trn.host_total_memory_usage.dma_buffers): ダイレクトメモリアクセスバッファに使用されるメモリ。trn.host_total_memory_usage.tensors): テンソルに使用されるメモリ。各ニューロンコアのメモリ使用に関する詳細情報：
trn.{core_index}.neuroncore_memory_usage.constants)trn.{core_index}.neuroncore_memory_usage.model_code)trn.{core_index}.neuroncore_memory_usage.model_shared_scratchpad)trn.{core_index}.neuroncore_memory_usage.runtime_memory)trn.{core_index}.neuroncore_memory_usage.tensors)カスタム正規表現ベースのメトリックフィルタを適用できるOpenMetrics / Prometheus互換データをエクスポートする外部エンドポイントからメトリクスをキャプチャし、ログに記録します。
特定のケースで NVIDIA DCGM-Exporter を使用してGPUクラスターのパフォーマンスを監視する方法の詳細な例については、このレポートを参照してください。
コードを誰でも簡単に実行できるように公開していますか？ 匿名モードを使用して、誰かがあなたのコードを実行し、W&B ダッシュボードを見て、W&B アカウントを作成することなく結果を視覚化できるようにします。
結果が匿名モードでログに記録されるようにするには、次のようにします：
import wandb
wandb.init(anonymous="allow")
例えば、次のコードスニペットは、W&B でアーティファクトを作成し、ログに記録する方法を示しています：
import wandb
run = wandb.init(anonymous="allow")
artifact = wandb.Artifact(name="art1", type="foo")
artifact.add_file(local_path="path/to/file")
run.log_artifact(artifact)
run.finish()
例のノートブックを試してみて、匿名モードがどのように機能するかを確認してください。