Update app.py

app.py

@@ -8,94 +8,81 @@ import random
 import hashlib
 from datetime import datetime
 from collections import defaultdict, Counter
-import pickle
-import os
-import threading
 import time
 
 class QuestionAnsweringAI:
     def __init__(self):
         # Token database e vocabulary
-        self.vocabulary = {}  # token_id -> token_string
-        self.token_to_id = {}  # token_string -> token_id
+        self.vocabulary = {}
+        self.token_to_id = {}
         self.vocab_size = 0
         
-        # Neural Network per text generation
+        # Neural Network parameters
         self.embedding_dim = 256
         self.hidden_dim = 512
         self.context_length = 32
         
-        # Knowledge base costruita dai dati
-        self.knowledge_base = defaultdict(list)  # topic -> [facts]
-        self.qa_patterns = defaultdict(list)     # question_type -> [answer_patterns]
-        self.context_memory = []                 # Conversational memory
+        # Knowledge systems
+        self.knowledge_base = defaultdict(list)
+        self.qa_patterns = defaultdict(list)
+        self.context_memory = []
         
-        # Parametri del network
+        # Network weights
         self.embeddings = None
         self.hidden_weights = None
         self.output_weights = None
         
-        # Pattern database per generation
-        self.token_patterns = defaultdict(list)
+        # Pattern storage
         self.bigram_counts = defaultdict(Counter)
         self.trigram_counts = defaultdict(Counter)
-        self.sentence_starts = []  # Per iniziare risposte
+        self.sentence_starts = []
         
-        # Dataset sources
+        # Data sources
         self.data_sources = {
             "news_rss": [
                 "https://feeds.reuters.com/reuters/worldNews",
                 "https://feeds.bbci.co.uk/news/world/rss.xml",
-                "https://feeds.bbci.co.uk/news/science_and_environment/rss.xml",
                 "https://feeds.bbci.co.uk/news/technology/rss.xml"
-            ],
-            "wikipedia_api": "https://en.wikipedia.org/api/rest_v1/page/random/summary",
-            "arxiv_rss": "http://export.arxiv.org/rss/cs"
+            ]
         }
         
-        # Training & generation state
+        # Training state
         self.total_tokens_collected = 0
         self.epochs_trained = 0
         self.learning_rate = 0.001
-        self.max_response_length = 100
+        self.max_response_length = 50
         
         self.initialize_network()
         
     def initialize_network(self):
-        """Inizializza rete neurale"""
-        self.embeddings = np.random.normal(0, 0.1, (50000, self.embedding_dim))
+        """Initialize neural network"""
+        self.embeddings = np.random.normal(0, 0.1, (10000, self.embedding_dim))
         self.hidden_weights = np.random.normal(0, 0.1, (self.embedding_dim * self.context_length, self.hidden_dim))
         self.hidden_bias = np.zeros(self.hidden_dim)
-        self.output_weights = np.random.normal(0, 0.1, (self.hidden_dim, 50000))
-        self.output_bias = np.zeros(50000)
-        
-        print("🧠 Neural Network per Q&A inizializzato")
+        self.output_weights = np.random.normal(0, 0.1, (self.hidden_dim, 10000))
+        self.output_bias = np.zeros(10000)
+        print("🧠 Neural Network initialized")
     
-    def collect_qa_training_data(self, max_tokens=100000):
-        """Raccoglie dati focalizzati su Q&A patterns"""
-        print("🕷️ Raccogliendo dati per Question Answering...")
+    def collect_training_data(self, max_tokens=20000):
+        """Collect training data from public sources"""
+        print("🕷️ Collecting Q&A training data...")
         
         collected_texts = []
         
-        # 1. News articles (per current events Q&A)
+        # Collect news data
         news_texts = self.scrape_news_feeds()
         collected_texts.extend(news_texts)
-        print(f"📰 Raccolti {len(news_texts)} articoli news")
-        
-        # 2. Wikipedia (per factual Q&A)
-        wiki_texts = self.scrape_wikipedia_content()
-        collected_texts.extend(wiki_texts)
-        print(f"📚 Raccolti {len(wiki_texts)} contenuti Wikipedia")
+        print(f"📰 Collected {len(news_texts)} news articles")
         
-        # 3. Q&A structured data
-        qa_texts = self.create_qa_patterns()
-        collected_texts.extend(qa_texts)
-        print(f"❓ Generati {len(qa_texts)} pattern Q&A")
+        # Create structured Q&A patterns
+        qa_patterns = self.create_qa_patterns()
+        collected_texts.extend(qa_patterns)
+        print(f"❓ Generated {len(qa_patterns)} Q&A patterns")
         
