HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

注釈付きJEPA

The Annotated JEPA (elonlit.com)

38 pointsby surprisetalk6 コメント

要約

この記事は、Yann LeCunが提唱する自己教師あり学習のアプローチであるJoint Embedding Predictive Architectures (JEPA)について、ゼロから段階的に解説します。JEPAは、ラベルなしで世界を理解するモデルを訓練するために、ピクセルレベルの再構築ではなく、表現空間(潜在空間)での予測を用いることを提案しています。これにより、モデルは意味のある構造を学習し、無関係な詳細に容量を浪費することを避けることができます。

全文翻訳

注釈付きJEPA

Elon Litman

[画像: 花]

この記事は、Joint Embedding Predictive Architectures(JEPA)のゼロからのステップバイステップ、注釈付きウォークスルーです。JEPAのために、Transformerのために『The Annotated Transformer』が行ったことと同じことを目指します。つまり、完全なオブジェクトを構築し、すべての動作部分を説明し、動作するトレーニングループで終わることです。

JEPAは、自己教師あり学習における根本的な問いに対する Yann LeCun の提案された答えです。それは、ラベルなしで世界を理解するモデルをどのように訓練するか、自明な解に崩壊せず、無関係な詳細に容量を浪費しないか、ということです。

その答えは、原理的にはエレガントで、実践では微妙ですが、表現空間または潜在空間での予測です。

議論を具体的に保つために、主な実行例は I‑JEPA、つまり画像インスタンシエーションです。なぜテキストではなく画像やビデオなのか? LeCun は、言語はすでに知識の高度に圧縮された離散的な表現であり、次のトークンを予測するには物理的現実ではなく人間のコミュニケーションパターンをモデル化する必要があると主張しています。対照的に、視覚的予測は、永続性、隠蔽、およびダイナミクスを理解する必要があります。JEPAは、ピクセルレベルの再構築が冗長な詳細に容量を浪費するドメイン向けに設計されています。これは、離散トークンの場合と同じようには発生しない問題です。この点については、最後に再び触れます。

自己教師あり学習手法として導入された I‑JEPA は、可視コンテキストからマスクされた領域の表現を予測することによって、意味的な画像表現を学習します。Self-Supervised Learning from Images with a Joint-Embedding Predictive Architecture (2023) を参照してください。I‑JEPA は非生成的なアプローチであり、手作業で作成されたデータ拡張を完全に回避します。私たちは I‑JEPA をゼロから構築し、次にビデオへの拡張である V‑JEPA および V‑JEPA 2 について議論し、最後に工学的なヒューリスティックを分布正則化器に置き換える最新の試みである LeJEPA を検討します。V-JEPA: Latent Video Prediction for Visual Representation Learning (2024)、および V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning (2025) を参照してください。

以下は教育的な目的で書かれています。実装では、FlashAttention、勾配チェックポインティング、混合精度、および大規模トレーニングを可能にするバッチ処理戦略は省略されています。これらは、プロダクションコードベースを支配するエンジニアリングの選択ですが、数学からは容易に分離可能です。

問題

自己教師あり表現学習は次のように問います。「ラベルなしで有用な特徴をどのように学習するか?」 meaningful structure を捉える目的関数が必要ですが、ラベルなしで実際に機能する目的関数を見つけることが、この分野の中心的な困難です。

JEPA の答えは、予測によって訓練することですが、表現空間で予測することです。しかし、これはなぜうまくいくのでしょうか?

画像の一部(コンテキスト (x))を見て、表現を学習したいとします。画像内のどこかに、見えないターゲット領域 (y) があります。エンコーダーは (y) を表現 (s_y) にマッピングします。予測器は、コンテキストのエンコーディングを受け取り、(s_y) があるべき値の推測である (\hat{s}_y) を出力します。トレーニングは距離 (D(\hat{s}_y, s_y)) を最小化します。

ここで問います。予測器はいつ成功できるでしょうか? コンテキストエンコーディング (s_x) が (s_y) が何であるかを決定するのに十分な情報を含む場合にのみです。車のボンネットを見た場合、タイヤの表現を予測するには、ボンネットのエンコーディングが「これは車だ」を捉えている必要があります。顔を見た場合、髪の表現を予測するには、エンコーディングが同一性、ポーズ、照明を捉えている必要があります。予測器は、コンテキストエンコーディングに欠けている構造を幻視することはできません。

これが強制関数です。コンテキストエンコーダーは、(y) の表現を予測可能にする (x) からの特徴を抽出することを学習する必要があります。これらはまさに意味的、構造的な特徴です。オブジェクトの同一性、空間的関係、物理的制約です。(x) のピクセルレベルのノイズは (s_y) の予測に役立たないため、エンコーダーはそれを無視することを学習します。残ったものが一般化するものです。

ターゲットエンコーダーには補完的な圧力がかかります。その出力 (s_y) はコンテキストから予測可能である必要があります。もし (s_y) がランダムな高周波テクスチャをエンコードしていたら、どんなコンテキストもそれを予測するのに役立ちません。したがって、ターゲットエンコーダーは、予測を可能にする構造、つまり予測を可能にする構造を捉える表現を、(y) だけの特異な詳細ではなく、出力することを学習します。

[画像: 自律型機械知能への道]

LeCun の位置論文では、これをエネルギーベースの定式化としてフレーム化しています。A Path Towards Autonomous Machine Intelligence (2022), OpenReview を参照してください。LeCun は JEPA を、潜在空間で計画するワールドモデルの基盤として位置づけています。(x) と (y) を表現にエンコードし、一方を他方から予測し、エネルギーをその抽象空間での予測誤差として定義します。アーキテクチャは、実装および分析可能なコンポーネントに分解されます。2つのエンコーダー、1つの予測器、1つの距離関数です。

JEPA テンプレート

JEPA は、ペアになった、意味的に関連する世界のビューから始まります。最も一般的な形式では、トリプル ((x, y, z)) を想像してください。(x) は観測したもの、(y) は予測したいもの、(z) は予測が多峰性になる未知の要因を捉えるオプションの潜在変数です。ペア ((x, y)) は、観測値の結合分布からサンプリングされます。画像事前学習では、(x) は可視パッチ、(y) は同じ画像のマスクされたパッチかもしれません。ビデオでは、(x) はクリップのプレフィックス、(y) は継続です。クロスモーダル設定では、(x) はオーディオ、(y) は対応するビデオかもしれません。唯一の構造的要件は、(x) を知ることが (y) が何であるかを制約するはずだということです。

LeCun の定式化は、多峰性を扱うためにオプションの潜在変数 (z) を追加します。複数の (y) の値が同じ (x) と一致する場合、予測器は (z) を条件としてそれらの間で選択します。これは時間的予測には重要ですが、将来は真に不確実であり、マスクされた画像モデリングほどではありません。コンテキストは通常、ノイズまでのターゲットを決定します。画像マスクモデリングでは、コンテキストは通常、ノイズまでのターゲットを決定します。

テンプレートには3つの部分があります。両方の観測値を共有表現空間にエンコードします。

$$ s_x = f_\theta(x), \quad s_y = f_{\bar\theta}(y) $$

エンコーダー (f_\theta) と (f_{\bar\theta}) は、アーキテクチャまたはパラメータ共有で異なる場合があります。(x) と (y) が異なるモダリティに属する場合、それらは異なる必要があります。同じモダリティの場合、重み共有は、帰納バイアスと柔軟性のトレードオフとなる設計上の選択です。

コンテキスト表現からターゲット表現を予測します。

$$\widehat{s}_y = g_\phi(s_x, z)$$

表現空間での予測誤差を最小化します。

