Positional Encodingとは？RoPEでLLMが語順を扱う仕組みを理解する

Positional Encodingは、Attention中心のTransformerにtokenの順序情報を渡すための仕組みです。

3文要約

Self-Attention（同じtoken列の中でtoken同士の関係を計算する仕組み）は、位置情報を別に与えなければ、同じtoken集合の並び順を区別しにくい計算です。

そのためTransformer論文ではsin/cosで作るPositional Encodingを入力埋め込みへ足し、RoFormer論文ではQueryとKeyを位置に応じて回転させるRoPE（Rotary Position Embedding、回転で位置を表す方法）を提案しました。

RoPEの要点は、Attention scoreに絶対位置を注入しながら、QueryとKeyの内積が位置差に依存する形を作り、長い入力でも語順と距離をAttentionで扱いやすくすることです。

論文情報

なぜTransformerに位置情報が必要なのか

先ほどのSelf-Attention編では、QueryとKeyの内積から「どのtokenを見るか」を決める流れを整理しました。

この計算は、token同士をまとめて比較しやすい一方で、RNN（前の状態を次へ渡しながら系列を読むニューラルネットワーク）のように処理順そのものへ語順が埋め込まれているわけではありません。

たとえば、次の2文はtokenの並び順が違います。

tokenの内容だけを見て順序を無視すると、主語と目的語の関係を誤解しやすくなります。

そこでTransformerでは、各tokenに「何番目に現れたか」という情報を添えます。

これにより、LLMは長文の入力を受け取ったときでも、文字やtokenの順序を手がかりにして、正しく注目すべき語彙へAttentionを向けやすくなります。

位置情報が弱いと、同じ語彙が何度も出てくる長い文脈で「どの語が、どの語に対応しているのか」を学習しづらくなります。

つまりPositional Encodingは、単なる補助情報ではなく、Attentionの重みを語順に沿って学習するための重要な仕組みです。

位置情報の入れ方には複数の選択肢があります。

RoPEは、この中で「Attentionの照合部分に位置を入れる」発想に近い方式です。

Attentionだけだと、token集合の並び順を区別しにくいという課題があります。

Transformer論文のsin/cos Positional Encodingは入力表現へ位置ベクトルを足す方式でしたが、RoFormer論文はQueryとKeyの内積そのものに回転位置を入れることで、Attention scoreに絶対位置を注入しながら、相対位置差も扱える形を提案しました。

この設計により、従来の入力加算型の位置表現だけでは直接表しにくかった「どの位置にあるtoken同士が、どれだけ離れているか」をAttention score側で扱いやすくなります。

Transformerのsin/cos Positional Encoding

Transformer論文では、入力のtoken embeddingへPositional Encoding（位置情報を表すベクトル）を足します。

偶数次元と奇数次元には、それぞれsinとcosを使います。

補足：ここでいう偶数次元・奇数次元は、「2番目、4番目に出現したtoken」という意味ではありません。 1つのtoken embeddingは、たとえば512次元のようなベクトルです。 そのベクトルの中の0番目、2番目、4番目の成分にsinを使い、1番目、3番目、5番目の成分にcosを使う、という意味です。 つまりtokenの出現順は \(pos\) が表し、偶数・奇数は各tokenが持つベクトル成分の番号を表します。

\[
PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{\mathrm{model}}}}\right)
\]
\[
PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{\mathrm{model}}}}\right)
\]

\(pos\) はtoken位置、\(i\) は次元ペアの番号、\(d_{\mathrm{model}}\) はモデルの隠れ次元です。

補足：たとえば \(d_{\mathrm{model}}=8\) とすると、次元ペアは \((0,1)\)、\((2,3)\)、\((4,5)\)、\((6,7)\) の4組になります。このとき、\(i=0\) のペアは \(\sin(pos)\) と \(\cos(pos)\) に近い速く変化する波になり、\(i\) が大きいペアほど分母が大きくなるため、\(pos\) が1つ進んでも値の変化がゆっくりになります。具体的には、\(d_{\mathrm{model}}=8\) のとき、\(i=0\) では分母が \(1\)、\(i=3\) では分母が \(10000^{6/8}=1000\) になります。そのため、\(pos=10\) に対して、低い次元では \(\sin(10)\) のように大きく位相が進み、高い次元では \(\sin(10/1000)\) のようにほとんど変化しない値になります。

