Update app.py

app.py

@@ -94,39 +94,105 @@ class VectorizedGeopoliticalAI:
             self.entity_embeddings[entity] = vector / (np.linalg.norm(vector) + 1e-8)
     
     def text_to_vector(self, text):
-        """Converte testo in rappresentazione vettoriale"""
-        # Tokenizzazione e pesatura TF-IDF semplificata
-        words = re.findall(r'\b\w+\b', text.lower())
+        """Converte testo in rappresentazione vettoriale robusta"""
+        if not text or not text.strip():
+            # Vettore casuale per input vuoti
+            return np.random.normal(0, 0.1, self.vector_dimensions)
         
-        # Crea vettore composito
+        words = re.findall(r'\b\w+\b', text.lower())
         composite_vector = np.zeros(self.vector_dimensions)
-        word_count = 0
         
-        # Mappa semantica delle parole chiave
+        # Mappa semantica estesa con pattern matching robusto
         semantic_mapping = {
-            'war': 'conflict', 'peace': 'diplomacy', 'trade': 'economy',
-            'military': 'military', 'sanctions': 'economy', 'alliance': 'alliance',
-            'nuclear': 'military', 'energy': 'resource', 'oil': 'resource',
-            'crisis': 'conflict', 'negotiation': 'diplomacy', 'summit': 'diplomacy'
+            # Conflitti e tensioni
+            'war': 'conflict', 'guerra': 'conflict', 'fight': 'conflict',
+            'conflict': 'conflict', 'crisis': 'conflict', 'tension': 'conflict',
+            'attack': 'military', 'invasion': 'military', 'strike': 'military',
+            
+            # Diplomazia e pace
+            'peace': 'diplomacy', 'pace': 'diplomacy', 'negotiation': 'diplomacy',
+            'summit': 'diplomacy', 'agreement': 'diplomacy', 'treaty': 'diplomacy',
+            'diplomatic': 'diplomacy', 'dialogue': 'diplomacy',
+            
+            # Economia e commercio
+            'trade': 'economy', 'economic': 'economy', 'economy': 'economy',
+            'sanctions': 'economy', 'embargo': 'economy', 'tariff': 'economy',
+            'market': 'economy', 'investment': 'economy', 'gdp': 'economy',
+            
+            # Militare e sicurezza
+            'military': 'military', 'defense': 'military', 'security': 'military',
+            'nuclear': 'military', 'missile': 'military', 'weapon': 'military',
+            'army': 'military', 'navy': 'military', 'airforce': 'military',
+            
+            # Alleanze e organizzazioni
+            'alliance': 'alliance', 'nato': 'alliance', 'partnership': 'alliance',
+            'coalition': 'alliance', 'bloc': 'alliance', 'union': 'alliance',
+            
+            # Risorse e territorio
+            'oil': 'resource', 'gas': 'resource', 'energy': 'resource',
+            'water': 'resource', 'mineral': 'resource', 'pipeline': 'resource',
+            'territory': 'territory', 'border': 'territory', 'region': 'territory',
+            
+            # Potere e influenza
+            'power': 'power', 'influence': 'influence', 'control': 'power',
+            'domination': 'power', 'hegemony': 'power', 'superpower': 'power',
+            
+            # Paesi specifici (mapping diretto)
+            'ukraine': 'conflict', 'russia': 'power', 'china': 'power',
+            'usa': 'power', 'america': 'power', 'taiwan': 'conflict',
+            'iran': 'conflict', 'israel': 'conflict', 'gaza': 'conflict'
         }
         
+        matched_words = 0
+        semantic_weights = defaultdict(float)
+        
+        # Prima passata: mapping diretto
         for word in words:
-            if word in semantic_mapping and semantic_mapping[word] in self.semantic_space:
+            if word in semantic_mapping:
                 concept = semantic_mapping[word]
-                composite_vector += self.semantic_space[concept]
-                word_count += 1
+                if concept in self.semantic_space:
+                    semantic_weights[concept] += 1.0
+                    matched_words += 1
             elif word in self.semantic_space:
