Upload complete_hf_app.py

complete_hf_app.py

@@ -0,0 +1,772 @@
+"""
+NER Anonymization Evaluator for Hugging Face Spaces
+ابزار ارزیابی استاندارد سیستم‌های ناشناس‌سازی با NER
+
+Author: Your Name
+Version: 1.0.0
+License: MIT
+"""
+
+import pandas as pd
+import numpy as np
+import re
+from typing import Dict, List, Tuple
+import gradio as gr
+from datetime import datetime
+import io
+
+# ==================== Import seqeval ====================
+try:
+    from seqeval.metrics import (
+        classification_report,
+        f1_score,
+        precision_score,
+        recall_score,
+        accuracy_score
+    )
+    from seqeval.scheme import IOB2
+    SEQEVAL_AVAILABLE = True
+except ImportError:
+    SEQEVAL_AVAILABLE = False
+    print("⚠️ Warning: seqeval not installed. Only Exact Match will be available.")
+
+
+# ==================== Main Evaluator Class ====================
+class StandardNEREvaluator:
+    """
+    ارزیابی استاندارد Named Entity Recognition
+    
+    این کلاس دو روش ارزیابی ارائه می‌دهد:
+    1. seqeval: استاندارد علمی با IOB2 tagging
+    2. Exact Match: مقایسه مستقیم شناسه‌ها
+    """
+    
+    def __init__(self):
+        """مقداردهی اولیه"""
+        self.results_df = None
+        
+        # انواع entity های پشتیبانی شده
+        self.entity_types = ['COMPANY', 'PERSON', 'AMOUNT', 'PERCENT', 'GROUP', 'STOCK']
+        
+        # الگوهای regex برای تشخیص entities
+        self.patterns = {
+            'COMPANY': [
+                r'company-(\d+)', r'Company-(\d+)', r'COMPANY-(\d+)',
+                r'COMPANY_(\d+)(?:_[A-Z]+)?', r'company_(\d+)(?:_[a-z]+)?'
+            ],
+            'PERSON': [
+                r'person-(\d+)', r'Person-(\d+)', r'PERSON-(\d+)',
+                r'PERSON_(\d+)(?:_[A-Z]+)?', r'person_(\d+)(?:_[a-z]+)?'
+            ],
+            'AMOUNT': [
+                r'amount-(\d+)', r'Amount-(\d+)', r'AMOUNT-(\d+)',
+                r'AMOUNT_(\d+)(?:_[A-Z]+)?', r'amount_(\d+)(?:_[a-z]+)?'
+            ],
+            'PERCENT': [
+                r'percent-(\d+)', r'Percent-(\d+)', r'PERCENT-(\d+)',
+                r'PERCENT_(\d+)(?:_[A-Z]+)?', r'percent_(\d+)(?:_[a-z]+)?'
+            ],
+            'GROUP': [
+                r'group-(\d+)', r'Group-(\d+)', r'GROUP-(\d+)',
+                r'GROUP_(\d+)(?:_[A-Z]+)?', r'group_(\d+)(?:_[a-z]+)?'
+            ],
+            'STOCK': [
+                r'stock-(\d+)', r'Stock-(\d+)', r'STOCK-(\d+)',
+                r'STOCK_SYMBOL_(\d+)(?:_[A-Z]+)?', r'stock_symbol_(\d+)(?:_[a-z]+)?'
+            ]
+        }
+    
+    def tokenize_text(self, text: str) -> List[str]:
+        """
+        تبدیل متن به توکن‌ها (کلمات)
+        
+        Args:
+            text: متن ورودی
+            
+        Returns:
+            لیست توکن‌ها
+        """
+        if pd.isna(text) or not isinstance(text, str):
+            return []
+        return text.split()
+    
+    def text_to_iob2_tags(self, text: str) -> List[str]:
+        """
+        تبدیل متن به فرمت IOB2 Tagging
+        
+        IOB2 Format:
+        - B-TYPE: Beginning of entity
+        - I-TYPE: Inside entity (continuation)
+        - O: Outside (not an entity)
+        
+        Args:
+            text: متن ورودی
+            
+        Returns:
+            لیست تگ‌های IOB2
+        """
+        if pd.isna(text) or not isinstance(text, str):
+            return []
+        
+        tokens = self.tokenize_text(text)
+        tags = ['O'] * len(tokens)
+        
+        # پیدا کردن entities در متن
+        for entity_type, pattern_list in self.patterns.items():
+            for pattern in pattern_list:
+                for match in re.finditer(pattern, text):
+                    start_pos = match.start()
+                    end_pos = match.end()
+                    
+                    # پیدا کردن توکن‌هایی که entity در آنها است
+                    current_pos = 0
+                    for i, token in enumerate(tokens):
+                        token_start = text.find(token, current_pos)
+                        token_end = token_start + len(token)
+                        
+                        if token_start >= start_pos and token_end <= end_pos:
+                            if tags[i] == 'O':
+                                # اولین توکن: B-TYPE
+                                if token_start == start_pos or i == 0 or tags[i-1].split('-')[-1] != entity_type:
+                                    tags[i] = f'B-{entity_type}'
+                                # توکن‌های بعدی: I-TYPE
+                                else:
+                                    tags[i] = f'I-{entity_type}'
+                        
+                        current_pos = token_end
+        
+        return tags
+    
+    def evaluate_with_seqeval(self, reference_text: str, predicted_text: str) -> Dict:
+        """
+        ارزیابی با seqeval (روش استاندارد)
+        
+        Args:
+            reference_text: متن مرجع
+            predicted_text: متن پیش‌بینی شده
+            
+        Returns:
+            دیکشنری شامل metrics
+        """
+        if not SEQEVAL_AVAILABLE:
+            return {
+                'precision': 0.0,
+                'recall': 0.0,
+                'f1': 0.0,
+                'accuracy': 0.0,
+                'error': 'seqeval not available'
+            }
+        
+        try:
+            # تبدیل به IOB2 tags
+            y_true = [self.text_to_iob2_tags(reference_text)]
+            y_pred = [self.text_to_iob2_tags(predicted_text)]
+            
+            # اگر هر دو خالی باشند
+            if not y_true[0] and not y_pred[0]:
+                return {
+                    'precision': 1.0,
+                    'recall': 1.0,
+                    'f1': 1.0,
+                    'accuracy': 1.0
+                }
+            
+            # محاسبه metrics
+            precision = precision_score(y_true, y_pred, scheme=IOB2, mode='strict')
+            recall = recall_score(y_true, y_pred, scheme=IOB2, mode='strict')
+            f1 = f1_score(y_true, y_pred, scheme=IOB2, mode='strict')
+            accuracy = accuracy_score(y_true, y_pred)
+            
+            return {
+                'precision': round(precision, 4),
+                'recall': round(recall, 4),
+                'f1': round(f1, 4),
+                'accuracy': round(accuracy, 4)
+            }
+            
+        except Exception as e:
+            print(f"خطا در seqeval: {str(e)}")
+            return {
+                'precision': 0.0,
+                'recall': 0.0,
+                'f1': 0.0,
+                'accuracy': 0.0,
+                'error': str(e)
+            }
+    
+    def evaluate_with_exact_match(self, reference_text: str, predicted_text: str) -> Dict:
+        """
+        ارزیابی با Exact Match (روش ساده)
+        
+        Args:
+            reference_text: متن مرجع
+            predicted_text: متن پیش‌بینی شده
+            
+        Returns:
+            دیکشنری شامل metrics
+        """
+        def extract_entities(text):
+            """استخراج entities از متن"""
+            entities = set()
+            for entity_type, pattern_list in self.patterns.items():
+                for pattern in pattern_list:
+                    for match in re.finditer(pattern, text):
+                        entity_id = match.group(1)
+                        entities.add(f"{entity_type}-{entity_id}")
+            return entities
+        
+        ref_entities = extract_entities(reference_text)
+        pred_entities = extract_entities(predicted_text)
+        
+        # محاسبه TP, FP, FN
+        tp = len(ref_entities & pred_entities)
+        fp = len(pred_entities - ref_entities)
+        fn = len(ref_entities - pred_entities)
+        
+        # محاسبه metrics
+        precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0
+        
+        return {
+            'precision': round(precision, 4),
+            'recall': round(recall, 4),
+            'f1': round(f1, 4),
+            'tp': tp,
+            'fp': fp,
+            'fn': fn
+        }
+    
+    def evaluate_single_row(self, reference_text: str, predicted_text: str) -> Dict:
+        """
+        ارزیابی یک سطر با هر دو روش
+        
+        Args:
+            reference_text: متن مرجع
+            predicted_text: متن پیش‌بینی شده
+            
+        Returns:
+            دیکشنری شامل همه metrics
+        """
+        # روش 1: seqeval
+        seqeval_metrics = self.evaluate_with_seqeval(reference_text, predicted_text)
+        
+        # روش 2: Exact Match
+        exact_metrics = self.evaluate_with_exact_match(reference_text, predicted_text)
+        
+        return {
+            'seqeval_precision': seqeval_metrics['precision'],
+            'seqeval_recall': seqeval_metrics['recall'],
+            'seqeval_f1': seqeval_metrics['f1'],
+            'seqeval_accuracy': seqeval_metrics['accuracy'],
+            'exact_precision': exact_metrics['precision'],
+            'exact_recall': exact_metrics['recall'],
+            'exact_f1': exact_metrics['f1'],
+            'tp_count': exact_metrics['tp'],
+            'fp_count': exact_metrics['fp'],
+            'fn_count': exact_metrics['fn']
+        }
+    
+    def evaluate_dataset(self, file_path: str) -> Tuple[bool, str, pd.DataFrame]:
+        """
+        ارزیابی کل دیتاست
+        
+        Args:
+            file_path: مسیر فایل CSV
+            
+        Returns:
+            (موفقیت, پیام وضعیت, DataFrame نتایج)
+        """
+        if not SEQEVAL_AVAILABLE:
+            return (
+                False, 
+                "⚠️ seqeval نصب نیست. لطفاً requirements.txt را چک کنید.", 
+                pd.DataFrame()
+            )
+        
+        try:
+            # بارگذاری فایل
+            df = pd.read_csv(file_path)
+            
+            # تشخیص ستون‌ها
+            if 'Reference_text' in df.columns and 'anonymized_text' in df.columns:
+                reference_col = 'Reference_text'
+                predicted_col = 'anonymized_text'
+            elif 'original_text' in df.columns and 'anonymized_text' in df.columns:
+                reference_col = 'original_text'
+                predicted_col = 'anonymized_text'
+            else:
+                return (
+                    False, 
+                    "❌ فایل باید شامل ستون‌های 'original_text' و 'anonymized_text' باشد", 
+                    pd.DataFrame()
+                )
+            
+            # ارزیابی هر سطر
+            results = []
+            for index, row in df.iterrows():
+                metrics = self.evaluate_single_row(
+                    str(row[reference_col]),
+                    str(row[predicted_col])
+                )
+                results.append(metrics)
+            
+            # ایجاد DataFrame نتایج
+            results_df = pd.DataFrame(results)
+            
+            # اضافه کردن ستون‌های اصلی
+            for col in df.columns:
+                results_df[col] = df[col].values
+            
+            # ترتیب ستون‌ها
+            metric_cols = [
+                'seqeval_precision', 'seqeval_recall', 'seqeval_f1', 'seqeval_accuracy',
+                'exact_precision', 'exact_recall', 'exact_f1',
+                'tp_count', 'fp_count', 'fn_count'
+            ]
+            other_cols = [col for col in results_df.columns if col not in metric_cols]
+            results_df = results_df[metric_cols + other_cols]
+            
+            self.results_df = results_df
+            
+            # محاسبه آمار کلی
+            avg_seqeval_p = results_df['seqeval_precision'].mean()
+            avg_seqeval_r = results_df['seqeval_recall'].mean()
+            avg_seqeval_f1 = results_df['seqeval_f1'].mean()
+            avg_seqeval_acc = results_df['seqeval_accuracy'].mean()
+            avg_exact_f1 = results_df['exact_f1'].mean()
+            
+            total_tp = results_df['tp_count'].sum()
+            total_fp = results_df['fp_count'].sum()
+            total_fn = results_df['fn_count'].sum()
+            
+            # ایجاد پیام وضعیت
+            status = f"""✅ ارزیابی با موفقیت انجام شد!
+
+📊 **نتایج seqeval (استاندارد NER - IOB2 Tagging):**
+• Precision: {avg_seqeval_p:.4f}
+• Recall: {avg_seqeval_r:.4f}
+• F1-Score: {avg_seqeval_f1:.4f}
+• Accuracy: {avg_seqeval_acc:.4f}
+
+📈 **آمار کلی:**
+• کل True Positives: {total_tp}
+• کل False Positives: {total_fp}
+• کل False Negatives: {total_fn}
+• تعداد سطرها: {len(df)}
+
+🔬 **مقایسه با Exact Match:**
+• F1 (seqeval): {avg_seqeval_f1:.4f}
+• F1 (Exact): {avg_exact_f1:.4f}
+• اختلاف: {abs(avg_seqeval_f1 - avg_exact_f1):.4f}
+
+✅ این ارزیابی مطابق با استانداردهای CoNLL-2003 است"""
+            
+            return True, status, results_df
+            
+        except Exception as e:
+            return False, f"❌ خطا در پردازش: {str(e)}", pd.DataFrame()
+    
+    def generate_report(self, df: pd.DataFrame) -> str:
+        """
+        تولید گزارش جامع
+        
+        Args:
+            df: DataFrame نتایج
+            
+        Returns:
+            متن گزارش
+        """
+        if df.empty:
+            return "هیچ داده‌ای برای گزارش یافت نشد"
+        
+        # محاسبه آمار
+        total_rows = len(df)
+        
+        avg_seqeval_p = df['seqeval_precision'].mean()
+        avg_seqeval_r = df['seqeval_recall'].mean()
+        avg_seqeval_f1 = df['seqeval_f1'].mean()
+        avg_seqeval_acc = df['seqeval_accuracy'].mean()
+        
+        high_f1_count = len(df[df['seqeval_f1'] >= 0.9])
+        mid_f1_count = len(df[df['seqeval_f1'] >= 0.7])
+        low_f1_count = len(df[df['seqeval_f1'] < 0.5])
+        
+        best_idx = df['seqeval_f1'].idxmax()
+        worst_idx = df['seqeval_f1'].idxmin()
+        
+        # تفسیر نتایج
+        if avg_seqeval_f1 >= 0.9:
+            interpretation = "✅ عملکرد عالی - سیستم شما بسیار دقیق است"
+        elif avg_seqeval_f1 >= 0.7:
+            interpretation = "⚠️ عملکرد خوب - اما قابل بهبود"
+        else:
+            interpretation = "❌ عملکرد ضعیف - نیاز به بهبود اساسی"
+        
+        report = f"""
+## 📊 گزارش جامع ارزیابی NER
+
+### 🎯 خلاصه نتا��ج:
+{interpretation}
+
+### 📈 آمار کلی:
+- **تعداد کل سطرها:** {total_rows}
+- **روش ارزیابی:** IOB2 Tagging (استاندارد CoNLL-2003)
+
+### ✅ نتایج seqeval (استاندارد):
+- **میانگین Precision:** {avg_seqeval_p:.4f}
+- **میانگین Recall:** {avg_seqeval_r:.4f}
+- **میانگین F1-Score:** {avg_seqeval_f1:.4f}
+- **میانگین Accuracy:** {avg_seqeval_acc:.4f}
+
+### 📊 توزیع عملکرد:
+- **F1 ≥ 0.9 (عالی):** {high_f1_count} سطر ({high_f1_count/total_rows*100:.1f}%)
+- **F1 ≥ 0.7 (خوب):** {mid_f1_count} سطر ({mid_f1_count/total_rows*100:.1f}%)
+- **F1 < 0.5 (ضعیف):** {low_f1_count} سطر ({low_f1_count/total_rows*100:.1f}%)
+
+### 🏆 بهترین و بدترین:
+- **بهترین F1:** {df.loc[best_idx, 'seqeval_f1']:.4f} (سطر {best_idx + 1})
+- **بدترین F1:** {df.loc[worst_idx, 'seqeval_f1']:.4f} (سطر {worst_idx + 1})
+
+### 💡 توصیه‌ها:
+{"- سیستم شما عملکرد بسیار خوبی دارد" if avg_seqeval_f1 >= 0.9 else ""}
+{"- روی بهبود Precision تمرکز کنید" if avg_seqeval_p < avg_seqeval_r else ""}
+{"- روی بهبود Recall تمرکز کنید" if avg_seqeval_r < avg_seqeval_p else ""}
+{"- نیاز به بازنگری اساسی در مدل دارید" if avg_seqeval_f1 < 0.5 else ""}
+        """
+        
+        return report
+    
+    def create_csv(self) -> bytes:
+        """
+        ایجاد فایل CSV برای دانلود
+        
+        Returns:
+            محتوای CSV به صورت bytes
+        """
+        if self.results_df is None or self.results_df.empty:
+            return None
+        
+        try:
+            csv_buffer = io.StringIO()
+            self.results_df.to_csv(csv_buffer, index=False, encoding='utf-8')
+            return csv_buffer.getvalue().encode('utf-8-sig')
+        except Exception as e:
+            print(f"خطا در ایجاد CSV: {str(e)}")
+            return None
+
+
+# ==================== Gradio Interface ====================
+def create_interface():
+    """ایجاد رابط کاربری Gradio"""
+    
+    evaluator = StandardNEREvaluator()
+    
+    # بررسی وضعیت seqeval
+    seqeval_status = "✅ فعال و آماده" if SEQEVAL_AVAILABLE else "❌ نصب نشده"
+    seqeval_emoji = "🟢" if SEQEVAL_AVAILABLE else "🔴"
+    
+    # تعریف CSS سفارشی
+    custom_css = """
+    .rtl {
+        direction: rtl;
+        text-align: right;
+        font-family: Tahoma, Arial, sans-serif;
+    }
+    .ltr {
+        direction: ltr;
+        text-align: left;
+    }
+    .center {
+        text-align: center;
+    }
+    .header-box {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .status-box {
+        background: #f0f9ff;
+        border-left: 4px solid #0284c7;
+        padding: 15px;
+        border-radius: 5px;
+        margin: 10px 0;
+    }
+    .metric-good {
+        color: #059669;
+        font-weight: bold;
+    }
+    .metric-bad {
+        color: #dc2626;
+        font-weight: bold;
+    }
+    """
+    
+    # ساخت Interface
+    with gr.Blocks(
+        title="NER Anonymization Evaluator",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="purple",
+        ),
+        css=custom_css
+    ) as demo:
+        
+        # هدر
+        with gr.Row():
+            gr.Markdown(f"""
+            <div class="header-box">
+            <h1 style="margin:0; text-align:center;">🎯 ابزار ارزیابی استاندارد NER</h1>
+            <p style="margin:5px 0 0 0; text-align:center;">
+                Named Entity Recognition Evaluation Tool
+            </p>
+            </div>
+            """)
+        
+        # وضعیت seqeval
+        with gr.Row():
+            gr.Markdown(f"""
+            <div class="status-box rtl">
+            <strong>وضعیت seqeval:</strong> {seqeval_emoji} {seqeval_status}
+            <br>
+            <small>این ابزار برای ارزیابی سیستم‌های ناشناس‌سازی متن با استفاده از الگوریتم‌های استاندارد NER طراحی شده است.</small>
+            </div>
+            """)
+        
+        # بخش اصلی
+        with gr.Row():
+            # ستون چپ: آپلود
+            with gr.Column(scale=1):
+                gr.Markdown("### 📁 بارگذاری فایل", elem_classes=["rtl"])
+                
+                file_input = gr.File(
+                    label="فایل CSV",
+                    file_types=[".csv"],
+                    type="filepath"
+                )
+                
+                gr.Markdown("""
+                <div class="rtl" style="font-size:0.9em; color:#666;">
+                فایل باید شامل دو ستون باشد:<br>
+                • <code>original_text</code> یا <code>Reference_text</code><br>
+                • <code>anonymized_text</code>
+                </div>
+                """)
+                
+                evaluate_btn = gr.Button(
+                    "🚀 شروع ارزیابی",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                download_btn = gr.DownloadButton(
+                    label="💾 دانلود نتایج CSV",
+                    visible=False,
+                    variant="secondary"
+                )
+            
+            # ستون راست: وضعیت
+            with gr.Column(scale=2):
+                status_output = gr.Markdown(
+                    "آماده دریافت فایل CSV...",
+                    elem_classes=["rtl"]
+                )
+        
+        # گزارش خلاصه
+        summary_output = gr.Markdown(
+            visible=False,
+            elem_classes=["rtl"]
+        )
+        
+        # جدول نتایج
+        results_table = gr.Dataframe(
+            label="نتایج تفصیلی (10 سطر اول)",
+            visible=False,
+            wrap=True
+        )
+        
+        # راهنما
+        with gr.Accordion("📖 راهنمای استفاده", open=False):
+            gr.Markdown("""
+            <div class="rtl">
+            
+            ## 🎯 نحوه استفاده:
+            
+            ### 1. آماده‌سازی فایل CSV:
+            
+            فایل شما باید شامل دو ستون باشد:
+            
+            ```csv
+            original_text,anonymized_text
+            "شرکت فولاد مبارکه","شرکت company-01"
+            "آقای احمد رضایی","person-02"
+            "سود 15 درصد","سود percent-03"
+            ```
+            
+            ### 2. فرمت‌های پشتیبانی شده:
+            
+            #### شرکت‌ها (Company):
+            - `company-01`, `Company-01`, `COMPANY-01`
+            - `COMPANY_001`, `COMPANY_001_REGEX`
+            
+            #### افراد (Person):
+            - `person-02`, `Person-02`, `PERSON-02`
+            - `PERSON_002`, `PERSON_002_REGEX`
+            
+            #### مبالغ (Amount):
+            - `amount-03`, `AMOUNT-03`
+            - `AMOUNT_003`, `AMOUNT_003_REGEX`
+            
+            #### درصدها (Percent):
+            - `percent-04`, `PERCENT-04`
+            
+            #### گروه‌ها (Group):
+            - `group-05`, `GROUP-05`
+            
+            #### سهام (Stock):
+            - `stock-06`, `STOCK-06`
+            - `STOCK_SYMBOL_006`
+            
+            ### 3. معیارهای ارزیابی:
+            
+            - **Precision**: از entities شناسایی شده، چند درصد درست بودند؟
+            - **Recall**: از entities واقعی، چند درصد پیدا شدند؟
+            - **F1-Score**: میانگین هماهنگ Precision و Recall
+            - **Accuracy**: دقت کلی
+            
+            ### 4. روش‌های ارزیابی:
+            
+            1. **seqeval (پیشنهادی)**: استفاده از IOB2 tagging - استاندارد CoNLL-2003
+            2. **Exact Match**: مقایسه مستقیم شناسه‌ها
+            
+            ### 5. تفسیر نتایج:
+            
+            - **F1 ≥ 0.9**: عملکرد عالی ✅
+            - **F1 ≥ 0.7**: عملکرد خوب ⚠️
+            - **F1 < 0.7**: نیاز به بهبود ❌
+            
+            </div>
+            """)
+        
+        # مثال
+        with gr.Accordion("💡 مثال عملی", open=False):
+            gr.Markdown("""
+            <div class="rtl">
+            
+            ## مثال:
+            
+            ### ورودی:
+            ```
+            متن مرجع:     "شرکت company-01 با person-02 کار می‌کند"
+            متن پیش‌بینی: "شرکت company-01 با person-99 کار می‌کند"
+            ```
+            
+            ### تحلیل:
+            - ✅ `company-01` درست شناسایی شد
+            - ❌ `person-02` باید بود اما `person-99` شد
+            
+            ### نتایج:
+            - **True Positive**: 1 (company-01)
+            - **False Positive**: 1 (person-99)
+            - **False Negative**: 1 (person-02)
+            - **Precision**: 0.50
+            - **Recall**: 0.50
+            - **F1-Score**: 0.50
+            
+            ### تفسیر:
+            سیستم 50% دقت دارد - نیمی از entities را درست تشخیص داده است.
+            
+            </div>
+            """)
+        
+        # فوتر
+        gr.Markdown("""
+        ---
+        
+        <div class="center">
+        
+        ### 📚 منابع:
+        [seqeval](https://github.com/chakki-works/seqeval) • 
+        [CoNLL-2003](https://www.clips.uantwerpen.be/conll2003/ner/) • 
+        [Gradio](https://gradio.app)
+        
+        ---
+        
+        Made with ❤️ for Persian NLP Community
+        
+        <small>Version 1.0.0 • MIT License</small>
+        
+        </div>
+        """)
+        
+        # ==================== Event Handlers ====================
+        
+        def evaluate_file(file):
+            """تابع ارزیابی فایل"""
+            if file is None:
+                return (
+                    "❌ لطفاً فایل CSV را بارگذاری کنید",
+                    gr.Markdown(visible=False),
+                    gr.Dataframe(visible=False),
+                    gr.DownloadButton(visible=False)
+                )
+            
+            try:
+                # ارزیابی
+                success, message, df = evaluator.evaluate_dataset(file)
+                
+                if not success:
+                    return (
+                        f"❌ {message}",
+                        gr.Markdown(visible=False),
+                        gr.Dataframe(visible=False),
+                        gr.DownloadButton(visible=False)
+                    )
+                
+                # تولید گزارش
+                summary = evaluator.generate_report(df)
+                
+                # ایجاد CSV
+                csv_content = evaluator.create_csv()
+                
+                # نمایش نتایج
+                return (
+                    message,
+                    gr.Markdown(value=summary, visible=True),
+                    gr.Dataframe(value=df.head(10), visible=True),
+                    gr.DownloadButton(
+                        label="💾 دانلود نتایج کامل CSV",
+                        value=csv_content,
+                        visible=True
+                    )
+                )
+                
+            except Exception as e:
+                return (
+                    f"❌ خطای غیرمنتظره: {str(e)}",
+                    gr.Markdown(visible=False),
+                    gr.Dataframe(visible=False),
+                    gr.DownloadButton(visible=False)
+                )
+        
+        # اتصال event
+        evaluate_btn.click(
+            fn=evaluate_file,
+            inputs=[file_input],
+            outputs=[status_output, summary_output, results_table, download_btn]
+        )
+    
+    return demo
+
+
+# ==================== Main ====================
+if __name__ == "__main__":
+    # ایجاد و اجرای interface
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )