Upload 13 files

158b_train_sample/drna_restore_train.py

@@ -0,0 +1,281 @@
+import os
+import math
+import sys
+import signal
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+from datetime import datetime
+from datasets import load_dataset
+from safetensors.torch import save_file, load_file
+from torch.utils.data import IterableDataset, DataLoader
+
+'''
+こちらは学習コードです、これはモデルコードから機能等を参照して読みだして実行します
+次元などの変更もこの学習コード側で行います、モデルコード側は基準として触らずに保持します
+---
+utf16をトークナイザ代替にする
+世界中のさまざまな言語、絵文字、特殊記号、ソースコードのインデントまで、あらゆる文字を100%表現できる
+(事前に決めた3万〜10万語の｢辞書｣にない言葉で[UNK]を生じることがなくなる)
+1つのアーキテクチャで全メディアを等価に処理できる究極のマルチモーダルが理論上可能になる
+Vocab Sizeを｢65,536｣(16bit境界)にジャストフィットさせることによるVRAM効率と計算効率を最大化します
+ハードウェア的な特性(メモリのビット幅、アライメント、並列計算の仕組み)に合致しオーバーヘッドを生じません
+(トークナイザやVAEなどの外付けはパディング処理などで空白を埋めるようなムダを生じる)
+スマートフォンやエッジデバイスでも標準的なutf16なら確実に動作可能です
+欠点は以下のみ、単純に少し長く学習するだけで解消します
+コンテキスト長(トークン効率)の悪化、意味的抽象化(セマンティクス)をゼロから自力で学習しなければならない
+'''
+
+# モデル定義ファイルから必要なクラスをインポート
+from drna_swi_mount import (
+    DRNA_Model, 
+    DRNA_Block,
+    TernaryTrainingManager, 
+    get_ternary_schedule
+)
+
+# グローバル変数：Ctrl+C ハンドラから安全にアクセスするため
+training_interrupted = False
+current_step_global = 0
+
+def sigint_handler(signum, frame):
+    '''Ctrl+C (SIGINT) をエレガントにキャッチするハンドラ'''
+    global training_interrupted
+    print("\n\n[!!] Ctrl+C (SIGINT) を検知しました。現在のステップで安全に緊急保存処理へ移行します...")
+    training_interrupted = True
+
+# SIGINT ハンドラを登録
+signal.signal(signal.SIGINT, sigint_handler)
+
+# UTF16 トークナイザ
+def encode_utf16(text: str, seq_len: int) -> torch.Tensor:
+    tokens = [ord(char) for char in text if ord(char) < 65536]
+    if len(tokens) < seq_len + 1:
+        tokens = tokens + [0] * (seq_len + 1 - len(tokens))
+    else:
+        tokens = tokens[:seq_len + 1]
+    return torch.tensor(tokens, dtype=torch.long)
+
+# Webテキスト逐次読み込み(ストリーミング)
+class StreamingWebTextDataset(IterableDataset):
+    def __init__(self, seq_len: int):
+        super().__init__()
+        self.seq_len = seq_len
+        print(">>> OpenWebText からデータをストリーミング接続中... (初回は数分かかる場合があります)")
+        self.dataset = load_dataset("openwebtext", split="train", streaming=True, trust_remote_code=True)
+
+    def __iter__(self):
+        buffer = ""
+        for item in self.dataset:
+            text = item["text"].strip()
+            if not text:
+                continue
+            buffer += text + " "
+            while len(buffer) >= self.seq_len + 1:
+                chunk = buffer[:self.seq_len + 1]
+                buffer = buffer[self.seq_len:]
+                token_tensor = encode_utf16(chunk, self.seq_len)
+                yield token_tensor[:-1], token_tensor[1:]
+
+# 💎 Gradient Checkpointing マウント関数
+def apply_gradient_checkpointing(model: nn.Module):
+    '''
+    フック構造確定後に呼び出し、DRNA_Block全体をGCで包む
+    これにより、再計算時にもフック(3値ブレンド)が正常に働き、w2の勾配消失を防ぐ
+    '''
+    print(">>> [成功] Gradient Checkpointing を各 DRNA_Block (レイヤー全体) に適用中...")
+
+    def make_checkpoint_forward(block_module):
+        original_forward = block_module.forward
+
+        def checkpoint_forward(*args, **kwargs):
+            x, cos, sin = args[0], args[1], args[2]
+            mask = kwargs.get('mask', None)
+            # GCでスキップされてしまう、そのフックを直接呼び出す
+            for name, module in block_module.named_modules():
+                if isinstance(module, nn.Linear):
+                    # モジュールに登録されている forward_pre_hook を探して直接実行する
+                    for hook in module._forward_pre_hooks.values():
+                        # フックを偽装実行(module と inputs を渡せば、内部で正しく3値化���れる)
+                        hook(module, (x,))
+            return checkpoint.checkpoint(
+                original_forward, x, cos, sin, mask, 
+                use_reentrant=False
+            )
+        return checkpoint_forward
+
+    for name, module in model.named_modules():
+        if isinstance(module, DRNA_Block):
+            module.forward = make_checkpoint_forward(module)
+            print(f"  -> {name} (DRNA_Block) の計算空間を GC で保護しました。")
+
+# 対話型セットアップ関数
+def select_model_setup(vocab_size, d_model, n_layers, n_heads, d_ff):
+    print(" D-RNA Trio 3値学習 セットアップモードの選択")
+    print("1: 新規モデルを初期化して作成し学習開始")
+    print("2: 既存の通常モデルや３値モデル、途中保存をマウントして学習開始")
+    choice = input("選択してください (1 or 2): ").strip()
+
+    model = DRNA_Model(
+        vocab_size=vocab_size, d_model=d_model, 
+        n_layers=n_layers, n_heads=n_heads, d_ff=d_ff
+    ).cuda()
+
+    if choice == "2":
+        checkpoint_path = input("読み込む重みファイルのパスを入力してください ").strip().strip("'\"")
+        if not os.path.exists(checkpoint_path):
+            print(f"エラー: パスが見つかりません。新規作成します")
+            return model
+
+        print("\n>>> [理論通りに復元開始] 通常/3値/途中保存の重みから連続勾配空間を復元中...")
+        _ = TernaryTrainingManager(model, warmup_steps=10, max_lambda=1.0)
+        checkpoint = load_file(checkpoint_path, device='cuda')
+
+        with torch.no_grad():
+            for name, module in model.named_modules():
+                if isinstance(module, nn.Linear):
+                    if "embed" in name or "output_head" in name:
+                        continue
+
+                    # 統一された単一の｢.weight｣から実数聖域｢raw_weight｣へバトンを戻す
+                    target_key = f"{name}.weight" if f"{name}.weight" in checkpoint else f"{name}.raw_weight"
+                    if target_key in checkpoint:
+                        module.raw_weight.copy_(checkpoint[target_key].cuda())
+        print(">>> マウントおよび連続勾配空間の再展開が完了しました \n")
+        model.is_already_mounted = True
+    else:
+        model.is_already_mounted = False
+
+    return model
+
+def select_save_precision():
+    print(" エクスポート精度の選択")
+    print("1: bfloat16 (推奨)")
+    print("2: float16")
+    print("3: float32")
+    choice = input("選択してください (1, 2, 3): ").strip()
+    if choice == "2": return torch.float16, "fp16"
+    if choice == "3": return torch.float32, "fp32"
+    return torch.bfloat16, "bf16"
+
+# メイン学習ループ
+def main():
+    global training_interrupted, current_step_global
+    '''次元などの変更はこちらで行います'''
+    # パラメータ設定
+    vocab_size = 65536  # UTF-16 全域 (BMP)
+    d_model = 256
+    n_layers = 16       # GCにより、12GB VRAM環境でも16層でも軽快に回ります
+    n_heads = 8
+    d_ff = 1024         # (d_model * 4)
+
+    seq_len = 256       
+    batch_size = 8      
+    max_train_steps = 3001 
+
+    # モデル初期化 / ロード
+    model = select_model_setup(vocab_size, d_model, n_layers, n_heads, d_ff)
+
+    # 3値誘導マネージャー外付け
+    warmup_steps = 300
+    max_lambda = 1.0
+    manager = TernaryTrainingManager(model, warmup_steps=warmup_steps, max_lambda=max_lambda)
+
+    # 🎯フック構造確定の｢後｣にGCをマウント
+    apply_gradient_checkpointing(model)
+
+    print(">>> 英語Webテキストをストリーミング中...")
+    dataset = StreamingWebTextDataset(seq_len=seq_len)
+    dataloader = DataLoader(dataset, batch_size=batch_size)
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=5e-4)
+    criterion = nn.CrossEntropyLoss()
+
+    print(f">>> 学習を開始します (最大 {max_train_steps} ステップ) ...")
+    print("※ 学習途中で安全に終了して実数保存したい場合は [Ctrl+C] を押してください")
+    model.train()
+
+    current_step = 0
+    save_mode = "crystallized"
+    timestamp = datetime.now().strftime("%y%m%d_%H%M")
+
+    for inputs, targets in dataloader:
+        if current_step >= max_train_steps or training_interrupted:
+            if training_interrupted:
+                save_mode = "emergency"
+            break
+
+        current_step_global = current_step
+        inputs = inputs.cuda()
+        targets = targets.cuda()
+
+        optimizer.zero_grad()
+
+        # 順伝播
+        outputs = model(inputs, pad_id=0)
+
+        # 損失計算
+        task_loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))
+        loss = manager.amend_loss(task_loss, step=current_step, total_steps=max_train_steps)
+
+        loss.backward()
+        optimizer.step()
+
+        if current_step % 100 == 0:
+            blend_ratio = get_ternary_schedule(current_step, max_train_steps, warmup_steps)
+
+            print(f"Step {current_step:3d}/{max_train_steps} | "
+                  f"CE-Loss: {task_loss.item():.4f} | "
+                  f"Trio Blend: {blend_ratio * 100:6.2f}%")
+
+        current_step += 1
+
+    # 💾 修正箇所: 2重保存バグを根絶するスマートなキー管理保存
+    # まずベースとなる全パラメータの辞書を取得(※この時点では PyTorch の仕様で両方入っている)
+    state_dict = model.state_dict()
+    output_state_dict = {}
+
+    if save_mode == "crystallized":
+        print("\n>>> [通常終了] 指定ステップに到達したため、3値重みの結晶化(export_ternary)を実行中...")
+        # モデル側のコアロジックを呼び出し、raw_weight と weight を完全に同じ3値で同期化
+        crystallized_model = manager.export_ternary()
+        state_dict = crystallized_model.state_dict()
+
+        # 保存フェーズ: 中身は同一なので、余計な '.raw_weight' キーだけを完全に排除
+        for k, v in state_dict.items():
+            if ".raw_weight" in k:
+                continue  # 重複保存しない
+            output_state_dict[k] = v
+
+        output_filename = f"drna_pure_158_{timestamp}.safetensors"
+    else:
+        print(f"\n>>> [緊急停止] Step {current_step_global} で中断されました。結晶化はせず、実数勾配空間を抽出中...")
+
+        # 保存フェーズ: フックの残骸 '.weight' を捨て、実数本体 '.raw_weight' の名前を '.weight' にリネームして詰め替える
+        for k, v in state_dict.items():
+            if ".weight" in k and not any(x in k for x in ["embed", "output_head", "final_norm"]):
+                # 3値化対象レイヤーの通常の '.weight' キー(バッファの残骸)は無視
+                continue
+            if ".raw_weight" in k:
+                # 実数の本体である '.raw_weight' を通常の '.weight' という名前にリネームして昇格
+                new_key = k.replace(".raw_weight", ".weight")
+                output_state_dict[new_key] = v
+            else:
+                # それ以外の全レイヤー(Embedding、Norm等)はそのまま保持
+                output_state_dict[k] = v
+
+        output_filename = f"drna_int_step{current_step_global}_{timestamp}_realw.safetensors"
+
+    # ユーザー指定の精度に一括キャストして safetensors でクリーンに書き出し
+    target_dtype, dtype_str = select_save_precision()
+    final_state_dict = {k: v.to(target_dtype).cpu() for k, v in output_state_dict.items()}
+
+    output_path = os.path.join(os.path.dirname(__file__ if __file__ else "."), f"{dtype_str}_{output_filename}")
+
+    save_file(final_state_dict, output_path)
+    print(f"  ==> [完了] 2重保存を完全に排除したクリーンな1倍サイズモデルを保存しました: {output_path}")
+    print("プロセスを正常に終了します")
+
+if __name__ == "__main__":
+    main()

158b_train_sample/drna_swi_mount.py

@@ -0,0 +1,447 @@
+import torch
+import math
+from typing import List, Tuple
+import torch.nn as nn
+import torch.nn.functional as F
+
+'''
+このコードは純粋３値学習を行うためのモデルコード(定義)です、通常はこちらを参照し呼び出すだけでOKです
+既存の重みをもつモデルを読み込んで３値へ転換も可能です(モデルの次元などは学習コード側で適切に合わせてください)
+---
+# チェックポイント読み込み(D-RNA-Trio の学習済みモデル) ／ fp8/16/32 相当の連続重みの復元
+2〜3 レイヤ：fp8相当、4〜6 レイヤ：bf16相当、7+ レイヤ：fp16/32 相当
+固有位相(K-energy × RoPE 周波数成分)を重ね合わせ＋正規化(二重らせんの共鳴収縮により歪みを抑制)
+特に K-for-phase の｢逐次カスケード的変化｣が位相シフトとなり自然な凸凹パターンを生成
+---
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE 版
+仕様：Pre-Norm(RMSNorm)、GELU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+Transformerの全接続性を継承しつつ、二重らせん(Dual-Helix)構造による
+｢共鳴収縮｣(Resonant Contraction)を物理的に再現したニューラルアーキテクチャです
+D-RNA の位相設計と Trio Induction system により３値学習を STE に頼らず安定的に行えます
+---
+これは STE で機能しない optimiser などを３値学習へ活用できるようになります
+将来的に３値モデルを位相差の重ねによる疑似重みをつくり、これを学習対象にして３値学習もおこなえるはずです
+つまり学習元も３値モデルにできるはずです、推論も学習も３値で済むようになる最初の１歩です
+'''
+
+#---restore mount START---
+class DRNAWeightRestorer:
+    '''
+    D-RNA の固有位相を利用した fp8/16/32 重み復元器
+    チェックポイント読み込み → 位相抽出 → 重ね合わせ → 正規化 で連続分布を生成
+    '''
+
+    def __init__(self, d_model: int = 256, num_layers: int = 16):
+        self.d_model = d_model
+        self.num_layers = num_layers
+
+    # チェックポイントから -/0/+ 重みを読み出す
+    def load_ternary_weights(self, checkpoint_path: str) -> List[torch.Tensor]:
+        '''ロードされたチェックポイントから各レイヤの重みを抽出する'''
+        checkpoint = torch.load(checkpoint_path, map_location='cuda')
+
+        layer_weights = []
+        for i in range(self.num_layers):
+            # QKV レイヤー(norm1 ブランチ)
+            qkv_weight = checkpoint[f'layers.{i}.qkv.weight']
+
+            # MLP 入力/出力レイヤー(norm2 ブランチ)
+            mlp_0_weight = checkpoint[f'layers.{i}.mlp.0.weight']
+            mlp_3_weight = checkpoint[f'layers.{i}.mlp.3.weight']
+
+            layer_weights.extend([qkv_weight, mlp_0_weight, mlp_3_weight])
+
+        return layer_weights
+
+    # K-for-phase のカスケード効果から各レイヤの固有位相を抽出する
+    def extract_phase_offsets(self, max_seq_len: int = 256) -> List[Tuple[torch.Tensor, torch.Tensor]]:
+        '''DRNA の固有位相(K-energy × RoPE 周波数成分)を計算し返す'''
+
+        num_layer_groups = self.num_layers * 3
+
+        phase_data_list = []
+        base_energy = torch.arange(128, dtype=torch.float32, device='cuda') / self.d_model
+
+        for i in range(num_layer_groups):
+            # K-energy のカスケード効果：レイヤごとに滑らかにシフト(K-for-phase 同様に)
+            k_energy = base_energy * (i % self.num_layers + 1)
+
+            # DRNA の動的位相変調: tanh(k_energy) × π
+            rt_phase = math.tanh(k_energy) * math.pi
+
+            # RoPE 的な周波数成分の抽出(各レイヤ固有の周波数パターン)
+            inv_freq = 1.0 / (10000 ** (torch.arange(0, 128, 2).float() / self.d_model))
+
+            freqs = torch.einsum("i,j->ij", 
+                               torch.arange(max_seq_len, device='cuda'),
+                               inv_freq)
+
+            # cos / sin の位相シフトを生成
+            cos_shift = torch.cos(freqs * rt_phase.unsqueeze(-1))
+            sin_shift = torch.sin(freqs * rt_phase.unsqueeze(-1))
+
+            phase_data_list.append((cos_shift, sin_shift))
+
+        return phase_data_list
+
+    # 固有位相を用いて重ね合わせ(RoPE 的な位相変調を適用)
+    def superimpose_weights(
+        self, 
+        layer_weights: List[torch.Tensor], 
+        phase_offsets: List[Tuple[torch.Tensor, torch.Tensor]]
+    ) -> torch.Tensor:
+        '''各レイヤの -/0/+ 重みに固有位相を適用し重ね合わせる'''
+
+        reconstructed = torch.zeros_like(layer_weights[0])
+
+        for i, w_i in enumerate(layer_weights):
+            cos_shift, sin_shift = phase_offsets[i]
+
+            # DRNA の K-for-phase 同様の位相変調: d_cos / d_sin を用いる重ね合わせ
+            contribution = w_i * (cos_shift - rotate_half(w_i) * sin_shift)
+            reconstructed += contribution
+
+        return reconstructed
+
+    # RMSNorm 的な正規化(3 値歪みのリセット)
+    def normalize(self, x: torch.Tensor) -> torch.Tensor:
+        '''重ね合わせ後の分布を RMSNorm で安定化する'''
+
+        mean = x.mean(-1, keepdim=True)
+        var = x.var(-1, keepdim=True, unbiased=False)
+
+        # 中心化･標準化(3 値歪みのリセット)
+        return (x - mean) * torch.rsqrt(var + 1e-8)
+
+    # 完全復元パイプライン
+    def restore_from_checkpoint(
+        self, 
+        checkpoint_path: str, 
+        max_seq_len: int = 256
+    ) -> torch.Tensor:
+        '''チェックポイントを読み込み、fp8/16 相当の連続重みを生成する'''
+
+        # -1.0/0.0/1.0 重みの読み出し
+        layer_weights = self.load_ternary_weights(checkpoint_path)
+
+        # 固有位相(K-energy × RoPE)の抽出
+        phase_offsets = self.extract_phase_offsets(max_seq_len)
+
+        # 重ね合わせ(RoPE 的な位相変調を適用)
+        continuous_weight = self.superimpose_weights(
+            layer_weights, 
+            phase_offsets)
+
+        # RMSNorm 的な正規化
+        normalized_weight = self.normalize(continuous_weight)
+
+        return normalized_weight
+
+# 補助関数: DRNA rotate_half 再現
+def rotate_half(x):
+    '''D-RNA の K-for-phase 同様の回転操作(位相変調の右辺項)'''
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)
+#---restore mount END---
+
+#---drna-swi-triox START---
+# 3値誘導制御コア(モデルの書き換え、3値ブレンド、ペナルティ計算、結晶化)
+class TernaryTrainingManager:
+    '''
+    D-RNAのコードに触れることなく、3値誘導の全ライフサイクルを統括する抽象化マネージャー
+    '''
+    def __init__(self, model, warmup_steps=100, max_lambda=1.0):
+        self.model = model
+        self.warmup_steps = warmup_steps
+        self.max_lambda = max_lambda
+        self.current_step = 0
+        self.total_steps = 0
+        
+        # 内部で利用するステッププロバイダー関数
+        def step_provider():
+            return self.current_step, self.total_steps
+
+        # モデル内の全2次元重みにフックを外付け
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Linear):
+                # ★ 拡張性：LLMの生命線である｢embed｣と｢output_head｣は絶対に3値化しない
+                if "embed" in name or "output_head" in name:
+                    continue
+                if not hasattr(module, "raw_weight"):
+                    # 元の実数重みを聖域(raw_weight)に退避
+                    module.register_parameter("raw_weight", nn.Parameter(module.weight.data.clone()))
+                    delattr(module, "weight")
+                    module.register_buffer("weight", module.raw_weight.data.clone())
+                module.register_forward_pre_hook(TernaryWeightHook(step_provider, self.warmup_steps))
+
+    def amend_loss(self, task_loss, step, total_steps):
+        '''
+        【ループ内抽象化用】 メインのタスク損失(CrossEntropy等)を受け取り、
+        現在のステップに応じた3値結晶化ペナルティを自動計算して合算した損失を返す
+        '''
+        self.current_step = step
+        self.total_steps = total_steps
+
+        blend_ratio = get_ternary_schedule(step, total_steps, self.warmup_steps)
+        current_lambda = blend_ratio * self.max_lambda
+
+        if current_lambda == 0.0:
+            return task_loss
+
+        # 3値誘導トリプレット･ペナルティ自動計算
+        ternary_penalty = 0.0
+        for name, param in self.model.named_parameters():
+            # 2次元以上の重み(LinearやEmbeddingの実数聖域)のみを対象とする
+            if "raw_weight" in name and param.dim() >= 2:
+                # W * (W - 1) * (W + 1) = W^3 - W を0に近づける(-1, 0, 1への収束強制力)
+                ternary_penalty += torch.mean(param * (param - 1.0) * (param + 1.0)) ** 2
+
+        return task_loss + current_lambda * ternary_penalty
+
+    def export_ternary(self):
+        '''学習終了後、モデルの全2次元重みを完全な[-1.0, 0.0, 1.0]へ固定(結晶化)する'''
+        with torch.no_grad():
+            for name, module in self.model.named_modules():
+                if isinstance(module, nn.Linear):
+                    # 拡張性：LLMの生命線である｢embed｣と｢output_head｣は絶対に3値化しない
+                    if "embed" in name or "output_head" in name:
+                        continue
+                    # raw_weight があればそっちを本体として使う
+                    if hasattr(module, "raw_weight"):
+                        param = module.raw_weight
+                    else:
+                        param = module.weight
+                    # 学習中と同じ写像：tanh(3w) で soft 3値ターゲットを作る
+                    soft = torch.tanh(param * 3.0)
+                    # soft を hard 3値に潰す
+                    ternary = torch.zeros_like(soft)
+                    ternary[soft >  0.08] =  1.0
+                    ternary[soft < -0.08] = -1.0
+                    # 実数パラメータ自体を3値に上書きして完全固定
+                    if hasattr(module, "raw_weight"):
+                        module.raw_weight.copy_(ternary)
+                    module.weight.copy_(ternary)
+
+        return self.model
+
+# 3値誘導外付けフックシステム(2次元重みを3値ブレンド)
+def get_ternary_schedule(step, total_steps, warmup_steps=100):
+    '''逆転コサインアニーリングスケジューラ'''
+    if step < warmup_steps:
+        return 0.0
+    anneal_steps = total_steps - warmup_steps
+    progress = (step - warmup_steps) / anneal_steps
+    return 1.0 - (0.5 * (1.0 + math.cos(progress * math.pi)))
+
+def get_soft_ternary_weight(param, step, total_steps, warmup_steps=100):
+    '''勾配直通バイパス型 3値ブレンド関数'''
+    if param.dim() < 2:  # 1次元パラメータは保護
+        return param
+    blend_ratio = get_ternary_schedule(step, total_steps, warmup_steps)
+    if blend_ratio == 0.0:
+        return param
+    with torch.no_grad():
+        ternary_target = torch.tanh(param * 3.0)
+    # 【最重要】生の勾配を裏に直通させるバイパス構造
+    return param + blend_ratio * (ternary_target - param)
+
+class TernaryWeightHook:
+    def __init__(self, step_provider, warmup_steps=100):
+        self.step_provider = step_provider
+        self.warmup_steps = warmup_steps
+
+    def __call__(self, module, inputs):
+        step, total_steps = self.step_provider()
+        if step is not None and total_steps is not None:
+            # バックアップした実数重み(raw_weight)から疑似3値重みを計算し一時的に上書き
+            module.weight.data = get_soft_ternary_weight(module.raw_weight, step, total_steps, self.warmup_steps)
+
+def apply_trio_induction(model, step_provider, warmup_steps=100):
+    '''モデル側ではなく外側から3値化プラグインを刺す関数'''
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            # ★ 拡張性：LLMの生命線である｢embed｣と｢output_head｣は絶対に3値化しない
+            if "embed" in name or "output_head" in name:
+                continue
+            if not hasattr(module, "raw_weight"):
+                # 元の実数重みを聖域(raw_weight)に退避
+                module.register_parameter("raw_weight", nn.Parameter(module.weight.data.clone()))
+                delattr(module, "weight")
+                module.register_buffer("weight", module.raw_weight.data.clone())
+            module.register_forward_pre_hook(TernaryWeightHook(step_provider, warmup_steps))
+
+# D-RNA 3値化のパニックを100%いなすコンサルタント(RMSNorm 修正)
+class RMSNorm(nn.Module):
+    '''【修正版】3値化の歪みをリセットする中心化･標準化型防波堤'''
+    def __init__(self, d_model, eps=1e-8):
+        super().__init__()
+        self.eps = eps
+        # 3値化の歪みによってズレた｢音量の軸｣を、フル精度の実数で強制的に中心に戻すバイアス
+        self.bias = nn.Parameter(torch.zeros(d_model))
+        # 3値化のせいで極端にインフレ･デフレした次元ごとの音量を、個別にジャストフィットさせる実数スケール
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        # 各次元ごとの平均と分散を計算
+        mean = x.mean(-1, keepdim=True)
+        var = x.var(-1, keepdim=True, unbiased=False)
+
+        # 3値化による｢歪み･偏り｣を、ここで完全にリセット(標準化)する
+        x_normed = (x - mean) * torch.rsqrt(var + self.eps)
+
+        # リセットされた綺麗な状態に対して、フル精度のオプティマイザが最適なスケールとオフセットを施す
+        return self.weight * x_normed + self.bias
+
+class DRNA_RoPE(nn.Module):
+    '''二重らせんの位相を決定する回転場'''
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    '''Kによる動的位相変調済み cos/sin を受け取る'''
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class DRNA_Block(nn.Module):
+    '''DRNA共鳴ブロック：安定性を高めたPre-Norm直列共鳴構造'''
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA：回想系 (Attention)
+        self.norm1 = RMSNorm(d_model) # 演算の前に配置
+        self.qkv = nn.Linear(d_model, d_model * 3)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        # らせんB：記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model) # 演算の前に配置
+
+        # SwiGLUの定石：パラメータ量をGELU版(×4倍)と合わせるため、約2.67倍(8/3)にする
+        if d_ff is None:
+            d_ff = int(2 * (d_model * 4) / 3) 
+
+        # SwiGLUは入力に対して2つのLinear(Gate･Up)を並列に走らせます
+        self.w1 = nn.Linear(d_model, d_ff, bias=False) # ゲート用
+        self.w3 = nn.Linear(d_model, d_ff, bias=False) # 値用(アッププロジェクション)
+        self.w2 = nn.Linear(d_ff, d_model, bias=False) # ダウンプロジェクション
+
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+        b, s, d = x.shape
+
+        # 共通の残差(ベースとなる螺旋の軸)
+        residual = x
+
+        # らせんA (Attention) 並列方式
+        x_norm1 = self.norm1(x)
+
+        # QKV生成 (3倍のまま)
+        # ※ self.qkv(x_norm) が x_norm1 になっているか確認してください
+        qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        # K因果的動的回転：一つ前の単語の K が今の単語の座標を決める
+        # 自分の情報で自分を回さないよう、Kを1つ未来にシフトさせる
+        # これにより｢赤い(K)｣が｢猫(Q,K)｣の位相を決定する構造になる
+        k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+
+        # Kのエネルギーを位相(回転角)に変換
+        rt_phase = torch.tanh(k_for_phase) * math.pi
+
+        # 静的RoPE (cos, sin) を動的位相 (rt_phase) で加法定理により変調
+        # ※ apply_drna_rope に rt_phase を渡せるように関数側を調整するか、
+        # ここで dynamic_cos / sin を作って渡します
+        d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+        d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+        # ２重らせんをつくる (変調された座標で回転)
+        q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+        # Attention計算
+        attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+        if mask is not None:
+            attn = attn + mask
+
+        attn = F.softmax(attn, dim=-1)
+        a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+        a_out = self.out_proj(a_out_raw)
+
+        # らせんB (MLP)
+        x_norm2 = self.norm2(x)
+
+        # SwiGLUのコア数式: Swish(xW1) * xW3(F.silu：PyTorchのSwish関数)
+        gate = F.silu(self.w1(x_norm2)) 
+        current_value = self.w3(x_norm2)
+
+        # 要素積(共鳴収縮の表現としても非常に相性が良いです)
+        swiglu_out = gate * current_value 
+
+        # 最終投影
+        m_out = self.w2(swiglu_out)
+
+        # 並列方式
+        x = residual + self.dropout(a_out) + self.dropout(m_out)
+
+        return x
+
+class DRNA_Model(nn.Module):
+    '''汎用 DRNA モデルコンテナ(安定化 Pre-Norm 版)'''
+    def __init__(self, vocab_size, d_model=256, n_layers=16, n_heads=8, d_ff=1024):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+
+        self.layers = nn.ModuleList([
+            DRNA_Block(d_model, n_heads, self.head_dim, d_ff) for _ in range(n_layers)
+        ])
+
+        # Pre-Norm構造の場合、最終レイヤーの後に全体のNormを置くのが一般的
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # pad_id が整数(int/long)として有効な場合のみ pad_mask を作成
+            # 退避させた inputs を使ってパディングを判定し因果マスクを準備
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        for layer in self.layers:
+            x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x) # 出力前の最終同期
+        return self.output_head(x)
+#---drna-swi-triox END---
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''

drna/drna.py

@@ -0,0 +1,179 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+'''
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE 版
+仕様：Pre-Norm(RMSNorm)、GELU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+Transformerの全接続性を継承しつつ、二重らせん(Dual-Helix)構造による
+｢共鳴収縮｣(Resonant Contraction)を物理的に再現したニューラルアーキテクチャです
+螺旋の同期：Attention(文脈の回想)とMLP(知識の定着)を並列配置し RoPE で情報を同期
+位相の保持：RoPE(Phase Field)を回転場として利用し、安定した相対位置を保ち早期収束を両立
+高密度圧縮：Pre-Norm により、各らせんを安定的に収縮させ、全結合により記憶を定着させる
+'''
+
+class RMSNorm(nn.Module):
+    def __init__(self, d_model, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        # 2乗平均の平方根で割る(平均を減算しない･中心化をしない)
+        norm = x.pow(2).mean(-1, keepdim=True)
+        x_normed = x * torch.rsqrt(norm + self.eps)
+        return self.weight * x_normed
+
+class DRNA_RoPE(nn.Module):
+    """二重らせんの位相を決定する回転場"""
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    """Kによる動的位相変調済み cos/sin を受け取る"""
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class DRNA_Block(nn.Module):
+    """DRNA共鳴ブロック：安定性を高めたPre-Norm直列共鳴構造"""
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA: 回想系 (Attention)
+        self.norm1 = RMSNorm(d_model) # 演算の前に配置
+        self.qkv = nn.Linear(d_model, d_model * 3)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        # らせんB: 記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model) # 演算の前に配置
+        d_ff = d_ff or d_model * 4
+        self.mlp = nn.Sequential(
+            nn.Linear(d_model, d_ff),
+            nn.GELU(), # VRAM抑制は ReLU (別レイヤの干渉で0勾配にならない｢可能性｣あり)
+            nn.Dropout(dropout),
+            nn.Linear(d_ff, d_model)
+        )
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+            b, s, d = x.shape
+
+            # 1. 共通の残差(ベースとなる螺旋の軸)
+            residual = x
+
+            # 2. らせんA (Attention) 並列方式
+            x_norm1 = self.norm1(x)
+
+            # QKV生成 (3倍のまま)
+            # ※ self.qkv(x_norm) が x_norm1 になっているか確認してください
+            qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+            q, k, v = qkv[0], qkv[1], qkv[2]
+
+            # K因果的動的回転：一つ前の単語の K が今の単語の座標を決める
+            # 自分の情報で自分を回さないよう、Kを1つ未来にシフトさせる
+            # これにより｢赤い(K)｣が｢猫(Q,K)｣の位相を決定する構造になる
+            k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+
+            # Kのエネルギーを位相(回転角)に変換
+            rt_phase = torch.tanh(k_for_phase) * math.pi
+
+            # 静的RoPE (cos, sin) を動的位相 (rt_phase) で加法定理により変調
+            # ※ apply_drna_rope に rt_phase を渡せるように関数側を調整するか、
+            # ここで dynamic_cos / sin を作って渡します
+            d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+            d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+            # ２重らせんをつくる (変調された座標で回転)
+            q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+            # Attention計算
+            attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+            if mask is not None:
+                attn = attn + mask
+
+            attn = F.softmax(attn, dim=-1)
+            a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+            a_out = self.out_proj(a_out_raw)
+
+            # 3. らせんB (MLP)
+            x_norm2 = self.norm2(x)
+            m_out = self.mlp(x_norm2)
+
+            # 4. 並列方式
+            x = residual + self.dropout(a_out) + self.dropout(m_out)
+
+            return x
+
+class DRNA_Model(nn.Module):
+    """汎用 DRNA モデルコンテナ(安定化 Pre-Norm 版)"""
+    def __init__(self, vocab_size, d_model=256, n_layers=16, n_heads=8, d_ff=1024):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+
+        self.layers = nn.ModuleList([
+            DRNA_Block(d_model, n_heads, self.head_dim, d_ff) for _ in range(n_layers)
+        ])
+
+        # Pre-Norm構造の場合、最終レイヤーの後に全体のNormを置くのが一般的
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # pad_id が整数(int/long)として有効な場合のみ pad_mask を作成
+            # 退避させた inputs を使ってパディングを判定し因果マスクを準備
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        for layer in self.layers:
+            x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x) # 出力前の最終同期
+        return self.output_head(x)
+
+'''
+260520：maskの微調整(AMP対応)／MoE-LoRA版、vlayer版、D-RNAの活用例を汎用コード化
+260507：Kによる回転で文脈に単語を沿わせ２重らせんの干渉による取捨選択とホログラム合成を可能にする
+260505：model構成から学習解像度を自動化、汎用 mask の精度への適正化、RMSNormへの移行
+260503：padding を引数で指定できるよう変更
+    # 例：一般的な Tokenizer の pad_id が 0 の場合
+    output = model(input_ids, pad_id=0)
+    # 例：Hugging Face 等の tokenizer を使っている場合
+    output = model(input_ids, pad_id=tokenizer.pad_token_id)
+260502：変数名を正確化(head_dim)、汎用 mask に変更し padding 等に対応可
+'''
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''

