Upload anonymization_benchmark (4).py

anonymization_benchmark (4).py

@@ -0,0 +1,707 @@
+import pandas as pd
+import re
+import numpy as np
+import json
+from typing import Dict, List, Any, Tuple
+import gradio as gr
+from pathlib import Path
+import plotly.graph_objects as go
+import plotly.express as px
+from dataclasses import dataclass
+from datetime import datetime
+
+@dataclass
+class BenchmarkMetrics:
+    """کلاس متریک‌های بنچمارک"""
+    model_name: str
+    total_texts: int
+    total_entities: int
+    accuracy: float    # درستی کلی ناشناس‌سازی
+    recall: float      # پوشش موجودیت‌ها
+    precision: float   # دقت شناسایی
+
+class AnonymizationBenchmark:
+    """کلاس اصلی بنچمارک ناشناس‌سازی"""
+    
+    def __init__(self):
+        self.models_data = {}
+        self.benchmark_results = {}
+        
+    def load_csv_files(self, chatgpt_file, grok_file, llama_file, manual_file):
+        """بارگذاری فایل‌های CSV"""
+        try:
+            # بارگذاری فایل‌ها
+            chatgpt_df = pd.read_csv(chatgpt_file)
+            grok_df = pd.read_csv(grok_file)
+            llama_df = pd.read_csv(llama_file)
+            manual_df = pd.read_csv(manual_file)
+            
+            # بررسی ستون‌ها
+            required_columns = ['original_text', 'anonymized_text']
+            
+            for df_name, df in [('ChatGPT', chatgpt_df), ('Grok', grok_df), ('Llama', llama_df), ('Manual', manual_df)]:
+                if not all(col in df.columns for col in required_columns):
+                    raise ValueError(f"فایل {df_name} فاقد ستون‌های مورد نیاز است")
+            
+            self.models_data = {
+                'ChatGPT': chatgpt_df,
+                'Grok': grok_df,
+                'Llama-3.1-8B': llama_df,
+                'Manual (دستی)': manual_df
+            }
+            
+            return True, "فایل‌ها با موفقیت بارگذاری شدند"
+            
+        except Exception as e:
+            return False, f"خطا در بارگذاری فایل‌ها: {str(e)}"
+    
+    def extract_entities_from_text(self, text: str) -> Dict[str, List[str]]:
+        """استخراج موجودیت‌ها از متن"""
+        entities = {
+            'companies': re.findall(r'company-(\d+)', text),
+            'persons': re.findall(r'person-(\d+)', text),
+            'amounts': re.findall(r'amount-(\d+)', text),
+            'percents': re.findall(r'percent-(\d+)', text),
+            'groups': re.findall(r'group-(\d+)', text)
+        }
+        return entities
+    
+    def count_original_entities(self, text: str) -> int:
+        """تخمین تعداد موجودیت‌های قابل ناشناس‌سازی در متن اصلی"""
+        # الگوهای شناسایی موجودیت‌ها در متن فارسی
+        patterns = [
+            r'[۰-۹]+(?:\.[۰-۹]+)?\s*(?:میلیارد|میلیون|هزار)?\s*(?:تومان|ریال|دلار|یورو)',  # اعداد پولی
+            r'[۰-۹]+(?:\.[۰-۹]+)?\s*درصد',  # درصدها
+            r'\b[آ-ی\s]{2,30}\b(?:\s*(?:شرکت|بانک|گروه|سازمان))',  # شرکت‌ها
+            r'\b[آ-ی\s]{2,20}\b(?:\s*(?:مدیرعامل|رئیس|مدیر))',  # اشخاص
+            r'[۰-۹]+(?:\.[۰-۹]+)?(?:\s*(?:میلیون|میلیارد|هزار))?',  # سایر اعداد
+        ]
+        
+        total_entities = 0
+        for pattern in patterns:
+            matches = re.findall(pattern, text)
+            total_entities += len(matches)
+            
+        return max(total_entities, 1)  # حداقل 1 برای جلوگیری از تقسیم بر صفر
+    
+    def check_indexing_correctness(self, entities: Dict[str, List[str]]) -> float:
+        """بررسی درستی اندیس‌گذاری"""
+        total_checks = 0
+        passed_checks = 0
+        
+        for entity_type, indices in entities.items():
+            if not indices:
+                continue
+                
+            total_checks += 1
+            unique_indices = sorted([int(x) for x in set(indices)])
+            
+            # بررسی شروع از 1
+            if unique_indices[0] == 1:
+                passed_checks += 0.5
+            
+            # بررسی پیوستگی
+            expected = list(range(1, len(unique_indices) + 1))
+            if unique_indices == expected:
+                passed_checks += 0.5
+        
+        return passed_checks / total_checks if total_checks > 0 else 0.0
+    
+    def calculate_structure_preservation(self, original_text: str, anonymized_text: str) -> float:
+        """محاسبه امتیاز حفظ ساختار"""
+        # کلمات مهم که باید حفظ شوند
+        important_words = [
+            'میلیارد', 'میلیون', 'تومان', 'ریال', 'درصد', 'سود', 'زیان',
+            'مدیرعامل', 'شرکت', 'بانک', 'درآمد', 'سال', 'ماه'
+        ]
+        
+        score = 0.0
+        total_checks = len(important_words)
+        
+        for word in important_words:
+            if word in original_text and word in anonymized_text:
+                score += 1.0
+            elif word not in original_text:
+                total_checks -= 1
+        
+        # بررسی حفظ تعداد کلمات (تقریبی)
+        original_words = len(original_text.split())
+        anonymized_words = len(anonymized_text.split())
+        
+        if original_words > 0:
+            word_ratio = min(anonymized_words / original_words, 1.0)
+            score += word_ratio * 2
+            total_checks += 2
+        
+        return score / total_checks if total_checks > 0 else 0.0
+    
+    def calculate_accuracy(self, original_text: str, anonymized_text: str) -> float:
+        """محاسبه درستی کلی ناشناس‌سازی"""
+        entities = self.extract_entities_from_text(anonymized_text)
+        
+        # بررسی درستی اندیس‌گذاری
+        indexing_score = self.check_indexing_correctness(entities)
+        
+        # بررسی حفظ ساختار
+        structure_score = self.calculate_structure_preservation(original_text, anonymized_text)
+        
+        # میانگین وزنی
+        accuracy = (indexing_score * 0.6) + (structure_score * 0.4)
+        return accuracy
+    
+    def calculate_recall(self, original_text: str, anonymized_text: str) -> float:
+        """محاسبه پوشش موجودیت‌ها (Recall)"""
+        original_entity_count = self.count_original_entities(original_text)
+        entities = self.extract_entities_from_text(anonymized_text)
+        anonymized_entity_count = sum(len(set(v)) for v in entities.values())
+        
+        return min(anonymized_entity_count / original_entity_count, 1.0)
+    
+    def calculate_precision(self, anonymized_text: str) -> float:
+        """محاسبه دقت شناسایی (Precision)"""
+        entities = self.extract_entities_from_text(anonymized_text)
+        
+        # بررسی کیفیت موجودیت‌های شناسایی شده
+        total_entities = sum(len(v) for v in entities.values())
+        if total_entities == 0:
+            return 0.0
+        
+        # بررسی درستی فرمت شناسه‌ها
+        correct_entities = 0
+        for entity_type, indices in entities.items():
+            for idx in indices:
+                if idx.isdigit() and int(idx) > 0:
+                    correct_entities += 1
+        
+        # بررسی عدم تکرار غیرضروری
+        unique_entities = sum(len(set(v)) for v in entities.values())
+        consistency_bonus = unique_entities / total_entities if total_entities > 0 else 0
+        
+        base_precision = correct_entities / total_entities if total_entities > 0 else 0
+        return (base_precision * 0.7) + (consistency_bonus * 0.3)
+    
+    def analyze_model(self, model_name: str, df: pd.DataFrame) -> BenchmarkMetrics:
+        """تحلیل یک مدل"""
+        print(f"تحلیل مدل {model_name}...")
+        
+        total_texts = len(df)
+        
+        # محاسبه متریک‌ها برای هر متن
+        accuracy_scores = []
+        recall_scores = []
+        precision_scores = []
+        total_entities = 0
+        
+        for _, row in df.iterrows():
+            original = str(row['original_text'])
+            anonymized = str(row['anonymized_text'])
+            
+            # محاسبه متریک‌ها
+            accuracy_scores.append(self.calculate_accuracy(original, anonymized))
+            recall_scores.append(self.calculate_recall(original, anonymized))
+            precision_scores.append(self.calculate_precision(anonymized))
+            
+            # شمارش موجودیت‌ها
+            entities = self.extract_entities_from_text(anonymized)
+            total_entities += sum(len(set(v)) for v in entities.values())
+        
+        return BenchmarkMetrics(
+            model_name=model_name,
+            total_texts=total_texts,
+            total_entities=total_entities,
+            accuracy=round(np.mean(accuracy_scores), 3),
+            recall=round(np.mean(recall_scores), 3),
+            precision=round(np.mean(precision_scores), 3)
+        )
+    
+    def run_benchmark(self) -> Tuple[bool, str, str]:
+        """اجرای بنچمارک کامل"""
+        if not self.models_data:
+            return False, "ابتدا فایل‌ها را بارگذاری کنید", ""
+        
+        try:
+            results = {}
+            
+            # تحلیل هر مدل
+            for model_name, df in self.models_data.items():
+                results[model_name] = self.analyze_model(model_name, df)
+            
+            self.benchmark_results = results
+            
+            # تولید HTML
+            html_report = self.generate_html_report()
+            
+            return True, "بنچمارک با موفقیت انجام شد", html_report
+            
+        except Exception as e:
+            return False, f"خطا در اجرای بنچمارک: {str(e)}", ""
+    
+    def generate_comparison_table(self) -> str:
+        """تولید جدول مقایسه"""
+        if not self.benchmark_results:
+            return "<p>هنوز بنچمارکی انجام نشده است</p>"
+        
+        # آماده‌سازی داده‌ها برای جدول
+        table_data = []
+        for model_name, metrics in self.benchmark_results.items():
+            table_data.append({
+                'مدل': model_name,
+                'تعداد متن‌ها': metrics.total_texts,
+                'کل موجودیت‌ها': metrics.total_entities,
+                '🎯 دقت (Accuracy)': f"{metrics.accuracy:.3f}",
+                '📊 بازیابی (Recall)': f"{metrics.recall:.3f}",
+                '✅ دقت شناسایی (Precision)': f"{metrics.precision:.3f}"
+            })
+        
+        # تولید HTML جدول
+        html = """
+        <div style="overflow-x: auto; margin: 20px 0;">
+            <table style="width: 100%; border-collapse: collapse; font-family: 'Tahoma', sans-serif;">
+                <thead>
+                    <tr style="background-color: #4CAF50; color: white;">
+        """
+        
+        # سرستون‌ها
+        headers = list(table_data[0].keys())
+        for header in headers:
+            html += f"<th style='border: 1px solid #ddd; padding: 12px; text-align: center;'>{header}</th>"
+        
+        html += "</tr></thead><tbody>"
+        
+        # ردیف‌ها
+        for i, row in enumerate(table_data):
+            bg_color = "#f2f2f2" if i % 2 == 0 else "white"
+            html += f"<tr style='background-color: {bg_color};'>"
+            
+            for j, (key, value) in enumerate(row.items()):
+                # رنگ‌بندی ستون‌های متریک‌ها
+                if key in ['🎯 دقت (Accuracy)', '📊 بازیابی (Recall)', '✅ دقت شناسایی (Precision)']:
+                    score = float(value)
+                    if score >= 0.8:
+                        color = "#4CAF50"  # سبز
+                    elif score >= 0.6:
+                        color = "#FF9800"  # نارنجی
+                    else:
+                        color = "#F44336"  # قرمز
+                    html += f"<td style='border: 1px solid #ddd; padding: 12px; text-align: center; font-weight: bold; color: {color};'>{value}</td>"
+                else:
+                    html += f"<td style='border: 1px solid #ddd; padding: 12px; text-align: center;'>{value}</td>"
+            
+            html += "</tr>"
+        
+        html += "</tbody></table></div>"
+        
+        return html
+    
+    def generate_charts(self) -> str:
+        """تولید نمودارها"""
+        if not self.benchmark_results:
+            return ""
+        
+        models = list(self.benchmark_results.keys())
+        accuracy_scores = [self.benchmark_results[model].accuracy for model in models]
+        recall_scores = [self.benchmark_results[model].recall for model in models]
+        precision_scores = [self.benchmark_results[model].precision for model in models]
+        
+        # نمودار مقایسه سه متریک
+        chart_html = """
+        <div style="margin: 20px 0;">
+            <h3 style="text-align: center; color: #333;">مقایسه متریک‌های عملکرد مدل‌ها</h3>
+            <div style="display: flex; justify-content: center; gap: 30px; background-color: #f9f9f9; padding: 30px; border-radius: 15px; flex-wrap: wrap;">
+        """
+        
+        colors = ['#4CAF50', '#2196F3', '#FF9800', '#9C27B0']  # اضافه کردن رنگ چهارم
+        
+        for i, model in enumerate(models):
+            accuracy = accuracy_scores[i]
+            recall = recall_scores[i] 
+            precision = precision_scores[i]
+            
+            chart_html += f"""
+                <div style="text-align: center; min-width: 180px; margin-bottom: 20px;">
+                    <h4 style="margin-bottom: 15px; color: #333; font-size: 14px;">{model}</h4>
+                    
+                    <div style="margin-bottom: 10px;">
+                        <div style="font-size: 11px; color: #666; margin-bottom: 5px;">Accuracy</div>
+                        <div style="background-color: {colors[0]}; width: 50px; height: {accuracy*80}px; margin: 0 auto; border-radius: 3px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 9px;">
+                            {accuracy:.3f}
+                        </div>
+                    </div>
+                    
+                    <div style="margin-bottom: 10px;">
+                        <div style="font-size: 11px; color: #666; margin-bottom: 5px;">Recall</div>
+                        <div style="background-color: {colors[1]}; width: 50px; height: {recall*80}px; margin: 0 auto; border-radius: 3px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 9px;">
+                            {recall:.3f}
+                        </div>
+                    </div>
+                    
+                    <div style="margin-bottom: 10px;">
+                        <div style="font-size: 11px; color: #666; margin-bottom: 5px;">Precision</div>
+                        <div style="background-color: {colors[2]}; width: 50px; height: {precision*80}px; margin: 0 auto; border-radius: 3px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 9px;">
+                            {precision:.3f}
+                        </div>
+                    </div>
+                </div>
+            """
+        
+        chart_html += "</div></div>"
+        
+        return chart_html
+    
+    def generate_html_report(self) -> str:
+        """تولید گزارش HTML کامل"""
+        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        html = f"""
+        <!DOCTYPE html>
+        <html lang="fa" dir="rtl">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>گزارش بنچمارک ناشناس‌سازی</title>
+            <style>
+                * {{
+                    margin: 0;
+                    padding: 0;
+                    box-sizing: border-box;
+                }}
+                body {{
+                    font-family: 'Tahoma', 'Arial', sans-serif;
+                    line-height: 1.6;
+                    color: #333;
+                    background-color: #f5f5f5;
+                    padding: 20px;
+                }}
+                .container {{
+                    max-width: 1400px;
+                    margin: 0 auto;
+                    background-color: white;
+                    border-radius: 10px;
+                    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+                    overflow: hidden;
+                }}
+                .header {{
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                    padding: 30px;
+                    text-align: center;
+                }}
+                .header h1 {{
+                    font-size: 2.5em;
+                    margin-bottom: 10px;
+                }}
+                .header p {{
+                    font-size: 1.2em;
+                    opacity: 0.9;
+                }}
+                .content {{
+                    padding: 30px;
+                }}
+                .summary {{
+                    background-color: #e8f5e8;
+                    border-right: 5px solid #4CAF50;
+                    padding: 20px;
+                    margin-bottom: 30px;
+                    border-radius: 5px;
+                }}
+                .section {{
+                    margin-bottom: 40px;
+                }}
+                .section h2 {{
+                    color: #333;
+                    border-bottom: 2px solid #4CAF50;
+                    padding-bottom: 10px;
+                    margin-bottom: 20px;
+                }}
+                .metrics-grid {{
+                    display: grid;
+                    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+                    gap: 20px;
+                    margin-bottom: 30px;
+                }}
+                .metric-card {{
+                    background-color: #f8f9fa;
+                    border: 1px solid #dee2e6;
+                    border-radius: 8px;
+                    padding: 20px;
+                    text-align: center;
+                    transition: transform 0.2s;
+                }}
+                .metric-card:hover {{
+                    transform: translateY(-5px);
+                    box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+                }}
+                .metric-number {{
+                    font-size: 2em;
+                    font-weight: bold;
+                    color: #4CAF50;
+                    margin-bottom: 5px;
+                }}
+                .metric-label {{
+                    color: #666;
+                    font-size: 0.9em;
+                }}
+                .footer {{
+                    background-color: #f8f9fa;
+                    padding: 20px;
+                    text-align: center;
+                    color: #666;
+                    border-top: 1px solid #dee2e6;
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <div class="header">
+                    <h1>🏆 گزارش بنچمارک ناشناس‌سازی</h1>
+                    <p>مقایسه عملکرد مدل‌های ChatGPT، Grok و Llama-3.1-8B</p>
+                </div>
+                
+                <div class="content">
+                    <div class="summary">
+                        <h3>📋 خلاصه نتایج</h3>
+                        <p>این گزارش نتایج بنچم��رک سه مدل مختلف برای ناشناس‌سازی متون فارسی را نشان می‌دهد. 
+                        متریک‌های ارزیابی شامل درستی اندیس‌گذاری، ثبات استفاده از شناسه‌ها، حفظ ساختار متن و پوشش موجودیت‌ها می‌باشد.</p>
+                    </div>
+                    
+                    <div class="section">
+                        <h2>📊 جدول مقایسه کامل</h2>
+                        {self.generate_comparison_table()}
+                    </div>
+                    
+                    <div class="section">
+                        <h2>📈 نمودار مقایسه</h2>
+                        {self.generate_charts()}
+                    </div>
+                    
+                    <div class="section">
+                        <h2>🔍 تحلیل تفصیلی</h2>
+                        {self.generate_detailed_analysis()}
+                    </div>
+                </div>
+                
+                <div class="footer">
+                    <p>گزارش تولید شده در تاریخ: {current_time}</p>
+                    <p>ابزار بنچمارک ناشناس‌سازی متون فارسی</p>
+                </div>
+            </div>
+        </body>
+        </html>
+        """
+        
+        return html
+    
+    def generate_detailed_analysis(self) -> str:
+        """تولید تحلیل تفصیلی"""
+        if not self.benchmark_results:
+            return "<p>داده‌ای برای تحلیل یافت نشد</p>"
+        
+        # یافتن بهترین مدل در هر متریک
+        best_accuracy = max(self.benchmark_results.keys(), 
+                           key=lambda k: self.benchmark_results[k].accuracy)
+        best_recall = max(self.benchmark_results.keys(), 
+                         key=lambda k: self.benchmark_results[k].recall)
+        best_precision = max(self.benchmark_results.keys(), 
+                            key=lambda k: self.benchmark_results[k].precision)
+        
+        # محاسبه میانگین
+        avg_accuracy = np.mean([m.accuracy for m in self.benchmark_results.values()])
+        avg_recall = np.mean([m.recall for m in self.benchmark_results.values()])
+        avg_precision = np.mean([m.precision for m in self.benchmark_results.values()])
+        
+        analysis = f"""
+        <div class="metrics-grid">
+            <div class="metric-card">
+                <div class="metric-number">🎯</div>
+                <div class="metric-label">بهترین Accuracy: {best_accuracy}</div>
+                <div style="color: #4CAF50; font-weight: bold;">
+                    {self.benchmark_results[best_accuracy].accuracy:.3f}
+                </div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-number">📊</div>
+                <div class="metric-label">بهترین Recall: {best_recall}</div>
+                <div style="color: #2196F3; font-weight: bold;">
+                    {self.benchmark_results[best_recall].recall:.3f}
+                </div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-number">✅</div>
+                <div class="metric-label">بهترین Precision: {best_precision}</div>
+                <div style="color: #FF9800; font-weight: bold;">
+                    {self.benchmark_results[best_precision].precision:.3f}
+                </div>
+            </div>
+        </div>
+        
+        <div style="background-color: #e3f2fd; border: 1px solid #2196F3; border-radius: 8px; padding: 20px; margin-top: 20px;">
+            <h4>📈 آمار کلی:</h4>
+            <ul style="margin-top: 10px; padding-right: 20px;">
+                <li><strong>میانگین Accuracy:</strong> {avg_accuracy:.3f}</li>
+                <li><strong>میانگین Recall:</strong> {avg_recall:.3f}</li>
+                <li><strong>میانگین Precision:</strong> {avg_precision:.3f}</li>
+            </ul>
+        </div>
+        
+        <div style="background-color: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; padding: 20px; margin-top: 20px;">
+            <h4>💡 تفسیر نتایج:</h4>
+            <ul style="margin-top: 10px; padding-right: 20px;">
+                <li><strong>Accuracy:</strong> دقت کلی ناشناس‌سازی (ترکیب اندیس‌گذاری صحیح و حفظ ساختار)</li>
+                <li><strong>Recall:</strong> پوشش موجودیت‌ها (چه درصدی از موجودیت‌ها شناسایی شدند)</li>
+                <li><strong>Precision:</strong> دقت شناسایی (چه درصدی از شناسه‌ها صحیح هستند)</li>
+            </ul>
+        </div>
+        """
+        
+        return analysis
+
+# رابط کاربری Gradio
+def create_benchmark_interface():
+    """ایجاد رابط کاربری بنچمارک"""
+    benchmark = AnonymizationBenchmark()
+    
+    with gr.Blocks(
+        title="بنچمارک ناشناس‌سازی",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            font-family: 'Tahoma', 'Arial', sans-serif !important;
+            direction: rtl;
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+        .upload-box {
+            border: 2px dashed #4CAF50;
+            border-radius: 10px;
+            padding: 20px;
+            text-align: center;
+            background-color: #f8f9fa;
+            margin: 10px 0;
+        }
+        """
+    ) as interface:
+        
+        gr.Markdown("""
+        # 🏆 ابزار بنچمارک ناشناس‌سازی متون فارسی
+        ### مقایسه عملکرد مدل‌های ChatGPT، Grok، Llama-3.1-8B و ناشناس‌سازی دستی
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📁 بارگذاری فایل‌های CSV")
+                
+                chatgpt_file = gr.File(
+                    label="📄 فایل ChatGPT",
+                    file_types=[".csv"],
+                    elem_classes=["upload-box"]
+                )
+                
+                grok_file = gr.File(
+                    label="📄 فایل Grok", 
+                    file_types=[".csv"],
+                    elem_classes=["upload-box"]
+                )
+                
+                llama_file = gr.File(
+                    label="📄 فایل Llama-3.1-8B",
+                    file_types=[".csv"],
+                    elem_classes=["upload-box"]
+                )
+                
+                manual_file = gr.File(
+                    label="📄 فایل ناشناس‌سازی دستی",
+                    file_types=[".csv"],
+                    elem_classes=["upload-box"]
+                )
+                
+                load_btn = gr.Button(
+                    "📂 بارگذاری فایل‌ها",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                benchmark_btn = gr.Button(
+                    "🚀 اجرای بنچمارک",
+                    variant="secondary", 
+                    size="lg",
+                    interactive=False
+                )
+            
+            with gr.Column(scale=2):
+                status_output = gr.Markdown("وضعیت: آماده بارگذاری فایل‌ها")
+                
+                results_html = gr.HTML(
+                    label="📊 نتایج بنچمارک",
+                    visible=False
+                )
+        
+        def load_files(chatgpt, grok, llama, manual):
+            if not all([chatgpt, grok, llama, manual]):
+                return "❌ لطفاً هر چهار فایل را انتخاب کنید", gr.Button(interactive=False), gr.HTML(visible=False)
+            
+            success, message = benchmark.load_csv_files(
+                chatgpt.name, grok.name, llama.name, manual.name
+            )
+            
+            if success:
+                return (
+                    f"✅ {message}",
+                    gr.Button(interactive=True),
+                    gr.HTML(visible=False)
+                )
+            else:
+                return (
+                    f"❌ {message}",
+                    gr.Button(interactive=False), 
+                    gr.HTML(visible=False)
+                )
+        
+        def run_benchmark():
+            success, message, html_report = benchmark.run_benchmark()
+            
+            if success:
+                return (
+                    f"✅ {message}",
+                    gr.HTML(value=html_report, visible=True)
+                )
+            else:
+                return (
+                    f"❌ {message}",
+                    gr.HTML(visible=False)
+                )
+        
+        # اتصال رویدادها
+        load_btn.click(
+            fn=load_files,
+            inputs=[chatgpt_file, grok_file, llama_file, manual_file],
+            outputs=[status_output, benchmark_btn, results_html]
+        )
+        
+        benchmark_btn.click(
+            fn=run_benchmark,
+            outputs=[status_output, results_html]
+        )
+        
+        # راهنمای استفاده
+        with gr.Accordion("📖 راهنمای استفاده", open=False):
+            gr.Markdown("""
+            ### نحوه استفاده:
+            1. **بارگذاری فایل‌ها:** سه فایل CSV مربوط به نتایج ناشناس‌سازی مدل‌های مختلف را انتخاب کنید
+            2. **بررسی فرمت:** هر فایل باید دارای ستون‌های `original_text` و `anonymized_text` باشد
+            3. **اجرای بنچمارک:** روی دکمه "اجرای بنچمارک" کلیک کنید
+            4. **مشاهده نتایج:** گزارش HTML کامل با جداول و نمودارها نمایش داده م��‌شود
+            
+            ### متریک‌های ارزیابی:
+            - **درستی اندیس‌گذاری:** بررسی شروع از 01 و پیوستگی شماره‌ها
+            - **ثبات شناسه‌ها:** استفاده مداوم از یک شناسه برای یک موجودیت
+            - **حفظ ساختار:** حفظ واژگان مهم و ساختار جمله
+            - **پوشش موجودیت‌ها:** درصد موجودیت‌های شناسایی و ناشناس شده
+            - **امتیاز کلی:** ترکیب وزنی همه متریک‌ها
+            """)
+    
+    return interface
+
+# اجرای برنامه
+if __name__ == "__main__":
+    interface = create_benchmark_interface()
+    interface.launch()