Add holographic_transformer_model.py

holographic_transformer_model.py

@@ -0,0 +1,114 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from tqdm import tqdm
+
+class HolographicMasterCodeTransformer(nn.Module):
+    def __init__(self, input_dim=8, d_model=128, nhead=8, num_layers=6, output_dim=1, n_harmonics=4):
+        super().__init__()
+        self.d_model = d_model
+        self.n_harmonics = n_harmonics
+        self.alpha_0 = 1.0 / 137.035
+        
+        self.input_proj = nn.Linear(input_dim, d_model)
+        
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, 
+            nhead=nhead, 
+            dim_feedforward=d_model * 4,
+            dropout=0.1,
+            activation='gelu',
+            batch_first=True,
+            norm_first=True
+        )
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        
+        self.harmonic_weights = nn.Parameter(torch.randn(n_harmonics, d_model))
+        
+        self.output_head = nn.Sequential(
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model // 2),
+            nn.GELU(),
+            nn.Dropout(0.1),
+            nn.Linear(d_model // 2, output_dim)
+        )
+        
+    def forward(self, x, alpha=None):
+        if alpha is None:
+            alpha = self.alpha_0
+            
+        h = self.input_proj(x)
+        h = h.unsqueeze(1)
+        h = self.transformer(h)
+        h = h.squeeze(1)
+        
+        # Master Code Ψ
+        psi = torch.zeros_like(h)
+        for n in range(self.n_harmonics):
+            phase = 2 * torch.pi * (n + 1) * (alpha - self.alpha_0) * 800.0   # Yumuşatıldı
+            psi += self.harmonic_weights[n] * torch.cos(h * (n + 1) + phase)
+        
+        # Güvenlik Kilidi (daha yumuşak)
+        alpha_dev = torch.abs(alpha - self.alpha_0)
+        security_factor = torch.exp(-300.0 * alpha_dev)   # Daha yumuşak
+        
+        h = h + 0.35 * psi * security_factor
+        return self.output_head(h)
+    
+    def holographic_reg(self):
+        reg = sum(torch.norm(w, p=1) for w in self.harmonic_weights)
+        return 0.0015 * reg / self.n_harmonics   # Daha dengeli
+
+
+# Eğitim fonksiyonu (300 epoch)
+def train_holographic(alpha_values, epochs=300):
+    results = {}
+    for name, alpha_val in alpha_values.items():
+        print(f"\n→ Eğitim: {name} (α = {alpha_val:.8f})")
+        model = HolographicMasterCodeTransformer()
+        optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-5)
+        scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)
+        criterion = nn.MSELoss()
+        
+        X = torch.randn(300, 8)
+        y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)
+        
+        best_loss = float('inf')
+        for epoch in tqdm(range(epochs)):
+            optimizer.zero_grad()
+            pred = model(X, alpha=alpha_val)
+            loss = criterion(pred, y)
+            reg = model.holographic_reg()
+            total_loss = loss + reg
+            
+            total_loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            optimizer.step()
+            scheduler.step()
+            
+            if loss.item() < best_loss:
+                best_loss = loss.item()
+                
+            if epoch % 50 == 0 or epoch == epochs-1:
+                print(f"Epoch {epoch:3d} | Loss: {loss.item():.6f} | Reg: {reg.item():.6f}")
+        
+        results[name] = best_loss
+    return results
+
+# ====================== Çalıştır ======================
+if __name__ == "__main__":
+    alpha_values = {
+        "Nominal": 1/137.035,
+        "Physical": 1/137.035999,
+        "Sapma1": 1/137.000,
+        "Sapma2": 1/137.070
+    }
+    
+    results = train_holographic(alpha_values, epochs=300)
+    
+    # En iyi sonucu yazdır
+    best_alpha = min(results, key=lambda k: results[k]['final_loss'])
+    print("\n" + "="*70)
+    print(f"EN İYİ SONUÇ → {best_alpha} α ile Final Loss = {results[best_alpha]:.6f}")
+    print("="*70)