Оновлено Пакетний режим тестування. Робочий варіант

.gitignore

@@ -4,4 +4,5 @@ __pycache__/
 .env
 
 *.npz
-*.db
+*.db
+*.csv

.~lock.kw_questions_tested.csv#

@@ -0,0 +1 @@
+,docsa,docsa-HP-ProBook-450-G7,03.02.2025 12:17,file:///home/docsa/.config/libreoffice/4;

app.py

@@ -85,24 +85,13 @@ def create_interface(app: ClassifierApp) -> gr.Blocks:
             
             # Вкладка 3: Пакетна обробка
             with gr.TabItem("Пакетна обробка"):
-                gr.Markdown("## 1) Завантаження даних")
+                gr.Markdown("## Оцінка класифікації")
                 with gr.Row():
-                    csv_input = gr.Textbox(
-                        value="messages.csv",
-                        label="CSV-файл"
+                    csv_input = gr.File(
+                        label="CSV файл з колонками Category та Question",
+                        file_types=[".csv"]
                     )
-                    emb_input = gr.Textbox(
-                        value="embeddings.npy",
-                        label="Numpy Embeddings"
-                    )
-                    load_btn = gr.Button("Завантажити дані")
-                
-                load_output = gr.Label(label="Результат завантаження")
-                
-                gr.Markdown("## 2) Класифікація")
-                with gr.Row():
-                    filter_in = gr.Textbox(label="Фільтр (опціонально)")
-                    batch_threshold = gr.Slider(
+                    threshold_slider_batch = gr.Slider(
                         minimum=0.0,
                         maximum=1.0,
                         value=0.3,
@@ -110,12 +99,17 @@ def create_interface(app: ClassifierApp) -> gr.Blocks:
                         label="Поріг впевненості"
                     )
                 
-                classify_btn = gr.Button("Класифікувати")
-                classify_out = gr.Dataframe(label="Результат (Message / Target / Scores)")
+                evaluate_btn = gr.Button("Оцінити класифікацію")
                 
-                gr.Markdown("## 3) Зберегти результати")
-                save_btn = gr.Button("Зберегти розмічені дані")
-                save_out = gr.Label()
+                results_df = gr.DataFrame(
+                    label="Результати класифікації"
+                )
+                
+                stats_md = gr.Markdown("### Статистика класифікації")
+
+                save_results_btn = gr.Button("Завантажити результати")
+                download_file = gr.File(label="Завантажити файл з результатами")
+                save_status = gr.Markdown()
 
         # Підключення обробників подій
         model_type.change(
@@ -156,22 +150,15 @@ def create_interface(app: ClassifierApp) -> gr.Blocks:
             outputs=result_text
         )
         
-        load_btn.click(
-            fn=app.load_data,
-            inputs=[csv_input, emb_input],
-            outputs=load_output
-        )
-        
-        classify_btn.click(
-            fn=app.classify_batch,
-            inputs=[filter_in, batch_threshold],
-            outputs=classify_out
+        evaluate_btn.click(
+            fn=app.evaluate_batch,
+            inputs=[csv_input, threshold_slider_batch],
+            outputs=[results_df, stats_md]
         )
         
-        save_btn.click(
-            fn=app.save_results,
-            inputs=[],
-            outputs=save_out
+        save_results_btn.click(
+            fn=app.save_evaluation_results,
+            outputs=[download_file, save_status]
         )
 
     return demo

classifier_app.py

@@ -5,13 +5,17 @@ import json
 import os
 from typing import Dict, Tuple, Optional, Any, List
 from dataclasses import dataclass, field
+import pandas as pd
 
 # Load environment variables
 load_dotenv()
 
 @dataclass
 class Config:
-    DEFAULT_CLASSES_FILE: str = "classes.json"
+    # DEFAULT_CLASSES_FILE: str = "classes.json"
+    DEFAULT_CLASSES_FILE: str = "kw_questions.json"
+
+
     DEFAULT_SIGNATURES_FILE: str = "signatures.npz"
     CACHE_FILE: str = "embeddings_cache.db"
     MODEL_INFO_FILE: str = "model_info.json"
@@ -29,6 +33,7 @@ class ClassifierApp:
             "classes_info": {},
             "errors": []
         }
+        self.model_type = "Local"  # Додати цей рядок
 
     def initialize_environment(self) -> Tuple[Dict, Optional[SDCClassifier]]:
         """Ініціалізація середовища при першому запуску"""
@@ -345,6 +350,86 @@ class ClassifierApp:
             }
             return self.initial_info
 
+    def evaluate_batch(self, csv_file, threshold: float) -> tuple[pd.DataFrame, str]:
+        """
+        Оцінка пакетної класифікації
+        
+        Args:
+            csv_file: завантажений CSV файл від gradio
+            threshold: поріг впевненості
+            
+        Returns:
+            tuple[pd.DataFrame, str]: результати та статистика
+        """
+        try:
+            if self.classifier is None:
+                return None, "Помилка: Класифікатор не ініціалізовано"
+            
+            # Перевірка на None
+            if csv_file is None:
+                return None, "Помилка: Файл не завантажено"
+                
+            # Зберігаємо тимчасовий файл
+            temp_path = "temp_upload.csv"
+            if hasattr(csv_file, 'name'):
+                # Якщо це файловий об'єкт від gradio
+                import shutil
+                shutil.copy2(csv_file.name, temp_path)
+            else:
+                # Якщо це шлях до файлу
+                temp_path = str(csv_file)
+                
+            # Виконуємо класифікацію
+            results_df, statistics = self.classifier.evaluate_classification(temp_path, threshold)
+            
+            # Формуємо текст статистики
+            stats_md = f"""### Статистика класифікації
+    - Всього зразків: {statistics['total_samples']}
+    - Правильний клас на першому місці: {statistics['correct_first_place']['count']} ({statistics['correct_first_place']['percentage']}%)
+    - Правильний клас в топ-3: {statistics['in_top3']['count']} ({statistics['in_top3']['percentage']}%)
+    - Правильний клас не знайдено: {statistics['not_found']['count']} ({statistics['not_found']['percentage']}%)
+
+    #### Середня впевненість для правильних класифікацій: {statistics['mean_confidence_correct']}%
+
+    #### Розподіл впевненості:
+    - 90-100%: {statistics['confidence_distribution']['90-100%']['count']} ({statistics['confidence_distribution']['90-100%']['percentage']}%)
+    - 70-90%: {statistics['confidence_distribution']['70-90%']['count']} ({statistics['confidence_distribution']['70-90%']['percentage']}%)
+    - 50-70%: {statistics['confidence_distribution']['50-70%']['count']} ({statistics['confidence_distribution']['50-70%']['percentage']}%)
+    - <50%: {statistics['confidence_distribution']['<50%']['count']} ({statistics['confidence_distribution']['<50%']['percentage']}%)
+    """
+            
+            # Зберігаємо результати для подальшого використання
+            self.current_evaluation_results = results_df
+            
+            # Видаляємо тимчасовий файл якщо він був створений
+            if temp_path == "temp_upload.csv" and os.path.exists(temp_path):
+                os.remove(temp_path)
+                
+            return results_df, stats_md
+        except Exception as e:
+            # У випадку помилки спробуємо видалити тимчасовий файл
+            if os.path.exists("temp_upload.csv"):
+                os.remove("temp_upload.csv")
+            return None, f"Помилка: {str(e)}"
+    
+    def save_evaluation_results(self) -> tuple[str, str]:
+        """
+        Зберігає результати останньої оцінки класифікації та готує файл для завантаження
+        
+        Returns:
+            tuple[str, str]: (шлях до файлу, повідомлення про статус)
+        """
+        try:
+            if not hasattr(self, 'current_evaluation_results'):
+                return None, "Помилка: Немає результатів для збереження"
+            
+            output_path = "evaluation_results.csv"
+            self.current_evaluation_results.to_csv(output_path, index=False)
+            return output_path, f"Результати збережено у файл {output_path}"
+            
+        except Exception as e:
+            return None, f"Помилка при збереженні: {str(e)}"
+
     @staticmethod
     def update_system_markdown(info: Dict) -> str:
         """Оновлення Markdown з системною інформацією"""

model_info.json

@@ -3,8 +3,8 @@
   "classes_count": 0,
   "signatures_count": 0,
   "cache_stats": {
-    "total_entries": 8746,
-    "cache_size_mb": 51.91,
+    "total_entries": 7756,
+    "cache_size_mb": 30.84,
     "hits": 0,
     "misses": 0,
     "hit_rate_percent": 0

sdc_classifier.py

@@ -430,7 +430,186 @@ class SDCClassifier:
             
         with open(path, 'w', encoding='utf-8') as f:
             json.dump(info, f, indent=2)
+    
+    def evaluate_classification(self, csv_path: str, threshold: float = 0.3) -> pd.DataFrame:
+        """
+        Оцінка класифікації текстів з CSV файлу
+        
+        Args:
+            csv_path: шлях до CSV файлу з колонками Category та Question
+            threshold: поріг впевненості для класифікації
+            
+        Returns:
+            pd.DataFrame: результати класифікації з додатковими метриками
+        """
+        if self.class_signatures is None:
+            raise ValueError("Спочатку збудуйте signatures!")
+            
+        # Завантаження даних
+        df = pd.read_csv(csv_path)
+        if not {'Category', 'Question'}.issubset(df.columns):
+            raise ValueError("CSV повинен містити колонки 'Category' та 'Question'")
+        
+        # Підготовка результатів
+        results = []
+        
+        for idx, row in df.iterrows():
+            # Отримуємо ембедінг для питання
+            emb = np.array(self.get_embedding(row['Question']))
+            
+            # Нормалізуємо якщо потрібно
+            if self.embeddings_mean is not None and self.embeddings_std is not None and not self.using_local:
+                emb = (emb - self.embeddings_mean) / self.embeddings_std
+                
+            # Отримуємо всі передбачення
+            predictions = self.predict_classes(emb, threshold)
+            
+            # Формуємо список класів за рівнем впевненості
+            sorted_classes = list(predictions.keys())
+            
+            # Знаходимо позицію очікуваного класу
+            expected_class = row['Category']
+            expected_position = sorted_classes.index(expected_class) + 1 if expected_class in sorted_classes else -1
+            
+            # Отримуємо рівень впевненості для очікуваного класу
+            expected_confidence = predictions.get(expected_class, 0.0)
+            
+            # Додаємо результат
+            results.append({
+                'Category': row['Category'],
+                'Question': row['Question'],
+                'ExpectedClassPosition': expected_position,
+                'ExpectedClassConfidence': expected_confidence,
+                'ClassificationResults': json.dumps(predictions)
+            })
+        
+        return pd.DataFrame(results)
+
+    def save_evaluation_results(self, df: pd.DataFrame, output_path: str = "evaluation_results.csv") -> str:
+        """
+        Зберігає результати оцінки класифікації
+        
+        Args:
+            df: DataFrame з результатами
+            output_path: шлях для збереження файлу
+            
+        Returns:
+            str: повідомлення про результат
+        """
+        try:
+            df.to_csv(output_path, index=False)
+            return f"Результати збережено у файл {output_path}"
+        except Exception as e:
+            return f"Помилка при збереженні результатів: {str(e)}"
+
+    def get_evaluation_statistics(self, df: pd.DataFrame) -> dict:
+        """
+        Розраховує статистику по результатам класифікації
+        
+        Args:
+            df: DataFrame з результатами класифікації
             
+        Returns:
+            dict: статистика класифікації
+        """
+        total = len(df)
+        found_mask = df['ExpectedClassPosition'] != -1
+        correct_first = (df['ExpectedClassPosition'] == 1).sum()
+        in_top3 = (df['ExpectedClassPosition'].between(1, 3)).sum()
+        not_found = (~found_mask).sum()
+        
+        # Середня впевненість для коректних класифікацій
+        mean_confidence = df[df['ExpectedClassPosition'] == 1]['ExpectedClassConfidence'].mean()
+        
+        # Підрахунок по діапазонах впевненості
+        confidence_ranges = {
+            "90-100%": ((df['ExpectedClassConfidence'] >= 0.9) & found_mask).sum(),
+            "70-90%": ((df['ExpectedClassConfidence'].between(0.7, 0.9)) & found_mask).sum(),
+            "50-70%": ((df['ExpectedClassConfidence'].between(0.5, 0.7)) & found_mask).sum(),
+            "<50%": ((df['ExpectedClassConfidence'] < 0.5) & found_mask).sum()
+        }
+        
+        return {
+            "total_samples": total,
+            "correct_first_place": {
+                "count": int(correct_first),
+                "percentage": round(correct_first/total * 100, 1)
+            },
+            "in_top3": {
+                "count": int(in_top3),
+                "percentage": round(in_top3/total * 100, 1)
+            },
+            "not_found": {
+                "count": int(not_found),
+                "percentage": round(not_found/total * 100, 1)
+            },
+            "mean_confidence_correct": round(mean_confidence * 100, 1) if not np.isnan(mean_confidence) else 0,
+            "confidence_distribution": {
+                k: {
+                    "count": int(v),
+                    "percentage": round(v/total * 100, 1)
+                }
+                for k, v in confidence_ranges.items()
+            }
+        }
+
+    def evaluate_classification(self, csv_path: str, threshold: float = 0.3) -> tuple[pd.DataFrame, dict]:
+        """
+        Оцінка класифікації текстів з CSV файлу
+        
+        Args:
+            csv_path: шлях до CSV файлу з колонками Category та Question
+            threshold: поріг впевненості для класифікації
+            
+        Returns:
+            tuple[pd.DataFrame, dict]: результати класифікації та статистика
+        """
+        if self.class_signatures is None:
+            raise ValueError("Спочатку збудуйте signatures!")
+            
+        # Завантаження даних
+        df = pd.read_csv(csv_path)
+        if not {'Category', 'Question'}.issubset(df.columns):
+            raise ValueError("CSV повинен містити колонки 'Category' та 'Question'")
+        
+        # Підготовка результатів
+        results = []
+        
+        for idx, row in df.iterrows():
+            # Отримуємо ембедінг для питання
+            emb = np.array(self.get_embedding(row['Question']))
+            
+            # Нормалізуємо якщо потрібно
+            if self.embeddings_mean is not None and self.embeddings_std is not None and not self.using_local:
+                emb = (emb - self.embeddings_mean) / self.embeddings_std
+                
+            # Отримуємо всі передбачення
+            predictions = self.predict_classes(emb, threshold)
+            
+            # Формуємо список класів за рівнем впевненості
+            sorted_classes = list(predictions.keys())
+            
+            # Знаходимо позицію очікуваного класу
+            expected_class = row['Category']
+            expected_position = sorted_classes.index(expected_class) + 1 if expected_class in sorted_classes else -1
+            
+            # Отримуємо рівень впевненості для очікуваного класу
+            expected_confidence = predictions.get(expected_class, 0.0)
+            
+            # Додаємо результат
+            results.append({
+                'Category': row['Category'],
+                'Question': row['Question'],
+                'ExpectedClassPosition': expected_position,
+                'ExpectedClassConfidence': expected_confidence,
+                'ClassificationResults': json.dumps(predictions)
+            })
+        
+        results_df = pd.DataFrame(results)
+        statistics = self.get_evaluation_statistics(results_df)
+    
+        return results_df, statistics
+    
     @staticmethod
     def load_model_info(path: str) -> dict:
         """