Update app.py

app.py

@@ -1,329 +1,419 @@
-import gradio as gr
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
 import requests
 import re
-import xml.etree.ElementTree as ET
+import json
+import os
+from collections import Counter
+from typing import List, Tuple, Dict
 import random
-from datetime import datetime
-from collections import defaultdict, Counter
+import math
+from datasets import load_dataset
+from transformers import AutoTokenizer
+import gradio as gr
 
-class SimpleQAAI:
-    def __init__(self):
-        self.knowledge_base = defaultdict(list)
-        self.qa_patterns = {}
-        self.vocabulary = set()
-        self.total_tokens = 0
-        self.is_trained = False
-        
-        # Initialize with basic Q&A patterns
-        self.initialize_basic_knowledge()
-        
-    def initialize_basic_knowledge(self):
-        """Initialize with basic Q&A knowledge"""
-        basic_qa = {
-            "what is artificial intelligence": "Artificial intelligence is a technology that enables machines to perform tasks that typically require human intelligence, such as learning, reasoning, and problem-solving.",
-            "how do computers work": "Computers work by processing data through electronic circuits, following programmed instructions to perform calculations and operations.",
-            "where is paris": "Paris is located in France and serves as the capital city of the country.",
-            "why is education important": "Education is important because it develops knowledge, critical thinking skills, and prepares people for careers and civic participation.",
-            "what is machine learning": "Machine learning is a subset of artificial intelligence that allows systems to automatically learn and improve from data without being explicitly programmed.",
-            "how does the internet work": "The internet works through a global network of interconnected computers that communicate using standardized protocols to share information.",
-            "what is climate change": "Climate change refers to long-term shifts in global weather patterns and temperatures, largely attributed to human activities.",
-            "why renewable energy": "Renewable energy is important because it provides sustainable power sources that don't deplete natural resources and help reduce environmental impact."
-        }
-        
-        for question, answer in basic_qa.items():
-            self.qa_patterns[question] = answer
-            words = question.split() + answer.split()
-            self.vocabulary.update(words)
-        
-        self.total_tokens = sum(len(answer.split()) for answer in basic_qa.values())
-        print(f"🧠 Initialized with {len(basic_qa)} Q&A patterns")
+class SelfOrganizingTokenizer:
+    def __init__(self, vocab_size=30000):
+        self.vocab_size = vocab_size
+        self.token_to_id = {'<PAD>': 0, '<UNK>': 1, '<BOS>': 2, '<EOS>': 3}
+        self.id_to_token = {0: '<PAD>', 1: '<UNK>', 2: '<BOS>', 3: '<EOS>'}
+        self.word_freq = Counter()
+        
+    def build_vocab(self, texts):
+        for text in texts:
+            words = re.findall(r'\w+|[^\w\s]', text.lower())
+            self.word_freq.update(words)
+        
+        most_common = self.word_freq.most_common(self.vocab_size - 4)
+        for i, (word, _) in enumerate(most_common):
+            idx = i + 4
+            self.token_to_id[word] = idx
+            self.id_to_token[idx] = word
     
-    def collect_training_data(self):
-        """Collect training data from public sources"""
-        print("🕷️ Collecting training data...")
+    def encode(self, text):
+        words = re.findall(r'\w+|[^\w\s]', text.lower())
+        return [self.token_to_id.get(word, 1) for word in words]
+    
+    def decode(self, ids):
+        return ' '.join([self.id_to_token.get(id, '<UNK>') for id in ids])
+
+class SelfOrganizingAttention(nn.Module):
+    def __init__(self, embed_dim, num_heads):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
         
-        collected_data = []
+        self.qkv = nn.Linear(embed_dim, embed_dim * 3)
+        self.proj = nn.Linear(embed_dim, embed_dim)
+        self.adaptation_layer = nn.Linear(embed_dim, embed_dim)
         
-        # Try to collect from news sources
-        news_data = self.fetch_news_data()
-        collected_data.extend(news_data)
+    def forward(self, x):
+        B, T, C = x.shape
+        qkv = self.qkv(x).reshape(B, T, 3, self.num_heads, self.head_dim)
+        q, k, v = qkv.permute(2, 0, 3, 1, 4)
         
