Update app.py

app.py

@@ -1,245 +1,483 @@
-# ============================================================================
-# ЭТАП 2: ПОЛНЫЙ ПЕРЕНОС ТОКЕНИЗАТОРА (ВСЕ 32000 ТОКЕНОВ)
-# ============================================================================
-import torch
-import torch.nn.functional as F
-from transformers import AutoTokenizer
-from safetensors.torch import load_file, save_file
-from huggingface_hub import hf_hub_download, HfApi
-from tqdm import tqdm
-import json
-import os
-import sys
-
-sys.path.append('.')
-from bdh import BDH, BDHConfig
+import gradio as gr
+import random
+from typing import List, Set, Tuple, Optional
+from dataclasses import dataclass
+import time
+
+# ========== КОНФИГУРАЦИЯ ==========
+@dataclass
+class Config:
+    num_neurons: int = 1000
+    depth: int = 3
+    input_size: int = 256
+    output_size: int = 256
+    spike_threshold: int = 1000
+    input_signal_strength: int = 1000
+    signal_scale_shift: int = 8
+    explore_noise_scale: int = 64
+    sparsity: float = 0.05
+    neighbor_radius: int = 10
+    hebbian_step_threshold: int = 10
+    sigma_decay_shift: int = 8
+    dopamine_decay: int = 9
+    homeostasis_interval_steps: int = 100
+    prune_interval_steps: int = 200
+    min_neurons: int = 100
+    target_activity: int = 100
+
+# ========== НЕЙРОНЫ ==========
+class Neuron:
+    def __init__(self, idx: int, threshold: int = 1000, noise_scale: int = 0):
+        self.idx = idx
+        self.potential = 0
+        self.threshold = threshold
+        self.fired = False
+        self.refractory = 0
+        self.neuron_sigma = 0
+        self.noise_scale = noise_scale
+        self.noise_accum = (idx * 1103515245 + 12345) & 0x7FFFFFFF
+        self.outgoing_synapses = []
+        self.outgoing_neurons = []
+        self.total_fires = 0
+        self.neuron_type = "basic"
+        
+    def tick(self, step_count: int) -> Tuple[bool, int]:
+        if self.refractory > 0:
+            self.refractory -= 1
+            return False, 0
+        if self.potential >= self.threshold:
+            self.fired = True
+            output = self.potential
+            self.refractory = 2
+            self.neuron_sigma += 1
+            self.total_fires += 1
+            return True, output
+        self.fired = False
+        return False, 0
+    
+    def integrate(self, signal: int):
+        if self.refractory == 0:
+            self.potential += signal
+    
+    def fire_ternary(self) -> int:
+        if self.fired:
+            if self.potential >= self.threshold + (self.threshold >> 2):
+                return 1
+            elif self.potential <= self.threshold - (self.threshold >> 2):
+                return -1
+        return 0
+    
+    def propagate(self, shift: int) -> List[Tuple[int, int]]:
+        if not self.fired:
+            return []
+        ternary = self.fire_ternary()
+        if ternary == 0:
+            self.potential = 0
+            return []
+        updates = []
+        for tgt, syn in zip(self.outgoing_neurons, self.outgoing_synapses):
+            signal = ternary * syn.weight
+            if signal != 0:
+                updates.append((tgt, signal << shift))
+        self.potential = 0
+        return updates
+    
+    def get_logit_with_noise(self) -> int:
+        self.noise_accum = (self.noise_accum * 1103515245 + 12345) & 0x7FFFFFFF
+        if self.noise_scale == 0:
+            return self.potential
+        noise = (self.noise_accum % (self.noise_scale * 2 + 1)) - self.noise_scale
+        return self.potential + noise
+    
+    def is_protected(self) -> bool:
+        return False
+
+class ExcitatoryNeuron(Neuron):
+    def __init__(self, idx: int, threshold: int = 1000):
+        super().__init__(idx, threshold)
+        self.neuron_type = "excitatory"
+    def fire_ternary(self) -> int:
+        return 1 if self.fired else 0
+
+class InhibitoryNeuron(Neuron):
+    def __init__(self, idx: int, threshold: int = 1000):
+        super().__init__(idx, threshold)
+        self.neuron_type = "inhibitory"
+    def fire_ternary(self) -> int:
+        return -1 if self.fired else 0
+
+class OscillatorNeuron(Neuron):
+    def __init__(self, idx: int, period_steps: int, threshold: int = 1000):
+        super().__init__(idx, threshold)
+        self.neuron_type = "oscillator"
+        self.period_steps = period_steps
+        self.step_counter = 0
+    def tick(self, step_count: int) -> Tuple[bool, int]:
+        self.step_counter += 1
+        if self.step_counter >= self.period_steps:
+            self.step_counter = 0
+            self.fired = True
+            return True, self.threshold
+        return False, 0
+    def is_protected(self) -> bool:
+        return True
+
+class CategoryDetectorNeuron(Neuron):
+    def __init__(self, idx: int, category_bytes: List[int], threshold: int = 1000):
+        super().__init__(idx, threshold)
+        self.neuron_type = "category_detector"
+        self.category_bytes = set(category_bytes)
+    def integrate(self, signal: int, input_byte: Optional[int] = None):
+        if input_byte is not None and input_byte in self.category_bytes:
+            super().integrate(signal)
+    def is_protected(self) -> bool:
+        return True
+
+# ========== СИНАПС ==========
+class Synapse:
+    def __init__(self, source: int, target: int, weight: int = 0):
+        self.source = source
+        self.target = target
+        self.weight = weight
+        self.G = 0
+        self.sigma = 0
+        self.bcm_theta = 512
+    
+    def hebbian_update(self, pre_fired: bool, post_fired: bool, 
+                       post_potential: int, dopamine_gain: int = 512):
+        if pre_fired and post_fired:
+            self.sigma += dopamine_gain
+            if abs(self.sigma) >= 10:
+                delta = 1 if self.sigma > 0 else -1
+                self.G = max(-1, min(1, self.G + delta))
+                self.sigma = 0
+        else:
+            self.sigma = (self.sigma * 255) >> 8
+    
+    def homeostasis(self, target_activity: int = 100):
+        current = abs(self.weight) * 100
+        if current > target_activity:
+            scale = (target_activity << 8) // current
+            self.weight = (self.weight * scale) >> 8
+
+# ========== ГРАФ ==========
+class Graph:
+    def __init__(self, config: Config):
+        self.config = config
+        self._n = config.num_neurons
+        self.synapses: List[Synapse] = []
+        self._incoming_count = [0] * self._n
+        self._build()
+    
+    def _build(self):
+        for i in range(self._n):
+            for j in range(max(0, i - self.config.neighbor_radius),
+                          min(self._n, i + self.config.neighbor_radius + 1)):
+                if i != j and random.random() < self.config.sparsity:
+                    self.synapses.append(Synapse(i, j))
+        self._update_incoming_counts()
+    
+    def _update_incoming_counts(self):
+        self._incoming_count = [0] * self._n
+        for syn in self.synapses:
+            self._incoming_count[syn.target] += 1
+    
+    def get_incoming_count(self, idx: int) -> int:
+        return self._incoming_count[idx] if idx < len(self._incoming_count) else 0
+    
+    def get_outgoing_count(self, idx: int) -> int:
+        return sum(1 for s in self.synapses if s.source == idx)
+    
+    def get_all_synapses(self) -> List[Synapse]:
+        return self.synapses
+    
+    def remove_neuron(self, idx: int):
+        self.synapses = [s for s in self.synapses if s.source != idx and s.target != idx]
+        self._update_incoming_counts()
+    
+    @property
+    def n(self) -> int:
+        return self._n
+    
+    @property
+    def num_edges(self) -> int:
+        return len(self.synapses)
 
