v.1.22

app.py

@@ -64,215 +64,152 @@ class ProcessControl:
 class EventDetector:
     def __init__(self):
         try:
+            # Initialize sentiment models
+            self.finbert = pipeline(
+                "sentiment-analysis",
+                model="ProsusAI/finbert",
+                truncation=True,
+                max_length=512
+            )
+            self.roberta = pipeline(
+                "sentiment-analysis",
+                model="cardiffnlp/twitter-roberta-base-sentiment",
+                truncation=True,
+                max_length=512
+            )
+            self.finbert_tone = pipeline(
+                "sentiment-analysis",
+                model="yiyanghkust/finbert-tone",
+                truncation=True,
+                max_length=512
+            )
+            
+            # Initialize MT5 model for event detection
             self.model_name = "google/mt5-small"
             self.tokenizer = AutoTokenizer.from_pretrained(
                 self.model_name,
                 legacy=True
             )
-            self.model = None
-            self.finbert = None
-            self.roberta = None
-            self.finbert_tone = None
-            self.last_gpu_use = 0
-            self.initialized = False
-            logger.info("EventDetector initialized successfully")
-        except Exception as e:
-            logger.error(f"Error in EventDetector initialization: {e}")
-            raise
-
-    def get_sentiment_label(self, result):
-        """
-        Convert model output to standardized sentiment label
-        """
-        try:
-            # Handle different model output formats
-            if isinstance(result, dict):
-                label = result.get('label', '').lower()
-            else:
-                return "Neutral"
-
-            # Map different model outputs to standard labels
-            if label in ['positive', 'pos', 'positive tone']:
-                return "Positive"
-            elif label in ['negative', 'neg', 'negative tone']:
-                return "Negative"
-            else:
-                return "Neutral"
-
-        except Exception as e:
-            logger.error(f"Error in get_sentiment_label: {e}")
-            return "Neutral"
-
-    @spaces.GPU(duration=30)
-    def initialize_models(self):
-        if self.initialized:
-            return True
-            
-        try:
-            current_time = time.time()
-            if current_time - self.last_gpu_use < 2:
-                time.sleep(2)
-            
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            logger.info(f"Initializing models on device: {device}")
-            
-            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name).to(device)
-            
-            # Initialize sentiment models with proper error handling
-            try:
-                self.finbert = pipeline(
-                    "sentiment-analysis",
-                    model="ProsusAI/finbert",
-                    device=device,
-                    truncation=True,
-                    max_length=512
-                )
-            except Exception as e:
-                logger.error(f"Error initializing finbert: {e}")
-                raise
-                
-            try:
-                self.roberta = pipeline(
-                    "sentiment-analysis",
-                    model="cardiffnlp/twitter-roberta-base-sentiment",
-                    device=device,
-                    truncation=True,
-                    max_length=512
-                )
-            except Exception as e:
-                logger.error(f"Error initializing roberta: {e}")
-                raise
-                
-            try:
-                self.finbert_tone = pipeline(
-                    "sentiment-analysis",
-                    model="yiyanghkust/finbert-tone",
-                    device=device,
-                    truncation=True,
-                    max_length=512
-                )
-            except Exception as e:
-                logger.error(f"Error initializing finbert_tone: {e}")
-                raise
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
             
-            self.last_gpu_use = time.time()
+            # Set device
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            self.model = self.model.to(self.device)
             self.initialized = True
-            logger.info("All models initialized successfully")
-            return True
+            st.success(f"Models initialized successfully on {self.device}")
             
         except Exception as e:
-            self.initialized = False
-            logger.error(f"Model initialization error: {str(e)}")
-            # Clean up any partially initialized models
-            self.cleanup()
+            st.error(f"Error in EventDetector initialization: {str(e)}")
             raise
 
-    @spaces.GPU(duration=20)
     def analyze_sentiment(self, text):
         try:
-            if not self.initialized:
-                if not self.initialize_models():
-                    return "Neutral"
-            
-            current_time = time.time()
-            if current_time - self.last_gpu_use < 2:
-                time.sleep(2)
+            if not text or not isinstance(text, str):
+                return "Neutral"
+                
+            text = text.strip()
+            if not text:
+                return "Neutral"
             
-            truncated_text = text[:500]
-            results = []
+            # Get predictions from all models
+            finbert_result = self.finbert(text)[0]
+            roberta_result = self.roberta(text)[0]
+            finbert_tone_result = self.finbert_tone(text)[0]
             
-            try:
-                inputs = [truncated_text]
-                sentiment_results = []
-                
-                # Process each model separately with delay
-                if self.finbert:
-                    finbert_result = self.finbert(inputs, truncation=True, max_length=512)[0]
-                    results.append(self.get_sentiment_label(finbert_result))
-                    time.sleep(0.5)
-                
-                if self.roberta:
-                    roberta_result = self.roberta(inputs, truncation=True, max_length=512)[0]
-                    results.append(self.get_sentiment_label(roberta_result))
-                    time.sleep(0.5)
-                
-                if self.finbert_tone:
-                    finbert_tone_result = self.finbert_tone(inputs, truncation=True, max_length=512)[0]
-                    results.append(self.get_sentiment_label(finbert_tone_result))
-                
-                # Get majority vote
-                if results:
-                    sentiment_counts = pd.Series(results).value_counts()
-                    final_sentiment = sentiment_counts.index[0] if sentiment_counts.iloc[0] >= 2 else "Neutral"
-                else:
-                    final_sentiment = "Neutral"
-                
-                self.last_gpu_use = time.time()
-                return final_sentiment
-                
-            except Exception as e:
-                logger.error(f"Model inference error: {e}")
+            # Map labels to standard format
+            def map_sentiment(result):
+                label = result['label'].lower()
+                if label in ['positive', 'pos', 'positive tone']:
+                    return "Positive"
+                elif label in ['negative', 'neg', 'negative tone']:
+                    return "Negative"
                 return "Neutral"
             