-        # Process collected data
-        if collected_data:
-            self.process_collected_data(collected_data)
-            self.is_trained = True
-            return f"✅ Training completed! Collected {len(collected_data)} articles and {self.total_tokens} total tokens."
-        else:
-            # Use fallback training
-            self.is_trained = True
-            return "�� Training completed using built-in knowledge patterns!"
+        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
+        att = torch.softmax(att, dim=-1)
+        
+        y = att @ v
+        y = y.transpose(1, 2).reshape(B, T, C)
+        y = self.proj(y)
+        
+        # Auto-organizzazione
+        adaptation = torch.tanh(self.adaptation_layer(x))
+        y = y * (1 + 0.1 * adaptation)
+        
+        return y
+
+class SelfOrganizingTransformer(nn.Module):
+    def __init__(self, vocab_size, embed_dim=512, num_heads=8, num_layers=6, max_len=1024):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.tok_embed = nn.Embedding(vocab_size, embed_dim)
+        self.pos_embed = nn.Embedding(max_len, embed_dim)
+        
+        self.layers = nn.ModuleList([
+            nn.ModuleDict({
+                'attn': SelfOrganizingAttention(embed_dim, num_heads),
+                'norm1': nn.LayerNorm(embed_dim),
+                'mlp': nn.Sequential(
+                    nn.Linear(embed_dim, 4 * embed_dim),
+                    nn.GELU(),
+                    nn.Linear(4 * embed_dim, embed_dim),
+                ),
+                'norm2': nn.LayerNorm(embed_dim),
+                'adaptation': nn.Linear(embed_dim, embed_dim)
+            }) for _ in range(num_layers)
+        ])
+        
+        self.ln_f = nn.LayerNorm(embed_dim)
+        self.head = nn.Linear(embed_dim, vocab_size)
+        
+        # Parametri per auto-organizzazione
+        self.plasticity = nn.Parameter(torch.ones(num_layers) * 0.01)
+        
+    def forward(self, x):
+        B, T = x.shape
+        pos = torch.arange(0, T, dtype=torch.long, device=x.device)
+        
+        x = self.tok_embed(x) + self.pos_embed(pos)
+        
+        for i, layer in enumerate(self.layers):
+            residual = x
+            x = layer['norm1'](x)
+            x = layer['attn'](x)
+            
+            # Auto-organizzazione adattiva
+            adaptation = torch.tanh(layer['adaptation'](x))
+            x = residual + x * (1 + self.plasticity[i] * adaptation)
+            
+            residual = x
+            x = layer['norm2'](x)
+            x = layer['mlp'](x)
+            x = residual + x
+        
+        x = self.ln_f(x)
+        logits = self.head(x)
+        return logits
+
+class TextDataset(Dataset):
+    def __init__(self, texts, tokenizer, max_len=512):
+        self.texts = texts
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+        
+    def __len__(self):
+        return len(self.texts)
     
-    def fetch_news_data(self):
-        """Fetch data from news sources"""
-        news_sources = [
-            "https://feeds.reuters.com/reuters/worldNews",
-            "https://feeds.bbci.co.uk/news/world/rss.xml"
-        ]
+    def __getitem__(self, idx):
+        text = self.texts[idx]
+        tokens = self.tokenizer.encode(text)
+        
+        if len(tokens) < self.max_len:
+            tokens = tokens + [0] * (self.max_len - len(tokens))
+        else:
+            tokens = tokens[:self.max_len]
+            
+        return torch.tensor(tokens[:-1]), torch.tensor(tokens[1:])
+
+class AITrainer:
+    def __init__(self):
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.tokenizer = None
+        self.model = None
+        self.datasets = []
+        
+    def load_public_datasets(self):
+        """Carica dataset pubblici senza API key"""
+        datasets = []
         
-        articles = []
+        try:
+            # Wikipedia in italiano
+            wiki = load_dataset("wikipedia", "20220301.it", split="train[:10000]")
+            for item in wiki:
+                if len(item['text']) > 100:
+                    datasets.append(item['text'])
+        except:
+            pass
+            
+        try:
+            # Common Crawl
+            cc = load_dataset("cc100", lang="it", split="train[:5000]")
+            for item in cc:
+                if len(item['text']) > 100:
+                    datasets.append(item['text'])
+        except:
+            pass
+            
+        try:
+            # OSCAR
+            oscar = load_dataset("oscar-corpus/OSCAR-2201", "it", split="train[:5000]")
+            for item in oscar:
+                if len(item['text']) > 100:
+                    datasets.append(item['text'])
+        except:
+            pass
         
-        for source in news_sources:
+        # Dataset di testo semplice da URL pubblici
+        urls = [
+            "https://www.gutenberg.org/files/2000/2000-0.txt",  # Divina Commedia
+            "https://www.gutenberg.org/files/1065/1065-0.txt"   # I Promessi Sposi
+        ]
+        
+        for url in urls:
             try:
