Update app.py

app.py

@@ -13,100 +13,87 @@ import os
 import threading
 import time
 
-class TokenPredictor:
+class QuestionAnsweringAI:
     def __init__(self):
         # Token database e vocabulary
         self.vocabulary = {}  # token_id -> token_string
         self.token_to_id = {}  # token_string -> token_id
         self.vocab_size = 0
         
-        # Neural Network semplificato per predizione
+        # Neural Network per text generation
         self.embedding_dim = 256
         self.hidden_dim = 512
         self.context_length = 32
         
-        # Parametri del network (pesi)
+        # 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
+        
+        # Parametri del network
         self.embeddings = None
         self.hidden_weights = None
         self.output_weights = None
         
-        # Pattern database per apprendimento
-        self.token_patterns = defaultdict(list)  # token -> [next_tokens]
-        self.bigram_counts = defaultdict(Counter)  # token -> {next_token: count}
-        self.trigram_counts = defaultdict(Counter)  # (tok1,tok2) -> {next_token: count}
+        # Pattern database per generation
+        self.token_patterns = defaultdict(list)
+        self.bigram_counts = defaultdict(Counter)
+        self.trigram_counts = defaultdict(Counter)
+        self.sentence_starts = []  # Per iniziare risposte
         
-        # Dataset sources (pubblici, no API key)
+        # Dataset sources
         self.data_sources = {
-            "gutenberg": "https://www.gutenberg.org/files/",
-            "wikipedia_dumps": "https://dumps.wikimedia.org/enwiki/latest/",
             "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"
             ],
-            "academic_arxiv": "https://arxiv.org/list/cs/recent",
-            "reddit_json": "https://files.pushshift.io/reddit/",
-            "opensubtitles": "https://opus.nlpl.eu/OpenSubtitles.php",
-            "common_crawl": "https://data.commoncrawl.org/crawl-data/"
+            "wikipedia_api": "https://en.wikipedia.org/api/rest_v1/page/random/summary",
+            "arxiv_rss": "http://export.arxiv.org/rss/cs"
         }
         
-        # Data collection stats
+        # Training & generation state
         self.total_tokens_collected = 0
-        self.quality_score_threshold = 0.7
-        self.collection_active = False
-        
-        # Training state
-        self.training_loss = []
         self.epochs_trained = 0
         self.learning_rate = 0.001
+        self.max_response_length = 100
         
         self.initialize_network()
         
     def initialize_network(self):
-        """Inizializza rete neurale con pesi casuali"""
-        # Embedding layer: converte token_id in vettori densi
+        """Inizializza rete neurale"""
         self.embeddings = np.random.normal(0, 0.1, (50000, self.embedding_dim))
-        
-        # Hidden layer weights  
         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)
-        
-        # Output layer weights
         self.output_weights = np.random.normal(0, 0.1, (self.hidden_dim, 50000))
         self.output_bias = np.zeros(50000)
         
-        print("🧠 Neural Network inizializzato con pesi casuali")
+        print("🧠 Neural Network per Q&A inizializzato")
     
-    def collect_quality_data(self, max_tokens=1000000):
-        """Raccoglie dati di qualità da fonti pubbliche"""
-        print("🕷️ Iniziando raccolta dati da fonti pubbliche...")
-        self.collection_active = True
+    def collect_qa_training_data(self, max_tokens=100000):
+        """Raccoglie dati focalizzati su Q&A patterns"""
+        print("🕷️ Raccogliendo dati per Question Answering...")
+        
         collected_texts = []
         
-        # 1. News RSS feeds (real-time, alta qualità)
+        # 1. News articles (per current events Q&A)
         news_texts = self.scrape_news_feeds()
         collected_texts.extend(news_texts)
         print(f"📰 Raccolti {len(news_texts)} articoli news")
         
