app.py

import gradio as gr
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR
import matplotlib.pyplot as plt
import numpy as np

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, enable_nested_tensor=False)

        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)

        psi = torch.zeros_like(h)
        for n in range(self.n_harmonics):
            phase = 2 * torch.pi * (n + 1) * (alpha - self.alpha_0) * 800.0
            psi += self.harmonic_weights[n] * torch.cos(h * (n + 1) + phase)

        alpha_dev = torch.abs(alpha - self.alpha_0)
        security_factor = torch.exp(-300.0 * alpha_dev)

        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


def train_model(alpha_value, epochs):
    """Modeli eğit ve loss grafiğini döndür"""
    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()

    torch.manual_seed(42)
    X = torch.randn(300, 8)
    y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)

    losses = []

    for epoch in range(epochs):
        optimizer.zero_grad()
        pred = model(X, alpha=alpha_value)
        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()

        losses.append(loss.item())

    # Grafik oluştur
    fig, ax = plt.subplots(figsize=(10, 6))
    ax.plot(losses, linewidth=2, color='#FF6B6B')
    ax.set_xlabel('Epoch', fontsize=12)
    ax.set_ylabel('Loss', fontsize=12)
    ax.set_title(f'Eğitim Süreci (α = {alpha_value:.8f})', fontsize=14)
    ax.grid(True, alpha=0.3)
    ax.set_yscale('log')

    final_loss = losses[-1]

    plt.close(fig) # Close the figure to free up memory
    return fig, f"Final Loss: {final_loss:.6f}"


def compare_alphas(epochs):
    """Farklı alpha değerlerini karşılaştır"""
    alpha_values = {
        "Nominal (1/137.035)": 1/137.035,
        "Fiziksel (1/137.035999)": 1/137.035999,
        "Sapma1 (1/137.000)": 1/137.000,
        "Sapma2 (1/137.070)": 1/137.070
    }

    fig, ax = plt.subplots(figsize=(12, 7))
    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A']

    results = {}

    for (name, alpha_val), color in zip(alpha_values.items(), colors):
        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()

        torch.manual_seed(42)
        X = torch.randn(300, 8)
        y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)

        losses = []

        for epoch in 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()

            losses.append(loss.item())

        ax.plot(losses, label=name, linewidth=2.5, color=color)
        results[name] = losses[-1]

    ax.set_xlabel('Epoch', fontsize=12)
    ax.set_ylabel('Loss', fontsize=12)
    ax.set_title('Alpha Değerleri Karşılaştırması', fontsize=14)
    ax.legend(fontsize=10)
    ax.grid(True, alpha=0.3)
    ax.set_yscale('log')

    # Sonuçları metne dönüştür
    results_text = "**Final Loss Değerleri:**\n\n"
    for name, loss in sorted(results.items(), key=lambda x: x[1]):
        results_text += f"• {name}: {loss:.6f}\n"

    plt.close(fig) # Close the figure to free up memory
    return fig, results_text


# Gradio Interface
with gr.Blocks(title="OmegaCode: Holographic Master Code") as demo: # Removed theme parameter from here based on Gradio 6.0 warning
    gr.Markdown("""
    # 🌌 OmegaCode: Evrensel Kaynak Kodun Holografik Korunumu

    Bu uygulama, **Ω_v57** teorisini temel alan Holografik Master Code Transformer modelini etkileşimli bir şekilde test etmenizi sağlar.

    **Teori Özeti:**
    - **Master Code (Ψ)**: Evrenin temel titreşim dokusunu temsil eden harmonik dalga süperpozisyonu
    - **Alpha (α) Güvenlik Kilidi**: İnce yapı sabiti değerindeki sapmalara karşı sistemi koruyan mekanizma
    - **Ryu-Takayanagi Entanglement**: Karadelik ufkundaki minimal yüzey alanı üzerinden bilgi korunumu
    - **Holografik AI**: Yapay zeka eğitiminde kuantum hata düzeltme benzeri etkileri
    """)

    with gr.Tabs():
        with gr.Tab("Tek Alpha Eğitimi"):
            gr.Markdown("### Belirli Bir Alpha Değeriyle Eğitim Yap")

            with gr.Row():
                alpha_input = gr.Number(
                    value=1/137.035,
                    label="Alpha Değeri",
                    info="Varsayılan: 1/137.035 (Nominal)"
                )
                epochs_input = gr.Slider(
                    minimum=50,
                    maximum=500,
                    value=150,
                    step=50,
                    label="Epoch Sayısı"
                )

            train_btn = gr.Button("Eğitimi Başlat", variant="primary", size="lg")

            with gr.Row():
                output_plot = gr.Plot(label="Loss Grafiği")
                output_text = gr.Textbox(label="Sonuç", interactive=False)

            train_btn.click(
                fn=train_model,
                inputs=[alpha_input, epochs_input],
                outputs=[output_plot, output_text]
            )

        with gr.Tab("Alpha Karşılaştırması"):
            gr.Markdown("### Farklı Alpha Değerlerini Karşılaştır")

            epochs_compare = gr.Slider(
                minimum=50,
                maximum=300,
                value=150,
                step=50,
                label="Epoch Sayısı"
            )

            compare_btn = gr.Button("Karşılaştırmayı Başlat", variant="primary", size="lg")

            with gr.Row():
                compare_plot = gr.Plot(label="Karşılaştırma Grafiği")
                compare_text = gr.Markdown(label="Sonuçlar")

            compare_btn.click(
                fn=compare_alphas,
                inputs=[epochs_compare],
                outputs=[compare_plot, compare_text]
            )

        with gr.Tab("Teori Hakkında"):
            gr.Markdown(r"""
            ## Ω_v57 Teorisi Detayları

            ### Master Code (Ψ)
            Evrenin temel titreşim dokusunu temsil eden harmonik dalga süperpozisyonu:

            $$\Psi(\mathbf{x}, t, lpha) = \sum_{n=1}^{N} A_n \cos(\mathbf{k}_n \cdot \mathbf{x} + \omega_n t + \phi_n(lpha))$$

            ### Alpha Güvenlik Kilidi
            İnce yapı sabiti α ≈ 1/137.035 değerindeki sapmalara karşı sistem kendini otomatik olarak korur:

            $$\delta(lpha - lpha_0) 	imes \exp\left(-rac{d\Psi}{dlpha}
ight)$$

            ### Ryu-Takayanagi Entanglement
            Karadelik ufkundaki minimal yüzey alanı üzerinden kuantum dolaşıklığının geometrik temsili:

            $$S_{	ext{ent}}^{	ext{RT}} = rac{	ext{Area}(\gamma_{	ext{min}})}{4 G_{13}}$$

            ### Holografik AI Etkisi
            Bu mekanizmalar, yapay zeka eğitiminde Loss Zeroing hızını %140 artırmaktadır.
            """)

    gr.Markdown("""
    ---

    **Proje Kaynakları:**
    - GitHub: [OmegaCode Repository](https://github.com/KULLANICI_ADI/OmegaCode)
    - Teori: Ω_v57 Holographic Master Code Framework
    - Lisans: MIT
    """)

if __name__ == "__main__":
    demo.launch(theme=gr.themes.Soft()) # Moved theme parameter here based on Gradio 6.0 warning

# Dummy comment to force file modification for re-upload: v1.0.2