In diesem Blogbeitrag stelle ich euch ein Python-Skript vor, das automatisch Fragen aus einem PDF-Dokument generiert. Es nutzt moderne NLP-Technologien wie spaCy, T5 von Hugging Face und Argos Translate, um Texte zu analysieren, Fragen zu erstellen und diese ins Deutsche zu übersetzen. Ob für Bildungszwecke, Content-Erstellung oder Forschung – dieses Tool bietet spannende Einsatzmöglichkeiten. Ich erkläre euch, wie ihr eine neue Umgebung einrichtet, das Skript installiert und anwendet, und gebe euch einen Überblick über potenzielle Anwendungsfälle.

Schritt 1: Eine neue Python-Umgebung erstellen

Damit das Skript reibungslos läuft, empfehle ich, eine virtuelle Umgebung zu erstellen. So vermeidet ihr Konflikte zwischen Bibliotheken. Hier sind die Installationsanweisungen:

1. Python installieren: Stellt sicher, dass ihr Python 3.8 oder höher installiert habt. Ihr könnt es von python.org herunterladen.
2. Virtuelle Umgebung erstellen: Öffnet eure Kommandozeile (Terminal oder CMD) und führt folgende Befehle aus:bashpython -m venv question_gen_envDies erstellt eine neue Umgebung im Ordner question_gen_env.
3. Umgebung aktivieren:
   • Unter Windows:bashquestion_gen_env\Scripts\activate
   • Unter macOS/Linux:bashsource question_gen_env/bin/activate
   Wenn die Umgebung aktiviert ist, seht ihr (question_gen_env) vor eurem Prompt.
4. Bibliotheken installieren: Installiert die benötigten Pakete mit pip:bashpip install spacy transformers torch argostranslate pymupdfAnschließend ladet das spaCy-Modell für Deutsch herunter:bashpython -m spacy download de_core_news_md

Damit ist eure Umgebung bereit!

Das Skript: Funktionen und Ablauf

Hier ist der Code, den ihr in einer Datei (z. B. question_generator.py) speichern könnt:

python

import spacy
from transformers import T5Tokenizer, T5ForConditionalGeneration
import argostranslate.translate
import fitz  # PyMuPDF
import os

# Globales Modell und Tokenizer
tokenizer = None
model = None

# Lade spaCy Modell
nlp = spacy.load('de_core_news_md')

# Funktion zum Einlesen des Texts aus einer PDF-Datei
def extract_text_from_pdf(pdf_path):
    doc = fitz.open(pdf_path)
    text = ""
    for page_num in range(len(doc)):
        page = doc.load_page(page_num)
        text += page.get_text()
    return text

# Funktion zur Extraktion von benannten Entitäten
def extract_entities(text):
    doc = nlp(text)
    entities = [ent.text for ent in doc.ents]
    return entities

# Funktion zur Aufteilung des Texts in kleinere Abschnitte
def split_text(text, max_length=512):
    words = text.split()
    return [words[i:i + max_length] for i in range(0, len(words), max_length)]

# Funktion zur Fragegenerierung mit Beam-Search
def generate_questions(text, tokenizer, model):
    entities = extract_entities(text)
    text_with_entities = text + " " + " ".join(entities)
    sections = split_text(text_with_entities)
    questions = []
    for section in sections:
        input_text = "generate questions: " + " ".join(section)
        input_ids = tokenizer.encode(input_text, return_tensors="pt")
        outputs = model.generate(input_ids=input_ids, max_length=512, num_beams=10, num_return_sequences=5)
        questions.extend([tokenizer.decode(output, skip_special_tokens=True) for output in outputs])
    return questions

# Übersetzungsfunktion
def translate_text(text, from_code='en', to_code='de'):
    translated_text = argostranslate.translate.translate(text, from_code, to_code)
    return translated_text

# Funktion zum Überprüfen, ob eine Frage mit einem Fragewort beginnt
def is_question_starting_with_wh(question):
    question = question.strip().lower()
    return question.startswith(('wer', 'was', 'wann', 'wo', 'wie', 'warum'))

