Update app.py

app.py

@@ -1,136 +1,127 @@
 import numpy as np
 import matplotlib.pyplot as plt
-import random
-from scipy.stats import entropy as scipy_entropy
 import streamlit as st
 
-# --- НАСТРОЙКИ ---
-seqlen = st.slider("Длина последовательности", 10, 100, 60)
-steps = st.slider("Количество шагов", 10, 200, 120)
-min_run, max_run = st.slider("Длина машин", 1, 10, 1), st.slider("Максимальная длина машин", 2, 10, 2)
-ANGLE_MAP = {'A': 60.0, 'C': 180.0, 'G': -60.0, 'T': -180.0, 'N': 0.0}
-bases = ['A', 'C', 'G', 'T']
-
-def find_local_min_runs(profile, min_run=1, max_run=2):
-    result = []
-    N = len(profile)
-    i = 0
-    while i < N:
-        run_val = profile[i]
-        run_length = 1
-        while i + run_length < N and profile[i + run_length] == run_val:
-            run_length += 1
-        if min_run <= run_length <= max_run:
-            result.append((i, i + run_length - 1, run_val))
-        i += run_length
-    return result
-
-# --- Более биологичные мутации ---
-def bio_mutate(seq):
-    r = random.random()
-    if r < 0.70:
-        idx = random.randint(0, len(seq)-1)
-        orig = seq[idx]
-        prob = random.random()
-        if orig in 'AG':
-            newbase = 'C' if prob < 0.65 else random.choice(['T', 'C'])
-        elif orig in 'CT':
-            newbase = 'G' if prob < 0.65 else random.choice(['A', 'G'])
-        else:
-            newbase = random.choice([b for b in bases if b != orig])
-        seq = seq[:idx] + newbase + seq[idx+1:]
-    elif r < 0.80:
-        idx = random.randint(0, len(seq)-1)
-        ins = ''.join(random.choices(bases, k=random.randint(1, 3)))
-        seq = seq[:idx] + ins + seq[idx:]
-        if len(seq) > seqlen:
-            seq = seq[:seqlen]
-    elif r < 0.90:
-        if len(seq) > 4:
-            idx = random.randint(0, len(seq)-2)
-            dell = random.randint(1, min(3, len(seq)-idx))
-            seq = seq[:idx] + seq[idx+dell:]
-    else:
-        if len(seq) > 10:
-            start = random.randint(0, len(seq)-6)
-            end = start + random.randint(3,6)
-            subseq = seq[start:end]
-            subseq = subseq[::-1]
-            seq = seq[:start] + subseq + seq[end:]
-    while len(seq) < seqlen:
-        seq += random.choice(bases)
-    if len(seq) > seqlen:
-        seq = seq[:seqlen]
-    return seq
+# === Параметры модели ===
+SEQ_LEN = 100  # длина последовательности
+HISTORY_LEN = 200  # сколько шагов хранить в статистике
+JUMP = 10  # максимальный шаг изменения угла
+ENTROPY_BINS = 36  # шаг 10 градусов
+
+# === Инициализация состояния ===
+if "seq" not in st.session_state:
+    st.session_state.seq = np.random.randint(-180, 180, size=SEQ_LEN)
+    st.session_state.history = []
+    st.session_state.bist_counts = []
+    st.session_state.entropy = []
+    st.session_state.autocorr = []
+    st.session_state.step = 0
+
+# === Функции анализа ===
+def find_local_min_runs(profile, threshold=10):
+    """Находит устойчивые участки ("машины"), где значения углов почти не меняются."""
+    runs = []
+    start = 0
+    for i in range(1, len(profile)):
+        if abs(profile[i] - profile[i - 1]) > threshold:
+            if i - start > 2:
+                runs.append((start, i - 1))
+            start = i
+    if len(profile) - start > 2:
+        runs.append((start, len(profile) - 1))
+    return runs
 
 def compute_autocorr(profile):
+    """Автокорреляция – структурность, насколько повторяется рисунок"""
     profile = profile - np.mean(profile)
     result = np.correlate(profile, profile, mode='full')