低い次元では速く変化する波、高い次元ではゆっくり変化する波を使うため、位置ごとに異なるパターンを作れます。

この方式はTransformerの基礎を理解するうえで重要です。

一方でRoFormer論文は、Attention scoreに相対位置を反映する観点から別の構成を考えます。

absolute positionとrelative positionの違い

absolute position（絶対位置）は、「このtokenは系列の3番目」のように各token単体の場所を表します。

relative position（相対位置）は、「Query位置からKey位置まで2 token離れている」のようにtokenペアの位置差を表します。

LLMで位置表現を考えるときは、「どの位置か」と「どれだけ離れたか」を分けると整理しやすくなります。

LLMは、位置情報を正確に扱えないと、推論結果に大きな影響を受けます。

特に長い文脈では、同じ語や似た表現が何度も現れるため、Attentionが「近い語を見るべきか」「遠くの対応語を見るべきか」を学習しづらくなります。

そのため、token単体の場所を表すabsolute positionと、token同士の距離を表すrelative positionを分けて設計することが重要になります。

RoPEは、位置 \(m\) のQueryと位置 \(n\) のKeyを回転させ、内積には位置差が現れるように設計します。

RoPEの直感：位置ごとにベクトルを回転する

Attentionでは、QueryとKeyの内積を取ることで類似度を計算し、各tokenがどこに着目すればよいかを学習していきます。

RoPEでは、この内積にベクトルの回転も考慮させることで、絶対位置と相対位置という概念をAttention scoreへ取り入れます。

LLMが実際に扱う高次元ベクトルの回転をそのまま考えると難しいため、まずは2次元平面上の回転として直感的に見ていきます。

位置 \(m\) の2次元ベクトルを角度 \(m\theta\) だけ回す回転行列は、次のように書けます。

\[
R_{\Theta,m}^{(2)} =
\begin{pmatrix}
\cos(m\theta) & -\sin(m\theta) \\
\sin(m\theta) & \cos(m\theta)
\end{pmatrix}
\]

QueryとKeyへ同じ考え方の回転を適用すると、位置 \(m\) のQueryと位置 \(n\) のKeyの類似度は、回転差 \(\Delta\theta\) に依存します。

\[
\left(R_{\Theta,n}^{d} k\right)^T
\left(R_{\Theta,m}^{d} q\right)
=
k^T R_{\Theta,m-n}^{d} q
\]

式の右辺には、位置差 \(m-n\) が残っています。

これは画像の \(\Delta\theta=(m-n)\theta\) と同じ向きで書いた形です。

Attention実装では通常 \(q_m^T k_n\) と書くため、同じスカラーを \(q^T R_{\Theta,n-m}^{d} k\) と表すこともできます。

どちらも同じ内積を別の向きから書いたもので、重要なのは絶対位置 \(m\) と \(n\) そのものではなく、回転差 \(\Delta\theta\)、つまり位置差がAttention scoreに残る点です。

つまりRoPEは、各tokenの絶対位置を使って回転を決めながら、Attentionの照合では相対位置差を使いやすい形を作ります。

これにより、入力へ位置ベクトルを足すだけの方式よりも、Attention scoreの中で絶対位置と相対位置を同時に考慮しやすくなります。

RoPEの数式を多次元で見る

実際のAttention headは2次元ではありません。

RoFormer論文では、head次元 \(d\) が偶数であることを前提に、ベクトル成分を \((0,1)\)、\((2,3)\)、\((4,5)\) のような2次元ペアへ分けます。

補足：ここで偶数次元というのは「偶数番目のtoken」ではなく、「head_dimが2で割り切れる」という意味です。各ペアの1つ目と2つ目の成分を、2次元平面の \(x\) 成分と \(y\) 成分のように扱い、位置に応じて回転させます。\(d_0\) がQueryで \(d_1\) がKeyという対応ではありません。 QueryもKeyも、それぞれ同じhead次元を持つベクトルであり、その各ベクトルの中に2次元ペアがあります。RoPEは、位置 \(m\) にあるQueryには \(m\) に応じた回転を、位置 \(n\) にあるKeyには \(n\) に応じた回転を適用します。周波数そのものは次元ペアごとに固定された設計値で、任意に学習される回転ではありません。位置が変わると、固定された周波数に位置番号を掛けた角度が変わるため、QueryとKeyの位置差がAttention scoreへ反映されます。

