Update app.py

app.py

@@ -1,106 +1,77 @@
-from transformers import pipeline, AutoModelForQuestionAnswering, AutoTokenizer
+import torch
+from transformers import RagRetriever, RagTokenizer, RagSequenceForGeneration
 import gradio as gr
 from PyPDF2 import PdfReader
 import re
 
-# Modell und Tokenizer laden
-model_name = "deepset/roberta-base-squad2"
-model = AutoModelForQuestionAnswering.from_pretrained(model_name)
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-qa_pipeline = pipeline("question-answering", model=model, tokenizer=tokenizer)
+# Laden des Tokenizers, des Retrievers und des Modells (auf CPU)
+model_name = "facebook/rag-token-nq"
+tokenizer = RagTokenizer.from_pretrained(model_name)
+retriever = RagRetriever.from_pretrained(model_name, index_name="exact")
+model = RagSequenceForGeneration.from_pretrained(model_name).to("cpu")  # Modell auf CPU laden
 
 # Funktion zum Extrahieren und Bereinigen von Text aus PDF
 def extract_text_from_pdf(pdf_path):
     reader = PdfReader(pdf_path)
     text = ""
     for page in reader.pages:
-        text += page.extract_text()
+        page_text = page.extract_text()
+        if page_text:
+            text += page_text
     return text
 
 def clean_text(text):
-    text = re.sub(r'\s+', ' ', text)  # Mehrere Leerzeichen und Zeilenumbrüche reduzieren
-    text = re.sub(r'[^\w\s.,-]', '', text)  # Entfernen von Sonderzeichen
+    # Entfernen unnötiger Zeichen, Reduktion von Leerzeichen
+    text = re.sub(r'\s+', ' ', text)
+    text = re.sub(r'[^\w\s.,-]', '', text)
     return text.strip()
 
-def split_text_into_paragraphs(text, max_length=500):
-    paragraphs = text.split("\n")
-    refined_paragraphs = []
-    temp = ""
-    for para in paragraphs:
-        if len(temp) + len(para) <= max_length:
-            temp += " " + para
-        else:
-            refined_paragraphs.append(temp.strip())
-            temp = para
-    if temp:
-        refined_paragraphs.append(temp.strip())
-    return refined_paragraphs
+# Funktion zum Aufteilen langer Texte in Abschnitte
+def split_text_into_chunks(text, chunk_size=1000):
+    words = text.split()
+    chunks = [' '.join(words[i:i + chunk_size]) for i in range(0, len(words), chunk_size)]
+    return chunks
 
-# Funktion zur Relevanzbewertung von Abschnitten
-def find_relevant_parts(question, context_parts):
-    keywords = question.lower().split()
-    relevant_parts = [
-        part for part in context_parts if any(keyword in part.lower() for keyword in keywords)
-    ]
-    if not relevant_parts:
-        # Fallback: Abschnitte mit den meisten Übereinstimmungen wählen
-        keyword_counts = [
-            (part, sum(part.lower().count(keyword) for keyword in keywords))
-            for part in context_parts
-        ]
-        keyword_counts.sort(key=lambda x: x[1], reverse=True)
-        relevant_parts = [keyword_counts[0][0]] if keyword_counts else context_parts
-    return relevant_parts
+# Hauptfunktion für die Fragebeantwortung mit RAG
+def chatbot_response(pdf_path, question):
+    try:
+        # PDF-Inhalt extrahieren und bereinigen
+        context = clean_text(extract_text_from_pdf(pdf_path))
+        if not context:
+            return "Das Dokument enthält keinen Text oder konnte nicht gelesen werden."
 
-# Funktion für Antwort-Postprocessing
-def refine_answer(answer, question, context):
-    if not answer or len(answer.split()) < 3:
-        # Versuche, die Antwort direkt aus dem Kontext zu extrahieren
-        keywords = question.lower().split()
-        relevant_sentences = [
-            sentence for sentence in context.split('.')
-            if any(keyword in sentence.lower() for keyword in keywords)
-        ]
-        if relevant_sentences:
-            return " ".join(relevant_sentences).strip()
-        return "Die Antwort konnte nicht eindeutig aus dem Dokument ermittelt werden."
-    return answer.capitalize().strip()
+        # Dokumenttext in Abschnitte aufteilen, um Speicher zu sparen
+        chunks = split_text_into_chunks(context)
 
-# Hauptfunktion für den Chatbot
-def chatbot_response(pdf_path, question):
-    # Text extrahieren und bereinigen
-    context = clean_text(extract_text_from_pdf(pdf_path))
-    context_parts = split_text_into_paragraphs(context)
-    
-    # Relevante Abschnitte finden
-    relevant_parts = find_relevant_parts(question, context_parts)
-    
-    # Antworten aus relevanten Abschnitten generieren
-    answers = []
-    for part in relevant_parts:
-        try:
-            result = qa_pipeline(question=question, context=part)
-            answers.append(result['answer'])
-        except Exception:
-            continue
+        # Antwortgenerierung mit minimalem Speicherverbrauch
+        answers = []
+        with torch.no_grad():  # Verhindert das Speichern von Gradienten (für CPU wichtig)
+            for chunk in chunks:
+                retriever.index = [chunk]
+                inputs = tokenizer(question, return_tensors="pt").to("cpu")  # Sicherstellen, dass Inputs auf CPU bleiben
+                generated_ids = model.generate(**inputs, max_length=150)  # Kürzere Antwortlänge
+                answer = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+                if answer:
+                    answers.append(answer)
+
+        final_answer = " / ".join(answers) if answers else "Keine spezifische Antwort gefunden."
+        return final_answer
 
-    # Beste Antwort auswählen und verfeinern
-    combined_context = " ".join(relevant_parts)
-    final_answer = refine_answer(" ".join(answers).strip(), question, combined_context)
-    return final_answer
+    except Exception as e:
+        return f"Es ist ein Fehler aufgetreten: {str(e)}"
 
 # Gradio-Interface erstellen
 pdf_input = gr.File(label="PDF-Datei hochladen", type="filepath")
 question_input = gr.Textbox(label="Frage eingeben", placeholder="Stelle eine Frage zu dem PDF-Dokument")
-response_output = gr.Textbox(label="Antwort")
+response_output = gr.Textbox(label="Antwort", lines=4)
 
 interface = gr.Interface(
     fn=chatbot_response,
     inputs=[pdf_input, question_input],
     outputs=response_output,
-    title="Verbesserte PDF-Fragebeantwortung",
-    description="Lade eine PDF-Datei hoch und stelle Fragen zu ihrem Inhalt. Antworten basieren nur auf den PDF-Inhalten."
+    title="RAG PDF-Fragebeantwortung auf CPU",
+    description="Lade eine PDF-Datei hoch und stelle Fragen zu ihrem Inhalt. Das System verwendet Retrieval-Augmented Generation (RAG) auf CPU zur Beantwortung.",
 )
 
-if __name__ == "__main__":
-    interface.launch()
+# Interface für Hugging Face Spaces
+interface.launch(share=True)