-                response = requests.get(source, timeout=5)
+                response = requests.get(url, timeout=30)
                 if response.status_code == 200:
-                    root = ET.fromstring(response.content)
-                    for item in root.findall(".//item")[:3]:  # Limit to 3 per source
-                        title = item.find("title")
-                        if title is not None and title.text:
-                            clean_title = re.sub(r'[^\w\s]', ' ', title.text).strip()
-                            if len(clean_title) > 10:
-                                articles.append(clean_title)
-                print(f"📰 Collected {len(articles)} articles from {source}")
-            except Exception as e:
-                print(f"⚠️ Failed to collect from {source}: {str(e)}")
+                    text = response.text
+                    chunks = [text[i:i+2000] for i in range(0, len(text), 2000)]
+                    datasets.extend(chunks[:500])
+            except:
                 continue
         
-        return articles
-    
-    def process_collected_data(self, data):
-        """Process collected data into knowledge base"""
-        for text in data:
-            # Extract key topics and add to knowledge base
-            words = text.lower().split()
-            self.vocabulary.update(words)
-            
-            # Simple topic extraction
-            if any(word in text.lower() for word in ['technology', 'ai', 'computer']):
-                self.knowledge_base['technology'].append(text)
-            elif any(word in text.lower() for word in ['climate', 'environment', 'energy']):
-                self.knowledge_base['environment'].append(text)
-            elif any(word in text.lower() for word in ['economy', 'market', 'business']):
-                self.knowledge_base['economy'].append(text)
-            else:
-                self.knowledge_base['general'].append(text)
-        
-        # Update token count
-        self.total_tokens += sum(len(text.split()) for text in data)
-        print(f"📚 Processed data into {len(self.knowledge_base)} knowledge categories")
-    
-    def answer_question(self, question):
-        """Answer a question using available knowledge"""
-        if not question.strip():
-            return "Hello! I'm an AI that learns from data. Ask me a question and I'll try to answer based on what I've learned!"
+        # Genera dati sintetici se necessario
+        if len(datasets) < 1000:
+            synthetic_texts = self.generate_synthetic_data(5000)
+            datasets.extend(synthetic_texts)
         
-        question_clean = question.lower().strip()
+        self.datasets = datasets[:10000]  # Limita a 10k esempi
+        print(f"Caricati {len(self.datasets)} esempi di training")
         
-        # Direct pattern matching
-        for pattern, answer in self.qa_patterns.items():
-            if self.calculate_similarity(question_clean, pattern) > 0.6:
-                return f"Based on my training: {answer}"
+    def generate_synthetic_data(self, num_samples):
+        """Genera dati sintetici per il training"""
+        templates = [
+            "Il {sostantivo} {verbo} nel {luogo} durante {tempo}.",
+            "La {sostantivo} è molto {aggettivo} e {verbo} sempre.",
+            "Quando {verbo}, il {sostantivo} diventa {aggettivo}.",
+            "Nel {luogo}, la {sostantivo} {verbo} con {sostantivo}.",
+            "Il {aggettivo} {sostantivo} {verbo} ogni {tempo}."
+        ]
         
-        # Topic-based responses
-        topic_response = self.get_topic_response(question_clean)
-        if topic_response:
-            return topic_response
+        sostantivi = ["gatto", "cane", "casa", "albero", "fiume", "montagna", "libro", "sole"]
+        verbi = ["corre", "salta", "vola", "nuota", "dorme", "mangia", "gioca", "legge"]
+        aggettivi = ["bello", "grande", "piccolo", "veloce", "lento", "intelligente", "forte"]
+        luoghi = ["parco", "giardino", "bosco", "città", "mare", "cielo", "campo"]
+        tempi = ["giorno", "notte", "mattina", "sera", "inverno", "estate", "primavera"]
         
-        # Fallback response
-        return self.generate_fallback_response(question_clean)
+        texts = []
+        for _ in range(num_samples):
+            template = random.choice(templates)
+            text = template.format(
+                sostantivo=random.choice(sostantivi),
+                verbo=random.choice(verbi),
+                aggettivo=random.choice(aggettivi),
+                luogo=random.choice(luoghi),
+                tempo=random.choice(tempi)
+            )
+            texts.append(text)
+        
+        return texts
     
