Для деплоя на HF

.~lock.kw_questions_tested.csv#

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

classifier_app.py

@@ -19,7 +19,7 @@ class Config:
     DEFAULT_SIGNATURES_FILE: str = "signatures.npz"
     CACHE_FILE: str = "embeddings_cache.db"
     MODEL_INFO_FILE: str = "model_info.json"
-    DEFAULT_OPENAI_MODELS: List[str] = field(default_factory=lambda: ["text-embedding-3-large", "text-embedding-3-small"])
+    DEFAULT_OPENAI_MODELS: List[str] = field(default_factory=lambda: ["text-embedding-3-large"])
     DEFAULT_LOCAL_MODEL: str = "cambridgeltl/SapBERT-from-PubMedBERT-fulltext"
 
 config = Config()
@@ -33,8 +33,8 @@ class ClassifierApp:
             "classes_info": {},
             "errors": []
         }
-        self.model_type = "Local"  # Додати цей рядок
-        # self.model_type = "OpenAI"  # Нова версія
+        # self.model_type = "Local"  # Додати цей рядок
+        self.model_type = "OpenAI"  # Нова версія
 
     def initialize_environment(self) -> Tuple[Dict, Optional[SDCClassifier]]:
         """Ініціалізація середовища при першому запуску"""
@@ -56,7 +56,7 @@ class ClassifierApp:
                     with open(config.MODEL_INFO_FILE, 'r') as f:
                         model_info = json.load(f)
                         if not model_info.get('using_local', True):
-                            signatures_model = "text-embedding-3-small"  # Модель, яка використовувалась
+                            signatures_model = "text-embedding-3-large"  # Модель, яка використовувалась
                 
                 # Створюємо класифікатор з тією ж моделлю
                 self.classifier = SDCClassifier(openai_api_key=os.getenv("OPENAI_API_KEY"))

model_info.json

@@ -3,15 +3,15 @@
   "classes_count": 358,
   "signatures_count": 358,
   "cache_stats": {
-    "total_entries": 14822,
-    "cache_size_mb": 58.9,
-    "hits": 1159,
-    "misses": 7066,
-    "hit_rate_percent": 14.09
+    "total_entries": 29633,
+    "cache_size_mb": 179.21,
+    "hits": 0,
+    "misses": 0,
+    "hit_rate_percent": 0
   },
   "local_model": {
     "model_name": "cambridgeltl/SapBERT-from-PubMedBERT-fulltext",
-    "device": "cuda",
+    "device": "cpu",
     "embedding_size": 768,
     "max_length": 512,
     "batch_size": 32

sdc_classifier.py

@@ -11,6 +11,7 @@ class SDCClassifier:
     def __init__(self, 
                  openai_api_key: str = None, 
                  cache_path: str = "embeddings_cache.db",
+                 openai_model = None,  # Модель OpenAI за замовчуванням
                  local_model: str = "cambridgeltl/SapBERT-from-PubMedBERT-fulltext",
                  device: str = None):
         """
@@ -134,34 +135,47 @@ class SDCClassifier:
         except (FileNotFoundError, IOError):
             return None
 
+    def set_openai_model(self, model_name: str) -> None:
+        """
+        Встановлює модель OpenAI для використання
+        
+        Args:
+            model_name: назва моделі OpenAI
+        """
+        print(f"Встановлення OpenAI моделі: {model_name}")
+        self.using_local = False
+        self.local_embedder = None  # Видаляємо локальний ембедер
+        self.openai_model = model_name  # Зберігаємо назву моделі
+        
     def get_embedding(self, text: str, model_name: str = None) -> list:
         """
         Отримання ембедінгу тексту
         
         Args:
             text: текст для ембедінгу
-            model_name: назва моделі (OpenAI) або None для локальної
+            model_name: назва моделі (OpenAI) або None для використання поточної
             
         Returns:
             list: ембедінг тексту
         """
         # Перевіряємо кеш
-        cached_embedding = self.cache.get(text, model_name or "local")
+        model_key = model_name or (self.openai_model if not self.using_local else "local")
+        cached_embedding = self.cache.get(text, model_key)
         if cached_embedding is not None:
             return cached_embedding.tolist()
         
         # Отримуємо ембедінг
-        if self.using_local and model_name is None:
+        if self.using_local:
             embedding = self.local_embedder.get_embeddings(text)[0]
         else:
             response = self.client.embeddings.create(
                 input=text,
-                model=model_name or "text-embedding-3-large"
+                model=model_name or self.openai_model or "text-embedding-3-large"
             )
             embedding = response.data[0].embedding
         
         # Зберігаємо в кеш
-        self.cache.put(text, model_name or "local", embedding)
+        self.cache.put(text, model_key, embedding)
         
         return embedding
         
@@ -430,8 +444,8 @@ 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:
+
+    def evaluate_classification(self, csv_path: str, threshold: float = 0.3) -> tuple[pd.DataFrame, dict]:
         """
         Оцінка класифікації текстів з CSV файлу
         
@@ -440,50 +454,73 @@ class SDCClassifier:
             threshold: поріг впевненості для класифікації
             
         Returns:
-            pd.DataFrame: результати класифікації з додатковими метриками
+            tuple[pd.DataFrame, dict]: результати класифікації та статистика
         """
         if self.class_signatures is None:
             raise ValueError("Спочатку збудуйте signatures!")
             
         # Завантаження даних
+        print(f"\nЗавантаження даних з {csv_path}...")
         df = pd.read_csv(csv_path)
         if not {'Category', 'Question'}.issubset(df.columns):
             raise ValueError("CSV повинен містити колонки 'Category' та 'Question'")
         
         # Підготовка результатів
         results = []
+        total = len(df)
+        print(f"Знайдено {total} рядків для класифікації")
+        print(f"Використовується {'OpenAI' if not self.using_local else 'локальна'} модель")
         
         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
+            if idx % 10 == 0:  # Логуємо прогрес кожні 10 рядків
+                print(f"Обробка рядка {idx + 1}/{total}")
                 
-            # Отримуємо всі передбачення
-            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)
-            })
+            try:
+                # Отримуємо ембедінг для питання
+                emb = np.array(self.get_embedding(row['Question']))
+                
+                # Нормалізуємо ембедінг
+                emb_norm = np.linalg.norm(emb)
+                if emb_norm > 0:
+                    emb = emb / emb_norm
+                
+                # Отримуємо всі передбачення
+                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, ensure_ascii=False)
+                })
+                
+            except Exception as e:
+                print(f"Помилка при обробці рядка {idx + 1}: {str(e)}")
+                results.append({
+                    'Category': row['Category'],
+                    'Question': row['Question'],
+                    'ExpectedClassPosition': -1,
+                    'ExpectedClassConfidence': 0.0,
+                    'ClassificationResults': json.dumps({})
+                })
+        
+        print("\nОбробка завершена")
+        results_df = pd.DataFrame(results)
+        statistics = self.get_evaluation_statistics(results_df)
         
-        return pd.DataFrame(results)
+        return results_df, statistics
 
     def save_evaluation_results(self, df: pd.DataFrame, output_path: str = "evaluation_results.csv") -> str:
         """