> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# 表をログする

> Python SDK を使用して、不変、変更可能、段階的など異なるログモードで W&B 表を作成およびログする方法について説明します。

W\&B 表で表形式データを可視化およびログします。W\&B 表は、各列が単一のデータタイプを持つ 2 次元のグリッドです。各行は W\&B [run](/ja/products/wandb/runs) にログされた 1 つ以上のデータポイントを表します。W\&B 表はプリミティブ型および数値型に加え、ネストしたリスト、辞書、リッチメディアタイプをサポートします。

W\&B 表は W\&B の特殊な [データタイプ](/ja/products/wandb/ref/python/data-types) で、[アーティファクト](/ja/products/wandb/artifacts) オブジェクトとしてログされます。

W\&B Python SDK を使用して [表オブジェクトを作成およびログ](#create-and-log-a-new-table) します。表オブジェクトを作成する際は、表の列とデータ、および [モード](#table-logging-modes) を指定します。このモードにより、ML 実験中に表がどのようにログおよび更新されるかが決まります。

<Note>
  `INCREMENTAL` モードは W\&B Server v0.70.0 以降でサポートされます。
</Note>

<h2 id="create-and-log-a-table">
  表を作成してログする
</h2>

1. `wandb.init()` で新しい run を初期化します。
2. [`wandb.Table`](/ja/products/wandb/ref/python/data-types/table) クラスを使用して Table オブジェクトを作成します。`columns` と `data` の各パラメーターに、表の列とデータをそれぞれ指定します。オプションの `log_mode` パラメーターを 3 つのモードのいずれかに設定することを推奨します: `IMMUTABLE` (デフォルト)、`MUTABLE`、または `INCREMENTAL`。詳細については、次のセクションの [Table ログモード](#logging-modes) を参照してください。
3. `run.log()` で表を W\&B にログします。

次の例は、2 つの列 `a` と `b`、および 2 行のデータ `["a1", "b1"]` と `["a2", "b2"]` を持つ表を作成してログする方法を示しています:

```python theme={"system"}
import wandb

# 新しい run を開始します
with wandb.init(project="table-demo") as run:

    # 2 列 2 行のデータを持つ表オブジェクトを作成します
    my_table = wandb.Table(
        columns=["a", "b"],
        data=[["a1", "b1"], ["a2", "b2"]],
        log_mode="IMMUTABLE"
        )

    # 表を W&B にログします
    run.log({"Table Name": my_table})
```

<h2 id="logging-modes">
  ログモード
</h2>

[`wandb.Table`](/ja/products/wandb/ref/python/data-types/table) の `log_mode` パラメーターは、ML 実験中に表をどのようにログし、更新するかを決定します。`log_mode` パラメーターは、`IMMUTABLE`、`MUTABLE`、`INCREMENTAL` の 3 つの引数のいずれかを受け入れます。モードによって、表のログ方法、変更方法、および W\&B アプリでのレンダリング方法が異なります。

以下に、3 つのログモードの定義、主な違い、および各モードの一般的なユースケースを示します。

| モード | 定義 | ユースケース | 利点 |
| - | - | - | - |
| `IMMUTABLE` | 表を W\&B にログした後は、変更できません。 | - run の終了時に生成された表形式データを、後の分析のために保存する | - run の終了時にログする場合のオーバーヘッドが最小限<br />- すべての行が UI にレンダリングされる |
| `MUTABLE` | 表を W\&B にログした後、既存の表を新しい表で上書きできます。 | - 既存の表に列や行を追加する<br />- 新しい情報で結果を拡充する | - 表の変更を取得できる<br />- すべての行が UI にレンダリングされる |
| `INCREMENTAL` | 機械学習の実験を通じて、新しい行をバッチ単位で表に追加します。 | - 表にバッチ単位で行を追加する<br /> - 長時間実行されるトレーニング ジョブ<br />- 大規模なデータセットをバッチ単位で処理する<br />- 進行中の結果をモニタリングする | - トレーニング中に UI で更新を確認できる<br />- 増分を順に確認できる |

次のセクションでは、各モードのコードスニペット例と、各モードを使用する際の考慮事項を示します。

<h3 id="mutable-mode">
  MUTABLE モード
</h3>

`MUTABLE` モードでは、既存の表を新しい表に置き換えることで表を更新します。`MUTABLE` モードは、反復処理ではないプロセスで既存の表に新しい列や行を追加する場合に便利です。UI では、最初にログした後に追加された列や行も含め、すべての行と列が表にレンダリングされます。

<Note>
  `MUTABLE` モードでは、表をログするたびに表オブジェクトが置き換えられます。表を新しい表で上書きする処理は計算コストが高く、大きな表では時間がかかる場合があります。
</Note>

次の例では、`MUTABLE` モードで表を作成してログし、その後に新しい列を追加する方法を示します。表オブジェクトは 3 回ログされます。1 回目は初期データ、2 回目は信頼度スコア、3 回目は最終的な予測を追加した時点です。

<Note>
  次の例では、データの読み込みに仮の関数 `load_eval_data()` を、予測に仮の関数 `model.predict()` を使用しています。これらは、ご自身のデータ読み込み関数と予測関数に置き換えてください。
</Note>

```python theme={"system"}
import wandb
import numpy as np

with wandb.init(project="mutable-table-demo") as run:

    # MUTABLE ログモードで表オブジェクトを作成します
    table = wandb.Table(columns=["input", "label", "prediction"],
                        log_mode="MUTABLE")

    # データを読み込んで予測を行います
    inputs, labels = load_eval_data() # プレースホルダー関数
    raw_preds = model.predict(inputs) # プレースホルダー関数

    for inp, label, pred in zip(inputs, labels, raw_preds):
        table.add_data(inp, label, pred)

    # ステップ 1: 初期データをログします 
    run.log({"eval_table": table})  # 初期状態の表をログします

    # ステップ 2: 信頼度スコアを追加します（例: softmax の最大値）
    confidences = np.max(raw_preds, axis=1)
    table.add_column("confidence", confidences)
    run.log({"eval_table": table})  # 信頼度の情報を追加します

    # ステップ 3: 後処理済みの予測を追加します
    # （例: しきい値処理や平滑化を施した出力）
    post_preds = (confidences > 0.7).astype(int)
    table.add_column("final_prediction", post_preds)
    run.log({"eval_table": table})  # 列をさらに追加して最終更新します
```

トレーニングループのように、列は追加せずに新しい行のバッチだけを段階的に追加したい場合は、代わりに [`INCREMENTAL` モード](#INCREMENTAL-mode) を使用することを検討してください。

<h3 id="incremental-mode">
  段階的モード
</h3>

段階的モードでは、機械学習の実験中に行をバッチ単位で表にログします。これは、長時間実行されるジョブのモニタリングや、更新のたびに run 中にログすると非効率になる大きな表を扱う場合に最適です。UI では、行がログされるたびに表に新しい行が追加されるため、run 全体の終了を待たずに最新のデータを確認できます。また、増分を順に切り替えて、さまざまな時点の表を確認することもできます。

<Note>
  W\&B アプリ の run ワークスペースには、増分数の上限が 100 あります。100 を超える増分をログした場合、run ワークスペースには最新の 100 のみが表示されます。
</Note>

次の例では、`INCREMENTAL` モードで表を作成してログした後、新しい行を追加します。表はトレーニングステップ (`step`) ごとに 1 回ログされます。

<Note>
  次の例では、データを読み込むための仮の関数 `get_training_batch()`、モデルをトレーニングするための仮の関数 `train_model_on_batch()`、予測を行うための仮の関数 `predict_on_batch()` を使用しています。これらを独自のデータ読み込み、トレーニング、予測の関数に置き換える必要があります。
</Note>

```python theme={"system"}
import wandb

with wandb.init(project="incremental-table-demo") as run:

    # INCREMENTAL ログモードで表を作成します
    table = wandb.Table(columns=["step", "input", "label", "prediction"],
                        log_mode="INCREMENTAL")

    # トレーニングループ
    for step in range(get_num_batches()): # 仮の関数
        # バッチデータを読み込みます
        inputs, labels = get_training_batch(step) # 仮の関数

        # トレーニングと予測を行います
        train_model_on_batch(inputs, labels) # 仮の関数
        predictions = predict_on_batch(inputs) # 仮の関数

        # バッチデータを表に追加します
        for input_item, label, prediction in zip(inputs, labels, predictions):
            table.add_data(step, input_item, label, prediction)

        # 表を段階的にログします
        run.log({"training_table": table}, step=step)
```

段階的にログする方法は、通常、毎回新しい表をログする方法 (`log_mode=MUTABLE`) よりも計算効率が高くなります。ただし、多数の増分をログすると、W\&B アプリ が表のすべての行をレンダリングしない場合があります。run の実行中に表のデータを更新して表示し、すべてのデータを分析に利用できるようにしたい場合は、2 つの表の使用を検討してください。一方のログモードを `INCREMENTAL` に、もう一方を `IMMUTABLE` に設定します。

次の例では、`INCREMENTAL` と `IMMUTABLE` のログモードを組み合わせて、これを実現する方法を示します。

```python theme={"system"}
import wandb

with wandb.init(project="combined-logging-example") as run:

    # トレーニング中に効率的に更新するための段階的な表を作成します
    incr_table = wandb.Table(columns=["step", "input", "prediction", "label"],
                            log_mode="INCREMENTAL")

    # トレーニングループ
    for step in range(get_num_batches()):
        # バッチを処理します
        inputs, labels = get_training_batch(step)
        predictions = model.predict(inputs)

        # 段階的な表にデータを追加します
        for inp, pred, label in zip(inputs, predictions, labels):
            incr_table.add_data(step, inp, pred, label)

        # 段階的な更新をログします（最終的な表と区別するために接尾辞 -incr を付けます）
        run.log({"table-incr": incr_table}, step=step)

    # トレーニング終了時に、すべてのデータを含む完全な不変の表を作成します
    # 完全なデータセットを保持するために、デフォルトの IMMUTABLE モードを使用します
    final_table = wandb.Table(columns=incr_table.columns, data=incr_table.data, log_mode="IMMUTABLE")
    run.log({"table": final_table})
```

この例では、トレーニング中に `incr_table` を段階的にログします (`log_mode="INCREMENTAL"` を使用) 。これにより、新しいデータが処理されるたびに、表の更新をログして表示できます。トレーニングの終了時に、段階的な表のすべてのデータを含む不変の表 (`final_table`) が作成されます。不変の表をログすることで、完全なデータセットを追加の分析用に保存し、W\&B アプリ ですべての行を表示できます。

<h2 id="examples">
  サンプル
</h2>

<h3 id="enriching-evaluation-results-with-mutable">
  MUTABLE を使用して評価結果を拡充する
</h3>

```python theme={"system"}
import wandb
import numpy as np

with wandb.init(project="mutable-logging") as run:

    # ステップ 1: 最初の予測をログする
    table = wandb.Table(columns=["input", "label", "prediction"], log_mode="MUTABLE")
    inputs, labels = load_eval_data()
    raw_preds = model.predict(inputs)

    for inp, label, pred in zip(inputs, labels, raw_preds):
        table.add_data(inp, label, pred)

    run.log({"eval_table": table})  # 生の予測をログする

    # ステップ 2: 信頼度スコア（例: softmax の最大値）を追加する
    confidences = np.max(raw_preds, axis=1)
    table.add_column("confidence", confidences)
    run.log({"eval_table": table})  # 信頼度情報を追加する

    # ステップ 3: 後処理した予測を追加する
    # （例: しきい値処理や平滑化を施した出力）
    post_preds = (confidences > 0.7).astype(int)
    table.add_column("final_prediction", post_preds)
    run.log({"eval_table": table})
```

<h3 id="resuming-runs-with-incremental-tables">
  段階的な表を使用した run の再開
</h3>

run を再開すると、段階的な表にログし続けることができます。

```python theme={"system"}
# run を開始または再開します
resumed_run = wandb.init(project="resume-incremental", id="your-run-id", resume="must")

# 段階的な表を作成します。以前ログした表のデータを設定する必要はありません
# 増分は表のアーティファクトに引き続き追加されます。
table = wandb.Table(columns=["step", "metric"], log_mode="INCREMENTAL")

# ログし続けます
for step in range(resume_step, final_step):
    metric = compute_metric(step)
    table.add_data(step, metric)
    resumed_run.log({"metrics": table}, step=step)

resumed_run.finish()
```

<Note>
  `wandb.Run.define_metric("<table_key>", summary="none")` または `wandb.Run.define_metric("*", summary="none")` を使用して、段階的な表に使用するキーのサマリーを無効にすると、増分は新しい表にログされます。
</Note>

<h3 id="training-with-incremental-batch-training">
  段階的なバッチトレーニングによるトレーニング
</h3>

```python theme={"system"}

with wandb.init(project="batch-training-incremental") as run:

    # 段階的な表を作成します
    table = wandb.Table(columns=["step", "input", "label", "prediction"], log_mode="INCREMENTAL")

    # トレーニングループをシミュレートします
    for step in range(get_num_batches()):
        # バッチデータを読み込みます
        inputs, labels = get_training_batch(step)

        # このバッチでモデルをトレーニングします
        train_model_on_batch(inputs, labels)

        # モデルの推論を実行します
        predictions = predict_on_batch(inputs)

        # 表にデータを追加します
        for input_item, label, prediction in zip(inputs, labels, predictions):
            table.add_data(step, input_item, label, prediction)

        # 表の現在の状態を段階的にログします
        run.log({"training_table": table}, step=step)
```