これは、このセクションの複数ページの印刷可能なビューです。 印刷するには、ここをクリックしてください.

このページの通常のビューに戻る.

Integrations

W&B の インテグレーション により、既存の プロジェクト 内で 実験管理 と データ バージョン管理 を迅速かつ簡単にセットアップできます。PyTorch などの ML フレームワーク、Hugging Face などの ML ライブラリ、または Amazon SageMaker などの クラウド サービス向けの インテグレーション をご確認ください。

関連リソース

  • Examples: 各 インテグレーション の ノートブック と スクリプト の例で コード を試してください。
  • Video Tutorials: YouTube の 動画チュートリアル で W&B の使用方法を学びましょう

1 - Add wandb to any library

任意のライブラリに wandb を追加する

このガイドでは、強力な 実験管理 、GPU とシステム監視、モデルチェックポイントなど、独自のライブラリのための機能を W&B と統合するためのベストプラクティスを提供します。

以下では、作業中のコードベースが単一の Python トレーニングスクリプトまたは Jupyter ノートブックよりも複雑な場合の、ベストなヒントとベストプラクティスについて説明します。取り上げるトピックは次のとおりです。

  • セットアップ要件
  • ユーザーログイン
  • wandb の Run の開始
  • Run の設定の定義
  • W&B へのログ記録
  • 分散トレーニング
  • モデルチェックポイントなど
  • ハイパーパラメータの チューニング
  • 高度な インテグレーション

セットアップ要件

開始する前に、ライブラリの依存関係に W&B を必須にするかどうかを決定します。

インストール時に W&B を必須とする

W&B Python ライブラリ（wandb）を依存関係ファイルに追加します。たとえば、requirements.txt ファイルに追加します。

torch==1.8.0
...
wandb==0.13.*

インストール時に W&B をオプションにする

W&B SDK（wandb）をオプションにするには、2つの方法があります。

A. ユーザーが手動でインストールせずに wandb 機能を使用しようとしたときにエラーを発生させ、適切なエラーメッセージを表示します。

try:
    import wandb
except ImportError:
    raise ImportError(
        "You are trying to use wandb which is not currently installed."
        "Please install it using pip install wandb"
    )

B. Python パッケージを構築している場合は、wandb をオプションの依存関係として pyproject.toml ファイルに追加します。

[project]
name = "my_awesome_lib"
version = "0.1.0"
dependencies = [
    "torch",
    "sklearn"
]

[project.optional-dependencies]
dev = [
    "wandb"
]

ユーザーログイン

APIキー を作成する

APIキー は、クライアントまたはマシンを W&B に対して認証します。 APIキー は、ユーザープロフィールから生成できます。

  1. 右上隅にあるユーザープロフィールアイコンをクリックします。
  2. [User Settings（ユーザー設定）]を選択し、[API Keys（APIキー）]セクションまでスクロールします。
  3. [Reveal（表示）]をクリックします。表示された APIキー をコピーします。 APIキー を非表示にするには、ページをリロードします。

wandb ライブラリをインストールしてログインする

wandb ライブラリをローカルにインストールしてログインするには:

  1. WANDB_API_KEY 環境変数 を APIキー に設定します。

    export WANDB_API_KEY=<your_api_key>

  2. wandb ライブラリをインストールしてログインします。

    pip install wandb

wandb login

pip install wandb

import wandb
wandb.login()

!pip install wandb

import wandb
wandb.login()

ユーザーが上記の手順に従わずに初めて wandb を使用する場合、スクリプトが wandb.init を呼び出すと、自動的にログインを求められます。

Run を開始する

W&B Run は、W&B によって記録される計算の単位です。通常、トレーニング実験ごとに単一の W&B Run を関連付けます。

W&B を初期化し、コード内で Run を開始するには:

run = wandb.init()

オプションで、プロジェクトの名前を指定したり、エンティティパラメーターのユーザー名やチーム名（wandb_entity）とともに、コード内の wandb_project などのパラメーターを使用して、ユーザー自身に設定させたりできます。

run = wandb.init(project=wandb_project, entity=wandb_entity)

Run を終了するには、run.finish() を呼び出す必要があります。これがインテグレーションの設計で機能する場合は、Run をコンテキストマネージャーとして使用します。

# When this block exits, it calls run.finish() automatically.
# If it exits due to an exception, it uses run.finish(exit_code=1) which
# marks the run as failed.
with wandb.init() as run:
    ...

wandb.init をいつ呼び出すか?

ライブラリは、W&B Run をできるだけ早く作成する必要があります。これは、エラーメッセージを含むコンソール内のすべての出力が W&B Run の一部として記録されるためです。これにより、デバッグが容易になります。

wandb をオプションの依存関係として使用する

ユーザーがライブラリを使用する際に wandb をオプションにしたい場合は、次のいずれかの方法があります。

  • 次のような wandb フラグを定義します。
trainer = my_trainer(..., use_wandb=True)

python train.py ... --use-wandb
  • または、wandb.init で wandb を disabled に設定します。
wandb.init(mode="disabled")

export WANDB_MODE=disabled

または

wandb disabled
  • または、wandb をオフラインに設定します。これは、wandb を実行しますが、インターネット経由で W&B に通信しようとはしません。
export WANDB_MODE=offline

または

os.environ['WANDB_MODE'] = 'offline'

wandb offline

Run の設定を定義する

wandb の Run の設定を使用すると、W&B Run の作成時にモデル、データセットなどに関するメタデータを提供できます。この情報を使用して、さまざまな実験を比較し、主な違いをすばやく理解できます。

W&B Runs table

ログに記録できる一般的な設定パラメーターは次のとおりです。

  • モデル名、バージョン、アーキテクチャー パラメーターなど。
  • データセット名、バージョン、トレーニング/検証の例の数など。
  • 学習率、 バッチサイズ 、 オプティマイザー などのトレーニングパラメーター。

次のコードスニペットは、設定をログに記録する方法を示しています。

config = {"batch_size": 32, ...}
wandb.init(..., config=config)

Run の設定を更新する

設定を更新するには、run.config.update を使用します。パラメーターが辞書の定義後に取得される場合に、設定辞書を更新すると便利です。たとえば、モデルのインスタンス化後にモデルのパラメーターを追加する場合があります。

run.config.update({"model_parameters": 3500})

設定ファイルの定義方法の詳細については、実験の設定 を参照してください。

W&B にログを記録する

メトリクス を記録する

キーの値が メトリクス の名前である辞書を作成します。この辞書オブジェクトをrun.logに渡します。

for epoch in range(NUM_EPOCHS):
    for input, ground_truth in data:
        prediction = model(input)
        loss = loss_fn(prediction, ground_truth)
        metrics = { "loss": loss }
        run.log(metrics)

メトリクス がたくさんある場合は、train/... や val/... などの メトリクス 名にプレフィックスを使用することで、UI で自動的にグループ化できます。これにより、トレーニングと検証の メトリクス 、または分離したいその他の メトリクス タイプ用に、W&B Workspace に個別のセクションが作成されます。

metrics = {
    "train/loss": 0.4,
    "train/learning_rate": 0.4,
    "val/loss": 0.5,
    "val/accuracy": 0.7
}
run.log(metrics)
A W&B Workspace with 2 separate sections

run.log の詳細を見る。

X軸のずれを防ぐ

同じトレーニングステップに対して run.log を複数回呼び出すと、wandb SDK は run.log を呼び出すたびに内部ステップカウンターをインクリメントします。このカウンターは、トレーニングループのトレーニングステップと一致しない場合があります。