周波数は次の形で置かれます。

\[
\theta_i = 10000^{-2(i-1)/d}, \quad i \in [1, 2, \ldots, d/2]
\]

補足：この \(10000\) はTransformerのsinusoidal Positional Encodingでも使われている周波数スケールの設計値です。学習で更新されるパラメータではなく、低い次元から高い次元まで異なる周期の波を広く用意するための固定定数です。実装によっては、この値を base や rope_theta として変更できることがあります。

位置 \(m\) のtoken表現 \(x_m\) から作ったQueryまたはKeyは、次のように表せます。

\[
f_{\{q,k\}}(x_m, m) = R_{\Theta,m}^{d} W_{\{q,k\}} x_m
\]

ここで \(x_m\) は位置 \(m\) にあるtokenの特徴表現です。

\(W_q\) と \(W_k\) は、その特徴表現からQuery用ベクトルとKey用ベクトルを作るための学習済み重み行列です。

つまり、同じtoken表現 \(x_m\) を「探す側の手がかり」であるQueryと、「照合される側の手がかり」であるKeyへ変換します。

\(R_{\Theta,m}^{d}\) は位置 \(m\) に応じた回転を表します。

Keyが位置 \(n\) にある場合は、同じ式で \(m\) を \(n\) に置き換え、\(R_{\Theta,n}^{d} W_k x_n\) として回転させます。

そのため、Query側の絶対位置だけでなく、Key側の絶対位置も考慮され、最終的な内積には両者の位置差が現れます。

論文では、\(R_{\Theta,m}^{d}\) をそのまま密行列で掛けるのではなく、sin/cosと要素の組み替えで効率よく計算できる形も示しています。

RoPEで押さえたいポイントは次の3つです。

1. QueryとKeyに適用する。
2. head次元を2次元ペアとして回転する。
3. 回転は固定された周波数とtoken位置で決まり、その後の内積が位置差を含むAttention scoreになる。

実装イメージ：PyTorchでRoPEを適用する

以下は、RoPEの回転部分だけを追うための最小例です。

実際のモデルでは、cos/sinをキャッシュしたり、head次元の並べ方に合わせて実装を最適化したりします。

import logging
from typing import Tuple

import torch
from torch import Tensor

logger = logging.getLogger(__name__)


def build_rope_cache(
    sequence_length: int,
    head_dim: int,
    device: torch.device,
    base: float = 10000.0,
) -> Tuple[Tensor, Tensor]:
    """Build cosine and sine caches for rotary position embedding.

    Args:
        sequence_length: Number of token positions to encode.
        head_dim: Per-head hidden dimension. It must be even.
        device: Device where the cache tensors should be allocated.
        base: Frequency base used by the rotary schedule.

    Returns:
        A pair `(cos, sin)` with shape `(1, 1, sequence_length, head_dim / 2)`.

    Raises:
        ValueError: If `sequence_length` is less than 1.
        ValueError: If `head_dim` is not a positive even number.
        ValueError: If `base` is not greater than 1.

    Example:
        >>> cos, sin = build_rope_cache(4, 8, torch.device("cpu"))
        >>> cos.shape
        torch.Size([1, 1, 4, 4])
    """
    if sequence_length < 1:
        logger.error("sequence_length must be positive")
        raise ValueError("sequence_length must be positive")

    if head_dim < 2 or head_dim % 2 != 0:
        logger.error("head_dim must be a positive even number")
        raise ValueError("head_dim must be a positive even number")

    if base <= 1:
        logger.error("base must be greater than 1")
        raise ValueError("base must be greater than 1")

    pair_indices: Tensor = torch.arange(0, head_dim, 2, device=device)
    inverse_frequencies: Tensor = base ** (-pair_indices / head_dim)
    positions: Tensor = torch.arange(sequence_length, device=device)
    angles: Tensor = positions[:, None] * inverse_frequencies[None, :]
    logger.debug(
        "built rope cache",
        extra={"sequence_length": sequence_length, "head_dim": head_dim},
    )
    return angles.cos()[None, None, :, :], angles.sin()[None, None, :, :]


