|
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 dotenv import load_dotenv, find_dotenv |
|
_ = load_dotenv(find_dotenv()) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
splittet = False |
|
|
|
db = None |
|
|
|
|
|
|
|
|
|
file_path_download = "" |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
MODEL_NAME= "gpt-4-1106-preview" |
|
MODEL_NAME_IMAGE = "gpt-4-vision-preview" |
|
MODEL_NAME_CODE = "code-davinci-002" |
|
|
|
|
|
|
|
|
|
|
|
repo_id = "HuggingFaceH4/zephyr-7b-alpha" |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
MODEL_NAME_HF = "mistralai/Mixtral-8x7B-Instruct-v0.1" |
|
MODEL_NAME_OAI_ZEICHNEN = "dall-e-3" |
|
|
|
|
|
API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1" |
|
|
|
API_URL_TEXT = "https://api-inference.huggingface.co/models/argilla/notux-8x7b-v1" |
|
|
|
|
|
|
|
|
|
os.environ["HUGGINGFACEHUB_API_TOKEN"] = HUGGINGFACEHUB_API_TOKEN |
|
|
|
|
|
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def clear_all(history, uploaded_file_paths, 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()) |
|
|
|
|
|
|
|
|
|
|
|
if chats != {} : |
|
id_neu = len(chats)+1 |
|
chats[id_neu]=summary |
|
else: |
|
chats[0]=summary |
|
|
|
|
|
headers, payload = process_chatverlauf(summary, MODEL_NAME, OAI_API_KEY) |
|
response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload) |
|
|
|
data = response.json() |
|
|
|
result = data['choices'][0]['message']['content'] |
|
worte = result.split() |
|
if len(worte) > 2: |
|
file_path_download = "data/" + str(len(chats)) + "_Chatverlauf" |
|
else: |
|
file_path_download = "data/" + str(len(chats)) + "_" + result |
|
with open(file_path_download, 'w') as file: |
|
|
|
file.write(summary) |
|
|
|
|
|
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, file_count="multiple", interactive = False), chats |
|
|
|
|
|
|
|
def clear_all3(history): |
|
|
|
uploaded_file_paths= "" |
|
return None, gr.Image(visible=False), [], |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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), "" |
|
|
|
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, "" |
|
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
def cancel_outputing(): |
|
reset_textbox() |
|
return "Stop Done" |
|
|
|
def reset_textbox(): |
|
return gr.update(value=""),"" |
|
|
|
|
|
|
|
|
|
def umwandeln_fuer_anzeige(image): |
|
buffer = io.BytesIO() |
|
image.save(buffer, format='PNG') |
|
return buffer.getvalue() |
|
|
|
|
|
|
|
|
|
|
|
def create_assistant_file(prompt, file): |
|
global client, general_assistant_file |
|
|
|
file_neu = client.files.create(file=open(file,"rb",),purpose="assistants",) |
|
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
def create_assistant_suche(prompt): |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def generate_auswahl(prompt_in, 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,top_k=35): |
|
global splittet, db |
|
|
|
|
|
|
|
neu_file = file_history |
|
|
|
|
|
prompt = normalise_prompt(prompt_in) |
|
|
|
if (rag_option == "An"): |
|
|
|
if not splittet: |
|
splits = document_loading_splitting() |
|
document_storage_chroma(splits) |
|
db = document_retrieval_chroma2() |
|
splittet = True |
|
|
|
|
|
|
|
|
|
|
|
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, top_k=35) |
|
history = history + [[prompt, result]] |
|
else: |
|
|
|
|
|
if (file != None): |
|
|
|
neu_file = file |
|
|
|
|
|
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) |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
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..............................") |
|
|
|
data = {"inputs": prompt} |
|
response = requests.post(API_URL, headers=HEADERS, json=data) |
|
print("fertig Bild") |
|
result = response.content |
|
|
|
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..............................") |
|
|
|
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(response.data[0].b64_json) |
|
|
|
return chatbot, "Antwort KI: Success" |
|
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
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) |
|
|
|
data = response.json() |
|
|
|
result = data['choices'][0]['message']['content'] |
|
return result |
|
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
prompt_neu = generate_prompt_with_history(neu_text_mit_chunks, history) |
|
|
|
result = create_assistant_file(prompt_neu, file) |
|
return result |
|
|
|
|
|
|
|
|
|
|
|
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, top_k=35): |
|
global splittet |
|
suche_im_Netz="Antwort der KI ..." |
|
print("Text pur..............................") |
|
if (openai_api_key == "" or openai_api_key == "sk-"): |
|
|
|
|
|
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.") |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
try: |
|
|
|
|
|
|
|
if (model_option == "OpenAI"): |
|
|
|
print("OpenAI Anfrage.......................") |
|
llm = ChatOpenAI(model_name = MODEL_NAME, openai_api_key = openai_api_key, temperature=temperature) |
|
|
|
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: |
|
|
|
print("HF Anfrage.......................") |
|
model_kwargs={"temperature": 0.5, "max_length": 512, "num_return_sequences": 1, "top_k": top_k, "top_p": top_p, "repetition_penalty": repetition_penalty} |
|
llm = HuggingFaceHub(repo_id=repo_id, model_kwargs=model_kwargs) |
|
|
|
|
|
|
|
|
|
print("HF") |
|
|
|
history_text_und_prompt = generate_prompt_with_history(prompt, history) |
|
|
|
|
|
if (rag_option == "An"): |
|
print("LLM aufrufen mit RAG: ...........") |
|
result = rag_chain(llm, history_text_und_prompt, db) |
|
|
|
|
|
|
|
|
|
|
|
else: |
|
|
|
print("LLM aufrufen ohne RAG: ...........") |
|
resulti = llm_chain(llm, history_text_und_prompt) |
|
result = resulti.strip() |
|
""" |
|
#Alternativ mit API_URL - aber das model braucht 93 B Space!!! |
|
data = {"inputs": prompt, "options": {"max_new_tokens": max_new_tokens},} |
|
response = requests.post(API_URL_TEXT, headers=HEADERS, json=data) |
|
result = response.json() |
|
print("responseresult.............................") |
|
print(result) |
|
chatbot_response = result[0]['generated_text'] |
|
print("anzahl tokens gesamt antwort:------------------") |
|
print (len(chatbot_response.split())) |
|
chatbot_message = chatbot_response[len(prompt):].strip() |
|
print("history/chatbot_rsponse:--------------------------------") |
|
print(history) |
|
print(chatbot_message) |
|
result = chatbot_message |
|
""" |
|
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
|
def generate_code(prompt_in, file, chatbot, history, 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,top_k=35): |
|
|
|
prompt = normalise_prompt(prompt_in) |
|
|
|
|
|
status = "Antwort der KI ..." |
|
if (file == None and file_history == None): |
|
result, status = generate_code_antwort(prompt, chatbot, history, 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, top_k=35) |
|
history = history + [[prompt, result]] |
|
else: |
|
|
|
|
|
if (file != None): |
|
|
|
neu_file = file |
|
|
|
|
|
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) |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
def generate_code_antwort (prompt, chatbot, history, 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, top_k=35): |
|
suche_im_Netz="Antwort der KI ..." |
|
print("Text pur..............................") |
|
if (openai_api_key == "" or openai_api_key == "sk-"): |
|
|
|
|
|
openai_api_key= OAI_API_KEY |
|
if (prompt == ""): |
|
raise gr.Error("Prompt ist erforderlich.") |
|
|
|
|
|
try: |
|
|
|
|
|
|
|
if (model_option == "Davinci"): |
|
|
|
print("OpenAI Anfrage.......................") |
|
llm = ChatOpenAI(model_name = MODEL_NAME_CODE, openai_api_key = openai_api_key, temperature=temperature) |
|
|
|
history_text_und_prompt = generate_prompt_with_history_openai(prompt, history) |
|
|
|
print("LLM aufrufen ohne RAG: ...........") |
|
resulti = llm_chain(llm, history_text_und_prompt) |
|
result = resulti.strip() |
|
except Exception as e: |
|
raise gr.Error(e) |
|
|
|
return result, suche_im_Netz |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def vote(data: gr.LikeData): |
|
if data.liked: print("You upvoted this response: " + data.value) |
|
else: print("You downvoted this response: " + data.value) |
|
|
|
def custom_css(): |
|
return """ |
|
body, html { |
|
background-color: #303030; /* Dunkler Hintergrund */ |
|
color:#353535; |
|
} |
|
""" |
|
|
|
print ("Start GUIneu") |
|
with open("custom.css", "r", encoding="utf-8") as f: |
|
customCSS = f.read() |
|
|
|
|
|
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=custom_css(), theme=themeAlex) as demo: |
|
|
|
|
|
|
|
history = gr.State([]) |
|
uploaded_file_paths= gr.State([]) |
|
history3 = gr.State([]) |
|
uploaded_file_paths3= gr.State([]) |
|
|
|
chats = gr.State({}) |
|
|
|
user_question = gr.State("") |
|
|
|
|
|
user_question2 = gr.State("") |
|
user_question3 = gr.State("") |
|
attached_file = gr.State(None) |
|
attached_file_history = gr.State(None) |
|
attached_file3 = gr.State(None) |
|
status_display = gr.State("") |
|
status_display2 = gr.State("") |
|
status_display3 = gr.State("") |
|
|
|
|
|
|
|
gr.Markdown(description_top) |
|
with gr.Tab("LI Chatbot"): |
|
with gr.Row(): |
|
|
|
status_display = gr.Markdown("Antwort der KI ...", visible = True) |
|
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(): |
|
|
|
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 ..."): |
|
|
|
|
|
|
|
file_download = gr.File(label="Noch keine Chatsverläufe", visible=True, interactive = False, file_count="multiple",) |
|
|
|
with gr.Tab(label="Parameter"): |
|
|
|
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, |
|
) |
|
top_k = gr.Slider( |
|
minimum=1, |
|
maximum=100, |
|
value=35, |
|
step=1, |
|
interactive=True, |
|
label="Top-k", |
|
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) |
|
|
|
|
|
|
|
|
|
|
|
with gr.Tab("LI Zeichnen"): |
|
with gr.Row(): |
|
gr.HTML("Lass den KI-Bot deine Ideen zeichnen...") |
|
status_display2 = gr.Markdown("Success", visible = False, elem_id="status_display") |
|
|
|
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.Row(): |
|
emptyBtn2 = gr.ClearButton([user_input, chatbot_bild], value="🧹 Neue Session", scale=10) |
|
|
|
with gr.Column(): |
|
with gr.Column(min_width=50, scale=1): |
|
with gr.Tab(label="Parameter Einstellung"): |
|
|
|
model_option_zeichnen = gr.Radio(["Stable Diffusion","DallE"], label="Modellauswahl", value = "Stable Diffusion") |
|
|
|
|
|
with gr.Tab("LI Codebot"): |
|
with gr.Row(): |
|
gr.HTML("Gib als textuelle Beschreibung ein, was in Programmcode übersetzt werden soll und in welcher Sprache...") |
|
status_display3 = gr.Markdown("Success", visible = False, elem_id="status_display") |
|
|
|
with gr.Row(): |
|
with gr.Column(scale=5): |
|
with gr.Row(): |
|
chatbot_code = gr.Chatbot(elem_id="li-zeichnen",show_copy_button=True, show_share_button=True) |
|
with gr.Row(): |
|
with gr.Column(scale=12): |
|
user_input3 = gr.Textbox( |
|
show_label=False, placeholder="Gib hier deinen Prompt ein...", |
|
container=False |
|
) |
|
with gr.Column(min_width=70, scale=1): |
|
submitBtn3 = gr.Button("Senden") |
|
with gr.Column(min_width=70, scale=1): |
|
cancelBtn3 = gr.Button("Stop") |
|
with gr.Row(): |
|
|
|
image_display3 = gr.Image( visible=False) |
|
upload3 = gr.UploadButton("📁", file_types=["image", "pdf", "docx", "pptx", "xlsx"], scale = 10) |
|
emptyBtn3 = gr.ClearButton([user_input3, chatbot_code, history3, attached_file3, image_display3], value="🧹 Neue Session", scale=10) |
|
with gr.Column(): |
|
with gr.Column(min_width=50, scale=1): |
|
with gr.Tab(label="Parameter Einstellung"): |
|
|
|
model_option_code3 = gr.Radio(["Davinci","kommt noch"], label="Modellauswahl", value = "Davinci") |
|
|
|
|
|
|
|
|
|
gr.Markdown(description) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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, |
|
top_k |
|
], |
|
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] |
|
) |
|
|
|
|
|
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] ) |
|
emptyBtn.click(clear_all, [history, uploaded_file_paths, chats], [attached_file, image_display, uploaded_file_paths, history, file_download, chats]) |
|
|
|
image_display.select(file_loeschen, [], [attached_file, image_display]) |
|
|
|
|
|
|
|
|
|
cancelBtn.click(cancel_outputing, [], [status_display], cancels=[predict_event1,predict_event2, predict_event3]) |
|
|
|
|
|
|
|
predict_args2 = dict( |
|
fn=generate_bild, |
|
inputs=[ |
|
user_question2, |
|
chatbot_bild, |
|
model_option_zeichnen, |
|
|
|
], |
|
outputs=[chatbot_bild, status_display2], |
|
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) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
predict_args3 = dict( |
|
fn=generate_code, |
|
inputs=[ |
|
user_question3, |
|
attached_file3, |
|
chatbot_code, |
|
history3, |
|
model_option, |
|
openai_key, |
|
top_p, |
|
temperature, |
|
max_length_tokens, |
|
max_context_length_tokens, |
|
repetition_penalty, |
|
top_k |
|
], |
|
outputs=[chatbot_code, history3, attached_file3, status_display3], |
|
show_progress=True, |
|
) |
|
|
|
|
|
reset_args3 = dict( |
|
fn=reset_textbox, inputs=[], outputs=[user_input3, status_display3] |
|
) |
|
|
|
|
|
transfer_input_args3 = dict( |
|
fn=add_text, inputs=[chatbot_code, history3, user_input3, attached_file3], outputs=[chatbot_code, history3, user_question3, attached_file3, image_display3, user_input3], show_progress=True |
|
) |
|
|
|
predict_event3_1 = user_input3.submit(**transfer_input_args3, queue=False,).then(**predict_args3) |
|
predict_event3_2 = submitBtn3.click(**transfer_input_args3, queue=False,).then(**predict_args3) |
|
predict_event3_3 = upload3.upload(file_anzeigen, [upload3], [image_display3, image_display3, attached_file3] ) |
|
emptyBtn3.click(clear_all3, [history3], [attached_file3, image_display3, history3]) |
|
|
|
image_display3.select(file_loeschen, [], [attached_file3, image_display3]) |
|
|
|
|
|
|
|
|
|
demo.title = "LI-ChatBot" |
|
demo.queue(default_concurrency_limit=15).launch(debug=True) |
|
|
|
|
|
|
|
|
|
|
|
|