drna/drna_moe.py

@@ -0,0 +1,226 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+'''
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE･MoE‑LoRA 版
+仕様：Pre-Norm(RMSNorm)、GELU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+汎用コードのコア(Base Weight)を不動の岩盤(ランダム初期化・完全固定)としつつ、
+Attention および MLP の全線形層に LoRA による複数 expert を配置する D-RNA 応用型です
+入力トークン、あるいはシーケンス特性に応じて動的に expert を選択・融合する MoE的拡張版
+'''
+
+class RMSNorm(nn.Module):
+    def __init__(self, d_model, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        norm = x.pow(2).mean(-1, keepdim=True)
+        x_normed = x * torch.rsqrt(norm + self.eps)
+        return self.weight * x_normed
+
+class DRNA_RoPE(nn.Module):
+    """二重らせんの位相を決定する回転場"""
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class MoELoRALinear(nn.Module):
+    """固定されたベース線形層に対して、複数のLoRA Expertを動的にルーティングするMoE構造"""
+    def __init__(self, in_features, out_features, r=16, lora_alpha=16, num_experts=4):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.r = r
+        self.scaling = lora_alpha / r
+        self.num_experts = num_experts
+
+        # 不動の岩盤 (ランダム初期化のまま勾配を固定)
+        self.base_weight = nn.Parameter(torch.empty(out_features, in_features), requires_grad=False)
+        self.base_bias = nn.Parameter(torch.empty(out_features), requires_grad=False)
+        nn.init.kaiming_uniform_(self.base_weight, a=math.sqrt(5))
+        bound = 1 / math.sqrt(in_features) if in_features > 0 else 0
+        nn.init.uniform_(self.base_bias, -bound, bound)
+
+        # MoE-LoRA Experts (学習対象)
+        self.lora_A = nn.Parameter(torch.randn(num_experts, r, in_features) / math.sqrt(in_features))
+        self.lora_B = nn.Parameter(torch.zeros(num_experts, out_features, r))
+
+        # どのExpertをどれだけ使うかを決定するルーター (シーケンス/トークン単位)
+        self.router = nn.Linear(in_features, num_experts)
+
+    def forward(self, x):
+        # 共通のベース出力を計算
+        base_out = F.linear(x, self.base_weight, self.base_bias)
+
+        # ルーティング重みの計算 (Softmaxによるソフトな結合、またはTop-kへの拡張も可能)
+        # x: (B, S, in_features) -> router_logits: (B, S, num_experts)
+        router_logits = self.router(x)
+        router_weights = F.softmax(router_logits, dim=-1).unsqueeze(-1) # (B, S, num_experts)
+
+        # 全ExpertのLoRA出力をループなしで一斉に並列計算
+        # self.lora_A の形状: (num_experts, r, in_features)
+        lora_A_out = torch.einsum("bsi,ejr->bsej", x, self.lora_A)
+
+        # self.lora_B の形状: (num_experts, out_features, r)
+        # -> lora_out_all: (B, S, num_experts, out_features)
+        lora_out_all = torch.einsum("bsej,ekj->bsek", lora_A_out, self.lora_B) * self.scaling
+        # ルーターの重みで加重平均して合流
+        # (B, S, num_experts, out_features) * (B, S, num_experts, 1) -> sum over experts
+        lora_out_total = (lora_out_all * router_weights).sum(dim=2)
+
+        return base_out + lora_out_total
+
+class DRNA_MoE_Block(nn.Module):
+    """DRNA共鳴ブロック：MoE-LoRA並列構造"""
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1, r=16, num_experts=4):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA: 回想系 (Attention)
+        self.norm1 = RMSNorm(d_model)
+        self.qkv = MoELoRALinear(d_model, d_model * 3, r=r, num_experts=num_experts)
+        self.out_proj = MoELoRALinear(d_model, d_model, r=r, num_experts=num_experts)
+
+        # らせんB: 記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model)
+        d_ff = d_ff or d_model * 4
+        
+        # 汎用コードの直列���述を維持するため、Sequentialではなく個別にMoEレイヤを定義
+        self.mlp_in = MoELoRALinear(d_model, d_ff, r=r, num_experts=num_experts)
+        self.mlp_out = MoELoRALinear(d_ff, d_model, r=r, num_experts=num_experts)
+        self.activation = nn.GELU()
+        self.mlp_dropout = nn.Dropout(dropout)
+        
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+        b, s, d = x.shape
+        residual = x
+
+        # らせんA (Attention)
+        x_norm1 = self.norm1(x)
+        qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+        rt_phase = torch.tanh(k_for_phase) * math.pi
+
+        d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+        d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+        q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+        attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+        if mask is not None:
+            attn = attn + mask
+
+        attn = F.softmax(attn, dim=-1)
+        a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+        a_out = self.out_proj(a_out_raw)
+
+        # らせんB (MLP)
+        x_norm2 = self.norm2(x)
+        m_intermediate = self.activation(self.mlp_in(x_norm2))
+        m_out = self.mlp_out(self.mlp_dropout(m_intermediate))
+
+        # 並列方式
+        x = residual + self.dropout(a_out) + self.dropout(m_out)
+        return x
+
+class DRNA_MoE_Model(nn.Module):
+    """汎用 DRNA モデルコンテナ（ランダム初期化ベース＋MoE-LoRA拡張・UTF-8対応版）"""
+    def __init__(self, vocab_size=256, d_model=256, n_layers=16, n_heads=8, d_ff=1024, lora_r=16, num_experts=4):
+        super().__init__()
+        # UTF-8直受けのため、vocab_sizeは固定で256を指定可能
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+
+        self.layers = nn.ModuleList([
+            DRNA_MoE_Block(d_model, n_heads, self.head_dim, d_ff, r=lora_r, num_experts=num_experts) for _ in range(n_layers)
+        ])
+
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # 退避させた inputs でパディング位置を判定
+            # パッドマスクとコーザルマスクを判定(pad_idの型チェック＆テンソルバグ修正)
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        for layer in self.layers:
+            x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x)
+        return self.output_head(x)
+
+'''
+260520：LoRA による MoE(Mixture of Experts) 多重拡張化をする Plugin型です
+学習元モデルをランダム初期化による完全カオス状態(凍結運用)とすることで"公開鍵"的に扱うことが可能となる
+これにより LoRA は"秘密鍵"的に扱える、つまりこの学習元モデルでしか機能しないためセキュリティを堅持できる
+学習元モデルを非公開で秘匿することで情報流出などを抑止した運用も可能になる
+---
+MoE-LoRAによる多重知性拡張－LoRA形式は高効率な学習と推論を可能とします
+学習元モデル単体では具体的な知識や偏りを持たない安全な共通基盤になります(ランダム行列表なので)
+このLoRAは学習元モデルでしか使えないため、LoRA単体だけではなにもできません
+完全非公開・秘匿とすることで、情報流出リスクを極小化したクローズド運用も実現可能です
+学習元モデルのみを公開するオープン運用でMoE-LoRAをみんなで自由に作成し機能向上を図ることも可能です
+---
+マルチモーダル対応：画像･動画･音��などの学習も可能です(必要ならトークナイザ等の差し替えも可能です)
+VAEなどの外付けをせず、UTF8 を用いたトークンで 16x16 パッド化などでViT的な学習もできます
+事前学習(プレトレーニング)もLoRAで行うことで高速化効率化を果たします(応答専用LoRAも学習可)
+純粋な古代語LoRAなどをつくることで現代語に浸食されたり現代語を破壊するような干渉も防げます
+'''
+
+'''
+[ 9B D-RNA ランダムベース重み (共通基盤：完全固定) ] (Dim4096/Layer32などを想定)
+         ├──► 【言語LoRA (各国語/英語)】 ────► 日常対話・創造的執筆
+         ├──► 【視覚パッチLoRA (512px)】 ────► 画像認識・マルチモーダル
+         ├──► 【時間補間LoRA (fps拡張)】 ──► 滑らかな動画生成
+         ├──► 【超解像LoRA (4K拡大)】 ────► 究極のディテール補間
+         └──► 【聴覚パッチLoRA (音声波形)】 ─► 音声認識
+画像：512px生成(主題と背景と物体等の対応関係)─►アップスケール(局所超解像MoE-LoRA)
+動画：512px生成(8fps)─►フレーム補間(60fps)─►空間アップスケール(4K超解像)
+このように位置関係LoRA、精細化LoRA、動体追従LoRA、などを付け足すだけで拡張可能です
+言語も種類問わず、プログラム言語専用、国や地域の固有のもの、歴史的なもの、を干渉防止で学習可能です
+'''
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''

drna/drna_restore.py

@@ -0,0 +1,137 @@
+import torch
+import math
+from typing import List, Tuple
+
+'''
+# チェックポイント読み込み(D-RNA-Trio の学習済みモデル)
+restorer = DRNAWeightRestorer(d_model=256, num_layers=16)
+# fp8/16/32 相当の連続重みの復元
+continuous_weights = restorer.restore_from_checkpoint(
+    'path/to/drna_trio_checkpoint.pth')
+# 結果の確認(多峰性の凸凹分布が観測される)
+print(f"重み分布の最小値: {continuous_weights.min():.4f}")
+print(f"重み分布の最大値: {continuous_weights.max():.4f}")
+print(f"重み分布の標準偏差: {continuous_weights.std():.4f}")
+# 仕組み
+2〜3 レイヤ：fp8相当、4〜6 レイヤ：bf16相当、7+ レイヤ：fp16/32 相当
+固有位相(K-energy × RoPE 周波数成分)を重ね合わせ＋正規化(二重らせんの共鳴収縮により歪みを抑制)
+特に K-for-phase の｢逐次カスケード的変化｣が位相シフトとなり自然な凸凹パターンを生成
+'''
+
+class DRNAWeightRestorer:
+    """
+    D-RNA の固有位相を利用した fp8/16/32 重み復元器
+    チェックポイント読み込み → 位相抽出 → 重ね合わせ → 正規化 で連続分布を生成
+    """
+
+    def __init__(self, d_model: int = 256, num_layers: int = 16):
+        self.d_model = d_model
+        self.num_layers = num_layers
+
+    # チェックポイントから -/0/+ 重みを読み出す
+    def load_ternary_weights(self, checkpoint_path: str) -> List[torch.Tensor]:
+        """ロードされたチェックポイントから各レイヤの重みを抽出する"""
+        checkpoint = torch.load(checkpoint_path, map_location='cuda')
+
+        layer_weights = []
+        for i in range(self.num_layers):
+            # QKV レイヤー(norm1 ブランチ)
+            qkv_weight = checkpoint[f'layers.{i}.qkv.weight']
+
+            # MLP 入力/出力レイヤー（norm2 ブランチ）
+            mlp_0_weight = checkpoint[f'layers.{i}.mlp.0.weight']
+            mlp_3_weight = checkpoint[f'layers.{i}.mlp.3.weight']
+
+            layer_weights.extend([qkv_weight, mlp_0_weight, mlp_3_weight])
+
+        return layer_weights
+
+    # K-for-phase のカスケード効果から各レイヤの固有位相を抽出する
+    def extract_phase_offsets(self, max_seq_len: int = 256) -> List[Tuple[torch.Tensor, torch.Tensor]]:
+        """DRNA の固有位相(K-energy × RoPE 周波数成分)を計算し返す"""
+
+        num_layer_groups = self.num_layers * 3
+
+        phase_data_list = []
+        base_energy = torch.arange(128, dtype=torch.float32, device='cuda') / self.d_model
+
+        for i in range(num_layer_groups):
+            # K-energy のカスケード効果：レイヤごとに滑らかにシフト(K-for-phase 同様に)
+            k_energy = base_energy * (i % self.num_layers + 1)
+
+            # DRNA の動的位相変調: tanh(k_energy) × π
+            rt_phase = math.tanh(k_energy) * math.pi
+
+            # RoPE 的な周波数成分の抽出(各レイヤ固有の周波数パターン)
+            inv_freq = 1.0 / (10000 ** (torch.arange(0, 128, 2).float() / self.d_model))
+
+            freqs = torch.einsum("i,j->ij", 
+                               torch.arange(max_seq_len, device='cuda'),
+                               inv_freq)
+
+            # cos/sin の位相シフトを生成
+            cos_shift = torch.cos(freqs * rt_phase.unsqueeze(-1))
+            sin_shift = torch.sin(freqs * rt_phase.unsqueeze(-1))
+
+            phase_data_list.append((cos_shift, sin_shift))
+
+        return phase_data_list
+
+    # 固有位相を用いて重ね合わせ(RoPE 的な位相変調を適用)
+    def superimpose_weights(
+        self, 
+        layer_weights: List[torch.Tensor], 
+        phase_offsets: List[Tuple[torch.Tensor, torch.Tensor]]
+    ) -> torch.Tensor:
+        """各レイヤの -/0/+ 重みに固有位相を適用し重ね合わせる"""
+
+        reconstructed = torch.zeros_like(layer_weights[0])
+
+        for i, w_i in enumerate(layer_weights):
+            cos_shift, sin_shift = phase_offsets[i]
+
+            # DRNA の K-for-phase 同様の位相変調: d_cos / d_sin を用いる重ね合わせ
+            contribution = w_i * (cos_shift - rotate_half(w_i) * sin_shift)
+            reconstructed += contribution
+
+        return reconstructed
+
+    # RMSNorm 的な正規化(3 値歪みのリセット)
+    def normalize(self, x: torch.Tensor) -> torch.Tensor:
+        """重ね合わせ後の分布を RMSNorm で安定化する"""
+
+        mean = x.mean(-1, keepdim=True)
+        var = x.var(-1, keepdim=True, unbiased=False)
+
+        # 中心化・標準化(3 値歪みのリセット)
+        return (x - mean) * torch.rsqrt(var + 1e-8)
+
+    # 完全復元パイプライン
+    def restore_from_checkpoint(
+        self, 
+        checkpoint_path: str, 
+        max_seq_len: int = 256
+    ) -> torch.Tensor:
+        """チェ���クポイントを読み込み、fp8/16 相当の連続重みを生成する"""
+
+        # -1.0/0.0/1.0 重みの読み出し
+        layer_weights = self.load_ternary_weights(checkpoint_path)
+
+        # 固有位相(K-energy × RoPE)の抽出
+        phase_offsets = self.extract_phase_offsets(max_seq_len)
+
+        # 重ね合わせ(RoPE 的な位相変調を適用)
+        continuous_weight = self.superimpose_weights(
+            layer_weights, 
+            phase_offsets)
+
+        # RMSNorm 的な正規化
+        normalized_weight = self.normalize(continuous_weight)
+
+        return normalized_weight
+
+# 補助関数: DRNA rotate_half 再現
+def rotate_half(x):
+    """D-RNA の K-for-phase 同様の回転操作(位相変調の右辺項)"""
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)

drna/drna_swi_restore.py

