Update app.py

app.py

@@ -15,19 +15,10 @@ class BenchmarkMetrics:
     """کلاس متریک‌های بنچمارک"""
     model_name: str
     total_texts: int
-    avg_original_length: float
-    avg_anonymized_length: float
-    company_entities: int
-    person_entities: int
-    amount_entities: int
-    percent_entities: int
-    group_entities: int
     total_entities: int
-    correct_indexing_rate: float
-    consistency_score: float
-    structure_preservation_score: float
-    entity_coverage_rate: float
-    quality_score: float
+    accuracy: float    # درستی کلی ناشناس‌سازی
+    recall: float      # پوشش موجودیت‌ها
+    precision: float   # دقت شناسایی
 
 class AnonymizationBenchmark:
     """کلاس اصلی بنچمارک ناشناس‌سازی"""
@@ -91,98 +82,50 @@ class AnonymizationBenchmark:
             
         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_consistency_score(self, anonymized_texts: List[str]) -> float:
-        """محاسبه امتیاز ثبات در استفاده از شناسه‌ها"""
-        # این متریک پیچیده‌تر است و نیاز به تحلیل عمیق‌تری دارد
-        # در اینجا یک تقریب ساده ارائه می‌دهم
-        consistency_scores = []
-        
-        for text in anonymized_texts:
-            entities = self.extract_entities_from_text(text)
-            total_entities = sum(len(v) for v in entities.values())
-            unique_entities = sum(len(set(v)) for v in entities.values())
-            
-            if total_entities > 0:
-                consistency = unique_entities / total_entities
-                consistency_scores.append(consistency)
-        
-        return np.mean(consistency_scores) if consistency_scores 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
+    def calculate_accuracy(self, original_text: str, anonymized_text: str) -> float:
+        """محاسبه درستی کلی ناشناس‌سازی"""
+        entities = self.extract_entities_from_text(anonymized_text)
         
-        # بررسی حفظ تعداد کلمات (تقریبی)
-        original_words = len(original_text.split())
-        anonymized_words = len(anonymized_text.split())
+        # بررسی درستی اندیس‌گذاری
+        indexing_score = self.check_indexing_correctness(entities)
         
-        if original_words > 0:
-            word_ratio = min(anonymized_words / original_words, 1.0)
-            score += word_ratio * 2  # وزن بیشتر برای حفظ تعداد کلمات
-            total_checks += 2
+        # بررسی حفظ ساختار
+        structure_score = self.calculate_structure_preservation(original_text, anonymized_text)
         
-        return score / total_checks if total_checks > 0 else 0.0
+        # میانگین وزنی
+        accuracy = (indexing_score * 0.6) + (structure_score * 0.4)
+        return accuracy
     
-    def calculate_entity_coverage(self, original_text: str, anonymized_text: str) -> float:
-        """محاسبه پوشش موجودیت‌ها"""
+    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_overall_quality(self, metrics: Dict[str, float]) -> float:
-        """محاسبه امتیاز کلی کیفیت"""
-        weights = {
-            'correct_indexing_rate': 0.3,
-            'consistency_score': 0.2,
-            'structure_preservation_score': 0.25,
-            'entity_coverage_rate': 0.25
-        }
+    def calculate_precision(self, anonymized_text: str) -> float:
+        """محاسبه دقت شناسایی (Precision)"""
+        entities = self.extract_entities_from_text(anonymized_text)
         
-        quality_score = 0.0
-        for metric, weight in weights.items():
-            quality_score += metrics.get(metric, 0.0) * weight
+        # بررسی کیفیت موجودیت‌های شناسایی شده
+        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
         
-        return quality_score
+        # بررسی عدم تکرار غیرضروری
+        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:
         """تحلیل یک مدل"""
@@ -190,63 +133,32 @@ class AnonymizationBenchmark:
         
         total_texts = len(df)
         
-        # محاسبه طول متن‌ها
-        avg_original_length = df['original_text'].str.len().mean()
-        avg_anonymized_length = df['anonymized_text'].str.len().mean()
-        
-        # استخراج موجودیت‌ها
-        all_entities = {'companies': [], 'persons': [], 'amounts': [], 'percents': [], 'groups': []}
-        indexing_scores = []
-        consistency_scores = []
-        structure_scores = []
-        coverage_scores = []
+        # محاسبه متریک‌ها برای هر متن
+        accuracy_scores = []
+        recall_scores = []
+        precision_scores = []
+        total_entities = 0
         
         for _, row in df.iterrows():
             original = str(row['original_text'])
             anonymized = str(row['anonymized_text'])
             