-        # 2. Wikipedia abstracts (altissima qualità)
-        wiki_texts = self.scrape_wikipedia_samples()
+        # 2. Wikipedia (per factual Q&A)
+        wiki_texts = self.scrape_wikipedia_content()
         collected_texts.extend(wiki_texts)
-        print(f"📚 Raccolti {len(wiki_texts)} abstract Wikipedia")
+        print(f"📚 Raccolti {len(wiki_texts)} contenuti Wikipedia")
         
-        # 3. ArXiv papers abstracts (qualità accademica)
-        arxiv_texts = self.scrape_arxiv_abstracts()
-        collected_texts.extend(arxiv_texts)
-        print(f"🔬 Raccolti {len(arxiv_texts)} abstract ArXiv")
-        
-        # 4. Project Gutenberg (libri pubblici)
-        gutenberg_texts = self.scrape_gutenberg_samples()
-        collected_texts.extend(gutenberg_texts)
-        print(f"📖 Raccolti {len(gutenberg_texts)} testi Gutenberg")
+        # 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")
         
         # Quality filtering
         quality_texts = self.filter_quality_texts(collected_texts)
-        print(f"✅ Filtrati {len(quality_texts)} testi di qualità")
         
         # Tokenization
         all_tokens = []
@@ -117,473 +104,556 @@ class TokenPredictor:
                 break
         
         self.total_tokens_collected = len(all_tokens)
-        print(f"🎯 Raccolti {self.total_tokens_collected:,} token di qualità")
+        print(f"🎯 Raccolti {self.total_tokens_collected:,} token per Q&A")
         
-        # Build vocabulary
+        # 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)
         
-        # Extract patterns per training
-        self.extract_training_patterns(all_tokens)
-        
-        self.collection_active = False
         return all_tokens
     
     def scrape_news_feeds(self):
-        """Scrape RSS news feeds per contenuto di qualità"""
+        """Scrape news per current events"""
         texts = []
         
-        for rss_url in self.data_sources["news_rss"][:2]:  # Limit per demo
+        for rss_url in self.data_sources["news_rss"]:
             try:
                 response = requests.get(rss_url, timeout=5)
                 if response.status_code == 200:
                     root = ET.fromstring(response.content)
-                    for item in root.findall(".//item")[:5]:
+                    for item in root.findall(".//item")[:3]:
                         title = item.find("title")
                         description = item.find("description")
                         if title is not None:
                             text = title.text
                             if description is not None:
-                                text += " " + description.text
+                                text += ". " + description.text
                             texts.append(self.clean_text(text))
             except:
                 continue
         
         return texts
     
-    def scrape_wikipedia_samples(self):
-        """Scrape Wikipedia content (sample)"""
+    def scrape_wikipedia_content(self):
+        """Scrape Wikipedia per factual knowledge"""
         texts = []
         
-        # Wikipedia API per articoli casuali
-        wiki_api_urls = [
-            "https://en.wikipedia.org/api/rest_v1/page/random/summary",
-            "https://en.wikipedia.org/w/api.php?action=query&format=json&list=random&rnnamespace=0&rnlimit=5"
-        ]
-        
         try:
-            for i in range(3):  # 3 articoli casuali
-                response = requests.get(wiki_api_urls[0], timeout=5)
+            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:
-                        texts.append(self.clean_text(data['extract']))
+                        content += data['extract']
+                    if content:
+                        texts.append(self.clean_text(content))
         except:
             pass
         
         return texts
     
-    def scrape_arxiv_abstracts(self):
-        """Scrape ArXiv abstracts (sample)"""
-        texts = []
-        
-        # ArXiv RSS feed per CS papers
-        arxiv_rss = "http://export.arxiv.org/rss/cs"
+    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"]
+            }
+        ]
         