+# ========== ПЛАСТИЧНОСТЬ ==========
 class Plasticity:
-    def __init__(self, n_neurons):
-        self.n_neurons = n_neurons
-        self.w = torch.zeros(n_neurons, n_neurons)
-        self.long_term_w = torch.zeros(n_neurons, n_neurons)
-        self.lr = 0.01
-        self.consolidation_rate = 0.01
-        self.forget_rate = 0.1
-        self.acc_pre = torch.zeros(n_neurons)
-        self.acc_post = torch.zeros(n_neurons)
-        self.threshold = 0.5
+    def __init__(self, graph: Graph, config: Config):
+        self.graph = graph
+        self.config = config
+    
+    def hebbian_update(self, active_neurons: Set[int], potentials: List[int],
+                       dopamine_gain: int = 512):
+        for src in active_neurons:
+            for syn in self.graph.synapses:
+                if syn.source == src:
+                    post_active = syn.target in active_neurons
+                    post_pot = potentials[syn.target] if post_active else 0
+                    syn.hebbian_update(True, post_active, post_pot, dopamine_gain)
+    
+    def homeostasis_all(self):
+        for syn in self.graph.synapses:
+            syn.homeostasis(self.config.target_activity)
+
+# ========== ЯДРО AURA ==========
+class AuraCore:
+    def __init__(self, config: Config):
+        self.config = config
+        self.graph = Graph(config)
+        self.plasticity = Plasticity(self.graph, config)
+        self.neurons: List[Neuron] = []
+        self._init_neurons()
+        self._init_category_detectors()
+        self._init_oscillators()
+        self._build_caches()
+        
+        self.input_neurons = list(range(min(config.input_size, len(self.neurons))))
+        self.output_neurons = list(range(min(config.output_size, len(self.neurons))))
+        
         self.step_count = 0
