これは、このセクションの複数ページの印刷可能なビューです。 印刷するには、ここをクリックしてください.
W&B Models は、モデルを整理し、生産性とコラボレーションを向上させ、大規模なプロダクション ML を提供したい ML エンジニアのための SoR (system of record) です。
W&B Models を使用すると、次のことが可能です。
機械学習エンジニアは、W&B Models を ML の SoR (system of record) として信頼して、実験の追跡と可視化、モデルのバージョンとリネージの管理、およびハイパーパラメーターの最適化を行っています。
数行のコードで 機械学習 の 実験 を追跡します。次に、インタラクティブ ダッシュボードで 結果 を確認するか、Public APIを使用して、プログラムで アクセス できるように データ を Python にエクスポートできます。
PyTorch, Keras, or Scikitのような一般的な フレームワーク を使用する場合は、W&B インテグレーション を活用してください。インテグレーション の完全なリストと、W&B を コード に追加する方法については、インテグレーション ガイドを参照してください。
上の図は、複数の runsにわたって メトリクス を表示および比較できる ダッシュボード の例を示しています。
数行の コード で 機械学習 の 実験 を追跡します。
run.config)に保存します。run.log())を ログ に記録します。次の コード は、一般的な W&B の 実験 管理 ワークフロー を示しています。
# Start a run.
#
# When this block exits, it waits for logged data to finish uploading.
# If an exception is raised, the run is marked failed.
with wandb.init(entity="", project="my-project-name") as run:
# Save mode inputs and hyperparameters.
run.config.learning_rate = 0.01
# Run your experiment code.
for epoch in range(num_epochs):
# Do some training...
# Log metrics over time to visualize model performance.
run.log({"loss": loss})
# Upload model outputs as artifacts.
run.log_artifact(model)
ユースケース に応じて、次の リソース を調べて W&B Experiments を開始してください。
実験 と ログ の ベストプラクティス と ヒント については、Best Practices: Experiments and Loggingを参照してください。
W&B Python SDK を使用して、 機械学習 の 実験 を追跡します。次に、インタラクティブな ダッシュボード で 結果 を確認するか、W&B Public API でプログラムから アクセス できるように データ を Python にエクスポートできます。
この ガイド では、W&B の構成要素を使用して W&B の 実験 を作成する方法について説明します。
W&B の 実験 は、次の 4 つの ステップ で作成します。
wandb.init() を使用して、W&B Run を作成します。
次の コードスニペット は、この run を識別するために、説明が “My first experiment” である “cat-classification” という名前の W&B の プロジェクト で 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() を呼び出すときに プロジェクト が既に存在する場合、既存の プロジェクト に追加されます。たとえば、“cat-classification” という プロジェクト が既にある場合、その プロジェクト は引き続き存在し、削除されません。代わりに、新しい run がその プロジェクト に追加されます。学習率や モデル タイプなどの ハイパーパラメーター の 辞書 を保存します。config でキャプチャする モデル の 設定 は、 後で 結果 を整理してクエリするのに役立ちます。
with wandb.init(
...,
config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
...
実験 の構成方法の詳細については、実験 の構成 を参照してください。
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 で ログ 記録できるさまざまな データ タイプ の詳細については、実験 中の データ の ログ 記録 を参照してください。
オプションで、W&B Artifact を ログ 記録します。Artifacts を使用すると、 データセット と モデル を簡単に バージョン管理 できます。
# You can save any file or even a directory. In this example, we pretend
# the model has a save() method that outputs an ONNX file.
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"],
# Record the run's hyperparameters.
config={"epochs": 100, "learning_rate": 0.001, "batch_size": 128},
) as run:
# Set up model and data.
model, dataloader = get_model(), get_data()
# Run your training while logging metrics to visualize model performance.
for epoch in range(run.config["epochs"]):
for batch in dataloader:
loss, accuracy = model.training_step()
run.log({"accuracy": accuracy, "loss": loss})
# Upload the trained model as an artifact.
model.save("path_to_model.onnx")
run.log_artifact("path_to_model.onnx", name="trained-model", type="model")
W&B ダッシュボード を、 機械学習 モデル からの 結果 を整理して視覚化するための一元的な場所として使用します。数回クリックするだけで、パラレル座標図、パラメータ の重要性分析 などの豊富な インタラクティブ な グラフ を構築できます。その他 もあります。
実験 と特定の run の表示方法の詳細については、実験 からの 結果 の視覚化 を参照してください。
以下は、 実験 を作成する際に考慮すべき推奨 ガイドライン です。
wandb.init() を with ステートメント で使用して、 コード が完了するか 例外 が発生したときに、run が自動的に完了としてマークされるようにします。
Jupyter ノートブック では、Run オブジェクト を自分で管理する方が便利な場合があります。この場合、Run オブジェクト で finish() を明示的に呼び出して、完了としてマークできます。
# In a notebook cell:
run = wandb.init()
# In a different cell:
run.finish()
次の コードスニペット は、上記の ベストプラクティス を使用して W&B の 実験 を定義する方法を示しています。
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 の 実験 を定義する際に使用できる パラメータ の詳細については、API Reference Guide の wandb.init API ドキュメント を参照してください。
config プロパティを使用すると、トレーニングの設定を保存できます。
run.config プロパティを使用すると、実験の分析や将来の作業の再現が容易になります。W&B App で設定値ごとにグループ化したり、異なる W&B の run の設定を比較したり、各トレーニング設定がアウトプットに与える影響を評価したりできます。config プロパティは、複数の辞書のようなオブジェクトから構成できる辞書のようなオブジェクトです。
run.config の代わりに run.log を使用してください。通常、設定はトレーニングスクリプトの最初に定義されます。ただし、機械学習のワークフローは異なる場合があるため、トレーニングスクリプトの最初に設定を定義する必要はありません。
config 変数名では、ピリオド（.）の代わりにダッシュ（-）またはアンダースコア（_）を使用してください。
スクリプトがルートより下の run.config キーにアクセスする場合は、属性アクセス構文 config.key.value の代わりに辞書アクセス構文 ["key"]["value"] を使用してください。
以下のセクションでは、実験設定を定義するさまざまな一般的なシナリオについて概説します。
W&B Run としてデータを同期およびログ記録するためのバックグラウンド プロセスを生成するために、wandb.init() API を呼び出すときに、スクリプトの先頭で辞書を渡します。
次のコードスニペットは、設定値を持つ Python 辞書を定義する方法と、W&B Run を初期化するときにその辞書を引数として渡す方法を示しています。
import wandb
# config 辞書オブジェクトを定義します
config = {
"hidden_layer_sizes": [32, 64],
"kernel_sizes": [3],
"activation": "ReLU",
"pool_sizes": [2],
"dropout": 0.5,
"num_classes": 10,
}
# W&B を初期化するときに config 辞書を渡します
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:
# config 辞書から値にアクセスし、読みやすくするために変数に格納します
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)
スクリプト全体で config オブジェクトにパラメーターを追加できます。次のコードスニペットは、新しいキーと値のペアを config オブジェクトに追加する方法を示しています。
import wandb
# config 辞書オブジェクトを定義します
config = {
"hidden_layer_sizes": [32, 64],
"kernel_sizes": [3],
"activation": "ReLU",
"pool_sizes": [2],
"dropout": 0.5,
"num_classes": 10,
}
# W&B を初期化するときに config 辞書を渡します
with wandb.init(project="config_example", config=config) as run:
# W&B を初期化した後に config を更新します
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 の config を更新します。
API には、エンティティ、プロジェクト名、および Run の ID を指定する必要があります。これらの詳細は、Run オブジェクトまたは W&B App UI で確認できます。
with wandb.init() as run:
...
# 現在のスクリプトまたはノートブックから開始された場合は、Run オブジェクトから次の値を見つけるか、W&B App 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.DEFINE_string("model", None, "実行するモデル") # name, default, help
run.config.update(flags.FLAGS) # absl フラグを config に追加します
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 コマンドライン 引数を使用し、ファイルへのパスを指定します。
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 フラグを config として追加します
project は、結果の可視化、実験の比較、Artifactsの表示とダウンロード、オートメーションの作成などを行う中心的な場所です。
各 project には、サイドバーからアクセスできる次のものが含まれています。
project の workspace は、実験を比較するための個人的なサンドボックスを提供します。異なるアーキテクチャ、ハイパーパラメーター、データセット、プロセッシングなどで同じ問題に取り組んでいる、比較できる Models を整理するために project を使用します。
Runs Sidebar: project 内のすべての run のリスト。
Runs tab で列をピン留め、非表示、または順序を変更すると、Runs サイドバーにこれらのカスタマイズが反映されます。
Panels layout: このスクラッチ スペースを使用して、結果を調べたり、チャートを追加および削除したり、さまざまなメトリクスに基づいて Models のバージョンを比較したりできます。
セクション ドロップダウン メニューをクリックし、[Add section] をクリックして、パネルの新しいセクションを作成します。セクションの名前を変更したり、ドラッグして再編成したり、セクションを展開および折りたたんだりできます。
各セクションの右上隅にはオプションがあります。
パネルをドラッグ アンド ドロップして、セクションに再配置および整理します。パネルの右上隅にある [Move] ボタンをクリックして、パネルの移動先のセクションを選択することもできます。
ワークスペースの検索ボックスを使用して、パネルを絞り込みます。この検索は、パネルのタイトル (デフォルトでは可視化されたメトリクスの名前) と一致します。
Runs タブを使用して、run をフィルター処理、グループ化、および並べ替えます。
次のタブは、Runs タブで実行できる一般的なアクションを示しています。
Runs タブには、project 内の run に関する詳細が表示されます。デフォルトでは、多数の列が表示されます。
... をクリックして、Pin column をクリックします。固定された列は、Name 列の後のページの左側に表示されます。固定された列を固定解除するには、Unpin column を選択します。... をクリックして、Hide column をクリックします。現在非表示になっているすべての列を表示するには、Columns をクリックします。
Runs タブをカスタマイズすると、カスタマイズは Workspace タブ の Runs セレクターにも反映されます。
テーブル内のすべての行を、指定された列の値で並べ替えます。
上記の画像は、val_acc という名前のテーブル列の並べ替えオプションを表示する方法を示しています。
ダッシュボードの左上にある Filter ボタンを使用して、式で行全体をフィルター処理します。
Add filter を選択して、行に 1 つ以上のフィルターを追加します。3 つのドロップダウン メニューが表示されます。左から右へ、フィルター タイプは、列名、演算子、および値に基づいています。
| 列名 | 二項関係 | 値 | |
|---|---|---|---|
| 受け入れられる値 | 文字列 | =, ≠, ≤, ≥, IN, NOT IN, | 整数、浮動小数点数、文字列、タイムスタンプ、null |
式エディターには、列名と論理述語構造のオートコンプリートを使用して、各項のオプションのリストが表示されます。「and」または「or」(および場合によっては括弧) を使用して、複数の論理述語を 1 つの式に接続できます。
上記の画像は、`val_loss` 列に基づいたフィルターを示しています。フィルターは、検証損失が 1 以下の run を表示します。
列ヘッダーの Group by ボタンを使用して、特定の列の値で行全体をグループ化します。
デフォルトでは、これにより、他の数値列が、グループ全体のその列の値の分布を示すヒストグラムに変わります。グループ化は、データ内のより高レベルのパターンを理解するのに役立ちます。
1 か所で結果のすべてのスナップショットを確認し、チームと学びを共有します。
project から新しい sweep を開始します。
トレーニングデータセットや fine-tuned models から、メトリクスとメディアのテーブル まで、project に関連付けられているすべての Artifacts を表示します。
Overview パネルには、Artifacts の名前とバージョン、変更を検出して重複を防ぐために使用されるハッシュ ダイジェスト、作成日、エイリアスなど、Artifacts に関するさまざまな高度な情報が表示されます。ここでエイリアスを追加または削除したり、バージョンと Artifacts 全体の両方に関するメモを取ることができます。
Metadata パネルは、Artifacts のメタデータへのアクセスを提供します。このメタデータは、Artifacts の構築時に提供されます。このメタデータには、Artifacts を再構築するために必要な構成 引数 、詳細情報が見つかる URL、または Artifacts を記録した run 中に生成されたメトリクスが含まれる場合があります。さらに、Artifacts を生成した run の構成と、Artifacts のロギング時の履歴メトリクスを確認できます。
Usage パネルは、ウェブ アプリの外 (たとえば、ローカル マシン上) で使用するために Artifacts をダウンロードするためのコード スニペットを提供します。このセクションでは、Artifacts を出力した run と、Artifacts を入力として使用する run も示し、リンクします。
Files パネルには、Artifacts に関連付けられているファイルとフォルダーがリストされます。W&B は、run の特定のファイルを自動的にアップロードします。たとえば、requirements.txt は run が使用した各ライブラリのバージョンを示し、wandb-metadata.json および wandb-summary.json には run に関する情報が含まれています。run の構成に応じて、Artifacts やメディアなど、他のファイルがアップロードされる場合があります。このファイル ツリーをナビゲートして、W&B ウェブ アプリでコンテンツを直接表示できます。
Artifacts に関連付けられた Tables は、このコンテキストで特に豊富でインタラクティブです。Artifacts で Tables を使用する方法について詳しくは、こちら をご覧ください。
Lineage パネルは、project に関連付けられているすべての Artifacts と、それらを相互に接続する run のビューを提供します。これは、run タイプをブロックとして、Artifacts を円として表示し、特定のタイプの run が特定のタイプの Artifacts を消費または生成するときを示す矢印を表示します。左側の列で選択された特定の Artifacts のタイプが強調表示されます。
[Explode] トグルをクリックすると、個々の Artifacts バージョンと、それらを接続する特定の run がすべて表示されます。
アクション履歴監査タブには、リソースの進化全体を監査できるように、Collection のすべてのエイリアス アクションとメンバーシップの変更が表示されます。
Versions タブには、Artifacts のすべてのバージョンと、バージョンのロギング時の Run History の各数値の値の列が表示されます。これにより、パフォーマンスを比較し、関心のあるバージョンをすばやく特定できます。
project にスターを追加して、その project を重要としてマークします。あなたとあなたのチームがスターで重要としてマークした project は、組織のホームページの上部に表示されます。
たとえば、次の画像は、重要としてマークされている 2 つの project、zoo_experiment と registry_demo を示しています。両方の project は、組織のホームページの Starred projects セクションの上部に表示されます。
project を重要としてマークするには、project の Overview タブ内またはチームのプロファイル ページの 2 つの方法があります。
https://wandb.ai/<team>/<project-name> ) で W&B project に移動します。
https://wandb.ai/<team>/projects ) に移動します。たとえば、次の画像は、“Compare_Zoo_Models” project の横にあるスター アイコンを示しています。
アプリの左上隅にある組織名をクリックして、project が組織のランディング ページに表示されることを確認します。
Overview タブの右側にある 3 つのドットをクリックして、project を削除できます。
project が空の場合、右上にあるドロップダウン メニューをクリックし、Delete project を選択して削除できます。
説明の概要として、またはワークスペース内のマークダウン パネルとして、project にメモを追加します。
ページに追加する説明は、プロファイルの Overview タブに表示されます。
W&B workspace は、チャートをカスタマイズし、モデルの 結果 を探索するための個人的なサンドボックスです。W&B workspace は、 Tables と Panel sections で構成されています。
workspace には、主に Personal workspaces と Saved views の2つのカテゴリがあります。
次の図は、Cécile-parker のチームメイトによって作成された複数の personal workspace を示しています。この project には、保存された view はありません。
カスタマイズされた workspace view で team のコラボレーションを改善します。保存された View を作成して、チャートと data の好みの 設定 を整理します。
新しい保存された view は、workspace ナビゲーションメニューに表示されます。
保存された変更は、保存された view の以前の状態を 上書き します。保存されていない変更は保持されません。W&B で保存された workspace view を 更新 するには：
不要になった保存された view を削除します。
workspace の URL を直接共有して、カスタマイズされた workspace を team と共有します。workspace project への アクセス 権を持つすべての ユーザー は、その workspace の保存された View を見ることができます。
wandb-workspaces は、W&B workspace と Reports をプログラムで 操作 するための Python library です。
wandb-workspaces を使用して、プログラムで workspace を定義します。wandb-workspaces は、W&B workspace と Reports をプログラムで 操作 するための Python library です。
workspace の プロパティ は、次のように定義できます。
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()
saved view を別の workspace にコピーする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()
workspace API の包括的な例については、wandb-workspace examples を参照してください。エンドツーエンドのチュートリアルについては、Programmatic Workspaces チュートリアルを参照してください。
run は、W&B によってログされる計算の単一の単位です。W&B の run は、プロジェクト全体の原子要素と考えることができます。つまり、各 run は、モデルのトレーニングと結果のログ、ハイパーパラメーターの スイープ など、特定の計算の記録です。
run を開始する一般的なパターンには、以下が含まれますが、これらに限定されません。
W&B は、作成した run を プロジェクト に保存します。run とそのプロパティは、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
# simulating a training 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 を選択すると、W&B App UI の run の ワークスペース に移動します。
スクリプト が wandb.init メソッド を 1 回だけ呼び出すため、W&B はシミュレートされたトレーニング ループ を jolly-haze-4 という単一の run 内でキャプチャすることに注意してください。
別の例として、sweep 中に、W&B は指定した ハイパーパラメーター 探索 空間を探索します。W&B は、sweep が作成する新しい ハイパーパラメーター の組み合わせを、一意の run として実装します。
wandb.init() を使用して W&B run を初期化します。次のコードスニペットは、W&B Python SDK をインポートして run を初期化する方法を示しています。
山かっこ (< >) で囲まれた値を、自分の値に置き換えてください。
import wandb
run = wandb.init(entity="<entity>", project="<project>")
run を初期化すると、W&B は プロジェクト フィールド に指定した プロジェクト (wandb.init(project="<project>" に run をログします。W&B は、 プロジェクト がまだ存在しない場合は、新しい プロジェクト を作成します。プロジェクト がすでに存在する場合は、W&B はその プロジェクト に run を保存します。
Uncategorized という プロジェクト に保存します。W&B の各 run には、run ID と呼ばれる一意の識別子があります。一意の ID を指定する か、W&B に ID をランダムに生成させる ことができます。
各 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>")
# Training code, logging, and so forth
run.finish()
各 run には、run の現在のステータス を記述する 状態 があります。可能な run の 状態 の完全なリストについては、Run の 状態 を参照してください。
次のテーブルは、run がとりうる 状態 を記述しています。
| 状態 | 説明 |
|---|---|
| Finished | run が終了し、 完全に データ が同期されたか、wandb.finish() が呼び出されました |
| Failed | run が 0 以外の終了ステータス で終了しました |
| 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 パス] フィールド に一意の run ID を表示します。run パス は、 チーム の名前、 プロジェクト の名前、run ID で構成されます。一意の ID は、run パス の最後の部分です。
たとえば、次の図では、一意の run ID は 9mxi1arc です。
wandb.init メソッド に id パラメータ を渡すことで、独自の run ID を指定できます。
import wandb
run = wandb.init(entity="<project>", project="<project>", id="<run-id>")
run の一意の ID を使用して、W&B App UI で run の Overview ページ に直接移動できます。次のセルは、特定の run の URL パス を示しています。
https://wandb.ai/<entity>/<project>/<run-id>
山かっこ (< >) で囲まれた値は、エンティティ 、 プロジェクト 、run ID の実際の値の プレースホルダー です。
run の名前は、人間が読める一意でない識別子です。
デフォルトでは、W&B は新しい run を初期化するときに ランダム な run 名を生成します。run の名前は、 プロジェクト の ワークスペース 内と、run の Overview ページ の上部に表示されます。
wandb.init メソッド に name パラメータ を渡すことで、run の名前を指定できます。
import wandb
run = wandb.init(entity="<project>", project="<project>", name="<run-name>")
特定の run に追加するメモは、[Overview] タブ の run ページ と、 プロジェクト ページ の 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 に変わります。
可能な run の 状態 の完全なリストについては、State フィールド を参照してください。
run の 状態、run にログされた Artifacts、run 中に記録された ログ ファイル など、特定の run に関する情報を表示します。
特定の run を表示するには:
https://wandb.ai/home の W&B App UI に移動します。
run の初期化時に指定した W&B プロジェクト に移動します。
プロジェクト サイドバー 内で、[Workspace] タブ を選択します。
run セレクター 内で、表示する run をクリックするか、run 名の一部を入力して、一致する run を フィルター します。
デフォルトでは、長い run 名は読みやすくするために中央で切り捨てられます。代わりに、run 名を先頭または末尾で切り捨てるには、run のリストの上部にある アクション ... メニュー をクリックし、[Run 名のトリミング] を設定して、末尾、中央、または先頭をトリミングします。
特定の run の URL パス には、次の形式があることに注意してください。
https://wandb.ai/<team-name>/<project-name>/runs/<run-id>
山かっこ (< >) で囲まれた値は、 チーム 名、 プロジェクト 名、run ID の実際の値の プレースホルダー です。
[Overview] タブ を使用して、 プロジェクト 内の特定の run 情報について学習します。次に例を示します。
entity/project/run-ID の形式で一意の run 識別子を識別します。baseline や production などの一時的なラベル を適用したりするのに役立ちます。W&B は、概要セクション の下に次の情報を保存します。
wandb.config で保存された config パラメータ のリスト。wandb.log() で保存された summary パラメータ のリスト。デフォルトでは、W&B はこの値を最後にログされた値に設定します。
プロジェクト の概要の例はこちらをご覧ください。
[Workspace] タブ を使用して、自動生成された カスタム プロット 、 システム メトリクス など、 可視化 を表示、検索、 グループ化 、および配置します。
プロジェクト ワークスペース の例はこちらをご覧ください
[Runs] タブ を使用して、run を フィルター 、 グループ化 、および並べ替えます。
次のタブ は、[Runs] タブ で実行できる一般的な アクション の一部を示しています。
[Runs] タブ には、 プロジェクト 内の run に関する詳細が表示されます。デフォルトでは、多数の 列 が表示されます。
... をクリックし、[Pin column] をクリックします。ピン留め された 列 は、[Name] 列 の後、 ページ の左側の近くに表示されます。ピン留め された 列 の ピン留め を解除するには、[Unpin column] を選択します... をクリックし、[Hide column] をクリックします。現在非表示になっているすべての 列 を表示するには、[Columns] をクリックします。[Runs] タブ を カスタマイズ すると、 カスタマイズ はWorkspace タブ の [Runs] セレクター にも反映されます。
指定された 列 の値で テーブル 内のすべての行を並べ替えます。
上の図は、val_acc という名前の テーブル 列 の並べ替え オプション を表示する方法を示しています。
ダッシュボード の上にある [Filter] ボタン を使用して、 式 で すべての行を フィルター します。
[Add filter] を選択して、1 つまたは複数の フィルター を行に追加します。3 つの ドロップダウン メニュー が表示されます。左から右への フィルター タイプ は、 列 名、 オペレーター 、および値に基づいています
| 列 名 | 二項関係 | 値 | |
|---|---|---|---|
| 受け入れられる値 | 文字列 | =, ≠, ≤, ≥, IN, NOT IN, | 整数, float, 文字列, タイムスタンプ , null |
式 エディター には、 列 名のオートコンプリート と論理述語構造を使用して、各 項 の オプション のリストが表示されます。「and」または「or」(および場合によっては 括弧 ) を使用して、複数の論理述語を 1 つの 式 に接続できます。
上の図は、`val_loss` 列 に基づく フィルター を示しています。この フィルター は、 検証 損失 が 1 以下 の run を表示します。
ダッシュボード の上にある [Group by] ボタン を使用して、特定の 列 の値で行を グループ化 します。
デフォルトでは、これにより、他の数値 列 が、その グループ 全体の 列 の値の分布を示す ヒストグラム に変わります。グループ化 は、 データ のより高レベルの パターン を理解するのに役立ちます。
[System タブ] には、CPU 使用率、 システム メモリ 、 ディスク I/O、 ネットワーク トラフィック、GPU 使用率など、特定の run に対して追跡される システム メトリクス が表示されます。
W&B が追跡する システム メトリクス の完全なリストについては、System メトリクス を参照してください。
システム タブ の例はこちらをご覧ください。
[Log タブ] には、 コマンドライン に出力された出力 (標準出力 (stdout) や 標準 エラー (stderr) など) が表示されます。
右上隅にある [Download] ボタン を選択して、 ログ ファイル をダウンロードします。
ログ タブ の例はこちらをご覧ください。
[Files タブ] を使用して、モデル チェックポイント 、 検証 セット の例など、特定の run に関連付けられた ファイル を表示します
ファイル タブ の例はこちらをご覧ください。
[Artifacts] タブ には、指定された run の 入力 および 出力 アーティファクト が一覧表示されます。
アーティファクト タブ の例はこちらをご覧ください。
W&B App を使用して、 プロジェクト から 1 つまたは複数の run を削除します。
このセクション では、 グループ と ジョブタイプ を使用して run を整理する方法について説明します。run を グループ (たとえば、 実験 名) に割り当て、 ジョブタイプ (たとえば、 前処理 、 トレーニング 、 評価 、 デバッグ ) を指定することで、 ワークフロー を効率化し、モデル の比較を改善できます。
W&B の各 run は、[グループ] と [ジョブタイプ] で 分類 できます。
preprocessing、training、evaluation など、run の 機能 。次のワークスペース の例 では、Fashion-MNIST データセット から 増え続ける量の データ を使用して ベースライン モデル を トレーニング します。ワークスペース では、使用される データ 量を色で表します。
W&B の フィルター オプション と検索バーを使用して、特定の条件に基づいて run を比較します。次に例を示します。
フィルター を適用すると、[Table] ビュー が自動的に更新されます。これにより、モデル 間の パフォーマンス の違いを特定できます。たとえば、一方のモデル で他方のモデル よりも大幅に困難な クラス を特定できます。
ログに記録されたメトリクスや Artifact データからは明らかでない、特定の機能を持つ run にラベルを付けるために、タグを追加します。
例えば、run の model が in_production であること、run が preemptible であること、この run が baseline を表していることなどを表すタグを、run に追加できます。
プログラムで、またはインタラクティブに、run にタグを追加します。
ユースケースに応じて、ニーズに最も適した以下のタブを選択してください。
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 logic to train model
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") # you can choose tags based on run data here
run.update()
この方法は、多数の run に同じタグを付けるのに最適です。
この方法は、1つの run に手動でタグを適用するのに最適です。
タグは、W&B App UI を使用して run から削除することもできます。
この方法は、多数の run からタグを削除するのに最適です。
WandB にログされた run からの洞察を得るには、プロジェクトページを使用してください。Workspace ページと Runs ページの両方から、run をフィルタリングおよび検索できます。
フィルターボタンを使用して、ステータス、タグ、またはその他のプロパティに基づいて run をフィルタリングします。
フィルターボタンを使用して、タグに基づいて run をフィルタリングします。
正規表現で目的の検索結果が得られない場合は、タグを使用して、Runs Table で run をフィルタリングできます。タグは、run の作成時または完了後に追加できます。タグが run に追加されると、以下の gif に示すようにタグフィルターを追加できます。
正規表現を使用して、指定した正規表現に一致する run を検索します。検索ボックスにクエリを入力すると、Workspace 上のグラフに表示される run が絞り込まれるとともに、テーブルの行もフィルタリングされます。
1 つまたは複数の列 (非表示の列を含む) で run をグループ化するには:
ログに記録されたメトリクスの最小値または最大値で、run テーブルを並べ替えます。これは、記録された最高 (または最低) の値を表示する場合に特に役立ちます。
次のステップでは、記録された最小値または最大値に基づいて、特定のメトリクスで run テーブルを並べ替える方法について説明します。
クライアント プロセスからの最後のハートビートをログに記録する End Time という名前の列を提供します。このフィールドはデフォルトで非表示になっています。
ダウンロードボタンを使用して、すべての run、ハイパーパラメーター 、およびサマリー メトリクスのテーブルを CSV にエクスポートします。
既存の W&B の run から「フォーク」するには、wandb.init() で run を初期化する際に fork_from を使用します。run からフォークすると、W&B はソース run の run ID と step を使用して新しい run を作成します。
run をフォークすると、元の run に影響を与えることなく、実験の特定の時点から異なるパラメータまたは model を調べることができます。
wandb SDK バージョン 0.16.5 以上が必要です。define_metric() で定義された非単調な step を使用してフォークポイントを設定することはできません。run の履歴とシステム メトリクスの本質的な時間順序が崩れるためです。run をフォークするには、wandb.init() で fork_from 引数を使用し、フォーク元のソース run ID とソース run からの step を指定します。
import wandb
# 後でフォークされる run を初期化する
original_run = wandb.init(project="your_project_name", entity="your_entity_name")
# ... トレーニングまたはログの記録を実行 ...
original_run.finish()
# 特定の step から 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 タブの右上隅にある ... メニュー (3 つのドット) をクリックします。ドロップダウンメニューから [イミュータブルな Run ID をコピー] オプションを選択します。
これらの手順に従うことで、run への安定した変更されない参照が得られ、run のフォークに使用できます。
フォークされた run を初期化したら、新しい run へのログ記録を続行できます。継続性のために同じメトリクスをログに記録し、新しいメトリクスを導入できます。
たとえば、次のコード例は、最初に run をフォークし、次に 200 のトレーニング step から始まるフォークされた 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()
# 特定の step で最初の run からフォークし、step 200 から始まるメトリクスをログに記録する
run2 = wandb.init(
"your_project_name", entity="your_entity_name", fork_from=f"{run1.id}?_step=200"
)
# 新しい run でログ記録を続行する
# 最初のいくつかの step では、run1 からメトリクスをそのままログに記録する
# Step 250 以降は、スパイキーパターンをログに記録し始める
for i in range(200, 300):
if i < 250:
run2.log({"metric": i}) # スパイクなしで run1 からログ記録を続行する
else:
# Step 250 からスパイキーな振る舞いを導入する
subtle_spike = i + (2 * math.sin(i / 3.0)) # 微妙なスパイキーパターンを適用する
run2.log({"metric": subtle_spike})
# さらに、すべての step で新しいメトリクスをログに記録する
run2.log({"additional_metric": i * 1.1})
run2.finish()
フォークは、run の管理と実験においてより柔軟性を提供することで、rewind を補完します。
run からフォークすると、W&B は特定のポイントで run から新しいブランチを作成し、異なるパラメータまたは model を試すことができます。
run を巻き戻すと、W&B は run の履歴自体を修正または変更できます。
個々のジョブをグループ化して実験をまとめるには、一意の group 名を wandb.init() に渡します。
グループ化を設定するには、次の3つの方法があります。
オプションの group と job_type を wandb.init() に渡します。これにより、個々のrunを含む実験ごとに専用のグループページが作成されます。例：wandb.init(group="experiment_1", job_type="eval")
WANDB_RUN_GROUP を使用して、runのグループを環境変数として指定します。詳細については、環境変数 に関するドキュメントをご覧ください。Group は、Project 内で一意であり、グループ内のすべての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」行をクリックすると、その実験専用のグループページに移動できます。
上記のプロジェクトページから、左側のサイドバーにある Group をクリックして、このページ のような専用ページに移動できます。
任意の列（例えば、ハイパーパラメーター）でrunをグループ化できます。その様子を以下に示します。
グループ化ボタンをクリックして、グループフィールドをいつでもクリアできます。これにより、テーブルとグラフはグループ化されていない状態に戻ります。
グラフの右上隅にある編集ボタンをクリックし、Advanced タブを選択して、線と網掛けを変更します。各グループの線の平均値、最小値、または最大値を選択できます。網掛けの場合、網掛けをオフにしたり、最小値と最大値、標準偏差、および標準誤差を表示したりできます。
このページでは、ある run を別の project へ、team の内外へ、またはある team から別の team へ移動する方法について説明します。現在の場所と新しい場所で run にアクセスできる必要があります。
wandb artifact get SDK コマンドまたは Api.artifact API を使用して artifact をダウンロードし、wandb artifact put または Api.artifact API を使用して run の新しい場所にアップロードします。Runs タブをカスタマイズするには、Project pageを参照してください。
ある project から別の project へ run を移動するには:
自分がメンバーである team へ run を移動するには:
run が停止またはクラッシュした場合に、run がどのように振る舞うかを指定します。run を再開するか、run が自動的に再開できるようにするには、id パラメータに対して、その run に関連付けられた一意の run ID を指定する必要があります。
run = wandb.init(entity="<entity>", \
project="<project>", id="<run ID>", resume="<resume>")
W&B がどのように応答するかを決定するために、次の引数のいずれかを resume パラメータに渡します。いずれの場合も、W&B は最初に run ID がすでに存在するかどうかを確認します。
| 引数 | 説明 | Run ID が存在する場合 | Run ID が存在しない場合 | ユースケース |
|---|---|---|---|---|
"must" |
W&B は、run ID で指定された run を再開する必要があります。 | W&B は同じ run ID で run を再開します。 | W&B はエラーを発生させます。 | 同じ run ID を使用する必要がある run を再開します。 |
"allow" |
W&B は、run ID が存在する場合に run を再開することを許可します。 | W&B は同じ run ID で run を再開します。 | W&B は、指定された run ID で新しい run を初期化します。 | 既存の run を上書きせずに run を再開します。 |
"never" |
W&B は、run ID で指定された run を再開することを許可しません。 | W&B はエラーを発生させます。 | W&B は、指定された run ID で新しい run を初期化します。 |
resume="auto" を指定して、W&B が自動的に run の再起動を試みるようにすることもできます。ただし、同じディレクトリーから run を再起動する必要があります。run を自動的に再開できるようにする セクションを参照してください。
以下のすべての例で、<> で囲まれた値を独自の値に置き換えてください。
run が停止、クラッシュ、または失敗した場合、同じ run ID を使用して再開できます。これを行うには、run を初期化し、以下を指定します。
resume パラメータを "must" (resume="must") に設定します。次のコードスニペットは、W&B Python SDK でこれを実現する方法を示しています。
run = wandb.init(entity="<entity>", \
project="<project>", id="<run ID>", resume="must")
複数のプロセスが同じ id を同時に使用すると、予期しない結果が発生します。
複数のプロセスを管理する方法の詳細については、分散トレーニング Experiments のログ記録 を参照してください。
既存の run を上書きせずに、停止またはクラッシュした run を再開します。これは、プロセスが正常に終了しない場合に特に役立ちます。次回 W&B を起動すると、W&B は最後のステップからログの記録を開始します。
W&B で run を初期化するときに、resume パラメータを "allow" (resume="allow") に設定します。停止またはクラッシュした run の run ID を指定します。次のコードスニペットは、W&B Python SDK でこれを実現する方法を示しています。
import wandb
run = wandb.init(entity="<entity>", \
project="<project>", id="<run ID>", resume="allow")
次のコードスニペットは、Python SDK または環境変数を使用して、run を自動的に再開できるようにする方法を示しています。
次のコードスニペットは、Python SDK で W&B の run 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 の run ID と共にシェルスクリプトを実行できます。次のコードスニペットは、run ID akj172 を渡します。
sh run_experiment.sh akj172
たとえば、Users/AwesomeEmployee/Desktop/ImageClassify/training/ というディレクトリーで train.py という Python スクリプトを実行するとします。train.py 内で、スクリプトは自動再開を有効にする run を作成します。次に、トレーニングスクリプトが停止したとします。この run を再開するには、Users/AwesomeEmployee/Desktop/ImageClassify/training/ 内で train.py スクリプトを再起動する必要があります。
WANDB_RUN_ID 環境変数を指定するか、W&B Python SDK で run ID を渡します。run ID の詳細については、「run とは何ですか?」ページの カスタム run ID セクションを参照してください。中断された sweep run を自動的に再キューします。これは、プリエンプティブキューの SLURM ジョブ、EC2 スポットインスタンス、または Google Cloud プリエンプティブ VM など、プリエンプションの影響を受けるコンピューティング環境で sweep agent を実行する場合に特に役立ちます。
mark_preempting 関数を使用して、W&B が中断された sweep run を自動的に再キューできるようにします。たとえば、次のコードスニペット
run = wandb.init() # run を初期化します
run.mark_preempting()
次の表は、sweep run の終了ステータスに基づいて W&B が run をどのように処理するかを示しています。
| ステータス | 振る舞い |
|---|---|
| ステータスコード 0 | Run は正常に終了したと見なされ、再キューされません。 |
| ゼロ以外のステータス | W&B は、run を sweep に関連付けられた run キューに自動的に追加します。 |
| ステータスなし | Run は sweep run キューに追加されます。Sweep agent は、キューが空になるまで run キューから run を消費します。キューが空になると、sweep キューは sweep 検索アルゴリズムに基づいて新しい run の生成を再開します。 |
run を巻き戻すオプションは、プライベートプレビュー版です。この機能へのアクセスをご希望の場合は、W&B Support（support@wandb.com）までご連絡ください。
W&B は現在、以下をサポートしていません。
0.17.1 が必要です。define_metric() で定義された非単調なステップは、run の履歴とシステムメトリクスの必要な時系列順序を混乱させるため使用できません。run を巻き戻して、元のデータを失うことなく、run の履歴を修正または変更します。さらに、run を巻き戻すと、その時点から新しいデータを記録できます。W&B は、新たに記録された履歴に基づいて、巻き戻した run のサマリーメトリクスを再計算します。これは、次の振る舞いを意味します。
run を巻き戻すと、W&B は run の状態を指定されたステップにリセットし、元のデータを保持し、一貫した run ID を維持します。これは次のことを意味します。
フォークは巻き戻しを補完します。
run からフォークすると、W&B は特定の時点で run から新しいブランチを作成し、さまざまなパラメータや Models を試すことができます。
run を巻き戻すと、W&B を使用して run の履歴自体を修正または変更できます。
resume_from を使用して wandb.init() を使用して、run の履歴を特定のステップに「巻き戻し」ます。巻き戻す run の名前とステップを指定します。
import wandb
import math
# Initialize the first run and log some metrics
# Replace with your_project_name and 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()
# Rewind from the first run at a specific step and log the metric starting from step 200
run2 = wandb.init(project="your_project_name", entity="your_entity_name", resume_from=f"{run1.id}?_step=200")
# Continue logging in the new run
# For the first few steps, log the metric as is from run1
# After step 250, start logging the spikey pattern
for i in range(200, 300):
if i < 250:
run2.log({"metric": i, "step": i}) # Continue logging from run1 without spikes
else:
# Introduce the spikey behavior starting from step 250
subtle_spike = i + (2 * math.sin(i / 3.0)) # Apply a subtle spikey pattern
run2.log({"metric": subtle_spike, "step": i})
# Additionally log the new metric at all steps
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
# Fork the run from a specific step
forked_run = wandb.init(
project="your_project_name",
entity="your_entity_name",
fork_from=f"{rewind_run.id}?_step=500",
)
# Continue logging in the new run
for i in range(500, 1000):
forked_run.log({"metric": i*3})
forked_run.finish()
run がクラッシュした場合、またはカスタムトリガーで Slack またはメールでアラートを作成します。たとえば、トレーニングループの勾配が爆発し始めた場合 (NaN を報告)、または ML パイプライン のステップが完了した場合にアラートを作成できます。アラートは、個人 プロジェクト と Team プロジェクト の両方を含む、run を初期化するすべての プロジェクト に適用されます。
次に、Slack (またはメール) で W&B Alerts メッセージを確認します。
次の ガイド は、マルチテナント cloud のアラートにのみ適用されます。
W&B Server を Private Cloud または W&B Dedicated Cloud で使用している場合は、このドキュメント を参照して、Slack アラートを設定してください。
アラートを設定するには、主に次の 2 つのステップがあります。
run.alert() を code に追加しますユーザー 設定 で:
run.alert() からアラートを受信しますW&B Alerts を初めて設定する場合、またはアラートの受信方法を変更する場合は、これを行う必要があります。
run.alert() を code に追加するアラートをトリガーする場所に、run.alert() を code ( notebook または Python スクリプト のいずれか) に追加します
import wandb
run = wandb.init()
run.alert(title="High Loss", text="Loss is increasing rapidly")
Slack またはメールでアラート メッセージを確認します。何も受信しなかった場合は、ユーザー 設定 で スクリプト可能なアラート のメールまたは 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")
Team 管理者は、Team 設定ページ wandb.ai/teams/your-team で Team のアラートを設定できます。
Team アラートは、Team の全員に適用されます。W&B は、アラートを非公開にするため、Slackbot channel を使用することをお勧めします。
アラートの送信先 channel を変更するには、Slack の接続を解除 をクリックしてから、再接続します。再接続後、別の Slack channel を選択します。
W&B Python SDK を使用して、メトリクス、メディア、またはカスタム オブジェクトの辞書をステップと共にログに記録します。W&B は、各ステップ中にキーと値のペアを収集し、wandb.log() でデータをログに記録するたびに、それらを 1 つの統合された辞書に保存します。スクリプトからログに記録されたデータは、ローカル マシンの 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 の Experiments 中に次の情報を自動的にログに記録します。
nvidia-smi で取得されます。アカウントの Settings page で Code Saving をオンにして、以下をログに記録します。
diff.patch ファイルも表示します。requirements.txt ファイルがアップロードされ、run の files タブに表示されます。また、run の wandb ディレクトリーに保存したファイルも表示されます。W&B を使用すると、ログに記録する内容を正確に決定できます。以下に、一般的にログに記録されるオブジェクトをいくつか示します。
wandb.plot を wandb.log と共に使用して、チャートを追跡します。詳細については、プロットのログ を参照してください。wandb.Table を使用してデータをログに記録し、W&B で視覚化およびクエリを実行します。詳細については、Tables のログ を参照してください。wandb.watch(model) を追加して、UI で重みの勾配をヒストグラムとして表示します。wandb.init(config=your_config_dictionary) のように渡されます。詳細については、PyTorch Integrations ページを参照してください。wandb.log を使用して、model からのメトリクスを表示します。トレーニング ループ内から精度や損失などのメトリクスをログに記録すると、UI でライブ更新グラフが表示されます。wandb.run.summary["best_accuracy"] = best_accuracywandb.log({"acc'": 0.9, "loss": 0.1}) のように、wandb.log への同じ呼び出しで複数のメトリクスをログに記録すると、それらは両方とも UI でプロットに使用できるようになります。wandb.log({'acc': 0.9, 'epoch': 3, 'batch': 117})。特定のメトリクスのデフォルトの x 軸を設定するには、Run.define_metric() を使用します。wandb.log は、画像や動画などのメディア から Tables および Charts まで、さまざまなデータ型のログ記録をサポートしています。Experiments とログ記録のベストプラクティスとヒントについては、ベストプラクティス: Experiments とログ記録 を参照してください。
wandb.plot のメソッドを使用すると、トレーニング中に時間とともに変化するグラフを含め、wandb.log でグラフを追跡できます。カスタムグラフ作成フレームワークの詳細については、このガイドを確認してください。
これらのシンプルなグラフを使用すると、メトリクスと結果の基本的な可視化を簡単に構築できます。
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つの次元で曲線を記録できます。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つの次元で散布ポイントを記録できます。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 は、行と列の2D配列をサポートすることを目的としたリストのリストであることに注意してください。
wandb.plot.line_series()
複数の線、または複数の異なるx-y座標ペアのリストを、1つの共有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値のリストを1つ、またはy値のリストごとに個別のx値のリストを提供できます。
これらのプリセットグラフには、wandb.plot メソッドが組み込まれており、スクリプトから直接グラフをすばやく簡単に記録し、UIで探している正確な情報を確認できます。
wandb.plot.pr_curve()
1行で PR曲線 を作成します。
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()
1行で ROC曲線 を作成します。
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 の文字列としてのラベル/クラス名の完全なリスト。例: インデックス0が cat、1が dog、2が bird の場合、class_names=["cat", "dog", "bird"]。
アプリで表示
完全にカスタマイズするには、組み込みの カスタムグラフプリセット を調整するか、新しいプリセットを作成し、グラフを保存します。グラフ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"},
)
wandb.plot を使用した W&B カスタムグラフ を使用する代わりに、matplotlib および Plotly で生成されたグラフを記録できます。
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.ylabel("some interesting numbers")
wandb.log({"chart": plt})
matplotlib プロットまたは figure オブジェクトを wandb.log() に渡すだけです。デフォルトでは、プロットを Plotly プロットに変換します。プロットを画像として記録する場合は、プロットを wandb.Image に渡すことができます。Plotly グラフも直接受け入れます。
fig = plt.figure() を使用してプロットとは別に figure を保存し、wandb.log の呼び出しで fig を記録できます。W&B は、Plotly および Bokeh からのインタラクティブなグラフを HTML として記録し、それらを Tables に追加することをサポートしています。
インタラクティブな Plotly グラフを HTML に変換して、wandb Tables に記録できます。
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 figure のパスを作成します
path_to_plotly_html = "./plotly_figure.html"
# Plotly figure の例
fig = px.scatter(x=[0, 1, 2, 3, 4], y=[0, 1, 4, 9, 16])
# Plotly figure を HTML に書き込みます
# auto_play を False に設定すると、アニメーション化された Plotly グラフが
# テーブル内で自動的に再生されるのを防ぎます
fig.write_html(path_to_plotly_html, auto_play=False)
# Plotly figure を HTML ファイルとして Table に追加します
table.add_data(wandb.Html(path_to_plotly_html))
# Table を記録します
run.log({"test_table": table})
wandb.finish()
インタラクティブな Bokeh グラフを HTML に変換して、wandb Tables に記録できます。
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()
define_metric を使用して、カスタムのX軸を設定します。カスタムのX軸は、トレーニング中に過去の異なるタイムステップに非同期で ログ を記録する必要がある場合に役立ちます。たとえば、エピソードごとの報酬とステップごとの報酬を追跡する強化学習で役立ちます。
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 step
}
wandb.log(log_dict)
分散トレーニングでは、モデルは複数の GPU を並行して使用してトレーニングされます。W&B は、分散トレーニング の 実験管理 を追跡するための 2 つのパターンをサポートしています。
wandb.init) を初期化し、単一の プロセス から 実験 (wandb.log) を ログ 記録します。これは、PyTorch Distributed Data Parallel (DDP) クラスを使用した分散トレーニング の 実験 を ログ 記録するための一般的なソリューションです。場合によっては、マルチプロセッシング キュー (または別の通信プリミティブ) を使用して、他の プロセス からメインの ログ 記録 プロセス にデータを送り込む ユーザー もいます。wandb.init) を初期化し、すべての プロセス で 実験 (wandb.log) を ログ 記録します。各 プロセス は、事実上別の 実験 です。W&B を初期化する際に group パラメータ (wandb.init(group='group-name')) を使用して、共有 実験 を定義し、 ログ 記録された 値 を W&B App UI にまとめて グループ化します。以下の例では、単一 マシン 上の 2 つの GPU で PyTorch DDP を使用して、W&B で メトリクス を追跡する方法を示します。PyTorch DDP (torch.nn の DistributedDataParallel) は、分散トレーニング 用の一般的な ライブラリ です。基本的な原則は、あらゆる分散トレーニング 設定に適用されますが、実装の詳細は異なる場合があります。
log-dpp.py Python スクリプトを参照してください。この方法では、ランク 0 の プロセス のみを追跡します。この方法を実装するには、W&B (wandb.init) を初期化し、W&B Run を開始して、ランク 0 の プロセス 内で メトリクス (wandb.log) を ログ 記録します。この方法はシンプルで堅牢ですが、他の プロセス から モデル の メトリクス (たとえば、バッチからの 損失 値 または 入力) を ログ 記録しません。使用量 や メモリ などの システム メトリクス は、その情報がすべての プロセス で利用できるため、すべての GPU に対して ログ 記録されます。
サンプル Python スクリプト (log-ddp.py) 内で、ランクが 0 かどうかを確認します。これを行うには、まず torch.distributed.launch で複数の プロセス を 起動します。次に、--local_rank コマンドライン 引数 でランクを確認します。ランクが 0 に設定されている場合、train() 関数で wandb ログ 記録を条件付きで設定します。Python スクリプト内で、次のチェックを使用します。
if __name__ == "__main__":
# Get args
args = parse_args()
if args.local_rank == 0: # only on main process
# Initialize wandb run
run = wandb.init(
entity=args.entity,
project=args.project,
)
# Train model with DDP
train(args, run)
else:
train(args)
W&B App UI を調べて、単一の プロセス から追跡された メトリクス の ダッシュボード 例 を表示します。ダッシュボード には、両方の GPU で追跡された 温度 や 使用率 などの システム メトリクス が表示されます。
ただし、 エポック と バッチサイズ の関数としての 損失 値 は、単一の GPU からのみ ログ 記録されました。
この方法では、ジョブ内の各 プロセス を追跡し、各 プロセス から wandb.init() と wandb.log() を個別に呼び出します。すべての プロセス が適切に終了するように、トレーニング の最後に wandb.finish() を呼び出すことをお勧めします。これにより、run が完了したことを示します。
この方法により、より多くの情報が ログ 記録にアクセスできるようになります。ただし、複数の W&B Runs が W&B App UI に 報告 されることに注意してください。複数の 実験 にわたって W&B Runs を追跡することが難しい場合があります。これを軽減するには、W&B を初期化する際に group パラメータ に 値 を指定して、どの W&B Run が特定の 実験 に属しているかを追跡します。トレーニング と 評価 の W&B Runs を 実験 で追跡する方法の詳細については、Run のグループ化 を参照してください。
次の Python コード スニペット は、W&B を初期化するときに group パラメータ を設定する方法を示しています。
if __name__ == "__main__":
# Get args
args = parse_args()
# Initialize run
run = wandb.init(
entity=args.entity,
project=args.project,
group="DDP", # all runs for the experiment in one group
)
# Train model with DDP
train(args, run)
W&B App UI を調べて、複数の プロセス から追跡された メトリクス の ダッシュボード 例 を表示します。左側のサイドバーに 2 つの W&B Runs が グループ化 されていることに注意してください。グループ をクリックして、 実験 専用のグループ ページ を表示します。専用のグループ ページ には、各 プロセス からの メトリクス が個別に表示されます。
上記の画像は、W&B App UI ダッシュボード を示しています。サイドバーには、2 つの 実験 が表示されます。1 つは「null」というラベルが付いており、2 つ目 (黄色のボックスで囲まれています) は「DPP」と呼ばれています。グループ を展開すると (グループ ドロップダウン を選択)、その 実験 に関連付けられている W&B Runs が表示されます。
W&B と分散トレーニング を使用する際に発生する可能性のある一般的な問題が 2 つあります。
wandb マルチプロセッシング が分散トレーニング からの マルチプロセッシング に干渉すると、wandb プロセス がハングする可能性があります。wandb プロセス がいつ終了する必要があるかを認識していない場合、トレーニング ジョブ がハングする可能性があります。Python スクリプト の最後に wandb.finish() API を呼び出して、Run が完了したことを W&B に伝えます。wandb.finish() API は、データの アップロード を終了し、W&B を終了させます。分散ジョブ の信頼性を向上させるために、wandb service を使用することをお勧めします。上記のトレーニング の問題はどちらも、wandb service が利用できない W&B SDK の バージョン でよく見られます。
W&B SDK の バージョン によっては、W&B Service がデフォルトで有効になっている場合があります。
W&B Service は、W&B SDK 0.13.0 以降の バージョン ではデフォルトで有効になっています。
Python スクリプト を変更して、W&B SDK バージョン 0.12.5 以降で W&B Service を有効にします。wandb.require メソッド を使用し、メイン関数内で 文字列 "service" を渡します。
if __name__ == "__main__":
main()
def main():
wandb.require("service")
# rest-of-your-script-goes-here
最適なエクスペリエンスを得るには、最新 バージョン に アップグレード することをお勧めします。
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()
画像、動画、音声など、様々な形式のメディアに対応しています。リッチメディアを ログ に記録して、結果を調査し、 run 、 model 、 dataset を視覚的に比較できます。例やハウツー ガイド については、以下をお読みください。
W&B SDK でメディア オブジェクト を ログ に記録するには、追加の依存関係をインストールする必要がある場合があります。 これらの依存関係をインストールするには、次の コマンド を実行します。
pip install wandb[media]
画像 を ログ に記録して、入力、出力、フィルターの重み、アクティベーションなどを追跡します。
画像 は、NumPy 配列から、PIL 画像 として、またはファイルシステムから直接 ログ に記録できます。
ステップから画像 を ログ に記録するたびに、UI に表示するために保存されます。画像 パネル を展開し、ステップ スライダーを使用して、異なるステップの画像 を確認します。これにより、 model の出力が トレーニング 中にどのように変化するかを簡単に比較できます。
torchvision の make_grid を使用するなどして、画像 を手動で構築する場合は、配列を直接指定します。
配列は Pillow を使用して png に変換されます。
images = wandb.Image(image_array, caption="Top: Output, Bottom: Input")
wandb.log({"examples": images})
最後の次元が 1 の場合はグレースケール画像、3 の場合は RGB、4 の場合は RGBA であると想定されます。配列に float が含まれている場合は、0 から 255 までの整数に変換します。画像 の正規化方法を変更する場合は、mode を手動で指定するか、この パネル の「PIL 画像 の ログ 記録」 タブ で説明されているように、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": (string) 保存された画像 マスク ファイル へのパス"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: 各ボックス に対して 1 つの 辞書 の リスト。ボックス 辞書 の形式については、以下で説明します。
position: 以下で説明するように、2 つの形式のいずれかでボックス の位置とサイズを表す 辞書。ボックス はすべて同じ形式を使用する必要はありません。
{"minX", "maxX", "minY", "maxY"}。各ボックス の次元の上限と下限を定義する座標セットを指定します。{"middle", "width", "height"}。[x,y] として middle 座標を指定する座標セットと、スカラーとして width と height を指定します。class_id: ボックス のクラス 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": [
{
# one box expressed in the default relative/fractional domain
"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},
# another box expressed in the pixel domain
# (for illustration purposes only, all boxes are likely
# to be in the same domain/format)
"position": {"middle": [150, 20], "width": 68, "height": 112},
"domain": "pixel",
"class_id": 3,
"box_caption": "a building",
"scores": {"acc": 0.5, "loss": 0.7},
# ...
# Log as many boxes an as needed
}
],
"class_labels": class_id_to_label,
},
# Log each meaningful group of boxes with a unique key name
"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 軸に メトリック 値、色で表されるカウントでプロットされ、 トレーニング 全体で ログ 記録された ヒストグラム の比較が容易になります。1 回限りの ヒストグラム の ログ 記録の詳細については、この パネル の「概要の ヒストグラム 」 タブ を参照してください。
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( # if only in summary, only visible on overview tab
{"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")),
]
}
)
ヒストグラム が概要にある場合、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 はデータを 300,000 ポイント で切り捨てます。 :::
柔軟な配色に対応するため、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 オブジェクト を定義し、以下に示すように from_point_cloud メソッドに渡すことができます。
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], # color in RGB of the bounding box
"label": "car", # string displayed on the bounding box
"score": 0.6 # numeric displayed on the bounding box
}],
vectors = [
{"start": [0, 0, 0], "end": [0.1, 0.2, 0.5], "color": [255, 0, 0]}, # color is optional
],
point_cloud_type = "lidar/beta",
)})
ポイントクラウド を表示するときは、control キー を押しながらマウスを使用すると、スペース内を移動できます。
the from_file メソッドを使用して、 ポイントクラウド データがいっぱいの 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"
}
上記で定義されている同じ配列形式を使用して、 from_numpy メソッドで numpy 配列を直接使用して、 ポイントクラウド を定義できます。
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, category
[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")})
10 個のファイルタイプ ( pdb、pqr、mmcif、mcif、cif、sdf、sd、gro、mol2、または mmtf) のいずれかで分子データを ログ 記録します。
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(...)})
# Or multiple images
wandb.log({"example": [wandb.Image(...) for img in images]})
動画は、wandb.Video データ型を使用して ログ 記録されます。
wandb.log({"example": wandb.Video("myvideo.mp4")})
これで、メディア ブラウザー で動画を表示できます。プロジェクト ワークスペース 、 run ワークスペース 、または レポート に移動し、[可視化 を追加] をクリックして、リッチメディア パネル を追加します。
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)})
ステップごとに最大 100 個のオーディオ クリップ を ログ 記録できます。詳細な使用方法については、audio-fileを参照してください。
wandb.log({"video": wandb.Video(numpy_array_or_path_to_video, fps=4, format="gif")})
numpy 配列が指定されている場合、次元は時間、 チャンネル 、幅、高さの順であると想定されます。デフォルトでは、4 fps の gif 画像 を作成します (ffmpeg および moviepy python ライブラリ は、numpy オブジェクト を渡す場合に必要です)。サポートされている形式は、"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"]
# Method 1
data = [["I love my phone", "1", "1"], ["My phone sucks", "0", "-1"]]
table = wandb.Table(data=data, columns=columns)
wandb.log({"examples": table})
# Method 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 のドキュメントを参照してください。
指定したディレクトリー内のコンテンツを含むモデル artifact を記録するには、log_model を使用します。log_model メソッドは、結果のモデル artifact を W&B run の出力としてもマークします。
モデルを W&B run の入力または出力としてマークすると、モデルの依存関係とモデルの関連付けを追跡できます。W&B App UI 内でモデルのリネージを表示します。詳細については、Artifacts チャプターの アーティファクトグラフの探索とトラバース ページを参照してください。
モデルファイルが保存されているパスを path パラメーターに指定します。パスは、ローカルファイル、ディレクトリー、または s3://bucket/path などの外部バケットへの参照 URIにすることができます。
<> で囲まれた値は、独自の値に置き換えてください。
import wandb
# W&B の run を初期化します
run = wandb.init(project="<your-project>", entity="<your-entity>")
# モデルをログに記録します
run.log_model(path="<path-to-model>", name="<name>")
オプションで、name パラメーターにモデル artifact の名前を指定します。name が指定されていない場合、W&B は入力パスのベース名を run ID を先頭に付加したものを名前として使用します。
name を記録しておいてください。use_model メソッドでモデルパスを取得するには、モデルの名前が必要です。可能なパラメーターの詳細については、API Reference ガイドの log_model を参照してください。
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 という名前のモデル artifact が作成され、ファイル model.h5 がモデル artifact に追加されました。ターミナルまたはノートブックには、モデルがログに記録された 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 関数を使用します。
取得するモデルファイルが保存されているモデル artifact の名前を指定します。指定する名前は、既存のログに記録されたモデル artifact の名前と一致する必要があります。
log_model でファイルを最初にログに記録したときに name を定義しなかった場合、割り当てられるデフォルトの名前は、入力パスのベース名に run ID が付加されたものです。
<> で囲まれた他の値は必ず置き換えてください。
import wandb
# run を初期化します
run = wandb.init(project="<your-project>", entity="<your-entity>")
# モデルにアクセスしてダウンロードします。ダウンロードされた artifact へのパスを返します
downloaded_model_path = run.use_model(name="<your-model-name>")
use_model 関数は、ダウンロードされたモデルファイルのパスを返します。このモデルを後でリンクする場合は、このパスを記録しておいてください。上記のコードスニペットでは、返されたパスは downloaded_model_path という名前の変数に格納されています。
たとえば、上記のコードスニペットでは、ユーザーが use_model API を呼び出しました。取得するモデル artifact の名前と、バージョン/エイリアスを指定しました。次に、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)
# モデルにアクセスしてダウンロードします。ダウンロードされた artifact へのパスを返します
downloaded_model_path = run.use_model(name = f"{model_artifact_name}:{alias}")
可能なパラメーターと戻り値の型の詳細については、API Reference ガイドの use_model を参照してください。
link_model メソッドは、現在、間もなく非推奨になる従来の W&B Model Registry とのみ互換性があります。新しいエディションのモデルレジストリにモデル artifact をリンクする方法については、Registry のドキュメントを参照してください。link_model メソッドを使用して、モデルファイルを W&B run にログ記録し、W&B Model Registry にリンクします。登録済みモデルが存在しない場合、W&B は registered_model_name パラメーターに指定した名前で新しいモデルを作成します。
モデルをリンクすることは、チームの他のメンバーが表示および利用できるモデルの一元化されたチームリポジトリにモデルを「ブックマーク」または「公開」することに似ています。
モデルをリンクすると、そのモデルは Registry で複製されたり、project から移動してレジストリに移動したりすることはありません。リンクされたモデルは、project 内の元のモデルへのポインターです。
Registry を使用して、タスクごとに最適なモデルを整理し、モデルライフサイクルを管理し、ML ライフサイクル全体で簡単な追跡と監査を促進し、webhook またはジョブでダウンストリームアクションを自動化します。
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()
オプションのパラメーターの詳細については、API Reference ガイドの link_model を参照してください。
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()
トレーニング中に時間とともに変化する値に加えて、モデルや前処理ステップを要約する単一の値を追跡することも重要です。この情報を W&B の Run の summary 辞書に記録します。Run の summary 辞書は、numpy 配列、PyTorch テンソル、または TensorFlow テンソルを処理できます。値がこれらの型のいずれかである場合、バイナリファイルにテンソル全体を保持し、min、平均、分散、パーセンタイルなどの高度な メトリクス を summary オブジェクトに格納します。
wandb.log で最後に記録された値は、W&B Run の summary 辞書として自動的に設定されます。summary メトリクス 辞書が変更されると、前の値は失われます。
次の コードスニペット は、カスタム summary メトリクス を W&B に提供する方法を示しています。
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 ページまたは project の runs テーブルで summary 値を表示します。
W&B Public API を使用して、run の summary 値を取得できます。
次の コード例 は、W&B Public API と pandas を使用して、特定の run に記録された summary 値を取得する方法の 1 つを示しています。
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) に基づいて行を取得し、dictionary に変換します。
df[df['name']==run_name].summary.reset_index(drop=True).to_dict()
wandb.Table を使用してデータをログに記録し、Weights & Biases（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)
テーブルは変更可能です。スクリプトの実行中に、最大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テーブルを段階的に作成および入力する方法を示しています。可能なすべてのラベルの信頼性スコアを含む、事前定義された列を持つテーブルを定義し、推論中にデータを1行ずつ追加します。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
) # 行データをテーブルに追加します
Artifactから既存のテーブルをロードし、データの最後の行を取得して、更新されたメトリクスを追加することにより、再開された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の行イテレーターを使用して、データの行を効率的に反復処理できます。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ページとプロジェクトページの両方の Workspace に表示されます。詳細については、テーブルの視覚化と分析を参照してください。
artifact.add() を使用して、ワークスペースではなく、runの Artifacts セクションにテーブルをログに記録します。これは、一度ログに記録して、将来の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() の詳細な例 と、Artifacts と Tables を使用して 表形式データのバージョン管理と重複排除を行う方法 の例については、このレポートを参照してください。
ローカルで構築したテーブル、または他の Artifacts から取得したテーブルを wandb.JoinedTable(table_1, table_2, join_key) を使用して結合できます。
| 引数 | 説明 |
|---|---|
| table_1 | (str, wandb.Table, ArtifactEntry) Artifact 内の wandb.Table へのパス、テーブルオブジェクト、または ArtifactEntry |
| table_2 | (str, wandb.Table, ArtifactEntry) Artifact 内の wandb.Table へのパス、テーブルオブジェクト、または ArtifactEntry |
| join_key | (str, [str, str]) 結合を実行するキー |
Artifact コンテキストで以前に記録した2つの Tables を結合するには、Artifact からそれらを取得し、結果を新しい Table に結合します。
たとえば、'original_songs' という元の曲の Table と、同じ曲の合成バージョンの別の Table 'synth_songs' を読み取る方法を示します。次のコード例では、2つのテーブルを "song_id" で結合し、結果のテーブルを新しい W&B Table としてアップロードします。
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")
# テーブルを Artifact に追加し、W&B に記録します
join_at.add(join_table, "synth_explore")
run.log_artifact(join_at)
異なる Artifact オブジェクトに保存されている2つの以前に保存されたテーブルを結合する方法の例については、このチュートリアル を参照してください。
W&B Python Library を使用して CSV ファイルをログに記録し、W&B Dashboard で可視化します。 W&B Dashboard は、機械学習モデルの結果を整理して可視化するための中央の場所です。これは、W&B にログ記録されていない以前の機械学習実験の情報を含む CSV ファイルがある場合、またはデータセットを含む CSV ファイルがある場合に特に役立ちます。
CSV ファイルの内容を再利用しやすくするために、W&B Artifacts を利用することをお勧めします。
iris.csv ファイル名を CSV ファイルの名前に置き換えます。import wandb
import pandas as pd
# Read our CSV into a new DataFrame
new_iris_dataframe = pd.read_csv("iris.csv")
# Convert the DataFrame into a W&B Table
iris_table = wandb.Table(dataframe=new_iris_dataframe)
# Add the table to an Artifact to increase the row
# limit to 200000 and make it easier to reuse
iris_table_artifact = wandb.Artifact("iris_artifact", type="dataset")
iris_table_artifact.add(iris_table, "iris_table")
# Log the raw csv file within an artifact to preserve our data
iris_table_artifact.add_file("iris.csv")
W&B Artifacts の詳細については、Artifacts のチャプター を参照してください。
wandb.init で W&B Run を開始し、W&B に追跡およびログを記録します。# Start a W&B run to log data
run = wandb.init(project="tables-walkthrough")
# Log the table to visualize with a run...
run.log({"iris": iris_table})
# and Log as an Artifact to increase the available row limit!
run.log_artifact(iris_table_artifact)
wandb.init() API は、Run にデータをログ記録するための新しいバックグラウンド プロセスを生成し、(デフォルトで) データを wandb.ai に同期します。 W&B Workspace Dashboard でライブ可視化を表示します。次の画像は、コードスニペットのデモの出力を示しています。
上記のコードスニペットを含む完全なスクリプトは、以下にあります。
import wandb
import pandas as pd
# Read our CSV into a new DataFrame
new_iris_dataframe = pd.read_csv("iris.csv")
# Convert the DataFrame into a W&B Table
iris_table = wandb.Table(dataframe=new_iris_dataframe)
# Add the table to an Artifact to increase the row
# limit to 200000 and make it easier to reuse
iris_table_artifact = wandb.Artifact("iris_artifact", type="dataset")
iris_table_artifact.add(iris_table, "iris_table")
# log the raw csv file within an artifact to preserve our data
iris_table_artifact.add_file("iris.csv")
# Start a W&B run to log data
run = wandb.init(project="tables-walkthrough")
# Log the table to visualize with a run...
run.log({"iris": iris_table})
# and Log as an Artifact to increase the available row limit!
run.log_artifact(iris_table_artifact)
# Finish the run (useful in notebooks)
run.finish()
場合によっては、CSV ファイルに experiment の詳細が含まれている場合があります。このような CSV ファイルにある一般的な詳細は次のとおりです。
| Experiment | Model Name | Notes | Tags | Num Layers | Final Train Acc | Final Val Acc | Training Losses |
|---|---|---|---|---|---|---|---|
| Experiment 1 | mnist-300-layers | Overfit way too much on training data | [latest] | 300 | 0.99 | 0.90 | [0.55, 0.45, 0.44, 0.42, 0.40, 0.39] |
| Experiment 2 | mnist-250-layers | Current best model | [prod, best] | 250 | 0.95 | 0.96 | [0.55, 0.45, 0.44, 0.42, 0.40, 0.39] |
| Experiment 3 | mnist-200-layers | Did worse than the baseline model. Need to debug | [debug] | 200 | 0.76 | 0.70 | [0.55, 0.45, 0.44, 0.42, 0.40, 0.39] |
| … | … | … | … | … | … | … | |
| Experiment N | mnist-X-layers | NOTES | … | … | … | … | […, …] |
W&B は、experiments の CSV ファイルを取得し、W&B Experiment Run に変換できます。次のコードスニペットとコードスクリプトは、experiments の 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"]
# Format Pandas DataFrame to make it easier to work with
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 Run を開始し、W&B に追跡およびログを記録します。run = wandb.init(
project=PROJECT_NAME, name=run_name, tags=tags, notes=notes, config=config
)
experiment の実行中に、W&B で表示、クエリ、および分析できるように、メトリクスのすべてのインスタンスをログに記録することができます。これを行うには、run.log() コマンドを使用します。
run.log({key: val})
オプションで、run の結果を定義するために、最終的なサマリーメトリクスをログに記録できます。これを行うには、W&B define_metric API を使用します。この例では、run.summary.update() を使用して、サマリーメトリクスを run に追加します。
run.summary.update(summaries)
サマリーメトリクスの詳細については、サマリーメトリクスのログ記録 を参照してください。
以下は、上記のサンプルテーブルを W&B Dashboard に変換する完全なスクリプトの例です。
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()
Jupyter で W&B を使用すると、ノートブックから離れることなくインタラクティブな可視化を得ることができます。カスタムの 分析 、 実験 、プロトタイプを組み合わせて、すべて完全に ログ に記録します。
次の コード でノートブックを開始して W&B をインストールし、アカウントをリンクします。
!pip install wandb -qqq
import wandb
wandb.login()
次に、 実験 を設定し、 ハイパーパラメータ を保存します。
wandb.init(
project="jupyter-projo",
config={
"batch_size": 128,
"learning_rate": 0.01,
"dataset": "CIFAR-100",
},
)
wandb.init() を実行した後、%%wandb を使用して新しいセルを開始すると、ノートブック にライブグラフが表示されます。このセルを複数回実行すると、データが run に追加されます。
%%wandb
# Your training loop here
# ここにトレーニングループを記述します
このサンプルノートブックでお試しください。
%wandb マジックを使用して、既存の ダッシュボード 、 Sweeps 、または Reports をノートブック で直接表示することもできます。
# Display a project workspace
# プロジェクトワークスペースを表示する
%wandb USERNAME/PROJECT
# Display a single run
# 単一のrunを表示する
%wandb USERNAME/PROJECT/runs/RUN_ID
# Display a sweep
# sweepを表示する
%wandb USERNAME/PROJECT/sweeps/SWEEP_ID
# Display a report
# reportを表示する
%wandb USERNAME/PROJECT/reports/REPORT_ID
# Specify the height of embedded iframe
# 埋め込みiframeの高さを指定する
%wandb USERNAME/PROJECT -h 2048
%%wandb または %wandb マジックの代わりに、wandb.init() を実行した後、wandb.run で任意のセルを終了してインライングラフを表示するか、API から返された report 、 sweep 、または run オブジェクトで ipython.display(...) を呼び出すことができます。
# Initialize wandb.run first
# 最初にwandb.runを初期化します
wandb.init()
# If cell outputs wandb.run, you'll see live graphs
# セルがwandb.runを出力する場合、ライブグラフが表示されます
wandb.run
wandb.init を初めて呼び出すと、ブラウザで W&B に現在 ログイン している場合、 ランタイム が自動的に認証されます。run ページの Overviewタブ に、Colab へのリンクが表示されます。%wandb マジックは、 プロジェクト 、 Sweeps 、または Reports へのパスを受け入れ、W&B インターフェースをノートブック で直接レンダリングします。wandb docker --jupyter を呼び出して dockerコンテナ を起動し、 コード をマウントし、Jupyter がインストールされていることを確認して、ポート 8888 で起動します。finished としてマークするために、次に wandb.init が呼び出されるまで待機します。これにより、複数のセル（たとえば、データをセットアップするセル、 トレーニング するセル、テストするセル）を好きな順序で実行し、すべて同じ run に ログ できます。 設定 で コード の保存をオンにすると、実行されたセルも、実行された順序と実行された状態で ログ に記録され、最も非線形の パイプライン でも再現できます。Jupyter ノートブック で run を手動で完了としてマークするには、run.finish を呼び出します。import wandb
run = wandb.init()
# training script and logging goes here
# ここにトレーニングスクリプトとロギングを記述します
run.finish()
以下の推奨範囲内でログを記録することで、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 が意図せずに数千もの新しい メトリクス を記録していないか確認してください。（これは、数千ものプロットがあるセクションで、表示されている run が 1 つまたは 2 つしかないことで簡単に見つけることができます。）記録されている場合は、それらの runs を削除し、目的の メトリクス で再作成することを検討してください。
ログに記録する単一の 値 のサイズを 1 MB 未満に、単一の wandb.log 呼び出しの合計サイズを 25 MB 未満に制限します。この制限は、wandb.Image、wandb.Audio などの wandb.Media タイプには適用されません。
# ❌ 推奨されません
wandb.log({"wide_key": range(10000000)})
# ❌ 推奨されません
with f as open("large_file.json", "r"):
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 config の合計サイズを 10 MB 未満に制限します。大きい 値 をログに記録すると、 プロジェクト ワークスペース と runs テーブル の操作が遅くなる可能性があります。
# ✅ 推奨
wandb.init(
config={
"lr": 0.1,
"batch_size": 32,
"epochs": 4,
}
)
# ❌ 推奨されません
wandb.init(
config={
"steps": range(10000000),
}
)
# ❌ 推奨されません
with f as open("large_config.json", "r"):
large_config = json.load(f)
wandb.init(config=large_config)
読み込み時間を短縮するには、単一の プロジェクト 内の runs の合計数を以下に抑えてください。
これらのしきい値を超える run カウントは、 プロジェクト ワークスペース または runs テーブル を含む操作、特に runs の グルーピング 時、または runs 中に多数の個別の メトリクス を収集する場合に、速度が低下する可能性があります。メトリクス 数 セクションも参照してください。
チームが頻繁に同じ runs のセット（最近の runs のセットなど）に アクセス する場合は、あまり頻繁に使用されない runs をまとめて移動することを検討して、新しい「アーカイブ」 プロジェクト に移動し、作業 プロジェクト にはより少ない runs のセットを残します。
このセクションでは、 ワークスペース のパフォーマンスを最適化するためのヒントを紹介します。
デフォルトでは、 ワークスペース は 自動 であり、ログに記録された キー ごとに標準 パネル を生成します。大規模な プロジェクト の ワークスペース に、ログに記録された多くの キー の パネル が含まれている場合、 ワークスペース の読み込みと使用に時間がかかる場合があります。パフォーマンスを向上させるには、次のことができます。
ワークスペース の構成の詳細については、パネルを参照してください。
ワークスペース 内に数百ものセクションがあると、パフォーマンスが低下する可能性があります。 メトリクス の高レベルの グルーピング に基づいてセクションを作成し、 メトリクス ごとに 1 つのセクションというアンチパターンを避けることを検討してください。
セクションが多すぎてパフォーマンスが低下している場合は、サフィックスではなくプレフィックスでセクションを作成するように ワークスペース 設定を検討してください。これにより、セクションの数が減り、パフォーマンスが向上する可能性があります。
run あたり 5000 ～ 100,000 個の メトリクス をログに記録する場合は、W&B は手動 ワークスペースを使用することをお勧めします。手動モードでは、さまざまな メトリクス のセットを探索するために、必要に応じて パネル を簡単に追加および削除できます。より集中的なプロットのセットを使用すると、 ワークスペース の読み込みが速くなります。プロットされていない メトリクス は、通常どおり収集および保存されます。
ワークスペース を手動モードにリセットするには、 ワークスペース のアクション ... メニューをクリックし、ワークスペース のリセット をクリックします。ワークスペース をリセットしても、runs の保存された メトリクス には影響しません。ワークスペース の管理の詳細をご覧ください。
単一の run でアップロードされるファイルの総数を 1,000 未満に抑えてください。多数の ファイル をログに記録する必要がある場合は、W&B Artifacts を使用できます。単一の run で 1,000 個を超える ファイル があると、run ページ の速度が低下する可能性があります。
レポート は、 パネル 、テキスト、 メディア の任意の配置を自由に構成できるため、同僚と洞察を簡単に共有できます。
対照的に、 ワークスペース では、数百から数十万もの runs にわたって、数十から数千もの メトリクス を高密度かつ高性能に 分析 できます。ワークスペース には、 Reports と比較して、最適化された キャッシュ 、クエリ、および読み込み機能があります。ワークスペース は、主に プレゼンテーション ではなく 分析 に使用される プロジェクト 、または 20 個以上のプロットをまとめて表示する必要がある場合にお勧めです。
Python スクリプト のパフォーマンスが低下する原因はいくつかあります。
wandb.log を 1 秒間に数回以上呼び出す。これは、wandb.log が呼び出されるたびに、トレーニングループにわずかな遅延が追加されるためです。W&B は、レート制限を超える制限は一切主張しません。W&B Python SDK は、制限を超える要求に対して、指数関数的な「バックオフ」および「再試行」要求を自動的に完了します。W&B Python SDK は、 コマンドライン で「ネットワーク 障害 」で応答します。無償アカウントの場合、W&B は、使用量が合理的なしきい値を超える極端な場合に連絡する場合があります。
W&B SaaS Cloud API は、システムの整合性を維持し、可用性を確保するために、レート制限を実装しています。この対策により、単一の ユーザー が共有 インフラストラクチャー で利用可能なリソースを独占することを防ぎ、すべての ユーザー がサービスに アクセス できる状態を維持します。さまざまな理由で、より低いレート制限が発生する可能性があります。
上記の テーブル は、レート制限 HTTP ヘッダー を示しています。
| ヘッダー 名 | 説明 |
|---|---|
| RateLimit-Limit | 1 つの時間枠で使用可能な クォータ 量。0 ～ 1000 の範囲でスケーリングされます。 |
| RateLimit-Remaining | 現在のレート制限ウィンドウの クォータ 量。0 ～ 1000 の範囲でスケーリングされます。 |
| RateLimit-Reset | 現在の クォータ がリセットされるまでの秒数 |
スクリプト 内の wandb.log 呼び出しは、 メトリクス ログ記録 API を利用して、トレーニングデータ を W&B にログ記録します。この API は、オンラインまたはオフライン同期のいずれかを通じて実行されます。いずれの場合も、ローリングタイムウィンドウでレート制限 クォータ 制限が課されます。これには、合計リクエストサイズとリクエストレートの制限が含まれます。後者は、ある時間の長さにおけるリクエスト数を示します。
W&B は、W&B プロジェクト ごとにレート制限を適用します。したがって、チームに 3 つの プロジェクト がある場合、各 プロジェクト には独自のレート制限 クォータ があります。チーム および エンタープライズ プラン の ユーザー は、無料 プラン の ユーザー よりも高いレート制限があります。
メトリクス ログ記録 API の使用中にレート制限に達すると、標準出力に エラー を示す関連 メッセージ が表示されます。
レート制限を超えると、レート制限がリセットされるまで run.finish() が遅延する可能性があります。これを回避するには、次の戦略を検討してください。
if epoch % 5 == 0: # 5 epoch ごとにメトリクスをログ記録する
wandb.log({"acc": accuracy, "loss": loss})
wandb sync <run-file-path> を使用して、データを手動で同期できます。詳細については、wandb sync リファレンス を参照してください。W&B Models UI および SDK のパブリック API は、GraphQL リクエスト を サーバー に送信して、データのクエリと変更を行います。SaaS Cloud 内のすべての GraphQL リクエスト について、W&B は、承認されていないリクエスト の場合は IP アドレス ごとに、承認されているリクエスト の場合は ユーザー ごとにレート制限を適用します。制限は、固定された時間枠内のリクエストレート（1 秒あたりのリクエスト数）に基づいており、料金 プラン によってデフォルトの制限が決定されます。 プロジェクト パス （たとえば、 Reports 、 runs 、 Artifacts ）を指定する関連 SDK リクエスト の場合、W&B は プロジェクト ごとにレート制限を適用します。これは、データベース のクエリ時間によって測定されます。
チーム および エンタープライズ プラン の ユーザー は、無料 プラン の ユーザー よりも高いレート制限を受け取ります。 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 を追加し、コンソール の出力をアカウントチームまたは サポート と共有します。
チームメンバーが作成した実験を再現して、その結果を検証します。
実験を再現する前に、以下をメモする必要があります。
実験を再現するには:
次に、特定のハッシュで実験の コード をダウンロードするか、実験の リポジトリ 全体をクローンします。
実験の Python スクリプトまたは notebook をダウンロードします。
チームメイトが実験の作成に使用した GitHub リポジトリをクローンします。これを行うには:
git clone https://github.com/your-repo.git && cd your-repo
git checkout -b "<run-name>" 0123456789012345678901234567890123456789
左側の ナビゲーションバー で [ファイル] を選択します。
requirements.txt ファイルをダウンロードして、作業 ディレクトリー に保存します。この ディレクトリー には、クローンされた GitHub リポジトリ、またはダウンロードされた Python スクリプトまたは notebook のいずれかが含まれている必要があります。
（推奨）Python 仮想 環境 を作成します。
requirements.txt ファイルで指定された 要件 をインストールします。
pip install -r requirements.txt
コード と依存関係が揃ったので、スクリプトまたは notebook を実行して実験を再現できます。リポジトリをクローンした場合は、スクリプトまたは notebook がある ディレクトリー に移動する必要がある場合があります。それ以外の場合は、作業 ディレクトリー からスクリプトまたは notebook を実行できます。
Python notebook をダウンロードした場合は、notebook をダウンロードした ディレクトリー に移動し、ターミナル で次の コマンド を実行します。
jupyter notebook
Python スクリプトをダウンロードした場合は、スクリプトをダウンロードした ディレクトリー に移動し、ターミナル で次の コマンド を実行します。<> で囲まれた 値 は独自の値に置き換えてください。
python <your-script-name>.py
W&B Public API を使用して、データのエクスポートまたはデータのインポートを行います。
W&B は、実験、run、Artifacts、メトリクス、その他のメタデータなど、MLFlow からのデータのインポートをサポートしています。
依存関係をインストールします。
# 注：これには 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 を収集します。特定のサブセットをアップロードする場合は、独自の run イテラブルを作成してインポーターに渡すことができます。
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 のインポートをスキップするには、artifacts=False を渡します。
importer.import_runs(runs, artifacts=False)
特定の W&B entity と project にインポートするには、Namespace を渡します。
from wandb.apis.importers import Namespace
importer.import_runs(runs, namespace=Namespace(entity, project))
Public API を使用して、W&B に保存したデータをエクスポートまたは更新します。この API を使用する前に、スクリプトからデータをログに記録します。詳細については、クイックスタートを確認してください。
Public API のユースケース
wandb.init(job_type="analysis")利用可能な機能の詳細については、生成されたリファレンスドキュメントを参照してください。
APIキーは、W&B に対するマシンの認証を行います。APIキーは、ユーザープロファイルから生成できます。
Public API を使用するには、run パス <entity>/<project>/<run_id> が必要になることがよくあります。アプリ UI で、run ページを開き、Overviewタブをクリックして、run パスを取得します。
完了した run またはアクティブな run からデータをダウンロードします。一般的な使用法としては、Jupyter ノートブックでカスタム分析を行うためのデータフレームのダウンロードや、自動化された環境でのカスタムロジックの使用などがあります。
import wandb
api = wandb.Api()
run = api.run("<entity>/<project>/<run_id>")
run オブジェクトの最も一般的に使用される属性は次のとおりです。
| 属性 | 意味 |
|---|---|
run.config |
トレーニング run のハイパーパラメーターや、データセット Artifact を作成する run の前処理メソッドなど、run の設定情報の辞書。これらを実行の入力と考えてください。 |
run.history() |
損失など、モデルのトレーニング中に変化する値を格納するための辞書のリスト。コマンド wandb.log() はこのオブジェクトに追加されます。 |
run.summary |
run の結果をまとめた情報の辞書。これには、精度や損失などのスカラーや、大きなファイルを含めることができます。デフォルトでは、wandb.log() は summary をログに記録された時系列の最終値に設定します。summary の内容は直接設定することもできます。summary を run の出力と考えてください。 |
過去の run のデータを変更または更新することもできます。デフォルトでは、api オブジェクトの単一インスタンスがすべてのネットワークリクエストをキャッシュします。ユースケースで実行中のスクリプトでリアルタイムの情報が必要な場合は、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,
}
デフォルトの履歴メソッドは、メトリクスを固定数のサンプルにサンプリングします（デフォルトは 500 です。これは samples __ 引数で変更できます）。大規模な run ですべてのデータをエクスポートする場合は、run.scan_history() メソッドを使用できます。詳細については、APIリファレンスを参照してください。
このサンプルスクリプトは project を検索し、名前、config、summary 統計を含む Runs の CSV を出力します。<entity> と <project> を、それぞれ W&B entity と project の名前に置き換えます。
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() を使用して project 内の 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 オブジェクトが返されます。デフォルトでは、オブジェクトは必要に応じて一度に 50 個の Runs を順番にロードしますが、per_page キーワード引数を使用して、ページごとにロードされる数を変更できます。
api.runs は order キーワード引数も受け入れます。デフォルトの順序は -created_at です。結果を昇順で並べ替えるには、+created_at を指定します。config または summary の値でソートすることもできます。たとえば、summary.val_acc や config.experiment_name などです。
W&B サーバーとの通信中にエラーが発生すると、wandb.CommError が発生します。元の例外は、exc 属性を介して調べることができます。
UI で、run をクリックし、run ページの Overview タブをクリックして、最新の git コミットを確認します。これはファイル wandb-metadata.json にもあります。Public API を使用して、run.commit で git ハッシュを取得できます。
wandb.init() を呼び出した後、スクリプトからランダムな run ID または人間が読める run 名に次のようにアクセスできます。
wandb.run.idwandb.run.nameRuns に役立つ識別子を設定する方法について検討している場合は、次のことをお勧めします。
wandb.init(notes="ここにノート") で設定できます。一般的なエクスポートパターンのいくつかの例については、API 例を確認してください。カスタムプロットまたは展開された Runs テーブルのダウンロードボタンをクリックして、ブラウザーから CSV をダウンロードすることもできます。
この例では、"<entity>/<project>/<run_id>" に保存された run の wandb.log({"accuracy": acc}) で保存されたタイムスタンプと精度を出力します。
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 Query Language を使用してフィルターできます。
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 で異なる config パラメーターが出力されます。
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 に設定します。また、以前の run の精度ヒストグラムを numpy_array のヒストグラムになるように変更します。
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()
この例では、テーブルの summary 列の名前を変更します。
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()
この例では、config 設定の 1 つを更新します。
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")
履歴からデータをプルすると、デフォルトで 500 ポイントにサンプリングされます。run.scan_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)
このスクリプトは、project 内の Runs をプルダウンし、名前、config、summary 統計を含む Runs のデータフレームと CSV を生成します。<entity> と <project> を、それぞれ W&B entity と project の名前に置き換えます。
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 project の 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()
このスニペットは、特定の sweep に関連付けられたすべての Runs をダウンロードします。
import wandb
api = wandb.Api()
sweep = api.sweep("<entity>/<project>/<sweep_id>")
sweep_runs = sweep.runs
次のスニペットは、指定された sweep から最適な Run を取得します。
import wandb
api = wandb.Api()
sweep = api.sweep("<entity>/<project>/<sweep_id>")
best_run = sweep.best_run()
best_run は、sweep config の metric パラメータによって定義された最適なメトリクスを持つ Run です。
このスニペットは、モデルファイルを model.h5 に保存した Runs を使用して、検証精度が最も高いモデルファイルを sweep からダウンロードします。
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 メトリクスを更新できます。
summary.update({"key": val})
各 Run は、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 で匿名の run を作成できるようにします。 |
| WANDB_API_KEY | アカウントに関連付けられた認証 key を設定します。設定ページ で 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 | wandb.config にロードする yaml ファイルのコンマ区切りリスト。config を参照してください。 |
| WANDB_CONSOLE | stdout / stderr ログを無効にするには、これを “off” に設定します。これは、サポートする環境ではデフォルトで “on” になっています。 |
| WANDB_DATA_DIR | ステージング Artifacts がアップロードされる場所。デフォルトの場所はプラットフォームによって異なります。これは、platformdirs Python パッケージの user_data_dir の値を使用するためです。 |
| WANDB_DIR | トレーニングスクリプトからの wandb ディレクトリーの相対位置ではなく、生成されたすべてのファイルをここに保存するには、これを絶対パスに設定します。このディレクトリーが存在し、プロセスを実行するユーザーが書き込むことができることを確認してください。これは、ダウンロードされた Artifacts の場所には影響しないことに注意してください。代わりに WANDB_ARTIFACT_DIR を使用して設定できます |
| WANDB_ARTIFACT_DIR | トレーニングスクリプトからの artifacts ディレクトリーの相対位置ではなく、ダウンロードされたすべての Artifacts をここに保存するには、これを絶対パスに設定します。このディレクトリーが存在し、プロセスを実行するユーザーが書き込むことができることを確認してください。これは、生成されたメタデータファイルの場所には影響しないことに注意してください。代わりに WANDB_DIR を使用して設定できます |
| WANDB_DISABLE_GIT | wandb が git リポジトリをプローブして最新のコミット/差分をキャプチャするのを防ぎます。 |
| WANDB_DISABLE_CODE | wandb が ノートブック または git の差分を保存しないようにするには、これを true に設定します。git リポジトリにいる場合は、現在のコミットを保存します。 |
| WANDB_DOCKER | run の復元を有効にするには、これを docker イメージのダイジェストに設定します。これは、wandb docker コマンドで自動的に設定されます。wandb docker my/image/name:tag --digest を実行して、イメージのダイジェストを取得できます |
| WANDB_ENTITY | run に関連付けられたエンティティ。トレーニングスクリプトのディレクトリーで wandb init を実行した場合、wandb という名前のディレクトリーが作成され、ソース管理にチェックインできるデフォルトのエンティティが保存されます。そのファイルを作成したくない場合、またはファイルを上書きしたい場合は、環境変数を使用できます。 |
| WANDB_ERROR_REPORTING | wandb が致命的なエラーをそのエラー追跡システムにログ記録しないようにするには、これを false に設定します。 |
| WANDB_HOST | システムが提供するホスト名を使用したくない場合に、wandb インターフェイスに表示するホスト名を設定します |
| WANDB_IGNORE_GLOBS | 無視するファイル glob のコンマ区切りリストにこれを設定します。これらのファイルはクラウドに同期されません。 |
| WANDB_JOB_NAME | wandb によって作成されたジョブの名前を指定します。 |
| WANDB_JOB_TYPE | run のさまざまなタイプを示すために、“トレーニング” や “評価” などのジョブタイプを指定します。詳細については、グループ化 を参照してください。 |
| WANDB_MODE | これを “offline” に設定すると、wandb は run のメタデータをローカルに保存し、サーバーに同期しません。これを disabled に設定すると、wandb は完全にオフになります。 |
| WANDB_NAME | run の人間が読める名前。設定されていない場合は、ランダムに生成されます |
| WANDB_NOTEBOOK_NAME | jupyter で実行している場合は、この変数で ノートブック の名前を設定できます。これを自動的に検出しようとします。 |
| WANDB_NOTES | run に関するより長いメモ。マークダウンは許可されており、UI で後で編集できます。 |
| WANDB_PROJECT | run に関連付けられた プロジェクト。これは wandb init で設定することもできますが、環境変数が値を上書きします。 |
| WANDB_RESUME | デフォルトでは、これは never に設定されています。auto に設定すると、wandb は失敗した run を自動的に再開します。must に設定すると、起動時に run が強制的に存在します。常に独自のユニークな ID を生成する場合は、これを allow に設定し、常に WANDB_RUN_ID を設定します。 |
| WANDB_RUN_GROUP | run を自動的にグループ化するための実験名を指定します。詳細については、グループ化 を参照してください。 |
| WANDB_RUN_ID | スクリプトの単一の run に対応するグローバルに一意の文字列（プロジェクトごと）にこれを設定します。64 文字以下である必要があります。単語以外の文字はすべてダッシュに変換されます。これは、障害が発生した場合に既存の run を再開するために使用できます。 |
| WANDB_SILENT | wandb ログステートメントを非表示にするには、これを true に設定します。これが設定されている場合、すべてのログは WANDB_DIR/debug.log に書き込まれます |
| WANDB_SHOW_RUN | オペレーティングシステムがサポートしている場合、run URL でブラウザーを自動的に開くには、これを true に設定します。 |
| WANDB_SWEEP_ID | sweep ID トラッキングを Run オブジェクトと関連クラスに追加し、UI に表示します。 |
| WANDB_TAGS | run に適用されるタグのコンマ区切りリスト。 |
| WANDB_USERNAME | run に関連付けられた チーム のメンバーの ユーザー 名。これは、サービスアカウント API key とともに使用して、自動 run の チーム のメンバーへの属性を有効にすることができます。 |
| WANDB_USER_EMAIL | run に関連付けられた チーム のメンバーのメール。これは、サービスアカウント API key とともに使用して、自動 run の チーム のメンバーへの属性を有効にすることができます。 |
Singularity でコンテナーを実行している場合は、上記の変数の前に SINGULARITYENV_ を付けることで環境変数を渡すことができます。Singularity 環境変数の詳細については、こちら を参照してください。
AWS でバッチジョブを実行している場合は、W&B 認証情報でマシンを簡単に認証できます。設定ページ から API key を取得し、AWS バッチジョブ仕様 で WANDB_API_KEY 環境変数を設定します。
W&B Sweeps を使用して、ハイパーパラメータの検索を自動化し、豊富なインタラクティブな 実験管理 を視覚化します。ベイズ、グリッド検索、ランダムなどの一般的な検索メソッドから選択して、ハイパーパラメータ空間を検索します。1つまたは複数のマシンに スイープ をスケールおよび並列化します。
2つの W&B CLI コマンドで スイープ を作成します。
wandb sweep --project <propject-name> <path-to-config file>
wandb agent <sweep-ID>
ユースケース に応じて、次のリソースを参照して W&B Sweeps を開始してください。
ステップごとのビデオについては、Tune Hyperparameters Easily with W&B Sweeps を参照してください。
このページでは、sweep の定義、初期化、および実行方法について説明します。主な手順は4つあります。
次のコードをコピーして Jupyter Notebook または 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 を開始します
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
wandb.agent(sweep_id, function=main, count=10)
以下のセクションでは、コード サンプルの各ステップを分解して説明します。
wandb.config から ハイパーパラメーター の値を受け取り、それらを使用して model をトレーニングし、メトリクスを返すトレーニング関数を定義します。
必要に応じて、W&B Run の出力を保存する project の名前を指定します (wandb.init の project パラメータ)。project が指定されていない場合、run は「未分類」の project に配置されます。
# 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})
辞書で sweep する ハイパーパラメーター を指定します。configuration オプションについては、sweep configuration の定義を参照してください。
上記の例は、ランダム検索 ('method':'random') を使用する sweep configuration を示しています。sweep は、バッチサイズ、エポック、および学習率について、configuration にリストされている値のランダムなセットをランダムに選択します。
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 を使用して、クラウド (標準)、ローカル (ローカル) で1つまたは複数のマシンにわたる Sweeps を管理します。Sweep Controller の詳細については、ローカルでの検索と停止アルゴリズムを参照してください。
sweep 識別番号は、sweep を初期化するときに返されます。
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
sweep の初期化の詳細については、sweep の初期化を参照してください。
wandb.agent API 呼び出しを使用して sweep を開始します。
wandb.agent(sweep_id, function=main, count=10)
project を開いて、W&B App ダッシュボードでライブ結果を確認します。数回クリックするだけで、パラレル座標図、パラメーター の重要性分析 などの豊富なインタラクティブなグラフを構築できます。詳細
結果の可視化方法の詳細については、sweep 結果の可視化を参照してください。ダッシュボードの例については、このサンプルSweeps Projectを参照してください。
ターミナル で、Ctrl+C を押して現在の run を停止します。もう一度押すと、agent が終了します。
W&B Python SDK をスクリプトまたは Jupyter Notebook に追加する方法は多数あります。以下に、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 variable with hyperparameter values
config = {"lr": 0.0001, "bs": 16, "epochs": 5}
def main():
# Note that we define values from `wandb.config`
# instead of defining hard values
# ハードコードされた値を定義する代わりに、`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 Notebook または Python スクリプト内で W&B Sweep ジョブを開始する場合は、[Python SDK] タブを確認してください。
batch_size)、エポック数 (epochs)、および学習率 (lr) の ハイパーパラメータ は、各 sweep 中に変化します。sweep configuration の作成方法の詳細については、sweep configuration の定義を参照してください。wandb.sweep に渡します。これにより、sweep が初期化されます。これにより、sweep ID (sweep_id) が返されます。sweep の初期化方法の詳細については、sweep の初期化を参照してください。wandb.init() API を使用して、W&B Run としてデータを同期およびログ記録するバックグラウンド プロセス を生成します。wandb.config から値を定義します。wandb.log でログに記録します。configuration で定義された メトリクス をログに記録する必要があります。configuration 辞書 (この例では sweep_configuration) 内で、val_acc 値を最大化するように sweep を定義しました。wandb.agent API 呼び出しで sweep を開始します。sweep ID、sweep が実行する関数の名前 (function=main) を指定し、試行する run の最大数を 4 (count=4) に設定します。W&B Sweep の開始方法の詳細については、sweep agent の開始を参照してください。import wandb
import numpy as np
import random
# Define sweep config
# sweep configuration を定義する
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},
},
}
# Initialize sweep by passing in config.
# (Optional) Provide a name of the project.
# configuration を渡して sweep を初期化します。
# （オプション） Project の名前を指定します。
sweep_id = wandb.sweep(sweep=sweep_configuration, project="my-first-sweep")
# Define training function that takes in hyperparameter
# values from `wandb.config` and uses them to train a
# model and return metric
# `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()
# note that we define values from `wandb.config`
# instead of defining hard values
# ハードコードされた値を定義する代わりに、`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,
}
)
# Start sweep job.
# sweep ジョブを開始します。
wandb.agent(sweep_id, function=main, count=4)
W&B Sweep を作成するには、まず YAML configuration ファイルを作成します。configuration ファイルには、sweep で探索する ハイパーパラメータ が含まれています。以下の例では、バッチサイズ (batch_size)、エポック数 (epochs)、および学習率 (lr) の ハイパーパラメータ は、各 sweep 中に変化します。
# 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 configuration の作成方法の詳細については、sweep configuration の定義を参照してください。
YAML ファイルの program キーに Python スクリプトの名前を指定する必要があることに注意してください。
次に、次のコード例を追加します。
wandb) と PyYAML (yaml) をインポートします。PyYAML は、YAML configuration ファイルを読み込むために使用されます。wandb.init() API を使用して、W&B Run としてデータを同期およびログ記録するバックグラウンド プロセス を生成します。config オブジェクトを config パラメータに渡します。wandb.config から ハイパーパラメータ 値を定義します。wandb.log でログに記録します。configuration で定義された メトリクス をログに記録する必要があります。configuration 辞書 (この例では sweep_configuration) 内で、val_acc 値を最大化するように sweep を定義しました。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():
# Set up your default hyperparameters
# デフォルトのハイパーパラメータを設定する
with open("./config.yaml") as file:
config = yaml.load(file, Loader=yaml.FullLoader)
run = wandb.init(config=config)
# Note that we define values from `wandb.config`
# instead of defining hard values
# ハードコードされた値を定義する代わりに、`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,
}
)
# Call the main function.
# main 関数を呼び出します。
main()
CLI に移動します。CLI 内で、sweep agent が試行する run の最大数を設定します。この手順はオプションです。次の例では、最大数を 5 に設定します。
NUM=5
次に、wandb sweep コマンドで sweep を初期化します。YAML ファイルの名前を指定します。オプションで、project フラグ (--project) の Project の名前を指定します。
wandb sweep --project sweep-demo-cli config.yaml
これにより、sweep ID が返されます。sweep の初期化方法の詳細については、sweep の初期化を参照してください。
sweep ID をコピーし、次の コードスニペット の sweepID を置き換えて、wandb agent コマンドで sweep ジョブを開始します。
wandb agent --count $NUM your-entity/sweep-demo-cli/sweepID
sweep ジョブの開始方法の詳細については、sweep ジョブの開始を参照してください。
sweep configuration で指定した メトリクス を明示的に W&B にログに記録してください。サブディレクトリー内で sweep の メトリクス をログに記録しないでください。
たとえば、次の疑似コードを考えてみましょう。ユーザーは 検証 損失 ("val_loss": loss) をログに記録したいと考えています。最初に、値を 辞書 に渡します。ただし、wandb.log に渡される 辞書 は、辞書 内のキーと値のペアに明示的にアクセスしません。
# Import the W&B Python Library and log into W&B
# 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()
# Incorrect. You must explicitly access the
# key-value pair in the dictionary
# 間違いです。 辞書 のキーと値のペアに明示的にアクセスする必要があります
# 正しいメトリクス の記録方法については、次のコードブロックを参照してください
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 メソッドに渡すときに、キーと値のペアを指定します。
# Import the W&B Python Library and log into W&B
# 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)
W&B Sweep は、ハイパーパラメーターの値を探索する戦略と、それらを評価するコードを組み合わせたものです。この戦略は、すべてのオプションを試すという単純なものから、ベイズ最適化やHyperband (BOHB) のように複雑なものまであります。
Python 辞書または YAML ファイルで sweep configuration を定義します。sweep configuration の定義方法は、sweep の管理方法によって異なります。
以下のガイドでは、sweep configuration のフォーマット方法について説明します。トップレベルの sweep configuration キーの包括的なリストについては、Sweep configuration options を参照してください。
両方の sweep configuration フォーマットオプション (YAML と Python 辞書) は、キーと 値 のペアとネストされた構造を利用します。
sweep configuration 内のトップレベルキーを使用して、sweep の名前 (name キー)、検索するパラメータ (parameters キー)、パラメータ空間を検索する方法 (method キー) など、sweep 検索の特性を定義します。
たとえば、次のコードスニペットは、YAML ファイル内と Python 辞書内で定義された同じ sweep configuration を示しています。sweep configuration 内には、program、name、method、metric、および parameters という 5 つのトップレベルキーが指定されています。
コマンドライン (CLI) からインタラクティブに Sweeps を管理する場合は、YAML ファイルで sweep configuration を定義します。
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 notebook でトレーニングアルゴリズムを定義する場合は、Python 辞書データ構造で sweep を定義します。
次のコードスニペットは、sweep_configuration という変数に 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 configuration は、ネストされたパラメータをサポートしています。ネストされたパラメータを区切るには、トップレベルのパラメータ名の下に追加の parameters キーを使用します。sweep config は、複数レベルのネスティングをサポートしています。
ベイズまたはランダムなハイパーパラメータ検索を使用する場合は、確率分布をランダム変数に指定します。各ハイパーパラメータについて:
parameters キーを作成します。parameters キー内に、以下をネストします。
distribution キーに使用する分布を指定します。ハイパーパラメータ名の下に distribution キーと 値 のペアをネストします。sweep configuration で定義されたネストされたパラメータは、W&B run configuration で指定されたキーを上書きします。
たとえば、train.py Python スクリプトで次の設定で W&B run を初期化するとします (1 ～ 2 行を参照)。次に、sweep_configuration という辞書で sweep configuration を定義します (4 ～ 13 行を参照)。次に、sweep config 辞書を wandb.sweep に渡して、sweep config を初期化します (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},
},
}
# Sweep を config に渡して初期化します。
sweep_id = wandb.sweep(sweep=sweep_configuration, project="<project>")
# Sweep ジョブを開始します。
wandb.agent(sweep_id, function=main, count=4)
W&B run の初期化時に渡される nested_param.manual_key にはアクセスできません。run.config は、sweep configuration 辞書で定義されているキーと 値 のペアのみを保持します。
次のテンプレートは、パラメータを構成し、検索制約を指定する方法を示しています。<> で囲まれた 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 が sweep パラメータを wandb.config に自動的に取り込むことを利用できます。
command:
- ${env}
- ${interpreter}
- ${program}
Hydra などの ツール が期待する方法で引数を渡すようにコマンドを変更できます。詳細については、Hydra with W&B を参照してください。
command:
- ${env}
- ${interpreter}
- ${program}
- ${args_no_hyphens}
sweep configurationは、ネストされたキーと値のペアで構成されています。sweep configuration内のトップレベルキーを使用して、検索するパラメータ（parameter キー）、パラメータ空間を検索する方法（method キー）など、sweep検索の品質を定義します。
以下の表は、トップレベルのsweep configurationキーと簡単な説明を示しています。各キーの詳細については、それぞれのセクションを参照してください。
| トップレベルキー | 説明 |
|---|---|
program |
（必須）実行するトレーニングスクリプト |
entity |
このsweepのエンティティ |
project |
このsweepのプロジェクト |
description |
sweepのテキストによる説明 |
name |
sweepの名前。W&B UIに表示されます。 |
method |
（必須）検索戦略 |
metric |
最適化するメトリック（特定の検索戦略と停止基準でのみ使用されます） |
parameters |
（必須）検索するパラメータ範囲 |
early_terminate |
早期停止基準 |
command |
トレーニングスクリプトを呼び出し、引数を渡すためのコマンド構造 |
run_cap |
このsweepのrunの最大数 |
sweep configurationの構造化方法の詳細については、Sweep configurationの構造を参照してください。
metricmetric トップレベルのsweep configurationキーを使用して、最適化する名前、目標、およびターゲットメトリックを指定します。
| キー | 説明 |
|---|---|
name |
最適化するメトリックの名前。 |
goal |
minimize または maximize（デフォルトは minimize）。 |
target |
最適化しているメトリックの目標値。指定した目標値にrunが到達した場合、sweepは新しいrunを作成しません。（runがターゲットに到達すると）runを実行しているアクティブなエージェントは、エージェントが新しいrunの作成を停止するまでrunの完了を待ちます。 |
parametersYAMLファイルまたはPythonスクリプトで、parametersをトップレベルキーとして指定します。parametersキーの中で、最適化するハイパーパラメータの名前を指定します。一般的なハイパーパラメータには、学習率、バッチサイズ、エポック、オプティマイザーなどがあります。sweep configurationで定義するハイパーパラメータごとに、1つまたは複数の検索制約を指定します。
次の表は、サポートされているハイパーパラメータ検索制約を示しています。ハイパーパラメータとユースケースに基づいて、以下の検索制約のいずれかを使用して、sweep agentに検索場所（分布の場合）または検索または使用するもの（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は次の条件に基づいて次の分布を設定します。
valuesを指定した場合はcategoricalmaxとminを整数として指定した場合はint_uniformmaxとminをfloatとして指定した場合はuniformvalueにセットを提供した場合はconstantmethodmethodキーでハイパーパラメータ検索戦略を指定します。選択できるハイパーパラメータ検索戦略は、グリッド、ランダム、ベイズ探索の3つです。
ハイパーパラメータ値のすべての組み合わせを反復処理します。グリッド検索は、各反復で使用するハイパーパラメータ値のセットについて、情報に基づかない決定を行います。グリッド検索は、計算コストが高くなる可能性があります。
グリッド検索は、連続検索空間内で検索している場合、永久に実行されます。
分布に基づいて、各反復でランダムで情報に基づかないハイパーパラメータ値のセットを選択します。コマンドライン、Pythonスクリプト内、またはW&B App UIからプロセスを停止しない限り、ランダム検索は永久に実行されます。
ランダム（method: random）検索を選択した場合は、メトリックキーで分布空間を指定します。
ランダムおよびグリッド検索とは対照的に、ベイズモデルは情報に基づいた決定を行います。ベイズ最適化は、確率モデルを使用して、目的関数を評価する前に代用関数で値をテストする反復プロセスを通じて、使用する値を決定します。ベイズ探索は、連続パラメータの数が少ない場合にはうまく機能しますが、スケールは劣ります。ベイズ探索の詳細については、ベイズ最適化入門論文を参照してください。
ベイズ探索は、コマンドライン、Pythonスクリプト内、またはW&B App UIからプロセスを停止しない限り、永久に実行されます。
parameterキー内で、ハイパーパラメータの名前をネストします。次に、distributionキーを指定し、値の分布を指定します。
次の表は、W&Bがサポートする分布を示しています。
distributionキーの値 |
説明 |
|---|---|
constant |
定数分布。使用する定数（value）を指定する必要があります。 |
categorical |
カテゴリ分布。このハイパーパラメータの有効な値（values）をすべて指定する必要があります。 |
int_uniform |
整数に対する離散一様分布。maxとminを整数として指定する必要があります。 |
uniform |
連続一様分布。maxとminをfloatとして指定する必要があります。 |
q_uniform |
量子化された一様分布。round(X / q) * qを返します。ここで、Xは一様です。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 |
量子化された対数一様分布。round(X / q) * qを返します。ここで、Xはlog_uniformです。qのデフォルトは1です。 |
q_log_uniform_values |
量子化された対数一様分布。round(X / q) * qを返します。ここで、Xはlog_uniform_valuesです。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 |
量子化された正規分布。round(X / q) * qを返します。ここで、Xはnormalです。Qのデフォルトは1です。 |
log_normal |
対数正規分布。自然対数log(X)が平均mu（デフォルト0）および標準偏差sigma（デフォルト1）で正規分布するように、値Xを返します。 |
q_log_normal |
量子化された対数正規分布。round(X / q) * qを返します。ここで、Xはlog_normalです。qのデフォルトは1です。 |
early_terminateパフォーマンスの低いrunを停止するには、早期終了（early_terminate）を使用します。早期終了が発生した場合、W&Bは新しいハイパーパラメータ値のセットで新しいrunを作成する前に、現在のrunを停止します。
early_terminateを使用する場合は、停止アルゴリズムを指定する必要があります。sweep configuration内のearly_terminate内にtypeキーをネストします。Hyperbandハイパーパラメータ最適化は、プログラムを停止するか、事前設定された1つ以上の反復回数（ブラケットと呼ばれる）で続行するかを評価します。
W&Bのrunがブラケットに到達すると、sweepはそのrunのメトリックを以前に報告されたすべてのメトリック値と比較します。runのメトリック値が高すぎる場合（目標が最小化の場合）、またはrunのメトリックが低すぎる場合（目標が最大化の場合）、sweepはrunを終了します。
ブラケットは、ログに記録された反復回数に基づいています。ブラケットの数は、最適化するメトリックをログに記録する回数に対応します。反復は、ステップ、エポック、またはその間の何かに対応できます。ステップカウンターの数値は、ブラケットの計算には使用されません。
min_iterまたはmax_iterのいずれかを指定します。| キー | 説明 |
|---|---|
min_iter |
最初のブラケットの反復を指定します |
max_iter |
最大反復回数を指定します。 |
s |
ブラケットの総数を指定します（max_iterに必要）。 |
eta |
ブラケット乗数スケジュールを指定します（デフォルト：3）。 |
strict |
元のHyperband論文に厳密に従って、runをより積極的にプルーニングする「strict」モードを有効にします。デフォルトはfalseです。 |
commandcommandキー内のネストされた値を使用して、形式と内容を変更します。ファイル名などの固定コンポーネントを直接含めることができます。
/usr/bin/envは、OSが環境に基づいて正しいPythonインタープリターを選択するようにします。W&Bは、コマンドの可変コンポーネントに対して次のマクロをサポートしています。
| コマンドマクロ | 説明 |
|---|---|
${env} |
Unixシステムでは/usr/bin/env、Windowsでは省略。 |
${interpreter} |
pythonに展開されます。 |
${program} |
sweep configurationの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 は、クラウド（標準）、ローカル（ローカル）の 1 台以上のマシンで Sweeps を管理するために、 Sweep Controller を使用します。run が完了すると、sweep controller は、実行する新しい run を記述した新しい一連の指示を発行します。これらの指示は、実際に run を実行する エージェント によって取得されます。典型的な W&B Sweep では、コントローラは W&B サーバー上に存在します。エージェントは あなたの マシン上に存在します。
以下のコードスニペットは、CLI および Jupyter Notebook または Python スクリプト内で Sweeps を初期化する方法を示しています。
wandb.init) は、W&B Sweep を初期化するときに指定する project の名前 (wandb.sweep) と一致する必要があります。W&B SDK を使用して sweep を初期化します。sweep configuration 辞書を sweep パラメータに渡します。オプションで、W&B Run の出力を保存する project パラメータ（project）の project 名を指定します。project が指定されていない場合、run は「未分類」の project に配置されます。
import wandb
# sweep configuration の例
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 関数は、sweep ID を返します。sweep ID には、Entity 名と project 名が含まれます。sweep ID をメモしておいてください。
W&B CLI を使用して sweep を初期化します。configuration ファイルの名前を指定します。オプションで、project フラグの project 名を指定します。project が指定されていない場合、W&B Run は「未分類」の project に配置されます。
wandb sweep コマンドを使用して、sweep を初期化します。次のコード例では、sweeps_demo project の sweep を初期化し、configuration に config.yaml ファイルを使用します。
wandb sweep --project sweeps_demo config.yaml
このコマンドは、sweep ID を出力します。sweep ID には、Entity 名と project 名が含まれます。sweep ID をメモしておいてください。
複数のマシン上の 1 つまたは複数のエージェントで W&B Sweep を開始します。W&B Sweep エージェントは、ハイパーパラメータのために W&B Sweep ( wandb sweep) を初期化したときに起動した W&B サーバーにクエリを実行し、それらを使用してモデルトレーニングを実行します。
W&B Sweep エージェントを開始するには、W&B Sweep を初期化したときに返された W&B Sweep ID を指定します。W&B Sweep ID の形式は次のとおりです。
entity/project/sweep_ID
以下に詳細を示します。
Jupyter Notebook または Python スクリプト内で W&B Sweep エージェントを開始する場合、W&B Sweep が実行する関数の名前を指定します。
以下のコードスニペットは、W&B でエージェントを開始する方法を示しています。設定ファイルが既にあって、W&B Sweep を初期化済みであることを前提としています。設定ファイルを定義する方法の詳細については、Sweep 設定の定義 を参照してください。
wandb agent コマンドを使用して sweep を開始します。sweep を初期化したときに返された sweep ID を指定します。以下のコードスニペットをコピーして貼り付け、sweep_id を sweep ID に置き換えます。
wandb agent sweep_id
W&B Python SDK ライブラリを使用して sweep を開始します。sweep を初期化したときに返された sweep ID を指定します。さらに、sweep が実行する関数の名前を指定します。
wandb.agent(sweep_id=sweep_id, function=function_name)
オプションで、W&B Run の数を Sweep エージェントが試行する回数を指定します。次のコードスニペットは、CLI および Jupyter Notebook、Python スクリプト内で W&B Runs の最大数を設定する方法を示しています。
まず、sweep を初期化します。詳細については、Sweeps の初期化 を参照してください。
sweep_id = wandb.sweep(sweep_config)
次に、sweep ジョブを開始します。sweep の開始から生成された sweep ID を指定します。試行する run の最大数を設定するには、count パラメータに整数値を渡します。
sweep_id, count = "dtzl1o7u", 10
wandb.agent(sweep_id, count=count)
wandb.teardown() を呼び出す必要があります。まず、wandb sweep コマンドで sweep を初期化します。詳細については、Sweeps の初期化 を参照してください。
wandb sweep config.yaml
試行する run の最大数を設定するには、count フラグに整数値を渡します。
NUM=10
SWEEPID="dtzl1o7u"
wandb agent --count $NUM $SWEEPID
マルチコアまたはマルチ GPU マシンで W&B Sweep エージェントを並列化します。開始する前に、W&B Sweep を初期化していることを確認してください。W&B Sweep の初期化方法の詳細については、Sweeps の初期化 を参照してください。
ユースケースに応じて、次のタブで CLI を使用するか、Jupyter Notebook 内で W&B Sweep エージェントを並列化する方法を検討してください。
wandb agent コマンドを使用して、ターミナルで複数の CPU に W&B Sweep エージェントを並列化します。sweep を初期化 したときに返された sweep ID を指定します。
sweep_id を sweep ID に置き換えます。wandb agent sweep_id
W&B Python SDK ライブラリを使用して、Jupyter Notebook 内で複数の CPU に W&B Sweep エージェントを並列化します。sweep を初期化 したときに返された sweep ID があることを確認してください。さらに、sweep が function パラメータに対して実行する関数の名前を指定します。
sweep_id という変数に格納され、関数の名前が function_name の場合、次の コードスニペット を複数の Jupyter Notebook に貼り付けて、sweep を並列化できます。wandb.agent(sweep_id=sweep_id, function=function_name)
次の手順に従って、CUDA Toolkit を使用してターミナルで複数の GPU に W&B Sweep エージェントを並列化します。
wandb agent) を開始するときに、CUDA_VISIBLE_DEVICES で使用する GPU インスタンスを指定します。CUDA_VISIBLE_DEVICES に、使用する GPU インスタンスに対応する整数値を割り当てます。たとえば、ローカルマシンに 2 つの NVIDIA GPU があるとします。ターミナルウィンドウを開き、CUDA_VISIBLE_DEVICES を 0 (CUDA_VISIBLE_DEVICES=0) に設定します。次の例の sweep_ID を、W&B Sweep を初期化したときに返される W&B Sweep ID に置き換えます。
ターミナル 1
CUDA_VISIBLE_DEVICES=0 wandb agent sweep_ID
2 番目のターミナルウィンドウを開きます。CUDA_VISIBLE_DEVICES を 1 (CUDA_VISIBLE_DEVICES=1) に設定します。上記の コードスニペット で説明されている sweep_ID に同じ W&B Sweep ID を貼り付けます。
ターミナル 2
CUDA_VISIBLE_DEVICES=1 wandb agent sweep_ID
W&B App UI で W&B Sweeps の結果を可視化します。https://wandb.ai/home にある W&B App UI に移動します。W&B Sweep を初期化する際に指定した project を選択します。project の workspace にリダイレクトされます。左側のパネルにある Sweep icon (ほうきのアイコン) を選択します。Sweep UI で、リストから Sweep の名前を選択します。
デフォルトでは、W&B は W&B Sweep ジョブを開始すると、自動的にパラレル座標図、パラメータのインポータンスプロット、および散布図を作成します。
パラレル座標図は、多数のハイパーパラメータとモデルのメトリクスの関係を一目でまとめたものです。パラレル座標図の詳細については、パラレル座標 を参照してください。
散布図 (左) は、Sweep 中に生成された W&B Runs を比較します。散布図の詳細については、散布図 を参照してください。
パラメータのインポータンスプロット (右) は、メトリクスの望ましい値の最良の予測因子であり、メトリクスの望ましい値と高度に相関するハイパーパラメータをリストします。パラメータのインポータンスプロットの詳細については、パラメータの重要性 を参照してください。
自動的に使用される従属値と独立値 (x 軸と y 軸) を変更できます。各 panel 内には、Edit panel という鉛筆アイコンがあります。Edit panel を選択します。モデルが表示されます。モーダル内で、グラフの振る舞いを変更できます。
すべてのデフォルトの W&B 可視化オプションの詳細については、Panels を参照してください。W&B Sweep の一部ではない W&B Runs からプロットを作成する方法については、Data Visualization のドキュメント を参照してください。
CLI で W&B Sweep を一時停止、再開、キャンセルします。W&B Sweep を一時停止すると、Sweep が再開されるまで新しい W&B Run を実行しないように W&B エージェント に指示します。Sweep を再開すると、新しい W&B Run の実行を続行するようにエージェントに指示します。W&B Sweep を停止すると、新しい W&B Run の作成または実行を停止するように W&B Sweep エージェントに指示します。W&B Sweep をキャンセルすると、現在実行中の W&B Run を強制終了し、新しい Run の実行を停止するように Sweep エージェントに指示します。
いずれの場合も、W&B Sweep を初期化したときに生成された W&B Sweep ID を指定してください。必要に応じて、新しい ターミナル ウィンドウを開いて、次のコマンドを実行します。W&B Sweep が現在の ターミナル ウィンドウに出力ステートメントを出力している場合は、新しい ターミナル ウィンドウを開くとコマンドを実行しやすくなります。
次のガイダンスに従って、sweep を一時停止、再開、およびキャンセルします。
新しい W&B Run の実行を一時的に停止するように W&B Sweep を一時停止します。W&B Sweep を一時停止するには、wandb sweep --pause コマンドを使用します。一時停止する W&B Sweep ID を指定します。
wandb sweep --pause entity/project/sweep_ID
wandb sweep --resume コマンドを使用して、一時停止した W&B Sweep を再開します。再開する W&B Sweep ID を指定します。
wandb sweep --resume entity/project/sweep_ID
新しい W&B Run の実行を停止し、現在実行中の Run を終了させるには、W&B sweep を完了させます。
wandb sweep --stop entity/project/sweep_ID
実行中のすべての run を強制終了し、新しい run の実行を停止するには、sweep をキャンセルします。W&B Sweep をキャンセルするには、wandb sweep --cancel コマンドを使用します。キャンセルする 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
エージェント 全体で Sweep を再開するには、Sweep ID と共に --resume フラグを指定します。
wandb sweep --resume entity/project/sweep_ID
W&B エージェント を並列化する方法の詳細については、エージェント の並列化 を参照してください。
Li, Lisha, 他. “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 を使用したハイパーパラメーター最適化を調査する Projects の例を示しています。
次のハウツー ガイドでは、W&B を使用して実際の問題を解決する方法を示します。
W&B はオープンソースを提唱し、コミュニティからの貢献を歓迎します。GitHub リポジトリは https://github.com/wandb/sweeps にあります。W&B オープンソースリポジトリへの貢献方法については、W&B GitHub のContribution guidelinesを参照してください。
ハイパーパラメータコントローラは、デフォルトで Weights & Biased によってクラウドサービスとしてホストされています。W&B エージェントはコントローラと通信して、トレーニングに使用するパラメータの次のセットを決定します。コントローラは、どの run を停止できるかを判断するために、早期停止アルゴリズムを実行する役割も担っています。
ローカルコントローラの機能を使用すると、ユーザーはローカルで検索および停止アルゴリズムを開始できます。ローカルコントローラを使用すると、ユーザーはコードを検査および調査して、問題をデバッグしたり、クラウドサービスに組み込むことができる新機能を開発したりできます。
始める前に、W&B SDK（wandb）をインストールする必要があります。コマンドラインに次のコードスニペットを入力します。
pip install wandb sweeps
以下の例では、設定ファイルとトレーニングループが Python スクリプトまたは Jupyter Notebook で定義されていることを前提としています。設定ファイルを定義する方法の詳細については、sweep configuration の定義を参照してください。
通常、Weights & Biased がクラウドサービスとしてホストするハイパーパラメータコントローラを使用する場合と同様に、sweep を初期化します。コントローラフラグ（controller）を指定して、W&B sweep ジョブにローカルコントローラを使用することを示します。
wandb sweep --controller config.yaml
または、sweep の初期化とローカルコントローラを使用することの指定を2つのステップに分けることもできます。
ステップを分けるには、まず、次のキーと値を sweep の YAML 設定ファイルに追加します。
controller:
type: local
次に、sweep を初期化します。
wandb sweep config.yaml
sweep を初期化したら、wandb controllerでコントローラを起動します。
# wandb sweep コマンドは sweep_id を出力します
wandb controller {user}/{entity}/{sweep_id}
ローカルコントローラを使用するように指定したら、1つ以上の Sweep agent を起動して sweep を実行します。通常と同じように W&B Sweep を開始します。詳細については、Sweep agent の開始を参照してください。
wandb sweep sweep_ID
次のコードスニペットは、W&B Python SDK でローカルコントローラを指定および使用する方法を示しています。
Python SDK でコントローラを使用する最も簡単な方法は、sweep ID をwandb.controllerメソッドに渡すことです。次に、return オブジェクトの run メソッドを使用して、sweep ジョブを開始します。
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()
コードで sweep を完全に指定する場合は、次のようにします。
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()
提案されたガイダンスに従って、一般的なエラーメッセージのトラブルシューティングを行います。
CommError, Run does not exist および ERROR Error uploadingこれらの 2 つのエラーメッセージが両方とも返された場合、W&B の Run ID が定義されている可能性があります。例として、Jupyter Notebook または Python スクリプトのどこかに、次のようなコードスニペットが定義されている可能性があります。
wandb.init(id="some-string")
W&B は W&B Sweeps によって作成された Runs に対して、ランダムでユニークな ID を自動的に生成するため、W&B Sweeps の Run ID を設定することはできません。
W&B の Run ID は、1 つの project 内でユニークである必要があります。
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 configuration ファイル (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"]
次に、次のコードを train.py Python スクリプトに追加します。
if _name_ == "_main_":
train()
CLI に移動し、wandb sweep で W&B Sweep を初期化します。
wandb sweep config.yaml
返された W&B Sweep ID をメモします。次に、Python SDK (wandb.agent) ではなく、CLI で wandb agent を使用して Sweep ジョブを開始します。次のコードスニペットの 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 内で Sweep を最適化するために定義した 正確な メトリック名を使用してください。設定ファイルの詳細については、Sweep configuration の定義 を参照してください。
State （ステート）、作成時間（Created）、sweep を開始した Entity （Creator）、完了した run の数（Run count）、sweep の計算にかかった時間（Compute time）は、Sweeps UI に表示されます。sweep が作成すると予想される run の数（Est. Runs）は、離散的な検索空間でグリッド検索を行う場合に提供されます。また、sweep をクリックして、インターフェースから sweep を一時停止、再開、停止、または強制終了することもできます。
このチュートリアルでは、既存の W&B の プロジェクト から sweep job を作成する方法について説明します。ここでは、Fashion MNIST データセット を使用して、PyTorch の畳み込み ニューラルネットワーク に画像の分類方法を学習させます。必要な コード と データセット は、W&B のリポジトリにあります。https://github.com/wandb/examples/tree/master/examples/pytorch/pytorch-cnn-fashion
この W&B ダッシュボード で 結果 を確認してください。
まず、 ベースライン を作成します。W&B examples 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 App UI ダッシュボード に表示される例を確認してください。
プロジェクト ページから、サイドバーの Sweep tab を開き、Create Sweep を選択します。
自動生成された 設定 は、完了した run に基づいて sweep する 値 を推測します。試したい ハイパーパラメーター の範囲を指定するには、 設定 を編集します。sweep を 起動 すると、ホストされている W&B sweep server で新しい プロセス が開始されます。この集中型 サービス は、 トレーニング job を実行している マシン である エージェント を調整します。
次に、 ローカル で エージェント を 起動 します。作業を分散して sweep job をより迅速に完了したい場合は、最大 20 個の エージェント を異なる マシン で 並行 して 起動 できます。エージェント は、次に試す パラメータ のセットを出力します。
これで sweep が実行されました。次の図は、サンプル sweep job の実行中に ダッシュボード がどのように表示されるかを示しています。プロジェクト ページの例を見る →
以前に ログ に記録した既存の run を使用して、新しい sweep を 起動 します。
これで、sweep が サーバー 上にセットアップされます。run の実行を開始するには、1 つ以上の エージェント を 起動 するだけです。
W&B Tables を使用して、テーブル形式のデータを可視化およびクエリします。例:
上の画像は、セマンティックセグメンテーションとカスタムメトリクスを含むテーブルを示しています。このテーブルは、W&B ML コースのサンプル project でご覧ください。
Table は、各カラムが単一のデータ型を持つデータの二次元グリッドです。Tables は、プリミティブ型と数値型、およびネストされたリスト、辞書、リッチメディア型をサポートしています。
数行のコードで Table をログします。
wandb.init(): run を作成して、結果を追跡します。wandb.Table(): 新しい 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})
次の クイックスタート では、データテーブル のログ記録、データの可視化、およびデータのクエリ方法について説明します。
下のボタンを選択して、MNIST データに関する PyTorch の クイックスタート のサンプル プロジェクト を試してください。
W&B で テーブル のログを記録します。新しい テーブル を構築するか、Pandas Dataframe を渡すことができます。
新しい テーブル を構築してログに記録するには、以下を使用します。
wandb.init(): run を作成して、結果を追跡します。wandb.Table(): 新しい テーブル オブジェクト を作成します。
columns: 列名を設定します。data: 各行の内容を設定します。run.log(): テーブル をログに記録して、W&B に保存します。例を次に示します。
import wandb
run = wandb.init(project="table-test")
# Create and log a new table.
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 検証データに対するモデルの 予測 を示します。
![[予測] をクリックしてテーブルを表示します](https://docs.wandb.ai/images/data_vis/preds_mnist.png)
最初は、 両方のテーブルがマージされて表示されます。 最初に選択されたテーブルのインデックスは0で青色で強調表示され、 2番目のテーブルのインデックスは1で黄色で強調表示されます。マージされたテーブルのライブ例はこちら をご覧ください。
マージされたビューからは、 以下が可能です。
2つのテーブルを並べて表示するには、 最初のドロップダウンを [テーブルをマージ: テーブル] から [リスト: テーブル] に変更し、 それぞれ [ページ サイズ] を更新します。 ここで、 最初に選択したテーブルは左側にあり、 2番目のテーブルは右側にあります。 また、 [垂直] チェックボックスをクリックして、 これらのテーブルを垂直方向に比較することもできます。
時間の経過とともにテーブルを比較 したり、 モデル バリアント を比較 したりすることもできます。
トレーニング の意味のあるステップごとに Artifacts にテーブルを記録して、 トレーニング 時間中のモデルの性能を分析します。 例えば、 すべての検証ステップの終了時、 トレーニング の50 エポックごと、 または パイプライン に適した頻度でテーブルを記録できます。 並べて表示するビューを使用して、 モデル 予測 の変化を可視化します。
トレーニング 時間中の 予測 の可視化に関するより詳細なウォークスルーについては、 この Report およびこのインタラクティブな ノートブック の例 を参照してください。
2つの異なるモデルに対して同じステップで記録された2つの Artifacts バージョンを比較して、 異なる 設定 (ハイパーパラメーター 、 ベース アーキテクチャー など) 全体でモデルの性能を分析します。
例えば、 baseline と新しいモデル バリアント である 2x_layers_2x_lr の間で 予測 を比較します。この場合、 最初の畳み込みレイヤーは32から64に、 2番目のレイヤーは128から256に、 学習率は0.001から0.002に倍増します。このライブ例 から、 並べて表示するビューを使用して、 1 (左側のタブ) 対 5 トレーニング エポック (右側のタブ) 後の不正な 予測 に絞り込みます。
![5 エポック後、 [ダブル] バリアント は ベースライン に追いついています。](https://docs.wandb.ai/images/data_vis/compare_across_variants_after_5_epochs.png)
run Workspace 、 Project Workspace 、 または Report で操作するテーブルは、 ビューの状態を自動的に保存します。 テーブル操作を適用して ブラウザ を閉じると、 次にテーブルに移動したときに、 テーブルには最後に表示された 設定 が保持されます。
特定の状態で Workspace からテーブルを保存するには、 W&B Report にエクスポートします。 テーブルを Report にエクスポートするには、 次の手順を実行します。
![[パネルを共有] を選択すると新しい Report が作成され、 [レポートに追加] を選択すると既存の Report に追加できます。](https://docs.wandb.ai/images/data_vis/share_your_view.png)
これらの Reports は、 W&B Tables のさまざまな ユースケース を示しています。
次のセクションでは、テーブルを使用できる方法のいくつかを紹介します。
モデルトレーニングまたは評価中に、メトリクスとリッチメディアをログに記録し、クラウドまたは ホスティングインスタンス に同期された永続的なデータベースで結果を可視化します。
たとえば、写真データセットのバランスの取れた分割を示すこのテーブル を確認してください。
テーブルの表示、並べ替え、フィルタリング、グループ化、結合、およびクエリを実行して、データとモデルのパフォーマンスを理解します。静的なファイルを参照したり、分析スクリプトを再実行したりする必要はありません。
たとえば、スタイルが転送されたオーディオに関するこのレポート を参照してください。
さまざまなトレーニングエポック、データセット、ハイパーパラメーターの選択、モデルアーキテクチャーなどで、結果をすばやく比較します。
たとえば、同じテスト画像で 2 つのモデルを比較するこのテーブル を参照してください。
特定のステップで特定の予測を可視化するためにズームインします。集計統計を表示し、エラーのパターンを特定し、改善の機会を理解するためにズームアウトします。このツールは、単一のモデルトレーニングのステップを比較したり、異なるモデルバージョン間で結果を比較したりするために使用できます。
たとえば、MNIST データセットで 1 回、次に 5 回のエポック後の結果を分析するこのサンプルテーブル を参照してください。
以下は、W&B Tables を使用する実際の W&B のProjectsのハイライトです。
このレポート を読むか、この colab に従うか、artifacts コンテキスト を調べて、CNN が iNaturalist の写真から 10 種類の生物（植物、鳥、昆虫など）を識別する方法を確認してください。
音色転送に関するこのレポート でオーディオテーブルを操作します。録音されたクジラの歌と、バイオリンやトランペットなどの楽器で同じメロディーをシンセサイズした演奏を比較できます。この colab を使用して、独自の曲を録音し、W&B でシンセサイズされたバージョンを探索することもできます。
トレーニングデータまたは生成された出力からテキストサンプルを参照し、関連フィールドで動的にグループ化し、モデルのバリアントまたは実験設定全体で評価を調整します。テキストを Markdown としてレンダリングするか、ビジュアル差分モードを使用してテキストを比較します。このレポート で、シェイクスピアを生成するための単純な文字ベースの RNN を探索してください。
トレーニング中にログに記録されたビデオを参照および集計して、モデルを理解します。副作用を最小限に抑える ことを目指す RL エージェント向けの SafeLife ベンチマーク を使用した初期の例を次に示します。
バージョン管理と重複排除を使用して 表形式データを分割および事前処理する方法に関するレポート を表示します。
セマンティックセグメンテーション用の Tables のログを記録し、異なるモデルを比較する インタラクティブノートブック と ライブ例。この Table で独自のクエリを試してください。
時間経過に伴う予測の可視化 と、それに付随する インタラクティブノートブック に関する詳細なレポート。
すべての W&B Artifacts と同様に、Tables は pandas のデータフレームに変換して、簡単にデータのエクスポートができます。
table を artifact に変換するまず、テーブルを 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)
# 作成した artifact を使用して、作成したテーブルを取得します。
with wandb.init() as r:
artifact = r.use_artifact("my_dataset:latest")
table = artifact.get("my_table")
artifact を Dataframe に変換する次に、テーブルをデータフレームに変換します。
# 前のコード例から続けて:
df = table.get_dataframe()
これで、データフレームがサポートする任意の方法を使用してエクスポートできます。
# テーブルデータを .csv に変換する
df.to_csv("example.csv", encoding="utf-8")
artifacts の リファレンスドキュメント を確認してください。ワークスペース パネルの 可視化 を使用して、ログに記録された データ を キー ごとに探索し、 ハイパーパラメータ と出力 メトリクス の関係を 可視化 することができます。
W&B の プロジェクト は、2つの異なる ワークスペース モードをサポートしています。 ワークスペース 名の横にあるアイコンは、そのモードを示しています。
| アイコン | ワークスペース モード |
|---|---|
 |
自動 ワークスペース は、 プロジェクト で ログ されたすべての キー に対して パネル を自動的に生成します。 自動 ワークスペース を選択する:
|
 |
手動 ワークスペース は、空白の状態から始まり、 ユーザー が意図的に追加した パネル のみを表示します。 手動 ワークスペース を選択する:
|
ワークスペース での パネル の生成方法を変更するには、ワークスペース をリセットします。
ワークスペース をリセットするには:
... をクリックします。ワークスペース のレイアウトを 設定 するには、 ワークスペース の上部にある Settings をクリックし、次に Workspace layout をクリックします。
ワークスペース の折れ線 プロット のデフォルトを 設定 するには、折れ線 プロット を参照してください。
セクションのレイアウトを 設定 するには、歯車アイコンをクリックし、次に Display preferences をクリックします。
フルスクリーン モード では、 run セレクター が表示され、 パネル は、通常 1000 バケットではなく、10,000 バケットの高精度サンプリング モード プロット を使用します。
パネル をフルスクリーン モード で表示するには:
... をクリックし、次にファインダーまたは正方形の4つの角を示すアウトラインのようなフルスクリーン ボタンをクリックします。
フルスクリーン モード から パネル の ワークスペース に戻るには、 ページ の上部にある左向きの矢印をクリックします。
このセクションでは、 ワークスペース に パネル を追加するさまざまな方法を示します。
グローバル またはセクション レベルで、 ワークスペース に パネル を1つずつ追加します。
... メニューをクリックし、次に + Add panels をクリックします。
Quick add を使用して、選択した キー ごとに パネル をグローバル またはセクション レベルで自動的に追加します。
... メニューをクリックし、Add panels をクリックして、次に Quick add をクリックします。このセクションでは、リンクを使用して パネル を共有する方法を示します。
リンクを使用して パネル を共有するには、次のいずれかを実行します。
... をクリックし、Copy panel URL を選択します。リンクを ユーザー または チーム と共有します。 ユーザー がリンクに アクセス すると、 パネル がフルスクリーン モード で開きます。
フルスクリーン モード から パネル の ワークスペース に戻るには、 ページ の上部にある左向きの矢印をクリックします。
オートメーション の作成など、特定の状況では、 パネル のフルスクリーン URL を含めると便利な場合があります。 このセクションでは、 パネル のフルスクリーン URL の形式を示します。 以下の例では、エンティティ 、 プロジェクト 、 パネル 、およびセクション名を角かっこで囲んで置き換えます。
https://wandb.ai/<ENTITY_NAME>/<PROJECT_NAME>?panelDisplayName=<PANEL_NAME>&panelSectionName=<SECTON_NAME>
同じセクション内の複数の パネル が同じ名前を持つ場合、この URL はその名前の最初の パネル を開きます。
Webサイトに パネル を埋め込んだり、ソーシャル メディア で共有したりするには、リンクを知っている人なら誰でも パネル を表示できる必要があります。 プロジェクト がプライベートの場合、 プロジェクト の メンバー のみ パネル を表示できます。 プロジェクト がパブリックの場合、リンクを知っている人なら誰でも パネル を表示できます。
ソーシャル メディア で パネル を埋め込んだり共有したりするための コード を取得するには:
... をクリックします。スタンドアロン レポート として単一の パネル をメールで送信するには:
... をクリックします。パネル を共有する場合とは異なり、受信者はこの レポート から ワークスペース にアクセスできません。
パネル を編集するには:
パネル を別のセクションに移動するには、 パネル のドラッグ ハンドルを使用できます。 代わりに、リストから新しいセクションを選択するには:
... メニューをクリックします。ドラッグ ハンドルを使用して、セクション内の パネル を再配置することもできます。
パネル を複製するには:
... メニューをクリックします。必要に応じて、複製された パネル をカスタマイズまたは移動できます。
パネル を削除するには:
... メニューを選択します。手動 ワークスペース からすべての パネル を削除するには、アクション ... メニューをクリックし、次に 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() の呼び出しでログに記録されていることを確認してください。折れ線グラフの個々の設定は、セクションまたはワークスペースの折れ線グラフの設定よりも優先されます。折れ線グラフをカスタマイズするには:
折れ線グラフでは、次の設定を構成できます。
日付: プロットのデータの表示に関する詳細を構成します。
wandb.log() が呼び出されるたびに増分され、モデルからログに記録したトレーニング ステップの数を反映することになっています。グループ化: プロットで run をグループ化および集計するかどうか、またその方法を構成します。
チャート: パネル、X 軸、Y 軸、および -軸のタイトルを指定し、凡例の表示/非表示を切り替え、その位置を構成します。
凡例: パネルの凡例の外観をカスタマイズします (有効になっている場合)。
式: カスタム計算式をパネルに追加します。
${summary:value} です。セクション内のすべての折れ線グラフのデフォルト設定をカスタマイズするには、折れ線グラフのワークスペース設定をオーバーライドします。
ワークスペース内のすべての折れ線グラフのデフォルト設定をカスタマイズするには:
各 データ 設定の詳細については、前のセクション 個々の折れ線グラフ を参照してください。
各 表示設定 セクションの詳細については、ワークスペースの表示設定 を参照してください。ワークスペース レベルでは、折れ線グラフのデフォルトの ズーム の振る舞いを構成できます。この設定は、一致する X 軸キーを持つ折れ線グラフ間でズームを同期するかどうかを制御します。デフォルトでは無効になっています。
いくつかの異なる Experiments があり、プロット上の値の平均を表示する場合は、テーブルのグループ化機能を使用できます。run テーブルの上にある [グループ] をクリックし、[すべて] を選択して、グラフに平均値を表示します。
平均化する前のグラフは次のようになります。
次の画像は、グループ化された線を使用して runs 全体の平均値を表すグラフを示しています。
wandb.log を使用して、PyTorch テンソルを含む NaN 値を折れ線グラフにプロットすることもできます。例：
wandb.log({"test": [..., float("nan"), ...]})
runs のデフォルトの色が比較に役立たない場合があります。これを克服するために、wandb には、手動で色を変更できる 2 つのインスタンスが用意されています。
各 run には、初期化時にデフォルトでランダムな色が割り当てられます。
いずれかの色をクリックすると、カラー パレットが表示され、そこから必要な色を手動で選択できます。
実験にかかった絶対時間を確認したり、実験が実行された曜日を確認したりする場合は、X 軸を切り替えることができます。ステップから相対時間、そして Wall Time に切り替える例を次に示します。
折れ線グラフの設定の [詳細設定] タブで、異なるプロット スタイルをクリックして、面グラフまたはパーセンテージ面グラフを取得します。
長方形をクリックしてドラッグし、垂直方向と水平方向に同時にズームします。これにより、X 軸と Y 軸のズームが変更されます。
この単純なトグルを使用して、折れ線グラフの凡例をオフにします。
折れ線グラフのX軸には、W&B.log でログに記録した値を設定できます。ただし、常に数値としてログに記録されている必要があります。
Y軸の変数には、wandb.log でログに記録した値を設定できます。ただし、数値、数値の配列、または数値のヒストグラムをログに記録している必要があります。変数のポイント数が1500を超える場合、W&B は1500ポイントまでサンプルダウンします。
プロットのXとYの最大値と最小値を変更できます。
X範囲のデフォルトは、X軸の最小値から最大値までです。
Y範囲のデフォルトは、メトリクスの最小値とゼロからメトリクスの最大値までです。
デフォルトでは、10個の run または run のグループのみがプロットされます。run は run テーブルまたは run セットの上部から取得されるため、run テーブルまたは run セットをソートすると、表示される run を変更できます。
チャートの凡例を制御して、ログに記録した任意の run の任意の設定値と、作成時間や run を作成した ユーザー など、run からのメタデータを表示できます。
例：
${run:displayName} - ${config:dropout} は、各 run の凡例名を royal-sweep - 0.5 のようにします。ここで、royal-sweep は run 名で、0.5 は dropout という名前の設定 パラメータ です。
[[ ]] 内に値を設定すると、チャートにカーソルを合わせたときに、ポイント固有の値をクロスヘアに表示できます。たとえば、\[\[ $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-精度などの メトリクス から派生した値をプロットできます。現在、単一の メトリクス をプロットしている場合にのみ機能します。単純な算術式（+、-、*、/、％）、および累乗の場合は ** を実行できます。
折れ線グラフのスタイルを選択します。
折れ線グラフ：
面グラフ：
パーセンテージ面グラフ：
Data Visualization の精度とパフォーマンスを向上させるために、折れ線グラフ内でポイント集約メソッドを使用します。ポイント集約モードには、full fidelity（完全精度） と random sampling（ランダムサンプリング） の2種類があります。W&B はデフォルトで完全精度モードを使用します。
完全精度モードを使用すると、W&B はデータポイントの数に基づいて、x軸を動的なバケットに分割します。次に、各バケット内の最小値、最大値、平均値を計算し、折れ線グラフのポイント集約をレンダリングします。
ポイント集約に完全精度モードを使用する主な利点は3つあります。
折れ線グラフの周りの影付き領域で最小値と最大値を表示または非表示にします。
次の画像は、青い折れ線グラフを示しています。水色の影付き領域は、各バケットの最小値と最大値を表しています。
折れ線グラフで最小値と最大値をレンダリングするには、次の3つの方法があります。
デフォルトでは、最小値と最大値は影付き領域として表示されません。影付き領域オプションのいずれかを表示するには、次の手順に従います。
極端な値やスパイクなどの重要なポイントを見逃すことなく、データセットの特定領域を分析します。折れ線グラフをズームインすると、W&B は各バケット内の最小値、最大値、平均値を計算するために使用されるバケットサイズを調整します。
W&B は x軸をデフォルトで1000個のバケットに動的に分割します。各バケットについて、W&B は次の値を計算します。
W&B は、完全なデータ表現を保持し、すべてのプロットに極端な値を含める方法でバケット内の値をプロットします。1,000ポイント以下にズームインすると、完全精度モードは追加の集約なしですべてのデータポイントをレンダリングします。
折れ線グラフをズームインするには、次の手順に従います。
折れ線グラフのグループ化を使用すると、W&B は選択したモードに基づいて以下を適用します。
ランダムサンプリングは、1500個のランダムにサンプリングされたポイントを使用して折れ線グラフをレンダリングします。ランダムサンプリングは、多数のデータポイントがある場合にパフォーマンス上の理由で役立ちます。
デフォルトでは、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;
});
これは アプリ内 では次のようになります。
ガウシアン平滑化 (またはガウシアン カーネル平滑化) は、点の加重平均を計算します。ここで、重みは平滑化 パラメータ として指定された標準偏差を持つガウス分布に対応します。を参照してください。平滑化された 値 は、すべての入力x 値 に対して計算されます。
TensorBoard の 振る舞い と一致させることを気にしない場合は、ガウシアン平滑化は平滑化に適した標準的な選択肢です。指数移動平均とは異なり、値の前後に発生する点に基づいて点が平滑化されます。
これは アプリ内 では次のようになります。
移動平均は、指定されたx 値 の前後のウィンドウ内の点の平均で点を置き換える平滑化アルゴリズムです。https://en.wikipedia.org/wiki/Moving_average の「Boxcar Filter」を参照してください。移動平均に選択された パラメータ は、Weights and Biases に移動平均で考慮する点の数を伝えます。
点 がx軸上で不均等に配置されている場合は、ガウシアン平滑化の使用を検討してください。
次の画像は、実行中のアプリが アプリ内 でどのように見えるかを示しています。
TensorBoard EMAアルゴリズムは、一貫した点密度 (x軸の単位あたりにプロットされる点の数) を持たない同じチャート上の複数の線を正確に平滑化できないため、非推奨になりました。
指数移動平均は、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);
これは アプリ内 では次のようになります。
すべての平滑化アルゴリズムはサンプリングされた データ で実行されます。つまり、1500を超える点を ログ に記録すると、平滑化アルゴリズムは サーバー から点がダウンロードされた 後 に実行されます。平滑化アルゴリズムの目的は、 データ 内のパターンをすばやく見つけるのに役立つことです。多数の ログ に記録された点 を持つ メトリクス で正確な平滑化された 値 が必要な場合は、API を介して メトリクス をダウンロードし、独自の平滑化 メソッド を実行する方が良い場合があります。
デフォルトでは、元の平滑化されていない データ が背景に薄い線として表示されます。これをオフにするには、[元のデータを表示] トグルをクリックします。
棒グラフは、カテゴリカルデータを長方形の棒で表示し、垂直または水平にプロットできます。棒グラフは、すべてのログに記録された値の長さが1の場合、デフォルトで wandb.log() で表示されます。
チャートの設定で、表示する最大 run 数を制限したり、configで run をグループ化したり、ラベルの名前を変更したりできます。
また、Box プロットまたは Violin プロットを作成して、多くの要約統計量を1つのチャートタイプにまとめることもできます。
並列座標チャートは、多数のハイパーパラメータとモデル の メトリクス の関係を一目で把握できるようにまとめたものです。
wandb.config のさまざまなハイパーパラメータと、wandb.log のメトリクス。パネル を構成するには、パネル の右上隅にある編集ボタンをクリックします。
このページでは、W&B で散布図を使用する方法について説明します。
散布図を使用して、複数の run を比較し、実験のパフォーマンスを可視化します。
次の例は、数週間の実験におけるさまざまな model の検証精度を表示する散布図を示しています。ツールチップには、バッチサイズ、ドロップアウト、および軸の値が含まれています。線は、検証精度の移動平均も示しています。
W&B UI で散布図を作成するには:
... をクリックします。x 軸と y 軸を設定します。オプションで、軸の最大範囲と最小範囲を設定するか、z 軸を追加します。デフォルトでは、W&B は最新の git コミットハッシュのみを保存します。より多くのコード機能を有効にすると、UI で Experiments 間のコードを動的に比較できます。
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 ソースコードファイルが Artifacts としてキャプチャされます。保存されるソースコードファイルの種類と場所をより詳細に制御するには、リファレンスドキュメント を参照してください。
プログラムでコードの保存を設定するだけでなく、W&B アカウントの Settings でこの機能を切り替えることもできます。これにより、アカウントに関連付けられているすべての Teams に対してコードの保存が有効になることに注意してください。
デフォルトでは、W&B はすべての Teams に対してコードの保存を無効にします。
異なる W&B の Runs で使用されるコードを比較します。
W&B は、Jupyter ノートブックセッションで実行されたコードの履歴を保存します。Jupyter 内で wandb.init() を呼び出すと、W&B は現在のセッションで実行されたコードの履歴を含む Jupyter ノートブックを自動的に保存する hook を追加します。
これにより、セッションで実行されたセルと、iPython の display メソッドを呼び出すことによって作成された出力が表示されます。これにより、特定の run で Jupyter 内で実行されたコードを正確に確認できます。可能な場合、W&B はコードディレクトリーにある最新バージョンのノートブックも保存します。
どのハイパーパラメータが最も優れた予測因子であり、メトリクスの望ましい値と高度に相関しているかを調べます。
相関 は、ハイパーパラメータと選択したメトリクス（この場合は val_loss）の間の線形相関です。したがって、高い相関は、ハイパーパラメータが高い値を持つ場合、メトリクスも高い値を持つことを意味し、その逆もまた同様です。相関は見るべき優れたメトリクスですが、入力間の二次的な相互作用を捉えることができず、大きく異なる範囲の入力を比較するのが面倒になる可能性があります。
したがって、W&B は 重要度 メトリクスも計算します。W&B は、ハイパーパラメータを入力として、メトリクスをターゲット出力としてランダムフォレストをトレーニングし、ランダムフォレストのフィーチャーの重要度の値をレポートします。
この手法のアイデアは、Jeremy Howard との会話に触発されました。彼は、Fast.ai でハイパーパラメータ空間を調査するために、ランダムフォレストのフィーチャーの重要度の使用を開拓しました。W&B は、この 講義 （およびこれらの ノート）をチェックして、この分析の背後にある動機について詳しく学ぶことを強くお勧めします。
ハイパーパラメータの重要度パネルは、高度に相関するハイパーパラメータ間の複雑な相互作用を解きほぐします。そうすることで、モデルのパフォーマンスを予測するという点で、どのハイパーパラメータが最も重要であるかを示すことにより、ハイパーパラメータの検索を微調整するのに役立ちます。
パラメータマネージャーを使用すると、表示および非表示のパラメータを手動で設定できます。
この panel には、トレーニングスクリプトの wandb.config オブジェクトに渡されたすべてのパラメータが表示されます。次に、これらの config パラメータのフィーチャーの重要度と相関関係が、選択したモデルメトリクス（この場合は val_loss）に関して表示されます。
重要度の列には、選択したメトリクスの予測に各ハイパーパラメータがどの程度役立ったかが表示されます。多数のハイパーパラメータのチューニングを開始し、このプロットを使用して、さらに調査する価値のあるハイパーパラメータを絞り込むシナリオを想像してください。後続の Sweeps は、最も重要なハイパーパラメータに限定できるため、より優れたモデルをより迅速かつ安価に見つけることができます。
前の画像では、epochs, learning_rate, batch_size および weight_decay が非常に重要であることがわかります。
相関は、個々のハイパーパラメータとメトリクスの値の間の線形関係を捉えます。SGD オプティマイザーなどのハイパーパラメータの使用と val_loss の間に有意な関係があるかどうかという質問に答えます（この場合の答えはイエスです）。相関値の範囲は -1 から 1 で、正の値は正の線形相関を表し、負の値は負の線形相関を表し、0 の値は相関がないことを表します。一般に、どちらかの方向に 0.7 より大きい値は強い相関を表します。
このグラフを使用して、メトリクスとの相関が高い値をさらに調べたり（この場合は、確率的勾配降下法または adam を rmsprop または nadam よりも選択したり）、より多くのエポックでトレーニングしたりできます。
重要度と相関の間の格差は、重要度がハイパーパラメータ間の相互作用を考慮するのに対し、相関は個々のハイパーパラメータがメトリクスの値に与える影響のみを測定するという事実に起因します。次に、相関は線形関係のみを捉え、重要度はより複雑な関係を捉えることができます。
ご覧のとおり、重要度と相関はどちらも、ハイパーパラメータがモデルのパフォーマンスにどのように影響するかを理解するための強力な Tool です。
Run Comparer を使用して、run間で異なるメトリクスを確認できます。
diff only オプションを切り替えて、run間で値が同じ行を非表示にします。
weave-plot を追加してください。クエリー パネルを使用して、データをクエリーし、インタラクティブに視覚化します。
ワークスペースまたは レポート 内にクエリーを追加します。
「/Query panel（/クエリー パネル ）」と入力して選択します。
または、クエリーを 一連の Runs に関連付けることもできます。
クエリー式を使用して、Runs、Artifacts、Models、Tables など、W&B に保存されているデータをクエリーします。
W&B Table をクエリーするとします。 トレーニング コード で、"cifar10_sample_table"というテーブルを ログ に記録します。
import wandb
wandb.log({"cifar10_sample_table":<MY_TABLE>})
クエリー パネル 内では、次のコードでテーブルをクエリーできます。
runs.summary["cifar10_sample_table"]
これを分解すると次のようになります。
runs は、クエリー パネル が ワークスペース にある場合、クエリー パネル 式に自動的に挿入される変数です。 その「値」は、特定の ワークスペース で表示できる Runs のリストです。 run で使用できるさまざまな属性については、こちらをお読みください。summary は、Run の Summary オブジェクトを返す op です。 Op は mapped です。つまり、この op はリスト内の各 Run に適用され、Summary オブジェクトのリストが生成されます。["cifar10_sample_table"] は、predictions という パラメータ を持つ Pick op（角かっこで示されます）です。 Summary オブジェクトは ディクショナリー または マップ のように動作するため、この操作は各 Summary オブジェクトから predictions フィールドを選択します。独自のクエリーをインタラクティブに作成する方法については、この レポート を参照してください。
パネル の左上隅にある歯車アイコンを選択して、クエリー 設定 を展開します。 これにより、 ユーザー は パネル のタイプと、結果 パネル の パラメータ を 設定 できます。
最後に、クエリー結果 パネル は、選択したクエリー パネル を使用して、クエリー式の結果をレンダリングし、データ をインタラクティブな形式で表示するように 設定 によって 設定 されます。 次の画像は、同じデータの Table とプロットを示しています。
クエリー パネル 内で実行できる一般的な操作を次に示します。
列オプションから並べ替えを行います。
クエリーで直接 フィルター するか、左上隅にある フィルター ボタンを使用できます（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 オブジェクトは、 Experiments のレコードを保存します。 詳細については、 レポート のこのセクションを参照してください。簡単にまとめると、runs オブジェクトには次のものが含まれます。
summary: Run の結果をまとめた情報の ディクショナリー 。 これは、精度や損失などのスカラー、または大きなファイルにすることができます。 デフォルトでは、wandb.log() は Summary を ログ に記録された 時系列 の最終値に 設定 します。 Summary の内容を直接 設定 できます。 Summary を Run の出力として考えてください。history: 損失など、モデル の トレーニング 中に変化する値を保存するための ディクショナリー のリスト。 コマンド wandb.log() はこの オブジェクト に追加されます。config: トレーニング Run の ハイパー パラメータ ーや、データセット Artifact を作成する Run の 前処理 メソッド など、Run の 設定 情報の ディクショナリー 。 これらを Run の「入力」と考えてください。
Artifacts は W&B の 中核となる概念です。 これらは、 バージョン 管理された名前付きのファイルと ディレクトリー のコレクションです。 Artifacts を使用して、モデル の重み、データセット 、およびその他のファイルまたは ディレクトリー を追跡します。 Artifacts は W&B に保存され、ダウンロードしたり、他の Runs で使用したりできます。 詳細と例については、 レポート のこのセクションを参照してください。 Artifacts には通常、project オブジェクト からアクセスします。
project.artifactVersion(): プロジェクト 内の指定された名前と バージョン の特定の Artifact バージョン を返します。project.artifact(""): プロジェクト 内の指定された名前の Artifact を返します。 次に、.versions を使用して、この Artifact のすべての バージョン のリストを取得できます。project.artifactType(): プロジェクト 内の指定された名前の artifactType を返します。 次に、.artifacts を使用して、このタイプのすべての Artifacts のリストを取得できます。project.artifactTypes: プロジェクト 下にあるすべての Artifact タイプ のリストを返します。
埋め込み は、オブジェクト（人、画像、投稿、単語など）を数値のリスト、つまり ベクトル で表現するために使用されます。 機械学習とデータサイエンスのユースケースでは、埋め込みは、さまざまなアプリケーションでさまざまなアプローチを使用して生成できます。このページでは、読者が埋め込みについてよく理解しており、W&B 内で視覚的に分析することに関心があることを前提としています。
W&B を使用すると、wandb.Table クラスを使用して埋め込みをログに記録できます。それぞれが 5 次元で構成される 3 つの埋め込みの次の例を考えてみましょう。
import wandb
wandb.init(project="embedding_tutorial")
embeddings = [
# D1 D2 D3 D4 D5
[0.2, 0.4, 0.1, 0.7, 0.5], # 埋め込み 1
[0.3, 0.1, 0.9, 0.2, 0.7], # 埋め込み 2
[0.4, 0.5, 0.2, 0.2, 0.1], # 埋め込み 3
]
wandb.log(
{"embeddings": wandb.Table(columns=["D1", "D2", "D3", "D4", "D5"], data=embeddings)}
)
wandb.finish()
上記のコードを実行すると、W&B ダッシュボードにデータを含む新しい Table が表示されます。 右上のパネルセレクターから [2D Projection] を選択して、埋め込みを 2 次元でプロットできます。 スマートデフォルトが自動的に選択されます。これは、歯車アイコンをクリックしてアクセスできる設定メニューで簡単にオーバーライドできます。 この例では、利用可能な 5 つの数値次元すべてを自動的に使用します。
上記の例は、埋め込みをログに記録する基本的なメカニズムを示していますが、通常はより多くの次元とサンプルを扱っています。 MNIST Digits データセット(UCI ML 手書き数字データセットs) について考えてみましょう。SciKit-Learn 経由で利用できます。 このデータセットには 1797 件のレコードがあり、それぞれに 64 の次元があります。 この問題は、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 に Table が表示されます。 [2D Projection] を選択すると、埋め込みの定義、色付け、アルゴリズム (PCA、UMAP、t-SNE)、アルゴリズムのパラメータ、さらにはオーバーレイ (この場合は、ポイントにカーソルを合わせると画像が表示されます) を設定できます。 この特定のケースでは、これらはすべて「スマートデフォルト」であり、[2D Projection] を 1 回クリックすると、非常によく似たものが表示されます。 (ここをクリックして操作この例を参照してください)。
埋め込みは、さまざまな形式でログに記録できます。
list[int]、list[float]、または np.ndarray になります。int または float を使用できます。
さらに、すべてのテーブルと同様に、テーブルの構築方法に関して多くのオプションがあります。
wandb.Table(dataframe=df) を使用して dataframe から直接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つの値のリストを互いにプロットする場合、リスト内の値の数は完全に一致する必要があります (たとえば、各ポイントには 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つの値のリストを互いにプロットする場合、リスト内の値の数は完全に一致する必要があることに注意してください (たとえば、各ポイントには 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"
)
}
)
これを使用して、任意の棒グラフをログに記録できます。リスト内のラベルと値の数は完全に一致する必要があることに注意してください (たとえば、各データポイントには両方が必要です)。
レポートの例 を参照するか、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 はリストのリストであり、行と列の2D配列をサポートすることを目的としています。
レポートの例 を参照するか、Google Colabノートブックの例 をお試しください。
wandb.plot.pr_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曲線 を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() を使用して、データを2D配列としてログに記録します。通常、このテーブルの各行は1つのデータポイントを表し、各列はプロットする各データポイントの関連フィールド/次元を示します。カスタム パネルを構成すると、テーブル全体が wandb.log() (custom_data_table below) に渡される名前付きキーを介してアクセスできるようになり、個々のフィールドは列名 (x、y、および z) を介してアクセスできるようになります。 experiment 全体で複数のタイムステップでテーブルをログに記録できます。各テーブルの最大サイズは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 を使用して、runs の config、サマリー、および履歴フィールドからデータをフェッチします。
右上隅の グラフ を選択して、デフォルトのプリセットから開始します。次に、グラフフィールド を選択して、クエリから取得しているデータをグラフの対応するフィールドにマッピングします。
次の画像は、メトリクスを選択し、それを下の棒グラフフィールドにマッピングする方法の例を示しています。
パネルの上部にある 編集 をクリックして、Vega 編集モードに移動します。ここでは、UI でインタラクティブなグラフを作成する Vega 仕様 を定義できます。グラフのあらゆる側面を変更できます。たとえば、タイトルを変更したり、別の配色を選択したり、曲線を接続された線としてではなく一連の点として表示したりできます。また、Vega 変換を使用して値の配列をヒストグラムにビン化するなど、データ自体に変更を加えることもできます。パネルプレビューはインタラクティブに更新されるため、Vega 仕様またはクエリを編集するときの変更の効果を確認できます。Vega のドキュメントとチュートリアル を参照してください。
フィールド参照
W&B からグラフにデータをプルするには、Vega 仕様の任意の場所に "${field:<field-name>}" 形式のテンプレート文字列を追加します。これにより、右側の グラフフィールド 領域にドロップダウンが作成され、ユーザーはクエリ結果の列を選択して Vega にマッピングできます。
フィールドのデフォルト値を設定するには、次の構文を使用します: "${field:<field-name>:<placeholder text>}"
モーダルの下部にあるボタンを使用して、特定の可視化パネルに変更を適用します。または、Vega 仕様を保存して、プロジェクトの他の場所で使用することもできます。再利用可能なグラフ定義を保存するには、Vega エディターの上部にある 名前を付けて保存 をクリックし、プリセットに名前を付けます。
カスタムチャートを使用すると、パネルにロードするデータとその可視化を制御できます。
まず、スクリプトにデータをログ記録します。トレーニングの開始時に設定された単一のポイント（ハイパーパラメータなど）には、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"])}
)
クイックなサンプルノートブックを試してデータテーブルをログに記録してください。次のステップでは、カスタムチャートを設定します。結果として得られるチャートがライブ Reportでどのように見えるかを確認してください。
可視化するデータをログに記録したら、プロジェクトページに移動し、**+**ボタンをクリックして新しいパネルを追加し、カスタムチャートを選択します。この Workspaceで一緒に操作できます。
wandb.Table() をログに記録したキーを入力します。上記のコードスニペットでは、my_custom_table でした。サンプルノートブックでは、キーは pr_curve と roc_curve です。クエリがこれらの列をロードするようになったので、Vega フィールドのドロップダウンメニューで選択するオプションとして使用できます。
見た目はかなり良いですが、散布図から折れ線グラフに切り替えたいと思います。「編集」をクリックして、この組み込みチャートの Vega 仕様を変更します。この Workspaceで一緒に操作できます。
Vega 仕様を更新して、可視化をカスタマイズしました。
これをプリセットとして保存して、このプロジェクトの他の場所で使用できるようにするには、ページの上部にある「名前を付けて保存」をクリックします。結果は次のようになり、ROC 曲線が表示されます。
ヒストグラムは、数値分布を可視化して、より大きなデータセットを理解するのに役立ちます。複合ヒストグラムは、同じビンに複数の分布を表示し、異なるモデル間、またはモデル内の異なるクラス間で、2 つ以上のメトリクスを比較できます。運転シーンでオブジェクトを検出するセマンティックセグメンテーションモデルの場合、精度と intersection over union (IOU) の最適化の効果を比較したり、異なるモデルが車（データ内の大きく一般的な領域）と交通標識（はるかに小さく、一般的でない領域）をどの程度検出できるかを知りたい場合があります。デモ Colabでは、10 種類の生物のクラスのうち 2 つの信頼度スコアを比較できます。
カスタム複合ヒストグラムパネルの独自のバージョンを作成するには:
summaryTable を追加し、対応する tableKey を class_scores に設定して、run によってログに記録された wandb.Table をフェッチします。これにより、class_scores としてログに記録された wandb.Table の列を使用して、ドロップダウンメニューから 2 つのヒストグラムビンセット（red_bins と blue_bins）を設定できます。私の例では、赤いビンの動物クラスの予測スコアと、青いビンの植物の予測スコアを選択しました。これは、非常に簡単な実験からの結果がどのように見えるかです。1 エポックでわずか 1000 個のサンプルでトレーニングすると、ほとんどの画像が植物ではないと非常に確信しており、どの画像が動物である可能性があるかについては非常に不確かなモデルが生成されます。
特定の ワークスペース ページ内には、ワークスペース、セクション、パネルという3つの異なる設定レベルがあります。ワークスペース の 設定 は、ワークスペース 全体に適用されます。セクション の 設定 は、セクション内のすべてのパネルに適用されます。パネル の 設定 は、個々のパネルに適用されます。
ワークスペース の 設定は、すべてのセクションと、それらのセクション内のすべてのパネルに適用されます。編集できるワークスペース の 設定には、ワークスペース の レイアウト と 折れ線グラフ の2種類があります。ワークスペース の レイアウト は ワークスペース の構造を決定し、折れ線グラフ の 設定は ワークスペース 内の折れ線グラフのデフォルト設定を制御します。
この ワークスペース の全体的な構造に適用される設定を編集するには:
ワークスペース のレイアウトを構成して、ワークスペース の全体的な構造を定義します。これには、セクション分割ロジックとパネルの構成が含まれます。
ワークスペース のレイアウト オプション ページには、ワークスペース がパネルを自動的に生成するか、手動で生成するかが表示されます。ワークスペース のパネル生成モードを調整するには、Panels を参照してください。
次の表は、各ワークスペース のレイアウト オプションについて説明したものです。
| ワークスペース の 設定 | 説明 |
|---|---|
| 検索時に空のセクションを非表示にする | パネルを検索するときに、パネルを含まないセクションを非表示にします。 |
| パネルをアルファベット順に並べ替える | ワークスペース 内のパネルをアルファベット順に並べ替えます。 |
| セクション の 構成 | 既存のすべてのセクションとパネルを削除し、新しいセクション名で再作成します。新しく作成されたセクションを、最初のプレフィックスまたは最後のプレフィックスでグループ化します。 |
Line plots ワークスペース の 設定を変更して、ワークスペース 内の折れ線グラフのグローバルなデフォルトとカスタムルールを設定します。
Line plots の 設定では、Data と Display preferences という2つのメイン設定を編集できます。Data タブには、次の設定が含まれています。
| 折れ線グラフ の 設定 | 説明 |
|---|---|
| X軸 | 折れ線グラフのX軸のスケール。X軸はデフォルトで Step に設定されています。X軸のオプションのリストについては、次の表を参照してください。 |
| 範囲 | X軸に表示する最小値と最大値の設定。 |
| Smoothing | 折れ線グラフの Smoothing を変更します。Smoothing の詳細については、Smooth line plots を参照してください。 |
| Outliers | デフォルトのプロットの最小スケールと最大スケールから外れ値を排除するためにリスケールします。 |
| Point aggregation method | Data Visualization の精度とパフォーマンスを向上させます。詳細については、Point aggregation を参照してください。 |
| Max number of runs or groups | 折れ線グラフに表示される Runs またはグループの数を制限します。 |
Step に加えて、X軸には次のオプションがあります。
| X軸 オプション | 説明 |
|---|---|
| 相対時間 (Wall) | プロセス の開始からのタイムスタンプ。たとえば、run を開始し、翌日にその run を再開するとします。その後、何かを log に記録すると、記録されたポイントは24時間になります。 |
| 相対時間 (Process) | 実行中のプロセス内のタイムスタンプ。たとえば、run を開始して10秒間続行するとします。翌日にその run を再開します。ポイントは10秒として記録されます。 |
| Wall Time | グラフ上の最初の run の開始からの経過時間 (分)。 |
| Step | wandb.log() を呼び出すたびに増分します。 |
Display preferences タブでは、次の設定を切り替えることができます。
| 表示設定 | 説明 |
|---|---|
| Remove legends from all panels | パネルの凡例を削除します |
| Display colored run names in tooltips | ツールチップ内に Runs を色付きのテキストとして表示します |
| Only show highlighted run in companion chart tooltip | チャートのツールチップに強調表示された Runs のみを表示します |
| Number of runs shown in tooltips | ツールチップに Runs の数を表示します |
| Display full run names on the primary chart tooltip | チャートのツールチップに run のフルネームを表示します |
セクション の 設定は、そのセクション内のすべてのパネルに適用されます。ワークスペース の セクション 内では、パネルの並べ替え、パネルの再配置、セクション名の変更を行うことができます。
セクション の 設定を変更するには、セクション の右上隅にある3つの水平ドット (…) を選択します。
ドロップダウンから、セクション全体に適用される次の設定を編集できます。
| セクション の 設定 | 説明 |
|---|---|
| Rename a section | セクションの名前を変更します |
| Sort panels A-Z | セクション内のパネルをアルファベット順に並べ替えます |
| Rearrange panels | セクション内のパネルを選択してドラッグし、パネルを手動で並べ替えます |
次のアニメーションは、セクション内のパネルを再配置する方法を示しています。
個々のパネルの 設定をカスタマイズして、同じプロット上に複数の線を比較したり、カスタム軸を計算したり、ラベルの名前を変更したりできます。パネルの 設定を編集するには:
パネルに適用できる設定の完全なリストについては、Edit line panel settings を参照してください。
個々の ユーザー アカウント内では、プロフィール画像、表示名、地理的な場所、自己紹介情報、アカウントに関連付けられたメールアドレスを編集したり、runs のアラートを管理したりできます。設定 ページを使用して、GitHub リポジトリをリンクしたり、アカウントを削除したりすることもできます。詳細については、ユーザー settings を参照してください。
Team settings ページを使用して、新しいメンバーを Team に招待または削除したり、Team runs のアラートを管理したり、プライバシー 設定を変更したり、ストレージの使用状況を表示および管理したりできます。Team settings の詳細については、Team settings を参照してください。
ユーザープロファイルページに移動し、右上隅にあるユーザーアイコンを選択します。ドロップダウンから、設定 を選択します。
プロフィール セクションでは、アカウント名と所属機関を管理および変更できます。オプションで、略歴、場所、個人または所属機関のウェブサイトへのリンクを追加したり、プロフィール画像をアップロードしたりできます。
イントロダクションを編集するには、プロフィールの最上部にある 編集 をクリックします。開く WYSIWYG エディターは Markdown をサポートしています。
/ と入力し、リストから Markdown を選択できます。X で @weights_biases アカウントのフォローバッジを追加するには、バッジ画像を指す HTML <img> タグを含む Markdown スタイルのリンクを追加できます。
[<img src="https://img.shields.io/twitter/follow/weights_biases?style=social" alt="X: @weights_biases" >](https://x.com/intent/follow?screen_name=weights_biases)
<img> タグでは、width、height、またはその両方を指定できます。いずれか一方のみを指定した場合、画像のプロポーションは維持されます。
Team セクションで新しい team を作成します。新しい team を作成するには、新しい team ボタンを選択し、以下を入力します。
ベータ機能 セクションでは、オプションで楽しいアドオンや開発中の新製品の先行プレビューを有効にできます。有効にするベータ機能の横にあるトグルスイッチを選択します。
wandb.alert() で、run がクラッシュまたは終了した場合、またはカスタムアラートを設定した場合に通知を受け取ります。メールまたは Slack で通知を受信します。アラートを受信するイベントタイプの横にあるスイッチを切り替えます。
アラートの設定と管理方法の詳細については、wandb.alert でアラートを送信 を参照してください。
個人の Github アカウントを接続します。Github アカウントを接続するには:
アカウントを削除 ボタンを選択して、アカウントを削除します。
ストレージ セクションでは、アカウントが Weights and Biases サーバーで使用した総メモリ使用量を説明します。デフォルトのストレージプランは 100GB です。ストレージと価格の詳細については、価格 ページを参照してください。
ユーザープロフィールページに移動し、右上隅にあるユーザーアイコンを選択します。ドロップダウンから、Billing を選択するか、Settings を選択し、Billing タブを選択します。
Plan details セクションでは、組織の現在のプラン、料金、制限、使用状況の概要が示されます。
ここから、プランを比較したり、営業担当者と話をしたりできます。
このセクションでは、現在の使用状況を視覚的にまとめ、今後の使用料金を表示します。月ごとの使用状況の詳細な分析情報を得るには、個々のタイルで View usage をクリックします。カレンダー月、Team、または Project ごとに使用状況をエクスポートするには、Export CSV をクリックします。
有料プランをご利用の組織の場合、管理者は、特定のしきい値に達すると、1 回の請求期間につき 1 回、メールでアラートを受信します。また、請求管理者 の場合は、組織の制限を増やす方法、それ以外の場合は、請求管理者に連絡する方法の詳細も記載されています。Pro plan では、請求管理者のみが使用状況アラートを受信します。
これらのアラートは構成できず、次の場合に送信されます。
使用状況または請求に関するご質問は、アカウントTeamまたはサポートにお問い合わせください。
このセクションには、組織に登録されている支払い方法が表示されます。支払い方法を追加していない場合は、プランをアップグレードするか、有料ストレージを追加するときに、追加するように求められます。
このセクションには、現在の請求管理者が表示されます。請求管理者は組織の管理者であり、請求関連のすべてのメールを受信し、支払い方法を表示および管理できます。
請求管理者を変更するか、ロールを追加のユーザーに割り当てるには、次の手順に従います。
クレジットカードで支払う場合、このセクションでは毎月の請求書を表示できます。
チームのメンバー、アバター、アラート、プライバシー、利用状況などの設定を変更します。Organization の管理者と チーム の管理者は、チーム の設定を表示および編集できます。
「メンバー」セクションには、保留中の招待と、チームへの参加招待を承認したメンバーのリストが表示されます。リストに表示される各メンバーには、メンバーの名前、ユーザー名、メールアドレス、チームの役割、および Models と Weave へのアクセス権限が表示されます。これらは Organization から継承されます。標準のチームの役割 Admin 、 Member 、および View-only から選択できます。Organization がカスタムロールを作成している場合は、代わりにカスタムロールを割り当てることができます。
チームの作成方法、チームの管理方法、チームのメンバーシップと役割の管理方法については、チームの追加と管理を参照してください。誰が新しいメンバーを招待できるかを設定し、チームのその他のプライバシー設定を構成するには、プライバシーを参照してください。
アバターセクションに移動し、画像をアップロードしてアバターを設定します。
run がクラッシュ、完了、またはカスタムアラートを設定したときに、チームに通知します。チームは、メールまたは Slack でアラートを受信できます。
アラートを受信するイベントタイプの横にあるスイッチを切り替えます。Weights and Biases は、デフォルトで次のイベントタイプのオプションを提供します。
アラートの設定と管理方法の詳細については、wandb.alert でアラートを送信を参照してください。
チームの Automations が、新しい Artifact が作成されたときや、run メトリクスが定義されたしきい値を満たしたときなど、Registry または プロジェクト でイベントが発生したときに通知を送信できる Slack の送信先を設定します。Slack オートメーションの作成を参照してください。
This feature is available for all Enterprise licenses.
チームの Automations が、新しい Artifact が作成されたときや、run メトリクスが定義されたしきい値を満たしたときなど、Registry または プロジェクト でイベントが発生したときに実行できる Webhook を設定します。Webhook オートメーションの作成を参照してください。
This feature is available for all Enterprise licenses.
プライバシーセクションに移動して、プライバシー設定を変更します。プライバシー設定を変更できるのは、Organization の管理者のみです。
利用状況セクションでは、チームが Weights and Biases サーバーで使用した総メモリ使用量について説明します。デフォルトのストレージプランは 100GB です。ストレージと価格の詳細については、価格ページを参照してください。
ストレージセクションでは、チームの データ に使用されている クラウド ストレージ バケットの設定について説明します。詳細については、セキュアストレージコネクタを参照するか、セルフホスティングの場合は W&B Server のドキュメントを確認してください。
W&B プロフィールの 設定 ページで、メールの種類やプライマリ メール アドレスの追加、削除、管理ができます。W&B ダッシュボード の右上にあるプロフィール アイコンを選択します。ドロップダウンから、設定 を選択します。設定 ページ内で、Emails ダッシュボード までスクロールします。
プライマリ メール は 😎 の絵文字でマークされています。プライマリ メール は、W&B アカウント を作成した際に提供したメール アドレスで自動的に定義されます。
ケバブ ドロップダウンを選択して、Weights And Biases アカウント に関連付けられたプライマリ メール を変更します。
+ Add Email を選択して、メール を追加します。これにより、Auth0 ページに移動します。新しいメール の認証情報を入力するか、シングル サインオン (SSO) を使用して接続できます。
ケバブ ドロップダウンを選択し、Delete Emails を選択して、W&B アカウント に登録されているメール を削除します。
[ログイン 方法] 列には、アカウント に関連付けられているログイン 方法が表示されます。
W&B アカウント を作成すると、確認メール がメール アカウント に送信されます。メール アカウント は、メール アドレス を確認するまで検証されていないと見なされます。未検証のメール は赤で表示されます。
メール アドレス で再度ログインして、メール アカウント に送信された最初の確認メール が既になくても、2 通目の確認メール を取得してみてください。
アカウント ログイン の問題については、support@wandb.com までお問い合わせください。
W&B Teams を、より優れたモデルをより迅速に構築するための ML チーム用の一元的なワークスペースとして使用します。
チームのプロファイルページをカスタマイズして、イントロダクションを表示したり、一般公開またはチームメンバーに公開されている Reports と Projects を紹介したりできます。 Reports 、 Projects 、および外部リンクを提示します。
チーム管理者は、チームの設定ページを開き、退職するメンバーの名前の横にある削除ボタンをクリックできます。 run は、ユーザーが退席した後もチームに記録されたままになります。
同僚をチームに招待するときに、チームの役割を選択します。次のチームの役割オプションがあります。
チームメンバーは、自分が作成した run のみ削除できます。メンバー A と B がいるとします。メンバー B は、 run をチーム B の Project からメンバー A が所有する別の Project に移動します。メンバー A は、メンバー B がメンバー A の Project に移動した run を削除できません。管理者は、チームメンバーが作成した Runs と Sweep Runs を管理できます。
チーム設定を使用すると、チームとそのメンバーの設定を管理できます。これらの権限を使用すると、W&B 内でチームを効果的に監督および整理できます。
| 権限 | 表示のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| チームメンバーを追加する | X | ||
| チームメンバーを削除する | X | ||
| チーム設定を管理する | X |
次の表に、特定のチームのすべての Projects に適用される権限を示します。
| 権限 | 表示のみ | チームメンバー | レジストリ管理者 | チーム管理者 |
|---|---|---|---|---|
| エイリアスを追加する | X | X | X | |
| モデルをレジストリに追加する | X | X | X | |
| レジストリでモデルを表示する | X | X | X | X |
| モデルをダウンロードする | X | X | X | X |
| レジストリ管理者を追加または削除する | X | X | ||
| 保護されたエイリアスを追加または削除する | X |
保護されたエイリアスの詳細については、レジストリアクセス制御を参照してください。
Report 権限は、 Reports を作成、表示、および編集するためのアクセスを許可します。次の表に、特定のチームのすべての Reports に適用される権限を示します。
| 権限 | 表示のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| Reports を表示する | X | X | X |
| Reports を作成する | X | X | |
| Reports を編集する | X （チームメンバーは自分の Reports のみ編集できます） | X | |
| Reports を削除する | X （チームメンバーは自分の Reports のみ編集できます） | X |
次の表に、特定のチームのすべての実験管理に適用される権限を示します。
| 権限 | 表示のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| 実験管理メタデータ（履歴メトリクス、システムメトリクス、ファイル、ログを含む）を表示する | X | X | X |
| 実験管理パネルとワークスペースを編集する | X | X | |
| 実験管理をログに記録する | X | X | |
| 実験管理を削除する | X （チームメンバーは自分が作成した実験管理のみ削除できます） | X | |
| 実験管理を停止する | X （チームメンバーは自分が作成した実験管理のみ停止できます） | X |
次の表に、特定のチームのすべての Artifacts に適用される権限を示します。
| 権限 | 表示のみ | チームメンバー | チーム管理者 |
|---|---|---|---|
| Artifacts を表示する | X | X | X |
| Artifacts を作成する | X | X | |
| Artifacts を削除する | X | X | |
| メタデータを編集する | X | X | |
| エイリアスを編集する | X | X | |
| エイリアスを削除する | X | X | |
| Artifacts をダウンロードする | X | X |
システム権限を使用して、チームとそのメンバーを作成および管理し、システム設定を調整します。これらの権限により、W&B インスタンスを効果的に管理および保守できます。
| 権限 | 表示のみ | チームメンバー | チーム管理者 | システム管理者 |
|---|---|---|---|---|
| システム設定を構成する | X | |||
| チームを作成/削除する | X |
Open Project の可視性に設定されている場合にのみ、 Runs を Project に記録できます。W&B のプランの詳細については、価格ページを参照してください。ダッシュボード UI またはエクスポート APIを使用して、いつでもすべてのデータをダウンロードできます。
チーム設定ページで、すべてのチーム Project のプライバシー設定を確認できます。
app.wandb.ai/teams/your-team-name
チームレベルのセキュアストレージコネクタを使用すると、チームは W&B で独自のクラウドストレージバケットを使用できます。これにより、機密性の高いデータや厳格なコンプライアンス要件を持つチームに対して、より優れたデータアクセス制御とデータ分離が提供されます。詳細については、セキュアストレージコネクタを参照してください。
ストレージ制限に近づいている、または超過している場合、データを管理するための複数の方法があります。最適な方法は、アカウントの種類と現在のプロジェクトの設定によって異なります。
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) で表します。 Disk In と同様に、最初のサンプルが取得されると、最初のディスク書き込みバイト数が記録されます。後続のサンプルでは、現在の書き込みバイト数と初期値の差が計算されます。
W&B は、このメトリクスに disk.out タグを割り当てます。
プロセスのメモリ常駐セットサイズ (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 の GPU 温度を摂氏で示します。
W&B は、このメトリクスに gpu.{gpu_index}.temp タグを割り当てます。
各 GPU の GPU 消費電力をワット単位で示します。
W&B は、このメトリクスに gpu.{gpu_index}.powerWatts タグを割り当てます。
各 GPU の電力容量に対する 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 形式がサポートされています。ROCm 形式の詳細については、AMD ROCm ドキュメント を参照してください。新しい形式には、より詳細な情報が含まれています。
各 AMD GPU デバイスの GPU 使用率をパーセントで表します。
W&B は、このメトリクスに gpu.{gpu_index}.gpu タグを割り当てます。
各 AMD GPU デバイスの利用可能な合計メモリに対する GPU 割り当て済みメモリをパーセンテージで示します。
W&B は、このメトリクスに gpu.{gpu_index}.memoryAllocated タグを割り当てます。
各 AMD GPU デバイスの GPU 温度を摂氏で示します。
W&B は、このメトリクスに gpu.{gpu_index}.temp タグを割り当てます。
各 AMD GPU デバイスの GPU 消費電力をワット単位で示します。
W&B は、このメトリクスに gpu.{gpu_index}.powerWatts タグを割り当てます。
各 AMD GPU デバイスの電力容量に対する 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 デバイスの GPU 温度を摂氏で示します。
W&B は、このメトリクスに gpu.0.temp タグを割り当てます。
ARM Mac 上の Apple GPU デバイスの GPU 消費電力をワット単位で示します。
W&B は、このメトリクスに gpu.0.powerWatts タグを割り当てます。
ARM Mac 上の Apple GPU デバイスの電力容量に対する GPU 消費電力をパーセンテージで示します。
W&B は、このメトリクスに gpu.0.powerPercent タグを割り当てます。
Graphcore IPU (Intelligence Processing Units) は、機械学習タスク専用に設計された独自のハードウェアアクセラレータです。
これらのメトリクスは、特定の 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)): データ伝送速度 (ギガ転送/秒)。Tensor Processing Units (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 メトリクスをキャプチャするために使用されます。
NeuronCore ごとの使用率 (%) (コアごとに報告)。
W&B は、このメトリクスに trn.{core_index}.neuroncore_utilization タグを割り当てます。
ホスト上の合計メモリ消費量 (バイト単位)。
W&B は、このメトリクスに trn.host_total_memory_usage タグを割り当てます。
Neuron デバイス上の合計メモリ使用量 (バイト単位)。
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): テンソルに使用されるメモリ。NeuronCore ごとの詳細なメモリ使用量情報:
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 で Artifacts を作成およびログに記録する方法を示しています。
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()
ノートブックの例を試して、匿名モードの動作を確認してください。