-        try:
-            response = requests.get(arxiv_rss, timeout=5)
-            if response.status_code == 200:
-                root = ET.fromstring(response.content)
-                for item in root.findall(".//item")[:3]:
-                    description = item.find("description")
-                    if description is not None:
-                        # Extract abstract from description
-                        desc_text = description.text
-                        if "Abstract:" in desc_text:
-                            abstract = desc_text.split("Abstract:")[1].strip()
-                            texts.append(self.clean_text(abstract))
-        except:
-            pass
+        # 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 texts
+        return qa_patterns
     
-    def scrape_gutenberg_samples(self):
-        """Scrape Project Gutenberg public domain texts (sample)"""
-        texts = []
-        
-        # Sample di testi Gutenberg famosi (public domain)
-        gutenberg_samples = [
-            "https://www.gutenberg.org/files/11/11-0.txt",  # Alice in Wonderland
-            "https://www.gutenberg.org/files/74/74-0.txt",  # Tom Sawyer
-            "https://www.gutenberg.org/files/1342/1342-0.txt",  # Pride and Prejudice
-        ]
+    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()
+        
+        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 url in gutenberg_samples[:1]:  # Solo 1 per demo
-            try:
-                response = requests.get(url, timeout=10)
-                if response.status_code == 200:
-                    text = response.text
-                    # Extract portion of text (primi 5000 chars)
-                    if len(text) > 1000:
-                        sample = text[1000:6000]  # Skip header
-                        texts.append(self.clean_text(sample))
-            except:
-                continue
+        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
         
-        return texts
+        # 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)
     
     def clean_text(self, text):
-        """Pulisce e normalizza il testo"""
+        """Pulisce testo"""
         if not text:
             return ""
         
-        # Remove HTML tags
         text = re.sub(r'<[^>]+>', ' ', text)
-        
-        # Normalize whitespace
         text = re.sub(r'\s+', ' ', text)
-        
-        # Remove special characters (keep basic punctuation)
         text = re.sub(r'[^\w\s\.\,\!\?\;\:\-\(\)\"\']+', ' ', text)
-        
-        # Remove extra spaces
         text = text.strip()
         
         return text
     
     def filter_quality_texts(self, texts):
-        """Filtra testi per qualità"""
+        """Filtra per qualità"""
         quality_texts = []
         
         for text in texts:
-            score = self.calculate_quality_score(text)
-            if score >= self.quality_score_threshold:
+            if self.calculate_quality_score(text) >= 0.6:
                 quality_texts.append(text)
         
         return quality_texts
     
     def calculate_quality_score(self, text):
-        """Calcola score di qualità del testo"""
-        if not text or len(text) < 50:
+        """Calcola quality score"""
+        if not text or len(text) < 30:
             return 0.0
         
         score = 0.0
         
-        # Length score (optimal 100-5000 chars)
+        # Length score
         length = len(text)
-        if 100 <= length <= 5000:
+        if 50 <= length <= 1000:
             score += 0.3
-        elif length > 50:
-            score += 0.1
         
-        # Language quality (proportion of dictionary words)
+        # Word quality
         words = text.lower().split()
         if words:
-            # Simple English word detection
-            english_words = sum(1 for word in words if self.is_likely_english_word(word))
+            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 (has proper punctuation)
+        # Sentence structure
         sentences = re.split(r'[.!?]+', text)
         if len(sentences) > 1:
             score += 0.2
         
-        # Avoid repetitive text
+        # Diversity
         word_set = set(words) if words else set()
-        if words and len(word_set) / len(words) > 0.5:  # Vocabulary diversity
+        if words and len(word_set) / len(words) > 0.4:
             score += 0.1
         
         return score
     
-    def is_likely_english_word(self, word):
-        """Simple heuristic per English words"""
+    def is_english_word(self, word):
+        """Check se è parola inglese"""
         word = re.sub(r'[^\w]', '', word.lower())
         if len(word) < 2:
             return False
         