+        self.active_neurons: Set[int] = set()
+        self.dopamine_trace = 0
+        self.dopamine_gain = 512
+        self.homeostasis_osc = self.neurons[-2]
+        self.prune_osc = self.neurons[-1]
     
-    def adapt_weights(self, weight_matrix):
-        if weight_matrix.dim() == 3:
-            wm_2d = weight_matrix.reshape(-1, weight_matrix.shape[-1])
-        else:
-            wm_2d = weight_matrix
+    def _init_neurons(self):
+        n = self.config.num_neurons
+        n_exc = int(n * 0.70)
+        n_inh = int(n * 0.15)
+        idx = 0
+        for _ in range(n_exc):
+            self.neurons.append(ExcitatoryNeuron(idx, self.config.spike_threshold))
+            idx += 1
+        for _ in range(n_inh):
+            self.neurons.append(InhibitoryNeuron(idx, self.config.spike_threshold))
+            idx += 1
+        while idx < n:
+            self.neurons.append(Neuron(idx, self.config.spike_threshold))
+            idx += 1
+    
+    def _init_category_detectors(self):
+        self.neurons.append(CategoryDetectorNeuron(
+            len(self.neurons), list(range(48, 58)), self.config.spike_threshold
+        ))
+        self.neurons.append(CategoryDetectorNeuron(
+            len(self.neurons), list(range(65, 91)), self.config.spike_threshold
+        ))
+        self.neurons.append(CategoryDetectorNeuron(
+            len(self.neurons), list(range(97, 123)), self.config.spike_threshold
+        ))
+        self.neurons.append(CategoryDetectorNeuron(
+            len(self.neurons), [9, 10, 32], self.config.spike_threshold
+        ))
+    
+    def _init_oscillators(self):
+        self.neurons.append(OscillatorNeuron(
+            len(self.neurons), self.config.homeostasis_interval_steps, self.config.spike_threshold
+        ))
+        self.neurons.append(OscillatorNeuron(
+            len(self.neurons), self.config.prune_interval_steps, self.config.spike_threshold
+        ))
+    
+    def _build_caches(self):
+        for n in self.neurons:
+            n.outgoing_synapses = []
+            n.outgoing_neurons = []
+        for syn in self.graph.synapses:
+            if syn.source < len(self.neurons):
+                self.neurons[syn.source].outgoing_synapses.append(syn)
+                self.neurons[syn.source].outgoing_neurons.append(syn.target)
+    
+    def forward(self, input_byte: int, reward: int = 0, explore: bool = True) -> int:
+        self.dopamine_trace = (self.dopamine_trace * self.config.dopamine_decay + reward * 10) // 10
+        self.dopamine_trace = max(0, min(1024, self.dopamine_trace))
+        self.dopamine_gain = 512 + self.dopamine_trace
         
