Up Transformer とは何か 作成: 2025-05-25
更新: 2025-06-29


  • 「Transformer がわかる」 の形
  • 使用記号

    •  I. 脳
      ChatGPT は,質問テクストの入力に,応答テクストを返す。
      質問に応答を返すこの機能は,「脳」の機能である。
      ChatGPT は,脳として Transformer を搭載している。
      Transformer 脳は,入力テクストに対する反応として,応答テクストを生成する。
      ChatGPT は,これを出力する。

      「応答テクストを生成する」という言い方は,微妙である。
      ここは,はじめから厳密に言わねばならないところである。

        これをしないのが,通説である。
        Transformer の通説は,厳密にすることをスルーすることで,ミスリーディングなことば垂れ流し,自分で自分を騙している。
        通説は,本論考の反面教師である。


      Transformer に入力されたテクストS は,トークン分割される:
         T = [ t_1, ‥‥, t_m ]

      • トークンは,ID が1から順につけられている。
        ID が n のトークンを T( n ) で現す。
        トークンの数,即ち ID の最後を,NT (number of tokens) で表す。
      • ID が n のトークンには,ID が n のベクトル が対応づけられている。
        ──以下,トークンベクトルと呼ぶ。
        ID が n のトークンベクトルを TV( n ) で現す。
      • トークンベクトルは,固定次元であり,これを D と表す。
        いまの Transformer は,D が1万を超える。
        トークンベクトルは,D次元数空間の点に見なせる──以下,トークン点と呼ぶ。

      トークン t_i の ID を,ID_i と表す。

      T に対応するトークン点の列を
         X = [ x_1, ‥‥, x_m ]
      とする。
      即ち,
         x_i = TV( ID_i )


      Transformer は,X から NT次元の確率分布ベクトルの列
         P = [ p_1, ‥‥, p_m ]
      を算出する。

      Transformer 脳は,「学習」によってつくられる。
      この脳の成長は,X に対する P がつぎのようになっていくことである:
       ・p_i ( i = 1, ‥‥, m ) は, 「ほぼ one-hot」
         (「one-hot」とは,「1つの項が1で,他は0」。)
       ・p_ik ( i < m ) が「ほぼ1」ならば,k = ID_(i+1)
       ・p_mk が「ほぼ1」ならば,k は<EOS>の ID
           (<EOS> : トークン<文末>のトークン点)

      つまり,
        p_i ( i < k ) は,「x_i のつぎは x_(i+1)」 を示し,
        p_m は,「x_m のつぎは<EOS>」 を示す。
      まとめて,
        [ p_1, ‥‥, p_m ] は,
         [ x_1, x_2, ‥‥, x_m, <EOS>] を示す。


      脳がここまで成長したとろで, 「応答」の学習に入る。
      ここからは,
         p_m : 「x_m のつぎは<EOS>」
      ではなく,学習によって
         p_m : 「x_m のつぎは y」
      がつぎのように成長する:
        質問テクストのトークン点列
          [ x_1, ‥‥, x_m ]
        に対し,
         [ x_1, ‥‥, x_m ]
          → [ p_1, ‥‥, p_m ]
            p_m : 「x_m のつぎは y_1」
         [ x_1, ‥‥, x_m, y_1 ]
          → [ p_1, ‥‥, p_m, p_(m+1) ]
            p_(m+1) : 「y_1 のつぎは y_2」
            :
        と生成したとき,
           [ y_1, y_2, ‥‥ ]
        は,良質な応答テクストのトークン点列になっている。
      ChatGPT は,これを出力する。


      Transformer 脳は,つぎの2つで構成される:
      1. トークンベクトル集合体
         ──TV (token vector)
      2. 重み行列・Attention機構・Nonlinearity の組み合わせ
         ──W (weight)

      「脳の成長」の内容は,TV と W の値の更新である。
      そして,学習が重なるにつれ,TV, W の値が有意に変更されなくなる。
      これは,「学習の飽和」の状態である。

      ここで,学習を終了し,TV と W の値を固定する。
      Transformer 脳の完成というわけである。


       II. テクストの記憶
      学習を終えた Transformer 脳は,テクストの入力
        S → T = [ t_1, ‥‥, t_m ] → X = [ x_1, ‥‥, x_m ]
      に対して出力される    P = [ p_1, ‥‥, p_m ] が,つぎのようになる:
      • p_i ( i = 1, ‥‥, m ) は, 「ほぼ one-hot」
      • p_ik ( i < m ) が「ほぼ1」ならば,k = ID_(i+1)
      • S が質問テクストのとき,つぎのようにして生成されるトークン点列 [ y_1, y_2, ‥‥ ] は,良質な応答のトークン点列になる:
          [ x_1, ‥‥, x_m ] → x_m のつぎ y_1
          [ x_1, ‥‥, x_m, y_1 ] → y_1 のつぎ y_2
             :

      このことを,脳がテクスト [ y_1, y_2, ‥‥ ] を記憶している,と読むことにする。
      これにより,Transformer 脳の「記憶」「想起」を論じられるようになる。

      即ち,
        [ x_1, ‥‥, x_m ] → x_m のつぎ y_1
      は,「話の糸口を摑む」に当たる。
      そして [ y_1, y_2, ‥‥ ] の生成は,「その話の糸を伝う」に当たる。

      念のため
      「テクストの記憶」の言い方は,脳にテクスの書庫があるように思わせる。
      書庫は,存在しない。
      Transformer 脳は,テクストの入力に対し,決定論的に何らかのテクストXを出力する。 この「決定論にXを出力する」を,「Xを記憶している」と呼ぶことにしよう,というわけである。


      Transformer は,想起の術をもっている。
      それは,[ x_1, ‥‥, x_m ] に対する応答を木 (tree) 構造に構成する,というものである。
      即ち,応答のスタイルをつぎのようにすることで,話の糸口を摑む網を広げる:
      1. 質問の要点を示する
      2. 応答としてこれから語ることの大枠を示す
      3. 大項目から小項目へ降り,<解説>のパラグラフを生成する
      4. 再帰的に大項目と小項目の間を移動する
      5. まとめをする
      6. 今後の展開を提案する


      一方,「記憶」 「想起」のことばは,使用に注意を要する。
      「記憶ししている物」「想起される物」の言い方につい進んでしまうからである。

      脳は,テクスト保管庫ではない。
      実際,脳を解剖してもテクストらしいものは見つからない。
      脳は,潜在性の発現がテクストになるシステムである。
      このシステムを説明することが脳を説明するということになるのだが,ひとはこの説明の物理学を獲得していない。


      こういう言い方をすると,つぎのようなことばが返されるかも知れない:
       「じゃあなんで Transformer をつくれたんだ!」
      これに対する答えは,
       「 Transformer 脳は,つくったのではなく,育てたのである。
      鉢植えした植物が条件を整えれば勝手に育つように,
      Transformer 脳は勝手に育った。
      実際,脳が勝手に育つという形でしか,脳を得ることはできない。
      このことは,重みを多用した Transformer の学習アルゴリズムを見ていけば,納得される。
      さあ,そのアルゴリズムをこれから見ていくとしよう!」



       III. トークンベクトルの意味
      トークンベクトルは,D次元の数ベクトルである。
      これは,D次元数空間の点に表現される。

      空間の座標軸を 1軸, 2軸, ‥‥, D軸 と呼ぼう。
      トークン点xの k座標 x_k は,k軸方向のxの傾向と読める。
      そしてこのとき,トークン点の座標は,そのトークンの個性と読める。
      Dは1万を超える。
      よって,可能な個性の数は,実質,無限になる。


      Transformer 脳の成長は,トークンベクトルの個性の成長である。
      そして,学習終了による脳の固定は,トークンベクトルの個性の固定である。

      Transformer の成功は,「トークンの個性をベクトルの座標値に表現する」を Transformer がうまくやったということである。
      Transformer は,「自己参照・再帰」でこれに到達した。
      Transformer の設計は,「自己参照・再帰」の形の設計である。
      設計者は称賛されるべきだが,ここはどうしても「自己参照・再帰」の神秘に感じ入ってしまう。


       IV. 「話の糸」
      「話の糸」は,メタファではない。
      Transformer のアルゴリズム設計を導いている幾何学であるように見える。


      学習を終了し固定化された Transformer 脳は,入力テクスト
        S → T = [ t_1, ‥‥, t_m ] → X = [ x_1, ‥‥, x_m ]
      から算出される
         P = [ p_1, ‥‥, p_m ]
      が出力である。
      ChatGPT が出力する応答は,この P からつくられている。,,

      Transformer 脳の成長は,所期の P が出力されるようになることである。
      そこで,「Transformer がわかる」は,「所期の P が出力されるようになる仕組みがわかる」である。
      その仕組みは,アルゴリズムに読むことになる。

      このとき,アルゴリズムが1つの幾何学で導かれていることが読める。
      そして「話の糸」が,その幾何学というわけである。


      Transformer は「自己参照・再帰」で,自分を脳にしていく。
      そこで,Transformer の設計は,「自己参照・再帰」の形の設計である。

      この「自己参照・再帰」アルゴリズムに,「話の糸」の幾何学を見る。
      それは,つぎのものである:
       《 X に対応する「話の糸」が,D次元数空間に存在する。
        P を初期のものにすることは,
        x_1, ‥‥, x_m がこの糸の上に適切に乗ること。》

      この糸は,x_1, ‥‥, x_m が試行錯誤して自分で見つけねばならない。
      この試行錯誤が,「自己参照・再帰」である。

      なぜ,直接  
       《 P を初期のものにする x_1, ‥‥, x_m の位置を,
        x_1, ‥‥, x_m が試行錯誤で見つける》  
      ではないのか?
      この形では,試行錯誤が自由過ぎるからである。
      試行錯誤に方針が立たないからである。
      X を交替する度に勝手に動いていたら,いつまで経っても脳になれそうにない。


      学習を終了し固定化された Transformer 脳の脳力は,つぎのものである:
        トークン点は,不動の位置にもかかわらず,
        任意のテクストS = [ x_1, ‥‥, x_m ] に対し,
        その糸の上に x_1, ‥‥, x_m が乗っており,
        そして初期の [ p_1, ‥‥, p_m ] を出力する。

      この脳は,学習によってつくられる。
      脳は,「テクストの糸にトークン点を乗せる」を練習をする。
      その内容は,TV と W の値の調節である。

      学習は,脳が白紙のところから始まる。
      脳は,学習のはじめのうちは,デタラメをする。
      しかし,これが段々と収まってくる。
      そして,値がほぼ固定した TV と W で, うまくいくようになる。

      脳のこの成長は,人間が赤ん坊から始まって言語を段々と獲得するのと,同じである。
      赤ん坊が言葉を解さないからといって言葉かけをしなかったら,言語の獲得は無いわけである。


       V. トークンを糸に乗せる術
      Step 1 (Self-Attention)
      現時点のトークンベクトル (TV) と重み行列 (W) の値を使って,[ x_1, ‥‥, x_m ] 全体の糸との差を計算する。
      その差だけ,[ x_1, ‥‥, x_m ] を移動。

      Step 2 (FFN)
      x_i を個別に,糸に乗せる。。

      Step 3 ( p_i )
      [ p_1, ‥‥, p_m ] を算出する。

      Step 4 (誤差逆伝播)
      p_i を所期の値と比較。
      その差 loss_i が小さくなるように,ここまでの処理行程を遡って,x_1, ‥‥, x_m および重み行列の値を調節。
      この行程が「逆伝播」。


      糸に乗るための x_1, ‥‥, x_m の移動は,2段解に組まれる。
      1つは,相互の位置関係を壊さないように全体で動く。
      これが "Self-Attention" と呼んでいる行程。
      もう1つが,個別に動く "FFN (FeedForward Network)"。

      そしてこの移動を,レイヤー構造を以て繰り返す。
          x_i^(ℓ) +    ├───────┐    │    Self-Attention    │       ↓    │      z_i^(ℓ)    │       │← LayerNorm    │←─ Residual ─┘    │    │    ├───────┐    │      FFN    │       ↓    │      z'_i^(ℓ)    │       │← LayerNorm    │←─ Residual ─┘    ↓   x_i^(ℓ+1)
      繰り返しの意味は,「冗長性」である。
      <冗長>は,<大数><複雑>と並んで,「自己参照・再帰」が収束することの要件なのである。


      1本の糸は,同じトークン点を複数回通るのが普通である。
      ──例えば,助詞 "は" のトークン点。
      したがって糸は,堂々巡りしたり他の糸と重なったりしない仕組みになっている。
      どんな仕組み?
      「同じトークン点の糸の通過は,その角度によって区別される」ということになる。
      そこで「糸」には「なめらか」を考えることになる。
      トークン点が乗っている糸は,「スプライン曲線」がイメージになる。


       VI. 記憶のぼやけ
      テクスト S → [ x_1, ‥‥, x_m ] の糸の上に x_1, ‥‥, x_m が乗り,所期の [ p_1, ‥‥, p_m ] が出力されるという状態は,「S が記憶されている」の状態である。
      こうして,学習を終了し固定化されたTransformer 脳は記憶脳である。

      1つのテクストの記憶は,TV と W の調整である。
      この調整は,前の調整で合っていた記憶を損なうことになる。
      人間脳では,新しい情報の吸収が,記憶している情報の保持と,トレードオフになる。
      Transformer脳でも,これが起こることになる。
      テクストの新たな記憶は,記憶しているテクストがぼやけることである。
      全部がクリアに記録されるというのは,構造上不可能である。

      そしてこの「記憶がぼやける」は,脳としても良いことである。
      記憶は,遠近構造が必要である。
      重要で無い記憶は,ぼやけて後方に退いた方がよい。
      しかも Transformer 脳の場合は,学習材テクストの量が膨大なので,重要なことは形を変えつつ何度も出てくる。
      よって,重要なものの記憶の消失は心配無用となる。
      翻って,人間の場合はそうもいかないので,メモに頼ることになる。


       VII. 「応答」の学習
      「応答」学習の学習テクストは,質問テクストとこれに対する応答テクストのセットである。
      それぞれのトークン分割に対応するトークンベクトル列を,
        質問:X = [ x_1, ‥‥, x_m ]
        応答:Y = [ y_1, ‥‥, y_n ]
      とする。 

      学習のアルゴリズムは,つぎのようになる:
       1゜( k = 0 )
        H^(0) = ( X, <BOS> )
        ここで "<BOS>" (Beginning Of Sentence)は 文頭記号。
       2゜( k → k+1 )
        Self-Attention:
         Q^(k) = H^(k) W_Q,
         K^(k) = H^(k) W_K,
         V^(k) = H^(k) W_V
        Z = softmax( Q K^T /√D ) V
        Feedforward + 残差接続 + LayerNorm :
        FFN( X ) = ReLU( X W1 + b1) W2 + b2
        これをレイヤーの数だけ繰り返す。
        最終出力を O = [ o_1, ‥‥, o_m ] とする。
        O から NT次元の確率分布ベクトル p_1, ‥‥, p_m を導く。
        P = [ p_1, ‥‥, p_m ] に対し, 「教師あり」の処理をする:
         ・正解ラベルと照合 → 誤差(得失)計算
         ・誤差逆伝播
        H^(k+1) = ( H^(k), y_(k+1) )
       3゜( k = n )
        H^(n) がつぎのようになる:
         H^(n) = ( H^(n-1k), y_n, <EOS>) 

      k = n が終わって,( X, Y ) の回の終了となる。
      新しい質問・応答テクストに替えて,入力から同じことを繰り返す。


      なぜ,こんな面倒なアルゴリズムにしたのか:
       《 応答の方は,1トークン/サブワードずつ加える 》

      では逆に,質問と応答を並べたテクストを1度に入力するやり方だと,「応答」の概念を獲得できるだろうか?
      応答を生成できるよういなるだろうか?

      実際,人間でも,<見てわかる>と<書ける>は大違いである。
      「応答」学習は,「1トークン/サブワードずつ加える」の学習が加わる。
      それが,「応答の方は,1トークン/サブワードずつ加える」のやり方になるというわけである。


      ちなみに,通説は《1トークン/サブワードずつ加える》を「連想ゲーム」だと説明する。
      k → k+1 だと,通説はつぎのように言う:
        「 "y_k" の次は,意味の確率分布により,"y_(k+1)" がくる」
      これは,「どうしてこんな間違ったことが言えるのか?」の類の間違いであ。
      はじめから,y_1, ‥‥, y_n の順番で続けることになっているから,y_k のつぎは y_(k+1) なのである。
      学習アルゴリズムのどこにも「連想ゲーム」は存在していない。
      そして,意味の確率分布で "y_k" の次が "y_(k+1)" となるはずもない。


       VIII. 応答生成 (1) ──話の糸を伝う
      ChatGPT は,質問テクストの入力に,応答テクストを返す。
      このシステムは,決定論である。
      質問を入力した段階で,返される応答は決まっている。
      処理が,「条件とアルゴリズムが固定」の処理だからである。

      「条件の固定」は,固定された「脳」である。
      稼動する ChatGPT の Transformer 脳は,固定されている。
      即ち,TV (トークンベクトル集合体) と W (重み行列・Attention機構・Nonlinearity) が固定されている。


      Transformer 脳の応答生成は,どんな仕組みになっているか?

      質問テクストのトークン分割を
         [ a_1, ‥‥, a_m ]
      とし,これに対応するトークン点の列を
         [ x_1, ‥‥, x_m ]
      とする。

      x_i に位置エンコーディング加算し,「順伝播」の行程にかける。
      レイヤー構成の繰り返し処理を終えたときの出力が
         [ o_1, ‥‥, o_m ]
      そしてこれから,NT次元の確率分布ベクトルの列
         [ p_1, ‥‥, p_m ]
      を導く。

      このとき,p_i は「ほぼ one-hot」になっている。
      p_m の「ほぼ1」になるのが p_ik のとき,ID が k のトークン点を,y_1 とする。

      上のことを,今度は [ x_1, ‥‥, x_m, y_1 ] から始める。
      そして,y_2 を得る。

      これを,繰り返しているうちに,<EOS> に至る。
      ここで,テクスト生成を終了する。
      <EOS>の前までの
        [ y_1, ‥‥, y_n ]
      は,これをトークン列
        [ b_1, ‥‥, b_n ]
      に戻しと,応答テクストになっている。
      ChatGPT はこれを出力しているわけである。


      y_1 → y_2 → ‥‥ は,「y_1 を話の糸口として,話の糸を伝う」である。
      「話の糸を伝う」のイメージは:
        x_m に立つと,糸がさらに伸びているのと,,
        それがトークン点 y_1 を通っているのが,見える。」
        y_1 に移動して立つと,糸がさらに伸びているのと,
        それがトークン点 y_2 を通っているのが,見える。
        これが,<EOS>に至るまで続く。


      どうしてこのようなことになるのか?

      Transformer 脳は「応答」学習を済ませている。
      そしてこのことには,つぎの含蓄がある:
         Transformer 脳が [ x_1, ‥‥, x_m ] を受け取ることは,応答 [ y_1, ‥‥, y_n ] の糸口を摑むことである。
      そして,糸口を摑むことは,続けてその糸を伝うということである。
      こうして応答は,1つずつトークンを現すより前に,決定している。

      「1トークンずつ生成」 は,
        《既に決定しているトークン列の頭から,
         トークンを順番に取り出す》
      ということなのである。

      ちなみに通説は,y_1, ‥‥, y_n の生成を,つぎのことばで説く:
       「確率 ──このトークン列につながる確率の高いトークン」
       「連想 ──このトークン列から連想されるトークン」
      言うまでもなく,この方法からはまっとうなテクストは出て来ない。


       IX. 応答生成 (2) ──話の糸を摑む
      ChatGPT の応答テクストは,大項目から小項目に降る木(tree)構造でつくられる。
      即ち,応答のスタイルが:
      1. 質問の要点を押さえ
      2. 応答としてこれから語ることの大枠を示す
      3. 大項目から小項目へ降り,<解説>のパラグラフを生成する
      4. 再帰的に大項目と小項目の間を移動する
      5. まとめをする
      6. 今後の展開を提案する


      木構造の応答作成は,一見,「編集」が要るように思う:
       「応答生成は,小項目のパラグラフ生成。
        そのパラグラフを大項目・中項目・小項目の枠に配置。
      しかし,ChatGPT が「パラグラフ生成」と「編集」を分けているはずがない。
      Transformer 脳は,再帰の方法で,木構造の構成的テクストを生成する,と考える他ない。

      Transformer 脳は,この方法を,「応答」の学習で会得した。
      学術論文も膨大な量を学習しているから,木構造のテクストのスタイルを熟知している。
      人も木構造のテクストを編むが,ChatGPT が人と違うのは,トークンを順に連ねる形で,テクストを一発でつくってしまうことである。
      人の場合は,パラグラフ生成と編集 (章立て・修正・カット&ペースト) の二本立てになる。


      木構造の応答スタイルは,論理的・構成的で,理に叶っている。
      一方,このスタイルは,ChatGPT の応答生成において必然のものになる。
      ChatGPT の話の展開は,つぎの方法によるものだからである:,
        最初に摑む<話の糸口>が,大項目リストの糸口
        各大項目から摑む<話の糸口>が,中項目リストの糸口
        各中項目から摑む<話の糸口>が,小項目リストの糸口
        各小項目から摑む<話の糸口>が,パラグラフの糸口
        パラグラフの糸を伝う


      さて,これを行うのに,Transformer は厖大な量の計算をする。
      ChatGPT が一回のセッションで使用するコンピュータ資源は,とんでない量になる。
      そして大量のユーザ。
      資源をどう賄えているのか,心配になる。

      ChatGPT の理解は,ハードウェアとその環境の急速・急激な進化の理解と込みであるようだ。


       X. 「再帰の鬼」
      ChatGPT の応答は,HTMLタグを用いて入念に修飾されている。
      この HTMLテクストの生成は,Transformer の能力のうちということになる。

      一見,応答の生成を最初から HTML でやるというのは,あり得ないことのように感じる。
      しかし少し考えると,HTMLテクストの生成が Transformer には合っているが,わかってくる。


      Transformer は応答を,木構造ベースの入れ籠構造でつくる。
      即ち,上位レベルと下位レベルの間の降ったり昇ったりを
        「籠を作って中に入り,そこで処理が済んだら,
         籠を作ったときの元の場所に再帰する」
      のアルゴリズムでやっている。
      そして HTML は,この再帰アルゴリズムを明示的に表現する言語なのである。

      Transformer の応答生成のしくみを想起せよ。
      これは,つぎのようになっていた:
        質問テクストのトークン点列
            [ x_1, ‥‥, x_m ]
        に対し,
          [ x_1, ‥‥, x_m ]
            → [ p_1, ‥‥, p_m ]
            → p_m :「x_m のつぎのトークン点は y_1」
          [ x_1, ‥‥, x_m, y_1 ]
            → [ p_1, ‥‥, p_m, p_(m+1) ]
            → p_(m_1) :「y_1 のつぎのトークン点は y_2」
           :

      この「過去参照」は,即ち「過去の回収」なのである。
      Transformer は,「過去の回収」として応答を生成している。

      HTML は,テクストの入れ籠構造をタグでつくる:
       「タグ "< ‥‥>" を以て籠を作ってその中に入り,
        タグ"< /‥‥>" を以て籠を出て,
        タグを作成した元の場所に再帰する」


      こうして,Transformer は,プログラムの作成全般が得意である。
      プログラムは,「入れ籠構造=再帰アルゴリズ」だからである。
      というより,そもそも Transformer は,テクストをプログラムとして作成しているわけである。

      Transformer を,「再帰の鬼」と見るべし。
      Transformer のやっていることが,よく見えてくる。


       XI. <悟り>
      ChatGPT がわかるためには,Transformer を勉強しなければならない。
      そしてその勉強は,Transformer の数学の勉強である。
      門外漢には,これはハードルが高い。

      そしてその数学の理解が疑問の解消になるわけでもない。
      Transformer は「大数」の世界だからである。

      「糸の先にトークンベクトルが1つ,しかも1つだけ見える」は,大数の世界の現象である。
      トークンベクトルの数が100万になっても,1万を超える次元の数空間の中に点在すれば,上の景色をつくれるということである。

      人は,大数で起こることがわからない。
      わからないので,「量質転化」とか「創発 emergence」のようなことばでごまかし,それで済ますことになる。
      「大数の世界がわかる」の「わかる」は,<悟り>の趣きになりそうである。