-        # Basic English patterns
-        common_patterns = [
-            r'^[a-z]+$',  # Only letters
-            r'.*[aeiou].*',  # Contains vowels
-        ]
-        
-        return any(re.match(pattern, word) for pattern in common_patterns)
+        return bool(re.match(r'^[a-z]+$', word) and any(c in word for c in 'aeiou'))
     
     def tokenize_text(self, text):
-        """Tokenizza il testo in token"""
-        # Simple word-based tokenization con punctuation
-        # In produzione: usare BPE (Byte Pair Encoding)
-        
-        # Split on whitespace e punctuation
+        """Tokenizza testo"""
         tokens = re.findall(r'\w+|[.!?;,]', text.lower())
-        
         return tokens
     
     def build_vocabulary(self, tokens):
-        """Costruisce vocabulary da tokens"""
+        """Costruisce vocabulary"""
         token_counts = Counter(tokens)
-        
-        # Keep only tokens con frequency >= 2
         filtered_tokens = {token: count for token, count in token_counts.items() if count >= 2}
         
-        # Add special tokens
         vocab_list = ['<PAD>', '<UNK>', '<START>', '<END>'] + list(filtered_tokens.keys())
         
         self.vocabulary = {i: token for i, token in enumerate(vocab_list)}
         self.token_to_id = {token: i for i, token in enumerate(vocab_list)}
         self.vocab_size = len(vocab_list)
         
-        print(f"📚 Vocabulary costruito: {self.vocab_size:,} token unici")
+        print(f"📚 Vocabulary: {self.vocab_size:,} token")
     
-    def extract_training_patterns(self, tokens):
-        """Estrae pattern per training prediction"""
-        print("🔍 Estraendo pattern per training...")
+    def answer_question(self, question):
+        """Risponde a una domanda usando AI trained"""
+        if not question.strip():
+            return "Ciao! Sono un AI che impara dai dati. Fai una domanda e userò la mia conoscenza per rispondere!"
         
-        # Convert tokens to IDs
-        token_ids = [self.token_to_id.get(token, 1) for token in tokens]  # 1 = <UNK>
-        
-        # Extract 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
+        # Add to conversation memory
+        self.context_memory.append(question)
+        if len(self.context_memory) > 5:
+            self.context_memory.pop(0)
         
-        # Extract trigrams  
-        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
+        # Classifica la domanda
+        question_type = self.classify_question(question)
         
-        print(f"📊 Pattern estratti:")
-        print(f"   Bigrams: {len(self.bigram_counts):,}")
-        print(f"   Trigrams: {len(self.trigram_counts):,}")
-    
-    def train_neural_network(self, training_sequences, epochs=5):
-        """Training della rete neurale"""
-        print(f"🏋️ Iniziando training per {epochs} epochs...")
+        # Trova knowledge rilevante
+        relevant_knowledge = self.find_relevant_knowledge(question)
         
-        for epoch in range(epochs):
-            epoch_loss = 0.0
-            batch_count = 0
+        # 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)
+        
+        return response
+    
+    def find_relevant_knowledge(self, question):
+        """Trova knowledge rilevante per la domanda"""
+        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
+        
+        # Cerca anche per keyword matching
+        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
+                    relevant_facts.append(fact)
+                    if len(relevant_facts) >= 5:
+                        break
+        
+        return relevant_facts[:5]  # Limit to top 5
+    
+    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:]
             
-            # Training su sequenze
-            for i in range(0, len(training_sequences) - self.context_length, 10):
-                # Create input/target pairs
-                input_sequence = training_sequences[i:i + self.context_length]
-                target_token = training_sequences[i + 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:]
                 
-                # Forward pass
-                prediction_probs = self.forward_pass(input_sequence)
+                # Predici prossimo token
+                probs = self.forward_pass(padded_context)
                 
-                # Calculate loss
-                loss = self.calculate_loss(prediction_probs, target_token)
-                epoch_loss += loss
+                # 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)
                 
-                # Backward pass (simplified)
-                self.backward_pass(input_sequence, target_token, prediction_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)
                 