@@ -0,0 +1,142 @@
+import torch
+import math
+from typing import List, Tuple
+
+'''
+# チェックポイント読み込み(D-RNA-Trio の学習済みモデル)
+restorer = DRNAWeightRestorer(d_model=256, num_layers=16)
+# fp8/16/32 相当の連続重みの復元
+continuous_weights = restorer.restore_from_checkpoint(
+    'path/to/drna_trio_checkpoint.pth')
+# 結果の確認(多峰性の凸凹分布が観測される)
+print(f"重み分布の最小値: {continuous_weights.min():.4f}")
+print(f"重み分布の最大値: {continuous_weights.max():.4f}")
+print(f"重み分布の標準偏差: {continuous_weights.std():.4f}")
+# 仕組み
+2〜3 レイヤ：fp8相当、4〜6 レイヤ：bf16相当、7+ レイヤ：fp16/32 相当
+固有位相(K-energy × RoPE 周波数成分)を重ね合わせ＋正規化(二重らせんの共鳴収縮により歪みを抑制)
+特に K-for-phase の｢逐次カスケード的変化｣が位相シフトとなり自然な凸凹パターンを生成
+'''
+
+class DRNAWeightRestorer:
+    """
+    D-RNA の固有位相を利用した fp8/16/32 重み復元器
+    チェックポイント読み込み → 位相抽出 → 重ね合わせ → 正規化 で連続分布を生成
+    """
+
+    def __init__(self, d_model: int = 256, num_layers: int = 16):
+        self.d_model = d_model
+        self.num_layers = num_layers
+
+    # チェックポイントから -/0/+ 重みを読み出す
+    def load_ternary_weights(self, checkpoint_path: str) -> List[torch.Tensor]:
+        """ロードされたチェックポイントから各レイヤの重みを抽出する"""
+        checkpoint = torch.load(checkpoint_path, map_location='cuda')
+
+        layer_weights = []
+        for i in range(self.num_layers):
+            # QKV レイヤー(norm1 ブランチ)
+            qkv_weight = checkpoint[f'layers.{i}.qkv.weight']
+
+            # MLP 入力/出力レイヤー(norm2 ブランチ)w3 も取得する
+            # 旧 mlp.0.weight 相当 ──> ゲート用 w1
+            mlp_w1_weight = checkpoint[f'layers.{i}.w1.weight']
+            # SwiGLU対応による拡張部分 ──> アッププロジェクション w3
+            mlp_w3_weight = checkpoint[f'layers.{i}.w3.weight']
+            # 旧 mlp.3 (絞るLinear) ──> ダウンプロジェクション w2
+            mlp_w2_weight = checkpoint[f'layers.{i}.w2.weight']
+
+            # 4つの重みをすべてリストに格納(qkv, w1, w3, w2)
+            layer_weights.extend([qkv_weight, mlp_w1_weight, mlp_w3_weight, mlp_w2_weight])
+
+        return layer_weights
+
+    # K-for-phase のカスケード効果から各レイヤの固有位相を抽出する
+    def extract_phase_offsets(self, max_seq_len: int = 256) -> List[Tuple[torch.Tensor, torch.Tensor]]:
+        """DRNA の固有位相(K-energy × RoPE 周波数成分)を計算し返す"""
+
+        num_layer_groups = self.num_layers * 4
+
+        phase_data_list = []
+        base_energy = torch.arange(128, dtype=torch.float32, device='cuda') / self.d_model
+
+        for i in range(num_layer_groups):
+            # K-energy のカスケード効果：レイヤごとに滑らかにシフト(K-for-phase 同様に)
+            k_energy = base_energy * (i % self.num_layers + 1)
+
+            # DRNA の動的位相変調: tanh(k_energy) × π
+            rt_phase = math.tanh(k_energy) * math.pi
+
+            # RoPE 的な周波数成分の抽出(各レイヤ固有の周波数パターン)
+            inv_freq = 1.0 / (10000 ** (torch.arange(0, 128, 2).float() / self.d_model))
+
+            freqs = torch.einsum("i,j->ij", 
+                               torch.arange(max_seq_len, device='cuda'),
+                               inv_freq)
+
+            # cos/sin の位相シフトを生成
+            cos_shift = torch.cos(freqs * rt_phase.unsqueeze(-1))
+            sin_shift = torch.sin(freqs * rt_phase.unsqueeze(-1))
+
+            phase_data_list.append((cos_shift, sin_shift))
+
+        return phase_data_list
+
+    # 固有位相を用いて重ね合わせ(RoPE 的な位相変調を適用)
+    def superimpose_weights(
+        self, 
+        layer_weights: List[torch.Tensor], 
+        phase_offsets: List[Tuple[torch.Tensor, torch.Tensor]]
+    ) -> torch.Tensor:
+        """各レイヤの -/0/+ 重みに固有位相を適用し重ね合わせる"""
+
+        reconstructed = torch.zeros_like(layer_weights[0])
+
+        for i, w_i in enumerate(layer_weights):
+            cos_shift, sin_shift = phase_offsets[i]
+
+            # DRNA の K-for-phase 同様の位相変調: d_cos / d_sin を用いる重ね合わせ
+            contribution = w_i * (cos_shift - rotate_half(w_i) * sin_shift)
+            reconstructed += contribution
+
+        return reconstructed
+
+    # RMSNorm 的な正規化(3 値歪みのリセット)
+    def normalize(self, x: torch.Tensor) -> torch.Tensor:
+        """重ね合わせ後の分布を RMSNorm で安定化する"""
+
+        mean = x.mean(-1, keepdim=True)
+        var = x.var(-1, keepdim=True, unbiased=False)
+
+        # 中心化・標準化(3 値歪みのリセット)
+        return (x - mean) * torch.rsqrt(var + 1e-8)
+
+    # 完全復元パイプライン
+    def restore_from_checkpoint(
+        self, 
+        checkpoint_path: str, 
+        max_seq_len: int = 256
+    ) -> torch.Tensor:
+        """チェックポイントを読み込み、fp8/16 相当の連続重みを生成する"""
+
+        # -1.0/0.0/1.0 重みの読み出し
+        layer_weights = self.load_ternary_weights(checkpoint_path)
+
+        # 固有位相(K-energy × RoPE)の抽出
+        phase_offsets = self.extract_phase_offsets(max_seq_len)
+
+        # 重ね合わせ(RoPE 的な位相変調を適用)
+        continuous_weight = self.superimpose_weights(
+            layer_weights, 
+            phase_offsets)
+
+        # RMSNorm 的な正規化
+        normalized_weight = self.normalize(continuous_weight)
+
+        return normalized_weight
+
+# 補助関数: DRNA rotate_half 再現
+def rotate_half(x):
+    """D-RNA の K-for-phase 同様の回転操作(位相変調の右辺項)"""
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)

drna/drna_swi_triox.py

@@ -0,0 +1,323 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+'''
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE 版
+仕様：Pre-Norm(RMSNorm)、GELU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+Transformerの全接続性を継承しつつ、二重らせん(Dual-Helix)構造による
+｢共鳴収縮｣(Resonant Contraction)を物理的に再現したニューラルアーキテクチャです
+D-RNA の位相設計と Trio Induction system により３値学習を STE に頼らず安定的に行えます
+これは STE で機能しない optimiser などを３値学習へ活用できるようになります
+将来的に３値モデルを位相差の重ねによる疑似重みをつくり、これを学習対象にして３値学習もおこなえるはずです
+つまり学習元も３値モデルにできるはずです、推論も学習も３値で済むようになる最初の１歩です
+'''
+
+# 3値誘導制御コア(モデルの書き換え、3値ブレンド、ペナルティ計算、結晶化)
+class TernaryTrainingManager:
+    """
+    D-RNAのコードに触れることなく、3値誘導の全ライフサイクルを統括する抽象化マネージャー。
+    """
+    def __init__(self, model, warmup_steps=100, max_lambda=1.0):
+        self.model = model
+        self.warmup_steps = warmup_steps
+        self.max_lambda = max_lambda
+        self.current_step = 0
+        self.total_steps = 0
+        
+        # 内部で利用するステッププロバイダー関数
+        def step_provider():
+            return self.current_step, self.total_steps
+            
+        # 1. モデル内の全2次元重みにフックを外付け
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Linear):
+                # ★ 拡張性：LLMの生命線である「embed」と「output_head」は絶対に3値化しない
+                if "embed" in name or "output_head" in name:
+                    continue
+                if not hasattr(module, "raw_weight"):
+                    # 元の実数重みを聖域(raw_weight)に退避
+                    module.register_parameter("raw_weight", nn.Parameter(module.weight.data.clone()))
+                    delattr(module, "weight")
+                    module.register_buffer("weight", module.raw_weight.data.clone())
+                module.register_forward_pre_hook(TernaryWeightHook(step_provider, self.warmup_steps))
+
+    def amend_loss(self, task_loss, step, total_steps):
+        """
+        【ループ内抽象化用】
+        メインのタスク損失（CrossEntropy等）を受け取り、
+        現在のステップに応じた3値結晶化ペナルティを自動計算して合算した損失を返します。
+        """
+        self.current_step = step
+        self.total_steps = total_steps
+        
+        blend_ratio = get_ternary_schedule(step, total_steps, self.warmup_steps)
+        current_lambda = blend_ratio * self.max_lambda
+        
+        if current_lambda == 0.0:
+            return task_loss
+            
+        # 3値誘導トリプレット・ペナルティ自動計算
+        ternary_penalty = 0.0
+        for name, param in self.model.named_parameters():
+            # 2次元以上の重み（LinearやEmbeddingの実数聖域）のみを対象とする
+            if "raw_weight" in name and param.dim() >= 2:
+                # W * (W - 1) * (W + 1) = W^3 - W を0に近づける（-1, 0, 1への収束強制力）
+                ternary_penalty += torch.mean(param * (param - 1.0) * (param + 1.0)) ** 2
+                
+        return task_loss + current_lambda * ternary_penalty
+
+    def export_ternary(self):
+        """学習終了後、モデルの全2次元重みを完全な[-1.0, 0.0, 1.0]へ固定（結晶化）する"""
+        with torch.no_grad():
+            for name, module in self.model.named_modules():
+                if isinstance(module, nn.Linear):
+                    # 拡張性：LLMの生命線である「embed」と「output_head」は絶対に3値化しない
+                    if "embed" in name or "output_head" in name:
+                        continue
+                    # raw_weight があればそっちを本体として使う
+                    if hasattr(module, "raw_weight"):
+                        param = module.raw_weight
+                    else:
+                        param = module.weight
+                    # 学習中と同じ写像：tanh(3w) で soft 3値ターゲットを作る
+                    soft = torch.tanh(param * 3.0)
+                    # soft を hard 3値に潰す
+                    ternary = torch.zeros_like(soft)
+                    ternary[soft >  0.08] =  1.0
+                    ternary[soft < -0.08] = -1.0
+                    # 実数パラメータ自体を3値に上書きして完全固定
+                    if hasattr(module, "raw_weight"):
+                        module.raw_weight.copy_(ternary)
+                    module.weight.copy_(ternary)
+
+        return self.model
+
+
+# 3値誘導外付けフックシステム(2次元重みを3値ブレンド）
+def get_ternary_schedule(step, total_steps, warmup_steps=100):
+    """逆転コサインアニーリングスケジューラ"""
+    if step < warmup_steps:
+        return 0.0
+    anneal_steps = total_steps - warmup_steps
+    progress = (step - warmup_steps) / anneal_steps
+    return 1.0 - (0.5 * (1.0 + math.cos(progress * math.pi)))
+
+def get_soft_ternary_weight(param, step, total_steps, warmup_steps=100):
+    """勾配直通バイパス型 3値ブレンド関数"""
+    if param.dim() < 2:  # 1次元パラメータは保護
+        return param
+    blend_ratio = get_ternary_schedule(step, total_steps, warmup_steps)
+    if blend_ratio == 0.0:
+        return param
+    with torch.no_grad():
+        ternary_target = torch.tanh(param * 3.0)
+    # 【最重要】生の勾配を裏に直通させるバイパス構造
+    return param + blend_ratio * (ternary_target - param)
+
+class TernaryWeightHook:
+    def __init__(self, step_provider, warmup_steps=100):
+        self.step_provider = step_provider
+        self.warmup_steps = warmup_steps
+
+    def __call__(self, module, inputs):
+        step, total_steps = self.step_provider()
+        if step is not None and total_steps is not None:
+            # バックアップした実数重み(raw_weight)から疑似3値重みを計算し、一時的に上書き
+            module.weight.data = get_soft_ternary_weight(module.raw_weight, step, total_steps, self.warmup_steps)
+
+def apply_trio_induction(model, step_provider, warmup_steps=100):
+    """モデルを汚さずに外側から3値化プラグインを刺す関数"""
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            # ★ 拡張性：LLMの生命線である「embed」と「output_head」は絶対に3値化しない
+            if "embed" in name or "output_head" in name:
+                continue
+            if not hasattr(module, "raw_weight"):
+                # 元の実数重みを聖域（raw_weight）に退避
+                module.register_parameter("raw_weight", nn.Parameter(module.weight.data.clone()))
+                delattr(module, "weight")
+                module.register_buffer("weight", module.raw_weight.data.clone())
+            module.register_forward_pre_hook(TernaryWeightHook(step_provider, warmup_steps))
+
+# D-RNA 3値化のパニックを100%いなすコンサルタント(RMSNorm 修正)
+class RMSNorm(nn.Module):
+    """【修正版】3値化の歪みをリセットする中心化・標準化型防波堤"""
+    def __init__(self, d_model, eps=1e-8):
+        super().__init__()
+        self.eps = eps
+        # 3値化の歪みによってズレた「音量の軸」を、フル精度の実数で強制的に中心に戻すバイアス
+        self.bias = nn.Parameter(torch.zeros(d_model))
+        # 3値化のせいで極端にインフレ・デフレした次元ごとの音量を、個別にジャストフィットさせる実数スケール
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        # 1. 各次元ごとの平均と分散を計算
+        mean = x.mean(-1, keepdim=True)
+        var = x.var(-1, keepdim=True, unbiased=False)
+        
+        # 2. 3値化による「歪み・偏り」を、ここで完全にリセット（標準化）する
+        x_normed = (x - mean) * torch.rsqrt(var + self.eps)
+        
+        # 3. リセットされた綺麗な状態に対して、フル精度のオプティマイザが最適なスケールとオフセットを施す
+        return self.weight * x_normed + self.bias
+
+class DRNA_RoPE(nn.Module):
+    """二重らせんの位相を決定する回転場"""
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    """Kによる動的位相変調済み cos/sin を受け取る"""
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class DRNA_Block(nn.Module):
+    """DRNA共鳴ブロック：安定性を高めたPre-Norm直列共鳴構造"""
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA：回想系 (Attention)
+        self.norm1 = RMSNorm(d_model) # 演算の前に配置
+        self.qkv = nn.Linear(d_model, d_model * 3)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        # らせんB：記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model) # 演算の前に配置
+
+        # SwiGLUの定石：パラメータ量をGELU版(×4倍)と合わせるため、約2.67倍(8/3)にする
+        if d_ff is None:
+            d_ff = int(2 * (d_model * 4) / 3) 
+            
+        # SwiGLUは入力に対して2つのLinear(Gate･Up)を並列に走らせます
+        self.w1 = nn.Linear(d_model, d_ff, bias=False) # ゲート用
+        self.w3 = nn.Linear(d_model, d_ff, bias=False) # 値用（アッププロジェクション）
+        self.w2 = nn.Linear(d_ff, d_model, bias=False) # ダウンプロジェクション
+
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+        b, s, d = x.shape
+
+        # 共通の残差(ベースとなる螺旋の軸)
+        residual = x
+
+        # らせんA (Attention) 並列方式
+        x_norm1 = self.norm1(x)
+
+        # QKV生成 (3倍のまま)
+        # ※ self.qkv(x_norm) が x_norm1 になっているか確認してください
+        qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        # K因果的動的回転：一つ前の単語の K が今の単語の座標を決める
+        # 自分の情報で自分を回さないよう、Kを1つ未来にシフトさせる
+        # これにより｢赤い(K)｣が｢猫(Q,K)｣の位相を決定する構造になる
+        k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+
+        # Kのエネルギーを位相(回転角)に変換
+        rt_phase = torch.tanh(k_for_phase) * math.pi
+
+        # 静的RoPE (cos, sin) を動的位相 (rt_phase) で加法定理により変調
+        # ※ apply_drna_rope に rt_phase を渡せるように関数側を調整するか、
+        # ここで dynamic_cos / sin を作って渡します
+        d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+        d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+        # ２重らせんをつくる (変調された座標で回転)
+        q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+        # Attention計算
+        attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+        if mask is not None:
+            attn = attn + mask
+
+        attn = F.softmax(attn, dim=-1)
+        a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+        a_out = self.out_proj(a_out_raw)
+
+        # らせんB (MLP)
+        x_norm2 = self.norm2(x)
+
+        # SwiGLUのコア数式: Swish(xW1) * xW3(F.silu：PyTorchのSwish関数)
+        gate = F.silu(self.w1(x_norm2)) 
+        current_value = self.w3(x_norm2)
+        
+        # 要素積（共鳴収縮の表現としても非常に相性が良いです）
+        swiglu_out = gate * current_value 
+        
+        # 最終投影
+        m_out = self.w2(swiglu_out)
+
+        # 並列方式
+        x = residual + self.dropout(a_out) + self.dropout(m_out)
+
+        return x
+
+class DRNA_Model(nn.Module):
+    """汎用 DRNA モデルコンテナ(安定化 Pre-Norm 版)"""
+    def __init__(self, vocab_size, d_model=256, n_layers=16, n_heads=8, d_ff=1024):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+
+        self.layers = nn.ModuleList([
+            DRNA_Block(d_model, n_heads, self.head_dim, d_ff) for _ in range(n_layers)
+        ])
+
+        # Pre-Norm構造の場合、最終レイヤーの後に全体のNormを置くのが一般的
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # pad_id が整数(int/long)として有効な場合のみ pad_mask を作成
+            # 退避させた inputs を使ってパディングを判定し因果マスクを準備
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        for layer in self.layers:
+            x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x) # 出力前の最終同期
+        return self.output_head(x)
+
+'''
+260528：３値モデル(-、0、+)学習対応／活用例"D-RNA-SwiGLU-Trio"版を追加(Trio Induction)
+260528：３値モデル(-、0、+)学習対応／活用例"D-RNA-Trio"版を追加(Trio Induction)
+260520：maskの微調整(AMP対応)／MoE-LoRA版、vlayer版、D-RNAの活用例を汎用コード化
+'''
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''

