torch 2.6

app.py

@@ -286,158 +286,80 @@ class EventDetector:
     def initialize_models(self, device):
         """Initialize all models with GPU support"""
         try:
-            # Force device to CUDA if available
-            if torch.cuda.is_available():
-                device = "cuda"
-                logger.info(f"Using CUDA: {torch.cuda.get_device_name(0)}")
-            
-            # === REPLACEMENT FOR HELSINKI-NLP USING M2M100 (SMALLER MODEL) ===
-            logger.info("replacing Helsinki-NLP with M2M100 (smaller model)")
-            from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
-            
-            # Use a much smaller model with 418M parameters (vs 2.46G)
-            model_name = "facebook/m2m100_418M"
-            
-            # Load tokenizer and model with explicit steps
-            self.translator_tokenizer = M2M100Tokenizer.from_pretrained(model_name)
-            
-            # Most careful loading to avoid meta tensor errors
-            self.translator_model = M2M100ForConditionalGeneration.from_pretrained(
-                model_name,
-                torch_dtype=torch.float16,  # Use half precision
-                low_cpu_mem_usage=True      # More memory efficient loading
+            # Initialize translation model with safetensors format
+            from transformers import AutoModelForSeq2SeqLM, MarianTokenizer
+            
+            # Direct model loading with safetensors
+            self.translator_tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-ru-en")
+            self.translator_model = AutoModelForSeq2SeqLM.from_pretrained(
+                "Helsinki-NLP/opus-mt-ru-en", 
+                use_safetensors=True,  # Force safetensors
+                from_tf=False,         # Not from TensorFlow 
+                device_map=device
             )
             
-            # Explicitly move to CUDA after loading
-            self.translator_model = self.translator_model.to(device)
-            
-            # Custom translation functions
-            def translate_ru_en(text_list):
-                """Function that mimics the Helsinki-NLP translator pipeline API"""
-                if not isinstance(text_list, list):
-                    text_list = [text_list]
+            # Create your own translation function
+            def translate_fn(text):
+                inputs = self.translator_tokenizer(text, return_tensors="pt").to(device)
+                outputs = self.translator_model.generate(**inputs)
+                return self.translator_tokenizer.decode(outputs[0], skip_special_tokens=True)
                 
-                results = []
-                for text in text_list:
-                    if not text or not isinstance(text, str):
-                        results.append({"translation_text": ""})
-                        continue
-                    
-                    try:
-                        # Explicitly set source and target languages
-                        self.translator_tokenizer.src_lang = "ru"
-                        self.translator_tokenizer.tgt_lang = "en"
-                        
-                        # Tokenize
-                        encoded = self.translator_tokenizer(text.strip(), return_tensors="pt")
-                        
-                        # Manually move to device
-                        encoded = {k: v.to(device) for k, v in encoded.items()}
-                        
-                        # Generate with careful error handling
-                        with torch.no_grad():
-                            output = self.translator_model.generate(**encoded, max_length=512, num_beams=2)
-                        
-                        # Decode
-                        decoded = self.translator_tokenizer.batch_decode(output, skip_special_tokens=True)
-                        translation = decoded[0] if decoded else ""
-                        
-                        results.append({"translation_text": translation})
-                    except Exception as e:
-                        logger.error(f"Translation error: {str(e)}")
-                        results.append({"translation_text": f"Translation error: {str(e)}"})
-                
-                return results
+            # Replace pipeline with custom function
+            self.translator = translate_fn
             
-            def translate_en_ru(text_list):
-                """Function that mimics the Helsinki-NLP translator pipeline API for EN-RU"""
-                if not isinstance(text_list, list):
-                    text_list = [text_list]
-                
-                results = []
-                for text in text_list:
-                    if not text or not isinstance(text, str):
-                        results.append({"translation_text": ""})
-                        continue
-                    
-                    try:
-                        # Explicitly set source and target languages
-                        self.translator_tokenizer.src_lang = "en"
-                        self.translator_tokenizer.tgt_lang = "ru"
-                        
-                        # Tokenize
-                        encoded = self.translator_tokenizer(text.strip(), return_tensors="pt")
-                        
-                        # Manually move to device
-                        encoded = {k: v.to(device) for k, v in encoded.items()}
-                        
-                        # Generate with careful error handling
-                        with torch.no_grad():
-                            output = self.translator_model.generate(**encoded, max_length=512, num_beams=2)
-                        
-                        # Decode
-                        decoded = self.translator_tokenizer.batch_decode(output, skip_special_tokens=True)
-                        translation = decoded[0] if decoded else ""
-                        
-                        results.append({"translation_text": translation})
-                    except Exception as e:
-                        logger.error(f"Translation error: {str(e)}")
-                        results.append({"translation_text": f"Translation error: {str(e)}"})
-                
-                return results
+            # Same for Russian translator
+            self.rutranslator_tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-ru")
+            self.rutranslator_model = AutoModelForSeq2SeqLM.from_pretrained(
+                "Helsinki-NLP/opus-mt-en-ru", 
+                use_safetensors=True,
+                device_map=device
+            )
             
-            # Set up the replacement pipelines
-            self.translator = translate_ru_en
-            self.rutranslator = translate_en_ru
+            def ru_translate_fn(text):
+                inputs = self.rutranslator_tokenizer(text, return_tensors="pt").to(device)
+                outputs = self.rutranslator_model.generate(**inputs)
+                return self.rutranslator_tokenizer.decode(outputs[0], skip_special_tokens=True)
+                
+            self.rutranslator = ru_translate_fn
             
-            # === CONTINUE WITH ORIGINAL CODE FOR OTHER MODELS ===
-            # But add safetensors parameter to all model loading
-            from transformers import AutoModelForSequenceClassification
+            # Continue with other models but use safetensors
+            # For sentiment models
+            from transformers import AutoModelForSequenceClassification, AutoTokenizer
             
-            # For sentiment models, use direct model loading instead of pipeline
-            self.finbert_tokenizer = AutoTokenizer.from_pretrained("ProsusAI/finbert")
-            self.finbert_model = AutoModelForSequenceClassification.from_pretrained(
-                "ProsusAI/finbert",
+            # Initialize FinBERT
+            finbert_tokenizer = AutoTokenizer.from_pretrained("ProsusAI/finbert")
+            finbert_model = AutoModelForSequenceClassification.from_pretrained(
+                "ProsusAI/finbert", 
                 use_safetensors=True,
-                torch_dtype=torch.float16,
-                low_cpu_mem_usage=True
-            ).to(device)
+                device_map=device
+            )
             
-            # Create custom sentiment function
-            def analyze_finbert(text):
-                inputs = self.finbert_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
-                inputs = {k: v.to(device) for k, v in inputs.items()}
-                
-                with torch.no_grad():
-                    outputs = self.finbert_model(**inputs)
-                    
-                probs = torch.nn.functional.softmax(outputs.logits, dim=1)
-                pred_class = torch.argmax(probs, dim=1).item()
-                
-                # Map to expected format
+            # Define custom pipeline instead of using transformers pipeline
+            def finbert_sentiment(text):
+                inputs = finbert_tokenizer(text, return_tensors="pt", truncation=True, max_length=512).to(device)
+                outputs = finbert_model(**inputs)
+                probs = outputs.logits.softmax(dim=1)[0]
+                pred_idx = probs.argmax().item()
                 labels = ["negative", "neutral", "positive"]
-                return [{"label": labels[pred_class], "score": probs[0][pred_class].item()}]
+                return {"label": labels[pred_idx], "score": probs[pred_idx].item()}
                 
-            # Replace pipelines with custom functions
-            self.finbert = analyze_finbert
+            self.finbert = lambda text: [finbert_sentiment(text)]
             
-            # Do the same for the other sentiment models...
-            # (Add similar custom implementations)
+            # Similar custom implementations for other sentiment models...
             
-            # Initialize MT5 model with careful loading
+            # Initialize MT5 model with safetensors
             self.model_name = "google/mt5-small"
             self.tokenizer = AutoTokenizer.from_pretrained(
                 self.model_name,
                 legacy=True
             )
             self.model = AutoModelForSeq2SeqLM.from_pretrained(
-                self.model_name,
+                self.model_name, 
                 use_safetensors=True,
-                torch_dtype=torch.float16,
-                low_cpu_mem_usage=True
-            ).to(device)
+                device_map=device
+            )
             