-                batch_count += 1
+                next_token_idx = np.random.choice(top_indices, p=top_probs)
                 
-                if batch_count % 100 == 0:
-                    print(f"   Epoch {epoch+1}, Batch {batch_count}, Loss: {loss:.4f}")
+                # 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
             
-            avg_loss = epoch_loss / batch_count if batch_count > 0 else 0
-            self.training_loss.append(avg_loss)
-            self.epochs_trained += 1
+            # 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,"
+            ]
+        }
+        
+        # Inizia risposta
+        if question_type in response_templates:
+            starter = random.choice(response_templates[question_type])
+        else:
+            starter = "Based on my training data,"
+        
+        # Usa knowledge se disponibile
+        if knowledge:
+            response = f"{starter} {knowledge[0]}"
+            # Aggiungi più context se disponibile
+            if len(knowledge) > 1:
+                response += f" Additionally, {knowledge[1]}"
+        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.",
+                '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."
+            }
             
-            print(f"🎯 Epoch {epoch+1} completato, Loss medio: {avg_loss:.4f}")
+            response = fallback_responses.get(question_type, f"{starter} this is a complex topic with multiple dimensions.")
         
-        print("✅ Training completato!")
+        # Clean up response
+        response = response[:200]  # Limit length
+        if not response.endswith('.'):
+            response += '.'
+        
+        return response
     
     def forward_pass(self, input_sequence):
-        """Forward pass della rete neurale"""
-        # Embedding lookup
+        """Neural network forward pass"""
         embeddings = np.array([self.embeddings[token_id] for token_id in input_sequence])
-        
-        # Flatten embeddings
         flattened = embeddings.flatten()
         
-        # Ensure correct size
         if len(flattened) < self.embedding_dim * self.context_length:
-            # Pad with zeros
             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 layer
         hidden = np.tanh(np.dot(flattened, self.hidden_weights) + self.hidden_bias)
+        self.hidden_output = hidden  # Save per backward pass
         
-        # Output layer
         logits = np.dot(hidden, self.output_weights) + self.output_bias
         
         # Softmax
-        exp_logits = np.exp(logits - np.max(logits))  # Numerical stability
+        exp_logits = np.exp(logits - np.max(logits))
         probabilities = exp_logits / np.sum(exp_logits)
         
         return probabilities
     
-    def calculate_loss(self, predictions, target_token):
-        """Calcola cross-entropy loss"""
-        # Ensure target_token is in valid range
-        if target_token >= len(predictions):
-            target_token = 1  # <UNK>
-        
-        # Cross-entropy loss
-        return -np.log(predictions[target_token] + 1e-10)  # Small epsilon per numerical stability
-    
-    def backward_pass(self, input_sequence, target_token, predictions):
-        """Simplified backward pass"""
-        # Questo è un backward pass molto semplificato
-        # In produzione: usare autograd frameworks come PyTorch
-        
-        # Calculate gradient per output layer
-        grad_output = predictions.copy()
-        if target_token < len(grad_output):
-            grad_output[target_token] -= 1  # Cross-entropy gradient
-        
-        # Update output weights (simplified)
-        learning_rate = self.learning_rate
-        
-        # Gradient clipping
-        grad_output = np.clip(grad_output, -1.0, 1.0)
-        
-        # Simple weight update (only output layer for demo)
-        if hasattr(self, 'hidden_output'):
-            weight_update = np.outer(self.hidden_output, grad_output)
-            self.output_weights -= learning_rate * weight_update
-    
-    def predict_next_token(self, context_text, num_predictions=5):
-        """Predice i prossimi token dato un contesto"""
-        if not context_text.strip():
-            return ["the", "a", "an", "to", "of"]
-        
-        # Tokenize context
-        context_tokens = self.tokenize_text(context_text)
-        context_ids = [self.token_to_id.get(token, 1) for token in context_tokens]
-        
-        # Use neural network se addestrato
-        if self.epochs_trained > 0 and len(context_ids) > 0:
-            # Take last context_length tokens
-            input_sequence = context_ids[-self.context_length:]
-            if len(input_sequence) < self.context_length:
-                # Pad with <PAD> tokens
-                input_sequence = [0] * (self.context_length - len(input_sequence)) + input_sequence
+    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
             
