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

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

インテグレーション

W&B のインテグレーションを使えば、既存のプロジェクトで実験管理やデータのバージョン管理をすばやく簡単にセットアップできます。PyTorch のような ML フレームワーク、Hugging Face のような ML ライブラリ、または Amazon SageMaker のようなクラウドサービスのインテグレーションをご覧ください。

関連リソース

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

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

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

このガイドでは、独自の Python ライブラリに W&B をインテグレーションするためのベストプラクティスを提供します。このことで、強力な実験管理、GPU およびシステム監視、モデルチェックポイントなどが利用可能になります。

ここでは、作業しているコードベースが単一の Python トレーニングスクリプトや Jupyter ノートブックよりも複雑な場合のベストなヒントとベストプラクティスを紹介します。対象となるトピックは以下の通りです：

  • 設定要件
  • ユーザーログイン
  • wandb Run の開始
  • Run Config の定義
  • 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 セクションまでスクロールします。
  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 によってログ記録された計算の単位です。通常、トレーニング実験ごとに1つの W&B Run を関連付けます。

以下のコードで W&B を初期化して Run を開始します：

run = wandb.init()

オプションとして、プロジェクトの名前をつけることができます。また、コード内で wandb_project といったパラメータを使ってユーザーに設定してもらうこともできます。エンティティのパラメータについては wandb_entity などのユーザー名やチーム名を使用します：

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

Run を終了するには run.finish() を呼び出す必要があります。次のように Run をコンテキストマネージャとして使うこともできます：

# このブロックが終了すると、自動的に run.finish() が呼び出されます。
# 例外によって終了した場合、run.finish(exit_code=1) を使用して
# Run を失敗とマークします。
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 Config の定義

wandb の Run Config を使って、W&B Run を作成する際にモデルやデータセットに関するメタデータを提供できます。この情報を利用して、異なる実験を比較し、その主な違いをすばやく理解することができます。

W&B Runs テーブル

ログ可能な一般的な設定パラメータには以下が含まれます：

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

以下のコードスニペットは設定をログする方法を示しています：

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

Run Config の更新

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)

メトリクスが多い場合、メトリクス名にプレフィックスを使用して UI 上で自動的にグループ化することができます。例えば、train/... と val/... を使用することで、トレーニングや検証メトリクス、その他のメトリクスを分けたセクションが W&B ワークスペースに作られます：

metrics = {
    "train/loss": 0.4,
    "train/learning_rate": 0.4,
    "val/loss": 0.5, 
    "val/accuracy": 0.7
}
run.log(metrics)
2つの別々のセクションがあるW&Bワークスペース

run.log の詳細を学ぶ。

x軸の非整合を防ぐ

同じトレーニングステップで run.log を複数回呼び出すと、wandb SDK は run.log を呼び出すたびに内部のステップカウンタを増加させます。このカウンタはトレーニングループ内のトレーニングステップと一致しないことがあります。

このような状況を避けるために、wandb.init を呼び出した直後に run.define_metric を使用して x 軸のステップを明示的に定義してください：

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

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

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

その後、メトリクス、step メトリクス、および global_step を run.log を呼び出すたびにログします：

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」が検証ループ中に利用できない場合、 wandb は自動的に以前にログされた「global_step」 の値を使用します。この場合、メトリクスの初期値をログして、その値が必要なときに定義されるようにしてください。

画像、テーブル、オーディオなどのログ記録

メトリクスに加えて、プロット、ヒストグラム、テーブル、テキスト、画像、動画、オーディオ、3D などのメディアをログすることができます。

データをログする際の考慮事項には以下が含まれます：

  • メトリクスはどのくらいの頻度でログされるべきか？ オプション化すべきか？
  • 視覚化に役立つデータの種類は何か？
    • 画像の場合、サンプル予測、セグメンテーションマスクなどのログを記録して、時間の経過を見て進化を追うことができます。
    • テキストの場合、後で検討できるサンプル予測のテーブルをログすることができます。

メディア、オブジェクト、プロットなどのログ記録について詳しく学ぶ。

分散トレーニング

分散環境をサポートするフレームワークでは、以下のワークフローのいずれかを適用することができます：

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

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

モデルチェックポイントとその他のログ記録

フレームワークがモデルまたはデータセットを使用または生成する場合、W&B Artifacts を通じて wandb で完全なトレース可能性を持ってそれらをログし、パイプライン全体を自動的に監視させることができます。

W&B に保存されたデータセットとモデルチェックポイント

Artifacts を使用しているとき、ユーザーに次のことを定義させることは有用ですが必須ではありません：

  • モデルチェックポイントまたはデータセットをログする機能を有すること（任意にする場合）。
  • 使用されるアーティファクトのパス/参照を入力として使用する場合。たとえば、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") # モデルの重みが保存されているローカルディレクトリ

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

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

Artifacts は任意の頻度で出力ログが可能（例えば、各エポックごと、各500ステップごとなど）であり、これらは自動的にバージョン管理されます。

学習済みモデルまたはデータセットのログと追跡

トレーニングの入力として使用されるアーティファクト（学習済みモデルやデータセットなど）をログすることができます。以下のスニペットでは、アーティファクトをログし、上記のグラフのように進行中の Run の入力として追加する方法を示しています。

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

アーティファクトをダウンロードする

アーティファクト（データセット、モデルなど）を再利用する場合、 wandb はローカルにコピー（およびキャッシュ）をダウンロードします：

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

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

たとえば分散環境や単純な推論のために wandb Run（wandb.init を通して）を作成せずに Artifact をダウンロードしたい場合、代わりに wandb API を使用してアーティファクトを参照できます：

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

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

ハイパーパラメータのチューニング

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

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

以下のインテグレーションで高度な W&B インテグレーションがどのように見えるか見ることができます。ただし、ほとんどのインテグレーションはこれほど複雑ではありません：

2 - Azure OpenAI ファインチューニング

Azure OpenAI モデルを Fine-Tune する方法とW&Bの使用方法。

イントロダクション

Microsoft Azureを使用してGPT-3.5やGPT-4モデルをファインチューニングすることで、W&Bはメトリクスを自動的にキャプチャし、W&Bの実験管理および評価ツールを通じて系統的な評価を促進することで、モデルの性能を追跡し、分析し、改善します。

前提条件

  • 公式のAzureドキュメントに従ってAzure OpenAIサービスをセットアップします。
  • APIキーを使用してW&Bアカウントを設定します。

ワークフローの概要

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

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

2. 実験管理

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

  • トレーニングと検証のメトリクス
  • モデルのハイパーパラメーター
  • リソースの利用状況
  • トレーニングアーティファクト

3. モデルの評価

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

  • モデルの出力を参照データセットと比較評価します。
  • 異なるファインチューニングのrun間で性能を比較します。
  • 特定のテストケースでモデルの振る舞いを分析します。
  • モデル選択のためのデータドリブンの意思決定を行います。

実際の例

追加リソース

3 - Catalyst

Catalyst、PyTorch フレームワークに W&B を統合する方法。

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

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

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

インタラクティブな例

Catalyst と W&B インテグレーションを実際に見るために、Colab の例 を実行してください。

4 - Cohere fine-tuning

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

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

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

Cohere ファインチューニング結果のログ

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

  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 の詳細で設定を作成します
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 の設定を渡します
    ),
  ),
)

  3. 作成した W&B プロジェクトで、モデルのファインチューニングトレーニングと検証のメトリクスやハイパーパラメーターを確認します。

Runsの整理

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

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

リソース

5 - Databricks

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

W&B は、Databricks 環境での W&B Jupyter ノートブック体験をカスタマイズすることにより、Databricks と統合します。

Databricks の設定

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

    クラスター設定に移動し、クラスターを選択し、Libraries をクリックします。Install New をクリックし、PyPI を選択してパッケージ wandb を追加します。

  2. 認証の設定

    あなたの W&B アカウントを認証するために、ノートブックが照会できる 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

# こちらから api_key を追加します: https://app.wandb.ai/authorize
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() を使用しようとする際に必要な設定（暫定的）です。

import os

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

6 - DeepChecks

W&B を DeepChecks と統合する方法。
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()

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

import wandb

wandb.login()

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

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

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

例

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

この Weights & Biases インテグレーションに関して質問や問題がある場合は、DeepChecks github リポジトリにイシューを開いてください。対応し、ご回答いたします :)

7 - DeepChem

DeepChem ライブラリ と W&B の統合方法について

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

DeepChem のロギングを 3 行のコードで

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

Report と Google Colab

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

すぐに動作するコードを見たい場合は、この Google Colab をチェックしてください。

実験管理のトラッキング

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 イメージを使用します。wandb docker my/image:latest のようにして、同じコマンドで独自の docker イメージを開始することもできます。コマンドは現在のディレクトリーをコンテナの “/app” ディレクトリーにマウントしますが、これは “–dir” フラグで変更できます。

プロダクション

wandb docker-run コマンドは、プロダクションのワークロードに提供されます。これは nvidia-docker の代替として使用されることを想定しています。これは、docker run コマンドにあなたの資格情報と WANDB_DOCKER 環境変数を追加する単純なラッパーです。"–runtime" フラグを渡さず、nvidia-docker がマシンにインストールされている場合、ランタイムが nvidia に設定されていることも確認されます。