この状況を回避するには、run.define_metric で X軸ステップを明示的に定義します。wandb.init を呼び出した直後に1回定義します。

with wandb.init(...) as run:
    run.define_metric("*", step_metric="global_step")

グロブパターン * は、すべての メトリクス がチャートで global_step を X軸として使用することを意味します。特定の メトリクス のみを global_step に対してログに記録する場合は、代わりにそれらを指定できます。

run.define_metric("train/loss", step_metric="global_step")

次に、run.log を呼び出すたびに、 メトリクス 、step メトリクス 、および global_step をログに記録します。

for step, (input, ground_truth) in enumerate(data):
    ...
    run.log({"global_step": step, "train/loss": 0.1})
    run.log({"global_step": step, "eval/loss": 0.2})

たとえば、検証ループ中に「global_step」が利用できないなど、独立したステップ変数にアクセスできない場合、「global_step」の以前にログに記録された値が wandb によって自動的に使用されます。この場合、メトリクス に必要なときに定義されるように、 メトリクス の初期値をログに記録してください。

画像、テーブル、音声などをログに記録する

メトリクス に加えて、プロット、ヒストグラム、テーブル、テキスト、および画像、ビデオ、オーディオ、3D などのメディアをログに記録できます。

データをログに記録する際の考慮事項は次のとおりです。

  • メトリクス をログに記録する頻度はどのくらいですか? オプションにする必要がありますか?
  • 視覚化に役立つデータの種類は何ですか?
    • 画像の場合は、サンプル予測、セグメンテーションマスクなどをログに記録して、時間の経過に伴う変化を確認できます。
    • テキストの場合は、サンプル予測のテーブルをログに記録して、後で調べることができます。

メディア、オブジェクト、プロットなどのログ記録の詳細をご覧ください。

分散トレーニング

分散環境をサポートするフレームワークの場合は、次のいずれかの ワークフロー を採用できます。

  • どの プロセス が「メイン」 プロセス であるかを検出し、そこで wandb のみを使用します。他の プロセス からの必要なデータは、最初にメイン プロセス にルーティングする必要があります（この ワークフロー を推奨します）。
  • すべての プロセス で wandb を呼び出し、すべてに同じ一意の group 名を付けて自動的にグループ化します。

詳細については、分散トレーニング実験のログを記録するを参照してください。

モデルチェックポイントなどを記録する

フレームワークがモデルまたはデータセットを使用または生成する場合は、それらをログに記録して完全なトレーサビリティを実現し、W&B Artifacts を介して パイプライン 全体を wandb で自動的に監視できます。

Stored Datasets and Model Checkpoints in W&B

Artifacts を使用する場合、ユーザーに次のことを定義させることは役立つかもしれませんが、必須ではありません。

  • モデルチェックポイントまたはデータセットをログに記録する機能（オプションにする場合）。
  • 入力として使用される Artifact のパス/参照（ある場合）。たとえば、user/project/artifact です。
  • Artifacts をログに記録する頻度。

モデルチェックポイント を記録する

モデルチェックポイント を W&B にログを記録できます。一意の wandb Run ID を利用して出力 モデルチェックポイント に名前を付け、Run 間で区別すると便利です。また、有用な メタデータ を追加することもできます。さらに、以下に示すように、各モデルに エイリアス を追加することもできます。

metadata = {"eval/accuracy": 0.8, "train/steps": 800}

artifact = wandb.Artifact(
                name=f"model-{run.id}",
                metadata=metadata,
                type="model"
                )
artifact.add_dir("output_model") # local directory where the model weights are stored

aliases = ["best", "epoch_10"]
run.log_artifact(artifact, aliases=aliases)

カスタム エイリアス の作成方法については、カスタム エイリアス を作成するを参照してください。

出力 Artifacts は、任意の頻度（たとえば、エポックごと、500ステップごとなど）でログに記録でき、自動的に バージョン 管理されます。

学習済み モデル または データセット をログに記録および追跡する

学習済み モデル や データセット など、トレーニングへの入力として使用される Artifacts をログに記録できます。次のスニペットは、Artifact をログに記録し、上記のグラフに示すように、実行中の Run に入力として追加する方法を示しています。

artifact_input_data = wandb.Artifact(name="flowers", type="dataset")
artifact_input_data.add_file("flowers.npy")
run.use_artifact(artifact_input_data)

Artifact をダウンロードする

Artifact（データセット、モデルなど）を再利用すると、wandb はローカルにコピーをダウンロード（およびキャッシュ）します。

artifact = run.use_artifact("user/project/artifact:latest")
local_path = artifact.download("./tmp")

Artifacts は W&B の Artifacts セクションにあり、自動的に生成される エイリアス （latest、v2、v3）またはログ記録時に手動で生成される エイリアス （best_accuracy など）で参照できます。

（wandb.init を介して）wandb Run を作成せずに Artifact をダウンロードするには（たとえば、分散環境または単純な推論の場合）、代わりにwandb APIで Artifact を参照できます。

artifact = wandb.Api().artifact("user/project/artifact:latest")
local_path = artifact.download()

詳細については、Artifacts のダウンロードと使用を参照してください。

ハイパーパラメーター を チューニング する

ライブラリで W&B ハイパーパラメーター チューニング 、W&B Sweepsを活用したい場合は、ライブラリに追加することもできます。

高度な インテグレーション

高度な W&B インテグレーション がどのようなものかについては、次の インテグレーション を参照してください。ほとんどの インテグレーション はこれほど複雑ではありません。

2 - Azure OpenAI Fine-Tuning

W&B を使用して Azure OpenAI モデルを ファインチューン する方法。

イントロダクション

Microsoft Azure 上で GPT-3.5 または GPT-4 モデルをファインチューニングする際、W&B を使用することで、メトリクスの自動的なキャプチャや W&B の 実験管理 および評価 ツールによる体系的な評価が促進され、モデルのパフォーマンスを追跡、分析、改善できます。

前提条件

ワークフローの概要

1. ファインチューニングのセットアップ

  • Azure OpenAI の要件に従ってトレーニングデータを準備します。
  • Azure OpenAI でファインチューニングジョブを設定します。
  • W&B は、ファインチューニングプロセスを自動的に追跡し、メトリクスとハイパーパラメータをログに記録します。

2. 実験管理

ファインチューニング中、W&B は以下をキャプチャします。

  • トレーニング および 検証メトリクス
  • モデル ハイパーパラメータ
  • リソース使用率
  • トレーニング Artifacts

3. モデルの評価

ファインチューニング後、W&B Weave を使用して以下を行います。

  • 参照データセットに対するモデル出力を評価します
  • 異なるファインチューニング Runs 全体のパフォーマンスを比較します
  • 特定のテストケースにおけるモデルの 振る舞い を分析します
  • データに基づいたモデル選択の意思決定を行います

実際の例

追加リソース

3 - Catalyst

Pytorch のフレームワークである Catalyst に W&B を統合する方法。

Catalyst は、再現性 、迅速な実験 、およびコードベースの再利用に重点を置いたディープラーニング のR&D用 PyTorch フレームワーク で、新しいものを創造できます。

Catalyst には、 パラメータ 、 メトリクス 、画像、およびその他の Artifacts を ログ 記録するための W&B インテグレーション が含まれています。

Python と Hydra を使用した例を含む、インテグレーション のドキュメント を確認してください。

インタラクティブな例