-            try:
+            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)
                 
-                # Get top predictions
-                top_indices = np.argsort(prediction_probs)[-num_predictions:][::-1]
-                predictions = []
+                # Loss
+                if target_token < len(prediction_probs):
+                    loss = -np.log(prediction_probs[target_token] + 1e-10)
+                    epoch_loss += loss
                 
-                for idx in top_indices:
-                    if idx < len(self.vocabulary):
-                        token = self.vocabulary[idx]
-                        prob = prediction_probs[idx]
-                        predictions.append(f"{token} ({prob:.3f})")
+                batch_count += 1
                 
-                return predictions
-            except:
-                pass
-        
-        # Fallback: use pattern matching
-        if len(context_ids) >= 2:
-            # Try trigram
-            last_bigram = (context_ids[-2], context_ids[-1])
-            if last_bigram in self.trigram_counts:
-                most_common = self.trigram_counts[last_bigram].most_common(num_predictions)
-                return [f"{self.vocabulary.get(token_id, '<UNK>')} ({count})" 
-                       for token_id, count in most_common]
-        
-        if len(context_ids) >= 1:
-            # Try bigram
-            last_token = context_ids[-1]
-            if last_token in self.bigram_counts:
-                most_common = self.bigram_counts[last_token].most_common(num_predictions)
-                return [f"{self.vocabulary.get(token_id, '<UNK>')} ({count})" 
-                       for token_id, count in most_common]
-        
-        # Ultimate fallback
-        return ["the", "a", "and", "to", "of"]
-    
-    def get_training_stats(self):
-        """Ritorna statistiche del training"""
-        stats = {
+                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!")
+    
+    def get_system_stats(self):
+        """Statistiche del sistema"""
+        return {
             "total_tokens": 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),
-            "trigram_patterns": len(self.trigram_counts),
-            "current_loss": self.training_loss[-1] if self.training_loss else None,
-            "collection_active": self.collection_active
+            "conversation_memory": len(self.context_memory)
         }
-        return stats
 
-# Initialize Token Predictor
-predictor = TokenPredictor()
+# Initialize Q&A AI
+qa_ai = QuestionAnsweringAI()
 
-def collect_and_train():
-    """Funzione per raccolta dati e training"""
+def train_qa_system():
+    """Training del sistema Q&A"""
     try:
-        # Phase 1: Data collection
-        tokens = predictor.collect_quality_data(max_tokens=50000)  # Limit per demo
-        
-        if len(tokens) > 100:
-            # Phase 2: Training
-            predictor.train_neural_network(
-                [predictor.token_to_id.get(token, 1) for token in tokens], 
-                epochs=3
-            )
-            return "✅ Raccolta dati e training completati!"
+        # Raccolta dati
+        training_tokens = qa_ai.collect_qa_training_data(max_tokens=30000)
+        
+        if len(training_tokens) > 100:
+            # Training
+            qa_ai.train_qa_system(training_tokens, epochs=3)
+            return "✅ Sistema Q&A addestrato con successo!"
         else:
-            return "❌ Dati insufficienti raccolti"
+            return "❌ Dati insufficienti per training"
     except Exception as e:
-        return f"❌ Errore: {str(e)}"
+        return f"❌ Errore durante training: {str(e)}"
 