-        a_pre = wm_2d.mean(dim=1)[:self.n_neurons]
-        a_post = wm_2d.mean(dim=0)[:self.n_neurons]
+        if self.homeostasis_osc.tick(self.step_count)[0]:
+            self.plasticity.homeostasis_all()
+        if self.prune_osc.tick(self.step_count)[0]:
+            self._prune_isolated()
         
-        if a_pre.shape[0] < self.n_neurons:
-            a_pre = torch.cat([a_pre, torch.zeros(self.n_neurons - a_pre.shape[0])])
-        if a_post.shape[0] < self.n_neurons:
-            a_post = torch.cat([a_post, torch.zeros(self.n_neurons - a_post.shape[0])])
+        input_idx = self.input_neurons[input_byte % len(self.input_neurons)]
+        input_neuron = self.neurons[input_idx]
         
-        self.acc_pre += a_pre
-        self.acc_post += a_post
+        if isinstance(input_neuron, CategoryDetectorNeuron):
+            input_neuron.integrate(self.config.input_signal_strength, input_byte=input_byte)
+        else:
+            input_neuron.integrate(self.config.input_signal_strength)
         
-        spike_pre = (self.acc_pre >= self.threshold).float()
-        spike_post = (self.acc_post >= self.threshold).float()
+        self.active_neurons.clear()
         
-        self.acc_pre -= spike_pre * self.threshold
-        self.acc_post -= spike_post * self.threshold
+        for _ in range(self.config.depth):
+            fired_this_step = []
+            for i, n in enumerate(self.neurons):
+                if n.tick(self.step_count)[0]:
+                    fired_this_step.append(n)
+                    self.active_neurons.add(i)
+            for src in fired_this_step:
+                updates = src.propagate(self.config.signal_scale_shift)
+                for tgt, signal in updates:
+                    if tgt < len(self.neurons):
+                        self.neurons[tgt].integrate(signal)
         
-        delta = self.lr * torch.outer(spike_pre, spike_post)
-        self.w += delta
+        potentials = [n.potential for n in self.neurons]
+        self.plasticity.hebbian_update(self.active_neurons, potentials, self.dopamine_gain)
         
-        update = self.w[:wm_2d.shape[0], :wm_2d.shape[1]] * 0.01
-        if weight_matrix.dim() == 3:
-            update = update.reshape(weight_matrix.shape)
+        logits = [0] * self.config.output_size
+        for byte in range(self.config.output_size):
+            idx = self.output_neurons[byte]
+            if idx < len(self.neurons):
+                logits[byte] = self.neurons[idx].get_logit_with_noise() if explore else self.neurons[idx].potential
         
+        next_byte = max(range(self.config.output_size), key=lambda i: logits[i])
         self.step_count += 1
-        if self.step_count % 10 == 0:
-            self.consolidate()
-        
-        return weight_matrix + update
+        return next_byte
     
