Upload 33 files

.gitattributes

@@ -115,3 +115,19 @@ report/TensorBoard01.png filter=lfs diff=lfs merge=lfs -text
 report/TensorBoard03.png filter=lfs diff=lfs merge=lfs -text
 report/xyz_grid-0001-1234.png filter=lfs diff=lfs merge=lfs -text
 report/xyz_grid-0002-4321.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rastrigin_EmoClan.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rastrigin_EmoFact.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rastrigin_EmoLynx.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rastrigin_EmoNavi.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rastrigin_EmoNeco.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rastrigin_EmoZeal.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rosenbrock_EmoClan.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rosenbrock_EmoFact.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rosenbrock_EmoLynx.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rosenbrock_EmoNavi.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rosenbrock_EmoNeco.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/docs/rosenbrock_EmoZeal.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/logs/fluctuation_and_accuracy_panel.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/logs/loss_comparison_panel.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/logs/trec_gpt2_weight_pca_3panel.png filter=lfs diff=lfs merge=lfs -text
+1Gv3_AMP-compatible/logs/trec_weights_log.json filter=lfs diff=lfs merge=lfs -text

1Gv2_AMP-compatible/emoclan.py

@@ -0,0 +1,274 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Callable, Union, Dict, Any, Tuple
+
+"""
+EmoClan v2.0 (250815) shadow-system v2.0 scalar-switch v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoClan(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True にすることで shadow をオンにできる
+emosens shadow-effect v1.0 反映 shadow-system、scalar-switch 修正
+"""
+
+# Helper function
+def exists(val):
+    return val is not None
+
+class EmoClan(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params: Union[list, torch.nn.Module], 
+                 lr: float = 1e-3, 
+                 betas: Tuple[float, float] = (0.9, 0.999), 
+                 eps: float = 1e-8, 
+                 weight_decay: float = 0.01,
+                 lynx_betas: Tuple[float, float] = (0.9, 0.99), # Lynx 固有の beta
+                 decoupled_weight_decay: bool = False,
+                 use_shadow: bool = False
+                ):
+        
+        if not 0.0 <= lr:
+            raise ValueError(f"Invalid learning rate: {lr}")
+        if not 0.0 <= eps:
+            raise ValueError(f"Invalid epsilon value: {eps}")
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError(f"Invalid beta parameter at index 0: {betas[0]}")
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError(f"Invalid beta parameter at index 1: {betas[1]}")
+        
+        # Lynx の betas もバリデーション
+        if not 0.0 <= lynx_betas[0] < 1.0:
+            raise ValueError(f"Invalid lynx_beta parameter at index 0: {lynx_betas[0]}")
+        if not 0.0 <= lynx_betas[1] < 1.0:
+            raise ValueError(f"Invalid lynx_beta parameter at index 1: {lynx_betas[1]}")
+
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay,
+                        lynx_betas=lynx_betas, decoupled_weight_decay=decoupled_weight_decay)
+        super().__init__(params, defaults)
+        
+        self._init_lr = lr # decoupled weight decay のために保存 (Lynx用)
+        self.should_stop = False # 全体の停止フラグ
+        self.use_shadow = use_shadow # EmoClanインスタンス自身がuse_shadowを保持
+
+    # --- 感情機構 (Emotion Mechanism) ---
+    def _update_ema(self, param_state: Dict[str, Any], loss_val: float) -> Dict[str, float]:
+        """損失値に基づいて短期・長期 EMA を更新"""
+        # param_state は各パラメータの state['ema'] を保持する
+        ema = param_state.setdefault('ema', {'short': loss_val, 'long': loss_val})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema['short']
+        ema['long'] = 0.01 * loss_val + 0.99 * ema['long']
+        return ema
+
+    """EMA の差分から感情スカラー値を生成"""
+    def _compute_scalar(self, ema: Dict[str, float]) -> float:
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    """感情スカラーに基づいて Shadow の混合比率を決定"""
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar: float) -> float:
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # --- 各最適化器のコアな勾配更新ロジック (プライベートメソッドとして統合) ---
+
+    def _lynx_update(
+        self, 
+        p: torch.Tensor, 
+        grad: torch.Tensor, 
+        param_state: Dict[str, Any], 
+        lr: float, 
+        beta1: float, 
+        beta2: float, 
+        wd_actual: float
+    ):
+        """EmoLynx のコアな勾配更新ロジック"""
+        # Stepweight decay: p = p * (1 - lr * wd)
+        p.mul_(1. - lr * wd_actual)
+
+        # Lynx 固有の EMA 状態は param_state に保持
+        if 'exp_avg_lynx' not in param_state:
+            param_state['exp_avg_lynx'] = torch.zeros_like(p)
+        exp_avg = param_state['exp_avg_lynx']
+
+        # 勾配ブレンド
+        blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+        
+        # 符号ベースの更新
+        p.add_(blended_grad.sign_(), alpha = -lr)
+
+        # exp_avg 更新
+        exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+    def _navi_update(
+        self, 
+        p: torch.Tensor, 
+        grad: torch.Tensor, 
+        param_state: Dict[str, Any], 
+        lr: float, 
+        betas: Tuple[float, float], 
+        eps: float, 
+        weight_decay: float
+    ):
+        """EmoNavi のコアな勾配更新ロジック"""
+        beta1, beta2 = betas
+
+        exp_avg = param_state.setdefault('exp_avg_navi', torch.zeros_like(p))
+        exp_avg_sq = param_state.setdefault('exp_avg_sq_navi', torch.zeros_like(p.to(torch.float32)))
+
+        exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+        exp_avg_sq.mul_(beta2).addcmul_(grad.to(torch.float32), grad.to(torch.float32), value=1 - beta2)
+        denom = exp_avg_sq.sqrt().add_(eps)
+
+        # Weight decay (標準的手法)
+        if weight_decay:
+            p.mul_(1 - lr * weight_decay) 
+
+        p.addcdiv_(exp_avg, denom, value=-lr)
+
+    def _fact_update(
+        self, 
+        p: torch.Tensor, 
+        grad: torch.Tensor, 
+        param_state: Dict[str, Any], 
+        lr: float, 
+        betas: Tuple[float, float], # beta2 は現状使われないが互換性のため残す (1D勾配で使用)
+        eps: float, 
+        weight_decay: float
+    ):
+        """EmoFact のコアな勾配更新ロジック (Adafactor ライク)"""
+        beta1, beta2 = betas
+
+        if grad.dim() >= 2:
+            # 行と列の2乗平均を計算 (分散の軽量な近似)
+            # gradをfloat32にキャストして計算することで数値安定性を高める
+            r_sq = torch.mean(grad.to(torch.float32) * grad.to(torch.float32), dim=tuple(range(1, grad.dim())), keepdim=True).add_(eps)
+            c_sq = torch.mean(grad.to(torch.float32) * grad.to(torch.float32), dim=0, keepdim=True).add_(eps)
+
+            param_state.setdefault('exp_avg_r_fact', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+            param_state.setdefault('exp_avg_c_fact', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+            
+            # 再構築した近似勾配の平方根の積で正規化
+            denom = torch.sqrt(param_state['exp_avg_r_fact'] * param_state['exp_avg_c_fact']).add_(eps)
+            update_term = grad / denom # grad は元の型（float16またはfloat32）
+
+        else: # 1次元(ベクトル)の勾配補正
+            exp_avg = param_state.setdefault('exp_avg_fact', torch.zeros_like(p))
+            exp_avg_sq = param_state.setdefault('exp_avg_sq_fact', torch.zeros_like(p.to(torch.float32)))
+            
+            exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+            exp_avg_sq.mul_(beta2).addcmul_(grad.to(torch.float32), grad.to(torch.float32), value=1 - beta2)
+            denom = exp_avg_sq.sqrt().add_(eps)
+            update_term = exp_avg / denom
+
+        # 最終的なパラメータ更新 (decoupled weight decayも適用)
+        # decoupled_weight_decay は __init__ でグループにdefaultsとして渡されているが、
+        # ここではfactorロジック自体がweight_decayを受け取る形式
+        p.mul_(1 - weight_decay * lr) 
+        p.add_(update_term, alpha=-lr)
+
+
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None):
+        loss = None
+        if exists(closure):
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        # 全体の scalar_hist を EmoClan インスタンスで管理
+        global_scalar_hist = self.state.setdefault('global_scalar_hist', [])
+        
+        # 全体としての感情EMA状態を self.state に保持し、現在の感情スカラーを計算
+        global_ema_state = self.state.setdefault('global_ema', {'short': loss_val, 'long': loss_val})
+        global_ema_state['short'] = 0.3 * loss_val + 0.7 * global_ema_state['short']
+        global_ema_state['long'] = 0.01 * loss_val + 0.99 * global_ema_state['long']
+        current_global_scalar = self._compute_scalar(global_ema_state)
+        
+        # global_scalar_hist に現在の感情スカラーを追加
+        global_scalar_hist.append(current_global_scalar)
+        if len(global_scalar_hist) >= 33:
+            global_scalar_hist.pop(0)
+
+
+        for group in self.param_groups:
+            lr = group['lr']
+            wd = group['weight_decay']
+            eps = group['eps']
+            decoupled_wd = group['decoupled_weight_decay']
+            
+            lynx_beta1, lynx_beta2 = group['lynx_betas']
+            navi_fact_betas = group['betas'] # Navi/Fact 共通の beta を使用 (デフォルトの betas)
+            
+            # Lynx の decoupled_wd のための _wd_actual 計算
+            _wd_actual_lynx = wd
+            if decoupled_wd:
+                _wd_actual_lynx /= self._init_lr
+
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                param_state = self.state[p] # 各パラメータごとの状態
+
+                # --- 各パラメータごとの感情機構の更新と Shadow 処理 ---
+                # 各パラメータの state['ema'] は、それぞれの loss_val (全体で共通) を元に更新される
+                # ただし、現状の loss_val はクロージャから受け取った単一の値なので、
+                # 各パラメータ固有の「感情」を定義するより、全体としての感情が使われることになる。
+                # use_shadow が True の場合にのみ Shadow 関連の処理を実行
+                if self.use_shadow:  
+                    param_ema = self._update_ema(param_state, loss_val) 
+                    param_scalar = self._compute_scalar(param_ema) # 各パラメータ固有のスカラー
+
+                    ratio = self._decide_ratio(param_scalar) # 各パラメータ固有の ratio
+
+                    if ratio > 0:
+                        if 'shadow' not in param_state:
+                            param_state['shadow'] = p.clone()
+                        else:
+                            # Shadow を現在値にブレンド
+                            p.mul_(1 - ratio).add_(param_state['shadow'], alpha=ratio)
+                        # Shadow を現在値に追従させる
+                        param_state['shadow'].lerp_(p, 0.05)
+
+                # --- 最適化器の選択と勾配更新 ---
+                # 現在のglobal_scalar_histに記録された全体としての感情スカラーに基づいてフェーズを判断
+                # global_scalar > abs 0.6 の範囲は Lynx
+                # global_scalar > abs 0.3 の範囲は Fact
+                # global_scalar < abs 0.3 の範囲は Navi
+                if abs(current_global_scalar) > 0.6: # 序盤・過学習・発散時
+                    self._lynx_update(p, grad, param_state, lr, lynx_beta1, lynx_beta2, _wd_actual_lynx)
+                elif abs(current_global_scalar) > 0.3: # 終盤・過学習・発散傾向時
+                    self._fact_update(p, grad, param_state, lr, navi_fact_betas, eps, wd)
+                else: # -0.3 <= current_global_scalar <= 0.3 の中盤･平時(安定期)
+                    self._navi_update(p, grad, param_state, lr, navi_fact_betas, eps, wd)
+
+        # Early Stop判断
+        # global_scalar_hist の評価
+        if len(global_scalar_hist) >= 32:
+            buf = global_scalar_hist
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ Emoシリーズは、Adam、Adafactor、Lion、Tiger、等から多くを学びました。  
+ この開発において先人たちの知見に深く感謝しつつ今後も新しい可能性を探究します。 
+ The Emo series has learned much from Adam, Adafactor, Lion, and Tiger.  
+ Rather than being their successors,  
+ In its development, we deeply appreciate the insights of those who came before us—and continue to explore new possibilities beyond them.  
+"""

1Gv2_AMP-compatible/emofact.py

@@ -0,0 +1,129 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoFact v2.0 (250815) shadow-system v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+emosens shadow-effect v1.0 反映 shadow-system 修正
+"""
+
+class EmoFact(Optimizer):
+    # クラス定義＆初期化
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # 感情EMA更新・スカラー生成 (既存ロジックを維持)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar)
+
+                # shadow_param：必要時のみ更新 (既存ロジックを維持)
+                if ratio > 0:
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # --- 勾配補正ロジック ---
+                # 行列の形状が2次元以上の場合、分散情報ベースのAB近似を使用
+                if grad.dim() >= 2:
+                    # 行と列の2乗平均を計算 (分散の軽量な近似)
+                    r_sq = torch.mean(grad * grad, dim=tuple(range(1, grad.dim())), keepdim=True).add_(group['eps'])
+                    c_sq = torch.mean(grad * grad, dim=0, keepdim=True).add_(group['eps'])
+
+                    # 分散情報から勾配の近似行列を生成
+                    # AB行列として見立てたものを直接生成し更新項を計算する
+                    # A = sqrt(r_sq), B = sqrt(c_sq) とすることでAB行列の近似を再現
+                    # これをEMAで平滑化する
+                    beta1, beta2 = group['betas']
+                    
+                    state.setdefault('exp_avg_r', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+                    state.setdefault('exp_avg_c', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+                    
+                    # 再構築した近似勾配の平方根の積で正規化
+                    # これにより2次モーメントのような役割を果たす
+                    denom = torch.sqrt(state['exp_avg_r'] * state['exp_avg_c']).add_(group['eps'])
+                    
+                    # 最終的な更新項を計算
+                    update_term = grad / denom
+
+                # 1次元(ベクトル)の勾配補正(decoupled weight decay 構造に近い)
+                else:
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                    beta1, beta2 = group['betas']
+                    exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                    denom = exp_avg_sq.sqrt().add_(group['eps'])
+                    update_term = exp_avg / denom
+
+                # 最終的なパラメータ更新 (decoupled weight decayも適用)
+                p.add_(p, alpha=-group['weight_decay'] * group['lr'])
+                p.add_(update_term, alpha=-group['lr'])
+
+                # --- Early Stop ロジック (既存ロジックを維持) ---
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Fact is inspired by Adafactor,  
+ and its VRAM-friendly design is something everyone loves.
+"""

1Gv2_AMP-compatible/emolynx.py

@@ -0,0 +1,139 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Tuple, Callable, Union
+
+"""
+EmoLynx v2.0 (250815) shadow-system v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+emosens shadow-effect v1.0 反映 shadow-system 修正
+"""
+
+# Helper function (Lynx)
+def exists(val):
+    return val is not None
+
+class EmoLynx(Optimizer):
+    # クラス定義＆初期化
+    def __init__(self, params: Union[list, torch.nn.Module], lr=1e-3, betas=(0.9, 0.99), 
+    # lynx用ベータ･互換性の追加(lynx用beta1･beta2)
+                 eps=1e-8, weight_decay=0.01, decoupled_weight_decay: bool = False): 
+
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        
+        # lynxに応じてウェイト減衰のため保存
+        self._init_lr = lr
+        self.should_stop = False # 停止フラグの初期化
+        self.decoupled_wd = decoupled_weight_decay
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None): # クロージャの型ヒントを追加
+        loss = None
+        if exists(closure): # 一貫性のためにexistsヘルパーを使う
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            # リンクス共通パラメータ抽出
+            lr, wd, beta1, beta2 = group['lr'], group['weight_decay'], *group['betas']
+            
+            # ウェイト減衰の処理を分離 (from lynx)
+            _wd_actual = wd
+            if self.decoupled_wd:
+                _wd_actual /= self._init_lr # 非連結時ウェイト減衰調整
+
+            for p in filter(lambda p: exists(p.grad), group['params']): # PGチェックにフィルタ
+
+                grad = p.grad # PG直接使用(計算に".data"不要)
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar)
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                if ratio > 0:
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        state['shadow'].lerp_(p, 0.05) 
+                        # lynx更新前 p で shadow 更新(現在値を5%ずつ追従)
+                        # p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        # EmoNavi: p = p * (1-ratio) + shadow * ratio
+
+                # --- Start Lynx Gradient Update Logic ---
+                
+                # lynx初期化(exp_avg_sq)
+                if 'exp_avg' not in state:
+                    state['exp_avg'] = torch.zeros_like(p)
+                exp_avg = state['exp_avg']
+
+                # Stepweight decay (from lynx): p = p * (1 - lr * wd)
+                # decoupled_wd 考慮 _wd_actual 使用(EmoNaviのwdは最後に適用)
+                p.mul_(1. - lr * _wd_actual)
+
+                # 勾配ブレンド
+                # m_t = beta1 * exp_avg_prev + (1 - beta1) * grad
+                blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+                
+                # p: p = p - lr * sign(blended_grad)
+                p.add_(blended_grad.sign_(), alpha = -lr)
+
+                # exp_avg = beta2 * exp_avg + (1 - beta2) * grad
+                exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+                # --- End Lynx Gradient Update Logic ---
+
+                # Early Stop用 scalar記録(バッファ共通で管理/最大32件保持/動静評価)
+                # この部分は p.state ではなく self.state にアクセスする
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図) - This part is outside the inner loop
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Lynx was developed with inspiration from Lion and Tiger, 
+ which we deeply respect for their lightweight and intelligent design.  
+ Lynx also integrates EmoNAVI to enhance its capabilities.
+"""

1Gv2_AMP-compatible/emonavi.py

@@ -0,0 +1,113 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoNavi v2.0 (250815) shadow-system v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+emosens shadow-effect v1.0 反映 shadow-system 修正
+"""
+
+class EmoNavi(Optimizer):
+    # クラス定義＆初期化
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar)
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                if ratio > 0:
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # スカラー生成：短期と長期EMAの差分から信号を得る(高ぶりの強さ)
+                # 混合比率：スカラーが閾値を超える場合にのみ計算される(信頼できる感情信号かどうかの選別)
+                # → スカラー値が小さい場合は ratio = 0 となり、shadow混合は行われない
+                # → 信頼できる強い差分のときのみ感情機構が発動する(暗黙の信頼度判定)                
+                
+                # 1次・2次モーメントを使った勾配補正(decoupled weight decay 構造に近い)
+                exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                beta1, beta2 = group['betas']
+                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                denom = exp_avg_sq.sqrt().add_(group['eps'])
+
+                step_size = group['lr']
+                if group['weight_decay']:
+                    p.add_(p, alpha=-group['weight_decay'] * step_size)
+                p.addcdiv_(exp_avg, denom, value=-step_size)
+
+        # 感情機構の発火が収まり"十分に安定"していることを外部伝達できる(自動停止ロジックではない)
+                # Early Stop用 scalar 記録(バッファ共通で管理/最大32件保持/動静評価)
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図)
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True  # 💡 外部からこれを見て判断可
+
+        # 32ステップ分のスカラー値の静かな条件を満たした時"フラグ" should_stop = True になるだけ
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ An emotion-driven optimizer that feels loss and navigates accordingly.
+ Don't think. Feel. Don't stop. Keep running. Believe in what's beyond.
+"""

1Gv2_AMP-compatible/emoneco.py

@@ -0,0 +1,161 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Tuple, Callable, Union
+
+"""
+EmoNeco v2.0 (250815) shadow-system v2.0 scalar-switch v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoNeco(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True にすることで shadow をオンにできる
+emosens shadow-effect v1.0 反映 shadow-system、scalar-switch 修正
+"""
+
+# Helper function (Lynx)
+def exists(val):
+    return val is not None
+# Soft Sign 関数
+def softsign(x):
+    return x / (1 + x.abs())
+
+class EmoNeco(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params: Union[list, torch.nn.Module], lr=1e-3, betas=(0.9, 0.99), 
+    # neco用ベータ･互換性の追加(neco用beta1･beta2)
+                 eps=1e-8, weight_decay=0.01, decoupled_weight_decay: bool = False, use_shadow: bool = False): 
+
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        
+        # ウェイト減衰のため保存
+        self._init_lr = lr
+        self.decoupled_wd = decoupled_weight_decay
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None): # クロージャの型ヒントを追加
+        loss = None
+        if exists(closure): # 一貫性のためにexistsヘルパーを使う
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            # 共通パラメータ抽出
+            lr, wd, beta1, beta2 = group['lr'], group['weight_decay'], *group['betas']
+            
+            # ウェイト減衰の処理を分離 (from lynx)
+            _wd_actual = wd
+            if self.decoupled_wd:
+                _wd_actual /= self._init_lr # 非連結時ウェイト減衰調整
+
+            for p in filter(lambda p: exists(p.grad), group['params']): # PGチェックにフィルタ
+
+                grad = p.grad # PG直接使用(計算に".data"不要)
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        state['shadow'].lerp_(p, 0.05) 
+                        # 更新前 p で shadow 更新(現在値を5%ずつ追従)
+                        # p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        # EmoNavi: p = p * (1-ratio) + shadow * ratio
+
+                # --- Start Neco Gradient Update Logic ---
+                
+                # neco初期化(exp_avg_sq)
+                if 'exp_avg' not in state:
+                    state['exp_avg'] = torch.zeros_like(p)
+                exp_avg = state['exp_avg']
+
+                # Stepweight decay (from lynx): p = p * (1 - lr * wd)
+                # decoupled_wd 考慮 _wd_actual 使用(EmoNaviのwdは最後に適用)
+                p.mul_(1. - lr * _wd_actual)
+
+                # 勾配ブレンド
+                # m_t = beta1 * exp_avg_prev + (1 - beta1) * grad
+                blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+                grad_norm = torch.norm(grad, dtype=torch.float32) # 勾配ノルムの計算
+
+                # 削除：-0.2 < scalar <= -0.5 : SoftSign (ゆっくり滑らかに)
+                #  0.2 < abs(scalar) <=  0.5 : SoftSign+norm (揺れを滑らかに)
+                # それ以外 Cautious (平時や過適合や崩壊傾向を慎重に)
+                # p - lr * softsign(blended_grad) (from softsign)
+                # p - lr * direction * mask (from Cautious)
+                # safe_norm 極値のブレンド勾配に対するスケーリング
+                if 0.2 < abs(scalar) <= 0.5:
+                    safe_norm = grad_norm + eps
+                    modified_grad = softsign(blended_grad) * safe_norm
+                    p.add_(-lr * modified_grad) 
+                else:
+                    direction = blended_grad.sign()    # 勾配方向の符号 Cautious 処理
+                    mask = (direction == grad.sign())  # 過去の勾配と方向が一致している部分のみ更新
+                    p.add_(direction * mask, alpha = -lr)  # Cautious 更新
+
+                # exp_avg = beta2 * exp_avg + (1 - beta2) * grad
+                exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+                # --- End Neco Gradient Update Logic ---
+
+                # Early Stop用 scalar記録(バッファ共通で管理/最大32件保持/動静評価)
+                # この部分は p.state ではなく self.state にアクセスする
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図) This part is outside the inner loop
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Neco was developed with inspiration from Lion, Tiger, Cautious, softsign, and EmoLynx 
+ which we deeply respect for their lightweight and intelligent design.  
+ Neco also integrates EmoNAVI to enhance its capabilities.
+"""

1Gv2_AMP-compatible/emozeal.py

@@ -0,0 +1,161 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoZeal v2.0 (250815) shadow-system v2.0 scalar-switch v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoNeco(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True にすることで shadow をオンにできる
+emosens shadow-effect v1.0 反映 shadow-system、scalar-switch 修正
+"""
+
+# Soft Sign 関数
+def softsign(x): 
+    return x / (1 + x.abs())
+    
+class EmoZeal(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01, use_shadow: bool = False): 
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+
+        super().__init__(params, defaults)
+
+        self.alpha_prev = getattr(self, 'alpha_prev', 1.0)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # 感情EMA更新・スカラー生成 (既存ロジックを維持)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # shadow_param：必要時のみ更新 (既存ロジックを維持)
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # --- 勾配補正ロジック ---
+                # 行列の形状が2次元以上の場合、分散情報ベースのAB近似を使用
+                if grad.dim() >= 2:
+                    # 行と列の2乗平均を計算 (分散の軽量な近似)
+                    r_sq = torch.mean(grad * grad, dim=tuple(range(1, grad.dim())), keepdim=True).add_(group['eps'])
+                    c_sq = torch.mean(grad * grad, dim=0, keepdim=True).add_(group['eps'])
+
+                    # 分散情報から勾配の近似行列を生成
+                    # AB行列として見立てたものを直接生成し更新項を計算する
+                    # A = sqrt(r_sq), B = sqrt(c_sq) とすることでAB行列の近似を再現
+                    # これをEMAで平滑化する
+                    beta1, beta2 = group['betas'] 
+                    eps = group['eps'] 
+                    lr = group['lr']   
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    blended_grad = grad.mul(1 - beta1).add_(exp_avg, alpha=beta1)
+                    grad_norm = torch.norm(grad, dtype=torch.float32)
+                    # > abs 0.6 Cautious (過適合や崩壊傾向を慎重に)
+                    # > abs 0.1 SoftSign+NormEPS (揺れを滑らかに)
+                    # 削除：それ以外 SoftSign (ゆっくり滑らかに)
+                    # p - lr * softsign(blended_grad) (from softsign)
+                    # p - lr * direction * mask (from Cautious)
+                    # safe_norm 極値のブレンド勾配に対するスケーリング
+                    if abs(scalar) > 0.6:
+                        direction = blended_grad.sign()    # 勾配方向の符号 Cautious 処理
+                        mask = (direction == grad.sign())  # 過去の勾配と方向が一致する部分のみ更新
+                        p.add_(direction * mask, alpha = -lr)  # Cautious 更新
+                    elif abs(scalar) > 0.1:
+                        safe_norm = grad_norm + eps
+                        modified_grad = softsign(blended_grad) * safe_norm
+                        p.add_(-lr * modified_grad) 
+                    
+                    state.setdefault('exp_avg_r', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+                    state.setdefault('exp_avg_c', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+                    
+                    # 再構築した近似勾配の平方根の積で正規化
+                    # これにより2次モーメントのような役割を果たす
+                    denom = torch.sqrt(state['exp_avg_r'] * state['exp_avg_c']) + eps
+                    
+                    # 最終的な更新項を計算
+                    update_term = grad / denom
+
+                # 1次元(ベクトル)の勾配補正(decoupled weight decay 構造に近い)
+                else:
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                    beta1, beta2 = group['betas']
+                    exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                    denom = exp_avg_sq.sqrt().add_(group['eps'])
+                    update_term = exp_avg / denom
+
+                # 最終的なパラメータ更新 (decoupled weight decayも適用)
+                p.add_(p, alpha=-group['weight_decay'] * group['lr'])
+                p.add_(update_term, alpha=-group['lr'])
+
+                # --- Early Stop ロジック (既存ロジックを維持) ---
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Zeal is inspired by Adafactor, and EmoFact,  
+ and its VRAM-friendly design is something everyone loves.
+"""

1Gv3_AMP-compatible/emoclan.py

@@ -0,0 +1,277 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Callable, Union, Dict, Any, Tuple
+
+"""
+EmoClan v3.0 (250825) shadow-system v2.0 -effect NoN -moment v1.0 scalar-switch v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoClan(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True にすることで shadow をオンにできる
+emosens shadow-effect v1.0 反映 shadow-system、scalar-switch 修正
+"""
+
+# Helper function
+def exists(val):
+    return val is not None
+
+class EmoClan(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params: Union[list, torch.nn.Module], 
+                 lr: float = 1e-3, 
+                 betas: Tuple[float, float] = (0.9, 0.999), 
+                 eps: float = 1e-8, 
+                 weight_decay: float = 0.01,
+                 lynx_betas: Tuple[float, float] = (0.9, 0.99), # Lynx 固有の beta
+                 decoupled_weight_decay: bool = False,
+                 use_shadow: bool = False
+                ):
+        
+        if not 0.0 <= lr:
+            raise ValueError(f"Invalid learning rate: {lr}")
+        if not 0.0 <= eps:
+            raise ValueError(f"Invalid epsilon value: {eps}")
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError(f"Invalid beta parameter at index 0: {betas[0]}")
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError(f"Invalid beta parameter at index 1: {betas[1]}")
+        
+        # Lynx の betas もバリデーション
+        if not 0.0 <= lynx_betas[0] < 1.0:
+            raise ValueError(f"Invalid lynx_beta parameter at index 0: {lynx_betas[0]}")
+        if not 0.0 <= lynx_betas[1] < 1.0:
+            raise ValueError(f"Invalid lynx_beta parameter at index 1: {lynx_betas[1]}")
+
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay,
+                        lynx_betas=lynx_betas, decoupled_weight_decay=decoupled_weight_decay)
+        super().__init__(params, defaults)
+        
+        self._init_lr = lr # decoupled weight decay のために保存 (Lynx用)
+        self.should_stop = False # 全体の停止フラグ
+        self.use_shadow = use_shadow # EmoClanインスタンス自身がuse_shadowを保持
+
+    # --- 感情機構 (Emotion Mechanism) ---
+    def _update_ema(self, param_state: Dict[str, Any], loss_val: float) -> Dict[str, float]:
+        """損失値に基づいて短期・長期 EMA を更新"""
+        # param_state は各パラメータの state['ema'] を保持する
+        ema = param_state.setdefault('ema', {'short': loss_val, 'long': loss_val})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema['short']
+        ema['long'] = 0.01 * loss_val + 0.99 * ema['long']
+        return ema
+
+    """EMA の差分から感情スカラー値を生成"""
+    def _compute_scalar(self, ema: Dict[str, float]) -> float:
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    """感情スカラーに基づいて Shadow の混合比率を決定"""
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar: float) -> float:
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # --- 各最適化器のコアな勾配更新ロジック (プライベートメソッドとして統合) ---
+
+    def _lynx_update(
+        self, 
+        p: torch.Tensor, 
+        grad: torch.Tensor, 
+        param_state: Dict[str, Any], 
+        lr: float, 
+        beta1: float, 
+        beta2: float, 
+        wd_actual: float,
+        scalar
+    ):
+        """EmoLynx のコアな勾配更新ロジック"""
+        # Stepweight decay: p = p * (1 - lr * wd)
+        p.mul_(1. - lr * wd_actual)
+
+        # Lynx 固有の EMA 状態は param_state に保持
+        if 'exp_avg_lynx' not in param_state:
+            param_state['exp_avg_lynx'] = torch.zeros_like(p)
+        exp_avg = param_state['exp_avg_lynx']
+
+        # 勾配ブレンド
+        blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+        
+        # 符号ベースの更新
+        p.add_(blended_grad.sign_(), alpha = -lr * (1 - abs(scalar)))
+
+        # exp_avg 更新
+        exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+    def _navi_update(
+        self, 
+        p: torch.Tensor, 
+        grad: torch.Tensor, 
+        param_state: Dict[str, Any], 
+        lr: float, 
+        betas: Tuple[float, float], 
+        eps: float, 
+        weight_decay: float,
+        scalar
+    ):
+        """EmoNavi のコアな勾配更新ロジック"""
+        beta1, beta2 = betas
+
+        exp_avg = param_state.setdefault('exp_avg_navi', torch.zeros_like(p))
+        exp_avg_sq = param_state.setdefault('exp_avg_sq_navi', torch.zeros_like(p.to(torch.float32)))
+
+        exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+        exp_avg_sq.mul_(beta2).addcmul_(grad.to(torch.float32), grad.to(torch.float32), value=1 - beta2)
+        denom = exp_avg_sq.sqrt().add_(eps)
+
+        # Weight decay (標準的手法)
+        if weight_decay:
+            p.mul_(1 - lr * weight_decay) 
+
+        p.addcdiv_(exp_avg, denom, value=-lr * (1 - abs(scalar)))
+
+    def _fact_update(
+        self, 
+        p: torch.Tensor, 
+        grad: torch.Tensor, 
+        param_state: Dict[str, Any], 
+        lr: float, 
+        betas: Tuple[float, float], # beta2 は現状使われないが互換性のため残す (1D勾配で使用)
+        eps: float, 
+        weight_decay: float,
+        scalar
+    ):
+        """EmoFact のコアな勾配更新ロジック (Adafactor ライク)"""
+        beta1, beta2 = betas
+
+        if grad.dim() >= 2:
+            # 行と列の2乗平均を計算 (分散の軽量な近似)
+            # gradをfloat32にキャストして計算することで数値安定性を高める
+            r_sq = torch.mean(grad.to(torch.float32) * grad.to(torch.float32), dim=tuple(range(1, grad.dim())), keepdim=True).add_(eps)
+            c_sq = torch.mean(grad.to(torch.float32) * grad.to(torch.float32), dim=0, keepdim=True).add_(eps)
+
+            param_state.setdefault('exp_avg_r_fact', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+            param_state.setdefault('exp_avg_c_fact', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+            
+            # 再構築した近似勾配の平方根の積で正規化
+            denom = torch.sqrt(param_state['exp_avg_r_fact'] * param_state['exp_avg_c_fact']).add_(eps)
+            update_term = grad / denom # grad は元の型（float16またはfloat32）
+
+        else: # 1次元(ベクトル)の勾配補正
+            exp_avg = param_state.setdefault('exp_avg_fact', torch.zeros_like(p))
+            exp_avg_sq = param_state.setdefault('exp_avg_sq_fact', torch.zeros_like(p.to(torch.float32)))
+            
+            exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+            exp_avg_sq.mul_(beta2).addcmul_(grad.to(torch.float32), grad.to(torch.float32), value=1 - beta2)
+            denom = exp_avg_sq.sqrt().add_(eps)
+            update_term = exp_avg / denom
+
+        # 最終的なパラメータ更新 (decoupled weight decayも適用)
+        # decoupled_weight_decay は __init__ でグループにdefaultsとして渡されているが、
+        # ここではfactorロジック自体がweight_decayを受け取る形式
+        p.mul_(1 - weight_decay * lr) 
+        p.add_(update_term, alpha=-lr * (1 - abs(scalar)))
+
+
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None):
+        loss = None
+        if exists(closure):
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        # 全体の scalar_hist を EmoClan インスタンスで管理
+        global_scalar_hist = self.state.setdefault('global_scalar_hist', [])
+        
+        # 全体としての感情EMA状態を self.state に保持し、現在の感情スカラーを計算
+        global_ema_state = self.state.setdefault('global_ema', {'short': loss_val, 'long': loss_val})
+        global_ema_state['short'] = 0.3 * loss_val + 0.7 * global_ema_state['short']
+        global_ema_state['long'] = 0.01 * loss_val + 0.99 * global_ema_state['long']
+        current_global_scalar = self._compute_scalar(global_ema_state)
+        
+        # global_scalar_hist に現在の感情スカラーを追加
+        global_scalar_hist.append(current_global_scalar)
+        if len(global_scalar_hist) >= 33:
+            global_scalar_hist.pop(0)
+
+
+        for group in self.param_groups:
+            lr = group['lr']
+            wd = group['weight_decay']
+            eps = group['eps']
+            decoupled_wd = group['decoupled_weight_decay']
+            
+            lynx_beta1, lynx_beta2 = group['lynx_betas']
+            navi_fact_betas = group['betas'] # Navi/Fact 共通の beta を使用 (デフォルトの betas)
+            
+            # Lynx の decoupled_wd のための _wd_actual 計算
+            _wd_actual_lynx = wd
+            if decoupled_wd:
+                _wd_actual_lynx /= self._init_lr
+
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                param_state = self.state[p] # 各パラメータごとの状態
+
+                # --- 各パラメータごとの感情機構の更新と Shadow 処理 ---
+                # 各パラメータの state['ema'] は、それぞれの loss_val (全体で共通) を元に更新される
+                # ただし、現状の loss_val はクロージャから受け取った単一の値なので、
+                # 各パラメータ固有の「感情」を定義するより、全体としての感情が使われることになる。
+                # use_shadow が True の場合にのみ Shadow 関連の処理を実行
+                if self.use_shadow:  
+                    param_ema = self._update_ema(param_state, loss_val) 
+                    param_scalar = self._compute_scalar(param_ema) # 各パラメータ固有のスカラー
+
+                    ratio = self._decide_ratio(param_scalar) # 各パラメータ固有の ratio
+
+                    if ratio > 0:
+                        if 'shadow' not in param_state:
+                            param_state['shadow'] = p.clone()
+                        else:
+                            # Shadow を現在値にブレンド
+                            p.mul_(1 - ratio).add_(param_state['shadow'], alpha=ratio)
+                        # Shadow を現在値に追従させる
+                        param_state['shadow'].lerp_(p, 0.05)
+
+                # --- 最適化器の選択と勾配更新 ---
+                # 現在のglobal_scalar_histに記録された全体としての感情スカラーに基づいてフェーズを判断
+                # global_scalar > abs 0.6 の範囲は Lynx
+                # global_scalar > abs 0.3 の範囲は Fact
+                # global_scalar < abs 0.3 の範囲は Navi
+                if abs(current_global_scalar) > 0.6: # 序盤・過学習・発散時
+                    self._lynx_update(p, grad, param_state, lr, lynx_beta1, lynx_beta2, _wd_actual_lynx, current_global_scalar)
+                elif abs(current_global_scalar) > 0.3: # 終盤・過学習・発散傾向時
+                    self._fact_update(p, grad, param_state, lr, navi_fact_betas, eps, wd, current_global_scalar)
+                else: # -0.3 <= current_global_scalar <= 0.3 の中盤･平時(安定期)
+                    self._navi_update(p, grad, param_state, lr, navi_fact_betas, eps, wd, current_global_scalar)
+
+        # Early Stop判断
+        # global_scalar_hist の評価
+        if len(global_scalar_hist) >= 32:
+            buf = global_scalar_hist
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ Emoシリーズは、Adam、Adafactor、Lion、Tiger、等から多くを学びました。  
+ この開発において先人たちの知見に深く感謝しつつ今後も新しい可能性を探究します。 
+ The Emo series has learned much from Adam, Adafactor, Lion, and Tiger.  
+ Rather than being their successors,  
+ In its development, we deeply appreciate the insights of those who came before us—and continue to explore new possibilities beyond them.  
+"""

1Gv3_AMP-compatible/emofact.py

@@ -0,0 +1,133 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoFact v3.0 (250825) shadow-system v2.0 -effect NoN -moment v1.0
+AMP対応完了(202507) p.data -> p 修正済み
+emosens shadow-effect v1.0 反映 shadow-system 修正
+optimizer 指定の際に True / False で shadow を切替できる(現在 False)
+"""
+
+class EmoFact(Optimizer):
+    # クラス定義＆初期化
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01, use_shadow: bool = False):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # 感情EMA更新・スカラー生成 (既存ロジックを維持)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar)
+
+                # shadow_param：必要時のみ更新 (スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                if self.use_shadow and ratio > 0:
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # --- 勾配補正ロジック ---
+                # 行列の形状が2次元以上の場合、分散情報ベースのAB近似を使用
+                if grad.dim() >= 2:
+                    # 行と列の2乗平均を計算 (分散の軽量な近似)
+                    r_sq = torch.mean(grad * grad, dim=tuple(range(1, grad.dim())), keepdim=True).add_(group['eps'])
+                    c_sq = torch.mean(grad * grad, dim=0, keepdim=True).add_(group['eps'])
+
+                    # 分散情報から勾配の近似行列を生成
+                    # AB行列として見立てたものを直接生成し更新項を計算する
+                    # A = sqrt(r_sq), B = sqrt(c_sq) とすることでAB行列の近似を再現
+                    # これをEMAで平滑化する
+                    beta1, beta2 = group['betas']
+                    
+                    state.setdefault('exp_avg_r', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+                    state.setdefault('exp_avg_c', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+                    
+                    # 再構築した近似勾配の平方根の積で正規化
+                    # これにより2次モーメントのような役割を���たす
+                    denom = torch.sqrt(state['exp_avg_r'] * state['exp_avg_c']).add_(group['eps'])
+                    
+                    # 最終的な更新項を計算
+                    update_term = grad / denom
+
+                # 1次元(ベクトル)の勾配補正(decoupled weight decay 構造に近い)
+                else:
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                    beta1, beta2 = group['betas']
+                    exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                    denom = exp_avg_sq.sqrt().add_(group['eps'])
+                    update_term = exp_avg / denom
+
+                # 最終的なパラメータ更新 (decoupled weight decayも適用)
+                p.add_(p, alpha=-group['weight_decay'] * group['lr'])
+                p.add_(update_term, alpha=-group['lr'] * (1 - abs(scalar)))
+
+                # --- Early Stop ロジック (既存ロジックを維持) ---
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Fact is inspired by Adafactor, and emoairy, 
+ and its VRAM-friendly design is something everyone loves.
+"""

1Gv3_AMP-compatible/emolynx.py

@@ -0,0 +1,140 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Tuple, Callable, Union
+
+"""
+EmoLynx v3.0 (250825) shadow-system v2.0 -effect NoN -moment v1.0
+AMP対応完了(202507) p.data -> p 修正済み
+emosens shadow-effect v1.0 反映 shadow-system 修正
+optimizer 指定の際に True / False で shadow を切替できる(現在 False)
+"""
+
+# Helper function (Lynx)
+def exists(val):
+    return val is not None
+
+class EmoLynx(Optimizer):
+    # クラス定義＆初期化 lynx用ベータ･互換性の追加(lynx用beta1･beta2)
+    def __init__(self, params: Union[list, torch.nn.Module], lr=1e-3, betas=(0.9, 0.99), 
+                 eps=1e-8, weight_decay=0.01, decoupled_weight_decay: bool = False, use_shadow: bool = False): 
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        # lynxに応じてウェイト減衰のため保存
+        self._init_lr = lr
+        self.should_stop = False # 停止フラグの初期化
+        self.decoupled_wd = decoupled_weight_decay
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None): # クロージャの型ヒントを追加
+        loss = None
+        if exists(closure): # 一貫性のためにexistsヘルパーを使う
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            # リンクス共通パラメータ抽出
+            lr, wd, beta1, beta2 = group['lr'], group['weight_decay'], *group['betas']
+            
+            # ウェイト減衰の処理を分離 (from lynx)
+            _wd_actual = wd
+            if self.decoupled_wd:
+                _wd_actual /= self._init_lr # 非連結時ウェイト減衰調整
+
+            for p in filter(lambda p: exists(p.grad), group['params']): # PGチェックにフィルタ
+
+                grad = p.grad # PG直接使用(計算に".data"不要)
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar)
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                if self.use_shadow and ratio > 0:
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        state['shadow'].lerp_(p, 0.05) 
+                        # lynx更新前 p で shadow 更新(現在値を5%ずつ追従)
+                        # p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        # EmoNavi: p = p * (1-ratio) + shadow * ratio
+
+                # --- Start Lynx Gradient Update Logic ---
+                
+                # lynx初期化(exp_avg_sq)
+                if 'exp_avg' not in state:
+                    state['exp_avg'] = torch.zeros_like(p)
+                exp_avg = state['exp_avg']
+
+                # Stepweight decay (from lynx): p = p * (1 - lr * wd)
+                # decoupled_wd 考慮 _wd_actual 使用(EmoNaviのwdは最後に適用)
+                p.mul_(1. - lr * _wd_actual)
+
+                # 勾配ブレンド
+                # m_t = beta1 * exp_avg_prev + (1 - beta1) * grad
+                blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+                
+                # p: p = p - lr * sign(blended_grad)
+                p.add_(blended_grad.sign_(), alpha = -lr * (1 - abs(scalar)))
+
+                # exp_avg = beta2 * exp_avg + (1 - beta2) * grad
+                exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+                # --- End Lynx Gradient Update Logic ---
+
+                # Early Stop用 scalar記録(バッファ共通で管理/最大32件保持/動静評価)
+                # この部分は p.state ではなく self.state にアクセスする
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図) - This part is outside the inner loop
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Lynx was developed with inspiration from Lion, Tiger, and emocats, 
+ which we deeply respect for their lightweight and intelligent design.  
+ Lynx also integrates EmoNAVI to enhance its capabilities.
+"""

1Gv3_AMP-compatible/emonavi.py

@@ -0,0 +1,118 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoNavi v3.0 (250825) shadow-system v2.0 -effect NoN -moment v1.0
+AMP対応完了(202507) p.data -> p 修正済み
+emosens shadow-effect v1.0 反映 shadow-system 修正
+optimizer 指定の際に True / False で shadow を切替できる(現在 False)
+"""
+
+class EmoNavi(Optimizer):
+    # クラス定義＆初期化
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01, use_shadow: bool = False):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar)
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                if self.use_shadow and ratio > 0:
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # スカラー生成：短期と長期EMAの差分から信号を得る(高ぶりの強さ)
+                # 混合比率：スカラーが閾値を超える場合にのみ計算される(信頼できる感情信号かどうかの選別)
+                # → スカラー値が小さい場合は ratio = 0 となり、shadow混合は行われない
+                # → 信頼できる強い差分のときのみ感情機構が発動する(暗黙の信頼度判定)                
+                
+                # 1次・2次モーメントを使った勾配補正(decoupled weight decay 構造に近い)
+                exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                beta1, beta2 = group['betas']
+
+                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                denom = exp_avg_sq.sqrt().add_(group['eps'])
+
+                step_size = group['lr']
+                if group['weight_decay']:
+                    p.add_(p, alpha=-group['weight_decay'] * step_size)
+                p.addcdiv_(exp_avg, denom, value=-step_size * (1 - abs(scalar)))
+
+        # 感情機構の発火が収まり"十分に安定"していることを外部伝達できる(自動停止ロジックではない)
+                # Early Stop用 scalar 記録(バッファ共通で管理/最大32件保持/動静評価)
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図)
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True  # 💡 外部からこれを見て判断可
+
+        # 32ステップ分のスカラー値の静かな条件を満たした時"フラグ" should_stop = True になるだけ
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ An emotion-driven optimizer that feels loss and navigates accordingly.
+ Don't think. Feel. Don't stop. Keep running. Believe in what's beyond.
+"""

1Gv3_AMP-compatible/emoneco.py

@@ -0,0 +1,162 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Tuple, Callable, Union
+
+"""
+EmoNeco v3.0 (250825) shadow-system v2.0 -effect NoN -moment v1.0 scalar-switch v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoNeco(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True にすることで shadow をオンにできる
+emosens shadow-effect v1.0 反映 shadow-system、scalar-switch 修正
+"""
+
+# Helper function (Lynx)
+def exists(val):
+    return val is not None
+# Soft Sign 関数
+def softsign(x):
+    return x / (1 + x.abs())
+
+class EmoNeco(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params: Union[list, torch.nn.Module], lr=1e-3, betas=(0.9, 0.99), 
+    # neco用ベータ･互換性の追加(neco用beta1･beta2)
+                 eps=1e-8, weight_decay=0.01, decoupled_weight_decay: bool = False, use_shadow: bool = False): 
+
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        
+        # ウェイト減衰のため保存
+        self._init_lr = lr
+        self.decoupled_wd = decoupled_weight_decay
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None): # クロージャの型ヒントを追加
+        loss = None
+        if exists(closure): # 一貫性のためにexistsヘルパーを使う
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            # 共通パラメータ抽出
+            lr, wd, beta1, beta2 = group['lr'], group['weight_decay'], *group['betas']
+            
+            # ウェイト減衰の処理を分離 (from lynx)
+            _wd_actual = wd
+            if self.decoupled_wd:
+                _wd_actual /= self._init_lr # 非連結時ウェイト減衰調整
+
+            for p in filter(lambda p: exists(p.grad), group['params']): # PGチェックにフィルタ
+
+                grad = p.grad # PG直接使用(計算に".data"不要)
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        state['shadow'].lerp_(p, 0.05) 
+                        # 更新前 p で shadow 更新(現在値を5%ずつ追従)
+                        # p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        # EmoNavi: p = p * (1-ratio) + shadow * ratio
+
+                # --- Start Neco Gradient Update Logic ---
+                
+                # neco初期化(exp_avg)
+                if 'exp_avg' not in state:
+                    state['exp_avg'] = torch.zeros_like(p)
+                exp_avg = state['exp_avg']
+
+                # Stepweight decay (from lynx): p = p * (1 - lr * wd)
+                # decoupled_wd 考慮 _wd_actual 使用(EmoNaviのwdは最後に適用)
+                p.mul_(1. - lr * _wd_actual)
+
+                # 勾配ブレンド
+                # m_t = beta1 * exp_avg_prev + (1 - beta1) * grad
+                blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+                grad_norm = torch.norm(grad, dtype=torch.float32) # 勾配ノルムの計算
+
+                # 削除：-0.2 < scalar <= -0.5 : SoftSign (ゆっくり滑らかに)
+                #  0.2 < abs(scalar) <=  0.5 : SoftSign+norm (揺れを滑らかに)
+                # それ以外 Cautious (平時や過適合や崩壊傾向を慎重に)
+                # p - lr * softsign(blended_grad) (from softsign)
+                # p - lr * direction * mask (from Cautious)
+                # safe_norm 極値のブレンド勾配に対するスケーリング
+                if 0.2 < abs(scalar) <= 0.5:
+                    safe_norm = grad_norm + eps
+                    modified_grad = softsign(blended_grad) * safe_norm * (1 - abs(scalar))
+                    p.add_(-lr * modified_grad) 
+                else:
+                    direction = blended_grad.sign()    # 勾配方向の符号 Cautious 処理
+                    mask = (direction == grad.sign())  # 過去の勾配と方向が一致している部分のみ更新
+                    scaled_direction = direction * mask * (1 - abs(scalar))
+                    p.add_(scaled_direction, alpha = -lr)  # Cautious 更新
+
+                # exp_avg = beta2 * exp_avg + (1 - beta2) * grad：勾配の履歴
+                exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+                # --- End Neco Gradient Update Logic ---
+
+                # Early Stop用 scalar記録(バッファ共通で管理/最大32件保持/動静評価)
+                # この部分は p.state ではなく self.state にアクセスする
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図) This part is outside the inner loop
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Neco was developed with inspiration from Lion, Tiger, Cautious, softsign, and EmoLynx 
+ which we deeply respect for their lightweight and intelligent design.  
+ Neco also integrates EmoNAVI to enhance its capabilities.
+"""

1Gv3_AMP-compatible/emozeal.py

@@ -0,0 +1,161 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoZeal v3.0 (250825) shadow-system v2.0 -effect NoN -moment v1.0 scalar-switch v2.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoNeco(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True にすることで shadow をオンにできる
+emosens shadow-effect v1.0 反映 shadow-system、scalar-switch 修正
+"""
+
+# Soft Sign 関数
+def softsign(x): 
+    return x / (1 + x.abs())
+    
+class EmoZeal(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01, use_shadow: bool = False): 
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+
+        super().__init__(params, defaults)
+
+        self.alpha_prev = getattr(self, 'alpha_prev', 1.0)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # 感情EMA更新・スカラー生成 (既存ロジックを維持)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # shadow_param：必要時のみ更新 (既存ロジックを維持)
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # --- 勾配補正ロジック ---
+                # 行列の形状が2次元以上の場合、分散情報ベースのAB近似を使用
+                if grad.dim() >= 2:
+                    # 行と列の2乗平均を計算 (分散の軽量な近似)
+                    r_sq = torch.mean(grad * grad, dim=tuple(range(1, grad.dim())), keepdim=True).add_(group['eps'])
+                    c_sq = torch.mean(grad * grad, dim=0, keepdim=True).add_(group['eps'])
+
+                    # 分散情報から勾配の近似行列を生成
+                    # AB行列として見立てたものを直接生成し更新項を計算する
+                    # A = sqrt(r_sq), B = sqrt(c_sq) とすることでAB行列の近似を再現
+                    # これをEMAで平滑化する
+                    beta1, beta2 = group['betas'] 
+                    eps = group['eps'] 
+                    lr = group['lr']   
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    blended_grad = grad.mul(1 - beta1).add_(exp_avg, alpha=beta1)
+                    grad_norm = torch.norm(grad, dtype=torch.float32)
+                    # > abs 0.6 Cautious (過適合や崩壊傾向を慎重に)
+                    # > abs 0.1 SoftSign+NormEPS (揺れを滑らかに)
+                    # p - lr * softsign(blended_grad) (from softsign)
+                    # p - lr * direction * mask (from Cautious)
+                    # safe_norm 極値のブレンド勾配に対するスケーリング
+                    if abs(scalar) > 0.6:
+                        direction = blended_grad.sign()    # 勾配方向の符号 Cautious 処理
+                        mask = (direction == grad.sign())  # 過去の勾配と方向が一致する部分のみ更新
+                        scaled_direction = direction * mask * (1 - abs(scalar))
+                        p.add_(scaled_direction, alpha = -lr)  # Cautious 更新
+                    elif abs(scalar) > 0.1:
+                        safe_norm = grad_norm + eps
+                        modified_grad = softsign(blended_grad) * safe_norm * (1 - abs(scalar))
+                        p.add_(-lr * modified_grad) 
+                    
+                    state.setdefault('exp_avg_r', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+                    state.setdefault('exp_avg_c', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+                    
+                    # 再構築した近似勾配の平方根の積で正規化
+                    # これにより2次モーメントのような役割を果たす
+                    denom = torch.sqrt(state['exp_avg_r'] * state['exp_avg_c']) + eps
+                    
+                    # 最終的な更新項を計算
+                    update_term = grad / denom
+
+                # 1次元(ベクトル)の勾配補正(decoupled weight decay 構造に近い)
+                else:
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                    beta1, beta2 = group['betas']
+                    exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                    denom = exp_avg_sq.sqrt().add_(group['eps'])
+                    update_term = exp_avg / denom
+
+                # 最終的なパラメータ更新 (decoupled weight decayも適用)
+                p.add_(p, alpha=-group['weight_decay'] * group['lr'])
+                p.add_(update_term, alpha=-group['lr'] * (1 - abs(scalar)))
+
+                # --- Early Stop ロジック (既存ロジックを維持) ---
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Zeal is inspired by Adafactor, and EmoFact,  
+ and its VRAM-friendly design is something everyone loves.
+"""

1Gv3_AMP-compatible/logs/trec_squad_step_accuracy.json

@@ -0,0 +1,2431 @@
+{
+  "TREC": {
+    "EmoNAVI": [
+      [
+        10,
+        0.274
+      ],
+      [
+        20,
+        0.258
+      ],
+      [
+        30,
+        0.336
+      ],
+      [
+        40,
+        0.374
+      ],
+      [
+        50,
+        0.332
+      ],
+      [
+        60,
+        0.422
+      ],
+      [
+        70,
+        0.308
+      ],
+      [
+        80,
+        0.168
+      ],
+      [
+        90,
+        0.422
+      ],
+      [
+        100,
+        0.32
+      ],
+      [
+        110,
+        0.494
+      ],
+      [
+        120,
+        0.31
+      ],
+      [
+        130,
+        0.344
+      ],
+      [
+        140,
+        0.474
+      ],
+      [
+        150,
+        0.37
+      ],
+      [
+        160,
+        0.402
+      ],
+      [
+        170,
+        0.58
+      ],
+      [
+        180,
+        0.474
+      ],
+      [
+        190,
+        0.516
+      ],
+      [
+        200,
+        0.518
+      ],
+      [
+        210,
+        0.422
+      ],
+      [
+        220,
+        0.522
+      ],
+      [
+        230,
+        0.564
+      ],
+      [
+        240,
+        0.51
+      ],
+      [
+        250,
+        0.672
+      ],
+      [
+        260,
+        0.548
+      ],
+      [
+        270,
+        0.57
+      ],
+      [
+        280,
+        0.538
+      ],
+      [
+        290,
+        0.508
+      ],
+      [
+        300,
+        0.672
+      ],
+      [
+        310,
+        0.606
+      ],
+      [
+        320,
+        0.6
+      ],
+      [
+        330,
+        0.65
+      ],
+      [
+        340,
+        0.662
+      ],
+      [
+        350,
+        0.652
+      ],
+      [
+        360,
+        0.67
+      ],
+      [
+        370,
+        0.632
+      ],
+      [
+        380,
+        0.634
+      ],
+      [
+        390,
+        0.61
+      ],
+      [
+        400,
+        0.7
+      ],
+      [
+        410,
+        0.67
+      ],
+      [
+        420,
+        0.704
+      ],
+      [
+        430,
+        0.692
+      ],
+      [
+        440,
+        0.724
+      ],
+      [
+        450,
+        0.724
+      ],
+      [
+        460,
+        0.722
+      ],
+      [
+        470,
+        0.668
+      ],
+      [
+        480,
+        0.694
+      ],
+      [
+        490,
+        0.744
+      ],
+      [
+        500,
+        0.732
+      ]
+    ],
+    "EmoFACT": [
+      [
+        10,
+        0.246
+      ],
+      [
+        20,
+        0.228
+      ],
+      [
+        30,
+        0.282
+      ],
+      [
+        40,
+        0.328
+      ],
+      [
+        50,
+        0.234
+      ],
+      [
+        60,
+        0.326
+      ],
+      [
+        70,
+        0.332
+      ],
+      [
+        80,
+        0.51
+      ],
+      [
+        90,
+        0.308
+      ],
+      [
+        100,
+        0.332
+      ],
+      [
+        110,
+        0.3
+      ],
+      [
+        120,
+        0.478
+      ],
+      [
+        130,
+        0.36
+      ],
+      [
+        140,
+        0.44
+      ],
+      [
+        150,
+        0.466
+      ],
+      [
+        160,
+        0.396
+      ],
+      [
+        170,
+        0.408
+      ],
+      [
+        180,
+        0.414
+      ],
+      [
+        190,
+        0.376
+      ],
+      [
+        200,
+        0.448
+      ],
+      [
+        210,
+        0.354
+      ],
+      [
+        220,
+        0.426
+      ],
+      [
+        230,
+        0.492
+      ],
+      [
+        240,
+        0.558
+      ],
+      [
+        250,
+        0.488
+      ],
+      [
+        260,
+        0.434
+      ],
+      [
+        270,
+        0.564
+      ],
+      [
+        280,
+        0.394
+      ],
+      [
+        290,
+        0.524
+      ],
+      [
+        300,
+        0.472
+      ],
+      [
+        310,
+        0.498
+      ],
+      [
+        320,
+        0.618
+      ],
+      [
+        330,
+        0.588
+      ],
+      [
+        340,
+        0.528
+      ],
+      [
+        350,
+        0.594
+      ],
+      [
+        360,
+        0.452
+      ],
+      [
+        370,
+        0.562
+      ],
+      [
+        380,
+        0.566
+      ],
+      [
+        390,
+        0.696
+      ],
+      [
+        400,
+        0.592
+      ],
+      [
+        410,
+        0.33
+      ],
+      [
+        420,
+        0.546
+      ],
+      [
+        430,
+        0.598
+      ],
+      [
+        440,
+        0.66
+      ],
+      [
+        450,
+        0.584
+      ],
+      [
+        460,
+        0.652
+      ],
+      [
+        470,
+        0.686
+      ],
+      [
+        480,
+        0.65
+      ],
+      [
+        490,
+        0.7
+      ],
+      [
+        500,
+        0.716
+      ]
+    ],
+    "EmoZEAL": [
+      [
+        10,
+        0.248
+      ],
+      [
+        20,
+        0.268
+      ],
+      [
+        30,
+        0.348
+      ],
+      [
+        40,
+        0.302
+      ],
+      [
+        50,
+        0.332
+      ],
+      [
+        60,
+        0.31
+      ],
+      [
+        70,
+        0.236
+      ],
+      [
+        80,
+        0.16
+      ],
+      [
+        90,
+        0.35
+      ],
+      [
+        100,
+        0.244
+      ],
+      [
+        110,
+        0.318
+      ],
+      [
+        120,
+        0.312
+      ],
+      [
+        130,
+        0.54
+      ],
+      [
+        140,
+        0.418
+      ],
+      [
+        150,
+        0.43
+      ],
+      [
+        160,
+        0.352
+      ],
+      [
+        170,
+        0.47
+      ],
+      [
+        180,
+        0.538
+      ],
+      [
+        190,
+        0.444
+      ],
+      [
+        200,
+        0.486
+      ],
+      [
+        210,
+        0.596
+      ],
+      [
+        220,
+        0.414
+      ],
+      [
+        230,
+        0.384
+      ],
+      [
+        240,
+        0.67
+      ],
+      [
+        250,
+        0.344
+      ],
+      [
+        260,
+        0.398
+      ],
+      [
+        270,
+        0.55
+      ],
+      [
+        280,
+        0.612
+      ],
+      [
+        290,
+        0.616
+      ],
+      [
+        300,
+        0.488
+      ],
+      [
+        310,
+        0.46
+      ],
+      [
+        320,
+        0.53
+      ],
+      [
+        330,
+        0.582
+      ],
+      [
+        340,
+        0.376
+      ],
+      [
+        350,
+        0.66
+      ],
+      [
+        360,
+        0.682
+      ],
+      [
+        370,
+        0.642
+      ],
+      [
+        380,
+        0.686
+      ],
+      [
+        390,
+        0.612
+      ],
+      [
+        400,
+        0.496
+      ],
+      [
+        410,
+        0.572
+      ],
+      [
+        420,
+        0.58
+      ],
+      [
+        430,
+        0.684
+      ],
+      [
+        440,
+        0.72
+      ],
+      [
+        450,
+        0.624
+      ],
+      [
+        460,
+        0.616
+      ],
+      [
+        470,
+        0.718
+      ],
+      [
+        480,
+        0.71
+      ],
+      [
+        490,
+        0.696
+      ],
+      [
+        500,
+        0.658
+      ]
+    ],
+    "EmoLYNX": [
+      [
+        10,
+        0.22
+      ],
+      [
+        20,
+        0.228
+      ],
+      [
+        30,
+        0.242
+      ],
+      [
+        40,
+        0.222
+      ],
+      [
+        50,
+        0.398
+      ],
+      [
+        60,
+        0.278
+      ],
+      [
+        70,
+        0.298
+      ],
+      [
+        80,
+        0.312
+      ],
+      [
+        90,
+        0.254
+      ],
+      [
+        100,
+        0.306
+      ],
+      [
+        110,
+        0.484
+      ],
+      [
+        120,
+        0.336
+      ],
+      [
+        130,
+        0.31
+      ],
+      [
+        140,
+        0.33
+      ],
+      [
+        150,
+        0.376
+      ],
+      [
+        160,
+        0.354
+      ],
+      [
+        170,
+        0.394
+      ],
+      [
+        180,
+        0.558
+      ],
+      [
+        190,
+        0.566
+      ],
+      [
+        200,
+        0.578
+      ],
+      [
+        210,
+        0.548
+      ],
+      [
+        220,
+        0.53
+      ],
+      [
+        230,
+        0.57
+      ],
+      [
+        240,
+        0.594
+      ],
+      [
+        250,
+        0.596
+      ],
+      [
+        260,
+        0.64
+      ],
+      [
+        270,
+        0.6
+      ],
+      [
+        280,
+        0.544
+      ],
+      [
+        290,
+        0.464
+      ],
+      [
+        300,
+        0.548
+      ],
+      [
+        310,
+        0.622
+      ],
+      [
+        320,
+        0.678
+      ],
+      [
+        330,
+        0.658
+      ],
+      [
+        340,
+        0.658
+      ],
+      [
+        350,
+        0.686
+      ],
+      [
+        360,
+        0.694
+      ],
+      [
+        370,
+        0.686
+      ],
+      [
+        380,
+        0.61
+      ],
+      [
+        390,
+        0.606
+      ],
+      [
+        400,
+        0.666
+      ],
+      [
+        410,
+        0.68
+      ],
+      [
+        420,
+        0.638
+      ],
+      [
+        430,
+        0.626
+      ],
+      [
+        440,
+        0.546
+      ],
+      [
+        450,
+        0.49
+      ],
+      [
+        460,
+        0.508
+      ],
+      [
+        470,
+        0.546
+      ],
+      [
+        480,
+        0.562
+      ],
+      [
+        490,
+        0.62
+      ],
+      [
+        500,
+        0.624
+      ]
+    ],
+    "EmoNECO": [
+      [
+        10,
+        0.164
+      ],
+      [
+        20,
+        0.198
+      ],
+      [
+        30,
+        0.29
+      ],
+      [
+        40,
+        0.372
+      ],
+      [
+        50,
+        0.236
+      ],
+      [
+        60,
+        0.384
+      ],
+      [
+        70,
+        0.23
+      ],
+      [
+        80,
+        0.406
+      ],
+      [
+        90,
+        0.476
+      ],
+      [
+        100,
+        0.226
+      ],
+      [
+        110,
+        0.398
+      ],
+      [
+        120,
+        0.234
+      ],
+      [
+        130,
+        0.37
+      ],
+      [
+        140,
+        0.568
+      ],
+      [
+        150,
+        0.554
+      ],
+      [
+        160,
+        0.542
+      ],
+      [
+        170,
+        0.578
+      ],
+      [
+        180,
+        0.488
+      ],
+      [
+        190,
+        0.574
+      ],
+      [
+        200,
+        0.58
+      ],
+      [
+        210,
+        0.616
+      ],
+      [
+        220,
+        0.59
+      ],
+      [
+        230,
+        0.612
+      ],
+      [
+        240,
+        0.622
+      ],
+      [
+        250,
+        0.624
+      ],
+      [
+        260,
+        0.684
+      ],
+      [
+        270,
+        0.63
+      ],
+      [
+        280,
+        0.694
+      ],
+      [
+        290,
+        0.632
+      ],
+      [
+        300,
+        0.66
+      ],
+      [
+        310,
+        0.708
+      ],
+      [
+        320,
+        0.552
+      ],
+      [
+        330,
+        0.622
+      ],
+      [
+        340,
+        0.676
+      ],
+      [
+        350,
+        0.732
+      ],
+      [
+        360,
+        0.702
+      ],
+      [
+        370,
+        0.646
+      ],
+      [
+        380,
+        0.726
+      ],
+      [
+        390,
+        0.758
+      ],
+      [
+        400,
+        0.73
+      ],
+      [
+        410,
+        0.698
+      ],
+      [
+        420,
+        0.754
+      ],
+      [
+        430,
+        0.732
+      ],
+      [
+        440,
+        0.666
+      ],
+      [
+        450,
+        0.756
+      ],
+      [
+        460,
+        0.728
+      ],
+      [
+        470,
+        0.74
+      ],
+      [
+        480,
+        0.776
+      ],
+      [
+        490,
+        0.73
+      ],
+      [
+        500,
+        0.668
+      ]
+    ],
+    "EmoCLAN": [
+      [
+        10,
+        0.15
+      ],
+      [
+        20,
+        0.228
+      ],
+      [
+        30,
+        0.226
+      ],
+      [
+        40,
+        0.166
+      ],
+      [
+        50,
+        0.312
+      ],
+      [
+        60,
+        0.284
+      ],
+      [
+        70,
+        0.338
+      ],
+      [
+        80,
+        0.466
+      ],
+      [
+        90,
+        0.288
+      ],
+      [
+        100,
+        0.326
+      ],
+      [
+        110,
+        0.298
+      ],
+      [
+        120,
+        0.406
+      ],
+      [
+        130,
+        0.322
+      ],
+      [
+        140,
+        0.392
+      ],
+      [
+        150,
+        0.378
+      ],
+      [
+        160,
+        0.372
+      ],
+      [
+        170,
+        0.428
+      ],
+      [
+        180,
+        0.364
+      ],
+      [
+        190,
+        0.472
+      ],
+      [
+        200,
+        0.47
+      ],
+      [
+        210,
+        0.494
+      ],
+      [
+        220,
+        0.528
+      ],
+      [
+        230,
+        0.528
+      ],
+      [
+        240,
+        0.544
+      ],
+      [
+        250,
+        0.57
+      ],
+      [
+        260,
+        0.57
+      ],
+      [
+        270,
+        0.588
+      ],
+      [
+        280,
+        0.564
+      ],
+      [
+        290,
+        0.608
+      ],
+      [
+        300,
+        0.548
+      ],
+      [
+        310,
+        0.578
+      ],
+      [
+        320,
+        0.594
+      ],
+      [
+        330,
+        0.7
+      ],
+      [
+        340,
+        0.688
+      ],
+      [
+        350,
+        0.672
+      ],
+      [
+        360,
+        0.692
+      ],
+      [
+        370,
+        0.46
+      ],
+      [
+        380,
+        0.586
+      ],
+      [
+        390,
+        0.588
+      ],
+      [
+        400,
+        0.636
+      ],
+      [
+        410,
+        0.632
+      ],
+      [
+        420,
+        0.668
+      ],
+      [
+        430,
+        0.684
+      ],
+      [
+        440,
+        0.662
+      ],
+      [
+        450,
+        0.602
+      ],
+      [
+        460,
+        0.572
+      ],
+      [
+        470,
+        0.57
+      ],
+      [
+        480,
+        0.616
+      ],
+      [
+        490,
+        0.668
+      ],
+      [
+        500,
+        0.614
+      ]
+    ]
+  },
+  "SQuAD_Tiny": {},
+  "GPT2": {
+    "EmoNAVI": [
+      [
+        10,
+        390.03
+      ],
+      [
+        20,
+        389.7
+      ],
+      [
+        30,
+        144.35
+      ],
+      [
+        40,
+        126.51
+      ],
+      [
+        50,
+        128.2
+      ],
+      [
+        60,
+        109.94
+      ],
+      [
+        70,
+        91.23
+      ],
+      [
+        80,
+        87.17
+      ],
+      [
+        90,
+        98.43
+      ],
+      [
+        100,
+        86.26
+      ],
+      [
+        110,
+        73.17
+      ],
+      [
+        120,
+        68.45
+      ],
+      [
+        130,
+        72.42
+      ],
+      [
+        140,
+        59.25
+      ],
+      [
+        150,
+        76.23
+      ],
+      [
+        160,
+        84.56
+      ],
+      [
+        170,
+        57.77
+      ],
+      [
+        180,
+        60.9
+      ],
+      [
+        190,
+        59.26
+      ],
+      [
+        200,
+        54.84
+      ],
+      [
+        210,
+        52.89
+      ],
+      [
+        220,
+        55.69
+      ],
+      [
+        230,
+        52.2
+      ],
+      [
+        240,
+        45.29
+      ],
+      [
+        250,
+        50.06
+      ],
+      [
+        260,
+        43.19
+      ],
+      [
+        270,
+        43.22
+      ],
+      [
+        280,
+        46.27
+      ],
+      [
+        290,
+        42.59
+      ],
+      [
+        300,
+        41.59
+      ],
+      [
+        310,
+        48.33
+      ],
+      [
+        320,
+        41.03
+      ],
+      [
+        330,
+        31.07
+      ],
+      [
+        340,
+        31.38
+      ],
+      [
+        350,
+        29.13
+      ],
+      [
+        360,
+        25.73
+      ],
+      [
+        370,
+        22.76
+      ],
+      [
+        380,
+        25.37
+      ],
+      [
+        390,
+        28.14
+      ],
+      [
+        400,
+        31.61
+      ],
+      [
+        410,
+        25.59
+      ],
+      [
+        420,
+        19.69
+      ],
+      [
+        430,
+        14.81
+      ],
+      [
+        440,
+        14.93
+      ],
+      [
+        450,
+        16.52
+      ],
+      [
+        460,
+        15.26
+      ],
+      [
+        470,
+        14.09
+      ],
+      [
+        480,
+        18.8
+      ],
+      [
+        490,
+        11.57
+      ],
+      [
+        500,
+        9.65
+      ]
+    ],
+    "EmoFACT": [
+      [
+        10,
+        415036.56
+      ],
+      [
+        20,
+        1082.92
+      ],
+      [
+        30,
+        173.88
+      ],
+      [
+        40,
+        180.84
+      ],
+      [
+        50,
+        134.73
+      ],
+      [
+        60,
+        119.16
+      ],
+      [
+        70,
+        112.98
+      ],
+      [
+        80,
+        114.38
+      ],
+      [
+        90,
+        95.07
+      ],
+      [
+        100,
+        95.62
+      ],
+      [
+        110,
+        159.77
+      ],
+      [
+        120,
+        122.98
+      ],
+      [
+        130,
+        133.86
+      ],
+      [
+        140,
+        109.73
+      ],
+      [
+        150,
+        287.33
+      ],
+      [
+        160,
+        117.7
+      ],
+      [
+        170,
+        112.34
+      ],
+      [
+        180,
+        97.98
+      ],
+      [
+        190,
+        103.99
+      ],
+      [
+        200,
+        133.38
+      ],
+      [
+        210,
+        94.22
+      ],
+      [
+        220,
+        90.21
+      ],
+      [
+        230,
+        113.93
+      ],
+      [
+        240,
+        77.51
+      ],
+      [
+        250,
+        159.87
+      ],
+      [
+        260,
+        85.87
+      ],
+      [
+        270,
+        91.0
+      ],
+      [
+        280,
+        79.88
+      ],
+      [
+        290,
+        80.98
+      ],
+      [
+        300,
+        67.46
+      ],
+      [
+        310,
+        69.69
+      ],
+      [
+        320,
+        65.7
+      ],
+      [
+        330,
+        54.08
+      ],
+      [
+        340,
+        48.44
+      ],
+      [
+        350,
+        92.18
+      ],
+      [
+        360,
+        46.75
+      ],
+      [
+        370,
+        54.9
+      ],
+      [
+        380,
+        41.72
+      ],
+      [
+        390,
+        40.68
+      ],
+      [
+        400,
+        36.56
+      ],
+      [
+        410,
+        38.22
+      ],
+      [
+        420,
+        40.82
+      ],
+      [
+        430,
+        27.42
+      ],
+      [
+        440,
+        3203.09
+      ],
+      [
+        450,
+        29.91
+      ],
+      [
+        460,
+        30.59
+      ],
+      [
+        470,
+        32.2
+      ],
+      [
+        480,
+        40.88
+      ],
+      [
+        490,
+        36.93
+      ],
+      [
+        500,
+        35.41
+      ]
+    ],
+    "EmoZEAL": [
+      [
+        10,
+        32368984.0
+      ],
+      [
+        20,
+        864642.69
+      ],
+      [
+        30,
+        702.81
+      ],
+      [
+        40,
+        6212.83
+      ],
+      [
+        50,
+        418.3
+      ],
+      [
+        60,
+        125.87
+      ],
+      [
+        70,
+        113.59
+      ],
+      [
+        80,
+        115.08
+      ],
+      [
+        90,
+        128.86
+      ],
+      [
+        100,
+        126.81
+      ],
+      [
+        110,
+        219.04
+      ],
+      [
+        120,
+        129.47
+      ],
+      [
+        130,
+        101.47
+      ],
+      [
+        140,
+        104.58
+      ],
+      [
+        150,
+        137.48
+      ],
+      [
+        160,
+        111.11
+      ],
+      [
+        170,
+        125.97
+      ],
+      [
+        180,
+        91.28
+      ],
+      [
+        190,
+        104.27
+      ],
+      [
+        200,
+        86.7
+      ],
+      [
+        210,
+        130.79
+      ],
+      [
+        220,
+        96.5
+      ],
+      [
+        230,
+        88.04
+      ],
+      [
+        240,
+        94.72
+      ],
+      [
+        250,
+        86.83
+      ],
+      [
+        260,
+        105.92
+      ],
+      [
+        270,
+        100.96
+      ],
+      [
+        280,
+        92.68
+      ],
+      [
+        290,
+        93.79
+      ],
+      [
+        300,
+        90.26
+      ],
+      [
+        310,
+        81.71
+      ],
+      [
+        320,
+        62.94
+      ],
+      [
+        330,
+        84.68
+      ],
+      [
+        340,
+        72.64
+      ],
+      [
+        350,
+        88.21
+      ],
+      [
+        360,
+        72.25
+      ],
+      [
+        370,
+        60.64
+      ],
+      [
+        380,
+        65.93
+      ],
+      [
+        390,
+        53.45
+      ],
+      [
+        400,
+        59.47
+      ],
+      [
+        410,
+        59.57
+      ],
+      [
+        420,
+        54.25
+      ],
+      [
+        430,
+        50.96
+      ],
+      [
+        440,
+        48.73
+      ],
+      [
+        450,
+        49.77
+      ],
+      [
+        460,
+        45.83
+      ],
+      [
+        470,
+        59.98
+      ],
+      [
+        480,
+        55.26
+      ],
+      [
+        490,
+        37.23
+      ],
+      [
+        500,
+        33.99
+      ]
+    ],
+    "EmoLYNX": [
+      [
+        10,
+        176.55
+      ],
+      [
+        20,
+        78.81
+      ],
+      [
+        30,
+        51.84
+      ],
+      [
+        40,
+        61.16
+      ],
+      [
+        50,
+        57.48
+      ],
+      [
+        60,
+        61.37
+      ],
+      [
+        70,
+        55.12
+      ],
+      [
+        80,
+        58.97
+      ],
+      [
+        90,
+        54.63
+      ],
+      [
+        100,
+        61.92
+      ],
+      [
+        110,
+        66.47
+      ],
+      [
+        120,
+        51.53
+      ],
+      [
+        130,
+        45.01
+      ],
+      [
+        140,
+        45.66
+      ],
+      [
+        150,
+        34.53
+      ],
+      [
+        160,
+        42.89
+      ],
+      [
+        170,
+        42.98
+      ],
+      [
+        180,
+        42.43
+      ],
+      [
+        190,
+        34.23
+      ],
+      [
+        200,
+        30.79
+      ],
+      [
+        210,
+        36.44
+      ],
+      [
+        220,
+        33.72
+      ],
+      [
+        230,
+        31.61
+      ],
+      [
+        240,
+        33.06
+      ],
+      [
+        250,
+        37.53
+      ],
+      [
+        260,
+        43.56
+      ],
+      [
+        270,
+        31.7
+      ],
+      [
+        280,
+        27.2
+      ],
+      [
+        290,
+        26.43
+      ],
+      [
+        300,
+        31.83
+      ],
+      [
+        310,
+        45.07
+      ],
+      [
+        320,
+        30.65
+      ],
+      [
+        330,
+        23.93
+      ],
+      [
+        340,
+        26.46
+      ],
+      [
+        350,
+        23.51
+      ],
+      [
+        360,
+        28.75
+      ],
+      [
+        370,
+        40.6
+      ],
+      [
+        380,
+        36.43
+      ],
+      [
+        390,
+        31.47
+      ],
+      [
+        400,
+        57.82
+      ],
+      [
+        410,
+        30.0
+      ],
+      [
+        420,
+        30.81
+      ],
+      [
+        430,
+        32.15
+      ],
+      [
+        440,
+        24.29
+      ],
+      [
+        450,
+        27.99
+      ],
+      [
+        460,
+        25.83
+      ],
+      [
+        470,
+        24.17
+      ],
+      [
+        480,
+        24.79
+      ],
+      [
+        490,
+        26.67
+      ],
+      [
+        500,
+        31.57
+      ]
+    ],
+    "EmoNECO": [
+      [
+        10,
+        43.63
+      ],
+      [
+        20,
+        41.81
+      ],
+      [
+        30,
+        29.89
+      ],
+      [
+        40,
+        21.48
+      ],
+      [
+        50,
+        34.85
+      ],
+      [
+        60,
+        35.27
+      ],
+      [
+        70,
+        20.74
+      ],
+      [
+        80,
+        22.34
+      ],
+      [
+        90,
+        22.61
+      ],
+      [
+        100,
+        17.34
+      ],
+      [
+        110,
+        20.47
+      ],
+      [
+        120,
+        30.86
+      ],
+      [
+        130,
+        19.76
+      ],
+      [
+        140,
+        18.27
+      ],
+      [
+        150,
+        17.08
+      ],
+      [
+        160,
+        17.37
+      ],
+      [
+        170,
+        19.73
+      ],
+      [
+        180,
+        18.19
+      ],
+      [
+        190,
+        17.4
+      ],
+      [
+        200,
+        12.44
+      ],
+      [
+        210,
+        9.06
+      ],
+      [
+        220,
+        7.12
+      ],
+      [
+        230,
+        6.33
+      ],
+      [
+        240,
+        7.67
+      ],
+      [
+        250,
+        5.18
+      ],
+      [
+        260,
+        5.39
+      ],
+      [
+        270,
+        5.6
+      ],
+      [
+        280,
+        5.41
+      ],
+      [
+        290,
+        5.32
+      ],
+      [
+        300,
+        5.23
+      ],
+      [
+        310,
+        4.38
+      ],
+      [
+        320,
+        4.73
+      ],
+      [
+        330,
+        4.98
+      ],
+      [
+        340,
+        5.48
+      ],
+      [
+        350,
+        5.61
+      ],
+      [
+        360,
+        4.57
+      ],
+      [
+        370,
+        4.24
+      ],
+      [
+        380,
+        4.71
+      ],
+      [
+        390,
+        3.63
+      ],
+      [
+        400,
+        3.62
+      ],
+      [
+        410,
+        2.83
+      ],
+      [
+        420,
+        2.96
+      ],
+      [
+        430,
+        2.78
+      ],
+      [
+        440,
+        3.06
+      ],
+      [
+        450,
+        3.2
+      ],
+      [
+        460,
+        3.03
+      ],
+      [
+        470,
+        3.05
+      ],
+      [
+        480,
+        2.97
+      ],
+      [
+        490,
+        3.08
+      ],
+      [
+        500,
+        3.6
+      ]
+    ],
+    "EmoCLAN": [
+      [
+        10,
+        2646.54
+      ],
+      [
+        20,
+        237.9
+      ],
+      [
+        30,
+        317.26
+      ],
+      [
+        40,
+        145.22
+      ],
+      [
+        50,
+        148.97
+      ],
+      [
+        60,
+        225.55
+      ],
+      [
+        70,
+        104.09
+      ],
+      [
+        80,
+        92.09
+      ],
+      [
+        90,
+        107.5
+      ],
+      [
+        100,
+        130.0
+      ],
+      [
+        110,
+        97.33
+      ],
+      [
+        120,
+        87.69
+      ],
+      [
+        130,
+        86.27
+      ],
+      [
+        140,
+        77.78
+      ],
+      [
+        150,
+        66.3
+      ],
+      [
+        160,
+        84.44
+      ],
+      [
+        170,
+        70.21
+      ],
+      [
+        180,
+        71.12
+      ],
+      [
+        190,
+        60.57
+      ],
+      [
+        200,
+        58.8
+      ],
+      [
+        210,
+        56.19
+      ],
+      [
+        220,
+        64.68
+      ],
+      [
+        230,
+        58.71
+      ],
+      [
+        240,
+        72.35
+      ],
+      [
+        250,
+        62.81
+      ],
+      [
+        260,
+        62.0
+      ],
+      [
+        270,
+        62.57
+      ],
+      [
+        280,
+        55.06
+      ],
+      [
+        290,
+        52.29
+      ],
+      [
+        300,
+        55.84
+      ],
+      [
+        310,
+        55.93
+      ],
+      [
+        320,
+        61.57
+      ],
+      [
+        330,
+        66.8
+      ],
+      [
+        340,
+        64.74
+      ],
+      [
+        350,
+        67.67
+      ],
+      [
+        360,
+        64.73
+      ],
+      [
+        370,
+        60.54
+      ],
+      [
+        380,
+        57.82
+      ],
+      [
+        390,
+        52.32
+      ],
+      [
+        400,
+        52.11
+      ],
+      [
+        410,
+        51.81
+      ],
+      [
+        420,
+        50.83
+      ],
+      [
+        430,
+        49.49
+      ],
+      [
+        440,
+        41.85
+      ],
+      [
+        450,
+        39.5
+      ],
+      [
+        460,
+        37.8
+      ],
+      [
+        470,
+        42.96
+      ],
+      [
+        480,
+        41.26
+      ],
+      [
+        490,
+        38.94
+      ],
+      [
+        500,
+        45.65
+      ]
+    ]
+  }
+}

1Gv3_AMP-compatible/logs/trec_weights_log.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1039ad77b7d2814784414fd1e9b769a61286f264a93e82ba7dd5e9bffd847b1c
+size 11052986

1Gv3_AMP-compatible/profile.txt

@@ -0,0 +1,45 @@
+AMP-compatible ／ AMP対応版
+
+emonavi 及び emoファミリーについて紹介します
+emonavi は、RefAdamWmini-ScheduleFree を作成し機能向上を試行錯誤するうちにできた感情機構を持つオプティマイザです
+emonavi is an optimizer equipped with an emotional mechanism, 
+developed through trial and error while creating and enhancing the functionality of RefAdamWmini-ScheduleFree.
+https://github.com/muooon/ref-adamw-mini-ScheduleFree
+
+RefAdamWmini は、ema、scaler、shadow、を持ちますが限定的な活用でした
+これを改善していくなかでたどり着いたのが感情機構という新しい仕組みです
+以下、emonavi から順に紹介します
+RefAdamWmini incorporated EMA, scaler, and shadow, but their application was limited. 
+Through our efforts to enhance this, we developed a novel mechanism: the emotional mechanism. 
+We'll introduce them in order, starting with emonavi.
+
+三姉妹 ／ The Three Sisters
+emonavi：長女／Adam参考 The eldest daughter, referencing Adam.
+emofact：次女／Adafactor参考 The second daughter, referencing Adafactor.
+emolynx：三女／Lion･Tiger参考 The youngest daughter, referencing Lion and Tiger.
+
+emoclan：統合／三姉妹に役割分担をさせた統合型 An integrated model where roles are assigned to the three sisters.
+
+従妹の双子 ／ Cousins of the Three Sisters
+emozeal：双子の姉／emofact参考 The elder twin sister, referencing emofact.
+emoneco：双子の妹／emolynx参考 The younger twin sister, referencing emolynx.
+
+emoclanという統合から三姉妹の従妹へ発展します
+emozeal と emoneco はそれぞれ場面に応じて更新方法を選択します
+The emoclan integration serves as the foundation for the development of the three sisters' cousins. 
+emozeal and emoneco each select their update method based on the specific situation.
+
+それぞれ同一の"感情機構"を持ちます
+emozeal は Adafactor系に情熱を持たせました
+emoneco は Lion系にしなやかさを持たせました
+Each possesses the same "emotional mechanism." 
+emozeal imbues Adafactor-based models with passion. 
+emoneco instills flexibility in Lion-based models.
+
+shadow 切替機能 ／ shadow switching function 
+emoclan、emozeal、emoneco、は、shadow 機能の 有効/無効 切替を可能にしました
+allows enabling/disabling of the shadow function
+
+memo : "optimizer = EmoNeco(model.parameters(), lr=1e-3, use_shadow=False)"
+optimizer 指定の際に False にすることで shadow をオフにできる
+Shadow can be turned off by setting it to False when specifying the optimizer.

2Gv2_AMP-compatible/emoairy.py

@@ -0,0 +1,162 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoAiry v2.0 (250815) shadow-system v2.0 shadow-effect v1.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoAiry(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True / False で shadow を切替できる(現在 False)
+"""
+
+class EmoAiry(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01, use_shadow: bool = False): 
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+
+        super().__init__(params, defaults)
+
+        self.alpha_prev = getattr(self, 'alpha_prev', 1.0)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # 感情EMA更新・スカラー生成 (既存ロジックを維持)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # shadow_param：必要時のみ更新 (既存ロジックを維持)
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+
+                # --- 勾配補正ロジック ---
+                # 行列の形状が2次元以上の場合、分散情報ベースのAB近似を使用
+                if grad.dim() >= 2:
+                    # フィルターしきい値（探索強度）←調整可能
+                    threshold = 1e-4 * (1 + abs(scalar))
+
+                    # 行と列の2乗平均を計算 (分散の軽量な近似)
+                    r_sq = torch.mean(grad * grad, dim=tuple(range(1, grad.dim())), keepdim=True).add_(group['eps'])
+                    c_sq = torch.mean(grad * grad, dim=0, keepdim=True).add_(group['eps'])
+
+                    # 行方向/列方向 探索フィルター
+                    r_mask = (r_sq.pow(1/3) > threshold).float()  # 行方向マスク
+                    c_mask = (c_sq.pow(1/3) > threshold).float()  # 列方向マスク
+
+                    # 行と列のマスクを組み合わせて、パラメータごとの最終的なマスクを作成
+                    # torch.matmulは2次元テンソルを前提とするため、元のコードのロジックを修正
+                    update_mask = r_mask * c_mask
+
+                    # Adafactor的な更新項を計算
+                    beta1, beta2 = group['betas']
+                    eps = group['eps']
+
+                    # EMAで平滑化された行と列の分散を計算（元のコードのdenom部分）
+                    state.setdefault('exp_avg_r', torch.zeros_like(r_sq)).mul_(beta1).add_(torch.sqrt(r_sq), alpha=1 - beta1)
+                    state.setdefault('exp_avg_c', torch.zeros_like(c_sq)).mul_(beta1).add_(torch.sqrt(c_sq), alpha=1 - beta1)
+
+                    # 再構築した近似勾配の平方根の積で正規化
+                    # これにより2次モーメントのような役割を果たす
+                    denom = torch.sqrt(state['exp_avg_r'] * state['exp_avg_c']) + eps
+
+                    # 勾配更新項の選別 通常のgrad/denomの更新式に対し、上で作成したマスクを適用
+                    update_term = (grad / denom) * update_mask
+
+                # 1次元(ベクトル)の勾配補正(decoupled weight decay 構造に近い)
+                else:
+                    # 3乗平方根によるフィルターを適用
+                    # フィルターの強度を決定するしきい値を設定
+                    # ここでは例として1e-4を使用しますが、これは調整可能です
+                    threshold = 1e-4 * (1 + abs(scalar))
+
+                    exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                    exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                    beta1, beta2 = group['betas']
+
+                    # Adamの1次モーメントと2次モーメントを計算
+                    exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+
+                    # 通常のAdamの更新項を計算
+                    denom = exp_avg_sq.sqrt().add_(group['eps'])
+                    update_term = exp_avg / denom
+
+                    # 勾配の3乗平方根がしきい値を超える部分をマスクとして抽出
+                    filter_mask = (grad.pow(2).pow(1/3) > threshold).float()
+
+                    # 更新項にマスクを適用して選別
+                    update_term = update_term * filter_mask
+
+                # 最終的なパラメータ更新 (decoupled weight decayも適用)
+                p.add_(p, alpha=-group['weight_decay'] * group['lr'])
+                p.add_(update_term, alpha=-group['lr'] * (1 - abs(scalar)))
+
+                # --- Early Stop ロジック (既存ロジックを維持) ---
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Airy is inspired by Adafactor, and EmoFact,  
+ and its VRAM-friendly design is something everyone loves.
+"""

2Gv2_AMP-compatible/emocats.py

@@ -0,0 +1,160 @@
+import torch
+from torch.optim import Optimizer
+import math
+from typing import Tuple, Callable, Union
+
+"""
+EmoCats v2.0 (250815) shadow-system v2.0 shadow-effect v1.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoCats(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True / False で shadow を切替できる(現在 False)
+"""
+
+# Helper function (Lynx)
+def exists(val):
+    return val is not None
+
+class EmoCats(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params: Union[list, torch.nn.Module], lr=1e-3, betas=(0.9, 0.99), 
+    # lynx用ベータ･互換性の追加(lynx用beta1･beta2)
+                 eps=1e-8, weight_decay=0.01, decoupled_weight_decay: bool = False, use_shadow: bool = False): 
+
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        
+        # lynxに応じてウェイト減衰のため保存
+        self._init_lr = lr
+        self.should_stop = False # 停止フラグの初期化
+        self.decoupled_wd = decoupled_weight_decay
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None): # クロージャの型ヒントを追加
+        loss = None
+        if exists(closure): # 一貫性のためにexistsヘルパーを使う
+            with torch.enable_grad():
+                loss = closure()
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            # 共通パラメータ抽出
+            lr, wd, beta1, beta2 = group['lr'], group['weight_decay'], *group['betas']
+            
+            # ウェイト減衰の処理を分離 (from Cats)
+            _wd_actual = wd
+            if self.decoupled_wd:
+                _wd_actual /= self._init_lr # 非連結時ウェイト減衰調整
+
+            for p in filter(lambda p: exists(p.grad), group['params']): # PGチェックにフィルタ
+
+                grad = p.grad # PG直接使用(計算に".data"不要)
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # shadow_param：必要時のみ更新(スパイク部分に現在値を5%ずつ追従させる動的履歴)
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        state['shadow'].lerp_(p, 0.05) 
+                        # 更新前 p で shadow 更新(現在値を5%ずつ追従)
+                        # p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio) 
+                        # EmoNavi: p = p * (1-ratio) + shadow * ratio
+
+                # --- Start Cats Gradient Update Logic ---
+                
+                # Cats初期化(exp_avg_sq)
+                if 'exp_avg' not in state:
+                    state['exp_avg'] = torch.zeros_like(p)
+                exp_avg = state['exp_avg']
+                
+                # フィルターのしきい値をscalarで動的に決定
+                threshold = 1e-4 * (1 + abs(scalar))
+                
+                # 勾配の多乗根を計算して、フィルターの基準とする
+                # Lionの更新は符号が重要なので、勾配自体ではなく、その絶対値を基準とします
+                filter_strength = torch.abs(grad).pow(1/3)
+                
+                # フィルタリング強度がしきい値を超えた部分がTrueになる
+                mask = torch.ge(filter_strength, threshold).float()
+
+                # Stepweight decay (from lynx): p = p * (1 - lr * wd)
+                # decoupled_wd 考慮 _wd_actual 使用(EmoNaviのwdは最後に適用)
+                p.mul_(1. - lr * _wd_actual)
+
+                # 勾配ブレンド
+                # m_t = beta1 * exp_avg_prev + (1 - beta1) * grad
+                blended_grad = grad.mul(1. - beta1).add_(exp_avg, alpha=beta1)
+                
+                # 更新を計算 p: p = p - lr * sign(blended_grad)
+                Cats_update = blended_grad.sign_()
+                
+                # 次に、この更新項にフィルターマスクを掛け合わせる
+                filtered_Cats_update = Cats_update * mask
+                
+                # p: p = p - lr * sign(blended_grad)
+                p.add_(filtered_Cats_update, alpha = -lr * (1 - abs(scalar)))
+
+                # exp_avg = beta2 * exp_avg + (1 - beta2) * grad
+                exp_avg.mul_(beta2).add_(grad, alpha = 1. - beta2)
+
+                # --- End Cats Gradient Update Logic ---
+
+                # Early Stop用 scalar記録(バッファ共通で管理/最大32件保持/動静評価)
+                # この部分は p.state ではなく self.state にアクセスする
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図) - This part is outside the inner loop
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True # 外部からこれを見て判断可
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ Cats was developed with inspiration from Lion, Tiger, and emoneco, 
+ which we deeply respect for their lightweight and intelligent design.  
+ Cats also integrates EmoNAVI to enhance its capabilities.
+"""

2Gv2_AMP-compatible/emosens.py

@@ -0,0 +1,132 @@
+import torch
+from torch.optim import Optimizer
+import math
+
+"""
+EmoSens v2.0 (250815) shadow-system v2.0 shadow-effect v1.0
+AMP対応完了(202507) p.data -> p 修正済み
+memo : "optimizer = EmoSens(model.parameters(), lr=1e-3, use_shadow=True)"
+optimizer 指定の際に True / False で shadow を切替できる(現在 False)
+shadow-system、effect、併用時は、system によるVRAM専有を低下させる？(全体は増加/navi比)
+"""
+
+class EmoSens(Optimizer):
+    # クラス定義＆初期化 🔸Shadow True(有効)/False(無効) 切替え
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999),
+                 eps=1e-8, weight_decay=0.01, use_shadow: bool = False):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        self._init_lr = lr 
+        self.should_stop = False # 停止フラグの初期化
+        self.use_shadow = use_shadow # 🔸shadowの使用フラグを保存
+
+    # 感情EMA更新(緊張と安静)
+    def _update_ema(self, state, loss_val):
+        ema = state.setdefault('ema', {})
+        ema['short'] = 0.3 * loss_val + 0.7 * ema.get('short', loss_val)
+        ema['long'] = 0.01 * loss_val + 0.99 * ema.get('long', loss_val)
+        return ema
+
+    # 感情スカラー値生成(EMA差分、滑らかな非線形スカラー、tanh 5 * diff で鋭敏さ強調)
+    def _compute_scalar(self, ema):
+        diff = ema['short'] - ema['long']
+        return math.tanh(5 * diff)
+
+    # Shadow混合比率(> abs 0.6：60〜100%、 > abs 0.1：10〜60%、 平時：0%) emosens反映
+    # 旧：Shadow混合比率(> 0.6：80〜90%、 < -0.6：10%、 abs> 0.3：30%、 平時：0%)
+    # 説明：scalar>+0.6 は "return 0.7(開始値) + 0.2(変化幅) * scalar" = 0.82～0.9 ← 誤
+    # 修正1：scalar>±0.6 を "return 開始値 + (abs(scalar) - 0.6(範囲)) / 範囲量 * 変化幅"
+    # 修正2：scalar>±0.1 を "return 開始値 + (abs(scalar) - 0.1(範囲)) / 範囲量 * 変化幅"
+    # タスク等に応じた調整のため３段階で適用しておく(上記を参考に調整してください／現状はshadow-effect反映)
+    def _decide_ratio(self, scalar):
+        if not self.use_shadow:
+            return 0.0 # 🔸use_shadow が False の場合は常に比率を 0 にする
+        if abs(scalar) > 0.6:
+            return 0.6 + (abs(scalar) - 0.6) / 0.4 * 0.4 # 元 return 0.7 + 0.2 * scalar
+        elif abs(scalar) > 0.1:
+            return 0.1 + (abs(scalar) - 0.1) / 0.5 * 0.5 # 元 return 0.3
+        return 0.0
+
+    # 損失取得(損失値 loss_val を数値化、感情判定に使用、存在しないパラメータ(更新不要)はスキップ)
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = closure() if closure is not None else None
+        loss_val = loss.item() if loss is not None else 0.0
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                state = self.state[p]
+
+                # EMA更新・スカラー生成(EMA差分からスカラーを生成しスパイク比率を決定)
+                ema = self._update_ema(state, loss_val)
+                scalar = self._compute_scalar(ema)
+                ratio = self._decide_ratio(scalar) # 🔸use_shadow に応じて ratio が 0 になる
+
+                # 🔸self.use_shadow が True で、かつ ratio > 0 の場合のみ shadow を更新
+                if self.use_shadow and ratio > 0: 
+                    if 'shadow' not in state:
+                        state['shadow'] = p.clone()
+                    else:
+                        p.mul_(1 - ratio).add_(state['shadow'], alpha=ratio)
+                        state['shadow'].lerp_(p, 0.05)
+                
+                # スカラー生成：短期と長期EMAの差分から信号を得る(高ぶりの強さ)
+                # 混合比率：スカラーが閾値を超える場合にのみ計算される(信頼できる感情信号かどうかの選別)
+                # → スカラー値が小さい場合は ratio = 0 となり、shadow混合は行われない
+                # → 信頼できる強い差分のときのみ感情機構が発動する(暗黙の信頼度判定)                
+                
+                # 1次・2次モーメントを使った勾配補正(decoupled weight decay 構造に近い)
+                exp_avg = state.setdefault('exp_avg', torch.zeros_like(p))
+                exp_avg_sq = state.setdefault('exp_avg_sq', torch.zeros_like(p))
+                beta1, beta2 = group['betas']
+
+                exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
+                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                denom = exp_avg_sq.sqrt().add_(group['eps'])
+
+                # 勾配の多乗根��計算して、フィルターの基準とする
+                threshold = 1e-4 * (1 + abs(scalar))
+                filter_strength = torch.abs(grad).pow(1/3)
+
+                # フィルタリング強度がしきい値を超えた部分がTrueになる
+                mask = torch.ge(filter_strength, threshold).float()
+
+                # 更新量を計算
+                update_term = exp_avg.div(denom)
+
+                # 更新量にマスクを適用して、生き残った部分のみを更新
+                filtered_update = update_term * mask
+
+                # 最終的なパラメータ更新（decoupled weight decayも適用）
+                if group['weight_decay']:
+                    p.add_(p, alpha=-group['weight_decay'] * group['lr'])
+                p.add_(filtered_update, alpha=-group['lr'] * (1 - abs(scalar)))
+
+        # 感情機構の発火が収まり"十分に安定"していることを外部伝達できる(自動停止ロジックではない)
+                # Early Stop用 scalar 記録(バッファ共通で管理/最大32件保持/動静評価)
+                hist = self.state.setdefault('scalar_hist', [])
+                hist.append(scalar)
+                if len(hist) >= 33:
+                    hist.pop(0)
+
+        # Early Stop判断(静けさの合図)
+        if len(self.state['scalar_hist']) >= 32:
+            buf = self.state['scalar_hist']
+            avg_abs = sum(abs(s) for s in buf) / len(buf)
+            std = sum((s - sum(buf)/len(buf))**2 for s in buf) / len(buf)
+            if avg_abs < 0.05 and std < 0.005:
+                self.should_stop = True  # 💡 外部からこれを見て判断可
+
+        # 32ステップ分のスカラー値の静かな条件を満たした時"フラグ" should_stop = True になるだけ
+
+        return loss
+
+"""
+ https://github.com/muooon/EmoNavi
+ An emotion-driven optimizer that feels loss and navigates accordingly.
+ Don't think. Feel. Don't stop. Keep running. Believe in what's beyond.
+"""