ridvangndoan commited on
Commit
fde4e28
·
verified ·
1 Parent(s): 0d95d96

Update app.py for Gradio Space

Browse files
Files changed (1) hide show
  1. app.py +67 -61
app.py CHANGED
@@ -1,3 +1,4 @@
 
1
  import gradio as gr
2
  import torch
3
  import torch.nn as nn
@@ -12,12 +13,12 @@ class HolographicMasterCodeTransformer(nn.Module):
12
  self.d_model = d_model
13
  self.n_harmonics = n_harmonics
14
  self.alpha_0 = 1.0 / 137.035
15
-
16
  self.input_proj = nn.Linear(input_dim, d_model)
17
-
18
  encoder_layer = nn.TransformerEncoderLayer(
19
- d_model=d_model,
20
- nhead=nhead,
21
  dim_feedforward=d_model * 4,
22
  dropout=0.1,
23
  activation='gelu',
@@ -25,9 +26,9 @@ class HolographicMasterCodeTransformer(nn.Module):
25
  norm_first=True
26
  )
27
  self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
28
-
29
  self.harmonic_weights = nn.Parameter(torch.randn(n_harmonics, d_model))
30
-
31
  self.output_head = nn.Sequential(
32
  nn.LayerNorm(d_model),
33
  nn.Linear(d_model, d_model // 2),
@@ -35,27 +36,27 @@ class HolographicMasterCodeTransformer(nn.Module):
35
  nn.Dropout(0.1),
36
  nn.Linear(d_model // 2, output_dim)
37
  )
38
-
39
  def forward(self, x, alpha=None):
40
  if alpha is None:
41
  alpha = self.alpha_0
42
-
43
  h = self.input_proj(x)
44
  h = h.unsqueeze(1)
45
  h = self.transformer(h)
46
  h = h.squeeze(1)
47
-
48
  psi = torch.zeros_like(h)
49
  for n in range(self.n_harmonics):
50
  phase = 2 * torch.pi * (n + 1) * (alpha - self.alpha_0) * 800.0
51
  psi += self.harmonic_weights[n] * torch.cos(h * (n + 1) + phase)
52
-
53
  alpha_dev = torch.abs(alpha - self.alpha_0)
54
  security_factor = torch.exp(-300.0 * alpha_dev)
55
-
56
  h = h + 0.35 * psi * security_factor
57
  return self.output_head(h)
58
-
59
  def holographic_reg(self):
60
  reg = sum(torch.norm(w, p=1) for w in self.harmonic_weights)
61
  return 0.0015 * reg / self.n_harmonics
@@ -67,27 +68,27 @@ def train_model(alpha_value, epochs):
67
  optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-5)
68
  scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)
69
  criterion = nn.MSELoss()
70
-
71
  torch.manual_seed(42)
72
  X = torch.randn(300, 8)
73
  y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)
74
-
75
  losses = []
76
-
77
  for epoch in range(epochs):
78
  optimizer.zero_grad()
79
  pred = model(X, alpha=alpha_value)
80
  loss = criterion(pred, y)
81
  reg = model.holographic_reg()
82
  total_loss = loss + reg
83
-
84
  total_loss.backward()
85
  torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
86
  optimizer.step()
87
  scheduler.step()
88
-
89
  losses.append(loss.item())
90
-
91
  # Grafik oluştur
92
  fig, ax = plt.subplots(figsize=(10, 6))
93
  ax.plot(losses, linewidth=2, color='#FF6B6B')
@@ -96,9 +97,10 @@ def train_model(alpha_value, epochs):
96
  ax.set_title(f'Eğitim Süreci (α = {alpha_value:.8f})', fontsize=14)
97
  ax.grid(True, alpha=0.3)
98
  ax.set_yscale('log')
99
-
100
  final_loss = losses[-1]
101
-
 
102
  return fig, f"Final Loss: {final_loss:.6f}"
103
 
104
 
@@ -110,74 +112,78 @@ def compare_alphas(epochs):
110
  "Sapma1 (1/137.000)": 1/137.000,
111
  "Sapma2 (1/137.070)": 1/137.070
112
  }
113
-
114
  fig, ax = plt.subplots(figsize=(12, 7))