drna/drna_swiglu.py

@@ -0,0 +1,192 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+'''
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE 版
+仕様：Pre-Norm(RMSNorm)、SwiGLU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+Transformerの全接続性を継承しつつ、二重らせん(Dual-Helix)構造による
+｢共鳴収縮｣(Resonant Contraction)を物理的に再現したニューラルアーキテクチャです
+螺旋の同期：Attention(文脈の回想)とMLP(知識の定着)を並列配置し RoPE で情報を同期
+位相の保持：RoPE(Phase Field)を回転場として利用し、安定した相対位置を保ち早期収束を両立
+高密度圧縮：Pre-Norm により、各らせんを安定的に収縮させ、全結合により記憶を定着させる
+'''
+
+class RMSNorm(nn.Module):
+    def __init__(self, d_model, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        # 2乗平均の平方根で割る(平均を減算しない･中心化をしない)
+        norm = x.pow(2).mean(-1, keepdim=True)
+        x_normed = x * torch.rsqrt(norm + self.eps)
+        return self.weight * x_normed
+
+class DRNA_RoPE(nn.Module):
+    """二重らせんの位相を決定する回転場"""
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    """Kによる動的位相変調済み cos/sin を受け取る"""
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class DRNA_Block(nn.Module):
+    """DRNA共鳴ブロック：安定性を高めたPre-Norm直列共鳴構造"""
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA：回想系 (Attention)
+        self.norm1 = RMSNorm(d_model) # 演算の前に配置
+        self.qkv = nn.Linear(d_model, d_model * 3)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        # らせんB：記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model) # 演算の前に配置
+
+        # SwiGLUの定石：パラメータ量をGELU版(×4倍)と合わせるため、約2.67倍(8/3)にする
+        if d_ff is None:
+            d_ff = int(2 * (d_model * 4) / 3) 
+            
+        # SwiGLUは入力に対して2つのLinear(Gate･Up)を並列に走らせます
+        self.w1 = nn.Linear(d_model, d_ff, bias=False) # ゲート用
+        self.w3 = nn.Linear(d_model, d_ff, bias=False) # 値用（アッププロジェクション）
+        self.w2 = nn.Linear(d_ff, d_model, bias=False) # ダウンプロジェクション
+
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+        b, s, d = x.shape
+
+        # 共通の残差(ベースとなる螺旋の軸)
+        residual = x
+
+        # らせんA (Attention) 並列方式
+        x_norm1 = self.norm1(x)
+
+        # QKV生成 (3倍のまま)
+        # ※ self.qkv(x_norm) が x_norm1 になっているか確認してください
+        qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        # K因果的動的回転：一つ前の単語の K が今の単語の座標を決める
+        # 自分の情報で自分を回さないよう、Kを1つ未来にシフトさせる
+        # これにより｢赤い(K)｣が｢猫(Q,K)｣の位相を決定する構造になる
+        k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+
+        # Kのエネルギーを位相(回転角)に変換
+        rt_phase = torch.tanh(k_for_phase) * math.pi
+
+        # 静的RoPE (cos, sin) を動的位相 (rt_phase) で加法定理により変調
+        # ※ apply_drna_rope に rt_phase を渡せるように関数側を調整するか、
+        # ここで dynamic_cos / sin を作って渡します
+        d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+        d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+        # ２重らせんをつくる (変調された座標で回転)
+        q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+        # Attention計算
+        attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+        if mask is not None:
+            attn = attn + mask
+
+        attn = F.softmax(attn, dim=-1)
+        a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+        a_out = self.out_proj(a_out_raw)
+
+        # らせんB (MLP)
+        x_norm2 = self.norm2(x)
+
+        # SwiGLUのコア数式: Swish(xW1) * xW3(F.silu：PyTorchのSwish関数)
+        gate = F.silu(self.w1(x_norm2)) 
+        current_value = self.w3(x_norm2)
+        
+        # 要素積（共鳴収縮の表現としても非常に相性が良いです）
+        swiglu_out = gate * current_value 
+        
+        # 最終投影
+        m_out = self.w2(swiglu_out)
+
+        # 並列方式
+        x = residual + self.dropout(a_out) + self.dropout(m_out)
+
+        return x
+
+class DRNA_Model(nn.Module):
+    """汎用 DRNA モデルコンテナ(安定化 Pre-Norm 版)"""
+    def __init__(self, vocab_size, d_model=256, n_layers=16, n_heads=8, d_ff=1024):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+
+        self.layers = nn.ModuleList([
+            DRNA_Block(d_model, n_heads, self.head_dim, d_ff) for _ in range(n_layers)
+        ])
+
+        # Pre-Norm構造の場合、最終レイヤーの後に全体のNormを置くのが一般的
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # pad_id が整数(int/long)として有効な場合のみ pad_mask を作成
+            # 退避させた inputs を使ってパディングを判定し因果マスクを準備
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        for layer in self.layers:
+            x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x) # 出力前の最終同期
+        return self.output_head(x)
+
+'''
+260528：SwiGLU構成／動的ゲート制御(d_ff で Dropout せず、w2 で d_model 凝縮直後で適用)
+260520：maskの微調整(AMP対応)／MoE-LoRA版、vlayer版、D-RNAの活用例を汎用コード化
+260507：Kによる回転で文脈に単語を沿わせ２重らせんの干渉による取捨選択とホログラム合成を可能にする
+260505：model構成から学習解像度を自動化、汎用 mask の精度への適正化、RMSNormへの移行
+260503：padding を引数で指定できるよう変更
+    # 例：一般的な Tokenizer の pad_id が 0 の場合
+    output = model(input_ids, pad_id=0)
+    # 例：Hugging Face 等の tokenizer を使っている場合
+    output = model(input_ids, pad_id=tokenizer.pad_token_id)
+260502：変数名を正確化(head_dim)、汎用 mask に変更し padding 等に対応可
+'''
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''

drna/drna_triox.py

@@ -0,0 +1,310 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+'''
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE 版
+仕様：Pre-Norm(RMSNorm)、GELU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+Transformerの全接続性を継承しつつ、二重らせん(Dual-Helix)構造による
+｢共鳴収縮｣(Resonant Contraction)を物理的に再現したニューラルアーキテクチャです
+D-RNA の位相設計と Trio Induction system により３値学習を STE に頼らず安定的に行えます
+これは STE で機能しない optimiser などを３値学習へ活用できるようになります
+将来的に３値モデルを位相差の重ねによる疑似重みをつくり、これを学習対象にして３値学習もおこなえるはずです
+つまり学習元も３値モデルにできるはずです、推論も学習も３値で済むようになる最初の１歩です
+'''
+
+# 3値誘導制御コア(モデルの書き換え、3値ブレンド、ペナルティ計算、結晶化)
+class TernaryTrainingManager:
+    """
+    D-RNAのコードに触れることなく、3値誘導の全ライフサイクルを統括する抽象化マネージャー。
+    """
+    def __init__(self, model, warmup_steps=100, max_lambda=1.0):
+        self.model = model
+        self.warmup_steps = warmup_steps
+        self.max_lambda = max_lambda
+        self.current_step = 0
+        self.total_steps = 0
+        
+        # 内部で利用するステッププロバイダー関数
+        def step_provider():
+            return self.current_step, self.total_steps
+            
+        # 1. モデル内の全2次元重みにフックを外付け
+        for name, module in self.model.named_modules():
+            if isinstance(module, nn.Linear):
+                # ★ 拡張性：LLMの生命線である「embed」と「output_head」は絶対に3値化しない
+                if "embed" in name or "output_head" in name:
+                    continue
+                if not hasattr(module, "raw_weight"):
+                    # 元の実数重みを聖域(raw_weight)に退避
+                    module.register_parameter("raw_weight", nn.Parameter(module.weight.data.clone()))
+                    delattr(module, "weight")
+                    module.register_buffer("weight", module.raw_weight.data.clone())
+                module.register_forward_pre_hook(TernaryWeightHook(step_provider, self.warmup_steps))
+
+    def amend_loss(self, task_loss, step, total_steps):
+        """
+        【ループ内抽象化用】
+        メインのタスク損失（CrossEntropy等）を受け取り、
+        現在のステップに応じた3値結晶化ペナルティを自動計算して合算した損失を返します。
+        """
+        self.current_step = step
+        self.total_steps = total_steps
+        
+        blend_ratio = get_ternary_schedule(step, total_steps, self.warmup_steps)
+        current_lambda = blend_ratio * self.max_lambda
+        
+        if current_lambda == 0.0:
+            return task_loss
+            
+        # 3値誘導トリプレット・ペナルティ自動計算
+        ternary_penalty = 0.0
+        for name, param in self.model.named_parameters():
+            # 2次元以上の重み（LinearやEmbeddingの実数聖域）のみを対象とする
+            if "raw_weight" in name and param.dim() >= 2:
+                # W * (W - 1) * (W + 1) = W^3 - W を0に近づける（-1, 0, 1への収束強制力）
+                ternary_penalty += torch.mean(param * (param - 1.0) * (param + 1.0)) ** 2
+                
+        return task_loss + current_lambda * ternary_penalty
+
+    def export_ternary(self):
+        """学習終了後、モデルの全2次元重みを完全な[-1.0, 0.0, 1.0]へ固定（結晶化）する"""
+        with torch.no_grad():
+            for name, module in self.model.named_modules():
+                if isinstance(module, nn.Linear):
+                    # 拡張性：LLMの生命線である「embed」と「output_head」は絶対に3値化しない
+                    if "embed" in name or "output_head" in name:
+                        continue
+                    # raw_weight があればそっちを本体として使う
+                    if hasattr(module, "raw_weight"):
+                        param = module.raw_weight
+                    else:
+                        param = module.weight
+                    # 学習中と同じ写像：tanh(3w) で soft 3値ターゲットを作る
+                    soft = torch.tanh(param * 3.0)
+                    # soft を hard 3値に潰す
+                    ternary = torch.zeros_like(soft)
+                    ternary[soft >  0.08] =  1.0
+                    ternary[soft < -0.08] = -1.0
+                    # 実数パラメータ自体を3値に上書きして完全固定
+                    if hasattr(module, "raw_weight"):
+                        module.raw_weight.copy_(ternary)
+                    module.weight.copy_(ternary)
+
+        return self.model
+
+
+# 3値誘導外付けフックシステム(2次元重みを3値ブレンド）
+def get_ternary_schedule(step, total_steps, warmup_steps=100):
+    """逆転コサインアニーリングスケジューラ"""
+    if step < warmup_steps:
+        return 0.0
+    anneal_steps = total_steps - warmup_steps
+    progress = (step - warmup_steps) / anneal_steps
+    return 1.0 - (0.5 * (1.0 + math.cos(progress * math.pi)))
+
+def get_soft_ternary_weight(param, step, total_steps, warmup_steps=100):
+    """勾配直通バイパス型 3値ブレンド関数"""
+    if param.dim() < 2:  # 1次元パラメータは保護
+        return param
+    blend_ratio = get_ternary_schedule(step, total_steps, warmup_steps)
+    if blend_ratio == 0.0:
+        return param
+    with torch.no_grad():
+        ternary_target = torch.tanh(param * 3.0)
+    # 【最重要】生の勾配を裏に直通させるバイパス構造
+    return param + blend_ratio * (ternary_target - param)
+
+class TernaryWeightHook:
+    def __init__(self, step_provider, warmup_steps=100):
+        self.step_provider = step_provider
+        self.warmup_steps = warmup_steps
+
+    def __call__(self, module, inputs):
+        step, total_steps = self.step_provider()
+        if step is not None and total_steps is not None:
+            # バックアップした実数重み(raw_weight)から疑似3値重みを計算し、一時的に上書き
+            module.weight.data = get_soft_ternary_weight(module.raw_weight, step, total_steps, self.warmup_steps)
+
+def apply_trio_induction(model, step_provider, warmup_steps=100):
+    """モデルを汚さずに外側から3値化プラグインを刺す関数"""
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            # ★ 拡張性：LLMの生命線である「embed」と「output_head」は絶対に3値化しない
+            if "embed" in name or "output_head" in name:
+                continue
+            if not hasattr(module, "raw_weight"):
+                # 元の実数重みを聖域（raw_weight）に退避
+                module.register_parameter("raw_weight", nn.Parameter(module.weight.data.clone()))
+                delattr(module, "weight")
+                module.register_buffer("weight", module.raw_weight.data.clone())
+            module.register_forward_pre_hook(TernaryWeightHook(step_provider, warmup_steps))
+
+# D-RNA 3値化のパニックを100%いなすコンサルタント(RMSNorm 修正)
+class RMSNorm(nn.Module):
+    """【修正版】3値化の歪みをリセットする中心化・標準化型防波堤"""
+    def __init__(self, d_model, eps=1e-8):
+        super().__init__()
+        self.eps = eps
+        # 3値化の歪みによってズレた「音量の軸」を、フル精度の実数で強制的に中心に戻すバイアス
+        self.bias = nn.Parameter(torch.zeros(d_model))
+        # 3値化のせいで極端にインフレ・デフレした次元ごとの音量を、個別にジャストフィットさせる実数スケール
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        # 1. 各次元ごとの平均と分散を計算
+        mean = x.mean(-1, keepdim=True)
+        var = x.var(-1, keepdim=True, unbiased=False)
+        
+        # 2. 3値化による「歪み・偏り」を、ここで完全にリセット（標準化）する
+        x_normed = (x - mean) * torch.rsqrt(var + self.eps)
+        
+        # 3. リセットされた綺麗な状態に対して、フル精度のオプティマイザが最適なスケールとオフセットを施す
+        return self.weight * x_normed + self.bias
+
+class DRNA_RoPE(nn.Module):
+    """二重らせんの位相を決定する回転場"""
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    """Kによる動的位相変調済み cos/sin を受け取る"""
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class DRNA_Block(nn.Module):
+    """DRNA共鳴ブロック：安定性を高めたPre-Norm直列共鳴構造"""
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA: 回想系 (Attention)
+        self.norm1 = RMSNorm(d_model) # 演算の前に配置
+        self.qkv = nn.Linear(d_model, d_model * 3)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        # らせんB: 記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model) # 演算の前に配置
+        d_ff = d_ff or d_model * 4
+        self.mlp = nn.Sequential(
+            nn.Linear(d_model, d_ff),
+            nn.GELU(), # VRAM抑制は ReLU (別レイヤの干渉で0勾配にならない｢可能性｣あり)
+            nn.Dropout(dropout),
+            nn.Linear(d_ff, d_model)
+        )
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+            b, s, d = x.shape
+
+            # 1. 共通の残差(ベースとなる螺旋の軸)
+            residual = x
+
+            # 2. らせんA (Attention) 並列方式
+            x_norm1 = self.norm1(x)
+
+            # QKV生成 (3倍のまま)
+            # ※ self.qkv(x_norm) が x_norm1 になっているか確認してください
+            qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+            q, k, v = qkv[0], qkv[1], qkv[2]
+
+            # K因果的動的回転：一つ前の単語の K が今の単語の座標を決める
+            # 自分の情報で自分を回さないよう、Kを1つ未来にシフトさせる
+            # これにより｢赤い(K)｣が｢猫(Q,K)｣の位相を決定する構造になる
+            k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+
+            # Kのエネルギーを位相(回転角)に変換
+            rt_phase = torch.tanh(k_for_phase) * math.pi
+
+            # 静的RoPE (cos, sin) を動的位相 (rt_phase) で加法定理により変調
+            # ※ apply_drna_rope に rt_phase を渡せるように関数側を調整するか、
+            # ここで dynamic_cos / sin を作って渡します
+            d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+            d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+            # ２重らせんをつくる (変調された座標で回転)
+            q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+            # Attention計算
+            attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+            if mask is not None:
+                attn = attn + mask
+
+            attn = F.softmax(attn, dim=-1)
+            a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+            a_out = self.out_proj(a_out_raw)
+
+            # 3. らせんB (MLP)
+            x_norm2 = self.norm2(x)
+            m_out = self.mlp(x_norm2)
+
+            # 4. 並列方式
+            x = residual + self.dropout(a_out) + self.dropout(m_out)
+
+            return x
+
+class DRNA_Model(nn.Module):
+    """汎用 DRNA モデルコンテナ(安定化 Pre-Norm 版)"""
+    def __init__(self, vocab_size, d_model=256, n_layers=16, n_heads=8, d_ff=1024):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+
+        self.layers = nn.ModuleList([
+            DRNA_Block(d_model, n_heads, self.head_dim, d_ff) for _ in range(n_layers)
+        ])
+
+        # Pre-Norm構造の場合、最終レイヤーの後に全体のNormを置くのが一般的
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # pad_id が整数(int/long)として有効な場合のみ pad_mask を作成
+            # 退避させた inputs を使ってパディングを判定し因果マスクを準備
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        for layer in self.layers:
+            x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x) # 出力前の最終同期
+        return self.output_head(x)
+
+'''
+260528：３値モデル(-、0、+)学習対応／活用例"D-RNA-Trio"版を追加(Trio Induction)
+260520：maskの微調整(AMP対応)／MoE-LoRA版、vlayer版、D-RNAの活用例を汎用コード化
+'''
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''