Kubernetes

トレーニングワークロードを Kubernetes 上で実行し、k8s API がポッドに公開されている場合（デフォルトでそうです）、wandb は API に対して docker イメージのダイジェストを問い合わせ、WANDB_DOCKER 環境変数を自動的に設定します。

復元

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

9 - Farama Gymnasium

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

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

私たちの Gymnasium インテグレーションは非常に軽量です。 単に gymnasium からログされるビデオファイルの名前を見るだけで、それにちなんで名前を付けるか、一致するものが見つからない場合はデフォルトで "videos" とします。 より細かい制御が必要な場合は、いつでも手動でビデオをログすることができます。

Gymnasium と CleanRL ライブラリを使用する方法について詳しく知りたい方は、このレポートをご覧ください。

10 - fastai

もしあなたが fastai を使ってモデルを訓練しているなら、W&B には WandbCallback を使用した簡単なインテグレーションがあります。インタラクティブなドキュメントと例についてはこちらをご覧ください →

登録と 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()

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

import wandb
from fastai.callback.wandb import *

# wandb run を開始してログをとる
wandb.init(project="my_project")

# トレーニングフェーズの一部のみログする場合
learn.fit(..., cbs=WandbCallback())

# すべてのトレーニングフェーズで継続的にログをとる場合
learn = learner(..., cbs=WandbCallback())

WandbCallback 引数

WandbCallback は以下の引数を受け入れます:

Args 説明
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 ログされたデータセットの名前 (デフォルトは フォルダ名)。
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 はこれを自動的にサポートし、マルチGPU実験をすぐにトラッキングできるようにします。

この簡単な例を確認してください:

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 learner。
save_model True モデルが各ステップで改善されれば保存します。また、トレーニング終了時に最適なモデルをロードします。
mode auto min、max、または auto: ステップ間で指定されたトレーニングメトリクスをどのように比較するか。
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. ユーザー設定を選択し、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()

初めてW&Bを使用する場合、クイックスタートをご覧になることをお勧めします。

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

W&B Projectは、関連するRunsからログされたすべてのチャート、データ、モデルを保存する場所です。プロジェクト名をつけることで、作業を整理し、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にデフォルト設定されます。

トレーニングRunsをW&Bにログする

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

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(
    # 他の引数やキーワード引数をここに
    report_to="wandb",  # W&Bにログを有効化
    run_name="bert-base-high-lr",  # W&B runの名前 (オプション)
    logging_steps=1,  # W&Bにログする頻度
)

trainer = Trainer(
    # 他の引数やキーワード引数をここに
    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でのモデルチェックポイントの例はこちらをご覧ください here)。

W&B Registry

チェックポイントをArtifactsにログしたら、最良のモデルチェックポイントを登録して、**Registry**でチーム全体に中央集約できます。Registryを使用すると、タスクごとに最良のモデルを整理し、モデルライフサイクルを管理し、機械学習ライフサイクル全体を追跡および監査し、オートメーションダウンストリームアクションを自動化できます。

モデルのアーティファクトをリンクするには、Registryを参照してください。

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

トレーニングや評価中にモデル出力を視覚化することは、モデルがどのようにトレーニングされているかを理解するためにしばしば重要です。

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

トレーニング中に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

最良のモデルを保存する方法は？

Trainerにload_best_model_at_end=TrueのTrainingArgumentsを渡すと、W&Bは最良のパフォーマンスを示すモデルチェックポイントをアーティファクトに保存します。

モデルチェックポイントをアーティファクトとして保存すれば、それらをRegistryに昇格させることができます。Registryでは以下のことが可能です：

  • MLタスクによって最良のモデルバージョンを整理する。
  • モデルを集約してチームと共有する。
  • モデルをステージングしてプロダクションに展開するか、さらに評価するためにブックマークする。
  • 下流のCI/CDプロセスをトリガーする。

保存したモデルをロードするには？

WANDB_LOG_MODELでW&B Artifactsにモデルを保存した場合、追加トレーニングや推論のためにモデルウェイトをダウンロードできます。同じHugging Faceアーキテクチャーにモデルを読み戻すだけです。

# 新しいrunを作成
with wandb.init(project="amazon_sentiment_analysis") as run:
    # アーティファクトの名前とバージョンを指定
    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引数として使用し、Trainerにresume_from_checkpoint=Trueを渡すことでトレーニングを再開できます。

last_run_id = "xxxxxxxx"  # wandb workspaceからrun_idを取得