$$ \mathcal{L}(\theta, \bar\theta, \phi) = D(\widehat{s}_y, s_y) $$

この記事の残りの部分では、これらの抽象化を具体化します。画像を対象とした (x) と (y) を具体的に定義し、エンコーダーと予測器のアーキテクチャを選択し、距離関数 (D) を指定し、すべての表現が定数に崩壊する自明な解を防ぐメカニズムを実装します。

予測 vs. 再構築

なぜピクセル空間ではなく表現空間で予測するのか?

意味的に同一で、同じオブジェクト、同じ意味を持つ2つの画像パッチを考えます。ただし、照明、テクスチャ、またはJPEGアーティファクトのために数百のピクセルが異なります。再構築目的関数は、それらのすべての違いを説明する必要があります。モデルは、高エントロピーノイズをモデル化するために容量を浪費します。

JEPA を使用すると、ターゲットエンコーダーは、ノイズの詳細を破棄する表現を出力することを学習できます。その表現に回帰すると、エンコーダーが保持するものを捉えるようにモデルをプッシュします。ピクセルに偶然含まれるものではなく、エンコーダーが保持するものを捉えるようにモデルをプッシュします。I‑JEPA はこれを明示しています。アーキテクチャは生成モデルに似ていますが、損失は埋め込み空間にあり、入力空間にはありません。知覚損失(LPIPS)とピクセル損失(MSE)のアナロジーです。表現空間での予測により、モデルは意味的に意味のある特徴に焦点を当てることができます。

崩壊

マッチング損失を最小化する最も簡単な方法は何でしょうか? すべてに同じベクトルを出力します。すると、損失はゼロになります。しかし、表現は役に立たなくなります。これは、すべての共同埋め込みメソッドの中心的な失敗モードであり、I‑JEPA はこれを直接対処します。それらはエンコーダー間で非対称な設計を使用します。

文献には多くのアンチコラプス戦略があります。SimCLR は対照的なネガティブを使用します。VICReg は分散-不変-共分散正則化を使用します。BYOL と SimSiam はストップグラジエントを使用します。DINO/MoCo は EMA ティーチャーを使用します。それぞれが異なるトレードオフをします。対照的なネガティブ(高価)、明示的な共分散制約(調整が難しい)、ストップグラジエント(驚くほど効果的)、または指数移動平均更新(I‑JEPA の選択)を持つティーチャー-スチューデントエンコーダー。I‑JEPA は、コンテキストエンコーダーと予測器を勾配降下法で訓練しますが、ターゲットエンコーダーはコンテキストエンコーダーの重みの指数移動平均(EMA)で更新します。これが崩壊を防ぐ理由です。

両方のエンコーダーが勾配降下法で訓練された場合に何が起こるかを考えてみましょう。損失は (D(\hat{s}_y, s_y)) です。ターゲットエンコーダーが自由に変化できる場合、予測しやすい表現を出力するように学習します。つまり、定数です。コンテキストエンコーダーがそれに続きます。両方ともすべての入力に同じベクトルを出力するように収束します。損失ゼロ、表現は役に立たない。EMA はこの共同適応を破ります。ターゲットエンコーダーは次のように更新されます。

$$\theta ext{target} \leftarrow m \theta ext{target} + (1-m) \theta ext{context}$$

ここで (m) は 1 に近い値です。これにより、ターゲットエンコーダーはコンテキストエンコーダーに遅れをとります。ターゲット表現は勾配ステップのタイムスケールで安定しているため、コンテキストエンコーダーは退行的な解を見つけるために急速に変化するターゲットを利用できません。コンテキストエンコーダーは、(ゆっくりと進化する)ターゲットエンコーダーが出力するものを実際に予測することを学習する必要があり、これにより意味のある特徴を抽出することが強制されます。

後で LeJEPA について議論しますが、これは崩壊防止をヒューリスティックではなく原理的に行おうとします。今のところ、古典的な I‑JEPA 設計に焦点を当てます。

画像への JEPA の特化

JEPA は、意味的に関連するペアのビュー (x) と (y) を必要とします。I‑JEPA では、両方とも同じ画像から取得されます。(x) はパッチの大きなコンテキストブロックであり、(y) は画像内の他の場所にあるいくつかの小さなターゲットブロックで構成されます。目標は、コンテキストブロックからターゲットブロックの表現を予測することです。I‑JEPA には 3 つの重要な設計上の選択肢があり、コードを書く前に理解しておく必要があります。

最初の選択肢は、Vision Transformer に従い、画像をパッチトークンのシーケンスとして表現することです。An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale (2020) の Dosovitskiy et al. を参照してください。ViT アーキテクチャは、画像を固定サイズのパッチに分割し、それらをシーケンスとして処理します。224×224 の画像に 16×16 のパッチを使用すると、14×14 のグリッドに配置された 196 個のトークンが得られます。

2番目の選択肢は、マスキング戦略です。論文によると、I‑JEPA を意味的な表現に導くためには、十分な大きさのターゲットブロックを予測し、十分な情報量と空間的に分散したコンテキストブロックを使用することが重要です。メソッドセクションでは、典型的なマスクサンプリング範囲を指定しています。通常、アスペクト比範囲 ((0.75, 1.5)) とスケール範囲 ((0.15, 0.2)) を持つ (M = 4) のターゲットブロックを使用します。コンテキストブロックは、スケール範囲 ((0.85, 1.0)) と単位アスペクト比でサンプリングされ、ターゲットとコンテキストの重複は、予測タスクを自明でないものにするために削除されます。

3番目の選択肢は、ターゲットのマスキングが発生する場所です。ターゲットブロックは、入力ではなく、ターゲットエンコーダーの出力のマスキングによって取得されます。ターゲットエンコーダーは画像全体を見て高レベルの表現を生成します。次に、予測する表現を選択します。論文によると、この区別は、ターゲット表現が高レベルの意味的レベルであることを保証するために重要です。これは、両方のビューの入力をマスクするよりも計算コストが高いですが、正しさのためには必要です。ViT はグローバルアテンションを使用するため、パッチの表現は画像全体のコンテキストに依存します。ターゲットエンコーダーをターゲットパッチのみで実行すると、それらの表現の意味が変わります。

これらは任意の実装の詳細ではありません。これらは I‑JEPA の帰納バイアスのすべてであり、手作業で設計されたマルチビュー拡張を構造化された予測タスクに置き換えます。

完全な Image‑JEPA アーキテクチャ

[画像: I-JEPA アーキテクチャ]

3つのネットワークを実装します。

コンテキストエンコーダー(スチューデントとも呼ばれる)は、可視コンテキストパッチのみを処理し、コンテキスト埋め込みのセットを生成する Vision Transformer です。

ターゲットエンコーダー(ティーチャーとも呼ばれる)は、画像全体を処理し、すべてのパッチの埋め込みを生成する別の Vision Transformer です。その重みは勾配で更新されません。それらは、コンテキストエンコーダーの重みの指数移動平均によって更新されます。

予測器は、コンテキスト埋め込みとターゲットパッチ位置に対応するマスクトークンのセットを受け取り、それらのターゲット位置の予測埋め込みを生成する小さな Transformer です。メソッドの説明によると、予測器はコンテキストエンコーダーの出力に、共有学習可能なベクトルと追加された位置埋め込みによってパラメータ化された各パッチを予測するためのマスクトークンを入力として受け取ります。

損失は、予測されたパッチ表現とターゲットブロックのターゲットエンコーダーのパッチ表現の間の平均二乗誤差です。これは JEPA テンプレートからの距離関数 (D) です。

$$D(\hat{s}_y, s_y) = |\hat{s}_y - s_y|^2_2$$

PyTorch 実装