drna/drna_triox_log.txt

@@ -0,0 +1,433 @@
+none-STE、ternary_schedule、amend_loss、
+---
+1.58-bit Ternary Model、
+This directory contains the training logs for our STE-free Ternary (1.58-bit) Model
+---
+（英語OpenWebText・10万歩）を開始します...
+Step 0/32000 | CE Loss: 12.2871 | Trio Blend: 0.0%
+Step 100/32000 | CE Loss: 8.5651 | Trio Blend: 0.0%
+Step 200/32000 | CE Loss: 5.9627 | Trio Blend: 0.0%
+Step 300/32000 | CE Loss: 5.4165 | Trio Blend: 0.0%
+Step 400/32000 | CE Loss: 5.2959 | Trio Blend: 0.0%
+Step 500/32000 | CE Loss: 4.6366 | Trio Blend: 0.0%
+Step 600/32000 | CE Loss: 5.0238 | Trio Blend: 0.0%
+Step 700/32000 | CE Loss: 4.3707 | Trio Blend: 0.0%
+Step 800/32000 | CE Loss: 7.5176 | Trio Blend: 0.0%
+Step 900/32000 | CE Loss: 4.5658 | Trio Blend: 0.0%
+Step 1000/32000 | CE Loss: 4.1014 | Trio Blend: 0.0%
+Step 1100/32000 | CE Loss: 4.3125 | Trio Blend: 0.0%
+Step 1200/32000 | CE Loss: 5.5312 | Trio Blend: 0.0%
+Step 1300/32000 | CE Loss: 5.2188 | Trio Blend: 0.0%
+Step 1400/32000 | CE Loss: 4.1875 | Trio Blend: 0.0%
+Step 1500/32000 | CE Loss: 3.2500 | Trio Blend: 0.0%
+Step 1600/32000 | CE Loss: 2.9844 | Trio Blend: 0.0%
+Step 1700/32000 | CE Loss: 3.2812 | Trio Blend: 0.0%
+Step 1800/32000 | CE Loss: 2.8438 | Trio Blend: 0.0%
+Step 1900/32000 | CE Loss: 2.9062 | Trio Blend: 0.0%
+Step 2000/32000 | CE Loss: 3.2812 | Trio Blend: 0.0%
+Step 2100/32000 | CE Loss: 4.1875 | Trio Blend: 0.0%
+Step 2200/32000 | CE Loss: 3.2344 | Trio Blend: 0.0%
+Step 2300/32000 | CE Loss: 3.4844 | Trio Blend: 0.0%
+Step 2400/32000 | CE Loss: 3.2344 | Trio Blend: 0.0%
+Step 2500/32000 | CE Loss: 4.3438 | Trio Blend: 0.0%
+Step 2600/32000 | CE Loss: 3.0781 | Trio Blend: 0.0%
+Step 2700/32000 | CE Loss: 3.6250 | Trio Blend: 0.0%
+Step 2800/32000 | CE Loss: 3.2188 | Trio Blend: 0.0%
+Step 2900/32000 | CE Loss: 2.7188 | Trio Blend: 0.0%
+Step 3000/32000 | CE Loss: 2.9375 | Trio Blend: 0.0%
+Step 3100/32000 | CE Loss: 5.3438 | Trio Blend: 0.0%
+Step 3200/32000 | CE Loss: 3.7656 | Trio Blend: 0.0%
+Step 3300/32000 | CE Loss: 2.7031 | Trio Blend: 0.0%
+Step 3400/32000 | CE Loss: 2.6094 | Trio Blend: 0.0%
+Step 3500/32000 | CE Loss: 4.0938 | Trio Blend: 0.0%
+Step 3600/32000 | CE Loss: 3.0000 | Trio Blend: 0.0%
+Step 3700/32000 | CE Loss: 3.0000 | Trio Blend: 0.0%
+Step 3800/32000 | CE Loss: 3.0938 | Trio Blend: 0.0%
+Step 3900/32000 | CE Loss: 2.7656 | Trio Blend: 0.0%
+Step 4000/32000 | CE Loss: 2.8281 | Trio Blend: 0.0%
+Step 4100/32000 | CE Loss: 2.7500 | Trio Blend: 0.0%
+Step 4200/32000 | CE Loss: 2.8906 | Trio Blend: 0.0%
+Step 4300/32000 | CE Loss: 3.1250 | Trio Blend: 0.0%
+Step 4400/32000 | CE Loss: 2.6094 | Trio Blend: 0.0%
+Step 4500/32000 | CE Loss: 2.8750 | Trio Blend: 0.0%
+Step 4600/32000 | CE Loss: 2.4688 | Trio Blend: 0.0%
+Step 4700/32000 | CE Loss: 2.6875 | Trio Blend: 0.0%
+Step 4800/32000 | CE Loss: 2.4531 | Trio Blend: 0.0%
+Step 4900/32000 | CE Loss: 2.6250 | Trio Blend: 0.0%
+Step 5000/32000 | CE Loss: 2.6875 | Trio Blend: 0.0%
+Step 5100/32000 | CE Loss: 2.7344 | Trio Blend: 0.0%
+Step 5200/32000 | CE Loss: 2.6406 | Trio Blend: 0.0%
+Step 5300/32000 | CE Loss: 2.8281 | Trio Blend: 0.0%
+Step 5400/32000 | CE Loss: 2.6094 | Trio Blend: 0.0%
+Step 5500/32000 | CE Loss: 2.5938 | Trio Blend: 0.0%
+Step 5600/32000 | CE Loss: 2.7031 | Trio Blend: 0.0%
+Step 5700/32000 | CE Loss: 3.0156 | Trio Blend: 0.0%
+Step 5800/32000 | CE Loss: 2.5781 | Trio Blend: 0.0%
+Step 5900/32000 | CE Loss: 2.7188 | Trio Blend: 0.0%
+Step 6000/32000 | CE Loss: 2.6250 | Trio Blend: 0.0%
+Step 6100/32000 | CE Loss: 3.5312 | Trio Blend: 0.0%
+Step 6200/32000 | CE Loss: 2.8125 | Trio Blend: 0.0%
+Step 6300/32000 | CE Loss: 2.7656 | Trio Blend: 0.0%
+Step 6400/32000 | CE Loss: 2.6875 | Trio Blend: 0.1%
+Step 6500/32000 | CE Loss: 2.7031 | Trio Blend: 0.1%
+Step 6600/32000 | CE Loss: 2.8594 | Trio Blend: 0.1%
+Step 6700/32000 | CE Loss: 2.6562 | Trio Blend: 0.2%
+Step 6800/32000 | CE Loss: 2.8906 | Trio Blend: 0.2%
+Step 6900/32000 | CE Loss: 2.4844 | Trio Blend: 0.3%
+Step 7000/32000 | CE Loss: 2.5469 | Trio Blend: 0.4%
+Step 7100/32000 | CE Loss: 2.8906 | Trio Blend: 0.4%
+Step 7200/32000 | CE Loss: 2.6094 | Trio Blend: 0.5%
+Step 7300/32000 | CE Loss: 2.7188 | Trio Blend: 0.6%
+Step 7400/32000 | CE Loss: 2.4531 | Trio Blend: 0.7%
+Step 7500/32000 | CE Loss: 3.1094 | Trio Blend: 0.8%
+Step 7600/32000 | CE Loss: 2.7500 | Trio Blend: 0.9%
+Step 7700/32000 | CE Loss: 2.7656 | Trio Blend: 1.1%
+Step 7800/32000 | CE Loss: 2.6094 | Trio Blend: 1.2%
+Step 7900/32000 | CE Loss: 2.4844 | Trio Blend: 1.3%
+Step 8000/32000 | CE Loss: 2.6094 | Trio Blend: 1.5%
+Step 8100/32000 | CE Loss: 2.8438 | Trio Blend: 1.6%
+Step 8200/32000 | CE Loss: 2.6250 | Trio Blend: 1.8%
+Step 8300/32000 | CE Loss: 2.7656 | Trio Blend: 1.9%
+Step 8400/32000 | CE Loss: 2.5781 | Trio Blend: 2.1%
+Step 8500/32000 | CE Loss: 3.0312 | Trio Blend: 2.3%
+Step 8600/32000 | CE Loss: 2.6719 | Trio Blend: 2.4%
+Step 8700/32000 | CE Loss: 3.6250 | Trio Blend: 2.6%
+Step 8800/32000 | CE Loss: 2.8125 | Trio Blend: 2.8%
+Step 8900/32000 | CE Loss: 2.6094 | Trio Blend: 3.0%
+Step 9000/32000 | CE Loss: 2.6562 | Trio Blend: 3.2%
+Step 9100/32000 | CE Loss: 2.9062 | Trio Blend: 3.5%
+Step 9200/32000 | CE Loss: 2.6875 | Trio Blend: 3.7%
+Step 9300/32000 | CE Loss: 2.6875 | Trio Blend: 3.9%
+Step 9400/32000 | CE Loss: 2.7188 | Trio Blend: 4.2%
+Step 9500/32000 | CE Loss: 2.4219 | Trio Blend: 4.4%
+Step 9600/32000 | CE Loss: 2.6562 | Trio Blend: 4.7%
+Step 9700/32000 | CE Loss: 2.7500 | Trio Blend: 4.9%
+Step 9800/32000 | CE Loss: 2.7500 | Trio Blend: 5.2%
+Step 9900/32000 | CE Loss: 2.7188 | Trio Blend: 5.4%
+Step 10000/32000 | CE Loss: 2.6562 | Trio Blend: 5.7%
+Step 10100/32000 | CE Loss: 2.8594 | Trio Blend: 6.0%
+Step 10200/32000 | CE Loss: 2.4531 | Trio Blend: 6.3%
+Step 10300/32000 | CE Loss: 2.5781 | Trio Blend: 6.6%
+Step 10400/32000 | CE Loss: 2.7344 | Trio Blend: 6.9%
+Step 10500/32000 | CE Loss: 2.5156 | Trio Blend: 7.2%
+Step 10600/32000 | CE Loss: 4.3438 | Trio Blend: 7.5%
+Step 10700/32000 | CE Loss: 2.5781 | Trio Blend: 7.8%
+Step 10800/32000 | CE Loss: 2.7344 | Trio Blend: 8.2%
+Step 10900/32000 | CE Loss: 2.2812 | Trio Blend: 8.5%
+Step 11000/32000 | CE Loss: 2.8438 | Trio Blend: 8.9%
+Step 11100/32000 | CE Loss: 2.6562 | Trio Blend: 9.2%
+Step 11200/32000 | CE Loss: 2.6875 | Trio Blend: 9.5%
+Step 11300/32000 | CE Loss: 2.5312 | Trio Blend: 9.9%
+Step 11400/32000 | CE Loss: 2.5000 | Trio Blend: 10.3%
+Step 11500/32000 | CE Loss: 2.5156 | Trio Blend: 10.6%
+Step 11600/32000 | CE Loss: 2.5156 | Trio Blend: 11.0%
+Step 11700/32000 | CE Loss: 2.6562 | Trio Blend: 11.4%
+Step 11800/32000 | CE Loss: 2.5625 | Trio Blend: 11.8%
+Step 11900/32000 | CE Loss: 2.7188 | Trio Blend: 12.2%
+Step 12000/32000 | CE Loss: 2.7344 | Trio Blend: 12.6%
+Step 12100/32000 | CE Loss: 2.9688 | Trio Blend: 13.0%
+Step 12200/32000 | CE Loss: 4.2500 | Trio Blend: 13.4%
+Step 12300/32000 | CE Loss: 2.7656 | Trio Blend: 13.8%
+Step 12400/32000 | CE Loss: 2.7031 | Trio Blend: 14.2%
+Step 12500/32000 | CE Loss: 3.3125 | Trio Blend: 14.6%
+Step 12600/32000 | CE Loss: 2.5625 | Trio Blend: 15.1%
+Step 12700/32000 | CE Loss: 2.7031 | Trio Blend: 15.5%
+Step 12800/32000 | CE Loss: 2.7500 | Trio Blend: 15.9%
+Step 12900/32000 | CE Loss: 2.6562 | Trio Blend: 16.4%
+Step 13000/32000 | CE Loss: 2.7656 | Trio Blend: 16.8%
+Step 13100/32000 | CE Loss: 2.5312 | Trio Blend: 17.3%
+Step 13200/32000 | CE Loss: 2.7188 | Trio Blend: 17.8%
+Step 13300/32000 | CE Loss: 2.6250 | Trio Blend: 18.2%
+Step 13400/32000 | CE Loss: 2.6875 | Trio Blend: 18.7%
+Step 13500/32000 | CE Loss: 3.0625 | Trio Blend: 19.2%
+Step 13600/32000 | CE Loss: 2.9219 | Trio Blend: 19.6%
+Step 13700/32000 | CE Loss: 2.6562 | Trio Blend: 20.1%
+Step 13800/32000 | CE Loss: 3.0469 | Trio Blend: 20.6%
+Step 13900/32000 | CE Loss: 2.7188 | Trio Blend: 21.1%
+Step 14000/32000 | CE Loss: 2.7500 | Trio Blend: 21.6%
+Step 14100/32000 | CE Loss: 2.6562 | Trio Blend: 22.1%
+Step 14200/32000 | CE Loss: 2.4531 | Trio Blend: 22.6%
+Step 14300/32000 | CE Loss: 2.7812 | Trio Blend: 23.1%
+Step 14400/32000 | CE Loss: 2.5469 | Trio Blend: 23.6%
+Step 14500/32000 | CE Loss: 2.8438 | Trio Blend: 24.1%
+Step 14600/32000 | CE Loss: 3.0781 | Trio Blend: 24.7%
+Step 14700/32000 | CE Loss: 2.9062 | Trio Blend: 25.2%
+Step 14800/32000 | CE Loss: 2.9844 | Trio Blend: 25.7%
+Step 14900/32000 | CE Loss: 2.7031 | Trio Blend: 26.2%
+Step 15000/32000 | CE Loss: 2.6562 | Trio Blend: 26.8%
+Step 15100/32000 | CE Loss: 2.6250 | Trio Blend: 27.3%
+Step 15200/32000 | CE Loss: 2.7500 | Trio Blend: 27.8%
+Step 15300/32000 | CE Loss: 2.8594 | Trio Blend: 28.4%
+Step 15400/32000 | CE Loss: 3.3750 | Trio Blend: 28.9%
+Step 15500/32000 | CE Loss: 3.0938 | Trio Blend: 29.5%
+Step 15600/32000 | CE Loss: 3.7188 | Trio Blend: 30.0%
+Step 15700/32000 | CE Loss: 3.2188 | Trio Blend: 30.6%
+Step 15800/32000 | CE Loss: 2.5156 | Trio Blend: 31.1%
+Step 15900/32000 | CE Loss: 2.6562 | Trio Blend: 31.7%
+Step 16000/32000 | CE Loss: 2.8906 | Trio Blend: 32.3%
+Step 16100/32000 | CE Loss: 2.6250 | Trio Blend: 32.8%
+Step 16200/32000 | CE Loss: 2.8594 | Trio Blend: 33.4%
+Step 16300/32000 | CE Loss: 3.0625 | Trio Blend: 34.0%
+Step 16400/32000 | CE Loss: 2.7656 | Trio Blend: 34.5%
+Step 16500/32000 | CE Loss: 3.2969 | Trio Blend: 35.1%
+Step 16600/32000 | CE Loss: 2.6406 | Trio Blend: 35.7%
+Step 16700/32000 | CE Loss: 3.0781 | Trio Blend: 36.3%
+Step 16800/32000 | CE Loss: 2.8438 | Trio Blend: 36.9%
+Step 16900/32000 | CE Loss: 2.8438 | Trio Blend: 37.4%
+Step 17000/32000 | CE Loss: 2.7031 | Trio Blend: 38.0%
+Step 17100/32000 | CE Loss: 2.7969 | Trio Blend: 38.6%
+Step 17200/32000 | CE Loss: 2.5938 | Trio Blend: 39.2%
+Step 17300/32000 | CE Loss: 2.5938 | Trio Blend: 39.8%
+Step 17400/32000 | CE Loss: 2.8438 | Trio Blend: 40.4%
+Step 17500/32000 | CE Loss: 3.1875 | Trio Blend: 41.0%
+Step 17600/32000 | CE Loss: 2.8438 | Trio Blend: 41.6%
+Step 17700/32000 | CE Loss: 2.7656 | Trio Blend: 42.2%
+Step 17800/32000 | CE Loss: 2.9062 | Trio Blend: 42.8%
+Step 17900/32000 | CE Loss: 2.6875 | Trio Blend: 43.4%
+Step 18000/32000 | CE Loss: 3.1406 | Trio Blend: 44.0%
+Step 18100/32000 | CE Loss: 4.0312 | Trio Blend: 44.6%
+Step 18200/32000 | CE Loss: 3.1406 | Trio Blend: 45.2%
+Step 18300/32000 | CE Loss: 3.2031 | Trio Blend: 45.8%
+Step 18400/32000 | CE Loss: 3.2969 | Trio Blend: 46.4%
+Step 18500/32000 | CE Loss: 3.0625 | Trio Blend: 47.0%
+Step 18600/32000 | CE Loss: 3.7031 | Trio Blend: 47.6%
+Step 18700/32000 | CE Loss: 3.1719 | Trio Blend: 48.2%
+Step 18800/32000 | CE Loss: 3.3906 | Trio Blend: 48.8%
+Step 18900/32000 | CE Loss: 3.1406 | Trio Blend: 49.4%
+Step 19000/32000 | CE Loss: 2.8594 | Trio Blend: 50.0%
+Step 19100/32000 | CE Loss: 2.8906 | Trio Blend: 50.6%
+Step 19200/32000 | CE Loss: 3.2344 | Trio Blend: 51.2%
+Step 19300/32000 | CE Loss: 2.6562 | Trio Blend: 51.8%
+Step 19400/32000 | CE Loss: 3.5312 | Trio Blend: 52.4%
+Step 19500/32000 | CE Loss: 3.1719 | Trio Blend: 53.0%
+Step 19600/32000 | CE Loss: 4.2500 | Trio Blend: 53.6%
+Step 19700/32000 | CE Loss: 3.5625 | Trio Blend: 54.2%
+Step 19800/32000 | CE Loss: 2.9688 | Trio Blend: 54.8%
+Step 19900/32000 | CE Loss: 8.0000 | Trio Blend: 55.4%
+Step 20000/32000 | CE Loss: 4.5312 | Trio Blend: 56.0%
+Step 20100/32000 | CE Loss: 6.0000 | Trio Blend: 56.6%
+Step 20200/32000 | CE Loss: 2.9531 | Trio Blend: 57.2%
+Step 20300/32000 | CE Loss: 3.8281 | Trio Blend: 57.8%
+Step 20400/32000 | CE Loss: 5.4688 | Trio Blend: 58.4%
+Step 20500/32000 | CE Loss: 7.0625 | Trio Blend: 59.0%
+Step 20600/32000 | CE Loss: 3.7500 | Trio Blend: 59.6%
+Step 20700/32000 | CE Loss: 3.1875 | Trio Blend: 60.2%
+Step 20800/32000 | CE Loss: 3.5312 | Trio Blend: 60.8%
+Step 20900/32000 | CE Loss: 3.3594 | Trio Blend: 61.4%
+Step 21000/32000 | CE Loss: 3.3125 | Trio Blend: 62.0%
+Step 21100/32000 | CE Loss: 3.2031 | Trio Blend: 62.6%
+Step 21200/32000 | CE Loss: 3.1406 | Trio Blend: 63.1%
+Step 21300/32000 | CE Loss: 3.4531 | Trio Blend: 63.7%
+Step 21400/32000 | CE Loss: 3.0625 | Trio Blend: 64.3%
+Step 21500/32000 | CE Loss: 3.7031 | Trio Blend: 64.9%
+Step 21600/32000 | CE Loss: 3.4062 | Trio Blend: 65.5%
+Step 21700/32000 | CE Loss: 4.8438 | Trio Blend: 66.0%
+Step 21800/32000 | CE Loss: 3.0000 | Trio Blend: 66.6%
+Step 21900/32000 | CE Loss: 6.6250 | Trio Blend: 67.2%
+Step 22000/32000 | CE Loss: 3.7344 | Trio Blend: 67.7%
+Step 22100/32000 | CE Loss: 3.9844 | Trio Blend: 68.3%
+Step 22200/32000 | CE Loss: 3.5625 | Trio Blend: 68.9%
+Step 22300/32000 | CE Loss: 11.6875 | Trio Blend: 69.4%
+Step 22400/32000 | CE Loss: 3.8906 | Trio Blend: 70.0%
+Step 22500/32000 | CE Loss: 3.4688 | Trio Blend: 70.5%
+Step 22600/32000 | CE Loss: 3.3125 | Trio Blend: 71.1%
+Step 22700/32000 | CE Loss: 3.4062 | Trio Blend: 71.6%
+Step 22800/32000 | CE Loss: 3.3906 | Trio Blend: 72.2%
+Step 22900/32000 | CE Loss: 2.8438 | Trio Blend: 72.7%
+Step 23000/32000 | CE Loss: 3.2031 | Trio Blend: 73.2%
+Step 23100/32000 | CE Loss: 2.7031 | Trio Blend: 73.8%
+Step 23200/32000 | CE Loss: 5.6562 | Trio Blend: 74.3%
+Step 23300/32000 | CE Loss: 3.5469 | Trio Blend: 74.8%
+Step 23400/32000 | CE Loss: 7.6875 | Trio Blend: 75.3%
+Step 23500/32000 | CE Loss: 3.3594 | Trio Blend: 75.9%
+Step 23600/32000 | CE Loss: 3.6406 | Trio Blend: 76.4%
+Step 23700/32000 | CE Loss: 3.3750 | Trio Blend: 76.9%
+Step 23800/32000 | CE Loss: 3.3125 | Trio Blend: 77.4%
+Step 23900/32000 | CE Loss: 3.0625 | Trio Blend: 77.9%
+Step 24000/32000 | CE Loss: 4.1875 | Trio Blend: 78.4%
+Step 24100/32000 | CE Loss: 4.3438 | Trio Blend: 78.9%
+Step 24200/32000 | CE Loss: 4.1250 | Trio Blend: 79.4%
+Step 24300/32000 | CE Loss: 4.4062 | Trio Blend: 79.9%
+Step 24400/32000 | CE Loss: 4.1875 | Trio Blend: 80.4%
+Step 24500/32000 | CE Loss: 3.0312 | Trio Blend: 80.8%
+Step 24600/32000 | CE Loss: 3.6406 | Trio Blend: 81.3%
+Step 24700/32000 | CE Loss: 3.8906 | Trio Blend: 81.8%
+Step 24800/32000 | CE Loss: 4.0312 | Trio Blend: 82.2%
+Step 24900/32000 | CE Loss: 4.4062 | Trio Blend: 82.7%
+Step 25000/32000 | CE Loss: 3.4688 | Trio Blend: 83.2%
+Step 25100/32000 | CE Loss: 5.0938 | Trio Blend: 83.6%
+Step 25200/32000 | CE Loss: 3.7344 | Trio Blend: 84.1%
+Step 25300/32000 | CE Loss: 3.6719 | Trio Blend: 84.5%
+Step 25400/32000 | CE Loss: 3.3438 | Trio Blend: 84.9%
+Step 25500/32000 | CE Loss: 3.1094 | Trio Blend: 85.4%
+Step 25600/32000 | CE Loss: 3.6094 | Trio Blend: 85.8%
+Step 25700/32000 | CE Loss: 3.2656 | Trio Blend: 86.2%
+Step 25800/32000 | CE Loss: 3.2344 | Trio Blend: 86.6%
+Step 25900/32000 | CE Loss: 4.0625 | Trio Blend: 87.0%
+Step 26000/32000 | CE Loss: 9.1250 | Trio Blend: 87.4%
+Step 26100/32000 | CE Loss: 4.4688 | Trio Blend: 87.8%
+Step 26200/32000 | CE Loss: 5.7500 | Trio Blend: 88.2%
+Step 26300/32000 | CE Loss: 3.2188 | Trio Blend: 88.6%
+Step 26400/32000 | CE Loss: 3.5625 | Trio Blend: 89.0%
+Step 26500/32000 | CE Loss: 6.2812 | Trio Blend: 89.4%
+Step 26600/32000 | CE Loss: 3.8438 | Trio Blend: 89.7%
+Step 26700/32000 | CE Loss: 3.0938 | Trio Blend: 90.1%
+Step 26800/32000 | CE Loss: 4.6875 | Trio Blend: 90.5%
+Step 26900/32000 | CE Loss: 3.0469 | Trio Blend: 90.8%
+Step 27000/32000 | CE Loss: 5.5000 | Trio Blend: 91.1%
+Step 27100/32000 | CE Loss: 3.3594 | Trio Blend: 91.5%
+Step 27200/32000 | CE Loss: 6.0312 | Trio Blend: 91.8%
+Step 27300/32000 | CE Loss: 5.5938 | Trio Blend: 92.2%
+Step 27400/32000 | CE Loss: 3.7656 | Trio Blend: 92.5%
+Step 27500/32000 | CE Loss: 3.3594 | Trio Blend: 92.8%
+Step 27600/32000 | CE Loss: 3.9062 | Trio Blend: 93.1%
+Step 27700/32000 | CE Loss: 5.8750 | Trio Blend: 93.4%
+Step 27800/32000 | CE Loss: 6.3125 | Trio Blend: 93.7%
+Step 27900/32000 | CE Loss: 4.4062 | Trio Blend: 94.0%
+Step 28000/32000 | CE Loss: 4.0625 | Trio Blend: 94.3%
+Step 28100/32000 | CE Loss: 3.4531 | Trio Blend: 94.6%
+Step 28200/32000 | CE Loss: 3.7031 | Trio Blend: 94.8%
+Step 28300/32000 | CE Loss: 3.5000 | Trio Blend: 95.1%
+Step 28400/32000 | CE Loss: 7.4688 | Trio Blend: 95.3%
+Step 28500/32000 | CE Loss: 4.0312 | Trio Blend: 95.6%
+Step 28600/32000 | CE Loss: 3.7812 | Trio Blend: 95.8%
+Step 28700/32000 | CE Loss: 4.4062 | Trio Blend: 96.1%
+Step 28800/32000 | CE Loss: 4.2500 | Trio Blend: 96.3%
+Step 28900/32000 | CE Loss: 5.2500 | Trio Blend: 96.5%
+Step 29000/32000 | CE Loss: 3.3281 | Trio Blend: 96.8%
+Step 29100/32000 | CE Loss: 3.7031 | Trio Blend: 97.0%
+Step 29200/32000 | CE Loss: 4.5312 | Trio Blend: 97.2%
+Step 29300/32000 | CE Loss: 5.6250 | Trio Blend: 97.4%
+Step 29400/32000 | CE Loss: 4.5625 | Trio Blend: 97.6%
+Step 29500/32000 | CE Loss: 3.5938 | Trio Blend: 97.7%
+Step 29600/32000 | CE Loss: 9.6250 | Trio Blend: 97.9%
+Step 29700/32000 | CE Loss: 4.9375 | Trio Blend: 98.1%
+Step 29800/32000 | CE Loss: 4.9062 | Trio Blend: 98.2%
+Step 29900/32000 | CE Loss: 3.4531 | Trio Blend: 98.4%
+Step 30000/32000 | CE Loss: 3.9062 | Trio Blend: 98.5%
+Step 30100/32000 | CE Loss: 4.4688 | Trio Blend: 98.7%
+Step 30200/32000 | CE Loss: 3.6250 | Trio Blend: 98.8%
+Step 30300/32000 | CE Loss: 4.4688 | Trio Blend: 98.9%
+Step 30400/32000 | CE Loss: 3.3125 | Trio Blend: 99.1%
+Step 30500/32000 | CE Loss: 3.7500 | Trio Blend: 99.2%
+Step 30600/32000 | CE Loss: 3.6094 | Trio Blend: 99.3%
+Step 30700/32000 | CE Loss: 5.5000 | Trio Blend: 99.4%
+Step 30800/32000 | CE Loss: 5.0000 | Trio Blend: 99.5%
+Step 30900/32000 | CE Loss: 4.8125 | Trio Blend: 99.6%
+Step 31000/32000 | CE Loss: 3.5625 | Trio Blend: 99.6%
+Step 31100/32000 | CE Loss: 4.0000 | Trio Blend: 99.7%
+Step 31200/32000 | CE Loss: 4.2188 | Trio Blend: 99.8%
+Step 31300/32000 | CE Loss: 5.3438 | Trio Blend: 99.8%
+Step 31400/32000 | CE Loss: 4.9062 | Trio Blend: 99.9%
+Step 31500/32000 | CE Loss: 2.9062 | Trio Blend: 99.9%
+Step 31600/32000 | CE Loss: 3.4375 | Trio Blend: 99.9%
+Step 31700/32000 | CE Loss: 3.6250 | Trio Blend: 100.0%
+Step 31800/32000 | CE Loss: 3.0469 | Trio Blend: 100.0%
+Step 31900/32000 | CE Loss: 3.6875 | Trio Blend: 100.0%
+
+--- フェーズ1（英語）完了。3値結晶化モデルを抽出・保存します ---
+🎉 D-RNAの構造を完全に守った3値結晶化ファイルを出力しました: drna_trio_phase1_english.safetensors
+
+---
+drna_trio_phase1_english.safetensors
+
+Layer Name                                    |    Mean |     Std |     Max |     Min |   SVD
+embed.weight                                  |  0.0016 |  1.0007 |    4.47 |   -4.28 |  5.50
+---------------------------------------------------------------------------------------------
+layers.0.mlp.0.weight                         |  0.0084 |  0.4821 |    1.00 |   -1.00 |  5.66
+layers.0.mlp.3.weight                         | -0.0194 |  0.3737 |    1.00 |   -1.00 |  5.66
+layers.0.out_proj.weight                      |  0.0145 |  0.2285 |    1.00 |   -1.00 |  5.16
+layers.0.qkv.weight                           | -0.0396 |  0.6020 |    1.00 |   -1.00 |  5.40
+layers.1.mlp.0.weight                         | -0.0237 |  0.4926 |    1.00 |   -1.00 |  5.67
+layers.1.mlp.3.weight                         | -0.0035 |  0.3485 |    1.00 |   -1.00 |  5.66
+layers.1.out_proj.weight                      |  0.0151 |  0.2843 |    1.00 |   -1.00 |  5.36
+layers.1.qkv.weight                           |  0.0143 |  0.5119 |    1.00 |   -1.00 |  5.52
+layers.10.mlp.0.weight                        | -0.0294 |  0.4374 |    1.00 |   -1.00 |  5.65
+layers.10.mlp.3.weight                        | -0.0018 |  0.3587 |    1.00 |   -1.00 |  5.58
+layers.10.out_proj.weight                     |  0.0134 |  0.3689 |    1.00 |   -1.00 |  5.34
+layers.10.qkv.weight                          | -0.0128 |  0.4449 |    1.00 |   -1.00 |  5.56
+layers.11.mlp.0.weight                        | -0.0230 |  0.3980 |    1.00 |   -1.00 |  5.66
+layers.11.mlp.3.weight                        |  0.0114 |  0.3651 |    1.00 |   -1.00 |  5.59
+layers.11.out_proj.weight                     | -0.0027 |  0.3156 |    1.00 |   -1.00 |  5.29
+layers.11.qkv.weight                          |  0.0132 |  0.3869 |    1.00 |   -1.00 |  5.52
+layers.12.mlp.0.weight                        | -0.0023 |  0.4047 |    1.00 |   -1.00 |  5.66
+layers.12.mlp.3.weight                        | -0.0210 |  0.3773 |    1.00 |   -1.00 |  5.60
+layers.12.out_proj.weight                     |  0.0310 |  0.3670 |    1.00 |   -1.00 |  5.34
+layers.12.qkv.weight                          | -0.0145 |  0.4328 |    1.00 |   -1.00 |  5.56
+layers.13.mlp.0.weight                        | -0.0134 |  0.3875 |    1.00 |   -1.00 |  5.66
+layers.13.mlp.3.weight                        | -0.0131 |  0.3814 |    1.00 |   -1.00 |  5.61
+layers.13.out_proj.weight                     | -0.0035 |  0.3549 |    1.00 |   -1.00 |  5.32
+layers.13.qkv.weight                          | -0.0154 |  0.4175 |    1.00 |   -1.00 |  5.54
+layers.14.mlp.0.weight                        | -0.0096 |  0.4027 |    1.00 |   -1.00 |  5.66
+layers.14.mlp.3.weight                        | -0.0101 |  0.3817 |    1.00 |   -1.00 |  5.60
+layers.14.out_proj.weight                     | -0.0135 |  0.3729 |    1.00 |   -1.00 |  5.35
+layers.14.qkv.weight                          |  0.0009 |  0.4264 |    1.00 |   -1.00 |  5.57
+layers.15.mlp.0.weight                        |  0.0066 |  0.4065 |    1.00 |   -1.00 |  5.66
+layers.15.mlp.3.weight                        |  0.0256 |  0.3939 |    1.00 |   -1.00 |  5.59
+layers.15.out_proj.weight                     |  0.0044 |  0.3477 |    1.00 |   -1.00 |  5.30
+layers.15.qkv.weight                          | -0.0036 |  0.4371 |    1.00 |   -1.00 |  5.55
+layers.16.mlp.0.weight                        |  0.0119 |  0.4346 |    1.00 |   -1.00 |  5.66
+layers.16.mlp.3.weight                        |  0.0189 |  0.3736 |    1.00 |   -1.00 |  5.66
+layers.16.out_proj.weight                     | -0.0043 |  0.3657 |    1.00 |   -1.00 |  5.36
+layers.16.qkv.weight                          |  0.0089 |  0.4011 |    1.00 |   -1.00 |  5.54
+layers.17.mlp.0.weight                        | -0.0105 |  0.4586 |    1.00 |   -1.00 |  5.67
+layers.17.mlp.3.weight                        |  0.0027 |  0.3710 |    1.00 |   -1.00 |  5.66
+layers.17.out_proj.weight                     | -0.0062 |  0.3893 |    1.00 |   -1.00 |  5.40
+layers.17.qkv.weight                          |  0.0083 |  0.4309 |    1.00 |   -1.00 |  5.56
+layers.18.mlp.0.weight                        |  0.0088 |  0.4437 |    1.00 |   -1.00 |  5.67
+layers.18.mlp.3.weight                        |  0.0181 |  0.3938 |    1.00 |   -1.00 |  5.64
+layers.18.out_proj.weight                     | -0.0287 |  0.4066 |    1.00 |   -1.00 |  5.39
+layers.18.qkv.weight                          |  0.0100 |  0.4649 |    1.00 |   -1.00 |  5.56
+layers.19.mlp.0.weight                        | -0.0041 |  0.4362 |    1.00 |   -1.00 |  5.66
+layers.19.mlp.3.weight                        | -0.0261 |  0.4043 |    1.00 |   -1.00 |  5.63
+layers.19.out_proj.weight                     | -0.0105 |  0.3573 |    1.00 |   -1.00 |  5.37
+layers.19.qkv.weight                          | -0.0117 |  0.4573 |    1.00 |   -1.00 |  5.56
+layers.2.mlp.0.weight                         |  0.0038 |  0.5067 |    1.00 |   -1.00 |  5.67
+layers.2.mlp.3.weight                         |  0.0038 |  0.3484 |    1.00 |   -1.00 |  5.65
+layers.2.out_proj.weight                      |  0.0002 |  0.2741 |    1.00 |   -1.00 |  5.38
+layers.2.qkv.weight                           |  0.0065 |  0.4754 |    1.00 |   -1.00 |  5.52
+layers.20.mlp.0.weight                        |  0.0185 |  0.4301 |    1.00 |   -1.00 |  5.66
+layers.20.mlp.3.weight                        |  0.0076 |  0.4125 |    1.00 |   -1.00 |  5.63
+layers.20.out_proj.weight                     | -0.0074 |  0.4323 |    1.00 |   -1.00 |  5.41
+layers.20.qkv.weight                          | -0.0095 |  0.4289 |    1.00 |   -1.00 |  5.56
+layers.21.mlp.0.weight                        |  0.0185 |  0.4340 |    1.00 |   -1.00 |  5.67
+layers.21.mlp.3.weight                        |  0.0117 |  0.4229 |    1.00 |   -1.00 |  5.63
+layers.21.out_proj.weight                     |  0.0379 |  0.4586 |    1.00 |   -1.00 |  5.43
+layers.21.qkv.weight                          |  0.0181 |  0.4517 |    1.00 |   -1.00 |  5.53
+layers.22.mlp.0.weight                        |  0.0127 |  0.4215 |    1.00 |   -1.00 |  5.67
+layers.22.mlp.3.weight                        | -0.0142 |  0.4287 |    1.00 |   -1.00 |  5.66
+layers.22.out_proj.weight                     |  0.0090 |  0.4570 |    1.00 |   -1.00 |  5.46
+layers.22.qkv.weight                          | -0.0030 |  0.4303 |    1.00 |   -1.00 |  5.53
+layers.23.mlp.0.weight                        |  0.0242 |  0.4349 |    1.00 |   -1.00 |  5.66
+layers.23.mlp.3.weight                        | -0.0092 |  0.3675 |    1.00 |   -1.00 |  5.67
+layers.23.out_proj.weight                     | -0.0005 |  0.3852 |    1.00 |   -1.00 |  5.38
+layers.23.qkv.weight                          |  0.0115 |  0.4324 |    1.00 |   -1.00 |  5.52
+layers.3.mlp.0.weight                         | -0.0189 |  0.4833 |    1.00 |   -1.00 |  5.67
+layers.3.mlp.3.weight                         |  0.0102 |  0.3595 |    1.00 |   -1.00 |  5.65
+layers.3.out_proj.weight                      | -0.0025 |  0.3115 |    1.00 |   -1.00 |  5.31
+layers.3.qkv.weight                           |  0.0251 |  0.4530 |    1.00 |   -1.00 |  5.53
+layers.4.mlp.0.weight                         |  0.0041 |  0.4719 |    1.00 |   -1.00 |  5.67
+layers.4.mlp.3.weight                         | -0.0088 |  0.3623 |    1.00 |   -1.00 |  5.65
+layers.4.out_proj.weight                      |  0.0069 |  0.3526 |    1.00 |   -1.00 |  5.35
+layers.4.qkv.weight                           |  0.0226 |  0.4593 |    1.00 |   -1.00 |  5.56
+layers.5.mlp.0.weight                         |  0.0029 |  0.5050 |    1.00 |   -1.00 |  5.66
+layers.5.mlp.3.weight                         |  0.0079 |  0.3396 |    1.00 |   -1.00 |  5.62
+layers.5.out_proj.weight                      |  0.0014 |  0.3697 |    1.00 |   -1.00 |  5.38
+layers.5.qkv.weight                           | -0.0267 |  0.4430 |    1.00 |   -1.00 |  5.56
+layers.6.mlp.0.weight                         |  0.0226 |  0.4660 |    1.00 |   -1.00 |  5.67
+layers.6.mlp.3.weight                         |  0.0037 |  0.3739 |    1.00 |   -1.00 |  5.63
+layers.6.out_proj.weight                      | -0.0061 |  0.3420 |    1.00 |   -1.00 |  5.34
+layers.6.qkv.weight                           |  0.0197 |  0.4442 |    1.00 |   -1.00 |  5.53
+layers.7.mlp.0.weight                         | -0.0398 |  0.4449 |    1.00 |   -1.00 |  5.66
+layers.7.mlp.3.weight                         |  0.0068 |  0.3722 |    1.00 |   -1.00 |  5.64
+layers.7.out_proj.weight                      | -0.0282 |  0.3675 |    1.00 |   -1.00 |  5.37
+layers.7.qkv.weight                           |  0.0120 |  0.4651 |    1.00 |   -1.00 |  5.56
+layers.8.mlp.0.weight                         | -0.0240 |  0.4524 |    1.00 |   -1.00 |  5.66
+layers.8.mlp.3.weight                         |  0.0231 |  0.3776 |    1.00 |   -1.00 |  5.60
+layers.8.out_proj.weight                      |  0.0170 |  0.3391 |    1.00 |   -1.00 |  5.33
+layers.8.qkv.weight                           | -0.0096 |  0.4836 |    1.00 |   -1.00 |  5.55
+layers.9.mlp.0.weight                         |  0.0147 |  0.4235 |    1.00 |   -1.00 |  5.66
+layers.9.mlp.3.weight                         |  0.0186 |  0.3676 |    1.00 |   -1.00 |  5.60
+layers.9.out_proj.weight                      | -0.0043 |  0.3399 |    1.00 |   -1.00 |  5.31
+layers.9.qkv.weight                           |  0.0182 |  0.4266 |    1.00 |   -1.00 |  5.55
+output_head.weight                            |  0.0031 |  0.0523 |    0.06 |   -0.06 |  2.68

