コンテンツにスキップ

EvoSpikeNet 推論パイプライン 実装計画

[!NOTE] 最新の実装状況は 機能実装ステータス (Remaining Functionality) を参照してください。

対象バージョン: EvoSpikeNet v4.0
作成日: 2026-04-01
著者: Masahiro Aoki / Moonlight Technologies Inc.

目次

  1. 概要・目的
  2. システム全体アーキテクチャ
  3. モジュール構成
  4. 推論パイプライン詳細
  5. 4.1 テキスト推論シーケンス
  6. 4.2 マルチモーダル推論シーケンス
  7. 4.3 RAG 推論シーケンス
  8. 4.4 分散ブレイン推論シーケンス
  9. 起動・設定
  10. 5.1 環境変数一覧
  11. 5.2 設定ファイル構造
  12. 5.3 起動手順
  13. API エンドポイント一覧
  14. TAS エンコーディング詳細
  15. メモリ・キャッシュ管理
  16. 実装チェックリスト（TODO）
  17. 今後の拡張計画

1. 概要・目的

EvoSpikeNet は スパイキングニューラルネットワーク (SNN) をコアとした大規模進化型 AI フレームワークです。
本ドキュメントは学習後のモデルを用いて テキスト / 画像 / 音声 / EEG などのマルチモーダル入力に対して推論結果を返す「大規模 AI 推論サービス」としての実装計画を記述します。

設計原則

原則 内容
スパイク駆動 TAS エンコーディング (特許 MT25-EV002) によりすべての入力をスパイク列に変換
マルチモーダル統合 テキスト・画像・音声エンコーダを Fusion 層で統合
分散推論 Zenoh メッセージングによるマルチノード分散処理
RAG 拡張 VectorDB アダプタ切替（InMemory / FAISS / Milvus / Chroma / Qdrant）+ 知識検索拡張生成
非同期パイプライン AsyncPipeline による並列バッチ処理

2. システム全体アーキテクチャ