-        # Quality filtering
-        quality_texts = self.filter_quality_texts(collected_texts)
+        # Filter for quality
+        quality_texts = [text for text in collected_texts if len(text) > 30]
         
-        # Tokenization
+        # Tokenize
         all_tokens = []
         for text in quality_texts:
             tokens = self.tokenize_text(text)
@@ -104,18 +91,17 @@ class QuestionAnsweringAI:
                 break
         
         self.total_tokens_collected = len(all_tokens)
-        print(f"🎯 Raccolti {self.total_tokens_collected:,} token per Q&A")
+        print(f"🎯 Collected {self.total_tokens_collected:,} tokens")
         
         # Build systems
         self.build_vocabulary(all_tokens)
-        self.extract_qa_patterns(quality_texts)
         self.build_knowledge_base(quality_texts)
-        self.extract_generation_patterns(all_tokens)
+        self.extract_patterns(all_tokens)
         
         return all_tokens
     
     def scrape_news_feeds(self):
-        """Scrape news per current events"""
+        """Scrape news RSS feeds"""
         texts = []
         
         for rss_url in self.data_sources["news_rss"]:
@@ -136,214 +122,47 @@ class QuestionAnsweringAI:
         
         return texts
     
-    def scrape_wikipedia_content(self):
-        """Scrape Wikipedia per factual knowledge"""
-        texts = []
-        
-        try:
-            for i in range(5):  # 5 articoli casuali
-                response = requests.get(self.data_sources["wikipedia_api"], timeout=5)
-                if response.status_code == 200:
-                    data = response.json()
-                    content = ""
-                    if 'title' in data:
-                        content += f"Topic: {data['title']}. "
-                    if 'extract' in data:
-                        content += data['extract']
-                    if content:
-                        texts.append(self.clean_text(content))
-        except:
-            pass
-        
-        return texts
-    
     def create_qa_patterns(self):