+            # Get mapped sentiments
+            sentiments = [
+                map_sentiment(finbert_result),
+                map_sentiment(roberta_result),
+                map_sentiment(finbert_tone_result)
+            ]
+            
+            # Use majority voting
+            sentiment_counts = pd.Series(sentiments).value_counts()
+            if sentiment_counts.iloc[0] >= 2:
+                return sentiment_counts.index[0]
+            
+            return "Neutral"
+            
         except Exception as e:
-            logger.error(f"Sentiment analysis error: {e}")
+            st.warning(f"Sentiment analysis error: {str(e)}")
             return "Neutral"
 
-    @spaces.GPU(duration=20)
     def detect_events(self, text, entity):
         if not text or not entity:
             return "Нет", "Invalid input"
             
         try:
-            if not self.initialized:
-                if not self.initialize_models():
-                    return "Нет", "Model initialization failed"
-            
-            current_time = time.time()
-            if current_time - self.last_gpu_use < 2:
-                time.sleep(2)
-            
-            text = text[:500]  # Truncate text
+            text = str(text).strip()
+            entity = str(entity).strip()
             
-            prompt = f"""<s>Analyze the following news about {entity}:
-            Text: {text}
-            Task: Identify the main event type and provide a brief summary.</s>"""
+            if not text or not entity:
+                return "Нет", "Empty input"
             
-            device = self.model.device
-            inputs = self.tokenizer(
-                prompt,
-                return_tensors="pt",
-                padding=True,
-                truncation=True,
-                max_length=512
-            ).to(device)
+            # First check for keyword matches
+            text_lower = text.lower()
+            keywords = {
+                'Отчетность': ['отчет', 'выручка', 'прибыль', 'ebitda', 'финансов', 'результат'],
+                'РЦБ': ['облигаци', 'купон', 'дефолт', 'реструктуризац', 'ценные бумаги'],
+                'Суд': ['суд', 'иск', 'арбитраж', 'разбирательств']
+            }
             
-            outputs = self.model.generate(
-                **inputs,
-                max_length=300,
-                num_return_sequences=1,
-                pad_token_id=self.tokenizer.pad_token_id,
-                eos_token_id=self.tokenizer.eos_token_id
-            )
-            
-            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            # Check keywords first
+            for event_type, terms in keywords.items():
+                if any(term in text_lower for term in terms):
+                    # Prepare prompt for summary
+                    prompt = f"""<s>Summarize the following news about {entity}:
+
+Text: {text}
+
+Task: Create a 2-3 sentence summary focusing on the main {event_type} event.
+
+Required format:
+Event: {event_type}
+Summary: [your summary here]</s>"""
+                    
+                    # Generate summary
+                    inputs = self.tokenizer(
+                        prompt,
+                        return_tensors="pt",
+                        padding=True,
+                        truncation=True,
+                        max_length=512
+                    ).to(self.device)
+                    
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_length=200,
+                        num_return_sequences=1,
+                        do_sample=False,
+                        pad_token_id=self.tokenizer.pad_token_id,
+                        eos_token_id=self.tokenizer.eos_token_id
+                    )
+                    
+                    response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+                    
+                    # Extract summary
+                    if "Summary:" in response:
+                        summary = response.split("Summary:")[1].strip()
+                    else:
+                        summary = f"Обнаружено событие типа {event_type} для компании {entity}"
+                    
+                    return event_type, summary
             
-            # Event classification
-            event_type = "Нет"
-            if any(term in text.lower() for term in ['отчет', 'выручка', 'прибыль', 'ebitda']):
-                event_type = "Отчетность"
-            elif any(term in text.lower() for term in ['облигаци', 'купон', 'дефолт']):
-                event_type = "РЦБ"
-            elif any(term in text.lower() for term in ['суд', 'иск', 'арбитраж']):
-                event_type = "Суд"
-                
-            self.last_gpu_use = time.time()
-            return event_type, response
+            # If no keywords matched
+            return "Нет", "No significant event detected"
             
         except Exception as e:
-            logger.error(f"Event detection error: {str(e)}")
-            return "Нет", f"Error: {str(e)}"
-
+            st.warning(f"Event detection error: {str(e)}")
+            return "Нет", f"Error in event detection: {str(e)}"
     def cleanup(self):
         """Clean up GPU resources"""
         try:
@@ -423,7 +360,7 @@ def create_interface():
     control = ProcessControl()
     
     with gr.Blocks(theme=gr.themes.Soft()) as app:
-        gr.Markdown("# AI-анализ мониторинга новостей v.1.21+")
+        gr.Markdown("# AI-анализ мониторинга новостей v.1.22")
         
         with gr.Row():
             file_input = gr.File(