-def predict_interface(context_text):
-    """Interface per predizione"""
-    if not context_text.strip():
-        return "Inserisci del testo per ottenere predizioni del prossimo token."
-    
-    predictions = predictor.predict_next_token(context_text)
-    
-    result = f"**🎯 Predizioni per:** '{context_text}'\n\n"
-    result += "**📊 Top token predetti:**\n"
-    for i, pred in enumerate(predictions, 1):
-        result += f"{i}. {pred}\n"
-    
-    # Add stats
-    stats = predictor.get_training_stats()
-    result += f"\n**📈 Stats del modello:**\n"
-    result += f"• Token raccolti: {stats['total_tokens']:,}\n"
-    result += f"• Vocabulary size: {stats['vocabulary_size']:,}\n"
-    result += f"• Epochs addestrati: {stats['epochs_trained']}\n"
-    result += f"• Pattern bigram: {stats['bigram_patterns']:,}\n"
-    result += f"• Pattern trigram: {stats['trigram_patterns']:,}\n"
-    
-    if stats['current_loss']:
-        result += f"• Loss attuale: {stats['current_loss']:.4f}\n"
-    
-    return result
+def chat_interface(message, history):
+    """Interface per Q&A"""
+    if not message.strip():
+        response = "Ciao! Sono un AI che impara dai dati e risponde alle tue domande. Prova a chiedermi qualcosa!"
+    else:
+        response = qa_ai.answer_question(message)
+    
+    history.append([message, response])
+    return history, ""
 
-def get_model_status():
-    """Ritorna status del modello"""
-    stats = predictor.get_training_stats()
+def get_system_status():
+    """Status del sistema"""
+    stats = qa_ai.get_system_stats()
     
-    status = "🤖 **STATUS DEL MODELLO TOKEN PREDICTOR**\n\n"
+    status = "🤖 **QUESTION ANSWERING AI STATUS**\n\n"
     
-    if stats['collection_active']:
-        status += "🔄 **Raccolta dati in corso...**\n\n"
-    elif stats['total_tokens'] == 0:
-        status += "⏳ **Modello non addestrato**\nClicca 'Avvia Training' per iniziare\n\n"
+    if stats['total_tokens'] == 0:
+        status += "⏳ **Sistema non addestrato**\nClicca 'Avvia Training' per iniziare\n\n"
     else:
-        status += "✅ **Modello addestrato e pronto**\n\n"
+        status += "✅ **Sistema addestrato e operativo**\n\n"
     
     status += "**📊 Statistiche:**\n"
     status += f"• **Token raccolti:** {stats['total_tokens']:,}\n"
-    status += f"• **Vocabulary:** {stats['vocabulary_size']:,} token unici\n"
-    status += f"• **Pattern appresi:** {stats['bigram_patterns']:,} bigram, {stats['trigram_patterns']:,} trigram\n"
+    status += f"• **Vocabulary:** {stats['vocabulary_size']:,} token\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"
-    
-    if stats['current_loss']:
-        status += f"• **Loss attuale:** {stats['current_loss']:.4f}\n"
+    status += f"• **Conversation memory:** {stats['conversation_memory']} messaggi\n"
     
     status += "\n**🎯 Capacità:**\n"
-    status += "• Predizione next token da contesto\n"
-    status += "• Pattern recognition da milioni di token\n"
-    status += "• Neural network con embeddings 256D\n"
-    status += "• Training su dati pubblici di qualità\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"
     
     return status
 
