Update app.py

app.py

@@ -1,399 +1,120 @@
-import gradio as gr
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import numpy as np
-from PIL import Image
-import imageio
 import os
-import tempfile
+import random
+import json
+from datasets import Dataset
+from huggingface_hub import HfApi
 
-# ============ ИСПРАВЛЕННАЯ ВЕРСИЯ ============
-class FullNeuralAnimator(nn.Module):
-    def __init__(self):
-        super().__init__()
-        
-        # Encoder
-        self.enc1 = self._block(3, 32)
-        self.enc2 = self._block(32, 64)
-        self.enc3 = self._block(64, 128)
-        self.enc4 = self._block(128, 256)
-        self.pool = nn.MaxPool2d(2)
-        
-        # LSTM
-        self.lstm = nn.LSTM(
-            input_size=256 * 8 * 8,
-            hidden_size=512,
-            num_layers=2,
-            batch_first=True,
-            dropout=0.2
-        )
-        
-        # Decoder
-        self.dec4 = self._block(512, 256)
-        self.dec3 = self._block(256, 128)
-        self.dec2 = self._block(128, 64)
-        self.dec1 = self._block(64, 32)
-        
-        self.up4 = nn.ConvTranspose2d(512, 256, 2, stride=2)
-        self.up3 = nn.ConvTranspose2d(256, 128, 2, stride=2)
-        self.up2 = nn.ConvTranspose2d(128, 64, 2, stride=2)
-        self.up1 = nn.ConvTranspose2d(64, 32, 2, stride=2)
-        
-        self.frame_generator = nn.Sequential(
-            nn.Conv2d(32, 16, 3, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(16, 3, 3, padding=1),
-            nn.Tanh()
-        )
-    
-    def _block(self, in_ch, out_ch):
-        return nn.Sequential(
-            nn.Conv2d(in_ch, out_ch, 3, padding=1),
-            nn.BatchNorm2d(out_ch),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(out_ch, out_ch, 3, padding=1),
-            nn.BatchNorm2d(out_ch),
-            nn.ReLU(inplace=True)
-        )
-    
-    def forward(self, x, num_frames=20):
-        batch_size = x.size(0)
-        
-        # Encoder
-        e1 = self.enc1(x)
-        e2 = self.enc2(self.pool(e1))
-        e3 = self.enc3(self.pool(e2))
-        e4 = self.enc4(self.pool(e3))
-        
-        skips = [e1, e2, e3, e4]
-        
-        # Bottleneck
-        bottleneck = e4.view(batch_size, -1)
-        
-        frames = []
-        hidden = None
-        lstm_input = bottleneck.unsqueeze(1)
-        
-        for t in range(num_frames):
-            lstm_out, hidden = self.lstm(lstm_input, hidden)
-            
-            h = lstm_out.squeeze(1).view(batch_size, 256, 8, 8)
-            
-            # Decoder с проверкой размеров
-            d4 = self.up4(h)
-            # Проверяем размеры и при необходимости ресайзим
-            if d4.size(2) != skips[3].size(2) or d4.size(3) != skips[3].size(3):
-                skips[3] = F.interpolate(skips[3], size=(d4.size(2), d4.size(3)), mode='bilinear')
-            d4 = torch.cat([d4, skips[3]], dim=1)
-            d4 = self.dec4(d4)
-            
-            d3 = self.up3(d4)
-            if d3.size(2) != skips[2].size(2) or d3.size(3) != skips[2].size(3):
-                skips[2] = F.interpolate(skips[2], size=(d3.size(2), d3.size(3)), mode='bilinear')
-            d3 = torch.cat([d3, skips[2]], dim=1)
-            d3 = self.dec3(d3)
-            
-            d2 = self.up2(d3)
-            if d2.size(2) != skips[1].size(2) or d2.size(3) != skips[1].size(3):
-                skips[1] = F.interpolate(skips[1], size=(d2.size(2), d2.size(3)), mode='bilinear')
-            d2 = torch.cat([d2, skips[1]], dim=1)
-            d2 = self.dec2(d2)
-            
-            d1 = self.up1(d2)
-            if d1.size(2) != skips[0].size(2) or d1.size(3) != skips[0].size(3):
-                skips[0] = F.interpolate(skips[0], size=(d1.size(2), d1.size(3)), mode='bilinear')
-            d1 = torch.cat([d1, skips[0]], dim=1)
-            d1 = self.dec1(d1)
-            
-            frame = self.frame_generator(d1)
-            frames.append(frame)
-            
-            # Обновляем вход для LSTM
-            next_features = self.enc4(self.pool(self.enc3(self.pool(self.enc2(self.pool(self.enc1(frame)))))))
-            next_features = next_features.view(batch_size, -1)
-            lstm_input = next_features.unsqueeze(1)
-        
-        return torch.stack(frames, dim=1)
+# === ТОКЕН ИЗ СЕКРЕТОВ SPACE ===
+HF_TOKEN = os.getenv("HF_TOKEN")
+USERNAME = "root39058"  # Ваш username
 
-# ============ СТИЛЕВАЯ НЕЙРОСЕТЬ ============
-class StyleTransferAnimator(nn.Module):
-    def __init__(self):
-        super().__init__()
-        
-        self.style_embeddings = nn.ParameterDict({
-            'wave': nn.Parameter(torch.randn(64)),
-            'pulse': nn.Parameter(torch.randn(64)),
-            'glitch': nn.Parameter(torch.randn(64)),
-            'melt': nn.Parameter(torch.randn(64)),
-            'twist': nn.Parameter(torch.randn(64)),
-        })
-        
-        self.encoder = nn.Sequential(
-            nn.Conv2d(3, 32, 4, stride=2, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(32, 64, 4, stride=2, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(64, 128, 4, stride=2, padding=1),
-            nn.ReLU(),
-            nn.Conv2d(128, 256, 4, stride=2, padding=1),
-            nn.ReLU(),
-        )
-        
-        self.lstm = nn.LSTM(
-            input_size=256 * 8 * 8,
-            hidden_size=512,
-            num_layers=2,
-            batch_first=True,
-            dropout=0.2
-        )
-        
-        self.decoder = nn.Sequential(
-            nn.ConvTranspose2d(512 + 64, 256, 4, stride=2, padding=1),
-            nn.ReLU(),
-            nn.ConvTranspose2d(256, 128, 4, stride=2, padding=1),
-            nn.ReLU(),
-            nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1),
-            nn.ReLU(),
-            nn.ConvTranspose2d(64, 3, 4, stride=2, padding=1),
-            nn.Tanh()
-        )
-    
-    def forward(self, x, style='wave', num_frames=20):
-        batch_size = x.size(0)
-        
-        features = self.encoder(x)
-        features_flat = features.view(batch_size, -1)
-        
-        style_vector = self.style_embeddings[style]
-        style_vector = style_vector.unsqueeze(0).repeat(batch_size, 1)
-        
-        frames = []
-        hidden = None
-        lstm_input = features_flat.unsqueeze(1)
-        
-        for t in range(num_frames):
-            lstm_out, hidden = self.lstm(lstm_input, hidden)
-            
-            h = lstm_out.squeeze(1).view(batch_size, 256, 8, 8)
-            style_expanded = style_vector.view(batch_size, 64, 1, 1).repeat(1, 1, 8, 8)
-            decoder_input = torch.cat([h, style_expanded], dim=1)
-            
-            frame = self.decoder(decoder_input)
-            frames.append(frame)
-            
-            next_features = self.encoder(frame)
-            next_features = next_features.view(batch_size, -1)
-            lstm_input = next_features.unsqueeze(1)
-        
-        return torch.stack(frames, dim=1)
+if not HF_TOKEN:
+    raise ValueError("HF_TOKEN не найден! Добавьте секрет в Space")
 
-# ============ НЕЙРОСЕТЕВОЙ АНИМАТОР ============
-class NeuralAnimator:
-    def __init__(self):
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        print(f"🔥 Устройство: {self.device}")
-        
-        self.animator = FullNeuralAnimator().to(self.device)
-        self.styler = StyleTransferAnimator().to(self.device)
-        
-        self.load_models()
-        
-        self.animator.eval()
-        self.styler.eval()
-    
-    def load_models(self):
-        models_dir = 'neural_models'
-        os.makedirs(models_dir, exist_ok=True)
-        
-        if os.path.exists(f'{models_dir}/animator.pth'):
-            self.animator.load_state_dict(torch.load(f'{models_dir}/animator.pth', map_location=self.device))
-            print("✅ Аниматор загружен")
-        else:
-            print("⚠️ Модель не найдена, используем случайную")
-        
-        if os.path.exists(f'{models_dir}/styler.pth'):
-            self.styler.load_state_dict(torch.load(f'{models_dir}/styler.pth', map_location=self.device))
-            print("✅ Стилизатор загружен")
-    
-    def generate_animation(self, image, style='wave', num_frames=20, size=128):
-        if image is None:
-            return None
-        
-        if isinstance(image, np.ndarray):
-            img = Image.fromarray(image)
-        else:
-            img = image
-        
-        img = img.resize((size, size))
-        img_tensor = torch.from_numpy(np.array(img)).float() / 127.5 - 1
-        img_tensor = img_tensor.permute(2, 0, 1).unsqueeze(0).to(self.device)
-        
-        with torch.no_grad():
-            if style in ['wave', 'pulse', 'glitch', 'melt', 'twist']:
-                frames_tensor = self.styler(img_tensor, style=style, num_frames=num_frames)
-            else:
-                frames_tensor = self.animator(img_tensor, num_frames=num_frames)
-        
-        frames = []
-        for t in range(num_frames):
-            frame = frames_tensor[0, t].cpu().numpy().transpose(1, 2, 0)
-            frame = np.clip((frame + 1) / 2, 0, 1)
-            frames.append((frame * 255).astype(np.uint8))
-        
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.gif')
-        imageio.mimsave(temp_file.name, frames, duration=0.05, loop=0)
-        
-        return temp_file.name
+print("🚀 Начинаем генерацию датасета...")
 
-# ============ ОБУЧЕНИЕ ============
-def train_neural_animator():
-    print("🧠 Обучаем нейросеть...")
-    
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    
-    animator = FullNeuralAnimator().to(device)
-    styler = StyleTransferAnimator().to(device)
-    
-    opt_anim = torch.optim.Adam(animator.parameters(), lr=0.0001)
-    opt_style = torch.optim.Adam(styler.parameters(), lr=0.0001)
-    
-    mse = nn.MSELoss()
-    
-    print("🚀 Начинаем обучение...")
-    
-    for epoch in range(5):  # 5 эпох для быстрого теста
-        batch_size = 2
-        fake_images = torch.randn(batch_size, 3, 128, 128, device=device)
-        
-        # Обучаем аниматор
-        frames = animator(fake_images, num_frames=10)
-        loss_smooth = mse(frames[:, 1:], frames[:, :-1])
-        loss_consistency = mse(frames.mean(dim=1), fake_images)
-        loss_anim = loss_smooth + 0.5 * loss_consistency
-        
-        opt_anim.zero_grad()
-        loss_anim.backward()
-        opt_anim.step()
-        
-        # Обучаем стилизатор
-        style_frames = styler(fake_images, style='wave', num_frames=10)
-        loss_style_smooth = mse(style_frames[:, 1:], style_frames[:, :-1])
-        loss_style_consistency = mse(style_frames.mean(dim=1), fake_images)
-        loss_style = loss_style_smooth + 0.5 * loss_style_consistency
-        
-        opt_style.zero_grad()
-        loss_style.backward()
-        opt_style.step()
-        
-        print(f"Epoch {epoch+1}/5 | Loss: {loss_anim.item():.4f} | Style: {loss_style.item():.4f}")
-    
-    os.makedirs('neural_models', exist_ok=True)
-    torch.save(animator.state_dict(), 'neural_models/animator.pth')
-    torch.save(styler.state_dict(), 'neural_models/styler.pth')
-    
-    print("✅ Обучение завершено!")
-    return "✅ Модель обучена!"
+# === СЛОВАРИ ===
+words = {
+    'nouns': [
+        'дом', 'лес', 'вода', 'огонь', 'земля', 'небо', 'ветер', 'дождь', 'снег', 'солнце',
+        'ночь', 'день', 'утро', 'вечер', 'зима', 'весна', 'лето', 'осень', 'город', 'деревня',
+        'машина', 'дорога', 'река', 'гора', 'море', 'океан', 'звезда', 'луна', 'птица', 'рыба',
+        'кот', 'пёс', 'волк', 'лиса', 'медведь', 'заяц', 'слон', 'тигр', 'лев', 'конь',
+        'стол', 'стул', 'кровать', 'окно', 'дверь', 'стена', 'пол', 'потолок', 'лампа', 'книга',
+        'компьютер', 'ноутбук', 'телефон', 'планшет', 'экран', 'клавиатура', 'мышь', 'монитор', 'память', 'процессор'
+    ],
+    'verbs': [
+        'бежит', 'идёт', 'летит', 'плывёт', 'сидит', 'стоит', 'лежит', 'ходит', 'едет', 'смотрит',
+        'видит', 'слышит', 'говорит', 'молчит', 'думает', 'знает', 'спит', 'ест', 'пьёт', 'играет',
+        'работает', 'учится', 'читает', 'пишет', 'рисует', 'поёт', 'танцует', 'гуляет', 'плавает', 'ныряет',
+        'прыгает', 'ползает', 'строит', 'ломает', 'чинит', 'моет', 'убирает', 'готовит', 'варит', 'жарит'
+    ],
+    'adjs': [
+        'большой', 'маленький', 'красивый', 'страшный', 'добрый', 'злой', 'умный', 'глупый',
+        'быстрый', 'медленный', 'высокий', 'низкий', 'широкий', 'узкий', 'длинный', 'короткий',
+        'глубокий', 'мелкий', 'толстый', 'тонкий', 'лёгкий', 'тяжёлый', 'горячий', 'холодный',
+        'тёплый', 'прохладный', 'мокрый', 'сухой', 'чистый', 'грязный', 'светлый', 'тёмный',
+        'яркий', 'тусклый', 'громкий', 'тихий', 'мягкий', 'жёсткий', 'вкусный', 'противный'
+    ],
+    'advs': [
+        'очень', 'сильно', 'немного', 'слегка', 'едва', 'почти', 'вполне', 'совершенно',
+        'абсолютно', 'чрезвычайно', 'крайне', 'слишком', 'чересчур', 'вдруг', 'внезапно',
+        'постепенно', 'медленно', 'быстро', 'тихо', 'громко', 'весело', 'грустно', 'красиво'
+    ],
+    'conj': [
+        'и', 'а', 'но', 'да', 'или', 'либо', 'же', 'вот', 'ещё', 'только',
+        'также', 'зато', 'однако', 'поэтому', 'потому что', 'так как', 'если',
+        'хотя', 'когда', 'пока', 'после', 'перед', 'через', 'около', 'рядом'
+    ]
+}
 
-# ============ GRADIO ИНТЕРФЕЙС ============
-animator = NeuralAnimator()
+# === ГЕНЕРАТОРЫ ===
+def generate_text():
+    noun = random.choice(words['nouns'])
+    adj = random.choice(words['adjs'])
+    verb = random.choice(words['verbs'])
+    adv = random.choice(words['advs']) if random.random() > 0.5 else ''
+    
+    if random.random() > 0.6:
+        conj = random.choice(words['conj'])
+        noun2 = random.choice(words['nouns'])
+        verb2 = random.choice(words['verbs'])
+        text = f"{adj} {noun} {adv} {verb} {conj} {noun2} {verb2}"
+    else:
+        text = f"{adj} {noun} {adv} {verb}"
+    
+    return text.capitalize() + "."
 
-def generate_wrapper(image, style, frames, size):
-    if image is None:
-        return None
-    try:
-        return animator.generate_animation(image, style, int(frames), int(size))
-    except Exception as e:
-        print(f"Ошибка: {e}")
-        return None
+def generate_code():
+    codes = [
+        'def hello():\n    print("Привет, мир!")',
+        'function greet(name) {\n    console.log(`Привет, ${name}`);\n}',
+        '<h1>Заголовок</h1>\n<p>Текст</p>',
+        '.class {\n    color: blue;\n    font-size: 16px;\n}',
+        'SELECT * FROM users WHERE id = 1;',
+        '{"key": "value", "array": [1, 2, 3]}'
+    ]
+    return random.choice(codes)
 
-# Создаём интерфейс
-with gr.Blocks(title="🧠 Нейросетевая анимация") as demo:
-    gr.Markdown("""
-    # 🧠 ПОЛНОСТЬЮ НЕЙРОСЕТЕВАЯ АНИМАЦИЯ
-    
-    Нейросеть делает ВСЁ: анализ, предсказание движения, генерацию кадров!
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_image = gr.Image(
-                label="📸 Загрузи фото",
-                type="numpy",
-                height=300
-            )
-            
-            style = gr.Dropdown(
-                choices=[
-                    ("Волна 🌊", "wave"),
-                    ("Пульс 💓", "pulse"),
-                    ("Глитч 📺", "glitch"),
-                    ("Плавление 🕯️", "melt"),
-                    ("Скручивание 🌀", "twist"),
-                    ("Нейросетевой 🧠", "neural")
-                ],
-                label="🎨 Стиль анимации",
-                value="wave"
-            )
-            
-            frames = gr.Slider(
-                minimum=10,
-                maximum=30,
-                value=20,
-                step=5,
-                label="Количество кадров"
-            )
-            
-            size = gr.Slider(
-                minimum=64,
-                maximum=256,
-                value=128,
-                step=64,
-                label="Размер (чем меньше, тем быстрее)"
-            )
-            
-            with gr.Row():
-                generate_btn = gr.Button("🧠 Запустить!", variant="primary")
-                train_btn = gr.Button("🎓 Обучить", variant="secondary")
-            
-            status = gr.Textbox(label="Статус", value="Готов к работе")
-        
-        with gr.Column(scale=1):
-            output_gif = gr.Image(
-                label="🎬 Результат",
-                type="filepath",
-                height=400
-            )
-            
-            download_btn = gr.DownloadButton(
-                label="📥 Скачать GIF",
-                variant="primary"
-            )
+# === ГЕНЕРАЦИЯ ДАТАСЕТА ===
+print("📊 Генерация...")
+
+data = []
+target_size = 100 * 1024 * 1024  # 100 МБ
+current_size = 0
+
+while current_size < target_size:
+    if random.random() > 0.2:
+        text = generate_text()
+    else:
+        text = generate_code()
     
-    generate_btn.click(
-        fn=generate_wrapper,
-        inputs=[input_image, style, frames, size],
-        outputs=[output_gif]
-    ).then(
-        fn=lambda gif: gif if gif else None,
-        inputs=[output_gif],
-        outputs=[download_btn]
-    )
+    data.append({"text": text})
+    current_size = len(json.dumps(data, ensure_ascii=False).encode('utf-8'))
     
-    train_btn.click(
-        fn=train_neural_animator,
-        inputs=[],
-        outputs=[status]
-    )
+    if len(data) % 1000 == 0:
+        print(f"Готово {len(data)} записей, {current_size // 1024 // 1024} МБ")
 
-if __name__ == "__main__":
-    print("""
-    🧠 ЗАПУСКАЕМ НЕЙРОСЕТЕВУЮ АНИМАЦИЮ!
-    📱 Открой браузер: http://localhost:7860
-    """)
-    
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+print(f"✅ Сгенерировано {len(data)} записей, {current_size // 1024 // 1024} МБ")
+
+# === СОЗДАНИЕ DATASET ===
+dataset = Dataset.from_list(data)
+
+# === СОХРАНЕНИЕ ЛОКАЛЬНО ===
+os.makedirs("/data", exist_ok=True)
+dataset.save_to_disk("/data/my_russian_dataset")
+print("✅ Сохранено в /data")
+
+# === ПУШ НА HF ===
+print("☁️ Загрузка на Hugging Face...")
+
+try:
+    dataset.push_to_hub(
+        f"{USERNAME}/Miniset",
+        token=HF_TOKEN,
+        private=False,
+        commit_message="Датасет сгенерирован через Space"
+    )
+    print(f"\n✅ ГОТОВО! https://huggingface.co/datasets/{USERNAME}/russian-dataset-100mb")
+except Exception as e:
+    print(f"❌ Ошибка: {e}")