Catalyst と W&B の インテグレーション の動作を確認するには、example colab を実行してください。

4 - Cohere fine-tuning

W&B を使用して Cohere モデル を ファインチューン する方法。

Weights & Biases を使用すると、Cohere モデルのファイン チューニング メトリクスと設定をログに記録して、モデルのパフォーマンスを分析および理解し、同僚と結果を共有できます。

この Cohere のガイド には、ファイン チューニング run を開始する方法の完全な例が記載されています。また、Cohere API ドキュメントはこちらにあります。

Cohere のファイン チューニング result をログに記録する

Cohere のファイン チューニング ログを W&B Workspace に追加するには:

  1. W&B API キー、W&B entity、および project 名を使用して WandbConfig を作成します。W&B API キーは、https://wandb.ai/authorize で確認できます。

  2. この設定を、モデル名、データセット、ハイパー パラメーターとともに FinetunedModel オブジェクトに渡して、ファイン チューニング run を開始します。

    from cohere.finetuning import WandbConfig, FinetunedModel

# W&B の詳細を含む config を作成する
wandb_ft_config = WandbConfig(
    api_key="<wandb_api_key>",
    entity="my-entity", # 提供された API キーに関連付けられている有効な entity である必要があります
    project="cohere-ft",
)

...  # データセットとハイパー パラメーターを設定する

# cohere でファイン チューニング run を開始する
cmd_r_finetune = co.finetuning.create_finetuned_model(
  request=FinetunedModel(
    name="command-r-ft",
    settings=Settings(
      base_model=...
      dataset_id=...
      hyperparameters=...
      wandb=wandb_ft_config  # ここに W&B config を渡す
    ),
  ),
)

  3. 作成した W&B project で、モデルのファイン チューニング トレーニング、検証メトリクス、およびハイパー パラメーターを表示します。

Runs を整理する

W&B の Runs は自動的に整理され、ジョブタイプ、ベース model、学習率、その他のハイパー パラメーターなどの任意の設定 parameter に基づいてフィルタリング/ソートできます。

さらに、Runs の名前を変更したり、メモを追加したり、タグを作成してグループ化したりできます。

リソース

5 - Databricks

W&B と Databricks を統合する方法。

W&B は、Databricks 環境で W&B Jupyter notebook のエクスペリエンスをカスタマイズすることにより、Databricks と統合されます。

Databricks の設定

  1. クラスターに wandb をインストールする

    クラスターの設定に移動し、クラスターを選択して、ライブラリ をクリックします。新規インストール をクリックし、PyPI を選択して、パッケージ wandb を追加します。

  2. 認証の設定

    W&B アカウントを認証するには、notebook がクエリできる Databricks シークレットを追加します。

    # databricks cli をインストールする
pip install databricks-cli

# databricks UI からトークンを生成する
databricks configure --token

# 次の 2 つのコマンドのいずれかを使用してスコープを作成します (Databricks でセキュリティ機能が有効になっているかどうかによって異なります)。
# セキュリティ アドオンを使用する場合
databricks secrets create-scope --scope wandb
# セキュリティ アドオンを使用しない場合
databricks secrets create-scope --scope wandb --initial-manage-principal users

# https://app.wandb.ai/authorize から api_key を追加します
databricks secrets put --scope wandb --key api_key

例

簡単な例

import os
import wandb

api_key = dbutils.secrets.get("wandb", "api_key")
wandb.login(key=api_key)

wandb.init()
wandb.log({"foo": 1})

Sweeps

wandb.sweep() または wandb.agent() を使用しようとする notebook に必要なセットアップ (一時的):

import os

# これらは将来的には不要になります
os.environ["WANDB_ENTITY"] = "my-entity"
os.environ["WANDB_PROJECT"] = "my-project-that-exists"

6 - DeepChecks

DeepChecks と W&B の統合方法。
Try in Colab

DeepChecks は、機械学習 モデル と データの検証を支援します。たとえば、データの整合性の検証、分布の検査、データ分割の検証、モデル の評価、異なる モデル 間の比較などを、最小限の労力で行うことができます。

DeepChecks と wandb の インテグレーション についてもっと読む ->

はじめに

DeepChecks を Weights & Biases とともに使用するには、まず Weights & Biases アカウント にサインアップする 必要があります こちら。DeepChecks の Weights & Biases の インテグレーション を使用すると、次のよう にすぐに開始できます。

import wandb

wandb.login()

# deepchecks から チェック をインポートします
from deepchecks.checks import ModelErrorAnalysis

# チェック を実行します
result = ModelErrorAnalysis()

# その 結果 を wandb にプッシュします
result.to_wandb()

DeepChecks テストスイート 全体 を Weights & Biases に ログ することもできます

import wandb

wandb.login()

# deepchecks から full_suite テスト をインポートします
from deepchecks.suites import full_suite

# DeepChecks テストスイート を作成して実行します
suite_result = full_suite().run(...)

# thes の 結果 を wandb にプッシュします
# ここでは、必要な wandb.init の config と 引数 を渡すことができます
suite_result.to_wandb(project="my-suite-project", config={"suite-name": "full-suite"})

例

``この レポート は、DeepChecks と Weights & Biases を使用する威力を示しています

この Weights & Biases の インテグレーション に関する質問や問題がありますか？ DeepChecks github repository で issue をオープンしてください。私たちがキャッチして回答します :)

7 - DeepChem

DeepChem ライブラリと W&B を統合する方法。

DeepChem library は、創薬、材料科学、化学、生物学における深層学習の利用を民主化するオープンソースのツールを提供します。この W&B の インテグレーション により、DeepChem を使用してモデルを トレーニング する際に、シンプルで使いやすい 実験管理 とモデルの チェックポイント が追加されます。

3 行のコードで DeepChem のログを記録

logger = WandbLogger(…)
model = TorchModel(…, wandb_logger=logger)
model.fit(…)

Report と Google Colab

W&B with DeepChem: Molecular Graph Convolutional Networks の記事で、W&B DeepChem インテグレーション を使用して生成されたチャートの例をご覧ください。

すぐにコードを試したい場合は、こちらの Google Colab をご覧ください。

Experiments の追跡

KerasModel または TorchModel タイプの DeepChem モデル用に W&B をセットアップします。

サインアップして API キー を作成する

API キー は、W&B へのマシンの認証を行います。API キー は、 ユーザー プロフィールから生成できます。

  1. 右上隅にある ユーザー プロフィール アイコンをクリックします。
  2. [User Settings] を選択し、[API Keys] セクションまでスクロールします。
  3. [Reveal] をクリックします。表示された API キー をコピーします。API キー を非表示にするには、ページをリロードします。

wandb ライブラリ をインストールしてログインする

wandb ライブラリ をローカルにインストールしてログインするには:

  1. WANDB_API_KEY 環境変数 を API キー に設定します。

    export WANDB_API_KEY=<your_api_key>

  2. wandb ライブラリ をインストールしてログインします。

    pip install wandb

wandb login

pip install wandb

import wandb
wandb.login()

!pip install wandb

import wandb
wandb.login()

トレーニング および 評価 データ を W&B に ログ 記録する

トレーニング 損失と 評価 メトリクス は、自動的に W&B に ログ 記録できます。オプションの 評価 は、DeepChem ValidationCallback を使用して有効にできます。WandbLogger は ValidationCallback コールバックを検出し、生成された メトリクス を ログ 記録します。

from deepchem.models import TorchModel, ValidationCallback