graph TB
    subgraph "入力レイヤー"
        P[プロンプト<br/>テキスト]
        I[画像<br/>Image]
        A[音声<br/>Audio/MFCC]
        E[EEG 信号]
        W[WebSocket<br/>リアルタイム]
    end

    subgraph "API サーバー (FastAPI :8000)"
        GW[API Gateway<br/>セキュリティ/レート制限<br/>api.py]
        GEN[テキスト生成<br/>POST /api/generate]
        MM[マルチモーダル<br/>POST /api/multimodal]
        RAG2[RAG クエリ<br/>POST /api/rag/query]
        MEM[メモリ操作<br/>/api/memory/*]
        PIP[パイプライン<br/>/api/pipeline/submit]
    end

    subgraph "推論コア"
        TAS[TASEncoderDecoder<br/>スパイクエンコード]
        VIS[SpikingEvoVisionEncoder<br/>CNN→スパイク]
        AUD[SpikingEvoAudioEncoder<br/>MFCC→スパイク]
        FUS[Fusion Layer<br/>モダリティ統合]
        STB[SpikingTransformerBlocks<br/>LIF ニューロン処理]
        DEC[Output FC<br/>ロジット→テキスト]
    end

    subgraph "モデルクラス"
        STLM[SpikingEvoTextLM<br/>テキスト専用]
        MMLM[SpikingEvoMultiModalLM<br/>テキスト+画像+音声]
        EMBED[SNNEmbeddingModel<br/>RAG 埋め込み]
    end

    subgraph "メモリ・ストレージ"
        EPI[EpisodicMemoryNode<br/>エピソード記憶]
        SEM[SemanticMemoryNode<br/>意味記憶]
        INTEG[MemoryIntegratorNode<br/>記憶統合]
        DB[(PostgreSQL<br/>モデルアーティファクト)]
        VDB[(VectorDB Adapter<br/>InMemory/FAISS/Milvus/Chroma/Qdrant)]
        ES[(Elasticsearch<br/>全文検索)]
    end

    subgraph "分散ネットワーク"
        ZR[Zenoh Router<br/>:7447]
        N1[Brain Node<br/>prefrontal]
        N2[Brain Node<br/>hippocampus]
        N3[Brain Node<br/>cerebellum]
        N4[Brain Node<br/>motor_cortex]
    end

    subgraph "外部サービス"
        REDIS[Redis<br/>Pub/Sub]
        OPA[OPA<br/>認可ポリシー]
        RAG_SRV[RAG API Server<br/>:8001]
    end

    P --> GW
    I --> GW
    A --> GW
    E --> GW
    W --> GW

    GW --> GEN & MM & RAG2 & MEM & PIP

    GEN --> STLM
    MM  --> MMLM
    RAG2 --> RAG_SRV

    STLM --> TAS --> STB --> DEC
    MMLM --> TAS
    MMLM --> VIS
    MMLM --> AUD
    TAS & VIS & AUD --> FUS --> STB --> DEC

    EMBED --> VDB

    GEN & MM --> EPI & SEM
    EPI & SEM --> INTEG

    DB -- モデルロード --> STLM & MMLM

    GW <--> ZR
    ZR <--> N1 & N2 & N3 & N4

    GW --> REDIS
    GW --> OPA

    classDef core fill:#1a6fd6,stroke:#0d4ca0,color:#fff
    classDef model fill:#d65a1a,stroke:#a04010,color:#fff
    classDef storage fill:#1a9655,stroke:#0d6e3e,color:#fff
    classDef external fill:#9629b5,stroke:#701985,color:#fff
    class TAS,VIS,AUD,FUS,STB,DEC core
    class STLM,MMLM,EMBED model
    class EPI,SEM,INTEG,DB,VDB,ES storage
    class REDIS,OPA,RAG_SRV external

3. モジュール構成

graph LR
    subgraph "evospikenet/"
        direction TB
        API[api.py<br/>FastAPI エントリポイント]

        subgraph "api_modules/"
            T_API[training_api.py]
            RAG_API[rag_api.py]
            MEM_API[memory_api.py]
            PIP_API[pipeline_api.py]
            DIST_API[distributed_brain_api.py]
            EEG_API[eeg_api.py]
            EVO_API[evolution_api.py]
        end

        subgraph "コアモデル"
            MODELS[models.py<br/>SpikingEvoTextLM<br/>SpikingEvoMultiModalLM<br/>TransformerLM]
            ENC[encoding.py<br/>TASEncoderDecoder]
            VIS_M[vision.py<br/>SpikingEvoVisionEncoder]
            AUD_M[audio.py<br/>SpikingEvoAudioEncoder]
            ATT[attention.py<br/>SpikingTransformerBlock]
        end

        subgraph "インフラ"
            BATCH[batch_optimizer.py<br/>DynamicBatchProcessor]
            MEMM[memory_manager.py<br/>MemoryManager]
            TC[tensor_cache.py<br/>TensorCache]
            LB[load_balancer.py<br/>AILoadBalancer]
            ASYNC[async_pipeline.py<br/>AsyncPipeline]
        end

        subgraph "分散通信"
            ZENOH[zenoh_comm.py<br/>zenoh_async.py]
            DBN[distributed_brain_node.py<br/>DistributedBrainNode]
        end

        subgraph "記憶システム"
            EPIM[episodic_memory.py]
            LTMM[long_term_memory.py]
            MN[memory_nodes.py<br/>EpisodicMemoryNode<br/>SemanticMemoryNode]
        end

        subgraph "RAG"
            RAG_C[rag_client.py]
            RAG_B[rag_backends.py]
            SNN_RAG[snn_rag.py<br/>SNNEmbeddingModel]
        end
    end

    API --> api_modules/
    API --> コアモデル
    API --> インフラ
    API --> 分散通信
    API --> 記憶システム
    API --> RAG

モジュール責務一覧

ファイル クラス/関数 責務
models.py SpikingEvoTextLM テキスト専用 SNN 言語モデル（学習・推論）
models.py SpikingEvoMultiModalLM テキスト + 画像 + 音声マルチモーダル SNN
models.py TransformerLM 標準 Transformer（蒸留の教師モデル）
models.py SNNEmbeddingModel RAG 用テキスト埋め込みモデル
encoding.py TASEncoderDecoder TAS スパイクエンコード（特許 MT25-EV002）
vision.py SpikingEvoVisionEncoder 画像→スパイク変換 CSNN
audio.py SpikingEvoAudioEncoder MFCC→スパイク変換 SNN
attention.py SpikingTransformerBlock スパイク対応 Self-Attention ブロック
batch_optimizer.py DynamicBatchProcessor 動的バッチサイズ最適化
memory_manager.py MemoryManager GPU/CPU メモリ効率化
tensor_cache.py TensorCache テンソルキャッシュ（推論高速化）
load_balancer.py AILoadBalancer AI 予測型ロードバランシング
async_pipeline.py AsyncPipeline 非同期並列処理パイプライン
api_modules/training_api.py router 学習 API（バックグラウンド起動）
api_modules/rag_api.py router RAG プロキシ API
api_modules/memory_api.py router エピソード/意味記憶 API
distributed_brain_node.py DistributedBrainNode 分散ブレインノード
zenoh_async.py AsyncZenohCommunicator Zenoh 非同期通信
snn_rag.py SNNEmbeddingModel SNN ベクトル埋め込み

4. 推論パイプライン詳細

4.1 テキスト推論シーケンス

sequenceDiagram
    actor Client
    participant GW as API Gateway<br/>(api.py)
    participant SM as SecurityMiddleware<br/>RateLimiter / OPA
    participant BP as DynamicBatchProcessor
    participant MM as MemoryManager
    participant LM as SpikingEvoTextLM
    participant TAS as TASEncoderDecoder
    participant STB as SpikingTransformerBlocks
    participant LIF as LIFNeuronLayer (lif_out)
    participant FC as output_fc (Linear)
    participant TOK as BertTokenizer
    participant DB as PostgreSQL<br/>(DataArtifact)
    participant EMN as EpisodicMemoryNode

    Note over DB,LM: 起動時: load_model_and_tokenizer() (background thread)
    DB -->> LM: checkpoint.pth (state_dict)
    DB -->> TOK: tokenizer_state / bert-base-uncased

    Client->>GW: POST /api/generate<br/>{"prompt": "...", "max_length": 100}
    GW->>SM: セキュリティ検証
    SM-->>GW: OK (API Key / Rate 通過)

    GW->>TOK: tokenize(prompt)
    TOK-->>GW: prompt_tokens: Tensor[1, seq_len]

    GW->>BP: process_batch(prompt_tokens, inference_func)
    BP->>MM: optimize_tensor_memory(prompt_tokens)
    MM-->>BP: 最適化済みテンソル

    loop max_new_tokens 回
        BP->>LM: model.generate(prompt_tokens, max_new_tokens)
        LM->>TAS: encode(tokens)<br/>λ=σ(E), φ=pos×Δφ → spike_trains[batch, time, seq, dim]
        TAS-->>LM: spike_trains

        loop SpikingTransformerBlock × N
            LM->>STB: forward(spike_trains)
            STB-->>LM: processed_spikes
        end

        LM->>LIF: reset(batch*seq), forward(spike_trains_flat[step])
        LIF-->>LM: output_spikes (sum over time = rate code)

        LM->>FC: linear(output_potential_sum)
        FC-->>LM: logits[batch, seq, vocab_size]

        LM->>LM: softmax + multinomial sampling (temperature, top_k)
    end

    LM-->>GW: generated_tokens[1, seq_len + max_new_tokens]
    GW->>TOK: decode(generated_tokens, skip_special_tokens=True)
    TOK-->>GW: generated_text: str

    GW->>BP: optimize_tensor_memory(generated_tokens)
    GW->>EMN: store_episodic_memory(generated_text)

    GW-->>Client: {"generated_text": "...", "prompt": "..."}

4.2 マルチモーダル推論シーケンス

sequenceDiagram
    actor Client
    participant GW as API Gateway
    participant MM_LM as SpikingEvoMultiModalLM
    participant TAS as TASEncoderDecoder<br/>(テキスト)
    participant VIS as SpikingEvoVisionEncoder<br/>(CSNN)
    participant AUD as SpikingEvoAudioEncoder<br/>(SNN)
    participant FUS as Fusion Layer<br/>(Linear + LayerNorm)
    participant STB as SpikingTransformerBlocks
    participant DEC as Output FC

    Client->>GW: POST /api/multimodal<br/>text + image (base64) + audio (base64)

    Note over GW: 画像: base64 → PIL → Tensor[B,C,H,W]<br/>音声: base64 → waveform → MFCC Tensor[B,T,13]

    par テキストエンコード
        GW->>TAS: encode(token_ids)
        TAS-->>MM_LM: text_spikes[batch, time, seq, dim]
    and 画像エンコード
        GW->>VIS: forward(image_tensor)
        Note over VIS: conv1→LIF1→pool1<br/>conv2→LIF2→pool2<br/>flatten→fc_lif
        VIS-->>MM_LM: image_spikes[batch, time, dim]
    and 音声エンコード
        GW->>AUD: forward(mfcc_tensor)
        AUD-->>MM_LM: audio_spikes[batch, time, dim]
    end

    MM_LM->>FUS: concat([text_spikes, image_spikes, audio_spikes])
    FUS->>FUS: Linear projection + LayerNorm
    FUS-->>STB: fused_spikes[batch, time, seq, dim]

    loop SpikingTransformerBlock × N
        STB->>STB: SpikingMultiHeadAttention + SNN-FFN
    end

    STB-->>DEC: processed_spikes
    DEC->>DEC: rate-code decode → logits
    DEC-->>GW: generated_text

    GW-->>Client: {"generated_text": "...", "modalities_used": ["text","image","audio"]}

4.3 RAG 推論シーケンス

sequenceDiagram
    actor Client
    participant GW as API Gateway
    participant RAG_P as RAG Proxy<br/>(/api/rag/query)
    participant RAG_SRV as RAG API Server<br/>(:8001)
    participant EMBED as SNNEmbeddingModel
    participant VDB as VectorDB Adapter
    participant ES as Elasticsearch
    participant LM as SpikingEvoTextLM

    Note over VDB,ES: 事前: 学習データ/ドキュメントをインデックス化

    Client->>GW: POST /api/rag/documents/text<br/>{"text": "知識テキスト..."}
    GW->>RAG_SRV: forward document
    RAG_SRV->>EMBED: encode(text) → vector[768]
    EMBED->>EMBED: TASEncode → SpikingTransformer → mean pooling
    EMBED-->>RAG_SRV: embedding vector
    RAG_SRV->>VDB: upsert(id, vector, metadata)
    RAG_SRV->>ES: index(document)
    RAG_SRV-->>GW: {"status": "indexed"}
    GW-->>Client: 200 OK

    Client->>GW: POST /api/rag/query<br/>{"query": "EvoSpikeNetの学習方法は？", "k": 5}
    GW->>RAG_P: proxy request
    RAG_P->>RAG_SRV: POST /query

    RAG_SRV->>EMBED: encode(query) → query_vector
    RAG_SRV->>VDB: search(query_vector, top_k=5)
    VDB-->>RAG_SRV: retrieved_docs[5]
    RAG_SRV->>ES: fulltext_search(query)
    ES-->>RAG_SRV: es_docs

    RAG_SRV->>RAG_SRV: hybrid rerank (vector + BM25)
    RAG_SRV->>LM: generate(context + query)
    LM-->>RAG_SRV: answer_text

    RAG_SRV-->>RAG_P: {"answer": "...", "sources": [...]}
    RAG_P-->>GW: response
    GW-->>Client: RAG 強化推論結果

4.4 分散ブレイン推論シーケンス

sequenceDiagram
    actor Client
    participant API as API Server<br/>(:8000)
    participant ZR as Zenoh Router<br/>(:7447)
    participant N_PFC as BrainNode<br/>prefrontal
    participant N_HPC as BrainNode<br/>hippocampus
    participant N_CRB as BrainNode<br/>cerebellum
    participant N_MOT as BrainNode<br/>motor_cortex
    participant MEM_INT as MemoryIntegratorNode

    Client->>API: POST /api/distributed_brain/query<br/>{"prompt": "...", "nodes": ["prefrontal","hippocampus"]}

    API->>ZR: publish("evospikenet/brain/query", {prompt_id, prompt})

    par 並列ブレインノード処理
        ZR->>N_PFC: query
        N_PFC->>N_PFC: BrainSimulation.forward()<br/>→ SpikingTransformerBlock 処理
        N_PFC-->>ZR: publish("evospikenet/brain/result", {node_id, partial_result})
    and
        ZR->>N_HPC: query
        N_HPC->>N_HPC: LongTermMemoryModule 参照<br/>→ 記憶検索 + 推論
        N_HPC-->>ZR: partial_result
    and
        ZR->>N_CRB: query
        N_CRB->>N_CRB: 運動制御パターン推論
        N_CRB-->>ZR: partial_result
    end

    ZR-->>API: on_result callback (subscribe "evospikenet/api/result")
    API->>API: write result → /tmp/evospikenet_query_result_{prompt_id}.json

    API->>MEM_INT: integrate(partial_results)
    MEM_INT->>MEM_INT: EpisodicMemoryNode + SemanticMemoryNode 統合

    API-->>Client: {"merged_response": "...", "contributing_nodes": [...]}

    Note over N_PFC,N_MOT: 各ノードはZenohを介して<br/>リアルタイムに結果を共有・収束する

5. 起動・設定

5.1 環境変数一覧

変数名 デフォルト 説明
DATABASE_URL sqlite:///./evospikenet.db DB 接続文字列
EVOSPIKENET_API_KEY test-api-key API 認証キー
EVOSPIKENET_API_KEYS test-api-key カンマ区切り複数キー
EVOSPIKENET_ALLOW_NO_AUTH false 認証スキップ（開発用）
LOG_LEVEL INFO ログレベル (DEBUG/INFO/WARNING/ERROR)
DEVICE cpu 推論デバイス (cpu / cuda)
UVICORN_WORKERS 4 uvicorn ワーカー数
RAG_VECTOR_DB_BACKEND inmemory RAG ベクターDB バックエンド (inmemory / faiss / milvus / chroma / qdrant)
MILVUS_HOST milvus-standalone Milvus ホスト
ELASTICSEARCH_HOST elasticsearch Elasticsearch ホスト
RAG_API_URL http://rag-api:8001 RAG API サーバー URL
DISTRIBUTED_WS_REDIS redis://redis:6379 WebSocket Pub/Sub 用 Redis
EVOSPIKENET_OPA_URL （未設定） OPA ポリシーサーバー URL
EVOSPIKENET_OPA_ENABLED false OPA 認可を有効化
NODE_ID api_node 分散ノード識別子
ACTIVE_RANKS 0,1,2,3,4,5,6 有効なブレインノードランク

5.2 設定ファイル構造

config/
├── settings.yaml              # デフォルト設定
├── settings.development.yaml  # 開発環境オーバーライド
├── settings.staging.yaml      # ステージング環境
├── settings.production.yaml   # 本番環境
├── training_config.yaml       # 学習ハイパーパラメータ
├── connectome_config.yaml     # コネクトーム接続設定
└── node_allocation.yaml       # 分散ノード割当設定

settings.yaml 主要パラメータ:

# モデル設定
model:
  default_device: "cpu"        # cuda に変更で GPU 推論
  enable_gpu: false
  hidden_size: 256             # d_model
  num_layers: 4                # SpikingTransformerBlock 数
  num_heads: 8                 # アテンションヘッド数
  batch_size: 32

# API サーバー設定
api:
  host: "0.0.0.0"
  port: 8000
  workers: 4
  max_request_size: 104857600  # 100MB

# Zenoh 分散通信
zenoh:
  router_address: "tcp/zenoh-router:7447"
  mode: "client"

5.3 起動手順

パターン A: ローカル開発（uvicorn 直接起動）

# 1. 仮想環境セットアップ
cd /home/maoki/GitHub
source .venv/bin/activate

# 2. 依存関係インストール
cd EvoSpikeNet-Core
pip install -e ".[dev]"

# 3. DB マイグレーション
alembic upgrade head

# 4. 環境変数設定
export DATABASE_URL="sqlite:///./evospikenet_dev.db"
export EVOSPIKENET_ALLOW_NO_AUTH=true
export LOG_LEVEL=DEBUG
export DEVICE=cpu

# 5. API サーバー起動
uvicorn evospikenet.api:app \
  --host 0.0.0.0 \
  --port 8000 \
  --reload \
  --log-level debug

# → http://localhost:8000/docs で Swagger UI 確認
# → モデルは DB から自動ロード（学習済みアーティファクトが必要）

パターン B: 学習からの一連フロー

# Step 1: テキストモデル学習
python examples/train_spiking_evospikenet_lm.py \
  --source wikipedia \
  --page "Artificial_intelligence" \
  --lang en \
  --epochs 10 \
  --d-model 256 \
  --n-heads 4 \
  --num-blocks 4 \
  --run-name my_model_v1 \
  --upload-to-db

# Step 2: マルチモーダルモデル学習
python examples/train_multi_modal_lm.py \
  --csv data/captions.csv \
  --img-dir data/images/ \
  --epochs 5 \
  --run-name multimodal_v1

# Step 3: 推論サーバー起動
uvicorn evospikenet.api:app --host 0.0.0.0 --port 8000

# Step 4: テキスト生成テスト
curl -X POST http://localhost:8000/api/generate \
  -H "Content-Type: application/json" \
  -H "X-API-Key: test-api-key" \
  -d '{"prompt": "スパイキングニューラルネットワークとは", "max_length": 100}'

# Step 5: スクリプト直接生成
python examples/run_spiking_lm_generation.py \
  --run-name my_model_v1 \
  --prompt "AIの未来について" \
  --max-new-tokens 100 \
  --temperature 0.8 \
  --top-k 40

パターン C: Docker Compose（フル環境）

# GPU 環境（CUDA 推論）
docker-compose -f docker-compose.gpu.yml up -d

# CPU のみ環境
docker-compose -f docker-compose.cpu-only.yml up -d

# 分散ブレイン環境（マルチノード）
docker-compose -f docker-compose.distributed.yml up -d

# サービス確認
docker-compose ps
# evospikenet-api       :8000  (FastAPI)
# evospikenet-frontend  :8050  (Dash UI)
# evospikenet-postgres  :5432
# evospikenet-redis     :6379
# evospikenet-zenoh-router :7447
# milvus-standalone     :19530
# elasticsearch         :9200
# rag-api               :8001

パターン D: 推論スクリプト単体実行

# テキスト生成（学習済みモデルから直接）
python examples/run_spiking_lm_generation.py \
  --run-name <run_name> \
  --prompt "プロンプトテキスト" \
  --max-new-tokens 200 \
  --temperature 0.8

# マルチモーダル推論デモ
python examples/evaluate_multi_modal_lm.py \
  --model-path saved_models/multimodal_v1/

# RAG クエリデモ
python examples/rag_ingest_and_query.py

6. API エンドポイント一覧

テキスト推論

メソッド パス 説明
POST /api/generate テキスト生成（SpikingEvoTextLM）
GET /api/model_status モデルロード状態確認

マルチモーダル推論（実装計画）

メソッド パス 説明 状態
POST /api/multimodal/generate テキスト+画像+音声マルチモーダル推論 TODO
POST /api/vision/encode 画像スパイクエンコード TODO
POST /api/audio/encode 音声→MFCC→スパイク変換 TODO

RAG

メソッド パス 説明
POST /api/rag/query RAG クエリ（検索+生成）
GET /api/rag/documents ドキュメント一覧
POST /api/rag/documents/text テキストドキュメント登録
POST /api/rag/documents/file ファイルアップロード

Foundation Extensions（実装済み）

メソッド パス 説明
GET /api/foundation/status foundation 機能の有効状態とデフォルト設定確認
POST /api/foundation/scale-benchmark スケールベンチ実行
POST /api/foundation/secure-store/roundtrip 保存時暗号化ストアの往復検証
POST /api/foundation/zero-trust/evaluate ゼロトラスト評価
POST /api/foundation/meta-learning/step MAML 少数ショット更新ステップ
POST /api/foundation/xai/explain XAI 説明生成 + フェイルセーフ評価

記憶システム

メソッド パス 説明
POST /api/memory/episodic/store エピソード記憶保存
GET /api/memory/episodic/retrieve エピソード記憶検索
POST /api/memory/semantic/store 意味記憶保存
GET /api/memory/semantic/retrieve 意味記憶検索

非同期パイプライン

メソッド パス 説明
POST /api/pipeline/submit タスク投入（NORMAL/HIGH/CRITICAL）
GET /api/pipeline/metrics パイプラインメトリクス
GET /api/pipeline/status パイプライン稼働状態

学習

メソッド パス 説明
POST /api/train/spiking-lm SpikingEvoTextLM 学習開始
POST /api/train/transformer TransformerLM 学習開始
POST /api/train/distillation ANN→SNN 蒸留学習
GET /api/train/status/{session_id} 学習セッション状態

WebSocket ストリーミング

プロトコル パス 説明
WS /ws/audio リアルタイム音声ストリーミング
WS /ws/video リアルタイム映像ストリーミング
WS /ws/brain_stream 分散ブレイン状態リアルタイム配信

7. TAS エンコーディング詳細

TAS-Encoding（特許 MT25-EV002）はすべてのテキスト入力をスパイク列に変換する中核技術です。

flowchart LR
    subgraph "TASEncoderDecoder.forward(tokens)"
        direction TB
        TOK["token_ids\n[batch, seq_len]"]
        EMB["nn.Embedding\n→ E [batch, seq, dim]"]
        LAMBDA["λ = σ(E)\n発火率計算"]
        PHI["φ = pos × Δφ\n位相オフセット"]
        N_SPIKE["n = round(λ × (T − φ))\nスパイク数決定"]
        PLACE["連続スパイク配置\n[batch, time, seq, dim]"]

        TOK --> EMB --> LAMBDA & PHI
        LAMBDA & PHI --> N_SPIKE --> PLACE
    end

    PLACE --> STB["SpikingTransformerBlocks"]

数式:

\[\lambda = \sigma(E) \in [0, 1] \quad \text{(発火率)}\]
\[\phi = \text{pos} \times \Delta\phi \quad \text{(位相オフセット)}\]
\[n = \text{round}(\lambda \times (T - \phi)) \quad \text{(スパイク数)}\]

無損失復号 (Claim 3):
\((λ, φ)\) ペアから最近傍探索で元のトークンを 100% 復元します。

8. メモリ・キャッシュ管理

flowchart TD
    subgraph "推論時メモリフロー"
        IN[入力テンソル]
        MC{TensorCache\nヒット?}
        OPT[memory_manager\noptimize_tensor_memory]
        FWD[モデル forward]
        CACHE[TensorCache.put]
        OUT[出力テンソル]

        IN --> MC
        MC -->|ヒット| OUT
        MC -->|ミス| OPT --> FWD --> CACHE --> OUT
    end

    subgraph "メモリ管理コンポーネント"
        MM[MemoryManager]
        GC[GPU Memory Cleanup\ntorch.cuda.empty_cache]
        PY_GC[Python GC\ngc.collect]
        WEAK[WeakRef 登録\nモデル自動解放]

        MM --> GC & PY_GC & WEAK
    end

    subgraph "バッチ最適化"
        BP[DynamicBatchProcessor]
        METRICS[BatchOptimizationMetrics\n処理時間/メモリ使用率\nGPU使用率追跡]
        OPT_BS[最適バッチサイズ自動計算]

        BP --> METRICS --> OPT_BS --> BP
    end

9. 実装チェックリスト（TODO）

フェーズ 1: 基本テキスト推論（完成済み）

  • [x] SpikingEvoTextLM 学習パイプライン (train_spiking_evospikenet_lm.py)
  • [x] POST /api/generate 推論エンドポイント
  • [x] DB からのモデル自動ロード (load_model_and_tokenizer)
  • [x] run_spiking_lm_generation.py スクリプト推論
  • [x] DynamicBatchProcessor による推論最適化
  • [x] TensorCache による推論キャッシュ

フェーズ 2: マルチモーダル推論（実装対象）

  • [ ] SpikingEvoMultiModalLM を DB からロードする load_multimodal_model() 関数の実装
  • ファイル: evospikenet/api.py
  • 実装内容: テキストと同様に DB から最新マルチモーダルモデルをロード
  • [ ] POST /api/multimodal/generate エンドポイントの追加
  • ファイル: evospikenet/api_modules/ に multimodal_api.py 新規作成
  • 入力: {"prompt": str, "image": base64_str, "audio": base64_str}
  • 前処理: 画像 → PIL → Tensor[B,C,H,W]、音声 → torchaudio MFCC
  • [ ] マルチモーダル推論の generate() メソッド拡張
  • ファイル: evospikenet/models.py の SpikingEvoMultiModalLM
  • 実装内容: 自己回帰生成ループを SpikingEvoTextLM.generate() に合わせて実装
  • [ ] POST /api/vision/encode エンドポイント
  • [ ] POST /api/audio/encode エンドポイント

フェーズ 3: RAG 強化推論（実装済み、運用最適化継続）

  • [x] POST /api/rag/query プロキシエンドポイント
  • [x] SNNEmbeddingModel による SNN ベクトル埋め込み
  • [x] RAG VectorDB アダプタ実装 (rag_backends.py) とランタイム切替 API (rag_client.py)
  • [ ] SNNEmbeddingModel.forward() のインデント・到達不能バグ修正
  • ファイル: evospikenet/models.py の SNNEmbeddingModel
  • 問題: models_api_summary() の内側に forward() が定義されており到達不能
  • 修正: forward() メソッドを SNNEmbeddingModel クラス内に移動

フェーズ 4: 分散ブレイン推論（部分実装済み）

  • [x] DistributedBrainNode + AsyncZenohCommunicator
  • [x] Zenoh Pub/Sub による結果転送
  • [ ] POST /api/distributed_brain/query のマルチノード融合ロジック
  • [ ] MemoryIntegratorNode による分散結果統合
  • [ ] BiomimeticAdapter を介した感情/報酬信号の推論反映

フェーズ 5: 大規模スケール対応（将来計画）

  • [ ] vLLM / DeepSpeed Inference との統合による大規模バッチ推論
  • [ ] モデルシャーディング（tensor_parallel 対応）
  • [ ] ONNX / TensorRT へのエクスポートパイプライン
  • [ ] 量子化推論オプション（INT8/FP16 自動切替）
  • ファイル: evospikenet/model_compressor.py の ModelCompressor

バグ修正（優先）

  • [ ] 重大: SNNEmbeddingModel.forward() が models_api_summary() 内に誤配置
  • evospikenet/models.py 約 L460-L475
  • [ ] SpikingEvoMultiModalLM に generate() メソッドが未実装
  • [ ] SpikingEvoTextLM.generate() の self.train() 呼び出しが推論後に不要（eval() 維持推奨）

補足: 2026-04-06 時点の反映済み項目

  • [x] Foundation API 追加 (/api/foundation/*) と API ルータ統合
  • [x] foundation 設定の settings.yaml / settings.schema.json 反映
  • [x] system 回帰テスト tests/system/test_scalability_and_performance.py 安定化

10. 今後の拡張計画

gantt
    title EvoSpikeNet 推論パイプライン実装ロードマップ
    dateFormat  YYYY-MM-DD
    section フェーズ1 (完成)
    テキスト推論基盤            :done, p1, 2025-01-01, 2025-06-30
    DB アーティファクト管理      :done, p1b, 2025-04-01, 2025-06-30
    section フェーズ2 (進行中)
    SNNEmbeddingModel バグ修正   :active, p2a, 2026-04-01, 2026-04-07
    multimodal_api.py 実装       :p2b, 2026-04-07, 2026-04-21
    マルチモーダル generate()    :p2c, 2026-04-14, 2026-04-28
    section フェーズ3
    RAG 統合テスト               :p3a, 2026-04-21, 2026-05-05
    分散ブレイン融合ロジック      :p3b, 2026-05-01, 2026-05-15
    section フェーズ4
    量子化推論 (INT8/FP16)        :p4a, 2026-05-10, 2026-05-31
    ONNX/TensorRT エクスポート   :p4b, 2026-06-01, 2026-06-30
    大規模バッチ (vLLM 統合)     :p4c, 2026-06-15, 2026-07-31

技術スタック

推論サービス   : FastAPI + uvicorn (async)
モデルフレームワーク: PyTorch + snntorch
エンコーディング  : TAS (MT25-EV002 特許)
分散通信       : Eclipse Zenoh
ベクトルDB      : VectorDB Adapter（InMemory / FAISS / Milvus / Chroma / Qdrant）
全文検索       : Elasticsearch  
メッセージキュー  : Redis Pub/Sub
認可           : Open Policy Agent (OPA)
コンテナ       : Docker / Kubernetes (k8s/)
監視          : Prometheus metrics (/metrics)
ドキュメント    : MkDocs

Moonlight Technologies Inc. © 2026 — EvoSpikeNet v4.0