実装はいくつかの部分に分かれています。上から下まで読めるはずです。全体を通して、これらの慣例を使用します。画像は ((B, C, H, W)) の形状を持ち、パッチトークンは ((B, N, D)) の形状を持ちます。ここで (N) はパッチ数、(D) は埋め込み次元です。パッチのサブセットを選択するたびに、パッチシーケンスのインデックスの 1 次元テンソルとして表現し、単純化のために絶対位置埋め込みを実装します。

インポートと小さなヘルパー
import math
import random
from dataclasses import dataclass
from typing import List, Optional, Tuple

import torch
import torch.nn as nn
import torch.nn.functional as F
パッチ埋め込み

標準的な Vision Transformer は、ストライド畳み込みを使用してパッチトークンを作成します。各パッチは (\mathbb{R}^D) のベクトルになります。

class PatchEmbed(nn.Module):
    """
    画像をパッチ埋め込みのシーケンスに変換します。

    入力:  (B, C, H, W)
    出力: (B, N, D) ここで N = (H / P) * (W / P)
    """
    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_chans: int = 3,
        embed_dim: int = 768,
    ):
        super().__init__()
        assert img_size % patch_size == 0, "img_size must be divisible by patch_size"

        self.img_size = img_size
        self.patch_size = patch_size
        self.grid_size = img_size // patch_size
        self.num_patches = self.grid_size * self.grid_size

        self.proj = nn.Conv2d(
            in_channels=in_chans,
            out_channels=embed_dim,
            kernel_size=patch_size,
            stride=patch_size,
            bias=True,
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.proj(x)                 # (B, D, G, G)
        x = x.flatten(2).transpose(1, 2) # (B, N, D)
        return x

唯一の自明でない行はリシェイプです。畳み込みの後、((B, D, G, G)) が得られます。次元 2 と 3 をフラット化すると ((B, D, N)) が得られます。転置すると、通常のトークン形式 ((B, N, D)) になります。

Transformer ブロック

I‑JEPA は、エンコーダーと予測器に Vision Transformer を使用します。標準的なプリノルム Transformer ブロックを実装します。これは、ほとんどの実用的な ViT が使用するものに近いものです。プリノルム(アテンション/MLP の前に LayerNorm)は、ポストノルム(LayerNorm の後に)よりもディープ Transformer のトレーニングにおいて安定しています。On Layer Normalization in the Transformer Architecture (2020) の Xiong et al. を参照してください。

まず、マルチヘッド自己アテンションです。

class MultiHeadSelfAttention(nn.Module):
    def __init__(
        self,
        dim: int,
        num_heads: int,
        attn_drop: float = 0.0,
        proj_drop: float = 0.0,
    ):
        super().__init__()
        assert dim % num_heads == 0, "dim must be divisible by num_heads"

        self.dim = dim
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        self.scale = self.head_dim ** -0.5

        self.qkv = nn.Linear(dim, 3 * dim, bias=True)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim, bias=True)
        self.proj_drop = nn.Dropout(proj_drop)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        x: (B, T, D)
        """
        B, T, D = x.shape

        qkv = self.qkv(x)                              # (B, T, 3D)
        qkv = qkv.reshape(B, T, 3, self.num_heads, self.head_dim)
        qkv = qkv.permute(2, 0, 3, 1, 4)               # (3, B, H, T, Hd)

        q, k, v = qkv[0], qkv[1], qkv[2]               # (B, H, T, Hd) each

        attn = (q @ k.transpose(-2, -1)) * self.scale  # (B, H, T, T)
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        out = attn @ v                                 # (B, H, T, Hd)
        out = out.transpose(1, 2).reshape(B, T, D)      # (B, T, D)

        out = self.proj(out)
        out = self.proj_drop(out)
        return out

次に MLP です。

class MLP(nn.Module):
    def __init__(self, dim: int, hidden_dim: int, drop: float = 0.0):
        super().__init__()
        self.fc1 = nn.Linear(dim, hidden_dim)
        self.act = nn.GELU()
        self.fc2 = nn.Linear(hidden_dim, dim)
        self.drop = nn.Dropout(drop)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.fc1(x)
        x = self.act(x)
        x = self.drop(x)
        x = self.fc2(x)
        x = self.drop(x)
        return x

次に Transformer ブロックです。

class TransformerBlock(nn.Module):
    def __init__(
        self,
        dim: int,
        num_heads: int,
        mlp_ratio: float = 4.0,
        attn_drop: float = 0.0,
        drop: float = 0.0,
    ):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attn = MultiHeadSelfAttention(
            dim=dim,
            num_heads=num_heads,
            attn_drop=attn_drop,
            proj_drop=drop,
        )
        self.norm2 = nn.LayerNorm(dim)
        self.mlp = MLP(dim=dim, hidden_dim=int(dim * mlp_ratio), drop=drop)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = x + self.attn(self.norm1(x))
        x = x + self.mlp(self.norm2(x))
        return x

これで、これらのブロックを積み重ねて ViT エンコーダーを構築できます。

パッチのサブセットを処理できる ViT エンコーダー

I‑JEPA の効率性は、コンテキストエンコーダーが可視コンテキストパッチのみを処理できることに由来します。それをモデル化するために、オプションでインデックスによってパッチを選択できるエンコーダーを作成します。

class ViTEncoder(nn.Module):
    """
    最小限の ViT スタイルのパッチエンコーダー。

    このバージョンは CLS トークンを使用しません。I-JEPA のメソッドセクションでは
    パッチレベルの表現について説明しており、事前学習中に CLS を必要としません。
    """
    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_chans: int = 3,
        embed_dim: int = 768,
        depth: int = 12,
        num_heads: int = 12,
        mlp_ratio: float = 4.0,
        drop: float = 0.0,
        attn_drop: float = 0.0,
    ):
        super().__init__()
        self.patch_embed = PatchEmbed(img_size, patch_size, in_chans, embed_dim)
        self.num_patches = self.patch_embed.num_patches

        self.pos_embed = nn.Parameter(torch.zeros(1, self.num_patches, embed_dim))
        nn.init.trunc_normal_(self.pos_embed, std=0.02)

        self.blocks = nn.ModuleList([
            TransformerBlock(
                dim=embed_dim,
                num_heads=num_heads,
                mlp_ratio=mlp_ratio,
                attn_drop=attn_drop,
                drop=drop,
            )
            for _ in range(depth)
        ])
        self.norm = nn.LayerNorm(embed_dim)

    def forward(self, images: torch.Tensor, patch_indices: Optional[torch.Tensor] = None) -> torch.Tensor:
        """
        images: (B, C, H, W)
        patch_indices: None またはパッチシーケンスへのインデックスの 1 次元テンソル

        返り値: (B, T, D)
        """
        x = self.patch_embed(images)  # (B, N, D)

        if patch_indices is None:
            x = x + self.pos_embed
        else:
            if patch_indices.dim() != 1:
                raise ValueError("patch_indices must be a 1D tensor in this minimal implementation")
            x = x[:, patch_indices, :] + self.pos_embed[:, patch_indices, :]

        for blk in self.blocks:
            x = blk(x)

        x = self.norm(x)
        return x

意図的な制限があります。patch_indices はバッチ全体で共有されます。実際のトレーニングでは、各画像に異なるマスクがあるため、パディングとアテンションマスクを使用してベクトル化するか、サンプルごとにループします。教育目的で、ループします。

ブロックマスクサンプリング

次に、I‑JEPA のコアビュー構築を実装します。複数のターゲットブロックと1つのコンテキストブロックをサンプリングし、重複を削除します。論文ではこの手順を説明し、典型的な範囲を提供しています。アスペクト比 ((0.75, 1.5)) およびスケール ((0.15, 0.2)) の範囲を持つ 4 つのターゲットブロック、スケール ((0.85, 1.0)) および単位アスペクト比のコンテキストブロック、そして重複を削除します。

パッチインデックスを返すマスクジェネレーターを実装します。

def _sample_block_on_grid(
    grid_size: int,
    scale_range: Tuple[float, float],
    aspect_ratio_range: Tuple[float, float],
) -> Tuple[int, int, int, int]:
    """
    grid_size x grid_size パッチグリッド上に長方形をサンプリングします。

    パッチ座標で (top, left, height, width) を返します。
    """
    G = grid_size
    N = G * G

    scale = random.uniform(scale_range[0], scale_range[1])
    aspect = random.uniform(aspect_ratio_range[0], aspect_ratio_range[1])

    area = scale * N
    w = int(round(math.sqrt(area * aspect)))
    h = int(round(math.sqrt(area / aspect)))

    w = max(1, min(G, w))
    h = max(1, min(G, h))

    top = random.randint(0, G - h)
    left = random.randint(0, G - w)
    return top, left, h, w


def _rect_to_indices(grid_size: int, top: int, left: int, h: int, w: int) -> torch.Tensor:
    """
    長方形を行優先順でフラットなパッチインデックスに変換します。
    """
    rows = torch.arange(top, top + h)
    cols = torch.arange(left, left + w)
    rr, cc = torch.meshgrid(rows, cols, indexing="ij")
    idx = rr * grid_size + cc
    return idx.flatten()

次にジェネレーターです。

@dataclass
class IJEPAMasks:
    context_idx: torch.Tensor
    target_blocks: List[torch.Tensor]


class IJEPAMaskGenerator:
    def __init__(
        self,
        grid_size: int,
        num_targets: int = 4,
        target_scale: Tuple[float, float] = (0.15, 0.20),
        target_aspect: Tuple[float, float] = (0.75, 1.50),
        context_scale: Tuple[float, float] = (0.85, 1.00),
        context_aspect: Tuple[float, float] = (1.00, 1.00),
    ):
        self.grid_size = grid_size
        self.num_targets = num_targets
        self.target_scale = target_scale
        self.target_aspect = target_aspect
        self.context_scale = context_scale
        self.context_aspect = context_aspect

    def __call__(self) -> IJEPAMasks:
        G = self.grid_size

        target_blocks: List[torch.Tensor] = []
        target_union = torch.zeros(G * G, dtype=torch.bool)

        for _ in range(self.num_targets):
            top, left, h, w = _sample_block_on_grid(G, self.target_scale, self.target_aspect)
            idx = _rect_to_indices(G, top, left, h, w)
            target_blocks.append(idx)
            target_union[idx] = True

        c_top, c_left, c_h, c_w = _sample_block_on_grid(G, self.context_scale, self.context_aspect)
        context_idx = _rect_to_indices(G, c_top, c_left, c_h, c_w)

        keep = ~target_union[context_idx]
        context_idx = context_idx[keep]

        return IJEPAMasks(context_idx=context_idx, target_blocks=target_blocks)

このジェネレーターは、ターゲットとコンテキストのサンプリング方法、および重複の削除方法に関する論文の説明を具体化しています。JEPA の観点からは、これは (x) の定義と、(y) のどの部分を予測しようとしているかの定義です。

予測器とマスクトークン

I‑JEPA では、予測器はコンテキスト埋め込みに加えて、予測したいターゲット位置を示すマスクトークンを受け取ります。論文では、マスクトークンは位置埋め込みが追加された共有学習可能なベクトルとして説明されています。

最小限の設計は、コンテキストトークンに続くマスクトークン(各ターゲットパッチ位置につき 1 つ)、および各マスクトークンにそのパッチ位置の位置埋め込みを追加したものを連結したシーケンスを処理する小さな Transformer として予測器を実装することです。出力シーケンスは同じ長さになり、ターゲット位置に対応する最後のトークンを読み出します。

class IJEPA_Predictor(nn.Module):
    def __init__(
        self,
        embed_dim: int,
        depth: int = 6,
        num_heads: int = 12,
        mlp_ratio: float = 4.0,
        drop: float = 0.0,
        attn_drop: float = 0.0,
    ):
        super().__init__()
        self.mask_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        nn.init.trunc_normal_(self.mask_token, std=0.02)

        self.blocks = nn.ModuleList([
            TransformerBlock(
                dim=embed_dim,
                num_heads=num_heads,
                mlp_ratio=mlp_ratio,
                attn_drop=attn_drop,
                drop=drop,
            )
            for _ in range(depth)
        ])
        self.norm = nn.LayerNorm(embed_dim)

    def forward(self, context_tokens: torch.Tensor, target_pos_embed: torch.Tensor) -> torch.Tensor:
        """
        context_tokens: (B, Nc, D)
        target_pos_embed: (B, Nt, D)

        返り値: (B, Nt, D)
        """
        B, Nc, D = context_tokens.shape
        _, Nt, _ = target_pos_embed.shape

        mask_tokens = self.mask_token.expand(B, Nt, D) + target_pos_embed
        x = torch.cat([context_tokens, mask_tokens], dim=1)

        for blk in self.blocks:
            x = blk(x)

        x = self.norm(x)
        pred_target = x[:, Nc:, :]
        return pred_target

これが機能する理由は 2 つあります。第一に、自己アテンションにより、各マスクトークンはすべてのコンテキストトークンにアテンションを向けられるため、モデルが見たものから予測する必要があるものへと情報が流れます。第二に、マスクトークンに位置埋め込みを追加することで、予測器に未知の領域が画像のどこにあるかが伝わります。これがなければ、すべてのターゲット位置は区別がつかなくなります。

モデル全体の配線

これで JEPA テンプレートを正確に実装します。ターゲットエンコーダーはすべてのパッチに対して (s_y) を生成します。マスクジェネレーターはコンテキストサブセットといくつかのターゲットサブセットを選択します。コンテキストエンコーダーはコンテキストサブセットのみを (s_x) にエンコードします。各ターゲットブロックについて、予測器はそれらの位置で (\hat{s}_y) を出力します。損失は、予測された埋め込みとターゲットブロックのターゲット埋め込みの間の平均二乗誤差です。

ターゲットエンコーダーは勾配ではなく、指数移動平均によって更新されます。

$$\theta ext{target} \leftarrow m \theta ext{target} + (1-m) \theta ext{context}$$

I‑JEPA はこれを明示的に述べ、EMA ターゲットエンコーダーが設定において不可欠であることを見出したと述べています。ここでは (m) は通常 (0.996) から (1.0) です。これにより、安定したターゲットを提供する、ゆっくりと進化するティーチャーが作成されます。

class IJEPAModel(nn.Module):
    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_chans: int = 3,
        embed_dim: int = 768,
        enc_depth: int = 12,
        enc_heads: int = 12,
        pred_depth: int = 6,
        pred_heads: int = 12,
        mlp_ratio: float = 4.0,
    ):
        super().__init__()

        self.context_encoder = ViTEncoder(
            img_size=img_size,
            patch_size=patch_size,
            in_chans=in_chans,
            embed_dim=embed_dim,
            depth=enc_depth,
            num_heads=enc_heads,
            mlp_ratio=mlp_ratio,
        )

        self.target_encoder = ViTEncoder(
            img_size=img_size,
            patch_size=patch_size,
            in_chans=in_chans,
            embed_dim=embed_dim,
            depth=enc_depth,
            num_heads=enc_heads,
            mlp_ratio=mlp_ratio,
        )

        self._init_teacher_from_student()

        self.predictor = IJEPA_Predictor(
            embed_dim=embed_dim,
            depth=pred_depth,
            num_heads=pred_heads,
            mlp_ratio=mlp_ratio,
        )

        G = self.context_encoder.patch_embed.grid_size
        self.mask_generator = IJEPAMaskGenerator(grid_size=G)

    @torch.no_grad()
    def _init_teacher_from_student(self) -> None:
        for p_t, p_s in zip(self.target_encoder.parameters(), self.context_encoder.parameters()):
            p_t.data.copy_(p_s.data)
        for p in self.target_encoder.parameters():
            p.requires_grad_(False)

    @torch.no_grad()
    def ema_update_teacher(self, momentum: float) -> None:
        """
        ティーチャー更新: theta_bar <- m * theta_bar + (1 - m) * theta
        """
        for p_t, p_s in zip(self.target_encoder.parameters(), self.context_encoder.parameters()):
            p_t.data.mul_(momentum).add_(p_s.data, alpha=(1.0 - momentum))

    def forward(self, images: torch.Tensor) -> torch.Tensor:
        """
        バッチ上で I-JEPA 損失を計算します。

        このバージョンは、マスクが画像ごとに異なるため、明確にするためにサンプルごとにループします。
        """
        B = images.shape[0]
        device = images.device

        with torch.no_grad():
            target_tokens_all = self.target_encoder(images, patch_indices=None)  # (B, N, D)

        pos_embed = self.context_encoder.pos_embed  # (1, N, D)

        total_loss = 0.0
        total_blocks = 0

        for b in range(B):
            masks = self.mask_generator()
            context_idx = masks.context_idx.to(device)

            context_tokens = self.context_encoder(images[b:b+1], patch_indices=context_idx)  # (1, Nc, D)

            for block_idx in masks.target_blocks:
                block_idx = block_idx.to(device)

                target_block = target_tokens_all[b:b+1, block_idx, :]  # (1, Nt, D)
                target_pos = pos_embed[:, block_idx, :]                # (1, Nt, D)

                pred_block = self.predictor(context_tokens, target_pos) # (1, Nt, D)

                loss = F.mse_loss(pred_block, target_block, reduction="mean")
                total_loss += loss
                total_blocks += 1

        return total_loss / max(1, total_blocks)

これは I‑JEPA のメソッド説明の最も明確な具体化です。予測器はターゲットブロックごとに 1 回適用され、ターゲット位置を条件付けられ、損失はそれらの予測されたパッチ表現の平均になります。ターゲットブロックのサイズが可変であるため、ブロックごとの MSE の平均は、小さいブロックのパッチを大きいブロックのパッチよりも重く重み付けします。エネルギーをパッチあたりの平均誤差として厳密に定義するには、二乗誤差を合計し、総パッチ数で割る必要があります。実際には、確率的サンプリングがこれを平均化します。

アーキテクチャは完成しました。残りはトレーニングです。

トレーニングループと EMA モーメンタムスケジュール

I‑JEPA は EMA ティーチャー更新を使用します。実際には、1 に近いモーメンタム (m) を選択し、トレーニング中に 1 に向かって増加させることがよくあります。異なる論文では線形またはコサインスケジュールを使用しています。本質的な要件は、ティーチャーが生徒よりもゆっくり進化することです。以下にスケジュールヘルパーと最小トレーニングループを示します。

def cosine_schedule(start: float, end: float, step: int, total_steps: int) -> float:
    if total_steps <= 1:
        return end
    t = step / (total_steps - 1)
    return end - (end - start) * (0.5 * (1 + math.cos(math.pi * t)))


def momentum_schedule(step: int, total_steps: int, start_m: float = 0.996, end_m: float = 1.0) -> float:
    return cosine_schedule(start_m, end_m, step, total_steps)


def train_ijepa(
    model: IJEPAModel,
    dataloader,
    epochs: int,
    lr: float = 1e-4,
    weight_decay: float = 0.05,
    device: str = "cuda",
) -> None:
    model.to(device)
    model.train()

    params = list(model.context_encoder.parameters()) + list(model.predictor.parameters())
    opt = torch.optim.AdamW(params, lr=lr, weight_decay=weight_decay)

    total_steps = epochs * len(dataloader)
    global_step = 0

    for epoch in range(epochs):
        for batch in dataloader:
            images = batch[0].to(device)

            loss = model(images)

            opt.zero_grad(set_to_none=True)
            loss.backward()
            opt.step()

            m = momentum_schedule(global_step, total_steps)
            model.ema_update_teacher(momentum=m)

            if global_step % 50 == 0:
                print(f"step={global_step} epoch={epoch} loss={loss.item():.6f} momentum={m:.6f}")

            global_step += 1

プロダクションコードには、混合精度、勾配クリッピング、分散トレーニング、および慎重なバッチ処理(たとえば、各バッチ内で均一なマスクサイズを使用すると、サンプルごとのループではなくフォワードパスをベクトル化できます)が追加されます。これらは、メソッドとは無関係なエンジニアリングの選択です。

EMA 更新とモーメンタムスケジュールは無関係ではありません。前述のように、EMA はターゲットエンコーダーをコンテキストエンコーダーに遅れさせることで崩壊を防ぐものです。スケジュール((m) を 1 に向かって増加させる)は、トレーニングが進むにつれてティーチャーをますます安定させます。これらは、トレーニング速度だけでなく、メソッドが機能するかどうかに影響を与える設計上の選択です。

事前学習済み I‑JEPA エンコーダーの使用方法

事前学習後、通常は画像ごとに 1 つの埋め込みが必要になります。一般的なアプローチは、ターゲットエンコーダーを使用し、そのパッチ埋め込みを平均プールすることです。これにより、線形分類器、最近傍評価、または下流のファインチューニングパイプラインにフィードできるグローバル表現が得られます。

@torch.no_grad()
def encode_global_target(model: IJEPAModel, images: torch.Tensor) -> torch.Tensor:
    model.eval()
    tokens = model.target_encoder(images, patch_indices=None)  # (B, N, D)
    return tokens.mean(dim=1)                                  # (B, D)

これは唯一の選択肢ではありません。ファインチューニング中に CLS トークンを使用したり、アテンションプーリングを使用したり、パッチ埋め込みを密な予測タスクのために保持したりする場合があります。JEPA 事前学習は、下流の適応を容易にするようにパッチ表現をすでに整理しています。

健全性チェック

JEPA の実装は静かに失敗する可能性があります。教師あり学習では、精度が関心のあるものを直接測定する場合、または言語モデリングでは、保持されたテキストのパープレキシティが下流の機能と合理的に相関する場合とは異なり、JEPA のトレーニング損失は表現の品質と等価ではありません。損失は表現空間での予測誤差を測定しますが、重要なのはそれらの表現が下流タスクに役立つかどうかです。JEPA では、自己教師あり目的と下流の有用性の間の関係は、表現空間自体を介して仲介され、その仲介は単調であること、または損失から予測可能であることは保証されません。

したがって、損失の減少を見て JEPA をデバッグすることはできません。補助診断が必要です。実装できる 3 つのチェックを短い診断関数として示します。まず、ティーチャーが勾配を受け取っていないことを確認します。

def assert_teacher_frozen(model: IJEPAModel) -> None:
    for p in model.target_encoder.parameters():
        assert p.requires_grad is False

次に、バッチ全体での表現の分散を監視します。崩壊は、ほぼゼロの分散として現れることがよくあります。健全な表現空間は、埋め込み次元にほぼ比例した分散を持つべきです。分散が (0.1) 程度を下回ると、崩壊が発生している可能性が高いです。この数量を明示的に正則化するために VICReg を使用することもできます。

@torch.no_grad()
def embedding_variance(tokens: torch.Tensor) -> float:
    return tokens.std(dim=0).mean().item()

3 番目に、コンテキスト領域とターゲット領域がパッチインデックスで実際に重複していないことを確認します。重複が存在する場合、タスクが簡単すぎ、学習された表現が歪む可能性があります。論文では、自明でないタスクのために明示的に重複を削除しています。この種の計装は論文に現れることはめったにありませんが、失敗した実行を迅速に診断するのに役立つことがよくあります。

I‑JEPA を JEPA たるものにしているもの

コードができたので、概念構造を再確認する価値があります。共同埋め込み部分は、スチューデントとティーチャーの両方が同じオブジェクト(画像)の埋め込みを生成し、学習信号は埋め込み空間での比較であるということです。予測部分は、スチューデントが画像全体の 2 番目のビューを一致させているわけではないということです。明示的な予測ネットワークと位置情報に条件付けられたコンテキスト領域の埋め込みからマスクされたターゲット領域の埋め込みを予測しています。非生成部分は、ピクセルデコーダーがないことです。モデルはトークンまたはピクセルを再構築するように求められていません。損失は埋め込みにあります。

V‑JEPA: JEPA をビデオに拡張

ビデオは、表現空間での予測の必要性を増幅します。フレームは冗長であり、ピクセルはノイズが多く、重要なダイナミクスは抽象化にあります。

V‑JEPA の前に、MC‑JEPA(Motion-Content JEPA)が 2023 年 7 月に公開されました。MC-JEPA: A Joint-Embedding Predictive Architecture for Self-Supervised Learning of Motion and Content Features (2023) を参照してください。MC‑JEPA は重要な洞察を導入しました。ビデオには、動き(物事の変化方法)とコンテンツ(物事が何であるか)という 2 つの絡み合った信号が含まれており、JEPA は共有エンコーダーを使用してそれらを分離することを学習できます。これは重要なステップであり、JEPA スタイルの予測が時間的データの追加の複雑性に対処できることを示しました。

V‑JEPA は、この基盤の上に、同じ原則(ピクセルではなく表現を予測する)を完全な時空間ドメインに拡張しています。V-JEPA: Latent Video Prediction for Visual Representation Learning (2024) を参照してください。この論文は、潜在空間での予測がビデオのピクセル空間予測目的関数を大幅に上回ることを示しています。

[画像: V-JEPA アーキテクチャ]

重要な洞察は、ビデオは画像よりも再構築するのがさらに無駄であるということです。連続するフレームは非常に冗長であり、ピクセルレベルの詳細の多くは無関係なノイズであり、ピクセルレベルでの時間的ダイナミクスをモデル化するには膨大な容量が必要です。V‑JEPA は、ビデオの時空間領域をマスクし、可視コンテキストからその表現を予測することで、これらすべてを回避します。

アーキテクチャ的には、V‑JEPA は、ビデオを時空間パッチのシーケンスとして処理する Vision Transformer バックボーンを使用します。ビデオは、パッチの 3D グリッド(空間 × 空間 × 時間)に分割され、各パッチが埋め込まれ、エンコーダーはこのシーケンス上で動作します。マスキング戦略はそれに応じて適応されます。I‑JEPA のように 2D ブロックをマスクするのではなく、V‑JEPA は 3D 時空間ブロックをマスクします。Earlier video methods like VideoMAE used tube masking, where the same spatial region is masked across all frames. V-JEPA moved away from this: random 3D blocks with limited temporal extent force the model to learn actual dynamics rather than relying on the tube assumption. これにより、モデルは時間的整合性と動きについて推論することが強制されます。

同じ EMA ティーチャーフレームワークが適用されます。コンテキストエンコーダーと予測器は勾配降下法で訓練され、ターゲットエンコーダーは指数移動平均更新を介して安定した回帰ターゲットを提供します。損失は、表現空間での予測誤差のままです。

V‑JEPA の結果は、このアプローチが時間的拡張、オプティカルフロー計算、またはピクセルレベルの再構築を必要とせずに強力なビデオ表現を学習することを示しています。表現は、アクション認識などの下流のビデオ理解タスクにうまく転送されます。

V‑JEPA 2: 表現学習から計画へ

V‑JEPA 2 は、同じアーキテクチャが表現学習だけでなく、予測と計画もサポートできることを示し、JEPA フレームワークをさらに進めます。V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning (2025) を参照してください。この研究は、単一の事前学習済みモデルが複数の目的を果たすことができることを示しています。分類のための凍結特徴、予測のためのファインチューニングされた予測、および組み込みエージェントのための潜在計画です。

[画像: V-JEPA 2 アーキテクチャとアクション条件付き計画のための V-JEPA 2-AC]

概念的な飛躍は重要です。V‑JEPA 2 は、同じ JEPA 目的(図の左側)を使用して大規模なビデオデータコーパスで訓練されますが、結果のモデルはその後 3 つの異なるモードで使用できます。

理解モードでは、事前学習済みエンコーダーは、元の V‑JEPA と同様に、ビデオ分類およびアクション認識タスクに転送される特徴を生成します。モデルはビデオを意味のある表現に整理することを学習しました。

予測モードでは、モデルは過去の観測値に条件付けられた将来の潜在状態を生成します。ビデオプレフィックスが与えられると、予測器は表現空間で次に何が起こるかを出力します。したがって、ピクセルを幻視しているわけではありません。むしろ、世界の抽象的な状態を予測しています。

計画モードは、表現空間での予測が最大の配当を支払う場所であり、これにはアクション条件付けが必要です。図の右側は V‑JEPA 2-AC を示しています。事前学習済みエンコーダーは凍結され、予測器はロボットアクションとポーズを入力として受け取るようにファインチューニングされます(JEPA テンプレートの潜在変数 (z))。現在の視覚状態と候補アクションが与えられると、予測器はそのアクション後に世界がどのようになるかの表現を出力します。これは潜在空間での学習されたダイナミクスモデルです。

このモデルを備えたエージェントは、検索によって計画できます。目標状態に到達するために、候補アクションシーケンスを検討し、予測器を繰り返し適用して各軌道をロールアウトし、どの軌道が目標表現に最も近いかを評価します。表現が冗長な詳細を圧縮しているため、検索は正確に実行可能です。仮説上の未来のためにテクスチャ、照明、またはカメラノイズを幻視する必要はありません。V‑JEPA 2 は、同じ中心的なアイデア、つまり再構築ではなく表現を予測することが、マスクされた画像パッチからリアルタイムの理解、複数ステップの予測、および目標指向の計画に拡張されることを示しています。自己教師あり事前学習目的として始まったものは、行動する前に想像できるシステムの基盤になる可能性があります!

LeJEPA: ヒューリスティックのない JEPA

[画像: LeJEPA: Provable and Scalable Self-Supervised Learning Without the Heuristics]

LeJEPA は、まさに私たちが実装したような設計に対する批判によって動機付けられているため、注意深い説明に値します。LeJEPA は、多くの一般的なヒューリスティックなしで JEPA トレーニングを安定させることを目的とした、軽量でスケーラブルで理論的に根拠のあるトレーニング目的として提示されています。抽象化では、「ストップグラジエントなし、ティーチャー-スチューデントなし、ハイパーパラメータスケジューラーなし」と明示的に宣伝されており、線形時間とメモリの複雑さ、および 1 つのトレードオフハイパーパラメータを主張しています。

LeJEPA の中心的なアイデアは、「崩壊の回避」を分布マッチング問題として扱うことです。

論文は、下流の予測リスクを最小化するために、JEPA 埋め込みは等方性ガウス分布に従うべきであると主張しており、埋め込み分布をそのターゲットに押し付ける方法として Sketched Isotropic Gaussian Regularization(SIGReg と略される)を導入しています。SIGReg は、完全な共分散行列を計算することなく、ランダムな投影と統計的テストを使用して分布プロパティを強制します。これにより、バッチサイズと埋め込み次元に対して線形にスケーリングされます。

それが何を意味するかを理解するために、次の観点から始めます。崩壊した表現は、スプレッドが低いため退化的です。すべての埋め込みがほぼ同一である場合、それらの分布は非常に集中しています。対照的に、等方性ガウスは、対称的な方法で最大限にスプレッドしています。理想化された意味では、分散はすべての方向に等しく、次元は相関していません。LeJEPA は、等方性ガウス分布を強制することが、理論的にも下流リスクにとって最適であり、実践的にも崩壊を防ぐのに効果的であると主張しています。さて、高次元でその分布を強制する方法は?

LeJEPA の SIGReg メカニズムは次のように機能します。埋め込みのバッチ ({s_i}) を (\mathbb{R}^D) に取ります。ランダムな方向 (w \in \mathbb{R}^D) をサンプリングします。各埋め込みをその方向に投影してスカラー ({w^\top s_i}) を取得します。埋め込みが真に等方性ガウスであれば、これらの投影されたスカラーは単変量ガウスになります。したがって、経験分布がガウスからどれだけ逸脱しているかを測定する統計的テスト(論文では特性関数マッチングを使用)を計算します。ランダムな方向 (w) を多数サンプリングして平均します。これにより、非ガウス性を罰する損失が得られます。

数学的根拠は Cramér-Wold 定理です。(\mathbb{R}^D) の分布は、その一次元投影によって一意に決定されます。Cramér-Wold 定理は、(\mathbb{R}^d) の確率分布が一意に一次元投影によって決定されると述べています。これは、スライスされた Wasserstein 距離および関連する方法論の理論的基盤です。 ランダムな投影をサンプリングすることで、完全な (D \times D) 共分散行列を計算するのではなく、次元とバッチサイズに対して線形にスケーリングされます。

実装の観点から、LeJEPA 目的関数は次のように考えることができます。

$$ \mathcal{L} ext{LeJEPA} = \mathcal{L} ext{predict} + \lambda \mathcal{L} ext{SIGReg} $$

ここで (\mathcal{L} ext{predict}) は、予測された埋め込みを関連ビューのターゲット埋め込みに一致させる JEPA 予測損失であり、(\mathcal{L} ext{SIGReg}) は、投影ベースのテストを介して埋め込み分布が等方性ガウスから逸脱することを罰します。論文では、この組み合わせを潜在ユークリッド JEPA、略して LeJEPA と呼んでいます。

I‑JEPA との重要な対比はアーキテクチャにあります。I‑JEPA では、安定性は、特定の非対称トレーニング手順、EMA ティーチャー、およびマスク戦略に由来します。LeJEPA では、埋め込み分布が適切に正則化されていれば、これらのエンジニアリングヒューリスティックの多くを必要とせず、トレーニングはアーキテクチャ、ドメイン、およびハイパーパラメータ全体で安定するという主張です。

JEPA のアイデアを再考

この時点で、JEPA に関する複数の視点があります。最初のものは、LeCun の論文の一般的なテンプレートです。2 つの関連変数をエンコードし、一方の表現を他方から予測し、エネルギーを表現空間での予測誤差として定義し、オプションで潜在変数について最小化します。

2 番目は I‑JEPA です。ブロックマスキング、コンテキストエンコーダー、EMA で更新されるターゲットエンコーダー、およびターゲットパッチ埋め込みに回帰する予測器を使用する具体的なビジョンインスタンシエーションであり、損失は埋め込み空間で適用されます。

3 番目は V‑JEPA と V‑JEPA 2 です。ビデオへの拡張であり、フレームワークが時空間データにスケーリングし、表現学習だけでなく、予測と計画もサポートできることを示しています。

4 番目は LeJEPA です。予測コアを維持しますが、SIGReg を介して埋め込み分布を等方性ガウスに明示的に正則化することにより、多くの安定化ヒューリスティックを排除しようとする、理論主導の目的関数です。

JEPA は画像やビデオに限定されません。同じパターンが、ピクセル再構築が意味をなさない多くのドメインに適用されています。JEPA テンプレートは、ドメイン固有のバリアントの小さな動物園を生み出しました。A partial list: A-JEPA for audio and speech, Graph-JEPA for graph-structured data using hyperbolic embeddings, Point-JEPA for 3D point clouds, Signal-JEPA for EEG signals, GeneJEPA for single-cell transcriptomics, ST-JEMA for fMRI functional connectivity, and various time-series JEPAs for sensor data and forecasting. この広がりは、JEPA が任意のドメインでの自己教師あり学習のための一般的なパターンであることを示しています。構造化データにコンテキストとターゲットの自然な概念がある場合はいつでも、テンプレートをインスタンシエートできます。

JEPA をこのように見ると、多くの設計上の質問はエンジニアリングの問題になります。あなたのドメインにおけるコンテキストとターゲットの概念は何ですか? どの表現空間が、あなたが気にかけているものを保持し、あなたが気にかけないものを破棄しますか? どのような予測器アーキテクチャが、ショートカット学習なしで予測問題を解決するのに十分な表現力を持っていますか? どのようなアンチコラプス機構が適切ですか? EMA ティーチャー、明示的な共分散正則化、または SIGReg のような分布マッチング正則化器ですか?

JEPA、エネルギーベースモデル、そしてワールドモデルへの道

この記事の実装は自己完結型ですが、JEPA は単なる自己教師あり学習トリックではありません。LeCun のフレーミングでは、それは自律的知能のためのより大きなアーキテクチャのコンポーネントであり、そのコンテキストを理解することは、設計上の選択に光を当てます。

エネルギーベースモデルとしての JEPA

LeCun の位置論文は、JEPA をエネルギーベースモデルとして明示的に位置づけています。Energy-based models define a scalar energy function (E(x, y)) over configurations. Low energy means compatibility, and high energy means incompatibility. Learning shapes the energy landscape so that observed data lies in low-energy regions. エネルギーは、表現空間での予測誤差です。

$$ E(x, y) = D\bigl(g_\phi(f_\theta(x)), f_{\bar\theta}(y)\bigr) $$

コンテキスト (x) とターゲット (y) が意味的に関連している場合(同じシーンの 2 つのビュー、連続するフレーム、コンテキストとマスクされた領域)、エネルギーは低くなるはずです。対照的な方法とは異なり、JEPA は、関連性のない ((x, y)) を高いエネルギーに押し出すために、負のペアで明示的に訓練しません。代わりに、アンチコラプス機構(EMA、分布正則化器)は、自明な解を防ぎながら、真に関連するペアに対してのみエネルギーを低くすることを可能にします。

このフレーミングは重要です。なぜなら、それは JEPA を豊富な理論的伝統に結びつけるからです。エネルギーベースモデルは正規化された確率分布を必要としません。それらは、多くの生成アプローチを悩ませる、不可能な分割関数を回避します。それらは尤度ではなく、互換性を自然に表現します。そして、それらは推論手順((x) が与えられたエネルギーを最小化する (y) を見つける)を許容し、それは反復的で柔軟になります。ワールドモデルにとって、これはまさに計画に必要なものです。目標と互換性のある将来の状態を検索します。

このレンズを通して見ると、アンチコラプス問題は、エネルギー表面が退化的にならないようにする問題です。エンコーダーがすべてを同じ点にマッピングすることを学習した場合、すべてのペアに対して (E(x, y) = 0) となり、モデルは何も学習しませんでした。私たちが議論したさまざまなメカニズム(EMA ティーチャー、ストップグラジエント、分布正則化器)はすべて、エネルギー表面が情報的であり続けるように形成する方法です。

潜在変数と多峰性予測

完全な JEPA 定式化には、オプションの潜在変数 (z) が含まれます。

$$ \widehat{s}_y = g_\phi(s_x, z), \quad E(x, y, z) = D(\widehat{s}_y, s_y) $$

(z) について最小化することによる全体的なエネルギー:

$$ E(x, y) = \min_z E(x, y, z) $$

これは、JEPA が将来の不確実性を処理するメカニズムです。ビデオで次に何が起こるかを予測することを考えてみましょう。交差点の車は左折または右折する可能性があります。(z) なしでは、予測器は単一の表現 (\hat{s}_y) を出力する必要があります。車がどちらの方向にも行ける場合、単一の予測は一方の結果に対して高い損失を発生させます。予測器は、両方の未来を一致させる平均のようなものを出力するように、ヘッジを余儀なくされます。

(z) を使用すると、予測器は (z) の異なる値に対して異なる予測を出力できます。1 つの (z) は左折に対応し、別の (z) は右折に対応します。テスト時には、(z) について検索して、実際の成果と一致する値を見つけることによってエネルギーを評価します。トレーニング時には、勾配を計算する前に同様に (z) について最小化します。予測器は (z) によってパラメータ化された予測のファミリーを学習し、可能な未来の空間をカバーします。これは条件付き VAE に関連していますが、主な違いは JEPA が表現空間で動作することです。潜在変数 (z) は、発生する未来の抽象的な不確実性を捉えます。ピクセルレベルのバリエーションではありません。

私たちが議論した I‑JEPA および V‑JEPA の実装では、この潜在変数は使用されていません。それらは決定論的な予測を行います。これは、コンテキストがターゲットを強く制約する単一の画像またはビデオ内のマスクされた予測には機能します。しかし、不確実性が存在する長期間の予測では、潜在変数が不可欠になります。V‑JEPA 2-AC はロボットアクションを (z) として使用します。異なるアクションは異なる予測された未来につながり、これは計画に必要な構造です。

ワールドモデルと計画

LeCun のより広範なビジョンは、JEPA をワールドモデルの予測コアとして位置づけています。これは、アクションに条件付けられる可能性のある世界の進化状態を予測する学習されたシミュレーターです。A Path Towards Autonomous Machine Intelligence (2022) の LeCun を参照してください。提案されたアーキテクチャには、ワールドモデル、コストモジュール、アクター、および短期メモリが含まれており、JEPA スタイルの予測が中心にあります。

LeCun が提案する完全なアーキテクチャはモジュール式で構成可能であり、6 つのコンポーネントが連携して動作します。コンフィギュレーターはエグゼクティブコントロールとして機能し、現在のタスクに基づいて他のモジュールを動的に調整します。知覚モジュールは、感覚入力から世界の現在の状態を推定します。ワールドモデルモジュール(JEPA が存在する場所)は、将来の状態を予測し、不足している情報を補完し、内部シミュレーターとして機能します。コストモジュールは、潜在的な結果を評価し、ハードワイヤードな不快感またはリスク(内在的コスト)と、将来のコストを推定する学習可能なクリティックに分割されます。アクターモジュールは、予測されたコストを最小化するアクションを提案します。そして、短期メモリは、リアルタイム意思決定のために状態、アクション、およびコストの即時履歴を維持します。このアーキテクチャは、最適制御理論、認知科学、および強化学習のアイデアを引き出しています。中心的な洞察は、計画には予測モデル(ワールドモデル)、結果を評価する方法(コスト)、およびアクションのシーケンスを検索する方法(アクター)が必要であるということです。

[画像: 自律的知能のための LeCun の認知アーキテクチャ]

表現空間で予測するワールドモデルがあれば、計画は実行可能になります。計算コストが高く、冗長な詳細で満たされたピクセルレベルの未来を想像するのではなく、エージェントは抽象的な状態軌道を検索できます。表現空間は、適切に学習されていれば、アクションにとって重要なものをエンコードし、そうでないものを破棄します。ピクセル空間のワールドモデルは、テクスチャ、照明、およびアクションに無関係なその他の詳細をモデル化するために容量を割り当てる必要があります。表現空間のワールドモデルは、これらすべてを無視し、重要なダイナミクスに容量を集中させることができます。

自己回帰言語モデルに対する議論

JEPA が提供しないものを正確に述べる価値があります。JEPA は表現学習および予測アーキテクチャです。それ自体は、目標を指定するコスト関数、アクションを提案するアクター、または良いアクションシーケンスを見つける検索アルゴリズムを提供しません。これらは LeCun のアーキテクチャの個別のコンポーネントであり、個別のソリューションが必要です。主張は、JEPA が単独で知能を解決するというものではなく、表現空間での予測がワールドモデルのより良い基盤であり、ワールドモデルが計画、推論、および物理世界で行動できるシステムの不可欠なコンポーネントであるということです。

ここには、現在の AI システムに関する暗黙の議論があります。大規模言語モデルは、次のトークンを予測するように訓練されています。これは一種の予測ですが、連続表現の空間ではなく、離散シンボルの空間で行われます。LeCun は、これが根本的に限界があることを主張しています。The critique is not that LLMs are useless, but that token prediction may not scale to physical-world understanding. Predicting the next word requires less world knowledge than predicting the next state of a physical system. (批判は LLM が役に立たないということではなく、トークン予測は物理世界の理解にスケールしない可能性があるということです。次の単語を予測するには、物理システムの次の状態を予測するよりも少ない世界知識が必要です。)

議論はほぼ次のように進みます。言語は、人間の知識の高度に圧縮された離散的な表現です。テキストを予測するには、人間のコミュニケーションパターンをモデル化する必要があります。これは有用ですが、物理的現実の深い理解を必要としません。言語モデルは、バランス、運動量、または物理的ダイナミクスの内部モデルを持たずに、自転車がどのように機能するかを説明できます。

対照的に、JEPA は生の感覚データ(画像、ビデオ、最終的にはマルチモーダルストリーム)で動作します。表現空間でうまく予測するには、モデルは物理世界の構造を捉える表現を学習する必要があります。オブジェクトは永続し、物理法則は動きを制約し、原因は結果に先行します。これは、言語モデルが欠いている可能性のある帰納バイアスです。

自律的知能への道

LeCun の完全な提案にはいくつかのコンポーネントが含まれています。ワールドモデル(JEPA スタイル)、状態を評価するコストモジュール、短期メモリ、およびアクションを提案するアクターです。システムは世界との相互作用によって学習し、ますます正確なワールドモデルを構築し、将来の低コスト状態につながるアクションシーケンスを検索することによって計画することによって行動します。これは、自律的知能システムを構築する方法に関する特定のアーキテクチャ仮説です。JEPA が提供するのは、1 つのコンポーネントのトレーニング可能なインスタンシエーションです。ワールドモデルの予測コアです。

この記事の実装、I‑JEPA、V‑JEPA、および LeJEPA は、存在証明です。表現空間での予測は機能し、ビデオにスケーリングし、計画を基礎付けることができます。これが自律的知能への進歩を構成するか、まだ想像されていない何かに吸収される技術になるかは不明です。

しかし、JEPA は、支配的なパラダイムに対する、首尾一貫した有望な代替手段を提供します。ピクセルの生成モデリング、手作業で設計された拡張機能による対照学習、または自己回帰トークン予測ではなく、表現自体がモデル化する価値のあるものを決定する抽象空間での予測です。

少なくとも、理解する価値のあるアイデアです。(\blacklozenge)