vc = ValidationCallback(…)  # optional
model = TorchModel(…, wandb_logger=logger)
model.fit(…, callbacks=[vc])
logger.finish()

from deepchem.models import KerasModel, ValidationCallback

vc = ValidationCallback(…)  # optional
model = KerasModel(…, wandb_logger=logger)
model.fit(…, callbacks=[vc])
logger.finish()

8 - Docker

W&B と Docker を統合する方法。

Docker インテグレーション

W&B は、 コード が実行された Docker イメージ へのポインターを保存できます。これにより、以前の 実験 を実行された環境に正確に復元できます。 wandb ライブラリ は、この状態を永続化するために WANDB_DOCKER 環境変数 を探します。この状態を自動的に設定するいくつかのヘルパーを提供します。

ローカル開発

wandb docker は、 dockerコンテナ を起動し、 wandb 環境変数 を渡し、 コード をマウントし、 wandb がインストールされていることを確認する コマンド です。デフォルトでは、この コマンド は TensorFlow、PyTorch、Keras、Jupyter がインストールされた Docker イメージ を使用します。同じ コマンド を使用して、独自の Docker イメージ を起動できます: wandb docker my/image:latest。この コマンド は、現在の ディレクトリー を コンテナ の “/app” ディレクトリー にマウントします。これは “–dir” フラグで変更できます。

本番環境

wandb docker-run コマンド は、 本番環境 の ワークロード 用に提供されています。これは nvidia-docker のドロップイン代替となることを意図しています。これは docker run コマンド へのシンプルなラッパーで、 認証情報 と WANDB_DOCKER 環境変数 を呼び出しに追加します。 “–runtime” フラグを渡さず、 nvidia-docker がマシンで利用可能な場合、これにより ランタイム が nvidia に設定されます。

Kubernetes

Kubernetes で トレーニング の ワークロード を実行し、 k8s API が pod に公開されている場合（デフォルトの場合）。 wandb は、 Docker イメージ のダイジェストについて API にクエリを実行し、 WANDB_DOCKER 環境変数 を自動的に設定します。

復元

run が WANDB_DOCKER 環境変数 で計測されている場合、 wandb restore username/project:run_id を呼び出すと、 コード を復元する新しいブランチをチェックアウトし、 トレーニング に使用された正確な Docker イメージ を元の コマンド で事前に設定して 起動 します。

9 - Farama Gymnasium

Farama Gymnasium と W&B を統合する方法。

Farama Gymnasium を使用している場合、gymnasium.wrappers.Monitor で生成された環境の動画が自動的にログに記録されます。monitor_gym キーワード 引数 を wandb.init に True に設定するだけです。

当社の Gymnasium インテグレーション は非常に軽量です。 gymnasium からログに記録されている 動画ファイルの名前を確認 し、その名前を付けます。一致するものが見つからない場合は、"videos" にフォールバックします。より詳細な制御が必要な場合は、いつでも手動で 動画をログに記録 できます。

CleanRL ライブラリ で Gymnasium を使用する方法の詳細については、こちらの Reports をご覧ください。

10 - fastai

fastai を使用してモデルをトレーニングする場合、W&B には WandbCallback を使用した簡単なインテグレーションがあります。インタラクティブなドキュメントと例はこちら →

サインアップして API キーを作成する

API キーは、W&B に対してお客様のマシンを認証します。API キーは、ユーザー プロフィールから生成できます。

  1. 右上隅にあるユーザー プロフィール アイコンをクリックします。
  2. ユーザー設定 を選択し、API キー セクションまでスクロールします。
  3. 表示 をクリックします。表示された API キーをコピーします。API キーを非表示にするには、ページをリロードします。

wandb ライブラリをインストールしてログインする

wandb ライブラリをローカルにインストールしてログインするには:

  1. WANDB_API_KEY 環境変数 を API キーに設定します。

    export WANDB_API_KEY=<your_api_key>

  2. wandb ライブラリをインストールしてログインします。

    pip install wandb

wandb login

pip install wandb

import wandb
wandb.login()

!pip install wandb

import wandb
wandb.login()

learner または fit メソッドに WandbCallback を追加する

import wandb
from fastai.callback.wandb import *

# start logging a wandb run
wandb.init(project="my_project")

# To log only during one training phase
learn.fit(..., cbs=WandbCallback())

# To log continuously for all training phases
learn = learner(..., cbs=WandbCallback())

WandbCallback 引数

WandbCallback は、次の引数を受け入れます。

Args Description
log モデルのログを記録するかどうか: gradients 、parameters、all または None (デフォルト)。損失とメトリクスは常にログに記録されます。
log_preds 予測サンプルをログに記録するかどうか (デフォルトは True)。
log_preds_every_epoch エポックごとに予測をログに記録するか、最後にログに記録するか (デフォルトは False)
log_model モデルをログに記録するかどうか (デフォルトは False)。これには SaveModelCallback も必要です
model_name 保存する file の名前。SaveModelCallback をオーバーライドします
log_dataset
  • False (デフォルト)
  • True は、learn.dls.path で参照されるフォルダーをログに記録します。
  • パスを明示的に定義して、ログに記録するフォルダーを参照できます。

