File size: 5,967 Bytes
6481b89 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 |
import logging
import gradio as gr
import time
import json
from main import (
load_model_with_questions_and_answers,
simulate_question_answering,
find_similar_question
)
# Deaktiviere alle Logging-Ausgaben außer kritischen Fehlern
logging.getLogger().setLevel(logging.CRITICAL)
# Modell laden
category_nodes, questions = load_model_with_questions_and_answers("model_with_qa.json")
def test_model_with_answers(category_nodes, questions, query):
"""
Testet das Modell mit einer Abfrage und gibt die gefundene Frage, Antwort und Gewichtung zurück.
Args:
category_nodes (list): Liste der Kategorie-Knoten.
questions (list): Liste der Fragen.
query (str): Die Abfrage, nach der gesucht werden soll.
Returns:
tuple: Die gefundene Frage, Antwort und Gewichtung.
"""
# Suche nach der ähnlichsten Frage im Modell
matched_question = find_similar_question(questions, query)
if matched_question and matched_question.get('question') != "Keine passende Frage gefunden":
answer = matched_question.get('answer', 'Keine Antwort verfügbar')
# Simulation der Fragebeantwortung (Gewichtung/Aktivierung)
activation = simulate_question_answering(category_nodes, matched_question['question'], questions)
# Rückgabe der relevanten Informationen
return f"Frage: \"{query}\"", f"Antwort: \"{answer}\"", f"Gewichtung: {activation:.2f}"
else:
# Falls keine passende Frage gefunden wurde
return f"Frage: \"{query}\"", "Antwort: \"Keine passende Frage gefunden\"", "Gewichtung: 0.00"
def measure_response_time(func, *args, **kwargs):
"""
Misst die Zeit, die eine Funktion benötigt, um ausgeführt zu werden, und gibt die Ergebnisse zusammen mit der Zeit zurück.
Args:
func (callable): Die auszuführende Funktion.
*args: Positionsargumente für die Funktion.
**kwargs: Schlüsselwortargumente für die Funktion.
Returns:
tuple: Die Ergebnisse der Funktion und die verstrichene Zeit in Millisekunden.
"""
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
elapsed_time = (end_time - start_time) * 1000 # Umwandlung in Millisekunden
return result, elapsed_time
def extract_questions_and_answers_from_json(input_json, output_txt):
"""
Extrahiert Fragen und Antworten aus einer JSON-Datei und schreibt sie in eine Textdatei.
Args:
input_json (str): Der Pfad zur Eingabe-JSON-Datei.
output_txt (str): Der Pfad zur Ausgabe-Textdatei.
"""
try:
with open(input_json, mode='r', encoding='utf-8') as jsonfile, open(output_txt, mode='w', encoding='utf-8') as txtfile:
data = json.load(jsonfile)
questions = data.get('questions', [])
for question in questions:
q = question.get('question', '')
a = question.get('answer', '')
if q and a:
txtfile.write(f'"question": "{q}",\n')
txtfile.write(f'"answer": "{a}"\n\n')
print(f"Fragen und Antworten wurden erfolgreich in {output_txt} geschrieben.")
except FileNotFoundError:
print(f"Die Datei {input_json} wurde nicht gefunden.")
except json.JSONDecodeError:
print(f"Fehler beim Parsen der JSON-Datei {input_json}.")
except Exception as e:
print(f"Ein Fehler ist aufgetreten: {e}")
def load_questions_and_answers(file_path):
"""
Lädt Fragen und Antworten aus einer Textdatei.
Args:
file_path (str): Der Pfad zur Textdatei.
Returns:
str: Der Inhalt der Textdatei.
"""
try:
with open(file_path, mode='r', encoding='utf-8') as file:
content = file.read()
return content
except FileNotFoundError:
return "Datei nicht gefunden."
except Exception as e:
return f"Fehler beim Lesen der Datei: {e}"
# Gradio-Interface
def gradio_interface(query):
"""
Gradio-Schnittstelle zur Verarbeitung der Benutzerabfrage.
Args:
query (str): Die Abfrage des Benutzers.
Returns:
tuple: Die gefundene Frage, Antwort, Gewichtung und die verstrichene Zeit in Millisekunden.
"""
if category_nodes and questions:
result, elapsed_time = measure_response_time(test_model_with_answers, category_nodes, questions, query)
return *result, f"Reaktionszeit: {elapsed_time:.2f} ms"
else:
logging.critical("Kein Modell gefunden.")
return "Fehler", "Kein Modell geladen.", "0.00", "Reaktionszeit: 0.00 ms"
# Pfade zu den Dateien
input_json = 'model_with_qa.json'
output_txt = 'questions_and_answers.txt'
# Extrahiere Fragen und Antworten aus der JSON-Datei und speichere sie in der Textdatei
extract_questions_and_answers_from_json(input_json, output_txt)
# Lade die Fragen und Antworten aus der Textdatei
questions_and_answers_content = load_questions_and_answers(output_txt)
# Erstelle das Gradio-Interface
iface = gr.Interface(
fn=gradio_interface,
inputs=gr.Textbox(label="Frage eingeben", placeholder="Stellen Sie eine Frage..."),
outputs=[
gr.Textbox(label="Frage"),
gr.Textbox(label="Antwort"),
gr.Textbox(label="Gewichtung"),
gr.Textbox(label="Reaktionszeit")
],
title="Frage-Antwort-Modell",
description="Stellen Sie eine Frage, und das Modell wird versuchen, eine passende Antwort mit Gewichtung zu finden."
)
# Füge ein aufklappbares Ausgabefenster hinzu, das die Liste der Fragen und Antworten anzeigt
with gr.Blocks() as demo:
gr.Markdown("## Frage-Antwort-Modell")
with gr.Row():
with gr.Column():
iface.render()
with gr.Column():
gr.Markdown("### Fragen und Antworten")
gr.Textbox(value=questions_and_answers_content, lines=20, label="Fragen und Antworten", interactive=False)
# Starte das Gradio-Interface
demo.launch()
|