-    def calculate_similarity(self, text1, text2):
-        """Calculate similarity between two texts"""
-        words1 = set(text1.split())
-        words2 = set(text2.split())
+    def setup_model(self, vocab_size=30000):
+        """Configura il modello transformer auto-organizzante"""
+        self.model = SelfOrganizingTransformer(
+            vocab_size=vocab_size,
+            embed_dim=512,
+            num_heads=8,
+            num_layers=6,
+            max_len=512
+        ).to(self.device)
         
-        if not words1 or not words2:
-            return 0.0
+        # Calcola parametri
+        total_params = sum(p.numel() for p in self.model.parameters())
+        print(f"Modello creato con {total_params:,} parametri")
         
-        intersection = len(words1.intersection(words2))
-        union = len(words1.union(words2))
+    def train(self, epochs=5, batch_size=16, lr=3e-4):
+        """Training del modello"""
+        print("Inizializzazione tokenizer...")
+        self.tokenizer = SelfOrganizingTokenizer()
+        self.tokenizer.build_vocab(self.datasets)
         
-        return intersection / union if union > 0 else 0.0
-    
-    def get_topic_response(self, question):
-        """Get response based on topic matching"""
-        topic_keywords = {
-            'technology': ['technology', 'computer', 'ai', 'artificial', 'machine', 'internet', 'digital'],
-            'environment': ['climate', 'environment', 'energy', 'renewable', 'carbon', 'sustainability'],
-            'economy': ['economy', 'economic', 'market', 'business', 'finance', 'money'],
-            'education': ['education', 'learning', 'school', 'university', 'knowledge', 'study']
-        }
-        
-        # Find matching topic
-        for topic, keywords in topic_keywords.items():
-            if any(keyword in question for keyword in keywords):
-                if topic in self.knowledge_base and self.knowledge_base[topic]:
-                    return f"Based on recent information about {topic}: {self.knowledge_base[topic][0][:150]}..."
-                else:
-                    return self.get_topic_template_response(topic, question)
-        
-        return None
-    
-    def get_topic_template_response(self, topic, question):
-        """Get template response for a topic"""
-        templates = {
-            'technology': "Technology is rapidly evolving and transforming how we work, communicate, and solve problems. Modern technological advances include artificial intelligence, machine learning, and digital innovations.",
-            'environment': "Environmental issues like climate change require urgent attention. Solutions include renewable energy adoption, sustainable practices, and reduced carbon emissions.",
-            'economy': "Economic factors influence global markets, employment, and business growth. Understanding economic principles helps in making informed decisions.",
-            'education': "Education plays a crucial role in personal development and societal progress. It provides knowledge, skills, and opportunities for growth."
-        }
-        
-        base_response = templates.get(topic, "This is an important topic that involves multiple factors and considerations.")
-        
-        if '?' in question:
-            return f"Regarding your question about {topic}: {base_response}"
-        else:
-            return f"About {topic}: {base_response}"
-    
-    def generate_fallback_response(self, question):
-        """Generate fallback response for unknown questions"""
-        fallback_responses = [
-            "That's an interesting question. Based on general knowledge, this topic involves various factors that need consideration.",
-            "From what I understand, this subject has multiple aspects worth exploring further.",
-            "This is a complex topic that relates to several areas of knowledge and research.",
-            "Based on my training data, this question touches on important concepts that merit detailed analysis."
-        ]
+        print("Configurazione modello...")
+        self.setup_model(len(self.tokenizer.token_to_id))
         
-        return random.choice(fallback_responses)
-    
-    def get_system_status(self):
-        """Get current system status"""
-        status = "🤖 **SIMPLE Q&A AI STATUS**\n\n"
+        print("Preparazione dataset...")
+        dataset = TextDataset(self.datasets, self.tokenizer)
+        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
         
-        if self.is_trained:
-            status += "✅ **System is trained and ready**\n\n"
-        else:
-            status += "⏳ **System ready for training**\n\n"
-        
-        status += "**📊 Statistics:**\n"
-        status += f"• **Total tokens processed:** {self.total_tokens:,}\n"
-        status += f"• **Vocabulary size:** {len(self.vocabulary):,} words\n"
-        status += f"• **Q&A patterns:** {len(self.qa_patterns)} direct patterns\n"
-        status += f"• **Knowledge categories:** {len(self.knowledge_base)}\n"
-        status += f"• **Training status:** {'Completed' if self.is_trained else 'Pending'}\n"
-        
-        status += "\n**🎯 Capabilities:**\n"
-        status += "• Answers questions using pattern matching\n"
-        status += "• Learns from news articles and data\n"
-        status += "• Handles multiple topics and domains\n"
-        status += "• Provides fallback responses for unknown queries\n"
-        
-        return status
-
-# Initialize the AI system
-ai_system = SimpleQAAI()
-
-def start_training():
-    """Start the training process"""
-    try:
-        result = ai_system.collect_training_data()
-        return result
-    except Exception as e:
-        return f"❌ Training failed: {str(e)}"
-
-def chat_function(message, history):
-    """Handle chat interactions"""
-    if not message:
-        return history, ""
-    
-    try:
-        response = ai_system.answer_question(message)
-        history.append([message, response])
-        return history, ""
-    except Exception as e:
-        error_response = f"Sorry, I encountered an error: {str(e)}"
-        history.append([message, error_response])
-        return history, ""
-
-def refresh_status():
-    """Refresh system status"""
-    return ai_system.get_system_status()
-
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft(), title="Simple Q&A AI") as app:
-    
-    gr.HTML("""
-    <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
-        <h1>🤖 Simple Question Answering AI</h1>
-        <p><b>Learn from data and answer questions intelligently</b></p>
-        <p>Stable • Fast • Reliable</p>
-    </div>
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=3):
-            gr.Markdown("### 💬 Chat with AI")
+        optimizer = optim.AdamW(self.model.parameters(), lr=lr, weight_decay=0.01)
+        criterion = nn.CrossEntropyLoss(ignore_index=0)
+        
+        print("Inizio training...")
+        self.model.train()
+        
+        for epoch in range(epochs):
+            total_loss = 0
+            num_batches = 0
             
-            chatbot = gr.Chatbot(
-                value=[],
-                label="AI Assistant",
-                height=400
-            )
+            for batch_idx, (input_ids, target_ids) in enumerate(dataloader):
+                input_ids = input_ids.to(self.device)
+                target_ids = target_ids.to(self.device)
+                
+                optimizer.zero_grad()
+                
+                logits = self.model(input_ids)
+                loss = criterion(logits.reshape(-1, logits.size(-1)), target_ids.reshape(-1))
+                
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
+                optimizer.step()
+                
+                total_loss += loss.item()
+                num_batches += 1
+                
+                if batch_idx % 50 == 0:
+                    print(f"Epoch {epoch+1}/{epochs}, Batch {batch_idx}, Loss: {loss.item():.4f}")
             
-            msg_input = gr.Textbox(
-                label="Your Question",
-                placeholder="Ask me anything: What is AI? How does technology work?",
-                lines=2
-            )
+            avg_loss = total_loss / num_batches
+            print(f"Epoch {epoch+1}/{epochs} completata. Loss media: {avg_loss:.4f}")
             
-            with gr.Row():
-                send_btn = gr.Button("💬 Send", variant="primary")
-                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+            # Test generazione
+            if epoch % 2 == 0:
+                self.test_generation("Il gatto")
         
-        with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ System Control")
+        print("Training completato!")
+        self.save_model()
+    
+    def test_generation(self, prompt, max_length=50):
+        """Test di generazione testo"""
+        self.model.eval()
+        with torch.no_grad():
+            tokens = self.tokenizer.encode(prompt)
+            input_ids = torch.tensor([tokens]).to(self.device)
             
-            status_box = gr.Textbox(
-                label="System Status",
-                value=ai_system.get_system_status(),
-                lines=16,
-                interactive=False
-            )
+            for _ in range(max_length):
+                logits = self.model(input_ids)
+                next_token = torch.argmax(logits[0, -1, :], dim=-1)
+                input_ids = torch.cat([input_ids, next_token.unsqueeze(0).unsqueeze(0)], dim=1)
+                
+                if next_token.item() == self.tokenizer.token_to_id.get('<EOS>', 3):
+                    break
             
-            train_btn = gr.Button("🚀 Start Training", variant="primary")
-            refresh_btn = gr.Button("🔄 Refresh Status", variant="secondary")
+            generated = self.tokenizer.decode(input_ids[0].cpu().numpy())
+            print(f"Generazione: {generated}")
+        
+        self.model.train()
+        return generated
     
-    # Example questions
-    gr.Examples(
-        examples=[
-            "What is artificial intelligence?",
-            "How do computers work?",
-            "Why is education important?",
-            "What is climate change?",
-            "How does the internet work?",
-            "What is machine learning?"
-        ],
-        inputs=msg_input,
-        label="📝 Try these questions"
-    )
+    def save_model(self):
+        """Salva il modello"""
+        torch.save({
+            'model_state_dict': self.model.state_dict(),
+            'tokenizer': self.tokenizer,
+            'vocab_size': len(self.tokenizer.token_to_id)
+        }, 'ai_model.pth')
+        print("Modello salvato in ai_model.pth")
     
-    # Event handlers
-    send_btn.click(
-        fn=chat_function,
-        inputs=[msg_input, chatbot],
-        outputs=[chatbot, msg_input]
-    )
+    def load_model(self):
+        """Carica il modello"""
+        if os.path.exists('ai_model.pth'):
+            checkpoint = torch.load('ai_model.pth', map_location=self.device)
+            self.tokenizer = checkpoint['tokenizer']
+            self.setup_model(checkpoint['vocab_size'])
+            self.model.load_state_dict(checkpoint['model_state_dict'])
+            print("Modello caricato da ai_model.pth")
+            return True
+        return False
     
-    msg_input.submit(
-        fn=chat_function,
-        inputs=[msg_input, chatbot],
-        outputs=[chatbot, msg_input]
-    )
+    def generate_text(self, prompt, max_length=100, temperature=0.8):
+        """Genera testo dal prompt"""
+        if not self.model or not self.tokenizer:
+            return "Modello non caricato. Esegui prima il training."
+        
+        self.model.eval()
+        with torch.no_grad():
+            tokens = self.tokenizer.encode(prompt)
+            input_ids = torch.tensor([tokens]).to(self.device)
+            
+            for _ in range(max_length):
+                logits = self.model(input_ids)
+                logits = logits[0, -1, :] / temperature
+                probs = torch.softmax(logits, dim=-1)
+                next_token = torch.multinomial(probs, 1)
+                
+                input_ids = torch.cat([input_ids, next_token.unsqueeze(0)], dim=1)
+                
+                if next_token.item() == self.tokenizer.token_to_id.get('<EOS>', 3):
+                    break
+            
+            generated = self.tokenizer.decode(input_ids[0].cpu().numpy())
+            return generated
+
+def create_interface():
+    """Crea interfaccia Gradio"""
+    trainer = AITrainer()
+    
+    def start_training():
+        try:
+            trainer.load_public_datasets()
+            trainer.train(epochs=3)
+            return "Training completato con successo!"
+        except Exception as e:
+            return f"Errore durante il training: {str(e)}"
     
-    clear_btn.click(
-        fn=lambda: ([], ""),
-        outputs=[chatbot, msg_input]
-    )
+    def generate(prompt, max_len, temp):
+        try:
+            if not trainer.load_model():
+                return "Modello non trovato. Esegui prima il training."
+            result = trainer.generate_text(prompt, max_len, temp)
+            return result
+        except Exception as e:
+            return f"Errore nella generazione: {str(e)}"
     
-    train_btn.click(
-        fn=start_training,
-        outputs=[status_box]
-    )
+    with gr.Blocks(title="AI Token Trainer") as demo:
+        gr.Markdown("# AI Training System - Predizione Token")
+        
+        with gr.Tab("Training"):
+            train_btn = gr.Button("Avvia Training", variant="primary")
+            train_output = gr.Textbox(label="Stato Training", lines=5)
+            train_btn.click(start_training, outputs=train_output)
+        
+        with gr.Tab("Generazione"):
+            prompt_input = gr.Textbox(label="Prompt", placeholder="Inserisci il testo di partenza...")
+            max_len_slider = gr.Slider(10, 200, value=50, label="Lunghezza massima")
+            temp_slider = gr.Slider(0.1, 2.0, value=0.8, label="Temperatura")
+            generate_btn = gr.Button("Genera Testo", variant="primary")
+            output_text = gr.Textbox(label="Testo Generato", lines=10)
+            
+            generate_btn.click(
+                generate,
+                inputs=[prompt_input, max_len_slider, temp_slider],
+                outputs=output_text
+            )
     
-    refresh_btn.click(
-        fn=refresh_status,
-        outputs=[status_box]
-    )
+    return demo
 
-# Launch the app
 if __name__ == "__main__":
-    app.launch()
+    # Training automatico se richiesto
+    if len(os.sys.argv) > 1 and os.sys.argv[1] == "train":
+        trainer = AITrainer()
+        trainer.load_public_datasets()
+        trainer.train()
+    else:
+        # Interfaccia Gradio
+        demo = create_interface()
+        demo.launch(share=True)