注: サブフォルダー “models” は常に無視されます。
dataset_name ログに記録されたデータセットの名前 (デフォルトは folder name)。
valid_dl 予測サンプルに使用されるアイテムを含む DataLoaders (デフォルトは learn.dls.valid からのランダムなアイテム。
n_preds ログに記録された予測の数 (デフォルトは 36)。
seed ランダム サンプルを定義するために使用されます。

カスタム ワークフローでは、データセットとモデルを手動でログに記録できます。

  • log_dataset(path, name=None, metadata={})
  • log_model(path, name=None, metadata={})

注: サブフォルダー “models” はすべて無視されます。

分散トレーニング

fastai は、コンテキスト マネージャー distrib_ctx を使用して分散トレーニングをサポートします。W&B はこれを自動的にサポートし、すぐに使える Multi-GPU の Experiments を追跡できるようにします。

この最小限の例を確認してください。

import wandb
from fastai.vision.all import *
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = rank0_first(lambda: untar_data(URLs.PETS) / "images")

def train():
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    wandb.init("fastai_ddp", entity="capecape")
    cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(sync_bn=False):
        learn.fit(1)

if __name__ == "__main__":
    train()

次に、ターミナルで次を実行します。

$ torchrun --nproc_per_node 2 train.py

この場合、マシンには 2 つの GPU があります。

ノートブック内で分散トレーニングを直接実行できるようになりました。

import wandb
from fastai.vision.all import *

from accelerate import notebook_launcher
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = untar_data(URLs.PETS) / "images"

def train():
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    wandb.init("fastai_ddp", entity="capecape")
    cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(in_notebook=True, sync_bn=False):
        learn.fit(1)

notebook_launcher(train, num_processes=2)

メイン プロセスでのみログを記録する

上記の例では、wandb はプロセスごとに 1 つの run を起動します。トレーニングの最後に、2 つの run が作成されます。これは混乱を招く可能性があるため、メイン プロセスでのみログに記録したい場合があります。そのためには、どのプロセスに手動でいるかを検出し、他のすべてのプロセスで run を作成 ( wandb.init を呼び出す) しないようにする必要があります。

import wandb
from fastai.vision.all import *
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = rank0_first(lambda: untar_data(URLs.PETS) / "images")

def train():
    cb = []
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    if rank_distrib() == 0:
        run = wandb.init("fastai_ddp", entity="capecape")
        cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(sync_bn=False):
        learn.fit(1)

if __name__ == "__main__":
    train()

ターミナルで次を呼び出します。

$ torchrun --nproc_per_node 2 train.py

import wandb
from fastai.vision.all import *

from accelerate import notebook_launcher
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = untar_data(URLs.PETS) / "images"

def train():
    cb = []
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    if rank_distrib() == 0:
        run = wandb.init("fastai_ddp", entity="capecape")
        cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(in_notebook=True, sync_bn=False):
        learn.fit(1)

notebook_launcher(train, num_processes=2)

例

10.1 - fastai v1

fastai v1 を使用するスクリプトの場合、モデルのトポロジー、損失、メトリクス、重み、勾配、サンプル予測、および最高のトレーニング済みモデルを自動的にログに記録できる コールバック があります。

import wandb
from wandb.fastai import WandbCallback

wandb.init()

learn = cnn_learner(data, model, callback_fns=WandbCallback)
learn.fit(epochs)

リクエストされたログデータは、 コールバック コンストラクターを通じて設定可能です。

from functools import partial

learn = cnn_learner(
    data, model, callback_fns=partial(WandbCallback, input_type="images")
)

トレーニング の開始時にのみ WandbCallback を使用することも可能です。この場合、インスタンス化する必要があります。

learn.fit(epochs, callbacks=WandbCallback(learn))

カスタム パラメータ は、その段階で指定することもできます。

learn.fit(epochs, callbacks=WandbCallback(learn, input_type="images"))

コード 例

この インテグレーション の動作を確認するためのいくつかの例を作成しました。

Fastai v1

オプション

WandbCallback() クラス は、多数のオプションをサポートしています。

キーワード 引数 デフォルト 説明
learn N/A フック する fast.ai の学習器。
save_model True 各ステップで改善された場合、モデルを保存します。トレーニング の最後に最高のモデルもロードします。
mode auto min、max、または auto: monitor で指定された トレーニング メトリクス をステップ間で比較する方法。
monitor None 最高のモデルを保存するためにパフォーマンスを測定するために使用される トレーニング メトリクス。None は、検証損失をデフォルトにします。
log gradients gradients、parameters、all、または None。損失と メトリクス は常にログに記録されます。
input_type None images または None。サンプル予測を表示するために使用されます。
validation_data None input_type が設定されている場合、サンプル予測に使用されるデータ。
predictions 36 input_type が設定され、validation_data が None の場合に行う予測の数。
seed 12345 input_type が設定され、validation_data が None の場合、サンプル予測のために乱数ジェネレーターを初期化します。

11 - Hugging Face Transformers

Try in Colab

Hugging Face Transformers ライブラリを使用すると、BERTのような最先端の NLP モデルや、混合精度や勾配チェックポイントなどのトレーニング手法を簡単に使用できます。W&B integration は、使いやすさを損なうことなく、インタラクティブな集中ダッシュボードに、豊富で柔軟な実験管理とモデルの バージョン管理を追加します。

わずか数行で次世代のロギング

os.environ["WANDB_PROJECT"] = "<my-amazing-project>"  # W&B プロジェクトに名前を付ける
os.environ["WANDB_LOG_MODEL"] = "checkpoint"  # すべてのモデルチェックポイントをログに記録

from transformers import TrainingArguments, Trainer

args = TrainingArguments(..., report_to="wandb")  # W&B ロギングをオンにする
trainer = Trainer(..., args=args)
W&B インタラクティブダッシュボードで実験結果を調べる

はじめに: 実験の トラッキング

サインアップして API キーを作成する

API キーは、お使いのマシンを W&B に対して認証します。API キーは、ユーザープロフィールから生成できます。

  1. 右上隅にあるユーザープロフィールアイコンをクリックします。
  2. [User Settings]を選択し、[API Keys]セクションまでスクロールします。
  3. [Reveal]をクリックします。表示された API キーをコピーします。API キーを非表示にするには、ページをリロードします。

wandb ライブラリをインストールしてログインする

wandb ライブラリをローカルにインストールしてログインするには:

  1. WANDB_API_KEY 環境変数 を API キーに設定します。

    export WANDB_API_KEY=<your_api_key>

  2. wandb ライブラリをインストールしてログインします。

    pip install wandb

wandb login

pip install wandb

import wandb
wandb.login()

!pip install wandb

import wandb
wandb.login()

W&B を初めて使用する場合は、クイックスタート を確認してください。

プロジェクトに名前を付ける

W&B の Project とは、関連する run からログに記録されたすべてのチャート、データ、およびモデルが保存される場所です。プロジェクトに名前を付けると、作業を整理し、単一のプロジェクトに関するすべての情報を 1 か所にまとめて管理できます。

run をプロジェクトに追加するには、WANDB_PROJECT 環境変数をプロジェクト名に設定するだけです。WandbCallback は、このプロジェクト名の環境変数を取得し、run の設定時に使用します。

WANDB_PROJECT=amazon_sentiment_analysis

import os
os.environ["WANDB_PROJECT"]="amazon_sentiment_analysis"

%env WANDB_PROJECT=amazon_sentiment_analysis

プロジェクト名が指定されていない場合、プロジェクト名はデフォルトで huggingface になります。

トレーニングの run を W&B に記録する

コード内またはコマンドラインで Trainer のトレーニング引数を定義する際に 最も重要なステップ は、W&B でのロギングを有効にするために、report_to を "wandb" に設定することです。

TrainingArguments の logging_steps 引数は、トレーニング中にトレーニングメトリクスが W&B にプッシュされる頻度を制御します。run_name 引数を使用して、W&B のトレーニング run に名前を付けることもできます。

これで完了です。モデルは、トレーニング中に損失、評価メトリクス、モデルトポロジー、および勾配を W&B に記録します。

python run_glue.py \     # Python スクリプトを実行する
  --report_to wandb \    # W&B へのロギングを有効にする
  --run_name bert-base-high-lr \   # W&B run の名前 (オプション)
  # その他のコマンドライン引数

from transformers import TrainingArguments, Trainer

args = TrainingArguments(
    # その他の args と kwargs
    report_to="wandb",  # W&B へのロギングを有効にする
    run_name="bert-base-high-lr",  # W&B run の名前 (オプション)
    logging_steps=1,  # W&B へのロギング頻度
)

trainer = Trainer(
    # その他の args と kwargs
    args=args,  # トレーニングの引数
)

trainer.train()  # トレーニングを開始して W&B にログを記録する

モデルチェックポイントをオンにする

Artifacts を使用すると、最大 100GB のモデルとデータセットを無料で保存し、Weights & Biases Registry を使用できます。Registry を使用すると、モデルを登録して探索および評価したり、ステージングの準備をしたり、本番環境にデプロイしたりできます。

Hugging Face モデルチェックポイントを Artifacts に記録するには、WANDB_LOG_MODEL 環境変数を次の いずれか に設定します。

  • checkpoint: TrainingArguments から args.save_steps ごとにチェックポイントをアップロードします。
  • end: load_best_model_at_end も設定されている場合は、トレーニングの最後にモデルをアップロードします。
  • false: モデルをアップロードしません。
WANDB_LOG_MODEL="checkpoint"

import os

os.environ["WANDB_LOG_MODEL"] = "checkpoint"

%env WANDB_LOG_MODEL="checkpoint"

これから初期化する Transformers Trainer はすべて、モデルを W&B プロジェクトにアップロードします。ログに記録したモデルチェックポイントは、Artifacts UI で表示でき、完全なモデルリネージが含まれています (UI のモデルチェックポイントの例は こちら を参照してください)。

W&B Registry

チェックポイントを Artifacts に記録したら、最高のモデルチェックポイントを登録し、Registry を使用してチーム全体で一元化できます。Registry を使用すると、タスクごとに最適なモデルを整理したり、モデルのライフサイクルを管理したり、ML ライフサイクル全体を追跡および監査したり、ダウンストリームアクションを 自動化 したりできます。

モデル Artifact をリンクするには、Registry を参照してください。

トレーニング中に評価出力を可視化する

トレーニング中または評価中にモデル出力を可視化することは、モデルのトレーニング方法を実際に理解するために不可欠なことがよくあります。

Transformers Trainer のコールバックシステムを使用すると、モデルのテキスト生成出力やその他の予測などの追加の役立つデータを W&B Tables に W&B に記録できます。

トレーニング中に評価出力を記録して、次のような W&B Table に記録する方法の詳細については、以下の カスタムロギングセクション を参照してください。

評価出力を示す W&B Table

W&B Run を終了する (ノートブックのみ)

トレーニングが Python スクリプトにカプセル化されている場合、スクリプトが終了すると W&B run は終了します。

Jupyter または Google Colab ノートブックを使用している場合は、wandb.finish() を呼び出して、トレーニングが完了したことを伝える必要があります。

trainer.train()  # トレーニングを開始して W&B にログを記録する

# トレーニング後の分析、テスト、その他のログに記録されたコード

wandb.finish()

結果を可視化する

トレーニング結果をログに記録したら、W&B Dashboard で結果を動的に調べることができます。柔軟でインタラクティブな可視化により、多数の run を一度に比較したり、興味深い発見を拡大したり、複雑なデータから洞察を引き出したりするのが簡単です。

高度な機能と FAQ

最適なモデルを保存するにはどうすればよいですか?

load_best_model_at_end=True で TrainingArguments を Trainer に渡すと、W&B は最適なパフォーマンスのモデルチェックポイントを Artifacts に保存します。

モデルチェックポイントを Artifacts として保存する場合は、Registry に昇格させることができます。Registry では、次のことができます。

  • ML タスクごとに最適なモデルバージョンを整理します。
  • モデルを一元化してチームと共有します。
  • 本番環境用にモデルをステージングするか、詳細な評価のためにブックマークします。
  • ダウンストリーム CI/CD プロセスをトリガーします。

保存されたモデルをロードするにはどうすればよいですか?

WANDB_LOG_MODEL を使用してモデルを W&B Artifacts に保存した場合は、追加のトレーニングまたは推論を実行するためにモデルの重みをダウンロードできます。以前に使用したのと同じ Hugging Face アーキテクチャにロードするだけです。

# 新しい run を作成する
with wandb.init(project="amazon_sentiment_analysis") as run:
    # Artifact の名前とバージョンを渡す
    my_model_name = "model-bert-base-high-lr:latest"
    my_model_artifact = run.use_artifact(my_model_name)

    # モデルの重みをフォルダーにダウンロードしてパスを返す
    model_dir = my_model_artifact.download()

    # 同じモデルクラスを使用して、そのフォルダーから Hugging Face モデルをロードする
    model = AutoModelForSequenceClassification.from_pretrained(
        model_dir, num_labels=num_labels
    )

    # 追加のトレーニングを実行するか、推論を実行する

チェックポイントからトレーニングを再開するにはどうすればよいですか?

WANDB_LOG_MODEL='checkpoint' を設定した場合は、model_dir を TrainingArguments の model_name_or_path 引数として使用し、resume_from_checkpoint=True を Trainer に渡すことで、トレーニングを再開することもできます。

last_run_id = "xxxxxxxx"  # wandb ワークスペースから run_id を取得する

# run_id から wandb run を再開する
with wandb.init(
    project=os.environ["WANDB_PROJECT"],
    id=last_run_id,
    resume="must",
) as run:
    # Artifact を run に接続する
    my_checkpoint_name = f"checkpoint-{last_run_id}:latest"
    my_checkpoint_artifact = run.use_artifact(my_model_name)

    # チェックポイントをフォルダーにダウンロードしてパスを返す
    checkpoint_dir = my_checkpoint_artifact.download()

    # モデルとトレーナーを再初期化する
    model = AutoModelForSequenceClassification.from_pretrained(
        "<model_name>", num_labels=num_labels
    )
    # ここに素晴らしいトレーニング引数を記述する。
    training_args = TrainingArguments()

    trainer = Trainer(model=model, args=training_args)

    # チェックポイントディレクトリを使用して、チェックポイントからトレーニングを再開する
    trainer.train(resume_from_checkpoint=checkpoint_dir)

トレーニング中に評価サンプルを記録して表示するにはどうすればよいですか?

Transformers Trainer を介した W&B へのロギングは、Transformers ライブラリの WandbCallback によって処理されます。Hugging Face ロギングをカスタマイズする必要がある場合は、WandbCallback をサブクラス化し、Trainer クラスの追加メソッドを活用する追加機能を追加して、このコールバックを変更できます。

以下は、この新しいコールバックを HF Trainer に追加する一般的なパターンであり、さらに下には、評価出力を W&B Table に記録するコード完全な例があります。

# Trainer を通常どおりインスタンス化する
trainer = Trainer()

# 新しいロギングコールバックをインスタンス化し、Trainer オブジェクトを渡す
evals_callback = WandbEvalsCallback(trainer, tokenizer, ...)

# コールバックを Trainer に追加する
trainer.add_callback(evals_callback)

# 通常どおり Trainer トレーニングを開始する
trainer.train()

トレーニング中に評価サンプルを表示する

次のセクションでは、WandbCallback をカスタマイズして、モデルの予測を実行し、トレーニング中に評価サンプルを W&B Table に記録する方法について説明します。Trainer コールバックの on_evaluate メソッドを使用して、すべての eval_steps を実行します。

ここでは、tokenizer を使用してモデル出力から予測とラベルをデコードする decode_predictions 関数を作成しました。

次に、予測とラベルから pandas DataFrame を作成し、DataFrame に epoch 列を追加します。

最後に、DataFrame から wandb.Table を作成し、wandb に記録します。 さらに、予測を freq エポックごとに記録することで、ロギングの頻度を制御できます。

注: 通常の WandbCallback とは異なり、このカスタムコールバックは、Trainer の初期化中ではなく、Trainer がインスタンス化された後にトレーナーに追加する必要があります。 これは、Trainer インスタンスが初期化中にコールバックに渡されるためです。

from transformers.integrations import WandbCallback
import pandas as pd


def decode_predictions(tokenizer, predictions):
    labels = tokenizer.batch_decode(predictions.label_ids)
    logits = predictions.predictions.argmax(axis=-1)
    prediction_text = tokenizer.batch_decode(logits)
    return {"labels": labels, "predictions": prediction_text}


class WandbPredictionProgressCallback(WandbCallback):
    """Custom WandbCallback to log model predictions during training.

    This callback logs model predictions and labels to a wandb.Table at each
    logging step during training. It allows to visualize the
    model predictions as the training progresses.

    Attributes:
        trainer (Trainer): The Hugging Face Trainer instance.
        tokenizer (AutoTokenizer): The tokenizer associated with the model.
        sample_dataset (Dataset): A subset of the validation dataset
          for generating predictions.
        num_samples (int, optional): Number of samples to select from
          the validation dataset for generating predictions. Defaults to 100.
        freq (int, optional): Frequency of logging. Defaults to 2.
    """

    def __init__(self, trainer, tokenizer, val_dataset, num_samples=100, freq=2):
        """Initializes the WandbPredictionProgressCallback instance.

        Args:
            trainer (Trainer): The Hugging Face Trainer instance.
            tokenizer (AutoTokenizer): The tokenizer associated
              with the model.
            val_dataset (Dataset): The validation dataset.
            num_samples (int, optional): Number of samples to select from
              the validation dataset for generating predictions.
              Defaults to 100.
            freq (int, optional): Frequency of logging. Defaults to 2.
        """
        super().__init__()
        self.trainer = trainer
        self.tokenizer = tokenizer
        self.sample_dataset = val_dataset.select(range(num_samples))
        self.freq = freq

    def on_evaluate(self, args, state, control, **kwargs):
        super().on_evaluate(args, state, control, **kwargs)
        # control the frequency of logging by logging the predictions
        # every `freq` epochs
        if state.epoch % self.freq == 0:
            # generate predictions
            predictions = self.trainer.predict(self.sample_dataset)
            # decode predictions and labels
            predictions = decode_predictions(self.tokenizer, predictions)
            # add predictions to a wandb.Table
            predictions_df = pd.DataFrame(predictions)
            predictions_df["epoch"] = state.epoch
            records_table = self._wandb.Table(dataframe=predictions_df)
            # log the table to wandb
            self._wandb.log({"sample_predictions": records_table})


# まず、Trainer をインスタンス化する
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=lm_datasets["train"],
    eval_dataset=lm_datasets["validation"],
)