-    def consolidate(self):
-        self.long_term_w += self.consolidation_rate * self.w
-        self.w = self.w * (1 - self.forget_rate)
-
-print("=" * 70)
-print("🧠 ЭТАП 2: ПОЛНЫЙ ПЕРЕНОС ТОКЕНИЗАТОРА (ВСЕ 32000 ТОКЕНОВ)")
-print("=" * 70)
-
-device = "cpu"
-
-# -----------------------------------------------------------------------------
-# 1. ЗАГРУЖАЕМ AURA ТОКЕНИЗАТОР
-# -----------------------------------------------------------------------------
-print("\n📥 Загрузка токенизатора Aura...")
-aura_tokenizer = AutoTokenizer.from_pretrained("ResplendentAI/Aura_v3_7B")
-vocab = aura_tokenizer.get_vocab()
-vocab_size = len(vocab)
-print(f"✅ Словарь загружен: {vocab_size} токенов")
-
-# -----------------------------------------------------------------------------
-# 2. ЗАГРУЖАЕМ ЭМБЕДДИНГИ AURA
-# -----------------------------------------------------------------------------
-print("\n📥 Загрузка эмбеддингов Aura...")
-
-repo_id = "ResplendentAI/Aura_v3_7B"
-index_path = hf_hub_download(repo_id=repo_id, filename="model.safetensors.index.json")
-with open(index_path, 'r') as f:
-    weight_map = json.load(f)['weight_map']
-
-embed_shard = None
-for name, shard in weight_map.items():
-    if 'embed_tokens' in name:
-        embed_shard = shard
-        break
-
-shard_path = hf_hub_download(repo_id=repo_id, filename=embed_shard)
-shard = load_file(shard_path)
-embeddings = None
-for name, tensor in shard.items():
-    if 'embed_tokens' in name:
-        embeddings = tensor.float()
-        break
-
-print(f"✅ Эмбеддинги загружены: {embeddings.shape}")
-
-# -----------------------------------------------------------------------------
-# 3. ЗАГРУЖАЕМ BDH
-# -----------------------------------------------------------------------------
-print("\n📥 Загрузка BDH...")
-
-config_path = hf_hub_download(
-    repo_id="Andrewstivan/AURA",
-    filename="bdh_plasticity/bdh_config.json",
-    repo_type="model"
-)
-with open(config_path, 'r') as f:
-    config_dict = json.load(f)
-
-# Убираем лишние поля
-config_dict.pop('model_type', None)
-
-config_dict['use_plasticity'] = True
-config = BDHConfig(**config_dict)
-bdh_model = BDH(config).to(device)
-
-weights_path = hf_hub_download(
-    repo_id="Andrewstivan/AURA",
-    filename="bdh_plasticity/bdh_plasticity.safetensors",
-    repo_type="model"
-)
-weights = load_file(weights_path)
-
-with torch.no_grad():
-    bdh_model.encoder.weight_fp32.data = weights['encoder'].to(device)
-    bdh_model.encoder_v.weight_fp32.data = weights['encoder_v'].to(device)
-    bdh_model.decoder.weight_fp32.data = weights['decoder'].to(device)
-    
-    bdh_model.encoder.update_ternary_weights()
-    bdh_model.encoder_v.update_ternary_weights()
-    bdh_model.decoder.update_ternary_weights()
-
-print("✅ BDH загружена")
-
-# -----------------------------------------------------------------------------
-# 4. ПОЛНЫЙ ПЕРЕНОС ТОКЕНИЗАТОРА (ВСЕ 32000)
-# -----------------------------------------------------------------------------
-print("\n🔄 Полный перенос токенизатора (все 32000 токенов)...")
-
-plasticity_embed = Plasticity(n_neurons=4096)
-
-# БЕРЁМ ВСЕ ТОКЕНЫ!
-for token_str, token_id in tqdm(vocab.items(), desc="Перенос токенов", total=vocab_size):
-    token_bytes = token_str.encode('utf-8')
-    byte_tensor = torch.tensor(list(token_bytes), dtype=torch.long).unsqueeze(0).to(device)
+    def _prune_isolated(self):
+        if self.graph.n <= self.config.min_neurons:
+            return
+        dead = []
+        for i, n in enumerate(self.neurons):
+            if i < self.config.input_size or n.is_protected():
+                continue
+            if self.graph.get_incoming_count(i) == 0 and self.graph.get_outgoing_count(i) == 0:
+                dead.append(i)
+        if dead and self.graph.n - len(dead) >= self.config.min_neurons:
+            for idx in sorted(dead, reverse=True):
+                self.graph.remove_neuron(idx)
+                del self.neurons[idx]
+            self._build_caches()
+
+# ========== ИНИЦИАЛИЗАЦИЯ МОДЕЛИ ==========
+print("🚀 Инициализация AURA...")
+config = Config()
+config.num_neurons = 800
+config.depth = 3
+core = AuraCore(config)
+print(f"✅ Модель готова: {len(core.neurons)} нейронов, {core.graph.num_edges} синапсов")
+
+# ========== ФУНКЦИИ ДЛЯ GRADIO ==========
+def generate_text(prompt: str, steps: int = 100, temperature: float = 1.0, reward: int = 0) -> str:
+    """Генерация текста из промпта."""
+    if not prompt:
+        prompt = "A"
     