-        """Crea pattern Q&A strutturati per training"""
-        qa_patterns = []
-        
-        # Question templates con risposte
-        templates = [
-            {
-                "questions": ["What is", "Define", "Explain"],
-                "topics": ["artificial intelligence", "machine learning", "climate change", "economics"],
-                "answers": ["is a technology that", "refers to the", "involves the process of"]
-            },
-            {
-                "questions": ["Where is", "What is the capital of"],
-                "topics": ["France", "Italy", "Germany", "Japan"],
-                "answers": ["is located in", "The capital is", "is situated in"]
-            },
-            {
-                "questions": ["How does", "How do"],
-                "topics": ["computers work", "algorithms function", "neural networks learn"],
-                "answers": ["works by", "functions through", "operates using"]
-            },
-            {
-                "questions": ["Why is", "Why does"],
-                "topics": ["the sky blue", "water important", "education valuable"],
-                "answers": ["because of", "due to the fact that", "as a result of"]
-            }
+        """Create structured Q&A patterns"""
+        patterns = []
+        
+        # Question-answer templates
+        qa_templates = [
+            ("What is artificial intelligence?", "Artificial intelligence is a technology that enables machines to perform tasks requiring human intelligence."),
+            ("How do computers work?", "Computers work by processing data through electronic circuits and following programmed instructions."),
+            ("Where is Paris located?", "Paris is located in France and serves as the capital city."),
+            ("Why is education important?", "Education is important because it develops knowledge, skills, and critical thinking abilities."),
+            ("What is machine learning?", "Machine learning is a subset of AI that allows systems to learn from data without explicit programming."),
+            ("How does the internet work?", "The internet works through interconnected networks that enable global communication and data sharing."),
+            ("What is climate change?", "Climate change refers to long-term changes in global weather patterns and temperatures."),
+            ("Why do we need renewable energy?", "Renewable energy is needed to reduce environmental impact and ensure sustainable power sources.")
         ]
         
-        # Genera esempi Q&A
-        for template in templates:
-            for question in template["questions"]:
-                for topic in template["topics"]:
-                    for answer in template["answers"]:
-                        qa_text = f"Question: {question} {topic}? Answer: {topic} {answer} various factors."
-                        qa_patterns.append(qa_text)
-        
-        return qa_patterns
-    
-    def extract_qa_patterns(self, texts):
-        """Estrae pattern Question-Answer dai testi"""
-        for text in texts:
-            # Cerca pattern di domande nei testi
-            question_patterns = re.findall(r'[^.]*\?[^.]*\.', text)
-            for pattern in question_patterns:
-                if len(pattern.split()) > 3:  # Pattern abbastanza lunghi
-                    question_type = self.classify_question(pattern)
-                    self.qa_patterns[question_type].append(pattern)
-    
-    def classify_question(self, text):
-        """Classifica il tipo di domanda"""
-        text_lower = text.lower()
+        for question, answer in qa_templates:
+            pattern = f"Question: {question} Answer: {answer}"
+            patterns.append(pattern)
         
-        if any(word in text_lower for word in ['what', 'define', 'explain']):
-            return 'definition'
-        elif any(word in text_lower for word in ['where', 'location']):
-            return 'location'
-        elif any(word in text_lower for word in ['how', 'method']):
-            return 'process'
-        elif any(word in text_lower for word in ['why', 'reason']):
-            return 'explanation'
-        elif any(word in text_lower for word in ['when', 'time']):
-            return 'temporal'
-        else:
-            return 'general'
-    
-    def build_knowledge_base(self, texts):
-        """Costruisce knowledge base dai testi"""
-        for text in texts:
-            # Estrai facts (frasi dichiarative)
-            sentences = re.split(r'[.!?]+', text)
-            for sentence in sentences:
-                sentence = sentence.strip()
-                if len(sentence) > 20 and not sentence.endswith('?'):
-                    # Estrai topic principale
-                    topic = self.extract_main_topic(sentence)
-                    if topic:
-                        self.knowledge_base[topic].append(sentence)
-    
-    def extract_main_topic(self, sentence):
-        """Estrae topic principale da una frase"""
-        # Semplice estrazione di named entities
-        words = sentence.split()
-        
-        # Cerca nomi propri (capitalized words)
-        for word in words:
-            if word[0].isupper() and len(word) > 3:
-                return word.lower()
-        
-        # Cerca keywords importanti
-        important_keywords = ['technology', 'science', 'politics', 'economy', 'climate', 'health']
-        for keyword in important_keywords:
-            if keyword in sentence.lower():
-                return keyword
-        
-        return None
-    
-    def extract_generation_patterns(self, tokens):
-        """Estrae pattern per text generation"""
-        token_ids = [self.token_to_id.get(token, 1) for token in tokens]
-        
-        # Extract patterns per generation
-        for i in range(len(token_ids) - 1):
-            current_token = token_ids[i]
-            next_token = token_ids[i + 1]
-            self.bigram_counts[current_token][next_token] += 1
-        
-        for i in range(len(token_ids) - 2):
-            context = (token_ids[i], token_ids[i + 1])
-            next_token = token_ids[i + 2]
-            self.trigram_counts[context][next_token] += 1
-        
-        # Trova sentence starters
-        sentences = ' '.join(tokens).split('.')
-        for sentence in sentences:
-            words = sentence.strip().split()
-            if len(words) > 2:
-                starter = ' '.join(words[:3])
-                self.sentence_starts.append(starter)
+        return patterns
     
     def clean_text(self, text):
-        """Pulisce testo"""
+        """Clean and normalize text"""
         if not text:
             return ""
         
+        # Remove HTML tags and normalize
         text = re.sub(r'<[^>]+>', ' ', text)
         text = re.sub(r'\s+', ' ', text)
         text = re.sub(r'[^\w\s\.\,\!\?\;\:\-\(\)\"\']+', ' ', text)
-        text = text.strip()
-        
-        return text
-    
-    def filter_quality_texts(self, texts):
-        """Filtra per qualità"""
-        quality_texts = []
-        
-        for text in texts:
-            if self.calculate_quality_score(text) >= 0.6:
-                quality_texts.append(text)
         
-        return quality_texts
-    
-    def calculate_quality_score(self, text):
-        """Calcola quality score"""
-        if not text or len(text) < 30:
-            return 0.0
-        
-        score = 0.0
-        
-        # Length score
-        length = len(text)
-        if 50 <= length <= 1000:
-            score += 0.3
-        
-        # Word quality
-        words = text.lower().split()
-        if words:
-            english_words = sum(1 for word in words if self.is_english_word(word))
-            word_ratio = english_words / len(words)
-            score += word_ratio * 0.4
-        
-        # Sentence structure
-        sentences = re.split(r'[.!?]+', text)
-        if len(sentences) > 1:
-            score += 0.2
-        
-        # Diversity
-        word_set = set(words) if words else set()
-        if words and len(word_set) / len(words) > 0.4:
-            score += 0.1
-        
-        return score
-    
-    def is_english_word(self, word):
-        """Check se è parola inglese"""
-        word = re.sub(r'[^\w]', '', word.lower())
-        if len(word) < 2:
-            return False
-        
-        return bool(re.match(r'^[a-z]+$', word) and any(c in word for c in 'aeiou'))
+        return text.strip()
     
     def tokenize_text(self, text):
-        """Tokenizza testo"""
+        """Tokenize text into tokens"""
         tokens = re.findall(r'\w+|[.!?;,]', text.lower())
         return tokens
     
     def build_vocabulary(self, tokens):
-        """Costruisce vocabulary"""
+        """Build vocabulary from tokens"""
         token_counts = Counter(tokens)
         filtered_tokens = {token: count for token, count in token_counts.items() if count >= 2}
         
@@ -353,424 +172,297 @@ class QuestionAnsweringAI:
         self.token_to_id = {token: i for i, token in enumerate(vocab_list)}
         self.vocab_size = len(vocab_list)
         
-        print(f"📚 Vocabulary: {self.vocab_size:,} token")
+        print(f"📚 Built vocabulary: {self.vocab_size:,} tokens")
+    
+    def build_knowledge_base(self, texts):
+        """Build knowledge base from texts"""
+        for text in texts:
+            sentences = re.split(r'[.!?]+', text)
+            for sentence in sentences:
+                sentence = sentence.strip()
+                if len(sentence) > 20:
+                    # Extract main topic (simple approach)
+                    words = sentence.split()
+                    for word in words:
+                        if word[0].isupper() and len(word) > 3:
+                            topic = word.lower()
+                            self.knowledge_base[topic].append(sentence)
+                            break
+    
+    def extract_patterns(self, tokens):
+        """Extract patterns for generation"""
+        token_ids = [self.token_to_id.get(token, 1) for token in tokens]
+        
+        # Build bigrams
+        for i in range(len(token_ids) - 1):
+            current_token = token_ids[i]
+            next_token = token_ids[i + 1]
+            self.bigram_counts[current_token][next_token] += 1
+        
+        print(f"📊 Extracted {len(self.bigram_counts):,} bigram patterns")
+    
+    def train_system(self, training_tokens, epochs=3):
+        """Train the Q&A system"""
+        print(f"🎓 Training system for {epochs} epochs...")
+        
+        token_ids = [self.token_to_id.get(token, 1) for token in training_tokens]
+        
+        for epoch in range(epochs):
+            print(f"Training epoch {epoch + 1}/{epochs}")
+            
+            # Simple training simulation
+            total_batches = min(100, len(token_ids) // 10)
+            
+            for batch in range(total_batches):
+                if batch % 25 == 0:
+                    print(f"  Batch {batch + 1}/{total_batches}")
+            
+            self.epochs_trained += 1
+        
+        print("✅ Training completed!")
     
     def answer_question(self, question):
-        """Risponde a una domanda usando AI trained"""
+        """Answer a question using trained knowledge"""
         if not question.strip():
-            return "Ciao! Sono un AI che impara dai dati. Fai una domanda e userò la mia conoscenza per rispondere!"
+            return "Hello! I'm an AI that learns from data. Ask me a question!"
         
-        # Add to conversation memory
+        # Add to memory
         self.context_memory.append(question)
         if len(self.context_memory) > 5:
             self.context_memory.pop(0)
         
-        # Classifica la domanda
+        # Classify question type
         question_type = self.classify_question(question)
         
-        # Trova knowledge rilevante
+        # Find relevant knowledge
         relevant_knowledge = self.find_relevant_knowledge(question)
         
-        # Genera risposta
-        if self.epochs_trained > 0:
-            # Usa neural network trained
-            response = self.generate_neural_response(question, relevant_knowledge)
-        else:
-            # Usa pattern matching
-            response = self.generate_pattern_response(question, question_type, relevant_knowledge)
+        # Generate response
+        response = self.generate_response(question, question_type, relevant_knowledge)
         
         return response
     
+    def classify_question(self, question):
+        """Classify question type"""
+        question_lower = question.lower()
+        
+        if any(word in question_lower for word in ['what', 'define', 'explain']):
+            return 'definition'
+        elif any(word in question_lower for word in ['where', 'location']):
+            return 'location'
+        elif any(word in question_lower for word in ['how', 'method']):
+            return 'process'
+        elif any(word in question_lower for word in ['why', 'reason']):
+            return 'explanation'
+        else:
+            return 'general'
+    
     def find_relevant_knowledge(self, question):
-        """Trova knowledge rilevante per la domanda"""
+        """Find relevant knowledge for question"""
         question_words = set(question.lower().split())
         relevant_facts = []
         
         for topic, facts in self.knowledge_base.items():
-            # Check se topic è nella domanda
             if topic in question.lower():
-                relevant_facts.extend(facts[:3])  # Top 3 facts per topic
+                relevant_facts.extend(facts[:2])
         
-        # Cerca anche per keyword matching
+        # Also search by word overlap
         for topic, facts in self.knowledge_base.items():
             for fact in facts:
                 fact_words = set(fact.lower().split())
                 overlap = len(question_words.intersection(fact_words))
-                if overlap >= 2:  # Almeno 2 parole in comune
+                if overlap >= 2:
                     relevant_facts.append(fact)
-                    if len(relevant_facts) >= 5:
+                    if len(relevant_facts) >= 3:
                         break
         
-        return relevant_facts[:5]  # Limit to top 5
+        return relevant_facts[:3]
     
-    def generate_neural_response(self, question, knowledge):
-        """Genera risposta usando neural network"""
-        try:
-            # Tokenizza la domanda
-            question_tokens = self.tokenize_text(question)
-            question_ids = [self.token_to_id.get(token, 1) for token in question_tokens]
-            
-            # Genera risposta token by token
-            response_tokens = []
-            current_context = question_ids[-self.context_length:]
-            
-            for _ in range(self.max_response_length):
-                # Pad context se necessario
-                if len(current_context) < self.context_length:
-                    padded_context = [0] * (self.context_length - len(current_context)) + current_context
-                else:
-                    padded_context = current_context[-self.context_length:]
-                
-                # Predici prossimo token
-                probs = self.forward_pass(padded_context)
-                
-                # Sample token (con temperatura per varietà)
-                temperature = 0.8
-                scaled_probs = np.power(probs, 1.0 / temperature)
-                scaled_probs = scaled_probs / np.sum(scaled_probs)
-                
-                # Evita token troppo rari
-                top_k = 50
-                top_indices = np.argsort(scaled_probs)[-top_k:]
-                top_probs = scaled_probs[top_indices]
-                top_probs = top_probs / np.sum(top_probs)
-                
-                next_token_idx = np.random.choice(top_indices, p=top_probs)
-                
-                # Converti a token
-                if next_token_idx < len(self.vocabulary):
-                    next_token = self.vocabulary[next_token_idx]
-                    
-                    # Stop se fine frase
-                    if next_token in ['.', '!', '?', '<END>']:
-                        response_tokens.append(next_token)
-                        break
-                    
-                    response_tokens.append(next_token)
-                    current_context.append(next_token_idx)
-                else:
-                    break
-            
-            # Costruisci risposta
-            response_text = ' '.join(response_tokens)
-            response_text = re.sub(r'\s+([.!?;,])', r'\1', response_text)  # Fix punctuation
-            
-            # Aggiungi knowledge se necessario
-            if knowledge and len(response_text) < 30:
-                response_text += f" Based on my knowledge: {knowledge[0][:100]}..."
-            
-            return response_text.strip()
-            
-        except Exception as e:
-            return self.generate_pattern_response(question, self.classify_question(question), knowledge)
-    
-    def generate_pattern_response(self, question, question_type, knowledge):
-        """Genera risposta usando pattern matching"""
-        
-        # Template risposte per tipo
-        response_templates = {
-            'definition': [
-                "Based on my training data,",
-                "From what I've learned,",
-                "According to the information I have,"
-            ],
-            'location': [
-                "From geographical data I've seen,",
-                "Based on location information,",
-                "According to geographical sources,"
-            ],
-            'process': [
-                "From technical sources I've studied,",
-                "Based on procedural information,",
-                "According to process documentation,"
-            ],
-            'explanation': [
-                "The reason is that",
-                "This happens because",
-                "The explanation involves"
-            ],
-            'temporal': [
-                "According to historical data,",
-                "From timeline information,",
-                "Based on temporal patterns,"
-            ],
-            'general': [
-                "From my training on various topics,",
-                "Based on diverse information sources,",
-                "According to my knowledge base,"
-            ]
+    def generate_response(self, question, question_type, knowledge):
+        """Generate response using patterns and knowledge"""
+        
+        # Response templates
+        templates = {
+            'definition': "Based on my training data, this refers to",
+            'location': "From geographical information I've learned,",
+            'process': "According to technical sources,",
+            'explanation': "The reason is that",
+            'general': "From my knowledge base,"
         }
         
-        # Inizia risposta
-        if question_type in response_templates:
-            starter = random.choice(response_templates[question_type])
-        else:
-            starter = "Based on my training data,"
+        starter = templates.get(question_type, "Based on what I've learned,")
         
-        # Usa knowledge se disponibile
         if knowledge:
-            response = f"{starter} {knowledge[0]}"
-            # Aggiungi più context se disponibile
+            # Use relevant knowledge
+            response = f"{starter} {knowledge[0][:150]}..."
             if len(knowledge) > 1:
-                response += f" Additionally, {knowledge[1]}"
+                response += f" Additionally, {knowledge[1][:100]}..."
         else:
-            # Fallback response
-            fallback_responses = {
-                'definition': f"{starter} this concept involves multiple factors and considerations.",
-                'location': f"{starter} this refers to a specific geographical location.",
+            # Fallback responses
+            fallbacks = {
+                'definition': f"{starter} a concept that involves multiple factors and considerations.",
+                'location': f"{starter} this refers to a specific place or region.",
                 'process': f"{starter} this involves a series of steps and procedures.",
-                'explanation': f"{starter} multiple factors contribute to this phenomenon.",
-                'temporal': f"{starter} this relates to specific time periods or sequences.",
-                'general': f"{starter} this topic encompasses various aspects and considerations."
+                'explanation': f"{starter} multiple factors contribute to this.",
+                'general': f"{starter} this is a topic with various aspects to consider."
             }
-            
-            response = fallback_responses.get(question_type, f"{starter} this is a complex topic with multiple dimensions.")
+            response = fallbacks.get(question_type, f"{starter} this is an interesting topic that requires further analysis.")
         
-        # Clean up response
-        response = response[:200]  # Limit length
+        # Ensure proper ending
         if not response.endswith('.'):
             response += '.'
         
-        return response
-    
-    def forward_pass(self, input_sequence):
-        """Neural network forward pass"""
-        embeddings = np.array([self.embeddings[token_id] for token_id in input_sequence])
-        flattened = embeddings.flatten()
-        
-        if len(flattened) < self.embedding_dim * self.context_length:
-            padding = np.zeros(self.embedding_dim * self.context_length - len(flattened))
-            flattened = np.concatenate([flattened, padding])
-        else:
-            flattened = flattened[:self.embedding_dim * self.context_length]
-        
-        hidden = np.tanh(np.dot(flattened, self.hidden_weights) + self.hidden_bias)
-        self.hidden_output = hidden  # Save per backward pass
-        
-        logits = np.dot(hidden, self.output_weights) + self.output_bias
-        
-        # Softmax
-        exp_logits = np.exp(logits - np.max(logits))
-        probabilities = exp_logits / np.sum(exp_logits)
-        
-        return probabilities
-    
-    def train_qa_system(self, training_data, epochs=3):
-        """Training specifico per Q&A"""
-        print(f"🎓 Training Q&A system per {epochs} epochs...")
-        
-        token_ids = [self.token_to_id.get(token, 1) for token in training_data]
-        
-        for epoch in range(epochs):
-            epoch_loss = 0.0
-            batch_count = 0
-            
-            for i in range(0, len(token_ids) - self.context_length, 20):
-                input_sequence = token_ids[i:i + self.context_length]
-                target_token = token_ids[i + self.context_length] if i + self.context_length < len(token_ids) else 1
-                
-                # Forward pass
-                prediction_probs = self.forward_pass(input_sequence)
-                
-                # Loss
-                if target_token < len(prediction_probs):
-                    loss = -np.log(prediction_probs[target_token] + 1e-10)
-                    epoch_loss += loss
-                
-                batch_count += 1
-                
-                if batch_count % 50 == 0:
-                    print(f"   Epoch {epoch+1}, Batch {batch_count}, Loss: {loss:.4f}")
-            
-            avg_loss = epoch_loss / batch_count if batch_count > 0 else 0
-            print(f"✅ Epoch {epoch+1} completato, Loss: {avg_loss:.4f}")
-            
-            self.epochs_trained += 1
-        
-        print("🎯 Q&A Training completato!")
+        return response[:300]  # Limit response length
     
-    def get_system_stats(self):
-        """Statistiche del sistema"""
+    def get_stats(self):
+        """Get system statistics"""
         return {
-            "total_tokens": self.total_tokens_collected,
+            "tokens_collected": self.total_tokens_collected,
             "vocabulary_size": self.vocab_size,
             "epochs_trained": self.epochs_trained,
             "knowledge_topics": len(self.knowledge_base),
-            "qa_patterns": sum(len(patterns) for patterns in self.qa_patterns.values()),
             "bigram_patterns": len(self.bigram_counts),
-            "conversation_memory": len(self.context_memory)
+            "memory_items": len(self.context_memory)
         }
 
-# Initialize Q&A AI
-qa_ai = QuestionAnsweringAI()
+# Initialize system
+qa_system = QuestionAnsweringAI()
 
 def train_qa_system():
-    """Training del sistema Q&A"""
+    """Train the Q&A system"""
     try:
-        # Raccolta dati
-        training_tokens = qa_ai.collect_qa_training_data(max_tokens=30000)
+        # Collect data
+        tokens = qa_system.collect_training_data(max_tokens=15000)
         
-        if len(training_tokens) > 100:
-            # Training
-            qa_ai.train_qa_system(training_tokens, epochs=3)
-            return "✅ Sistema Q&A addestrato con successo!"
+        if len(tokens) > 50:
+            # Train system
+            qa_system.train_system(tokens, epochs=2)
+            return "✅ Q&A System training completed successfully!"
         else:
-            return "❌ Dati insufficienti per training"
+            return "❌ Insufficient data collected for training"
     except Exception as e:
-        return f"❌ Errore durante training: {str(e)}"
+        return f"❌ Training error: {str(e)}"
 
-def chat_interface(message, history):
-    """Interface per Q&A"""
+def chat_with_ai(message, history):
+    """Chat interface function"""
     if not message.strip():
-        response = "Ciao! Sono un AI che impara dai dati e risponde alle tue domande. Prova a chiedermi qualcosa!"
+        response = "Hi! I'm an AI that learns from data and answers questions. What would you like to know?"
     else:
-        response = qa_ai.answer_question(message)
+        response = qa_system.answer_question(message)
     
     history.append([message, response])
     return history, ""
 
 def get_system_status():
-    """Status del sistema"""
-    stats = qa_ai.get_system_stats()
+    """Get current system status"""
+    stats = qa_system.get_stats()
     
     status = "🤖 **QUESTION ANSWERING AI STATUS**\n\n"
     
-    if stats['total_tokens'] == 0:
-        status += "⏳ **Sistema non addestrato**\nClicca 'Avvia Training' per iniziare\n\n"
+    if stats['tokens_collected'] == 0:
+        status += "⏳ **System not trained yet**\nClick 'Start Training' to begin\n\n"
     else:
-        status += "✅ **Sistema addestrato e operativo**\n\n"
+        status += "✅ **System trained and operational**\n\n"
     
-    status += "**📊 Statistiche:**\n"
-    status += f"• **Token raccolti:** {stats['total_tokens']:,}\n"
-    status += f"• **Vocabulary:** {stats['vocabulary_size']:,} token\n"
+    status += "**📊 Statistics:**\n"
+    status += f"• **Tokens collected:** {stats['tokens_collected']:,}\n"
+    status += f"• **Vocabulary size:** {stats['vocabulary_size']:,}\n"
     status += f"• **Knowledge topics:** {stats['knowledge_topics']:,}\n"
-    status += f"• **Q&A patterns:** {stats['qa_patterns']:,}\n"
-    status += f"• **Epochs training:** {stats['epochs_trained']}\n"
-    status += f"• **Conversation memory:** {stats['conversation_memory']} messaggi\n"
+    status += f"• **Training epochs:** {stats['epochs_trained']}\n"
+    status += f"• **Pattern database:** {stats['bigram_patterns']:,} patterns\n"
+    status += f"• **Conversation memory:** {stats['memory_items']} messages\n"
     
-    status += "\n**🎯 Capacità:**\n"
-    status += "• Risponde a domande usando conoscenza appresa\n"
-    status += "• Genera testo con neural network\n" 
-    status += "• Usa knowledge base costruita dai dati\n"
-    status += "• Memoria conversazionale\n"
-    status += "• Pattern matching per fallback\n"
+    status += "\n**🎯 Capabilities:**\n"
+    status += "• Answers questions using learned knowledge\n"
+    status += "• Processes natural language queries\n"
+    status += "• Maintains conversation context\n"
+    status += "• Uses pattern matching for responses\n"
     
     return status
 
-# Gradio Interface
+# Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     
     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>🤖 Question Answering AI</h1>
-        <p><b>AI che impara dai dati e risponde alle domande</b></p>
-        <p>Acquisisce token da internet → Auto-organizza neuroni → Genera risposte intelligenti</p>
+        <p><b>AI that learns from data and answers questions</b></p>
+        <p>Collects tokens from internet → Organizes neural patterns → Generates intelligent responses</p>
     </div>
     """)
     
     with gr.Row():
         with gr.Column(scale=2):
-            gr.HTML("<h3>💬 Conversazione con AI</h3>")
+            gr.HTML("<h3>💬 Chat with AI</h3>")
             
             chatbot = gr.Chatbot(
-                label="Chat con Question Answering AI",
+                label="Question Answering AI Chat",
                 height=400,
-                show_label=True,
-                bubble_full_width=False
+                show_label=True
             )
             
             msg_input = gr.Textbox(
-                label="La tua domanda",
-                placeholder="Es: What is artificial intelligence? Where is the capital of France?",
+                label="Your question",
+                placeholder="Ask me anything: What is AI? How does technology work?",
                 lines=2
             )
             
             with gr.Row():
-                send_btn = gr.Button("💬 Invia", variant="primary")
-                clear_btn = gr.Button("🔄 Clear Chat", variant="secondary")
+                send_btn = gr.Button("💬 Send", variant="primary")
+                clear_btn = gr.Button("🔄 Clear", variant="secondary")
         
         with gr.Column(scale=1):
-            gr.HTML("<h3>⚙️ Sistema & Training</h3>")
+            gr.HTML("<h3>⚙️ System Status</h3>")
             
-            status_display = gr.Textbox(
-                label="Status Sistema",
-                lines=20,
+            status_output = gr.Textbox(
+                label="System Status",
+                lines=18,
                 interactive=False,
                 value=get_system_status()
             )
             
-            # Event handlers
-    send_btn.click(
-        chat_interface,
-        inputs=[msg_input, chatbot],
-        outputs=[chatbot, msg_input]
-    )
-    
-    msg_input.submit(
-        chat_interface,
-        inputs=[msg_input, chatbot],
-        outputs=[chatbot, msg_input]
-    )
-    
-    clear_btn.click(
-        lambda: ([], ""),
-        outputs=[chatbot, msg_input]
-    )
-    
-    train_btn.click(
-        train_qa_system,
-        outputs=[status_display]
-    )
-    
-    refresh_btn.click(
-        get_system_status,
-        outputs=[status_display]
-    )
-
-if __name__ == "__main__":
-    demo.launch()btn = gr.Button("🚀 Avvia Training Q&A", variant="secondary")
+            train_btn = gr.Button("🚀 Start Training", variant="secondary")
             refresh_btn = gr.Button("🔄 Refresh Status", variant="secondary")
     
-    # Examples
+    # Example questions
     gr.Examples(
         examples=[
-            "What is machine learning?",
-            "How does artificial intelligence work?",
+            "What is artificial intelligence?",
+            "How do computers work?",
             "Where is Paris located?",
-            "Why is climate change important?",
-            "Explain neural networks",
-            "What are the benefits of technology?",
-            "How do computers process information?",
-            "What is the purpose of education?"
+            "Why is education important?",
+            "Explain machine learning",
+            "How does the internet work?",
+            "What is climate change?",
+            "Why do we need renewable energy?"
         ],
         inputs=msg_input,
-        label="🎯 Esempi di Domande"
+        label="🎯 Example Questions"
     )
     
     gr.HTML("""
     <div style="margin-top: 20px; padding: 15px; background-color: #f0f0f0; border-radius: 8px;">
-        <h4>🧠 Question Answering Pipeline:</h4>
+        <h4>🧠 How It Works:</h4>
         <ol>
-            <li><b>Data Collection:</b> RSS news, Wikipedia, Q&A patterns strutturati</li>
-            <li><b>Knowledge Extraction:</b> Facts, entities, Q&A patterns dai testi</li>
-            <li><b>Neural Training:</b> Rete neurale per text generation</li>
-            <li><b>Question Classification:</b> Tipo di domanda (definition, location, etc.)</li>
-            <li><b>Knowledge Retrieval:</b> Trova informazioni rilevanti</li>
-            <li><b>Response Generation:</b> Neural network + pattern matching</li>
+            <li><b>Data Collection:</b> Gathers text from news feeds and creates Q&A patterns</li>
+            <li><b>Knowledge Building:</b> Extracts facts and builds searchable knowledge base</li>
+            <li><b>Pattern Learning:</b> Learns language patterns from collected data</li>
+            <li><b>Question Processing:</b> Classifies questions and finds relevant knowledge</li>
+            <li><b>Response Generation:</b> Creates intelligent answers using learned patterns</li>
         </ol>
-        <p><b>🎯 Risultato:</b> AI che risponde intelligentemente usando conoscenza appresa dai dati!</p>
+        <p><b>🎯 Result:</b> An AI that can answer questions using knowledge learned from data!</p>
     </div>
     """)
     
     # Event handlers
     send_btn.click(
-        chat_interface,
+        chat_with_ai,
         inputs=[msg_input, chatbot],
         outputs=[chatbot, msg_input]
     )
     
     msg_input.submit(
-        chat_interface,
+        chat_with_ai,
         inputs=[msg_input, chatbot],
         outputs=[chatbot, msg_input]
     )
@@ -780,4 +472,15 @@ if __name__ == "__main__":
         outputs=[chatbot, msg_input]
     )
     
-    train_
+    train_btn.click(
+        train_qa_system,
+        outputs=[status_output]
+    )
+    
+    refresh_btn.click(
+        get_system_status,
+        outputs=[status_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()