# WandbPredictionProgressCallback をインスタンス化する
progress_callback = WandbPredictionProgressCallback(
    trainer=trainer,
    tokenizer=tokenizer,
    val_dataset=lm_dataset["validation"],
    num_samples=10,
    freq=2,
)

# コールバックをトレーナーに追加する
trainer.add_callback(progress_callback)

詳細な例については、こちらの colab を参照してください。

その他の W&B 設定はありますか?

環境変数を設定することで、Trainer でログに記録される内容をさらに構成できます。W&B 環境変数の完全なリストは、こちら にあります。

環境変数 使用法
WANDB_PROJECT プロジェクトに名前を付けます (デフォルトでは huggingface)
WANDB_LOG_MODEL

モデルチェックポイントを W&B Artifact として記録します (デフォルトでは false)

  • false (デフォルト): モデルチェックポイントなし
  • checkpoint: チェックポイントは args.save_steps ごとにアップロードされます (Trainer の TrainingArguments で設定)。
  • end: 最終的なモデルチェックポイントはトレーニングの最後にアップロードされます。
WANDB_WATCH

モデルの勾配、パラメーター、またはそのどちらもログに記録するかどうかを設定します

  • false (デフォルト): 勾配またはパラメーターのロギングなし
  • gradients: 勾配のヒストグラムをログに記録します
  • all: 勾配とパラメーターのヒストグラムをログに記録します