# run_idからwandb runを再開
with wandb.init(
    project=os.environ["WANDB_PROJECT"],
    id=last_run_id,
    resume="must",
) as run:
    # アーティファクトを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に評価サンプルをログする方法を示します。on_evaluateメソッドを使用してeval_stepsごとにログします。

ここでは、トークナイザーを使用してモデル出力から予測とラベルをデコードするための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):
    """トレーニング中にモデルの予測をログするカスタムWandbCallback。

    このコールバックは、トレーニング中の各ログステップでモデルの予測とラベルをwandb.Tableにログします。トレーニングの進行に応じたモデルの予測を視覚化することができます。

    Attributes:
        trainer (Trainer): Hugging Face Trainerインスタンス。
        tokenizer (AutoTokenizer): モデルに関連付けられたトークナイザー。
        sample_dataset (Dataset): 予測を生成するための
          検証データセットのサブセット。
        num_samples (int, optional): 検証データセットから選択するサンプルの数。
          デフォルトは100。
        freq (int, optional): ログの頻度。デフォルトは2。
    """

    def __init__(self, trainer, tokenizer, val_dataset, num_samples=100, freq=2):
        """WandbPredictionProgressCallbackインスタンスを初期化します。

        Args:
            trainer (Trainer): Hugging Face Trainerインスタンス。
            tokenizer (AutoTokenizer): モデルに関連付けられたトークナイザー。
            val_dataset (Dataset): 検証データセット。
            num_samples (int, optional): 予測を生成するために
              検証データセットから選択するサンプルの数。
              デフォルトは100。
            freq (int, optional): ログの頻度。デフォルトは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)
        # `freq`エポックごとに予測をログすることにより、ログの頻度を制御
        if state.epoch % self.freq == 0:
            # 予測を生成
            predictions = self.trainer.predict(self.sample_dataset)
            # 予測とラベルをデコード
            predictions = decode_predictions(self.tokenizer, predictions)
            # 予測をwandb.Tableに追加
            predictions_df = pd.DataFrame(predictions)
            predictions_df["epoch"] = state.epoch
            records_table = self._wandb.Table(dataframe=predictions_df)
            # テーブルを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アーティファクトとしてログします（デフォルトはfalse）

  • false（デフォルト）：モデルチェックポイントは行われません
  • checkpoint：args.save_stepsごとにチェックポイントがアップロードされます（TrainerのTrainingArgumentsで設定）
  • end：トレーニングの終了時に最終モデルチェックポイントがアップロードされます。
WANDB_WATCH

モデルの勾配、パラメータ、またはそのいずれもログするかどうかを設定します

  • false（デフォルト）：勾配やパラメータのログは行わない
  • gradients：勾配のヒストグラムをログ
  • all：勾配とパラメータのヒストグラムをログ
WANDB_DISABLED trueに設定すると、ログが完全にオフになります（デフォルトはfalse）
WANDB_SILENT trueに設定すると、wandbによって印刷される出力が消音されます（デフォルトは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",
)

追加のリソース

以下は、6つのTransformersとW&Bに関連する記事で楽しめるかもしれないものです。

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

詳細なレポートはこちらをご覧ください。

Hugging Tweets: ツイートを生成するモデルをトレーニング
  • 記事では、著者が任意の人のツイートを5分で再学習するようにGPT2 HuggingFace Transformerモデルをファインチューニングする方法を実演します。
  • モデルは以下のパイプラインを使用します：ツイートのダウンロード、データセットの最適化、初期実験、ユーザー間の損失の比較、モデルのファインチューニング。

詳細なレポートはこちらをご覧ください。

Hugging Face BERTとWBによる文の分類
  • この記事では、自然言語処理の最近のブレークスルーの力を活用した文分類器の構築について説明します。NLPへの転移学習の適用に焦点を当てています。
  • 文法的に正しいかどうかをラベル付けした文のセットである、単一文分類用のThe Corpus of Linguistic Acceptability (CoLA) データセットを使用します。このデータセットは2018年5月に初めて公開されました。
  • GoogleのBERTを使用して、最小限の努力で様々なNLPタスクで高性能なモデルを作成します。

詳細なレポートはこちらをご覧ください。

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

詳細なレポートはこちらをご覧ください。

HuggingFaceにおけるEarly Stoppingの例
  • Early Stopping正則化を使用して、Hugging Face Transformerをファインチューニングすることは、PyTorchやTensorFlowでネイティブに実行できます。
  • TensorFlowでEarlyStoppingコールバックを使用する方法は、tf.keras.callbacks.EarlyStopping コールバックを使って簡単にできます。
  • PyTorchでは、オフの早期停止メソッドはありませんが、GitHub Gistで利用可能な早期停止フックがあります。

詳細なレポートはこちらをご覧ください。

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

カスタムIMDBデータセットでセンチメント分析（二項分類）のためにDistilBERT transformerをファインチューニングします。

詳細なレポートはこちらをご覧ください。

ヘルプを受けたり、機能をリクエストする

Hugging Face W&Bインテグレーションに関する問題、質問、または機能のリクエストについては、Hugging Faceフォーラムのこのスレッドに投稿するか、Hugging FaceTransformers GitHubリポジトリで問題を開いてください。

12 - Hugging Face Diffusers

Try in Colab

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

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

実験に関連するすべてのプロンプト、ネガティブプロンプト、生成されたメディア、および設定を、たった2行のコードを含めるだけでログできます。ログを始めるためのコードはこちらの2行です:

# autolog 関数をインポート
from wandb.integration.diffusers import autolog

# パイプラインを呼び出す前に autolog を呼ぶ
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 を初期化し、すべてのサポートされているパイプライン呼び出しからの入出力を自動的に追跡します。

    init パラメータを持つ autolog() 関数を呼び出すことができ、このパラメータは wandb.init() によって要求されるパラメータの辞書が受け入れられます。

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

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

例

Autologging

ここでは、autolog の動作を示す簡単なエンドツーエンドの例を示します。

import torch
from diffusers import DiffusionPipeline

# autolog 関数をインポート
from wandb.integration.diffusers import autolog

# パイプラインを呼び出す前に autolog を呼ぶ
autolog(init=dict(project="diffusers_logging"))

# 拡散パイプラインを初期化
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
).to("cuda")

# プロンプト、ネガティブプロンプト、種を定義
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)

# パイプラインを呼び出して画像を生成
images = pipeline(
    prompt,
    negative_prompt=negative_prompt,
    num_images_per_prompt=2,
    generator=generator,
)

import torch
from diffusers import DiffusionPipeline

import wandb

# autolog 関数をインポート
from wandb.integration.diffusers import autolog

# パイプラインを呼び出す前に autolog を呼ぶ
autolog(init=dict(project="diffusers_logging"))

# 拡散パイプラインを初期化
pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
).to("cuda")

# プロンプト、ネガティブプロンプト、種を定義
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)

# パイプラインを呼び出して画像を生成
images = pipeline(
    prompt,
    negative_prompt=negative_prompt,
    num_images_per_prompt=2,
    generator=generator,
)

# 実験を終了
wandb.finish()

  • 単一の実験の結果:

    An example of how the results of your experiment are logged

  • 複数の実験の結果:

    An example of how the results of your experiment are logged

  • 実験の設定:

    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

# SDXL ベース パイプラインを初期化
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()

# SDXL リファイナー パイプラインを初期化
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"

# 乱数を制御することで実験を再現可能にします。
# シードは自動的に WandB にログされます。
seed = 42
generator_base = torch.Generator(device="cuda").manual_seed(seed)
generator_refiner = torch.Generator(device="cuda").manual_seed(seed)

# WandB Autolog を Diffusers に呼び出します。これにより、
# プロンプト、生成された画像、パイプライン アーキテクチャー、すべての
# 関連する実験設定が Weights & Biases に自動的にログされ、
# 画像生成実験を簡単に再現、共有、分析できるようになります。
autolog(init=dict(project="sdxl"))

# ベースパイプラインを呼び出して潜在変数を生成
image = base_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    output_type="latent",
    generator=generator_base,
).images[0]

# リファイナーパイプラインを呼び出して調整された画像を生成
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

# SDXL ベース パイプラインを初期化
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()

# SDXL リファイナー パイプラインを初期化
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"

# 乱数を制御することで実験を再現可能にします。
# シードは自動的に WandB にログされます。
seed = 42
generator_base = torch.Generator(device="cuda").manual_seed(seed)
generator_refiner = torch.Generator(device="cuda").manual_seed(seed)

# WandB Autolog を Diffusers に呼び出します。これにより、
# プロンプト、生成された画像、パイプライン アーキテクチャー、すべての
# 関連する実験設定が Weights & Biases に自動的にログされ、
# 画像生成実験を簡単に再現、共有、分析できるようになります。
autolog(init=dict(project="sdxl"))

# ベースパイプラインを呼び出して潜在変数を生成
image = base_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    output_type="latent",
    generator=generator_base,
).images[0]

# リファイナーパイプラインを呼び出して調整された画像を生成
image = refiner_pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image[None, :],
    generator=generator_refiner,
).images[0]

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

追加リソース