@@ -592,87 +662,104 @@ 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>🧠 Token Predictor AI</h1>
-        <p><b>Neural Network che impara a predire il prossimo token</b></p>
-        <p>Input: Milioni di token da database pubblici → Process: Auto-organizzazione neurale → Output: Predizione intelligente</p>
+        <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>
     </div>
     """)
     
     with gr.Row():
         with gr.Column(scale=2):
-            gr.HTML("<h3>🎯 Token Prediction</h3>")
+            gr.HTML("<h3>💬 Conversazione con AI</h3>")
             
-            context_input = gr.Textbox(
-                label="Contesto",
-                placeholder="Es: The capital of France is",
-                lines=2
+            chatbot = gr.Chatbot(
+                label="Chat con Question Answering AI",
+                height=400,
+                show_label=True,
+                bubble_full_width=False
             )
             
-            predict_btn = gr.Button("🔮 Predici Next Token", variant="primary")
-            
-            prediction_output = gr.Textbox(
-                label="Predizioni",
-                lines=10,
-                interactive=False
+            msg_input = gr.Textbox(
+                label="La tua domanda",
+                placeholder="Es: What is artificial intelligence? Where is the capital of France?",
+                lines=2
             )
+            
+            with gr.Row():
+                send_btn = gr.Button("💬 Invia", variant="primary")
+                clear_btn = gr.Button("🔄 Clear Chat", variant="secondary")
         
         with gr.Column(scale=1):
-            gr.HTML("<h3>⚙️ Training & Status</h3>")
+            gr.HTML("<h3>⚙️ Sistema & Training</h3>")
             
-            status_output = gr.Textbox(
-                label="Status Modello",
-                lines=15,
+            status_display = gr.Textbox(
+                label="Status Sistema",
+                lines=20,
                 interactive=False,
-                value=get_model_status()
+                value=get_system_status()
             )
             
-            train_btn = gr.Button("🚀 Avvia Data Collection & Training", variant="secondary")
+            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")
             refresh_btn = gr.Button("🔄 Refresh Status", variant="secondary")
     
+    # Examples
+    gr.Examples(
+        examples=[
+            "What is machine learning?",
+            "How does artificial intelligence 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?"
+        ],
+        inputs=msg_input,
+        label="🎯 Esempi di Domande"
+    )
+    
     gr.HTML("""
     <div style="margin-top: 20px; padding: 15px; background-color: #f0f0f0; border-radius: 8px;">
-        <h4>🔬 Come Funziona:</h4>
+        <h4>🧠 Question Answering Pipeline:</h4>
         <ol>
-            <li><b>Data Collection:</b> Raccoglie token da fonti pubbliche (RSS news, Wikipedia, ArXiv, Project Gutenberg)</li>
-            <li><b>Quality Filtering:</b> Filtra contenuti per qualità linguistica e strutturale</li>
-            <li><b>Tokenization:</b> Converte testo in token discreti</li>
-            <li><b>Pattern Extraction:</b> Estrae bigram e trigram per apprendimento</li>
-            <li><b>Neural Training:</b> Addestra rete neurale per predizione next token</li>
-            <li><b>Prediction:</b> Usa pattern appresi per predire token successivi</li>
+            <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>
         </ol>
-        <p><b>🎯 Obiettivo:</b> AI che predice bene il prossimo token tramite auto-organizzazione neurale su milioni di esempi!</p>
+        <p><b>🎯 Risultato:</b> AI che risponde intelligentemente usando conoscenza appresa dai dati!</p>
     </div>
     """)
     
-    # Examples
-    gr.Examples(
-        examples=[
-            "The weather today is",
-            "Artificial intelligence will",
-            "The capital of Italy is",
-            "Machine learning algorithms",
-            "In the year 2030",
-            "The most important thing"
-        ],
-        inputs=context_input
-    )
-    
     # Event handlers
-    predict_btn.click(
-        predict_interface,
-        inputs=[context_input],
-        outputs=[prediction_output]
+    send_btn.click(
+        chat_interface,
+        inputs=[msg_input, chatbot],
+        outputs=[chatbot, msg_input]
     )
     
-    train_btn.click(
-        collect_and_train,
-        outputs=[status_output]
+    msg_input.submit(
+        chat_interface,
+        inputs=[msg_input, chatbot],
+        outputs=[chatbot, msg_input]
     )
     
-    refresh_btn.click(
-        get_model_status,
-        outputs=[status_output]
+    clear_btn.click(
+        lambda: ([], ""),
+        outputs=[chatbot, msg_input]
     )
-
-if __name__ == "__main__":
-    demo.launch()
+    
+    train_