-                composite_vector += self.semantic_space[word]
-                word_count += 1
-        
-        # Normalizzazione con peso logaritmico
-        if word_count > 0:
-            composite_vector /= math.log(word_count + 1)
+                semantic_weights[word] += 1.0
+                matched_words += 1
+        
+        # Seconda passata: pattern parziali
+        if matched_words == 0:
+            for word in words:
+                for pattern, concept in semantic_mapping.items():
+                    if pattern in word or word in pattern:
+                        if concept in self.semantic_space:
+                            semantic_weights[concept] += 0.5
+                            matched_words += 0.5
+        
+        # Costruzione vettore con pesi
+        for concept, weight in semantic_weights.items():
+            if concept in self.semantic_space:
+                composite_vector += weight * self.semantic_space[concept]
+        
+        # Aggiungi componente casuale se nessun match
+        if matched_words == 0:
+            # Crea vettore basato su hash del testo per consistenza
+            text_hash = int(hashlib.md5(text.encode()).hexdigest(), 16)
+            np.random.seed(text_hash % 2**31)
+            composite_vector = np.random.normal(0, 0.3, self.vector_dimensions)
+            matched_words = 1
+        
+        # Normalizzazione adattiva
+        if matched_words > 0:
+            composite_vector *= math.log(matched_words + 1) / (matched_words + 0.1)
+        
+        # Assicura che il vettore non sia zero
+        norm = np.linalg.norm(composite_vector)
+        if norm < 1e-6:
+            composite_vector = np.random.normal(0, 0.1, self.vector_dimensions)
+            norm = np.linalg.norm(composite_vector)
             
-        return composite_vector / (np.linalg.norm(composite_vector) + 1e-8)
+        return composite_vector / norm
     
     def compute_entity_relations(self, entities):
-        """Calcola relazioni tra entità nello spazio vettoriale"""
+        """Calcola relazioni tra entità nello spazio vettoriale con valori realistici"""
         relations = {}
         
         for i, entity1 in enumerate(entities):
@@ -140,24 +206,62 @@ class VectorizedGeopoliticalAI:
                 vec1 = self.entity_embeddings[entity1]
                 vec2 = self.entity_embeddings[entity2]
                 
-                # Similarità coseno
-                cosine_sim = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+                # Similarità coseno con correzione numerica
+                dot_product = np.dot(vec1, vec2)
+                norm_product = np.linalg.norm(vec1) * np.linalg.norm(vec2)
+                cosine_sim = dot_product / (norm_product + 1e-8)
                 
                 # Distanza euclidea normalizzata
                 euclidean_dist = np.linalg.norm(vec1 - vec2) / math.sqrt(self.vector_dimensions)
                 
-                # Proiezione su spazio delle alleanze
-                alliance_projection = np.dot(vec1 + vec2, self.semantic_space['alliance'])
+                # Proiezioni su sottospazi semantici
+                alliance_vec = self.semantic_space['alliance']
+                conflict_vec = self.semantic_space['conflict']
+                
+                # Proiezione alliance: (v1 + v2) · alliance_basis
+                alliance_sum = (vec1 + vec2) / 2
+                alliance_projection = np.dot(alliance_sum, alliance_vec)
+                
+                # Proiezione conflict: |v1 - v2| · conflict_basis  
+                conflict_diff = vec1 - vec2
+                conflict_projection = abs(np.dot(conflict_diff, conflict_vec))
                 
-                # Proiezione su spazio dei conflitti
-                conflict_projection = np.dot(vec1 - vec2, self.semantic_space['conflict'])
+                # Power differential basato su norma dei vettori
+                power_diff = np.linalg.norm(vec1) - np.linalg.norm(vec2)
+                
+                # Relazioni storiche note (override per realismo)
+                historical_adjustments = {
+                    ('Russia', 'Ukraine'): {'conflict_boost': 0.7, 'alliance_penalty': -0.8},
+                    ('USA', 'Russia'): {'conflict_boost': 0.4, 'alliance_penalty': -0.6},
+                    ('USA', 'China'): {'conflict_boost': 0.3, 'alliance_penalty': -0.5},
+                    ('Israel', 'Iran'): {'conflict_boost': 0.8, 'alliance_penalty': -0.9},
+                    ('China', 'Taiwan'): {'conflict_boost': 0.9, 'alliance_penalty': -0.9},
+                    ('NATO', 'Russia'): {'conflict_boost': 0.6, 'alliance_penalty': -0.7}
+                }
+                
+                # Applica aggiustamenti storici
+                key = (entity1, entity2)
+                reverse_key = (entity2, entity1)
+                
+                if key in historical_adjustments:
+                    adj = historical_adjustments[key]
+                    conflict_projection += adj['conflict_boost']
+                    alliance_projection += adj['alliance_penalty']
+                elif reverse_key in historical_adjustments:
+                    adj = historical_adjustments[reverse_key]
+                    conflict_projection += adj['conflict_boost'] 
+                    alliance_projection += adj['alliance_penalty']
+                
+                # Clamp valori in range realistico
+                alliance_projection = max(-1.0, min(1.0, alliance_projection))
+                conflict_projection = max(0.0, min(1.0, conflict_projection))
                 
                 relations[(entity1, entity2)] = {
                     'similarity': cosine_sim,
                     'distance': euclidean_dist,
                     'alliance_potential': alliance_projection,
-                    'conflict_potential': abs(conflict_projection),
-                    'power_differential': np.linalg.norm(vec1) - np.linalg.norm(vec2)
+                    'conflict_potential': conflict_projection,
+                    'power_differential': power_diff
                 }
         
         return relations
