Spaces:
Runtime error
Runtime error
| import requests | |
| import os, sys, json | |
| import gradio as gr | |
| import openai | |
| from openai import OpenAI | |
| import time | |
| import re | |
| import io | |
| from PIL import Image, ImageDraw, ImageOps, ImageFont | |
| import base64 | |
| import tempfile | |
| from tavily import TavilyClient | |
| from langchain.chains import LLMChain, RetrievalQA | |
| from langchain.chat_models import ChatOpenAI | |
| from langchain.document_loaders import PyPDFLoader, WebBaseLoader, UnstructuredWordDocumentLoader, DirectoryLoader | |
| from langchain.document_loaders.blob_loaders.youtube_audio import YoutubeAudioLoader | |
| from langchain.document_loaders.generic import GenericLoader | |
| from langchain.document_loaders.parsers import OpenAIWhisperParser | |
| from langchain.schema import AIMessage, HumanMessage | |
| from langchain.llms import HuggingFaceHub | |
| from langchain.llms import HuggingFaceTextGenInference | |
| from langchain.embeddings import HuggingFaceInstructEmbeddings, HuggingFaceEmbeddings, HuggingFaceBgeEmbeddings, HuggingFaceInferenceAPIEmbeddings | |
| from langchain.retrievers.tavily_search_api import TavilySearchAPIRetriever | |
| from langchain.embeddings.openai import OpenAIEmbeddings | |
| from langchain.prompts import PromptTemplate | |
| from langchain.text_splitter import RecursiveCharacterTextSplitter | |
| from langchain.vectorstores import Chroma | |
| from chromadb.errors import InvalidDimensionException | |
| from utils import * | |
| from beschreibungen import * | |
| #from langchain.vectorstores import MongoDBAtlasVectorSearch | |
| #from pymongo import MongoClient | |
| from dotenv import load_dotenv, find_dotenv | |
| _ = load_dotenv(find_dotenv()) | |
| ############################################### | |
| #globale Variablen | |
| ############################################## | |
| #nur bei ersten Anfrage splitten der Dokumente - um die Vektordatenbank entsprechend zu füllen | |
| splittet = False | |
| #für eine Session werden die chatsverläufe hier gespeichert... | |
| chats={} | |
| ############################################# | |
| # Allgemeine Konstanten | |
| #Filepath zu temp Folder (temp) mit File von ausgewähltem chatverlauf | |
| file_path_download = "" | |
| ################################################## | |
| #Für MongoDB statt Chroma als Vektorstore | |
| #MONGODB_URI = os.environ["MONGODB_ATLAS_CLUSTER_URI"] | |
| #client = MongoClient(MONGODB_URI) | |
| #MONGODB_DB_NAME = "langchain_db" | |
| #MONGODB_COLLECTION_NAME = "gpt-4" | |
| #MONGODB_COLLECTION = client[MONGODB_DB_NAME][MONGODB_COLLECTION_NAME] | |
| #MONGODB_INDEX_NAME = "default" | |
| #Plattform Keys aus den Secrets holen zu diesem Space | |
| HUGGINGFACEHUB_API_TOKEN = os.getenv("HF_ACCESS_READ") | |
| OAI_API_KEY=os.getenv("OPENAI_API_KEY") | |
| HEADERS = {"Authorization": f"Bearer {HUGGINGFACEHUB_API_TOKEN}"} | |
| TAVILY_KEY = os.getenv("TAVILY_KEY") | |
| os.environ["TAVILY_API_KEY"] = TAVILY_KEY | |
| ################################################ | |
| #LLM Model mit dem gearbeitet wird | |
| #openai------------------------------------- | |
| #MODEL_NAME = "gpt-3.5-turbo-16k" | |
| #MODEL_NAME = "gpt-3.5-turbo-1106" | |
| MODEL_NAME= "gpt-4-1106-preview" | |
| MODEL_NAME_IMAGE = "gpt-4-vision-preview" | |
| #verfügbare Modelle anzeigen lassen | |
| #HuggingFace Reop ID-------------------------------- | |
| #repo_id = "meta-llama/Llama-2-13b-chat-hf" | |
| repo_id = "HuggingFaceH4/zephyr-7b-alpha" #das Modell ist echt gut!!! Vom MIT | |
| #repo_id = "TheBloke/Yi-34B-Chat-GGUF" | |
| #repo_id = "meta-llama/Llama-2-70b-chat-hf" | |
| #repo_id = "tiiuae/falcon-40b" | |
| #repo_id = "Vicuna-33b" | |
| #repo_id = "alexkueck/ChatBotLI2Klein" | |
| #repo_id = "mistralai/Mistral-7B-v0.1" | |
| #repo_id = "internlm/internlm-chat-7b" | |
| #repo_id = "Qwen/Qwen-7B" | |
| #repo_id = "Salesforce/xgen-7b-8k-base" | |
| #repo_id = "Writer/camel-5b-hf" | |
| #repo_id = "databricks/dolly-v2-3b" | |
| #repo_id = "google/flan-t5-xxl" | |
| #HuggingFace Model name-------------------------------- | |
| MODEL_NAME_HF = "mistralai/Mixtral-8x7B-Instruct-v0.1" | |
| MODEL_NAME_OAI_ZEICHNEN = "dall-e-3" | |
| #Alternativ zeichnen: Stabe Diffusion from HF: | |
| API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1" | |
| ################################################ | |
| #HF Hub Zugriff ermöglichen | |
| ############################################### | |
| os.environ["HUGGINGFACEHUB_API_TOKEN"] = HUGGINGFACEHUB_API_TOKEN | |
| ################################################ | |
| #OpenAI Zugang, client und Assistant einmal erzeugen. | |
| ################################################ | |
| #zentral einmal erzeugen!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |
| client = OpenAI() | |
| general_assistant_file = client.beta.assistants.create(name="File Analysator",instructions=template, model="gpt-4-1106-preview",) | |
| thread_file = client.beta.threads.create() | |
| general_assistant_suche= openai_assistant_suche(client) | |
| ################################################# | |
| ################################################# | |
| ################################################# | |
| #Funktionen zur Verarbeitung | |
| ################################################ | |
| ############################################## | |
| #wenn löschen Button geklickt | |
| def clear_all(history, uploaded_file_paths): | |
| global chats | |
| dic_history = {schluessel: wert for schluessel, wert in history} | |
| summary = "\n\n".join(f'{schluessel}: \n {wert}' for schluessel, wert in dic_history.items()) | |
| #falls file mit summay für download existiert hat: das zunächst löschen | |
| #cleanup(file_path_download) | |
| #noch nicht im Einsatz, aber hier werden alle Chats einer Sitzung gespeichert | |
| #den aktuellen Chatverlauf zum Download bereitstellen: | |
| if chats != {} : | |
| id_neu = len(chats)+1 | |
| chats[id_neu]=summary | |
| else: | |
| chats[0]=summary | |
| #file_path_download = save_and_download(summary) | |
| headers, payload = process_chatverlauf("Gib eine Überschrift aus maximal 2 Worten zu folgendem Text an", MODEL_NAME, OAI_API_KEY) | |
| response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload) | |
| #als json ausgeben | |
| data = response.json() | |
| # Den "content" auswählen, da dort die Antwort der Ki enthalten ist | |
| result = data['choices'][0]['message']['content'] | |
| print (result) | |
| file_path_download = "data/" + str(len(chats)) + "_" + result | |
| with open(file_path_download, 'w') as file: | |
| # String in die Datei schreiben | |
| file.write(summary) | |
| #die session variable in gradio erweitern und alle fliepath neu in das gr.File hochladen | |
| uploaded_file_paths= uploaded_file_paths + [file_path_download] | |
| return None, gr.Image(visible=False), uploaded_file_paths, [], gr.File(uploaded_file_paths, label="Download-Chatverläufe", visible=True, interactive = False) | |
| ######################################### | |
| # Funktionen, um vergangene Chats anzuzeigen und zum Download anzubieten | |
| def update_chat_options(): | |
| global chats | |
| # Diese Funktion aktualisiert die verfügbaren Chat-Optionen | |
| if chats != {}: | |
| return list(chats.keys()) | |
| else: | |
| return None | |
| def download_chats(selected_chats): | |
| global chats | |
| global file_path_download | |
| if chats != {}: | |
| # Diese Funktion bereitet die ausgewählten Chats zum Download vor | |
| data = "\n\n".join(chats[chat] for chat in selected_chats) | |
| file_path_download = save_and_download(data) | |
| return gr.File(file_path_download, label="Download-Chat", visible=True) | |
| """ | |
| # Dateipfad festlegen (hier wird die Datei im aktuellen Verzeichnis gespeichert) | |
| file_path = FILE_PATH #'data/chatverlauf.txt' | |
| # Datei im Schreibmodus öffnen (erstellt die Datei, wenn sie nicht existiert) | |
| with open(file_path, 'w') as file: | |
| # String in die Datei schreiben | |
| file.write(data) | |
| return gr.File(file_path, label="Download-Chat", visible = True, show_label=True) | |
| """ | |
| else: | |
| return gr.File(visible=False) | |
| ############################################## | |
| #History - die Frage oder das File eintragen... | |
| #in history_file ist ein file gespeichert, falls voher im Verlauf schon ein File hochgeladen wurde. | |
| #wird ein neuer File hochgeladen, so wird history_fiel dadurch ersetzt | |
| def add_text(chatbot, history, prompt, file, file_history): | |
| if (file == None): | |
| chatbot = chatbot +[(prompt, None)] | |
| else: | |
| file_history = file | |
| if (prompt == ""): | |
| chatbot=chatbot + [((file.name,), "Prompt fehlt!")] | |
| else: | |
| ext = analyze_file(file) | |
| if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"): | |
| chatbot = chatbot +[((file.name,), None), (prompt, None)] | |
| else: | |
| chatbot = chatbot +[("Hochgeladenes Dokument: "+ get_filename(file) +"\n" + prompt, None)] | |
| return chatbot, history, prompt, file, file_history, gr.Image(visible = False), "" #gr.Image( label=None, size=(30,30), visible=False, scale=1) #gr.Textbox(value="", interactive=False) | |
| def add_text2(chatbot, prompt): | |
| if (prompt == ""): | |
| chatbot = chatbot + [("", "Prompt fehlt!")] | |
| else: | |
| chatbot = chatbot + [(prompt, None)] | |
| print("chatbot nach add_text............") | |
| print(chatbot) | |
| return chatbot, prompt, "" | |
| ############################################ | |
| #nach dem Upload soll das zusätzliche Fenster mit dem image drinnen angezeigt werden | |
| def file_anzeigen(file): | |
| ext = analyze_file(file) | |
| if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"): | |
| return gr.Image(width=47, visible=True, interactive = False, height=47, min_width=47, show_label=False, show_share_button=False, show_download_button=False, scale = 0.5), file, file | |
| else: | |
| return gr.Image(width=47, visible=True, interactive = False, height=47, min_width=47, show_label=False, show_share_button=False, show_download_button=False, scale = 0.5), "data/file.png", file | |
| def file_loeschen(): | |
| return None, gr.Image(visible = False) | |
| ############################################ | |
| #wenn 'Stop' Button geklickt, dann Message dazu und das Eingabe-Fenster leeren | |
| def cancel_outputing(): | |
| reset_textbox() | |
| return "Stop Done" | |
| def reset_textbox(): | |
| return gr.update(value=""),"" | |
| ########################################## | |
| #Hilfsfunktion, um ein von Stable Diffusion erzeugtes Bild für die Ausgabe in der History vorzubereiten | |
| def umwandeln_fuer_anzeige(image): | |
| buffer = io.BytesIO() | |
| image.save(buffer, format='PNG') | |
| return buffer.getvalue() | |
| ################################################## | |
| #openassistant um uploaded Files zu analysieren | |
| def create_assistant_file(prompt, file): | |
| global client, general_assistant_file | |
| #neues File dem Assistant hinzufügen | |
| file_neu = client.files.create(file=open(file,"rb",),purpose="assistants",) | |
| # Update Assistant | |
| #wenn type: code_interpreter, wird das file mit angehängt an den Prpmt, aber vorher nicht bearbeitet | |
| #wenn type: retrieval, wird das Dokument vorher embedded in einem vektorstore und nur entsprechende chunks mitgegeben. | |
| #pro Assistant 20 cent pro Tag als Nutzung - egal wie viele Fragen dazu. | |
| updated_assistant = client.beta.assistants.update(general_assistant_file.id,tools=[{"type": "code_interpreter"}, {"type": "retrieval"}],file_ids=[file_neu.id],) | |
| thread_file, run = create_thread_and_run(prompt, client, updated_assistant.id) | |
| run = wait_on_run(run, thread_file, client) | |
| response = get_response(thread_file, client, updated_assistant.id) | |
| result = response.data[1].content[0].text.value | |
| return result | |
| ################################################## | |
| #openassistant um im Netz zu suchen | |
| def create_assistant_suche(prompt): | |
| #global client, general_assistant_suche | |
| retriever = TavilySearchAPIRetriever(k=4) | |
| result = retriever.invoke(template + prompt) | |
| erg = "Aus dem Internet: " + result[0].page_content + ".\n Quelle: " | |
| src = result[0].metadata['source'] | |
| """ | |
| #neues Thread mit akt. prompt dem Assistant hinzufügen | |
| thread_suche, run = create_thread_and_run(prompt, client, general_assistant_suche.id) | |
| run = wait_on_run(run, thread_suche, client) | |
| response = get_response(thread_suche, client, general_assistant_suche.id) | |
| result = response.data[1].content[0].text.value | |
| """ | |
| return erg + src | |
| ################################################### | |
| #Funktion von Gradio aus, die den dort eingegebenen Prompt annimmt und weiterverarbeitet | |
| ################################################### | |
| ######################################################### | |
| #Funktion wird direkt aufgerufen aus der GUI - von hier muss auch die Rückmeldung kommen.... | |
| #man kann einen Text-Prompt eingeben (mit oder ohne RAG), dazu ein Image hochladen, ein Bild zu einem reinen textprompt erzeugen lassen | |
| def generate_auswahl(prompt, file, file_history, chatbot, history, rag_option, model_option, openai_api_key, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3,): | |
| global splittet | |
| #wenn RAG angeschaltet - Vektorstore initialisieren | |
| #aber nur, wenn es noch nicht geshehen ist (splittet = False) | |
| #falls schon ein File hochgeladen wurde, ist es in history_file gespeichert - falls ein neues File hochgeladen wurde, wird es anschließend neu gesetzt | |
| neu_file = file_history | |
| if (rag_option == "An"): | |
| #muss nur einmal ausgeführt werden... | |
| if not splittet: | |
| splits = document_loading_splitting() | |
| document_storage_chroma(splits) | |
| db = document_retrieval_chroma2() | |
| splittet = True | |
| else: | |
| db=None | |
| splittet = False | |
| #kein Bild hochgeladen -> auf Text antworten... | |
| status = "Antwort der KI ..." | |
| if (file == None and file_history == None): | |
| result, status = generate_text(prompt, chatbot, history, rag_option, model_option, openai_api_key, db, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3,) | |
| history = history + [[prompt, result]] | |
| else: | |
| #Es wurde ein File neu angehängt -> wenn prompt dazu, das Bild analysieren | |
| #das history_fiel muss neu gesetzt werden | |
| if (file != None): | |
| # file_history wird neu gesetzt in der Rückgabe dieser Funktion... | |
| neu_file = file | |
| #herausfinden, ob Bild oder Dokument... | |
| ext = analyze_file(neu_file) | |
| if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"): | |
| result= generate_text_zu_bild(neu_file, prompt, k, rag_option, chatbot, history, db) | |
| else: | |
| result = generate_text_zu_doc(neu_file, prompt, k, rag_option, chatbot, history, db) | |
| #die history erweitern - abhängig davon, ob gerade ein file hochgeladen wurde oder nicht | |
| if (file != None): | |
| history = history + [[(file,), None],[prompt, result]] | |
| else: | |
| history = history + [[prompt, result]] | |
| chatbot[-1][1] = "" | |
| for character in result: | |
| chatbot[-1][1] += character | |
| time.sleep(0.03) | |
| yield chatbot, history, None, neu_file, status | |
| if shared_state.interrupted: | |
| shared_state.recover() | |
| try: | |
| yield chatbot, history, None, neu_file, "Stop: Success" | |
| except: | |
| pass | |
| ################################################## | |
| #zu einem Text-Prompt ein Bild via Stable Diffusion generieren | |
| def generate_bild(prompt, chatbot, model_option_zeichnen='HuggingFace', temperature=0.5, max_new_tokens=4048,top_p=0.6, repetition_penalty=1.3): | |
| global client | |
| if (model_option_zeichnen == "Stable Diffusion"): | |
| print("Bild Erzeugung HF..............................") | |
| #Bild nach Anweisung zeichnen und in History darstellen... | |
| data = {"inputs": prompt} | |
| response = requests.post(API_URL, headers=HEADERS, json=data) | |
| print("fertig Bild") | |
| result = response.content | |
| #Bild ausgeben | |
| image = Image.open(io.BytesIO(result)) | |
| image_64 = umwandeln_fuer_anzeige(image) | |
| chatbot[-1][1]= "<img src='data:image/png;base64,{0}'/>".format(base64.b64encode(image_64).decode('utf-8')) | |
| else: | |
| print("Bild Erzeugung DallE..............................") | |
| #als Format ginge auch 'url', n - Anz. der erzeugten Bilder | |
| response = client.images.generate(model="dall-e-3",prompt=prompt,size="1024x1024",quality="standard",n=1, response_format='b64_json') | |
| #chatbot[-1][1]= "<img src='data:image/png;base64,{0}'/>".format(base64.b64encode(image_64).decode('utf-8')) | |
| chatbot[-1][1] = "<img src='data:image/png;base64,{0}'/>".format(response.data[0].b64_json) | |
| return chatbot, "Antwort KI: Success" | |
| ################################################## | |
| #zu einem Bild und Text-Prompt eine Analyse generieren | |
| def generate_text_zu_bild(file, prompt, k, rag_option, chatbot, history, db): | |
| global splittet | |
| print("Text mit Bild ..............................") | |
| prompt_neu = generate_prompt_with_history(prompt, history) | |
| if (rag_option == "An"): | |
| print("Bild mit RAG..............................") | |
| neu_text_mit_chunks = rag_chain2(prompt, db, k) | |
| #für Chat LLM: | |
| #prompt = generate_prompt_with_history_openai(neu_text_mit_chunks, history) | |
| #als reiner prompt: | |
| prompt_neu = generate_prompt_with_history(neu_text_mit_chunks, history) | |
| headers, payload = process_image(file, prompt_neu, MODEL_NAME_IMAGE, OAI_API_KEY) | |
| response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload) | |
| #als json ausgeben | |
| data = response.json() | |
| # Den "content" auswählen, da dort die Antwort der Ki enthalten ist | |
| result = data['choices'][0]['message']['content'] | |
| return result | |
| ################################################## | |
| #zu einem Bild und Text-Prompt eine Analyse generieren | |
| def generate_text_zu_doc(file, prompt, k, rag_option, chatbot, history, db): | |
| global splittet | |
| print("text mit doc ..............................") | |
| prompt_neu = generate_prompt_with_history(prompt, history) | |
| if (rag_option == "An"): | |
| print("Doc mit RAG..............................") | |
| neu_text_mit_chunks = rag_chain2(prompt, db, k) | |
| #für Chat LLM: | |
| #prompt_neu = generate_prompt_with_history_openai(neu_text_mit_chunks, history) | |
| #als reiner prompt: | |
| prompt_neu = generate_prompt_with_history(neu_text_mit_chunks, history) | |
| result = create_assistant_file(prompt_neu, file) | |
| return result | |
| #################################################### | |
| #aus einem Text-Prompt die Antwort von KI bekommen | |
| #mit oder ohne RAG möglich | |
| def generate_text (prompt, chatbot, history, rag_option, model_option, openai_api_key, db, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3,): | |
| global splittet | |
| suche_im_Netz="Antwort der KI ..." | |
| print("Text pur..............................") | |
| if (openai_api_key == "" or openai_api_key == "sk-"): | |
| #raise gr.Error("OpenAI API Key is required.") | |
| #eigenen OpenAI key nutzen | |
| openai_api_key= OAI_API_KEY | |
| if (rag_option is None): | |
| raise gr.Error("Retrieval Augmented Generation ist erforderlich.") | |
| if (prompt == ""): | |
| raise gr.Error("Prompt ist erforderlich.") | |
| #history für HuggingFace Models formatieren | |
| #history_text_und_prompt = generate_prompt_with_history_hf(prompt, history) | |
| #history für openAi formatieren | |
| #history_text_und_prompt = generate_prompt_with_history_openai(prompt, history) | |
| #history für Langchain formatieren | |
| #history_text_und_prompt = generate_prompt_with_history_langchain(prompt, history) | |
| try: | |
| ########################### | |
| #LLM auswählen (OpenAI oder HF) | |
| ########################### | |
| if (model_option == "OpenAI"): | |
| #Anfrage an OpenAI ---------------------------- | |
| print("OpenAI Anfrage.......................") | |
| llm = ChatOpenAI(model_name = MODEL_NAME, openai_api_key = openai_api_key, temperature=temperature)#, top_p = top_p) | |
| #Prompt an history anhängen und einen Text daraus machen | |
| if (rag_option == "An"): | |
| history_text_und_prompt = generate_prompt_with_history(prompt, history) | |
| else: | |
| history_text_und_prompt = generate_prompt_with_history_openai(prompt, history) | |
| else: | |
| #oder an Hugging Face -------------------------- | |
| print("HF Anfrage.......................") | |
| llm = HuggingFaceHub(repo_id=repo_id, model_kwargs={"temperature": 0.5, "max_length": 128}) | |
| #llm = HuggingFaceChain(model=MODEL_NAME_HF, model_kwargs={"temperature": 0.5, "max_length": 128}) | |
| #llm = HuggingFaceHub(url_??? = "https://wdgsjd6zf201mufn.us-east-1.aws.endpoints.huggingface.cloud", model_kwargs={"temperature": 0.5, "max_length": 64}) | |
| #llm = HuggingFaceTextGenInference( inference_server_url="http://localhost:8010/", max_new_tokens=max_new_tokens,top_k=10,top_p=top_p,typical_p=0.95,temperature=temperature,repetition_penalty=repetition_penalty,) | |
| print("HF") | |
| #Prompt an history anhängen und einen Text daraus machen | |
| history_text_und_prompt = generate_prompt_with_history(prompt, history) | |
| #zusätzliche Dokumenten Splits aus DB zum Prompt hinzufügen (aus VektorDB - Chroma oder Mongo DB) | |
| if (rag_option == "An"): | |
| print("LLM aufrufen mit RAG: ...........") | |
| result = rag_chain(llm, history_text_und_prompt, db) | |
| #elif (rag_option == "MongoDB"): | |
| #splits = document_loading_splitting() | |
| #document_storage_mongodb(splits) | |
| #db = document_retrieval_mongodb(llm, history_text_und_prompt) | |
| #result = rag_chain(llm, history_text_und_prompt, db) | |
| else: | |
| splittet = False | |
| print("LLM aufrufen ohne RAG: ...........") | |
| resulti = llm_chain(llm, history_text_und_prompt) | |
| result = resulti.strip() | |
| #Wenn keine Antwort möglich "Ich weiß es nicht" etc., dann versuchen mit Suche im Internet. | |
| if (result == None or is_response_similar(result)): | |
| print("Suche im Netz: ...........") | |
| suche_im_Netz="Antwort aus dem Internet ..." | |
| result = create_assistant_suche(prompt) | |
| except Exception as e: | |
| raise gr.Error(e) | |
| return result, suche_im_Netz | |
| ################################################ | |
| #GUI | |
| ############################################### | |
| #Beschreibung oben in GUI | |
| ################################################ | |
| #css = """.toast-wrap { display: none !important } """ | |
| #examples=[['Was ist ChtGPT-4?'],['schreibe ein Python Programm, dass die GPT-4 API aufruft.']] | |
| def vote(data: gr.LikeData): | |
| if data.liked: print("You upvoted this response: " + data.value) | |
| else: print("You downvoted this response: " + data.value) | |
| print ("Start GUIneu") | |
| with open("custom.css", "r", encoding="utf-8") as f: | |
| customCSS = f.read() | |
| #Add Inputs für Tab 2 | |
| additional_inputs = [ | |
| gr.Slider(label="Temperature", value=0.65, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Höhere Werte erzeugen diversere Antworten", visible=True), | |
| gr.Slider(label="Max new tokens", value=1024, minimum=0, maximum=4096, step=64, interactive=True, info="Maximale Anzahl neuer Tokens", visible=True), | |
| gr.Slider(label="Top-p (nucleus sampling)", value=0.6, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Höhere Werte verwenden auch Tokens mit niedrigerer Wahrscheinlichkeit.", visible=True), | |
| gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Strafe für wiederholte Tokens", visible=True) | |
| ] | |
| with gr.Blocks(css=customCSS, theme=small_and_beautiful_theme) as demo: | |
| #Session Variablen, um Weete zu speichern, auch wenn die Felder in der GUI bereits wieder leer sind | |
| # history parallel zu chatbot speichern - da in chatbot bei Bildern zum Anzeigen in der GUI die Bilder speziell formatiert werden, | |
| # für die Übergabe an die ki aber der Pfad zum Bild behalten werden muss - was in der history der Fall ist! | |
| history = gr.State([]) | |
| uploaded_file_paths= gr.State([]) | |
| #damit der Prompt auch nach dem upload in die History noch für predicts_args verfügbar ist | |
| user_question = gr.State("") | |
| #damit der Prompt auch nach dem upload in die History noch für predicts_args verfügbar ist | |
| user_question2 = gr.State("") | |
| attached_file = gr.State(None) | |
| attached_file_history = gr.State(None) | |
| status_display = gr.State("") | |
| status_display2 = gr.State("") | |
| ################################################ | |
| # Tab zum Chatbot mit Text oder Bildeingabe | |
| ################################################ | |
| gr.Markdown(description_top) | |
| with gr.Tab("LI Chatbot"): | |
| with gr.Row(): | |
| #gr.HTML("LI Chatot") | |
| status_display = gr.Markdown("Antwort der KI ...", visible = True) #, elem_id="status_display") | |
| with gr.Row(): | |
| with gr.Column(scale=5): | |
| with gr.Row(): | |
| chatbot = gr.Chatbot(elem_id="li-chat",show_copy_button=True) | |
| with gr.Row(): | |
| with gr.Column(scale=12): | |
| user_input = gr.Textbox( | |
| show_label=False, placeholder="Gib hier deinen Prompt ein...", | |
| container=False | |
| ) | |
| with gr.Column(min_width=70, scale=1): | |
| submitBtn = gr.Button("Senden") | |
| with gr.Column(min_width=70, scale=1): | |
| cancelBtn = gr.Button("Stop") | |
| with gr.Row(): | |
| #file_display = gr.File(visible=False) | |
| image_display = gr.Image( visible=False) | |
| upload = gr.UploadButton("📁", file_types=["image", "pdf", "docx", "pptx", "xlsx"], scale = 10) | |
| emptyBtn = gr.ClearButton([user_input, chatbot, history, attached_file, attached_file_history, image_display], value="🧹 Neue Session", scale=10) | |
| with gr.Column(): | |
| with gr.Column(min_width=50, scale=1): | |
| with gr.Tab(label="Chats ..."): | |
| #Geht nicht, da für alle gleichzeitig sichtbar | |
| #chat_selector = gr.CheckboxGroup(label="", choices=update_chat_options()) | |
| #download_button = gr.Button("Download ausgewählte Chats") | |
| file_download = gr.File(label="Download-Chat", visible=False, interactive = False) | |
| with gr.Tab(label="Parameter Einstellung"): | |
| #gr.Markdown("# Parameters") | |
| rag_option = gr.Radio(["Aus", "An"], label="LI Erweiterungen (RAG)", value = "Aus") | |
| model_option = gr.Radio(["OpenAI", "HuggingFace"], label="Modellauswahl", value = "OpenAI") | |
| top_p = gr.Slider( | |
| minimum=-0, | |
| maximum=1.0, | |
| value=0.95, | |
| step=0.05, | |
| interactive=True, | |
| label="Top-p", | |
| visible=False, | |
| ) | |
| temperature = gr.Slider( | |
| minimum=0.1, | |
| maximum=2.0, | |
| value=0.5, | |
| step=0.1, | |
| interactive=True, | |
| label="Temperature", | |
| visible=False | |
| ) | |
| max_length_tokens = gr.Slider( | |
| minimum=0, | |
| maximum=512, | |
| value=512, | |
| step=8, | |
| interactive=True, | |
| label="Max Generation Tokens", | |
| visible=False, | |
| ) | |
| max_context_length_tokens = gr.Slider( | |
| minimum=0, | |
| maximum=4096, | |
| value=2048, | |
| step=128, | |
| interactive=True, | |
| label="Max History Tokens", | |
| visible=False, | |
| ) | |
| repetition_penalty=gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Strafe für wiederholte Tokens", visible=False) | |
| anzahl_docs = gr.Slider(label="Anzahl Dokumente", value=3, minimum=1, maximum=10, step=1, interactive=True, info="wie viele Dokumententeile aus dem Vektorstore an den prompt gehängt werden", visible=False) | |
| openai_key = gr.Textbox(label = "OpenAI API Key", value = "sk-", lines = 1, visible = False) | |
| ################################################ | |
| # Tab zum Zeichnen mit Stable Diffusion | |
| ################################################ | |
| with gr.Tab("LI Zeichnen"): | |
| with gr.Row(): | |
| #gr.HTML("LI Zeichnen mit KI") | |
| status_display2 = gr.Markdown("Success", visible = False, elem_id="status_display") | |
| #gr.Markdown(description2) | |
| with gr.Row(): | |
| with gr.Column(scale=5): | |
| with gr.Row(): | |
| chatbot_bild = gr.Chatbot(elem_id="li-zeichnen",show_copy_button=True, show_share_button=True) | |
| with gr.Row(): | |
| with gr.Column(scale=12): | |
| user_input2 = gr.Textbox( | |
| show_label=False, placeholder="Gib hier deinen Prompt ein...", | |
| container=False | |
| ) | |
| with gr.Column(min_width=70, scale=1): | |
| submitBtn2 = gr.Button("Senden") | |
| #with gr.Column(min_width=70, scale=1): | |
| #cancelBtn2 = gr.Button("Stop") | |
| with gr.Row(): | |
| emptyBtn2 = gr.ClearButton([user_input, chatbot_bild], value="🧹 Neue Session", scale=10) | |
| #additional_inputs_accordion = gr.Accordion(label="Weitere Eingaben...", open=False) | |
| with gr.Column(): | |
| with gr.Column(min_width=50, scale=1): | |
| with gr.Tab(label="Parameter Einstellung"): | |
| #gr.Markdown("# Parameters") | |
| model_option_zeichnen = gr.Radio(["Stable Diffusion","DallE"], label="Modellauswahl", value = "Stable Diffusion") | |
| gr.Markdown(description) | |
| ###################################### | |
| # Events und Übergabe Werte an Funktionen | |
| ####################################### | |
| ###################################### | |
| # Für Tab 1: Chatbot | |
| #Argumente für generate Funktion als Input | |
| predict_args = dict( | |
| fn=generate_auswahl, | |
| inputs=[ | |
| user_question, | |
| attached_file, | |
| attached_file_history, | |
| chatbot, | |
| history, | |
| rag_option, | |
| model_option, | |
| openai_key, | |
| anzahl_docs, | |
| top_p, | |
| temperature, | |
| max_length_tokens, | |
| max_context_length_tokens, | |
| repetition_penalty | |
| ], | |
| outputs=[chatbot, history, attached_file, attached_file_history, status_display], | |
| show_progress=True, | |
| ) | |
| reset_args = dict( | |
| fn=reset_textbox, inputs=[], outputs=[user_input, status_display] | |
| ) | |
| # Chatbot | |
| transfer_input_args = dict( | |
| fn=add_text, inputs=[chatbot, history, user_input, attached_file, attached_file_history], outputs=[chatbot, history, user_question, attached_file, attached_file_history, image_display , user_input], show_progress=True | |
| ) | |
| predict_event1 = user_input.submit(**transfer_input_args, queue=False,).then(**predict_args) | |
| predict_event2 = submitBtn.click(**transfer_input_args, queue=False,).then(**predict_args) | |
| predict_event3 = upload.upload(file_anzeigen, [upload], [image_display, image_display, attached_file] ) #.then(**predict_args) | |
| emptyBtn.click(clear_all, [history, uploaded_file_paths], [attached_file, image_display, uploaded_file_paths, history, file_download]) | |
| #Bild Anzeige neben dem Button wieder entfernen oder austauschen.. | |
| image_display.select(file_loeschen, [], [attached_file, image_display]) | |
| #download_button.click(fn=download_chats, inputs=chat_selector, outputs=[file_download]) | |
| #Berechnung oder Ausgabe anhalten (kann danach fortgesetzt werden) | |
| cancelBtn.click(cancel_outputing, [], [status_display], cancels=[predict_event1,predict_event2, predict_event3]) | |
| ###################################### | |
| # Für Tab 2: Zeichnen | |
| predict_args2 = dict( | |
| fn=generate_bild, | |
| inputs=[ | |
| user_question2, | |
| chatbot_bild, | |
| model_option_zeichnen, | |
| #additional_inputs, | |
| ], | |
| outputs=[chatbot_bild, status_display2], #[chatbot, history, status_display] | |
| show_progress=True, | |
| ) | |
| transfer_input_args2 = dict( | |
| fn=add_text2, inputs=[chatbot_bild, user_input2], outputs=[chatbot_bild, user_question2, user_input2], show_progress=True | |
| ) | |
| predict_event2_1 = user_input2.submit(**transfer_input_args2, queue=False,).then(**predict_args2) | |
| predict_event2_2 = submitBtn2.click(**transfer_input_args2, queue=False,).then(**predict_args2) | |
| #emptyBtn2.click(clear_all, [], [file_display, image_display]) | |
| #cancelBtn2.click( | |
| #cancels=[predict_event2_1,predict_event2_2 ] | |
| #) | |
| demo.title = "LI-ChatBot" | |
| demo.queue(default_concurrency_limit=15).launch(debug=True) | |