-            # استخراج موجودیت‌ها
-            entities = self.extract_entities_from_text(anonymized)
-            for key in all_entities.keys():
-                all_entities[key].extend(entities[key])
-            
             # محاسبه متریک‌ها
-            indexing_scores.append(self.check_indexing_correctness(entities))
-            structure_scores.append(self.calculate_structure_preservation(original, anonymized))
-            coverage_scores.append(self.calculate_entity_coverage(original, anonymized))
-        
-        # محاسبه ثبات کلی
-        consistency_score = self.calculate_consistency_score(df['anonymized_text'].tolist())
-        
-        # آمار موجودیت‌ها
-        entity_counts = {
-            'company_entities': len(set(all_entities['companies'])),
-            'person_entities': len(set(all_entities['persons'])),
-            'amount_entities': len(set(all_entities['amounts'])),
-            'percent_entities': len(set(all_entities['percents'])),
-            'group_entities': len(set(all_entities['groups']))
-        }
-        
-        # محاسبه امتیازهای میانگین
-        avg_metrics = {
-            'correct_indexing_rate': np.mean(indexing_scores),
-            'consistency_score': consistency_score,
-            'structure_preservation_score': np.mean(structure_scores),
-            'entity_coverage_rate': np.mean(coverage_scores)
-        }
-        
-        # امتیاز کلی کیفیت
-        quality_score = self.calculate_overall_quality(avg_metrics)
+            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,
-            avg_original_length=round(avg_original_length, 2),
-            avg_anonymized_length=round(avg_anonymized_length, 2),
-            total_entities=sum(entity_counts.values()),
-            quality_score=round(quality_score, 3),
-            **entity_counts,
-            **{k: round(v, 3) for k, v in avg_metrics.items()}
+            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]:
@@ -282,19 +194,10 @@ class AnonymizationBenchmark:
             table_data.append({
                 'مدل': model_name,
                 'تعداد متن‌ها': metrics.total_texts,
-                'میانگین طول اصلی': f"{metrics.avg_original_length:.0f}",
-                'میانگین طول ناشناس': f"{metrics.avg_anonymized_length:.0f}",
-                'شرکت‌ها': metrics.company_entities,
-                'اشخاص': metrics.person_entities,
-                'مبالغ': metrics.amount_entities,
-                'درصدها': metrics.percent_entities,
-                'گروه‌ها': metrics.group_entities,
                 'کل موجودیت‌ها': metrics.total_entities,
-                'درستی اندیس (%)': f"{metrics.correct_indexing_rate*100:.1f}",
-                'ثبات (%)': f"{metrics.consistency_score*100:.1f}",
-                'حفظ ساختار (%)': f"{metrics.structure_preservation_score*100:.1f}",
-                'پوشش موجودیت (%)': f"{metrics.entity_coverage_rate*100:.1f}",
-                '🏆 امتیاز کلی': f"{metrics.quality_score:.3f}"
+                '🎯 دقت (Accuracy)': f"{metrics.accuracy:.3f}",
+                '📊 بازیابی (Recall)': f"{metrics.recall:.3f}",
+                '✅ دقت شناسایی (Precision)': f"{metrics.precision:.3f}"
             })
         
         # تولید HTML جدول
@@ -318,8 +221,8 @@ class AnonymizationBenchmark:
             html += f"<tr style='background-color: {bg_color};'>"
             
             for j, (key, value) in enumerate(row.items()):
-                # رنگ‌بندی ستون امتیاز کلی
-                if key == '🏆 امتیاز کلی':
+                # رنگ‌بندی ستون‌های متریک‌ها
+                if key in ['🎯 دقت (Accuracy)', '📊 بازیابی (Recall)', '✅ دقت شناسایی (Precision)']:
                     score = float(value)
                     if score >= 0.8:
                         color = "#4CAF50"  # سبز
@@ -343,24 +246,48 @@ class AnonymizationBenchmark:
             return ""
         
         models = list(self.benchmark_results.keys())
-        quality_scores = [self.benchmark_results[model].quality_score for model in models]
+        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; align-items: end; height: 300px; gap: 50px; background-color: #f9f9f9; padding: 20px; border-radius: 10px;">
+            <h3 style="text-align: center; color: #333;">مقایسه متریک‌های عملکرد مدل‌ها</h3>
+            <div style="display: flex; justify-content: center; gap: 40px; background-color: #f9f9f9; padding: 30px; border-radius: 15px;">
         """
         
         colors = ['#4CAF50', '#2196F3', '#FF9800']
-        for i, (model, score) in enumerate(zip(models, quality_scores)):
-            height = score * 200  # ارتفاع بر اساس امتیاز
+        
+        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;">
-                    <div style="background-color: {colors[i]}; width: 80px; height: {height}px; border-radius: 5px; margin-bottom: 10px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold;">
-                        {score:.3f}
+                <div style="text-align: center; min-width: 200px;">
+                    <h4 style="margin-bottom: 15px; color: #333;">{model}</h4>
+                    
+                    <div style="margin-bottom: 10px;">
+                        <div style="font-size: 12px; color: #666; margin-bottom: 5px;">Accuracy</div>
+                        <div style="background-color: {colors[0]}; width: 60px; height: {accuracy*100}px; margin: 0 auto; border-radius: 3px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 10px;">
+                            {accuracy:.3f}
+                        </div>
+                    </div>
+                    
+                    <div style="margin-bottom: 10px;">
+                        <div style="font-size: 12px; color: #666; margin-bottom: 5px;">Recall</div>
+                        <div style="background-color: {colors[1]}; width: 60px; height: {recall*100}px; margin: 0 auto; border-radius: 3px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 10px;">
+                            {recall:.3f}
+                        </div>
+                    </div>
+                    
+                    <div style="margin-bottom: 10px;">
+                        <div style="font-size: 12px; color: #666; margin-bottom: 5px;">Precision</div>
+                        <div style="background-color: {colors[2]}; width: 60px; height: {precision*100}px; margin: 0 auto; border-radius: 3px; display: flex; align-items: center; justify-content: center; color: white; font-weight: bold; font-size: 10px;">
+                            {precision:.3f}
+                        </div>
                     </div>
-                    <div style="font-weight: bold; color: #333;">{model}</div>
                 </div>
             """
         
@@ -516,61 +443,59 @@ class AnonymizationBenchmark:
         if not self.benchmark_results:
             return "<p>داده‌ای برای تحلیل یافت نشد</p>"
         
-        # یافتن بهترین مدل
-        best_model = max(self.benchmark_results.keys(), 
-                        key=lambda k: self.benchmark_results[k].quality_score)
+        # یافتن بهترین مدل در هر متریک
+        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)
         
-        best_score = self.benchmark_results[best_model].quality_score
+        # محاسبه میانگین
+        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">بهترین مدل: {best_model}</div>
+                <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">{best_score:.3f}</div>
-                <div class="metric-label">بالاترین امتیاز کلی</div>
+                <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">{len(self.models_data)}</div>
-                <div class="metric-label">تعداد مدل‌های مقایسه شده</div>
+                <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: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; padding: 20px; margin-top: 20px;">
-            <h4>💡 نتیجه‌گیری:</h4>
+        <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;">
-        """
-        
-        # تحلیل نقاط قوت و ضعف هر مدل
-        for model_name, metrics in self.benchmark_results.items():
-            strong_points = []
-            weak_points = []
-            
-            if metrics.correct_indexing_rate > 0.8:
-                strong_points.append("اندیس‌گذاری دقیق")
-            else:
-                weak_points.append("مشکل در اندیس���گذاری")
-            
-            if metrics.structure_preservation_score > 0.8:
-                strong_points.append("حفظ ساختار متن")
-            else:
-                weak_points.append("ضعف در حفظ ساختار")
-            
-            if metrics.entity_coverage_rate > 0.8:
-                strong_points.append("پوشش مناسب موجودیت‌ها")
-            else:
-                weak_points.append("پوشش ناکافی موجودیت‌ها")
-            
-            analysis += f"""
-                <li><strong>{model_name}:</strong> 
-                    نقاط قوت: {', '.join(strong_points) if strong_points else 'ندارد'} | 
-                    نقاط ضعف: {', '.join(weak_points) if weak_points else 'ندارد'}
-                </li>
-            """
+                <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>
         
-        analysis += """
+        <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>
         """