-    target_embedding = embeddings[token_id].to(device)
+    # Устанавливаем шум в зависимости от температуры
+    core.config.explore_noise_scale = int(64 * temperature)
     
-    with torch.no_grad():
-        bdh_embedding = bdh_model.embed(byte_tensor).mean(dim=1).squeeze(0)
+    start_time = time.time()
     
-    bdh_embedding = plasticity_embed.adapt_weights(
-        bdh_embedding.unsqueeze(0).unsqueeze(0)
-    )
-
-plasticity_embed.consolidate()
-print("✅ Знания токенизатора перенесены (ВСЕ 32000)")
-
-# -----------------------------------------------------------------------------
-# 5. ПОЛНЫЙ ПЕРЕНОС lm_head (ВСЕ 32000)
-# -----------------------------------------------------------------------------
-print("\n🔄 Полный перенос lm_head (все 32000)...")
-
-lm_head_aura = None
-for shard_file in set(weight_map.values()):
-    shard_path = hf_hub_download(repo_id=repo_id, filename=shard_file)
-    shard = load_file(shard_path)
-    for name, tensor in shard.items():
-        if 'lm_head' in name:
-            lm_head_aura = tensor.float()
-            break
-    if lm_head_aura is not None:
-        break
-
-print(f"✅ lm_head Aura загружен: {lm_head_aura.shape}")
-
-plasticity_lm = Plasticity(n_neurons=4096)
-
-# БЕРЁМ ВСЕ ТОКЕНЫ!
-for token_id in tqdm(range(vocab_size), desc="Перенос lm_head", total=vocab_size):
-    target = lm_head_aura[token_id].to(device)
+    # Подаём промпт
+    for ch in prompt:
+        core.forward(ord(ch), reward=reward, explore=True)
     
-    with torch.no_grad():
-        bdh_output = bdh_model.lm_head.weight_fp32.data[token_id]
+    # Генерируем
+    result = list(prompt)
+    current = ord(prompt[-1])
     