@@ -462,28 +566,84 @@ class VectorizedGeopoliticalAI:
         return "\n".join(report_parts)
     
     def calculate_vector_risk_metrics(self, vector_analysis, relations):
-        """Calcola metriche di rischio basate su analisi vettoriale"""
+        """Calcola metriche di rischio basate su analisi vettoriale con valori realistici"""
+        
+        # Risk magnitude basato su proiezioni semantiche con pesi
+        conflict_indicators = {
+            'conflict': 3.0,    # Peso alto per conflitto diretto
+            'military': 2.5,    # Peso medio-alto per aspetti militari
+            'power': 1.5        # Peso medio per dinamiche di potere
+        }
+        
+        risk_magnitude = 0.0
+        for indicator, weight in conflict_indicators.items():
+            projection = abs(vector_analysis['semantic_projections'].get(indicator, 0))
+            risk_magnitude += projection * weight
+        
+        # Normalizza tra 0 e 1
+        risk_magnitude = min(risk_magnitude / 5.0, 1.0)
         
-        # Risk magnitude basato su proiezioni semantiche
-        conflict_indicators = ['conflict', 'military', 'power']
-        risk_magnitude = sum(abs(vector_analysis['semantic_projections'].get(indicator, 0)) 
-                           for indicator in conflict_indicators)
+        # Aggiungi boost se ci sono conflitti noti nelle relazioni
+        if relations:
+            max_conflict_potential = max(
+                (rel.get('conflict_potential', 0) for rel in relations.values()), 
+                default=0
+            )
+            risk_magnitude = max(risk_magnitude, max_conflict_potential * 0.7)
         
         # Entropy del sistema basata su trasformazioni contestuali
-        entropies = [transform['entropy'] for transform in vector_analysis['contextual_transforms'].values()]
-        system_entropy = np.mean(entropies) if entropies else 0
+        entropies = []
+        for context_name, transform in vector_analysis['contextual_transforms'].items():
+            # Calcola entropy dalla distribuzione del vettore trasformato
+            vector = transform['vector']
+            # Soft-max per creare distribuzione di probabilità
+            exp_vector = np.exp(vector - np.max(vector))
+            prob_dist = exp_vector / np.sum(exp_vector)
+            entropy = -np.sum(prob_dist * np.log(prob_dist + 1e-8))
+            entropies.append(entropy)
+        
+        # Entropy media normalizzata
+        system_entropy = np.mean(entropies) / math.log(self.vector_dimensions) if entropies else 0.3
+        
+        # Stability index basato su varianza delle relazioni + fattori aggiuntivi
+        stability_factors = []
         
-        # Stability index basato su varianza delle relazioni
         if relations:
+            # Varianza delle similarità
             similarities = [rel['similarity'] for rel in relations.values()]
-            stability = 1.0 - np.var(similarities) if similarities else 1.0
+            if similarities:
+                similarity_variance = np.var(similarities)
+                stability_factors.append(1.0 - similarity_variance)
+            
+            # Asimmetria di potere
+            power_diffs = [abs(rel['power_differential']) for rel in relations.values()]
+            if power_diffs:
+                power_asymmetry = np.mean(power_diffs)
+                stability_factors.append(1.0 - min(power_asymmetry, 1.0))
+        
+        # Stability semantica basata su coherenza delle proiezioni
+        semantic_projections = list(vector_analysis['semantic_projections'].values())
+        if semantic_projections:
+            semantic_coherence = 1.0 - (np.var(semantic_projections) / (np.mean(np.abs(semantic_projections)) + 1e-8))
+            stability_factors.append(max(0.0, min(1.0, semantic_coherence)))
+        
+        # Stability index finale
+        if stability_factors:
+            stability = np.mean(stability_factors)
         else:
-            stability = 0.5
+            stability = 0.5  # Default per situazioni neutre
+        
+        # Aggiustamenti basati su context
+        # Se ci sono molte trasformazioni attive, riduce stabilità
+        active_transforms = sum(1 for t in vector_analysis['contextual_transforms'].values() 
+                              if t['norm'] > 0.1)
+        if active_transforms > 3:
+            stability *= 0.85
         
         return {
-            'magnitude': min(risk_magnitude, 1.0),
-            'entropy': system_entropy,
-            'stability': stability
+            'magnitude': max(0.0, min(1.0, risk_magnitude)),
+            'entropy': max(0.0, min(1.0, system_entropy)), 
+            'stability': max(0.0, min(1.0, stability))
         }
 
 # Inizializza il sistema AI vettoriale