antaris commited on
Commit
00a07d6
·
verified ·
1 Parent(s): e35c3a2

Upload 32 files

Browse files
Files changed (2) hide show
  1. src/modules/auto_params.py +99 -0
  2. src/streamlit_app.py +42 -6
src/modules/auto_params.py ADDED
@@ -0,0 +1,99 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from __future__ import annotations
2
+
3
+ from typing import Dict, Sequence, Tuple
4
+
5
+ import networkx as nx
6
+ import numpy as np
7
+
8
+
9
+ def estimate_bath_correlation_length(
10
+ G: nx.Graph,
11
+ boundary_nodes: Sequence[int],
12
+ max_pairs: int = 200,
13
+ min_xi: float = 0.5,
14
+ max_xi: float = 10.0,
15
+ factor: float = 4.0,
16
+ ) -> float:
17
+ """
18
+ Schätze eine sinnvolle Korrelationlänge ξ_bad aus den Graph-Distanzen der Randknoten.
19
+
20
+ Idee:
21
+ - Bestimme typische kürzeste Pfadlängen d(i,j) zwischen Randknoten i,j.
22
+ - Verwende den Mittelwert dieser Distanzen, geteilt durch einen Faktor ``factor``,
23
+ als Schätzer für ξ_bad.
24
+ - Beschneide den Wert auf das Intervall [min_xi, max_xi].
25
+
26
+ Die Berechnung verwendet aus Effizienzgründen maximal ``max_pairs`` Randknoten-Paare.
27
+ """
28
+ bnodes = list(boundary_nodes)
29
+ if len(bnodes) < 2:
30
+ # Fallback: neutraler Wert im Sliderbereich
31
+ return 1.0
32
+
33
+ pairs: list[Tuple[int, int]] = []
34
+ for i, u in enumerate(bnodes):
35
+ for v in bnodes[i + 1 :]:
36
+ pairs.append((u, v))
37
+
38
+ if not pairs:
39
+ return 1.0
40
+
41
+ if len(pairs) > max_pairs:
42
+ rng = np.random.default_rng(0)
43
+ idx = rng.choice(len(pairs), size=max_pairs, replace=False)
44
+ pairs = [pairs[int(k)] for k in idx]
45
+
46
+ dists = [nx.shortest_path_length(G, u, v) for (u, v) in pairs]
47
+ if not dists:
48
+ return 1.0
49
+
50
+ d_mean = float(np.mean(dists))
51
+ if d_mean <= 0.0 or not np.isfinite(d_mean):
52
+ return 1.0
53
+
54
+ xi = d_mean / float(factor)
55
+ xi = float(np.clip(xi, min_xi, max_xi))
56
+ return xi
57
+
58
+
59
+ def estimate_alpha_beta(
60
+ edge_energies: Dict[Tuple[int, int], float],
61
+ min_alpha: float = 0.05,
62
+ max_alpha: float = 1.5,
63
+ min_beta: float = 0.1,
64
+ max_beta: float = 5.0,
65
+ ) -> tuple[float, float]:
66
+ """
67
+ Schätze (α, β) aus der Verteilung der Kantenergien.
68
+
69
+ Heuristik:
70
+ - β wächst mit dem Logarithmus des Dynamikbereichs R = E_max / E_mean.
71
+ - α wächst mit der relativen Streuung (Coefficient of Variation) CV = E_std / E_mean.
72
+
73
+ Die Rückgabewerte werden auf die Intervalle [min_alpha, max_alpha] bzw.
74
+ [min_beta, max_beta] beschränkt.
75
+ """
76
+ if not edge_energies:
77
+ return 0.5, 1.5
78
+
79
+ E = np.fromiter(edge_energies.values(), dtype=float)
80
+ if E.size == 0:
81
+ return 0.5, 1.5
82
+
83
+ E_mean = float(E.mean())
84
+ E_std = float(E.std())
85
+ E_max = float(E.max())
86
+
87
+ ref = E_mean
88
+ if abs(ref) < 1e-12:
89
+ ref = E_std if abs(E_std) > 1e-12 else 1.0
90
+
91
+ R = abs(E_max / ref) if ref != 0.0 else 1.0
92
+ beta = 0.5 * float(np.log1p(R))
93
+ beta = float(np.clip(beta, min_beta, max_beta))
94
+
95
+ CV = abs(E_std / ref) if ref != 0.0 else 0.0
96
+ alpha = 0.3 * CV
97
+ alpha = float(np.clip(alpha, min_alpha, max_alpha))
98
+
99
+ return alpha, beta
src/streamlit_app.py CHANGED
@@ -4,7 +4,7 @@ import pkgutil
4
 
5
  import streamlit as st
6
 
7
- from modules import geometry, bath, real_dynamics, markov_gksl, address_tree, visualization
8
 
9
 