WANDB_DISABLED ロギングを完全にオフにするには true に設定します (デフォルトでは false)
WANDB_SILENT wandb によって出力される出力を抑制するには true に設定します (デフォルトでは false) 
WANDB_WATCH=all
WANDB_SILENT=true

%env WANDB_WATCH=all
%env WANDB_SILENT=true

wandb.init をカスタマイズするにはどうすればよいですか?

Trainer が使用する WandbCallback は、Trainer が初期化されるときに内部で wandb.init を呼び出します。Trainer が初期化される前に wandb.init を呼び出すことで、run を手動で設定することもできます。これにより、W&B run の構成を完全に制御できます。

init に渡したい可能性のあるものの例を以下に示します。wandb.init の使用方法の詳細については、リファレンスドキュメントをご確認ください。

wandb.init(
    project="amazon_sentiment_analysis",
    name="bert-base-high-lr",
    tags=["baseline", "high-lr"],
    group="bert",
)

その他のリソース

以下は、Transformer と W&B に関連する 6 つの記事です。

Hugging Face Transformers のハイパーパラメーター最適化
  • Hugging Face Transformers のハイパーパラメーター最適化のための 3 つの戦略 (グリッド検索、ベイズ最適化、Population Based Training) が比較されます。
  • Hugging Face transformers から標準的な uncased BERT モデルを使用し、SuperGLUE ベンチマークから RTE データセットでファインチューニングしたいと考えています。
  • 結果は、Population Based Training が Hugging Face transformer モデルのハイパーパラメーター最適化に最も効果的なアプローチであることを示しています。

完全なレポートは こちら をお読みください。

Hugging Tweets: ツイートを生成するモデルをトレーニングする
  • この記事では、著者は、誰かのツイートで学習済みの GPT2 HuggingFace Transformer モデルを 5 分でファインチューニングする方法を示しています。
  • このモデルは、ツイートのダウンロード、データセットの最適化、初期実験、ユーザー間の損失の比較、モデルのファインチューニングというパイプラインを使用しています。

完全なレポートは こちら をお読みください。

Hugging Face BERT および WB を使用した文分類
  • この記事では、自然言語処理における最近の画期的な進歩の力を活用して、文分類子を作成します。ここでは、NLP への転移学習の応用例に焦点を当てます。
  • 単一文分類には、言語的許容度 (CoLA) データセットを使用します。これは、2018 年 5 月に初めて公開された、文法的に正しいか正しくないかというラベルが付けられた文のセットです。
  • Google の BERT を使用して、さまざまな NLP タスクで最小限の労力で高性能モデルを作成します。

完全なレポートは こちら をお読みください。

Hugging Face モデルのパフォーマンスを追跡するためのステップバイステップガイド
  • W&B と Hugging Face transformers を使用して、GLUE ベンチマークで DistilBERT (BERT より 40% 小さいが、BERT の精度の 97% を保持する Transformer) をトレーニングします。
  • GLUE ベンチマークは、NLP モデルをトレーニングするための 9 つのデータセットとタスクのコレクションです。

完全なレポートは こちら をお読みください。

HuggingFace での早期停止の例
  • 早期停止の正規化を使用して Hugging Face Transformer をファインチューニングは、PyTorch または TensorFlow でネイティブに行うことができます。
  • TensorFlow での EarlyStopping コールバックの使用は、tf.keras.callbacks.EarlyStopping コールバックを使用すると簡単です。
  • PyTorch では、既製の早期停止メソッドはありませんが、GitHub Gist で利用できる作業中の早期停止フックがあります。

完全なレポートは こちら をお読みください。

カスタムデータセットで Hugging Face Transformers をファインチューンする方法

カスタム IMDB データセットでセンチメント分析 (バイナリ分類) 用に DistilBERT transformer をファインチューンします。

完全なレポートは こちら をお読みください。

ヘルプの入手または機能のリクエスト

Hugging Face W&B integration に関する問題、質問、または機能のリクエストについては、Hugging Face フォーラムのこのスレッド に投稿するか、Hugging Face Transformers GitHub repo で issue をオープンしてください。

12 - Hugging Face Diffusers

Try in Colab

Hugging Face Diffusers は、画像、音声、さらには分子の3D構造を生成するための、最先端の学習済み拡散モデルのための頼りになるライブラリです。Weights & Biases のインテグレーションは、その使いやすさを損なうことなく、インタラクティブな集中 ダッシュボードに、豊富で柔軟な 実験管理、メディアの 可視化、パイプライン アーキテクチャ、および 設定管理を追加します。

