Update app.py

app.py

@@ -1,109 +1,112 @@
 import streamlit as st
-from diffusers import DiffusionPipeline
-import torch
-from PIL import Image
-import io
-import gc  # Import garbage collection
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+from scipy.stats import entropy as scipy_entropy
 
-# Заголовок приложения
-st.title("Генератор изображений с LCM Dreamshaper")
-st.write("Используйте эту модель для быстрой генерации изображений на CPU")
+# Настройки
+seqlen = 60
+min_run, max_run = 1, 2
+ANGLE_MAP = {'A': 60.0, 'C': 180.0, 'G': -60.0, 'T': -180.0, 'N': 0.0}
+bases = ['A', 'C', 'G', 'T']
 
-# Создаем область для настроек
-with st.sidebar:
-    st.header("Настройки")
-    prompt = st.text_area("Введите ваш запрос:", "hoaxx kitty", height=100)
-    
-    num_inference_steps = st.slider(
-        "Количество шагов инференса:", 
-        min_value=1, 
-        max_value=50, 
-        value=5,
-        help="Больше шагов = выше качество, но медленнее"
-    )
-    
-    guidance_scale = st.slider(
-        "Guidance Scale:", 
-        min_value=1.0, 
-        max_value=15.0, 
-        value=8.0,
-        step=0.5,
-        help="Насколько строго модель следует промпту"
-    )
-    
-    lcm_origin_steps = st.slider(
-        "LCM Origin Steps:", 
-        min_value=1, 
-        max_value=50, 
-        value=35
-    )
-    
-    generate_button = st.button("Сгенерировать изображение")
+# --- Логика ---
+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
 
-# Загружаем модель при первом запуске
-@st.cache_resource
-def load_model():
-    pipe = DiffusionPipeline.from_pretrained(
-        "SimianLuo/LCM_Dreamshaper_v7", 
-        torch_dtype=torch.float32
-    )
-    pipe.to("cpu")
-    pipe.enable_attention_slicing()
-    pipe.safety_checker = None
-    return pipe
+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:]
+        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][::-1]
+            seq = seq[:start] + subseq + seq[end:]
+    while len(seq) < seqlen:
+        seq += random.choice(bases)
+    if len(seq) > seqlen:
+        seq = seq[:seqlen]
+    return seq
 
-# Функция для генерации изображения
-def generate_image(pipe, prompt, steps, guidance, lcm_steps):
-    try:
-        with torch.inference_mode():
-            images = pipe(
-                prompt=prompt, 
-                num_inference_steps=steps, 
-                guidance_scale=guidance, 
-                lcm_origin_steps=lcm_steps, 
-                output_type="pil"
-            ).images
-        return images[0]
-    except Exception as e:
-        st.error(f"Error generating image: {e}")
-        return None
+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
 
-# Загружаем модель
-pipe = load_model()
+def compute_entropy(profile):
+    vals, counts = np.unique(profile, return_counts=True)
+    p = counts / counts.sum()
+    return scipy_entropy(p, base=2)
 
-# Отображаем прогресс и результат
-if generate_button:
-    with st.spinner("Генерация изображения..."):
-        # Создаем место для вывода изображения
-        result_container = st.empty()
-        
-        # Генерируем изображение
-        image = generate_image(
-            pipe, 
-            prompt, 
-            num_inference_steps, 
-            guidance_scale, 
-            lcm_origin_steps
-        )
-        
-        # Показываем результат
-        if image:  # Only display if image generation was successful
-            result_container.image(image, caption=f"Результат для: {prompt}", use_container_width=True)  # Use use_container_width
-            
-            # Предлагаем скачать
-            buf = io.BytesIO()
-            image.save(buf, format="PNG")
-            byte_im = buf.getvalue()
-            
-            st.download_button(
-                label="Скачать изображение",
-                data=byte_im,
-                file_name="generated_image.png",
-                mime="image/png"
-            )
-        
-        gc.collect()  # Garbage collection after image generation
+# --- Streamlit UI ---
+st.title("🧬 Эволюция ДНК-подобной цепи с мутациями")
+steps = st.slider("Число шагов симуляции", 1, 200, 60)
 
-# Инструкции по использованию
-if not generate_button:
-    st.write("👈 Настройте параметры в боковой панели и нажмите 'Сгенерировать изображение'")
+if st.button("▶️ Запустить симуляцию"):
+    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)
+
+    for i in range(steps):
+        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))
+        stat_entropy.append(compute_entropy(torsion_profile))
+        stat_autocorr.append(compute_autocorr(torsion_profile))
+        seq = bio_mutate(seq)
+
+    # Отрисовка последнего состояния
+    axs[0].plot(torsion_profile, color='royalblue', label="Торсионный угол")
+    for start, end, val in runs:
+        axs[0].axvspan(start, end, color="red", alpha=0.3)
+        axs[0].plot(range(start, end+1), torsion_profile[start:end+1], 'ro', markersize=5)
+    axs[0].set_ylim(-200, 200)
+    axs[0].set_title(f"Шаг {steps}: {seq}\nЧисло машин: {len(runs)}, энтропия: {stat_entropy[-1]:.2f}")
+    axs[0].legend()
+
+    axs[1].plot(stat_bist_counts, '-o', color='crimson', markersize=4)
+    axs[1].set_title("Динамика: число 'биомашин'")
+
+    axs[2].bar(np.arange(6), stat_autocorr[-1][:6], color='teal', alpha=0.7)
+    axs[2].set_title("Автокорреляция и энтропия")
+    axs[2].text(0.7, 0.7, f"Энтропия: {stat_entropy[-1]:.2f}", transform=axs[2].transAxes)
+
+    st.pyplot(fig)