def apply_rope(x: Tensor, cos: Tensor, sin: Tensor) -> Tensor:
    """Rotate Attention vectors with rotary position embedding.

    Args:
        x: Tensor with shape `(batch, heads, sequence_length, head_dim)`.
        cos: Cosine cache broadcastable to the even/odd dimension pairs of `x`.
        sin: Sine cache broadcastable to the even/odd dimension pairs of `x`.

    Returns:
        Tensor with the same shape as `x`.

    Raises:
        ValueError: If the last dimension of `x` is not even.
        ValueError: If `cos` and `sin` do not have matching shapes.

    Example:
        >>> q = torch.randn(2, 4, 3, 8)
        >>> cos, sin = build_rope_cache(3, 8, q.device)
        >>> apply_rope(q, cos, sin).shape
        torch.Size([2, 4, 3, 8])
    """
    if x.size(-1) % 2 != 0:
        logger.error("RoPE requires an even head dimension")
        raise ValueError("x must have an even last dimension")

    if cos.shape != sin.shape:
        logger.error("cos and sin caches must match")
        raise ValueError("cos and sin must have matching shapes")

    even: Tensor = x[..., 0::2]
    odd: Tensor = x[..., 1::2]
    # 2次元ペアを保つことで、回転行列を密に作らず同じ幾何を実装できるためです。
    rotated_even: Tensor = even * cos - odd * sin
    rotated_odd: Tensor = even * sin + odd * cos
    rotated: Tensor = torch.stack((rotated_even, rotated_odd), dim=-1)
    logger.debug("applied rope rotation", extra={"shape": tuple(x.shape)})
    return rotated.flatten(-2)

Attentionへ入れるときは、QueryとKeyを回転し、Valueは通常そのままにします。

rotated_query: Tensor = apply_rope(query, cos, sin)
rotated_key: Tensor = apply_rope(key, cos, sin)

この位置が、入力埋め込みへベクトルを足すsinusoidal Positional Encodingとの大きな違いです。

RoFormer論文の実験結果をどう読むか

RoFormer論文は、RoPEを位置表現の提案だけで終わらせず、複数のタスクで比較しています。

たとえばGLUE表では、RoFormerがAverage 78.8を報告し、同表のBERT 75.8、BERT+Sinusoidal 76.8、BERT+Relative 77.4を上回っています。

長文中国語分類では、512 tokenで学習したモデルを1024 token評価へ広げた表で、RoFormerはIFLYTEKとCMeEEの双方で比較対象より高い値を報告しています。

ただし、これらはRoFormer論文内の実験条件で得られた結果です。

RoPEを採用すれば任意のLLMが無条件に長文へ強くなる、と読むのは行き過ぎです。

長いコンテキストでは、位置表現だけでなく学習長、データ、Attention計算、KV Cache、推論実装も効いてきます。

よくある誤解

まとめ

Transformerでは、Self-Attentionの強みを活かすために位置情報を別途与える必要があります。

sin/cos Positional Encodingは、固定式で作った位置ベクトルをtoken embeddingへ足すTransformerの基本方式です。

RoPEは、QueryとKeyを位置ごとに回転し、Attention scoreへ相対位置差が現れる構造を作ります。

2次元の回転をhead次元のペアへ拡張すると、RoPEの式と実装は追いやすくなります。

RoFormer論文は翻訳、事前学習、GLUE、長文分類でRoPEを評価していますが、その結果は位置表現以外の条件も含む実験として読む必要があります。

次にDecoder-only Transformerを見ると、RoPEのような位置表現がcausal Self-Attentionの中でどこに効くかを結び付けやすくなります。

関連技術

次に読むべき記事

• GPT系LLMの構造とは？Decoder-only Transformerをやさしく解説
• KV Cacheとは？LLMの生成を高速化する仕組み
• FlashAttentionとは？Attentionを高速化する技術
• Long Contextとは？LLMが長文を扱う仕組み