-    result = result[result.size // 2:]
-    norm = np.max(result) if np.max(result)!=0 else 1
-    return result[:10]/norm  # только лаги 0..9
+    mid = len(result) // 2
+    return result[mid + 1] / result[mid]
 
 def compute_entropy(profile):
-    vals, counts = np.unique(profile, return_counts=True)
-    p = counts / counts.sum()
-    return scipy_entropy(p, base=2)
-
-# --- Начальная цепь ---
-seq = ''.join(random.choices(bases, k=seqlen))
-stat_bist_counts = []
-stat_entropy = []
-stat_autocorr = []
-
-fig, axs = plt.subplots(3, 1, figsize=(10, 8))
-plt.subplots_adjust(hspace=0.45)
-lags_shown = 6
+    """Энтропия – мера хаотичности, насколько случайна структура"""
+    hist, _ = np.histogram(profile, bins=ENTROPY_BINS, range=(-180, 180), density=True)
+    hist = hist[hist > 0]
+    return -np.sum(hist * np.log2(hist))
 
+# === Функция отрисовки ===
 def draw_world(seq, axs, step, stat_bist_counts, stat_entropy, stat_autocorr):
     axs[0].cla()
     axs[1].cla()
     axs[2].cla()
     axs[3].cla()
 
-    # Отображение торсионного профиля
-    axs[0].plot(seq, label=f"Step {step}", color='skyblue')
+    # Отображение профиля
+    axs[0].plot(seq, label=f"Шаг {step}", color='skyblue')
     axs[0].set_title("Торсионный профиль (углы)")
     axs[0].set_ylim(-180, 180)
-    
-    # Выделение устойчивых машин
+
+    # Визуальное выделение устойчивых "машин"
     stable_zones = find_local_min_runs(seq)
     for start, end in stable_zones:
         axs[0].axvspan(start, end, color='yellow', alpha=0.3)
-        axs[0].text((start + end) // 2, 160, f'▲ {end - start}', ha='center', va='center', fontsize=8, color='darkgreen')
+        axs[0].text((start + end) // 2, 160, f'▲{end - start}', ha='center', va='center', fontsize=8, color='darkgreen')
 
-    # Количество "машин"
-    axs[1].plot(stat_bist_counts, label='Machines', color='orchid')
+    # График количества "стромбистов"
+    axs[1].plot(stat_bist_counts, color='orchid')
     axs[1].set_title("Кол-во устойчивых машин (стромбистов)")
 
     # Энтропия
-    axs[2].plot(stat_entropy, label='Entropy', color='crimson')
+    axs[2].plot(stat_entropy, color='crimson')
     axs[2].set_title("Энтропия торсионного поля")
 
     # Автокорреляция
-    axs[3].plot(stat_autocorr, label='Autocorr', color='seagreen')
+    axs[3].plot(stat_autocorr, color='seagreen')
     axs[3].set_title("Автокорреляция (память)")
 
     for ax in axs:
         ax.legend()
 
+# === Функция обновления ===
+def update_step():
+    seq = st.session_state.seq
+    history = st.session_state.history
+    stat_bist_counts = st.session_state.bist_counts
+    stat_entropy = st.session_state.entropy
+    stat_autocorr = st.session_state.autocorr
+    step = st.session_state.step
+
+    # Случайная мутация
+    i = np.random.randint(0, len(seq))
+    delta = np.random.randint(-JUMP, JUMP + 1)
+    seq[i] = (seq[i] + delta + 180) % 360 - 180
+
+    history.append(seq.copy())
+    if len(history) > HISTORY_LEN:
+        history.pop(0)
+
+    stable_regions = find_local_min_runs(seq)
+    stat_bist_counts.append(len(stable_regions))
+    stat_entropy.append(compute_entropy(seq))
+    stat_autocorr.append(compute_autocorr(seq))
+    st.session_state.step += 1
+
+# === Интерфейс Streamlit ===
+st.set_page_config(layout="wide")
+st.title("🧬 Стромбистный анализ торсионного поля")
+col1, col2 = st.columns([1, 2])
+
+with col1:
+    if st.button("🔁 Следующий шаг"):
+        update_step()
+    st.markdown(f"**Текущий шаг**: {st.session_state.step}")
+    st.markdown("**Стромбисты** — устойчивые участки структуры, подобные памяти или машинам.")
+    st.markdown("**Автокорреляция** — отражает повторяемость паттерна.")
+    st.markdown("**Энтропия** — мера хаоса.")
 
-# --- Запуск анимации в Streamlit ---
-if st.button("Начать анимацию"):
-    chart_placeholder = st.empty()  # создаем пустое место для графиков
-    for step in range(steps):
-        seq = bio_mutate(seq)
-        torsion_profile = np.array([ANGLE_MAP.get(nt, 0.0) for nt in seq])
-        runs = find_local_min_runs(torsion_profile, min_run, max_run)
-        stat_bist_counts.append(len(runs))
-        ent = compute_entropy(torsion_profile)
-        stat_entropy.append(ent)
-        acorr = compute_autocorr(torsion_profile)
-        stat_autocorr.append(acorr)
-        draw_world(seq, axs, step, stat_bist_counts, stat_entropy, stat_autocorr)
-        
-        chart_placeholder.pyplot(fig)  # обновляем график
-        # После каждого шага Streamlit перерисует график
+with col2:
+    fig, axs = plt.subplots(4, 1, figsize=(10, 10), sharex=True)
+    draw_world(
+        st.session_state.seq,
+        axs,
+        st.session_state.step,
+        st.session_state.bist_counts,
+        st.session_state.entropy,
+        st.session_state.autocorr
+    )
+    st.pyplot(fig)