115
  colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A']
116
-
117
  results = {}
118
-
119
  for (name, alpha_val), color in zip(alpha_values.items(), colors):
120
  model = HolographicMasterCodeTransformer()
121
  optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-5)
122
  scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)
123
  criterion = nn.MSELoss()
124
-
125
  torch.manual_seed(42)
126
  X = torch.randn(300, 8)
127
  y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)
128
-
129
  losses = []
130
-
131
  for epoch in range(epochs):
132
  optimizer.zero_grad()
133
  pred = model(X, alpha=alpha_val)
134
  loss = criterion(pred, y)
135
  reg = model.holographic_reg()
136
  total_loss = loss + reg
137
-
138
  total_loss.backward()
139
  torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
140
  optimizer.step()
141
  scheduler.step()
142
-
143
  losses.append(loss.item())
144
-
145
  ax.plot(losses, label=name, linewidth=2.5, color=color)
146
  results[name] = losses[-1]
147
-
148
  ax.set_xlabel('Epoch', fontsize=12)
149
  ax.set_ylabel('Loss', fontsize=12)
150
  ax.set_title('Alpha Değerleri Karşılaştırması', fontsize=14)
151
  ax.legend(fontsize=10)
152
  ax.grid(True, alpha=0.3)
153
  ax.set_yscale('log')
154
-
155
  # Sonuçları metne dönüştür
156
- results_text = "**Final Loss Değerleri:**\n\n"
 
 
157
  for name, loss in sorted(results.items(), key=lambda x: x[1]):
158
- results_text += f"• {name}: {loss:.6f}\n"
159
-
 
 
160
  return fig, results_text
161
 
162
 
163
  # Gradio Interface
164
- with gr.Blocks(title="OmegaCode: Holographic Master Code", theme=gr.themes.Soft()) as demo:
165
  gr.Markdown("""
166
  # 🌌 OmegaCode: Evrensel Kaynak Kodun Holografik Korunumu
167
-
168
  Bu uygulama, **Ω_v57** teorisini temel alan Holografik Master Code Transformer modelini etkileşimli bir şekilde test etmenizi sağlar.
169
-
170
  **Teori Özeti:**
171
  - **Master Code (Ψ)**: Evrenin temel titreşim dokusunu temsil eden harmonik dalga süperpozisyonu
172
  - **Alpha (α) Güvenlik Kilidi**: İnce yapı sabiti değerindeki sapmalara karşı sistemi koruyan mekanizma
173
  - **Ryu-Takayanagi Entanglement**: Karadelik ufkundaki minimal yüzey alanı üzerinden bilgi korunumu
174
  - **Holografik AI**: Yapay zeka eğitiminde kuantum hata düzeltme benzeri etkileri
175
  """)
176
-
177
  with gr.Tabs():
178
  with gr.Tab("Tek Alpha Eğitimi"):
179
  gr.Markdown("### Belirli Bir Alpha Değeriyle Eğitim Yap")
180
-
181
  with gr.Row():