たった2行で次世代のログ記録

わずか2行のコードを含めるだけで、プロンプト、ネガティブプロンプト、生成されたメディア、および 実験 に関連付けられた config をすべて記録します。以下は、ログ記録を開始するための2行のコードです。

# import the autolog function
from wandb.integration.diffusers import autolog

# call the autolog before calling the pipeline
autolog(init=dict(project="diffusers_logging"))
An example of how the results of your experiment are logged
実験 の 結果 がどのように記録されるかの例。

はじめに

  1. diffusers、transformers、accelerate、および wandb をインストールします。

    • コマンドライン:

      pip install --upgrade diffusers transformers accelerate wandb

    • ノートブック:

      !pip install --upgrade diffusers transformers accelerate wandb

  2. autolog を使用して Weights & Biases の run を初期化し、サポートされているすべての パイプライン 呼び出しからの入力と出力を自動的に追跡します。

    wandb.init()に必要な パラメータ の 辞書 を受け入れる init パラメータ を使用して、autolog() 関数を呼び出すことができます。

    autolog() を呼び出すと、Weights & Biases の run が初期化され、サポートされているすべての パイプライン 呼び出しからの入力と出力が自動的に追跡されます。

    • 各 パイプライン 呼び出しは、ワークスペース 内の独自の テーブルに追跡され、パイプライン 呼び出しに関連付けられた config は、その run の config 内の ワークフロー のリストに追加されます。
    • プロンプト、ネガティブプロンプト、および生成されたメディアは、wandb.Tableに記録されます。
    • シードや パイプライン アーキテクチャ を含む、実験 に関連付けられたその他すべての config は、run の config セクションに保存されます。
    • 各 パイプライン 呼び出しで生成されたメディアは、run の メディア パネルにも記録されます。

例

Autologging

以下は、動作中の autolog の簡単な エンドツーエンド の例です。

import torch
from diffusers import DiffusionPipeline

# import the autolog function
from wandb.integration.diffusers import autolog

# call the autolog before calling the pipeline
autolog(init=dict(project="diffusers_logging"))

# Initialize the diffusion pipeline
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
).to("cuda")

# Define the prompts, negative prompts, and seed.
prompt = ["a photograph of an astronaut riding a horse", "a photograph of a dragon"]
negative_prompt = ["ugly, deformed", "ugly, deformed"]
generator = torch.Generator(device="cpu").manual_seed(10)

# call the pipeline to generate the images
images = pipeline(
    prompt,
    negative_prompt=negative_prompt,
    num_images_per_prompt=2,
    generator=generator,
)

import torch
from diffusers import DiffusionPipeline

import wandb

# import the autolog function
from wandb.integration.diffusers import autolog

# call the autolog before calling the pipeline
autolog(init=dict(project="diffusers_logging"))

# Initialize the diffusion pipeline
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
).to("cuda")

# Define the prompts, negative prompts, and seed.
prompt = ["a photograph of an astronaut riding a horse", "a photograph of a dragon"]
negative_prompt = ["ugly, deformed", "ugly, deformed"]
generator = torch.Generator(device="cpu").manual_seed(10)

# call the pipeline to generate the images
images = pipeline(
    prompt,
    negative_prompt=negative_prompt,
    num_images_per_prompt=2,
    generator=generator,
)

# Finish the experiment
wandb.finish()

  • 単一の 実験 の結果:

    An example of how the results of your experiment are logged

  • 複数の 実験 の結果:

    An example of how the results of your experiment are logged

  • 実験 の config:

    An example of how the autolog logs the configs of your experiment

複数 パイプライン ワークフロー の追跡

このセクションでは、StableDiffusionXLPipelineによって生成された潜在空間が対応するリファイナーによって改良される、典型的な Stable Diffusion XL + Refiner ワークフロー での autolog を示します。

Try in Colab 
import torch
from diffusers import StableDiffusionXLImg2ImgPipeline, StableDiffusionXLPipeline
from wandb.integration.diffusers import autolog

# initialize the SDXL base pipeline
base_pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    variant="fp16",
    use_safetensors=True,
)
base_pipeline.enable_model_cpu_offload()

# initialize the SDXL refiner pipeline
refiner_pipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base_pipeline.text_encoder_2,
    vae=base_pipeline.vae,
    torch_dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
)
refiner_pipeline.enable_model_cpu_offload()

prompt = "a photo of an astronaut riding a horse on mars"
negative_prompt = "static, frame, painting, illustration, sd character, low quality, low resolution, greyscale, monochrome, nose, cropped, lowres, jpeg artifacts, deformed iris, deformed pupils, bad eyes, semi-realistic worst quality, bad lips, deformed mouth, deformed face, deformed fingers, deformed toes standing still, posing"

# Make the experiment reproducible by controlling randomness.
# The seed would be automatically logged to WandB.
seed = 42
generator_base = torch.Generator(device="cuda").manual_seed(seed)
generator_refiner = torch.Generator(device="cuda").manual_seed(seed)

# Call WandB Autolog for Diffusers. This would automatically log
# the prompts, generated images, pipeline architecture and all
# associated experiment configs to Weights & Biases, thus making your
# image generation experiments easy to reproduce, share and analyze.
autolog(init=dict(project="sdxl"))

# Call the base pipeline to generate the latents
image = base_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    output_type="latent",
    generator=generator_base,
).images[0]

# Call the refiner pipeline to generate the refined image
image = refiner_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image[None, :],
    generator=generator_refiner,
).images[0]

import torch
from diffusers import StableDiffusionXLImg2ImgPipeline, StableDiffusionXLPipeline

import wandb
from wandb.integration.diffusers import autolog

# initialize the SDXL base pipeline
base_pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    variant="fp16",
    use_safetensors=True,
)
base_pipeline.enable_model_cpu_offload()

# initialize the SDXL refiner pipeline
refiner_pipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base_pipeline.text_encoder_2,
    vae=base_pipeline.vae,
    torch_dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
)
refiner_pipeline.enable_model_cpu_offload()

prompt = "a photo of an astronaut riding a horse on mars"
negative_prompt = "static, frame, painting, illustration, sd character, low quality, low resolution, greyscale, monochrome, nose, cropped, lowres, jpeg artifacts, deformed iris, deformed pupils, bad eyes, semi-realistic worst quality, bad lips, deformed mouth, deformed face, deformed fingers, deformed toes standing still, posing"

# Make the experiment reproducible by controlling randomness.
# The seed would be automatically logged to WandB.
seed = 42
generator_base = torch.Generator(device="cuda").manual_seed(seed)
generator_refiner = torch.Generator(device="cuda").manual_seed(seed)

# Call WandB Autolog for Diffusers. This would automatically log
# the prompts, generated images, pipeline architecture and all
# associated experiment configs to Weights & Biases, thus making your
# image generation experiments easy to reproduce, share and analyze.
autolog(init=dict(project="sdxl"))

# Call the base pipeline to generate the latents
image = base_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    output_type="latent",
    generator=generator_base,
).images[0]

# Call the refiner pipeline to generate the refined image
image = refiner_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image[None, :],
    generator=generator_refiner,
).images[0]

# Finish the experiment
wandb.finish()
  • Stable Diffisuion XL + Refiner の 実験 の例: An example of how the autolog tracks an Stable Diffusion XL + Refiner experiment

その他のリソース