これは、このセクションの複数ページの印刷可能なビューです。 印刷するには、ここをクリックしてください.
W&B Core は、W&B Models と W&B Weave をサポートする基盤となる フレームワーク であり、それ自体が W&B Platform によってサポートされています。
W&B Core は、ML ライフサイクル全体にわたる機能を提供します。W&B Core を使用すると、次のことができます。
W&B Artifacts を使用して、W&B Runs の入力および出力としてデータを追跡およびバージョン管理します。たとえば、モデルトレーニング run は、データセットを入力として受け取り、トレーニング済みのモデルを出力として生成する場合があります。ハイパー パラメーター、メタデータ、およびメトリクスを run に記録できます。また、artifact を使用して、モデルのトレーニングに使用されるデータセットを入力として、結果のモデル チェックポイントを別の artifact として、ログ記録、追跡、およびバージョン管理できます。
Artifact は、runs の入力および出力として、ML ワークフロー全体で使用できます。データセット、モデル、またはその他の artifact を、処理の入力として使用できます。
| ユースケース | 入力 | 出力 |
|---|---|---|
| モデルトレーニング | データセット (トレーニングおよび検証データ) | トレーニング済みモデル |
| データセットの前処理 | データセット (未加工データ) | データセット (前処理済みデータ) |
| モデルの評価 | モデル + データセット (テストデータ) | W&B Table |
| モデルの最適化 | モデル | 最適化されたモデル |
4 行のコードで artifact を作成します。
wandb.Artifact API を使用して、artifact オブジェクトを作成します。たとえば、次のコード スニペットは、dataset.h5 というファイルを example_artifact という artifact に記録する方法を示しています。
import wandb
run = wandb.init(project="artifacts-example", job_type="add-dataset")
artifact = wandb.Artifact(name="example_artifact", type="dataset")
artifact.add_file(local_path="./dataset.h5", name="training_dataset")
artifact.save()
# artifact バージョン "my_data" を dataset.h5 のデータを持つデータセットとして記録します
use_artifact メソッドを使用して、run への入力としてマークする artifact を示します。
上記のコード スニペットに従って、次のコード ブロックは training_dataset artifact の使用方法を示しています。
artifact = run.use_artifact(
"training_dataset:latest"
) # "my_data" artifact を使用して run オブジェクトを返します
これにより、artifact オブジェクトが返されます。
次に、返されたオブジェクトを使用して、artifact のすべてのコンテンツをダウンロードします。
datadir = (
artifact.download()
) # `my_data` artifact 全体をデフォルトのディレクトリーにダウンロードします。
root parameter に渡して、artifact を特定のディレクトリーにダウンロードできます。artifact をダウンロードする別の方法、および追加のパラメータについては、artifact のダウンロードと使用 のガイドを参照してください。W&B Python SDK を使用して、W&B Runs から Artifacts を構築します。ファイル、ディレクトリー、URI、および並列 run からのファイルを Artifacts に追加できます。ファイルを Artifacts に追加したら、Artifacts を W&B サーバーまたは独自のプライベートサーバーに保存します。
Amazon S3 に保存されているファイルなど、外部ファイルを追跡する方法については、外部ファイルを追跡のページを参照してください。
W&B Artifactは、次の3つのステップで構築します。
wandb.Artifact() で Artifacts Python オブジェクトを作成するwandb.Artifact() クラスを初期化して、Artifacts オブジェクトを作成します。次の パラメータ を指定します。
'dataset' または 'model' があります。指定する「name」と「type」は、有向非巡回グラフの作成に使用されます。つまり、W&B App で Artifacts の リネージ を表示できます。
詳細については、Artifacts グラフを探索およびトラバースを参照してください。
dataset の cats という名前の Artifacts と、タイプ model の同じ名前の別の Artifacts を作成することはできません。Artifacts オブジェクトを初期化するときに、オプションで説明と メタデータ を指定できます。利用可能な属性と パラメータ の詳細については、Python SDK リファレンス ガイドの wandb.Artifact クラス定義を参照してください。
次の例は、データセット Artifacts を作成する方法を示しています。
import wandb
artifact = wandb.Artifact(name="<replace>", type="<replace>")
上記の コードスニペット の文字列 引数 を、自分の名前とタイプに置き換えます。
Artifacts メソッド を使用して、ファイル、ディレクトリー、外部 URI 参照 (Amazon S3 など) などを追加します。たとえば、単一のテキスト ファイルを追加するには、add_file メソッド を使用します。
artifact.add_file(local_path="hello_world.txt", name="optional-name")
add_dir メソッド を使用して、複数のファイルを追加することもできます。ファイルを追加する方法の詳細については、Artifacts を更新を参照してください。
最後に、Artifacts を W&B サーバー に保存します。Artifacts は run に関連付けられています。したがって、run オブジェクト の log_artifact() メソッド を使用して、Artifacts を保存します。
# W&B Run を作成します。'job-type' を置き換えます。
run = wandb.init(project="artifacts-example", job_type="job-type")
run.log_artifact(artifact)
オプションで、W&B run の外部で Artifacts を構築できます。詳細については、外部ファイルを追跡を参照してください。
log_artifact の呼び出しは、パフォーマンスの高いアップロードのために非同期的に実行されます。これにより、ループで Artifacts を ログ 記録するときに、予期しない 振る舞い が発生する可能性があります。次に例を示します。
for i in range(10):
a = wandb.Artifact(
"race",
type="dataset",
metadata={
"index": i,
},
)
# ... Artifacts a にファイルを追加 ...
run.log_artifact(a)
Artifacts バージョン v0 は、Artifacts が任意の順序で ログ 記録される可能性があるため、 メタデータ に 0 のインデックスを持つことは保証されません。
次のセクションでは、さまざまなファイル タイプ と並列 run から Artifacts を構築する方法について説明します。
次の例では、複数のファイルとディレクトリー構造を持つ プロジェクト ディレクトリー があると仮定します。
project-directory
|-- images
| |-- cat.png
| +-- dog.png
|-- checkpoints
| +-- model.h5
+-- model.h5
上記の コードスニペット は、単一のローカル ファイルを Artifacts に追加する方法を示しています。
# 単一のファイルを追加
artifact.add_file(local_path="path/file.format")
たとえば、作業ローカル ディレクトリー に 'file.txt' という名前のファイルがあるとします。
artifact.add_file("path/file.txt") # `file.txt' として追加されました
Artifacts には、次のコンテンツが含まれるようになりました。
file.txt
オプションで、name パラメータ に Artifacts 内の目的の パス を渡します。
artifact.add_file(local_path="path/file.format", name="new/path/file.format")
Artifacts は次のように保存されます。
new/path/file.txt
| API 呼び出し | 結果の Artifacts |
|---|---|
artifact.add_file('model.h5') |
model.h5 |
artifact.add_file('checkpoints/model.h5') |
model.h5 |
artifact.add_file('model.h5', name='models/mymodel.h5') |
models/mymodel.h5 |
上記の コードスニペット は、ローカル ディレクトリー 全体を Artifacts に追加する方法を示しています。
# ディレクトリー を再帰的に追加
artifact.add_dir(local_path="path/file.format", name="optional-prefix")
上記の API 呼び出しは、上記の Artifacts コンテンツを生成します。
| API 呼び出し | 結果の Artifacts |
|---|---|
artifact.add_dir('images') |
|
artifact.add_dir('images', name='images') |
|
artifact.new_file('hello.txt') |
hello.txt |
Artifacts は、W&B ライブラリ が処理する方法を知っている スキーム を URI が持つ場合、再現性のために チェックサム やその他の情報を追跡します。
add_reference メソッド を使用して、外部 URI 参照を Artifacts に追加します。'uri' 文字列を自分の URI に置き換えます。オプションで、name パラメータ に Artifacts 内の目的の パス を渡します。
# URI 参照を追加
artifact.add_reference(uri="uri", name="optional-name")
Artifacts は現在、次の URI スキーム をサポートしています。
http(s)://: HTTP 経由でアクセス可能なファイルへの パス 。Artifacts は、HTTP サーバー が ETag および Content-Length レスポンス ヘッダー をサポートしている場合、etag および サイズ メタデータ の形式で チェックサム を追跡します。s3://: S3 内の オブジェクト または オブジェクト プレフィックス への パス 。Artifacts は、参照されている オブジェクト の チェックサム および バージョン 管理情報 ( バケット で オブジェクト の バージョン 管理が有効になっている場合) を追跡します。オブジェクト プレフィックス は、プレフィックス の下の オブジェクト を含むように拡張され、最大 10,000 個の オブジェクト が含まれます。gs://: GCS 内の オブジェクト または オブジェクト プレフィックス への パス 。Artifacts は、参照されている オブジェクト の チェックサム および バージョン 管理情報 ( バケット で オブジェクト の バージョン 管理が有効になっている場合) を追跡します。オブジェクト プレフィックス は、プレフィックス の下の オブジェクト を含むように拡張され、最大 10,000 個の オブジェクト が含まれます。上記の API 呼び出しは、上記の Artifacts を生成します。
| API 呼び出し | 結果の Artifacts コンテンツ |
|---|---|
artifact.add_reference('s3://my-bucket/model.h5') |
model.h5 |
artifact.add_reference('s3://my-bucket/checkpoints/model.h5') |
model.h5 |
artifact.add_reference('s3://my-bucket/model.h5', name='models/mymodel.h5') |
models/mymodel.h5 |
artifact.add_reference('s3://my-bucket/images') |
|
artifact.add_reference('s3://my-bucket/images', name='images') |
|
大規模な データセット または分散 トレーニング の場合、複数の並列 run が単一の Artifacts に貢献する必要がある場合があります。
import wandb
import time
# デモ の目的で、ray を使用して並列で run を 起動 します。
# ただし、並列 run は、どのように編成してもかまいません。
import ray
ray.init()
artifact_type = "dataset"
artifact_name = "parallel-artifact"
table_name = "distributed_table"
parts_path = "parts"
num_parallel = 5
# 並列 ライター の各 バッチ には、独自の
# 一意の グループ 名が必要です。
group_name = "writer-group-{}".format(round(time.time()))
@ray.remote
def train(i):
"""
ライター ジョブ 。各 ライター は、1つの画像を Artifacts に追加します。
"""
with wandb.init(group=group_name) as run:
artifact = wandb.Artifact(name=artifact_name, type=artifact_type)
# データを wandb テーブル に追加します。この場合、サンプル データ を使用します
table = wandb.Table(columns=["a", "b", "c"], data=[[i, i * 2, 2**i]])
# テーブル を Artifacts 内の フォルダ に追加します
artifact.add(table, "{}/table_{}".format(parts_path, i))
# Artifacts を アップサート すると、Artifacts のデータ が作成または追加されます
run.upsert_artifact(artifact)
# 並列で run を 起動 します
result_ids = [train.remote(i) for i in range(num_parallel)]
# すべての ライター に 参加 して、ファイル が
# Artifacts を終了する前に追加されていることを確認します。
ray.get(result_ids)
# すべての ライター が終了したら、Artifacts を終了して、
# 準備完了にします。
with wandb.init(group=group_name) as run:
artifact = wandb.Artifact(artifact_name, type=artifact_type)
# テーブル の フォルダ を指す "PartitionTable" を作成します
# Artifacts に追加します。
artifact.add(wandb.data_types.PartitionedTable(parts_path), table_name)
# Finish artifact は Artifacts を確定し、この バージョン への将来の "upsert" を許可しません
run.finish_artifact(artifact)
W&B サーバーにすでに保存されている Artifacts をダウンロードして使用するか、必要に応じて重複排除のために Artifacts オブジェクトを構築して渡します。
W&B Run の内部または外部で、W&B に保存されている Artifacts をダウンロードして使用します。Public API (wandb.Api) を使用して、W&B にすでに保存されているデータをエクスポート (または更新) します。詳細については、W&B のPublic API Reference guideを参照してください。
まず、W&B Python SDK をインポートします。次に、W&B Runを作成します。
import wandb
run = wandb.init(project="<example>", job_type="<job-type>")
use_artifact メソッドを使用して、使用する Artifacts を指定します。これにより、run オブジェクトが返されます。次のコードスニペットでは、エイリアス 'latest' を持つ 'bike-dataset' という Artifacts を指定します。
artifact = run.use_artifact("bike-dataset:latest")
返されたオブジェクトを使用して、Artifacts のすべてのコンテンツをダウンロードします。
datadir = artifact.download()
オプションで、ルートパラメータにパスを渡して、Artifacts のコンテンツを特定のディレクトリーにダウンロードできます。詳細については、Python SDK Reference Guideを参照してください。
get_path メソッドを使用して、ファイルのサブセットのみをダウンロードします。
path = artifact.get_path(name)
これは、パス name にあるファイルのみをフェッチします。これは、次のメソッドを持つ Entry オブジェクトを返します。
Entry.download: パス name にある Artifacts からファイルをダウンロードしますEntry.ref: add_reference がエントリをリファレンスとして保存した場合、URI を返しますW&B が処理する方法を知っているスキームを持つリファレンスは、Artifacts ファイルとまったく同じようにダウンロードされます。詳細については、Track external filesを参照してください。
まず、W&B SDK をインポートします。次に、Public API クラスから Artifacts を作成します。その Artifacts に関連付けられたエンティティ、プロジェクト、Artifacts、エイリアスを指定します。
import wandb
api = wandb.Api()
artifact = api.artifact("entity/project/artifact:alias")
返されたオブジェクトを使用して、Artifacts のコンテンツをダウンロードします。
artifact.download()
オプションで、root パラメータにパスを渡して、Artifacts のコンテンツを特定のディレクトリーにダウンロードできます。詳細については、API Reference Guideを参照してください。
wandb artifact get コマンドを使用して、W&B サーバーから Artifacts をダウンロードします。
$ wandb artifact get project/artifact:alias --root mnist/
オプションで、プレフィックスに基づいて Artifacts の一部をダウンロードできます。path_prefix パラメータを使用すると、単一のファイルまたはサブフォルダーのコンテンツをダウンロードできます。
artifact = run.use_artifact("bike-dataset:latest")
artifact.download(path_prefix="bike.png") # bike.png のみをダウンロードします
または、特定のディレクトリーからファイルをダウンロードすることもできます。
artifact.download(path_prefix="images/bikes/") # images/bikes ディレクトリー内のファイルをダウンロードします
Artifacts の名前をプロジェクト名とともに指定して、Artifacts を参照します。エンティティ名とともに Artifacts の名前を指定することで、エンティティ間で Artifacts を参照することもできます。
次のコード例は、別のプロジェクトから Artifacts をクエリして、現在の W&B run への入力として使用する方法を示しています。
import wandb
run = wandb.init(project="<example>", job_type="<job-type>")
# 別のプロジェクトから Artifacts の W&B をクエリして、それをマークします
# この run への入力として。
artifact = run.use_artifact("my-project/artifact:alias")
# 別のエンティティからの Artifacts を使用して、入力としてマークします
# この run に。
artifact = run.use_artifact("my-entity/my-project/artifact:alias")
Artifacts を同時に構築して使用します。Artifacts オブジェクトを作成し、それを use_artifact に渡します。これにより、Artifacts がまだ存在しない場合は W&B に作成されます。use_artifact API はべき等であるため、必要な回数だけ呼び出すことができます。
import wandb
artifact = wandb.Artifact("reference model")
artifact.add_file("model.h5")
run.use_artifact(artifact)
Artifacts の構築の詳細については、Construct an artifactを参照してください。
Artifact の description、metadata、および alias を更新するために希望する value を渡します。W&B サーバー上の Artifact を更新するには、save() メソッドを呼び出します。W&B の Run 中または Run の外部で Artifact を更新できます。
Run の外部で Artifact を更新するには、W&B Public API（wandb.Api）を使用します。Run 中に Artifact を更新するには、Artifact API（wandb.Artifact）を使用します。
次のコード例は、wandb.Artifact API を使用して、Artifact の description を更新する方法を示しています。
import wandb
run = wandb.init(project="<example>")
artifact = run.use_artifact("<artifact-name>:<alias>")
artifact.description = "<description>"
artifact.save()
次のコード例は、wandb.Api API を使用して、Artifact の description を更新する方法を示しています。
import wandb
api = wandb.Api()
artifact = api.artifact("entity/project/artifact:alias")
# description を更新
artifact.description = "My new description"
# 選択的に metadata の キー を更新
artifact.metadata["oldKey"] = "new value"
# metadata を完全に置き換え
artifact.metadata = {"newKey": "new value"}
# エイリアス を追加
artifact.aliases.append("best")
# エイリアス を削除
artifact.aliases.remove("latest")
# エイリアス を完全に置き換え
artifact.aliases = ["replaced"]
# すべての Artifact の変更を永続化
artifact.save()
詳細については、Weights and Biases Artifact API を参照してください。
単一の Artifact と同じ方法で、Artifact のコレクションを更新することもできます。
import wandb
run = wandb.init(project="<example>")
api = wandb.Api()
artifact = api.artifact_collection(type="<type-name>", collection="<collection-name>")
artifact.name = "<new-collection-name>"
artifact.description = "<This is where you'd describe the purpose of your collection.>"
artifact.save()
詳細については、Artifacts Collection のリファレンスを参照してください。
エイリアス を使用して、特定の バージョン へのポインタとして使用します。デフォルトでは、Run.log_artifact はログに記録された バージョン に latest エイリアス を追加します。
アーティファクト の バージョン v0 は、初めて アーティファクト を ログ に記録する際に作成され、 アーティファクト にアタッチされます。W&B は、同じ アーティファクト に再度 ログ を記録する際に、コンテンツの チェックサム を計算します。アーティファクト が変更された場合、W&B は新しい バージョン v1 を保存します。
たとえば、 トレーニング スクリプト で データセット の最新 バージョン を取得したい場合は、その アーティファクト を使用する際に latest を指定します。次の コード 例は、latest という エイリアス を持つ bike-dataset という名前の最新の データセット アーティファクト をダウンロードする方法を示しています。
import wandb
run = wandb.init(project="<example-project>")
artifact = run.use_artifact("bike-dataset:latest")
artifact.download()
カスタム エイリアス を アーティファクト バージョン に適用することもできます。たとえば、 モデル の チェックポイント が メトリック AP-50 で最高であることを示したい場合は、 モデル アーティファクト を ログ に記録する際に、'best-ap50' という 文字列を エイリアス として追加できます。
artifact = wandb.Artifact("run-3nq3ctyy-bike-model", type="model")
artifact.add_file("model.h5")
run.log_artifact(artifact, aliases=["latest", "best-ap50"])
単一の run で、または分散されたrunと共同で、新しいアーティファクトのバージョンを作成します。オプションで、インクリメンタルアーティファクト として知られる、以前のバージョンから新しいアーティファクトのバージョンを作成できます。
新しいアーティファクトのバージョンを作成する方法は2つあります。単一のrunから作成する方法と、分散されたrunから作成する方法です。それらは次のように定義されます。
W&B は、プロジェクトに存在しない名前を wandb.Artifact API に渡すと、新しいアーティファクトを作成し、v0 エイリアスを割り当てます。同じアーティファクトに再度ログを記録すると、W&B はコンテンツのチェックサムを計算します。アーティファクトが変更された場合、W&B は新しいバージョン v1 を保存します。
wandb.Artifact API に名前とアーティファクトのタイプを渡し、それがプロジェクト内の既存のアーティファクトと一致する場合、W&B は既存のアーティファクトを取得します。取得されたアーティファクトのバージョンは1より大きくなります。
アーティファクト内のすべてのファイルを生成する単一のrunで、Artifactの新しいバージョンをログに記録します。このケースは、単一のrunがアーティファクト内のすべてのファイルを生成する場合に発生します。
ユースケースに基づいて、以下のタブのいずれかを選択して、runの内側または外側に新しいアーティファクトのバージョンを作成します。
W&B run内でアーティファクトのバージョンを作成します。
wandb.init でrunを作成します。wandb.Artifact で新しいアーティファクトを作成するか、既存のアーティファクトを取得します。.add_file でアーティファクトにファイルを追加します。.log_artifact でアーティファクトをrunにログ記録します。with wandb.init() as run:
artifact = wandb.Artifact("artifact_name", "artifact_type")
# `.add`、`.add_file`、`.add_dir`、および `.add_reference` を使用して、
# ファイルとアセットをアーティファクトに追加します
artifact.add_file("image1.png")
run.log_artifact(artifact)
W&B runの外側でアーティファクトのバージョンを作成します。
wanb.Artifact で新しいアーティファクトを作成するか、既存のアーティファクトを取得します。.add_file でアーティファクトにファイルを追加します。.save でアーティファクトを保存します。artifact = wandb.Artifact("artifact_name", "artifact_type")
# `.add`、`.add_file`、`.add_dir`、および `.add_reference` を使用して、
# ファイルとアセットをアーティファクトに追加します
artifact.add_file("image1.png")
artifact.save()
コミットする前に、runのコレクションがバージョンで共同作業できるようにします。これは、1つのrunが新しいバージョンのすべてのデータを提供する上記の単一runモードとは対照的です。
distributed_id と呼ばれます）を認識している必要があります。デフォルトでは、存在する場合、W&B は wandb.init(group=GROUP) によって設定されたrunの group を distributed_id として使用します。upsert_artifact を使用し、コミットを完了するには finish_artifact を使用します。次の例を検討してください。異なるrun（以下では Run 1、Run 2、および Run 3 としてラベル付け）は、upsert_artifact で同じアーティファクトに異なる画像ファイルを追加します。
with wandb.init() as run:
artifact = wandb.Artifact("artifact_name", "artifact_type")
# `.add`、`.add_file`、`.add_dir`、および `.add_reference` を使用して、
# ファイルとアセットをアーティファクトに追加します
artifact.add_file("image1.png")
run.upsert_artifact(artifact, distributed_id="my_dist_artifact")
with wandb.init() as run:
artifact = wandb.Artifact("artifact_name", "artifact_type")
# `.add`、`.add_file`、`.add_dir`、および `.add_reference` を使用して、
# ファイルとアセットをアーティファクトに追加します
artifact.add_file("image2.png")
run.upsert_artifact(artifact, distributed_id="my_dist_artifact")
Run 1とRun 2が完了した後に実行する必要があります。finish_artifact を呼び出すRunはアーティファクトにファイルを含めることができますが、必須ではありません。
with wandb.init() as run:
artifact = wandb.Artifact("artifact_name", "artifact_type")
# ファイルとアセットをアーティファクトに追加します
# `.add`、`.add_file`、`.add_dir`、および `.add_reference`
artifact.add_file("image3.png")
run.finish_artifact(artifact, distributed_id="my_dist_artifact")
変更されていないファイルを再インデックスする必要なく、以前のアーティファクトのバージョンからファイルのサブセットを追加、変更、または削除します。以前のアーティファクトのバージョンからファイルのサブセットを追加、変更、または削除すると、インクリメンタルアーティファクトとして知られる新しいアーティファクトのバージョンが作成されます。
発生する可能性のあるインクリメンタルな変更のタイプごとのシナリオを次に示します。
インクリメンタルアーティファクトと同じ機能を実行するために、アーティファクトをゼロから作成できます。ただし、アーティファクトをゼロから作成する場合、アーティファクトのすべてのコンテンツをローカルディスクに用意する必要があります。インクリメンタルな変更を行う場合、以前のアーティファクトのバージョンからファイルを変更せずに、単一のファイルを追加、削除、または変更できます。
以下の手順に従って、アーティファクトをインクリメンタルに変更します。
saved_artifact = run.use_artifact("my_artifact:latest")
client = wandb.Api()
saved_artifact = client.artifact("my_artifact:latest")
draft_artifact = saved_artifact.new_draft()
これらの変更を実行する方法の例については、以下のタブのいずれかを選択してください。
add_file メソッドを使用して、既存のアーティファクトのバージョンにファイルを追加します。
draft_artifact.add_file("file_to_add.txt")
add_dir メソッドを使用してディレクトリーを追加することで、複数のファイルを追加することもできます。remove メソッドを使用して、既存のアーティファクトのバージョンからファイルを削除します。
draft_artifact.remove("file_to_remove.txt")
remove メソッドを使用して複数のファイルを削除することもできます。ドラフトから古いコンテンツを削除し、新しいコンテンツを再度追加して、コンテンツを変更または置き換えます。
draft_artifact.remove("modified_file.txt")
draft_artifact.add_file("modified_file.txt")
run.log_artifact(draft_artifact)
draft_artifact.save()
まとめると、上記のコード例は次のようになります。
with wandb.init(job_type="データセットの変更") as run:
saved_artifact = run.use_artifact(
"my_artifact:latest"
) # アーティファクトをフェッチしてrunに入力します
draft_artifact = saved_artifact.new_draft() # ドラフトバージョンを作成します
# ドラフトバージョン内のファイルのサブセットを変更します
draft_artifact.add_file("file_to_add.txt")
draft_artifact.remove("dir_to_remove/")
run.log_artifact(
artifact
) # 変更をログに記録して新しいバージョンを作成し、runへの出力としてマークします
client = wandb.Api()
saved_artifact = client.artifact("my_artifact:latest") # アーティファクトをロードします
draft_artifact = saved_artifact.new_draft() # ドラフトバージョンを作成します
# ドラフトバージョン内のファイルのサブセットを変更します
draft_artifact.remove("deleted_file.txt")
draft_artifact.add_file("modified_file.txt")
draft_artifact.save() # ドラフトへの変更をコミットします
参照 Artifacts を使用して、W&Bシステム外に保存されたファイル（例えば、Amazon S3 バケット、GCS バケット、Azure Blob、HTTP ファイルサーバー、あるいは NFS 共有など）を追跡します。W&B CLIを使用し、W&B Runの外で Artifacts をログ記録します。
run の外で Artifact をログ記録すると、W&B は run を作成します。各 Artifact は run に属し、その run は プロジェクト に属します。Artifact（バージョン）はコレクションにも属し、タイプを持ちます。
wandb artifact put コマンドを使用すると、W&B run の外で Artifact を W&B サーバーにアップロードできます。Artifact が属する プロジェクト の名前と Artifact の名前（project/artifact_name）を指定します。オプションで、タイプ（TYPE）を指定します。以下のコードスニペットの PATH を、アップロードする Artifact のファイルパスに置き換えます。
$ wandb artifact put --name project/artifact_name --type TYPE PATH
指定した プロジェクト が存在しない場合、W&B は新しい プロジェクト を作成します。Artifact のダウンロード方法については、Artifacts のダウンロードと使用を参照してください。
W&B Artifacts を使用して、データセット の バージョン管理 と モデルリネージ を行い、参照 Artifacts を使用して W&B サーバーの外に保存されたファイルを追跡します。このモードでは、Artifact は URL、サイズ、チェックサムなどのファイルに関する メタデータ のみを保存します。基になる データ がシステムから離れることはありません。ファイルを W&B サーバーに保存する方法については、クイックスタートを参照してください。
以下では、参照 Artifacts を構築する方法と、ワークフロー に組み込む最適な方法について説明します。
W&B Artifacts を使用して、データセット と モデル の バージョン管理 を行い、クラウド ストレージ バケット内の参照を追跡します。Artifact の参照を使用すると、既存のストレージ レイアウトを変更することなく、シームレスに追跡を バケット の上に重ねることができます。
Artifacts は、基盤となるクラウド ストレージ ベンダー（AWS、GCP、Azure など）を抽象化します。以下のセクションで説明する情報は、Amazon S3、Google Cloud Storage、Azure Blob Storage に均一に適用されます。
AWS_S3_ENDPOINT_URL 環境変数 を MinIO サーバーを指すように設定すると、以下の スクリプト はそのまま動作します。次の構造の バケット があると仮定します。
s3://my-bucket
+-- datasets/
| +-- mnist/
+-- models/
+-- cnn/
mnist/ の下には、画像のコレクションである データセット があります。これを Artifact で追跡してみましょう。
import wandb
run = wandb.init()
artifact = wandb.Artifact("mnist", type="dataset")
artifact.add_reference("s3://my-bucket/datasets/mnist")
run.log_artifact(artifact)
add_reference の呼び出しで max_objects= を指定することで調整できます。新しい参照 Artifact mnist:latest は、通常の Artifact と同様に見え、動作します。唯一の違いは、Artifact が S3/GCS/Azure オブジェクト に関する メタデータ （ETag、サイズ、オブジェクト の バージョン管理 が バケット で有効になっている場合は バージョン ID など）のみで構成されていることです。
W&B は、使用している クラウド プロバイダー に基づいて、認証情報 を検索するためのデフォルトのメカニズムを使用します。使用する認証情報 の詳細については、 クラウド プロバイダー の ドキュメント を参照してください。
| クラウド プロバイダー | 認証情報 の ドキュメント |
|---|---|
| AWS | Boto3 documentation |
| GCP | Google Cloud documentation |
| Azure | Azure documentation |
AWS の場合、 バケット が設定された ユーザー のデフォルト リージョン にない場合は、AWS_REGION 環境変数 を バケット リージョン と一致するように設定する必要があります。
この Artifact は、通常の Artifact と同様に操作します。App UI では、ファイル ブラウザー を使用して参照 Artifact のコンテンツ を調べたり、完全な依存関係グラフ を調べたり、Artifact の バージョン管理 された履歴をスキャンしたりできます。
画像、オーディオ、ビデオ、ポイント クラウド などのリッチ メディア は、 バケット の CORS 設定によっては、App UI で レンダリング されない場合があります。 バケット の CORS 設定で app.wandb.ai のリストを許可すると、App UI でそのようなリッチ メディア を適切に レンダリング できます。
会社の VPN がある場合、プライベート バケット の パネル が App UI で レンダリング されない場合があります。VPN 内の IP を ホワイトリスト に登録するように バケット の アクセス ポリシー を更新できます。
import wandb
run = wandb.init()
artifact = run.use_artifact("mnist:latest", type="dataset")
artifact_dir = artifact.download()
W&B は、参照 Artifact をダウンロードする際に、Artifact がログ記録されたときに記録された メタデータ を使用して、基盤となる バケット からファイル を取得します。 バケット で オブジェクト の バージョン管理 が有効になっている場合、W&B は Artifact がログ記録された時点でのファイルの 状態 に対応する オブジェクト バージョン を取得します。これは、 バケット のコンテンツ を進化させても、特定の モデル がトレーニング された データの 正確な イテレーション を指すことができることを意味します。Artifact は トレーニング 時の バケット の スナップショット として機能するためです。
ワークフロー の一部としてファイルを上書きする場合は、ストレージ バケット で「オブジェクト の バージョン管理 」を有効にすることをお勧めします。 バケット で バージョン管理 が有効になっている場合、上書きされたファイルへの参照を持つ Artifacts は、古い オブジェクト バージョン が保持されるため、そのまま残ります。
ユースケース に基づいて、オブジェクト の バージョン管理 を有効にする 手順 を読んでください：AWS, GCP, Azure.
次のコード例は、Amazon S3、GCS、または Azure で データセット を追跡するために使用できる簡単な ワークフロー を示しています。
import wandb
run = wandb.init()
artifact = wandb.Artifact("mnist", type="dataset")
artifact.add_reference("s3://my-bucket/datasets/mnist")
# Artifact を追跡し、この run への入力としてマークします。
# バケット 内のファイル が変更された場合にのみ、新しい Artifact バージョン がログ記録されます。
run.use_artifact(artifact)
artifact_dir = artifact.download()
# ここで トレーニング を実行します...
モデル を追跡するために、 トレーニング スクリプト が モデル ファイル を バケット にアップロードした後、 モデル Artifact をログ記録できます。
import boto3
import wandb
run = wandb.init()
# トレーニング はこちら...
s3_client = boto3.client("s3")
s3_client.upload_file("my_model.h5", "my-bucket", "models/cnn/my_model.h5")
model_artifact = wandb.Artifact("cnn", type="model")
model_artifact.add_reference("s3://my-bucket/models/cnn/")
run.log_artifact(model_artifact)
GCP または Azure の参照によって Artifacts を追跡する方法のエンドツーエンド の チュートリアル については、次の レポート を参照してください。
データセット に 高速 に アクセス するためのもう 1 つの一般的なパターンは、すべての トレーニング ジョブ を実行しているマシンでリモート ファイルシステム に NFS マウント ポイント を公開することです。トレーニング スクリプト の観点から見ると、ファイル がローカル ファイルシステム にあるように見えるため、これは クラウド ストレージ バケット よりもさらに簡単なソリューションになる可能性があります。幸いなことに、その使いやすさは、ファイルシステム への参照を追跡するために Artifacts を使用することにも拡張されます（マウントされているかどうかに関係なく）。
次の構造のファイルシステム が /mount にマウントされていると仮定します。
mount
+-- datasets/
| +-- mnist/
+-- models/
+-- cnn/
mnist/ の下には、画像のコレクションである データセット があります。これを Artifact で追跡してみましょう。
import wandb
run = wandb.init()
artifact = wandb.Artifact("mnist", type="dataset")
artifact.add_reference("file:///mount/datasets/mnist/")
run.log_artifact(artifact)
デフォルトでは、W&B は ディレクトリー への参照を追加する際に 10,000 ファイル の制限を課します。この制限は、add_reference の呼び出しで max_objects= を指定することで調整できます。
URL には 3 つのスラッシュ があることに注意してください。最初のコンポーネント は、ファイルシステム 参照の使用を示す file:// プレフィックス です。2 番目のコンポーネント は、 データセット へのパス /mount/datasets/mnist/ です。
結果として得られる Artifact mnist:latest は、通常の Artifact と同じように見え、動作します。唯一の違いは、Artifact がファイル に関する メタデータ （サイズ や MD5 チェックサム など）のみで構成されていることです。ファイル 自体がシステムから離れることはありません。
この Artifact は、通常の Artifact と同じように操作できます。UI では、ファイル ブラウザー を使用して参照 Artifact のコンテンツ を参照したり、完全な依存関係グラフ を調べたり、Artifact の バージョン管理 された履歴をスキャンしたりできます。ただし、 データ 自体が Artifact に含まれていないため、UI は画像 やオーディオ などのリッチ メディア を レンダリング できません。
参照 Artifact のダウンロードは簡単です。
import wandb
run = wandb.init()
artifact = run.use_artifact("entity/project/mnist:latest", type="dataset")
artifact_dir = artifact.download()
ファイルシステム 参照の場合、download() 操作は参照されたパスからファイルをコピーして Artifact ディレクトリー を構築します。上記の例では、/mount/datasets/mnist のコンテンツ が ディレクトリー artifacts/mnist:v0/ にコピーされます。Artifact に上書きされたファイル への参照が含まれている場合、Artifact を再構築できなくなるため、download() は エラー をスローします。
すべてをまとめると、マウントされたファイルシステム の下にある データセット を追跡するために使用できる簡単な ワークフロー を次に示します。
import wandb
run = wandb.init()
artifact = wandb.Artifact("mnist", type="dataset")
artifact.add_reference("file:///mount/datasets/mnist/")
# Artifact を追跡し、この run への入力としてマークします。
# ディレクトリー の下のファイル が変更された場合にのみ、新しい Artifact バージョン がログ記録されます。
run.use_artifact(artifact)
artifact_dir = artifact.download()
# ここで トレーニング を実行します...
モデル を追跡するために、 トレーニング スクリプト が モデル ファイル をマウント ポイント に書き込んだ後、 モデル Artifact をログ記録できます。
import wandb
run = wandb.init()
# トレーニング はこちら...
# モデル を ディスク に書き込みます
model_artifact = wandb.Artifact("cnn", type="model")
model_artifact.add_reference("file:///mount/cnn/my_model.h5")
run.log_artifact(model_artifact)
App UIまたは W&B SDK を使用して、アーティファクトをインタラクティブに、またはプログラムで削除できます。アーティファクトを削除すると、W&B はそのアーティファクトを 論理削除 としてマークします。つまり、アーティファクトは削除対象としてマークされますが、ファイルはストレージからすぐに削除されるわけではありません。
アーティファクトの内容は、論理削除、つまり削除保留状態のままとなり、定期的に実行されるガベージコレクション プロセスが、削除対象としてマークされたすべてのアーティファクトを確認します。ガベージコレクション プロセスは、アーティファクトとその関連ファイルが、以前または以降のアーティファクト バージョンで使用されていない場合、ストレージから関連ファイルを削除します。
このページのセクションでは、特定のアーティファクト バージョンを削除する方法、アーティファクト コレクションを削除する方法、エイリアスを使用または使用せずにアーティファクトを削除する方法などについて説明します。アーティファクトが W&B から削除されるタイミングは、TTL ポリシーでスケジュールできます。詳細については、アーティファクト TTL ポリシーによるデータ保持の管理 を参照してください。
アーティファクト バージョンを削除するには:
アーティファクト バージョンは、delete() メソッドを使用してプログラムで削除することもできます。以下の例を参照してください。
次のコード例は、エイリアスが関連付けられているアーティファクトを削除する方法を示しています。アーティファクトを作成したエンティティ、プロジェクト名、run ID を指定します。
import wandb
run = api.run("entity/project/run_id")
for artifact in run.logged_artifacts():
artifact.delete()
アーティファクトに1つ以上のエイリアスがある場合にエイリアスを削除するには、delete_aliases パラメータをブール値 True に設定します。
import wandb
run = api.run("entity/project/run_id")
for artifact in run.logged_artifacts():
# 1つ以上エイリアスを持つ
# アーティファクトを削除するには
# delete_aliases=True を設定します
artifact.delete(delete_aliases=True)
次のコードは、特定のエイリアスを持つ複数のアーティファクト バージョンを削除する方法を示しています。アーティファクトを作成したエンティティ、プロジェクト名、run ID を指定します。削除ロジックを独自のものに置き換えます。
import wandb
runs = api.run("entity/project_name/run_id")
# エイリアス 'v3' と 'v4' を持つアーティファクトを削除します
for artifact_version in runs.logged_artifacts():
# 独自の削除ロジックに置き換えます。
if artifact_version.name[-2:] == "v3" or artifact_version.name[-2:] == "v4":
artifact.delete(delete_aliases=True)
次のコードスニペットは、エイリアスを持たないアーティファクトのすべてのバージョンを削除する方法を示しています。wandb.Api の project および entity キーに、プロジェクトとエンティティの名前をそれぞれ指定します。<> をアーティファクトの名前に置き換えます。
import wandb
# wandb.Api メソッドを使用する場合は、
# エンティティとプロジェクト名を指定してください。
api = wandb.Api(overrides={"project": "project", "entity": "entity"})
artifact_type, artifact_name = "<>" # タイプと名前を指定
for v in api.artifact_versions(artifact_type, artifact_name):
# 'latest' などのエイリアスを持たないバージョンをクリーンアップします。
# 注: ここには、必要な削除ロジックを入れることができます。
if len(v.aliases) == 0:
v.delete()
アーティファクト コレクションを削除するには:
delete() メソッドを使用して、プログラムでアーティファクト コレクションを削除することもできます。wandb.Api の project および entity キーに、プロジェクトとエンティティの名前をそれぞれ指定します。
import wandb
# wandb.Api メソッドを使用する場合は、
# エンティティとプロジェクト名を指定してください。
api = wandb.Api(overrides={"project": "project", "entity": "entity"})
collection = api.artifact_collection(
"<artifact_type>", "entity/project/artifact_collection_name"
)
collection.delete()
W&B の共有クラウドを使用している場合、ガベージコレクションはデフォルトで有効になっています。W&B のホスト方法によっては、ガベージコレクションを有効にするために追加の手順が必要になる場合があります。これには以下が含まれます。
GORILLA_ARTIFACT_GC_ENABLED 環境変数を true に設定します: GORILLA_ARTIFACT_GC_ENABLED=true次の表は、デプロイメントの種類に基づいてガベージコレクションを有効にするための要件を満たす方法を示しています。
X は、要件を満たす必要があることを示します。
| 環境変数 | バージョン管理を有効にする | |
|---|---|---|
| 共有クラウド | ||
| セキュア ストレージ コネクタ を使用した共有クラウド | X | |
| 専用クラウド | ||
| セキュア ストレージ コネクタ を使用した専用クラウド | X | |
| 顧客管理クラウド | X | X |
| 顧客管理オンプレミス | X | X |
W&B Artifact time-to-live（TTL）ポリシーを使用して、Artifacts が W&B から削除されるタイミングをスケジュールします。アーティファクトを削除すると、W&B はそのアーティファクトを ソフト削除 としてマークします。つまり、アーティファクトは削除対象としてマークされますが、ファイルはストレージからすぐに削除されるわけではありません。W&B が Artifacts を削除する方法の詳細については、Artifacts の削除 ページを参照してください。
W&B アプリで Artifacts TTL を使用してデータ保持を管理する方法については、こちらのビデオチュートリアルをご覧ください。
ユーザーが生成した Artifacts のみ、TTL ポリシーを使用できます。W&B によって自動生成された Artifacts は、TTL ポリシーを設定できません。
次の Artifact の種類は、自動生成された Artifact を示します。
run_tablecodejobwandb-* で始まる任意の Artifact の種類W&B プラットフォームで、またはプログラムで Artifact の種類を確認できます。
import wandb
run = wandb.init(project="<my-project-name>")
artifact = run.use_artifact(artifact_or_name="<my-artifact-name>")
print(artifact.type)
<> で囲まれた値を独自の値に置き換えます。
チーム内で TTL ポリシーを設定および編集できるユーザーを定義します。TTL 権限をチーム管理者のみに付与するか、チーム管理者とチームメンバーの両方に TTL 権限を付与できます。
アーティファクトを作成するとき、またはアーティファクトの作成後に遡及的に、アーティファクトの TTL ポリシーを設定します。
以下のすべてのコードスニペットについて、<> で囲まれたコンテンツを自分の情報に置き換えて、コードスニペットを使用します。
W&B Python SDK を使用して、アーティファクトを作成するときに TTL ポリシーを定義します。TTL ポリシーは通常、日数で定義されます。
ttl 属性に時間デルタを渡す点が異なります。手順は次のとおりです。
datetime.timedelta データ型を使用して、TTL 制限時間を定義します。次のコードスニペットは、アーティファクトを作成し、TTL ポリシーを設定する方法を示しています。
import wandb
from datetime import timedelta
run = wandb.init(project="<my-project-name>", entity="<my-entity>")
artifact = wandb.Artifact(name="<artifact-name>", type="<type>")
artifact.add_file("<my_file>")
artifact.ttl = timedelta(days=30) # TTL ポリシーを設定
run.log_artifact(artifact)
上記のコードスニペットは、アーティファクトの TTL ポリシーを 30 日に設定します。つまり、W&B は 30 日後にアーティファクトを削除します。
W&B アプリ UI または W&B Python SDK を使用して、既に存在するアーティファクトの TTL ポリシーを定義します。
createdAt タイムスタンプを使用して計算されます。ttl 属性に渡します。saveメソッドを使用してアーティファクトを更新します。次のコードスニペットは、アーティファクトの TTL ポリシーを設定する方法を示しています。
import wandb
from datetime import timedelta
artifact = run.use_artifact("<my-entity/my-project/my-artifact:alias>")
artifact.ttl = timedelta(days=365 * 2) # 2 年後に削除
artifact.save()
上記のコード例では、TTL ポリシーを 2 年に設定しています。
チームのデフォルト TTL ポリシーを設定します。デフォルト TTL ポリシーは、それぞれの作成日に基づいて、既存および将来のすべてのアーティファクトに適用されます。既存のバージョンレベルの TTL ポリシーを持つアーティファクトは、チームのデフォルト TTL の影響を受けません。
パブリック API を使用して、run を取得せずにアーティファクトを取得し、TTL ポリシーを設定します。TTL ポリシーは通常、日数で定義されます。
次のコードサンプルは、パブリック API を使用してアーティファクトを取得し、TTL ポリシーを設定する方法を示しています。
api = wandb.Api()
artifact = api.artifact("entity/project/artifact:alias")
artifact.ttl = timedelta(days=365) # 1 年後に削除
artifact.save()
W&B Python SDK または W&B アプリ UI を使用して、特定のアーティファクトバージョンの TTL ポリシーを無効化します。
ttl 属性を None に設定します。saveメソッドを使用してアーティファクトを更新します。次のコードスニペットは、アーティファクトの TTL ポリシーをオフにする方法を示しています。
artifact = run.use_artifact("<my-entity/my-project/my-artifact:alias>")
artifact.ttl = None
artifact.save()
Python SDK または W&B アプリ UI でアーティファクトの TTL ポリシーを表示します。
print ステートメントを使用して、アーティファクトの TTL ポリシーを表示します。次の例は、アーティファクトを取得し、その TTL ポリシーを表示する方法を示しています。
artifact = run.use_artifact("<my-entity/my-project/my-artifact:alias>")
print(artifact.ttl)
W&B アプリ UI でアーティファクトの TTL ポリシーを表示します。
コレクションビュー内では、選択したコレクション内のすべてのアーティファクトを表示できます。[Time to Live] 列には、そのアーティファクトに割り当てられた TTL ポリシーが表示されます。
W&B は artifact ファイルを、デフォルトで米国にあるプライベートな Google Cloud Storage バケットに保存します。すべてのファイルは、保存時および転送時に暗号化されます。
機密性の高いファイルについては、Private Hosting をセットアップするか、reference artifacts を使用することをお勧めします。
トレーニング中、W&B はログ、アーティファクト、および設定ファイルを次のローカルディレクトリーにローカルに保存します。
| ファイル | デフォルトの場所 | デフォルトの場所を変更するには、以下を設定します： |
|---|---|---|
| ログ | ./wandb |
wandb.init の dir 、または WANDB_DIR 環境変数を設定 |
| artifacts | ~/.cache/wandb |
WANDB_CACHE_DIR 環境変数 |
| configs | ~/.config/wandb |
WANDB_CONFIG_DIR 環境変数 |
| アップロード用に artifacts をステージング | ~/.cache/wandb-data/ |
WANDB_DATA_DIR 環境変数 |
| ダウンロードされた artifacts | ./artifacts |
WANDB_ARTIFACT_DIR 環境変数 |
環境変数を使用して W&B を構成するための完全なガイドについては、環境変数のリファレンスを参照してください。
wandb が初期化されるマシンによっては、これらのデフォルトフォルダーがファイルシステムの書き込み可能な場所に配置されていない場合があります。これにより、エラーが発生する可能性があります。W&B は artifact ファイルをキャッシュして、ファイルを共有する バージョン 間でのダウンロードを高速化します。時間の経過とともに、このキャッシュディレクトリーが大きくなる可能性があります。wandb artifact cache cleanup コマンドを実行して、キャッシュを削除し、最近使用されていないファイルを削除します。
次のコードスニペットは、キャッシュのサイズを 1GB に制限する方法を示しています。コードスニペットをコピーして ターミナル に貼り付けます。
$ wandb artifact cache cleanup 1GB
W&B は、特定の run が ログに記録した Artifacts と、特定の run が使用する Artifacts を自動的に追跡します。これらの Artifacts には、データセット、モデル、評価結果などが含まれます。Artifacts のリネージを調べることで、機械学習のライフサイクル全体で生成されるさまざまな Artifacts を追跡および管理できます。
Artifacts のリネージを追跡することには、いくつかの重要な利点があります。
再現性: すべての Artifacts のリネージを追跡することで、チームは Experiments、モデル、および結果を再現できます。これは、デバッグ、実験、および機械学習モデルの検証に不可欠です。
バージョン管理: Artifacts のリネージには、Artifacts のバージョン管理と、時間の経過に伴う変更の追跡が含まれます。これにより、チームは必要に応じてデータまたはモデルの以前のバージョンにロールバックできます。
監査: Artifacts とその変換の詳細な履歴を持つことで、組織は規制およびガバナンスの要件を遵守できます。
コラボレーションと知識の共有: Artifacts のリネージは、試行錯誤の明確な記録を提供することにより、チームメンバー間のより良いコラボレーションを促進します。これは、努力の重複を回避し、開発プロセスを加速するのに役立ちます。
[Artifacts] タブで Artifacts を選択すると、Artifacts のリネージを確認できます。このグラフビューには、パイプラインの概要が表示されます。
Artifacts グラフを表示するには:
指定した Artifacts またはジョブタイプが名前の前に表示され、Artifacts は青いアイコンで、runs は緑のアイコンで表示されます。矢印は、グラフ上の run または Artifacts の入出力を詳細に示します。
より詳細なビューを表示するには、個々の Artifacts または run をクリックして、特定のオブジェクトに関する詳細情報を取得します。
グラフのレベルに 5 つ以上の runs または Artifacts がある場合、クラスターが作成されます。クラスターには、runs または Artifacts の特定の バージョン を検索するための検索バーがあり、クラスターから個々のノードをプルして、クラスター内のノードのリネージの調査を続行します。
ノードをクリックすると、ノードの概要を示すプレビューが開きます。矢印をクリックすると、個々の run または Artifacts が抽出され、抽出されたノードのリネージを調べることができます。
W&B APIを使用してグラフをナビゲートすることもできます。
Artifacts を作成します。まず、wandb.init で run を作成します。次に、wandb.Artifact で新しい Artifacts を作成するか、既存の Artifacts を取得します。次に、.add_file で Artifacts にファイルを追加します。最後に、.log_artifact で Artifacts を run に ログ します。完成した コード は次のようになります。
with wandb.init() as run:
artifact = wandb.Artifact("artifact_name", "artifact_type")
# Add Files and Assets to the artifact using
# `.add`, `.add_file`, `.add_dir`, and `.add_reference`
artifact.add_file("image1.png")
run.log_artifact(artifact)
Artifacts オブジェクトの logged_by メソッドと used_by メソッドを使用して、Artifacts からグラフをたどります。
# Walk up and down the graph from an artifact:
producer_run = artifact.logged_by()
consumer_runs = artifact.used_by()
ファイルを Artifacts としてログに記録すると、ファイルは W&B が管理する Google Cloud バケットにアップロードされます。バケットの内容は、保存時も転送時も暗号化されます。Artifact ファイルは、対応する プロジェクト への アクセス権 を持つ ユーザー のみに表示されます。
Artifact の バージョン を削除すると、 データベース 内でソフト削除としてマークされ、ストレージコストから削除されます。Artifact 全体を削除すると、 完全に削除されるようにキューに入れられ、そのすべてのコンテンツが W&B バケット から削除されます。ファイルの削除に関して特別なニーズがある場合は、カスタマーサポートまでご連絡ください。
マルチテナント 環境 に存在できない機密性の高い データセット の場合、 クラウド バケット に接続された プライベート W&B サーバー 、または reference artifacts を使用できます。Reference artifacts は、ファイルの内容を W&B に送信せずに、 プライベート バケット への参照を追跡します。Reference artifacts は、 バケット または サーバー 上のファイルへのリンクを保持します。つまり、W&B はファイル自体ではなく、ファイルに関連付けられた メタデータ のみを追跡します。
Reference artifact は、非 Reference artifact を作成するのと同じように作成します。
import wandb
run = wandb.init()
artifact = wandb.Artifact("animals", type="dataset")
artifact.add_reference("s3://my-bucket/animals")
代替案については、contact@wandb.com までお問い合わせいただき、 プライベートクラウド および オンプレミス のインストールについてご相談ください。
このチュートリアルでは、W&B Runsからデータセット Artifactsを作成、追跡、および使用する方法を示します。
W&Bライブラリをインポートし、W&Bにログインします。まだお持ちでない場合は、無料のW&Bアカウントにサインアップする必要があります。
import wandb
wandb.login()
wandb.init() APIを使用して、W&B Runとしてデータを同期および記録するためのバックグラウンド プロセスを生成します。 project名とジョブタイプを指定します。
# W&B Runを作成します。この例では、データセット Artifactsの作成方法を示すため、ジョブタイプとして「dataset」を指定します。
run = wandb.init(project="artifacts-example", job_type="upload-dataset")
wandb.Artifact() APIを使用して、artifact オブジェクトを作成します。 artifactの名前とファイルタイプの記述を、それぞれname パラメータと type パラメータに指定します。
たとえば、次のコードスニペットは、‘bicycle-dataset’ という名前で ‘dataset’ というラベルの artifact を作成する方法を示しています。
artifact = wandb.Artifact(name="bicycle-dataset", type="dataset")
artifact の構成方法の詳細については、Artifactsの構築を参照してください。
artifact にファイルを追加します。一般的なファイルタイプには、Models や Datasets などがあります。次の例では、マシンにローカルに保存されている dataset.h5 という名前のデータセットを artifact に追加します。
# ファイルをartifactのコンテンツに追加します。
artifact.add_file(local_path="dataset.h5")
上記のコードスニペットのファイル名 dataset.h5 を、artifact に追加するファイルへのパスに置き換えます。
W&B run オブジェクトの log_artifact() メソッドを使用して、artifact のバージョンを保存し、artifact を run の出力として宣言します。
# artifact のバージョンを W&B に保存し、この run の出力としてマークします。
run.log_artifact(artifact)
artifact をログに記録すると、デフォルトで 'latest' エイリアスが作成されます。 artifact のエイリアスとバージョンの詳細については、カスタムエイリアスを作成すると新しい artifact バージョンを作成するをそれぞれ参照してください。
次のコード例は、W&B サーバーにログして保存した artifact を使用するために実行できる手順を示しています。
wandb.init() を使用して新しい run オブジェクトを初期化します。use_artifact() メソッドを使用して、使用する artifact を W&B に指示します。 これにより、artifact オブジェクトが返されます。download() メソッドを使用して、artifact のコンテンツをダウンロードします。# W&B Runを作成します。ここでは、この run をトレーニングの追跡に使用するため、'type' に 'training' を指定します。
run = wandb.init(project="artifacts-example", job_type="training")
# W&B に artifact を照会し、この run への入力としてマークします。
artifact = run.use_artifact("bicycle-dataset:latest")
# artifact のコンテンツをダウンロードします
artifact_dir = artifact.download()
または、パブリック API（wandb.Api）を使用して、Run の外部にある W&B にすでに保存されているデータをエクスポート（または更新）できます。 詳細については、外部ファイルを追跡するを参照してください。
W&B Secret Manager を使用すると、アクセス トークン、ベアラートークン、API キー、パスワードなどの機密性の高い文字列である secrets（シークレット） を安全かつ一元的に保存、管理、および挿入できます。W&B Secret Manager を使用すると、機密性の高い文字列をコードに直接追加したり、Webhook のヘッダーまたは ペイロード を構成したりする必要がなくなります。
シークレットは、各 Teams の Secret Manager の、Team Settings（チーム設定） の Team secrets（チームシークレット） セクションに保存および管理されます。
W&B の管理者のみが、シークレットの作成、編集、または削除を実行できます。
シークレットは、Azure、GCP、または AWS でホストする W&B Server deployments を含め、W&B のコア部分として含まれています。別の種類のデプロイメントを使用している場合は、W&B アカウントチームに連絡して、W&B でシークレットを使用する方法について話し合ってください。
W&B Server では、セキュリティ ニーズを満たすセキュリティ対策を構成する必要があります。
W&B は、高度なセキュリティ機能で構成された、AWS、GCP、または Azure が提供するクラウド プロバイダーのシークレット マネージャーの W&B インスタンスにシークレットを保存することを強くお勧めします。
クラウド シークレット マネージャー (AWS、GCP、または Azure) の W&B インスタンスを使用できない場合、およびクラスターを使用した場合に発生する可能性のあるセキュリティ脆弱性を防ぐ方法を理解している場合を除き、Kubernetes クラスターをシークレット ストアのバックエンドとして使用しないことをお勧めします。
シークレットを追加するには:
_) を使用して、シークレットの名前を指定します。Webhook を構成するときに、Webhook オートメーションに使用するシークレットを指定します。詳細については、Webhook の構成 セクションを参照してください。
${SECRET_NAME} という形式を使用して、Webhook オートメーションのペイロード でそのシークレットにアクセスできます。シークレットをローテーションしてその値を更新するには:
シークレットを削除するには:
チームのオートメーションは、チームのシークレットを使用できます。シークレットを削除する前に、それを使用するオートメーションが動作を停止しないように、更新または削除してください。
W&B Registry は、組織内の artifact バージョンの厳選された中央リポジトリです。組織内で許可を持っている ユーザー は、所属する Teams に関係なく、すべての artifact のライフサイクルをダウンロード、共有、および共同で管理できます。
Registry を使用して、artifact の バージョン を追跡し、artifact の使用状況と変更の履歴を監査し、artifact のガバナンスとコンプライアンスを確保し、モデル CI/CD などのダウンストリーム プロセス を自動化できます。
要約すると、W&B Registry を使用して以下を行います。
上の図は、“Model” および “Dataset” コア registry とカスタム registry を含む Registry App を示しています。
各組織には、モデル および データセット artifact を整理するために使用できる Models および Datasets という 2 つの registry が最初から含まれています。組織のニーズに基づいて他の artifact タイプ を整理するために、追加の registry を作成できます。
各registryは、1 つ以上のコレクションで構成されています。各コレクションは、明確なタスクまたは ユースケース を表します。
artifact を registry に追加するには、まず特定の artifact バージョン を W&B に ログ します。artifact を ログ するたびに、W&B はその artifact に バージョン を自動的に割り当てます。artifact バージョン は 0 からインデックスを開始するため、最初の バージョン は v0、2 番目の バージョン は v1 のようになります。
artifact を W&B に ログ したら、その特定の artifact バージョン を registry 内のコレクションにリンクできます。
例として、次の コード 例は、“my_model.txt” という名前のモデル artifact をコア registryの “first-collection” という名前のコレクションに ログ してリンクする方法を示しています。
この Python コード を スクリプト に保存して実行します。W&B Python SDK バージョン 0.18.6 以降が必要です。
import wandb
import random
# Artifact を追跡するために W&B run を初期化します。
run = wandb.init(project="registry_quickstart")
# ログ できるようにシミュレートされたモデルファイルを作成します
with open("my_model.txt", "w") as f:
f.write("Model: " + str(random.random()))
# Artifact を W&B に ログ します
logged_artifact = run.log_artifact(
artifact_or_path="./my_model.txt",
name="gemma-finetuned",
type="model" # artifact タイプを指定します
)
# artifact を公開するコレクションと registry の名前を指定します
COLLECTION_NAME = "first-collection"
REGISTRY_NAME = "model"
# artifact を registry にリンクします
run.link_artifact(
artifact=logged_artifact,
target_path=f"wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}"
)
返された run オブジェクトの link_artifact(target_path = "") メソッドで指定したコレクションが、指定した registry 内に存在しない場合、W&B は自動的にコレクションを作成します。
Registry App に移動して、 ユーザー と組織の他のメンバーが公開する artifact バージョン を表示します。これを行うには、まず W&B に移動します。[アプリケーション] の下の左側のサイドバーで Registry を選択します。“Model” registry を選択します。registry 内に、リンクされた artifact バージョン を持つ “first-collection” コレクションが表示されます。
artifact バージョン を registry 内のコレクションにリンクすると、組織のメンバーは、適切な権限を持っている場合、artifact バージョン の表示、ダウンロード、管理、ダウンストリーム オートメーション の作成などを行うことができます。
run.log_artifact() を使用して) メトリクス を ログ する場合、詳細ページからその バージョン の メトリクス を表示したり、コレクションのページから artifact バージョン 全体で メトリクス を比較したりできます。registry でリンクされた artifact を表示を参照してください。デプロイメントタイプに基づいて、次の条件を満たして W&B Registry を有効にします。
| デプロイメントタイプ | 有効にする方法 |
|---|---|
| Multi-tenant Cloud | アクションは不要です。W&B Registry は W&B App で利用できます。 |
| 専用クラウド | アカウントチームにお問い合わせください。ソリューションアーキテクト (SA) チームが、インスタンスのオペレーターコンソール内で W&B Registry を有効にします。インスタンスがサーバーリリースバージョン 0.59.2 以降であることを確認してください。 |
| Self-Managed | ENABLE_REGISTRY_UI という名前の 環境変数 を有効にします。サーバー で 環境変数 を有効にする方法の詳細については、これらのドキュメントを参照してください。セルフマネージドインスタンスでは、インフラストラクチャ 管理者 がこの 環境変数 を有効にして true に設定する必要があります。インスタンスがサーバーリリースバージョン 0.59.2 以降であることを確認してください。 |
ユースケース に応じて、W&B Registry を開始するための次のリソースをご覧ください。
レガシー Model Registry は、正確な日付はまだ決定されていませんが、廃止が予定されています。レガシー Model Registry を廃止する前に、W&B はレガシー Model Registry のコンテンツを W&B Registry に移行します。
レガシー Model Registry から W&B Registry への移行 プロセス の詳細については、レガシー Model Registry からの移行を参照してください。
移行が行われるまで、W&B はレガシー Model Registry と新しい Registry の両方をサポートします。
レガシー Model Registry を表示するには、W&B App の Model Registry に移動します。ページの上部に、レガシー Model Registry App UI の使用を有効にするバナーが表示されます。
ご質問がある場合、または移行に関する懸念について W&B Product Team と話したい場合は、support@wandb.com までご連絡ください。
W&B は、コアレジストリ と カスタムレジストリ の2種類のレジストリをサポートしています。
コアレジストリは、特定の ユースケース ( Models と Datasets ) のためのテンプレートです。
デフォルトでは、Models レジストリは "model" artifact タイプを受け入れるように設定され、Dataset レジストリは "dataset" artifact タイプを受け入れるように設定されています。管理者は、追加の受け入れ可能な artifact タイプを追加できます。
上の図は、W&B Registry App UI の Models と Dataset コアレジストリと、Fine_Tuned_Models というカスタムレジストリを示しています。
コアレジストリは、組織の可視性 を持っています。レジストリ管理者は、コアレジストリの可視性を変更できません。
カスタムレジストリは、"model" artifact タイプまたは "dataset" artifact タイプに制限されません。
初期の データ 収集から最終的な モデル の デプロイメント まで、機械学習 パイプライン の各ステップに対してカスタムレジストリを作成できます。
たとえば、トレーニング された モデル のパフォーマンスを評価するために、キュレーションされた データセット を整理するために「Benchmark_Datasets」というレジストリを作成できます。このレジストリ内には、「User_Query_Insurance_Answer_Test_Data」というコレクションがあり、トレーニング 中に モデル が見たことのない ユーザー の質問と、対応する専門家によって検証された回答のセットが含まれている場合があります。
カスタムレジストリは、組織または制限付きの可視性 を持つことができます。レジストリ管理者は、カスタムレジストリの可視性を組織から制限付きに変更できます。ただし、レジストリ管理者は、カスタムレジストリの可視性を制限付きから組織の可視性には変更できません。
カスタムレジストリの作成方法については、カスタムレジストリの作成 を参照してください。
次の表は、コアレジストリとカスタムレジストリの違いをまとめたものです。
| Core | Custom | |
|---|---|---|
| 可視性 | 組織の可視性のみ。可視性は変更できません。 | 組織または制限付き。可視性は組織から制限付きの可視性へ変更できます。 |
| メタデータ | 事前設定されており、 ユーザー は編集できません。 | ユーザー が編集できます。 |
| Artifact タイプ | 事前設定されており、受け入れられた artifact タイプは削除できません。 ユーザー は追加の受け入れられた artifact タイプを追加できます。 | 管理者は、受け入れられたタイプを定義できます。 |
| カスタマイズ | 既存のリストにタイプを追加できます。 | レジストリ名、説明、可視性、および受け入れられた artifact タイプを編集します。 |
カスタムレジストリは、使用できるアーティファクトのタイプに対する柔軟性と制御を提供し、レジストリの可視性を制限できます。
コアレジストリとカスタムレジストリの完全な比較については、レジストリの種類の概要表を参照してください。
カスタムレジストリを作成するには:
たとえば、次の図は、ユーザーが作成しようとしている Fine_Tuned_Models という名前のカスタムレジストリを示しています。レジストリは、レジストリに手動で追加されたメンバーのみに Restricted されています。
レジストリの可視性は、誰がそのレジストリにアクセスできるかを決定します。カスタムレジストリの可視性を制限すると、指定されたメンバーのみがレジストリにアクセスできるようになります。
カスタムレジストリには、次の2つのタイプのレジストリ可視性オプションがあります。
| 可視性 | 説明 |
|---|---|
| Restricted | 招待された組織メンバーのみがレジストリにアクセスできます。 |
| Organization | 組織内のすべてのユーザーがレジストリにアクセスできます。 |
チーム管理者またはレジストリ管理者は、カスタムレジストリの可視性を設定できます。
Restricted の可視性でカスタムレジストリを作成したユーザーは、レジストリ管理者として自動的にレジストリに追加されます。
チーム管理者またはレジストリ管理者は、カスタムレジストリの作成中または作成後に、カスタムレジストリの可視性を割り当てることができます。
既存のカスタムレジストリの可視性を制限するには:
チーム管理者がカスタムレジストリを作成するときに、カスタムレジストリの可視性を割り当てる方法の詳細については、カスタムレジストリの作成を参照してください。
Registry の管理者は、Registry の設定を構成することで、Registry のロールを設定、ユーザーを追加、または ユーザーを削除 できます。
Registry の管理者は、個々の ユーザー または Teams 全体を Registry に追加できます。 ユーザー または Teams を Registry に追加するには:
Registry での ユーザー ロールの設定、または Registry ロールの権限 について詳細をご覧ください。
Registry の管理者は、個々の ユーザー または Teams 全体を Registry から削除できます。 ユーザー または Teams を Registry から削除するには:
Registry 内の各 ユーザー は、その Registry で何ができるかを決定する Registry ロール を持っています。
W&B は、ユーザー または Teams が Registry に追加されると、デフォルトの Registry ロールを自動的に割り当てます。
| エンティティ | デフォルトの Registry ロール |
|---|---|
| Teams | Viewer |
| ユーザー (管理者以外) | Viewer |
| 組織の管理者 | Admin |
Registry の管理者は、Registry 内の ユーザー および Teams のロールを割り当てまたは変更できます。 詳細については、Registry での ユーザー ロールの設定 を参照してください。
W&B には、2 種類のロールがあります。Teams ロール と Registry ロール です。
Teams でのロールは、Registry でのロールに影響を与えたり、関係したりすることはありません。
次の表に、ユーザー が持つことができるさまざまなロールと、その権限を示します。
| 権限 | 権限グループ | Viewer | Member | Admin |
|---|---|---|---|---|
| コレクションの詳細を表示する | Read | X | X | X |
| リンクされた Artifact の詳細を表示する | Read | X | X | X |
| 使用法: use_artifact を使用して Registry 内の Artifact を消費する | Read | X | X | X |
| リンクされた Artifact をダウンロードする | Read | X | X | X |
| Artifact のファイルビューアーからファイルをダウンロードする | Read | X | X | X |
| Registry を検索する | Read | X | X | X |
| Registry の 設定 と ユーザー リストを表示する | Read | X | X | X |
| コレクションの新しい自動化を作成する | Create | X | X | |
| 新しい バージョン が追加されたときに Slack 通知をオンにする | Create | X | X | |
| 新しいコレクションを作成する | Create | X | X | |
| 新しいカスタム Registry を作成する | Create | X | X | |
| コレクションカード (説明) を編集する | Update | X | X | |
| リンクされた Artifact の説明を編集する | Update | X | X | |
| コレクションのタグを追加または削除する | Update | X | X | |
| リンクされた Artifact から エイリアス を追加または削除する | Update | X | X | |
| 新しい Artifact をリンクする | Update | X | X | |
| Registry で許可されている種類のリストを編集する | Update | X | X | |
| カスタム Registry 名を編集する | Update | X | X | |
| コレクションを削除する | Delete | X | X | |
| 自動化を削除する | Delete | X | X | |
| Registry から Artifact のリンクを解除する | Delete | X | X | |
| Registry で許可されている Artifact の種類を編集する | Admin | X | ||
| Registry の表示設定 (Organization または Restricted) を変更する | Admin | X | ||
| Registry に ユーザー を追加する | Admin | X | ||
| Registry で ユーザー のロールを割り当てるか変更する | Admin | X |
Registry での ユーザー の権限は、個人または Teams メンバーシップによって割り当てられた、その ユーザー に割り当てられた最高の特権レベルによって異なります。
たとえば、Registry の管理者が Nico という ユーザー を Registry A に追加し、Viewer Registry ロールを割り当てるとします。次に、Registry の管理者が Foundation Model Team という Teams を Registry A に追加し、Foundation Model Team に Member Registry ロールを割り当てます。
Nico は Foundation Model Team のメンバーであり、Member は Registry のメンバーです。Member は Viewer よりも多くの権限を持っているため、W&B は Nico に Member ロールを付与します。
次の表は、ユーザー の個々の Registry ロールと、メンバーである Teams の Registry ロールとの間で競合が発生した場合の、最高の権限レベルを示しています。
| Teams Registry ロール | 個々の Registry ロール | 継承された Registry ロール |
|---|---|---|
| Viewer | Viewer | Viewer |
| Member | Viewer | Member |
| Admin | Viewer | Admin |
競合がある場合、W&B は ユーザー の名前の横に最高の権限レベルを表示します。
たとえば、次の画像では、Alex は smle-reg-team-1 Teams のメンバーであるため、Member ロールの特権を継承しています。
コレクション とは、レジストリ内のリンクされた artifact バージョンのセットです。各コレクションは、明確なタスクまたはユースケースを表します。
たとえば、コア Dataset レジストリ内には複数のコレクションが存在する場合があります。各コレクションには、MNIST、CIFAR-10、ImageNet など、異なるデータセットが含まれています。
別の例として、「chatbot」というレジストリがあり、モデル artifact のコレクション、データセット artifact の別のコレクション、ファインチューンされたモデル artifact の別のコレクションが含まれている場合があります。
レジストリとそのコレクションをどのように編成するかは、あなた次第です。
各コレクションは、1 つ、かつ 1 つのみの artifact の タイプ を受け入れます。指定するタイプは、あなたと組織の他のメンバーがそのコレクションにリンクできる artifact の種類を制限します。
たとえば、「データセット」 artifact タイプを受け入れるコレクションを作成するとします。これは、タイプ「データセット」を持つ将来の artifact バージョンのみをこのコレクションにリンクできることを意味します。同様に、モデル artifact タイプのみを受け入れるコレクションには、タイプ「model」の artifact のみをリンクできます。
artifact オブジェクトを作成するときに、artifact のタイプを指定します。wandb.Artifact() の type フィールドに注意してください。
import wandb
# Initialize a run
run = wandb.init(
entity = "<team_entity>",
project = "<project>"
)
# Create an artifact object
artifact = wandb.Artifact(
name="<artifact_name>",
type="<artifact_type>"
)
コレクションを作成するときは、定義済みの artifact タイプのリストから選択できます。利用可能な artifact タイプは、コレクションが属するレジストリによって異なります。
artifact をコレクションにリンクする、または新しいコレクションを作成する前に、コレクションが受け入れる artifact のタイプを調べてください。
コレクションにリンクする前に、コレクションが受け入れる artifact タイプを調べてください。コレクションが受け入れる artifact タイプは、W&B Python SDK を使用してプログラムで、または W&B App を使用してインタラクティブに調べることができます。
受け入れられる artifact タイプは、ホームページのレジストリカード、またはレジストリの設定ページにあります。
どちらの方法でも、まず W&B Registry App に移動します。
Registry App のホームページ内で、そのレジストリのレジストリカードまでスクロールすると、受け入れられる artifact タイプを表示できます。レジストリカード内の灰色の水平方向の楕円は、そのレジストリが受け入れる artifact タイプを示しています。
たとえば、上記の画像は、Registry App ホームページの複数のレジストリカードを示しています。Model レジストリカード内には、model と model-new の 2 つの artifact タイプが表示されています。
レジストリの設定ページ内で受け入れられる artifact タイプを表示するには：
W&B Python SDK を使用して、レジストリが受け入れる artifact タイプをプログラムで表示します。
import wandb
registry_name = "<registry_name>"
artifact_types = wandb.Api().project(name=f"wandb-registry-{registry_name}").artifact_types()
print(artifact_type.name for artifact_type in artifact_types)
コレクションが受け入れる artifact のタイプがわかったら、コレクションを作成できます。
レジストリ内にインタラクティブまたはプログラムでコレクションを作成します。コレクションの作成後に、コレクションが受け入れる artifact のタイプを変更することはできません。
wandb.init.link_artifact() メソッドを使用して、artifact をコレクションにリンクします。target_path フィールドに、コレクションとレジストリの両方を次の形式のパスとして指定します。
f"wandb-registry-{registry_name}/{collection_name}"
ここで、registry_name はレジストリの名前、collection_name はコレクションの名前です。プレフィックス wandb-registry- をレジストリ名に必ず追加してください。
上記のコードスニペットは、プログラムでコレクションを作成する方法を示しています。<> で囲まれた他の値を必ず独自の値に置き換えてください。
import wandb
# Initialize a run
run = wandb.init(entity = "<team_entity>", project = "<project>")
# Create an artifact object
artifact = wandb.Artifact(
name = "<artifact_name>",
type = "<artifact_type>"
)
registry_name = "<registry_name>"
collection_name = "<collection_name>"
target_path = f"wandb-registry-{registry_name}/{collection_name}"
# Link the artifact to a collection
run.link_artifact(artifact = artifact, target_path = target_path)
run.finish()
次の手順では、W&B Registry App UI を使用してレジストリ内にコレクションを作成する方法について説明します。
Artifact の バージョンをコレクションにリンクして、組織内の他のメンバーが利用できるようにします。
Artifact をレジストリにリンクすると、その Artifact がそのレジストリに「公開」されます。そのレジストリへのアクセス権を持つ ユーザー は、コレクション内のリンクされた Artifact の バージョン にアクセスできます。
言い換えれば、Artifact をレジストリ コレクションにリンクすると、その Artifact の バージョン がプライベートなプロジェクトレベルのスコープから、共有の組織レベルのスコープに移行します。
wandb.Artifact) を作成するか、Artifact (wandb.init.log_artifact) を ログ に記録する場合、type パラメータ の type を指定します。Artifact の バージョン を、インタラクティブまたはプログラムでコレクションにリンクします。
ユースケース に基づいて、以下のタブに記載されている手順に従って、Artifact の バージョン をリンクしてください。
run.log_artifact() を使用するなど)、その バージョン の詳細ページからその バージョン のメトリクスを表示したり、Artifact のページから Artifact の バージョン 全体のメトリクスを比較したりできます。レジストリ内のリンクされた Artifact を表示する を参照してください。wandb.init.Run.link_artifact() を使用して、プログラムで Artifact の バージョン をコレクションにリンクします。
target_path パラメータ を使用して、Artifact の バージョン のリンク先となるコレクションとレジストリを指定します。ターゲット パス は、プレフィックス「wandb-registry」、レジストリの名前、およびフォワード スラッシュで区切られたコレクションの名前で構成されます。
wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}
以下の コードスニペット をコピーして貼り付け、既存のレジストリ内のコレクションに Artifact の バージョン をリンクします。「<>」で囲まれた 値 を自分の 値 に置き換えます。
import wandb
# Run を初期化する
run = wandb.init(
entity = "<team_entity>",
project = "<project_name>"
)
# Artifact オブジェクトを作成する
# type パラメータ は、Artifact オブジェクト の type と
# コレクション の type の両方を指定します
artifact = wandb.Artifact(name = "<name>", type = "<type>")
# Artifact オブジェクト にファイルを追加します。
# ローカルマシン 上のファイルへの パス を指定します。
artifact.add_file(local_path = "<local_path_to_artifact>")
# Artifact のリンク先のコレクションとレジストリを指定します
REGISTRY_NAME = "<registry_name>"
COLLECTION_NAME = "<collection_name>"
target_path=f"wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}"
# Artifact をコレクションにリンクする
run.link_artifact(artifact = artifact, target_path = target_path)
"model" または "dataset" に設定します。
https://wandb.ai/<entity>/<project>/artifacts) に移動します。Registry アプリ で、リンクされた Artifact の メタデータ、バージョン データ、使用状況、リネージ 情報を表示します。
Registry アプリ で、メタデータ、リネージ、使用状況情報など、リンクされた Artifact に関する情報を表示します。
v0 から始まるリンクされた各 Artifact の バージョン にインクリメントに割り当てられます。バージョン タブ内の フルネーム フィールドに注意してください。リンクされた Artifact のフルネームは、レジストリ、コレクション名、および Artifact の バージョン の エイリアス または インデックス で構成されます。
wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}:v{INTEGER}
プログラムで Artifact の バージョン にアクセスするには、リンクされた Artifact のフルネームが必要です。
Artifact をリンクできない場合は、以下に示す一般的な確認事項を再確認してください。
個人の Entity で W&B に ログ に記録された Artifact は、レジストリにリンクできません。組織内の チーム Entity を使用して Artifact を ログ に記録していることを確認してください。組織の チーム 内で ログ に記録された Artifact のみ、組織のレジストリにリンクできます。
W&B は、チーム の名前を チーム の Entity として使用します。たとえば、チーム の名前が team-awesome の場合、チーム Entity は team-awesome です。
次の方法で チーム の名前を確認できます。
https://wandb.ai/<team> の形式です。<team> は チーム の名前と チーム の Entity の両方です。wandb.init() で run を初期化するときに、Entity として チーム を指定します。run を初期化するときに entity を指定しない場合、run はデフォルト の Entity を使用します。これは チーム Entity である場合とそうでない場合があります。import wandb
run = wandb.init(
entity='<team_entity>',
project='<project_name>'
)
run.log_artifact を使用して、または Artifact オブジェクト を作成し、次にファイルを Artifact オブジェクト に追加して、Artifact を run に ログ に記録します。
artifact = wandb.Artifact(name="<artifact_name>", type="<type>")
Artifact の ログ 方法について詳しくは、Artifact を構築する をご覧ください。
Artifact が個人の Entity に ログ に記録されている場合は、組織内の Entity に再度 ログ に記録する必要があります。
UI を使用してレジストリの パス を確認するには、空のコレクションを作成してコレクションの詳細を表示するか、コレクションの ホーム ページで自動生成された コード をコピーして貼り付けます。
.link_artifact() 内の target_path フィールドを特定します。
たとえば、概説されている手順を完了した後、target_path パラメータ を使用して コード ブロックを見つけます。
target_path =
"smle-registries-bug-bash/wandb-registry-Golden Datasets/raw_images"
これをコンポーネント に分解すると、プログラムで Artifact をリンクするための パス を作成するために使用する必要があるものを確認できます。
ORG_ENTITY_NAME = "smle-registries-bug-bash"
REGISTRY_NAME = "Golden Datasets"
COLLECTION_NAME = "raw_images"
W&B Python SDK を使用して、レジストリにリンクされた artifact をダウンロードします。artifact をダウンロードして使用するには、レジストリの名前、コレクションの名前、およびダウンロードする artifact バージョンのエイリアスまたはインデックスを知っておく必要があります。
artifact のプロパティがわかったら、リンクされた artifact へのパスを構築して artifact をダウンロードできます。または、W&B App UI から事前生成されたコードスニペットをコピーして貼り付けて、レジストリにリンクされた artifact をダウンロードすることもできます。
レジストリにリンクされた artifact をダウンロードするには、そのリンクされた artifact のパスを知っておく必要があります。パスは、レジストリ名、コレクション名、およびアクセスする artifact バージョンのエイリアスまたはインデックスで構成されます。
レジストリ、コレクション、および artifact バージョンのエイリアスまたはインデックスを取得したら、次の文字列テンプレートを使用して、リンクされた artifact へのパスを構築できます。
# バージョンインデックスが指定された Artifact 名
f"wandb-registry-{REGISTRY}/{COLLECTION}:v{INDEX}"
# エイリアスが指定された Artifact 名
f"wandb-registry-{REGISTRY}/{COLLECTION}:{ALIAS}"
中かっこ{}内の値を、アクセスするレジストリ、コレクション、および artifact バージョンのエイリアスまたはインデックスの名前に置き換えます。
modelまたはdatasetを指定します。リンクされた artifact のパスを取得したら、wandb.init.use_artifact メソッドを使用して artifact にアクセスし、そのコンテンツをダウンロードします。次のコードスニペットは、W&B Registry にリンクされた artifact を使用およびダウンロードする方法を示しています。<>内の値を自分の値に置き換えてください。
import wandb
REGISTRY = '<registry_name>'
COLLECTION = '<collection_name>'
ALIAS = '<artifact_alias>'
run = wandb.init(
entity = '<team_name>',
project = '<project_name>'
)
artifact_name = f"wandb-registry-{REGISTRY}/{COLLECTION}:{ALIAS}"
# artifact_name = '<artifact_name>' # Registry App で指定されたフルネームをコピーして貼り付けます
fetched_artifact = run.use_artifact(artifact_or_name = artifact_name)
download_path = fetched_artifact.download()
.use_artifact() メソッドは、runを作成し、ダウンロードした artifact をその run への入力としてマークします。artifact を run への入力としてマークすると、W&B はその artifact のリネージを追跡できます。
run を作成したくない場合は、wandb.Api() オブジェクトを使用して artifact にアクセスできます。
import wandb
REGISTRY = "<registry_name>"
COLLECTION = "<collection_name>"
VERSION = "<version>"
api = wandb.Api()
artifact_name = f"wandb-registry-{REGISTRY}/{COLLECTION}:{VERSION}"
artifact = api.artifact(name = artifact_name)
次のコード例は、ユーザーが Fine-tuned Models レジストリの phi3-finetuned というコレクションにリンクされた artifact をダウンロードする方法を示しています。artifact バージョンのエイリアスは production に設定されています。
import wandb
TEAM_ENTITY = "product-team-applications"
PROJECT_NAME = "user-stories"
REGISTRY = "Fine-tuned Models"
COLLECTION = "phi3-finetuned"
ALIAS = 'production'
# 指定された Team と Project 内で Run を初期化します
run = wandb.init(entity=TEAM_ENTITY, project = PROJECT_NAME)
artifact_name = f"wandb-registry-{REGISTRY}/{COLLECTION}:{ALIAS}"
# Artifact にアクセスし、リネージ追跡のために Run への入力としてマークします
fetched_artifact = run.use_artifact(artifact_or_name = name)
# Artifact をダウンロードします。ダウンロードしたコンテンツへのパスを返します
downloaded_path = fetched_artifact.download()
可能なパラメータと戻り値の型の詳細については、API Reference ガイドの use_artifact および Artifact.download() を参照してください。
複数の組織に属する個人 Entity を持つ Users は、レジストリにリンクされた artifact にアクセスする際に、組織の名前を指定するか、Team Entity を使用する必要があります。
import wandb
REGISTRY = "<registry_name>"
COLLECTION = "<collection_name>"
VERSION = "<version>"
# API をインスタンス化するために、Team Entity を使用していることを確認してください
api = wandb.Api(overrides={"entity": "<team-entity>"})
artifact_name = f"wandb-registry-{REGISTRY}/{COLLECTION}:{VERSION}"
artifact = api.artifact(name = artifact_name)
# パスで組織の表示名または組織 Entity を使用します
api = wandb.Api()
artifact_name = f"{ORG_NAME}/wandb-registry-{REGISTRY}/{COLLECTION}:{VERSION}"
artifact = api.artifact(name = artifact_name)
ORG_NAME は、組織の表示名です。マルチテナント SaaS ユーザーは、組織の設定ページ（https://wandb.ai/account-settings/）で組織の名前を見つけることができます。Dedicated Cloud および Self-Managed ユーザーは、アカウント管理者に連絡して、組織の表示名を確認してください。
W&B は、Python スクリプト、notebook、またはターミナルにコピーして貼り付けて、レジストリにリンクされた artifact をダウンロードできるコードスニペットを作成します。
W&B Registry App のグローバル検索バー を使用して、レジストリ、コレクション、アーティファクト バージョン タグ、コレクション タグ、または エイリアス を検索します。MongoDB スタイルのクエリを使用して、W&B Python SDK を使用して特定の条件に基づいてレジストリ、コレクション、およびアーティファクト バージョンをフィルタリングできます。
表示する権限を持つアイテムのみが検索結果に表示されます。
レジストリ アイテムを検索するには:
指定した用語が既存のレジストリ、コレクション名、アーティファクト バージョン タグ、コレクション タグ、または エイリアス と一致する場合、検索結果は検索バーの下に表示されます。
wandb.Api().registries() と クエリ述語 を使用して、1 つ以上の MongoDB スタイルのクエリ に基づいて、レジストリ、コレクション、およびアーティファクト バージョンをフィルタリングします。
次の表に、フィルタリングするアイテムのタイプに基づいて使用できるクエリ名を示します。
| クエリ名 | |
|---|---|
| registries | name, description, created_at, updated_at |
| collections | name, tag, description, created_at, updated_at |
| versions | tag, alias, created_at, updated_at, metadata |
次の コードスニペット は、一般的な検索シナリオを示しています。
wandb.Api().registries() メソッドを使用するには、まず W&B Python SDK (wandb) ライブラリをインポートします。
import wandb
# (オプション) 可読性を高めるために wandb.Api() クラスのインスタンスを作成します
api = wandb.Api()
文字列 model を含むすべての registries をフィルタリングします。
# 文字列 `model` を含むすべての registries をフィルタリングします
registry_filters = {
"name": {"$regex": "model"}
}
# フィルタに一致するすべての registries のイテラブルを返します
registries = api.registries(filter=registry_filters)
コレクション名に文字列 yolo を含む、registry に関係なく、すべての collections をフィルタリングします。
# コレクション名に文字列 `yolo` を含む、registry に関係なく、
# すべての collections をフィルタリングします
collection_filters = {
"name": {"$regex": "yolo"}
}
# フィルタに一致するすべての collections のイテラブルを返します
collections = api.registries().collections(filter=collection_filters)
コレクション名に文字列 yolo を含み、cnn をタグとして持つ、registry に関係なく、すべての collections をフィルタリングします。
# コレクション名に文字列 `yolo` を含み、
# `cnn` をタグとして持つ、registry に関係なく、すべての collections をフィルタリングします
collection_filters = {
"name": {"$regex": "yolo"},
"tag": "cnn"
}
# フィルタに一致するすべての collections のイテラブルを返します
collections = api.registries().collections(filter=collection_filters)
文字列 model を含み、タグ image-classification または latest エイリアス のいずれかを持つすべてのアーティファクト バージョンを検索します。
# 文字列 `model` を含み、
# タグ `image-classification` または `latest` エイリアス のいずれかを持つすべてのアーティファクト バージョンを検索します
registry_filters = {
"name": {"$regex": "model"}
}
# 論理 $or 演算子を使用してアーティファクト バージョンをフィルタリングします
version_filters = {
"$or": [
{"tag": "image-classification"},
{"alias": "production"}
]
}
# フィルタに一致するすべてのアーティファクト バージョンのイテラブルを返します
artifacts = api.registries(filter=registry_filters).collections().versions(filter=version_filters)
論理クエリオペレーター の詳細については、MongoDB のドキュメントを参照してください。
前の コードスニペット の artifacts イテラブルの各アイテムは、Artifact クラスのインスタンスです。つまり、各アーティファクトの属性 ( name 、 collection 、 aliases 、 tags 、 created_at など) にアクセスできます。
for art in artifacts:
print(f"artifact name: {art.name}")
print(f"collection artifact belongs to: { art.collection.name}")
print(f"artifact aliases: {art.aliases}")
print(f"tags attached to artifact: {art.tags}")
print(f"artifact created at: {art.created_at}\n")
アーティファクト オブジェクトの属性の完全なリストについては、API Reference ドキュメントの Artifacts Class を参照してください。
2024-01-08 から 2025-03-04 の 13:10 UTC の間に作成された、registry または collection に関係なく、すべてのアーティファクト バージョンをフィルタリングします。
# 2024-01-08 から 2025-03-04 の 13:10 UTC の間に作成されたすべてのアーティファクト バージョンを検索します。
artifact_filters = {
"alias": "latest",
"created_at" : {"$gte": "2024-01-08", "$lte": "2025-03-04 13:10:00"},
}
# フィルタに一致するすべてのアーティファクト バージョンのイテラブルを返します
artifacts = api.registries().collections().versions(filter=artifact_filters)
日付と時刻を YYYY-MM-DD HH:MM:SS 形式で指定します。日付のみでフィルタリングする場合は、時間、分、秒を省略できます。
クエリ比較 の詳細については、MongoDB のドキュメントを参照してください。
レジストリ内のコレクションまたは Artifacts バージョンを整理するために、タグを作成して追加します。W&B App UIまたは W&B Python SDK を使用して、コレクションまたは Artifacts バージョンにタグを追加、変更、表示、または削除します。
特定の Artifacts バージョンを一意に参照する必要がある場合は、エイリアスを使用します。たとえば、artifact_name:alias が常に単一の特定のバージョンを指すようにするために、‘production’ や ’latest’ などのエイリアスを使用します。
グループ化や検索の柔軟性を高めたい場合は、タグを使用します。タグは、複数のバージョンまたはコレクションが同じラベルを共有でき、特定の識別子に1つのバージョンのみが関連付けられているという保証が不要な場合に最適です。
W&B App UIまたは Python SDK を使用して、コレクションにタグを追加します。
W&B App UIを使用して、コレクションにタグを追加します。
import wandb
COLLECTION_TYPE = "<collection_type>"
ORG_NAME = "<org_name>"
REGISTRY_NAME = "<registry_name>"
COLLECTION_NAME = "<collection_name>"
full_name = f"{ORG_NAME}/wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}"
collection = wandb.Api().artifact_collection(
type_name = COLLECTION_TYPE,
name = full_name
)
collection.tags = ["your-tag"]
collection.save()
tags 属性を再割り当てするか、変更することで、プログラムでタグを更新します。W&B は、インプレースミューテーションではなく、tags 属性を再割り当てすることを推奨しており、これは良い Python のプラクティスです。
たとえば、次のコードスニペットは、再割り当てでリストを更新する一般的な方法を示しています。簡潔にするために、コレクションにタグを追加するセクションのコード例を続けます。
collection.tags = [*collection.tags, "new-tag", "other-tag"]
collection.tags = collection.tags + ["new-tag", "other-tag"]
collection.tags = set(collection.tags) - set(tags_to_delete)
collection.tags = [] # deletes all tags
次のコードスニペットは、インプレースミューテーションを使用して、Artifacts バージョンに属するタグを更新する方法を示しています。
collection.tags += ["new-tag", "other-tag"]
collection.tags.append("new-tag")
collection.tags.extend(["new-tag", "other-tag"])
collection.tags[:] = ["new-tag", "other-tag"]
collection.tags.remove("existing-tag")
collection.tags.pop()
collection.tags.clear()
W&B App UIを使用して、コレクションに追加されたタグを表示します。
コレクションに1つ以上のタグがある場合、[タグ] フィールドの横にあるコレクションカード内でそれらのタグを表示できます。
コレクションに追加されたタグは、そのコレクションの名前の横にも表示されます。
たとえば、上記の画像では、「tag1」というタグが「zoo-dataset-tensors」コレクションに追加されました。
W&B App UIを使用して、コレクションからタグを削除します。
W&B App UIまたは Python SDK を使用して、コレクションにリンクされた Artifacts バージョンにタグを追加します。
タグを追加または更新する Artifacts バージョンをフェッチします。Artifacts バージョンを取得したら、Artifacts オブジェクトの tag 属性にアクセスして、その Artifacts にタグを追加または変更できます。Artifacts の tag 属性に1つまたは複数のタグをリストとして渡します。
他の Artifacts と同様に、run を作成せずに W&B から Artifacts をフェッチするか、run を作成してその run 内で Artifacts をフェッチできます。いずれの場合も、Artifacts オブジェクトの save メソッドを呼び出して、W&B サーバー上の Artifacts を更新してください。
以下の適切なコードセルをコピーして貼り付け、Artifacts バージョンのタグを追加または変更します。<> の値を自分の値に置き換えます。
次のコードスニペットは、新しい run を作成せずに Artifacts をフェッチしてタグを追加する方法を示しています。
import wandb
ARTIFACT_TYPE = "<TYPE>"
ORG_NAME = "<org_name>"
REGISTRY_NAME = "<registry_name>"
COLLECTION_NAME = "<collection_name>"
VERSION = "<artifact_version>"
artifact_name = f"{ORG_NAME}/wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}:v{VERSION}"
artifact = wandb.Api().artifact(name = artifact_name, type = ARTIFACT_TYPE)
artifact.tags = ["tag2"] # リストで1つ以上のタグを提供します
artifact.save()
次のコードスニペットは、新しい run を作成して Artifacts をフェッチし、タグを追加する方法を示しています。
import wandb
ORG_NAME = "<org_name>"
REGISTRY_NAME = "<registry_name>"
COLLECTION_NAME = "<collection_name>"
VERSION = "<artifact_version>"
run = wandb.init(entity = "<entity>", project="<project>")
artifact_name = f"{ORG_NAME}/wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}:v{VERSION}"
artifact = run.use_artifact(artifact_or_name = artifact_name)
artifact.tags = ["tag2"] # リストで1つ以上のタグを提供します
artifact.save()
tags 属性を再割り当てするか、変更することで、プログラムでタグを更新します。W&B は、インプレースミューテーションではなく、tags 属性を再割り当てすることを推奨しており、これは良い Python のプラクティスです。
たとえば、次のコードスニペットは、再割り当てでリストを更新する一般的な方法を示しています。簡潔にするために、Artifacts バージョンにタグを追加するセクションのコード例を続けます。
artifact.tags = [*artifact.tags, "new-tag", "other-tag"]
artifact.tags = artifact.tags + ["new-tag", "other-tag"]
artifact.tags = set(artifact.tags) - set(tags_to_delete)
artifact.tags = [] # deletes all tags
次のコードスニペットは、インプレースミューテーションを使用して、Artifacts バージョンに属するタグを更新する方法を示しています。
artifact.tags += ["new-tag", "other-tag"]
artifact.tags.append("new-tag")
artifact.tags.extend(["new-tag", "other-tag"])
artifact.tags[:] = ["new-tag", "other-tag"]
artifact.tags.remove("existing-tag")
artifact.tags.pop()
artifact.tags.clear()
W&B App UIまたは Python SDK を使用して、レジストリにリンクされている Artifacts バージョンに属するタグを表示します。
Artifacts バージョンに1つ以上のタグがある場合、[タグ] 列内でそれらのタグを表示できます。
タグを表示する Artifacts バージョンをフェッチします。Artifacts バージョンを取得したら、Artifacts オブジェクトの tag 属性を表示して、その Artifacts に属するタグを表示できます。
他の Artifacts と同様に、run を作成せずに W&B から Artifacts をフェッチするか、run を作成してその run 内で Artifacts をフェッチできます。
以下の適切なコードセルをコピーして貼り付け、Artifacts バージョンのタグを追加または変更します。<> の値を自分の値に置き換えます。
次のコードスニペットは、新しい run を作成せずに Artifacts バージョンのタグをフェッチして表示する方法を示しています。
import wandb
ARTIFACT_TYPE = "<TYPE>"
ORG_NAME = "<org_name>"
REGISTRY_NAME = "<registry_name>"
COLLECTION_NAME = "<collection_name>"
VERSION = "<artifact_version>"
artifact_name = f"{ORG_NAME}/wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}:v{VERSION}"
artifact = wandb.Api().artifact(name = artifact_name, type = artifact_type)
print(artifact.tags)
次のコードスニペットは、新しい run を作成して Artifacts バージョンのタグをフェッチして表示する方法を示しています。
import wandb
ORG_NAME = "<org_name>"
REGISTRY_NAME = "<registry_name>"
COLLECTION_NAME = "<collection_name>"
VERSION = "<artifact_version>"
run = wandb.init(entity = "<entity>", project="<project>")
artifact_name = f"{ORG_NAME}/wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}:v{VERSION}"
artifact = run.use_artifact(artifact_or_name = artifact_name)
print(artifact.tags)
W&B App UIを使用して、コレクションおよび Artifacts バージョンで既存のタグを検索します。
W&B Python SDK を使用して、タグのセットを持つ Artifacts バージョンを検索します。
import wandb
api = wandb.Api()
tagged_artifact_versions = api.artifacts(
type_name = "<artifact_type>",
name = "<artifact_name>",
tags = ["<tag_1>", "<tag_2>"]
)
for artifact_version in tagged_artifact_versions:
print(artifact_version.tags)
コレクションに人に優しいテキストを追加して、ユーザーがコレクションの目的とそれに含まれる Artifacts を理解できるようにします。
コレクションによっては、トレーニングデータ、モデルアーキテクチャー、タスク、ライセンス、参考文献、およびデプロイメントに関する情報を含めることをお勧めします。以下に、コレクションでドキュメント化する価値のあるトピックをいくつか示します。
W&B は、少なくとも以下の詳細を含めることを推奨します。
コレクションにトレーニングデータが含まれている場合は、次の詳細を含めることを検討してください。
コレクションに機械学習 モデルが含まれている場合は、次の詳細を含めることを検討してください。
W&B Registry UI または Python SDK を使用して、コレクションにインタラクティブまたはプログラムで説明を追加します。
wandb.Api().artifact_collection() メソッドを使用して、コレクションの説明にアクセスします。返されたオブジェクトの description プロパティを使用して、コレクションに説明を追加または更新します。
type_name パラメータにコレクションのタイプを指定し、name パラメータにコレクションのフルネームを指定します。コレクションの名前は、プレフィックス “wandb-registry”、レジストリの名前、およびフォワード スラッシュで区切られたコレクションの名前で構成されます。
wandb-registry-{REGISTRY_NAME}/{COLLECTION_NAME}
次のコード スニペットを Python スクリプトまたは ノートブック にコピーして貼り付けます。山かっこ (<>) で囲まれた値を独自の値に置き換えます。
import wandb
api = wandb.Api()
collection = api.artifact_collection(
type_name = "<collection_type>",
name = "<collection_name>"
)
collection.description = "This is a description."
collection.save()
たとえば、次の画像は、モデルのアーキテクチャー、意図された使用法、パフォーマンス情報などを文書化したコレクションを示しています。
W&B Registry内のコレクションでは、ML 実験で使用される Artifacts の履歴を表示できます。この履歴は リネージグラフ と呼ばれます。
コレクションの一部ではない、W&B に記録した Artifacts のリネージグラフも表示できます。
リネージグラフは、Artifacts を記録する特定の run を示すことができます。さらに、リネージグラフは、どの run が Artifacts を入力として使用したかを示すこともできます。言い換えれば、リネージグラフは run の入力と出力を示すことができます。
たとえば、以下の画像は、ML 実験全体で作成および使用された Artifacts を示しています。
左から右へ、画像は以下を示しています。
split_zoo_dataset:v4 アーティファクトを記録します。split_zoo_dataset:v4 アーティファクトを使用します。zoo-ylbchv20:v0 というモデルアーティファクトです。zoo-ylbchv20:v0 を使用してモデルを評価します。wandb.init.use_artifact API を使用して、Artifacts を run の入力または依存関係としてマークします。
以下のコードスニペットは、use_artifact の使用方法を示しています。山括弧 (< >) で囲まれた値を自分の値に置き換えてください。
import wandb
# Initialize a run
run = wandb.init(project="<project>", entity="<entity>")
# Get artifact, mark it as a dependency
artifact = run.use_artifact(artifact_or_name="<name>", aliases="<alias>")
Artifacts を run の出力として宣言するには、(wandb.init.log_artifact) を使用します。
以下のコードスニペットは、wandb.init.log_artifact API の使用方法を示しています。山括弧 (< >) で囲まれた値を必ず自分の値に置き換えてください。
import wandb
# Initialize a run
run = wandb.init(entity "<entity>", project = "<project>",)
artifact = wandb.Artifact(name = "<artifact_name>", type = "<artifact_type>")
artifact.add_file(local_path = "<local_filepath>", name="<optional-name>")
# Log the artifact as an output of the run
run.log_artifact(artifact_or_path = artifact)
Artifacts の作成に関する詳細については、Artifacts の作成 を参照してください。
W&B Registry でコレクションにリンクされた Artifacts のリネージを表示します。
Artifacts のリネージグラフページにアクセスすると、そのリネージグラフ内の任意のノードに関する追加情報を表示できます。
run の ID、run の名前、run の状態など、その run の詳細を表示するには、run ノードを選択します。例として、以下の画像は rural-feather-20 run に関する情報を示しています。
Artifacts のフルネーム、タイプ、作成時間、および関連するエイリアスなど、その Artifacts の詳細を表示するには、Artifacts ノードを選択します。
W&B は、レガシーな W&B Model Registry から新しい W&B Registry へとアセットを移行します。この移行は完全に W&B によって管理およびトリガーされ、 ユーザー からの介入は必要ありません。この プロセス は、既存の ワークフロー を最小限に中断するように、可能な限りシームレスになるように設計されています。
移行は、新しい W&B Registry が Model Registry で現在利用可能なすべての機能を含むと実行されます。W&B は、現在の ワークフロー 、 コード ベース、および参照を保持しようとします。
この ガイド は生きたドキュメントであり、より多くの情報が利用可能になるにつれて定期的に更新されます。ご質問やサポートについては、support@wandb.com までお問い合わせください。
W&B Registry は、 モデル 、 データセット 、およびその他の アーティファクト を管理するための、より堅牢で柔軟な 環境 を提供するように設計された、さまざまな新機能と拡張機能を紹介します。
レガシー Model Registry を表示するには、W&B アプリ の Model Registry に移動します。ページの上部にバナーが表示され、レガシー Model Registry アプリ UI を使用できます。
レガシー Model Registry にリンクされた Artifacts は、 チーム レベルの可視性を持ちます。これは、 チーム の メンバー のみがレガシー W&B Model Registry で Artifacts を表示できることを意味します。W&B Registry は、組織レベルの可視性を持ちます。これは、適切な 権限 を持つ組織全体の メンバー が、 レジストリ にリンクされた Artifacts を表示できることを意味します。
カスタム レジストリ を表示および アクセス できる ユーザー を制限します。カスタム レジストリ を作成するとき、またはカスタム レジストリ を作成した後に、 レジストリ への可視性を制限できます。制限された レジストリ では、選択された メンバー のみ コンテンツ に アクセス でき、 プライバシー と制御を維持します。レジストリ の可視性の詳細については、レジストリ の可視性タイプ を参照してください。
従来の Model Registry とは異なり、W&B Registry は モデル または データセット レジストリ に限定されません。特定の ワークフロー または プロジェクト のニーズに合わせて調整されたカスタム レジストリ を作成でき、任意の オブジェクト タイプを保持できます。この柔軟性により、 チーム は独自の要件に従って Artifacts を整理および管理できます。カスタム レジストリ の作成方法の詳細については、カスタム レジストリ を作成する を参照してください。
各 レジストリ は詳細な アクセス 制御をサポートしており、 メンバー には管理者、 メンバー 、または閲覧者などの特定の ロール を割り当てることができます。管理者は、 メンバー の追加または削除、 ロール の設定、可視性の構成など、 レジストリ の 設定 を管理できます。これにより、 チーム は レジストリ 内の Artifacts を表示、管理、および操作できる ユーザー を確実に制御できます。
登録済み モデル は、コレクションと呼ばれるようになりました。
| レガシー W&B Model Registry | W&B Registry | |
|---|---|---|
| Artifact の可視性 | チーム の メンバー のみ Artifacts を表示または アクセス できます | 組織内の メンバー は、適切な 権限 を持っていれば、 レジストリ にリンクされた Artifacts を表示または アクセス できます |
| カスタム アクセス 制御 | 利用不可 | 利用可能 |
| カスタム レジストリ | 利用不可 | 利用可能 |
| 用語の更新 | モデル バージョン への ポインター （リンク）の セット は、*登録済み モデル *と呼ばれます。 | アーティファクト バージョン への ポインター （リンク）の セット は、コレクションと呼ばれます。 |
wandb.init.link_model |
Model Registry 固有の API | 現在、レガシー Model Registry とのみ互換性があります |
W&B は、登録済みの モデル （現在はコレクションと呼ばれています）と、関連する Artifacts バージョン を、レガシー Model Registry から W&B Registry に移行します。この プロセス は自動的に実行され、 ユーザー からの アクション は必要ありません。
移行後、 モデル レジストリ は組織レベルの可視性を持つようになります。 ロール を割り当てる ことで、 レジストリ への アクセス 権を持つ ユーザー を制限できます。これにより、特定の メンバー のみが特定の レジストリ に アクセス できるようになります。
移行により、レガシー W&B Model Registry 内の現在の チーム レベルの登録済み モデル （まもなくコレクションと呼ばれるようになります）の既存の 権限 境界が保持されます。レガシー Model Registry で現在定義されている 権限 は、新しい Registry で保持されます。これは、現在特定の チーム メンバー に制限されているコレクションが、移行中および移行後も保護された状態を維持することを意味します。
現在、 アクション は必要ありません。
W&B は移行 プロセス を開始します。移行は、W&B サービス の中断を最小限に抑える時間帯に実行されます。レガシー Model Registry は、移行が開始されると読み取り専用状態に移行し、参照用に アクセス 可能な状態を維持します。
移行後、コレクション、 Artifacts バージョン 、および関連する 属性 は、新しい W&B Registry 内で完全に アクセス 可能になります。焦点は、現在の ワークフロー が確実にそのまま残るようにすることであり、変更をナビゲートするのに役立つ継続的なサポートが利用可能です。
ユーザー は、W&B Registry で利用可能な新機能と性能を調査することをお勧めします。Registry は、現在依存している機能をサポートするだけでなく、カスタム レジストリ 、可視性の向上、柔軟な アクセス 制御などの拡張機能も導入します。
早期に W&B Registry を試してみたい場合、または新しい ユーザー がレガシー W&B Model Registry ではなく Registry から開始したい場合は、サポートをご利用いただけます。この機能を有効にするには、support@wandb.com またはセールス MLE までご連絡ください。早期移行は BETA バージョン に移行することに注意してください。BETA バージョン の W&B Registry は、レガシー Model Registry のすべての機能または特徴を備えていない可能性があります。
詳細および W&B Registry のすべての機能の詳細については、W&B Registry ガイド を参照してください。
W&B は、新しい Registry でより高度な機能と性能を提供するために、 プラットフォーム を進化させています。この移行は、 モデル 、 データセット 、およびその他の Artifacts を管理するための、より統合された強力な ツール セット を提供するためのステップです。
移行前に ユーザー が行う必要のある アクション はありません。W&B が移行を処理し、 ワークフロー と参照が確実に保持されるようにします。
いいえ、 モデル Artifacts への アクセス は移行後も保持されます。レガシー Model Registry は読み取り専用状態のままになり、関連するすべての データ が新しい Registry に移行されます。
はい、 Artifacts の作成、 リネージ 、およびその他の 属性 に関連する重要な メタデータ は、移行中に保持されます。ユーザー は、移行後も関連するすべての メタデータ に引き続き アクセス でき、 Artifacts の 整合性 とトレーサビリティが確実に維持されるようにします。
ご質問やご不明な点がございましたら、サポートをご利用いただけます。サポートが必要な場合は、support@wandb.com までご連絡ください。
W&B は最終的に W&B Model Registry のサポートを停止します。 ユーザー は、代わりにモデルアーティファクトの バージョン をリンクおよび共有するために、W&B Registry を使用することをお勧めします。 W&B Registry は、従来の W&B Model Registry の機能を拡張します。 W&B Registry の詳細については、Registry のドキュメント を参照してください。
W&B は、従来の Model Registry にリンクされている既存のモデルアーティファクトを、近い将来、新しい W&B Registry に移行します。 移行 プロセス の詳細については、従来の Model Registry からの移行 を参照してください。
W&B Model Registry には、 ML 実践者がプロダクション 用の候補を公開し、ダウンストリーム の チーム や関係者が利用できる、 チーム がトレーニング したモデルが格納されています。 これは、ステージング されたモデル/候補モデルを格納し、ステージング に関連する ワークフロー を管理するために使用されます。
W&B Model Registry では、次のことが可能です。
いくつかの簡単なステップで、ステージング されたモデルを追跡および管理します。
次の コード スニペット は、モデルを ログ に記録して Model Registry にリンクする方法を示しています。
import wandb
import random
# Start a new W&B run
run = wandb.init(project="models_quickstart")
# Simulate logging model metrics
run.log({"acc": random.random()})
# Create a simulated model file
with open("my_model.h5", "w") as f:
f.write("Model: " + str(random.random()))
# Log and link the model to the Model Registry
run.link_model(path="./my_model.h5", registered_model_name="MNIST")
run.finish()
ユースケース に応じて、次の リソース を調べて W&B Models の使用を開始してください。
以下のチュートリアルでは、モデルを W&B に記録する方法を紹介します。このチュートリアルを終えるまでに、以下のことができるようになります。
始める前に、このチュートリアルに必要な Python の依存関係をインポートします。
import wandb
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
from wandb.integration.keras import WandbMetricsLogger
from sklearn.model_selection import train_test_split
W&B の entity を entity 変数に指定します。
entity = "<entity>"
まず、データセットを作成します。次の コード スニペットは、MNIST データセットをダウンロードする関数を作成します。
def generate_raw_data(train_size=6000):
eval_size = int(train_size / 6)
(x_train, y_train), (x_eval, y_eval) = keras.datasets.mnist.load_data()
x_train = x_train.astype("float32") / 255
x_eval = x_eval.astype("float32") / 255
x_train = np.expand_dims(x_train, -1)
x_eval = np.expand_dims(x_eval, -1)
print("Generated {} rows of training data.".format(train_size))
print("Generated {} rows of eval data.".format(eval_size))
return (x_train[:train_size], y_train[:train_size]), (
x_eval[:eval_size],
y_eval[:eval_size],
)
# データセットを作成します
(x_train, y_train), (x_eval, y_eval) = generate_raw_data()
次に、データセットを W&B にアップロードします。これを行うには、アーティファクト オブジェクトを作成し、そのアーティファクトにデータセットを追加します。
project = "model-registry-dev"
model_use_case_id = "mnist"
job_type = "build_dataset"
# W&B の run を初期化します
run = wandb.init(entity=entity, project=project, job_type=job_type)
# トレーニングデータ用の W&B テーブルを作成します
train_table = wandb.Table(data=[], columns=[])
train_table.add_column("x_train", x_train)
train_table.add_column("y_train", y_train)
train_table.add_computed_columns(lambda ndx, row: {"img": wandb.Image(row["x_train"])})
# 評価データ用の W&B テーブルを作成します
eval_table = wandb.Table(data=[], columns=[])
eval_table.add_column("x_eval", x_eval)
eval_table.add_column("y_eval", y_eval)
eval_table.add_computed_columns(lambda ndx, row: {"img": wandb.Image(row["x_eval"])})
# Artifact オブジェクトを作成します
artifact_name = "{}_dataset".format(model_use_case_id)
artifact = wandb.Artifact(name=artifact_name, type="dataset")
# wandb.WBValue オブジェクトを Artifact に追加します。
artifact.add(train_table, "train_table")
artifact.add(eval_table, "eval_table")
# Artifact に加えられた変更を永続化します。
artifact.save()
# W&B にこの run が完了したことを伝えます。
run.finish()
前のステップで作成した Artifact データセットを使用してモデルをトレーニングします。
前のステップで作成したデータセット Artifact を W&B の run への入力として宣言します。Artifact を run への入力として宣言すると、特定のモデルのトレーニングに使用されたデータセット (およびデータセットの version) を追跡できるため、モデルのログを記録する際に特に役立ちます。W&B は、収集された情報を使用して、リネージマップ を作成します。
use_artifact API を使用して、データセット Artifact を run の入力として宣言し、Artifact 自体を取得します。
job_type = "train_model"
config = {
"optimizer": "adam",
"batch_size": 128,
"epochs": 5,
"validation_split": 0.1,
}
# W&B の run を初期化します
run = wandb.init(project=project, job_type=job_type, config=config)
# データセット Artifact を取得します
version = "latest"
name = "{}:{}".format("{}_dataset".format(model_use_case_id), version)
artifact = run.use_artifact(artifact_or_name=name)
# データフレームから特定の内容を取得します
train_table = artifact.get("train_table")
x_train = train_table.get_column("x_train", convert_to="numpy")
y_train = train_table.get_column("y_train", convert_to="numpy")
モデルの入力と出力を追跡する方法の詳細については、モデルリネージ マップの作成を参照してください。
このチュートリアルでは、Keras を使用して MNIST データセットから画像を分類する 2D Convolutional Neural Network (CNN) を定義します。
# 設定ディクショナリの値を簡単にアクセスできるように変数に格納します
num_classes = 10
input_shape = (28, 28, 1)
loss = "categorical_crossentropy"
optimizer = run.config["optimizer"]
metrics = ["accuracy"]
batch_size = run.config["batch_size"]
epochs = run.config["epochs"]
validation_split = run.config["validation_split"]
# モデルアーキテクチャを作成します
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)
# トレーニングデータのラベルを生成します
y_train = keras.utils.to_categorical(y_train, num_classes)
# トレーニングセットとテストセットを作成します
x_t, x_v, y_t, y_v = train_test_split(x_train, y_train, test_size=0.33)
次に、モデルをトレーニングします。
# モデルをトレーニングします
model.fit(
x=x_t,
y=y_t,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_v, y_v),
callbacks=[WandbCallback(log_weights=True, log_evaluation=True)],
)
最後に、モデルをローカルマシンに保存します。
# モデルをローカルに保存します
path = "model.h5"
model.save(path)
link_model API を使用して、モデルの 1 つ以上のファイルを W&B の run に記録し、W&B モデルレジストリ にリンクします。
path = "./model.h5"
registered_model_name = "MNIST-dev"
run.link_model(path=path, registered_model_name=registered_model_name)
run.finish()
registered-model-name に指定した名前がまだ存在しない場合、W&B は登録済みモデルを作成します。
オプションのパラメータの詳細については、API リファレンスガイドのlink_model を参照してください。
1 つ以上のモデルのパフォーマンスを評価するのは一般的な方法です。
まず、前のステップで W&B に保存された評価データセット Artifact を取得します。
job_type = "evaluate_model"
# run を初期化します
run = wandb.init(project=project, entity=entity, job_type=job_type)
model_use_case_id = "mnist"
version = "latest"
# データセット Artifact を取得し、依存関係としてマークします
artifact = run.use_artifact(
"{}:{}".format("{}_dataset".format(model_use_case_id), version)
)
# 目的のデータフレームを取得します
eval_table = artifact.get("eval_table")
x_eval = eval_table.get_column("x_eval", convert_to="numpy")
y_eval = eval_table.get_column("y_eval", convert_to="numpy")
評価する W&B から モデル version をダウンロードします。use_model API を使用して、モデルにアクセスしてダウンロードします。
alias = "latest" # エイリアス
name = "mnist_model" # モデル Artifact の名前
# モデルにアクセスしてダウンロードします。ダウンロードした Artifact へのパスを返します
downloaded_model_path = run.use_model(name=f"{name}:{alias}")
Keras モデルをロードし、損失を計算します。
model = keras.models.load_model(downloaded_model_path)
y_eval = keras.utils.to_categorical(y_eval, 10)
(loss, _) = model.evaluate(x_eval, y_eval)
score = (loss, _)
最後に、損失メトリクスを W&B の run に記録します。
# # メトリクス、画像、テーブル、または評価に役立つデータを記録します。
run.log(data={"loss": (loss, _)})
モデル エイリアス を使用して、機械学習 ワークフローの次の段階に向けてモデル version を準備完了としてマークします。各登録済みモデルには、1 つ以上のモデル エイリアスを設定できます。モデル エイリアスは、一度に 1 つのモデル version にのみ属することができます。
たとえば、モデルのパフォーマンスを評価した後、そのモデルが production の準備ができていると確信したとします。そのモデル version を昇格させるには、production エイリアスをその特定のモデル version に追加します。
production エイリアスは、モデルを production 準備完了としてマークするために使用される最も一般的なエイリアスの 1 つです。W&B アプリ UI を使用してインタラクティブに、または Python SDK を使用してプログラムで、モデル version にエイリアスを追加できます。次の手順では、W&B モデルレジストリアプリでエイリアスを追加する方法を示します。
production と入力します。
W&B の モデルレジストリ の主要コンポーネントは、以下の用語で説明されます。モデル バージョン, モデル artifact, そして registered model。
モデル バージョンは、単一のモデル チェックポイント を表します。モデル バージョンは、実験 内におけるモデルとそのファイルの特定時点での スナップショット です。
モデル バージョンは、トレーニング されたモデルを記述するデータと メタデータ の不変の ディレクトリー です。W&B は、モデルの アーキテクチャー と学習済み パラメータ を後で保存（および復元）できるように、モデル バージョンにファイルを追加することをお勧めします。
モデル バージョンは、1つの モデル artifact にのみ属します。モデル バージョンは、ゼロまたは複数の registered model に属することができます。モデル バージョンは、モデル artifact に ログ された順にモデル artifact に保存されます。W&B は、(同じモデル artifact に) ログ するモデルの内容が以前のモデル バージョンと異なる場合、新しいモデル バージョンを自動的に作成します。
モデリング ライブラリ (たとえば、PyTorch や Keras) によって提供されるシリアル化 プロセス から生成されたファイルをモデル バージョン内に保存します。
モデル エイリアス は、 registered model 内のモデル バージョンを、セマンティックに関連する識別子で一意に識別または参照できる、変更可能な文字列です。エイリアス は、 registered model の 1 つの バージョン にのみ割り当てることができます。これは、 エイリアス がプログラムで使用される場合に一意の バージョン を参照する必要があるためです。また、 エイリアス を使用してモデルの状態 (チャンピオン、候補、本番) をキャプチャすることもできます。
"best"、"latest"、"production"、"staging" などの エイリアス を使用して、特別な目的を持つモデル バージョン をマークするのが一般的な方法です。
たとえば、モデルを作成し、それに "best" エイリアス を割り当てるとします。run.use_model でその特定のモデルを参照できます。
import wandb
run = wandb.init()
name = f"{entity/project/model_artifact_name}:{alias}"
run.use_model(name=name)
モデル タグ は、1 つまたは複数の registered model に属する キーワード または ラベル です。
モデル タグ を使用して、 registered model を カテゴリ に整理し、 モデルレジストリ の検索バーでそれらの カテゴリ を検索します。モデル タグ は、 Registered Model Card の上部に表示されます。これらを使用して、 registered model を ML タスク 、所有 チーム 、または 優先度 でグループ化することもできます。同じモデル タグ を複数の registered model に追加して、グループ化できます。
モデル artifact は、 ログ された モデル バージョン のコレクションです。モデル バージョンは、モデル artifact に ログ された順にモデル artifact に保存されます。
モデル artifact には、1 つ以上のモデル バージョン を含めることができます。モデル バージョン が ログ されていない場合、モデル artifact は空になる可能性があります。
たとえば、モデル artifact を作成するとします。モデル トレーニング 中に、 チェックポイント 中にモデルを定期的に保存します。各 チェックポイント は、独自の モデル バージョン に対応します。モデル トレーニング 中に作成され、 チェックポイント の保存されたすべてのモデル バージョン は、 トレーニング スクリプト の開始時に作成した同じモデル artifact に保存されます。
次の図は、v0、v1、v2 の 3 つのモデル バージョン を含むモデル artifact を示しています。
モデル artifact の例はこちら でご覧ください。
Registered model は、モデル バージョン への ポインタ (リンク) のコレクションです。registered model は、同じ ML タスク の候補モデルの「 ブックマーク 」の フォルダー と考えることができます。registered model の各「 ブックマーク 」は、モデル artifact に属する モデル バージョン への ポインタ です。モデル タグ を使用して、 registered model をグループ化できます。
Registered model は、多くの場合、単一のモデリング ユースケース または タスク の候補モデルを表します。たとえば、使用するモデルに基づいて、さまざまな 画像分類 タスク の registered model を作成する場合があります:ImageClassifier-ResNet50、ImageClassifier-VGG16、DogBreedClassifier-MobileNetV2 など。モデル バージョン には、 registered model にリンクされた順に バージョン 番号が割り当てられます。
Registered Model の例はこちら でご覧ください。
W&B Python SDKで、モデル、モデルの依存関係、およびそのモデルに関連するその他の情報を追跡します。
W&Bは内部で、モデル Artifact のリネージを作成します。これは、W&B App UIで表示したり、W&B Python SDKでプログラム的に表示したりできます。詳細については、モデルリネージマップの作成 を参照してください。
モデルをログに記録するには、run.log_model APIを使用します。モデルファイルが保存されているパスを path パラメータに指定します。パスは、ローカルファイル、ディレクトリー、または s3://bucket/path などの外部バケットへの参照URI にすることができます。
オプションで、name パラメータにモデル Artifactの名前を指定します。name が指定されていない場合、W&Bはrun IDを先頭に付加した入力パスのベース名を使用します。
以下のコードスニペットをコピーして貼り付けます。<> で囲まれた値は、ご自身の値に置き換えてください。
import wandb
# W&B runを初期化する
run = wandb.init(project="<project>", entity="<entity>")
# モデルをログに記録する
run.log_model(path="<path-to-model>", name="<name>")
以下のコード例は、畳み込みニューラルネットワーク (CNN) モデルをW&Bにログする方法を示しています。
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-project", 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)
# モデルをログに記録する
run.log_model(path=full_path, name="MNIST")
# W&B に run を終了することを明示的に伝える。
run.finish()
モデリングタスクのすべての候補モデルを保持するために、registered modelを作成します。 registered model は、Model Registry 内でインタラクティブに、または Python SDK でプログラム的に作成できます。
W&B Python SDK でモデルをプログラム的に登録します。 registered model が存在しない場合、W&B は自動的に registered model を作成します。
必ず、<> で囲まれた値を独自の値に置き換えてください。
import wandb
run = wandb.init(entity="<entity>", project="<project>")
run.link_model(path="<path-to-model>", registered_model_name="<registered-model-name>")
run.finish()
registered_model_name に指定した名前は、Model Registry App に表示される名前です。
Model Registry App 内でインタラクティブに registered model を作成します。
モデルを Model Registry に手動でリンクすることは、1 回限りのモデルに役立ちます。ただし、多くの場合、プログラムでモデルバージョンを Model Registry にリンクすることが役立ちます。
たとえば、毎晩のジョブがあるとします。毎晩作成されるモデルを手動でリンクするのは面倒です。代わりに、モデルを評価するスクリプトを作成し、モデルのパフォーマンスが向上した場合、W&B Python SDK を使用してそのモデルを Model Registry にリンクすることができます。
W&B Appまたは Python SDK で、モデルのバージョンを登録済みモデルにリンクします。
link_model メソッドを使用して、モデルファイルをプログラムで W&B の run に ログ し、それをW&B モデルレジストリにリンクします。
必ず <> で囲まれた値を独自の値に置き換えてください。
import wandb
run = wandb.init(entity="<entity>", project="<project>")
run.link_model(path="<path-to-model>", registered_model_name="<登録済みモデル名>")
run.finish()
registered-model-name パラメータに指定した名前がまだ存在しない場合、W&B によって登録済みモデルが作成されます。
たとえば、モデルレジストリに「Fine-Tuned-Review-Autocompletion 」(registered-model-name="Fine-Tuned-Review-Autocompletion") という名前の既存の登録済みモデルがあるとします。また、いくつかのモデルバージョンがそれ(v0、v1、v2)にリンクされているとします。新しいモデルをプログラムでリンクし、同じ登録済みモデル名 (registered-model-name="Fine-Tuned-Review-Autocompletion") を使用すると、W&B はこのモデルを既存の登録済みモデルにリンクし、モデルバージョン v3 を割り当てます。この名前の登録済みモデルが存在しない場合は、新しい登録済みモデルが作成され、モデルバージョン v0 が割り当てられます。
“Fine-Tuned-Review-Autocompletion” 登録済みモデルの例はこちらをご覧ください。
モデルレジストリまたは Artifact ブラウザを使用して、インタラクティブにモデルをリンクします。
https://wandb.ai/<entity>/<project>/artifacts
リンクされたモデルのソースを表示する方法は 2 つあります。モデルが ログ されている project 内の Artifact ブラウザと W&B モデルレジストリです。
ポインタは、モデルレジストリ内の特定のモデルバージョンをソース モデル artifact (モデルが ログ されている project 内にある) に接続します。ソース モデル artifact には、モデルレジストリへのポインタもあります。
たとえば、次の図は、MNIST-dev という名前の登録済みモデルにリンクされた mnist_model という名前の v0 モデル バージョンを示しています (ソースバージョン フィールド mnist_model:v0 を参照)。
https://wandb.ai/<entity>/<project>/artifactsregistered-model-name:version) の両方が表示されます。たとえば、次の図では、MNIST-dev という名前の登録済みモデルがあります (リンク先 フィールドを参照)。バージョン v0 (mnist_model:v0) を持つ mnist_model という名前のモデル バージョンは、MNIST-dev 登録済みモデルを指しています。
モデルタグを使用すると、登録されたモデルをカテゴリに分類し、それらのカテゴリを検索できます。
https://wandb.ai/registry/model の W&B Model Registry アプリケーションに移動します。
モデルタグを追加する登録済みモデルの名前の横にある View details（詳細を見る） を選択します。
Model card（モデルカード） セクションまでスクロールします。
Tags（タグ） フィールドの横にあるプラスボタン（+）をクリックします。
タグの名前を入力するか、既存のモデルタグを検索します。 たとえば、次の図は、FineTuned-Review-Autocompletion という登録済みモデルに追加された複数のモデルタグを示しています。
このページでは、従来の W&B Model Registry でリネージグラフを作成する方法について説明します。W&B Registry のリネージグラフについては、リネージマップの作成と表示を参照してください。
モデル アーティファクト を W&B に ログ 記録する便利な機能は、リネージグラフです。リネージグラフは、 run によって ログ 記録された アーティファクト と、特定の run で使用された アーティファクト を示します。
つまり、モデル アーティファクト を ログ 記録すると、少なくともモデル アーティファクト を使用または生成した W&B の run を表示できます。依存関係を追跡する場合、モデル アーティファクト で使用される入力も表示されます。
たとえば、次の図は、ML 実験 全体で作成および使用された アーティファクト を示しています。
左から右へ、画像は以下を示しています。
jumping-monkey-1 W&B run は、mnist_dataset:v0 データセット アーティファクト を作成しました。vague-morning-5 W&B run は、mnist_dataset:v0 データセット アーティファクト を使用してモデルをトレーニングしました。この W&B run の出力は、mnist_model:v0 というモデル アーティファクト でした。serene-haze-6 という run は、モデル アーティファクト ( mnist_model:v0) を使用してモデルを評価しました。use_artifact API を使用して、データセット アーティファクト を W&B run への入力として宣言し、依存関係を追跡します。
次の コード スニペット は、use_artifact API の使用方法を示しています。
# run を初期化する
run = wandb.init(project=project, entity=entity)
# アーティファクト を取得し、依存関係としてマークします
artifact = run.use_artifact(artifact_or_name="name", aliases="<alias>")
アーティファクト を取得したら、その アーティファクト を使用して (たとえば) モデルのパフォーマンスを評価できます。
job_type = "train_model"
config = {
"optimizer": "adam",
"batch_size": 128,
"epochs": 5,
"validation_split": 0.1,
}
run = wandb.init(project=project, job_type=job_type, config=config)
version = "latest"
name = "{}:{}".format("{}_dataset".format(model_use_case_id), version)
artifact = run.use_artifact(name)
train_table = artifact.get("train_table")
x_train = train_table.get_column("x_train", convert_to="numpy")
y_train = train_table.get_column("y_train", convert_to="numpy")
# config 辞書 からの値を簡単にアクセスできるように変数に格納します
num_classes = 10
input_shape = (28, 28, 1)
loss = "categorical_crossentropy"
optimizer = run.config["optimizer"]
metrics = ["accuracy"]
batch_size = run.config["batch_size"]
epochs = run.config["epochs"]
validation_split = run.config["validation_split"]
# モデル アーキテクチャ を作成する
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)
# トレーニング データ のラベルを生成する
y_train = keras.utils.to_categorical(y_train, num_classes)
# トレーニング セット と テスト セット を作成する
x_t, x_v, y_t, y_v = train_test_split(x_train, y_train, test_size=0.33)
# モデルをトレーニングする
model.fit(
x=x_t,
y=y_t,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_v, y_v),
callbacks=[WandbCallback(log_weights=True, log_evaluation=True)],
)
# モデルをローカルに保存する
path = "model.h5"
model.save(path)
path = "./model.h5"
registered_model_name = "MNIST-dev"
name = "mnist_model"
run.link_model(path=path, registered_model_name=registered_model_name, name=name)
run.finish()
登録済みモデルのモデルカードに説明を追加して、 機械学習 モデルの側面を文書化します。文書化する価値のあるトピックには、次のものがあります。
たとえば、次の図は、Credit-card Default Prediction 登録済みモデルのモデルカードを示しています。
W&B Python SDK を使用して、Model Registry にリンクしたモデル artifact をダウンロードします。
モデルを再構築し、デシリアライズして、操作できる形式にするための追加の Python 関数、API 呼び出しはお客様の責任で提供する必要があります。
W&B では、モデルをメモリにロードする方法に関する情報をモデルカードに記載することをお勧めします。詳細については、機械学習モデルのドキュメント ページを参照してください。
<> 内の values はお客様ご自身のものに置き換えてください。
import wandb
# run を初期化する
run = wandb.init(project="<project>", entity="<entity>")
# モデルにアクセスしてダウンロードします。ダウンロードした artifact への path を返します
downloaded_model_path = run.use_model(name="<your-model-name>")
以下のいずれかの形式でモデル version を参照してください。
latest - 最新の latest エイリアスを使用して、最も新しくリンクされたモデル version を指定します。v# - v0、v1、v2 などを使用して、Registered Model 内の特定の version を取得しますalias - ユーザー と Teams がモデル version に割り当てたカスタム alias を指定します可能なパラメータと戻り値の型について詳しくは、API Reference ガイドのuse_model を参照してください。
たとえば、次のコード snippet では、ユーザー が use_model API を呼び出しました。フェッチするモデル artifact の名前を指定し、version/alias も指定しました。次に、API から返された path を downloaded_model_path 変数に格納しました。
import wandb
entity = "luka"
project = "NLP_Experiments"
alias = "latest" # モデル version のセマンティックなニックネームまたは識別子
model_artifact_name = "fine-tuned-model"
# run を初期化する
run = wandb.init()
# モデルにアクセスしてダウンロードします。ダウンロードした artifact への path を返します
downloaded_model_path = run.use_model(name=f"{entity/project/model_artifact_name}:{alias}")
次のタブは、まもなく廃止される Model Registry を使用してモデル artifact を消費する方法を示しています。
W&B Registry を使用して、モデル artifact を追跡、整理、消費します。詳細については、Registry docsを参照してください。
<> 内の values はお客様ご自身のものに置き換えてください。
import wandb
# run を初期化する
run = wandb.init(project="<project>", entity="<entity>")
# モデルにアクセスしてダウンロードします。ダウンロードした artifact への path を返します
downloaded_model_path = run.use_model(name="<your-model-name>")
以下のいずれかの形式でモデル version を参照してください。
latest - 最新の latest エイリアスを使用して、最も新しくリンクされたモデル version を指定します。v# - v0、v1、v2 などを使用して、Registered Model 内の特定の version を取得しますalias - ユーザー と Teams がモデル version に割り当てたカスタム alias を指定します可能なパラメータと戻り値の型について詳しくは、API Reference ガイドのuse_model を参照してください。
新しいモデル バージョンがモデルレジストリにリンクされたときに、Slack通知を受信します。
チームの Slack 通知を設定すると、通知を受信する Registered Model を選択できます。
以下のスクリーンショットは、Slack 通知が設定されている FMNIST 分類器の Registered Model を示しています。
新しいモデル バージョンが FMNIST 分類器の Registered Model にリンクされるたびに、メッセージが接続された Slack チャンネルに自動的に投稿されます。
モデル開発 パイプライン の主要な段階を表すために、 保護されたエイリアス を使用します。 モデルレジストリ管理者 のみが、保護されたエイリアスを追加、変更、または削除できます。モデルレジストリ管理者は、保護されたエイリアスを定義して使用できます。W&B は、管理者以外の ユーザー がモデル バージョン から保護されたエイリアスを追加または削除することをブロックします。
たとえば、 staging と production を保護されたエイリアスとして設定するとします。Team のメンバーは誰でも新しいモデル バージョンを追加できます。ただし、管理者のみが staging または production エイリアスを追加できます。
次の手順では、Team の モデルレジストリ の アクセス 制御を設定する方法について説明します。
W&B Reports の用途:
次の画像は、トレーニングの過程で W&B に ログ された メトリクス から作成された レポート のセクションを示しています。
上記の画像が取得された レポート は こちら からご覧ください。
数回クリックするだけで、コラボレーティブな レポート を作成できます。
W&B Python SDK を使用して インタラクティブ およびプログラムで レポート を作成する方法の詳細については、レポート の作成 ページを参照してください。
ユースケース に応じて、次のリソースを調べて W&B Reports を開始してください。
Experiments と ログ の ベストプラクティス とヒントについては、Best Practices: Reports を参照してください。
W&B App UI または W&B Python SDK を使用して、プログラムでインタラクティブに report を作成します。
W&B App で project の workspace に移動します。
workspace の右上隅にある [Create report] をクリックします。
モーダルが表示されます。最初に表示するグラフを選択します。グラフは report インターフェイスから後で追加または削除できます。
[Filter run sets] オプションを選択して、新しい run が report に追加されないようにします。このオプションはオン/オフを切り替えることができます。[Create report] をクリックすると、下書き report が report タブで使用できるようになり、作業を続けることができます。
W&B App で project の workspace に移動します。
project の [Reports] タブ (クリップボードの画像) を選択します。
report ページで [Create Report] ボタンを選択します。
wandb ライブラリを使用して、プログラムで report を作成します。
W&B SDK と Workspaces API をインストールします。
pip install wandb wandb-workspaces
次に、ワークスペースをインポートします。
import wandb
import wandb_workspaces.reports.v2 as wr
wandb_workspaces.reports.v2.Report を使用して report を作成します。Report Class Public API (wandb.apis.reports) を使用して report インスタンスを作成します。 project の名前を指定します。
report = wr.Report(project="report_standard")
report を保存します。Reports は、.save() メソッドを呼び出すまで W&B サーバーにアップロードされません。
report.save()
App UI またはプログラムで report をインタラクティブに編集する方法については、Edit a report を参照してください。
App UIまたは W&B SDKでプログラム的に、インタラクティブにレポートを編集できます。
Reports は ブロック で構成されています。ブロックはレポートの本文を構成します。これらのブロック内には、テキスト、画像、埋め込み 可視化、実験からのプロットと run、および パネル グリッドを追加できます。
パネル グリッド は、パネルと run sets を保持する特定のタイプのブロックです。Run sets は、W&B のプロジェクトに記録された runs の集合です。パネルは run set データの 可視化です。
レポートをプログラムで編集する場合は、W&B Python SDKに加えて wandb-workspaces がインストールされていることを確認してください。
pip install wandb wandb-workspaces
各パネル グリッドには、run sets のセットとパネルのセットがあります。セクションの下部にある run sets は、グリッド内のパネルに表示されるデータを制御します。異なる runs のセットからデータを取得するグラフを追加する場合は、新しいパネル グリッドを作成します。
レポートにスラッシュ (/) を入力して、ドロップダウン メニューを表示します。[パネルを追加] を選択して、パネルを追加します。折れ線グラフ、散布図、平行座標グラフなど、W&B でサポートされている任意のパネルを追加できます。
SDKを使用して、プログラムでプロットをレポートに追加します。1つ以上のプロットまたはグラフ オブジェクトのリストを PanelGrid Public API Classの panels パラメータに渡します。関連するPythonクラスを使用してプロットまたはグラフ オブジェクトを作成します。
次の例は、折れ線グラフと散布図を作成する方法を示しています。
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(
project="report-editing",
title="An amazing title",
description="A descriptive description.",
)
blocks = [
wr.PanelGrid(
panels=[
wr.LinePlot(x="time", y="velocity"),
wr.ScatterPlot(x="time", y="acceleration"),
]
)
]
report.blocks = blocks
report.save()
プログラムでレポートに追加できる利用可能なプロットとグラフの詳細については、wr.panels を参照してください。
App UIまたは W&B SDKを使用して、プロジェクトからrun setsをインタラクティブに追加します。
レポートにスラッシュ (/) を入力して、ドロップダウン メニューを表示します。ドロップダウンから、[パネル グリッド] を選択します。これにより、レポートが作成されたプロジェクトから run set が自動的にインポートされます。
wr.Runset() および wr.PanelGrid クラスを使用して、プロジェクトから run sets を追加します。次の手順では、run set を追加する方法について説明します。
wr.Runset() オブジェクト インスタンスを作成します。プロジェクトの run sets が含まれるプロジェクトの名前を project パラメータに、プロジェクトを所有するエンティティを entity パラメータに指定します。wr.PanelGrid() オブジェクト インスタンスを作成します。1つ以上の run set オブジェクトのリストを runsets パラメータに渡します。wr.PanelGrid() オブジェクト インスタンスをリストに格納します。import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(
project="report-editing",
title="An amazing title",
description="A descriptive description.",
)
panel_grids = wr.PanelGrid(
runsets=[wr.RunSet(project="<project-name>", entity="<entity-name>")]
)
report.blocks = [panel_grids]
report.save()
オプションで、SDKへの1回の呼び出しで run sets とパネルを追加できます。
import wandb
report = wr.Report(
project="report-editing",
title="An amazing title",
description="A descriptive description.",
)
panel_grids = wr.PanelGrid(
panels=[
wr.LinePlot(
title="line title",
x="x",
y=["y"],
range_x=[0, 100],
range_y=[0, 100],
log_x=True,
log_y=True,
title_x="x axis title",
title_y="y axis title",
ignore_outliers=True,
groupby="hyperparam1",
groupby_aggfunc="mean",
groupby_rangefunc="minmax",
smoothing_factor=0.5,
smoothing_type="gaussian",
smoothing_show_original=True,
max_runs_to_show=10,
plot_type="stacked-area",
font_size="large",
legend_position="west",
),
wr.ScatterPlot(
title="scatter title",
x="y",
y="y",
# z='x',
range_x=[0, 0.0005],
range_y=[0, 0.0005],
# range_z=[0,1],
log_x=False,
log_y=False,
# log_z=True,
running_ymin=True,
running_ymean=True,
running_ymax=True,
font_size="small",
regression=True,
),
],
runsets=[wr.RunSet(project="<project-name>", entity="<entity-name>")],
)
report.blocks = [panel_grids]
report.save()
レポートは、プロジェクトからの最新のデータを表示するために、run sets を自動的に更新します。Run set を固定 することで、レポート内の run set を保持できます。Run set を固定すると、ある時点でのレポート内の run set の状態が保持されます。
レポートの表示中に run set を固定するには、[フィルタ] ボタンの近くにあるパネル グリッド内の雪のアイコンをクリックします。
App UIまたは W&B SDKを使用して、インタラクティブにコード ブロックをレポートに追加します。
レポートにスラッシュ (/) を入力して、ドロップダウン メニューを表示します。ドロップダウンから [コード] を選択します。
コード ブロックの右側にあるプログラミング言語の名前を選択します。これにより、ドロップダウンが展開されます。ドロップダウンから、プログラミング言語の構文を選択します。Javascript、Python、CSS、JSON、HTML、Markdown、および YAML から選択できます。
wr.CodeBlock クラスを使用して、プログラムでコード ブロックを作成します。それぞれ言語パラメータとコード パラメータに表示する言語の名前とコードを指定します。
たとえば、次の例は YAML ファイルのリストを示しています。
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.CodeBlock(
code=["this:", "- is", "- a", "cool:", "- yaml", "- file"], language="yaml"
)
]
report.save()
これにより、次のようなコード ブロックがレンダリングされます。
this:
- is
- a
cool:
- yaml
- file
次の例は、Pythonコード ブロックを示しています。
report = wr.Report(project="report-editing")
report.blocks = [wr.CodeBlock(code=["Hello, World!"], language="python")]
report.save()
これにより、次のようなコード ブロックがレンダリングされます。
Hello, World!
App UIまたは W&B SDKを使用して、インタラクティブに Markdown をレポートに追加します。
レポートにスラッシュ (/) を入力して、ドロップダウン メニューを表示します。ドロップダウンから [Markdown] を選択します。
wandb.apis.reports.MarkdownBlock クラスを使用して、プログラムで Markdown ブロックを作成します。文字列を text パラメータに渡します。
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.MarkdownBlock(text="Markdown cell with *italics* and **bold** and $e=mc^2$")
]
これにより、次のような Markdown ブロックがレンダリングされます。
App UIまたは W&B SDKを使用して、インタラクティブに HTML 要素をレポートに追加します。
レポートにスラッシュ (/) を入力して、ドロップダウン メニューを表示します。ドロップダウンからテキスト ブロックのタイプを選択します。たとえば、H2 見出しブロックを作成するには、[見出し 2] オプションを選択します。
1つ以上のHTML要素のリストを wandb.apis.reports.blocks 属性に渡します。次の例は、H1、H2、および順序なしリストを作成する方法を示しています。
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.H1(text="How Programmatic Reports work"),
wr.H2(text="Heading 2"),
wr.UnorderedList(items=["Bullet 1", "Bullet 2"]),
]
report.save()
これにより、HTML要素が次のようにレンダリングされます。
App UIまたは W&B SDKを使用して、レポート内にリッチ メディアを埋め込みます。
URLをコピーしてレポートに貼り付け、レポート内にリッチ メディアを埋め込みます。次のアニメーションは、Twitter、YouTube、および SoundCloud から URL をコピーして貼り付ける方法を示しています。
ツイート リンクの URL をコピーしてレポートに貼り付け、レポート内でツイートを表示します。
YouTube ビデオの URL リンクをコピーして貼り付け、ビデオをレポートに埋め込みます。
SoundCloud リンクをコピーして貼り付け、オーディオ ファイルをレポートに埋め込みます。
1つ以上の埋め込みメディア オブジェクトのリストを wandb.apis.reports.blocks 属性に渡します。次の例は、ビデオと Twitter メディアをレポートに埋め込む方法を示しています。
import wandb
import wandb_workspaces.reports.v2 as wr
report = wr.Report(project="report-editing")
report.blocks = [
wr.Video(url="https://www.youtube.com/embed/6riDJMI-Y8U"),
wr.Twitter(
embed_html='<blockquote class="twitter-tweet"><p lang="en" dir="ltr">The voice of an angel, truly. <a href="https://twitter.com/hashtag/MassEffect?src=hash&ref_src=twsrc%5Etfw">#MassEffect</a> <a href="https://t.co/nMev97Uw7F">pic.twitter.com/nMev97Uw7F</a></p>— Mass Effect (@masseffect) <a href="https://twitter.com/masseffect/status/1428748886655569924?ref_src=twsrc%5Etfw">August 20, 2021</a></blockquote>\n'
),
]
report.save()
再利用したいレイアウトがある場合は、パネル グリッドを選択してコピーして貼り付け、同じレポートに複製したり、別のレポートに貼り付けたりすることもできます。
右上隅にあるドラッグ ハンドルを選択して、パネル グリッド セクション全体を強調表示します。クリックしてドラッグして、パネル グリッド、テキスト、見出しなどのレポート内の領域を強調表示して選択します。
パネル グリッドを選択し、キーボードの delete を押してパネル グリッドを削除します。
Report のヘッダーを折りたたんで、テキスト ブロック内のコンテンツを非表示にします。レポートが読み込まれると、展開されているヘッダーのみがコンテンツを表示します。レポートでヘッダーを折りたたむと、コンテンツを整理し、過剰なデータ読み込みを防ぐことができます。次の gif は、そのプロセスを示しています。
複数の次元にわたる関係を効果的に 可視化 するには、カラー グラデーションを使用して変数の1つを表します。これにより、明瞭さが向上し、パターンが解釈しやすくなります。
レポートを保存したら、Shareボタンを選択して共同作業ができます。Editボタンを選択すると、レポートのドラフトコピーが作成されます。ドラフトレポートは自動保存されます。変更を共有レポートに公開するには、Save to reportを選択します。
編集の競合が発生した場合、警告通知が表示されます。これは、あなたと別の共同作業者が同じレポートを同時に編集した場合に発生する可能性があります。警告通知は、潜在的な編集の競合を解決するのに役立ちます。
レポートの パネル にコメントボタンをクリックすると、その パネル に直接コメントを追加できます。
レポート をPDFまたは LaTeXとしてエクスポートします。 レポート 内で、ケバブアイコンを選択してドロップダウンメニューを展開します。[Download] を選択し、PDFまたは LaTeX出力形式を選択します。
レポート 内で、ケバブアイコンを選択してドロップダウンメニューを展開します。[Clone this report] ボタンを選択します。モーダルで、複製された レポート の宛先を選択します。[Clone report] を選択します。
レポート を複製して、 プロジェクト のテンプレートと形式を再利用します。チームのアカウント内で プロジェクト を複製すると、複製された プロジェクト はチームに表示されます。個人のアカウント内で複製された プロジェクト は、その ユーザー にのみ表示されます。
URLから Report をロードして、テンプレートとして使用します。
report = wr.Report(
project=PROJECT, title="Quickstart Report", description="That was easy!"
) # 作成
report.save() # 保存
new_report = wr.Report.from_url(report.url) # ロード
new_report.blocks内のコンテンツを編集します。
pg = wr.PanelGrid(
runsets=[
wr.Runset(ENTITY, PROJECT, "First Run Set"),
wr.Runset(ENTITY, PROJECT, "Elephants Only!", query="elephant"),
],
panels=[
wr.LinePlot(x="Step", y=["val_acc"], smoothing_factor=0.8),
wr.BarPlot(metrics=["acc"]),
wr.MediaBrowser(media_keys="img", num_columns=1),
wr.RunComparer(diff_only="split", layout={"w": 24, "h": 9}),
],
)
new_report.blocks = (
report.blocks[:1] + [wr.H1("Panel Grid Example"), pg] + report.blocks[1:]
)
new_report.save()
レポート の右上隅にある [共有] ボタンを選択します。モーダルウィンドウが表示されます。モーダルウィンドウ内で、[埋め込みコードをコピー] を選択します。コピーされたコードは、インラインフレーム (IFrame) HTML 要素内にレンダリングされます。コピーしたコードを、選択した iframe HTML 要素に貼り付けます。
次のアニメーションは、Confluence の IFrame セル内にレポートへの直接リンクを挿入する方法を示しています。
次のアニメーションは、Notion の Embed ブロックとレポートの埋め込みコードを使用して、レポートを Notion ドキュメントに挿入する方法を示しています。
gr.HTML 要素を使用すると、Gradio Apps 内に W&B Reports を埋め込み、Hugging Face Spaces 内で使用できます。
import gradio as gr
def wandb_report(url):
iframe = f'<iframe src={url} style="border:none;height:1024px;width:100%">'
return gr.HTML(iframe)
with gr.Blocks() as demo:
report = wandb_report(
"https://wandb.ai/_scott/pytorch-sweeps-demo/reports/loss-22-10-07-16-00-17---VmlldzoyNzU2NzAx"
)
demo.launch()
クロスプロジェクト レポートを使用して、2 つの異なるプロジェクトの run を比較します。run セット テーブルのプロジェクト セレクターを使用して、プロジェクトを選択します。
セクション内の 可視化 は、最初のアクティブな runset から列をプルします。ラインプロットで探している メトリクス が見つからない場合は、セクションで最初にチェックされた run セットにその列があることを確認してください。
この機能は、 時系列 ラインの履歴データをサポートしていますが、異なるプロジェクトから異なるサマリー メトリクス をプルすることはサポートしていません。つまり、別のプロジェクトでのみ ログ に記録される列から散布図を作成することはできません。
2 つのプロジェクトの run を比較する必要があり、列が機能しない場合は、一方のプロジェクトの run にタグを追加し、それらの run をもう一方のプロジェクトに移動します。各プロジェクトの run のみをフィルタリングできますが、 レポート には両方の run セットのすべての列が含まれます。
プライベート プロジェクト または Team プロジェクトにある レポート への表示専用リンクを共有します。
表示専用の レポート リンクは、URL に秘密の アクセス トークンを追加するため、リンクを開いた人は誰でもページを表示できます。誰でもマジック リンクを使用して、最初に ログ インしなくても レポート を表示できます。W&B Local プライベート クラウド インストールをご利用のお客様の場合、これらのリンクはファイアウォールの内側に保持されるため、プライベート インスタンスへの アクセス 権と表示専用リンクへの アクセス 権を持つチームのメンバーのみが レポート を表示できます。
表示専用モード では、 ログ インしていない人は、チャートを表示したり、マウスオーバーして 値 のツールチップを表示したり、チャートを拡大/縮小したり、テーブル内の列をスクロールしたりできます。表示モードの場合、新しいチャートや新しいテーブル クエリを作成して データを探索することはできません。表示専用の レポート リンクの訪問者は、run をクリックして run ページに移動することはできません。また、表示専用の訪問者には共有モーダルは表示されませんが、代わりにホバーすると、次のようなツールチップが表示されます: 表示専用アクセスでは共有は利用できません。
ワークスペース からグラフを レポート に送信して、進捗状況を追跡します。 レポート にコピーするチャートまたは パネル のドロップダウン メニューをクリックし、Add to report をクリックして宛先の レポート を選択します。
プロジェクトの開発で重要な観察、将来の作業のためのアイデア、または達成されたマイルストーンを記録します。 Report 内のすべての実験 run は、パラメータ、メトリクス、ログ、およびコードにリンクされるため、作業の完全なコンテキストを保存できます。
テキストを書き留め、関連するグラフを取り込んで、洞察を説明します。
トレーニング時間の比較を共有する方法の例については、Inception-ResNet-V2 が遅すぎる場合の対処法 W&B Report を参照してください。
参照と将来のインタラクションのために、複雑なコードベースから最良の例を保存します。 Lyft dataset からの LIDAR ポイントクラウドを可視化し、3D バウンディングボックスで注釈を付ける方法の例については、LIDAR ポイントクラウド W&B Report を参照してください。
プロジェクトの開始方法を説明し、これまでに観察した内容を共有し、最新の 学び をまとめます。同僚は、 Report の任意の panel または最後にコメントを使用して、提案をしたり、詳細を議論したりできます。
同僚が自分で探索し、追加の洞察を得て、次のステップをより適切に計画できるように、動的な settings を含めます。この例では、3 種類の experiments を個別に可視化、比較、または平均化できます。
ベンチマークの最初の run と観察を共有する方法の例については、SafeLife ベンチマーク experiments W&B Report を参照してください。
スライダーと構成可能なメディア panel を使用して、 model の結果または training の進捗状況を紹介します。スライダー付きの W&B Report の例については、かわいい動物とポストモダンのスタイル転送: マルチドメイン画像合成のための StarGAN v2 report をご覧ください。
プロジェクトを進める際に、 experiments、学び、注意点、および次のステップに関する考えを書き留め、すべてを 1 か所に整理します。これにより、スクリプト以外の重要な部分をすべて「文書化」できます。 学び を report する方法の例については、Who Is Them? Text Disambiguation With Transformers W&B Report を参照してください。
model がどのように、そしてなぜ開発されたのかを理解するために、あなたと他の人が後で参照できるプロジェクトのストーリーを語ります。 学び を report する方法については、運転席からの眺め W&B Report を参照してください。
OpenAI Robotics チームが W&B Reports を使用して大規模な machine learning プロジェクトをどのように実行したかを調査するために W&B Reports がどのように使用されたかの例については、W&B Reports を使用したエンドツーエンドの Learning Dexterityを参照してください。
This feature requires a Pro or Enterprise plan.
このページでは、W&B の automations について説明します。W&B のイベント（artifact Artifacts のバージョンが作成されたときなど）に基づいて、自動モデルテストやデプロイメントなどのワークフローステップをトリガーする オートメーションの作成 を行います。
たとえば、新しいバージョンが作成されたときに Slack チャンネルに投稿したり、production エイリアスが Artifacts に追加されたときに webhook を実行して自動テストをトリガーしたりできます。
Automation は、特定の event が Registry または Project で発生したときに実行できます。
Registry 内の Artifacts の場合、Automation の実行を次のように設定できます。
Project 内の Artifacts の場合、Automation の実行を次のように設定できます。
詳細については、オートメーションイベントとスコープ を参照してください。
オートメーションを作成 するには、次の手順を実行します。
This feature requires a Pro or Enterprise plan.
このページでは、W&B のオートメーションの作成と管理の概要について説明します。詳細な手順については、Slack オートメーションの作成またはWebhook オートメーションの作成を参照してください。
オートメーションに関するチュートリアルをお探しですか？
Project または Registry の [Automations] タブからオートメーションを作成します。大まかに言って、オートメーションを作成するには、次の手順に従います。
詳細については、以下を参照してください。
Project または Registry の [Automations] タブからオートメーションを表示および管理します。
... メニューをクリックし、[Edit automation] をクリックします。... メニューをクリックし、[Delete automation] をクリックします。This feature requires a Pro or Enterprise plan.
このページでは、Slack オートメーション の作成方法について説明します。Webhook オートメーションを作成するには、代わりに Webhook オートメーションの作成 を参照してください。
大まかに言うと、Slack オートメーションを作成するには、次の手順を実行します。
Team の管理者は、Team に Slack の送信先を追加できます。
Weights & Biases にログインして、Team Settings ページに移動します。
[Slack channel integrations] セクションで、[Connect Slack] をクリックして新しい Slack インスタンスを追加します。既存の Slack インスタンスに channel を追加するには、[New integration] をクリックします。
必要に応じて、ブラウザで Slack にサインインします。プロンプトが表示されたら、選択した Slack channel に投稿する権限を Weights & Biases に付与します。ページを読んでから、[Search for a channel] をクリックして、channel 名を入力します。リストから channel を選択し、[Allow] をクリックします。
Slack で、選択した channel に移動します。[Your Slack handle] added an integration to this channel: Weights & Biases のような投稿が表示された場合、インテグレーションは正しく構成されています。
これで、構成した Slack channel に通知する オートメーションの作成 ができます。
Team の管理者は、Team の Slack インスタンスと channel を表示および管理できます。
Weights & Biases Team を Slack に接続 したら、[Registry] または [Project] を選択し、次の手順に従って Slack channel に通知するオートメーションを作成します。
Registry の管理者は、その Registry でオートメーションを作成できます。
Weights & Biases にログインします。
Registry の名前をクリックして、詳細を表示します。
Registry を対象範囲とするオートメーションを作成するには、[Automations] タブをクリックし、[Create automation] をクリックします。Registry を対象範囲とするオートメーションは、そのすべてのコレクション (将来作成されるコレクションを含む) に自動的に適用されます。
Registry 内の特定のコレクションのみを対象範囲とするオートメーションを作成するには、コレクションのアクション ... メニューをクリックし、[Create automation] をクリックします。または、コレクションを表示しているときに、コレクションの詳細ページの [Automations] セクションにある [Create automation] ボタンを使用して、コレクションのオートメーションを作成します。
監視する Event を選択します。
表示される追加フィールドに入力します。これは、イベントによって異なります。たとえば、[An artifact alias is added] を選択した場合は、[Alias regex] を指定する必要があります。
[Next step] をクリックします。
Slack インテグレーション を所有する Team を選択します。
[Action type] を [Slack notification] に設定します。Slack channel を選択し、[Next step] をクリックします。
オートメーションの名前を入力します。必要に応じて、説明を入力します。
[Create automation] をクリックします。
Weights & Biases の管理者は、Project でオートメーションを作成できます。
Weights & Biases にログインします。
Project ページに移動し、[Automations] タブをクリックします。
[Create automation] をクリックします。
監視する Event を選択します。
表示される追加フィールドに入力します。これは、イベントによって異なります。たとえば、[An artifact alias is added] を選択した場合は、[Alias regex] を指定する必要があります。
[Next step] をクリックします。
Slack インテグレーション を所有する Team を選択します。
[Action type] を [Slack notification] に設定します。Slack channel を選択し、[Next step] をクリックします。
オートメーションの名前を入力します。必要に応じて、説明を入力します。
[Create automation] をクリックします。
これらのページのいずれかから、Registry の管理者は既存のオートメーションを管理できます。
... メニューをクリックし、[Edit automation] をクリックします。... メニューをクリックし、[Delete automation] をクリックします。確認が必要です。Weights & Biases の管理者は、Project の [Automations] タブから Project のオートメーションを表示および管理できます。
... メニューをクリックし、[Edit automation] をクリックします。... メニューをクリックし、[Delete automation] をクリックします。確認が必要です。This feature requires a Pro or Enterprise plan.
このページでは、webhook オートメーション の作成方法について説明します。Slack オートメーションを作成するには、代わりに Slack オートメーションの作成 を参照してください。
大まかに言うと、webhook オートメーションを作成するには、次の手順を実行します。
Team の管理者は、 Team に webhook を追加できます。
Weights & Biases にログインし、Team の Settings ページに移動します。
Webhooks セクションで、New webhook をクリックします。
webhook の名前を入力します。
webhook のエンドポイント URL を入力します。
webhook に Bearer トークンが必要な場合は、Access token をそれを含む シークレット に設定します。webhook オートメーションを使用すると、Weights & Biases は Authorization: Bearer HTTP ヘッダーをアクセストークンに設定し、${ACCESS_TOKEN} ペイロード変数 でトークンにアクセスできます。
webhook のペイロードにパスワードまたはその他の機密文字列が必要な場合は、Secret をそれを含むシークレットに設定します。webhook を使用するオートメーションを設定すると、名前の先頭に $ を付けることで、ペイロード変数 としてシークレットにアクセスできます。
webhook のアクセストークンがシークレットに保存されている場合は、次の手順も完了して、シークレットをアクセストークンとして指定する 必要 があります。
Weights & Biases がエンドポイントに接続して認証できることを確認するには：
$ を付けます。このペイロードはテスト専用であり、保存されません。オートメーションのペイロードは、オートメーションを作成 するときに設定します。シークレットとアクセストークンが POST リクエストのどこに指定されているかを確認するには、webhook のトラブルシューティング を参照してください。テストが成功しない場合は、webhook の設定を確認して、もう一度お試しください。必要に応じて、webhook のトラブルシューティング を参照してください。
これで、webhook を使用する オートメーションを作成 できます。
webhook を設定 したら、Registry または Project を選択し、次の手順に従って webhook をトリガーするオートメーションを作成します。
Registry 管理者は、その Registry でオートメーションを作成できます。Registry オートメーションは、今後追加されるものを含め、Registry 内のすべてのコレクションに適用されます。
Weights & Biases にログインします。
Registry の名前をクリックして詳細を表示します。
Registry の範囲に設定されたオートメーションを作成するには、Automations タブをクリックし、Create automation をクリックします。Registry の範囲に設定されたオートメーションは、そのすべてのコレクション（今後作成されるものを含む）に自動的に適用されます。
Registry 内の特定のコレクションのみを範囲とするオートメーションを作成するには、コレクションのアクション ... メニューをクリックし、Create automation をクリックします。または、コレクションを表示しながら、コレクションの詳細ページの Automations セクションにある Create automation ボタンを使用して、コレクションのオートメーションを作成します。
監視する Event を選択します。イベントに応じて表示される追加フィールドに入力します。たとえば、An artifact alias is added を選択した場合は、Alias regex を指定する必要があります。Next step をクリックします。
webhook を所有する Team を選択します。
Action type を Webhooks に設定し、使用する webhook を選択します。
webhook のアクセストークンを設定した場合は、${ACCESS_TOKEN} ペイロード変数 でトークンにアクセスできます。webhook のシークレットを設定した場合は、名前の先頭に $ を付けることで、ペイロードでアクセスできます。webhook の要件は、webhook のサービスによって決まります。
Next step をクリックします。
オートメーションの名前を入力します。必要に応じて、説明を入力します。Create automation をクリックします。
Weights & Biases 管理者は、Project でオートメーションを作成できます。
Weights & Biases にログインし、Project ページに移動します。
サイドバーで、Automations をクリックします。
Create automation をクリックします。
監視する Event を選択します。
イベントに応じて表示される追加フィールドに入力します。たとえば、An artifact alias is added を選択した場合は、Alias regex を指定する必要があります。
必要に応じて、コレクションフィルターを指定します。それ以外の場合、オートメーションは、今後追加されるものを含め、Project 内のすべてのコレクションに適用されます。
Next step をクリックします。
webhook を所有する Team を選択します。
Action type を Webhooks に設定し、使用する webhook を選択します。
webhook にペイロードが必要な場合は、ペイロードを作成して Payload フィールドに貼り付けます。webhook のアクセストークンを設定した場合は、${ACCESS_TOKEN} ペイロード変数 でトークンにアクセスできます。webhook のシークレットを設定した場合は、名前の先頭に $ を付けることで、ペイロードでアクセスできます。webhook の要件は、webhook のサービスによって決まります。
Next step をクリックします。
オートメーションの名前を入力します。必要に応じて、説明を入力します。Create automation をクリックします。
これらのページのいずれかから、Registry 管理者は既存のオートメーションを管理できます。
... メニューをクリックし、Edit automation をクリックします。... メニューをクリックし、Delete automation をクリックします。確認が必要です。Weights & Biases 管理者は、Project の Automations タブから Project のオートメーションを表示および管理できます。
... メニューをクリックし、Edit automation をクリックします。... メニューをクリックし、Delete automation をクリックします。確認が必要です。これらのセクションを使用して、webhook のペイロードを作成します。webhook とそのペイロードのテストの詳細については、webhook のトラブルシューティング を参照してください。
このセクションでは、webhook のペイロードの作成に使用できる変数について説明します。
| 変数 | 詳細 |
|---|---|
${project_name} |
アクションをトリガーした変更を所有する Project の名前。 |
${entity_name} |
アクションをトリガーした変更を所有する Entity または Team の名前。 |
${event_type} |
アクションをトリガーしたイベントのタイプ。 |
${event_author} |
アクションをトリガーしたユーザー。 |
${artifact_collection_name} |
Artifact バージョンがリンクされている Artifact コレクションの名前。 |
${artifact_metadata.<KEY>} |
アクションをトリガーした Artifact バージョンからの任意のトップレベル メタデータ キーの値。<KEY> をトップレベル メタデータ キーの名前に置き換えます。トップレベル メタデータ キーのみが、webhook のペイロードで使用できます。 |
${artifact_version} |
アクションをトリガーした Artifact バージョンの Wandb.Artifact 表現。 |
${artifact_version_string} |
アクションをトリガーした Artifact バージョンの string 表現。 |
${ACCESS_TOKEN} |
アクセストークンが設定されている場合は、webhook で設定されたアクセストークンの値。アクセストークンは、Authorization: Bearer HTTP ヘッダーで自動的に渡されます。 |
${SECRET_NAME} |
設定されている場合は、webhook で設定されたシークレットの値。SECRET_NAME をシークレットの名前に置き換えます。 |
このセクションには、一般的なユースケースの webhook ペイロードの例が含まれています。この例では、ペイロード変数 の使用方法を示します。
Weights & Biases からリポジトリディスパッチを送信して、GitHub アクションをトリガーします。たとえば、on キーのトリガーとしてリポジトリディスパッチを受け入れる GitHub ワークフローファイルがあるとします。
on:
repository_dispatch:
types: BUILD_AND_DEPLOY
リポジトリのペイロードは、次のようになります。
{
"event_type": "BUILD_AND_DEPLOY",
"client_payload":
{
"event_author": "${event_author}",
"artifact_version": "${artifact_version}",
"artifact_version_string": "${artifact_version_string}",
"artifact_collection_name": "${artifact_collection_name}",
"project_name": "${project_name}",
"entity_name": "${entity_name}"
}
}
event_type キーは、GitHub ワークフロー YAML ファイルの types フィールドと一致する必要があります。レンダリングされたテンプレート文字列の内容と配置は、オートメーションが設定されているイベントまたはモデルバージョンによって異なります。${event_type} は、LINK_ARTIFACT または ADD_ARTIFACT_ALIAS のいずれかとしてレンダリングされます。以下に、マッピングの例を示します。
${event_type} --> "LINK_ARTIFACT" or "ADD_ARTIFACT_ALIAS"
${event_author} --> "<wandb-user>"
${artifact_version} --> "wandb-artifact://_id/QXJ0aWZhY3Q6NTE3ODg5ODg3""
${artifact_version_string} --> "<entity>/model-registry/<registered_model_name>:<alias>"
${artifact_collection_name} --> "<registered_model_name>"
${project_name} --> "model-registry"
${entity_name} --> "<entity>"
テンプレート文字列を使用して、Weights & Biases から GitHub Actions およびその他のツールにコンテキストを動的に渡します。これらのツールが Python スクリプトを呼び出すことができる場合は、Weights & Biases API を使用して、登録されたモデル Artifacts を利用できます。
リポジトリディスパッチの詳細については、GitHub Marketplace の公式ドキュメント を参照してください。
モデル評価の Webhook オートメーション および モデルデプロイメントの Webhook オートメーション のビデオをご覧ください。これらのビデオでは、モデル評価およびデプロイメントのオートメーションを作成する方法を説明しています。
Weights & Biases レポート を確認してください。このレポートでは、モデル CI に Github Actions webhook オートメーションを使用する方法を示しています。この GitHub リポジトリ をチェックして、Modal Labs webhook でモデル CI を作成する方法を学んでください。
このペイロードの例は、webhook を使用して Teams チャンネルに通知する方法を示しています。
{
"@type": "MessageCard",
"@context": "http://schema.org/extensions",
"summary": "New Notification",
"sections": [
{
"activityTitle": "Notification from WANDB",
"text": "This is an example message sent via Teams webhook.",
"facts": [
{
"name": "Author",
"value": "${event_author}"
},
{
"name": "Event Type",
"value": "${event_type}"
}
],
"markdown": true
}
]
}
テンプレート文字列を使用して、実行時に Weights & Biases データをペイロードに挿入できます（上記の Teams の例に示すように）。
Slack API ドキュメント で強調表示されている手順に従って、Slack アプリを設定し、受信 webhook インテグレーションを追加します。Bot User OAuth Token で指定されたシークレットが、Weights & Biases webhook のアクセストークンであることを確認してください。
以下は、ペイロードの例です。
{
"text": "New alert from WANDB!",
"blocks": [
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": "Registry event: ${event_type}"
}
},
{
"type":"section",
"text": {
"type": "mrkdwn",
"text": "New version: ${artifact_version_string}"
}
},
{
"type": "divider"
},
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": "Author: ${event_author}"
}
}
]
}
Weights & Biases App UI を使用してインタラクティブに、または Bash スクリプトを使用してプログラムで webhook のトラブルシューティングを行います。新しい webhook を作成するとき、または既存の webhook を編集するときに、webhook のトラブルシューティングを行うことができます。
Team 管理者は、Weights & Biases App UI を使用して webhook をインタラクティブにテストできます。
デモンストレーションについては、ビデオ Weights & Biases での Webhook のテスト をご覧ください。
このシェルスクリプトは、トリガーされたときに Weights & Biases が webhook オートメーションに送信するリクエストと同様の POST リクエストを生成する 1 つの方法を示しています。
以下のコードをコピーしてシェルスクリプトに貼り付け、webhook のトラブルシューティングを行います。次の独自の値（バリュー）を指定します。
ACCESS_TOKENSECRETPAYLOADAPI_ENDPOINTwebhook_test.shThis feature requires a Pro or Enterprise plan.
オートメーション は、特定のイベントが project または registry のスコープ内で発生したときに開始できます。 project の スコープ は、[スコープの技術的な定義を挿入] を指します。このページでは、各スコープ内で オートメーション をトリガーできるイベントについて説明します。
オートメーション の詳細については、オートメーション の概要 または オートメーション の作成 を参照してください。
このセクションでは、Registry 内の オートメーション のスコープとイベントについて説明します。
オートメーション の作成 の詳細について説明します。
次のスコープで Registry オートメーション を作成できます。
Registry オートメーション は、次のイベントを監視できます。
production エイリアス が適用されたときに model をデプロイします。このセクションでは、project 内の オートメーション のスコープとイベントについて説明します。
https://wandb.ai/<team>/<project-name> ) で W&B project に移動します。オートメーション の作成 の詳細について説明します。
次のスコープで project オートメーション を作成できます。
project オートメーション は、次のイベントを監視できます。
test-set-quality-check エイリアス が適用されたときに、一連のダウンストリーム プロセッシング ステップを実行します。