update

binoculars/detector.py

@@ -20,8 +20,11 @@ huggingface_config = {
 BINOCULARS_ACCURACY_THRESHOLD = 0.9015310749276843  # optimized for f1-score
 BINOCULARS_FPR_THRESHOLD = 0.8536432310785527  # optimized for low-fpr [chosen at 0.01%]
 
-DEVICE_1 = "cuda:0" if torch.cuda.is_available() else "cpu"
-DEVICE_2 = "cuda:1" if torch.cuda.device_count() > 1 else DEVICE_1
+# More efficient device handling for Spaces (likely single GPU)
+DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
+# Use same device for both models in single-GPU environment
+DEVICE_1 = DEVICE
+DEVICE_2 = DEVICE
 
 
 class Binoculars(object):
@@ -35,20 +38,36 @@ class Binoculars(object):
         assert_tokenizer_consistency(observer_name_or_path, performer_name_or_path)
 
         self.change_mode(mode)
+        
+        # Log memory usage before loading models
+        if torch.cuda.is_available():
+            print(f"Before loading observer model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+            
+        # Load first model
         self.observer_model = AutoModelForCausalLM.from_pretrained(observer_name_or_path,
-                                                                   device_map={"": DEVICE_1},
+                                                                  device_map={"": DEVICE_1},
+                                                                  trust_remote_code=True,
+                                                                  torch_dtype=torch.bfloat16 if use_bfloat16
+                                                                  else torch.float32,
+                                                                  token=huggingface_config["TOKEN"]
+                                                                  )
+        # Clear cache between model loads
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            print(f"After loading observer model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+            
+        # Load second model
+        self.performer_model = AutoModelForCausalLM.from_pretrained(performer_name_or_path,
+                                                                   device_map={"": DEVICE_2},
                                                                    trust_remote_code=True,
                                                                    torch_dtype=torch.bfloat16 if use_bfloat16
                                                                    else torch.float32,
                                                                    token=huggingface_config["TOKEN"]
                                                                    )
-        self.performer_model = AutoModelForCausalLM.from_pretrained(performer_name_or_path,
-                                                                    device_map={"": DEVICE_2},
-                                                                    trust_remote_code=True,
-                                                                    torch_dtype=torch.bfloat16 if use_bfloat16
-                                                                    else torch.float32,
-                                                                    token=huggingface_config["TOKEN"]
-                                                                    )
+        
+        if torch.cuda.is_available():
+            print(f"After loading performer model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+            
         self.observer_model.eval()
         self.performer_model.eval()
 
@@ -66,8 +85,13 @@ class Binoculars(object):
             raise ValueError(f"Invalid mode: {mode}")
         
     def free_memory(self) -> None:
-        self.observer_model = self.observer_model.to('cpu')
-        self.performer_model = self.performer_model.to('cpu')
+        """Explicitly free GPU memory by moving models to CPU and deleting them"""
+        print("Freeing model memory...")
+        if hasattr(self, 'observer_model') and self.observer_model is not None:
+            self.observer_model = self.observer_model.to('cpu')
+            
+        if hasattr(self, 'performer_model') and self.performer_model is not None:
+            self.performer_model = self.performer_model.to('cpu')
         
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
@@ -91,6 +115,7 @@ class Binoculars(object):
 
     @torch.inference_mode()
     def _get_logits(self, encodings: transformers.BatchEncoding) -> torch.Tensor:
+        # Ensure we're using the same device for both models
         observer_logits = self.observer_model(**encodings.to(DEVICE_1)).logits
         performer_logits = self.performer_model(**encodings.to(DEVICE_2)).logits
         if DEVICE_1 != "cpu":
@@ -102,8 +127,9 @@ class Binoculars(object):
         encodings = self._tokenize(batch)
         observer_logits, performer_logits = self._get_logits(encodings)
         ppl = perplexity(encodings, performer_logits)
-        x_ppl = entropy(observer_logits.to(DEVICE_1), performer_logits.to(DEVICE_1),
-                        encodings.to(DEVICE_1), self.tokenizer.pad_token_id)
+        # No need to move tensors again if they're already on the same device
+        x_ppl = entropy(observer_logits, performer_logits,
+                        encodings, self.tokenizer.pad_token_id)
         binoculars_scores = ppl / x_ppl
         binoculars_scores = binoculars_scores.tolist()
         return binoculars_scores[0] if isinstance(input_text, str) else binoculars_scores

binoculars_utils.py

@@ -1,43 +1,105 @@
 from binoculars import Binoculars
+import torch
+import gc
 
-def initialize_binoculars():
-    chat_model_pair = {
-        "observer": "deepseek-ai/deepseek-llm-7b-base",
-        "performer": "deepseek-ai/deepseek-llm-7b-chat"
-    }
+CHAT_MODEL_PAIR = {
+    "observer": "deepseek-ai/deepseek-llm-7b-base",
+    "performer": "deepseek-ai/deepseek-llm-7b-chat"
+}
 
-    coder_model_pair = {
-        "observer": "deepseek-ai/deepseek-llm-7b-base",
-        "performer": "deepseek-ai/deepseek-coder-7b-instruct-v1.5"
-    }
+CODER_MODEL_PAIR = {
+    "observer": "deepseek-ai/deepseek-llm-7b-base",
+    "performer": "deepseek-ai/deepseek-coder-7b-instruct-v1.5"
+}
+
+def initialize_chat_model():
+    print("Initializing chat Binoculars model...")
     
-    print("Initializing Binoculars models...")
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        print(f"GPU Memory before chat model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
     
     bino_chat = Binoculars(
         mode="accuracy", 
-        observer_name_or_path=chat_model_pair["observer"],
-        performer_name_or_path=chat_model_pair["performer"],
+        observer_name_or_path=CHAT_MODEL_PAIR["observer"],
+        performer_name_or_path=CHAT_MODEL_PAIR["performer"],
         max_token_observed=2048
     )
+    
+    if torch.cuda.is_available():
+        print(f"GPU Memory after chat model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+    
+    return bino_chat
 
+def initialize_coder_model():
+    print("Initializing coder Binoculars model...")
+    
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        print(f"GPU Memory before coder model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+    
     bino_coder = Binoculars(
         mode="accuracy", 
-        observer_name_or_path=coder_model_pair["observer"],
-        performer_name_or_path=coder_model_pair["performer"],
+        observer_name_or_path=CODER_MODEL_PAIR["observer"],
+        performer_name_or_path=CODER_MODEL_PAIR["performer"],
         max_token_observed=2048
     )
     
-    return bino_chat, bino_coder
+    if torch.cuda.is_available():
+        print(f"GPU Memory after coder model: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+    
+    return bino_coder
+
+def compute_chat_score(text):
+    print("Computing chat score...")
+    bino_chat = initialize_chat_model()
+    
+    try:
+        score_chat = bino_chat.compute_score(text)
+        return {"score_chat": score_chat}
+    finally:
+        cleanup_model(bino_chat)
 
-def compute_scores(text, bino_chat=None, bino_coder=None):
+def compute_coder_score(text):
+    print("Computing coder score...")
+    bino_coder = initialize_coder_model()
+    
+    try:
+        score_coder = bino_coder.compute_score(text)
+        return {"score_coder": score_coder}
+    finally:
+        cleanup_model(bino_coder)
+
+def compute_scores(text, use_chat=True, use_coder=True):
     scores = {}
     
+    if use_chat:
+        chat_scores = compute_chat_score(text)
+        scores.update(chat_scores)
+    
+    if use_coder:
+        coder_scores = compute_coder_score(text)
+        scores.update(coder_scores)
+    
+    return scores
+
+def cleanup_model(model):
+    if model:
+        try:
+            print(f"Cleaning up model resources...")
+            model.free_memory()
+            
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                torch.cuda.synchronize()
+                print(f"After cleanup: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+        except Exception as e:
+            print(f"Error during model cleanup: {str(e)}")
+    
+def cleanup_models(bino_chat, bino_coder):
     if bino_chat:
-        #print("Computing score_chat...")
-        scores['score_chat'] = bino_chat.compute_score(text)
+        cleanup_model(bino_chat)
     
     if bino_coder:
-        #print("Computing score_coder...")
-        scores['score_coder'] = bino_coder.compute_score(text)
-    
-    return scores 
+        cleanup_model(bino_coder) 

demo/binary_classifier_demo.py

@@ -4,9 +4,10 @@ import gradio as gr
 import torch
 import os
 import spaces
+import gc
 
 from model_utils import load_model, classify_text
-from binoculars_utils import initialize_binoculars, compute_scores
+from binoculars_utils import compute_scores, cleanup_model, cleanup_models
 
 MINIMUM_TOKENS = 200
 
@@ -46,42 +47,48 @@ css = """
 
 @spaces.GPU
 def run_binary_classifier(text, show_analysis=False):
+    # Check GPU status at the beginning
+    if torch.cuda.is_available():
+        print(f"Starting classification with GPU: {torch.cuda.get_device_name(0)}")
+        print(f"Initial GPU memory: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+        torch.cuda.empty_cache()
+    else:
+        print("No GPU available, running on CPU")
+    
     if len(text.strip()) < MINIMUM_TOKENS:
         return gr.Markdown(f"Текст слишком короткий. Требуется минимум {MINIMUM_TOKENS} символов."), None, None
     
-    # Initialize Binoculars models
-    bino_chat, bino_coder = initialize_binoculars()
-
-    # Load binary classifier model
-    model, scaler, label_encoder, imputer = load_model()
+    try:
+        # Load binary classifier model
+        model, scaler, label_encoder, imputer = load_model()
 
-    # Compute scores using binoculars
-    scores = compute_scores(text, bino_chat, bino_coder)
-    
-    # Run classification
-    result = classify_text(text, model, scaler, label_encoder, imputer=imputer, scores=scores)
-    
-    # Format results
-    predicted_class = result['predicted_class']
-    probabilities = result['probabilities']
-    
-    # Format probabilities
-    prob_str = ""
-    for cls, prob in probabilities.items():
-        prob_str += f"- {cls}: {prob:.4f}\n"
-    
-    # Format scores
-    scores_str = ""
-    if scores:
-        scores_str = "### Binoculars Scores\n"
-        if 'score_chat' in scores:
-            scores_str += f"- Score Chat: {scores['score_chat']:.4f}\n"
-        if 'score_coder' in scores:
-            scores_str += f"- Score Coder: {scores['score_coder']:.4f}\n"
-    
-    # Result markdown
-    class_style = "human-text" if predicted_class == "Human" else "ai-text"
-    result_md = f"""
+        # Compute scores последовательно
+        scores = compute_scores(text, use_chat=True, use_coder=True)
+        
+        # Run classification
+        result = classify_text(text, model, scaler, label_encoder, imputer=imputer, scores=scores)
+        
+        # Format results
+        predicted_class = result['predicted_class']
+        probabilities = result['probabilities']
+        
+        # Format probabilities
+        prob_str = ""
+        for cls, prob in probabilities.items():
+            prob_str += f"- {cls}: {prob:.4f}\n"
+        
+        # Format scores
+        scores_str = ""
+        if scores:
+            scores_str = "### Binoculars Scores\n"
+            if 'score_chat' in scores:
+                scores_str += f"- Score Chat: {scores['score_chat']:.4f}\n"
+            if 'score_coder' in scores:
+                scores_str += f"- Score Coder: {scores['score_coder']:.4f}\n"
+        
+        # Result markdown
+        class_style = "human-text" if predicted_class == "Human" else "ai-text"
+        result_md = f"""
 ## Результат классификации
 
 Предсказанный класс: <span class="{class_style}">{predicted_class}</span>
@@ -91,199 +98,217 @@ def run_binary_classifier(text, show_analysis=False):
 
 {scores_str}
 """
-    
-    # Analysis markdown
-    analysis_md = None
-    if show_analysis:
-        features = result['features']
-        text_analysis = result['text_analysis']
-        
-        basic_stats_dict = {
-            'total_tokens': 'Количество токенов',
-            'total_words': 'Количество слов',
-            'unique_words': 'Количество уникальных слов',
-            'stop_words': 'Количество стоп-слов',
-            'avg_word_length': 'Средняя длина слова (символов)'
-        }
-        
-        morph_dict = {
-            'pos_distribution': 'Распределение частей речи',
-            'unique_lemmas': 'Количество уникальных лемм',
-            'lemma_word_ratio': 'Отношение лемм к словам'
-        }
-        
-        synt_dict = {
-            'dependencies': 'Зависимости между словами',
-            'noun_chunks': 'Количество именных групп'
-        }
         
-        entities_dict = {
-            'total_entities': 'Общее количество именованных сущностей',
-            'entity_types': 'Типы именованных сущностей'
-        }
-        
-        diversity_dict = {
-            'ttr': 'TTR (отношение типов к токенам)',
-            'mtld': 'MTLD (мера лексического разнообразия)'
-        }
-        
-        structure_dict = {
-            'sentence_count': 'Количество предложений',
-            'avg_sentence_length': 'Средняя длина предложения (токенов)',
-            'question_sentences': 'Количество вопросительных предложений',
-            'exclamation_sentences': 'Количество восклицательных предложений'
-        }
-        
-        readability_dict = {
-            'words_per_sentence': 'Слов на предложение',
-            'syllables_per_word': 'Слогов на слово',
-            'flesh_kincaid_score': 'Индекс читабельности Флеша-Кинкейда',
-            'long_words_percent': 'Процент длинных слов'
-        }
-        
-        semantic_dict = {
-            'avg_coherence_score': 'Средняя связность между предложениями'
-        }
-        
-        analysis_md = "## Анализ текста\n\n"
-        
-        # Basic statistics
-        analysis_md += "### Основная статистика\n"
-        for key, value in text_analysis.get('basic_stats', {}).items():
-            label = basic_stats_dict.get(key, key)
-            if isinstance(value, float):
-                analysis_md += f"- {label}: {value:.2f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
-        
-        # Morphological analysis
-        analysis_md += "### Морфологический анализ\n"
-        morph_analysis = text_analysis.get('morphological_analysis', {})
-        for key, value in morph_analysis.items():
-            label = morph_dict.get(key, key)
-            if key == 'pos_distribution':
-                analysis_md += f"- {label}:\n"
-                for pos, count in value.items():
-                    pos_name = pos
-                    if pos == 'NOUN': pos_name = 'Существительные'
-                    elif pos == 'VERB': pos_name = 'Глаголы'
-                    elif pos == 'ADJ': pos_name = 'Прилагательные'
-                    elif pos == 'ADV': pos_name = 'Наречия'
-                    elif pos == 'PROPN': pos_name = 'Имена собственные'
-                    elif pos == 'DET': pos_name = 'Определители'
-                    elif pos == 'ADP': pos_name = 'Предлоги'
-                    elif pos == 'PRON': pos_name = 'Местоимения'
-                    elif pos == 'CCONJ': pos_name = 'Сочинительные союзы'
-                    elif pos == 'SCONJ': pos_name = 'Подчинительные союзы'
-                    elif pos == 'NUM': pos_name = 'Числительные'
-                    elif pos == 'PART': pos_name = 'Частицы'
-                    elif pos == 'PUNCT': pos_name = 'Знаки препинания'
-                    elif pos == 'AUX': pos_name = 'Вспомогательные глаголы'
-                    elif pos == 'SYM': pos_name = 'Символы'
-                    elif pos == 'INTJ': pos_name = 'Междометия'
-                    elif pos == 'X': pos_name = 'Другое (X)'
-                    analysis_md += f"  - {pos_name}: {count}\n"
-            elif isinstance(value, float):
-                analysis_md += f"- {label}: {value:.3f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
-        
-        # Syntactic analysis
-        analysis_md += "### Синтаксический анализ\n"
-        synt_analysis = text_analysis.get('syntactic_analysis', {})
-        for key, value in synt_analysis.items():
-            label = synt_dict.get(key, key)
-            if key == 'dependencies':
-                analysis_md += f"- {label}:\n"
-                for dep, count in value.items():
-                    dep_name = dep
-                    if dep == 'nsubj': dep_name = 'Подлежащие'
-                    elif dep == 'obj': dep_name = 'Дополнения'
-                    elif dep == 'amod': dep_name = 'Определения'
-                    elif dep == 'nmod': dep_name = 'Именные модификаторы'
-                    elif dep == 'ROOT': dep_name = 'Корневые узлы'
-                    elif dep == 'punct': dep_name = 'Пунктуация'
-                    elif dep == 'case': dep_name = 'Падежные маркеры'
-                    elif dep == 'dep': dep_name = 'Общие зависимости'
-                    elif dep == 'appos': dep_name = 'Приложения'
-                    elif dep == 'flat:foreign': dep_name = 'Иностранные выражения'
-                    elif dep == 'conj': dep_name = 'Сочинитель��ые конструкции'
-                    elif dep == 'obl': dep_name = 'Косвенные дополнения'
-                    analysis_md += f"  - {dep_name}: {count}\n"
-            elif key == 'noun_chunks':
-                if isinstance(value, bool):
-                    analysis_md += f"- {label}: {0 if value is False else value}\n"
+        # Analysis markdown
+        analysis_md = None
+        if show_analysis:
+            features = result['features']
+            text_analysis = result['text_analysis']
+            
+            basic_stats_dict = {
+                'total_tokens': 'Количество токенов',
+                'total_words': 'Количество слов',
+                'unique_words': 'Количество уникальных слов',
+                'stop_words': 'Количество стоп-слов',
+                'avg_word_length': 'Средняя длина слова (символов)'
+            }
+            
+            morph_dict = {
+                'pos_distribution': 'Распределение частей речи',
+                'unique_lemmas': 'Количество уникальных лемм',
+                'lemma_word_ratio': 'Отношение лемм к словам'
+            }
+            
+            synt_dict = {
+                'dependencies': 'Зависимости между словами',
+                'noun_chunks': 'Количество именных групп'
+            }
+            
+            entities_dict = {
+                'total_entities': 'Общее количество именованных сущностей',
+                'entity_types': 'Типы именованных сущностей'
+            }
+            
+            diversity_dict = {
+                'ttr': 'TTR (отношение типов к токенам)',
+                'mtld': 'MTLD (мера лексического разнообразия)'
+            }
+            
+            structure_dict = {
+                'sentence_count': 'Количество предложений',
+                'avg_sentence_length': 'Средняя длина предложения (токенов)',
+                'question_sentences': 'Количество вопросительных предложений',
+                'exclamation_sentences': 'Количество восклицательных предложений'
+            }
+            
+            readability_dict = {
+                'words_per_sentence': 'Слов на предложение',
+                'syllables_per_word': 'Слогов на слово',
+                'flesh_kincaid_score': 'Индекс читабельности Флеша-Кинкейда',
+                'long_words_percent': 'Процент длинных слов'
+            }
+            
+            semantic_dict = {
+                'avg_coherence_score': 'Средняя связность между предложениями'
+            }
+            
+            analysis_md = "## Анализ текста\n\n"
+            
+            # Basic statistics
+            analysis_md += "### Основная статистика\n"
+            for key, value in text_analysis.get('basic_stats', {}).items():
+                label = basic_stats_dict.get(key, key)
+                if isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.2f}\n"
                 else:
                     analysis_md += f"- {label}: {value}\n"
-            elif isinstance(value, float):
-                analysis_md += f"- {label}: {value:.3f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
-        
-        # Named entities
-        analysis_md += "### Именованные сущности\n"
-        entities = text_analysis.get('named_entities', {})
-        for key, value in entities.items():
-            label = entities_dict.get(key, key)
-            if key == 'entity_types':
-                analysis_md += f"- {label}:\n"
-                for ent, count in value.items():
-                    ent_name = ent
-                    if ent == 'PER': ent_name = 'Люди'
-                    elif ent == 'LOC': ent_name = 'Локации'
-                    elif ent == 'ORG': ent_name = 'Организации'
-                    analysis_md += f"  - {ent_name}: {count}\n"
-            elif isinstance(value, float):
-                analysis_md += f"- {label}: {value:.3f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
-        
-        # Lexical diversity
-        analysis_md += "### Лексическое разнообразие\n"
-        for key, value in text_analysis.get('lexical_diversity', {}).items():
-            label = diversity_dict.get(key, key)
-            if isinstance(value, float):
-                analysis_md += f"- {label}: {value:.3f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
-        
-        # Text structure
-        analysis_md += "### Структура текста\n"
-        for key, value in text_analysis.get('text_structure', {}).items():
-            label = structure_dict.get(key, key)
-            if isinstance(value, float):
-                analysis_md += f"- {label}: {value:.2f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
+            analysis_md += "\n"
+            
+            # Morphological analysis
+            analysis_md += "### Морфологический анализ\n"
+            morph_analysis = text_analysis.get('morphological_analysis', {})
+            for key, value in morph_analysis.items():
+                label = morph_dict.get(key, key)
+                if key == 'pos_distribution':
+                    analysis_md += f"- {label}:\n"
+                    for pos, count in value.items():
+                        pos_name = pos
+                        if pos == 'NOUN': pos_name = 'Существительные'
+                        elif pos == 'VERB': pos_name = 'Глаголы'
+                        elif pos == 'ADJ': pos_name = 'Прилагательные'
+                        elif pos == 'ADV': pos_name = 'Наречия'
+                        elif pos == 'PROPN': pos_name = 'Имена собственные'
+                        elif pos == 'DET': pos_name = 'Определители'
+                        elif pos == 'ADP': pos_name = 'Предлоги'
+                        elif pos == 'PRON': pos_name = 'Местоимения'
+                        elif pos == 'CCONJ': pos_name = 'Сочинительные союзы'
+                        elif pos == 'SCONJ': pos_name = 'Подчинительные союзы'
+                        elif pos == 'NUM': pos_name = 'Числительные'
+                        elif pos == 'PART': pos_name = 'Частицы'
+                        elif pos == 'PUNCT': pos_name = 'Знаки препинания'
+                        elif pos == 'AUX': pos_name = 'Вспомогательные глаголы'
+                        elif pos == 'SYM': pos_name = 'Символы'
+                        elif pos == 'INTJ': pos_name = 'Междометия'
+                        elif pos == 'X': pos_name = 'Другое (X)'
+                        analysis_md += f"  - {pos_name}: {count}\n"
+                elif isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.3f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+            analysis_md += "\n"
+            
+            # Syntactic analysis
+            analysis_md += "### Синтаксический анализ\n"
+            synt_analysis = text_analysis.get('syntactic_analysis', {})
+            for key, value in synt_analysis.items():
+                label = synt_dict.get(key, key)
+                if key == 'dependencies':
+                    analysis_md += f"- {label}:\n"
+                    for dep, count in value.items():
+                        dep_name = dep
+                        if dep == 'nsubj': dep_name = 'Подлежащие'
+                        elif dep == 'obj': dep_name = 'Дополнения'
+                        elif dep == 'amod': dep_name = 'Определения'
+                        elif dep == 'nmod': dep_name = 'Именные модификаторы'
+                        elif dep == 'ROOT': dep_name = 'Корневые узлы'
+                        elif dep == 'punct': dep_name = 'Пунктуация'
+                        elif dep == 'case': dep_name = 'Падежные маркеры'
+                        elif dep == 'dep': dep_name = 'Общие зависимости'
+                        elif dep == 'appos': dep_name = 'Приложения'
+                        elif dep == 'flat:foreign': dep_name = 'Иностранные выражения'
+                        elif dep == 'conj': dep_name = 'Сочинительные конструкции'
+                        elif dep == 'obl': dep_name = 'Косвенные дополнения'
+                        analysis_md += f"  - {dep_name}: {count}\n"
+                elif key == 'noun_chunks':
+                    if isinstance(value, bool):
+                        analysis_md += f"- {label}: {0 if value is False else value}\n"
+                    else:
+                        analysis_md += f"- {label}: {value}\n"
+                elif isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.3f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+            analysis_md += "\n"
+            
+            # Named entities
+            analysis_md += "### Именованные сущности\n"
+            entities = text_analysis.get('named_entities', {})
+            for key, value in entities.items():
+                label = entities_dict.get(key, key)
+                if key == 'entity_types':
+                    analysis_md += f"- {label}:\n"
+                    for ent, count in value.items():
+                        ent_name = ent
+                        if ent == 'PER': ent_name = 'Люди'
+                        elif ent == 'LOC': ent_name = 'Локации'
+                        elif ent == 'ORG': ent_name = 'Организации'
+                        analysis_md += f"  - {ent_name}: {count}\n"
+                elif isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.3f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+            analysis_md += "\n"
+            
+            # Lexical diversity
+            analysis_md += "### Лексическое разнообразие\n"
+            for key, value in text_analysis.get('lexical_diversity', {}).items():
+                label = diversity_dict.get(key, key)
+                if isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.3f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+            analysis_md += "\n"
+            
+            # Text structure
+            analysis_md += "### Структура текста\n"
+            for key, value in text_analysis.get('text_structure', {}).items():
+                label = structure_dict.get(key, key)
+                if isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.2f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+            analysis_md += "\n"
+            
+            # Readability
+            analysis_md += "### Читабельность\n"
+            for key, value in text_analysis.get('readability', {}).items():
+                label = readability_dict.get(key, key)
+                if isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.2f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+            analysis_md += "\n"
+            
+            # Semantic coherence
+            analysis_md += "### Семантическая связность\n"
+            for key, value in text_analysis.get('semantic_coherence', {}).items():
+                label = semantic_dict.get(key, key)
+                if isinstance(value, float):
+                    analysis_md += f"- {label}: {value:.3f}\n"
+                else:
+                    analysis_md += f"- {label}: {value}\n"
+                    
+        # Return results
+        result_output = gr.Markdown(result_md)
+        analysis_output = gr.Markdown(analysis_md) if analysis_md else None
         
-        # Readability
-        analysis_md += "### Читабельность\n"
-        for key, value in text_analysis.get('readability', {}).items():
-            label = readability_dict.get(key, key)
-            if isinstance(value, float):
-                analysis_md += f"- {label}: {value:.2f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-        analysis_md += "\n"
+        # Report final GPU memory status
+        if torch.cuda.is_available():
+            print(f"Final GPU memory: {torch.cuda.memory_allocated(0) / 1e9:.2f} GB allocated")
+            
+        return result_output, analysis_output, text
         
-        # Semantic coherence
-        analysis_md += "### Семантическая связность\n"
-        for key, value in text_analysis.get('semantic_coherence', {}).items():
-            label = semantic_dict.get(key, key)
-            if isinstance(value, float):
-                analysis_md += f"- {label}: {value:.3f}\n"
-            else:
-                analysis_md += f"- {label}: {value}\n"
-    
-    return gr.Markdown(result_md), gr.Markdown(analysis_md) if analysis_md else None, text
+    except Exception as e:
+        # Выводим ошибку в случае проблем
+        error_msg = f"Ошибка при классификации: {str(e)}"
+        print(error_msg)
+        return gr.Markdown(error_msg), None, text
 
 def reset_outputs():
+    # Force memory cleanup when resetting
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    
     return None, None, ""
 
 with gr.Blocks(css=css, theme=gr.themes.Base()) as binary_app: