VLAの代替になり得るか：SNNで考えるロボット制御
VLAとSNNを、計算方式・時間表現・実機制約の観点から比較する
VLA（Vision-Language-Action）は、画像と言語からロボットの行動を生成する強力な枠組みだ。ただし、現在の実装の多くは、大規模なTransformer、GPU、フレーム単位の画像入力を前提にしている。
この構成は意味理解には強い。一方、数ミリ秒単位の反応、消費電力、非同期センサーの処理まで一つのモデルに任せると、実機では無理が出る。
そこで本稿では、SNN（Spiking Neural Network）を別の設計候補として検討する。焦点は「VLAとSNNのどちらが優れているか」ではない。意味推論とリアルタイム制御をどう分担すれば、ロボット上で無理なく動かせるか、という点にある。
この記事は自身の知識管理のために書いた目的が強いので、読みにくい部分が多分にあると思います。ご容赦ください。あと、markdownが慣れなすぎて、数式が変換しきれていない部分もあると思います...
TL;DR
先に結論をまとめる。
- VLAは意味理解と多タスク化に強いが、計算量、制御遅延、消費電力に課題がある
- SNNはイベント駆動の時系列処理に向くが、言語能力と学習基盤はまだVLAに及ばない
- 現段階で全面置換は現実的ではない
- 当面は、VLM/VLAを低頻度のプランナー、SNNを高速な知覚・制御系として組み合わせる構成が妥当である
- 比較には精度だけでなく、実機上のエネルギー、P99レイテンシ、ジッタ、発火率を含める必要がある
以下では、VLAとSNNの構造、両者の違い、実装方法、評価指標、研究テーマの順に整理する。
1. VLAの基本構造
VLAは、Vision-Language-Action Modelの略である。
一般には、カメラ画像などの視覚入力と自然言語による指示を受け取り、ロボットが実行すべき行動を出力するモデルを指す。
単純化すると、VLAは次の写像を学習する。
$$
\pi_\theta :
(o_{\leq t}, l)
\mapsto
a_t
$$
ここで、
- $o_{\leq t}$：時刻 $t$ までの観測
- $l$：自然言語による指示
- $a_t$：時刻 $t$ に出力する行動
- $\theta$：モデルパラメータ
である。
例えば、
観測:
テーブル上に赤いコップと青い箱がある
言語指示:
「赤いコップを青い箱の中に入れて」
出力:
ロボットアームの関節角度
エンドエフェクタの移動量
グリッパーの開閉
という関係を、単一のニューラルネットワークで学習する。
1.1 VLMからVLAへ
Vision-Language Model、すなわちVLMは、おおむね次の写像を扱う。
$$
f_\theta(I, l) \rightarrow y
$$
- $I$：画像
- $l$：テキスト
- $y$：説明文、回答、分類結果など
VLAでは、出力が文章ではなく行動になる。
$$
\pi_\theta(I, l) \rightarrow a
$$
VLMとの違いは、出力が実世界へ作用する点にある。
言語モデルが単語を一つ間違えても、文章が多少不自然になるだけかもしれない。
しかし、ロボットが行動を間違えると、
- 物体を落とす
- 人間に衝突する
- 関節の可動域を超える
- 高価な装置を破損する
- 制御周期に間に合わない
といった問題が起こる。
VLAは「画像と言語を扱うLLM」というより、意味表現を物理的な行動へ変換する方策モデルと捉えるほうが近い。
1.2 代表的なVLA
VLAの流れをつかむうえで、まず押さえておきたいモデルを挙げる。
RT-1
RT-1は、複数の実ロボットタスクを一つのTransformerベースモデルで学習し、画像と言語命令から離散化された行動トークンを予測する枠組みを示した。
RT-2
RT-2は、Web規模のVision-Language事前学習で得られた意味知識を、ロボットの行動生成へ転移する考え方を明確にした。
Web上の画像と言語から学習した知識
↓
ロボット行動の生成に利用
という流れである。
RT-2は、VLAという考え方を広く認知させた代表的研究である。
OpenVLA
OpenVLAは、Llama 2を基盤とし、DINOv2とSigLIP由来の視覚特徴を組み合わせた7Bパラメータ規模のオープンVLAである。
約97万件の実ロボットデモンストレーションを用いて学習され、VLA研究をオープンに再現するための重要な基盤となった。
$\pi_0$ / OpenPI
$\pi_0$は、連続的なロボット行動を生成するために、Flow Matchingという技術（Diffusionの拡散過程の一般化のようなもの）を利用するVLAである。
言語モデルのように一つずつ離散行動トークンを出すだけではなく、連続値の行動系列を滑らかに生成する方向へ進んでいる。
現在では、$\pi_{0.5}$や$ \pi_{0.6}$などの後継モデルが発表されている。
2. VLAの強み
SNNとの比較に入る前に、VLAの強みを4点に整理する。
2.1 意味理解と行動の統合
従来のロボットシステムは、しばしば次のように分割されていた。
物体検出
↓
セマンティック認識
↓
タスクプランニング
↓
軌道計画
↓
低レベル制御
この構成にはモジュール性という利点がある一方、モジュール間の誤差伝播や設計コストが大きい。
VLAはこれらの一部を学習ベースで統合する。
画像 + 言語命令
↓
VLA
↓
行動
これにより、人間が明示的にすべての中間表現を定義しなくても、知覚から行動までを学習できる。
2.2 Web知識のロボットへの転移
VLAの大きな魅力は、インターネット上の画像・言語データから得た知識を、ロボット制御へ持ち込める点にある。
例えば、
- 「リンゴは食べ物である」
- 「ナイフは注意して扱うべきである」
- 「壊れやすい物体は慎重に置くべきである」
- 「空のコップと液体入りのコップでは操作方法が異なる」
といった知識を、ロボットデータだけから学習するのは難しい。
VLAでは、VLMが持つ意味表現を行動生成に利用できる。
2.3 多タスク化
従来の模倣学習では、タスクごとに方策を学習するケースが多かった。
$$
\pi_{\theta_i}(o_t) \rightarrow a_t
$$
VLAでは言語命令を条件として与えることで、一つの方策が複数のタスクを扱える。
$$
\pi_\theta(o_t, l_i) \rightarrow a_t
$$
同じ画像でも、
「赤い物体を持ち上げて」
「青い箱を右に動かして」
「机の上を片付けて」
という命令によって異なる行動を生成できる。
2.4 大規模事前学習
ロボットデータ、視覚言語データ、シミュレーションデータを事前学習に使えば、タスク固有のデータ量を減らせる可能性がある。
OpenVLAでは、低ランク適応や量子化を利用したファインチューニング・推論効率化も検討されている。
3. VLAの構造的な課題
VLAの性能が向上しても、現在のアーキテクチャがロボット知能の最終形であるとは限らない。
問題は、単に
VLAはモデルサイズが大きい
と批判することではない。
モデルサイズだけでなく、この計算方式がリアルタイムに動くロボットへ適しているかを考える必要がある。
3.1 高密度計算
通常のTransformerでは、ほぼすべての層で高密度な行列積が実行される。単純化すれば以下のような行列積が何度も繰り返される。
$$
Y = XW
$$
入力に大きな変化がなくても、次のフレームが与えられれば、多数の積和演算が再び実行されてしまう。
Attention機構では、次を計算する。
$$
\operatorname{Attention}(Q,K,V) = \operatorname{softmax}
\left(
\frac{QK^\top}{\sqrt{d}}
\right)V
$$
トークン数を $N$、特徴次元を $d$ とすると、標準的なSelf-Attentionの主要計算量はおおむね
$$
O(N^2d)
$$
となる。
画像トークン、言語トークン、時系列トークン、ロボット状態トークンを同時に処理すると、計算負荷は大きくなる。
3.2 フレーム駆動である
一般的なカメラは、一定周期で完全な画像を生成する。
Frame 0: 全画素
Frame 1: 全画素
Frame 2: 全画素
Frame 3: 全画素
しかし、実際には多くの画素がほとんど変化していないことがある。
それでも通常の画像ベースVLAは、各フレームを独立した高密度テンソルとして処理する。
これは、静止している背景を何度も再計算することを意味する。
3.3 制御周期と意味推論の時間スケールが異なる
ロボットには複数の時間スケールが存在する。
| 処理 | 典型的な時間スケール |
|---|---|
| 衝突回避・反射制御 | ms |
| 関節制御 | ms〜数十ms |
| 視覚追跡 | 数十ms |
| 操作方策 | 数十〜数百ms |
| 言語理解・タスク計画 | 数百ms〜秒 |
| 長期計画 | 秒〜分 |
巨大VLAでこれらをすべて一つの推論周期に押し込めると、処理の最も遅い部分がシステム全体を制約する。
言語推論は毎ミリ秒実行する必要がない。
一方で、人間の手が突然ロボットの前に入った場合、衝突回避を言語モデルの推論完了まで待つべきではない。
3.4 連続時間を離散フレームへ変換している
現実世界は連続時間で進む。
しかし、通常のVLAでは、
$$
t = 0,1,2,\ldots
$$
という離散時刻にサンプリングされた観測を処理する。
その結果、
- フレーム間で起きた高速運動
- 微細な接触変化
- 非同期センサーからの入力
- センサーごとに異なる更新周期
- 行動と観測の厳密な時間関係
を扱うためには、追加の設計が必要になる。
3.5 状態を毎回トークン列へ再符号化する
多くのVLAでは、過去の観測を複数フレームの履歴やトークン列として与える。
$$
x_{t-k:t} = [x_{t-k},\ldots,x_t]
$$
しかし、この方法では時間的状態を保持するために、過去入力そのものを繰り返しモデルへ渡す必要がある。
SNNや状態空間モデルの立場から見ると、これは必ずしも自然ではない。
システム内部に状態 (h_t) を持つなら、
$$
h_t = F(h_{t-1},x_t)
$$
として過去を圧縮できる。
3.6 エッジロボットへの展開
データセンター上で動作するモデルと、自律移動ロボット上で動作するモデルでは条件が異なる。
実ロボットでは、
- バッテリー容量
- 発熱
- 重量
- 通信遅延
- 通信切断
- メモリ容量
- 安全性
- 長時間稼働
が問題になる。
モデルの精度だけでなく、
$$
\text{Task Success per Joule}
$$
や
$$
\text{Reaction Quality under Energy Budget}
$$
のような評価が必要になる。
4. SNNとは何か
SNNは、Spiking Neural Networkの略である。
通常のニューラルネットワークでは、ニューロンの出力は連続値で表現される。
$$
y = \sigma(Wx+b)
$$
一方、SNNではニューロンが内部状態を持ち、膜電位が閾値を超えたときにスパイクを発生させる。
4.1 LIFニューロン
代表的なモデルがLeaky Integrate-and-Fire、LIFニューロンである。
離散時間版を単純化すると、
$$
u_i[t] = \beta u_i[t-1] + \sum_j w_{ij}s_j[t] - v_{\mathrm{th}}s_i[t-1]
$$
$$
s_i[t] = H(u_i[t]-v_{\mathrm{th}})
$$
となる。
ここで、
- $u_i[t]$：ニューロン $i$ の膜電位
- $\beta$：膜電位の減衰係数
- $w_{ij}$：シナプス重み
- $s_j[t]\in{0,1}$：入力スパイク
- $v_{\mathrm{th}}$：発火閾値
- $H$：Heaviside関数
である。
直感的には、
入力スパイクが到着
↓
膜電位へ蓄積
↓
時間とともに一部が減衰
↓
閾値を超えたら発火
↓
膜電位をリセット
という処理を行う。
4.2 通常のANNとの違い
通常のANNニューロンは、おおむね次のように計算する。
$$
y_i = \sigma \left( \sum_j w_{ij}x_j
\right)
$$
一方、SNNは時間発展を持つ。
$$
u_i[t] = F(u_i[t-1],s[t])
$$
$$
s_i[t] = H(u_i[t]-v_{\mathrm{th}})
$$
つまり、SNNでは時間が外部から付与された添字ではなく、ニューロンの状態方程式の一部になっている。
4.3 スパイクは二値でも、表現は単純ではない
SNNの出力は0または1のスパイクである。
しかし、情報は一つのスパイクだけでなく、
- 発火頻度
- 最初のスパイク時刻
- スパイク間隔
- 発火順序
- 同期
- 位相
- バースト
- 集団活動
によって表現できる。
例えば、Rate Codingでは一定時間内の発火数を利用する。
$$
r_i = \frac{1}{T}
\sum_{t=1}^{T}
s_i[t]
$$
Time-to-First-Spikeでは、最初に発火した時刻を利用する。
$$
\tau_i = \min{t \mid s_i[t]=1}
$$
したがって、SNNの二値性は「情報量が1bitしかない」ことを意味しない。
5. SNNをロボット制御に使う理由
SNNは、ANNの活性化を二値化しただけの省電力モデルではない。VLAとは時間と状態の扱い方が異なる。
| 観点 | 一般的なVLA | SNNベースエージェント |
|---|---|---|
| 入力 | フレーム、トークン | 非同期イベント、スパイク |
| 計算 | クロック駆動・高密度 | イベント駆動・スパース |
| 時間 | 位置埋め込みや履歴で表現 | 状態方程式に内在 |
| 状態 | KV Cache、履歴トークン | 膜電位・シナプス状態 |
| 推論 | 一定周期で全体更新 | 変化時に局所更新可能 |
| ハードウェア | GPU・TPU | ニューロモルフィックチップ |
| 学習 | 誤差逆伝播中心 | 代理勾配、変換、局所学習 |
| 強み | 大規模意味知識 | 時系列、反応性、電力効率 |
| 弱み | レイテンシ、電力、周期処理 | 学習困難、規模、言語能力 |
5.1 イベント駆動
SNNでは、ニューロンが発火しなければ後段へのイベント伝播が発生しない。
通常の高密度層では、
$$
y_i=\sum_jw_{ij}x_j
$$
を多数の $i,j$ について計算する。
SNNでは、入力スパイクがある接続だけを更新できる。
$$
u_i[t]
\leftarrow
u_i[t]
+
w_{ij}
\quad
\text{if }s_j[t]=1
$$
スパイク率を (\rho) とすると、理想化されたイベント駆動計算では、有効なシナプス更新数は
$$
O(\rho |E|)
$$
となる。
ここで $|E|$ は接続数である。
$\rho \ll 1$を維持できれば、高密度計算より更新回数を減らせる。
ただし、GPU上の密行列としてSNNをシミュレーションした場合、この利点は失われることがある。
SNNの省電力性は、スパース性を実際に利用できる実装とハードウェアがあって初めて成立する。
5.2 時間情報が内部状態に存在する
LIFニューロンは、過去の入力を膜電位に蓄積する。
$$
u[t] = \beta u[t-1] + I[t]
$$
展開すると、
$$
u[t] = \sum_{k=0}^{t} \beta^{t-k}I[k]
$$
となる。
これは、膜電位が過去入力の指数移動和として働くことを示す。
つまりSNNは、明示的に過去フレームをすべて保持しなくても、時系列情報を状態へ圧縮できる。
ロボットにおける、
- 物体速度
- 接触の継続
- 滑り
- 振動
- 運動方向
- センサー入力の時間差
のような時間変化を、履歴フレームを並べずに表現できる。
5.3 イベントカメラとの整合性
イベントカメラは、各画素の輝度変化が閾値を超えたときにイベントを出力する。
典型的には、イベントを
$$
e_k=(x_k,y_k,t_k,p_k)
$$
として表現する。
- $(x_k,y_k)$：画素位置
- $t_k$：イベント時刻
- $p_k$：輝度変化の極性
通常のカメラがフレーム全体を周期的に出力するのに対し、イベントカメラは変化した画素だけを非同期に出力する。
Frame Camera:
時刻ごとに画像全体を送信
Event Camera:
変化が起きた画素だけを送信
イベントカメラの出力は、SNNのスパイク表現と自然に対応する。
$$
\text{Sensor Event}
\rightarrow
\text{Spike}
\rightarrow
\text{Neural Dynamics}
\rightarrow
\text{Motor Event}
$$
この経路を維持できれば、センサー入力を一度フレームへ変換し、その後再び時系列処理するような冗長性を減らせる。
イベントベース視覚とSNNの組み合わせは、Visual Place Recognition、Optical Flow、SLAM、物体検出などで研究されている。
5.4 反射的制御と高次推論を分離できる
現在のVLAでは、意味理解と行動生成を一つの巨大モデルに統合する方向が強い。
しかし、生物の神経系では、すべての運動が意識的な言語推論を経由するわけではない。
例えば、
- 熱いものから手を離す
- 体勢を立て直す
- 接触力を調整する
- 移動物体を追跡する
といった処理は、高次推論より短い時間スケールで行われる。
SNNを使えば、次のような階層を構成できる。
┌─────────────────────────────┐
│ Semantic Planner │
│ Language / Task Reasoning │
│ 数百ms〜数秒 │
└──────────────┬──────────────┘
│ goal spikes / latent command
┌──────────────▼──────────────┐
│ Spiking Sensorimotor Policy │
│ 状態推定・運動生成 │
│ 数ms〜数十ms │
└──────────────┬──────────────┘
│ motor command
┌──────────────▼──────────────┐
│ Reflex / Safety Controller │
│ 接触・衝突回避 │
│ sub-ms〜数ms │
└─────────────────────────────┘
この構成では、言語モデルが毎制御周期に動作する必要はない。
高次モデルは目標や制約を低頻度で更新し、SNNが高速な閉ループ制御を担当する。
5.5 オンライン適応との親和性
実世界では環境分布が固定されない。
- ロボットの摩耗
- センサーのずれ
- 照明変化
- バッテリー電圧
- 対象物の個体差
- ユーザーごとの操作傾向
が継続的に変化する。
通常の巨大モデルをロボット上で常時ファインチューニングするのは難しい。
SNNでは、STDPなどの局所的学習則を組み込める。
代表的なSTDPでは、発火時刻差
$$
\Delta t=t_{\mathrm{post}}-t_{\mathrm{pre}}
$$
に応じて重みを更新する。
$$
\Delta w=
\begin{cases}
A_+\exp(-\Delta t/\tau_+) & \Delta t>0\
-A_-\exp(\Delta t/\tau_-) & \Delta t<0
\end{cases}
$$
これだけで大規模な意味学習ができるわけではない。
しかし、
- センサー較正
- 反射応答
- 運動パターン
- 個体差適応
- 短期的な環境適応
のような局所的な適応には使いやすい。
6. SNNによる言語処理の現状
言語処理は、現在のSNNがVLAに及ばない領域の一つだ。スパイクベースの言語モデルはすでに提案されているものの、現在のLLMと比べると規模にも性能にも大きな差がある。
6.1 SpikeGPT
SpikeGPTは、スパイキングニューロンを用いた生成言語モデルである。
RWKVに影響を受けた構造を採用し、入力トークンを逐次処理することで、系列長に対する二次計算量を避ける方向を取っている。
論文では45Mおよび216Mパラメータのモデルが学習され、ニューロモルフィックハードウェア上でスパース性を活用できる場合、演算数を大幅に削減できる可能性が報告された。
ただし、これは最新の大規模LLMと同等の言語性能を達成したことを意味しない。
この研究の意義は、スパイクベースでも生成言語モデルを構成できると示した点にある。最新LLMの代替と捉えるのは早い。
6.2 Spikformer
Spikformerは、TransformerとSNNを組み合わせた代表的研究である。
通常のSelf-AttentionではSoftmaxと高密度な積和演算が用いられる。
Spikformerでは、スパイク形式のQuery、Key、Valueを用いたSpiking Self-Attentionを導入し、Softmaxを使わない注意機構を構成した。
初期のSpikformerは、ImageNet上で直接学習されたSNNとして高い性能を示した。
Spikformer V2では、ImageNetで80%を超えるTop-1精度が報告されている。
これは、SNNが単純な小規模分類器に限定されず、比較的大規模な視覚バックボーンへ発展可能であることを示している。
6.3 Spikingformer
SNNを名乗るモデルでも、内部に浮動小数点の積和演算が多く残っている場合がある。
Spikingformerは、Residual Connectionに起因する非スパイク演算に注目し、より純粋なイベント駆動構造を目指した。
論文では、従来のSpikformerに対して非スパイク演算を抑え、推定されたエネルギー消費を削減したと報告している。
活性化関数をスパイクへ置き換えるだけでは、モデル全体はイベント駆動にならない。次の要素も含めた設計が必要になる。
- 正規化
- Residual Connection
- Attention
- Embedding
- Readout
- Memory Access
7. SNNを導入する3つの段階
「代替」が指す範囲は曖昧なので、ここでは3段階に分ける。
7.1 一部のモジュールへ導入する
まずは、VLAの知覚・制御モジュールの一部だけにSNNを導入する。
RGB / Event Camera
↓
Spiking Vision Encoder
↓
Language-Conditioned Policy
↓
Spiking Motor Controller
例えば、
- イベントカメラ処理
- Optical Flow
- 物体追跡
- 接触検出
- 低レベル制御
- 衝突回避
をSNNで担当し、意味推論には既存VLMを使う。
これは完全な代替ではなく、VLAとSNNのハイブリッド構成である。
7.2 全経路をスパイクベースで実装する
次の段階では、Vision、Language、Actionの全経路をスパイクベースで構成する。
Visual Spikes ──┐
├── Spiking Multimodal Backbone
Language Spikes ┘
↓
Spiking Action Decoder
↓
Motor Commands
このときの方策を、
$ \pi_{\theta}^{\mathrm{spike}}: (S^{V}{\leq t},S^{L})$ $\to S^{A}{t:t+H}$
と表せる。
- $S^V$：視覚スパイク列
- $S^L$：言語を符号化したスパイク列
- $S^A$：行動スパイク列
- $H$：行動予測ホライズン
最終的な連続行動は、スパイク列をデコードして得る。
$$
a_t = D\left(S^A_{t:t+\Delta}\right)
$$
例えば発火率を利用するなら、
$$
a_{t,k}=a_k^{\min}+\left(a_k^{\max}-a_k^{\min}\right)\frac{1}{\Delta}
\sum_{\tau=t}^{t+\Delta}
s_k[\tau]
$$
のように関節速度やトルクへ変換できる。
7.3 エージェント設計そのものを変える
さらに進めるなら、Vision・Language・Actionを一つの巨大なトークンモデルへ入力する構成自体を見直す。
VLAでは、しばしば異なるモダリティを共通トークン空間へ射影する。
$$
z^V,z^L,z^A \in \mathbb{R}^d
$$
一方、SNNベースの身体知能では、すべてを同じ同期的トークン列へ変換する必要はない。
$$
\mathcal{E} = { e_k^{\mathrm{vision}}, e_k^{\mathrm{audio}},
e_k^{\mathrm{touch}},
e_k^{\mathrm{proprioception}},
e_k^{\mathrm{language}},
e_k^{\mathrm{motor}}
}
$$
という非同期イベントの集合として処理できる。
この場合、モデルは
$$
\frac{dh(t)}{dt} = F(h(t),\mathcal{E}(t))
$$
という連続時間動的システムとして捉えられる。
出力行動も、
$$
a(t)=G(h(t))
$$
として連続的に生成される。
これは「画像と言語を入力して行動トークンを出すモデル」よりも、
多種のイベントを受け取り、内部状態を更新し続ける身体化動的システム
に近い。
この段階では、SNNはVLAの省電力版ではなく、別のエージェント設計になる。
8. 提案：Hierarchical Spiking-VLA
筆者が最初に試すなら、完全なエンドツーエンド構成ではなく、意味推論とセンサーモーター制御を分ける。
8.1 全体構造
┌────────────────────────────────────────────┐
│ Slow Semantic System │
│ │
│ Image / Language Foundation Model │
│ - 命令理解 │
│ - タスク分解 │
│ - 物体・概念理解 │
│ - 長期計画 │
│ │
│ Update rate: 0.5〜10 Hz │
└───────────────────┬────────────────────────┘
│
│ Goal embedding
│ Constraint
│ Affordance
▼
┌────────────────────────────────────────────┐
│ Spiking Sensorimotor System │
│ │
│ Event Vision Encoder │
│ Proprioceptive Encoder │
│ Tactile Spike Encoder │
│ Recurrent Spiking Policy │
│ │
│ Update rate: Event-driven / 100〜1000 Hz │
└───────────────────┬────────────────────────┘
│
▼
┌────────────────────────────────────────────┐
│ Safety and Reflex Layer │
│ │
│ Collision avoidance │
│ Torque limit │
│ Contact reflex │
│ Emergency stop │
└───────────────────┬────────────────────────┘
│
▼
Robot
8.2 高次モデルの役割
高次モデルは、次の情報を生成する。
$$
g_t = f_{\mathrm{semantic}}
(I_t,l,m_t)
$$
- タスク目標
- 対象物
- 許可された行動
- 禁止された行動
- サブゴール
- アフォーダンス
- 終了条件
この $g_t$は、毎ミリ秒更新する必要がない。
8.3 SNN方策の役割
低レベルSNNは、
$$
h_t = F_\theta(h_{t-1},e_t,g_t)
$$
$$
a_t = G_\theta(h_t)
$$
を実行する。
ここで、
- $e_t$：時刻 (t) に到着したセンサーイベント
- $g_t$：高次モデルからの目標表現
- $h_t$：SNNの内部状態
- $a_t$：行動
である。
高次目標が変わらなくても、センサーイベントに応じてSNNは継続的に状態を更新できる。
8.4 目標情報をスパイクへ変換する
高次モデルの埋め込み $g\in\mathbb{R}^d$ は、そのままSNNへ渡すこともできるが、スパイク列へ符号化することもできる。
Rate Coding
$$
p_i[t] = \operatorname{clip} (\alpha g_i,0,1)
$$
$$
s_i[t]\sim\operatorname{Bernoulli}(p_i[t])
$$
Latency Coding
$$
\tau_i = T_{\max} - \alpha g_i
$$
値が大きい特徴ほど早く発火させる。
Population Coding
一つの連続値を複数ニューロンの集団発火で表現する。
$$
r_i(x) = \exp \left(
-\frac{(x-\mu_i)^2}{2\sigma^2}
\right)
$$
ロボットの関節角度や目標位置にはPopulation Codingが利用しやすい。
9. SNN方策をどう学習するか
SNNの大きな難しさは、発火関数が微分不可能であることだ。
$$
s[t]=H(u[t]-v_{\mathrm{th}})
$$
Heaviside関数の微分は、ほとんどすべての点で0となる。
$$
\frac{\partial H(x)}{\partial x}=0
\quad
(x\neq 0)
$$
そのままでは誤差逆伝播ができない。
9.1 Surrogate Gradient
学習時だけ、発火関数の微分を滑らかな関数で近似する。
例えば、
$$
\frac{\partial s}{\partial u}
\approx
\frac{1}
{\left(1+\alpha|u-v_{\mathrm{th}}|\right)^2}
$$
とする。
Forwardでは二値スパイクを使い、Backwardでは代理微分を使う。
class SpikeFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, membrane, threshold):
ctx.save_for_backward(membrane, threshold)
return (membrane >= threshold).float()
@staticmethod
def backward(ctx, grad_output):
membrane, threshold = ctx.saved_tensors
distance = membrane - threshold
surrogate = 1.0 / (1.0 + 10.0 * distance.abs()).pow(2)
return grad_output * surrogate, None
9.2 BPTT
時系列全体を展開してBackpropagation Through Timeを行う。
$$
\mathcal{L} = \sum_{t=1}^{T} \ell(a_t,a_t^\ast)
$$
勾配は、
$$
\frac{\partial\mathcal{L}}{\partial\theta} = \sum_t \frac{\partial\mathcal{L}}{\partial h_t}
\frac{\partial h_t}{\partial\theta}
$$
として計算される。
ただし、時間方向へ展開するため、メモリ消費が大きい。
長いロボット軌道では、
- Truncated BPTT
- State Detachment
- Temporal Chunking
- Eligibility Trace
- Local Learning
などが必要になる。
9.3 ANN-to-SNN Conversion
まず通常のANNを学習し、その後SNNへ変換する。
Train ANN
↓
Normalize activation
↓
Convert ReLU to spiking neuron
↓
Calibrate threshold
↓
Deploy SNN
利点は、既存ANNの学習資産を利用できること。
欠点は、
- 多くのタイムステップが必要
- レイテンシが増える
- 変換誤差が生じる
- 本来の時間情報を十分に活かせない
- Transformer固有演算が残る
ことである。
9.4 知識蒸留
VLAをTeacher、SNNをStudentとして学習する。
Teacher方策を
$$
\pi_T(a_t|o_t,l)
$$
SNN方策を
$$
\pi_S(a_t|e_{\leq t},l)
$$
とすると、
$$
D_{\mathrm{KL}} \left( \pi_T \parallel \pi_S \right)
$$
を最小化できる。
実際のロボットでは、行動だけでなく中間表現も蒸留したい。
- $\lambda_a \mathcal{L}_{\mathrm{action}} $
- $ \lambda_z\mathcal{L}_{\mathrm{feature}}$
- $ \lambda_s\mathcal{L}_{\mathrm{sparsity}}$
- $\lambda_e\mathcal{L}_{\mathrm{energy}}$
この方法は、
大規模VLAの意味知識を、軽量なイベント駆動方策へ圧縮する
研究として現実的である。
VLAのリアルタイム化においても、知識蒸留は重要な方向性になっている。2026年のRT-VLAでは、運転向けVLAの軽量Studentへ能力を蒸留し、Teacherに対する大幅な推論高速化が報告されている。
10. 実装してみる：最小Spiking Policy
ここではPyTorch風の最小構成を示す。
実用コードというより、構造を理解するための例である。
from __future__ import annotations
from dataclasses import dataclass
import torch
from torch import Tensor, nn
class SurrogateSpike(torch.autograd.Function):
@staticmethod
def forward(
ctx,
membrane: Tensor,
threshold: Tensor,
) -> Tensor:
ctx.save_for_backward(membrane, threshold)
return (membrane >= threshold).to(membrane.dtype)
@staticmethod
def backward(
ctx,
grad_output: Tensor,
) -> tuple[Tensor, None]:
membrane, threshold = ctx.saved_tensors
distance = membrane - threshold
alpha = 10.0
surrogate_grad = 1.0 / (1.0 + alpha * distance.abs()).pow(2)
return grad_output * surrogate_grad, None
spike_fn = SurrogateSpike.apply
class LIFLayer(nn.Module):
def __init__(
self,
input_size: int,
hidden_size: int,
beta: float = 0.95,
threshold: float = 1.0,
) -> None:
super().__init__()
self.linear = nn.Linear(input_size, hidden_size)
self.register_buffer(
"beta",
torch.tensor(beta, dtype=torch.float32),
)
self.register_buffer(
"threshold",
torch.tensor(threshold, dtype=torch.float32),
)
def forward(
self,
x: Tensor,
membrane: Tensor,
) -> tuple[Tensor, Tensor]:
current = self.linear(x)
membrane = self.beta * membrane + current
spikes = spike_fn(membrane, self.threshold)
membrane = membrane - spikes * self.threshold
return spikes, membrane
@dataclass
class SpikingPolicyState:
membrane_1: Tensor
membrane_2: Tensor
class SpikingPolicy(nn.Module):
def __init__(
self,
observation_dim: int,
goal_dim: int,
hidden_dim: int,
action_dim: int,
) -> None:
super().__init__()
self.hidden_dim = hidden_dim
self.encoder = nn.Linear(
observation_dim + goal_dim,
hidden_dim,
)
self.lif_1 = LIFLayer(
input_size=hidden_dim,
hidden_size=hidden_dim,
)
self.lif_2 = LIFLayer(
input_size=hidden_dim,
hidden_size=hidden_dim,
)
self.action_head = nn.Linear(
hidden_dim,
action_dim,
)
def initial_state(
self,
batch_size: int,
device: torch.device,
dtype: torch.dtype,
) -> SpikingPolicyState:
zeros = torch.zeros(
batch_size,
self.hidden_dim,
device=device,
dtype=dtype,
)
return SpikingPolicyState(
membrane_1=zeros.clone(),
membrane_2=zeros.clone(),
)
def forward_step(
self,
observation: Tensor,
goal_embedding: Tensor,
state: SpikingPolicyState,
) -> tuple[Tensor, SpikingPolicyState, dict[str, Tensor]]:
x = torch.cat(
[observation, goal_embedding],
dim=-1,
)
x = self.encoder(x)
spikes_1, membrane_1 = self.lif_1(
x,
state.membrane_1,
)
spikes_2, membrane_2 = self.lif_2(
spikes_1,
state.membrane_2,
)
action = torch.tanh(
self.action_head(spikes_2)
)
new_state = SpikingPolicyState(
membrane_1=membrane_1,
membrane_2=membrane_2,
)
diagnostics = {
"spike_rate_1": spikes_1.mean(),
"spike_rate_2": spikes_2.mean(),
"membrane_mean_1": membrane_1.mean(),
"membrane_mean_2": membrane_2.mean(),
}
return action, new_state, diagnostics
10.1 時系列学習
def rollout_policy(
policy: SpikingPolicy,
observations: Tensor,
goal_embedding: Tensor,
) -> tuple[Tensor, dict[str, Tensor]]:
"""
observations:
[batch, time, observation_dim]
goal_embedding:
[batch, goal_dim]
"""
batch_size, sequence_length, _ = observations.shape
state = policy.initial_state(
batch_size=batch_size,
device=observations.device,
dtype=observations.dtype,
)
actions = []
spike_rates_1 = []
spike_rates_2 = []
for t in range(sequence_length):
action, state, diagnostics = policy.forward_step(
observation=observations[:, t],
goal_embedding=goal_embedding,
state=state,
)
actions.append(action)
spike_rates_1.append(diagnostics["spike_rate_1"])
spike_rates_2.append(diagnostics["spike_rate_2"])
stacked_actions = torch.stack(actions, dim=1)
metrics = {
"spike_rate_1": torch.stack(spike_rates_1).mean(),
"spike_rate_2": torch.stack(spike_rates_2).mean(),
}
return stacked_actions, metrics
10.2 模倣学習損失
def imitation_loss(
predicted_actions: Tensor,
target_actions: Tensor,
metrics: dict[str, Tensor],
spike_regularization_weight: float = 1e-3,
) -> tuple[Tensor, dict[str, Tensor]]:
action_loss = torch.nn.functional.mse_loss(
predicted_actions,
target_actions,
)
spike_loss = (
metrics["spike_rate_1"]
+ metrics["spike_rate_2"]
)
total_loss = (
action_loss
+ spike_regularization_weight * spike_loss
)
logs = {
"loss": total_loss.detach(),
"action_loss": action_loss.detach(),
"spike_loss": spike_loss.detach(),
}
return total_loss, logs
発火率だけを最小化すると、すべてのニューロンが発火しない退化解になる可能性がある。
したがって、実際には目標発火率 $\rho^\ast$を設定して、
$$
\mathcal{L}_{\mathrm{rate}} = \left|
\rho-\rho^\ast
\right|
$$
とする方法もある。
11. イベントカメラ入力をどう扱うか
イベント列は、
$$
E={(x_k,y_k,t_k,p_k)}_{k=1}^{K}
$$
として与えられる。
SNNへ直接投入する方法以外に、一定時間窓ごとにテンソル化する方法がある。
11.1 Event Count
$$
V(x,y,p) = \sum_k
\mathbf{1}\left[
x_k=x,;
y_k=y,;
p_k=p
\right]
$$
単純だが、細かい時刻情報が失われる。
11.2 Voxel Grid
時間を $B$ 個のビンへ分割する。
$$
V(x,y,b,p) = \sum_k
\mathbf{1}\left[
x_k=x,;
y_k=y,;
b(t_k)=b,;
p_k=p
\right]
$$
通常のCNNやSpiking CNNへ入力しやすい。
11.3 直接イベント駆動
イベントが到着するたびに、対応する入力ニューロンを発火させる。
for event in event_stream:
x, y, timestamp, polarity = event
input_spikes = encode_event(
x=x,
y=y,
polarity=polarity,
)
output_spikes, state = network.step(
input_spikes,
state,
timestamp,
)
理想的にはこの方式が最もSNNらしい。
しかし、一般的なGPUでは細粒度な非同期処理が非効率になることがある。
12. SNNの省電力性を評価する
SNN論文では、「MACよりACが低消費電力」という説明がよく使われる。
- MAC：Multiply-Accumulate
- AC：Accumulate
通常のANNでは、
$$
y \leftarrow y + wx
$$
という乗算と加算を行う。
二値スパイク ($s\in{0,1}$) であれば、
$$
y \leftarrow y + ws
$$
なので、$s=1$ のときだけ重みを加算できる。
しかし、この説明だけでは不十分である。
12.1 評価項目
評価項目は次のように分ける。
演算数
$$
N_{\mathrm{MAC}},
\quad
N_{\mathrm{AC}}
$$
発火率
$$
\rho = \frac{\text{Number of spikes}}
{\text{Number of neurons}\times T}
$$
メモリアクセス
$$
N_{\mathrm{DRAM}},
\quad
N_{\mathrm{SRAM}}
$$
消費エネルギー
$$
E_{\mathrm{total}} = E_{\mathrm{compute}}
+
E_{\mathrm{memory}}
+
E_{\mathrm{communication}}
+
E_{\mathrm{control}}
$$
レイテンシ
- 平均レイテンシ
- P95
- P99
- Worst-case latency
実タスク性能
- Success Rate
- Completion Time
- Collision Rate
- Action Smoothness
- Recovery Rate
12.2 GPUシミュレーションの落とし穴
PyTorch上でSNNを実装すると、スパイクが0でも高密度テンソル演算が実行される場合がある。
current = weight @ spikes
spikesの大半が0でも、Dense GEMMを呼べば計算量はほぼ変わらない。
したがって、
GPU上でSNNを動かしたがANNより遅かった
という結果は、SNNの原理そのものを否定しない。
逆に、
理論上ACが少ないので省電力である
だけでも不十分である。
実際のニューロモルフィックハードウェア上で、
- ネットワーク全体
- センサーI/O
- データ転送
- ホストCPU
- デコード処理
を含めて測定する必要がある。
ニューロモルフィック計算は、連続動作、イベント駆動通信、サイズ・重量・電力制約のある用途で注目されている一方、商用展開にはソフトウェア、ベンチマーク、ハードウェア統合などの課題が残る。
13. VLAとSNNの比較ベンチマーク
精度だけを比較してはいけない。
ロボット向けモデルであれば、少なくとも以下の多目的評価が必要である。
13.1 タスク成功率
$$
\mathrm{SuccessRate} = \frac{N_{\mathrm{success}}}
{N_{\mathrm{trials}}}
$$
13.2 エネルギー当たり成功率
$$
\mathrm{SuccessPerJoule} = \frac{N_{\mathrm{success}}}
{E_{\mathrm{total}}}
$$
13.3 時間当たり成功率
$$
\mathrm{SuccessPerSecond} = \frac{N_{\mathrm{success}}}
{T_{\mathrm{total}}}
$$
13.4 反応レイテンシ
危険イベント発生から行動開始までを測る。
$$
L_{\mathrm{reaction}} = t_{\mathrm{action}} - t_{\mathrm{event}}
$$
13.5 制御ジッタ
$$
J = \sqrt{
\frac{1}{N}
\sum_{i=1}^{N}
(\Delta t_i-\overline{\Delta t})^2
}
$$
平均レイテンシが低くてもジッタが大きいと、制御は不安定になり得る。
13.6 行動の滑らかさ
Jerkを用いるなら、
$$
\mathrm{JerkCost} = \int \left|
\frac{d^3q(t)}{dt^3}
\right|^2dt
$$
を評価できる。
13.7 OOD汎化
- 未知物体
- 未知背景
- 未知照明
- 未知速度
- センサー欠損
- 指示表現の言い換え
- ロボット形態の違い
を評価する。
VLAのOOD汎化については、モデルや行動表現、タスク複雑性に強く依存し、現在も十分に解決された問題ではない。
13.8 Pareto Frontier
単一スコアではなく、
$$
(
\text{Success Rate},
\text{Energy},
\text{Latency},
\text{Model Size}
)
$$
のPareto Frontierを比較すべきである。
高精度・高消費電力なVLA
低精度・超低消費電力なSNN
中間的なHybrid Model
のどれが優れているかは、用途によって異なる。
14. SNNがVLAより有利になりやすい領域
SNNがすべてのロボットタスクで有利とは限らない。
特に有望なのは、次の条件を持つ領域である。
14.1 高速イベントが重要
- Drone
- Autonomous Racing
- 高速把持
- 動的物体追跡
- 衝突回避
- 高速Visual Servoing
14.2 電力制約が厳しい
- 小型移動ロボット
- ウェアラブルロボット
- 義肢
- 長時間稼働センサー
- 宇宙ロボット
- バッテリー駆動ドローン
14.3 通信が不安定
- 災害現場
- 地下
- 海中
- 宇宙
- 遠隔地
- 工場内の閉域環境
クラウドVLAに依存せず、オンデバイスで制御を完結する価値が高い。
14.4 時系列センサーが中心
- Event Camera
- Tactile Sensor
- Neuromorphic Auditory Sensor
- IMU
- Force/Torque Sensor
- Proprioception
14.5 継続的なオンライン適応が必要
- ユーザーごとに異なる義肢
- 摩耗するロボット
- 環境が変化する農業ロボット
- 個体差が大きいソフトロボット
15. 逆に、SNNが不利な領域
SNNを過度に持ち上げるべきではない。
15.1 大規模言語理解
現在のSNNは、最先端LLMと同等の、
- 長文理解
- 高度な推論
- コード生成
- 世界知識
- In-context Learning
を実現していない。
SpikeGPTなどは重要な研究だが、最新LLMの代替にはまだ距離がある。
15.2 大規模事前学習の方法論
Transformerには、
- 大規模分散学習
- Tensor Parallelism
- Pipeline Parallelism
- FlashAttention
- Quantization
- LoRA
- MoE
- 成熟したGPUカーネル
という巨大な技術資産がある。
SNNでは同程度に成熟した学習基盤がまだ整っていない。
15.3 時間展開による学習コスト
SNNは推論時に省電力でも、学習時にはBPTTによって高コストになることがある。
$$
\text{Activation Memory}
\propto
T \times L \times N
$$
- $T$：タイムステップ
- $L$：層数
- $N$：ニューロン数
SNNの学習が自動的に低コストになるわけではない。
15.4 ニューロモルフィックハードウェア依存
SNNの利点は、GPU上では十分に発揮されないことがある。
その一方で、専用ハードウェアは、
- 入手性
- ツールチェーン
- 対応演算
- デバッグ
- モデル変換
- メモリ容量
- ベンダーロックイン
に制約がある。
15.5 発火率の制御
発火率が高すぎると、省電力性が失われる。
$$
\rho \rightarrow 1
$$
なら、ほぼすべてのニューロンが常時発火し、イベント駆動の利点が小さくなる。
一方、発火率を下げすぎると情報伝達が不足する。
$$
\rho \rightarrow 0
$$
したがって、
$$
\text{Accuracy}
\quad\text{vs.}\quad
\text{Spike Sparsity}
$$
のトレードオフを最適化する必要がある。
16. 生物らしさと工学的性能は別である
SNNを語る際、よくある誤解がある。
人間の脳がスパイクを使っているため、SNNは必ずANNより優れている。
これは論理的に正しくない。
生物学的妥当性と工学的性能は別である。
飛行機は鳥と同じ羽ばたき方をしなくても飛べる。
同様に、知能を実現するために脳を完全に模倣する必要はない。
SNNを評価すべき理由は、
- イベント駆動
- 状態保持
- 時間処理
- 通信スパース性
- 専用ハードウェア
- 局所学習
- 実時間システムとの整合性
という工学的性質にある。
「脳らしいから」ではなく、ロボットに必要な制約へ適合するから検討するべきである。
17. Transformerとの組み合わせ
既存のTransformerを捨てる必要はない。現在の研究は、主に次の3方向に分けられる。
17.1 Transformerをスパイク化する
Spikformerのように、Transformerの表現力を維持しつつ、スパイクベースの計算へ変換する。
利点：
- 既存Transformer研究を利用できる
- 大域的な依存関係を扱いやすい
- VLAとの接続が容易
欠点：
- Transformer固有の高密度演算が残りやすい
- SoftmaxやNormalizationがハードウェアに適さない
- 真のイベント駆動性が損なわれる場合がある
17.2 Attention-FreeなSNN
Attentionを使わず、
- Recurrent Dynamics
- State Space
- Fourier Transform
- Wavelet Transform
- Local Connectivity
を利用する。
Attention-free Spikformerでは、Spiking Self-Attentionを固定の線形変換へ置き換え、視覚タスクにおける計算・メモリ効率化を報告している。
17.3 トークン処理から動的システムへ移る
最も挑戦的なのは、トークン処理という発想から離れることである。
$$
\dot{h}(t) = F_\theta(h(t),e(t),g(t))
$$
という連続時間のイベント駆動システムを構築する。
この場合、Attention Mapや固定長トークン列が中心ではなく、
- アトラクタ
- 発火同期
- 神経振動
- 局所回路
- 階層的時定数
- シナプス可塑性
が計算の中心になる。
これは既存VLAの高速化ではなく、身体知能の再定義に近い。
18. 実験につながる研究テーマ
ここまでの議論から、実験に落とし込みやすいテーマを挙げる。
18.1 VLA-to-SNN Policy Distillation
問い
巨大VLAの行動知識を、イベント駆動SNNへどこまで蒸留できるか。
方法
- OpenVLAなどをTeacherとして利用
- RGB画像とイベントデータを同期取得
- Teacherの行動分布を生成
- SNN Studentへ蒸留
- 実機上で電力・遅延・成功率を比較
損失
- $\mathcal{L}_{\mathrm{BC}}$
- $ \lambda_1\mathcal{L}_{\mathrm{KD}}$
- $ \lambda_2\mathcal{L}_{\mathrm{spike}}$
- $\lambda_3\mathcal{L}_{\mathrm{temporal}}$
18.2 Language-Conditioned Spiking Policy
問い
言語埋め込みによって、SNNのアトラクタや発火パターンを切り替えられるか。言語埋め込みを (g) とすると、ニューロンダイナミクスを
$$
u[t] = \beta(g)\odot u[t-1] + W(g)s[t] + I[t]
$$
と条件付けする。
言語によって、
- 閾値
- 時定数
- シナプスゲート
- 初期膜電位
- 発火抑制
- 行動Readout
を変化させる。
18.3 Multi-timescale SNN
ロボット内の処理は、同じ時間スケールでは動かない。
各層で異なる減衰率を使う。
$$
u_l[t] = \beta_lu_l[t-1]+I_l[t]
$$
例えば、
Layer 1:
β = 0.5
高速な変化を処理
Layer 2:
β = 0.9
運動パターンを処理
Layer 3:
β = 0.99
長期状態を保持
とする。
異なる時定数を持たせることで、反射とサブゴールを同じモデル内で扱う。
18.4 Event-Based World Model
VLAの代わりに、イベントベースの世界モデルを構築する。
$$
p_\theta
(
e_{t+1},
r_t
\mid
h_t,a_t
)
$$
内部状態を、
$$
h_{t+1} = F_\theta(h_t,e_t,a_t)
$$
で更新する。
予測誤差が大きいイベントだけを処理する構造にすれば、Predictive Codingとの接続も可能である。
18.5 Neuromorphic Diffusion Policy
Diffusion PolicyやFlow Matchingはロボット行動生成で強力だが、反復推論を必要とする。
そこで、
- ノイズ除去過程をスパイクダイナミクスとして表現する
- 膜電位の緩和を生成過程として利用する
- 発火タイミングで行動軌道を表現する
という研究が考えられる。
例えば、
$$
u^{k+1} = u^k - \eta\nabla_uE_\theta(u^k,c) + \xi^k
$$
という反復更新を、リカレントSNNの状態緩和へ対応づける。
18.6 Safety-Critical Spiking Reflex
VLAが生成した行動をSNN反射層が監視する。
$$
a_t^{\mathrm{safe}} = a_t^{\mathrm{VLA}} + \Delta a_t^{\mathrm{SNN}}
$$
危険イベントがなければ、
$$
\Delta a_t^{\mathrm{SNN}}=0
$$
危険を検出したときのみ、
$$
\Delta a_t^{\mathrm{SNN}}\neq 0
$$
とする。
SNNは常時大きな修正を行うのではなく、イベント発生時だけ介入する。
18.7 Cross-Embodiment Spiking Representation
異なるロボット間で、関節角度そのものではなく、
- 接触イベント
- 速度変化
- 位相
- 力覚パターン
- アフォーダンス
をスパイク表現として共有できるかを調べる。
これはOpen X-Embodimentのような多ロボットデータと接続できる。
19. 実験計画の具体例
最初の実験には、言語条件付きPick-and-Placeが扱いやすい。
タスク
言語条件付きのPick-and-Place。
命令:
「赤いブロックを左の箱へ入れて」
比較モデル
Baseline A
通常のMLPまたはRNN方策。
Baseline B
Transformer Policy。
Baseline C
OpenVLAまたは軽量VLA。
Proposed A
LIFベースRecurrent SNN。
Proposed B
Spiking Transformer。
Proposed C
VLM Planner + SNN Controller。
入力
- RGB
- Event Camera
- Joint State
- Gripper State
- Language Embedding
評価指標
Task Success Rate
Energy per Episode
Mean Inference Latency
P99 Inference Latency
Reaction Latency
Collision Rate
Spike Rate
Memory Usage
Action Smoothness
Robustness to Frame Drop
Robustness to Lighting Change
アブレーション
[ ] RGB only
[ ] Event only
[ ] RGB + Event
[ ] No language condition
[ ] Fixed language embedding
[ ] Dynamic language modulation
[ ] Single time constant
[ ] Multi-timescale neuron
[ ] No spike regularization
[ ] Spike regularization
[ ] Direct training
[ ] Distillation
[ ] ANN-to-SNN conversion
20. 期待される失敗
実装前に、起こりそうな失敗と対策も整理しておく。
20.1 SNNの発火率が高くなる
原因：
- 入力正規化不足
- 閾値が低い
- 膜電位減衰が遅い
- スパイク正則化不足
- Denseな言語埋め込み
対策：
- Adaptive Threshold
- Homeostatic Regularization
- Activity Penalty
- Sparse Goal Coding
- Threshold Calibration
20.2 行動が不連続になる
二値スパイクを直接行動へ変換すると、出力が不安定になる可能性がある。
対策として
$$
a_t = \alpha a_{t-1}
+
(1-\alpha)\hat{a}_t
$$
による平滑化、Population Coding、膜電位Readout、低域通過フィルタを使う。
20.3 長期命令を忘れる
膜電位だけでは、長い時間スケールの命令保持が難しい可能性がある。
対策：
- Slow Neuron
- Adaptive LIF
- Recurrent Memory
- 外部メモリ
- 高次モデルからの周期的Goal Refresh
- シナプス状態による保持
20.4 GPU上では速くならない
これは十分に起こり得る。
対策：
- Sparse Kernel
- Event Batch
- Custom CUDA Kernel
- Neuromorphic Hardware
- FPGA
- 非同期実行
- タイムステップ削減
20.5 SNN StudentがTeacherの意味能力を継承できない
行動出力だけを蒸留すると、Teacherの内部知識は失われる可能性がある。
対策
$$
\mathcal{L}_{\mathrm{feature}} = \sum_l \left| P_l(h_l^{S}) - h_l^{T} \right|^2
$$
による中間特徴蒸留や、アフォーダンス・サブゴール・価値関数を補助教師として与える。
21. VLAとSNNの役割分担
VLAの大規模な意味知識と、SNNのイベント駆動・時間処理は補完関係にある。
VLA:
「何をすべきか」を理解する
SNN:
「いつ、どのように反応するか」を処理する
SNN単独で基盤モデルを構成するなら、少なくとも次の要素を統合しなければならない。
- 視覚
- 言語
- 行動
- 世界モデル
- 記憶
- オンライン学習
22. SNNがVLAを代替するために必要なブレークスルー
全面的な代替を目指す場合、次の課題が残る。
22.1 スパイクベース大規模事前学習
現在のLLMに相当する規模で、
- 安定して学習できる
- 並列化できる
- 長系列を扱える
- 学習コストが現実的
- スパース性を維持できる
手法が必要である。
22.2 スパイクベース言語表現
単語を単にRate Codingするだけでは、SNNの利点が薄れる可能性がある。
- 発火時刻
- 位相
- 集団符号化
- イベント列
- 構文構造
- 階層的時間スケール
を活用した言語表現が必要である。
22.3 ニューロモルフィック向け学習アルゴリズム
推論だけでなく学習もデバイス上で行うには、
- Local Learning
- Eligibility Trace
- Three-Factor Learning Rule
- Forward-Only Learning
- Equilibrium-Based Learning
- Online Distillation
などが重要になる。
22.4 ソフトウェアスタック
CUDAに相当する成熟した環境が必要である。
理想的には、
High-level Model Definition
↓
Spike Graph Compiler
↓
Hardware-aware Optimization
↓
Neuromorphic Runtime
↓
Robot Middleware
という流れが必要になる。
ROS 2、シミュレータ、イベントカメラ、ニューロモルフィックチップを一貫して扱えることが望ましい。
22.5 公平なベンチマーク
ANNに有利な静止画像分類だけではなく、
- 非同期イベント
- 低電力
- 長時間動作
- 動的環境
- センサー欠損
- 高速反応
- オンライン適応
を含むベンチマークが必要である。
23. 省電力性が成立する条件
SNNへ置き換えるだけでは、高速化も省電力化も保証されない。精度を維持できるかどうかも別の問題である。
実際には、
$$
\text{Benefit} = f(
\text{Spike Rate},
\text{Time Steps},
\text{Topology},
\text{Hardware},
\text{Memory},
\text{Encoding},
\text{Task}
)
$$
で決まる。
特にタイムステップ数 $T$ が大きいと、SNNの計算量は増える。
$$
C_{\mathrm{SNN}}
\propto
T\rho|E|
$$
したがって、
$$
T\rho
$$
が十分小さいことが重要になる。
Spikformer V2が少ないタイムステップで高い画像分類性能を目指しているのも、この問題と関係する。
24. 結論
SNNがVLAを全面的に置き換える段階には、まだ達していない。大規模な意味理解、Web知識の転移、多タスクの命令追従では、VLAが大きく先行している。
一方、VLAだけですべての制御周期を担う必要もない。言語によるタスク分解は低頻度で実行し、物体追跡、接触検出、反射制御はイベント駆動のSNNへ任せる。この分担なら、それぞれの得意な時間スケールを活かせる。
したがって、当面の研究対象として有望なのは「完全なSpiking VLA」よりも、次のような階層構成だ。
VLM / VLAによる意味推論（低頻度）
↓ 目標・制約
SNNによる知覚と運動制御（高頻度）
↓
安全制御・ロボット
評価では、タスク成功率だけで結論を出さない。実機上でエネルギー、反応レイテンシ、P99レイテンシ、制御ジッタ、発火率まで測る必要がある。SNNの利点は、モデル名ではなく、この測定結果で判断すべきだ。
参考文献
Vision-Language-Action
- Brohan et al., RT-1: Robotics Transformer for Real-World Control at Scale, 2022.
- Brohan et al., RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control, 2023.
- Kim et al., OpenVLA: An Open-Source Vision-Language-Action Model, 2024.
- Black et al., $\pi_0$: A Vision-Language-Action Flow Model for General Robot Control, 2024.
- Vision-Language-Action Models: Concepts, Progress, Applications and Challenges, 2025.
Spiking Neural Network
- Zhou et al., Spikformer: When Spiking Neural Network Meets Transformer, ICLR 2023.
- Zhou et al., Spikformer V2: Join the High Accuracy Club on ImageNet with an SNN Ticket, 2024.
- Zhou et al., Spikingformer: Spike-driven Residual Learning for Transformer-based Spiking Neural Network, 2023.
- Zhu et al., SpikeGPT: Generative Pre-trained Language Model with Spiking Neural Networks, 2023.
- Wang et al., Attention-free Spikformer: Mixing Spike Sequences with Simple Linear Transforms, 2023.
- Kudithipudi et al., Neuromorphic Computing at Scale, Nature, 2025.
- Muir et al., The Road to Commercial Success for Neuromorphic Technologies, Nature Communications, 2025.