-            # Initialize Groq
+            # Initialize Groq LLM if key is available
             if 'groq_key':
                 self.groq = ChatOpenAI(
                     base_url="https://api.groq.com/openai/v1",
@@ -449,10 +371,6 @@ class EventDetector:
                 logger.warning("Groq API key not found, impact estimation will be limited")
                 self.groq = None
                 
-            self.device = device
-            self.initialized = True
-            logger.info("All models initialized successfully!")
-            
         except Exception as e:
             logger.error(f"Error in model initialization: {str(e)}")
             raise
@@ -1141,7 +1059,7 @@ def create_interface():
     control = ProcessControl()
     
     with gr.Blocks(analytics_enabled=False) as app:
-        gr.Markdown("# AI-анализ мониторинга новостей v.3.1 + forced cuda")
+        gr.Markdown("# AI-анализ мониторинга новостей v.2.26 + forced cuda")
         
         with gr.Row():
             file_input = gr.File(

requirements.txt

@@ -1,8 +1,10 @@
 gradio==4.44.0
 spaces==0.19.4
 pandas
-transformers>=4.30.0
-torch==2.1.2
+transformers==4.38.0
+safetensors==0.4.2  
+sentencepiece==0.1.99 
+torch==2.6.0
 tqdm
 sentencepiece
 pymystem3