Delete app2.py

app2.py

@@ -1,1707 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-🚀 Enhanced Bilingual Data Anonymization Benchmark System
-====================================================================
-نسخه پیشرفته با مقایسه واقعی متون اصلی و ناشناس‌سازی شده
-"""
-
-import gradio as gr
-import pandas as pd
-import numpy as np
-import json
-import time
-import os
-import re
-import logging
-import requests
-from datetime import datetime
-from functools import lru_cache
-from packaging import version
-from typing import Dict, List, Tuple, Any, Optional
-import warnings
-import gc
-import threading
-from collections import defaultdict, Counter
-import hashlib
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import multiprocessing
-from dataclasses import dataclass
-from difflib import SequenceMatcher
-
-# Enhanced metrics imports
-try:
-    import psutil
-    PSUTIL_AVAILABLE = True
-except ImportError:
-    PSUTIL_AVAILABLE = False
-
-try:
-    from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score, classification_report
-    from sklearn.feature_extraction.text import TfidfVectorizer
-    from sklearn.cluster import KMeans
-    SKLEARN_AVAILABLE = True
-except ImportError:
-    SKLEARN_AVAILABLE = False
-
-try:
-    import spacy
-    SPACY_AVAILABLE = True
-except ImportError:
-    SPACY_AVAILABLE = False
-
-warnings.filterwarnings('ignore')
-
-# تنظیم logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# =============================================================================
-# Data Classes for Better Structure
-# =============================================================================
-
-@dataclass
-class ComparisonResult:
-    """نتیجه مقایسه متن اصلی با ناشناس‌سازی شده"""
-    index: int
-    success: bool
-    processing_time_ms: float
-    original_text: str
-    anonymized_text: str
-    original_length: int
-    anonymized_length: int
-    entities_should_anonymize: int
-    entities_correctly_anonymized: int
-    entities_missed: int
-    missed_entities_list: List[Dict]
-    anonymization_accuracy: float
-    precision: float
-    recall: float
-    f1_score: float
-    detected_language: str
-    confidence_score: float
-    memory_used_mb: float
-    entity_categories: Dict[str, int]
-    error: Optional[str] = None
-
-@dataclass
-class BenchmarkConfig:
-    """تنظیمات بنچمارک"""
-    sample_size: int = 200
-    max_workers: int = 4
-    enable_parallel_processing: bool = True
-    enable_memory_profiling: bool = True
-    enable_language_detection: bool = True
-    enable_confidence_scoring: bool = True
-    stress_test_iterations: int = 50
-    enable_clustering_analysis: bool = False
-
-# =============================================================================
-# Enhanced Pattern Library
-# =============================================================================
-
-class EnhancedPatternLibrary:
-    """کتابخانه الگوهای پیشرفته"""
-    
-    def __init__(self):
-        self.patterns = self._load_enhanced_patterns()
-        self.compiled_patterns = self._compile_patterns()
-        
-    def _load_enhanced_patterns(self):
-        """بارگذاری الگوهای پیشرفته و جامع‌تر"""
-        return {
-            'PERSIAN_PERSON': [
-                r'آقای\s+([آ-ی\u200C]{2,}(?:\s+[آ-ی\u200C]{2,})*)',
-                r'خانم\s+([آ-ی\u200C]{2,}(?:\s+[آ-ی\u200C]{2,})*)',
-                r'مهندس\s+([آ-ی\u200C]{2,}(?:\s+[آ-ی\u200C]{2,})*)',
-                r'دکتر\s+([آ-ی\u200C]{2,}(?:\s+[آ-ی\u200C]{2,})*)',
-                r'استاد\s+([آ-ی\u200C]{2,}(?:\s+[آ-ی\u200C]{2,})*)',
-                r'([آ-ی\u200C]{3,}\s+[آ-ی\u200C]{3,})(?=\s+مدیرعامل|\s+رئیس|\s+مدیر|[،.]|\s*$)',
-                r'\b([آ-ی\u200C]{3,}(?:\s+[آ-ی\u200C]{3,}){1,2})\b',
-                # نام‌های متداول فارسی
-                r'\b(احمد|علی|حسن|حسین|محمد|رضا|مهدی|امیر|سعید|مجید|فرهاد|بهرام|کامران|داود|یوسف|ابراهیم)\s+[آ-ی\u200C]{3,}\b',
-                r'\b[آ-ی\u200C]{3,}\s+(احمدی|علوی|حسینی|محمدی|رضایی|کریمی|موسوی|صادقی|مرادی|فرهادی)\b',
-            ],
-            'ENGLISH_PERSON': [
-                r'(Mr\.|Mrs\.|Ms\.|Dr\.|Prof\.)\s+([A-Z][a-z]{2,}(?:\s+[A-Z][a-z]{2,})*)',
-                r'\b([A-Z][a-z]{2,}\s+[A-Z][a-z]{2,})(?=\s+(?:CEO|President|Manager|Director|said|stated|announced))',
-                r'\b([A-Z][a-z]{2,}(?:\s+[A-Z]\.)*\s+[A-Z][a-z]{2,})\b',
-                # نام‌های متداول انگلیسی
-                r'\b(John|James|Michael|William|David|Richard|Joseph|Thomas|Christopher|Daniel|Paul|Mark|Donald|Steven|Andrew|Kenneth|Paul|Joshua|Kevin|Brian|George|Timothy|Ronald|Jason|Edward|Jeffrey|Ryan|Jacob|Gary|Nicholas|Eric|Jonathan|Stephen|Larry|Justin|Scott|Brandon|Benjamin|Samuel|Gregory|Frank|Raymond|Alexander|Patrick|Jack|Dennis|Jerry|Tyler|Aaron|Jose|Henry|Adam|Douglas|Nathan|Zachary|Kyle)\s+[A-Z][a-z]{2,}\b',
-                r'\b[A-Z][a-z]{2,}\s+(Smith|Johnson|Williams|Brown|Jones|Garcia|Miller|Davis|Rodriguez|Martinez|Hernandez|Lopez|Gonzalez|Wilson|Anderson|Thomas|Taylor|Moore|Jackson|Martin|Lee|Perez|Thompson|White|Harris|Sanchez|Clark|Ramirez|Lewis|Robinson|Walker|Young|Allen|King|Wright|Scott|Torres|Nguyen|Hill|Flores|Green|Adams|Nelson|Baker|Hall|Rivera|Campbell|Mitchell|Carter|Roberts)\b',
-            ],
-            'ENHANCED_PHONE': [
-                r'(?:تلفن|موبایل|تماس)[\s:]*(?:\+98|0098)?(?:0)?([۰-۹0-9]{10,11})',
-                r'(?:\+98|0098)[\s\-]?([۰-۹0-9]{2,3})[\s\-]?([۰-۹0-9]{7,8})',
-                r'(?:^|[^\d])0([۰-۹0-9]{2,3})[\s\-]?([۰-۹0-9]{7,8})',
-                r'\b([۰-۹0-9]{4})[\s\-]([۰-۹0-9]{3})[\s\-]([۰-۹0-9]{4})\b',
-                r'\b(\+\d{1,3}[\s\-]?\d{3}[\s\-]?\d{3}[\s\-]?\d{4})\b',
-                r'\b(\d{3}[-.]?\d{3}[-.]?\d{4})\b',
-                r'\b([۰-۹]{4}[\s\-][۰-۹]{7})\b',
-                r'\b(09[۰-۹0-9]{9})\b',  # شماره موبایل ایرانی
-                # الگوهای تلفن بین‌المللی
-                r'\b(\+1[\s\-]?\d{3}[\s\-]?\d{3}[\s\-]?\d{4})\b',  # US
-                r'\b(\+44[\s\-]?\d{4}[\s\-]?\d{6})\b',  # UK
-            ],
-            'ENHANCED_EMAIL': [
-                r'\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})\b',
-                r'(?:ایمیل|email)[\s:]*([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})',
-                r'\b([a-zA-Z0-9._%+-]+@(?:gmail|yahoo|hotmail|outlook|aol)\.com)\b',
-            ],
-            'ENHANCED_NATIONAL_ID': [
-                r'(?:کد\s*ملی|شناسه\s*ملی)[\s:]*([۰-۹0-9]{10})',
-                r'(?:National\s*ID)[\s:]*([0-9]{10})',
-                r'(?:شماره\s*شناسنامه)[\s:]*([۰-۹0-9]{1,10})',
-                r'\b([۰-۹0-9]{10})\b',
-                r'(?:SSN|Social\s*Security)[\s:]*([0-9]{3}-[0-9]{2}-[0-9]{4})',
-            ],
-            'ENHANCED_BANK_ACCOUNT': [
-                r'(?:شماره\s*حساب|حساب\s*بانکی)[\s:]*([۰-۹0-9\-]{10,20})',
-                r'(?:شبا|IBAN)[\s:]*IR([۰-۹0-9]{24})',
-                r'(?:کارت\s*بانکی)[\s:]*([۰-۹0-9]{4}[\s\-]?[۰-۹0-9]{4}[\s\-]?[۰-۹0-9]{4}[\s\-]?[۰-۹0-9]{4})',
-                r'\b([0-9]{4}[\s\-]?[0-9]{4}[\s\-]?[0-9]{4}[\s\-]?[0-9]{4})\b',
-                r'\b([0-9]{10,20})\b(?=.*(?:account|حساب))',
-                # الگوهای کارت اعتباری
-                r'\b(4[0-9]{12}(?:[0-9]{3})?)\b',  # Visa
-                r'\b(5[1-5][0-9]{14})\b',  # MasterCard
-                r'\b(3[47][0-9]{13})\b',  # American Express
-            ],
-            'ENHANCED_AMOUNT': [
-                r'(?:مبلغ)?\s*([۰-۹0-9,]+)\s*(?:میلیون|میلیارد|هزار)?\s*(?:تومان|ریال)',
-                r'\$([0-9,]+(?:\.[0-9]{2})?)\s*(?:million|billion|thousand|M|B|K)?',
-                r'€([0-9,]+(?:\.[0-9]{2})?)',
-                r'£([0-9,]+(?:\.[0-9]{2})?)',
-                r'\b([0-9,]+(?:\.[0-9]{2})?)\s*(?:dollar|euro|pound|USD|EUR|GBP)s?\b',
-                r'\b([۰-۹0-9,]+)\s*(?:درهم|دینار|ین|یوان)\b',
-            ],
-            'ENHANCED_DATE': [
-                r'([۰-۹0-9]{4})[/\-]([۰-۹0-9]{1,2})[/\-]([۰-۹0-9]{1,2})',
-                r'([۰-۹0-9]{1,2})[/\-]([۰-۹0-9]{1,2})[/\-]([۰-۹0-9]{4})',
-                r'(\d{1,2})\s+(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{4})',
-                r'(\d{1,2})\s+(فروردین|اردیبهشت|خرداد|تیر|مرداد|شهریور|مهر|آبان|آذر|دی|بهمن|اسفند)\s+(\d{4})',
-                r'\b(\d{1,2}/\d{1,2}/\d{2,4})\b',
-                r'\b(\d{4}-\d{2}-\d{2})\b',  # ISO format
-                r'\b([۰-۹]{4}/[۰-۹]{1,2}/[۰-۹]{1,2})\b',
-            ],
-            'ENHANCED_COMPANY': [
-                r'(?:شرکت)\s+([آ-ی\u200C\s]{3,}?)(?=\s+در|\s+که|\s+با|[،.]|\s*$)',
-                r'(?:بانک)\s+([آ-ی\u200C\s]{3,})',
-                r'\b([A-Z][a-zA-Z\s&]{2,}(?:Inc|Corp|Corporation|Company|Ltd|Limited|LLC|LLP))\b',
-                r'\b([A-Z][a-zA-Z\s&]{2,}Bank)\b',
-                r'\b(Apple|Google|Microsoft|Amazon|Facebook|Tesla|Netflix|IBM|Oracle|Samsung|Sony|Toyota|BMW|Mercedes|Volkswagen|Ford|General Motors)\b',
-                r'\b([آ-ی\u200C]{3,}(?:\s+[آ-ی\u200C]{3,})*)\s+(?:شرکت|گروه|هلدینگ|صنایع)\b',
-            ],
-            'ENHANCED_LOCATION': [
-                r'(?:شهر|استان)\s+([آ-ی\u200C\s]{2,})',
-                r'\b(تهران|اصفهان|شیراز|مشهد|تبریز|اهواز|کرج|قم|کرمان|یزد|ساری|گرگان|رشت|ارومیه|زاهدان|کرمانشاه|همدان|اراک|قزوین|زنجان|سنندج|ایلام|یاسوج|بجنورد|گر��ان|بندرعباس|بوشهر)\b',
-                r'(خیابان|کوچه|بلوار|میدان)\s+([آ-ی\u200C\s]{2,})',
-                r'پلاک\s*([۰-۹0-9]+)',
-                r'\b([A-Z][a-zA-Z\s]{2,}(?:Street|Avenue|Road|Boulevard|Drive|Lane|Way))\b',
-                r'\b([A-Z][a-zA-Z\s]{2,},\s*[A-Z]{2}\s+\d{5})\b',
-                r'\b(New York|Los Angeles|Chicago|Houston|Phoenix|Philadelphia|San Antonio|San Diego|Dallas|San Jose|Austin|Jacksonville|Fort Worth|Columbus|Charlotte|San Francisco|Indianapolis|Seattle|Denver|Washington|Boston|El Paso|Detroit|Nashville|Portland|Memphis|Oklahoma City|Las Vegas|Louisville|Baltimore|Milwaukee|Albuquerque|Tucson|Fresno|Sacramento|Long Beach|Kansas City|Mesa|Virginia Beach|Atlanta|Colorado Springs|Omaha|Raleigh|Miami|Oakland|Minneapolis|Tulsa|Cleveland|Wichita|Arlington)\b',
-                # کشورها
-                r'\b(Iran|Iraq|Turkey|Afghanistan|Pakistan|India|China|Russia|Germany|France|Italy|Spain|United Kingdom|Canada|Australia|Japan|South Korea|Brazil|Mexico|Argentina)\b',
-                r'\b(ایران|عراق|ترکیه|افغانستان|پاکستان|هندوستان|چین|روسیه|آلمان|فرانسه|ایتالیا|اسپانیا|انگلستان|کانادا|استرالیا|ژاپن|کره جنوبی|برزیل|مکزیک|آرژانتین)\b',
-            ],
-            'ENHANCED_PERCENTAGE': [
-                r'([۰-۹0-9]+(?:\.[۰-۹0-9]+)?)\s*درصد',
-                r'([۰-۹0-9]+(?:\.[۰-۹0-9]+)?)\s*%',
-                r'(?:رشد|افزایش|کاهش|تغییر)\s+([۰-۹0-9]+(?:\.[۰-۹0-9]+)?)\s*درصدی',
-                r'\b([0-9]+(?:\.[0-9]+)?)\s*percent\b',
-            ],
-            'ENHANCED_ADDRESS': [
-                r'([آ-ی\u200C\s]{2,})\s*،\s*(خیابان|کوچه|بلوار|میدان)\s+([آ-ی\u200C\s]{2,})\s*،\s*پلاک\s*([۰-۹0-9]+)',
-                r'([0-9]+)\s+([A-Z][a-zA-Z\s]{2,}(?:Street|Avenue|Road|Boulevard|Drive|Lane))',
-                r'\b([0-9]+\s+[A-Z][a-zA-Z\s]{2,},\s*[A-Z][a-zA-Z\s]{2,},\s*[A-Z]{2}\s+[0-9]{5})\b',
-            ],
-            'ENHANCED_IP_ADDRESS': [
-                r'\b((?:[0-9]{1,3}\.){3}[0-9]{1,3})\b',
-                r'\b([0-9a-fA-F:]+::[0-9a-fA-F:]+)\b',  # IPv6
-            ],
-            'ENHANCED_URL': [
-                r'\b(https?://[^\s]+)\b',
-                r'\b(www\.[^\s]+\.[a-zA-Z]{2,})\b',
-            ]
-        }
-    
-    def _compile_patterns(self):
-        """کامپایل الگوهای regex برای بهبود عملکرد"""
-        compiled = {}
-        for category, patterns in self.patterns.items():
-            compiled[category] = [re.compile(pattern, re.IGNORECASE | re.UNICODE) for pattern in patterns]
-        return compiled
-    
-    def find_matches(self, text: str, category: Optional[str] = None) -> Dict[str, List[Tuple[str, int, int]]]:
-        """پیدا کردن تطبیق‌ها با بازگشت موقعیت"""
-        matches = defaultdict(list)
-        
-        patterns_to_check = {category: self.compiled_patterns[category]} if category else self.compiled_patterns
-        
-        for cat, compiled_patterns in patterns_to_check.items():
-            for pattern in compiled_patterns:
-                for match in pattern.finditer(text):
-                    matched_text = match.group(1) if match.groups() else match.group(0)
-                    if matched_text and matched_text.strip():
-                        matches[cat].append((matched_text.strip(), match.start(), match.end()))
-        
-        return dict(matches)
-
-# =============================================================================
-# Enhanced Comparison Anonymizer
-# =============================================================================
-
-class EnhancedComparisonAnonymizer:
-    """سیستم مقایسه و ارزیابی ناشناس‌سازی"""
-    
-    def __init__(self, config: BenchmarkConfig):
-        self.config = config
-        self.pattern_lib = EnhancedPatternLibrary()
-        self.processing_stats = {
-            'total_processed': 0,
-            'total_entities_should_anonymize': 0,
-            'total_entities_correctly_anonymized': 0,
-            'total_entities_missed': 0,
-            'language_distribution': Counter(),
-        }
-        
-        # Load models if available
-        self.models_loaded = False
-        self.load_models()
-    
-    def load_models(self):
-        """بارگذاری مدل‌های NER"""
-        try:
-            if SPACY_AVAILABLE:
-                try:
-                    import spacy
-                    self.nlp_en = spacy.load("en_core_web_sm")
-                    logger.info("✅ English spaCy model loaded")
-                except OSError:
-                    logger.warning("⚠️ English spaCy model not found")
-                    self.nlp_en = None
-                
-                try:
-                    self.nlp_fa = spacy.load("fa_core_news_sm")
-                    logger.info("✅ Persian spaCy model loaded")
-                except OSError:
-                    logger.warning("⚠️ Persian spaCy model not found")
-                    self.nlp_fa = None
-                
-                self.models_loaded = (self.nlp_en is not None) or (self.nlp_fa is not None)
-            
-        except Exception as e:
-            logger.error(f"❌ Error loading models: {e}")
-            self.models_loaded = False
-    
-    def detect_language(self, text: str) -> str:
-        """تشخیص زبان متن"""
-        persian_chars = len(re.findall(r'[\u0600-\u06FF]', text))
-        english_chars = len(re.findall(r'[a-zA-Z]', text))
-        total_chars = persian_chars + english_chars
-        
-        if total_chars == 0:
-            return 'unknown'
-        
-        persian_ratio = persian_chars / total_chars
-        english_ratio = english_chars / total_chars
-        
-        if persian_ratio > 0.7:
-            return 'fa'
-        elif english_ratio > 0.7:
-            return 'en'
-        elif persian_ratio > 0.3 and english_ratio > 0.3:
-            return 'mixed'
-        elif persian_ratio > english_ratio:
-            return 'fa'
-        else:
-            return 'en'
-    
-    def compare_texts(self, original_text: str, anonymized_text: str) -> ComparisonResult:
-        """مقایسه متن اصلی با ناشناس‌سازی شده"""
-        start_time = time.time()
-        memory_before = self._get_memory_usage()
-        
-        try:
-            # تشخیص زبان
-            detected_lang = self.detect_language(original_text)
-            
-            # پیدا کردن موجودیت‌هایی که باید ناشناس‌سازی شوند
-            original_entities = self._find_all_entities(original_text, detected_lang)
-            
-            # بررسی اینکه کدام موجودیت‌ها ناشناس‌سازی شده‌اند
-            correctly_anonymized, missed_entities = self._check_anonymization_quality(
-                original_text, anonymized_text, original_entities
-            )
-            
-            # محاسبه متریک‌ها
-            total_should_anonymize = len(original_entities)
-            correctly_anonymized_count = len(correctly_anonymized)
-            missed_count = len(missed_entities)
-            
-            # محاسبه دقت، بازخوانی و F1
-            precision = correctly_anonymized_count / max(1, correctly_anonymized_count + self._count_false_positives(anonymized_text))
-            recall = correctly_anonymized_count / max(1, total_should_anonymize)
-            f1 = 2 * (precision * recall) / max(0.001, precision + recall)
-            anonymization_accuracy = correctly_anonymized_count / max(1, total_should_anonymize)
-            
-            # محاسبه آمار
-            processing_time = (time.time() - start_time) * 1000
-            memory_after = self._get_memory_usage()
-            memory_used = max(0, memory_after - memory_before)
-            
-            confidence = self._calculate_confidence_score(original_entities, correctly_anonymized_count, total_should_anonymize)
-            
-            # شمارش دسته‌ها
-            entity_categories = defaultdict(int)
-            for entity in original_entities:
-                entity_categories[entity['category']] += 1
-            
-            # به‌روزرسانی آمار کلی
-            self.processing_stats['total_processed'] += 1
-            self.processing_stats['total_entities_should_anonymize'] += total_should_anonymize
-            self.processing_stats['total_entities_correctly_anonymized'] += correctly_anonymized_count
-            self.processing_stats['total_entities_missed'] += missed_count
-            self.processing_stats['language_distribution'][detected_lang] += 1
-            
-            return ComparisonResult(
-                index=self.processing_stats['total_processed'],
-                success=True,
-                processing_time_ms=processing_time,
-                original_text=original_text[:500] + "..." if len(original_text) > 500 else original_text,
-                anonymized_text=anonymized_text[:500] + "..." if len(anonymized_text) > 500 else anonymized_text,
-                original_length=len(original_text),
-                anonymized_length=len(anonymized_text),
-                entities_should_anonymize=total_should_anonymize,
-                entities_correctly_anonymized=correctly_anonymized_count,
-                entities_missed=missed_count,
-                missed_entities_list=missed_entities,
-                anonymization_accuracy=anonymization_accuracy,
-                precision=precision,
-                recall=recall,
-                f1_score=f1,
-                detected_language=detected_lang,
-                confidence_score=confidence,
-                memory_used_mb=memory_used,
-                entity_categories=dict(entity_categories)
-            )
-            
-        except Exception as e:
-            processing_time = (time.time() - start_time) * 1000
-            return ComparisonResult(
-                index=self.processing_stats['total_processed'],
-                success=False,
-                processing_time_ms=processing_time,
-                original_text=original_text[:200] + "..." if len(original_text) > 200 else original_text,
-                anonymized_text=anonymized_text[:200] + "..." if len(anonymized_text) > 200 else anonymized_text,
-                original_length=len(original_text),
-                anonymized_length=len(anonymized_text),
-                entities_should_anonymize=0,
-                entities_correctly_anonymized=0,
-                entities_missed=0,
-                missed_entities_list=[],
-                anonymization_accuracy=0.0,
-                precision=0.0,
-                recall=0.0,
-                f1_score=0.0,
-                detected_language='unknown',
-                confidence_score=0.0,
-                memory_used_mb=0.0,
-                entity_categories={},
-                error=str(e)
-            )
-    
-    def _find_all_entities(self, text: str, language: str) -> List[Dict]:
-        """پیدا کردن تمام موجودیت‌هایی که باید ناشناس‌سازی شوند"""
-        entities = []
-        
-        # استفاده از pattern matching
-        pattern_matches = self.pattern_lib.find_matches(text)
-        
-        for category, matches in pattern_matches.items():
-            for match_text, start, end in matches:
-                entities.append({
-                    'text': match_text,
-                    'category': category,
-                    'start': start,
-                    'end': end,
-                    'source': 'pattern'
-                })
-        
-        # استفاده از NER اگر در دسترس باشد
-        if self.models_loaded:
-            ner_entities = self._extract_entities_with_ner(text, language)
-            for entity in ner_entities:
-                entities.append({
-                    'text': entity['text'],
-                    'category': self._map_ner_label(entity['label']),
-                    'start': entity['start'],
-                    'end': entity['end'],
-                    'source': entity['source']
-                })
-        
-        # حذف تداخل‌ها
-        entities = self._remove_overlapping_entities(entities)
-        
-        return entities
-    
-    def _extract_entities_with_ner(self, text: str, language: str) -> List[Dict]:
-        """استخراج entities با مدل‌های NER"""
-        entities = []
-        
-        try:
-            if language in ['en', 'mixed'] and hasattr(self, 'nlp_en') and self.nlp_en:
-                doc = self.nlp_en(text)
-                for ent in doc.ents:
-                    entities.append({
-                        'text': ent.text,
-                        'label': ent.label_,
-                        'start': ent.start_char,
-                        'end': ent.end_char,
-                        'source': 'spacy_en'
-                    })
-            
-            if language in ['fa', 'mixed'] and hasattr(self, 'nlp_fa') and self.nlp_fa:
-                doc = self.nlp_fa(text)
-                for ent in doc.ents:
-                    entities.append({
-                        'text': ent.text,
-                        'label': ent.label_,
-                        'start': ent.start_char,
-                        'end': ent.end_char,
-                        'source': 'spacy_fa'
-                    })
-        
-        except Exception as e:
-            logger.error(f"Error in NER extraction: {e}")
-        
-        return entities
-    
-    def _map_ner_label(self, ner_label: str) -> str:
-        """نقشه‌برداری برچسب‌های NER"""
-        mapping = {
-            'PERSON': 'PERSIAN_PERSON',
-            'PER': 'PERSIAN_PERSON',
-            'ORG': 'ENHANCED_COMPANY',
-            'ORGANIZATION': 'ENHANCED_COMPANY',
-            'LOC': 'ENHANCED_LOCATION',
-            'LOCATION': 'ENHANCED_LOCATION',
-            'GPE': 'ENHANCED_LOCATION',
-            'MONEY': 'ENHANCED_AMOUNT',
-            'PERCENT': 'ENHANCED_PERCENTAGE',
-            'DATE': 'ENHANCED_DATE',
-            'TIME': 'ENHANCED_DATE'
-        }
-        return mapping.get(ner_label.upper(), 'OTHER')
-    
-    def _remove_overlapping_entities(self, entities: List[Dict]) -> List[Dict]:
-        """حذف موجودیت‌های همپوشان"""
-        entities.sort(key=lambda x: (x['start'], x['end'] - x['start']))
-        
-        filtered_entities = []
-        used_positions = []
-        
-        for entity in entities:
-            start, end = entity['start'], entity['end']
-            overlaps = any(not (end <= pos_start or start >= pos_end) for pos_start, pos_end in used_positions)
-            
-            if not overlaps:
-                filtered_entities.append(entity)
-                used_positions.append((start, end))
-        
-        return filtered_entities
-    
-    def _check_anonymization_quality(self, original_text: str, anonymized_text: str, entities: List[Dict]) -> Tuple[List[Dict], List[Dict]]:
-        """بررسی کیفیت ناشناس‌سازی"""
-        correctly_anonymized = []
-        missed_entities = []
-        
-        for entity in entities:
-            entity_text = entity['text']
-            
-            # بررسی اینکه آیا موجودیت در متن ناشناس‌سازی شده وجود دارد یا نه
-            if entity_text in anonymized_text:
-                # موجودیت ناشناس‌سازی نشده
-                missed_entities.append({
-                    'text': entity_text,
-                    'category': entity['category'],
-                    'reason': 'موجود در متن ناشناس‌سازی شده'
-                })
-            else:
-                # بررسی اینکه آیا جایگزین شده یا حذف شده
-                original_words = set(original_text.split())
-                anonymized_words = set(anonymized_text.split())
-                entity_words = set(entity_text.split())
-                
-                if entity_words.issubset(original_words) and not entity_words.issubset(anonymized_words):
-                    correctly_anonymized.append(entity)
-                else:
-                    # بررسی دقیق‌تر با استفاده از similarity
-                    if self._is_anonymized_with_similarity(original_text, anonymized_text, entity_text):
-                        correctly_anonymized.append(entity)
-                    else:
-                        missed_entities.append({
-                            'text': entity_text,
-                            'category': entity['category'],
-                            'reason': 'تشخیص ناشناس‌سازی ناموفق'
-                        })
-        
-        return correctly_anonymized, missed_entities
-    
-    def _is_anonymized_with_similarity(self, original: str, anonymized: str, entity_text: str) -> bool:
-        """بررسی ناشناس‌سازی با استفاده از شباهت متنی"""
-        try:
-            # حذف موجودیت از متن اصلی
-            original_without_entity = original.replace(entity_text, "[REMOVED]")
-            
-            # محاسبه شباهت
-            similarity = SequenceMatcher(None, original_without_entity, anonymized).ratio()
-            
-            # اگر شباهت بالا باشد، احتمالاً ناشناس‌سازی شده
-            return similarity > 0.7
-            
-        except:
-            return False
-    
-    def _count_false_positives(self, anonymized_text: str) -> int:
-        """شمارش کلمات اشتباه ناشناس‌سازی شده"""
-        # شمارش کلماتی که به نظر placeholder هستند اما نباید باشند
-        false_positive_patterns = [
-            r'\b[A-Z_]+_\d+_ANONYMIZED\b',
-            r'\[\w+\]',
-            r'\*+',
-        ]
-        
-        false_positives = 0
-        for pattern in false_positive_patterns:
-            false_positives += len(re.findall(pattern, anonymized_text))
-        
-        return false_positives
-    
-    def _calculate_confidence_score(self, entities: List[Dict], correctly_anonymized: int, total_entities: int) -> float:
-        """محاسبه امتیاز اعتماد"""
-        if total_entities == 0:
-            return 1.0
-        
-        accuracy = correctly_anonymized / total_entities
-        diversity = min(1.0, len(set(e['category'] for e in entities)) / 10)
-        
-        confidence = (accuracy * 0.8 + diversity * 0.2)
-        return round(confidence, 3)
-    
-    def _get_memory_usage(self) -> float:
-        """دریافت مصرف حافظه فعلی"""
-        if not PSUTIL_AVAILABLE or not self.config.enable_memory_profiling:
-            return 0.0
-        try:
-            process = psutil.Process()
-            return process.memory_info().rss / 1024 / 1024  # MB
-        except:
-            return 0.0
-
-# =============================================================================
-# Enhanced Benchmark Interface
-# =============================================================================
-
-class EnhancedBenchmarkInterface:
-    """رابط کاربری پیشرفته بنچمارک"""
-    
-    def __init__(self):
-        self.current_results = None
-        self.current_language = 'fa'
-        self.config = BenchmarkConfig()
-        
-        try:
-            self.anonymizer = EnhancedComparisonAnonymizer(self.config)
-            self.system_ready = True
-            logger.info("✅ Enhanced comparison system initialized")
-        except Exception as e:
-            logger.error(f"❌ System initialization failed: {e}")
-            self.system_ready = False
-    
-    def load_local_datasets(self) -> Tuple[List[Tuple[str, str]], List[Tuple[str, str]]]:
-        """بارگذاری دیتاست‌های محلی با جفت متون"""
-        persian_pairs = []
-        english_pairs = []
-        
-        def find_text_columns(df):
-            """پیدا کردن ستون‌های متن اصلی و ناشناس‌سازی شده"""
-            # تمیز کردن نام ستون‌ها
-            df.columns = df.columns.str.strip()
-            
-            original_col = None
-            anonymized_col = None
-            
-            # ستون‌های احتمالی برای متن اصلی
-            original_candidates = ['original_text', 'original', 'text', 'sentence', 'content', 'input']
-            # ستون‌های احتمالی برای متن ناشناس‌سازی شده  
-            anonymized_candidates = ['anonymized_text', 'anonymized', 'output', 'result', 'processed']
-            
-            logger.info(f"Available columns: {list(df.columns)}")
-            
-            for col in original_candidates:
-                if col in df.columns:
-                    original_col = col
-                    logger.info(f"Found original text column: {col}")
-                    break
-            
-            for col in anonymized_candidates:
-                if col in df.columns:
-                    anonymized_col = col
-                    logger.info(f"Found anonymized text column: {col}")
-                    break
-            
-            # اگر ستون‌های دقیق پیدا نشد، از دو ستون اول استفاده کن
-            if not original_col and not anonymized_col and len(df.columns) >= 2:
-                original_col = df.columns[0]
-                anonymized_col = df.columns[1]
-                logger.info(f"Using first two columns: {original_col}, {anonymized_col}")
-            
-            return original_col, anonymized_col
-        
-        try:
-            # بارگذاری دیتاست فارسی
-            fa_files = ['dataset-fa.csv', 'datasetfa.csv', 'datasetfa.txt', 'dataset_fa.csv']
-            for filename in fa_files:
-                if os.path.exists(filename):
-                    try:
-                        logger.info(f"Attempting to load Persian dataset: {filename}")
-                        
-                        if filename.endswith('.csv'):
-                            # تلاش برای خواندن با encoding های مختلف
-                            df_fa = None
-                            for encoding in ['utf-8', 'utf-8-sig', 'cp1256', 'iso-8859-1']:
-                                try:
-                                    df_fa = pd.read_csv(filename, encoding=encoding)
-                                    logger.info(f"Successfully read {filename} with encoding: {encoding}")
-                                    break
-                                except UnicodeDecodeError:
-                                    continue
-                            
-                            if df_fa is None:
-                                logger.error(f"Could not read {filename} with any encoding")
-                                continue
-                                
-                            logger.info(f"File shape: {df_fa.shape}")
-                            logger.info(f"Columns before cleaning: {list(df_fa.columns)}")
-                            
-                            original_col, anonymized_col = find_text_columns(df_fa)
-                            
-                            if original_col and anonymized_col:
-                                valid_pairs = 0
-                                for _, row in df_fa.iterrows():
-                                    try:
-                                        orig_text = str(row[original_col]).strip()
-                                        anon_text = str(row[anonymized_col]).strip()
-                                        
-                                        # بررسی اینکه متن‌ها معتبر هستند
-                                        if (orig_text and anon_text and 
-                                            orig_text != 'nan' and anon_text != 'nan' and
-                                            len(orig_text) > 5 and len(anon_text) > 5):
-                                            persian_pairs.append((orig_text, anon_text))
-                                            valid_pairs += 1
-                                    except Exception as e:
-                                        logger.warning(f"Error processing row: {e}")
-                                        continue
-                                        
-                                logger.info(f"✅ Loaded {valid_pairs} Persian pairs from {filename}")
-                                if valid_pairs > 0:
-                                    break
-                            else:
-                                logger.warning(f"❌ Could not find appropriate columns in {filename}")
-                                logger.warning(f"Available columns: {list(df_fa.columns)}")
-                                
-                    except Exception as e:
-                        logger.error(f"Error loading Persian {filename}: {e}")
-                        continue
-            
-            # بارگذاری دیتاست انگلیسی (همان منطق)
-            en_files = ['dataset-en.csv', 'dataseten.csv', 'dataseten.txt', 'dataset_en.csv']
-            for filename in en_files:
-                if os.path.exists(filename):
-                    try:
-                        logger.info(f"Attempting to load English dataset: {filename}")
-                        
-                        if filename.endswith('.csv'):
-                            df_en = None
-                            for encoding in ['utf-8', 'utf-8-sig', 'cp1256', 'iso-8859-1']:
-                                try:
-                                    df_en = pd.read_csv(filename, encoding=encoding)
-                                    logger.info(f"Successfully read {filename} with encoding: {encoding}")
-                                    break
-                                except UnicodeDecodeError:
-                                    continue
-                            
-                            if df_en is None:
-                                logger.error(f"Could not read {filename} with any encoding")
-                                continue
-                                
-                            logger.info(f"File shape: {df_en.shape}")
-                            logger.info(f"Columns before cleaning: {list(df_en.columns)}")
-                            
-                            original_col, anonymized_col = find_text_columns(df_en)
-                            
-                            if original_col and anonymized_col:
-                                valid_pairs = 0
-                                for _, row in df_en.iterrows():
-                                    try:
-                                        orig_text = str(row[original_col]).strip()
-                                        anon_text = str(row[anonymized_col]).strip()
-                                        
-                                        if (orig_text and anon_text and 
-                                            orig_text != 'nan' and anon_text != 'nan' and
-                                            len(orig_text) > 5 and len(anon_text) > 5):
-                                            english_pairs.append((orig_text, anon_text))
-                                            valid_pairs += 1
-                                    except Exception as e:
-                                        logger.warning(f"Error processing row: {e}")
-                                        continue
-                                        
-                                logger.info(f"✅ Loaded {valid_pairs} English pairs from {filename}")
-                                if valid_pairs > 0:
-                                    break
-                            else:
-                                logger.warning(f"❌ Could not find appropriate columns in {filename}")
-                                logger.warning(f"Available columns: {list(df_en.columns)}")
-                                
-                    except Exception as e:
-                        logger.error(f"Error loading English {filename}: {e}")
-                        continue
-                
-        except Exception as e:
-            logger.error(f"❌ Error loading local datasets: {e}")
-        
-        logger.info(f"Final counts - Persian: {len(persian_pairs)}, English: {len(english_pairs)}")
-        return persian_pairs, english_pairs
-    
-    def run_enhanced_benchmark(self, sample_size: int, enable_parallel: bool = True,
-                             enable_clustering: bool = False, progress=gr.Progress()):
-        """اجرای بنچمارک پیشرفته با مقایسه واقعی"""
-        
-        if not self.system_ready:
-            return self._get_error_response("System not ready")
-        
-        try:
-            progress(0.05, desc="Loading local datasets...")
-            
-            # بارگذاری دیتاست‌های محلی
-            persian_pairs, english_pairs = self.load_local_datasets()
-            
-            if not persian_pairs and not english_pairs:
-                return self._get_error_response("No text pairs loaded from local datasets. Check file format and columns.")
-            
-            # ترکیب جفت‌ها
-            all_pairs = persian_pairs + english_pairs
-            
-            # محدود کردن تعداد
-            if len(all_pairs) > sample_size:
-                all_pairs = all_pairs[:sample_size]
-            
-            # تنظیم پیکربندی
-            self.config.sample_size = len(all_pairs)
-            self.config.enable_parallel_processing = enable_parallel
-            self.config.enable_clustering_analysis = enable_clustering
-            
-            progress(0.1, desc=f"Comparing {len(all_pairs)} text pairs...")
-            
-            # پردازش جفت‌ها
-            results = []
-            start_time = time.time()
-            
-            if enable_parallel and len(all_pairs) > 10:
-                results = self._process_parallel(all_pairs, progress)
-            else:
-                results = self._process_sequential(all_pairs, progress)
-            
-            total_time = time.time() - start_time
-            
-            # محاسبه آمار کلی
-            progress(0.85, desc="Calculating comprehensive metrics...")
-            
-            successful_results = [r for r in results if r.success]
-            
-            if not successful_results:
-                return self._get_error_response("No successful results")
-            
-            # محاسبه متریک‌های پیشرفته
-            summary = self._calculate_comprehensive_metrics(successful_results, total_time)
-            
-            # اجرای تحلیل‌های اضافی
-            if enable_clustering and SKLEARN_AVAILABLE:
-                progress(0.92, desc="Running clustering analysis...")
-                clustering_results = self._run_clustering_analysis(successful_results)
-                summary['clustering_analysis'] = clustering_results
-            
-            # تست استرس
-            progress(0.95, desc="Running stress test...")
-            if all_pairs:
-                stress_results = self._run_stress_test(all_pairs[0])
-                summary['stress_test'] = stress_results
-            
-            # ذخیره نتایج
-            self.current_results = {
-                'summary': summary,
-                'detailed_results': [self._result_to_dict(r) for r in results],
-                'timestamp': datetime.now().isoformat(),
-                'benchmark_version': 'enhanced_comparison_v3.1',
-                'config': {
-                    'sample_size': sample_size,
-                    'parallel_processing': enable_parallel,
-                    'clustering_enabled': enable_clustering,
-                }
-            }
-            
-            progress(1.0, desc="Enhanced benchmark completed!")
-            
-            # ایجاد گزارش جامع متنی
-            detailed_report = self._create_comprehensive_report()
-            
-            success_msg = f"✅ Enhanced benchmark completed! Compared {len(all_pairs)} text pairs with real accuracy metrics"
-            
-            return (
-                success_msg,
-                detailed_report,  # فقط گزارش متنی
-                gr.update(visible=True),  # results visibility
-                gr.update(visible=True),  # download button
-            )
-            
-        except Exception as e:
-            logger.error(f"❌ Benchmark error: {e}")
-            return self._get_error_response(f"Benchmark failed: {str(e)}")
-    
-    def _process_sequential(self, pairs: List[Tuple[str, str]], progress) -> List[ComparisonResult]:
-        """پردازش ترتیبی جفت‌ها"""
-        results = []
-        
-        for i, (original, anonymized) in enumerate(pairs):
-            progress(0.1 + (0.7 * i / len(pairs)), 
-                    desc=f"Comparing pair {i+1}/{len(pairs)}")
-            
-            result = self.anonymizer.compare_texts(original, anonymized)
-            results.append(result)
-            
-            if i % 50 == 0:  # garbage collection هر 50 جفت
-                gc.collect()
-        
-        return results
-    
-    def _process_parallel(self, pairs: List[Tuple[str, str]], progress) -> List[ComparisonResult]:
-        """پردازش موازی جفت‌ها"""
-        results = []
-        completed = 0
-        
-        max_workers = min(self.config.max_workers, multiprocessing.cpu_count())
-        
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            # ارسال وظایف
-            future_to_index = {
-                executor.submit(self.anonymizer.compare_texts, original, anonymized): i 
-                for i, (original, anonymized) in enumerate(pairs)
-            }
-            
-            # جمع‌آوری نتایج
-            index_to_result = {}
-            
-            for future in as_completed(future_to_index):
-                index = future_to_index[future]
-                try:
-                    result = future.result()
-                    index_to_result[index] = result
-                except Exception as e:
-                    logger.error(f"Error processing pair {index}: {e}")
-                    original, anonymized = pairs[index] if index < len(pairs) else ("", "")
-                    index_to_result[index] = ComparisonResult(
-                        index=index,
-                        success=False,
-                        processing_time_ms=0,
-                        original_text=original[:200],
-                        anonymized_text=anonymized[:200],
-                        original_length=len(original),
-                        anonymized_length=len(anonymized),
-                        entities_should_anonymize=0,
-                        entities_correctly_anonymized=0,
-                        entities_missed=0,
-                        missed_entities_list=[],
-                        anonymization_accuracy=0.0,
-                        precision=0.0,
-                        recall=0.0,
-                        f1_score=0.0,
-                        detected_language='unknown',
-                        confidence_score=0.0,
-                        memory_used_mb=0.0,
-                        entity_categories={},
-                        error=str(e)
-                    )
-                
-                completed += 1
-                progress(0.1 + (0.7 * completed / len(pairs)),
-                        desc=f"Completed {completed}/{len(pairs)} pairs")
-        
-        # مرتب‌سازی نتایج بر اساس ایندکس
-        results = [index_to_result[i] for i in sorted(index_to_result.keys())]
-        
-        return results
-    
-    def _calculate_comprehensive_metrics(self, results: List[ComparisonResult], total_time: float) -> Dict:
-        """محاسبه متریک‌های جامع بر اساس مقایسه واقعی"""
-        
-        # آمار پایه
-        total_pairs = len(results)
-        successful_pairs = sum(1 for r in results if r.success)
-        success_rate = successful_pairs / total_pairs if total_pairs > 0 else 0
-        
-        processing_times = [r.processing_time_ms for r in results if r.success]
-        avg_processing_time = np.mean(processing_times) if processing_times else 0
-        
-        # محاسبه آمار واقعی ناشناس‌سازی
-        total_entities_should_anonymize = sum(r.entities_should_anonymize for r in results if r.success)
-        total_correctly_anonymized = sum(r.entities_correctly_anonymized for r in results if r.success)
-        total_missed = sum(r.entities_missed for r in results if r.success)
-        
-        # محاسبه متریک‌های کلی
-        overall_precision = np.mean([r.precision for r in results if r.success and r.precision > 0])
-        overall_recall = np.mean([r.recall for r in results if r.success and r.recall > 0])
-        overall_f1 = np.mean([r.f1_score for r in results if r.success and r.f1_score > 0])
-        overall_anonymization_rate = np.mean([r.anonymization_accuracy for r in results if r.success])
-        
-        # تعدیل نرخ موفقیت بر اساس entities جا افتاده
-        if total_entities_should_anonymize > 0:
-            entity_miss_penalty = (total_missed / total_entities_should_anonymize) * 100
-            adjusted_success_rate = max(0, success_rate * 100 - entity_miss_penalty) / 100
-        else:
-            adjusted_success_rate = success_rate
-        
-        # محاسبه مقیاس‌پذیری
-        scalability_score = self._calculate_scalability_score(processing_times)
-        
-        # آمار حافظه
-        memory_usage = [r.memory_used_mb for r in results if r.success]
-        memory_stats = {
-            'avg_memory_per_pair': np.mean(memory_usage) if memory_usage else 0,
-            'peak_memory': max(memory_usage) if memory_usage else 0,
-            'total_memory': sum(memory_usage) if memory_usage else 0,
-        }
-        
-        # آمار زبان
-        languages = [r.detected_language for r in results if r.success and r.detected_language]
-        language_distribution = Counter(languages)
-        
-        # تحلیل دسته‌های جا افتاده
-        missed_categories = Counter()
-        for result in results:
-            if result.success and result.missed_entities_list:
-                for missed_entity in result.missed_entities_list:
-                    missed_categories[missed_entity['category']] += 1
-        
-        # امتیاز کلی عملکرد بر اساس مقایسه واقعی
-        performance_score = self._calculate_realistic_performance_score(
-            adjusted_success_rate, avg_processing_time, overall_anonymization_rate, scalability_score
-        )
-        
-        return {
-            'total_pairs': total_pairs,
-            'successful_pairs': successful_pairs,
-            'success_rate': success_rate,
-            'adjusted_success_rate': adjusted_success_rate,  # تعدیل شده بر اساس entities جا افتاده
-            'avg_processing_time_ms': avg_processing_time,
-            'total_entities_should_anonymize': total_entities_should_anonymize,
-            'total_correctly_anonymized': total_correctly_anonymized,
-            'total_missed_entities': total_missed,
-            'overall_anonymization_rate': overall_anonymization_rate,
-            'pairs_per_minute': (successful_pairs / max(0.01, total_time / 60)),
-            'total_benchmark_time': total_time,
-            'scalability_score': scalability_score,
-            'performance_score': performance_score,
-            'memory_stats': memory_stats,
-            'language_distribution': dict(language_distribution),
-            'missed_categories_analysis': dict(missed_categories.most_common(10)),
-            'quality_metrics': {
-                'precision': round(overall_precision if not np.isnan(overall_precision) else 0, 1),
-                'recall': round(overall_recall if not np.isnan(overall_recall) else 0, 1),
-                'f1_score': round(overall_f1 if not np.isnan(overall_f1) else 0, 1),
-                'accuracy': round(overall_anonymization_rate * 100, 1)
-            },
-            'processing_time_percentiles': {
-                '50th': np.percentile(processing_times, 50) if processing_times else 0,
-                '95th': np.percentile(processing_times, 95) if processing_times else 0,
-                '99th': np.percentile(processing_times, 99) if processing_times else 0,
-            },
-            'entity_miss_penalty_percent': (total_missed / max(1, total_entities_should_anonymize)) * 100
-        }
-
-    def _calculate_realistic_performance_score(self, adjusted_success_rate: float, avg_time: float, 
-                                             anonymization_rate: float, scalability: float) -> float:
-        """محاسبه امتیاز کلی عملکرد بر اساس مقایسه واقعی"""
-        
-        weights = {
-            'adjusted_success': 0.35,  # وزن بیشتر برای نرخ موفقیت تعدیل شده
-            'anonymization_quality': 0.30,  # کیفیت ناشناس‌سازی واقعی
-            'speed': 0.20,
-            'scalability': 0.15
-        }
-        
-        success_score = adjusted_success_rate * 100
-        quality_score = anonymization_rate * 100
-        speed_score = min(100, max(0, 100 - (avg_time / 10)))  # کمتر بهتر
-        scalability_score = scalability
-        
-        total_score = (
-            weights['adjusted_success'] * success_score +
-            weights['anonymization_quality'] * quality_score +
-            weights['speed'] * speed_score +
-            weights['scalability'] * scalability_score
-        )
-        
-        return round(total_score, 1)
-    
-    def _calculate_scalability_score(self, processing_times: List[float]) -> float:
-        """محاسبه امتیاز مقیاس‌پذیری"""
-        if not processing_times:
-            return 100.0
-        
-        std_dev = np.std(processing_times)
-        mean_time = np.mean(processing_times)
-        cv = std_dev / mean_time if mean_time > 0 else 1
-        
-        scalability = max(0, 100 - (cv * 100))
-        return round(scalability, 1)
-    
-    def _run_clustering_analysis(self, results: List[ComparisonResult]) -> Dict:
-        """اجرای تحلیل کلاسترینگ"""
-        if not SKLEARN_AVAILABLE:
-            return {}
-        
-        try:
-            features = []
-            for result in results:
-                feature_vector = [
-                    result.processing_time_ms,
-                    result.original_length,
-                    result.entities_should_anonymize,
-                    result.anonymization_accuracy,
-                    result.precision,
-                    result.recall
-                ]
-                features.append(feature_vector)
-            
-            if len(features) < 3:
-                return {}
-            
-            kmeans = KMeans(n_clusters=min(3, len(features)), random_state=42)
-            clusters = kmeans.fit_predict(features)
-            
-            cluster_analysis = {}
-            for i in range(max(clusters) + 1):
-                cluster_results = [results[j] for j, c in enumerate(clusters) if c == i]
-                cluster_analysis[f'cluster_{i}'] = {
-                    'count': len(cluster_results),
-                    'avg_processing_time': np.mean([r.processing_time_ms for r in cluster_results]),
-                    'avg_entities': np.mean([r.entities_should_anonymize for r in cluster_results]),
-                    'avg_accuracy': np.mean([r.anonymization_accuracy for r in cluster_results])
-                }
-            
-            return cluster_analysis
-            
-        except Exception as e:
-            logger.error(f"Clustering analysis failed: {e}")
-            return {}
-    
-    def _run_stress_test(self, sample_pair: Tuple[str, str]) -> Dict:
-        """اجرای تست استرس"""
-        try:
-            iterations = self.config.stress_test_iterations
-            response_times = []
-            successful = 0
-            failed = 0
-            
-            original, anonymized = sample_pair
-            
-            for _ in range(iterations):
-                start_time = time.time()
-                try:
-                    result = self.anonymizer.compare_texts(original, anonymized)
-                    if result.success:
-                        successful += 1
-                    else:
-                        failed += 1
-                except:
-                    failed += 1
-                
-                response_time = (time.time() - start_time) * 1000
-                response_times.append(response_time)
-            
-            return {
-                'iterations': iterations,
-                'successful': successful,
-                'failed': failed,
-                'avg_response_time': np.mean(response_times),
-                'max_response_time': max(response_times),
-                'min_response_time': min(response_times),
-                'throughput_per_sec': 1000 / np.mean(response_times) if response_times else 0
-            }
-            
-        except Exception as e:
-            logger.error(f"Stress test failed: {e}")
-            return {}
-    
-    def _result_to_dict(self, result: ComparisonResult) -> Dict:
-        """تبدیل ComparisonResult به دیکشنری"""
-        return {
-            'index': result.index,
-            'success': result.success,
-            'processing_time_ms': result.processing_time_ms,
-            'original_length': result.original_length,
-            'anonymized_length': result.anonymized_length,
-            'entities_should_anonymize': result.entities_should_anonymize,
-            'entities_correctly_anonymized': result.entities_correctly_anonymized,
-            'entities_missed': result.entities_missed,
-            'missed_entities_list': result.missed_entities_list,
-            'anonymization_accuracy': result.anonymization_accuracy,
-            'precision': result.precision,
-            'recall': result.recall,
-            'f1_score': result.f1_score,
-            'detected_language': result.detected_language,
-            'confidence_score': result.confidence_score,
-            'memory_used_mb': result.memory_used_mb,
-            'entity_categories': result.entity_categories,
-            'error': result.error,
-        }
-    
-    def _create_comprehensive_report(self) -> str:
-        """ایجاد گزارش جامع و تفصیلی"""
-        if not self.current_results:
-            return "No results available."
-        
-        summary = self.current_results['summary']
-        config = self.current_results['config']
-        
-        # تحلیل نتایج تفصیلی
-        detailed_results = self.current_results['detailed_results']
-        successful_results = [r for r in detailed_results if r.get('success', False)]
-        
-        # آمار تفصیلی
-        processing_times = [r['processing_time_ms'] for r in successful_results]
-        accuracy_scores = [r['anonymization_accuracy'] for r in successful_results]
-        precision_scores = [r['precision'] for r in successful_results if r['precision'] > 0]
-        recall_scores = [r['recall'] for r in successful_results if r['recall'] > 0]
-        
-        # تحلیل دسته‌بندی‌ها
-        all_categories = defaultdict(int)
-        missed_categories = defaultdict(int)
-        
-        for result in successful_results:
-            for category, count in result.get('entity_categories', {}).items():
-                all_categories[category] += count
-            
-            for missed_entity in result.get('missed_entities_list', []):
-                missed_categories[missed_entity['category']] += 1
-        
-        report = f"""
-# 📊 گزارش جامع بنچمارک مقایسه واقعی - نسخه 3.1
-
-## ⭐ خلاصه کلیدی
-**امتیاز عملکرد کلی:** {summary['performance_score']:.1f}/100
-**نرخ موفقیت تعدیل شده:** {summary['adjusted_success_rate']*100:.1f}%
-**دقت ناشناس‌سازی واقعی:** {summary['overall_anonymization_rate']*100:.1f}%
-**جریمه entities جا افتاده:** {summary['entity_miss_penalty_percent']:.1f}%
-
-## 📈 آمار کلی عملیات
-- **کل جفت متون بررسی شده**: {summary['total_pairs']:,}
-- **جفت‌های موفق**: {summary['successful_pairs']:,}
-- **نرخ موفقیت اولیه**: {summary['success_rate']*100:.1f}%
-- **نرخ موفقیت تعدیل شده**: {summary['adjusted_success_rate']*100:.1f}% (پس از کسر جریمه entities جا افتاده)
-
-## 🎯 تحلیل عمیق ناشناس‌سازی واقعی
-
-### نتایج اصلی:
-- **کل entities که باید ناشناس‌سازی می‌شدند**: {summary['total_entities_should_anonymize']:,}
-- **entities صحیح ناشناس‌سازی شده**: {summary['total_correctly_anonymized']:,}
-- **entities جا افتاده**: {summary['total_missed_entities']:,}
-- **نرخ دقت واقعی**: {summary['overall_anonymization_rate']*100:.1f}%
-
-### متریک‌های کیفیت پیشرفته:
-- **دقت (Precision)**: {summary['quality_metrics']['precision']:.1f}%
-- **بازخوانی (Recall)**: {summary['quality_metrics']['recall']:.1f}%
-- **امتیاز F1**: {summary['quality_metrics']['f1_score']:.1f}%
-- **صحت کلی (Accuracy)**: {summary['quality_metrics']['accuracy']:.1f}%
-
-## ⚡ آنالیز عملکرد سیستم
-
-### سرعت و توان عملیاتی:
-- **متوسط زمان پردازش هر جفت**: {summary['avg_processing_time_ms']:.1f} میلی‌ثانیه
-- **توان عملیاتی**: {summary['pairs_per_minute']:.0f} جفت/دقیقه
-- **کل زمان بنچمارک**: {summary['total_benchmark_time']:.1f} ثانیه
-- **امتیاز مقیاس‌پذیری**: {summary['scalability_score']:.1f}/100
-
-### توزیع زمان پردازش:
-"""
-        
-        if processing_times:
-            report += f"""- **میانه زمان پردازش**: {np.median(processing_times):.1f} ms
-- **حداقل زمان**: {min(processing_times):.1f} ms  
-- **حداکثر زمان**: {max(processing_times):.1f} ms
-- **انحراف معیار**: {np.std(processing_times):.1f} ms
-"""
-
-        percentiles = summary.get('processing_time_percentiles', {})
-        if percentiles:
-            report += f"""- **50درصدی زمان**: {percentiles.get('50th', 0):.1f} ms
-- **95درصدی زمان**: {percentiles.get('95th', 0):.1f} ms
-- **99درصدی زمان**: {percentiles.get('99th', 0):.1f} ms
-"""
-        
-        report += f"""
-## 💾 تحلیل مصرف حافظه
-- **متوسط حافظه هر جفت**: {summary['memory_stats']['avg_memory_per_pair']:.2f} MB
-- **حداکثر مصرف حافظه**: {summary['memory_stats']['peak_memory']:.2f} MB
-- **کل حافظه استفاده شده**: {summary['memory_stats']['total_memory']:.2f} MB
-- **امتیاز کارایی حافظه**: {max(0, 100 - summary['memory_stats']['avg_memory_per_pair']):.1f}/100
-
-## 🌍 تحلیل زبان‌ها
-"""
-        
-        lang_dist = summary['language_distribution']
-        total_samples = sum(lang_dist.values())
-        for lang, count in lang_dist.items():
-            lang_name = {'fa': 'فارسی', 'en': 'انگلیسی', 'mixed': 'ترکیبی', 'unknown': 'نامشخص'}.get(lang, lang)
-            percentage = (count/total_samples)*100 if total_samples > 0 else 0
-            report += f"- **{lang_name}**: {count} جفت ({percentage:.1f}%)\n"
-        
-        report += f"""
-## 🔍 تحلیل عمیق دسته‌های entities
-
-### توزیع کل دسته‌ها:
-"""
-        
-        for category, count in sorted(all_categories.items(), key=lambda x: x[1], reverse=True):
-            percentage = (count/sum(all_categories.values()))*100 if sum(all_categories.values()) > 0 else 0
-            report += f"- **{category}**: {count} مورد ({percentage:.1f}%)\n"
-        
-        report += f"""
-### تحلیل دسته‌های جا افتاده:
-"""
-        
-        if missed_categories:
-            for category, missed_count in sorted(missed_categories.items(), key=lambda x: x[1], reverse=True):
-                total_in_category = all_categories.get(category, 0)
-                miss_rate = (missed_count/total_in_category)*100 if total_in_category > 0 else 0
-                report += f"- **{category}**: {missed_count} جا افتاده از {total_in_category} ({miss_rate:.1f}% نرخ جا افتادگی)\n"
-        else:
-            report += "- هیچ entity جا نیافتاده! (عملکرد فوق‌العاده)\n"
-        
-        report += f"""
-## 📊 تحلیل آماری پیشرفته
-
-### توزیع دقت ناشناس‌سازی:
-"""
-        
-        if accuracy_scores:
-            report += f"""- **میانگین دقت**: {np.mean(accuracy_scores)*100:.1f}%
-- **میانه دقت**: {np.median(accuracy_scores)*100:.1f}%
-- **حداقل دقت**: {min(accuracy_scores)*100:.1f}%
-- **حداکثر دقت**: {max(accuracy_scores)*100:.1f}%
-- **انحراف معیار**: {np.std(accuracy_scores)*100:.1f}%
-- **نمونه‌های با دقت 100%**: {sum(1 for s in accuracy_scores if s >= 1.0)} از {len(accuracy_scores)}
-- **نمونه‌های با دقت کمتر از 50%**: {sum(1 for s in accuracy_scores if s < 0.5)} از {len(accuracy_scores)}
-"""
-
-        # تحلیل کارایی بر اساس طول متن
-        if successful_results:
-            long_texts = [r for r in successful_results if r['original_length'] > 200]
-            short_texts = [r for r in successful_results if r['original_length'] <= 200]
-            
-            if long_texts and short_texts:
-                long_avg_accuracy = np.mean([r['anonymization_accuracy'] for r in long_texts])
-                short_avg_accuracy = np.mean([r['anonymization_accuracy'] for r in short_texts])
-                long_avg_time = np.mean([r['processing_time_ms'] for r in long_texts])
-                short_avg_time = np.mean([r['processing_time_ms'] for r in short_texts])
-                
-                report += f"""
-### تحلیل بر اساس طول متن:
-- **متون کوتاه (≤200 کاراکتر)**: {len(short_texts)} نمونه
-  - میانگین دقت: {short_avg_accuracy*100:.1f}%
-  - میانگین زمان: {short_avg_time:.1f} ms
-- **متون طولانی (>200 کاراکتر)**: {len(long_texts)} نمونه
-  - میانگین دقت: {long_avg_accuracy*100:.1f}%
-  - میانگین زمان: {long_avg_time:.1f} ms
-"""
-        
-        stress = summary.get('stress_test', {})
-        if stress and 'iterations' in stress:
-            report += f"""
-## 🔥 نتایج تست استرس
-- **کل تکرارها**: {stress['iterations']}
-- **موفق**: {stress['successful']} ({stress['successful']/stress['iterations']*100:.1f}%)
-- **ناموفق**: {stress['failed']} ({stress['failed']/stress['iterations']*100:.1f}%)
-- **متوسط زمان پاسخ**: {stress['avg_response_time']:.1f} ms
-- **حداکثر زمان پاسخ**: {stress['max_response_time']:.1f} ms
-- **حداقل زمان پاسخ**: {stress['min_response_time']:.1f} ms
-- **توان عملیاتی**: {stress['throughput_per_sec']:.1f} عملیات/ثانیه
-"""
-        
-        # ارزیابی و پیشنهادات
-        performance = summary['performance_score']
-        miss_penalty = summary['entity_miss_penalty_percent']
-        
-        if performance >= 85 and miss_penalty < 10:
-            report += """
-## ✅ سیستم شما عملکرد عالی دارد!
-
-### نقاط قوت:
-- ناشناس‌سازی با دقت بالا انجام می‌شود
-- entities جا افتاده کم است  
-- سرعت پردازش مطلوب
-- مقیاس‌پذیری خوب
-- استفاده بهینه از حافظه
-
-### توصیه‌ها:
-- آماده برای استفاده در محیط تولید
-- ادامه مانیتورینگ منظم
-- حفظ کیفیت فعلی در به‌روزرسانی‌ها
-- تست دوره‌ای با داده‌های جدید
-"""
-        elif performance >= 70 or miss_penalty < 20:
-            report += """
-## ⚠️ سیستم نیاز به بهبودهایی دارد:
-
-### مشکلات شناسایی شده:
-- نرخ entities جا افتاده قابل توجه است
-- دقت ناشناس‌سازی نیاز به بهبود دارد
-- عملکرد در برخی دسته‌ها ضعیف است
-
-### پیشنهادات بهبود:
-- بهینه‌سازی الگوریتم‌های تشخیص موجودیت
-- کاهش entities جا افتاده با تنظیم threshold ها
-- بهبود دقت pattern matching
-- افزایش پوشش دسته‌های مختلف
-- تنظیم دقیق‌تر پارامترهای سیستم
-- آموزش مجدد مدل‌ها با داده‌های بیشتر
-
-### اولویت‌های فوری:
-1. کاهش نرخ جا افتادگی در دسته‌های حساس
-2. بهبود دقت تشخیص entities
-3. تست با حجم بیشتر داده
-"""
-        else:
-            report += """
-## 🔧 سیستم نیاز به بازنگری اساسی دارد:
-
-### مشکلات جدی شناسایی شده:
-- نرخ بالای entities جا افتاده
-- دقت ناشناس‌سازی پایین
-- عملکرد غیرقابل اعتماد
-
-### اقدامات ضروری:
-- بازطراحی کامل الگوریتم‌های اصلی
-- افزایش چشمگیر patterns تشخیص
-- پیاده‌سازی مدل‌های NER بهتر
-- بهبود preprocessing متون
-- training مجدد با داده‌های بیشتر
-- کاهش قابل توجه نرخ false negative ها
-- تست گسترده قبل از استقرار
-
-### پیشنهاد:
-سیستم در حال حاضر آماده استقرار در محیط تولید نیست. 
-نیاز به توسعه اساسی و تست‌های گسترده‌تر دارد.
-"""
-        
-        report += f"""
-
-## 📋 تنظیمات بنچمارک
-- **اندازه نمونه**: {config['sample_size']}
-- **پردازش موازی**: {'فعال' if config['parallel_processing'] else 'غیرفعال'}
-- **تحلیل کلاسترینگ**: {'فعال' if config['clustering_enabled'] else 'غیرفعال'}
-
-## 📌 نتیجه‌گیری
-این گزارش بر اساس مقایسه واقعی {summary['total_pairs']} جفت متن تولید شده است.
-نتایج نشان‌دهنده عملکرد واقعی سیستم ناشناس‌سازی با در نظر گیری 
-entities جا افتاده و دقت فعلی الگوریتم‌های تشخیص می‌باشد.
-
-**زمان تولید گزارش**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-**نسخه بنچمارک**: Enhanced Real Comparison v3.1
-
----
-*این گزارش برای ارزیابی دقیق و بهبود سیستم ناشناس‌سازی طراحی شده است*
-"""
-        
-        return report
-    
-    def _get_error_response(self, error_msg: str):
-        """پاسخ استاندارد برای خطاها"""
-        return (
-            f"❌ {error_msg}",
-            "خطا در اجرای benchmark رخ داده است.",
-            gr.update(visible=False),
-            gr.update(visible=False)
-        )
-    
-    def download_results(self):
-        """دانلود نتایج"""
-        if not self.current_results:
-            return None
-        
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"real_comparison_benchmark_{timestamp}.json"
-        
-        with open(filename, 'w', encoding='utf-8') as f:
-            json.dump(self.current_results, f, ensure_ascii=False, indent=2, default=str)
-        
-        return filename
-
-# =============================================================================
-# Main Interface Creation
-# =============================================================================
-
-def create_enhanced_interface():
-    """ایجاد رابط کاربری پیشرفته"""
-    
-    benchmark_interface = EnhancedBenchmarkInterface()
-    
-    custom_css = """
-    .gradio-container {
-        font-family: 'Segoe UI', Tahoma, Arial, sans-serif !important;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-        min-height: 100vh !important;
-    }
-
-    .gradio-button {
-        border-radius: 25px !important;
-        font-weight: bold !important;
-        transition: all 0.3s ease !important;
-        margin: 5px 0 !important;
-        min-height: 50px !important;
-    }
-
-    .gradio-button:hover {
-        transform: translateY(-2px) !important;
-        box-shadow: 0 6px 20px rgba(0,0,0,0.2) !important;
-    }
-
-    h1, h2, h3 {
-        text-shadow: 2px 2px 4px rgba(0,0,0,0.3) !important;
-        margin: 10px 0 !important;
-        line-height: 1.2 !important;
-    }
-    """
-    
-    with gr.Blocks(title="🚀 Enhanced Real Comparison Benchmark", theme=gr.themes.Soft(), css=custom_css) as app:
-        
-        # Header
-        gr.HTML("""
-        <div style="text-align: center; padding: 20px;">
-            <h1>🚀 Enhanced Real Comparison Anonymization Benchmark v3.1</h1>
-            <p style="font-size: 1.2rem;">Real Performance Analysis with Original vs Anonymized Text Comparison</p>
-            <p>✨ Features: Real Entity Counting, Miss Rate Calculation, Adjusted Success Metrics</p>
-        </div>
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                # Dataset Status
-                gr.HTML("""
-                <div style="background-color: #e8f4f8; padding: 15px; border-radius: 10px; margin-bottom: 15px;">
-                    <h3>📁 Dataset Requirements</h3>
-                    <p>System looks for files with columns:</p>
-                    <ul>
-                        <li><strong>original_text</strong> - Original sentences</li>
-                        <li><strong>anonymized_text</strong> - Anonymized versions</li>
-                    </ul>
-                    <p><strong>Supported files:</strong></p>
-                    <p>datasetfa.csv, dataset-fa.csv, dataseten.csv, dataset-en.csv</p>
-                </div>
-                """)
-                
-                sample_size = gr.Slider(
-                    minimum=10,
-                    maximum=500,
-                    value=100,
-                    step=5,
-                    label="📊 Sample Size (Text Pairs to Compare)"
-                )
-                
-                with gr.Row():
-                    enable_parallel = gr.Checkbox(
-                        label="⚡ Enable Parallel Processing",
-                        value=True
-                    )
-                    
-                    enable_clustering = gr.Checkbox(
-                        label="🎯 Enable Clustering Analysis",
-                        value=False
-                    )
-                
-                run_btn = gr.Button(
-                    "🚀 Run Real Comparison Benchmark",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                download_btn = gr.Button(
-                    "📥 Download Complete Results",
-                    variant="secondary",
-                    visible=False
-                )
-                
-                status_output = gr.Textbox(
-                    label="📋 Status",
-                    interactive=False,
-                    lines=4
-                )
-            
-            with gr.Column(scale=2):
-                # Results - Only Text Report
-                detailed_report = gr.Markdown(
-                    "No results yet. Please run the real comparison benchmark first.",
-                    visible=False,
-                    label="📊 Comprehensive Analysis Report"
-                )
-        
-        # System Status with file check
-        system_status = "✅ Enhanced comparison system ready" if benchmark_interface.system_ready else "⚠️ Running in limited mode"
-        
-        # Check for datasets
-        fa_files = ['datasetfa.csv', 'dataset-fa.csv']
-        en_files = ['dataseten.csv', 'dataset-en.csv']
-        
-        fa_status = "❌ Not found"
-        en_status = "❌ Not found"
-        
-        for f in fa_files:
-            if os.path.exists(f):
-                fa_status = f"✅ Found: {f}"
-                break
-                
-        for f in en_files:
-            if os.path.exists(f):
-                en_status = f"✅ Found: {f}"
-                break
-        
-        gr.HTML(f"""
-        <div style="text-align: center; margin-top: 20px; padding: 15px; background-color: #e8f4f8; border-radius: 10px;">
-            <p><strong>System Status:</strong> {system_status}</p>
-            <p><strong>Persian Dataset:</strong> {fa_status}</p>
-            <p><strong>English Dataset:</strong> {en_status}</p>
-            <p><strong>Available Features:</strong> 
-                {'✅ Parallel Processing' if multiprocessing.cpu_count() > 1 else '❌ Sequential Only'} | 
-                {'✅ Advanced Metrics' if SKLEARN_AVAILABLE else '❌ Basic Metrics'} | 
-                {'✅ Memory Profiling' if PSUTIL_AVAILABLE else '❌ No Memory Tracking'} |
-                {'✅ NER Models' if SPACY_AVAILABLE else '❌ Pattern-Only'}
-            </p>
-        </div>
-        """)
-        
-        # Usage Guide
-        with gr.Accordion("📖 Real Comparison Guide", open=False):
-            gr.HTML("""
-            <div style="padding: 20px;">
-                <h3>🚀 How It Works</h3>
-                <ol>
-                    <li><strong>Dataset Preparation:</strong> CSV files with original_text and anonymized_text columns</li>
-                    <li><strong>Real Entity Detection:</strong> System finds entities that should be anonymized in original text</li>
-                    <li><strong>Comparison Analysis:</strong> Checks which entities were actually anonymized</li>
-                    <li><strong>Miss Rate Calculation:</strong> Calculates percentage of missed entities</li>
-                    <li><strong>Adjusted Metrics:</strong> Success rate adjusted based on missed entities</li>
-                </ol>
-                
-                <h3>📊 Key Metrics</h3>
-                <ul>
-                    <li><strong>Real Anonymization Accuracy:</strong> Correctly anonymized / Should be anonymized</li>
-                    <li><strong>Adjusted Success Rate:</strong> Initial success - entity miss penalty</li>
-                    <li><strong>Entity Miss Penalty:</strong> (Missed entities / Total entities) × 100</li>
-                    <li><strong>Precision & Recall:</strong> Based on actual entity detection and anonymization</li>
-                </ul>
-                
-                <h3>🎯 Expected File Format</h3>
-                <pre>
-original_text,anonymized_text
-"John Smith works at Apple Inc","PERSON_001 works at COMPANY_001"
-"Call me at 555-1234","Call me at PHONE_001"
-                </pre>
-            </div>
-            """)
-        
-        # Event Handlers
-        run_btn.click(
-            fn=benchmark_interface.run_enhanced_benchmark,
-            inputs=[sample_size, enable_parallel, enable_clustering],
-            outputs=[
-                status_output,
-                detailed_report,
-                download_btn,
-                detailed_report  # visibility toggle
-            ],
-            show_progress=True
-        )
-        
-        download_btn.click(
-            fn=benchmark_interface.download_results,
-            outputs=gr.File()
-        )
-    
-    return app
-
-# =============================================================================
-# Main Function
-# =============================================================================
-
-def main():
-    """تابع اصلی"""
-    
-    print("🚀 Starting Enhanced Real Comparison Benchmark System v3.1...")
-    print("=" * 80)
-    
-    # Check for datasets
-    datasets = [
-        ('dataset-fa.csv', 'Persian'),
-        ('dataset-fa.csv', 'Persian (Alt)'),
-        ('dataset-en.csv', 'English'),
-        ('dataset-en.csv', 'English (Alt)')
-    ]
-    
-    for filename, desc in datasets:
-        if os.path.exists(filename):
-            print(f"✅ {desc} dataset found: {filename}")
-            try:
-                df = pd.read_csv(filename, encoding='utf-8')
-                print(f"   - Rows: {len(df)}")
-                print(f"   - Columns: {list(df.columns)}")
-                if 'original_text' in df.columns and 'anonymized_text' in df.columns:
-                    print(f"   - ✅ Required columns present")
-                else:
-                    print(f"   - ❌ Missing required columns: original_text, anonymized_text")
-            except Exception as e:
-                print(f"   - ❌ Error reading file: {e}")
-        else:
-            print(f"❌ {desc} dataset not found: {filename}")
-    
-    # System capabilities
-    features = []
-    if SKLEARN_AVAILABLE:
-        features.append("Advanced ML Metrics")
-    if PSUTIL_AVAILABLE:
-        features.append("Memory Profiling")
-    if SPACY_AVAILABLE:
-        features.append("NER Models")
-    
-    features.extend(["Real Entity Comparison", "Miss Rate Analysis", "Adjusted Metrics"])
-    
-    print(f"✨ Available features: {', '.join(features)}")
-    print(f"🖥️ CPU Cores: {multiprocessing.cpu_count()}")
-    print(f"🧠 Memory: {psutil.virtual_memory().total // (1024**3) if PSUTIL_AVAILABLE else 'Unknown'} GB")
-    
-    # Create and launch interface
-    demo = create_enhanced_interface()
-    
-    # Launch with enhanced configuration
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        inbrowser=True,
-        show_error=True,
-        favicon_path=None,
-        ssl_verify=False,
-        max_file_size="50mb"
-    )
-
-if __name__ == "__main__":
-    main()