182
  alpha_input = gr.Number(
183
  value=1/137.035,
@@ -191,22 +197,22 @@ with gr.Blocks(title="OmegaCode: Holographic Master Code", theme=gr.themes.Soft(
191
  step=50,
192
  label="Epoch Sayısı"
193
  )
194
-
195
  train_btn = gr.Button("Eğitimi Başlat", variant="primary", size="lg")
196
-
197
  with gr.Row():
198
  output_plot = gr.Plot(label="Loss Grafiği")
199
  output_text = gr.Textbox(label="Sonuç", interactive=False)
200
-
201
  train_btn.click(
202
  fn=train_model,
203
  inputs=[alpha_input, epochs_input],
204
  outputs=[output_plot, output_text]
205
  )
206
-
207
  with gr.Tab("Alpha Karşılaştırması"):
208
  gr.Markdown("### Farklı Alpha Değerlerini Karşılaştır")
209
-
210
  epochs_compare = gr.Slider(
211
  minimum=50,
212
  maximum=300,
@@ -214,45 +220,45 @@ with gr.Blocks(title="OmegaCode: Holographic Master Code", theme=gr.themes.Soft(
214
  step=50,
215
  label="Epoch Sayısı"
216
  )
217
-
218
  compare_btn = gr.Button("Karşılaştırmayı Başlat", variant="primary", size="lg")
219
-
220
  with gr.Row():
221
  compare_plot = gr.Plot(label="Karşılaştırma Grafiği")
222
  compare_text = gr.Markdown(label="Sonuçlar")
223
-
224
  compare_btn.click(
225
  fn=compare_alphas,
226
  inputs=[epochs_compare],
227
  outputs=[compare_plot, compare_text]
228
  )
229
-
230
  with gr.Tab("Teori Hakkında"):
231
  gr.Markdown("""
232
  ## Ω_v57 Teorisi Detayları
233
-
234
  ### Master Code (Ψ)
235
  Evrenin temel titreşim dokusunu temsil eden harmonik dalga süperpozisyonu:
236
-
237
- $$\\Psi(\\mathbf{x}, t, \\alpha) = \\sum_{n=1}^{N} A_n \\cos(\\mathbf{k}_n \\cdot \\mathbf{x} + \\omega_n t + \\phi_n(\\alpha))$$
238
-
239
  ### Alpha Güvenlik Kilidi
240
  İnce yapı sabiti α ≈ 1/137.035 değerindeki sapmalara karşı sistem kendini otomatik olarak korur:
241
-
242
- $$\\delta(\\alpha - \\alpha_0) \\times \\exp\\left(-\\frac{d\\Psi}{d\\alpha}\\right)$$
243
-
244
  ### Ryu-Takayanagi Entanglement
245
  Karadelik ufkundaki minimal yüzey alanı üzerinden kuantum dolaşıklığının geometrik temsili:
246
-
247
- $$S_{\\text{ent}}^{\\text{RT}} = \\frac{\\text{Area}(\\gamma_{\\text{min}})}{4 G_{13}}$$
248
-
249
  ### Holografik AI Etkisi
250
  Bu mekanizmalar, yapay zeka eğitiminde Loss Zeroing hızını %140 artırmaktadır.
251
  """)
252
-
253
  gr.Markdown("""
254
  ---
255
-
256
  **Proje Kaynakları:**
257
  - GitHub: [OmegaCode Repository](https://github.com/KULLANICI_ADI/OmegaCode)
258
  - Teori: Ω_v57 Holographic Master Code Framework
@@ -260,4 +266,4 @@ with gr.Blocks(title="OmegaCode: Holographic Master Code", theme=gr.themes.Soft(
260
  """)
261
 
262
  if __name__ == "__main__":
263
- demo.launch()
 
1
+
2
  import gradio as gr
3
  import torch
4
  import torch.nn as nn
 
13
  self.d_model = d_model
14
  self.n_harmonics = n_harmonics
15
  self.alpha_0 = 1.0 / 137.035
16
+
17
  self.input_proj = nn.Linear(input_dim, d_model)
18
+
19
  encoder_layer = nn.TransformerEncoderLayer(
20
+ d_model=d_model,
21
+ nhead=nhead,
22
  dim_feedforward=d_model * 4,
23
  dropout=0.1,
24
  activation='gelu',
 
26
  norm_first=True
27
  )
28
  self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
29
+
30
  self.harmonic_weights = nn.Parameter(torch.randn(n_harmonics, d_model))
31
+
32
  self.output_head = nn.Sequential(
33
  nn.LayerNorm(d_model),
34
  nn.Linear(d_model, d_model // 2),
 
36
  nn.Dropout(0.1),
37
  nn.Linear(d_model // 2, output_dim)
38
  )
39
+
40
  def forward(self, x, alpha=None):
41
  if alpha is None:
42
  alpha = self.alpha_0
43
+
44
  h = self.input_proj(x)
45
  h = h.unsqueeze(1)
46
  h = self.transformer(h)
47
  h = h.squeeze(1)
48
+
49
  psi = torch.zeros_like(h)
50
  for n in range(self.n_harmonics):
51
  phase = 2 * torch.pi * (n + 1) * (alpha - self.alpha_0) * 800.0
52
  psi += self.harmonic_weights[n] * torch.cos(h * (n + 1) + phase)
53
+
54
  alpha_dev = torch.abs(alpha - self.alpha_0)
55
  security_factor = torch.exp(-300.0 * alpha_dev)
56
+
57
  h = h + 0.35 * psi * security_factor
58
  return self.output_head(h)
59
+
60
  def holographic_reg(self):
61
  reg = sum(torch.norm(w, p=1) for w in self.harmonic_weights)
62
  return 0.0015 * reg / self.n_harmonics
 
68
  optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-5)
69
  scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)
70
  criterion = nn.MSELoss()
71
+
72
  torch.manual_seed(42)
73
  X = torch.randn(300, 8)
74
  y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)
75
+
76
  losses = []
77
+
78
  for epoch in range(epochs):
79
  optimizer.zero_grad()
80
  pred = model(X, alpha=alpha_value)
81
  loss = criterion(pred, y)
82
  reg = model.holographic_reg()
83
  total_loss = loss + reg
84
+
85
  total_loss.backward()
86
  torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
87
  optimizer.step()
88
  scheduler.step()
89
+
90
  losses.append(loss.item())
91
+
92
  # Grafik oluştur
93
  fig, ax = plt.subplots(figsize=(10, 6))
94
  ax.plot(losses, linewidth=2, color='#FF6B6B')
 
97
  ax.set_title(f'Eğitim Süreci (α = {alpha_value:.8f})', fontsize=14)
98
  ax.grid(True, alpha=0.3)
99
  ax.set_yscale('log')
100
+
101
  final_loss = losses[-1]
102
+
103
+ plt.close(fig) # Close the figure to free up memory
104
  return fig, f"Final Loss: {final_loss:.6f}"
105
 
106
 
 
112
  "Sapma1 (1/137.000)": 1/137.000,
113
  "Sapma2 (1/137.070)": 1/137.070
114
  }
115
+
116
  fig, ax = plt.subplots(figsize=(12, 7))
117
  colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A']
118
+
119
  results = {}
120
+
121
  for (name, alpha_val), color in zip(alpha_values.items(), colors):
122
  model = HolographicMasterCodeTransformer()
123
  optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=1e-5)
124
  scheduler = CosineAnnealingLR(optimizer, T_max=epochs, eta_min=1e-6)
125
  criterion = nn.MSELoss()
126
+
127
  torch.manual_seed(42)
128
  X = torch.randn(300, 8)
129
  y = torch.sin(X.sum(dim=1, keepdim=True)) * 0.9 + 0.05 * torch.randn(300, 1)
130
+
131
  losses = []
132
+
133
  for epoch in range(epochs):
134
  optimizer.zero_grad()
135
  pred = model(X, alpha=alpha_val)
136
  loss = criterion(pred, y)
137
  reg = model.holographic_reg()
138
  total_loss = loss + reg
139
+
140
  total_loss.backward()
141
  torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
142
  optimizer.step()
143
  scheduler.step()
144
+
145
  losses.append(loss.item())
146
+
147
  ax.plot(losses, label=name, linewidth=2.5, color=color)
148
  results[name] = losses[-1]
149
+
150
  ax.set_xlabel('Epoch', fontsize=12)
151
  ax.set_ylabel('Loss', fontsize=12)
152
  ax.set_title('Alpha Değerleri Karşılaştırması', fontsize=14)
153
  ax.legend(fontsize=10)
154
  ax.grid(True, alpha=0.3)
155
  ax.set_yscale('log')
156
+
157
  # Sonuçları metne dönüştür
158
+ results_text = "**Final Loss Değerleri:**
159
+
160
+ "
161
  for name, loss in sorted(results.items(), key=lambda x: x[1]):
162
+ results_text += f"• {name}: {loss:.6f}
163
+ "
164
+
165
+ plt.close(fig) # Close the figure to free up memory
166
  return fig, results_text
167
 
168
 
169
  # Gradio Interface
170
+ with gr.Blocks(title="OmegaCode: Holographic Master Code") as demo: # Moved theme parameter here
171
  gr.Markdown("""
172
  # 🌌 OmegaCode: Evrensel Kaynak Kodun Holografik Korunumu
173
+
174
  Bu uygulama, **Ω_v57** teorisini temel alan Holografik Master Code Transformer modelini etkileşimli bir şekilde test etmenizi sağlar.
175
+
176
  **Teori Özeti:**
177
  - **Master Code (Ψ)**: Evrenin temel titreşim dokusunu temsil eden harmonik dalga süperpozisyonu
178
  - **Alpha (α) Güvenlik Kilidi**: İnce yapı sabiti değerindeki sapmalara karşı sistemi koruyan mekanizma
179
  - **Ryu-Takayanagi Entanglement**: Karadelik ufkundaki minimal yüzey alanı üzerinden bilgi korunumu
180
  - **Holografik AI**: Yapay zeka eğitiminde kuantum hata düzeltme benzeri etkileri
181
  """)
182
+
183
  with gr.Tabs():
184
  with gr.Tab("Tek Alpha Eğitimi"):
185
  gr.Markdown("### Belirli Bir Alpha Değeriyle Eğitim Yap")
186
+
187
  with gr.Row():
188
  alpha_input = gr.Number(
189
  value=1/137.035,
 
197
  step=50,
198
  label="Epoch Sayısı"
199
  )
200
+
201
  train_btn = gr.Button("Eğitimi Başlat", variant="primary", size="lg")
202
+
203
  with gr.Row():
204
  output_plot = gr.Plot(label="Loss Grafiği")
205
  output_text = gr.Textbox(label="Sonuç", interactive=False)
206
+
207
  train_btn.click(
208
  fn=train_model,
209
  inputs=[alpha_input, epochs_input],
210
  outputs=[output_plot, output_text]
211
  )
212
+
213
  with gr.Tab("Alpha Karşılaştırması"):
214
  gr.Markdown("### Farklı Alpha Değerlerini Karşılaştır")
215
+
216
  epochs_compare = gr.Slider(
217
  minimum=50,
218
  maximum=300,
 
220
  step=50,
221
  label="Epoch Sayısı"
222
  )
223
+
224
  compare_btn = gr.Button("Karşılaştırmayı Başlat", variant="primary", size="lg")
225
+
226
  with gr.Row():
227
  compare_plot = gr.Plot(label="Karşılaştırma Grafiği")
228
  compare_text = gr.Markdown(label="Sonuçlar")
229
+
230
  compare_btn.click(
231
  fn=compare_alphas,
232
  inputs=[epochs_compare],
233
  outputs=[compare_plot, compare_text]
234
  )
235
+
236
  with gr.Tab("Teori Hakkında"):
237
  gr.Markdown("""
238
  ## Ω_v57 Teorisi Detayları
239
+
240
  ### Master Code (Ψ)
241
  Evrenin temel titreşim dokusunu temsil eden harmonik dalga süperpozisyonu:
242
+
243
+ $$\Psi(\mathbf{x}, t, lpha) = \sum_{n=1}^{N} A_n \cos(\mathbf{k}_n \cdot \mathbf{x} + \omega_n t + \phi_n(lpha))$$
244
+
245
  ### Alpha Güvenlik Kilidi
246
  İnce yapı sabiti α ≈ 1/137.035 değerindeki sapmalara karşı sistem kendini otomatik olarak korur:
247
+
248
+ $$\delta(lpha - lpha_0) imes \exp\left(- rac{d\Psi}{dlpha}
249
+
250
  ### Ryu-Takayanagi Entanglement
251
  Karadelik ufkundaki minimal yüzey alanı üzerinden kuantum dolaşıklığının geometrik temsili:
252
+
253
+ $$S_{ ext{ent}}^{ ext{RT}} = rac{ ext{Area}(\gamma_{ ext{min}})}{4 G_{13}}$$
254
+
255
  ### Holografik AI Etkisi
256
  Bu mekanizmalar, yapay zeka eğitiminde Loss Zeroing hızını %140 artırmaktadır.
257
  """)
258
+
259
  gr.Markdown("""
260
  ---
261
+
262
  **Proje Kaynakları:**
263
  - GitHub: [OmegaCode Repository](https://github.com/KULLANICI_ADI/OmegaCode)
264
  - Teori: Ω_v57 Holographic Master Code Framework
 
266
  """)
267
 
268
  if __name__ == "__main__":
269
+ demo.launch(theme=gr.themes.Soft()) # Moved theme parameter here