10
  def build_context(fractal_id: str,
@@ -36,6 +36,13 @@ def build_context(fractal_id: str,
36
  # Kantenergien
37
  edge_energies = real_dynamics.compute_edge_energies(G_ideal, f_potential)
38
 
 
 
 
 
 
 
 
39
  # REAL-Graph: nur innere Kanten anpassen, äußere fix lassen
40
  G_real = real_dynamics.copy_graph_with_weights(G_ideal)
41
  G_real = real_dynamics.update_internal_edge_weights(
@@ -88,6 +95,11 @@ def build_context(fractal_id: str,
88
  "Q": Q,
89
  "node_order": node_order,
90
  "spectrum": spectrum,
 
 
 
 
 
91
  "random_seed": seed,
92
  }
93
  return context
@@ -122,7 +134,7 @@ def main():
122
  level = st.sidebar.slider(
123
  "Approximationslevel",
124
  min_value=1,
125
- max_value=15,
126
  value=2,
127
  step=1,
128
  )
@@ -131,24 +143,27 @@ def main():
131
  "Korrelationlänge des Bads (Graph-Distanz)",
132
  min_value=0.5,
133
  max_value=10.0,
134
- value=3.0,
135
  step=0.5,
 
136
  )
137
 
138
  alpha = st.sidebar.slider(
139
  "Selbstwechselwirkungsstärke α",
140
  min_value=0.0,
141
  max_value=2.0,
142
- value=0.5,
143
  step=0.1,
 
144
  )
145
 
146
  beta = st.sidebar.slider(
147
  "Nichtlinearität β",
148
  min_value=0.1,
149
  max_value=5.0,
150
- value=1.5,
151
  step=0.1,
 
152
  )
153
 
154
  gamma_mode_label = st.sidebar.radio(
@@ -216,6 +231,27 @@ def main():
216
  # Flag für Visualisierung
217
  context["show_ideal"] = show_ideal
218
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
219
  st.title("B.0 – ST/SG-Toy-Model mit Bad, REAL-Geometrie und GKSL-Einbettung")
220
 
221
  # Artefakt-ZIP
@@ -247,4 +283,4 @@ def main():
247
 
248
 
249
  if __name__ == "__main__":
250
- main()
 
4
 
5
  import streamlit as st
6
 
7
+ from modules import geometry, bath, real_dynamics, markov_gksl, address_tree, visualization, auto_params
8
 
9
 
10
  def build_context(fractal_id: str,
 
36
  # Kantenergien
37
  edge_energies = real_dynamics.compute_edge_energies(G_ideal, f_potential)
38
 
39
+ # Auto-Parameter: aus Randgeometrie und Kantenergien ableiten
40
+ xi_auto = auto_params.estimate_bath_correlation_length(
41
+ G_ideal,
42
+ boundary_nodes,
43
+ )
44
+ alpha_auto, beta_auto = auto_params.estimate_alpha_beta(edge_energies)
45
+
46
  # REAL-Graph: nur innere Kanten anpassen, äußere fix lassen
47
  G_real = real_dynamics.copy_graph_with_weights(G_ideal)
48
  G_real = real_dynamics.update_internal_edge_weights(
 
95
  "Q": Q,
96
  "node_order": node_order,
97
  "spectrum": spectrum,
98
+ "auto_params": {
99
+ "xi_bad": xi_auto,
100
+ "alpha": alpha_auto,
101
+ "beta": beta_auto,
102
+ },
103
  "random_seed": seed,
104
  }
105
  return context
 
134
  level = st.sidebar.slider(
135
  "Approximationslevel",
136
  min_value=1,
137
+ max_value=7 if fractal_id == "SG" else 6,
138
  value=2,
139
  step=1,
140
  )
 
143
  "Korrelationlänge des Bads (Graph-Distanz)",
144
  min_value=0.5,
145
  max_value=10.0,
146
+ value=st.session_state.get("correlation_length", 3.0),
147
  step=0.5,
148
+ key="correlation_length",
149
  )
150
 
151
  alpha = st.sidebar.slider(
152
  "Selbstwechselwirkungsstärke α",
153
  min_value=0.0,
154
  max_value=2.0,
155
+ value=st.session_state.get("alpha", 0.5),
156
  step=0.1,
157
+ key="alpha",
158
  )
159
 
160
  beta = st.sidebar.slider(
161
  "Nichtlinearität β",
162
  min_value=0.1,
163
  max_value=5.0,
164
+ value=st.session_state.get("beta", 1.5),
165
  step=0.1,
166
+ key="beta",
167
  )
168
 
169
  gamma_mode_label = st.sidebar.radio(
 
231
  # Flag für Visualisierung
232
  context["show_ideal"] = show_ideal
233
 
234
+ # Auto-Parameter aus dem aktuellen Kontext anzeigen und optional übernehmen
235
+ auto_ctx = context.get("auto_params", {})
236
+ xi_auto = auto_ctx.get("xi_bad")
237
+ alpha_auto = auto_ctx.get("alpha")
238
+ beta_auto = auto_ctx.get("beta")
239
+
240
+ with st.sidebar.expander("Auto-Parameter aus aktueller Realisierung", expanded=False):
241
+ if xi_auto is not None and alpha_auto is not None and beta_auto is not None:
242
+ st.markdown(
243
+ f"**ξ_bad (auto):** {xi_auto:.3f} \n"
244
+ f"**α (auto):** {alpha_auto:.3f} \n"
245
+ f"**β (auto):** {beta_auto:.3f}"
246
+ )
247
+ if st.button("Auto-Werte übernehmen"):
248
+ st.session_state["correlation_length"] = float(xi_auto)
249
+ st.session_state["alpha"] = float(alpha_auto)
250
+ st.session_state["beta"] = float(beta_auto)
251
+ st.experimental_rerun()
252
+ else:
253
+ st.caption("Auto-Parameter stehen für diese Konfiguration nicht zur Verfügung.")
254
+
255
  st.title("B.0 – ST/SG-Toy-Model mit Bad, REAL-Geometrie und GKSL-Einbettung")
256
 
257
  # Artefakt-ZIP
 
283
 
284
 
285
  if __name__ == "__main__":
286
+ main()