-    bdh_output = plasticity_lm.adapt_weights(bdh_output.unsqueeze(0).unsqueeze(0))
-
-plasticity_lm.consolidate()
-print("✅ lm_head перенесён (ВСЕ 32000)")
-
-# -----------------------------------------------------------------------------
-# 6. СОХРАНЕНИЕ ПОЛНОЙ МОДЕЛИ
-# -----------------------------------------------------------------------------
-print("\n💾 Сохранение полной модели...")
-
-os.makedirs("bdh_full_model", exist_ok=True)
-
-full_weights = {
-    'encoder': bdh_model.encoder.weight_ternary.cpu(),
-    'encoder_v': bdh_model.encoder_v.weight_ternary.cpu(),
-    'decoder': bdh_model.decoder.weight_ternary.cpu(),
-    'embed': bdh_model.embed.weight.cpu(),
-    'lm_head': bdh_model.lm_head.weight_fp32.data.cpu(),
-}
-
-save_file(full_weights, "bdh_full_model/bdh_full.safetensors")
-
-with open("bdh_full_model/config.json", "w") as f:
-    json.dump(config_dict, f, indent=2)
-
-print("✅ Полная модель сохранена")
-
-# -----------------------------------------------------------------------------
-# 7. ЗАГРУЗКА НА HUB
-# -----------------------------------------------------------------------------
-token = os.environ.get('HF_TOKEN')
-if token:
-    api = HfApi(token=token)
-    api.upload_folder(
-        folder_path="bdh_full_model",
-        repo_id="Andrewstivan/AURA",
-        repo_type="model",
-        path_in_repo="bdh_full",
-        commit_message="🧠 ПОЛНАЯ BDH: веса + токенизатор (32000) + lm_head (32000)"
+    for _ in range(steps):
+        current = core.forward(current, reward=reward, explore=True)
+        if 32 <= current <= 126 or current in (9, 10, 13):
+            result.append(chr(current))
+        elif current == 0:
+            result.append(' ')
+        else:
+            result.append(chr(32 + (current % 95)))
+    
+    elapsed = time.time() - start_time
+    
+    stats = f"""
+    ⏱️ Время: {elapsed:.2f} сек
+    📊 Шагов: {steps}
+    🔥 Активных нейронов: {len(core.active_neurons)}
+    💪 Дофамин: {core.dopamine_trace}
+    """
+    
+    return ''.join(result), stats
+
+def reset_model():
+    """Сброс модели."""
+    global core
+    core = AuraCore(config)
+    return "✅ Модель сброшена"
+
+# ========== ИНТЕРФЕЙС GRADIO ==========
+with gr.Blocks(title="AURA — Спайковая нейросеть", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧠 AURA — Спайковая нейросеть с Hebbian-обучением
+    
+    Минимальная версия ядра AURA. Модель обучается на лету через локальную пластичность.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            prompt_input = gr.Textbox(
+                label="📝 Промпт",
+                placeholder="Введите текст для генерации...",
+                value="Hello",
+                lines=2
+            )
+            
+            with gr.Row():
+                steps_slider = gr.Slider(
+                    label="📏 Длина генерации",
+                    minimum=10,
+                    maximum=500,
+                    value=100,
+                    step=10
+                )
+                temp_slider = gr.Slider(
+                    label="🌡️ Temperature (креативность)",
+                    minimum=0.1,
+                    maximum=2.0,
+                    value=1.0,
+                    step=0.1
+                )
+            
+            reward_slider = gr.Slider(
+                label="🏆 Reward (награда за шаг)",
+                minimum=0,
+                maximum=100,
+                value=0,
+                step=10
+            )
+            
+            generate_btn = gr.Button("🚀 Сгенерировать", variant="primary", size="lg")
+            reset_btn = gr.Button("🔄 Сбросить модель", variant="secondary")
+        
+        with gr.Column(scale=3):
+            output_text = gr.Textbox(
+                label="✨ Сгенерированный текст",
+                lines=10,
+                max_lines=20
+            )
+            stats_text = gr.Textbox(
+                label="📊 Статистика",
+                lines=5
+            )
+    
+    generate_btn.click(
+        fn=generate_text,
+        inputs=[prompt_input, steps_slider, temp_slider, reward_slider],
+        outputs=[output_text, stats_text]
     )
-    print("✅ Загружено в Andrewstivan/AURA/bdh_full/")
-
-print("\n🎉 ПОЛНЫЙ ПЕРЕНОС ЗАВЕРШЁН!")
-print("   - Веса модели: 32 слоя ✅")
-print("   - Токенизатор: 32000 токенов ✅")
-print("   - lm_head: 32000 токенов ✅")
+    
+    reset_btn.click(
+        fn=reset_model,
+        inputs=[],
+        outputs=[output_text]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### О модели
+    - **Архитектура**: Спайковая нейросеть на разреженном графе
+    - **Обучение**: Hebbian-пластичность (локальные правила)
+    - **Нейронов**: 800 (70% excitatory, 15% inhibitory)
+    - **Категориальные детекторы**: цифры, буквы, пробелы
+    """)
+
+if __name__ == "__main__":
+    demo.launch()