Update utils.py

utils.py

@@ -2,23 +2,34 @@ import pandas as pd
 from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
 
-class CSVAnalyzer:
+# Globale Analyseinstanz
+_analyzer = None
+
+def get_analyzer():
+    """Singleton-Muster zur Vermeidung der Modellneuinitialisierung bei jedem Aufruf"""
+    global _analyzer
+    if _analyzer is None:
+        _analyzer = CSVAnalysierer()
+    return _analyzer
+
+class CSVAnalysierer:
     def __init__(self):
         self.model_name = "mistralai/Mistral-7B-Instruct-v0.2"
         try:
-            # Tokenizer initialization with specific configuration
+            print("Modell wird initialisiert...")
+            # Tokenizer-Initialisierung mit spezifischer Konfiguration
             self.tokenizer = AutoTokenizer.from_pretrained(
                 self.model_name,
                 trust_remote_code=True,
                 use_fast=False
             )
             
-            # Padding token configuration
+            # Padding-Token-Konfiguration
             if self.tokenizer.pad_token is None:
                 self.tokenizer.pad_token = self.tokenizer.eos_token
                 self.tokenizer.padding_side = "right"
 
-            # Model initialization
+            # Modell-Initialisierung
             self.model = AutoModelForCausalLM.from_pretrained(
                 self.model_name,
                 torch_dtype=torch.float16,
@@ -26,42 +37,43 @@ class CSVAnalyzer:
                 trust_remote_code=True
             )
             
-            # Ensure model knows the pad_token
+            # Sicherstellen, dass das Modell das Padding-Token kennt
             self.model.config.pad_token_id = self.tokenizer.pad_token_id
+            print("Modell erfolgreich initialisiert!")
             
         except Exception as e:
             print(f"Initialisierungsfehler: {str(e)}")
             raise
 
-    def prepare_context(self, df: pd.DataFrame) -> str:
+    def kontext_vorbereiten(self, df: pd.DataFrame) -> str:
         """Bereitet den Kontext mit den DataFrame-Daten vor."""
         try:
-            context = "E-Mail-Informationen:\n\n"
+            kontext = "E-Mail-Informationen:\n\n"
             
-            # Convert DataFrame to string and handle missing values
+            # DataFrame in String umwandeln und fehlende Werte behandeln
             df_str = df.fillna("Keine Angabe").astype(str)
             
-            # Process each row
+            # Jede Zeile verarbeiten
             for index in range(len(df_str)):
-                row = df_str.iloc[index]
-                context += f"E-Mail {index + 1}:\n"
-                for column in df_str.columns:
-                    context += f"{column}: {row[column]}\n"
-                context += "---\n"
+                zeile = df_str.iloc[index]
+                kontext += f"E-Mail {index + 1}:\n"
+                for spalte in df_str.columns:
+                    kontext += f"{spalte}: {zeile[spalte]}\n"
+                kontext += "---\n"
             
-            return context.strip()
+            return kontext.strip()
             
         except Exception as e:
             raise Exception(f"Fehler bei der Kontextvorbereitung: {str(e)}")
 
-    def generate_response(self, context: str, query: str) -> str:
+    def antwort_generieren(self, kontext: str, frage: str) -> str:
         """Generiert eine Antwort auf die Frage unter Verwendung des Kontexts."""
         prompt = f"""<s>[INST] Sie sind ein deutscher Assistent für Facility Management Datenanalyse. 
 Analysieren Sie die folgenden E-Mail-Daten:
 
-{context}
+{kontext}
 
-Frage: {query}
+Frage: {frage}
 
 Wichtige Anweisungen:
 1. Antworten Sie AUSSCHLIEßLICH auf Deutsch
@@ -72,7 +84,7 @@ Wichtige Anweisungen:
 Ihre deutsche Antwort: [/INST]"""
 
         try:
-            inputs = self.tokenizer(
+            eingabe = self.tokenizer(
                 prompt,
                 return_tensors="pt",
                 padding=True,
@@ -83,9 +95,9 @@ Ihre deutsche Antwort: [/INST]"""
             ).to(self.model.device)
             
             with torch.no_grad():
-                outputs = self.model.generate(
-                    input_ids=inputs["input_ids"],
-                    attention_mask=inputs["attention_mask"],
+                ausgabe = self.model.generate(
+                    input_ids=eingabe["input_ids"],
+                    attention_mask=eingabe["attention_mask"],
                     max_new_tokens=512,
                     temperature=0.7,
                     top_p=0.95,
@@ -96,21 +108,21 @@ Ihre deutsche Antwort: [/INST]"""
                     eos_token_id=self.tokenizer.eos_token_id
                 )
             
-            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            response = response.split("[/INST]")[-1].strip()
+            antwort = self.tokenizer.decode(ausgabe[0], skip_special_tokens=True)
+            antwort = antwort.split("[/INST]")[-1].strip()
             
-            return response
+            return antwort
             
         except Exception as e:
-            return f"Fehler bei der Analyse: {str(e)}"
+            return f"Generierungsfehler: {str(e)}"
 
-def analyze_csv(df: pd.DataFrame, query: str) -> str:
+def csv_analysieren(df: pd.DataFrame, frage: str) -> str:
     """Hauptfunktion zur CSV-Analyse und Fragenbeantwortung."""
     try:
-        analyzer = CSVAnalyzer()
-        context = analyzer.prepare_context(df)
-        response = analyzer.generate_response(context, query)
-        return response
+        analysierer = get_analyzer()  # Verwendet die einzige Instanz
+        kontext = analysierer.kontext_vorbereiten(df)
+        antwort = analysierer.antwort_generieren(kontext, frage)
+        return antwort
         
     except Exception as e:
         return f"Fehler bei der Analyse: {str(e)}"