drna/drna_vlayer.py

@@ -0,0 +1,173 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+import math
+
+'''
+D‑RNA: Dual‑Helix Resonance Neural Architecture (DRNA) Pre-Norm･Kv-RoPE･vlayer版
+仕様：Pre-Norm(RMSNorm)、GELU(Activation)、Kv-RoPE(head_dim)、mask(padding + causal)
+仮想レイヤ再帰（p_layers）、Gradient Checkpointing対応
+'''
+
+class RMSNorm(nn.Module):
+    def __init__(self, d_model, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(d_model))
+
+    def forward(self, x):
+        norm = x.pow(2).mean(-1, keepdim=True)
+        x_normed = x * torch.rsqrt(norm + self.eps)
+        return self.weight * x_normed
+
+class DRNA_RoPE(nn.Module):
+    """二重らせんの位相を決定する回転場"""
+    def __init__(self, head_dim, base=10000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq)
+
+    def forward(self, x, seq_len):
+        t = torch.arange(seq_len, device=x.device).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        return emb.cos()[None, None, :, :], emb.sin()[None, None, :, :]
+
+def apply_drna_rope(q, k, cos, sin):
+    def rotate_half(x):
+        x1, x2 = x.chunk(2, dim=-1)
+        return torch.cat((-x2, x1), dim=-1)
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+class DRNA_Block(nn.Module):
+    """DRNA共鳴ブロック：安定性を高めたPre-Norm直列共鳴構造"""
+    def __init__(self, d_model, n_heads, head_dim, d_ff=None, dropout=0.1):
+        super().__init__()
+        self.n_heads = n_heads
+        self.head_dim = head_dim
+
+        # らせんA: 回想系 (Attention)
+        self.norm1 = RMSNorm(d_model)
+        self.qkv = nn.Linear(d_model, d_model * 3)
+        self.out_proj = nn.Linear(d_model, d_model)
+
+        # らせんB: 記憶系 (MLP)
+        self.norm2 = RMSNorm(d_model)
+        d_ff = d_ff or d_model * 4
+        self.mlp = nn.Sequential(
+            nn.Linear(d_model, d_ff),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_ff, d_model)
+        )
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, cos, sin, mask=None):
+        b, s, d = x.shape
+        residual = x
+
+        # らせんA (Attention) 並列方式
+        x_norm1 = self.norm1(x)
+        qkv = self.qkv(x_norm1).reshape(b, s, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        # K因果的動的回転
+        k_for_phase = torch.cat([torch.zeros_like(k[:, :, :1, :]), k[:, :, :-1, :]], dim=2)
+        rt_phase = torch.tanh(k_for_phase) * math.pi
+
+        # 静的RoPEを動的位相で変調
+        d_cos = (cos * torch.cos(rt_phase)) - (sin * torch.sin(rt_phase))
+        d_sin = (sin * torch.cos(rt_phase)) + (cos * torch.sin(rt_phase))
+
+        # ２重らせん回転
+        q, k = apply_drna_rope(q, k, d_cos, d_sin)
+
+        # Attention計算
+        attn = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(self.head_dim))
+        if mask is not None:
+            attn = attn + mask
+
+        attn = F.softmax(attn, dim=-1)
+        a_out_raw = (attn @ v).transpose(1, 2).reshape(b, s, d)
+        a_out = self.out_proj(a_out_raw)
+
+        # らせんB (MLP)
+        x_norm2 = self.norm2(x)
+        m_out = self.mlp(x_norm2)
+
+        # 並列結合
+        x = residual + self.dropout(a_out) + self.dropout(m_out)
+        return x
+
+class DRNA_Recurrent_Model(nn.Module):
+    """汎用 DRNA モデルコンテナ（レイヤ回帰・仮想レイヤ組み込み版）"""
+    def __init__(self, vocab_size, d_model=256, n_layers=4, p_layers=4, n_heads=8, d_ff=1024):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, d_model)
+        self.head_dim = d_model // n_heads
+        self.rope = DRNA_RoPE(self.head_dim)
+        self.p_layers = p_layers  # 仮想レイヤーの周回数（再帰回数）
+
+        self.layers = nn.ModuleList([
+            DRNA_Block(d_model, n_heads, self.head_dim, d_ff) for _ in range(n_layers)
+        ])
+
+        self.final_norm = RMSNorm(d_model)
+        self.output_head = nn.Linear(d_model, vocab_size)
+
+    def forward(self, x, mask=None, pad_id=None):
+        b, s = x.shape
+        device = x.device
+        inputs = x
+        x = self.embed(x)
+
+        if mask is None or mask.sum() == 0:
+            # 退避させた inputs でパディング位置を判定
+            # パッドマスクとコーザルマスクを判定(pad_idの型チェック＆テンソルバグ修正)
+            p_id = pad_id.item() if isinstance(pad_id, torch.Tensor) else pad_id
+            pad_mask = (inputs != p_id).unsqueeze(1).unsqueeze(2) if isinstance(p_id, (int, float)) else torch.ones((1, 1, 1, s), device=device, dtype=torch.bool)
+            causal = torch.triu(torch.ones(s, s, device=device), diagonal=1).bool().unsqueeze(0).unsqueeze(0)
+
+            # 環境(fp16/32)に応じた最小値を安全に自動計算
+            inf_value = torch.finfo(x.dtype).min if x.dtype != torch.float16 else -65500.0
+
+            # ゼロ初期化テンソルに無効領域をインプレースで直接埋める(カンニングの完全遮断)
+            mask = torch.zeros((b, 1, s, s), device=device, dtype=x.dtype).masked_fill_(causal | (~pad_mask), inf_value)
+
+        cos, sin = self.rope(x, x.size(1))
+
+        # 実レイヤーのループ
+        for layer in self.layers:
+            # 🌀 仮想レイヤーの再帰ループ
+            for _ in range(self.p_layers):
+                if self.training:
+                    # 確実に勾配追跡を有効化するため、x のrequires_gradを確認・保障
+                    if not x.requires_grad:
+                        x.requires_grad_()
+                    # グラディエント・チェックポインティングによるVRAM抑制
+                    x = checkpoint.checkpoint(
+                        layer,
+                        x,
+                        cos,
+                        sin,
+                        mask,
+                        use_reentrant=False
+                    )
+                else:
+                    x = layer(x, cos, sin, mask=mask)
+
+        x = self.final_norm(x)
+        return self.output_head(x)
+
+'''
+260520：p_layers による回帰で仮想レイヤをつくる(グラディエント・チェックポインティング活用/VRAM抑制)
+｢仮想レイヤ｣は物理的なレイヤ数を最小限に、同一レイヤ内で自己周回(再帰)させ、安定的な効率化を実現する
+グラディエント・チェックポインティング(GC)による再帰は中間計算(勾配)を必要時に再計算することで省VRAM化をします
+'''
+
+'''
+汎用型 D-RNA (Pre-Norm) License: Apache License 2.0 https://github.com/muooon/DRNA
+Attention is all you need_started, Resonance is all you need_endure, 
+Neocognitron ― Transformer ― D‑RNA Dream Resonance Never Adjourns — it goes on...
+'''