статистика по сигнатурам (не до кінця робочий)

app.py

@@ -14,27 +14,56 @@ def initialize_environment():
     DEFAULT_SIGNATURES_FILE = "signatures.npz"
     CACHE_FILE = "embeddings_cache.db"
     
+    initial_info = {
+        "status": "initializing",
+        "model_info": {},
+        "classes_info": {},
+        "errors": []
+    }
+    
     # Перевіряємо наявність необхідних файлів
     if not os.path.exists(DEFAULT_CLASSES_FILE):
-        print(f"ПОМИЛКА: Файл {DEFAULT_CLASSES_FILE} не знайдено!")
-        return False
+        initial_info["errors"].append(f"ПОМИЛКА: Файл {DEFAULT_CLASSES_FILE} не знайдено!")
+        initial_info["status"] = "error"
+        return initial_info
+        
+    # Створюємо класифікатор та завантажуємо класи
+    try:
+        classifier = SDCClassifier()
+        classes = classifier.load_classes(DEFAULT_CLASSES_FILE)
+        
+        # Збираємо інформацію про класи
+        initial_info["classes_info"] = {
+            "total_classes": len(classes),
+            "classes_list": list(classes.keys()),
+            "hints_per_class": {cls: len(hints) for cls, hints in classes.items()}
+        }
         
-    if not os.path.exists(DEFAULT_SIGNATURES_FILE):
-        print("Signatures не знайдено. Створюємо нові...")
-        try:
-            classifier = SDCClassifier()
-            classifier.load_classes(DEFAULT_CLASSES_FILE)
+        # Якщо signatures не існують, створюємо нові
+        if not os.path.exists(DEFAULT_SIGNATURES_FILE):
+            initial_info["status"] = "creating_signatures"
             result = classifier.initialize_signatures(
                 force_rebuild=True,
                 signatures_file=DEFAULT_SIGNATURES_FILE
             )
-            print(f"Результат ініціалізації: {result}")
-            return True
-        except Exception as e:
-            print(f"ПОМИЛКА при ініціалізації: {str(e)}")
-            return False
             
-    return True
+            if isinstance(result, str) and "error" in result.lower():
+                initial_info["errors"].append(result)
+                initial_info["status"] = "error"
+                return initial_info
+        
+        # Завантажуємо інформацію про модель
+        classifier.save_model_info("model_info.json")
+        with open("model_info.json", "r") as f:
+            initial_info["model_info"] = json.load(f)
+            
+        initial_info["status"] = "success"
+        return initial_info, classifier
+        
+    except Exception as e:
+        initial_info["errors"].append(f"ПОМИЛКА при ініціалізації: {str(e)}")
+        initial_info["status"] = "error"
+        return initial_info, None
 
 def create_classifier(model_type, openai_model=None, local_model=None, device=None):
     """
@@ -61,40 +90,37 @@ def main():
     CACHE_FILE = "embeddings_cache.db"
     
     # Перевіряємо та ініціалізуємо середовище
-    if not initialize_environment():
+    init_result = initialize_environment()
+    if isinstance(init_result, tuple):
+        initial_info, classifier = init_result
+    else:
+        initial_info = init_result
         print("Не вдалося ініціалізувати середовище")
         return
-    
-    # Ініціалізуємо класифікатор
-    classifier = SDCClassifier()
-    
-    print("Завантаження початкових класів...")
-    # Перевірка наявності кешу
-    if not os.path.exists(CACHE_FILE):
-        print("Кеш ембедінгів не знайдено. Створюємо новий...")
-        
-        # Завантажуємо класи і створюємо нові signatures
-        try:
-            classifier.load_initial_state(DEFAULT_CLASSES_FILE, DEFAULT_SIGNATURES_FILE)
-            result = classifier.initialize_signatures(
-                force_rebuild=True,
-                signatures_file=DEFAULT_SIGNATURES_FILE
-            )
-            print(f"Результат ініціалізації: {result}")
-        except Exception as e:
-            print(f"ПОМИЛКА при ініціалізації: {str(e)}")
-            return
-    else:
-        # Якщо кеш існує, просто завантажуємо початковий стан
-        try:
-            classifier.load_initial_state(DEFAULT_CLASSES_FILE, DEFAULT_SIGNATURES_FILE)
-        except Exception as e:
-            print(f"ПОМИЛКА при завантаженні початкового стану: {str(e)}")
-            return
 
     with gr.Blocks() as demo:
         gr.Markdown("# SDC Classifier")
         
+        # Додаємо інформаційний блок про модель та класи
+        with gr.Accordion("Інформація про систему", open=True):
+            system_info = gr.JSON(
+                value=initial_info,
+                label="Статус системи"
+            )
+            
+            if initial_info["status"] == "success":
+                gr.Markdown(f"""
+                ### Поточна конфігурація:
+                - Модель: {initial_info['model_info'].get('using_local', 'OpenAI')}
+                - Кількість класів: {initial_info['classes_info']['total_classes']}
+                - Класи: {', '.join(initial_info['classes_info']['classes_list'])}
+                """)
+            else:
+                gr.Markdown(f"""
+                ### Помилки ініціалізації:
+                {chr(10).join('- ' + err for err in initial_info['errors'])}
+                """)
+        
         with gr.Tabs():
             # Вкладка 1: Single Text Testing
             with gr.TabItem("Тестування одного тексту"):
@@ -244,6 +270,23 @@ def main():
                     signatures_file=DEFAULT_SIGNATURES_FILE if not force_rebuild else None
                 )
                 
+                # Оновлюємо інформацію про систему
+                classifier.save_model_info("model_info.json")
+                with open("model_info.json", "r") as f:
+                    model_info = json.load(f)
+                
+                system_info.update(value={
+                    "status": "success",
+                    "model_info": model_info,
+                    "classes_info": {
+                        "total_classes": len(classifier.classes_json),
+                        "classes_list": list(classifier.classes_json.keys()),
+                        "hints_per_class": {cls: len(hints) 
+                                          for cls, hints in classifier.classes_json.items()}
+                    },
+                    "errors": []
+                })
+                
                 return result, classifier.get_cache_stats()
             except Exception as e:
                 return f"Помилка: {str(e)}", classifier.get_cache_stats()

model_info.json

@@ -0,0 +1,19 @@
+{
+  "using_local": true,
+  "classes_count": 15,
+  "signatures_count": 15,
+  "cache_stats": {
+    "total_entries": 3647,
+    "cache_size_mb": 31.64,
+    "hits": 545,
+    "misses": 0,
+    "hit_rate_percent": 100.0
+  },
+  "local_model": {
+    "model_name": "cambridgeltl/SapBERT-from-PubMedBERT-fulltext",
+    "device": "cuda",
+    "embedding_size": 768,
+    "max_length": 512,
+    "batch_size": 32
+  }
+}

sdc_classifier.py

@@ -202,9 +202,9 @@ class SDCClassifier:
         return np.array(emb_list, dtype=np.float32)
 
     def initialize_signatures(self, 
-                            model_name: str = None,
-                            signatures_file: str = "signatures.npz",
-                            force_rebuild: bool = False) -> str:
+                                model_name: str = None,
+                                signatures_file: str = "signatures.npz",
+                                force_rebuild: bool = False) -> str:
         """
         Ініціалізує signatures: завантажує існуючі або створює нові
         