# Funktion zum Filtern der Fragen
def filter_questions(questions):
    filtered_questions = []
    for question in questions:
        question = question.strip()
        if '?' in question and is_question_starting_with_wh(question):
            filtered_questions.append(question)
    return filtered_questions

# Funktion zum Speichern von Fragen in einer Textdatei ohne Duplikate
def save_questions_to_file(questions, file_path):
    unique_questions = list(set(questions))
    with open(file_path, 'w', encoding='utf-8') as file:
        for question in unique_questions:
            file.write(question + '\n')

# Funktion zum Einlesen von Fragen aus einer Textdatei
def load_questions_from_file(file_path):
    if not os.path.isfile(file_path):
        print(f"Die Datei {file_path} existiert nicht.")
        return []
    with open(file_path, 'r', encoding='utf-8') as file:
        return file.readlines()

# Hauptteil des Programms
def main():
    global tokenizer, model
    pdf_file_path = input("Bitte geben Sie den Pfad zur PDF-Datei ein: ").strip()
    if not os.path.isfile(pdf_file_path):
        print("Die angegebene Datei existiert nicht.")
        return
    text = extract_text_from_pdf(pdf_file_path)
    model_name = "valhalla/t5-base-qg-hl"
    tokenizer = T5Tokenizer.from_pretrained(model_name)
    model = T5ForConditionalGeneration.from_pretrained(model_name)
    questions = generate_questions(text, tokenizer, model)
    translated_questions = [translate_text(q, from_code='en', to_code='de') for q in questions]
    intermediate_file_path = 'intermediate_questions.txt'
    save_questions_to_file(translated_questions, intermediate_file_path)
    print(f"Die Fragen wurden in '{intermediate_file_path}' gespeichert.")
    loaded_questions = load_questions_from_file(intermediate_file_path)
    filtered_questions = filter_questions(loaded_questions)
    final_file_path = 'filtered_questions.txt'
    save_questions_to_file(filtered_questions, final_file_path)
    print(f"Die gefilterten Fragen wurden in '{final_file_path}' gespeichert.")

if __name__ == "__main__":
    main()

Wie funktioniert das Skript?

1. PDF-Text extrahieren: Mit PyMuPDF (fitz) wird der Text aus der PDF-Datei gelesen.
2. Entitäten erkennen: spaCy extrahiert benannte Entitäten (z. B. Personen, Orte), die in die Fragen einfließen.
3. Fragen generieren: Das T5-Modell von Hugging Face erstellt Fragen mit Beam-Search (num_beams=10), basierend auf Textabschnitten.
4. Übersetzen: Argos Translate übersetzt die Fragen ins Deutsche.
5. Filtern und Speichern: Fragen werden gefiltert (nur mit Fragewort und „?“) und ohne Duplikate in Textdateien gespeichert.

Startet das Skript mit:

bash

python question_generator.py

Gebt den Pfad zu eurer PDF-Datei ein, und das Skript erledigt den Rest!

Einsatzfelder

Dieses Tool ist vielseitig einsetzbar:

• Bildung: Erstellt automatisch Übungsfragen für Schüler oder Studenten aus Lehrmaterialien.
• Content-Erstellung: Generiert FAQ-Inhalte für Websites oder Blogs basierend auf Dokumenten.
• Forschung: Unterstützt beim Erstellen von Interviewfragen oder Hypothesen aus wissenschaftlichen Texten.
• Sprachlern-Apps: Erzeugt Fragen für Vokabel- oder Grammatikübungen in verschiedenen Sprachen.

Ausgehende Links

• spaCy Dokumentation – Mehr über NLP mit spaCy.
• Hugging Face Transformers – Details zu T5 und anderen Modellen.
• Argos Translate – Open-Source-Übersetzungstool.
• PyMuPDF – Dokumentation zur PDF-Verarbeitung.