@@ -212,9 +212,6 @@ class SDCClassifier:
             model_name: назва моделі для ембедінгів
             signatures_file: шлях до файлу для збереження (None - не зберігати)
             force_rebuild: примусово перебудувати signatures
-            
-        Returns:
-            str: повідомлення про результат
         """
         if not self.classes_json:
             return "Помилка: Не знайдено жодного класу в classes.json"
@@ -244,8 +241,16 @@ class SDCClassifier:
                     
                 print(f"Обробка класу {cls_name} ({idx}/{total_classes})...")
                 try:
+                    # Отримуємо ембедінги для всіх хінтів класу
                     arr = self.embed_hints(hints, model_name=model_name)
-                    self.class_signatures[cls_name] = arr.mean(axis=0)
+                    
+                    # Нормалізуємо кожен ембедінг
+                    norms = np.linalg.norm(arr, axis=1, keepdims=True)
+                    arr = arr / norms
+                    
+                    # Обчислюємо середній нормалізований ембедінг
+                    self.class_signatures[cls_name] = np.mean(arr, axis=0)
+                    
                     print(f"Успішно створено signature для {cls_name}")
                 except Exception as e:
                     print(f"Помилка при створенні signature для {cls_name}: {str(e)}")
@@ -265,7 +270,7 @@ class SDCClassifier:
             return f"Створено нові signatures для {len(self.class_signatures)} класів"
         except Exception as e:
             return f"Помилка при створенні signatures: {str(e)}"
-    
+
     def load_data(self, csv_path: str = "messages.csv", emb_path: str = "embeddings.npy") -> str:
         """
         Завантаження даних з CSV та NPY файлів
@@ -322,25 +327,31 @@ class SDCClassifier:
         if self.class_signatures is None:
             return {"error": "Спочатку збудуйте signatures!"}
             
-        emb = self.get_embedding(text)
+        # Отримуємо ембедінг
+        emb = np.array(self.get_embedding(text))
         
-        if self.embeddings_mean is not None and self.embeddings_std is not None:
+        # Нормалізуємо відносно даних навчання, якщо вони доступні
+        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)
         
         if not predictions:
             return {"message": text, "result": "Жодного класу не знайдено"}
         
+        # Форматуємо результати
         formatted_results = []
         for cls, score in predictions.items():
-            formatted_results.append(f"{cls}: {score:.2%}")
+            # Конвертуємо score в відсотки, обмежуємо до 100%
+            score_percent = min(abs(float(score)) * 100, 100)
+            formatted_results.append(f"{cls}: {score_percent:.2f}%")
         
         return {
             "message": text,
-            "result": "\n".join(formatted_results)
+            "result": " ".join(formatted_results)
         }
-
+    
     def classify_rows(self, filter_substring: str = "", threshold: float = 0.3) -> pd.DataFrame:
         """
         Класифікація всіх або відфільтрованих рядків