date_collected
stringclasses 1
value | repo_name
stringlengths 6
116
| file_name
stringlengths 2
220
| file_contents
stringlengths 13
357k
| prompts
sequence |
|---|---|---|---|---|
2024-01-10 | Mishra-Manit/DataAgent | dsassistant.py | import openai
import APIKEY
import io
import sys
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
openai.api_key = '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'
#Replace this with the actual file path
filePath = 'Toy Datasets/Large/Real Estate/New Real Estate.csv'
datasetcsv = pd.read_csv(filePath)
#Replace this with the question
actualQuestion = 'How many columns are in the dataset '
allContext = {
#"datasetcsv.head()" : datasetcsv.head(),
#"datasetcsv.describe()" : datasetcsv.describe(),
"file path of dataset": filePath
}
textContext = ''
for key, value in allContext.items():
textContext += f'{key}: {value}\n'
#print(textContext)
# Define the system message
system_msg = 'You are an assistant that is a data scientist. Your objective is to execute given tasks with utmost accuracy and precision. Avoid providing unnecessary explanations and focus solely on delivering the exact results or outputs requested. Only give answers and do not provide supplementary information unless specifically asked to do so. Make sure to always make variables if you are going to call them later!'
#This first message asks for code to get any information from the dataset for this project
user_msg1 = '''
For the question going to be asked of you, only answer with the code needed access the information from the dataset needed to answer the question at hand.
Here is some background information about the dataset: {}
DO NOT REQUEST LARGE AMOUNTS OF DATA SUCH AS THE WHOLE COLUMN.
You will only respond with the python code that can be directly run inside of an IDE, with no extra explanation. Write the code to access specific information about the dataset, since the dataset is not provided to you. Only write question that should access preliminary information from the dataset that is needed to solve the question asked.
Use a print statement to display the information.
The variable where the dataset is stored is named datasetcsv
DO NOT ANSWER THE QUESTION IN ANY CAPACITY.
IMPORTANT: For this step, you can only get text information, no graphs or plots can be created. Make sure you only generate information that is in text format. For example, you can not write code to generate a graph here.
Example Question and Answer:
Question: "Make a barplot displaying different columns"
Answer: print(datasetcsv.columns)
Real Question: {} but do not write code to generate the answer'
'''.format(textContext, actualQuestion)
response1 = openai.ChatCompletion.create(model="gpt-3.5-turbo",
messages=[{"role": "system", "content": system_msg},
{"role": "user", "content": user_msg1}],
temperature=0.00,
max_tokens=2048,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
answer1 = response1["choices"][0]["message"]["content"]
print("answer1: " + answer1)
backup = sys.stdout
sys.stdout = io.StringIO()
#Below is what actually executes
exec(answer1)
# Get the printed value and store it
output = sys.stdout.getvalue()
# Restore stdout
sys.stdout = backup
output1 = output.strip()
print(f'this is what GPT wanted as context: "{output.strip()}"')
#Updating the context dictionary
allContext[answer1] = output1
#Remake the textContext variable with the new addition
textContext = ''
for key, value in allContext.items():
textContext += f'{key}: {value}\n'
#This step generates the list of action items to be completed
user_msg2 = '''
For the question going to be asked of you, only answer with a list of steps needed to execute in order to find the final answer. DO NOT give the final answer, instead, in a array format, give a list of steps needed to arrive at the answer. After generating these steps, review them and make sure they are correct.
Here is some background information about the dataset: {}
The output generated will be turned into an array, so ensure that correct array syntax is made. There should be no extra characters, just the array.
In a previous prompt, some preliminary context about the dataset was generated, it is in the dictionary text above.
In your generate an array of steps and write your answer giving the steps such as this EXAMPLE:
Example Question: "what is the number of columns and largest data value out of these columns"
ExampleGPTAnswer: ["Load the dataset from the file "boston.csv", "Get the number of columns in the dataset.", "Find the largest data value in each column.", "Identify the column with the largest data value.", "Determine the largest data value."]
Real Question: {}
'''.format(textContext, actualQuestion)
response2 = openai.ChatCompletion.create(model="gpt-3.5-turbo",
messages=[{"role": "system", "content": system_msg},
#make sure to change the user_msg variable
{"role": "user", "content": user_msg2}],
temperature=0.00,
max_tokens=2048,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
answer2 = response2["choices"][0]["message"]["content"]
print("This is answer two: " + answer2)
#this changes from text to a list
answer2 = eval(answer2)
print("Array of steps: " + str(answer2))
#Updating the context dictionary
allContext["array of steps"] = answer2
textContext = ''
for key, value in allContext.items():
textContext += f'{key}: {value}\n'
#Variable defined to store previous context
previousAnswer = "This is the previous question: "+ str(answer1) + ", and this is the output that was generated: " + str(output1)
for i in range(len(answer2)):
if i < len(answer2):
textContext = ''
for key, value in allContext.items():
textContext += f'{key}: {value}\n'
#I have already imported the correct libraries and datasets. Do not import and libraries.
user_msg3 = '''
In order to answer a larger question, there are a series of smaller steps generated. Each step will be completed and then the result will be calculated in the last step.
You will only respond with the python code that can be directly run inside of an IDE, with no extra explanation.Use a print statement to display the information.
Here is some information after running some commands on the dataset: {}
DO NOT ANSWER THE QUESTION IN ANY CAPACITY until the last step in the array. The loop is currently on this number step {}, out of {} total steps.
Make sure not to use .plot for any of the steps.
Example Question and Answer:
Q: "what are the name of the columns in the dataset"
A: print(boston.head())
In a previous prompt, some preliminary context about the dataset was generated. This was the previous code and output: {}
The file is titled "boston.csv"
Because these steps are not the last steps, make sure not to use .plot() in any of the steps. Furthermore, don't repeat steps such as opening the dataset or checking the name of the columns.
IMPORTANT: Only write code steps and no english language as the writing is being executed.
Instruction: {}'
'''.format(textContext, i+1, len(answer2), previousAnswer, answer2[i])
response3 = openai.ChatCompletion.create(model="gpt-3.5-turbo",
messages=[{"role": "system", "content": system_msg},
{"role": "user", "content": user_msg3}],
temperature=0.00,
max_tokens=2048,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
answer3 = response3["choices"][0]["message"]["content"]
#print(answer3)
print("answer3: " + answer3)
# Backup of stdout
backup = sys.stdout
# Create a string IO buffer
sys.stdout = io.StringIO()
# Execute the code
exec(answer3)
# Get the printed value and store it
output = sys.stdout.getvalue()
# Restore stdout
sys.stdout = backup
output4 = output.strip()
#Updating the context dictionary
allContext[answer2[i]] = output4
previousAnswer = "This is the previous question: "+ str(answer3) + ", and this is the output that was generated: " + str(output4)
textContext = ''
for key, value in allContext.items():
textContext += f'{key}: {value}\n'
if (i+1) == len(answer2):
user_msg4 = '''
Here is some information after running some commands on the dataset: {}.
This is the last step. step {}, this was the previous instruction and output: {}. You are to only write the code for this last step, which upon executing will give the answer to our originial question: {}. Make sure that you only write the code, and display the ANSWER WITH A PRINT statement for numerical outputs. DO NOT use print statements when plotting graphs with matplotlib.
Do not provide additional instructions as the code generated will be executed in an IDE.
Example of a few instructions and answers:
Q: Display the heatmap.
A: sns.heatmap(datasetcsv.corr())
plt.show()
Print Statement Example:
Q: Calculate the correlation between the 'zn' and 'crim' columns.
A: print(datasetcsv['zn'].corr(datasetcsv['crim']))
IMPORTANT: DO USE print statements when displaying final answers which are not graphs
DO NOT use print statements when plotting graphs with matplotlib.
This is the final instruction: {}.
IMPORTANT: When the final answer is a graph or a plot, MAKE SURE TO USE plt.show() function to display the final answer.
IMPORTANT: Use a print statement on the final answer for all other answers!
'''.format(textContext, len(answer2), previousAnswer, actualQuestion, answer2[i])
response4 = openai.ChatCompletion.create(model="gpt-3.5-turbo",
messages=[{"role": "system", "content": system_msg},
{"role": "user", "content": user_msg4}],
temperature=0.00,
max_tokens=2048,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
answer4 = response4["choices"][0]["message"]["content"]
print("This is answer 5: " + answer4)
backup = sys.stdout
sys.stdout = io.StringIO()
#make sure to change the following line of code with the right answer choice
exec(answer4)
output5 = sys.stdout.getvalue()
sys.stdout = backup
output5 = output5.strip()
print(output5)
print("Final Answer given by GPT: ", output5)
| [] |
2024-01-10 | informaticacba/Assistant-Personal-JARVIS | jarvis.py | import pyttsx3
import wikipedia
import speech_recognition as sr
import webbrowser
import datetime
import os
import getpass
import cv2
import sys
import smtplib
import whisper
import mediapipe
import openai
import yolov5
from news import speak_news, getNewsUrl
from OCR import OCR
from diction import translate
from helpers import *
from youtube import youtube
from sys import platform
engine = pyttsx3.init()
voices = engine.getProperty('voices')
engine.setProperty('voice', voices[0].id)
# print(voices[0].id)
class Jarvis:
def __init__(self) -> None:
if platform == "linux" or platform == "linux2":
self.chrome_path = '/usr/bin/google-chrome'
elif platform == "darwin":
self.chrome_path = 'open -a /Applications/Google\ Chrome.app'
elif platform == "win32":
self.chrome_path = 'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe'
else:
print('Unsupported OS')
exit(1)
webbrowser.register(
'chrome', None, webbrowser.BackgroundBrowser(self.chrome_path)
)
def wishMe(self) -> None:
hour = int(datetime.datetime.now().hour)
if hour >= 0 and hour < 12:
speak("Good Morning")
elif hour >= 12 and hour < 18:
speak("Good Afternoon")
else:
speak("Good Evening")
weather()
speak('I am JARVIS. Please tell me how can I help you?')
def sendEmail(self, to, content) -> None:
server = smtplib.SMTP('smtp.gmail.com', 587)
server.ehlo()
server.starttls()
server.login('email', 'password')
server.sendmail('email', to, content)
server.close()
def execute_query(self, query):
# TODO: make this more concise
if 'wikipedia' in query:
speak('Searching Wikipedia....')
query = query.replace('wikipedia', '')
results = wikipedia.summary(query, sentences=2)
speak('According to Wikipedia')
print(results)
speak(results)
elif 'youtube downloader' in query:
exec(open('youtube_downloader.py').read())
elif 'voice' in query:
if 'female' in query:
engine.setProperty('voice', voices[1].id)
else:
engine.setProperty('voice', voices[0].id)
speak("Hello, I have switched my voice. How is it?")
if 'jarvis are you there' in query:
speak("Yes, at your service")
if 'jarvis who made you' in query:
speak("Yes, my master build me in AI")
elif 'open google' in query:
webbrowser.get('chrome').open_new_tab('https://www.google.com')
elif 'search in google' in query:
webbrowser.get('chrome').open_new_tab('https://www.google.com?q=')
elif 'open stackoverflow' in query:
webbrowser.get('chrome').open_new_tab('https://www.stackoverflow.com')
elif 'open youtube' in query:
webbrowser.get('chrome').open_new_tab('https://www.youtube.com')
elif 'search youtube' in query:
webbrowser.get('chrome').open_new_tab('https://www.youtube.com?q=')
elif 'open amazon' in query:
webbrowser.get('chrome').open_new_tab('https://amazon.com')
elif 'cpu' in query:
cpu()
elif 'joke' in query:
joke()
elif 'screenshot' in query:
speak("taking screenshot")
screenshot()
elif 'play music' in query:
musica=input("Ingrese la musica: ")
os.startfile(musica)
elif 'search youtube' in query:
speak('What you want to search on Youtube?')
webbrowser.get('chrome').open_new_tab('https://youtube.com?q=')
youtube(takeCommand())
elif 'the time' in query:
strTime = datetime.datetime.now().strftime("%H:%M:%S")
speak(f'Sir, the time is {strTime}')
elif 'search' in query:
speak('What do you want to search for?')
search = takeCommand()
url = 'https://google.com/search?q=' + search
webbrowser.get('chrome').open_new_tab(
url)
speak('Here is What I found for' + search)
elif 'location' in query:
speak('What is the location?')
location = takeCommand()
url = 'https://google.nl/maps/place/' + location + '/&'
webbrowser.get('chrome').open_new_tab(url)
speak('Here is the location ' + location)
elif 'your master' in query:
if platform == "win32" or "darwin":
speak('Gaurav is my master. He created me couple of days ago')
elif platform == "linux" or platform == "linux2":
name = getpass.getuser()
speak(name, 'is my master. He is running me right now')
elif 'your name' in query:
speak('My name is JARVIS')
elif 'who made you' in query:
speak('I was created by my AI master in 2021')
elif 'stands for' in query:
speak('J.A.R.V.I.S stands for JUST A RATHER VERY INTELLIGENT SYSTEM')
elif 'open code' in query:
if platform == "win32":
os.startfile(
"C:\\Users\\gs935\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe")
elif platform == "linux" or platform == "linux2" or "darwin":
os.system('code .')
elif 'shutdown' in query:
if platform == "win32":
os.system('shutdown /p /f')
elif platform == "linux" or platform == "linux2" or "darwin":
os.system('poweroff')
elif 'cpu' in query:
cpu()
elif 'your friend' in query:
speak('My friends are Google assisstant alexa and siri')
elif 'joke' in query:
joke()
elif 'screenshot' in query:
speak("taking screenshot")
screenshot()
elif 'github' in query:
webbrowser.get('chrome').open_new_tab(
'https://github.com/gauravsingh9356')
elif 'remember that' in query:
speak("what should i remember sir")
rememberMessage = takeCommand()
speak("you said me to remember"+rememberMessage)
remember = open('data.txt', 'w')
remember.write(rememberMessage)
remember.close()
elif 'do you remember anything' in query:
remember = open('data.txt', 'r')
speak("you said me to remember that" + remember.read())
elif 'sleep' in query:
sys.exit()
elif 'dictionary' in query:
speak('What you want to search in your intelligent dictionary?')
translate(takeCommand())
elif 'news' in query:
speak('Ofcourse ..')
speak_news()
speak('Do you want to read the full news...')
test = takeCommand()
if 'yes' in test:
speak('Ok Sir, Opening browser...')
webbrowser.open(getNewsUrl())
speak('You can now read the full news from this website.')
else:
speak('No Problem')
elif 'voice' in query:
if 'female' in query:
engine.setProperty('voice', voices[0].id)
else:
engine.setProperty('voice', voices[1].id)
speak("Hello, I have switched my voice. How is it?")
elif 'email to gaurav' in query:
try:
speak('What should I say?')
content = takeCommand()
to = 'email'
self.sendEmail(to, content)
speak('Email has been sent!')
except Exception as e:
speak('Sorry sir, Not able to send email at the moment')
def wakeUpJARVIS():
bot_ = Jarvis()
bot_.wishMe()
while True:
query = takeCommand().lower()
bot_.execute_query(query)
if __name__ == '__main__':
recognizer = cv2.face.LBPHFaceRecognizer_create() # Local Binary Patterns Histograms
recognizer.read('./Face-Recognition/trainer/trainer.yml') #load trained model
cascadePath = "./Face-Recognition/haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath) #initializing haar cascade for object detection approach
font = cv2.FONT_HERSHEY_SIMPLEX #denotes the font type
id = 2 #number of persons you want to Recognize
names = ['','Gaurav'] #names, leave first empty bcz counter starts from 0
cam = cv2.VideoCapture(0, cv2.CAP_DSHOW) #cv2.CAP_DSHOW to remove warning
cam.set(3, 640) # set video FrameWidht
cam.set(4, 480) # set video FrameHeight
# Define min window size to be recognized as a face
minW = 0.1*cam.get(3)
minH = 0.1*cam.get(4)
# flag = True
while True:
ret, img =cam.read() #read the frames using the above created object
converted_image = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #The function converts an input image from one color space to another
faces = faceCascade.detectMultiScale(
converted_image,
scaleFactor = 1.2,
minNeighbors = 5,
minSize = (int(minW), int(minH)),
)
for(x,y,w,h) in faces:
cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2) #used to draw a rectangle on any image
id, accuracy = recognizer.predict(converted_image[y:y+h,x:x+w]) #to predict on every single image
# Check if accuracy is less them 100 ==> "0" is perfect match
if (accuracy < 100):
# Do a bit of cleanup
speak("Optical Face Recognition Done. Welcome")
cam.release()
cv2.destroyAllWindows()
wakeUpJARVIS()
else:
speak("Optical Face Recognition Failed")
break;
| [] |
2024-01-10 | joshuasundance-swca/pyteam | pyteam~fleet_retrievers.py | from __future__ import annotations
import re
import warnings
from typing import Optional
import pandas as pd
from context import download_embeddings
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.schema.document import Document
from langchain.schema.storage import BaseStore
from langchain.storage.in_memory import InMemoryStore
from langchain.vectorstores.faiss import FAISS
class MultiVectorFleetRetriever(MultiVectorRetriever):
"""A class to create retrievers from `fleet-context` embeddings."""
@staticmethod
def _prep_df(df: pd.DataFrame, library_name: str):
def _join_metadata(_df: pd.DataFrame):
return _df.join(
_df["metadata"].apply(pd.Series),
lsuffix="_orig",
rsuffix="_md",
)
return df.assign(
metadata=lambda _df: _df.metadata.apply(
lambda md: {**md, "library_name": library_name},
),
).pipe(_join_metadata)
@staticmethod
def _get_vectorstore(joined_df: pd.DataFrame, **kwargs) -> FAISS:
"""Get FAISS vectorstore from joined df."""
return FAISS.from_embeddings(
joined_df[["text", "dense_embeddings"]].values,
OpenAIEmbeddings(model="text-embedding-ada-002"),
metadatas=joined_df["metadata"].tolist(),
**kwargs,
)
@staticmethod
def _df_to_parent_docs(joined_df: pd.DataFrame, sep: str = "\n") -> list[Document]:
return (
joined_df[["parent", "title", "text", "type", "url", "section_index"]]
.rename(columns={"parent": "id"})
.sort_values(["id", "section_index"])
.groupby("id")
.apply(
lambda chunk: Document(
page_content=chunk.iloc[0]["title"]
+ "\n"
+ chunk["text"].str.cat(sep=sep),
metadata=chunk.iloc[0][["title", "type", "url", "id"]].to_dict(),
),
)
.tolist()
)
def __init__(
self,
df: pd.DataFrame,
library_name: str,
docstore: Optional[BaseStore] = None,
parent_doc_sep: str = "\n",
vectorstore_kwargs: Optional[dict] = None,
**kwargs,
):
joined_df = self._prep_df(df, library_name)
parent_docs = self._df_to_parent_docs(joined_df, sep=parent_doc_sep)
vectorstore_kwargs = vectorstore_kwargs or {}
vectorstore = self._get_vectorstore(joined_df, **vectorstore_kwargs)
docstore = docstore or InMemoryStore()
docstore.mset([(doc.metadata["id"], doc) for doc in parent_docs])
super().__init__(
vectorstore=vectorstore,
docstore=docstore,
id_key="parent",
**kwargs,
)
@classmethod
def from_df(
cls,
df: pd.DataFrame,
library_name: str,
**kwargs,
) -> MultiVectorFleetRetriever:
"""Create MultiVectorFleetRetriever from df."""
return cls(df, library_name=library_name, **kwargs)
@classmethod
def from_library(
cls,
library_name: str,
download_kwargs: Optional[dict] = None,
**kwargs,
) -> MultiVectorFleetRetriever:
"""Create MultiVectorFleetRetriever from library_name."""
download_kwargs = download_kwargs or {}
try:
library_df = download_embeddings(library_name, **download_kwargs)
except TypeError:
if download_kwargs:
warnings.warn(
"`download_kwargs` not yet implemented in `context`; ignoring.",
)
library_df = download_embeddings(library_name)
return cls(library_df, library_name=library_name, **kwargs)
@staticmethod
def get_library_name_from_filename(filename: str) -> str:
filename_pat = re.compile("libraries_(.*).parquet")
search_result = filename_pat.search(filename)
if search_result is None:
raise ValueError(
f"filename {filename} does not match pattern {filename_pat}",
)
return search_result.group(1)
@classmethod
def from_parquet(cls, filename: str, **kwargs) -> MultiVectorFleetRetriever:
"""Create MultiVectorFleetRetriever from parquet filename."""
library_name = cls.get_library_name_from_filename(filename)
return cls(pd.read_parquet(filename), library_name=library_name, **kwargs)
| [] |
2024-01-10 | joshuasundance-swca/pyteam | pyteam~fleet_specialists.py | from __future__ import annotations
from typing import Optional
import pandas as pd
from langchain.agents import AgentType, initialize_agent
from langchain.agents import Tool
from langchain.chains import RetrievalQA
from langchain.llms.base import BaseLLM
from langchain.memory import ConversationBufferMemory
from langchain.prompts import MessagesPlaceholder
from langchain.schema.document import Document
from langchain.schema.runnable import Runnable
from pyteam.fleet_retrievers import MultiVectorFleetRetriever
class FleetBackedSpecialist:
library_name: str
retriever: MultiVectorFleetRetriever
# prompt: ChatPromptTemplate
llm: BaseLLM
memory: ConversationBufferMemory
qa_chain: RetrievalQA
specialist: Runnable
# _system_message_template = (
# "You are a great software engineer who is very familiar with Python. "
# "Given a user question or request about a new Python library "
# "called `{library}` and parts of the `{library}` documentation, "
# "answer the question or generate the requested code. "
# "Your answers must be accurate, should include code whenever possible, "
# "and should not assume anything about `{library}` which is not "
# "explicitly stated in the `{library}` documentation. "
# "If the required information is not available, just say so.\n\n"
# "`{library}` Documentation\n"
# "------------------\n\n"
# "{context}"
# )
#
# _prompt_template = ChatPromptTemplate.from_messages(
# [
# ("system", _system_message_template),
# ("human", "{question}"),
# ],
# )
@staticmethod
def _join_docs(docs: list[Document], sep: str = "\n\n") -> str:
return sep.join(d.page_content for d in docs)
def __init__(
self,
library_name: str,
retriever: MultiVectorFleetRetriever,
llm: BaseLLM,
memory: Optional[ConversationBufferMemory] = None,
):
self.memory = memory or ConversationBufferMemory()
self.llm = llm
self.retriever = retriever
# self.prompt = self._prompt_template.partial(
# library=library_name,
# )
self.qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=self.retriever,
)
self.specialist = initialize_agent(
[
Tool(
name=f"{library_name} QA System",
func=self.qa_chain.run,
description=f"Useful for when you need to answer questions about "
f"the {library_name} library. Input should be a fully formed question.",
),
],
llm,
agent_kwargs={
"extra_prompt_messages": [
MessagesPlaceholder(variable_name="memory"),
],
},
memory=self.memory,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
)
@classmethod
def from_df(
cls,
df: pd.DataFrame,
library_name: str,
llm: BaseLLM,
**kwargs,
) -> FleetBackedSpecialist:
retriever = MultiVectorFleetRetriever.from_df(
df,
library_name,
**kwargs,
)
return cls(library_name, retriever, llm)
@classmethod
def from_library(
cls,
library_name: str,
llm: BaseLLM,
download_kwargs: Optional[dict] = None,
**kwargs,
) -> FleetBackedSpecialist:
retriever = MultiVectorFleetRetriever.from_library(
library_name,
download_kwargs,
**kwargs,
)
return cls(library_name, retriever, llm)
@classmethod
def from_parquet(
cls,
parquet_path,
llm: BaseLLM,
**kwargs,
) -> FleetBackedSpecialist:
retriever = MultiVectorFleetRetriever.from_parquet(
parquet_path,
**kwargs,
)
library_name = MultiVectorFleetRetriever.get_library_name_from_filename(
parquet_path,
)
return cls(library_name, retriever, llm)
| [] |
2024-01-10 | woj-i/btgym | btgym~algorithms~worker.py | #
# Original A3C code comes from OpenAI repository under MIT licence:
# https://github.com/openai/universe-starter-agent
#
# Papers:
# https://arxiv.org/abs/1602.01783
# https://arxiv.org/abs/1611.05397
from logbook import Logger, StreamHandler
import sys
import os
import random
import multiprocessing
import datetime
import tensorflow as tf
sys.path.insert(0, '..')
tf.logging.set_verbosity(tf.logging.INFO)
class FastSaver(tf.train.Saver):
"""
Disables write_meta_graph argument,
which freezes entire process and is mostly useless.
"""
def save(
self,
sess,
save_path,
global_step=None,
latest_filename=None,
meta_graph_suffix="meta",
write_meta_graph=True,
write_state=True,
strip_default_attrs=False
):
super(FastSaver, self).save(
sess,
save_path,
global_step,
latest_filename,
meta_graph_suffix,
write_meta_graph=False,
)
class Worker(multiprocessing.Process):
"""
Distributed tf worker class.
Sets up environment, trainer and starts training process in supervised session.
"""
env_list = None
def __init__(self,
env_config,
policy_config,
trainer_config,
cluster_spec,
job_name,
task,
log_dir,
log_ckpt_subdir,
initial_ckpt_dir,
save_secs,
log_level,
max_env_steps,
random_seed=None,
render_last_env=True,
test_mode=False):
"""
Args:
env_config: environment class_config_dict.
policy_config: model policy estimator class_config_dict.
trainer_config: algorithm class_config_dict.
cluster_spec: tf.cluster specification.
job_name: worker or parameter server.
task: integer number, 0 is chief worker.
log_dir: path for tb summaries and current checkpoints.
log_ckpt_subdir: log_dir subdirectory to store current checkpoints
initial_ckpt_dir: path for checkpoint to load as pre-trained model.
save_secs: int, save model checkpoint every N secs.
log_level: int, logbook.level
max_env_steps: number of environment steps to run training on
random_seed: int or None
render_last_env: bool, if True and there is more than one environment specified for each worker,
only allows rendering for last environment in a list;
allows rendering for all environments of a chief worker otherwise;
test_mode: if True - use Atari mode, BTGym otherwise.
Note:
- Conventional `self.global_step` refers to number of environment steps,
summarized over all environment instances, not to number of policy optimizer train steps.
- Every worker can run several environments in parralell, as specified by `cluster_config'['num_envs'].
If use 4 forkers and num_envs=4 => total number of environments is 16. Every env instance has
it's own ThreadRunner process.
- When using replay memory, keep in mind that every ThreadRunner is keeping it's own replay memory,
If memory_size = 2000, num_workers=4, num_envs=4 => total replay memory size equals 32 000 frames.
"""
super(Worker, self).__init__()
self.env_class = env_config['class_ref']
self.env_kwargs = env_config['kwargs']
self.policy_config = policy_config
self.trainer_class = trainer_config['class_ref']
self.trainer_kwargs = trainer_config['kwargs']
self.cluster_spec = cluster_spec
self.job_name = job_name
self.task = task
self.is_chief = (self.task == 0)
self.log_dir = log_dir
self.save_secs = save_secs
self.max_env_steps = max_env_steps
self.log_level = log_level
self.log = None
self.test_mode = test_mode
self.random_seed = random_seed
self.render_last_env = render_last_env
# Saver and summaries path:
self.current_ckpt_dir = self.log_dir + log_ckpt_subdir
self.initial_ckpt_dir = initial_ckpt_dir
self.summary_dir = self.log_dir + '/worker_{}'.format(self.task)
# print(log_ckpt_subdir)
# print(self.log_dir)
# print(self.current_ckpt_dir)
# print(self.initial_ckpt_dir)
# print(self.summary_dir)
self.summary_writer = None
self.config = None
self.saver = None
def _restore_model_params(self, sess, save_path):
"""
Restores model parameters from specified location.
Args:
sess: tf.Session obj.
save_path: path where parameters were previously saved.
Returns: True if model has been successfully loaded, False otherwise.
"""
if save_path is None:
return False
assert self.saver is not None, 'FastSaver has not been configured.'
try:
# Look for valid checkpoint:
ckpt_state = tf.train.get_checkpoint_state(save_path)
if ckpt_state is not None and ckpt_state.model_checkpoint_path:
self.saver.restore(sess, ckpt_state.model_checkpoint_path)
else:
self.log.notice('no saved model parameters found in:\n{}'.format(save_path))
return False
except (ValueError, tf.errors.NotFoundError, tf.errors.InvalidArgumentError) as e:
self.log.notice('failed to restore model parameters from:\n{}'.format(save_path))
return False
return True
def _save_model_params(self, sess, global_step):
"""
Saves model checkpoint to predefined location.
Args:
sess: tf.Session obj.
global_step: global step number is appended to save_path to create the checkpoint filenames
"""
assert self.saver is not None, 'FastSaver has not been configured.'
self.saver.save(
sess,
save_path=self.current_ckpt_dir + '/model_parameters',
global_step=global_step
)
def run(self):
"""Worker runtime body.
"""
# Logging:
StreamHandler(sys.stdout).push_application()
self.log = Logger('Worker_{}'.format(self.task), level=self.log_level)
try:
tf.reset_default_graph()
if self.test_mode:
import gym
# Define cluster:
cluster = tf.train.ClusterSpec(self.cluster_spec).as_cluster_def()
# Start tf.server:
if self.job_name in 'ps':
server = tf.train.Server(
cluster,
job_name=self.job_name,
task_index=self.task,
config=tf.ConfigProto(device_filters=["/job:ps"])
)
self.log.debug('parameters_server started.')
# Just block here:
server.join()
else:
server = tf.train.Server(
cluster,
job_name='worker',
task_index=self.task,
config=tf.ConfigProto(
intra_op_parallelism_threads=4, # original was: 1
inter_op_parallelism_threads=4, # original was: 2
)
)
self.log.debug('tf.server started.')
self.log.debug('making environments:')
# Making as many environments as many entries in env_config `port` list:
# TODO: Hacky-II: only one example over all parallel environments can be data-master [and renderer]
# TODO: measure data_server lags, maybe launch several instances
self.env_list = []
env_kwargs = self.env_kwargs.copy()
env_kwargs['log_level'] = self.log_level
port_list = env_kwargs.pop('port')
data_port_list = env_kwargs.pop('data_port')
data_master = env_kwargs.pop('data_master')
render_enabled = env_kwargs.pop('render_enabled')
render_list = [False for entry in port_list]
if render_enabled:
if self.render_last_env:
render_list[-1] = True
else:
render_list = [True for entry in port_list]
# render_list[0] = True
data_master_list = [False for entry in port_list]
if data_master:
data_master_list[0] = True
# Parallel envs. numbering:
if len(port_list) > 1:
task_id = 0.0
else:
task_id = 0
for port, data_port, is_render, is_master in zip(port_list, data_port_list, render_list, data_master_list):
# Get random seed for environments:
env_kwargs['random_seed'] = random.randint(0, 2 ** 30)
if not self.test_mode:
# Assume BTgym env. class:
self.log.debug('setting env at port_{} is data_master: {}'.format(port, data_master))
self.log.debug('env_kwargs:')
for k, v in env_kwargs.items():
self.log.debug('{}: {}'.format(k, v))
try:
self.env_list.append(
self.env_class(
port=port,
data_port=data_port,
data_master=is_master,
render_enabled=is_render,
task=self.task + task_id,
**env_kwargs
)
)
data_master = False
self.log.info('set BTGym environment {} @ port:{}, data_port:{}'.
format(self.task + task_id, port, data_port))
task_id += 0.01
except Exception as e:
self.log.exception(
'failed to make BTGym environment at port_{}.'.format(port)
)
raise e
else:
# Assume atari testing:
try:
self.env_list.append(self.env_class(env_kwargs['gym_id']))
self.log.debug('set Gyn/Atari environment.')
except Exception as e:
self.log.exception('failed to make Gym/Atari environment')
raise e
self.log.debug('Defining trainer...')
# Define trainer:
trainer = self.trainer_class(
env=self.env_list,
task=self.task,
policy_config=self.policy_config,
log_level=self.log_level,
cluster_spec=self.cluster_spec,
random_seed=self.random_seed,
**self.trainer_kwargs,
)
self.log.debug('trainer ok.')
# Saver-related:
variables_to_save = [v for v in tf.global_variables() if not 'local' in v.name]
local_variables = [v for v in tf.global_variables() if 'local' in v.name] + tf.local_variables()
init_op = tf.initializers.variables(variables_to_save)
local_init_op = tf.initializers.variables(local_variables)
init_all_op = tf.global_variables_initializer()
def init_fn(_sess):
self.log.notice("initializing all parameters...")
_sess.run(init_all_op)
# def init_fn_scaff(scaffold, _sess):
# self.log.notice("initializing all parameters...")
# _sess.run(init_all_op)
# self.log.warning('VARIABLES TO SAVE:')
# for v in variables_to_save:
# self.log.warning(v)
#
# self.log.warning('LOCAL VARS:')
# for v in local_variables:
# self.log.warning(v)
self.saver = FastSaver(var_list=variables_to_save, max_to_keep=1, save_relative_paths=True)
self.config = tf.ConfigProto(device_filters=["/job:ps", "/job:worker/task:{}/cpu:0".format(self.task)])
sess_manager = tf.train.SessionManager(
local_init_op=local_init_op,
ready_op=None,
ready_for_local_init_op=tf.report_uninitialized_variables(variables_to_save),
graph=None,
recovery_wait_secs=90,
)
with sess_manager.prepare_session(
master=server.target,
init_op=init_op,
config=self.config,
init_fn=init_fn,
) as sess:
# Try to restore pre-trained model
pre_trained_restored = self._restore_model_params(sess, self.initial_ckpt_dir)
_ = sess.run(trainer.reset_global_step)
if not pre_trained_restored:
# If not - try to recover current checkpoint:
current_restored = self._restore_model_params(sess, self.current_ckpt_dir)
else:
current_restored = False
if not pre_trained_restored and not current_restored:
self.log.notice('training from scratch...')
self.log.info("connecting to the parameter server... ")
self.summary_writer = tf.summary.FileWriter(self.summary_dir, sess.graph)
trainer.start(sess, self.summary_writer)
# Note: `self.global_step` refers to number of environment steps
# summarized over all environment instances, not to number of policy optimizer train steps.
global_step = sess.run(trainer.global_step)
self.log.notice("started training at step: {}".format(global_step))
last_saved_time = datetime.datetime.now()
last_saved_step = global_step
while global_step < self.max_env_steps:
trainer.process(sess)
global_step = sess.run(trainer.global_step)
time_delta = datetime.datetime.now() - last_saved_time
if self.is_chief and time_delta.total_seconds() > self.save_secs:
self._save_model_params(sess, global_step)
train_speed = (global_step - last_saved_step) / (time_delta.total_seconds() + 1)
self.log.notice(
'env. step: {}; cluster speed: {:.0f} step/sec; checkpoint saved.'.format(
global_step,
train_speed
)
)
last_saved_time = datetime.datetime.now()
last_saved_step = global_step
# Ask for all the services to stop:
for env in self.env_list:
env.close()
self.log.notice('reached {} steps, exiting.'.format(global_step))
except Exception as e:
self.log.exception(e)
raise e
| [] |
2024-01-10 | jplopez19/cocoUI | UItest.py | import streamlit as st
import os
import pyodbc
import openai
import streamlit.components.v1 as components
def init_connection():
return pyodbc.connect(
"Driver={ODBC Driver 17 for SQL Server};Server="
+ st.secrets["MYSQL_SERVER"]
+ ";Database="
+ st.secrets["MYSQL_DB"]
+ ";Uid="
+ st.secrets["MYSQL_USER"]
+ ";Pwd="
+ st.secrets["MYSQL_PASSWORD"]
+ ";Encrypt="
+ st.secrets["MYSQL_ENCRYPT"]
+ ";TrustServerCertificate="
+ st.secrets["MYSQL_SERV_CERT_SET"]
+ ";Connection Timeout="
+ st.secrets["MYSQL_CONN_TO"]
)
conn = init_connection()
# Function to store user-bot exchange in the database
def store_exchange(id, user_input, bot_response, feedback=None):
try:
with conn.cursor() as cursor:
# Construct the query string
sql_query = '''INSERT INTO dbo.EXCHANGE_LOG (id, user_input, bot_response, feedback)
VALUES (?, ?, ?, ?);'''
# Execute the query
cursor.execute(sql_query, (id, user_input, bot_response, feedback))
# Commit the transaction
conn.commit()
except Exception as e:
st.write(f"Database error: {e}")
pass
# This function will handle the logic for storing feedback and explanations in the database.
def handle_feedback(user_id, message_index, feedback):
exchange = st.session_state.conversation_history[message_index]
feedback_value = 'positive' if feedback else 'negative'
# Store the exchange, feedback, and explanation in the database
store_exchange(user_id, exchange['user'], exchange['chatbot'], feedback_value)
st.write(f"Feedback received for message {message_index}: {feedback_value}")
def render_feedback_buttons(user_id, message_index):
feedback_col1, feedback_col2 = st.columns([1, 1])
feedback_key_positive = f"feedback_positive_{message_index}"
feedback_key_negative = f"feedback_negative_{message_index}"
if feedback_col1.button("👍", key=feedback_key_positive):
handle_feedback(user_id, message_index, True)
if feedback_col2.button("👎", key=feedback_key_negative):
handle_feedback(user_id, message_index, False)
SYSTEM_MESSAGE = """ Your name is COCO.
You have a special role as an AI companion designed to uplift the mental health of family caregivers. To ensure you fulfill this purpose effectively, here's a comprehensive guide:
Role & Responsibilities:
1. **Supportive Conversations**:
- Actively listen to users and acknowledge their feelings.
- Employ empathetic responses like 'That sounds challenging.' or 'You're handling a lot; don’t forget to give yourself some time too.'
2. **Problem-Solving Therapy (PST)**:
- Guide caregivers in breaking down their issues: defining the problem, brainstorming potential solutions, and weighing pros and cons.
- Use probing questions such as 'What's an aspect you'd like to address first?' or 'How did that situation make you feel?'
3. **Self-Care Suggestions**:
- Offer practices like 'How about short breaks to rejuvenate?' or 'Mindfulness exercises can be calming. Have you given them a shot?'
- For users appearing overwhelmed: 'This seems tough; a professional might offer more tailored guidance.'
Key Boundaries:
1. **Avoid Professional Recommendations**:
- Make it clear you aren’t a substitute for medical or legal consultation. Use reminders like 'I offer emotional assistance, but it's important to seek expert advice on specific matters.'
2. **In Crises**:
- If a user signals a severe issue, respond promptly with 'Please reach out to a professional or emergency service for this concern.'
3. **Decision Guidance, Not Making**:
- Do not decide for the user. Instead, steer the conversation with inquiries such as 'What direction feels right to you?' or 'Have you evaluated all the possible choices?'
Communication Essentials:
- Maintain a consistently warm, empathetic, and patient demeanor.
- Your replies should be succinct yet full of compassion.
- **Avoid Repetitiveness**: Ensure your responses are diverse. While it's essential to be consistent, avoid echoing the same phrases too frequently.
- Your ultimate aim is to offer support, steer discussions, and occasionally redirect to specialized assistance when necessary.
"""
# Set page configuration
st.set_page_config(
page_title="COCO Bot Training UI",
layout="wide",
initial_sidebar_state="expanded",
)
def main():
# Enhanced CSS for better UI consistency and responsiveness
st.markdown(
"""
<style>
.chat-box {
max-height: 450px;
overflow-y: auto;
border: 1px solid #ECEFF1;
border-radius: 5px;
padding: 10px;
background-color: whitesmoke;
}
.chat-message {
margin-bottom: 15px;
}
.user-message {
color: #0056b3; /* Changed to a standard blue color */
margin-left: 10px;
}
.bot-message {
color: #800080; /* Changed to a standard purple color */
}
.feedback-icon {
border: 1px solid #000;
padding: 2px;
border-radius: 5px;
cursor: pointer;
margin-right: 5px;
display: inline-block;
}
.feedback-container {
margin-top: 5px;
}
.bot-message.latest-response {
background-color: #F5F5F5;
border-radius: 5px;
padding: 5px;
margin: 5px 0;
color: black;
font-weight: bold;
}
.instruction-box {
border: 1px solid #ECEFF1;
border-radius: 5px;
padding: 10px;
margin-bottom: 20px;
background-color: silver;
color: #333;
}
h1, h2, h3, h4, h5, h6 {
color: #000;
}
.css-2trqyj {
color: whitesmoke;
}
</style>
""",
unsafe_allow_html=True,
)
st.markdown(
"""
<script>
const inputBox = document.getElementById("user_input_key");
inputBox.addEventListener("keyup", function(event) {
if (event.key === "Enter") {
event.preventDefault();
const submitButton = document.querySelector("button[aria-label='Send']");
submitButton.click();
}
});
</script>
""",
unsafe_allow_html=True,
)
# Sidebar for Authentication and Title
with st.sidebar:
st.title("Authorization")
# Authentication token input with a tooltip for guidance
auth_token = st.text_input("Enter Authentication Token:",
help="Enter the token provided to you for authentication.")
# User ID input with a tooltip for guidance
user_id = st.text_input("Enter your ID Number:",
help="Enter your unique ID number to start the conversation.")
# Initialize conversation history and feedback if they don't exist
if 'conversation_history' not in st.session_state:
st.session_state.conversation_history = []
if auth_token == st.secrets["COCO_TOKEN"]:
st.sidebar.success("Authentication Approved!") # Display success message when user ID is entered
user_id = st.sidebar.text_input("Enter your ID Number:") # Prompt for user ID number
if user_id: # Make sure user_id is entered
st.sidebar.success("User ID set!") # Display success message when user ID is entered
# Initialize conversation history and feedback
conversation_history = []
feedback_history = []
# Configure API
openai.api_type = st.secrets["API_TYPE"]
openai.api_version = st.secrets["API_VERSION"]
openai.api_base = st.secrets["API_BASE"]
openai.api_key = st.secrets["API_KEY"]
# Instruction box.
st.markdown(
"""
<div class="instruction-box">
<h2>Welcome to our COCO Training UI</h2>
<p>We're excited to have you onboard to help us refine our support tool for family caregivers. Your insights are invaluable to this process, and we appreciate your time and effort. Below, you'll find a concise guide to interacting with our chatbot. Let's get started!</p>
<h4>Quick Testing Guide</h4>
<li><strong>Start the conversation</strong> by typing a caregiving-related message.</li>
<li class="important">Remember to click "Submit" to send your message.</li>
<li><strong>Rate the highlighted chatbot's replies</strong> with "Thumb Up" or "Thumb Down" buttons.</li>
<li><strong>Engage with various topics</strong> to assess the chatbot's capabilities.</li>
<li><strong>If you wish to start over,</strong> click the "Reset" button to begin a new conversation.</li>
<li><strong>End the session</strong> when completed and fill concluding survey [OPTIONAL]</li>
<li><strong>Disclaimer.</strong> This tool is supportive, not a professional advice substitute.</li>
<p></p>
<p>Thank you for your participation and honest feedback. You're helping enhance this essential caregiving support tool!</p>
<p>[Optional]End Evaluation Survey: <a href="https://www.surveymonkey.com/r/7M9VPDP" target="_blank">COCO Test Survey</a></p>
</div>
""",
unsafe_allow_html=True,
)
st.write("---")
st.markdown('<h1 style="color: whitesmoke;">COCO Chat Interface</h1>', unsafe_allow_html=True)
# Initialize 'user_input' in session state if it doesn't exist
if 'user_input' not in st.session_state:
st.session_state.user_input = ''
# If 'input_key' is not in session_state, initialize it
if 'input_key' not in st.session_state:
st.session_state.input_key = 'user_input_key_1'
# Container for chat
chat_container = st.empty()
feedback_container = st.empty()
# Render conversation in the chat box
messages_html = "<div class='chat-box'>"
# Check if there's an existing conversation history
if 'conversation_history' not in st.session_state:
st.session_state.conversation_history = [] # Initialize it if it doesn't exist
# Initialize the messages HTML string
for index, exchange in enumerate(st.session_state.conversation_history):
user_class = 'user-message'
bot_class = 'bot-message'
# Check if this is the last message in the conversation history
is_last_message = index == len(st.session_state.conversation_history) - 1
if is_last_message:
bot_class += ' latest-response' # This class should be defined in your CSS
# Render the message without the msg_id
messages_html += f"<div class='chat-message' id='message-{index}'>" # id attribute uses the message index
messages_html += f"<span class='{user_class}'>You: {exchange['user']}</span><br>"
messages_html += f"<span class='{bot_class}'>🤖 Coco: {exchange['chatbot']}</span>"
if is_last_message:
# Add placeholders for feedback buttons; these will be replaced by real Streamlit buttons
messages_html += f"<div id='feedback-{index}'></div>"
messages_html += "</div>"
chat_container.markdown(messages_html, unsafe_allow_html=True)
if st.session_state.conversation_history:
last_message_index = len(st.session_state.conversation_history) - 1
render_feedback_buttons(user_id, last_message_index) # Render feedback buttons for the last message
user_input = st.text_input(label="", placeholder='Enter Message...', key=st.session_state.input_key)
# st.markdown("""
# <script>
# function handleFeedback(messageIndex, isPositive) {
# let feedback = isPositive ? 'positive' : 'negative';
# let user_id = '%s'; // Replace this with the actual user ID.
# let params = {index: messageIndex, user_id: user_id, feedback: feedback};
# // Make a POST request to the Streamlit server with the feedback data
# fetch(window.location.href, {
# method: 'POST',
# headers: {
# 'Content-Type': 'application/json'
# },
# body: JSON.stringify(params)
# }).then(response => response.json()).then(data => {
# console.log('Success:', data);
# }).catch((error) => {
# console.error('Error:', error);
# });
# }
# </script>
# """ % user_id, unsafe_allow_html=True)
# Remove the 'if st.button('Submit') and user_input.strip():' block
# And directly check for user input and process it
if user_input.strip(): # Check if there is user input
try:
completion = openai.ChatCompletion.create(
engine="CocoGPT_2",
messages=[
{"role": "system", "content": SYSTEM_MESSAGE},
{"role": "user", "content": user_input}
]
)
generated_text = completion.choices[0].message.content
# Append the new exchange to the conversation history
st.session_state.conversation_history.append({"user": user_input, "chatbot": generated_text})
# After sending a message and receiving a response, record the user input and bot response in the database.
if generated_text: # Ensure there's a bot response to record
try:
store_exchange(user_id, user_input, generated_text)
# Change the key to reset the text_input
new_key_value = int(st.session_state.input_key.split('_')[-1]) + 1
st.session_state.input_key = f'user_input_key_{new_key_value}'
st.experimental_rerun()
except Exception as e:
st.error(f"Failed to store exchange: {e}")
except Exception as e:
st.error(f"An error occurred: {e}")
except Exception as e:
st.write(f"An error occurred: {e} 😢")
# Check if there's feedback in the URL query parameters and handle it
feedback_data = st.experimental_get_query_params().get("feedback")
message_index = st.experimental_get_query_params().get("index")
user_id_data = st.experimental_get_query_params().get("user_id")
if feedback_data is not None and message_index is not None and user_id_data is not None:
# URL-decode and parse the feedback, explanation, and message index
feedback = feedback_data[0] # 'positive' or 'negative'
index = int(message_index[0])
user_id = user_id_data[0]
# Clear the query parameters to avoid resubmitting the feedback
st.experimental_set_query_params()
# Reset conversation
if st.button("Reset Conversation 🔄"):
st.session_state.conversation_history = [] # Clear the conversation history
st.experimental_rerun() # This reruns the script, refreshing the conversation display
else:
st.sidebar.warning("Please enter your ID number to begin the conversation.") # Warning if ID number is not entered
else:
st.write("Not Authenticated 😢") # Warning if authentication number is not entered
if __name__ == "__main__":
main()
| [] |
2024-01-10 | oga8867/AI | streamlit_mini~QNA.py | import os
import openai
import streamlit as st
import requests
import json
openai.api_key = ("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")
REST_API_KEY = 'ec7c50f41f3ac55bf52521dbccc4084d'
def kogpt_api(prompt, max_tokens=1, temperature=1.0, top_p=1.0, n=1):
r = requests.post(
'https://api.kakaobrain.com/v1/inference/kogpt/generation',
json={
'prompt': prompt,
'max_tokens': max_tokens,
'temperature': temperature,
'top_p': top_p,
'n': n
},
headers={
'Authorization': 'KakaoAK ' + REST_API_KEY,
'Content-Type': 'application/json'
}
)
# 응답 JSON 형식으로 변환
response = json.loads(r.content)
return response
def QNA():
col1, col2,col3 = st.columns(3)
with col1:
st.subheader("i'm chatgpt. ask me anything, everything to english")
name = st.text_area('그래도 gpt라서 이상한거 물어보거나 부정확한 말들을 할 수 있음. 또한 어려운 질문은 답변을 하지 못함.')
response = openai.Completion.create(
model="text-davinci-003",
prompt=f"Q:{name} A:",
temperature=0,
max_tokens=100,
top_p=1,
frequency_penalty=0.0,
presence_penalty=0.0,
stop=["\n"]
)
response = response['choices']
response = response[0]
response = response['text']
if st.button("ask!"):
st.write(response)
with col3:
st.subheader("i'm kogpt. ask me anything, everything to korean")
kogptname = st.text_area('부정확하고 오류가 잘남')
kogptname = kogptname+'\n답:'
responsekogpt = kogpt_api(prompt=kogptname, max_tokens=250, temperature=0.2, top_p=1.0, n=1)
responsekogpt = responsekogpt['generations']
responsekogpt = responsekogpt[0]
responsekogpt = responsekogpt['text']
responsekogpt = responsekogpt.split('\n')[0]
responsekogpt = responsekogpt.split('.')[0]
responsekogpt = responsekogpt.split('^')[0]
responsekogpt = responsekogpt.split('▶')[0]
responsekogpt = responsekogpt.split('/')[0]
responsekogpt = responsekogpt.split('#')[0]
if st.button("ask!!"):
st.write(responsekogpt)
# 예제 Textfile
# 예외처리
# st.write('text') # df, err, func, keras
| [
"Q:PLACEHOLDER A:"
] |
2024-01-10 | oga8867/AI | streamlit_mini~bugfixer.py | import os
import openai
import streamlit as st
openai.api_key = ("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")
def bugfixer():
st.subheader("T.T i can't solve error")
name = st.text_area('dont worry, chatGPT can help you! be happy!:D')
response = openai.Completion.create(
model="code-davinci-002",
prompt=f"##### Fix bugs in the below function\n### Buggy Python \n{name} \n ### Fixed Python",
temperature=0,
max_tokens=182,
top_p=1.0,
frequency_penalty=0.0,
presence_penalty=0.0,
stop=["###"]
)
response = response['choices']
response = response[0]
response = response['text']
if st.button("find!"):
st.write(response)
# 예제 Textfile
# 예외처리
# st.write('text') # df, err, func, keras
| [
"##### Fix bugs in the below function\n### Buggy Python \nPLACEHOLDER \n ### Fixed Python"
] |
2024-01-10 | amitkumarsing1997/smartyinventoryfastapi | src2~app~exception~handler.py |
from typing import Any
from fastapi import Request,FastAPI,HTTPException
from fastapi.responses import JSONResponse
from src2.app.exception.custom_exception import GenericException
from src2.app.shared.response import Response
# from starlette.exceptions import HTTPException as StarletteHTTPException
def exception_handlers(app : FastAPI):
@app.exception_handler(GenericException)
def generic_exception_handler(request:Request , exc:GenericException):
return JSONResponse(
status_code=200,
content=Response[Any](success=False, msg=exc.msg, msg_code=exc.msg_code, body=exc.body).model_dump()
)
@app.exception_handler(HTTPException)
def http_exception_handler(request:Request, exc:HTTPException):
return JSONResponse(
status_code=200,
content=Response[Any](success=False, msg=exc.detail, msg_code=str(exc.status_code),body=exc.headers).model_dump()
)
@app.exception_handler(Exception)
def other_exceptions(request: Request, exc: Exception):
return JSONResponse(
status_code=500,
content=Response[Any](success=False, msg='Exception occurred while procession your request',
msg_code='server_error', body=None).model_dump()
)
# from fastapi import FastAPI, HTTPException
# from fastapi.exceptions import RequestValidationError
# from fastapi.responses import PlainTextResponse
# from starlette.exceptions import HTTPException as StarletteHTTPException
#
# app = FastAPI()
#
#
# @app.exception_handler(StarletteHTTPException)
# async def http_exception_handler(request, exc):
# return PlainTextResponse(str(exc.detail), status_code=exc.status_code)
#
#
# @app.exception_handler(RequestValidationError)
# async def validation_exception_handler(request, exc):
# return PlainTextResponse(str(exc), status_code=400)
#
#
# @app.get("/items/{item_id}")
# async def read_item(item_id: int):
# if item_id == 3:
# raise HTTPException(status_code=418, detail="Nope! I don't like 3.")
# return {"item_id": item_id}
#
#
#
#
#
#
#
#
#
#
#
#
# from typing import Any
#
# import openai
# from fastapi import Request, FastAPI
# from fastapi.responses import JSONResponse
#
# from src.app.exception.custom_exception import GenericException
# from src.app.shared.app_const import APIMsgCode
# from src.app.shared.response import Response
#
#
# def exception_handlers(app: FastAPI):
#
# @app.exception_handler(GenericException)
# def generic_exception_handler(request: Request, exc: GenericException):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, msg=exc.msg, msg_code=exc.msg_code, body=exc.body).model_dump()
# )
#
# # open ai exception handling
# @app.exception_handler(openai.BadRequestError)
# def openai_bad_request_exception(request: Request, exc: openai.BadRequestError):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, body=exc.message, msg_code=APIMsgCode.GPT_REQ_INV_ERR, msg="Please send the valid data").model_dump()
# )
#
# @app.exception_handler(openai.RateLimitError)
# def openai_bad_request_exception(request: Request, exc: openai.RateLimitError):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, body=exc.message, msg_code=APIMsgCode.GPT_REQ_LIMIT_CROSS_ERR, msg="You have crossed your request limit.").model_dump()
# )
#
# @app.exception_handler(openai.APITimeoutError)
# def openai_bad_request_exception(request: Request, exc: openai.APITimeoutError):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, body=exc.message, msg_code=APIMsgCode.GPT_REQ_TIMEOUT_ERR, msg="Request timeout, Please try again").model_dump()
# )
#
# @app.exception_handler(openai.APIError)
# def openai_bad_request_exception(request: Request, exc: openai.APIError):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, body=exc.message, msg_code=APIMsgCode.GPT_API_ERR, msg="Some error occurred while processing your request").model_dump()
# )
#
# @app.exception_handler(openai.BadRequestError)
# def openai_bad_request_exception(request: Request, exc: openai.BadRequestError):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, body=exc.message, msg_code=APIMsgCode.GPT_REQ_INV_ERR).model_dump()
# )
#
# @app.exception_handler(openai.BadRequestError)
# def openai_bad_request_exception(request: Request, exc: openai.BadRequestError):
# return JSONResponse(
# status_code=200,
# content=Response[Any](success=False, body=exc.message, msg_code=APIMsgCode.GPT_REQ_INV_ERR).model_dump()
# )
#
# @app.exception_handler(Exception)
# def other_exceptions(request: Request, exc: Exception):
# return JSONResponse(
# status_code=500,
# content=Response[Any](success=False, msg='Exception occurred while procession your request',
# msg_code='server_error', body=None).model_dump()
# )
| [] |
2024-01-10 | vprayagala/VoiceLearning | Source~Models~BuildModel.py | # -*- coding: utf-8 -*-
"""
Created on Thu Oct 11 09:30:43 2018
@author: vprayagala2
Build Model
Write function for each of machine learning experimentation
"""
#%%
#Get the logger
import logging
from Source.Config import LoadConfiguration as LC
from Source.DataHandler import PrepareData as PD
#import os
#import numpy as np
import pandas as pd
#from sklearn.metrics import silhouette_score
# Gensim
import gensim
from gensim.summarization import keywords
import gensim.corpora as corpora
#from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
# spacy for lemmatization
#import spacy
# Plotting tools
#import pyLDAvis
#import pyLDAvis.gensim
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.feature_extraction.text import TfidfVectorizer
#%%
#Load Configurtion and get logger
LC.load_config_file()
logger=logging.getLogger(LC.getParmValue('LogSetup/Log_Name'))
#%%
#Define Functions
def cluster_texts_kmeans(texts, clusters=5,true_k=3):
""" Transform texts to Tf-Idf coordinates and cluster texts using K-Means """
vectorizer = TfidfVectorizer(#max_df=0.5,
#min_df=0.1,
#lowercase=True)
)
tfidf_model = vectorizer.fit_transform([word for word in texts])
#Fit different cluster and pick the optimal cluster size
df_clust=pd.DataFrame()
for i in range(2,clusters+1):
#Build model
logger.info("Building Kmean with {} cluster".format(i))
km_model = KMeans(n_clusters=i,random_state=7)
km_model.fit(tfidf_model)
#labels=km_model.labels_
#score=silhouette_score(tfidf_model, labels, metric='euclidean')
score=km_model.inertia_
logger.info("K-Means Score:{}".format(score))
df_clust=df_clust.append({"num_clusters":i,"score":score},ignore_index=True)
plt.figure()
plt.plot(df_clust["num_clusters"],df_clust["score"])
plt.savefig("kmeans_elbow.png")
#clustering = collections.defaultdict(list)
#for idx, label in enumerate(km_model.labels_):
# clustering[label].append(idx)
km=KMeans(n_clusters=true_k,random_state=77)
km.fit(tfidf_model)
kmeans_clust=pd.DataFrame()
logger.info("Top terms per cluster:")
order_centroids = km.cluster_centers_.argsort()[:, ::-1]
terms = vectorizer.get_feature_names()
for i in range(true_k):
term_list=[]
logger.info("Cluster %d:\n" % i)
for ind in order_centroids[i, :15]:
logger.info(' %s' % terms[ind])
term_list.append(terms[ind])
kmeans_clust=kmeans_clust.append({"Cluster_Num":i,"Top_Terms":term_list},\
ignore_index=True)
return km,kmeans_clust
def topic_modeling_lda(texts, max_topics=5,true_topics=3):
""" Transform texts to Tf-Idf coordinates and cluster texts using K-Means """
#Explore Topic Modeling
## python3 -m spacy download en
# Create Dictionary
bigram = gensim.models.Phrases(texts)
bigram_mod = gensim.models.phrases.Phraser(bigram)
data_bigrams=[bigram_mod[sentence] for sentence in texts]
data_cleaned = PD.lemmatization(data_bigrams,\
allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV'])
#Dictionary of Word Mappings
id2word = corpora.Dictionary(data_cleaned)
# Term Document Frequency
tdm = [id2word.doc2bow(word) for word in data_cleaned]
df_result=pd.DataFrame()
for i in range(2,max_topics+1):
logger.info("Experimenting LDA with {} Topics".format(i))
lda_model = gensim.models.ldamodel.LdaModel(corpus=tdm,
id2word=id2word,
num_topics=i,
random_state=7,
update_every=1,
chunksize=1,
passes=10,
alpha='auto',
per_word_topics=True
)
# Compute Perplexity
perplexity=lda_model.log_perplexity(tdm)
logger.info('\nPerplexity: {}'.format(perplexity) )
# Compute Coherence Score
coherence_model_lda = CoherenceModel(model=lda_model, texts=data_cleaned,
dictionary=id2word, coherence='c_v')
coherence_lda = coherence_model_lda.get_coherence()
logger.info('\nCoherence Score: {}'.format(coherence_lda))
df_result=df_result.append({"num_topics":i,
"Perplexity":perplexity,
"Coherence":coherence_lda
},ignore_index=True)
logger.info("Result of Experiment:{}".format(df_result))
#Build the final topic model with true topics provided in configuration
lda_model = gensim.models.ldamodel.LdaModel(corpus=tdm,
id2word=id2word,
num_topics=true_topics,
random_state=7,
update_every=1,
chunksize=1,
passes=10,
alpha='auto',
per_word_topics=True
)
topics = lda_model.print_topics(num_topics=true_topics, num_words=15)
logger.info("Topics:{}".format(topics))
return lda_model,tdm,id2word
def extractTopKeywords(text,num_keywords=30):
keyword_list =[]
""" Transform texts to Tf-Idf coordinates and cluster texts using K-Means """
#vectorizer = TfidfVectorizer()
#tfidf_model = vectorizer.fit_transform([word for word in text])
#terms = vectorizer.get_feature_names()
#scores = tfidf_model.toarray().flatten().tolist()
#data = list(zip(terms,scores))
pos_tag=('NN','JJ','RB','VB','CD')
cap=int(len(text.split()) * 0.2)
if num_keywords >= cap:
num_keywords = cap
print("Extracting {} Keywords".format(num_keywords))
data=keywords(text,scores=True,
pos_filter=pos_tag,
lemmatize=True,
words=num_keywords)
sorted_data = sorted(data,key=lambda x: x[1],reverse=True)
if len(sorted_data) > num_keywords:
keyword_list = sorted_data[:num_keywords]
else:
keyword_list = sorted_data
return keyword_list | [] |
2024-01-10 | MoayedHajiAli/ElasticDiffusion-official | elastic_diffusion.py | from typing import Any
from transformers import CLIPTextModel, CLIPTokenizer, logging, CLIPTextModelWithProjection
from diffusers import AutoencoderKL, UNet2DConditionModel, DDIMScheduler
from diffusers.models.attention_processor import (
AttnProcessor2_0,
LoRAAttnProcessor2_0,
LoRAXFormersAttnProcessor,
XFormersAttnProcessor)
# suppress partial model loading warning
logging.set_verbosity_error()
import torch
import torch.nn as nn
import torchvision.transforms as T
import torch.nn.functional as F
import argparse
from tqdm import tqdm
from datetime import datetime
from torchvision.utils import make_grid
import os
import math
import numpy as np
import time
from contextlib import contextmanager
from fractions import Fraction
import hashlib
class TimeIt:
def __init__(self, sync_gpu=False):
self.sync_gpu = sync_gpu
self.total_time = {}
def time_function(self, func):
def wrapper(*args, **kwargs):
if self.sync_gpu and torch.cuda.is_available():
torch.cuda.synchronize()
start_time = time.time()
result = func(*args, **kwargs)
if self.sync_gpu and torch.cuda.is_available():
torch.cuda.synchronize()
end_time = time.time()
self.total_time[f'FUNCTION_{func.__name__}'] = self.total_time.get(f'FUNCTION_{func.__name__}', 0) + (end_time - start_time)
return result
return wrapper
@contextmanager
def time_block(self, block_title):
if self.sync_gpu and torch.cuda.is_available():
torch.cuda.synchronize()
start_time = time.time()
try:
yield
finally:
if self.sync_gpu and torch.cuda.is_available():
torch.cuda.synchronize()
end_time = time.time()
self.total_time[f'BLOCK_{block_title}'] = self.total_time.get(f'BLOCK_{block_title}', 0) + (end_time - start_time)
def print_results(self):
for key, time_spent in self.total_time.items():
print(f"{key} took total {time_spent} seconds to complete.")
class LinearScheduler():
def __init__(self, steps, start_val, stop_val):
self.steps = steps
self.start_val = start_val
self.stop_val = stop_val
def __call__(self, t, *args: Any, **kwds: Any) -> Any:
if t >= self.steps:
return self.stop_val
return self.start_val + (self.stop_val - self.start_val) / self.steps * t
class ConstScheduler():
def __init__(self, steps, start_val, stop_val):
self.steps = steps
self.start_val = start_val
self.stop_val = stop_val
def __call__(self, t, *args: Any, **kwds: Any) -> Any:
if t >= self.steps:
return self.stop_val
return self.start_val
class CosineScheduler():
def __init__(self, steps, cosine_scale, factor=0.01):
self.steps = steps
self.cosine_scale = cosine_scale
self.factor = factor
def __call__(self, t, *args: Any, **kwds: Any) -> Any:
if t >= self.steps:
return 0
cosine_factor = 0.5 * (1 + np.cos(np.pi * t / self.steps))
return self.factor * (cosine_factor ** self.cosine_scale)
timelog = TimeIt(sync_gpu=False)
class ElasticDiffusion(nn.Module):
def __init__(self, device, sd_version='2.0',
verbose=False,
log_freq=5,
view_batch_size=1,
low_vram=False):
super().__init__()
self.device = device
self.sd_version = sd_version
self.verbose = verbose
self.torch_dtype = torch.float16 if low_vram else torch.float32
self.view_batch_size = view_batch_size
self.log_freq = log_freq
self.low_vram = low_vram
print(f'[INFO] loading stable diffusion...')
if self.sd_version == '2.1':
model_key = "stabilityai/stable-diffusion-2-1-base"
elif self.sd_version == '2.0':
model_key = "stabilityai/stable-diffusion-2-base"
elif self.sd_version == '1.5':
model_key = "runwayml/stable-diffusion-v1-5"
elif self.sd_version == '1.4':
model_key = "CompVis/stable-diffusion-v1-4"
elif self.sd_version == 'XL1.0':
model_key = "stabilityai/stable-diffusion-xl-base-1.0"
else:
print(f'[INFO] using hugging face custom model key: {self.sd_version}')
model_key = self.sd_version
# Create model
self.vae = AutoencoderKL.from_pretrained(model_key, subfolder="vae", torch_dtype=self.torch_dtype).to('cpu' if self.low_vram else self.device)
self.tokenizer = [CLIPTokenizer.from_pretrained(model_key, subfolder="tokenizer", torch_dtype=self.torch_dtype)]
self.text_encoder = [CLIPTextModel.from_pretrained(model_key, subfolder="text_encoder", torch_dtype=self.torch_dtype).to('cpu' if self.low_vram else self.device)]
self.unet = UNet2DConditionModel.from_pretrained(model_key, subfolder="unet", torch_dtype=self.torch_dtype).to('cpu' if self.low_vram else self.device)
if self.sd_version == 'XL1.0':
self.text_encoder.append(CLIPTextModelWithProjection.from_pretrained(model_key, subfolder="text_encoder_2", torch_dtype=self.torch_dtype).to('cpu' if self.low_vram else self.device))
self.tokenizer.append(CLIPTokenizer.from_pretrained(model_key, subfolder="tokenizer_2", torch_dtype=self.torch_dtype))
self.scheduler = DDIMScheduler.from_pretrained(model_key, subfolder="scheduler")
self.requires_grad(self.vae, False)
self.set_view_config()
self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
print(f'[INFO] loaded stable diffusion!')
def set_view_config(self, patch_size=None):
self.view_config = {
"window_size": patch_size if patch_size is not None else self.unet.config.sample_size // 2,
"stride": patch_size if patch_size is not None else self.unet.config.sample_size // 2}
self.view_config["context_size"] = self.unet.config.sample_size - self.view_config["window_size"]
def seed_everything(self, seed, seed_np=True):
torch.manual_seed(seed)
if self.device.type == 'cuda':
torch.cuda.manual_seed(seed)
if seed_np:
np.random.seed(seed)
def requires_grad(self, model, flag=True):
for p in model.parameters():
p.requires_grad = flag
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_upscale.StableDiffusionUpscalePipeline.upcast_vae
def upcast_vae(self):
dtype = self.vae.dtype
self.vae.to(dtype=torch.float32)
use_torch_2_0_or_xformers = isinstance(
self.vae.decoder.mid_block.attentions[0].processor,
(
AttnProcessor2_0,
XFormersAttnProcessor,
LoRAXFormersAttnProcessor,
LoRAAttnProcessor2_0,
),
)
# if xformers or torch_2_0 is used attention block does not need
# to be in float32 which can save lots of memory
if use_torch_2_0_or_xformers:
self.vae.post_quant_conv.to(dtype)
self.vae.decoder.conv_in.to(dtype)
self.vae.decoder.mid_block.to(dtype)
@torch.no_grad()
def get_views(self, panorama_height, panorama_width, h_ws=64, w_ws=64, stride=32, **kwargs):
if int(panorama_height / self.vae_scale_factor) != panorama_height/ self.vae_scale_factor or int(panorama_width / self.vae_scale_factor) != panorama_width / self.vae_scale_factor:
raise f"height {panorama_height} and Width {panorama_width} must be divisable by {self.vae_scale_factor}"
panorama_height //= self.vae_scale_factor # go to LDM latent size
panorama_width //= self.vae_scale_factor
num_blocks_height = math.ceil((panorama_height - h_ws) / stride) + 1 if stride else 1
num_blocks_width = math.ceil((panorama_width - w_ws) / stride) + 1 if stride else 1
total_num_blocks = int(num_blocks_height * num_blocks_width)
views = []
for i in range(total_num_blocks):
h_start = int((i // num_blocks_width) * stride)
h_end = h_start + h_ws
if h_end > panorama_height: # adjust last crop
h_start -= h_end - panorama_height
h_end = panorama_height
h_start = max(0, h_start)
w_start = int((i % num_blocks_width) * stride)
w_end = w_start + w_ws
if w_end > panorama_width: # adjust last crop
w_start -= w_end - panorama_width
w_end = panorama_width
w_start = max(0, w_start)
views.append((h_start, h_end, w_start, w_end))
return views
## Copied from https://github.com/huggingface/diffusers/blob/cf03f5b7188c603ff037d686f7256d0571fbd651/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L94
def _get_add_time_ids(self, original_size, crops_coords_top_left, target_size, dtype):
add_time_ids = list(original_size + crops_coords_top_left + target_size)
passed_add_embed_dim = (
self.unet.config.addition_time_embed_dim * len(add_time_ids) + self.text_encoder[1].config.projection_dim
)
expected_add_embed_dim = self.unet.add_embedding.linear_1.in_features
if expected_add_embed_dim != passed_add_embed_dim:
raise ValueError(
f"Model expects an added time embedding vector of length {expected_add_embed_dim}, but a vector of {passed_add_embed_dim} was created. The model has an incorrect config. Please check `unet.config.time_embedding_type` and `text_encoder_2.config.projection_dim`."
)
add_time_ids = torch.tensor([add_time_ids], dtype=dtype)
return add_time_ids
def encoder_prompt(self, prompt, encoder_id):
text_input = self.tokenizer[encoder_id](prompt, padding='max_length', max_length=self.tokenizer[encoder_id].model_max_length,
truncation=True, return_tensors='pt')
text_embeddings = self.text_encoder[encoder_id](text_input.input_ids.to(self.device), output_hidden_states=True)
return text_embeddings
@torch.no_grad()
def get_text_embeds(self, prompt):
if self.sd_version == 'XL1.0':
text_embeddings = torch.cat([self.encoder_prompt(prompt, 0).hidden_states[-2],
self.encoder_prompt(prompt, 1).hidden_states[-2]], dim=-1)
pooled_prompt_embeds = self.encoder_prompt(prompt, 1)[0]
else:
text_embeddings = self.encoder_prompt(prompt, 0)[0]
pooled_prompt_embeds = text_embeddings
return text_embeddings, pooled_prompt_embeds
def decode_latents(self, latents):
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
latents = latents / self.vae.config.scaling_factor
imgs = self.vae.decode(latents).sample
imgs = (imgs / 2 + 0.5).clamp(0, 1)
return imgs
## Adapted from https://github.com/PRIS-CV/DemoFusion/blob/540b5e26f5e238589bee60aa2124ae8c37d00777/pipeline_demofusion_sdxl.py#L603
def tiled_decode(self, latents):
current_height, current_width = latents.shape[2] * self.vae_scale_factor, latents.shape[3] * self.vae_scale_factor
sample_size = self.unet.config.sample_size
core_size = self.unet.config.sample_size // 4
core_stride = core_size
pad_size = self.unet.config.sample_size // self.vae_scale_factor * 3
decoder_view_batch_size = 1
if self.low_vram:
core_stride = core_size // 2
pad_size = core_size
views = self.get_views(current_height, current_width, h_ws=core_size, w_ws=core_size, stride=core_stride)
views_batch = [views[i : i + decoder_view_batch_size] for i in range(0, len(views), decoder_view_batch_size)]
latents_ = F.pad(latents, (pad_size, pad_size, pad_size, pad_size), 'constant', 0)
image = torch.zeros(latents.size(0), 3, current_height, current_width).to(latents.device)
count = torch.zeros_like(image).to(latents.device)
# get the latents corresponding to the current view coordinates
for j, batch_view in enumerate(views_batch):
vb_size = len(batch_view)
latents_for_view = torch.cat(
[
latents_[:, :, h_start:h_end+pad_size*2, w_start:w_end+pad_size*2]
for h_start, h_end, w_start, w_end in batch_view
]
).to(self.vae.device)
# image_patch = self.vae.decode(latents_for_view / self.vae.config.scaling_factor, return_dict=False)[0]
image_patch = self.decode_latents(latents_for_view)
h_start, h_end, w_start, w_end = views[j]
h_start, h_end, w_start, w_end = h_start * self.vae_scale_factor, h_end * self.vae_scale_factor, w_start * self.vae_scale_factor, w_end * self.vae_scale_factor
p_h_start, p_h_end, p_w_start, p_w_end = pad_size * self.vae_scale_factor, image_patch.size(2) - pad_size * self.vae_scale_factor, pad_size * self.vae_scale_factor, image_patch.size(3) - pad_size * self.vae_scale_factor
image[:, :, h_start:h_end, w_start:w_end] += image_patch[:, :, p_h_start:p_h_end, p_w_start:p_w_end].to(latents.device)
count[:, :, h_start:h_end, w_start:w_end] += 1
image = image / count
# image = (image / 2 + 0.5).clamp(0, 1)
return image
def compute_downsampling_size(self, image, scale_factor):
B, C, H, W = image.shape
# Calculating new dimensions based on scale_factor
new_H = math.floor(H * scale_factor)
new_W = math.floor(W * scale_factor)
return (new_H, new_W)
def string_to_number(self, s, num_bytes=4):
hash_object = hashlib.md5(s.encode())
hex_dig = hash_object.hexdigest()[:num_bytes * 2]
return int(hex_dig, 16)
def make_denoised_background(self, size, t, id=0, white=False):
with torch.autocast('cuda', enabled=False): # vae encoder is sensetive to precision
H, W = size
id = f"{id}_{H}_{W}_{t}"
if H == 0 or W == 0:
return torch.zeros(1, 4, H, W).to(self.device)
self.seed_everything(self.string_to_number(id), seed_np=False) # make sure same background and noise are sampled at each iteration
random_bg = torch.rand(1, 3, device=self.device)[:, :, None, None].repeat(1, 1, H * self.vae_scale_factor, W * self.vae_scale_factor)
needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast
# TODO: precompute random backgrounds to enable efficeint low_vram option instead of constantly moving vae between cpu and gpu
if self.low_vram:
# needs_upcasting = False
# self.unet.cpu()
self.vae.to(self.device)
if needs_upcasting:
self.upcast_vae()
random_bg = random_bg.float()
random_bg_encoded = self.vae.encode(random_bg).latent_dist.sample() * self.vae.config.scaling_factor
# if self.low_vram:
# self.vae.cpu()
# self.unet.to(self.device)
noise = [random_bg_encoded, torch.randn_like(random_bg_encoded)]
timesteps = t.long()
random_bg_encoded_t = self.scheduler.add_noise(noise[0], noise[1], timesteps)
self.seed_everything(np.random.randint(100000), seed_np=False)
if needs_upcasting:
self.vae.to(dtype=torch.float16)
return random_bg_encoded_t
def background_pad(self, input_tensor, pad_sequence, t, white=False):
# Ensure pad_sequence length is even and divides evenly by 2 (for pairs)
assert len(pad_sequence) % 2 == 0, "pad_sequence length must be even."
output_tensor = input_tensor
B, C, H, W = output_tensor.shape
for dim, (pad_before, pad_after) in enumerate(zip(pad_sequence[0::2], pad_sequence[1::2])):
dim = len(input_tensor.shape) - dim - 1
pad_shape_before = list(output_tensor.shape)
pad_shape_after = list(output_tensor.shape)
pad_shape_before[dim] = pad_before
pad_shape_after[dim] = pad_after
pad_tensor_before = self.make_denoised_background(size=(pad_shape_before[-2], pad_shape_before[-1]),
t=t,
id=f"{dim}_1",
white=white).repeat(B, 1, 1, 1).to(input_tensor)
pad_tensor_after = self.make_denoised_background(size=(pad_shape_after[-2], pad_shape_after[-1]),
t=t,
id=f"{dim}_2",
white=white).repeat(B, 1, 1, 1).to(input_tensor)
output_tensor = torch.cat([pad_tensor_before, output_tensor, pad_tensor_after], dim=dim)
return output_tensor
def unet_step(self, latent, t, text_embeds,
add_text_embeds,
crops_coords_top_left=(0, 0)):
B, C, H, W = latent.shape
d_H, d_W = 64, 64
if self.sd_version.startswith('XL'):
d_H, d_W = 128, 128
latent = self.scheduler.scale_model_input(latent, t)
# adjust latent size with padding
h_p, w_p = max(d_H - latent.shape[-2], 0), max(d_W - latent.shape[-1], 0)
l_p, r_p, t_p, b_p = w_p//2, w_p - w_p//2, h_p//2, h_p-h_p//2
if h_p > 0 or w_p > 0:
padded_latent = self.background_pad(latent, (l_p, r_p, t_p, b_p), t, white=False)
else:
padded_latent = latent
if self.sd_version.startswith('XL'):
original_size = target_size = self.default_size
add_time_ids = self._get_add_time_ids(original_size, crops_coords_top_left, target_size, dtype=text_embeds.dtype).to(text_embeds.device)
add_time_ids = add_time_ids.to(self.device).repeat(padded_latent.shape[0], 1)
added_cond_kwargs = {"text_embeds": add_text_embeds, "time_ids": add_time_ids}
nxt_latent = self.unet(padded_latent, t, encoder_hidden_states=text_embeds, added_cond_kwargs=added_cond_kwargs)['sample']
else:
nxt_latent = self.unet(padded_latent, t, encoder_hidden_states=text_embeds)['sample']
# crop latent
if h_p > 0 or w_p > 0:
nxt_latent = nxt_latent[:, :, t_p:nxt_latent.shape[-2] - b_p, l_p:nxt_latent.shape[-1] - r_p]
return nxt_latent
@timelog.time_function
def obtain_latent_direction(self, latent, t, text_embeds, add_text_embeds, return_scores=False):
downsampled_latent_model_input = torch.cat([latent] * 2)
downsampled_noise = self.unet_step(downsampled_latent_model_input, t,
text_embeds=text_embeds, add_text_embeds=add_text_embeds)
downsampled_noise_pred_uncond, downsampled_noise_pred_cond = downsampled_noise.chunk(2)
direction = (downsampled_noise_pred_cond - downsampled_noise_pred_uncond)
if return_scores:
return direction, {"uncond_score":downsampled_noise_pred_uncond, "cond_score":downsampled_noise_pred_cond}
return direction
def restore_mask_shape(self, M, A, dim):
i, j = 0, 0
R = []
while i < M.shape[dim]:
if j < len(A) and i == A[j]:
if dim == 0:
R.append(M[i:i+1, :])
R.append(M[i+1:i+2, :])
else:
R.append(M[:, i:i+1])
R.append(M[:, i+1:i+2])
j += 2
else:
if dim == 0:
R.append(M[i:i+1, :] | M[i+1:i+2, :])
else:
R.append(M[:, i:i+1] | M[:, i+1:i+2])
i += 2
return torch.cat(R, dim=dim)
def to_even_rational(self, f, max_block_sz=32):
frac = Fraction(f).limit_denominator(max_block_sz)
if frac.numerator % 2 != 0 or frac.denominator % 2 != 0:
frac = Fraction(f).limit_denominator(max_block_sz//2)
if frac.numerator % 2 != 0 or frac.denominator % 2 != 0:
return frac.numerator * 2, frac.denominator * 2
return frac.numerator, frac.denominator
def get_keep_blocks(self, tensor, n):
num_blocks = n // 2
mask = torch.ones_like(tensor, dtype=torch.bool)
interval = len(tensor) // (num_blocks + 1)
# interval should be even
if interval % 2 != 0:
interval += 1
cnt_blocks = 0
masked_blocks = []
for i in range(num_blocks):
start_index = (i + 1) * interval - 1
masked_blocks.extend([start_index - 1 - cnt_blocks * 2, start_index + 2 - (cnt_blocks+1) * 2])
mask[start_index:start_index + 2] = False
cnt_blocks += 1
result = tensor[mask]
return result, torch.tensor(masked_blocks).to(result.device)
@timelog.time_function
def random_sample_exclude_mask(self, N, mask=None, hi=4, max_iteration=50):
random_indices = torch.randint(0, hi, (N,))
if mask is not None:
invalid = mask[torch.arange(N), random_indices]
M = invalid.sum()
while M > 0 and max_iteration > 0:
random_indices[invalid] = torch.randint(0, hi, (M,))
invalid = mask[torch.arange(N), random_indices]
M = invalid.sum()
max_iteration -= 1
# For any remaining zeros (if all 1-4 were excluded), just randomize between 1 and 4. This risks repeated elements
invalid = mask[torch.arange(N), random_indices]
M = invalid.sum()
if M > 0:
random_indices[invalid] = torch.randint(0, hi, (M,))
return random_indices
@timelog.time_function
def random_downsample(self, input, downsample_factor, exclude_mask=None, prev_random_indices=None, drop_p=0.8, nearest=False):
# Input: Batch x Channels x Height x Width tensor
random_indices = None
B, C, H, W = input.shape
new_H, new_W = H // downsample_factor, W // downsample_factor
mask = torch.zeros((H, W), dtype=torch.bool, device=input.device)
ret = []
for c in range(input.shape[1]):
unfold = F.unfold(input[:, c:c+1, :, :], kernel_size=downsample_factor, stride=downsample_factor)
if random_indices is None:
if nearest:
random_indices = torch.zeros(unfold.size(2), device=input.device, dtype=torch.long)
else:
random_indices = self.random_sample_exclude_mask(N=unfold.size(2), mask=exclude_mask, hi=downsample_factor ** 2).to(input.device)
if prev_random_indices is not None:
drop_mask = torch.randint(0, 101, (unfold.size(2),), device=input.device)
drop_mask[drop_mask <= (100 * drop_p)] = 0
drop_mask[drop_mask >= (100 * drop_p)] = 1
random_indices = random_indices * drop_mask + prev_random_indices * (1 - drop_mask)
downsampled = unfold[:, random_indices, torch.arange(unfold.size(2))]
output_shape = (input.size(0), 1, input.size(2) // downsample_factor, input.size(3) // downsample_factor)
ret.append(downsampled.view(output_shape))
idx_h, idx_w = torch.meshgrid(torch.arange(new_H, device=input.device), torch.arange(new_W, device=input.device), indexing='ij')
idx_h, idx_w = idx_h.contiguous(), idx_w.contiguous()
sampled_h = (idx_h * downsample_factor + random_indices.reshape(idx_h.shape[0], idx_h.shape[1]) // downsample_factor).view(-1)
sampled_w = (idx_w * downsample_factor + random_indices.reshape(idx_h.shape[0], idx_h.shape[1]) % downsample_factor).view(-1)
mask[sampled_h, sampled_w] = True
return torch.cat(ret, dim=1), mask, random_indices
@timelog.time_function
def random_nearest_downsample(self, input, downsample_size, prev_random_indices=None, exclude_mask=None, drop_p=0.8, nearest=False):
# Future TODO: enable this function for downsample_factor > 2
# scale input to 2x
resized = self.nearest_interpolate(input, size=(input.shape[2] * 2, input.shape[3] * 2), mode='nearest')
# scale result to downsample_size * 2
r_n_keep, r_block_sz = self.to_even_rational(downsample_size[0] / input.shape[2])
r_n_remove = r_block_sz-r_n_keep # rows to remove per block to reach downsample_factor * 2
c_n_keep, c_block_sz = self.to_even_rational(downsample_size[1] / input.shape[3])
c_n_remove = c_block_sz-c_n_keep # cols to remove per block to reach downsample_factor * 2
r_num_blocks = ((downsample_size[0] * 2) // r_n_keep)
c_num_blocks = ((downsample_size[1] * 2) // c_n_keep)
if r_num_blocks * r_block_sz > input.shape[2] * 2:
r_num_blocks -= 1
if c_num_blocks * c_block_sz > input.shape[3] * 2:
c_num_blocks -= 1
r_blocks = r_num_blocks * r_block_sz # number of row blocks in 2x input
c_blocks = c_num_blocks * c_block_sz # number of column blocks in 2x input
if 'row_indices' not in self.random_downasmple_pre:
row_indices = torch.arange(0, r_blocks, r_block_sz)
offsets, r_masked_blocks = self.get_keep_blocks(torch.arange(r_block_sz), r_n_remove) # indices to keep and remove in each block
row_indices = (row_indices.view(-1, 1) + offsets).view(-1)
row_indices = row_indices[row_indices < input.shape[2] * 2]
self.random_downasmple_pre['row_indices'] = row_indices
mask_row_indices = torch.arange(0, downsample_size[0]*2, r_n_keep)
mask_row_indices = (mask_row_indices.view(-1, 1) + r_masked_blocks).view(-1)
self.random_downasmple_pre['mask_row_indices'] = mask_row_indices
if 'col_indices' not in self.random_downasmple_pre:
col_indices = torch.arange(0, c_blocks, c_block_sz)
offsets, c_masked_blocks = self.get_keep_blocks(torch.arange(c_block_sz), c_n_remove)
col_indices = (col_indices.view(-1, 1) + offsets).view(-1)
col_indices = col_indices[col_indices < input.shape[3] * 2]
self.random_downasmple_pre['col_indices'] = col_indices
mask_col_indices = torch.arange(0, downsample_size[1]*2, c_n_keep)
mask_col_indices = (mask_col_indices.view(-1, 1) + c_masked_blocks).view(-1)
self.random_downasmple_pre['mask_col_indices'] = mask_col_indices
row_indices = self.random_downasmple_pre['row_indices']
col_indices = self.random_downasmple_pre['col_indices']
r_remain = downsample_size[0]*2 - len(row_indices)
c_remain = downsample_size[1]*2 - len(col_indices)
rows = torch.cat([resized[:, :, row_indices, :], resized[:, :, r_blocks:r_blocks+r_remain]], dim=2)
resized = torch.cat([rows[:, :, :, col_indices], rows[:, :, :, c_blocks:c_blocks+c_remain]], dim=3)
downsampled, mask, prev_random_indices = self.random_downsample(resized,
downsample_factor=2,
drop_p=drop_p,
prev_random_indices=prev_random_indices,
exclude_mask=exclude_mask,
nearest=nearest) # Using the previous random_downsample function
mask_rows = self.restore_mask_shape(mask, self.random_downasmple_pre['mask_row_indices'], 0)
mask = self.restore_mask_shape(mask_rows, self.random_downasmple_pre['mask_col_indices'], 1)
if input.shape[2] > mask.shape[0]:
mask = torch.cat([mask, torch.zeros(input.shape[2] - mask.shape[0], mask.shape[1]).to(torch.bool).to(mask.device)], dim=0)
if input.shape[3] > mask.shape[1]:
mask = torch.cat([mask, torch.zeros(mask.shape[0], input.shape[3] - mask.shape[1]).to(torch.bool).to(mask.device)], dim=1)
return downsampled, mask, prev_random_indices
@timelog.time_function
def fill_in_from_downsampled_direction(self, target_direction, downsampled_direction, mask, fill_all=False):
B, C, H, W = target_direction.shape
upsampled_direction = self.nearest_interpolate(downsampled_direction, size=(target_direction.size(2), target_direction.size(3)))
target_direction = torch.where(mask, upsampled_direction, target_direction)
if fill_all:
if self.verbose:
print(f"[INFO] {(torch.sum(~torch.isnan(target_direction)) / target_direction.numel()) * 100:.2f}% of the target direction was filled with resampling")
nan_mask = torch.isnan(target_direction)
target_direction = torch.where(nan_mask, upsampled_direction, target_direction)
return target_direction
@timelog.time_function
def approximate_latent_direction_w_resampling(self, latent, t, text_embeds, add_text_embeds,
factor=None, downsample_size=None, resampling_steps=6,
drop_p=0.7, fix_initial=True):
exclude_mask = None
target_direction = torch.full_like(latent, float('nan')).half()
approximation_info = {}
approximation_info['init_downsampled_latent'] = None
prev_random_indices = None
for step in range(resampling_steps+1):
if downsample_size is None:
downsample_size = self.compute_downsampling_size(latent, scale_factor=1/factor)
downsampled_latent, mask, prev_random_indices = self.random_nearest_downsample(latent, downsample_size,
prev_random_indices=prev_random_indices,
drop_p=drop_p,
exclude_mask=exclude_mask,
nearest=(step==0) and fix_initial)
if exclude_mask is None:
exclude_mask = torch.zeros((len(prev_random_indices), 4), dtype=torch.bool, device=mask.device)
exclude_mask[torch.arange(len(prev_random_indices)), prev_random_indices] = True
if approximation_info['init_downsampled_latent'] is None:
approximation_info['init_downsampled_latent'] = downsampled_latent.clone()
direction, scores = self.obtain_latent_direction(downsampled_latent, t, text_embeds, add_text_embeds, return_scores=True)
target_direction = self.fill_in_from_downsampled_direction(target_direction, direction, mask, fill_all=(step==resampling_steps))
if self.verbose:
print(f"[INFO] {(torch.sum(~torch.isnan(target_direction)) / target_direction.numel()) * 100:.2f}% of the target direction was filled after resampling step {step}")
approximation_info['downsampled_latent'] = downsampled_latent
approximation_info['scores'] = scores
approximation_info['downsampled_direction'] = self.nearest_interpolate(target_direction, size=downsample_size, mode='nearest')
return target_direction, approximation_info
def undo_step(self, sample, timestep, generator=None):
n = self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps
for i in range(n):
if i >= self.scheduler.config.num_train_timesteps:
continue
t = timestep + i
beta = self.scheduler.betas[t]
noise = torch.randn(sample.shape, generator=generator, device=sample.device, dtype=sample.dtype)
sample = (1 - beta) ** 0.5 * sample + beta**0.5 * noise
return sample
def crop_with_context(self, X, a, b, c, d, S, n):
"""
X: torch.Tensor - input image of shape (B, C, H, W)
a, b: int - vertical cropping indices
c, d: int - horizontal cropping indices
S: int - stride
n: int - number of context pixels
"""
B, C, H, W = X.shape
n_t = n_b = n_r = n_l = n
if a - n_t * S < 0:
top_rows = np.arange(max(0, a - n_t * S), a - S + 1, S)
n_t = len(top_rows)
n_b = 2 * n - n_t
bottom_rows = np.arange(b - 1 + S, min(H, b + n_b * S), S)
n_b = len(bottom_rows)
else:
bottom_rows = np.arange(b - 1 + S, min(H, b + n_b * S), S)
n_b = len(bottom_rows)
n_t = 2 * n - n_b
top_rows = np.arange(max(0, a - n_t * S), a - S + 1, S)
n_t = len(top_rows)
# Get the top context rows
if c - n_l * S < 0:
left_cols = np.arange(max(0, c - n_l * S), c - S + 1, S)
n_l = len(left_cols)
n_r = 2 * n - n_l
right_cols = np.arange(d - 1 + S, min(W, d + n_r * S), S)
n_r = len(right_cols)
else:
right_cols = np.arange(d - 1 + S, min(W, d + n_r * S), S)
n_r = len(right_cols)
n_l = 2 * n - n_r
left_cols = np.arange(max(0, c - n_l * S), c - S + 1, S)
n_l = len(left_cols)
x_inds = np.concatenate([top_rows, np.arange(a, b), bottom_rows])
top_samples = X[:, :, top_rows, c:d]
bottom_samples = X[:, :, bottom_rows, c:d]
left_samples = X[:, :, x_inds, :][:, :, :, left_cols]
right_samples = X[:, :, x_inds, :][:, :, :, right_cols]
# Combine the contexts with the center crop
vertical_combined = torch.cat([top_samples, X[:, :, a:b, c:d], bottom_samples], dim=2)
final_crop = torch.cat([left_samples, vertical_combined, right_samples], dim=3)
return final_crop, (n_t, n_b, n_l, n_r)
@torch.no_grad()
def generate(self, latent, text_embeds, add_text_embeds, guidance_scale=7.5):
intermediate_steps_x0 = []
if self.low_vram:
self.vae.cpu()
self.unet.to(self.device)
with torch.autocast('cuda', enabled=(self.device.type=='cuda')):
for i, t in enumerate(tqdm(self.scheduler.timesteps)):
global_latent_model_input = torch.cat([latent] * 2)
global_noise = self.unet_step(global_latent_model_input, t,
text_embeds=text_embeds, add_text_embeds=add_text_embeds)
global_noise_pred_uncond, global_noise_pred_cond = global_noise.chunk(2)
global_direction = (global_noise_pred_cond - global_noise_pred_uncond)
global_noise_pred = global_noise_pred_uncond + guidance_scale * global_direction
ddim_out = self.scheduler.step(global_noise_pred, t, latent)
latent = ddim_out['prev_sample']
if i % self.log_freq == 0:
intermediate_steps_x0.append(ddim_out['pred_original_sample'].cpu())
#upcast vae
needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast
if self.low_vram:
# needs_upcasting = False
self.unet.cpu()
self.vae.to(self.device)
if needs_upcasting:
self.upcast_vae()
image = T.ToPILImage()(self.decode_latents(latent).cpu()[0]), {"inter_x0":intermediate_steps_x0}
if needs_upcasting:
self.vae.to(dtype=torch.float16)
return image
## Copied from https://github.com/huggingface/diffusers/blob/cf03f5b7188c603ff037d686f7256d0571fbd651/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L66
def rescale_noise_cfg(self, noise_cfg, noise_pred_text, guidance_rescale=0.0):
"""
Rescale `noise_cfg` according to `guidance_rescale`. Based on findings of [Common Diffusion Noise Schedules and
Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). See Section 3.4
"""
std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
# rescale the results from guidance (fixes overexposure)
noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
# mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg
return noise_cfg
@timelog.time_function
def compute_local_uncond_signal(self, latent, t,
uncond_text_embeds, negative_pooled_prompt_embeds,
view_config):
height, width = latent.shape[-2] * self.vae_scale_factor, latent.shape[-1] * self.vae_scale_factor
# edge case where context pixel are not required in one dimension
h_ws = w_ws = view_config['window_size']
if h_ws + view_config['context_size'] >= latent.shape[2]:
h_ws = latent.shape[2]
if w_ws + view_config['context_size'] >= latent.shape[3]:
w_ws = latent.shape[3]
views = self.get_views(height, width, h_ws=h_ws, w_ws=w_ws, **view_config)
local_uncond_noise_val = torch.zeros_like(latent)
for batch_start_idx in range(0, len(views), self.view_batch_size):
views_batch = views[batch_start_idx:batch_start_idx+self.view_batch_size]
latent_views = []
views_batch_wc = []
for view in views_batch:
h_start, h_end, w_start, w_end = view
latent_view, (n_t, n_b, n_l, n_r) = \
self.crop_with_context(latent, h_start, h_end, w_start, w_end, S=1, n=view_config['context_size'] // 2)
latent_views.append(latent_view)
views_batch_wc.append((n_t, n_b, n_l, n_r))
# predict the noise residual
latent_model_input = torch.cat(latent_views)
text_embeds_input = torch.cat([uncond_text_embeds] * len(views_batch))
add_text_embeds_input = torch.cat([negative_pooled_prompt_embeds] * len(views_batch))
noise_pred_uncond = self.unet_step(latent_model_input, t,
text_embeds=text_embeds_input,
add_text_embeds=add_text_embeds_input)
for view, view_wc, view_pred_noise in zip(views_batch, views_batch_wc, noise_pred_uncond.chunk(len(views_batch))):
h_start, h_end, w_start, w_end = view
n_t, n_b, n_l, n_r = view_wc
s_h = (n_t, view_pred_noise.shape[-2] - n_b)
s_w = (n_l, view_pred_noise.shape[-1] - n_r)
non_zero_maks = local_uncond_noise_val[:, :, h_start:h_end, w_start:w_end] != 0
local_uncond_noise_val[:, :, h_start:h_end, w_start:w_end][~non_zero_maks] = \
view_pred_noise[:, :, s_h[0]:s_h[1], s_w[0]:s_w[1]][~non_zero_maks].to(local_uncond_noise_val.dtype)
return local_uncond_noise_val
@timelog.time_function
def nearest_interpolate(self, x, size, bottom=False, right=False, mode='nearest'):
"""nearest interpolate with different corresponding pixels to choose top-left, top-right, bottom-left, or bottom-right"""
if bottom:
x = torch.flip(x, [2])
if right:
x = torch.flip(x, [3])
x = F.interpolate(x, size=size, mode=mode)
if bottom:
x = torch.flip(x, [2])
if right:
x = torch.flip(x, [3])
return x
@timelog.time_function
def reduced_resolution_guidance(self, global_latent, t, global_direction,
latent_x0_original, uncond_text_embeds, negative_pooled_prompt_embeds,
view_config, guidance_scale, rrg_scale,
factor=None, downsample_size=None, bottom=False, right=False, text_embeds=None, min_H=-0, min_W=0,
donwsampled_scores=None):
if downsample_size is None:
downsample_size = self.compute_downsampling_size(global_latent, scale_factor=1/factor)
if donwsampled_scores is None:
H, W = downsample_size
H = max(H, min_H)
W = max(W, min_W)
global_latent_downsampled = self.nearest_interpolate(global_latent, size=(H, W), bottom=bottom, right=right)
input_latent = global_latent_downsampled
direction = self.nearest_interpolate(global_direction, size=(H, W), bottom=bottom, right=right)
local_uncond_noise = self.compute_local_uncond_signal(input_latent, t,
uncond_text_embeds, negative_pooled_prompt_embeds,
view_config)
else:
input_latent = donwsampled_scores['latent']
direction = donwsampled_scores['direction']
local_uncond_noise = donwsampled_scores['uncond_score']
H, W = direction.shape[-1], direction.shape[-2]
H = max(H, min_H)
W = max(W, min_W)
global_noise_pred = local_uncond_noise + guidance_scale * direction
ddim_out = self.scheduler.step(global_noise_pred, t, input_latent)
ref_x0_original = ddim_out['pred_original_sample']
ref_x0_original_upsampled = self.nearest_interpolate(ref_x0_original,
size=(latent_x0_original.shape[-2], latent_x0_original.shape[-1]),
mode='nearest')
added_grad_list = []
for j in range(len(global_latent)):
with torch.enable_grad():
dummy_pred = latent_x0_original[j:j+1].clone().detach()
dummy_pred = dummy_pred.requires_grad_(requires_grad=True)
loss = rrg_scale * torch.nn.functional.mse_loss(ref_x0_original_upsampled[j:j+1], dummy_pred)
loss.backward()
added_grad = dummy_pred.grad.clone() * -1.
added_grad_list.append(added_grad)
added_grad = torch.cat(added_grad_list)
return added_grad, {"x0" : [ref_x0_original], "rrg_latent_out": [ddim_out['prev_sample']]}
def get_downsample_size(self, H, W):
if 'XL' in self.sd_version:
factor = max(H, W) / 1024
else:
factor = max(H, W) / 512
factor = max(factor, 1)
return (int((H // factor) // self.vae_scale_factor), int((W // factor) // self.vae_scale_factor))
@torch.no_grad()
def generate_image(self, prompts, negative_prompts='',
height=768, width=768,
num_inference_steps=50,
guidance_scale=10.0,
resampling_steps=20,
new_p=0.3, rrg_stop_t=0.2,
rrg_init_weight=1000,
rrg_scherduler_cls=CosineScheduler,
cosine_scale=3.0,
repaint_sampling=True,
progress=tqdm,
tiled_decoder=False,
grid=False):
self.random_downasmple_pre = {}
downsample_size = self.get_downsample_size(height, width)
self.default_size = (4*height, 4*width)
view_config = self.view_config
if rrg_scherduler_cls == CosineScheduler:
rrg_scheduler = rrg_scherduler_cls(steps=num_inference_steps - int(num_inference_steps * rrg_stop_t),
cosine_scale=cosine_scale,
factor=rrg_init_weight)
else:
rrg_scheduler = rrg_scherduler_cls(steps=num_inference_steps - int(num_inference_steps * rrg_stop_t),
start_val=rrg_init_weight,
stop_val=0)
if isinstance(prompts, str):
prompts = [prompts]
if isinstance(negative_prompts, str):
negative_prompts = [negative_prompts] * len(prompts)
if self.low_vram:
self.vae.cpu()
self.unet.cpu()
self.text_encoder = [encoder.to(self.device) for encoder in self.text_encoder]
uncond_text_embeds, negative_pooled_prompt_embeds = self.get_text_embeds(negative_prompts)
cond_text_embeds, pooled_prompt_embeds= self.get_text_embeds(prompts)
text_embeds = torch.cat([uncond_text_embeds, cond_text_embeds])
add_text_embeds = torch.cat([negative_pooled_prompt_embeds, pooled_prompt_embeds], dim=0)
global_latent = torch.randn((len(prompts), self.unet.config.in_channels, height // self.vae_scale_factor, width // self.vae_scale_factor),
device=self.device,
dtype=self.torch_dtype)
self.scheduler.set_timesteps(num_inference_steps)
init_downsampled_latent = None
intermediate_x0_imgs = []
intermediate_cascade_x0_imgs_lst = {}
if self.low_vram:
self.text_encoder = [encoder.cpu() for encoder in self.text_encoder]
self.vae.cpu()
self.unet.to(self.device)
with torch.autocast('cuda', enabled=(self.device.type=='cuda')):
for i, t in enumerate(progress(self.scheduler.timesteps)):
#################### Estimate directions ####################
cur_resampling_steps = resampling_steps
global_direction, approximation_info = self.approximate_latent_direction_w_resampling(global_latent, t, text_embeds,
resampling_steps=cur_resampling_steps,
downsample_size=downsample_size,
add_text_embeds=add_text_embeds,
drop_p=1-new_p)
if init_downsampled_latent is None:
init_downsampled_latent = approximation_info['init_downsampled_latent']
local_uncond_noise = self.compute_local_uncond_signal(global_latent, t,
uncond_text_embeds, negative_pooled_prompt_embeds,
view_config)
global_noise_pred = local_uncond_noise + guidance_scale * global_direction
ddim_out = self.scheduler.step(global_noise_pred, t, global_latent)
latent_x0_original = ddim_out['pred_original_sample']
global_latent_nxt = ddim_out['prev_sample']
rrg_cfg = guidance_scale
if repaint_sampling and cur_resampling_steps > 0 and i < len(self.scheduler.timesteps) - 1:
global_latent = ddim_out['prev_sample']
global_latent = self.undo_step(global_latent, self.scheduler.timesteps[i+1])
rrg_cfg = guidance_scale / 3
global_direction, approximation_info = self.approximate_latent_direction_w_resampling(global_latent, t, text_embeds,
resampling_steps=0,
downsample_size=downsample_size,
add_text_embeds=add_text_embeds,
drop_p=1-new_p)
local_uncond_noise = self.compute_local_uncond_signal(global_latent, t,
uncond_text_embeds, negative_pooled_prompt_embeds,
view_config)
global_noise_pred = local_uncond_noise + rrg_cfg * global_direction
ddim_out = self.scheduler.step(global_noise_pred, t, global_latent)
latent_x0_original = ddim_out['pred_original_sample']
global_latent_nxt = ddim_out['prev_sample']
if self.verbose and i % self.log_freq == 0:
intermediate_x0_imgs.append(latent_x0_original.cpu())
cascade_dir = torch.zeros_like(global_latent_nxt)
if rrg_scheduler(i) > 10:
donwsampled_scores = {"latent":approximation_info['downsampled_latent'],
"uncond_score": approximation_info['scores']['uncond_score'],
"direction": approximation_info['downsampled_direction']}
cascade_dir, cascade_info = self.reduced_resolution_guidance(global_latent, t, global_direction,
latent_x0_original, uncond_text_embeds, negative_pooled_prompt_embeds,
view_config, downsample_size=downsample_size, rrg_scale=rrg_scheduler(i),
guidance_scale=rrg_cfg, text_embeds=text_embeds,
donwsampled_scores=donwsampled_scores, bottom=False, right=False)
if self.verbose and i % self.log_freq == 0:
lst = intermediate_cascade_x0_imgs_lst.get('rrg', [])
lst.append(cascade_info['x0'][0].cpu())
intermediate_cascade_x0_imgs_lst['rrg'] = lst
global_latent = global_latent_nxt + cascade_dir
#upcast vae
needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast
if self.low_vram:
# needs_upcasting = False
self.unet.cpu()
self.vae.to(self.device)
if needs_upcasting:
self.upcast_vae()
decode_bs = 1
decode_fn = self.tiled_decode if tiled_decoder else self.decode_latents
image_log = {}
if self.verbose:
if init_downsampled_latent is not None:
image_log['global_img'], generation_info = self.generate(init_downsampled_latent, text_embeds, add_text_embeds, guidance_scale=guidance_scale)
if 'inter_x0' in generation_info:
inter_x0_decoded = torch.cat([decode_fn(torch.cat(generation_info['inter_x0'][i:i+decode_bs]).to(self.device)) \
for i in range(0, len(generation_info['inter_x0']), decode_bs)])
image_log['global_img_inter_x0_imgs'] = T.ToPILImage()(make_grid(inter_x0_decoded,
nrows=len(generation_info['inter_x0']),
normalize=False).cpu())
if intermediate_x0_imgs:
inter_x0_decoded = torch.cat([decode_fn(torch.cat(intermediate_x0_imgs[i:i+decode_bs]).to(self.device)) \
for i in range(0, len(intermediate_x0_imgs), decode_bs)])
inter_x0_decoded = torch.clip(inter_x0_decoded, 0, 1)
image_log['intermediate_x0_imgs'] = T.ToPILImage()(make_grid(inter_x0_decoded,
nrows=len(intermediate_x0_imgs),
normalize=False).cpu())
image_log['intermediate_cascade_x0_imgs'] = {}
for factor, intermediate_cascade_x0_imgs in intermediate_cascade_x0_imgs_lst.items():
inter_cascade_x0_decoded = torch.cat([decode_fn(torch.cat(intermediate_cascade_x0_imgs[i:i+decode_bs]).to(self.device)) \
for i in range(0, len(intermediate_cascade_x0_imgs), decode_bs)])
image_log['intermediate_cascade_x0_imgs'][factor] = T.ToPILImage()(make_grid(inter_cascade_x0_decoded,
nrows=len(intermediate_cascade_x0_imgs),
normalize=False).cpu())
# Img latents -> imgs
imgs = torch.cat([decode_fn(global_latent[i:i+decode_bs]) for i in range(0, len(global_latent), decode_bs)])
if grid:
imgs = [make_grid(imgs, nrows=len(imgs), normalize=False)]
imgs = [T.ToPILImage()(img.cpu()) for img in imgs]
if needs_upcasting:
self.vae.to(dtype=torch.float16)
return imgs, image_log
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--prompt', type=str, default="A realistic portrait of a young black woman. she has a Christmas red hat and a red scarf. Her eyes are light brown like they're almost caramel color. Her attire, simple yet dignified.")
parser.add_argument('--negative', type=str, default='blurry, ugly, duplicate, no details, deformed')
parser.add_argument('--sd_version', type=str, default='XL1.0', choices=['1.4', '1.5', '2.0', '2.1', 'XL1.0'],
help="stable diffusion version stable diffusion version ['1.4', '1.5', '2.0', '2.1', or 'XL1.0'] or a model key for a huggingface stable diffusion version")
parser.add_argument('--H', type=int, default=2048)
parser.add_argument('--W', type=int, default=2048)
parser.add_argument('--low_vram', type=bool, default=True, help="run with half percision on low memeory mode")
parser.add_argument('--seed', type=int, default=0)
parser.add_argument('--steps', type=int, default=50)
parser.add_argument('--num_sampled', type=int, default=1)
parser.add_argument('--guidance_scale', type=float, default=10.0)
parser.add_argument('--cosine_scale', type=float, default=10.0, help='effective only with CosineScheduler')
parser.add_argument('--rrg_scale', type=float, default=4000)
parser.add_argument('--resampling_steps', type=int, default=10)
parser.add_argument('--new_p', type=float, default=0.3)
parser.add_argument('--rrg_stop_t', type=float, default=0.2)
parser.add_argument('--view_batch_size', type=int, default=16)
parser.add_argument('--outdir', type=str, default='../release_results_log/')
parser.add_argument('--make_grid', type=bool, default=False, help="make a grid of the output images")
parser.add_argument('--repaint_sampling', type=bool, default=True, help="")
parser.add_argument('--tiled_decoder', type=bool, default=True, help="")
parser.add_argument('--exp', type=str, default='ElasticDiffusion', help='experiment tag')
parser.add_argument('--tag', type=str, default='', help='identifier experiment tag')
parser.add_argument('--log_freq', type=int, default=5, help="log frequency of intermediate diffusion steps")
parser.add_argument('--verbose', type=bool, default=False)
opt = parser.parse_args()
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
if opt.verbose:
timelog.sync_gpu = opt.verbose # get accurate time log
sd = ElasticDiffusion(device,
opt.sd_version,
verbose=opt.verbose,
log_freq=opt.log_freq,
view_batch_size=opt.view_batch_size,
low_vram = opt.low_vram)
sd.seed_everything(opt.seed)
prompts = [opt.prompt] * opt.num_sampled
imgs, image_log = sd.generate_image(prompts=prompts, negative_prompts=opt.negative,
height=opt.H, width=opt.W,
num_inference_steps=opt.steps,
grid=opt.make_grid,
guidance_scale=opt.guidance_scale,
resampling_steps=opt.resampling_steps,
new_p=opt.new_p,
cosine_scale = opt.cosine_scale,
rrg_init_weight = opt.rrg_scale,
rrg_stop_t = opt.rrg_stop_t,
repaint_sampling=opt.repaint_sampling,
tiled_decoder=opt.tiled_decoder)
if opt.verbose:
timelog.print_results()
current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
save_dir = os.path.join(opt.outdir, opt.exp, f"{current_time}_{str(opt.seed)}")
os.makedirs(save_dir, exist_ok=True)
# save image
for i, img in enumerate(imgs):
img.save(f"{save_dir}/{i}.png")
for key, imgs in image_log.items():
if isinstance(imgs, dict):
[img.save(f"{save_dir}/{key}_{label}.png") for label, img in image_log[key].items()]
else:
image_log[key].save(f"{save_dir}/{key}.png")
# save meta
with open(f"{save_dir}/args.txt", 'w') as f:
args_str = '\n'.join(['{}: {}'.format(k, v) for k, v in vars(opt).items()])
f.write(args_str)
| [] |
2024-01-10 | CakKhoiron/Robby-chatbot | tuto_chatbot_csv.py | #pip install streamlit langchain openai faiss-cpu tiktoken
import streamlit as st
from streamlit_chat import message
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.document_loaders.csv_loader import CSVLoader
from langchain.vectorstores import FAISS
import tempfile
import os
user_api_key = st.sidebar.text_input(
label="#### Your OpenAI API key 👇",
placeholder="Paste your openAI API key, sk-",
type="password")
os.environ["OPENAI_API_KEY"] = user_api_key
uploaded_file = st.sidebar.file_uploader("upload", type="csv")
if uploaded_file :
with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
tmp_file.write(uploaded_file.getvalue())
tmp_file_path = tmp_file.name
loader = CSVLoader(file_path=tmp_file_path, encoding="utf-8")
data = loader.load()
embeddings = OpenAIEmbeddings()
vectors = FAISS.from_documents(data, embeddings)
chain = ConversationalRetrievalChain.from_llm(llm = ChatOpenAI(temperature=0.0,model_name='gpt-3.5-turbo', openai_api_key=user_api_key),
retriever=vectors.as_retriever())
def conversational_chat(query):
result = chain({"question": query, "chat_history": st.session_state['history']})
st.session_state['history'].append((query, result["answer"]))
return result["answer"]
if 'history' not in st.session_state:
st.session_state['history'] = []
if 'generated' not in st.session_state:
st.session_state['generated'] = ["Hello ! Ask me anything about " + uploaded_file.name + " 🤗"]
if 'past' not in st.session_state:
st.session_state['past'] = ["Hey ! 👋"]
#container for the chat history
response_container = st.container()
#container for the user's text input
container = st.container()
with container:
with st.form(key='my_form', clear_on_submit=True):
user_input = st.text_input("Query:", placeholder="Talk about your csv data here (:", key='input')
submit_button = st.form_submit_button(label='Send')
if submit_button and user_input:
output = conversational_chat(user_input)
st.session_state['past'].append(user_input)
st.session_state['generated'].append(output)
if st.session_state['generated']:
with response_container:
for i in range(len(st.session_state['generated'])):
message(st.session_state["past"][i], is_user=True, key=str(i) + '_user', avatar_style="big-smile")
message(st.session_state["generated"][i], key=str(i), avatar_style="thumbs")
#streamlit run tuto_chatbot_csv.py
| [] |
2024-01-10 | CakKhoiron/Robby-chatbot | src~pages~3_%F0%9F%8E%AC%20Robby-Youtube.py | import os
import streamlit as st
import re
from modules.layout import Layout
from modules.utils import Utilities
from modules.sidebar import Sidebar
from youtube_transcript_api import YouTubeTranscriptApi
from langchain.chains.summarize import load_summarize_chain
from langchain.chains import AnalyzeDocumentChain
from youtube_transcript_api import YouTubeTranscriptApi
from langchain.llms import OpenAI
import os
from langchain.text_splitter import CharacterTextSplitter
st.set_page_config(layout="wide", page_icon="💬", page_title="Robby | Chat-Bot 🤖")
# Instantiate the main components
layout, sidebar, utils = Layout(), Sidebar(), Utilities()
st.markdown(
f"""
<h1 style='text-align: center;'> Ask Robby to summarize youtube video ! 😁</h1>
""",
unsafe_allow_html=True,
)
user_api_key = utils.load_api_key()
sidebar.about()
if not user_api_key:
layout.show_api_key_missing()
else:
os.environ["OPENAI_API_KEY"] = user_api_key
script_docs = []
def get_youtube_id(url):
video_id = None
match = re.search(r"(?<=v=)[^&#]+", url)
if match :
video_id = match.group()
else :
match = re.search(r"(?<=youtu.be/)[^&#]+", url)
if match :
video_id = match.group()
return video_id
video_url = st.text_input(placeholder="Enter Youtube Video URL", label_visibility="hidden", label =" ")
if video_url :
video_id = get_youtube_id(video_url)
if video_id != "":
t = YouTubeTranscriptApi.get_transcript(video_id, languages=('en','fr','es', 'zh-cn', 'hi', 'ar', 'bn', 'ru', 'pt', 'sw' ))
finalString = ""
for item in t:
text = item['text']
finalString += text + " "
text_splitter = CharacterTextSplitter()
chunks = text_splitter.split_text(finalString)
summary_chain = load_summarize_chain(OpenAI(temperature=0),
chain_type="map_reduce",verbose=True)
summarize_document_chain = AnalyzeDocumentChain(combine_docs_chain=summary_chain)
answer = summarize_document_chain.run(chunks)
st.subheader(answer)
| [] |
2024-01-10 | tzteyang/GraduationProject | BaiduTop.py | import random
import time
import jsonlines
import json
import tiktoken
import openai
import os
from SeleniumInit import SeleniumInit
from lxml import etree
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from get_content import GetInfo
from svm_model import text_filter
from transformers import AutoTokenizer
from tqdm import tqdm
from utls.selenium_tool import selenium_entity
from info_extract import top_content_clean
from web_page_preprocess import noisy_text_clean
class BaiDuTop():
"""百度top5搜索结果返回"""
def __init__(self, expert) -> None:
self.expert = expert
# self.url = f"https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&tn=baidu&wd={expert['name']}%20{expert['institute']}&oq=%25E8%2582%2596%25E6%2581%2592%25E4%25BE%25A8%2520%25E6%25B5%2599%25E6%25B1%259F%25E7%259C%2581%25E5%258C%2596%25E5%25B7%25A5%25E7%25A0%2594%25E7%25A9%25B6%25E9%2599%25A2%25E6%259C%2589%25E9%2599%2590%25E5%2585%25AC%25E5%258F%25B8&rsv_pq=f834336f00015541&rsv_t=8d70cS7osmXXImOBws0Bhy9AbGS5Shi%2FBnH3TYydqM2cEUJW7%2Fj0OfmzlJc&rqlang=cn&rsv_dl=tb&rsv_enter=0&rsv_btype=t" if expert else ''
self.url = 'https://www.baidu.com/'
self.selInit = selenium_entity()
self.selInit.browser_run(url=self.url)
self.time_sleep(1, 1.5)
input_el = self.selInit.browser.find_elements(By.XPATH, '//input[@id="kw"]')[0]
input_el.send_keys(f"{expert['name']} {expert['scholar_institute']}")
self.time_sleep(1.5, 2)
# input_el.send_keys(Keys.ENTER)
search_el = self.selInit.browser.find_elements(By.XPATH, '//input[@id="su"]')[0]
search_el.click()
self.time_sleep(2, 2.5)
def time_sleep(self, a=1, b=3):
"""等待时间"""
time.sleep(random.uniform(a, b))
def get_el_prop_value(self, el, prop="innerHTML"):
"""获取标签属性内容"""
try:
_el = el
if "list" in str(type(el)):
_el = el[0]
return etree.HTML(_el.get_attribute(prop)).xpath('string(.)')
except Exception as e:
return None
def get_el(self, cover, xpath):
"""获取元素"""
try:
return cover.find_elements(By.XPATH, xpath)
except Exception as e:
return None
def change_window_handle(self, selInit):
"""切换窗口句柄
"""
handles = selInit.browser.window_handles # 获取当前浏览器的所有窗口句柄
selInit.browser.switch_to.window(handles[-1]) # 切换到最新打开的窗口
def getInfoTop(self, top):
"""top限制最大为10"""
if top > 10:
top = 10
# self.selInit.page_parse(url=self.selInit.browser.current_url)
title_xpath = '//h3[contains(@class, "c-title")]/a'
# 获取title元素
title_el_list = self.get_el(cover=self.selInit.browser, xpath=title_xpath)
url_list = []
for title_el in title_el_list[:top]:
try:
title = self.get_el_prop_value(el=title_el)
url = self.get_el_prop_value(el=title_el, prop="href")
print("虚假url：", url)
title_el.click()
self.time_sleep(1,2)
except Exception as e:
print('标题元素获取异常:\n', str(e))
continue
try:
self.change_window_handle(selInit=self.selInit)
except Exception as e:
print('浏览器窗口切换异常:\n',str(e))
continue
real_url = ""
wait = True
cnt = 0
while wait and cnt < 20:
try:
real_url = self.selInit.browser.current_url
print("真实url：", real_url)
wait = False
except Exception as e:
print('当前页面url获取异常:\n', str(e))
cnt += 1
time.sleep(1)
self.selInit.browser.close() # 关闭当前窗口
self.change_window_handle(selInit=self.selInit)
if real_url != '':
url_list.append({"title":title, "url":real_url})
self.selInit.browser_close()
return url_list
def main_info_check(experts_list):
for expert in experts_list:
main_info = 0
check = lambda x: 0 if x == [] or x == None else 1
if 'graduate_university' in expert:
main_info |= check(expert['graduate_university'])
if 'scholar_history' in expert:
main_info |= check(expert['scholar_history'])
if 'scholar_brief_info' in expert:
main_info |= check(expert['scholar_brief_info'])
if 'major_achievement_list' in expert:
main_info |= check(expert['major_achievement_list'])
expert['main_info'] = main_info
return experts_list
def run():
tokenizer = AutoTokenizer.from_pretrained('gpt2')
# 测试数据入口
experts_list = random.sample(list(jsonlines.open('./Data/res_04_28.jsonl')), 10)
experts_list = main_info_check(experts_list)
# experts_list = [expert for expert in main_info_check(experts_list) if expert['main_info'] == 0]
# print(len(experts_list))
for expert in tqdm(experts_list):
print('\n当前处理专家:\n', expert)
if expert['main_info'] == 1:
with open('./Data/gpt_extract_res_test_ner_v1.json', 'a', encoding='utf-8') as f:
f.write(json.dumps(expert, ensure_ascii=False) + '\n')
continue
start = time.time()
wait = True
cnt = 0
while wait and cnt < 10:
try:
info_list = BaiDuTop(expert=expert).getInfoTop(top=5)
wait = False
except Exception as e:
print('网络连接异常:\n', str(e))
cnt += 1
time.sleep(1)
if cnt >= 10:
print('当前处理网络请求超时重试次数达到上限...')
continue
index, tokens_count = 0, 0
print('\n当前专家网页文本开始过滤...')
extract_info_list = []
for info in info_list:
index += 1
info["content"] = GetInfo(info["url"]).get_page_content()
info["expert_name"] = expert["name"]
if isinstance(info["content"], str) and not info["expert_name"] in info["content"]:
print("当前网页内容文本不包含目标专家实体，跳过处理...")
continue
print('\n当前专家分网页预处理开始...')
if "AllBulletinDetail" in info["url"]:
continue
info["content"] = noisy_text_clean(info["content"], info["expert_name"]) # 网页内容预处理
# print(info["content"])
filtered = text_filter(info)
token_ids = tokenizer.encode(filtered)
tokens_count = len(tokenizer.encode(filtered, truncation=False))
# 生成日志数据
data_in = {
'id': expert['id'],
'name': expert['name'],
'institute': expert['scholar_institute'],
'filtered_content': filtered,
'tokens': tokens_count,
'page_index': index,
'url': info['url'],
'main_info': expert['main_info']
}
extract_info_list.append(data_in)
with open('./Data/cleaned_text_res1000_ner_v1.json', 'a', encoding='utf-8') as f:
f.write(json.dumps(data_in, ensure_ascii=False))
f.write('\n')
# with jsonlines.open("./Data/origin_text_res1000.jsonl", 'a') as f:
# f.write(info)
print('\n当前专家开始gpt信息抽取...')
extract_res_list = top_content_clean(extract_info_list)
for extract_res in extract_res_list:
if '当前任职' in extract_res and extract_res['当前任职'] != 'unk':
if 'occupation' in expert and isinstance(expert['occupation'], list):
expert['occupation'].append({
'content': extract_res['当前任职'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
})
else:
expert['occupation'] = [{
'content': extract_res['当前任职'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
}]
if '教育工作履历' in extract_res and extract_res['教育工作履历'] != 'unk':
if 'scholar_history' in expert and isinstance(expert['scholar_history'], list):
expert['scholar_history'].append({
'content': extract_res['教育工作履历'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
})
else:
expert['scholar_history'] = [{
'content': extract_res['教育工作履历'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
}]
if 'scholar_history_source' in expert and isinstance(expert['scholar_history_source'], list):
expert['scholar_history_source'].append(extract_res['url'])
else:
expert['scholar_history_source'] = [extract_res['url']]
if '个人简介' in extract_res and extract_res['个人简介'] != 'unk':
if 'scholar_brief_info' in expert and isinstance(expert['scholar_brief_info'], list):
expert['scholar_brief_info'].append({
'content': extract_res['个人简介'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
})
else:
expert['scholar_brief_info'] = [{
'content': extract_res['个人简介'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
}]
if 'scholar_brief_info_source' in expert and isinstance(expert['scholar_brief_info_source'], list):
expert['scholar_brief_info_source'].append(extract_res['url'])
else:
expert['scholar_brief_info_source'] = [extract_res['url']]
if '奖项成就' in extract_res and extract_res['奖项成就'] != 'unk':
if 'major_achievement_list' in expert and isinstance(expert['major_achievement_list'], list):
expert['major_achievement_list'].append({
'content': extract_res['奖项成就'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
})
else:
expert['major_achievement_list'] = [{
'content': extract_res['奖项成就'],
'url': extract_res['url'],
'tag': 'gpt-3.5-turbo'
}]
if 'major_achievement_list_source'in expert and isinstance(expert['major_achievement_list_source'], list):
expert['major_achievement_list_source'].append(extract_res['url'])
else:
expert['major_achievement_list_source'] = [extract_res['url']]
end = time.time()
print("\n处理耗时: {:.2f} 秒".format(end - start))
with open('./Data/gpt_extract_res_ner_v1.json', 'a', encoding='utf-8') as f:
f.write(json.dumps(expert, ensure_ascii=False) + '\n')
if __name__ == '__main__':
run()
| [] |
2024-01-10 | tzteyang/GraduationProject | info_extract.py | import time
import tiktoken
import jsonlines
import openai
import os
import sys
import json
from pathlib import Path
from transformers import AutoTokenizer
from tqdm import tqdm
BASE_DIR = str(Path(__file__).resolve().parent)
sys.path.append(BASE_DIR)
PROMPT_FILE = BASE_DIR + '/few_shot_prompt.txt'
RET_FILE = BASE_DIR + '/Data/extract_res_1000_0428.json'
tokenizer = AutoTokenizer.from_pretrained('gpt2')
def get_key():
return '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'
def openai_query(content, apikey):
os.environ["http_proxy"] = "127.0.0.1:7890"
os.environ["https_proxy"] = "127.0.0.1:7890"
openai.api_key = apikey
cnt = 0
while cnt < 10:
try:
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo", # gpt-3.5-turbo-0301
messages=[
{"role": "user", "content": content}
],
temperature=0.15, # 控制生成的随机性 0-1越高随机性越强
max_tokens=832, # 生成内容的最大token限制
frequency_penalty=0,
presence_penalty=0,
)
del os.environ["http_proxy"]
del os.environ["https_proxy"]
return response.choices[0].message.content
except Exception as e:
cnt += 1
time.sleep(5)
print('openai接口请求出错或请求过快:\n',str(e))
del os.environ["http_proxy"]
del os.environ["https_proxy"]
def text_to_chunks(text, chunk_size=2000, overlap=100):
token_ids = tokenizer.encode(text, truncation=False)
# print(token_ids)
# print(tokenizer.decode(token_ids))
tokens_count = len(token_ids)
chunks = []
for i in range(0, tokens_count, chunk_size-overlap):
chunk = token_ids[i:(i + chunk_size)]
chunks.append(chunk)
return chunks
def top_content_clean(info_list):
extract_res_list = []
for info in tqdm(info_list):
if info['filtered_content'] == '': continue
text = info['filtered_content']
chunks = text_to_chunks(text)
cleaned_text = ""
index = 0
for chunk in chunks:
index += 1
with open(PROMPT_FILE, 'r', encoding='utf-8') as f:
prompt = f.read()
prompt = prompt.replace('{{person}}', info['name'])
prompt_ids = tokenizer.encode(prompt, truncation=False)
print(len(prompt_ids))
prompt = prompt.replace('{{text}}', tokenizer.decode(chunk)).replace('<SEP>', ' ')
print(prompt + '\n' + '=' * 30)
completion = openai_query(prompt, get_key())
try:
completion_json = json.loads(completion)
completion_json['id'] = info['id']
completion_json['chunk_index'] = index
completion_json['url'] = info['url']
completion_json['name'] = info['name']
completion_json['institute'] = info['institute']
completion_json['main_info'] = info['main_info']
extract_res_list.append(completion_json)
with open('./Data/extract_res_1000_ner_v1json', 'a', encoding='utf-8') as f:
f.write(json.dumps(completion_json, ensure_ascii=False))
f.write('\n')
except Exception as e:
print('\napi返回格式有误\n'+str(e))
return extract_res_list
def value_check(value):
# if value == '' or value == '空' or '未在文本中出现' in value:
if value == 'unk':
return False
return True
def hit_rate_calculate():
extract_datas = []
with open(RET_FILE, 'r', encoding='utf-8') as f:
for line in f.readlines():
extract_datas.append(json.loads(line))
# 按照姓名分组处理
grouped_datas, group = [], []
last_name = ''
for data in extract_datas:
if last_name != '' and data['name'] != last_name:
grouped_datas.append(group.copy()) # 注意要添加列表的浅拷贝
group.clear()
group.append(data)
last_name = data['name']
grouped_datas.append(group)
# print(grouped_datas[:10])
# print(len(grouped_datas))
occupation, edu_background, resume, achievement, main_info = 0, 0, 0, 0, 0
count = 0
cred, part_cred, uncred = 0, 0, 0
for group in grouped_datas:
o_tag, e_tag, r_tag, a_tag = False, False, False, False
for data in group:
o_tag |= value_check(data['当前职位'])
e_tag |= value_check(data['工作教育履历'])
if '个人简介' in data:
r_tag |= value_check(data['个人简介'])
if '个人简历' in data:
r_tag |= value_check(data['个人简历'])
a_tag |= value_check(data['奖项成就'])
count += 1 if (o_tag or e_tag or r_tag or a_tag) else 0
occupation += 1 if o_tag else 0
edu_background += 1 if e_tag else 0
resume += 1 if r_tag else 0
achievement += 1 if a_tag else 0
main_info += 1 if (e_tag or r_tag or a_tag) else 0
# if e_tag or r_tag or a_tag:
# cred_tag, uncred_tag = 0, 0
# for data in group:
# o2_tag, e2_tag, r2_tag, a2_tag = False, False, False, False
# o2_tag |= value_check(data['当前职位'])
# e2_tag |= value_check(data['工作教育履历'])
# if '个人简介' in data:
# r2_tag |= value_check(data['个人简介'])
# if '个人简历' in data:
# r2_tag |= value_check(data['个人简历'])
# a2_tag |= value_check(data['奖项成就'])
# if data['cred'] == 1:
# cred_tag += 1
# else:
# uncred_tag += 1
# if cred_tag == len(group):
# cred += 1
# elif uncred_tag == len(group):
# uncred += 1
# else:
# part_cred += 1
# assert(cred_tag + uncred_tag == len(group))
# print(group)
# print(cred_tag, uncred_tag, len(group))
# print('=' * 30)
# print('gpt抽取流程准确率:')
# print(f'完全正确: {cred}/{main_info}, 概率: {cred/main_info}')
# print(f'部分正确: {part_cred}/{main_info}, 概率: {part_cred/main_info}')
# print(f'不正确: {uncred}/{main_info}, 概率: {uncred/main_info}')
print('=' * 30)
print(f'主要关注字段得到补充的专家数: {main_info}')
print(f'任职 字段得到补充的专家数: {occupation}')
print(f'工作教育履历 字段得到补充的专家数: {edu_background}')
print(f'个人简介 字段得到补充的专家数: {resume}')
print(f'奖项成就 字段得到补充的专家数: {achievement}')
"""
v1
任意字段得到补充的专家数: 47
任职 字段得到补充的专家数: 36
毕业院校 字段得到补充的专家数: 16
个人履历 字段得到补充的专家数: 26
研究领域 字段得到补充的专家数: 21
奖项成就 字段得到补充的专家数: 19
v2
任意字段得到补充的专家数: 49
任职 字段得到补充的专家数: 43
毕业院校 字段得到补充的专家数: 17
个人履历 字段得到补充的专家数: 21
研究领域 字段得到补充的专家数: 15
奖项成就 字段得到补充的专家数: 13
v3-0428
主要关注字段得到补充的专家数: 134
任职 字段得到补充的专家数: 148
工作教育履历 字段得到补充的专家数: 91
个人简介 字段得到补充的专家数: 107
奖项成就 字段得到补充的专家数: 80
"""
"""
5/47
科研之友网站
badcase的原因：
1. ner工具的准确率问题，漏掉某些人物实体，带进了干扰噪声。
2. 文本切块时，将关键人物姓名和其个人信息分隔开来，造成了错误的抽取。
"""
if __name__ == '__main__':
# pass
# top_content_clean()
hit_rate_calculate()
| [
"{{person}}",
"name",
" ",
"PLACEHOLDER/few_shot_prompt.txt"
] |
2024-01-10 | tzteyang/GraduationProject | ExpertCrawl~BaikeCrawl~utils~SentenceSimilarity.py | # -*- coding:utf-8 -*-
import openai
import sys
import json
import time
def get_key():
return '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'
def prompt_pretreatment(query: str, candidates: list):
similarity_prompt = "我将向你提供一个查询语句和一个候选语句列表，请你从语义相似和内容相似两个方面综合考虑选出候选语句列表中与查询语句匹配程度最高的候选项。\n" \
"请将返回结果格式调整为json格式。\n" \
"例如：匹配成功，返回结果{\"code\": \"succ\",\"sentence\": \"匹配程度最高的候选语句\"}。匹配失败，返回结果{\"code\": \"fail\",\"sentence\": \"\"}。\n" \
"注意: 请不要输出除我要求格式以外的任何其它内容。请你输出候选语句中成功匹配的候选项时，不要对候选项本身的内容做任何改动。\n" \
"查询语句: {q}。\n" \
"候选语句列表: {c}。"
similarity_prompt = similarity_prompt.replace("{q}", f"\"{query}\"")
# candidates_list = str(candidates).replace('[', '')
# candidates_list = candidates_list.replace(']', '')
similarity_prompt = similarity_prompt.replace("{c}", str(candidates))
if len(similarity_prompt) > 3200:
similarity_prompt = similarity_prompt[:3200]
return similarity_prompt
def openai_query(content, apikey):
# 防止返回速率超过openai限制
time.sleep(2)
openai.api_key = apikey
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo", # gpt-3.5-turbo-0301
messages=[
{"role": "user", "content": content}
],
temperature=0.1, # 控制生成的随机性 0-1越高随机性越强
max_tokens=128, # 生成内容的最大token限制
top_p=1,
frequency_penalty=0,
presence_penalty=0,
)
print(response)
return response.choices[0].message.content
if __name__ == '__main__':
# temp_list = ['中国科学技术大学教授','江西赣锋锂业股份有限公司董事长，民建江西省委副主委']
# #
# prompt = prompt_pretreatment("江西赣锋锂业股份有限公司", temp_list)
# print(prompt)
# ans = openai_query(prompt, get_key())
# print(eval(ans))
pass
| [
"\"PLACEHOLDER\"",
"我将向你提供一个查询语句和一个候选语句列表，请你从语义相似和内容相似两个方面综合考虑选出候选语句列表中与查询语句匹配程度最高的候选项。\n请将返回结果格式调整为json格式。\n例如：匹配成功，返回结果{\"code\": \"succ\",\"sentence\": \"匹配程度最高的候选语句\"}。匹配失败，返回结果{\"code\": \"fail\",\"sentence\": \"\"}。\n注意: 请不要输出除我要求格式以外的任何其它内容。请你输出候选语句中成功匹配的候选项时，不要对候选项本身的内容做任何改动。\n查询语句: {q}。\n候选语句列表: {c}。"
] |
2024-01-10 | tzteyang/GraduationProject | name_entity_reg.py | # -*- coding: utf8 -*-
import json
import requests
import numpy as np
import time
from hanlp_restful import HanLPClient
# from info_extract import openai_query
# def name_reg_quick(text: str):
# nlp = HanLP.newSegment().enableNameRecognize(True)
# doc = nlp.seg(text)
# name_entitys = [elem.word for elem in doc if elem.nature.toString() == 'nr']
# print(name_entitys)
# return name_entitys
def name_reg_texsamrt(text: str):
obj = {
"str": text,
"options":
{
"input_spec":{"lang":"auto"},
"word_seg":{"enable":True},
"pos_tagging":{"enable":True,"alg":"log_linear"},
"ner":{"enable":True,"alg":"coarse.lua"},
"syntactic_parsing":{"enable":False},
"srl":{"enable":False},
"text_cat":{"enable":False},
},
}
req_str = json.dumps(obj).encode()
entitys = []
try:
url = "https://texsmart.qq.com/api"
r = requests.post(url, data=req_str).json()
# print(r["entity_list"])
entitys = [elem["str"] for elem in r["entity_list"] if elem["type"]["name"] == "person.generic"]
except Exception as e:
print('姓名实体识别Texsmart接口请求异常',str(e))
# print(entitys)
return entitys
def name_reg_hanlp(text: str):
# auth不填则匿名，zh中文，mul多语种
time.sleep(0.5)
HanLP = HanLPClient('https://www.hanlp.com/api', auth="MjUzNkBiYnMuaGFubHAuY29tOjNLODZoUWxCeVBBaHVtMFI=", language='zh')
ret_list = HanLP.parse(text, tasks='ner/msra')["ner/msra"]
# ret_np = np.array(ret_list)
entitys = [[entity for entity in ret if "PERSON" in entity] for ret in ret_list]
name_list = []
for sep in entitys:
for entity in sep:
name_list.append(entity[0])
# print(name_list)
return name_list
if __name__ == "__main__":
# name_reg_hanlp("�机分析和大偏差理论及其在金融保险中的应用电子邮箱：[email protected]黄健飞 副教授黄健飞，理学博士，副教授，校特聘教授，硕士生导师。2012年毕业于中国科学院数学与系统科学研究院，获博士学位；2013年至2016年在美国爱荷华大学从事生物统计方法的博士后研究工作。已主持完成国家自然科学基金2项，在研2项。已以第一作者或 2项，在研2项。已以第一作者或通讯作者身份在Genetics和Applied Numerical Mathematics等国际著名SCI期刊发表论文30多篇。目前担任中国仿真学会仿真算法专业委员会委员、江苏省计算数学学会常务理事、美国《数学评论》评论员、Inter.J.Model.Simul.Sci.Comput.")
# s = "#荣誉奖项 毕恩兵,博士,毕业于上海交通大学。2017年出任上海黎元新能源科技有限公司技术总监。主要研究方向包括新型低成本太阳能电池的工作机理研究、石墨烯和半导体等新型功能材料的开发、高效率太阳能电池器件的制备与应用。2018年2月26日入选2018年度上海市青年英才扬帆计划。"
# name_reg_hanlp(s)
# nlp=HanLP.newSegment().enableNameRecognize(True)
# doc = nlp.seg(s)
# print(doc)
pass | [] |
2024-01-10 | bmd1905/vietnamese_local_GPT_v2 | run_localGPT.py | import os
import logging
import click
import torch
import utils
from langdetect import detect
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain.llms import HuggingFacePipeline
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler # for streaming response
from langchain.callbacks.manager import CallbackManager
from nlp_preprocessing import Translation
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
from prompt_template_utils import get_prompt_template
# from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.vectorstores import Chroma
from transformers import (
GenerationConfig,
pipeline,
)
from load_models import (
load_quantized_model_awq,
load_quantized_model_gguf_ggml,
load_quantized_model_qptq,
load_full_model,
)
from constants import (
EMBEDDING_MODEL_NAME,
PERSIST_DIRECTORY,
MODEL_ID,
MODEL_BASENAME,
MAX_NEW_TOKENS,
MODELS_PATH,
CHROMA_SETTINGS
)
def load_model(device_type, model_id, model_basename=None, LOGGING=logging):
"""
Select a model for text generation using the HuggingFace library.
If you are running this for the first time, it will download a model for you.
subsequent runs will use the model from the disk.
Args:
device_type (str): Type of device to use, e.g., "cuda" for GPU or "cpu" for CPU.
model_id (str): Identifier of the model to load from HuggingFace's model hub.
model_basename (str, optional): Basename of the model if using quantized models.
Defaults to None.
Returns:
HuggingFacePipeline: A pipeline object for text generation using the loaded model.
Raises:
ValueError: If an unsupported model or device type is provided.
"""
logging.info(f"Loading Model: {model_id}, on: {device_type}")
logging.info("This action can take a few minutes!")
if model_basename is not None:
if ".gguf" in model_basename.lower():
print("Load quantized model gguf")
llm = load_quantized_model_gguf_ggml(model_id, model_basename, device_type, LOGGING)
return llm
elif ".ggml" in model_basename.lower():
print("Load quantized model ggml")
model, tokenizer = load_quantized_model_gguf_ggml(model_id, model_basename, device_type, LOGGING)
elif ".awq" in model_basename.lower():
print("Load quantized model awq")
model, tokenizer = load_quantized_model_awq(model_id, LOGGING)
else:
print("Load quantized model qptq")
model, tokenizer = load_quantized_model_qptq(model_id, model_basename, device_type, LOGGING)
else:
print("load_full_model")
model, tokenizer = load_full_model(model_id, model_basename, device_type, LOGGING)
# Load configuration from the model to avoid warnings
generation_config = GenerationConfig.from_pretrained(model_id)
# see here for details:
# https://huggingface.co/docs/transformers/
# main_classes/text_generation#transformers.GenerationConfig.from_pretrained.returns
# Create a pipeline for text generation
pipe = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
max_length=MAX_NEW_TOKENS,
temperature=0.2,
# top_p=0.95,
repetition_penalty=1.15,
generation_config=generation_config,
)
local_llm = HuggingFacePipeline(pipeline=pipe)
logging.info("Local LLM Loaded")
return local_llm
def retrieval_qa_pipline(device_type, use_history, promptTemplate_type="llama"):
"""
Initializes and returns a retrieval-based Question Answering (QA) pipeline.
This function sets up a QA system that retrieves relevant information using embeddings
from the HuggingFace library. It then answers questions based on the retrieved information.
Parameters:
- device_type (str): Specifies the type of device where the model will run, e.g., 'cpu', 'cuda', etc.
- use_history (bool): Flag to determine whether to use chat history or not.
Returns:
- RetrievalQA: An initialized retrieval-based QA system.
Notes:
- The function uses embeddings from the HuggingFace library, either instruction-based or regular.
- The Chroma class is used to load a vector store containing pre-computed embeddings.
- The retriever fetches relevant documents or data based on a query.
- The prompt and memory, obtained from the `get_prompt_template` function, might be used in the QA system.
- The model is loaded onto the specified device using its ID and basename.
- The QA system retrieves relevant documents using the retriever and then answers questions based on those documents.
"""
embeddings = HuggingFaceInstructEmbeddings(model_name=EMBEDDING_MODEL_NAME, model_kwargs={"device": device_type})
# uncomment the following line if you used HuggingFaceEmbeddings in the ingest.py
# embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL_NAME)
# load the vectorstore
db = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=embeddings,
client_settings=CHROMA_SETTINGS
)
retriever = db.as_retriever()
# get the prompt template and memory if set by the user.
prompt, memory = get_prompt_template(promptTemplate_type=promptTemplate_type, history=use_history)
# load the llm pipeline
llm = load_model(device_type, model_id=MODEL_ID, model_basename=MODEL_BASENAME, LOGGING=logging)
if use_history:
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff", # try other chains types as well. refine, map_reduce, map_rerank
retriever=retriever,
return_source_documents=True, # verbose=True,
callbacks=callback_manager,
chain_type_kwargs={"prompt": prompt, "memory": memory},
)
else:
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff", # try other chains types as well. refine, map_reduce, map_rerank
retriever=retriever,
return_source_documents=True, # verbose=True,
callbacks=callback_manager,
chain_type_kwargs={
"prompt": prompt,
},
)
return qa
# chose device typ to run on as well as to show source documents.
@click.command()
@click.option(
"--device_type",
default="cuda" if torch.cuda.is_available() else "cpu",
type=click.Choice(
[
"cpu",
"cuda",
"ipu",
"xpu",
"mkldnn",
"opengl",
"opencl",
"ideep",
"hip",
"ve",
"fpga",
"ort",
"xla",
"lazy",
"vulkan",
"mps",
"meta",
"hpu",
"mtia",
],
),
help="Device to run on. (Default is cuda)",
)
@click.option(
"--show_sources",
"-s",
is_flag=True,
help="Show sources along with answers (Default is False)",
)
@click.option(
"--use_history",
"-h",
is_flag=True,
help="Use history (Default is False)",
)
@click.option(
"--model_type",
default="llama",
type=click.Choice(
["llama", "mistral", "non_llama"],
),
help="model type, llama, mistral or non_llama",
)
@click.option(
"--save_qa",
is_flag=True,
help="whether to save Q&A pairs to a CSV file (Default is False)",
)
@click.option(
"--translate_output",
"-t",
is_flag=True,
help="translate answer to VN lang",
)
def main(device_type, show_sources, use_history, model_type, save_qa, translate_output):
"""
Implements the main information retrieval task for a localGPT.
This function sets up the QA system by loading the necessary embeddings, vectorstore, and LLM model.
It then enters an interactive loop where the user can input queries and receive answers. Optionally,
the source documents used to derive the answers can also be displayed.
Parameters:
- device_type (str): Specifies the type of device where the model will run, e.g., 'cpu', 'mps', 'cuda', etc.
- show_sources (bool): Flag to determine whether to display the source documents used for answering.
- use_history (bool): Flag to determine whether to use chat history or not.
Notes:
- Logging information includes the device type, whether source documents are displayed, and the use of history.
- If the models directory does not exist, it creates a new one to store models.
- The user can exit the interactive loop by entering "exit".
- The source documents are displayed if the show_sources flag is set to True.
"""
logging.info(f"Running on: {device_type}")
logging.info(f"Display Source Documents set to: {show_sources}")
logging.info(f"Use history set to: {use_history}")
# check if models directory do not exist, create a new one and store models here.
if not os.path.exists(MODELS_PATH):
os.mkdir(MODELS_PATH)
qa = retrieval_qa_pipline(device_type, use_history, promptTemplate_type=model_type)
translater = Translation(from_lang="en", to_lang='vi', mode='translate')
# Interactive questions and answers
while True:
query = input("\nEnter a query: ")
if query == "exit":
break
# Get the answer from the chain
res = qa(query)
answer, docs = res["result"], res["source_documents"]
# translate answer to VN
if translate_output:
if detect(answer) != 'vi':
ans_lang = detect(answer)
translater = Translation(from_lang=ans_lang, to_lang='vi', mode='translate')
answer = translater(answer)
# Print the result
print("\n\n> Question:")
print(query)
print("\n> Answer:")
print(answer)
if show_sources: # this is a flag that you can set to disable showing answers.
# # Print the relevant sources used for the answer
print("----------------------------------SOURCE DOCUMENTS---------------------------")
for document in docs:
print("\n> " + document.metadata["source"] + ":")
print(document.page_content)
print("----------------------------------SOURCE DOCUMENTS---------------------------")
# Log the Q&A to CSV only if save_qa is True
if save_qa:
utils.log_to_csv(query, answer)
if __name__ == "__main__":
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(filename)s:%(lineno)s - %(message)s", level=logging.INFO
)
main() | [] |
2024-01-10 | bmd1905/vietnamese_local_GPT_v2 | constants.py | import os
# from dotenv import load_dotenv
from chromadb.config import Settings
# https://python.langchain.com/en/latest/modules/indexes/document_loaders/examples/excel.html?highlight=xlsx#microsoft-excel
from langchain.document_loaders import CSVLoader, PDFMinerLoader, TextLoader, UnstructuredExcelLoader, Docx2txtLoader
from langchain.document_loaders import UnstructuredFileLoader, UnstructuredMarkdownLoader, JSONLoader
# load_dotenv()
ROOT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
# Define the folder for storing database
SOURCE_DIRECTORY = f"{ROOT_DIRECTORY}/SOURCE_DOCUMENTS"
PERSIST_DIRECTORY = f"{ROOT_DIRECTORY}/DB"
MODELS_PATH = "./models"
# Can be changed to a specific number
INGEST_THREADS = os.cpu_count() or 8
# Define the Chroma settings
CHROMA_SETTINGS = Settings(
anonymized_telemetry=False,
is_persistent=True,
)
# Context Window and Max New Tokens
CONTEXT_WINDOW_SIZE = 4096
MAX_NEW_TOKENS = int(CONTEXT_WINDOW_SIZE/4) #CONTEXT_WINDOW_SIZE
#### If you get a "not enough space in the buffer" error, you should reduce the values below, start with half of the original values and keep halving the value until the error stops appearing
N_GPU_LAYERS = 40 # Llama-2-70B has 83 layers
N_BATCH = 512
### From experimenting with the Llama-2-7B-Chat-GGML model on 8GB VRAM, these values work:
# N_GPU_LAYERS = 20
# N_BATCH = 512
# https://python.langchain.com/en/latest/_modules/langchain/document_loaders/excel.html#UnstructuredExcelLoader
DOCUMENT_MAP = {
".txt": TextLoader,
".md": UnstructuredMarkdownLoader,
".py": TextLoader,
# ".pdf": PDFMinerLoader,
".pdf": UnstructuredFileLoader,
".csv": CSVLoader,
".xls": UnstructuredExcelLoader,
".xlsx": UnstructuredExcelLoader,
".docx": Docx2txtLoader,
".doc": Docx2txtLoader,
".json": JSONLoader,
}
EMBEDDING_MODEL_NAME = "intfloat/multilingual-e5-base"
#MODEL_ID = "vilm/vinallama-7b-chat-GGUF"
#MODEL_BASENAME = "vinallama-7b-chat_q5_0.gguf"
MODEL_ID = "TheBloke/Mixtral-8x7B-Instruct-v0.1-GGUF"
MODEL_BASENAME = "mixtral-8x7b-instruct-v0.1.Q4_K_M.gguf"
| [] |
2024-01-10 | bmd1905/vietnamese_local_GPT_v2 | run_localGPT_API.py | import logging
import os
import shutil
import subprocess
import argparse
import torch
from flask import Flask, jsonify, request
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceInstructEmbeddings
# from langchain.embeddings import HuggingFaceEmbeddings
from run_localGPT import load_model
from prompt_template_utils import get_prompt_template
# from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.vectorstores import Chroma
from werkzeug.utils import secure_filename
from constants import CHROMA_SETTINGS, EMBEDDING_MODEL_NAME, PERSIST_DIRECTORY, MODEL_ID, MODEL_BASENAME
if torch.backends.mps.is_available():
DEVICE_TYPE = "mps"
elif torch.cuda.is_available():
DEVICE_TYPE = "cuda"
else:
DEVICE_TYPE = "cpu"
SHOW_SOURCES = True
logging.info(f"Running on: {DEVICE_TYPE}")
logging.info(f"Display Source Documents set to: {SHOW_SOURCES}")
EMBEDDINGS = HuggingFaceInstructEmbeddings(model_name=EMBEDDING_MODEL_NAME, model_kwargs={"device": DEVICE_TYPE})
# uncomment the following line if you used HuggingFaceEmbeddings in the ingest.py
# EMBEDDINGS = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL_NAME)
# if os.path.exists(PERSIST_DIRECTORY):
# try:
# shutil.rmtree(PERSIST_DIRECTORY)
# except OSError as e:
# print(f"Error: {e.filename} - {e.strerror}.")
# else:
# print("The directory does not exist")
# run_langest_commands = ["python", "ingest.py"]
# if DEVICE_TYPE == "cpu":
# run_langest_commands.append("--device_type")
# run_langest_commands.append(DEVICE_TYPE)
# result = subprocess.run(run_langest_commands, capture_output=True)
# if result.returncode != 0:
# raise FileNotFoundError(
# "No files were found inside SOURCE_DOCUMENTS, please put a starter file inside before starting the API!"
# )
# load the vectorstore
DB = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=EMBEDDINGS,
client_settings=CHROMA_SETTINGS,
)
RETRIEVER = DB.as_retriever()
LLM = load_model(device_type=DEVICE_TYPE, model_id=MODEL_ID, model_basename=MODEL_BASENAME)
prompt, memory = get_prompt_template(promptTemplate_type="llama", history=False)
QA = RetrievalQA.from_chain_type(
llm=LLM,
chain_type="stuff",
retriever=RETRIEVER,
return_source_documents=SHOW_SOURCES,
chain_type_kwargs={
"prompt": prompt,
},
)
app = Flask(__name__)
@app.route("/api/delete_source", methods=["GET"])
def delete_source_route():
folder_name = "SOURCE_DOCUMENTS"
if os.path.exists(folder_name):
shutil.rmtree(folder_name)
os.makedirs(folder_name)
return jsonify({"message": f"Folder '{folder_name}' successfully deleted and recreated."})
@app.route("/api/save_document", methods=["GET", "POST"])
def save_document_route():
if "document" not in request.files:
return "No document part", 400
file = request.files["document"]
if file.filename == "":
return "No selected file", 400
if file:
filename = secure_filename(file.filename)
folder_path = "SOURCE_DOCUMENTS"
if not os.path.exists(folder_path):
os.makedirs(folder_path)
file_path = os.path.join(folder_path, filename)
file.save(file_path)
return "File saved successfully", 200
@app.route("/api/run_ingest", methods=["GET"])
def run_ingest_route():
global DB
global RETRIEVER
global QA
try:
if os.path.exists(PERSIST_DIRECTORY):
try:
shutil.rmtree(PERSIST_DIRECTORY)
except OSError as e:
print(f"Error: {e.filename} - {e.strerror}.")
else:
print("The directory does not exist")
run_langest_commands = ["python", "ingest.py"]
if DEVICE_TYPE == "cpu":
run_langest_commands.append("--device_type")
run_langest_commands.append(DEVICE_TYPE)
result = subprocess.run(run_langest_commands, capture_output=True)
if result.returncode != 0:
return "Script execution failed: {}".format(result.stderr.decode("utf-8")), 500
# load the vectorstore
DB = Chroma(
persist_directory=PERSIST_DIRECTORY,
embedding_function=EMBEDDINGS,
client_settings=CHROMA_SETTINGS,
)
RETRIEVER = DB.as_retriever()
prompt, memory = get_prompt_template(promptTemplate_type="llama", history=False)
QA = RetrievalQA.from_chain_type(
llm=LLM,
chain_type="stuff",
retriever=RETRIEVER,
return_source_documents=SHOW_SOURCES,
chain_type_kwargs={
"prompt": prompt,
},
)
return "Script executed successfully: {}".format(result.stdout.decode("utf-8")), 200
except Exception as e:
return f"Error occurred: {str(e)}", 500
@app.route("/api/prompt_route", methods=["GET", "POST"])
def prompt_route():
global QA
user_prompt = request.form.get("user_prompt")
if user_prompt:
# print(f'User Prompt: {user_prompt}')
# Get the answer from the chain
res = QA(user_prompt)
answer, docs = res["result"], res["source_documents"]
prompt_response_dict = {
"Prompt": user_prompt,
"Answer": answer,
}
prompt_response_dict["Sources"] = []
for document in docs:
prompt_response_dict["Sources"].append(
(os.path.basename(str(document.metadata["source"])), str(document.page_content))
)
return jsonify(prompt_response_dict), 200
else:
return "No user prompt received", 400
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--port", type=int, default=5110, help="Port to run the API on. Defaults to 5110.")
parser.add_argument(
"--host",
type=str,
default="127.0.0.1",
help="Host to run the UI on. Defaults to 127.0.0.1. "
"Set to 0.0.0.0 to make the UI externally "
"accessible from other devices.",
)
args = parser.parse_args()
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(filename)s:%(lineno)s - %(message)s", level=logging.INFO
)
app.run(debug=False, host=args.host, port=args.port) | [
"user_prompt",
"{'Prompt': PLACEHOLDER, 'Answer': PLACEHOLDER}"
] |
2024-01-10 | bmd1905/vietnamese_local_GPT_v2 | load_models.py | import torch
from auto_gptq import AutoGPTQForCausalLM
from huggingface_hub import hf_hub_download
from langchain.llms import LlamaCpp
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
LlamaForCausalLM,
LlamaTokenizer,
)
from constants import CONTEXT_WINDOW_SIZE, MAX_NEW_TOKENS, N_GPU_LAYERS, N_BATCH, MODELS_PATH
def load_quantized_model_gguf_ggml(model_id, model_basename, device_type, logging):
"""
Load a GGUF/GGML quantized model using LlamaCpp.
This function attempts to load a GGUF/GGML quantized model using the LlamaCpp library.
If the model is of type GGML, and newer version of LLAMA-CPP is used which does not support GGML,
it logs a message indicating that LLAMA-CPP has dropped support for GGML.
Parameters:
- model_id (str): The identifier for the model on HuggingFace Hub.
- model_basename (str): The base name of the model file.
- device_type (str): The type of device where the model will run, e.g., 'mps', 'cuda', etc.
- logging (logging.Logger): Logger instance for logging messages.
Returns:
- LlamaCpp: An instance of the LlamaCpp model if successful, otherwise None.
Notes:
- The function uses the `hf_hub_download` function to download the model from the HuggingFace Hub.
- The number of GPU layers is set based on the device type.
"""
# try:
logging.info("Using Llamacpp for GGUF/GGML quantized models")
model_path = hf_hub_download(
repo_id=model_id,
filename=model_basename,
resume_download=True,
cache_dir=MODELS_PATH,
)
kwargs = {
"model_path": model_path,
"n_ctx": CONTEXT_WINDOW_SIZE,
"max_tokens": MAX_NEW_TOKENS,
"n_batch": N_BATCH, # set this based on your GPU & CPU RAM
}
if device_type.lower() == "mps":
kwargs["n_gpu_layers"] = 1
if device_type.lower() == "cuda":
kwargs["n_gpu_layers"] = N_GPU_LAYERS # set this based on your GPU
return LlamaCpp(**kwargs)
# except:
# if "ggml" in model_basename:
# logging.INFO("If you were using GGML model, LLAMA-CPP Dropped Support, Use GGUF Instead")
# return None
def load_quantized_model_qptq(model_id, model_basename, device_type, logging):
"""
Load a GPTQ quantized model using AutoGPTQForCausalLM.
This function loads a quantized model that ends with GPTQ and may have variations
of .no-act.order or .safetensors in their HuggingFace repo.
Parameters:
- model_id (str): The identifier for the model on HuggingFace Hub.
- model_basename (str): The base name of the model file.
- device_type (str): The type of device where the model will run.
- logging (logging.Logger): Logger instance for logging messages.
Returns:
- model (AutoGPTQForCausalLM): The loaded quantized model.
- tokenizer (AutoTokenizer): The tokenizer associated with the model.
Notes:
- The function checks for the ".safetensors" ending in the model_basename and removes it if present.
"""
# The code supports all huggingface models that ends with GPTQ and have some variation
# of .no-act.order or .safetensors in their HF repo.
logging.info("Using AutoGPTQForCausalLM for quantized models")
if ".safetensors" in model_basename:
# Remove the ".safetensors" ending if present
model_basename = model_basename.replace(".safetensors", "")
tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
logging.info("Tokenizer loaded")
model = AutoGPTQForCausalLM.from_quantized(
model_id,
model_basename=model_basename,
use_safetensors=True,
trust_remote_code=True,
device_map="auto",
use_triton=False,
quantize_config=None,
inject_fused_attention=False
)
return model, tokenizer
def load_full_model(model_id, model_basename, device_type, logging):
"""
Load a full model using either LlamaTokenizer or AutoModelForCausalLM.
This function loads a full model based on the specified device type.
If the device type is 'mps' or 'cpu', it uses LlamaTokenizer and LlamaForCausalLM.
Otherwise, it uses AutoModelForCausalLM.
Parameters:
- model_id (str): The identifier for the model on HuggingFace Hub.
- model_basename (str): The base name of the model file.
- device_type (str): The type of device where the model will run.
- logging (logging.Logger): Logger instance for logging messages.
Returns:
- model (Union[LlamaForCausalLM, AutoModelForCausalLM]): The loaded model.
- tokenizer (Union[LlamaTokenizer, AutoTokenizer]): The tokenizer associated with the model.
Notes:
- The function uses the `from_pretrained` method to load both the model and the tokenizer.
- Additional settings are provided for NVIDIA GPUs, such as loading in 4-bit and setting the compute dtype.
"""
if device_type.lower() in ["mps", "cpu"]:
logging.info("Using LlamaTokenizer")
tokenizer = LlamaTokenizer.from_pretrained(model_id, cache_dir="./models/")
model = LlamaForCausalLM.from_pretrained(model_id, cache_dir="./models/")
else:
logging.info("Using AutoModelForCausalLM for full models")
tokenizer = AutoTokenizer.from_pretrained(model_id, cache_dir="./models/")
logging.info("Tokenizer loaded")
model = AutoModelForCausalLM.from_pretrained(
model_id,
device_map="auto",
torch_dtype=torch.float16,
low_cpu_mem_usage=True,
cache_dir=MODELS_PATH,
trust_remote_code=True, # set these if you are using NVIDIA GPU
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
max_memory={0: "15GB"} # Uncomment this line with you encounter CUDA out of memory errors
)
model.tie_weights()
return model, tokenizer
def load_quantized_model_awq(model_id, logging):
"""
Load a AWQ quantized model using AutoModelForCausalLM.
This function loads a quantized model that ends with AWQ.
Parameters:
- model_id (str): The identifier for the model on HuggingFace Hub.
- logging (logging.Logger): Logger instance for logging messages.
Returns:
- model (AutoModelForCausalLM): The loaded quantized model.
- tokenizer (AutoTokenizer): The tokenizer associated with the model.
"""
# The code supports all huggingface models that ends with AWQ.
logging.info("Using AutoModelForCausalLM for AWQ quantized models")
tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
logging.info("Tokenizer loaded")
model = AutoModelForCausalLM.from_pretrained(
model_id,
use_safetensors=True,
trust_remote_code=True,
device_map="auto",
)
return model, tokenizer | [] |
2024-01-10 | mfalang/autodrone | src~catkin_ws~src~control~scripts~track_helipad.py | #!/usr/bin/env python3
import threading
import numpy as np
import control
import guidance
import control_util
import rospy
import perception.msg
import drone_interface.msg
import ground_truth.msg
class Tracker():
STATE_TRACKING = "track"
STATE_DESCENDING = "descend"
STATE_LANDING = "land"
def __init__(self):
node_name = "helipad_tracker"
rospy.init_node(node_name)
control_params = control_util.load_control_params_config(node_name)
self._controller = control.Controller(control_params)
self._guidance_law_type = rospy.get_param("~guidance_law")
rospy.loginfo(f"Tracker started with guidance law: {self._guidance_law_type}")
guidance_law_params = control_params["guidance"][self._guidance_law_type]
velocity_limits = control_params["guidance"]["velocity_limits"]
guidance_law = guidance.get_guidance_law(self._guidance_law_type)
self._guidance_law = guidance_law(guidance_law_params, velocity_limits)
self._prev_telemetry_timestamp: float = None
self._prev_atttiude: np.ndarray = None # roll and pitch
self._prev_velocity: np.ndarray = None # vx and vy
self._prev_pos_timestamp: float = None
self._prev_gt_timestamp: float = None
self._prev_pos: np.ndarray = None
self._prev_gt: np.ndarray = None
self._state = self.STATE_TRACKING
self._is_tracking = False
rospy.Subscriber("/drone/out/telemetry", drone_interface.msg.AnafiTelemetry, self._drone_telemetry_cb)
rospy.Subscriber("/estimate/ekf", perception.msg.PointWithCovarianceStamped, self._ekf_cb)
rospy.Subscriber("/ground_truth/body_frame/helipad_pose", ground_truth.msg.PoseStampedEuler, self._gt_position_cb)
def _drone_telemetry_cb(self, msg: drone_interface.msg.AnafiTelemetry) -> None:
self._prev_telemetry_timestamp = msg.header.stamp.to_sec()
self._prev_atttiude = np.array([
msg.roll,
msg.pitch
])
self._prev_velocity = np.array([
msg.vx,
msg.vy
])
def _ekf_cb(self, msg: perception.msg.PointWithCovarianceStamped) -> None:
self._prev_pos_timestamp = msg.header.stamp.to_sec()
self._prev_pos = np.array([
msg.position.x,
msg.position.y
])
def _gt_position_cb(self, msg: ground_truth.msg.PoseStampedEuler) -> None:
# self._prev_pos_timestamp = msg.header.stamp.to_sec()
# self._prev_pos = np.array([
# msg.x,
# msg.y
# ])
if self._is_tracking:
self._prev_gt_timestamp = msg.header.stamp.to_sec()
self._prev_gt = np.array([
msg.x,
msg.y
])
def start(self, debug=False):
self._controller.takeoff()
control_util.await_user_confirmation("Move up 1.5m")
self._controller.move_relative(0, 0, -1.5, 0)
control_util.await_user_confirmation("Move away from the helipad")
self._controller.move_relative(-1, -1, 0, 0)
control_util.await_user_confirmation("Start tracking")
rate = rospy.Rate(20)
dt = 0.05
v_d = np.zeros(4)
n_sec_to_save = 100
n_entries = n_sec_to_save * 20
self._vrefs = np.zeros((2, n_entries))
self._vds = np.zeros_like(self._vrefs)
self._v_meas = np.zeros_like(self._vrefs)
self._att_meas = np.zeros_like(self._vrefs)
self._att_refs = np.zeros_like(self._vrefs)
self._time_refs = np.zeros(self._vrefs.shape[1])
self._time_meas = np.zeros(self._vrefs.shape[1])
self._pos_errors = np.zeros_like(self._vrefs)
self._gt_pos = np.zeros_like(self._vrefs)
self._time_gt = np.zeros(self._vrefs.shape[1])
self._counter = 0
rospy.on_shutdown(self._shutdown)
threading.Thread(target=self._change_state, args=(), daemon=True).start()
while not rospy.is_shutdown():
if self._state == Tracker.STATE_TRACKING:
self._is_tracking = True
v_ref = self._guidance_law.get_velocity_reference(self._prev_pos, self._prev_pos_timestamp, debug=False)
v_d = self._controller.get_smooth_reference(v_d, v_ref, dt)
att_ref = self._controller.set_attitude(
v_d, self._prev_velocity, self._prev_telemetry_timestamp
)
if self._counter < n_entries:
self._vrefs[:, self._counter] = v_ref
self._vds[:, self._counter] = v_d[:2]
self._att_refs[:, self._counter] = att_ref
self._time_refs[ self._counter] = rospy.Time.now().to_sec()
self._v_meas[:, self._counter] = self._prev_velocity
self._att_meas[:, self._counter] = self._prev_atttiude
self._time_meas[ self._counter] = self._prev_telemetry_timestamp
self._pos_errors[:, self._counter] = self._prev_pos
self._gt_pos[:, self._counter] = self._prev_gt
self._time_gt[ self._counter] = self._prev_gt_timestamp
self._counter += 1
if debug:
print(f"Pos error: x: \t{self._prev_pos[0]:.3f} y: \t{self._prev_pos[1]:.3f}")
print(f"Vref: vx: \t{v_ref[0]:.3f} vy: \t{v_ref[1]:.3f}")
print(f"Vd: x: \t\t{v_d[0]:.3f} y: \t{v_d[1]:.3f}")
print(f"Attref: r: \t{att_ref[0]:.3f} p: \t{att_ref[1]:.3f}")
print()
elif self._state == Tracker.STATE_DESCENDING:
pass
elif self._state == Tracker.STATE_LANDING:
break
rate.sleep()
def _change_state(self):
next_state = ""
while next_state != Tracker.STATE_TRACKING or next_state != Tracker.STATE_DESCENDING or next_state != Tracker.STATE_LANDING:
next_state = input(f"Current state: {self._state}. Enter next state (track, descend, land): ")
if next_state == self._state:
print("Same state as current state given. No change.")
elif next_state == Tracker.STATE_TRACKING:
rospy.loginfo("Starting tracking")
self._state = Tracker.STATE_TRACKING
elif next_state == Tracker.STATE_DESCENDING:
self._state = Tracker.STATE_DESCENDING
rospy.sleep(1)
rospy.loginfo("Starting descending")
self._controller.move_relative(0, 0, 1.5, 0)
elif next_state == Tracker.STATE_LANDING:
rospy.loginfo("Starting landing")
self._controller.land()
self._state = Tracker.STATE_LANDING
else:
print(f"Invalid next state {next_state}. Must be {Tracker.STATE_TRACKING}/{Tracker.STATE_DESCENDING}/{Tracker.STATE_LANDING}")
def _shutdown(self):
# self._controller.land()
output_dir = "/home/martin/code/autodrone/out/temp_guidance_ouput"
print(f"Saving output data to: {output_dir}")
np.savetxt(f"{output_dir}/vrefs.txt", self._vrefs[:, :self._counter])
np.savetxt(f"{output_dir}/vds.txt", self._vds[:, :self._counter])
np.savetxt(f"{output_dir}/v_meas.txt", self._v_meas[:, :self._counter])
np.savetxt(f"{output_dir}/att_refs.txt", self._att_refs[:, :self._counter])
np.savetxt(f"{output_dir}/att_meas.txt", self._att_meas[:, :self._counter])
np.savetxt(f"{output_dir}/time_refs.txt", self._time_refs[:self._counter])
np.savetxt(f"{output_dir}/time_meas.txt", self._time_meas[:self._counter])
np.savetxt(f"{output_dir}/pos_errors.txt", self._pos_errors[:, :self._counter])
np.savetxt(f"{output_dir}/time_gt.txt", self._time_gt[:self._counter])
np.savetxt(f"{output_dir}/gt_pos.txt", self._gt_pos[:, :self._counter])
def plot_output():
import os
script_dir = os.path.dirname(os.path.realpath(__file__))
base_dir = f"{script_dir}/../../../../../out/controller_results/guidance_results"
env = "sim"
data_folder = "track_helipad_2D/pp/kappa_0.2"
data_dir = f"{base_dir}/{env}/{data_folder}"
v_ref = np.loadtxt(f"{data_dir}/vrefs.txt")
v_d = np.loadtxt(f"{data_dir}/vds.txt")
v_meas = np.loadtxt(f"{data_dir}/v_meas.txt")
t_refs = np.loadtxt(f"{data_dir}/time_refs.txt")
t_meas = np.loadtxt(f"{data_dir}/time_meas.txt")
att_refs = np.loadtxt(f"{data_dir}/att_refs.txt")
att_meas = np.loadtxt(f"{data_dir}/att_meas.txt")
pos_errors = np.loadtxt(f"{data_dir}/pos_errors.txt")
gt_pos = np.loadtxt(f"{data_dir}/gt_pos.txt")
t_gt = np.loadtxt(f"{data_dir}/time_gt.txt")
if "pp" in data_folder:
guidance_law = "Pure pursuit"
else:
guidance_law = "PID"
velocity_title = f"Reference vs. measured horizontal velocities\nEnvironment: {env.upper()} - Guidance law: {guidance_law}"
velocity_title = ""
attitude_title = f"Reference vs. measured roll and pitch angles\nEnvironment: {env.upper()} - Guidance law: {guidance_law}"
attitude_title = ""
pos_error_title = f"Ground truth vs. estimated horizontal position error\nEnvironment: {env.upper()} - Guidance law: {guidance_law}"
pos_error_title = ""
control_util.plot_drone_velocity_vs_reference_trajectory(
v_ref, v_d, t_refs, v_meas, t_meas, plot_title=velocity_title,
start_time_from_0=True, save_fig=True
)
control_util.plot_drone_attitude_vs_reference(
att_refs, t_refs, att_meas, t_meas, plot_title=attitude_title,
start_time_from_0=True, save_fig=True
)
control_util.plot_drone_position_error_vs_gt(
pos_errors[:, 1:], t_refs[1:], gt_pos[:, 1:], t_gt[1:], plot_title=pos_error_title,
start_time_from_0=True, save_fig=True, show_plot=True
)
if __name__ == "__main__":
import sys
if len(sys.argv) == 2 and sys.argv[1] == "plot":
plot_output()
else:
tracker = Tracker()
tracker.start(debug=False)
| [] |
2024-01-10 | mfalang/autodrone | src~catkin_ws~src~control~scripts~mission_control.py | #!/usr/bin/env python3
import rospy
import rospkg
import subprocess
import numpy as np
import control
import guidance
import control_util
import perception.msg
import drone_interface.msg
class MissionController():
def __init__(self) -> None:
node_name = "mission_control"
rospy.init_node(node_name, anonymous=False)
self._action_sequence = self._generate_action_sequence()
mission_plan_params = control_util.load_config(node_name, "mission_plan_config_file")
self._locations, self._locations_type = self._load_locations(mission_plan_params)
control_params = control_util.load_control_params_config(node_name)
self._controller = control.Controller(control_params)
self._guidance_law_type = rospy.get_param("~guidance_law")
rospy.loginfo(f"Using guidance law: {self._guidance_law_type}")
guidance_law_params = control_params["guidance"][self._guidance_law_type]
velocity_limits = control_params["guidance"]["velocity_limits"]
guidance_law = guidance.get_guidance_law(self._guidance_law_type)
self._guidance_law = guidance_law(guidance_law_params, velocity_limits)
self._prev_telemetry_timestamp: float = None
self._prev_telemetry: drone_interface.msg.AnafiTelemetry = None
self._new_telemetry_available: bool = False
self._prev_atttiude: np.ndarray = None # roll and pitch
self._prev_velocity: np.ndarray = None # vx and vy
self._require_user_confirmation = rospy.get_param("~require_user_confirmation")
self._prev_pos_timestamp: float = None
self._prev_pos: np.ndarray = None
rospy.Subscriber("/drone/out/telemetry", drone_interface.msg.AnafiTelemetry, self._drone_telemetry_cb)
rospy.Subscriber("/estimate/ekf", perception.msg.PointWithCovarianceStamped, self._ekf_cb)
def _generate_action_sequence(self):
mission_number = rospy.get_param("~mission_number")
if mission_number == "test":
return ["Takeoff", "Trackheli", "Land"]
elif mission_number == "track":
return ["Takeoff", "Trackheli"]
rospack = rospkg.RosPack()
graphplan_path = rospack.get_path("graphplan")
subprocess.run(["python", f"{graphplan_path}/scripts/GraphPlan_main.py", "drone_domain.txt", f"drone_problem_{mission_number}.txt", "zero"])
action_sequence = np.loadtxt(f"{graphplan_path}/output/problem{mission_number}.txt", dtype=str)
return action_sequence
def _load_locations(self, mission_plan_config: dict):
mission_number = rospy.get_param("~mission_number")
loc_type = mission_plan_config[f"mission_{mission_number}"]["loc_type"]
locations = np.vstack((
np.array([mission_plan_config["locations"]["loc_1"][f"{loc_type}_coords"]]),
np.array([mission_plan_config["locations"]["loc_2"][f"{loc_type}_coords"]]),
np.array([mission_plan_config["locations"]["loc_3"][f"{loc_type}_coords"]]),
))
return locations, loc_type
def _drone_telemetry_cb(self, msg: drone_interface.msg.AnafiTelemetry) -> None:
self._prev_telemetry_timestamp = msg.header.stamp.to_sec()
self._prev_telemetry = msg
self._new_telemetry_available = True
def _ekf_cb(self, msg: perception.msg.PointWithCovarianceStamped) -> None:
self._prev_pos_timestamp = msg.header.stamp.to_sec()
self._prev_pos = np.array([
msg.position.x,
msg.position.y,
msg.position.z
])
def _wait_for_hovering(self):
rospy.loginfo("Waiting for drone to hover")
# Require 5 messages in a row with hovering
counter = 0
while not rospy.is_shutdown():
if self._new_telemetry_available:
flying_state = self._prev_telemetry.flying_state
if flying_state == "hovering":
counter += 1
if counter >= 5:
break
else:
counter = 0
self._new_telemetry_available = False
rospy.sleep(0.1)
rospy.loginfo("Hovering")
def _get_reliable_altitude_estimate(self):
# Use EKF if altitude is above 1m
# if self._prev_pos[2] > 2:
# return self._prev_pos[2]
# else:
# return -self._prev_telemetry.relative_altitude # negative to get it in the BODY frame
return self._prev_pos[2]
def _get_action_function(self, action: str):
if action == "Takeoff":
return self.takeoff
elif action == "Land":
return self.land
elif "Move" in action:
return self.move
elif action == "Trackheli":
return self.track_helipad
elif "Search" in action:
return self.search
elif "Drop" in action:
return self.drop
elif action == "Resupply":
return self.resupply
else:
print(f"Unknown action: {action}")
raise ValueError
def start(self):
print("\nSelected action sequence:")
for i, action in enumerate(self._action_sequence):
print(f"\t{i+1}. {action}")
control_util.await_user_confirmation(f"Start action sequence")
for action in self._action_sequence:
if not rospy.is_shutdown():
function = self._get_action_function(action)
if self._require_user_confirmation:
control_util.await_user_confirmation(f"Start action {action}")
function(action)
rospy.loginfo(f"Finished action {action}")
rospy.sleep(1)
def takeoff(self, action: str):
# Take off and wait for drone to be stable in the air
self._controller.takeoff(require_confirmation=False)
self._wait_for_hovering()
# Move up to a total of 3m altitude
rospy.loginfo("Moving up 2m")
self._controller.move_relative(0, 0, -2, 0)
self._wait_for_hovering()
def land(self, action: str):
# Assuming that the altitude above the helipad is about 0.5m (done by the tracking
# helipad action) and therefore we can just execute the landing here.
self._controller.land(require_confirmation=False)
def move(self, action: str):
dest = int(action[-1])
if self._locations_type == "relative":
if dest == 1:
origin = int(action[-2])
dxyz = - self._locations[origin - 1] # -1 as locations are labeled 1,2,3 and not 0,1,2
else:
dxyz = self._locations[dest - 1]
self._controller.move_relative(*dxyz, 0)
else:
print("GPS not implemented")
# use_gps_coordinates should only be set to true in the simulator and if used in real
# life one must be very careful to actually select the correct GPS location.
self._wait_for_hovering()
def track_helipad(self, action: str):
rate = rospy.Rate(20)
dt = 0.05
v_d = np.zeros(4)
pos_error_threshold = 0.2 # m
# control_util.await_user_confirmation("Move away from the helipad")
# self._controller.move_relative(-1, -1, 0, 0)
# control_util.await_user_confirmation("Start tracking")
# First align the drone with the helipad horizontally
rospy.loginfo("Aligning horizontally, then descending")
descending = False
landing_position_ref = np.array([0, 0, 0.7]) # in body frame
ready_to_land_counter = 0
while not rospy.is_shutdown():
if np.linalg.norm(self._prev_pos[:2]) < pos_error_threshold:
if descending == False:
print("Starting to descend")
descending = True
else:
if descending == True:
print("Hovering")
descending = False
if descending:
alt = self._get_reliable_altitude_estimate()
alt_error = alt - landing_position_ref[2]
# Sign of position errro in z must be switched as positive climb rate is defined as upwards
# in the drone interface, but since these measurements are in BODY, being above the desired
# altitude will result in a positive error, hence this error must be made negative to work with
# the control
alt_error *= -1
pos_error = np.hstack((self._prev_pos[:2], alt_error))
# print(f"Error{pos_error}, altitude: {alt}")
# if np.abs(pos_error[2]) < 0.2 and np.all(pos_error[:2] < 0.2):
if np.all(np.abs(pos_error) < 0.2):
ready_to_land_counter += 1
if ready_to_land_counter >= 10:
break
else:
ready_to_land_counter = 0
else:
pos_error = np.hstack((self._prev_pos[:2], 0))
v_ref = self._guidance_law.get_velocity_reference(pos_error, self._prev_pos_timestamp, debug=False)
v_d = self._controller.get_smooth_reference(v_d, v_ref[:2], dt)
prev_vel = np.array([
self._prev_telemetry.vx,
self._prev_telemetry.vy,
self._prev_telemetry.vz
])
vd_3D = np.hstack((v_d[:2], v_ref[2]))
self._controller.set_attitude3D(
vd_3D, prev_vel, self._prev_telemetry_timestamp
)
rate.sleep()
rospy.loginfo("Ready to land")
def search(self, action: str):
print(f"Searching in location {action[-1]}")
print("Not implemented")
def drop(self, action: str):
print(f"Dropping life buoy in location {action[-1]}")
def resupply(self, action: str):
print("Resupplying")
def main():
mission_controller = MissionController()
mission_controller.start()
if __name__ == "__main__":
main() | [] |
2024-01-10 | zhangir-azerbayev/formal_nmt | gen_distill_set~of_codex.py | import sys
import os
from tqdm import tqdm
import json
import yaml
import ndjson
import openai
from ratelimit import limits, sleep_and_retry
def batch_loader(seq, size):
"""
Iterator that takes in a list `seq` and returns
chunks of size `size`
"""
return [seq[pos : pos + size] for pos in range(0, len(seq), size)]
# calls=3, period=60 is max for reliability with batch_size=20
# might want to throttle it to keep lean chat up
@sleep_and_retry
@limits(calls=1, period=60)
def call_api(prompt, stop, max_tokens=150,):
return openai.Completion.create(
engine="code-davinci-002",
prompt=prompt,
max_tokens=150,
n=1,
temperature=0,
stop=stop,
)
def main():
with open(sys.argv[1]) as f:
cfg = yaml.safe_load(f)
BATCH_SIZE = cfg["batch_size"]
BEFORE_EXAMPLE = cfg["before_example"]
AFTER_EXAMPLE = cfg["after_example"]
IN_KEY = cfg["in_key"]
OUT_KEY = cfg["out_key"]
save_path = cfg["save_path"]
if os.path.isfile(save_path):
raise OSError("save_path already exists")
few_shot_prompt_path = cfg["few_shot_prompt_path"]
data_path = cfg["data_path"]
STOP = cfg["stop"]
max_tokens = cfg["max_tokens"]
with open(few_shot_prompt_path) as f:
FEW_SHOT_PROMPT = f.read()
with open(data_path) as f:
data = ndjson.load(f)
dataloader = batch_loader(data, BATCH_SIZE)
for batch in tqdm(dataloader):
prompts = [FEW_SHOT_PROMPT + BEFORE_EXAMPLE + x[IN_KEY] + AFTER_EXAMPLE for x in batch]
outs = call_api(prompts, stop=STOP, max_tokens=max_tokens)
finish_reasons = [x["finish_reason"]
for x in outs["choices"]]
if "length" in finish_reasons:
print("HIT LENGTH LIMIT, RETRYING WITH MORE TOKENS")
outs = call_api(prompts, stop=STOP, max_tokens=400)
text_outs = [x["text"] for x in outs["choices"]]
for text_out, step in zip(text_outs, batch):
step[OUT_KEY] = text_out
with open(save_path, "a+") as f:
record = json.dumps(step)
f.write(record+"\n")
if __name__=="__main__":
main()
| [
"few_shot_prompt_path"
] |
2024-01-10 | victorneo/transponder | transcriber~transcribe.py | import textwrap
import json
import tiktoken
import sys
import os
from dotenv import load_dotenv
from whispercpp import Whisper
from langchain.docstore.document import Document
from langchain.text_splitter import CharacterTextSplitter
from langchain import OpenAI, PromptTemplate, LLMChain
load_dotenv()
OPENAI_MODEL_NAME = 'gpt-3.5-turbo-16k'
class DocumentWrapper(textwrap.TextWrapper):
def wrap(self, text):
split_text = text.split('\n')
lines = [line for para in split_text for line in textwrap.TextWrapper.wrap(self, para)]
return lines
def num_tokens_from_string(string: str, encoding_name: str) -> int:
"""Returns the number of tokens in a text string."""
encoding = tiktoken.encoding_for_model(encoding_name)
num_tokens = len(encoding.encode(string))
return num_tokens
def transcribe_audio_file(fname: str) -> str:
transcript_file = fname + '.txt'
try:
with open(transcript_file, 'r') as f:
transcript = f.read()
except:
print('Local transcript file not found')
w = Whisper('small')
print(f'Transcribing {fname}')
result = w.transcribe(fname)
text = w.extract_text(result)
transcript = '\n'.join(text)
with open(transcript_file, 'w') as f:
f.write(transcript)
else:
print('Found local transcript file')
return transcript
def llm_organize(fname: str, transcript: str) -> str:
llm_output_fname = fname + '.gpt'
try:
with open(llm_output_fname, 'r') as f:
output = f.read()
except:
print(f'Local LLM output file not found, using {OPENAI_MODEL_NAME} for organization')
# Send to LLM for creating section headers
template = """The following is a transcript of a podcast,
help me add section headers into the following transcript directly in Markdown
(I should see the original transcript in each section in nice readable paragraphs):
{transcript}"""
prompt_template = PromptTemplate(input_variables=['transcript'], template=template)
llm = OpenAI(temperature=0, model_name=OPENAI_MODEL_NAME)
output = llm(prompt_template.format(transcript=transcript))
with open(llm_output_fname, 'w') as f:
f.write(output)
else:
print('Found local LLM output file')
return output
def main(fname: str):
transcript = transcribe_audio_file(fname)
# count tokens: need to be below 8k for GPT 3.5 16k
num_tokens = num_tokens_from_string(transcript, 'gpt-3.5-turbo-16k')
print(f'Total number of tokens: {num_tokens}')
if num_tokens >= 8000:
print('Unable to proceed as token exceeds what GPT 3.5 16k can handle')
sys.exit(1)
output = llm_organize(fname, transcript)
# output += '\n\n## Original Transcript\n{}'.format(transcript)
wrapper = DocumentWrapper(width=100, break_long_words=False, replace_whitespace=False)
lines = []
for line in wrapper.wrap(text=output):
if line.startswith('#'):
lines.append('\n')
lines.append(line)
output = '\n'.join(lines).strip()
# Write into a markdown text file for exporting
output_file = f'{fname}.md'
with open(output_file, 'w') as f:
f.write(output)
print(f'Transcript written to {output_file}')
if __name__ == '__main__':
if len(sys.argv) < 2:
print('Please provide the audio file name')
sys.exit(1)
main(sys.argv[1])
| [
"The following is a transcript of a podcast,\n help me add section headers into the following transcript directly in Markdown\n (I should see the original transcript in each section in nice readable paragraphs):\n\n {transcript}",
"transcript"
] |
2024-01-10 | cjoke/smallapps | aichat.py | #!/usr/bin/env python
import openai
import time
from utils import microphone
api_key = $OPENAI_API_KEY
openai.api_key = api_key
mypromt = [
{"role": "system", "content": "You are a nice intelligent python code assistant."}
]
def log_conversation(conversation, filename):
with open(filename, "a") as logfile:
logfile.write(f"\nTIMESTAMP: {time.ctime()}\n")
for line in conversation:
logfile.write(line)
class TextFormatter:
def __init__(self, text):
self.text = text
def format_output(self):
chunks = [self.text[i : i + 100] for i in range(0, len(self.text), 100)]
formatted_text = "\n".join(chunks)
return formatted_text
while True:
recording = microphone.SpeechRecognizer()
recorded_message = recording.recognize_speech()
if recorded_message == "text please":
recorded_message = input(" Message to chatGPT here : ")
if recorded_message == "exit":
exit()
if recorded_message:
mypromt.append(
{"role": "user", "content": recorded_message},
)
mycontent = openai.chat.completions.create(
model="gpt-3.5-turbo",
messages=mypromt,
temperature=0.7,
max_tokens=1024
)
reply = mycontent.choices[0].message.content
formatter = TextFormatter(reply)
formatted_output = formatter.format_output()
reply = formatted_output
logger = f"USER INPUT : {recorded_message} " + "\n" + f" ChatGPT :{reply} "
print(f"CHAT GPT: {reply}")
mypromt.append({"role": "assistant", "content": reply})
log_conversation(logger, "conversation_log.txt")
| [
"You are a nice intelligent python code assistant."
] |
2024-01-10 | CodingLucasLi/MySQL_GPT_Query_Generator | db_helper.py | from sqlalchemy import create_engine, inspect, MetaData, DDL
import os
from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader, GPTSimpleKeywordTableIndex
from llama_index import StorageContext, load_index_from_storage
import my_key
from llama_index import ServiceContext, LLMPredictor
from langchain import OpenAI
from langchain.chat_models import ChatOpenAI
import pandas as pd
data_folder = "data"
def get_create_table_statement(engine, table_name):
with engine.connect() as connection:
# Get the DDL object for the CREATE TABLE statement
statement = DDL(f"SHOW CREATE TABLE {table_name};")
result = connection.execute(statement)
create_table_statement = result.fetchone()[1]
return create_table_statement
def run_sql(db_url, query):
engine = create_engine(db_url, pool_recycle=3600)
conn = engine.raw_connection()
cursor = conn.cursor()
cursor.execute(query)
result = cursor.fetchall()
column_names = [desc[0] for desc in cursor.description]
# Close the connection
cursor.close()
conn.close()
engine.dispose()
# Convert the result to a DataFrame
df = pd.DataFrame(result, columns=column_names)
return df
def scan_table_to_file(db_url):
engine = create_engine(db_url)
inspector = inspect(engine)
metadata = MetaData()
table_names = inspector.get_table_names()
for table_name in table_names:
create_table_statement = get_create_table_statement(engine, table_name)
with open(f"data/{table_name}.sql", "w", encoding='utf-8') as file:
file.write(create_table_statement)
engine.dispose()
def build_index(selected_files):
# Set up LLM
llm = ChatOpenAI(model=model_name, max_tokens=2500)
llm_predictor = LLMPredictor(llm=llm)
service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor)
# Generate the local index
selected_files_with_path = [f"{data_folder}/{file_name}" for file_name in selected_files]
documents = SimpleDirectoryReader(input_files=selected_files_with_path).load_data()
index = GPTVectorStoreIndex.from_documents(documents, service_context=service_context)
index.storage_context.persist('db_index')
def create_query(query_str, request_str):
llm = ChatOpenAI(model=model_name, max_tokens=2500, temperature=0.7)
llm_predictor = LLMPredictor(llm=llm)
service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor)
storage_context = StorageContext.from_defaults(persist_dir="./db_index")
db_index = load_index_from_storage(storage_context, service_context=service_context)
query_engine = db_index.as_query_engine()
response = query_engine.query("You are a MySQL query generation bot. Please provide a query command based on the table names, column names, and requirements of the current MySQL database. Query string: (%s); Request string: (%s)" % (query_str, request_str))
return response
def analyse_db(db_question):
llm = ChatOpenAI(model=model4_name, temperature=0.7, max_tokens=6000)
llm_predictor = LLMPredictor(llm=llm)
service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor)
storage_context = StorageContext.from_defaults(persist_dir="./db_index")
db_index = load_index_from_storage(storage_context, service_context=service_context)
query_engine = db_index.as_query_engine()
response = query_engine.query("You are a senior MySQL data warehouse engineer. Please answer the following question: %s. Please focus on the key points and keep the response within 4000 Chinese characters, concise, persuasive, and informative." % db_question)
return response
| [] |
2024-01-10 | bpinnyc/gpt-engineer | gpt_engineer~steps.py | import inspect
import re
import subprocess
from enum import Enum
from typing import List, Union
from langchain.schema import AIMessage, HumanMessage, SystemMessage
from termcolor import colored
from gpt_engineer.ai import AI
from gpt_engineer.chat_to_files import (
format_file_to_input,
get_code_strings,
overwrite_files,
to_files,
)
from gpt_engineer.db import DBs
from gpt_engineer.file_selector import FILE_LIST_NAME, ask_for_files
from gpt_engineer.learning import human_review_input
Message = Union[AIMessage, HumanMessage, SystemMessage]
def setup_sys_prompt(dbs: DBs) -> str:
"""
Primes the AI with instructions as to how it should
generate code and the philosophy to follow
"""
return (
dbs.preprompts["roadmap"]
+ dbs.preprompts["generate"].replace("FILE_FORMAT", dbs.preprompts["file_format"])
+ "\nUseful to know:\n"
+ dbs.preprompts["philosophy"]
)
def setup_sys_prompt_existing_code(dbs: DBs) -> str:
"""
Similar to code generation, but using an existing code base.
"""
return (
dbs.preprompts["improve"].replace("FILE_FORMAT", dbs.preprompts["file_format"])
+ "\nUseful to know:\n"
+ dbs.preprompts["philosophy"]
)
def curr_fn() -> str:
"""
Get the name of the current function
This will be the name of the function that called this function,
so it serves to ensure we don't hardcode the function name in the step,
but allow the step names to be refactored
"""
return inspect.stack()[1].function
def lite_gen(ai: AI, dbs: DBs) -> List[Message]:
"""Run the AI on only the main prompt and save the results"""
messages = ai.start(
dbs.input["prompt"], dbs.preprompts["file_format"], step_name=curr_fn()
)
to_files(messages[-1].content.strip(), dbs.workspace)
return messages
def simple_gen(ai: AI, dbs: DBs) -> List[Message]:
"""Run the AI on the default prompts and save the results"""
messages = ai.start(setup_sys_prompt(dbs), dbs.input["prompt"], step_name=curr_fn())
to_files(messages[-1].content.strip(), dbs.workspace)
return messages
def clarify(ai: AI, dbs: DBs) -> List[Message]:
"""
Ask the user if they want to clarify anything and save the results to the workspace
"""
messages: List[Message] = [ai.fsystem(dbs.preprompts["clarify"])]
user_input = dbs.input["prompt"]
while True:
messages = ai.next(messages, user_input, step_name=curr_fn())
msg = messages[-1].content.strip()
if "nothing to clarify" in msg.lower():
break
if msg.lower().startswith("no"):
print("Nothing to clarify.")
break
print()
user_input = input('(answer in text, or "c" to move on)\n')
print()
if not user_input or user_input == "c":
print("(letting gpt-engineer make its own assumptions)")
print()
messages = ai.next(
messages,
"Make your own assumptions and state them explicitly before starting",
step_name=curr_fn(),
)
print()
return messages
user_input += """
\n\n
Is anything else unclear? If yes, ask another question.\n
Otherwise state: "Nothing to clarify"
"""
print()
return messages
def gen_clarified_code(ai: AI, dbs: DBs) -> List[dict]:
"""Takes clarification and generates code"""
messages = AI.deserialize_messages(dbs.logs[clarify.__name__])
messages = [
ai.fsystem(setup_sys_prompt(dbs)),
] + messages[
1:
] # skip the first clarify message, which was the original clarify priming prompt
messages = ai.next(
messages,
dbs.preprompts["generate"].replace("FILE_FORMAT", dbs.preprompts["file_format"]),
step_name=curr_fn(),
)
to_files(messages[-1].content.strip(), dbs.workspace)
return messages
def execute_entrypoint(ai: AI, dbs: DBs) -> List[dict]:
command = dbs.workspace["run.sh"]
print()
print(
colored(
"Do you want to execute this code? (y/n)",
"red",
)
)
print()
print(command)
print()
print("To execute, you can also press enter.")
print()
if input() not in ["", "y", "yes"]:
print("Ok, not executing the code.")
return []
print("Executing the code...")
print()
print(
colored(
"Note: If it does not work as expected, consider running the code"
+ " in another way than above.",
"green",
)
)
print()
print("You can press ctrl+c *once* to stop the execution.")
print()
p = subprocess.Popen("bash run.sh", shell=True, cwd=dbs.workspace.path)
try:
p.wait()
except KeyboardInterrupt:
print()
print("Stopping execution.")
print("Execution stopped.")
p.kill()
print()
return []
def gen_entrypoint(ai: AI, dbs: DBs) -> List[dict]:
messages = ai.start(
system=(
"You will get information about a codebase that is currently on disk in "
"the current folder.\n"
"From this you will answer with code blocks that includes all the necessary "
"unix terminal commands to "
"a) install dependencies "
"b) run all necessary parts of the codebase (in parallel if necessary).\n"
"Do not install globally. Do not use sudo.\n"
"Do not explain the code, just give the commands.\n"
"Do not use placeholders, use example values (like . for a folder argument) "
"if necessary.\n"
),
user="Information about the codebase:\n\n" + dbs.workspace["all_output.txt"],
step_name=curr_fn(),
)
print()
regex = r"```\S*\n(.+?)```"
matches = re.finditer(regex, messages[-1].content.strip(), re.DOTALL)
dbs.workspace["run.sh"] = "\n".join(match.group(1) for match in matches)
return messages
def use_feedback(ai: AI, dbs: DBs):
messages = [
ai.fsystem(setup_sys_prompt(dbs)),
ai.fuser(f"Instructions: {dbs.input['prompt']}"),
ai.fassistant(
dbs.workspace["all_output.txt"]
), # reload previously generated code
]
if dbs.input["feedback"]:
messages = ai.next(messages, dbs.input["feedback"], step_name=curr_fn())
to_files(messages[-1].content.strip(), dbs.workspace)
return messages
else:
print(
"No feedback was found in the input folder. Please create a file "
+ "called 'feedback' in the same folder as the prompt file."
)
exit(1)
def set_improve_filelist(ai: AI, dbs: DBs):
"""Sets the file list for files to work with in existing code mode."""
ask_for_files(dbs.project_metadata, dbs.input) # stores files as full paths.
return []
def assert_files_ready(ai: AI, dbs: DBs):
"""Checks that the required files are present for headless
improve code execution."""
assert (
"file_list.txt" in dbs.project_metadata
), "For auto_mode file_list.txt need to be in your .gpteng folder."
assert "prompt" in dbs.input, "For auto_mode a prompt file must exist."
return []
def get_improve_prompt(ai: AI, dbs: DBs):
"""
Asks the user what they would like to fix.
"""
if not dbs.input.get("prompt"):
dbs.input["prompt"] = input(
"\nWhat do you need to improve with the selected files?\n"
)
confirm_str = "\n".join(
[
"-----------------------------",
"The following files will be used in the improvement process:",
f"{FILE_LIST_NAME}:",
colored(str(dbs.project_metadata[FILE_LIST_NAME]), "green"),
"",
"The inserted prompt is the following:",
colored(f"{dbs.input['prompt']}", "green"),
"-----------------------------",
"",
"You can change these files in your project before proceeding.",
"",
"Press enter to proceed with modifications.",
"",
]
)
input(confirm_str)
return []
def improve_existing_code(ai: AI, dbs: DBs):
"""
After the file list and prompt have been aquired, this function is called
to sent the formatted prompt to the LLM.
"""
files_info = get_code_strings(
dbs.input.path, dbs.project_metadata
) # this has file names relative to the workspace path
messages = [
ai.fsystem(setup_sys_prompt_existing_code(dbs)),
]
# Add files as input
for file_name, file_str in files_info.items():
code_input = format_file_to_input(file_name, file_str)
messages.append(ai.fuser(f"{code_input}"))
messages.append(ai.fuser(f"Request: {dbs.input['prompt']}"))
messages = ai.next(messages, step_name=curr_fn())
overwrite_files(messages[-1].content.strip(), dbs)
return messages
def human_review(ai: AI, dbs: DBs):
"""Collects and stores human review of the code"""
review = human_review_input()
if review is not None:
dbs.memory["review"] = review.to_json() # type: ignore
return []
class Config(str, Enum):
DEFAULT = "default"
BENCHMARK = "benchmark"
SIMPLE = "simple"
LITE = "lite"
CLARIFY = "clarify"
RESPEC = "respec"
EXECUTE_ONLY = "execute_only"
EVALUATE = "evaluate"
USE_FEEDBACK = "use_feedback"
IMPROVE_CODE = "improve_code"
EVAL_IMPROVE_CODE = "eval_improve_code"
EVAL_NEW_CODE = "eval_new_code"
STEPS = {
Config.DEFAULT: [
simple_gen,
gen_entrypoint,
execute_entrypoint,
human_review,
],
Config.LITE: [
lite_gen,
],
Config.CLARIFY: [
clarify,
gen_clarified_code,
gen_entrypoint,
execute_entrypoint,
human_review,
],
Config.BENCHMARK: [
simple_gen,
gen_entrypoint,
],
Config.SIMPLE: [
simple_gen,
gen_entrypoint,
execute_entrypoint,
],
Config.USE_FEEDBACK: [use_feedback, gen_entrypoint, execute_entrypoint, human_review],
Config.EXECUTE_ONLY: [execute_entrypoint],
Config.EVALUATE: [execute_entrypoint, human_review],
Config.IMPROVE_CODE: [
set_improve_filelist,
get_improve_prompt,
improve_existing_code,
],
Config.EVAL_IMPROVE_CODE: [assert_files_ready, improve_existing_code],
Config.EVAL_NEW_CODE: [simple_gen],
}
# Future steps that can be added:
# run_tests_and_fix_files
# execute_entrypoint_and_fix_files_if_it_results_in_error
| [] |
2024-01-10 | LiamSwayne/khoj | src~khoj~processor~content~pdf~pdf_to_entries.py | # Standard Packages
import base64
import logging
import os
from typing import List, Tuple
# External Packages
from langchain.document_loaders import PyMuPDFLoader
from khoj.database.models import Entry as DbEntry
from khoj.database.models import KhojUser
# Internal Packages
from khoj.processor.content.text_to_entries import TextToEntries
from khoj.utils.helpers import timer
from khoj.utils.rawconfig import Entry
logger = logging.getLogger(__name__)
class PdfToEntries(TextToEntries):
def __init__(self):
super().__init__()
# Define Functions
def process(
self, files: dict[str, str] = None, full_corpus: bool = True, user: KhojUser = None, regenerate: bool = False
) -> Tuple[int, int]:
# Extract required fields from config
if not full_corpus:
deletion_file_names = set([file for file in files if files[file] == ""])
files_to_process = set(files) - deletion_file_names
files = {file: files[file] for file in files_to_process}
else:
deletion_file_names = None
# Extract Entries from specified Pdf files
with timer("Parse entries from PDF files into dictionaries", logger):
current_entries = PdfToEntries.convert_pdf_entries_to_maps(*PdfToEntries.extract_pdf_entries(files))
# Split entries by max tokens supported by model
with timer("Split entries by max token size supported by model", logger):
current_entries = self.split_entries_by_max_tokens(current_entries, max_tokens=256)
# Identify, mark and merge any new entries with previous entries
with timer("Identify new or updated entries", logger):
num_new_embeddings, num_deleted_embeddings = self.update_embeddings(
current_entries,
DbEntry.EntryType.PDF,
DbEntry.EntrySource.COMPUTER,
"compiled",
logger,
deletion_file_names,
user,
regenerate=regenerate,
)
return num_new_embeddings, num_deleted_embeddings
@staticmethod
def extract_pdf_entries(pdf_files):
"""Extract entries by page from specified PDF files"""
entries = []
entry_to_location_map = []
for pdf_file in pdf_files:
try:
# Write the PDF file to a temporary file, as it is stored in byte format in the pdf_file object and the PDF Loader expects a file path
tmp_file = f"tmp_pdf_file.pdf"
with open(f"{tmp_file}", "wb") as f:
bytes = pdf_files[pdf_file]
f.write(bytes)
try:
loader = PyMuPDFLoader(f"{tmp_file}", extract_images=True)
pdf_entries_per_file = [page.page_content for page in loader.load()]
except ImportError:
loader = PyMuPDFLoader(f"{tmp_file}")
pdf_entries_per_file = [page.page_content for page in loader.load()]
entry_to_location_map += zip(pdf_entries_per_file, [pdf_file] * len(pdf_entries_per_file))
entries.extend(pdf_entries_per_file)
except Exception as e:
logger.warning(f"Unable to process file: {pdf_file}. This file will not be indexed.")
logger.warning(e, exc_info=True)
finally:
if os.path.exists(f"{tmp_file}"):
os.remove(f"{tmp_file}")
return entries, dict(entry_to_location_map)
@staticmethod
def convert_pdf_entries_to_maps(parsed_entries: List[str], entry_to_file_map) -> List[Entry]:
"Convert each PDF entries into a dictionary"
entries = []
for parsed_entry in parsed_entries:
entry_filename = entry_to_file_map[parsed_entry]
# Append base filename to compiled entry for context to model
heading = f"{entry_filename}\n"
compiled_entry = f"{heading}{parsed_entry}"
entries.append(
Entry(
compiled=compiled_entry,
raw=parsed_entry,
heading=heading,
file=f"{entry_filename}",
)
)
logger.debug(f"Converted {len(parsed_entries)} PDF entries to dictionaries")
return entries
@staticmethod
def convert_pdf_maps_to_jsonl(entries: List[Entry]):
"Convert each PDF entry to JSON and collate as JSONL"
return "".join([f"{entry.to_json()}\n" for entry in entries])
| [] |
2024-01-10 | LiamSwayne/khoj | src~khoj~processor~conversation~openai~whisper.py | # Standard Packages
from io import BufferedReader
# External Packages
from asgiref.sync import sync_to_async
import openai
async def transcribe_audio(audio_file: BufferedReader, model, api_key) -> str:
"""
Transcribe audio file using Whisper model via OpenAI's API
"""
# Send the audio data to the Whisper API
response = await sync_to_async(openai.Audio.translate)(model=model, file=audio_file, api_key=api_key)
return response["text"]
| [] |
2024-01-10 | LiamSwayne/khoj | src~khoj~processor~conversation~offline~chat_model.py | from typing import Iterator, Union, List, Any
from datetime import datetime
import logging
from threading import Thread
from langchain.schema import ChatMessage
from khoj.processor.conversation.utils import ThreadedGenerator, generate_chatml_messages_with_context
from khoj.processor.conversation import prompts
from khoj.utils.constants import empty_escape_sequences
from khoj.utils import state
from khoj.utils.helpers import ConversationCommand, is_none_or_empty
logger = logging.getLogger(__name__)
def extract_questions_offline(
text: str,
model: str = "mistral-7b-instruct-v0.1.Q4_0.gguf",
loaded_model: Union[Any, None] = None,
conversation_log={},
use_history: bool = True,
should_extract_questions: bool = True,
) -> List[str]:
"""
Infer search queries to retrieve relevant notes to answer user query
"""
try:
from gpt4all import GPT4All
except ModuleNotFoundError as e:
logger.info("There was an error importing GPT4All. Please run pip install gpt4all in order to install it.")
raise e
# Assert that loaded_model is either None or of type GPT4All
assert loaded_model is None or isinstance(loaded_model, GPT4All), "loaded_model must be of type GPT4All or None"
all_questions = text.split("? ")
all_questions = [q + "?" for q in all_questions[:-1]] + [all_questions[-1]]
if not should_extract_questions:
return all_questions
gpt4all_model = loaded_model or GPT4All(model)
# Extract Past User Message and Inferred Questions from Conversation Log
chat_history = ""
if use_history:
for chat in conversation_log.get("chat", [])[-4:]:
if chat["by"] == "khoj":
chat_history += f"Q: {chat['intent']['query']}\n"
chat_history += f"A: {chat['message']}\n"
current_date = datetime.now().strftime("%Y-%m-%d")
last_year = datetime.now().year - 1
last_christmas_date = f"{last_year}-12-25"
next_christmas_date = f"{datetime.now().year}-12-25"
system_prompt = prompts.system_prompt_extract_questions_gpt4all.format(
message=(prompts.system_prompt_message_extract_questions_gpt4all)
)
example_questions = prompts.extract_questions_gpt4all_sample.format(
query=text,
chat_history=chat_history,
current_date=current_date,
last_year=last_year,
last_christmas_date=last_christmas_date,
next_christmas_date=next_christmas_date,
)
message = system_prompt + example_questions
state.chat_lock.acquire()
try:
response = gpt4all_model.generate(message, max_tokens=200, top_k=2, temp=0, n_batch=512)
finally:
state.chat_lock.release()
# Extract, Clean Message from GPT's Response
try:
# This will expect to be a list with a single string with a list of questions
questions = (
str(response)
.strip(empty_escape_sequences)
.replace("['", '["')
.replace("<s>", "")
.replace("</s>", "")
.replace("']", '"]')
.replace("', '", '", "')
.replace('["', "")
.replace('"]', "")
.split("? ")
)
questions = [q + "?" for q in questions[:-1]] + [questions[-1]]
questions = filter_questions(questions)
except:
logger.warning(f"Llama returned invalid JSON. Falling back to using user message as search query.\n{response}")
return all_questions
logger.debug(f"Extracted Questions by Llama: {questions}")
questions.extend(all_questions)
return questions
def filter_questions(questions: List[str]):
# Skip questions that seem to be apologizing for not being able to answer the question
hint_words = [
"sorry",
"apologize",
"unable",
"can't",
"cannot",
"don't know",
"don't understand",
"do not know",
"do not understand",
]
filtered_questions = []
for q in questions:
if not any([word in q.lower() for word in hint_words]) and not is_none_or_empty(q):
filtered_questions.append(q)
return filtered_questions
def converse_offline(
references,
online_results,
user_query,
conversation_log={},
model: str = "mistral-7b-instruct-v0.1.Q4_0.gguf",
loaded_model: Union[Any, None] = None,
completion_func=None,
conversation_command=ConversationCommand.Default,
max_prompt_size=None,
tokenizer_name=None,
) -> Union[ThreadedGenerator, Iterator[str]]:
"""
Converse with user using Llama
"""
try:
from gpt4all import GPT4All
except ModuleNotFoundError as e:
logger.info("There was an error importing GPT4All. Please run pip install gpt4all in order to install it.")
raise e
assert loaded_model is None or isinstance(loaded_model, GPT4All), "loaded_model must be of type GPT4All or None"
gpt4all_model = loaded_model or GPT4All(model)
# Initialize Variables
compiled_references_message = "\n\n".join({f"{item}" for item in references})
# Get Conversation Primer appropriate to Conversation Type
if conversation_command == ConversationCommand.Notes and is_none_or_empty(compiled_references_message):
return iter([prompts.no_notes_found.format()])
elif conversation_command == ConversationCommand.Online and is_none_or_empty(online_results):
completion_func(chat_response=prompts.no_online_results_found.format())
return iter([prompts.no_online_results_found.format()])
elif conversation_command == ConversationCommand.Online:
conversation_primer = prompts.online_search_conversation.format(
query=user_query, online_results=str(online_results)
)
elif conversation_command == ConversationCommand.General or is_none_or_empty(compiled_references_message):
conversation_primer = user_query
else:
conversation_primer = prompts.notes_conversation_gpt4all.format(
query=user_query, references=compiled_references_message
)
# Setup Prompt with Primer or Conversation History
messages = generate_chatml_messages_with_context(
conversation_primer,
prompts.system_prompt_message_gpt4all,
conversation_log,
model_name=model,
max_prompt_size=max_prompt_size,
tokenizer_name=tokenizer_name,
)
g = ThreadedGenerator(references, online_results, completion_func=completion_func)
t = Thread(target=llm_thread, args=(g, messages, gpt4all_model))
t.start()
return g
def llm_thread(g, messages: List[ChatMessage], model: Any):
user_message = messages[-1]
system_message = messages[0]
conversation_history = messages[1:-1]
formatted_messages = [
prompts.khoj_message_gpt4all.format(message=message.content)
if message.role == "assistant"
else prompts.user_message_gpt4all.format(message=message.content)
for message in conversation_history
]
stop_words = ["<s>"]
chat_history = "".join(formatted_messages)
templated_system_message = prompts.system_prompt_gpt4all.format(message=system_message.content)
templated_user_message = prompts.user_message_gpt4all.format(message=user_message.content)
prompted_message = templated_system_message + chat_history + templated_user_message
state.chat_lock.acquire()
response_iterator = send_message_to_model_offline(prompted_message, loaded_model=model, streaming=True)
try:
for response in response_iterator:
if any(stop_word in response.strip() for stop_word in stop_words):
logger.debug(f"Stop response as hit stop word in {response}")
break
g.send(response)
finally:
state.chat_lock.release()
g.close()
def send_message_to_model_offline(
message, loaded_model=None, model="mistral-7b-instruct-v0.1.Q4_0.gguf", streaming=False
):
try:
from gpt4all import GPT4All
except ModuleNotFoundError as e:
logger.info("There was an error importing GPT4All. Please run pip install gpt4all in order to install it.")
raise e
assert loaded_model is None or isinstance(loaded_model, GPT4All), "loaded_model must be of type GPT4All or None"
gpt4all_model = loaded_model or GPT4All(model)
return gpt4all_model.generate(message, max_tokens=200, top_k=2, temp=0, n_batch=512, streaming=streaming)
| [
"PLACEHOLDERPLACEHOLDERPLACEHOLDER"
] |
2024-01-10 | ashpreetbedi/qabot | qabot~agents~data_query_chain.py | from langchain import LLMChain
from langchain.agents import AgentExecutor, Tool, ZeroShotAgent
from qabot.tools.duckdb_execute_tool import DuckDBTool
from qabot.duckdb_query import run_sql_catch_error
from qabot.tools.describe_duckdb_table import describe_table_or_view
def get_duckdb_data_query_chain(llm, database, callback_manager=None, verbose=False):
tools = [
Tool(
name="Show Tables",
func=lambda _: run_sql_catch_error(database, "show tables;"),
description="Useful to show the available tables and views. Empty input required."
),
Tool(
name="Describe Table",
func=lambda table: describe_table_or_view(database, table),
description="Useful to show the column names and types of a table or view. Use a valid table name as the input."
),
Tool(
name="Query Inspector",
func=lambda query: query.strip('"').strip("'"),
description="Useful to show the query before execution. Always inspect your query before execution. Input MUST be on one line."
),
DuckDBTool(engine=database),
]
# prompt = PromptTemplate(
# input_variables=["input", "agent_scratchpad"],
# template=_DEFAULT_TEMPLATE,
# )
prompt = ZeroShotAgent.create_prompt(
tools,
prefix=prefix,
suffix=suffix,
input_variables=["input", "agent_scratchpad", 'table_names'],
)
llm_chain = LLMChain(llm=llm, prompt=prompt)
tool_names = [tool.name for tool in tools]
agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names,)
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
callback_manager=callback_manager,
verbose=verbose,
)
return agent_executor
suffix = """After outputting the Action Input you never output an Observation, that will be provided to you.
List the relevant SQL queries you ran in your final answer.
If a query fails, try fix it, if the database doesn't contain the answer, or returns no results,
output a summary of your actions in your final answer. It is important that you use the exact format:
Final Answer: I have successfully created a view of the data.
Queries should be output on one line and don't use any escape characters.
Let's go! Remember it is important that you use the exact phrase "Final Answer: " to begin your
final answer.
Question: {input}
Thought: I should describe the most relevant tables in the database to see what columns will be useful.
{agent_scratchpad}"""
prefix = """Given an input question, identify the relevant tables and relevant columns, then create
one single syntactically correct DuckDB query to inspect, then execute, before returning the answer.
If the input is a valid looking SQL query selecting data or creating a view, execute it directly.
Even if you know the answer, you MUST show you can get the answer from the database.
Inspect your query before execution.
Refuse to delete any data, or drop tables. You only execute one statement at a time. You may import data.
Example imports:
- CREATE table customers AS SELECT * FROM 'data/records.json';
- CREATE VIEW covid AS SELECT * FROM 's3://covid19-lake/data.csv';
Unless the user specifies in their question a specific number of examples to obtain, limit your
query to at most 5 results. You can order the results by a relevant column to return the most interesting
examples in the database.
Pay attention to use only the column names that you can see in the schema description. Pay attention
to which column is in which table.
You have access to the following tables/views:
{table_names}
You have access to the following tools:
"""
# Other examples
"""
An example final answer:
```
Final Answer: There were 109 male passengers who survived.
The following SQL queries were executed to obtain the result:
- SELECT Sex, Survived FROM titanic limit 5;
- CREATE VIEW male_survivors AS SELECT * FROM titanic WHERE Sex = 'male' AND Survived = 1;
- select count(*) from male_survivors;
```
Examples:?
For example:
Input: "Create a names table with an id, name and email column"
Thought: "I need to execute a query to create a table called names, with an id, name and email column"
Action: execute
Action Input: "CREATE TABLE names (id INTEGER, name VARCHAR, email VARCHAR);"
Thought: "I should describe the table to make sure it was created correctly"
Action: Describe Table
Action Input: names
Final Answer: <Summary>
Errors should be returned directly:
Input: "Create a names table with an id, name and email column"
Thought: "I need to execute a query to create a table called names, with an id, name and email column"
Action: execute
Action Input: "CREATE TABLE names (id INTEGER, name VARCHAR, email VARCHAR);"
Final Answer: Error: Catalog Error: Table with name "names" already exists!
For example:
Input: "count the number of entries in the "addresses" table that belong to each different city filtering out cities with a count below 50"
Thought: "I need to execute a query to count the number of entries in the "addresses" table that belong to each different city filtering out cities with a count below 50"
Action: execute
Action Input: SELECT city, COUNT(*) FROM addresses GROUP BY city HAVING COUNT(*) >= 50 limit 2;
Thought:
Final Answer:
""" | [
"Final Answer: ",
"table_names",
"data/records.json",
"agent_scratchpad",
"input",
"s3://covid19-lake/data.csv"
] |
2024-01-10 | ashpreetbedi/qabot | qabot~duckdb_documentation.py | from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain import VectorDBQA
from langchain.document_loaders import WebBaseLoader
"""
Notes:
- requires torch etc for embedding. Requires installing the optional `embedding` group of dependencies.
- currently just loads one html page, could do something more like ReadTheDocsLoader
to load all.
"""
def get_duckdb_docs_chain(llm):
embeddings = OpenAIEmbeddings()
loader = WebBaseLoader("https://duckdb.org/docs/sql/introduction")
docs = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(docs)
docdb = Chroma.from_documents(texts, embeddings, collection_name="duckdb")
return VectorDBQA.from_chain_type(llm=llm, chain_type="stuff", vectorstore=docdb)
| [] |
2024-01-10 | ashpreetbedi/qabot | qabot~progress_callback.py | from typing import Any, Dict, Optional
from langchain.callbacks import OpenAICallbackHandler
from langchain.schema import AgentAction
from rich import print
from rich.progress import Progress
class QACallback(OpenAICallbackHandler):
def __init__(self, *args, **kwargs):
self.progress: Progress = kwargs.pop('progress')
self.chain_task_ids = []
self.tool_task_id = None
super().__init__(*args, **kwargs)
def on_chain_start(self, serialized, inputs, **kwargs):
self.chain_task_ids.append(self.progress.add_task(f"on chain start"))
if isinstance(serialized, dict) and 'name' in serialized:
self.progress.update(self.chain_task_ids[-1], description=f"[yellow]{serialized['name']}")
elif 'agent_scratchpad' in inputs and len(inputs['agent_scratchpad']):
self.progress.update(self.chain_task_ids[-1], description=inputs['agent_scratchpad'])
def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs):
self.tool_task_id = self.progress.add_task(f"on tool start")
self.progress.update(self.tool_task_id, description=f"[yellow]{serialized['name']}")
def on_tool_end(self, output: str, color, observation_prefix, **kwargs):
self.progress.remove_task(self.tool_task_id)
self.tool_task_id = None
def on_agent_action(
self, action: AgentAction, color: Optional[str] = None, **kwargs
):
"""Run on agent requesting an action."""
print(f"[{color}]{action.log}[/{color}]")
def on_chain_end(self, outputs, **kwargs):
super().on_chain_end(outputs, **kwargs)
if isinstance(outputs, dict) and 'text' in outputs:
outputs = outputs['text']
#print(f"[cyan]{outputs}")
self.progress.update(self.chain_task_ids[-1], description=f"[yellow]{outputs}")
self.progress.remove_task(self.chain_task_ids.pop())
def on_agent_finish(
self, finish, color: Optional[str] = None, **kwargs
) -> None:
"""Run on agent end."""
if 'output' in finish.return_values:
print(f"[{color}]{finish.return_values['output']}[/{color}]")
def on_llm_end(self, response, **kwargs):
print("[yellow]On llm end")
| [] |
2024-01-10 | ashpreetbedi/qabot | qabot~caching.py |
from sqlalchemy import Column, Integer, String, Sequence, text
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from langchain.cache import SQLAlchemyCache
import langchain
Base = declarative_base()
class FulltextLLMCache(Base): # type: ignore
"""Table for indexed LLM Cache"""
__tablename__ = "llm_cache_fulltext"
id = Column(Integer, Sequence('cache_id'), primary_key=True)
prompt = Column(String, nullable=False, index=True)
llm = Column(String, nullable=False)
idx = Column(Integer)
response = Column(String)
def configure_caching(database_uri):
engine = create_engine(database_uri)
langchain.llm_cache = SQLAlchemyCache(engine, FulltextLLMCache)
| [] |
2024-01-10 | ashpreetbedi/qabot | experiments~flan_query_planner.py | from langchain import HuggingFaceHub, LLMChain
from langchain.agents import Tool, ZeroShotAgent
prefix = """
You are an agent designed to interact with a SQL database.
Given an input question, create a syntactically correct DuckDB query to run, then look at the results of the
query and return the answer.
Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most 5 results.
You can order the results by a relevant column to return the most interesting examples in the database.
Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
You have access to tools for interacting with the database. Only use the below tools. Only use the information returned
by the below tools to construct your final answer.
You MUST double check your query before executing it. If you get an error while executing a query, rewrite the query
and try again.
DO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.
If the question does not seem related to the database, just return "I don't know" as the answer.
"""
suffix = """Begin!
Question: {input}
Thought: I should look at the tables in the database to see what I can query.
{agent_scratchpad}"""
template = """Question: {question}
"""
tools = [
Tool(
name="Show Tables",
func=lambda _: "show tables;",
description="Useful to show the available tables and views. Input is an empty string, output is a comma separated list of tables in the database."
),
Tool(
name="Check Query",
func=lambda query: query,
description="Useful to check a query is valid. Always use this tool before executing a query"
),
Tool(
name="Describe Table",
func=lambda table: table,
description="Useful to show the column names and types of a table or view. Use a valid table name as the input."
),
#DuckDBTool(engine=database),
Tool(name="Execute SQL", func=lambda sql: sql, description="Useful to execute a SQL query. Use a valid SQL query as the input.")
]
prompt = ZeroShotAgent.create_prompt(
tools,
prefix=prefix,
suffix=suffix,
input_variables=["input", "agent_scratchpad"]
)
llm = HuggingFaceHub(
repo_id="google/flan-t5-xxl",
model_kwargs={"temperature": 0, "max_length": 4000}
)
llm_chain = LLMChain(prompt=prompt, llm=llm)
agent_scratchpad = """Action: Show Tables
Observation: 'titanic', 'unrelated_table'
Thought: I should look at the schema of the 'titanic' table to see what I can query.
"""
# possible_next_step = """Action: Describe Table
# Observation: The table 'titanic' has the following schema:
# ┌─────────────┬─────────────┬
# │ column_name │ column_type │
# ├─────────────┼─────────────┼
# │ PassengerId │ BIGINT │
# │ Survived │ BIGINT │
# │ Pclass │ BIGINT │
# │ Name │ VARCHAR │
# │ Sex │ VARCHAR │
# │ Age │ DOUBLE │
# │ SibSp │ BIGINT │
# │ Parch │ BIGINT │
# │ Ticket │ VARCHAR │
# │ Fare │ DOUBLE │
# │ Cabin │ VARCHAR │
# │ Embarked │ VARCHAR │
# ├─────────────┴─────────────┴
# Thought:
# """
question = """how many passengers survived by gender from the 'titanic' table.
"""
result = llm_chain({'input': question, 'agent_scratchpad': agent_scratchpad})
if 'text' in result:
print(result['text'])
print()
print(result)
#print(llm_chain.run({'input': question, 'agent_scratchpad': {}}))
| [
"I don't know",
"Question: {question}\n",
"input",
"agent_scratchpad"
] |
2024-01-10 | ashpreetbedi/qabot | qabot~tools~duckdb_execute_tool.py | import time
from typing import Any
from rich import print
from langchain.tools import BaseTool
from sqlalchemy import text
from qabot.duckdb_query import run_sql_catch_error
class DuckDBTool(BaseTool):
name = "execute"
description = """useful for when you need to run SQL queries against a DuckDB database.
Input to this tool is a detailed and correct SQL query, output is a result from the database.
If the query is not correct, an error message will be returned.
If an error is returned, rewrite the query, check the query, and try again.
"""
database: Any = None
def __init__(self, engine, *args, **kwargs):
super().__init__(*args, **kwargs)
self.database = engine
def _run(self, query: str) -> str:
#
query_result = run_sql_catch_error(self.database, query)
print(f"[pink]{query_result}[/pink]")
time.sleep(1)
return query_result
async def _arun(self, query: str) -> str:
raise NotImplementedError("DuckDBTool does not support async")
| [
"useful for when you need to run SQL queries against a DuckDB database.\n Input to this tool is a detailed and correct SQL query, output is a result from the database.\n If the query is not correct, an error message will be returned. \n If an error is returned, rewrite the query, check the query, and try again.\n "
] |
2024-01-10 | joshsisto/journal-app | journal_bot.py | import openai
import os
from datetime import datetime,timedelta
import glob
from utilities import get_today, get_now, red, blue, bold
openai.api_key = os.getenv('OPENAI_API_KEY')
def get_prompt_and_conversation():
# Load prompt
with open('./prompts/assistant_prompt.txt', 'r') as f:
assistant_prompt = f.read()
# Load .all file
all_file_path = f"./logs/{get_today()}/{get_today()}.all"
with open(all_file_path, 'r') as f:
all_conversation = f.read()
# Concatenate the prompt and the conversation
conversation = assistant_prompt + "\n" + all_conversation
return conversation
def chatbot():
# Get the combined prompt and conversation
conversation = get_prompt_and_conversation()
# Create an initial system message with the conversation
messages = [
{"role": "system", "content": conversation},
]
timestamp_start = datetime.now()
timestamp_str = timestamp_start.strftime("%Y-%m-%d_%H-%M-%S")
filename = f'./logs/{get_today()}/{timestamp_str}.chat'
with open(filename, 'w') as f:
f.write(f"Conversation started at: {timestamp_str}\n\n")
# Send the messages to the assistant and get the response
response = openai.ChatCompletion.create(
model="gpt-4",
messages=messages,
temperature=0.8,
max_tokens=500,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6
)
assistant_message = response.choices[0].message['content']
messages.append({"role": "assistant", "content": assistant_message})
f.write("Assistant: " + assistant_message + "\n\n")
print("Assistant: ", blue(assistant_message))
while True:
user_message = input(bold(red("You: ")))
if user_message.lower() == "quit":
timestamp_end = datetime.now()
f.write(f"\nConversation ended at: {timestamp_end.strftime('%Y-%m-%d_%H-%M-%S')}")
duration = timestamp_end - timestamp_start
f.write(f"\nDuration of conversation: {str(duration)}\n")
break
messages.append({"role": "user", "content": user_message})
f.write("You: " + user_message + "\n\n")
# Send the messages to the assistant and get the response
response = openai.ChatCompletion.create(
model="gpt-4",
messages=messages,
temperature=0.8,
max_tokens=500,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6
)
assistant_message = response.choices[0].message['content']
messages.append({"role": "assistant", "content": assistant_message})
f.write("Assistant: " + assistant_message + "\n\n")
print("Assistant: ", blue(assistant_message))
def summarize_all_files():
# Load the summarization prompt
with open('./prompts/summary_prompt.txt', 'r') as f:
summary_prompt = f.read()
# Scan the logs directory for all .all files
all_files = glob.glob("./logs/*/*.all")
for file_path in all_files:
# Check if corresponding .summ file already exists
summary_filename = file_path.replace('.all', '.summ')
if os.path.exists(summary_filename):
print(f"Skipping {file_path} as {summary_filename} already exists.")
continue
# Read the content of the .all file
with open(file_path, 'r') as f:
content = f.read()
# Concatenate the prompt and the content
conversation = summary_prompt + "\n" + content
# Prepare the initial message to send to the assistant
messages = [
{"role": "system", "content": conversation},
]
# Get the summary from the assistant
response = openai.ChatCompletion.create(
model="gpt-4",
messages=messages,
temperature=0.8,
max_tokens=500,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6
)
summary = response.choices[0].message['content']
# Save the summary to a .summ file
with open(summary_filename, 'w') as f:
f.write(summary)
print("Summarization completed for all applicable .all files.")
def weekly_summary():
# Load the weekly summarization prompt
with open('./prompts/weekly_summary_prompt.txt', 'r') as f:
weekly_summary_prompt = f.read()
# Get all .summ files and sort them
summ_files = sorted(glob.glob("./logs/*/*.summ"))
while summ_files:
# Take last 7 .summ files for a week
weekly_files = summ_files[-7:]
del summ_files[-7:]
# Aggregate content from these .summ files
aggregated_content = ""
for file_path in weekly_files:
with open(file_path, 'r') as f:
aggregated_content += f.read() + "\n\n"
# Concatenate the prompt and the aggregated content
conversation = weekly_summary_prompt + "\n" + aggregated_content
# Prepare the initial message to send to the assistant
messages = [
{"role": "system", "content": conversation},
]
# Get the weekly summary from the assistant
response = openai.ChatCompletion.create(
model="gpt-4",
messages=messages,
temperature=0.8,
max_tokens=1500,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6
)
summary = response.choices[0].message['content']
# Extract the date range based on the filenames in the chunk
start_date_str = os.path.basename(weekly_files[0]).replace('.summ', '')
end_date_str = os.path.basename(weekly_files[-1]).replace('.summ', '')
date_range_str = f"{start_date_str}_to_{end_date_str}"
# Save the weekly summary to a .week file in the root of the /logs/ folder
weekly_filename = f"./logs/{date_range_str}.week"
with open(weekly_filename, 'w') as f:
f.write(summary)
print(f"Weekly summary saved to {weekly_filename}.")
def count_tokens(text):
"""Utility function to count tokens in a given text."""
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=[{"role": "user", "content": text}],
)
return response.usage['total_tokens']
def total_summary():
# Load the total summarization prompt
with open('./prompts/total_summary_prompt.txt', 'r') as f:
total_summary_prompt = f.read()
prompt_tokens = count_tokens(total_summary_prompt)
max_tokens = 10000 - prompt_tokens # Adjusting for the prompt's token count
# Get all .summ files and sort them
summ_files = sorted(glob.glob("./logs/*/*.summ"))
aggregated_content = ""
token_count = 0
start_file = summ_files[0]
for file_path in summ_files:
with open(file_path, 'r') as f:
content = f.read()
tokens = count_tokens(content)
if token_count + tokens > max_tokens:
# Save the aggregated content as .sum and reset
end_file = file_path
save_summary(aggregated_content, start_file, end_file, total_summary_prompt)
# Reset aggregation and token count
aggregated_content = content + "\n\n"
token_count = tokens
start_file = file_path
else:
aggregated_content += content + "\n\n"
token_count += tokens
# Handle any remaining content after the loop ends
if aggregated_content:
end_file = summ_files[-1]
save_summary(aggregated_content, start_file, end_file, total_summary_prompt)
def save_summary(aggregated_content, start_file, end_file, total_summary_prompt):
"""Utility function to save the summary based on content and date range."""
conversation = total_summary_prompt + "\n" + aggregated_content
messages = [{"role": "system", "content": conversation}]
# Adjusting the max tokens to ensure total tokens (input + output) is within model's limit
max_response_tokens = 14385 - len(conversation.split()) # Assuming one word = one token for simplicity
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo-16k",
messages=messages,
temperature=0.8,
max_tokens=max_response_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6
)
summary = response.choices[0].message['content']
start_date_str = os.path.basename(start_file).replace('.summ', '')
end_date_str = os.path.basename(end_file).replace('.summ', '')
date_range_str = f"{start_date_str}_to_{end_date_str}"
total_filename = f"./logs/{date_range_str}.sum"
with open(total_filename, 'w') as f:
f.write(summary)
print(f"Total summary saved to {total_filename}.")
| [] |
2024-01-10 | Sallenmoore/autonomous | src~autonomous~ai~autoteam.py | # from .agents.autogen import AutoGenAgent
# from .agents.local import LocalAIAgent
import os
from .agents.mockai import MockAIAgent
from .agents.openai import OpenAIAgent
class AutoTeam:
def __init__(self, model=None):
if model:
self.proxy = model()
else:
model = os.getenv("AI_AGENT", "openai")
self.proxy = None
# if model == "autogen":
# self.proxy = AutoGenAgent()
# if model == "local":
# self.proxy = LocalAIAgent()
if model == "openai":
self.proxy = OpenAIAgent()
elif model == "mockai":
self.proxy = MockAIAgent()
else:
raise Exception("Invalid model")
def generate_image(self, prompt, **kwargs):
return self.proxy.generate_image(prompt, **kwargs)
def generate_json(
self,
text,
functions,
primer_text="",
):
return self.proxy.generate_json(text, functions, primer_text)
def generate_text(self, text, primer_text=""):
return self.proxy.generate_text(text, primer_text)
def summarize_text(self, text, primer=""):
return self.proxy.summarize_text(text, primer)
| [] |
2024-01-10 | Sallenmoore/autonomous | src~autonomous~ai~agents~autogen.py | # import json
# import os
# import uuid
# from dotenv import load_dotenv
# load_dotenv()
# import autogen
# from .openai import OpenAIAgent
# class AutoGenAgent:
# config_list = [
# {
# "model": "gpt-4",
# "api_key": os.getenv("OPENAI_API_KEY"),
# },
# {
# "model": "gpt-4-32k",
# "api_key": os.getenv("OPENAI_API_KEY"),
# },
# {
# "model": "gpt-3.5-turbo",
# "api_key": os.environ.get("OPENAI_API_KEY"),
# },
# ]
# def __init__(self, config_path=None):
# aiteam_config = {}
# if config_path:
# with open(config_path, "r") as f:
# aiteam_config = json.load(f)
# self.seed = aiteam_config.get("seed", 42)
# self.max_round = aiteam_config.get("max_round", 20)
# self.temperature = aiteam_config.get("temperature", 0)
# self.input_mode = aiteam_config.get("input_mode", "NEVER")
# self.max_reply = aiteam_config.get("max_reply", 10)
# self.agents = {}
# self.proxy = autogen.UserProxyAgent(
# name="user_proxy",
# human_input_mode=self.input_mode,
# max_consecutive_auto_reply=self.max_reply,
# is_termination_msg=lambda x: x.get("content", "")
# .rstrip()
# .endswith("TERMINATE"),
# code_execution_config={
# "work_dir": "tmp",
# "use_docker": False, # set to True or image name like "python:3" to use docker
# },
# )
# agents = aiteam_config.get(
# "agents",
# [
# {
# "name": "Assistant",
# "role": "You are a helpful, encouraging, and genial AI Assistant ready to help with any task.",
# }
# ],
# )
# for agent in agents:
# self.create_assistant(agent["name"], agent["role"])
# @property
# def solution(self):
# self.proxy.send(
# "summarize the solution in an easy-to-understand way", self.manager
# )
# # return the last message the proxy received
# last_message = self.proxy.last_message()
# return last_message["content"] if last_message.get("content") else None
# def create_agent(self, name, system_message):
# assistant = autogen.AssistantAgent(
# name=name,
# system_message=system_message,
# llm_config={
# "seed": self.seed,
# "config_list": self.config_list,
# "temperature": self.temperature,
# },
# )
# self.agents[name] = assistant
# return self
# def generate(self, message):
# # the assistant receives a message from the user_proxy, which contains the task description
# groupchat = autogen.GroupChat(
# agents=list(self.agents.values()),
# messages=[message],
# max_round=self.max_round,
# )
# self.manager = autogen.GroupChatManager(
# groupchat=groupchat,
# llm_config={
# "seed": self.seed,
# "config_list": self.config_list,
# "temperature": self.temperature,
# },
# )
# self.proxy.initiate_chat(self.manager, message=message)
# def generate_image(self, prompt, **kwargs):
# pass
# def generate_json(
# self,
# text,
# functions,
# primer_text="",
# ):
# pass
# def generate_text(self, text, primer_text=""):
# pass
# def summarize_text(self, text, primer=""):
# pass
| [] |
2024-01-10 | JennaXiao3/Speakrly | server~rerank.py | import cohere
co = cohere.Client('lEYa3WjiekUVp1xl02LlSw9oFwosqoXtQE9BVY7J')
def missingPoints(query, docs):
highs = []
results = co.rerank(query=query, documents=docs, model='rerank-english-v2.0')
for idx, r in enumerate(results):
print(query)
print(f"Document Rank: {idx + 1}, Document Index: {r.index}")
print(f"Document: {r.document['text']}")
print(f"Relevance Score: {r.relevance_score:.2f}")
print("\n")
if r.relevance_score > 0:
highs.append(r.document['text'])
return highs | [] |
2024-01-10 | amadeus4dev/developer-guides | .github~update_db.py | import os
import logging
import tiktoken
import hashlib
from tqdm.auto import tqdm
import requests
from requests.adapters import HTTPAdapter, Retry
from langchain.document_loaders import UnstructuredMarkdownLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
docs_dir = './docs'
endpoint_url = os.environ['ENDPOINT_URL']
BEARER_TOKEN = os.environ.get('BEARER_TOKEN')
logging.basicConfig(level=logging.INFO)
headers = {
"Authorization": f"Bearer {BEARER_TOKEN}"
}
all_docs = []
# Loop through all files in the directory and subdirectories and load markdown files
for root, dirs, files in os.walk(docs_dir):
for file in files:
if file.endswith('.md'):
file_path = os.path.join(root, file)
loader = UnstructuredMarkdownLoader(file_path)
docs = loader.load()
logging.info(f'Loaded {len(docs)} document(s) from {file_path}')
# Append the loaded documents to the all_docs list
all_docs.extend(docs)
logging.info(f'Total documents loaded: {len(all_docs)}')
# Chunking
tokenizer = tiktoken.get_encoding('cl100k_base')
def tiktoken_len(text):
tokens = tokenizer.encode(
text,
disallowed_special=()
)
return len(tokens)
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=400,
chunk_overlap=20, # number of tokens overlap between chunks
length_function=tiktoken_len,
separators=['\n\n', '\n', ' ', '']
)
chunks = text_splitter.split_text(all_docs[5].page_content)
m = hashlib.md5() # this will convert URL into unique ID
documents = []
# Delete the existing documents, so we can update them later
del_session = requests.Session()
del_session.delete(
f'{endpoint_url}/delete',
headers=headers,
json={
'delete_all': 'true'
}
)
for doc in tqdm(all_docs):
url = doc.metadata['source'].replace(
'./docs/', 'https://amadeus4dev.github.io/developer-guides/').replace('.md', '')
m.update(url.encode('utf-8'))
uid = m.hexdigest()[:12]
chunks = text_splitter.split_text(doc.page_content)
for i, chunk in enumerate(chunks):
documents.append({
'id': f'{uid}-{i}',
'text': chunk,
'metadata': {'url': url}
})
batch_size = 100
s = requests.Session()
# we setup a retry strategy to retry on 5xx errors
retries = Retry(
total=5,
backoff_factor=0.1,
status_forcelist=[500, 502, 503, 504]
)
s.mount('http://', HTTPAdapter(max_retries=retries))
for i in tqdm(range(0, len(documents), batch_size)):
i_end = min(len(documents), i+batch_size)
res = s.post(
f'{endpoint_url}/upsert',
headers=headers,
json={
'documents': documents[i:i_end]
}
)
logging.info(res.status_code)
| [] |
2024-01-10 | arpelletier/openai_sandbox | openai_api~chat_test.py | import os
import openai
import sys
sys.path.append("../")
from config import OPENAI_KEY
# Changed the open ai key here
openai.api_key = OPENAI_KEY
from utils.utils import get_project_root
def parse_message(chat_completion):
message = chat_completion['choices'][0]['message']
role = message['role'].capitalize()
content = message['content']
return "%s: %s"%(role,content)
def get_log_file(directory):
try:
# Create the output directory if it doesn't exist
if not os.path.exists(directory):
os.makedirs(directory)
# Find the next available log file
log_file = None
i = 0
while True:
log_file = os.path.join(directory, f"log_{i}.txt")
if not os.path.exists(log_file):
break
i += 1
return log_file
except Exception as e:
print(f"An error occurred: {str(e)}")
def write_to_log(log_file, text):
try:
with open(log_file, 'a') as file:
file.write(text + '\n')
except Exception as e:
print(f"An error occured: {str(e)}")
def single_chat(user_input, timeout_threshold=100):
# TODO: if takes longer than thresh then skip/rerun
chat_completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": user_input}])
message = parse_message(chat_completion)
# Write to log as well
log_folder = os.path.join('../chat_log')
log_file = get_log_file(log_folder)
write_to_log(log_file, "User: "+ user_input)
write_to_log(log_file, message)
return message
def start_chat(log_file=None, text_file_input=False, text_file_path='query.txt'):
first_pass = True
while True:
# Get user input
if text_file_input and first_pass:
first_pass = False
with open(text_file_path) as f:
user_input = '\n'.join(f.readlines())
print("User: {}".format(user_input))
else:
user_input = input("User: ")
print("Got the input.")
# Send to API
# Just have start chat call single chat
# BUT instead of making a new chat every time just have it continue with the previous context
# Boolean flag that returns whether
chat_completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": user_input}])
response = parse_message(chat_completion)
print(response)
if log_file:
write_to_log(log_file, "User: "+ user_input)
write_to_log(log_file, response)
# Send output to log folder
if __name__ == "__main__":
log_folder = os.path.join('../chat_log')
log_file = get_log_file(log_folder)
# Start chat
if len(sys.argv) >= 2:
start_chat(log_file, True)
else:
start_chat(log_file)
| [] |
2024-01-10 | arpelletier/openai_sandbox | interface.py | import os
import openai
from utils.utils import get_project_root
from NER.spacy_ner import SpacyNER
from utils.logger import get_log_file, write_to_log # Import the logger functions
from neo4j_api.neo4j_api import Neo4j_API
from openai_api.chat_test import single_chat as gpt_response
from openai_api.openai_client import OpenAI_API
def ner(input):
"""
Where we would do NER on the next input.
"""
print("Named Entity Recognition module:")
ner = SpacyNER()
disease_ner_results, scientific_entity_ner_results, pos_results, mesh_ids = ner.get_entities(input)
# Look for mesh ids
if mesh_ids:
print("MESH IDS: {}".format(mesh_ids))
disease_entities = [d.text for d in mesh_ids.keys()]
# Get the mesh ids
mesh_list = [mesh_ids[entity] for entity in mesh_ids.keys()]
# Identify non-disease entities
non_disease_entities = [entity for entity, e_type in scientific_entity_ner_results if
entity not in disease_entities]
for entity, e_type in pos_results:
if e_type == 'NOUN':
in_diseases = False
for d in disease_entities:
if entity in d:
in_diseases = True
if not in_diseases:
non_disease_entities += [entity]
relationships = []
for entity, e_type in pos_results:
if e_type == 'VERB':
relationships += [entity]
print("Non disease entities: {}".format(non_disease_entities))
print("Relationships: {}".format(relationships))
return mesh_ids, non_disease_entities, relationships
def get_gpt_response(single_entry, all_types, N=5):
"""
To avoid the problem of getting too many different responses from the LLM,
try and aggregate them and take the most common response
"""
responses = list()
for i in range(N):
# Specify prompt
prompt = """Which of the following is {} most similar to in the following list: {}?
You may select an item even if it does not seem that similar,
just be sure to pick one. Only list the terms seperated by commas with
no additional information or descriptions.""".format(single_entry, all_types)
# Append response to list
response = gpt_response(prompt)
responses.append()
# Return the most common response
return max(set(prompt), key=prompt.count)
def kg(ner_results):
"""
This function identifies relevant nodes in the knowledge graph
"""
mesh_ids, non_disease_entities, relationships = ner_results
mesh_id_results = list()
non_disease_ent_results = list()
relationship_results = list()
# Connect to the Neo4j API
neo4j_api = Neo4j_API()
# Check the MeSH terms are in the graph if any
for mesh_id in mesh_ids:
print(mesh_ids[mesh_id])
mesh_query = "MATCH (n:MeSH_Disease {{name: 'MeSH_Disease:{}'}}) RETURN n LIMIT 25".format(mesh_ids[mesh_id][0])
result = neo4j_api.search(mesh_query)
mesh_id_results.append([mesh_ids[mesh_id][0], result])
# Check the non-disease entities are in the graph if any
node_types = neo4j_api.get_node_types()
# Also be sure to save
for entity in non_disease_entities:
non_disease_ent_results.append([entity, get_gpt_response(entity, node_types)])
# Check the relationships are in the graph if any
relationship_types = neo4j_api.get_rel_types()
for rel in relationships:
relationship_results.append([rel, get_gpt_response(rel, relationship_types)])
return non_disease_ent_results, relationship_results
def start_chat(log_file=None):
while True:
# Get user input
# user_input = input("User: ")
user_input = "What drugs treat lung cancer?"
# Identify entities
ner_results = ner(user_input)
# Identifies relevant nodes in the knowledge graph
kg_results = kg(ner_results)
# Send to Open AI API
# response = call_openai_api(user_input)
if log_file:
write_to_log(log_file, "User: " + user_input)
write_to_log(log_file, response)
"""
For the interface, use the Open AI class and create an object
From this object, use the LLM to make a query for neo4j
Test if the query returns anything
Keep going until the query returns something
"""
class Prompt_Response():
def __init__(self, user_input):
self.user_input = user_input
# NOTE: For testing, I added a single Mesh disease which I knew was in the KG
self.mesh_ids = ['D044584']
self.non_disease_entities = list()
self.relationships = list()
self.client = OpenAI_API()
def perform_ner(self, debug=True):
if debug:
print("PERFORMING NER...")
ner = SpacyNER()
disease_ner_results, scientific_entity_ner_results, pos_results, mesh_ids = ner.get_entities(self.user_input)
# Check for mesh_ids
if mesh_ids:
if debug:
print("MESH IDS: {}".format(mesh_ids))
disease_entities = [d.text for d in mesh_ids.keys()]
# Get the mesh ids
mesh_list = [mesh_ids[entity] for entity in mesh_ids.keys()]
# Identify non-disease entities
non_disease_entities = [entity for entity, e_type in scientific_entity_ner_results if
entity not in disease_entities]
for entity, e_type in pos_results:
if e_type == 'NOUN':
in_diseases = False
for d in disease_entities:
if entity in d:
in_diseases = True
if not in_diseases:
non_disease_entities += [entity]
relationships = []
for entity, e_type in pos_results:
if e_type == 'VERB':
relationships += [entity]
# TODO: Clean up double for loop
for id in mesh_list:
for i in id:
self.mesh_ids.append(i)
self.non_disease_entities += non_disease_entities
self.relationships += relationships
if debug:
print("Debug diagnostic")
print("self.mesh_ids: {}".format(self.mesh_ids))
print("self.non_disease_entities: {}".format(self.non_disease_entities))
print("self.relationships: {}".format(self.relationships))
def process_kg_results(self, results: list):
for res in results:
print(res[1][0], type(res[1]))
def kg(self, debug=True):
# Save results for mesh, non-disease entities and relationships
# TODO: There is likely a better way of doing this
mesh_id_results = list()
non_empty_mesh_id_results = list()
non_disease_ent_results = list()
relationship_results = list()
# Connect to the API for Neo4j
neo4j_api = Neo4j_API()
# Use the Neo4j api to find relevant mesh diseases
for mesh_id in self.mesh_ids:
# if debug:
# print(self.mesh_ids)
# TODO: May need to use the API and check if there are better ways of calling this query
# TODO: There may be Mesh items that are compounds instead of diseases
mesh_query = "MATCH (n:MeSH_Disease {{name: 'MeSH_Disease:{}'}}) RETURN n LIMIT 25".format(mesh_id)
result = neo4j_api.search(mesh_query)
mesh_id_results.append([mesh_id, result])
# Determine which Mesh IDs were able to be found in the knowledge graph
# TODO: There is likely more that can be done with this information
for id in mesh_id_results:
if id[1][0] != []:
non_empty_mesh_id_results.append(id[0])
# TODO: Implement context queries to LLM
# For each of the non-disease entities, see if you can create a query for it using the API
# From there, try and see if the query returns anything
# If the query returns something, then stop
# Otherwise, try and update the prompt
# There is no current way of saving the context
# You must send the information every time in the prompt
# Check the non-disease entities are in the graph if any
node_types = list(neo4j_api.get_node_types())
# Also be sure to save
for entity in self.non_disease_entities:
found_word = False
self.client.clear_context()
while not found_word:
# If no message has been passed in yet, then start with this inital prompt
if self.client.get_context_length() < 2:
prompt = "What is the word '{}' closest to in the following list of terms: {}? You must select only one word from the list.".format(entity, node_types)
# If there have been prompts before, then
else:
prompt = "Retry but do not make the output verbose at all."
response = self.client.single_chat(prompt)
if response[0][11:] in list(node_types):
# TODO: This may be redundant but add break just in case
found_word = True
break
else:
# Add the context to the client for "failed" responses
context_message = response[0][11:]
self.client.add_context(context_message=context_message)
print("LLM response: {}".format(response[0]))
print("Parameter self.messages: {}".format(response[1]))
# non_disease_ent_results.append([entity, get_gpt_response(entity, node_types)])
if debug:
print("MESH ID RESULTS")
print(mesh_id_results)
# prompt = "What does the MESH ID {} correspond to?".format(self.mesh_ids[0])
# print(self.client.single_chat(prompt))
# print(self.client.single_chat("What does this MESH ID correspond to: {}".format(self.mesh_ids[0])))
# """
# This function identifies relevant nodes in the knowledge graph
# """
# mesh_ids, non_disease_entities, relationships = ner_results
# # Connect to the Neo4j API
# neo4j_api = Neo4j_API()
# # Check the MeSH terms are in the graph if any
# for mesh_id in mesh_ids:
# print(mesh_ids[mesh_id])
# mesh_query = "MATCH (n:MeSH_Disease {{name: 'MeSH_Disease:{}'}}) RETURN n LIMIT 25".format(mesh_ids[mesh_id][0])
# result = neo4j_api.search(mesh_query)
# mesh_id_results.append([mesh_ids[mesh_id][0], result])
# # Check the non-disease entities are in the graph if any
# node_types = neo4j_api.get_node_types()
# # Also be sure to save
# for entity in non_disease_entities:
# non_disease_ent_results.append([entity, get_gpt_response(entity, node_types)])
# # Check the relationships are in the graph if any
# relationship_types = neo4j_api.get_rel_types()
# for rel in relationships:
# relationship_results.append([rel, get_gpt_response(rel, relationship_types)])
if __name__ == "__main__":
prompt = "How does aspartate aminotransferase affect myocardial ischemia, arrhythmias, and ductal carcinoma?"
pr = Prompt_Response(prompt)
pr.perform_ner()
pr.kg()
"""
Spare notes
'''
TODO Joseph
- Replace 'Entity' with the Node Type identified from Neo4j API
e.g., neo4j_api.get_node_type_properties() -> find the closest match. Maybe ask LLM to identify best match?
- After creating the query, query the KG see if the node exists (if it's a class-based node like 'drug',
then get a few examples? Otherwise if it's a specific drug with an ID, check it exists.
MY NOTES
Do ner on the results (which is what is currently doing) and see the results that are most most similar to
'''
'''
TODO Joseph
- Similar to above, but use neo4j_api.get_rel_types() to find the closest match.
- To consider, how do we know which node types the relationships needs? This means we have to look at the
original query, in the NER step and identify head and tail of the relationship... Then we can use the
neo4j_api.get_uniq_relation_pairs() to find the closest match.
'''
""" | [
"Which of the following is PLACEHOLDER most similar to in the following list: PLACEHOLDER? \n You may select an item even if it does not seem that similar, \n just be sure to pick one. Only list the terms seperated by commas with \n no additional information or descriptions.",
"Retry but do not make the output verbose at all.",
"What is the word 'PLACEHOLDER' closest to in the following list of terms: PLACEHOLDER? You must select only one word from the list.",
"How does aspartate aminotransferase affect myocardial ischemia, arrhythmias, and ductal carcinoma?"
] |
2024-01-10 | dahwin/AudioGPT | audio-chatgpt.py | import sys
import os
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'NeuralSeq'))
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'text_to_audio/Make_An_Audio'))
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'audio_detection'))
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'mono2binaural'))
import gradio as gr
import matplotlib
import librosa
import torch
from langchain.agents.initialize import initialize_agent
from langchain.agents.tools import Tool
from langchain.chains.conversation.memory import ConversationBufferMemory
from langchain.llms.openai import OpenAI
import re
import uuid
import soundfile
from PIL import Image
import numpy as np
from omegaconf import OmegaConf
from einops import repeat
from ldm.util import instantiate_from_config
from ldm.data.extract_mel_spectrogram import TRANSFORMS_16000
from vocoder.bigvgan.models import VocoderBigVGAN
from ldm.models.diffusion.ddim import DDIMSampler
import whisper
from utils.hparams import set_hparams
from utils.hparams import hparams as hp
import scipy.io.wavfile as wavfile
import librosa
from audio_infer.utils import config as detection_config
from audio_infer.pytorch.models import PVT
import clip
import numpy as np
AUDIO_CHATGPT_PREFIX = """AudioGPT
AudioGPT can not directly read audios, but it has a list of tools to finish different speech, audio, and singing voice tasks. Each audio will have a file name formed as "audio/xxx.wav". When talking about audios, AudioGPT is very strict to the file name and will never fabricate nonexistent files.
AudioGPT is able to use tools in a sequence, and is loyal to the tool observation outputs rather than faking the audio content and audio file name. It will remember to provide the file name from the last tool observation, if a new audio is generated.
Human may provide new audios to AudioGPT with a description. The description helps AudioGPT to understand this audio, but AudioGPT should use tools to finish following tasks, rather than directly imagine from the description.
Overall, AudioGPT is a powerful audio dialogue assistant tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics.
TOOLS:
------
AudioGPT has access to the following tools:"""
AUDIO_CHATGPT_FORMAT_INSTRUCTIONS = """To use a tool, please use the following format:
```
Thought: Do I need to use a tool? Yes
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
```
When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
```
Thought: Do I need to use a tool? No
{ai_prefix}: [your response here]
```
"""
AUDIO_CHATGPT_SUFFIX = """You are very strict to the filename correctness and will never fake a file name if not exists.
You will remember to provide the audio file name loyally if it's provided in the last tool observation.
Begin!
Previous conversation history:
{chat_history}
New input: {input}
Thought: Do I need to use a tool? {agent_scratchpad}"""
def cut_dialogue_history(history_memory, keep_last_n_words = 500):
tokens = history_memory.split()
n_tokens = len(tokens)
print(f"history_memory:{history_memory}, n_tokens: {n_tokens}")
if n_tokens < keep_last_n_words:
return history_memory
else:
paragraphs = history_memory.split('\n')
last_n_tokens = n_tokens
while last_n_tokens >= keep_last_n_words:
last_n_tokens = last_n_tokens - len(paragraphs[0].split(' '))
paragraphs = paragraphs[1:]
return '\n' + '\n'.join(paragraphs)
def merge_audio(audio_path_1, audio_path_2):
merged_signal = []
sr_1, signal_1 = wavfile.read(audio_path_1)
sr_2, signal_2 = wavfile.read(audio_path_2)
merged_signal.append(signal_1)
merged_signal.append(signal_2)
merged_signal = np.hstack(merged_signal)
merged_signal = np.asarray(merged_signal, dtype=np.int16)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
wavfile.write(audio_filename, sr_2, merged_signal)
return audio_filename
class T2I:
def __init__(self, device):
from transformers import AutoModelForCausalLM, AutoTokenizer
from diffusers import StableDiffusionPipeline
from transformers import pipeline
print("Initializing T2I to %s" % device)
self.device = device
self.pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
self.text_refine_tokenizer = AutoTokenizer.from_pretrained("Gustavosta/MagicPrompt-Stable-Diffusion")
self.text_refine_model = AutoModelForCausalLM.from_pretrained("Gustavosta/MagicPrompt-Stable-Diffusion")
self.text_refine_gpt2_pipe = pipeline("text-generation", model=self.text_refine_model, tokenizer=self.text_refine_tokenizer, device=self.device)
self.pipe.to(device)
def inference(self, text):
image_filename = os.path.join('image', str(uuid.uuid4())[0:8] + ".png")
refined_text = self.text_refine_gpt2_pipe(text)[0]["generated_text"]
print(f'{text} refined to {refined_text}')
image = self.pipe(refined_text).images[0]
image.save(image_filename)
print(f"Processed T2I.run, text: {text}, image_filename: {image_filename}")
return image_filename
class ImageCaptioning:
def __init__(self, device):
from transformers import BlipProcessor, BlipForConditionalGeneration
print("Initializing ImageCaptioning to %s" % device)
self.device = device
self.processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
self.model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to(self.device)
def inference(self, image_path):
inputs = self.processor(Image.open(image_path), return_tensors="pt").to(self.device)
out = self.model.generate(**inputs)
captions = self.processor.decode(out[0], skip_special_tokens=True)
return captions
class T2A:
def __init__(self, device):
print("Initializing Make-An-Audio to %s" % device)
self.device = device
self.sampler = self._initialize_model('text_to_audio/Make_An_Audio/configs/text_to_audio/txt2audio_args.yaml', 'text_to_audio/Make_An_Audio/useful_ckpts/ta40multi_epoch=000085.ckpt', device=device)
self.vocoder = VocoderBigVGAN('text_to_audio/Make_An_Audio/vocoder/logs/bigv16k53w',device=device)
def _initialize_model(self, config, ckpt, device):
config = OmegaConf.load(config)
model = instantiate_from_config(config.model)
model.load_state_dict(torch.load(ckpt, map_location='cpu')["state_dict"], strict=False)
model = model.to(device)
model.cond_stage_model.to(model.device)
model.cond_stage_model.device = model.device
sampler = DDIMSampler(model)
return sampler
def txt2audio(self, text, seed = 55, scale = 1.5, ddim_steps = 100, n_samples = 3, W = 624, H = 80):
SAMPLE_RATE = 16000
prng = np.random.RandomState(seed)
start_code = prng.randn(n_samples, self.sampler.model.first_stage_model.embed_dim, H // 8, W // 8)
start_code = torch.from_numpy(start_code).to(device=self.device, dtype=torch.float32)
uc = self.sampler.model.get_learned_conditioning(n_samples * [""])
c = self.sampler.model.get_learned_conditioning(n_samples * [text])
shape = [self.sampler.model.first_stage_model.embed_dim, H//8, W//8] # (z_dim, 80//2^x, 848//2^x)
samples_ddim, _ = self.sampler.sample(S = ddim_steps,
conditioning = c,
batch_size = n_samples,
shape = shape,
verbose = False,
unconditional_guidance_scale = scale,
unconditional_conditioning = uc,
x_T = start_code)
x_samples_ddim = self.sampler.model.decode_first_stage(samples_ddim)
x_samples_ddim = torch.clamp((x_samples_ddim+1.0)/2.0, min=0.0, max=1.0) # [0, 1]
wav_list = []
for idx,spec in enumerate(x_samples_ddim):
wav = self.vocoder.vocode(spec)
wav_list.append((SAMPLE_RATE,wav))
best_wav = self.select_best_audio(text, wav_list)
return best_wav
def select_best_audio(self, prompt, wav_list):
from wav_evaluation.models.CLAPWrapper import CLAPWrapper
clap_model = CLAPWrapper('text_to_audio/Make_An_Audio/useful_ckpts/CLAP/CLAP_weights_2022.pth', 'text_to_audio/Make_An_Audio/useful_ckpts/CLAP/config.yml',
use_cuda=torch.cuda.is_available())
text_embeddings = clap_model.get_text_embeddings([prompt])
score_list = []
for data in wav_list:
sr, wav = data
audio_embeddings = clap_model.get_audio_embeddings([(torch.FloatTensor(wav), sr)], resample=True)
score = clap_model.compute_similarity(audio_embeddings, text_embeddings,
use_logit_scale=False).squeeze().cpu().numpy()
score_list.append(score)
max_index = np.array(score_list).argmax()
print(score_list, max_index)
return wav_list[max_index]
def inference(self, text, seed = 55, scale = 1.5, ddim_steps = 100, n_samples = 3, W = 624, H = 80):
melbins,mel_len = 80,624
with torch.no_grad():
result = self.txt2audio(
text = text,
H = melbins,
W = mel_len
)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename, result[1], samplerate = 16000)
print(f"Processed T2I.run, text: {text}, audio_filename: {audio_filename}")
return audio_filename
class I2A:
def __init__(self, device):
print("Initializing Make-An-Audio-Image to %s" % device)
self.device = device
self.sampler = self._initialize_model('text_to_audio/Make_An_Audio/configs/img_to_audio/img2audio_args.yaml', 'text_to_audio/Make_An_Audio/useful_ckpts/ta54_epoch=000216.ckpt', device=device)
self.vocoder = VocoderBigVGAN('text_to_audio/Make_An_Audio/vocoder/logs/bigv16k53w',device=device)
def _initialize_model(self, config, ckpt, device):
config = OmegaConf.load(config)
model = instantiate_from_config(config.model)
model.load_state_dict(torch.load(ckpt, map_location='cpu')["state_dict"], strict=False)
model = model.to(device)
model.cond_stage_model.to(model.device)
model.cond_stage_model.device = model.device
sampler = DDIMSampler(model)
return sampler
def img2audio(self, image, seed = 55, scale = 3, ddim_steps = 100, W = 624, H = 80):
SAMPLE_RATE = 16000
n_samples = 1 # only support 1 sample
prng = np.random.RandomState(seed)
start_code = prng.randn(n_samples, self.sampler.model.first_stage_model.embed_dim, H // 8, W // 8)
start_code = torch.from_numpy(start_code).to(device=self.device, dtype=torch.float32)
uc = self.sampler.model.get_learned_conditioning(n_samples * [""])
#image = Image.fromarray(image)
image = Image.open(image)
image = self.sampler.model.cond_stage_model.preprocess(image).unsqueeze(0)
image_embedding = self.sampler.model.cond_stage_model.forward_img(image)
c = image_embedding.repeat(n_samples, 1, 1)
shape = [self.sampler.model.first_stage_model.embed_dim, H//8, W//8] # (z_dim, 80//2^x, 848//2^x)
samples_ddim, _ = self.sampler.sample(S=ddim_steps,
conditioning=c,
batch_size=n_samples,
shape=shape,
verbose=False,
unconditional_guidance_scale=scale,
unconditional_conditioning=uc,
x_T=start_code)
x_samples_ddim = self.sampler.model.decode_first_stage(samples_ddim)
x_samples_ddim = torch.clamp((x_samples_ddim+1.0)/2.0, min=0.0, max=1.0) # [0, 1]
wav_list = []
for idx,spec in enumerate(x_samples_ddim):
wav = self.vocoder.vocode(spec)
wav_list.append((SAMPLE_RATE,wav))
best_wav = wav_list[0]
return best_wav
def inference(self, image, seed = 55, scale = 3, ddim_steps = 100, W = 624, H = 80):
melbins,mel_len = 80,624
with torch.no_grad():
result = self.img2audio(
image=image,
H=melbins,
W=mel_len
)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename, result[1], samplerate = 16000)
print(f"Processed I2a.run, image_filename: {image}, audio_filename: {audio_filename}")
return audio_filename
class TTS:
def __init__(self, device=None):
from inference.tts.PortaSpeech import TTSInference
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print("Initializing PortaSpeech to %s" % device)
self.device = device
self.exp_name = 'checkpoints/ps_adv_baseline'
self.set_model_hparams()
self.inferencer = TTSInference(self.hp, device)
def set_model_hparams(self):
set_hparams(exp_name=self.exp_name, print_hparams=False)
self.hp = hp
def inference(self, text):
self.set_model_hparams()
inp = {"text": text}
out = self.inferencer.infer_once(inp)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename, out, samplerate=22050)
return audio_filename
class T2S:
def __init__(self, device= None):
from inference.svs.ds_e2e import DiffSingerE2EInfer
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print("Initializing DiffSinger to %s" % device)
self.device = device
self.exp_name = 'checkpoints/0831_opencpop_ds1000'
self.config= 'NeuralSeq/egs/egs_bases/svs/midi/e2e/opencpop/ds1000.yaml'
self.set_model_hparams()
self.pipe = DiffSingerE2EInfer(self.hp, device)
self.default_inp = {
'text': '你 说 你 不 SP 懂 为 何 在 这 时 牵 手 AP',
'notes': 'D#4/Eb4 | D#4/Eb4 | D#4/Eb4 | D#4/Eb4 | rest | D#4/Eb4 | D4 | D4 | D4 | D#4/Eb4 | F4 | D#4/Eb4 | D4 | rest',
'notes_duration': '0.113740 | 0.329060 | 0.287950 | 0.133480 | 0.150900 | 0.484730 | 0.242010 | 0.180820 | 0.343570 | 0.152050 | 0.266720 | 0.280310 | 0.633300 | 0.444590'
}
def set_model_hparams(self):
set_hparams(config=self.config, exp_name=self.exp_name, print_hparams=False)
self.hp = hp
def inference(self, inputs):
self.set_model_hparams()
val = inputs.split(",")
key = ['text', 'notes', 'notes_duration']
try:
inp = {k: v for k, v in zip(key, val)}
wav = self.pipe.infer_once(inp)
except:
print('Error occurs. Generate default audio sample.\n')
inp = self.default_inp
wav = self.pipe.infer_once(inp)
#if inputs == '' or len(val) < len(key):
# inp = self.default_inp
#else:
# inp = {k:v for k,v in zip(key,val)}
#wav = self.pipe.infer_once(inp)
wav *= 32767
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
wavfile.write(audio_filename, self.hp['audio_sample_rate'], wav.astype(np.int16))
print(f"Processed T2S.run, audio_filename: {audio_filename}")
return audio_filename
class t2s_VISinger:
def __init__(self, device=None):
from espnet2.bin.svs_inference import SingingGenerate
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print("Initializing VISingere to %s" % device)
tag = 'AQuarterMile/opencpop_visinger1'
self.model = SingingGenerate.from_pretrained(
model_tag=str_or_none(tag),
device=device,
)
phn_dur = [[0. , 0.219 ],
[0.219 , 0.50599998],
[0.50599998, 0.71399999],
[0.71399999, 1.097 ],
[1.097 , 1.28799999],
[1.28799999, 1.98300004],
[1.98300004, 7.10500002],
[7.10500002, 7.60400009]]
phn = ['sh', 'i', 'q', 'v', 'n', 'i', 'SP', 'AP']
score = [[0, 0.50625, 'sh_i', 58, 'sh_i'], [0.50625, 1.09728, 'q_v', 56, 'q_v'], [1.09728, 1.9832100000000001, 'n_i', 53, 'n_i'], [1.9832100000000001, 7.105360000000001, 'SP', 0, 'SP'], [7.105360000000001, 7.604390000000001, 'AP', 0, 'AP']]
tempo = 70
tmp = {}
tmp["label"] = phn_dur, phn
tmp["score"] = tempo, score
self.default_inp = tmp
def inference(self, inputs):
val = inputs.split(",")
key = ['text', 'notes', 'notes_duration']
try: # TODO: input will be update
inp = {k: v for k, v in zip(key, val)}
wav = self.model(text=inp)["wav"]
except:
print('Error occurs. Generate default audio sample.\n')
inp = self.default_inp
wav = self.model(text=inp)["wav"]
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename, wav, samplerate=self.model.fs)
return audio_filename
class TTS_OOD:
def __init__(self, device):
from inference.tts.GenerSpeech import GenerSpeechInfer
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print("Initializing GenerSpeech to %s" % device)
self.device = device
self.exp_name = 'checkpoints/GenerSpeech'
self.config = 'NeuralSeq/modules/GenerSpeech/config/generspeech.yaml'
self.set_model_hparams()
self.pipe = GenerSpeechInfer(self.hp, device)
def set_model_hparams(self):
set_hparams(config=self.config, exp_name=self.exp_name, print_hparams=False)
f0_stats_fn = f'{hp["binary_data_dir"]}/train_f0s_mean_std.npy'
if os.path.exists(f0_stats_fn):
hp['f0_mean'], hp['f0_std'] = np.load(f0_stats_fn)
hp['f0_mean'] = float(hp['f0_mean'])
hp['f0_std'] = float(hp['f0_std'])
hp['emotion_encoder_path'] = 'checkpoints/Emotion_encoder.pt'
self.hp = hp
def inference(self, inputs):
self.set_model_hparams()
key = ['ref_audio', 'text']
val = inputs.split(",")
inp = {k: v for k, v in zip(key, val)}
wav = self.pipe.infer_once(inp)
wav *= 32767
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
wavfile.write(audio_filename, self.hp['audio_sample_rate'], wav.astype(np.int16))
print(
f"Processed GenerSpeech.run. Input text:{val[1]}. Input reference audio: {val[0]}. Output Audio_filename: {audio_filename}")
return audio_filename
class Inpaint:
def __init__(self, device):
print("Initializing Make-An-Audio-inpaint to %s" % device)
self.device = device
self.sampler = self._initialize_model_inpaint('text_to_audio/Make_An_Audio/configs/inpaint/txt2audio_args.yaml', 'text_to_audio/Make_An_Audio/useful_ckpts/inpaint7_epoch00047.ckpt')
self.vocoder = VocoderBigVGAN('text_to_audio/Make_An_Audio/vocoder/logs/bigv16k53w',device=device)
self.cmap_transform = matplotlib.cm.viridis
def _initialize_model_inpaint(self, config, ckpt):
config = OmegaConf.load(config)
model = instantiate_from_config(config.model)
model.load_state_dict(torch.load(ckpt, map_location='cpu')["state_dict"], strict=False)
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model = model.to(device)
print(model.device, device, model.cond_stage_model.device)
sampler = DDIMSampler(model)
return sampler
def make_batch_sd(self, mel, mask, num_samples=1):
mel = torch.from_numpy(mel)[None,None,...].to(dtype=torch.float32)
mask = torch.from_numpy(mask)[None,None,...].to(dtype=torch.float32)
masked_mel = (1 - mask) * mel
mel = mel * 2 - 1
mask = mask * 2 - 1
masked_mel = masked_mel * 2 -1
batch = {
"mel": repeat(mel.to(device=self.device), "1 ... -> n ...", n=num_samples),
"mask": repeat(mask.to(device=self.device), "1 ... -> n ...", n=num_samples),
"masked_mel": repeat(masked_mel.to(device=self.device), "1 ... -> n ...", n=num_samples),
}
return batch
def gen_mel(self, input_audio_path):
SAMPLE_RATE = 16000
sr, ori_wav = wavfile.read(input_audio_path)
print("gen_mel")
print(sr,ori_wav.shape,ori_wav)
ori_wav = ori_wav.astype(np.float32, order='C') / 32768.0
if len(ori_wav.shape)==2:# stereo
ori_wav = librosa.to_mono(ori_wav.T)
print(sr,ori_wav.shape,ori_wav)
ori_wav = librosa.resample(ori_wav,orig_sr = sr,target_sr = SAMPLE_RATE)
mel_len,hop_size = 848,256
input_len = mel_len * hop_size
if len(ori_wav) < input_len:
input_wav = np.pad(ori_wav,(0,mel_len*hop_size),constant_values=0)
else:
input_wav = ori_wav[:input_len]
mel = TRANSFORMS_16000(input_wav)
return mel
def gen_mel_audio(self, input_audio):
SAMPLE_RATE = 16000
sr,ori_wav = input_audio
print("gen_mel_audio")
print(sr,ori_wav.shape,ori_wav)
ori_wav = ori_wav.astype(np.float32, order='C') / 32768.0
if len(ori_wav.shape)==2:# stereo
ori_wav = librosa.to_mono(ori_wav.T)
print(sr,ori_wav.shape,ori_wav)
ori_wav = librosa.resample(ori_wav,orig_sr = sr,target_sr = SAMPLE_RATE)
mel_len,hop_size = 848,256
input_len = mel_len * hop_size
if len(ori_wav) < input_len:
input_wav = np.pad(ori_wav,(0,mel_len*hop_size),constant_values=0)
else:
input_wav = ori_wav[:input_len]
mel = TRANSFORMS_16000(input_wav)
return mel
def show_mel_fn(self, input_audio_path):
crop_len = 500
crop_mel = self.gen_mel(input_audio_path)[:,:crop_len]
color_mel = self.cmap_transform(crop_mel)
image = Image.fromarray((color_mel*255).astype(np.uint8))
image_filename = os.path.join('image', str(uuid.uuid4())[0:8] + ".png")
image.save(image_filename)
return image_filename
def inpaint(self, batch, seed, ddim_steps, num_samples=1, W=512, H=512):
model = self.sampler.model
prng = np.random.RandomState(seed)
start_code = prng.randn(num_samples, model.first_stage_model.embed_dim, H // 8, W // 8)
start_code = torch.from_numpy(start_code).to(device=self.device, dtype=torch.float32)
c = model.get_first_stage_encoding(model.encode_first_stage(batch["masked_mel"]))
cc = torch.nn.functional.interpolate(batch["mask"],
size=c.shape[-2:])
c = torch.cat((c, cc), dim=1) # (b,c+1,h,w) 1 is mask
shape = (c.shape[1]-1,)+c.shape[2:]
samples_ddim, _ = self.sampler.sample(S=ddim_steps,
conditioning=c,
batch_size=c.shape[0],
shape=shape,
verbose=False)
x_samples_ddim = model.decode_first_stage(samples_ddim)
mel = torch.clamp((batch["mel"]+1.0)/2.0,min=0.0, max=1.0)
mask = torch.clamp((batch["mask"]+1.0)/2.0,min=0.0, max=1.0)
predicted_mel = torch.clamp((x_samples_ddim+1.0)/2.0,min=0.0, max=1.0)
inpainted = (1-mask)*mel+mask*predicted_mel
inpainted = inpainted.cpu().numpy().squeeze()
inapint_wav = self.vocoder.vocode(inpainted)
return inpainted, inapint_wav
def inference(self, input_audio, mel_and_mask, seed = 55, ddim_steps = 100):
SAMPLE_RATE = 16000
torch.set_grad_enabled(False)
mel_img = Image.open(mel_and_mask['image'])
mask_img = Image.open(mel_and_mask["mask"])
show_mel = np.array(mel_img.convert("L"))/255
mask = np.array(mask_img.convert("L"))/255
mel_bins,mel_len = 80,848
input_mel = self.gen_mel_audio(input_audio)[:,:mel_len]
mask = np.pad(mask,((0,0),(0,mel_len-mask.shape[1])),mode='constant',constant_values=0)
print(mask.shape,input_mel.shape)
with torch.no_grad():
batch = self.make_batch_sd(input_mel,mask,num_samples=1)
inpainted,gen_wav = self.inpaint(
batch=batch,
seed=seed,
ddim_steps=ddim_steps,
num_samples=1,
H=mel_bins, W=mel_len
)
inpainted = inpainted[:,:show_mel.shape[1]]
color_mel = self.cmap_transform(inpainted)
input_len = int(input_audio[1].shape[0] * SAMPLE_RATE / input_audio[0])
gen_wav = (gen_wav * 32768).astype(np.int16)[:input_len]
image = Image.fromarray((color_mel*255).astype(np.uint8))
image_filename = os.path.join('image', str(uuid.uuid4())[0:8] + ".png")
image.save(image_filename)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename, gen_wav, samplerate = 16000)
return image_filename, audio_filename
class ASR:
def __init__(self, device):
print("Initializing Whisper to %s" % device)
self.device = device
self.model = whisper.load_model("base", device=device)
def inference(self, audio_path):
audio = whisper.load_audio(audio_path)
audio = whisper.pad_or_trim(audio)
mel = whisper.log_mel_spectrogram(audio).to(self.device)
_, probs = self.model.detect_language(mel)
options = whisper.DecodingOptions()
result = whisper.decode(self.model, mel, options)
return result.text
def translate_english(self, audio_path):
audio = self.model.transcribe(audio_path, language='English')
return audio['text']
class A2T:
def __init__(self, device):
from audio_to_text.inference_waveform import AudioCapModel
print("Initializing Audio-To-Text Model to %s" % device)
self.device = device
self.model = AudioCapModel("audio_to_text/audiocaps_cntrstv_cnn14rnn_trm")
def inference(self, audio_path):
audio = whisper.load_audio(audio_path)
caption_text = self.model(audio)
return caption_text[0]
class GeneFace:
def __init__(self, device=None):
print("Initializing GeneFace model to %s" % device)
from audio_to_face.GeneFace_binding import GeneFaceInfer
if device is None:
device = 'cuda' if torch.cuda.is_available() else 'cpu'
self.device = device
self.geneface_model = GeneFaceInfer(device)
print("Loaded GeneFace model")
def inference(self, audio_path):
audio_base_name = os.path.basename(audio_path)[:-4]
out_video_name = audio_path.replace("audio","video").replace(".wav", ".mp4")
inp = {
'audio_source_name': audio_path,
'out_npy_name': f'geneface/tmp/{audio_base_name}.npy',
'cond_name': f'geneface/tmp/{audio_base_name}.npy',
'out_video_name': out_video_name,
'tmp_imgs_dir': f'video/tmp_imgs',
}
self.geneface_model.infer_once(inp)
return out_video_name
class SoundDetection:
def __init__(self, device):
self.device = device
self.sample_rate = 32000
self.window_size = 1024
self.hop_size = 320
self.mel_bins = 64
self.fmin = 50
self.fmax = 14000
self.model_type = 'PVT'
self.checkpoint_path = 'audio_detection/audio_infer/useful_ckpts/audio_detection.pth'
self.classes_num = detection_config.classes_num
self.labels = detection_config.labels
self.frames_per_second = self.sample_rate // self.hop_size
# Model = eval(self.model_type)
self.model = PVT(sample_rate=self.sample_rate, window_size=self.window_size,
hop_size=self.hop_size, mel_bins=self.mel_bins, fmin=self.fmin, fmax=self.fmax,
classes_num=self.classes_num)
checkpoint = torch.load(self.checkpoint_path, map_location=self.device)
self.model.load_state_dict(checkpoint['model'])
self.model.to(device)
def inference(self, audio_path):
# Forward
(waveform, _) = librosa.core.load(audio_path, sr=self.sample_rate, mono=True)
waveform = waveform[None, :] # (1, audio_length)
waveform = torch.from_numpy(waveform)
waveform = waveform.to(self.device)
# Forward
with torch.no_grad():
self.model.eval()
batch_output_dict = self.model(waveform, None)
framewise_output = batch_output_dict['framewise_output'].data.cpu().numpy()[0]
"""(time_steps, classes_num)"""
# print('Sound event detection result (time_steps x classes_num): {}'.format(
# framewise_output.shape))
import numpy as np
import matplotlib.pyplot as plt
sorted_indexes = np.argsort(np.max(framewise_output, axis=0))[::-1]
top_k = 10 # Show top results
top_result_mat = framewise_output[:, sorted_indexes[0 : top_k]]
"""(time_steps, top_k)"""
# Plot result
stft = librosa.core.stft(y=waveform[0].data.cpu().numpy(), n_fft=self.window_size,
hop_length=self.hop_size, window='hann', center=True)
frames_num = stft.shape[-1]
fig, axs = plt.subplots(2, 1, sharex=True, figsize=(10, 4))
axs[0].matshow(np.log(np.abs(stft)), origin='lower', aspect='auto', cmap='jet')
axs[0].set_ylabel('Frequency bins')
axs[0].set_title('Log spectrogram')
axs[1].matshow(top_result_mat.T, origin='upper', aspect='auto', cmap='jet', vmin=0, vmax=1)
axs[1].xaxis.set_ticks(np.arange(0, frames_num, self.frames_per_second))
axs[1].xaxis.set_ticklabels(np.arange(0, frames_num / self.frames_per_second))
axs[1].yaxis.set_ticks(np.arange(0, top_k))
axs[1].yaxis.set_ticklabels(np.array(self.labels)[sorted_indexes[0 : top_k]])
axs[1].yaxis.grid(color='k', linestyle='solid', linewidth=0.3, alpha=0.3)
axs[1].set_xlabel('Seconds')
axs[1].xaxis.set_ticks_position('bottom')
plt.tight_layout()
image_filename = os.path.join('image', str(uuid.uuid4())[0:8] + ".png")
plt.savefig(image_filename)
return image_filename
class SoundExtraction:
def __init__(self, device):
from sound_extraction.model.LASSNet import LASSNet
from sound_extraction.utils.stft import STFT
import torch.nn as nn
self.device = device
self.model_file = 'sound_extraction/useful_ckpts/LASSNet.pt'
self.stft = STFT()
self.model = nn.DataParallel(LASSNet(device)).to(device)
checkpoint = torch.load(self.model_file)
self.model.load_state_dict(checkpoint['model'])
self.model.eval()
def inference(self, inputs):
#key = ['ref_audio', 'text']
from sound_extraction.utils.wav_io import load_wav, save_wav
val = inputs.split(",")
audio_path = val[0] # audio_path, text
text = val[1]
waveform = load_wav(audio_path)
waveform = torch.tensor(waveform).transpose(1,0)
mixed_mag, mixed_phase = self.stft.transform(waveform)
text_query = ['[CLS] ' + text]
mixed_mag = mixed_mag.transpose(2,1).unsqueeze(0).to(self.device)
est_mask = self.model(mixed_mag, text_query)
est_mag = est_mask * mixed_mag
est_mag = est_mag.squeeze(1)
est_mag = est_mag.permute(0, 2, 1)
est_wav = self.stft.inverse(est_mag.cpu().detach(), mixed_phase)
est_wav = est_wav.squeeze(0).squeeze(0).numpy()
#est_path = f'output/est{i}.wav'
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
print('audio_filename ', audio_filename)
save_wav(est_wav, audio_filename)
return audio_filename
class Binaural:
def __init__(self, device):
from src.models import BinauralNetwork
self.device = device
self.model_file = 'mono2binaural/useful_ckpts/m2b/binaural_network.net'
self.position_file = ['mono2binaural/useful_ckpts/m2b/tx_positions.txt',
'mono2binaural/useful_ckpts/m2b/tx_positions2.txt',
'mono2binaural/useful_ckpts/m2b/tx_positions3.txt',
'mono2binaural/useful_ckpts/m2b/tx_positions4.txt',
'mono2binaural/useful_ckpts/m2b/tx_positions5.txt']
self.net = BinauralNetwork(view_dim=7,
warpnet_layers=4,
warpnet_channels=64,
)
self.net.load_from_file(self.model_file)
self.sr = 48000
def inference(self, audio_path):
mono, sr = librosa.load(path=audio_path, sr=self.sr, mono=True)
mono = torch.from_numpy(mono)
mono = mono.unsqueeze(0)
import numpy as np
import random
rand_int = random.randint(0,4)
view = np.loadtxt(self.position_file[rand_int]).transpose().astype(np.float32)
view = torch.from_numpy(view)
if not view.shape[-1] * 400 == mono.shape[-1]:
mono = mono[:,:(mono.shape[-1]//400)*400] #
if view.shape[1]*400 > mono.shape[1]:
m_a = view.shape[1] - mono.shape[-1]//400
rand_st = random.randint(0,m_a)
view = view[:,m_a:m_a+(mono.shape[-1]//400)] #
# binauralize and save output
self.net.eval().to(self.device)
mono, view = mono.to(self.device), view.to(self.device)
chunk_size = 48000 # forward in chunks of 1s
rec_field = 1000 # add 1000 samples as "safe bet" since warping has undefined rec. field
rec_field -= rec_field % 400 # make sure rec_field is a multiple of 400 to match audio and view frequencies
chunks = [
{
"mono": mono[:, max(0, i-rec_field):i+chunk_size],
"view": view[:, max(0, i-rec_field)//400:(i+chunk_size)//400]
}
for i in range(0, mono.shape[-1], chunk_size)
]
for i, chunk in enumerate(chunks):
with torch.no_grad():
mono = chunk["mono"].unsqueeze(0)
view = chunk["view"].unsqueeze(0)
binaural = self.net(mono, view).squeeze(0)
if i > 0:
binaural = binaural[:, -(mono.shape[-1]-rec_field):]
chunk["binaural"] = binaural
binaural = torch.cat([chunk["binaural"] for chunk in chunks], dim=-1)
binaural = torch.clamp(binaural, min=-1, max=1).cpu()
#binaural = chunked_forwarding(net, mono, view)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
import torchaudio
torchaudio.save(audio_filename, binaural, sr)
#soundfile.write(audio_filename, binaural, samplerate = 48000)
print(f"Processed Binaural.run, audio_filename: {audio_filename}")
return audio_filename
class TargetSoundDetection:
def __init__(self, device):
from target_sound_detection.src import models as tsd_models
from target_sound_detection.src.models import event_labels
self.device = device
self.MEL_ARGS = {
'n_mels': 64,
'n_fft': 2048,
'hop_length': int(22050 * 20 / 1000),
'win_length': int(22050 * 40 / 1000)
}
self.EPS = np.spacing(1)
self.clip_model, _ = clip.load("ViT-B/32", device=self.device)
self.event_labels = event_labels
self.id_to_event = {i : label for i, label in enumerate(self.event_labels)}
config = torch.load('audio_detection/target_sound_detection/useful_ckpts/tsd/run_config.pth', map_location='cpu')
config_parameters = dict(config)
config_parameters['tao'] = 0.6
if 'thres' not in config_parameters.keys():
config_parameters['thres'] = 0.5
if 'time_resolution' not in config_parameters.keys():
config_parameters['time_resolution'] = 125
model_parameters = torch.load('audio_detection/target_sound_detection/useful_ckpts/tsd/run_model_7_loss=-0.0724.pt'
, map_location=lambda storage, loc: storage) # load parameter
self.model = getattr(tsd_models, config_parameters['model'])(config_parameters,
inputdim=64, outputdim=2, time_resolution=config_parameters['time_resolution'], **config_parameters['model_args'])
self.model.load_state_dict(model_parameters)
self.model = self.model.to(self.device).eval()
self.re_embeds = torch.load('audio_detection/target_sound_detection/useful_ckpts/tsd/text_emb.pth')
self.ref_mel = torch.load('audio_detection/target_sound_detection/useful_ckpts/tsd/ref_mel.pth')
def extract_feature(self, fname):
import soundfile as sf
y, sr = sf.read(fname, dtype='float32')
print('y ', y.shape)
ti = y.shape[0]/sr
if y.ndim > 1:
y = y.mean(1)
y = librosa.resample(y, sr, 22050)
lms_feature = np.log(librosa.feature.melspectrogram(y, **self.MEL_ARGS) + self.EPS).T
return lms_feature,ti
def build_clip(self, text):
text = clip.tokenize(text).to(self.device) # ["a diagram with dog", "a dog", "a cat"]
text_features = self.clip_model.encode_text(text)
return text_features
def cal_similarity(self, target, retrievals):
ans = []
#target =torch.from_numpy(target)
for name in retrievals.keys():
tmp = retrievals[name]
#tmp = torch.from_numpy(tmp)
s = torch.cosine_similarity(target.squeeze(), tmp.squeeze(), dim=0)
ans.append(s.item())
return ans.index(max(ans))
def inference(self, text, audio_path):
from target_sound_detection.src.utils import median_filter, decode_with_timestamps
target_emb = self.build_clip(text) # torch type
idx = self.cal_similarity(target_emb, self.re_embeds)
target_event = self.id_to_event[idx]
embedding = self.ref_mel[target_event]
embedding = torch.from_numpy(embedding)
embedding = embedding.unsqueeze(0).to(self.device).float()
#print('embedding ', embedding.shape)
inputs,ti = self.extract_feature(audio_path)
#print('ti ', ti)
inputs = torch.from_numpy(inputs)
inputs = inputs.unsqueeze(0).to(self.device).float()
#print('inputs ', inputs.shape)
decision, decision_up, logit = self.model(inputs, embedding)
pred = decision_up.detach().cpu().numpy()
pred = pred[:,:,0]
frame_num = decision_up.shape[1]
time_ratio = ti / frame_num
filtered_pred = median_filter(pred, window_size=1, threshold=0.5)
#print('filtered_pred ', filtered_pred)
time_predictions = []
for index_k in range(filtered_pred.shape[0]):
decoded_pred = []
decoded_pred_ = decode_with_timestamps(target_event, filtered_pred[index_k,:])
if len(decoded_pred_) == 0: # neg deal
decoded_pred_.append((target_event, 0, 0))
decoded_pred.append(decoded_pred_)
for num_batch in range(len(decoded_pred)): # when we test our model,the batch_size is 1
cur_pred = pred[num_batch]
# Save each frame output, for later visualization
label_prediction = decoded_pred[num_batch] # frame predict
# print(label_prediction)
for event_label, onset, offset in label_prediction:
time_predictions.append({
'onset': onset*time_ratio,
'offset': offset*time_ratio,})
ans = ''
for i,item in enumerate(time_predictions):
ans = ans + 'segment' + str(i+1) + ' start_time: ' + str(item['onset']) + ' end_time: ' + str(item['offset']) + '\t'
#print(ans)
return ans
# class Speech_Enh_SS_SC:
# """Speech Enhancement or Separation in single-channel
# Example usage:
# enh_model = Speech_Enh_SS("cuda")
# enh_wav = enh_model.inference("./test_chime4_audio_M05_440C0213_PED_REAL.wav")
# """
# def __init__(self, device="cuda", model_name="lichenda/chime4_fasnet_dprnn_tac"):
# self.model_name = model_name
# self.device = device
# print("Initializing ESPnet Enh to %s" % device)
# self._initialize_model()
# def _initialize_model(self):
# from espnet_model_zoo.downloader import ModelDownloader
# from espnet2.bin.enh_inference import SeparateSpeech
# d = ModelDownloader()
# cfg = d.download_and_unpack(self.model_name)
# self.separate_speech = SeparateSpeech(
# train_config=cfg["train_config"],
# model_file=cfg["model_file"],
# # for segment-wise process on long speech
# segment_size=2.4,
# hop_size=0.8,
# normalize_segment_scale=False,
# show_progressbar=True,
# ref_channel=None,
# normalize_output_wav=True,
# device=self.device,
# )
# def inference(self, speech_path, ref_channel=0):
# speech, sr = soundfile.read(speech_path)
# speech = speech[:, ref_channel]
# assert speech.dim() == 1
# enh_speech = self.separate_speech(speech[None, ], fs=sr)
# if len(enh_speech) == 1:
# return enh_speech[0]
# return enh_speech
# class Speech_Enh_SS_MC:
# """Speech Enhancement or Separation in multi-channel"""
# def __init__(self, device="cuda", model_name=None, ref_channel=4):
# self.model_name = model_name
# self.ref_channel = ref_channel
# self.device = device
# print("Initializing ESPnet Enh to %s" % device)
# self._initialize_model()
# def _initialize_model(self):
# from espnet_model_zoo.downloader import ModelDownloader
# from espnet2.bin.enh_inference import SeparateSpeech
# d = ModelDownloader()
# cfg = d.download_and_unpack(self.model_name)
# self.separate_speech = SeparateSpeech(
# train_config=cfg["train_config"],
# model_file=cfg["model_file"],
# # for segment-wise process on long speech
# segment_size=2.4,
# hop_size=0.8,
# normalize_segment_scale=False,
# show_progressbar=True,
# ref_channel=self.ref_channel,
# normalize_output_wav=True,
# device=self.device,
# )
# def inference(self, speech_path):
# speech, sr = soundfile.read(speech_path)
# speech = speech.T
# enh_speech = self.separate_speech(speech[None, ...], fs=sr)
# if len(enh_speech) == 1:
# return enh_speech[0]
# return enh_speech
class Speech_Enh_SS_SC:
"""Speech Enhancement or Separation in single-channel
Example usage:
enh_model = Speech_Enh_SS("cuda")
enh_wav = enh_model.inference("./test_chime4_audio_M05_440C0213_PED_REAL.wav")
"""
def __init__(self, device="cuda", model_name="espnet/Wangyou_Zhang_chime4_enh_train_enh_conv_tasnet_raw"):
self.model_name = model_name
self.device = device
print("Initializing ESPnet Enh to %s" % device)
self._initialize_model()
def _initialize_model(self):
from espnet_model_zoo.downloader import ModelDownloader
from espnet2.bin.enh_inference import SeparateSpeech
d = ModelDownloader()
cfg = d.download_and_unpack(self.model_name)
self.separate_speech = SeparateSpeech(
train_config=cfg["train_config"],
model_file=cfg["model_file"],
# for segment-wise process on long speech
segment_size=2.4,
hop_size=0.8,
normalize_segment_scale=False,
show_progressbar=True,
ref_channel=None,
normalize_output_wav=True,
device=self.device,
)
def inference(self, speech_path, ref_channel=0):
speech, sr = soundfile.read(speech_path)
speech = speech[:, ref_channel]
# speech = torch.from_numpy(speech)
# assert speech.dim() == 1
enh_speech = self.separate_speech(speech[None, ...], fs=sr)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
# if len(enh_speech) == 1:
soundfile.write(audio_filename, enh_speech[0].squeeze(), samplerate=sr)
# return enh_speech[0]
# return enh_speech
# else:
# print("############")
# audio_filename_1 = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
# soundfile.write(audio_filename_1, enh_speech[0].squeeze(), samplerate=sr)
# audio_filename_2 = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
# soundfile.write(audio_filename_2, enh_speech[1].squeeze(), samplerate=sr)
# audio_filename = merge_audio(audio_filename_1, audio_filename_2)
return audio_filename
class Speech_SS:
def __init__(self, device="cuda", model_name="lichenda/wsj0_2mix_skim_noncausal"):
self.model_name = model_name
self.device = device
print("Initializing ESPnet SS to %s" % device)
self._initialize_model()
def _initialize_model(self):
from espnet_model_zoo.downloader import ModelDownloader
from espnet2.bin.enh_inference import SeparateSpeech
d = ModelDownloader()
cfg = d.download_and_unpack(self.model_name)
self.separate_speech = SeparateSpeech(
train_config=cfg["train_config"],
model_file=cfg["model_file"],
# for segment-wise process on long speech
segment_size=2.4,
hop_size=0.8,
normalize_segment_scale=False,
show_progressbar=True,
ref_channel=None,
normalize_output_wav=True,
device=self.device,
)
def inference(self, speech_path):
speech, sr = soundfile.read(speech_path)
enh_speech = self.separate_speech(speech[None, ...], fs=sr)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
if len(enh_speech) == 1:
soundfile.write(audio_filename, enh_speech[0], samplerate=sr)
else:
# print("############")
audio_filename_1 = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename_1, enh_speech[0].squeeze(), samplerate=sr)
audio_filename_2 = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
soundfile.write(audio_filename_2, enh_speech[1].squeeze(), samplerate=sr)
audio_filename = merge_audio(audio_filename_1, audio_filename_2)
return audio_filename
class ConversationBot:
def __init__(self):
print("Initializing AudioGPT")
self.llm = OpenAI(temperature=0)
self.t2i = T2I(device="cuda:1")
self.i2t = ImageCaptioning(device="cuda:0")
self.t2a = T2A(device="cuda:0")
self.tts = TTS(device="cpu")
self.t2s = T2S(device="cpu")
self.i2a = I2A(device="cuda:0")
self.a2t = A2T(device="cpu")
self.asr = ASR(device="cuda:0")
self.SE_SS_SC = Speech_Enh_SS_SC(device="cuda:0")
# self.SE_SS_MC = Speech_Enh_SS_MC(device="cuda:0")
self.SS = Speech_SS(device="cuda:0")
self.inpaint = Inpaint(device="cuda:0")
self.tts_ood = TTS_OOD(device="cpu")
self.geneface = GeneFace(device="cuda:0")
self.detection = SoundDetection(device="cpu")
self.binaural = Binaural(device="cuda:0")
self.extraction = SoundExtraction(device="cuda:0")
self.TSD = TargetSoundDetection(device="cuda:0")
self.memory = ConversationBufferMemory(memory_key="chat_history", output_key='output')
def init_tools(self, interaction_type):
if interaction_type == 'text':
self.tools = [
Tool(name="Generate Image From User Input Text", func=self.t2i.inference,
description="useful for when you want to generate an image from a user input text and it saved it to a file. like: generate an image of an object or something, or generate an image that includes some objects. "
"The input to this tool should be a string, representing the text used to generate image. "),
Tool(name="Get Photo Description", func=self.i2t.inference,
description="useful for when you want to know what is inside the photo. receives image_path as input. "
"The input to this tool should be a string, representing the image_path. "),
Tool(name="Generate Audio From User Input Text", func=self.t2a.inference,
description="useful for when you want to generate an audio from a user input text and it saved it to a file."
"The input to this tool should be a string, representing the text used to generate audio."),
Tool(
name="Style Transfer", func= self.tts_ood.inference,
description="useful for when you want to generate speech samples with styles (e.g., timbre, emotion, and prosody) derived from a reference custom voice."
"Like: Generate a speech with style transferred from this voice. The text is xxx., or speak using the voice of this audio. The text is xxx."
"The input to this tool should be a comma seperated string of two, representing reference audio path and input text."),
Tool(name="Generate Singing Voice From User Input Text, Note and Duration Sequence", func= self.t2s.inference,
description="useful for when you want to generate a piece of singing voice (Optional: from User Input Text, Note and Duration Sequence) and save it to a file."
"If Like: Generate a piece of singing voice, the input to this tool should be \"\" since there is no User Input Text, Note and Duration Sequence ."
"If Like: Generate a piece of singing voice. Text: xxx, Note: xxx, Duration: xxx. "
"Or Like: Generate a piece of singing voice. Text is xxx, note is xxx, duration is xxx."
"The input to this tool should be a comma seperated string of three, representing text, note and duration sequence since User Input Text, Note and Duration Sequence are all provided."),
Tool(name="Synthesize Speech Given the User Input Text", func=self.tts.inference,
description="useful for when you want to convert a user input text into speech audio it saved it to a file."
"The input to this tool should be a string, representing the text used to be converted to speech."),
# Tool(name="Speech Enhancement Or Separation In Single-Channel", func=self.SE_SS_SC.inference,
# description="useful for when you want to enhance the quality of the speech signal by reducing background noise (single-channel), "
# "or separate each speech from the speech mixture (single-channel), receives audio_path as input."
# "The input to this tool should be a string, representing the audio_path."),
Tool(name="Speech Enhancement In Single-Channel", func=self.SE_SS_SC.inference,
description="useful for when you want to enhance the quality of the speech signal by reducing background noise (single-channel), receives audio_path as input."
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Speech Separation In Single-Channel", func=self.SS.inference,
description="useful for when you want to separate each speech from the speech mixture, receives audio_path as input."
"The input to this tool should be a string, representing the audio_path."),
# Tool(name="Speech Enhancement In Multi-Channel", func=self.SE_SS_MC.inference,
# description="useful for when you want to enhance the quality of the speech signal by reducing background noise (multi-channel), receives audio_path as input."
# "The input to this tool should be a string, representing the audio_path."),
Tool(name="Generate Audio From The Image", func=self.i2a.inference,
description="useful for when you want to generate an audio based on an image."
"The input to this tool should be a string, representing the image_path. "),
Tool(name="Generate Text From The Audio", func=self.a2t.inference,
description="useful for when you want to describe an audio in text, receives audio_path as input."
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Audio Inpainting", func=self.inpaint.show_mel_fn,
description="useful for when you want to inpaint a mel spectrum of an audio and predict this audio, this tool will generate a mel spectrum and you can inpaint it, receives audio_path as input, "
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Transcribe Speech", func=self.asr.inference,
description="useful for when you want to know the text corresponding to a human speech, receives audio_path as input."
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Generate a talking human portrait video given a input Audio", func=self.geneface.inference,
description="useful for when you want to generate a talking human portrait video given a input audio."
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Detect The Sound Event From The Audio", func=self.detection.inference,
description="useful for when you want to know what event in the audio and the sound event start or end time, this tool will generate an image of all predict events, receives audio_path as input. "
"The input to this tool should be a string, representing the audio_path. "),
Tool(name="Sythesize Binaural Audio From A Mono Audio Input", func=self.binaural.inference,
description="useful for when you want to transfer your mono audio into binaural audio, receives audio_path as input. "
"The input to this tool should be a string, representing the audio_path. "),
Tool(name="Extract Sound Event From Mixture Audio Based On Language Description", func=self.extraction.inference,
description="useful for when you extract target sound from a mixture audio, you can describe the target sound by text, receives audio_path and text as input. "
"The input to this tool should be a comma seperated string of two, representing mixture audio path and input text."),
Tool(name="Target Sound Detection", func=self.TSD.inference,
description="useful for when you want to know when the target sound event in the audio happens. You can use language descriptions to instruct the model. receives text description and audio_path as input. "
"The input to this tool should be a comma seperated string of two, representing audio path and the text description. ")]
self.agent = initialize_agent(
self.tools,
self.llm,
agent="conversational-react-description",
verbose=True,
memory=self.memory,
return_intermediate_steps=True,
agent_kwargs={'prefix': AUDIO_CHATGPT_PREFIX, 'format_instructions': AUDIO_CHATGPT_FORMAT_INSTRUCTIONS, 'suffix': AUDIO_CHATGPT_SUFFIX}, )
return gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
else:
self.tools = [
Tool(name="Generate Audio From User Input Text", func=self.t2a.inference,
description="useful for when you want to generate an audio from a user input text and it saved it to a file."
"The input to this tool should be a string, representing the text used to generate audio."),
Tool(
name="Style Transfer", func= self.tts_ood.inference,
description="useful for when you want to generate speech samples with styles (e.g., timbre, emotion, and prosody) derived from a reference custom voice."
"Like: Generate a speech with style transferred from this voice. The text is xxx., or speak using the voice of this audio. The text is xxx."
"The input to this tool should be a comma seperated string of two, representing reference audio path and input text."),
Tool(name="Generate Singing Voice From User Input Text, Note and Duration Sequence", func= self.t2s.inference,
description="useful for when you want to generate a piece of singing voice (Optional: from User Input Text, Note and Duration Sequence) and save it to a file."
"If Like: Generate a piece of singing voice, the input to this tool should be \"\" since there is no User Input Text, Note and Duration Sequence ."
"If Like: Generate a piece of singing voice. Text: xxx, Note: xxx, Duration: xxx. "
"Or Like: Generate a piece of singing voice. Text is xxx, note is xxx, duration is xxx."
"The input to this tool should be a comma seperated string of three, representing text, note and duration sequence since User Input Text, Note and Duration Sequence are all provided."),
Tool(name="Synthesize Speech Given the User Input Text", func=self.tts.inference,
description="useful for when you want to convert a user input text into speech audio it saved it to a file."
"The input to this tool should be a string, representing the text used to be converted to speech."),
Tool(name="Generate Text From The Audio", func=self.a2t.inference,
description="useful for when you want to describe an audio in text, receives audio_path as input."
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Generate a talking human portrait video given a input Audio", func=self.geneface.inference,
description="useful for when you want to generate a talking human portrait video given a input audio."
"The input to this tool should be a string, representing the audio_path."),
Tool(name="Generate Binaural Audio From A Mono Audio Input", func=self.binaural.inference,
description="useful for when you want to transfer your mono audio into binaural audio, receives audio_path as input. "
"The input to this tool should be a string, representing the audio_path. "),
Tool(name="Extract Sound Event From Mixture Audio Based On Language Description", func=self.extraction.inference,
description="useful for when you extract target sound from a mixture audio, you can describe the target sound by text, receives audio_path and text as input. "
"The input to this tool should be a comma seperated string of two, representing mixture audio path and input text."),
Tool(name="Target Sound Detection", func=self.TSD.inference,
description="useful for when you want to know when the target sound event in the audio happens. You can use language descriptions to instruct the model. receives text description and audio_path as input. "
"The input to this tool should be a comma seperated string of two, representing audio path and the text description. ")]
self.agent = initialize_agent(
self.tools,
self.llm,
agent="conversational-react-description",
verbose=True,
memory=self.memory,
return_intermediate_steps=True,
agent_kwargs={'prefix': AUDIO_CHATGPT_PREFIX, 'format_instructions': AUDIO_CHATGPT_FORMAT_INSTRUCTIONS, 'suffix': AUDIO_CHATGPT_SUFFIX}, )
return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
def run_text(self, text, state):
print("===============Running run_text =============")
print("Inputs:", text, state)
print("======>Previous memory:\n %s" % self.agent.memory)
self.agent.memory.buffer = cut_dialogue_history(self.agent.memory.buffer, keep_last_n_words=500)
res = self.agent({"input": text})
if res['intermediate_steps'] == []:
print("======>Current memory:\n %s" % self.agent.memory)
response = res['output']
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(visible=False), gr.Video.update(visible=False), gr.Image.update(visible=False), gr.Button.update(visible=False)
else:
tool = res['intermediate_steps'][0][0].tool
if tool == "Generate Image From User Input Text" or tool == "Generate Text From The Audio" or tool == "Target Sound Detection":
print("======>Current memory:\n %s" % self.agent.memory)
response = re.sub('(image/\S*png)', lambda m: f'})*{m.group(0)}*', res['output'])
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(visible=False), gr.Video.update(visible=False), gr.Image.update(visible=False), gr.Button.update(visible=False)
elif tool == "Transcribe Speech":
response = res['output']
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(visible=False), gr.Video.update(visible=False), gr.Image.update(visible=False), gr.Button.update(visible=False)
elif tool == "Detect The Sound Event From The Audio":
image_filename = res['intermediate_steps'][0][1]
response = res['output'] + f"*{image_filename}*"
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(visible=False), gr.Video.update(visible=False), gr.Image.update(visible=False), gr.Button.update(visible=False)
elif tool == "Audio Inpainting":
audio_filename = res['intermediate_steps'][0][0].tool_input
image_filename = res['intermediate_steps'][0][1]
print("======>Current memory:\n %s" % self.agent.memory)
response = res['output']
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(value=audio_filename,visible=True), gr.Video.update(visible=False), gr.Image.update(value=image_filename,visible=True), gr.Button.update(visible=True)
elif tool == "Generate a talking human portrait video given a input Audio":
video_filename = res['intermediate_steps'][0][1]
print("======>Current memory:\n %s" % self.agent.memory)
response = res['output']
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(visible=False), gr.Video.update(value=video_filename,visible=True), gr.Image.update(visible=False), gr.Button.update(visible=False)
print("======>Current memory:\n %s" % self.agent.memory)
response = re.sub('(image/\S*png)', lambda m: f'})*{m.group(0)}*', res['output'])
audio_filename = res['intermediate_steps'][0][1]
state = state + [(text, response)]
print("Outputs:", state)
return state, state, gr.Audio.update(value=audio_filename,visible=True), gr.Video.update(visible=False), gr.Image.update(visible=False), gr.Button.update(visible=False)
def run_image_or_audio(self, file, state, txt):
file_type = file.name[-3:]
if file_type == "wav":
print("===============Running run_audio =============")
print("Inputs:", file, state)
print("======>Previous memory:\n %s" % self.agent.memory)
audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
# audio_load = whisper.load_audio(file.name)
audio_load, sr = soundfile.read(file.name)
soundfile.write(audio_filename, audio_load, samplerate = sr)
description = self.a2t.inference(audio_filename)
Human_prompt = "\nHuman: provide an audio named {}. The description is: {}. This information helps you to understand this audio, but you should use tools to finish following tasks, " \
"rather than directly imagine from my description. If you understand, say \"Received\". \n".format(audio_filename, description)
AI_prompt = "Received. "
self.agent.memory.buffer = self.agent.memory.buffer + Human_prompt + 'AI: ' + AI_prompt
print("======>Current memory:\n %s" % self.agent.memory)
#state = state + [(f"<audio src=audio_filename controls=controls></audio>*{audio_filename}*", AI_prompt)]
state = state + [(f"*{audio_filename}*", AI_prompt)]
print("Outputs:", state)
return state, state, gr.Audio.update(value=audio_filename,visible=True), gr.Video.update(visible=False)
else:
print("===============Running run_image =============")
print("Inputs:", file, state)
print("======>Previous memory:\n %s" % self.agent.memory)
image_filename = os.path.join('image', str(uuid.uuid4())[0:8] + ".png")
print("======>Auto Resize Image...")
img = Image.open(file.name)
width, height = img.size
ratio = min(512 / width, 512 / height)
width_new, height_new = (round(width * ratio), round(height * ratio))
img = img.resize((width_new, height_new))
img = img.convert('RGB')
img.save(image_filename, "PNG")
print(f"Resize image form {width}x{height} to {width_new}x{height_new}")
description = self.i2t.inference(image_filename)
Human_prompt = "\nHuman: provide a figure named {}. The description is: {}. This information helps you to understand this image, but you should use tools to finish following tasks, " \
"rather than directly imagine from my description. If you understand, say \"Received\". \n".format(image_filename, description)
AI_prompt = "Received. "
self.agent.memory.buffer = self.agent.memory.buffer + Human_prompt + 'AI: ' + AI_prompt
print("======>Current memory:\n %s" % self.agent.memory)
state = state + [(f"*{image_filename}*", AI_prompt)]
print("Outputs:", state)
return state, state, gr.Audio.update(visible=False), gr.Video.update(visible=False)
def speech(self, speech_input, state):
input_audio_filename = os.path.join('audio', str(uuid.uuid4())[0:8] + ".wav")
text = self.asr.translate_english(speech_input)
print("Inputs:", text, state)
print("======>Previous memory:\n %s" % self.agent.memory)
self.agent.memory.buffer = cut_dialogue_history(self.agent.memory.buffer, keep_last_n_words=500)
res = self.agent({"input": text})
if res['intermediate_steps'] == []:
print("======>Current memory:\n %s" % self.agent.memory)
response = res['output']
output_audio_filename = self.tts.inference(response)
state = state + [(text, response)]
print("Outputs:", state)
return gr.Audio.update(value=None), gr.Audio.update(value=output_audio_filename,visible=True), state, gr.Video.update(visible=False)
else:
tool = res['intermediate_steps'][0][0].tool
if tool == "Generate Image From User Input Text" or tool == "Generate Text From The Audio" or tool == "Target Sound Detection":
print("======>Current memory:\n %s" % self.agent.memory)
response = re.sub('(image/\S*png)', lambda m: f'})*{m.group(0)}*', res['output'])
output_audio_filename = self.tts.inference(res['output'])
state = state + [(text, response)]
print("Outputs:", state)
return gr.Audio.update(value=None), gr.Audio.update(value=output_audio_filename,visible=True), state, gr.Video.update(visible=False)
elif tool == "Transcribe Speech":
print("======>Current memory:\n %s" % self.agent.memory)
output_audio_filename = self.tts.inference(res['output'])
response = res['output']
state = state + [(text, response)]
print("Outputs:", state)
return gr.Audio.update(value=None), gr.Audio.update(value=output_audio_filename,visible=True), state, gr.Video.update(visible=False)
elif tool == "Detect The Sound Event From The Audio":
print("======>Current memory:\n %s" % self.agent.memory)
image_filename = res['intermediate_steps'][0][1]
output_audio_filename = self.tts.inference(res['output'])
response = res['output'] + f"*{image_filename}*"
state = state + [(text, response)]
print("Outputs:", state)
return gr.Audio.update(value=None), gr.Audio.update(value=output_audio_filename,visible=True), state, gr.Video.update(visible=False)
elif tool == "Generate a talking human portrait video given a input Audio":
video_filename = res['intermediate_steps'][0][1]
print("======>Current memory:\n %s" % self.agent.memory)
response = res['output']
output_audio_filename = self.tts.inference(res['output'])
state = state + [(text, response)]
print("Outputs:", state)
return gr.Audio.update(value=None), gr.Audio.update(value=output_audio_filename,visible=True), state, gr.Video.update(value=video_filename,visible=True)
print("======>Current memory:\n %s" % self.agent.memory)
response = re.sub('(image/\S*png)', lambda m: f'})*{m.group(0)}*', res['output'])
audio_filename = res['intermediate_steps'][0][1]
Res = "The audio file has been generated and the audio is "
output_audio_filename = merge_audio(self.tts.inference(Res), audio_filename)
print(output_audio_filename)
state = state + [(text, response)]
response = res['output']
print("Outputs:", state)
return gr.Audio.update(value=None), gr.Audio.update(value=output_audio_filename,visible=True), state, gr.Video.update(visible=False)
def inpainting(self, state, audio_filename, image_filename):
print("===============Running inpainting =============")
print("Inputs:", state)
print("======>Previous memory:\n %s" % self.agent.memory)
new_image_filename, new_audio_filename = self.inpaint.inference(audio_filename, image_filename)
AI_prompt = "Here are the predict audio and the mel spectrum." + f"*{new_audio_filename}*" + f"*{new_image_filename}*"
output_audio_filename = self.tts.inference(AI_prompt)
self.agent.memory.buffer = self.agent.memory.buffer + 'AI: ' + AI_prompt
print("======>Current memory:\n %s" % self.agent.memory)
state = state + [(f"Audio Inpainting", AI_prompt)]
print("Outputs:", state)
return state, state, gr.Image.update(visible=False), gr.Audio.update(value=new_audio_filename, visible=True), gr.Video.update(visible=False), gr.Button.update(visible=False)
def clear_audio(self):
return gr.Audio.update(value=None, visible=False)
def clear_input_audio(self):
return gr.Audio.update(value=None)
def clear_image(self):
return gr.Image.update(value=None, visible=False)
def clear_video(self):
return gr.Video.update(value=None, visible=False)
def clear_button(self):
return gr.Button.update(visible=False)
if __name__ == '__main__':
bot = ConversationBot()
with gr.Blocks(css="#chatbot .overflow-y-auto{height:500px}") as demo:
with gr.Row():
gr.Markdown("## AudioGPT")
chatbot = gr.Chatbot(elem_id="chatbot", label="AudioGPT", visible=False)
state = gr.State([])
with gr.Row() as select_raws:
with gr.Column(scale=0.7):
interaction_type = gr.Radio(choices=['text', 'speech'], value='text', label='Interaction Type')
with gr.Column(scale=0.3, min_width=0):
select = gr.Button("Select")
with gr.Row(visible=False) as text_input_raws:
with gr.Column(scale=0.7):
txt = gr.Textbox(show_label=False, placeholder="Enter text and press enter, or upload an image").style(container=False)
with gr.Column(scale=0.1, min_width=0):
run = gr.Button("🏃♂️Run")
with gr.Column(scale=0.1, min_width=0):
clear_txt = gr.Button("🔄Clear️")
with gr.Column(scale=0.1, min_width=0):
btn = gr.UploadButton("🖼️Upload", file_types=["image","audio"])
with gr.Row():
outaudio = gr.Audio(visible=False)
with gr.Row():
with gr.Column(scale=0.3, min_width=0):
outvideo = gr.Video(visible=False)
with gr.Row():
show_mel = gr.Image(type="filepath",tool='sketch',visible=False)
with gr.Row():
run_button = gr.Button("Predict Masked Place",visible=False)
with gr.Row(visible=False) as speech_input_raws:
with gr.Column(scale=0.7):
speech_input = gr.Audio(source="microphone", type="filepath", label="Input")
with gr.Column(scale=0.15, min_width=0):
submit_btn = gr.Button("🏃♂️Submit")
with gr.Column(scale=0.15, min_width=0):
clear_speech = gr.Button("🔄Clear️")
with gr.Row():
speech_output = gr.Audio(label="Output",visible=False)
select.click(bot.init_tools, [interaction_type], [chatbot, select_raws, text_input_raws, speech_input_raws])
txt.submit(bot.run_text, [txt, state], [chatbot, state, outaudio, outvideo, show_mel, run_button])
txt.submit(lambda: "", None, txt)
run.click(bot.run_text, [txt, state], [chatbot, state, outaudio, outvideo, show_mel, run_button])
run.click(lambda: "", None, txt)
btn.upload(bot.run_image_or_audio, [btn, state, txt], [chatbot, state, outaudio, outvideo])
run_button.click(bot.inpainting, [state, outaudio, show_mel], [chatbot, state, show_mel, outaudio, outvideo, run_button])
clear_txt.click(bot.memory.clear)
clear_txt.click(lambda: [], None, chatbot)
clear_txt.click(lambda: [], None, state)
clear_txt.click(lambda:None, None, txt)
clear_txt.click(bot.clear_button, None, run_button)
clear_txt.click(bot.clear_image, None, show_mel)
clear_txt.click(bot.clear_audio, None, outaudio)
clear_txt.click(bot.clear_video, None, outvideo)
submit_btn.click(bot.speech, [speech_input, state], [speech_input, speech_output, state, outvideo])
clear_speech.click(bot.clear_input_audio, None, speech_input)
clear_speech.click(bot.clear_audio, None, speech_output)
clear_speech.click(lambda: [], None, state)
clear_speech.click(bot.clear_video, None, outvideo)
demo.launch(server_name="0.0.0.0", server_port=7860, share=True) | [
"\nHuman: provide a figure named PLACEHOLDER. The description is: PLACEHOLDER. This information helps you to understand this image, but you should use tools to finish following tasks, rather than directly imagine from my description. If you understand, say \"Received\". \n",
"Received. ",
"Here are the predict audio and the mel spectrum.*PLACEHOLDER**PLACEHOLDER*",
"\nHuman: provide an audio named PLACEHOLDER. The description is: PLACEHOLDER. This information helps you to understand this audio, but you should use tools to finish following tasks, rather than directly imagine from my description. If you understand, say \"Received\". \n"
] |
2024-01-10 | ckak912/CodeBuddy_LLM | front_end~server~content.py | import atexit
import random
from datetime import datetime
import gzip
from helper import *
from imgcompare import *
import json
import math
import re
import sqlite3
import traceback
from yaml import load
#import zipfile
# IMPORTANT: When creating/modifying queries that include any user input,
# please follow the recommendations on this page:
# https://realpython.com/prevent-python-sql-injection/
BLANK_IMAGE = "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"
class Content:
def __init__(self, settings_dict):
self.__settings_dict = settings_dict
self.conn = open_db("CodeBuddy.db")
self.conn.row_factory = sqlite3.Row
self.execute("PRAGMA foreign_keys=OFF")
self.execute("PRAGMA cache_size=1000000")
self.execute("PRAGMA mmap_size=1000000")
self.execute("PRAGMA temp_store=MEMORY")
self.execute("PRAGMA journal_mode=OFF")
atexit.register(self.close)
def close(self):
self.conn.close()
def execute(self, sql, params=()):
cursor = self.conn.cursor()
cursor.execute(sql, params)
lastrowid = cursor.lastrowid
cursor.close()
return lastrowid
def execute_multiple(self, sql_statements, params_list, lastrowid_index=-1):
if len(sql_statements) != len(params_list):
raise Exception(f"The size of sql_statements ({len(sql_statements)}) must be identical to the size of param_tuples ({len(params_list)}).")
cursor = self.conn.cursor()
cursor.execute("BEGIN")
lastrowid = -1
for i, sql in enumerate(sql_statements):
cursor.execute(sql, params_list[i])
if i == lastrowid_index:
lastrowid = cursor.lastrowid
self.conn.commit()
cursor.close()
return lastrowid
def fetchone(self, sql, params=()):
cursor = self.conn.cursor()
cursor.execute(sql, params)
result = cursor.fetchone()
cursor.close()
return result
def fetchall(self, sql, params=()):
cursor = self.conn.cursor()
cursor.execute(sql, params)
result = cursor.fetchall()
cursor.close()
return result
# This function creates tables as they were in version 5. Subsequent changes
# to the database are implemented as migration scripts.
def create_database_tables(self):
print("Creating the initial database schema...")
self.execute('''CREATE TABLE IF NOT EXISTS metadata (version integer NOT NULL);''')
self.execute('''INSERT INTO metadata (version) VALUES (5);''')
self.execute('''CREATE TABLE IF NOT EXISTS users (
user_id text PRIMARY KEY,
name text,
given_name text,
family_name text,
picture text,
locale text,
ace_theme text NOT NULL DEFAULT "tomorrow");''')
self.execute('''CREATE TABLE IF NOT EXISTS permissions (
user_id text NOT NULL,
role text NOT NULL,
course_id integer,
FOREIGN KEY (user_id) REFERENCES users (user_id) ON DELETE CASCADE ON UPDATE CASCADE
);''')
self.execute('''CREATE TABLE IF NOT EXISTS course_registration (
user_id text NOT NULL,
course_id integer NOT NULL,
FOREIGN KEY (user_id) REFERENCES users (user_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (course_id) REFERENCES courses (course_id) ON DELETE CASCADE ON UPDATE CASCADE
);''')
self.execute('''CREATE TABLE IF NOT EXISTS courses (
course_id integer PRIMARY KEY AUTOINCREMENT,
title text NOT NULL UNIQUE,
introduction text,
visible integer NOT NULL,
passcode text,
date_created timestamp NOT NULL,
date_updated timestamp NOT NULL
);''')
self.execute('''CREATE TABLE IF NOT EXISTS assignments (
course_id integer NOT NULL,
assignment_id integer PRIMARY KEY AUTOINCREMENT,
title text NOT NULL,
introduction text,
visible integer NOT NULL,
start_date timestamp,
due_date timestamp,
allow_late integer,
late_percent real,
view_answer_late integer,
has_timer int NOT NULL,
hour_timer int,
minute_timer int,
date_created timestamp NOT NULL,
date_updated timestamp NOT NULL,
FOREIGN KEY (course_id) REFERENCES courses (course_id) ON DELETE CASCADE ON UPDATE CASCADE
);''')
self.execute('''CREATE TABLE IF NOT EXISTS problems (
course_id integer NOT NULL,
assignment_id integer NOT NULL,
problem_id integer PRIMARY KEY AUTOINCREMENT,
title text NOT NULL,
visible integer NOT NULL,
answer_code text NOT NULL,
answer_description text,
hint text,
max_submissions integer NOT NULL,
credit text,
data_url text,
data_file_name text,
data_contents text,
back_end text NOT NULL,
expected_text_output text NOT NULL,
expected_image_output text NOT NULL,
instructions text NOT NULL,
output_type text NOT NULL,
show_answer integer NOT NULL,
show_student_submissions integer NOT NULL,
show_expected integer NOT NULL,
show_test_code integer NOT NULL,
test_code text,
date_created timestamp NOT NULL,
date_updated timestamp NOT NULL,
FOREIGN KEY (course_id) REFERENCES courses (course_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (assignment_id) REFERENCES assignments (assignment_id) ON DELETE CASCADE ON UPDATE CASCADE
);''')
self.execute('''CREATE TABLE IF NOT EXISTS submissions (
course_id integer NOT NULL,
assignment_id integer NOT NULL,
problem_id integer NOT NULL,
user_id text NOT NULL,
submission_id integer NOT NULL,
code text NOT NULL,
text_output text NOT NULL,
image_output text NOT NULL,
passed integer NOT NULL,
date timestamp NOT NULL,
FOREIGN KEY (course_id) REFERENCES courses (course_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (assignment_id) REFERENCES assignments (assignment_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (problem_id) REFERENCES problems (problem_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE ON UPDATE CASCADE,
PRIMARY KEY (course_id, assignment_id, problem_id, user_id, submission_id)
);''')
self.execute('''CREATE TABLE IF NOT EXISTS scores (
course_id integer NOT NULL,
assignment_id integer NOT NULL,
problem_id integer NOT NULL,
user_id text NOT NULL,
score real NOT NULL,
FOREIGN KEY (course_id) REFERENCES courses (course_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (assignment_id) REFERENCES assignments (assignment_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (problem_id) REFERENCES problems (problem_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (user_id) REFERENCES users (user_id) ON DELETE CASCADE ON UPDATE CASCADE,
PRIMARY KEY (course_id, assignment_id, problem_id, user_id)
);''')
self.execute('''CREATE TABLE IF NOT EXISTS user_assignment_start (
user_id text NOT NULL,
course_id text NOT NULL,
assignment_id text NOT NULL,
start_time timestamp NOT NULL,
FOREIGN KEY (course_id) REFERENCES courses (course_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (assignment_id) REFERENCES assignments (assignment_id) ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (user_id) REFERENCES users (user_id) ON DELETE CASCADE ON UPDATE CASCADE
);''')
def get_database_version(self):
sql = "SELECT COUNT(*) AS count FROM sqlite_master"
# This tells us whether we have created the initial database scheme.
# If not, create it.
num_tables = self.fetchone(sql)["count"]
if num_tables == 0:
self.create_database_tables()
return 5
sql = '''SELECT MAX(version) AS version
FROM metadata'''
return self.fetchone(sql)["version"]
def update_database_version(self, version):
print(f"Updating database to version {version}")
sql = '''DELETE FROM metadata'''
self.execute(sql)
sql = '''INSERT INTO metadata (version)
VALUES (?)'''
self.execute(sql, (version,))
print(f"Done updating database to version {version}")
def find_when_content_updated(self):
sql = '''SELECT scope, when_updated
FROM when_content_updated'''
updated_dict = {}
try:
for row in self.fetchall(sql):
updated_dict[row["scope"]] = str(row["when_updated"])
except:
print(traceback.format_exc())
return updated_dict
def update_when_content_updated(self, scope):
sql = '''UPDATE when_content_updated
SET when_updated = datetime('now')
WHERE scope = ?'''
try:
self.execute(sql, (scope, ))
except:
print(traceback.format_exc())
def delete_content_updated(self, scope):
sql = '''DELETE FROM when_content_updated
WHERE scope = ?'''
try:
self.execute(sql, (scope, ))
except:
print(traceback.format_exc())
def set_user_assignment_start_time(self, course_id, assignment_id, user_id, start_time):
sql = '''INSERT INTO user_assignment_starts (course_id, assignment_id, user_id, start_time)
VALUES (?, ?, ?, ?)'''
self.execute(sql, (course_id, assignment_id, user_id, start_time,))
def get_user_assignment_start_time(self, course_id, assignment_id, user_id):
sql = '''SELECT start_time
FROM user_assignment_starts
WHERE course_id = ?
AND assignment_id = ?
AND user_id = ?'''
row = self.fetchone(sql, (course_id, assignment_id, user_id,))
if row:
return row["start_time"]
def is_taking_restricted_assignment(self, user_id, assignment_id):
sql = '''SELECT ((julianday(datetime('now')) - julianday(latest_start_time)) * 24 * 60) < minute_limit AS yes
FROM
(SELECT (hour_timer * 60 + minute_timer) AS minute_limit, MAX(start_time) AS latest_start_time
FROM user_assignment_starts uas
INNER JOIN assignments a
ON uas.course_id = a.course_id
AND uas.assignment_id = a.assignment_id
WHERE uas.user_id = ?
AND a.assignment_id != ?
AND a.has_timer = 1
)'''
row = self.fetchone(sql, (user_id, assignment_id, ))
if row:
return bool(row["yes"])
return False
def get_all_user_assignment_expired(self, course_id, assignment_id):
user_dict = {}
sql = '''SELECT user_id, start_time
FROM user_assignment_starts
WHERE course_id = ?
AND assignment_id = ?'''
for row in self.fetchall(sql, (course_id, assignment_id,)):
#TODO: It is not efficient to hit the database each time through this loop.
start_time = datetime.strftime(row["start_time"], "%a, %d %b %Y %H:%M:%S %Z")
timer_ended = self.has_user_assignment_start_timer_ended(course_id, assignment_id, start_time)
user_dict[row["user_id"]] = timer_ended
return user_dict
def has_user_assignment_start_timer_ended(self, course_id, assignment_id, start_time):
if not start_time:
return False
curr_time = datetime.utcnow()
start_time = datetime.strptime(start_time, "%a, %d %b %Y %H:%M:%S ")
sql = '''SELECT hour_timer, minute_timer
FROM assignments
WHERE course_id = ?
AND assignment_id = ?'''
row = self.fetchone(sql, (course_id, assignment_id,))
if row:
#TODO: This logic could be much simpler using datetime module.
elapsed_time = curr_time - start_time
seconds = elapsed_time.total_seconds()
e_hours = math.floor(seconds/3600)
e_minutes = math.floor((seconds/60) - (e_hours*60))
e_seconds = (seconds - (e_minutes*60) - (e_hours*3600))
if e_hours > int(row["hour_timer"]):
return True
elif e_hours == int(row["hour_timer"]) and e_minutes > int(row["minute_timer"]):
return True
elif e_hours == int(row["hour_timer"]) and e_minutes == int(row["minute_timer"]) and e_seconds > 0:
return True
return False
def reset_user_assignment_start_timer(self, course_id, assignment_id, user_id):
sql = '''DELETE FROM user_assignment_starts
WHERE course_id = ?
AND assignment_id = ?
AND user_id = ?'''
self.execute(sql, (course_id, assignment_id, user_id))
def user_exists(self, user_id):
sql = '''SELECT user_id
FROM users
WHERE user_id = ?'''
return self.fetchone(sql, (user_id,)) != None
def administrator_exists(self):
sql = '''SELECT COUNT(*) AS num_administrators
FROM permissions
WHERE role = "administrator"'''
return self.fetchone(sql)["num_administrators"]
def is_administrator(self, user_id):
return self.user_has_role(user_id, 0, "administrator")
def user_has_role(self, user_id, course_id, role):
sql = '''SELECT COUNT(*) AS has_role
FROM permissions
WHERE role = ?
AND user_id = ?
AND course_id = ?'''
return self.fetchone(sql, (role, user_id, course_id, ))["has_role"] > 0
def get_users_from_role(self, course_id, role):
sql = '''SELECT user_id
FROM permissions
WHERE role = ?
AND (course_id = ? OR course_id IS NULL)'''
rows = self.fetchall(sql, (role, course_id,))
return [row["user_id"] for row in rows]
def get_course_id_from_role(self, user_id):
sql = '''SELECT course_id
FROM permissions
WHERE user_id = ?'''
row = self.fetchone(sql, (user_id,))
if row:
return row["course_id"]
else:
return -1 # The user is a student.
def set_user_dict_defaults(self, user_dict):
if "name" not in user_dict:
user_dict["name"] = "[Unknown name]"
if "given_name" not in user_dict:
user_dict["given_name"] = "[Unknown given name]"
if "family_name" not in user_dict:
user_dict["family_name"] = "[Unknown family name]"
if "locale" not in user_dict:
user_dict["locale"] = ""
def add_user(self, user_id, user_dict):
self.set_user_dict_defaults(user_dict)
sql = '''INSERT INTO users (user_id, name, given_name, family_name, locale, ace_theme, email_address)
VALUES (?, ?, ?, ?, ?, ?, ?)'''
self.execute(sql, (user_id, user_dict["name"], user_dict["given_name"], user_dict["family_name"], user_dict["locale"], "tomorrow", user_dict["email_address"]))
self.update_when_content_updated("user")
def register_user_for_course(self, course_id, user_id):
sql = '''INSERT INTO course_registrations (course_id, user_id)
VALUES (?, ?)'''
self.execute(sql, (course_id, user_id,))
self.update_when_content_updated("user")
self.update_when_content_updated(str(course_id))
def unregister_user_from_course(self, course_id, user_id):
self.execute('''DELETE FROM course_registrations
WHERE course_id = ?
AND user_id = ?''', (course_id, user_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?
AND user_id = ?''', (course_id, user_id, ))
self.execute('''DELETE FROM submissions
WHERE course_id = ?
AND user_id = ?''', (course_id, user_id, ))
self.execute('''DELETE FROM user_assignment_starts
WHERE course_id = ?
AND user_id = ?''', (course_id, user_id, ))
self.update_when_content_updated("user")
self.update_when_content_updated(str(course_id))
def is_user_registered(self, course_id, user_id):
sql = '''SELECT 1
FROM course_registrations
WHERE course_id = ?
AND user_id = ?'''
if self.fetchone(sql, (course_id, user_id,)):
return True
return False
def get_user_info(self, user_id):
null_user_info = {"user_id": None, "name": None, "given_name": None, "family_name": None, "locale": None, "email_address": None, "ace_theme": None, "use_auto_complete": True, "use_studio_mode": True, "enable_vim": False}
sql = '''SELECT *
FROM users
WHERE user_id = ?'''
user = self.fetchone(sql, (user_id,))
if not user:
return null_user_info
return {"user_id": user_id, "name": user["name"], "given_name": user["given_name"], "family_name": user["family_name"], "locale": user["locale"], "email_address": user["email_address"], "ace_theme": user["ace_theme"], "use_auto_complete": user["use_auto_complete"], "use_studio_mode": user["use_studio_mode"], "enable_vim": user["enable_vim"]}
def add_permissions(self, course_id, user_id, role):
sql = '''SELECT role
FROM permissions
WHERE user_id = ?
AND (course_id = ? OR course_id IS NULL)'''
# Admins are not assigned to a particular course.
if not course_id:
course_id = 0
role_exists = self.fetchone(sql, (user_id, int(course_id),)) != None
if role_exists:
sql = '''UPDATE permissions
SET role = ?, course_id = ?
WHERE user_id = ?'''
self.execute(sql, (role, course_id, user_id,))
else:
sql = '''INSERT INTO permissions (user_id, role, course_id)
VALUES (?, ?, ?)'''
self.execute(sql, (user_id, role, course_id,))
if course_id != 0:
self.update_when_content_updated(str(course_id))
self.update_when_content_updated("user")
def remove_permissions(self, course_id, user_id, role):
sql = '''DELETE FROM permissions
WHERE user_id = ?
AND role = ?
AND (course_id = ? OR course_id IS NULL)'''
# Admins are not assigned to a particular course.
if not course_id:
course_id = "0"
self.execute(sql, (user_id, role, int(course_id),))
if course_id != "0":
self.update_when_content_updated(course_id)
self.update_when_content_updated("user")
def add_admin_permissions(self, user_id):
self.add_permissions(None, user_id, "administrator")
self.update_when_content_updated("user")
def get_user_count(self):
sql = '''SELECT COUNT(*) AS count
FROM users'''
return self.fetchone(sql)["count"]
def get_all_courses(self):
courses = []
sql = '''SELECT course_id, title, visible, introduction, passcode
FROM courses
WHERE visible = 1
ORDER BY title'''
for course in self.fetchall(sql):
if course["visible"] or show_hidden:
course_basics = {"id": course["course_id"], "title": course["title"], "visible": course["visible"], "introduction": course["introduction"], "passcode": course["passcode"], "exists": True}
courses.append([course["course_id"], course_basics])
return courses
def get_registered_courses(self, user_id):
registered_courses = []
sql = '''SELECT r.course_id, c.title, c.introduction, 'student' AS role
FROM course_registrations r
INNER JOIN courses c
ON r.course_id = c.course_id
WHERE r.user_id = ?
AND c.visible = 1
UNION
SELECT c.course_id, c.title, c.introduction, p.role AS role
FROM permissions p
INNER JOIN courses c
ON p.course_id = 0 OR p.course_id = c.course_id
WHERE p.user_id = ?
ORDER BY c.title'''
unique_course_ids = set()
for course in self.fetchall(sql, (user_id, user_id, )):
course_id = course["course_id"]
if course_id not in unique_course_ids:
unique_course_ids.add(course_id)
course_basics = {"id": course_id, "title": course["title"], "introduction": course["introduction"], "role": course["role"]}
registered_courses.append([course["course_id"], course_basics])
return registered_courses
def retrieve_llm_feedback(self, exercise_id, course_id, assignment_id):
# SQL query to retrieve feedback information from LLM_stuff table
sql = '''SELECT LF.exercise_feedback, LF.LLM_assignment_id, LF.LLM_course_id, LF.LLM_exercise_id
FROM LLM_stuff as LF
JOIN exercises as E on LF.LLM_exercise_id = E.exercise_id
WHERE LF.LLM_exercise_id = ? AND E.course_id = ? AND E.assignment_id = ?
'''
# Fetch feedback data from the database
result = self.fetchall(sql, (exercise_id, course_id, assignment_id))
if result and result[0]:
return result[0]
else:
return None
# return result[0]
# This function contains the SQL logic for storing steps after you have retrieved them from OpenAI
def store_llm_feedback(self, exercise_id, course_id, assignment_id, exercise_feedback_json_str):
print(f"feedback beings stored: {exercise_feedback_json_str}")
sql = '''INSERT OR REPLACE INTO LLM_STUFF (LLM_exercise_id, LLM_course_id, LLM_assignment_id, exercise_feedback)
VALUES (?, ?, ?, ?)
'''
result = self.execute(sql, (exercise_id, course_id, assignment_id, exercise_feedback_json_str))
if result:
return result
return None
def store_hint_code(self, exercise_id, course_id, assignment_id, hint_code):
sql = '''INSERT OR REPLACE INTO LLM_STUFF (LLM_exercise_id, LLM_course_id, LLM_assignment_id, hint_code)
VALUES (?, ?, ?, ?)
'''
result = self.execute(sql, (exercise_id, course_id, assignment_id, hint_code))
if result:
return result
return None
# This function contains the SQL logic for storing pseudo code generated from the model
def store_pseudo_code(self, exercise_id, course_id, assignment_id, pseudo_code):
try:
sql = '''INSERT OR REPLACE INTO LLM_STUFF (LLM_exercise_id, LLM_course_id, LLM_assignment_id, pseudo_code)
VALUES (?, ?, ?, ?)
'''
result = self.execute(sql, (exercise_id, course_id, assignment_id, pseudo_code))
if result:
return result
except Exception as inst:
print("Error in store_pseudo_code:", inst)
return None
def store_user_code(self, exercise_id, course_id, assignment_id, user_code):
print("hello this is the store_user_code")
print(f"this is the user code being stored: {user_code}")
try:
sql = '''INSERT OR REPLACE INTO LLM_user_code (exercise_id, course_id, assignment_id, code, date_created)
VALUES (?, ?, ?, ?, ?)
'''
result = self.execute(sql, (exercise_id, course_id, assignment_id, user_code, datetime.utcnow()) )
if result:
return result
except Exception as inst:
print("Error in store_user_code:", inst)
return None
def retrieve_pseudo_code(self, exercise_id, course_id, assignment_id):
try:
# SQL query to retrieve pseudo code from LLM_stuff table
sql = '''SELECT LF.pseudo_code, LF.LLM_assignment_id, LF.LLM_course_id, LF.LLM_exercise_id
FROM LLM_stuff as LF
JOIN exercises as E on LF.LLM_exercise_id = E.exercise_id
WHERE LF.LLM_exercise_id = ? AND E.course_id = ? AND E.assignment_id = ?
'''
# Fetch feedback data from the database
result = self.fetchall(sql, (exercise_id, course_id, assignment_id))
if result and result[0]:
return result[0]
else:
return None
except Exception as inst:
print("Error in retrieve_pseudo_code:", inst)
return None
def retrieve_hint_code(self, exercise_id, course_id, assignment_id):
# SQL query to retrieve hint code from LLM_stuff table
sql = '''SELECT LF.hint_code, LF.LLM_assignment_id, LF.LLM_course_id, LF.LLM_exercise_id
FROM LLM_stuff as LF
JOIN exercises as E on LF.LLM_exercise_id = E.exercise_id
WHERE LF.LLM_exercise_id = ? AND E.course_id = ? AND E.assignment_id = ?
'''
# Fetch feedback data from the database
result = self.fetchall(sql, (exercise_id, course_id, assignment_id))
if result and result[0]:
return result[0]
else:
return None
# TODO: This function could probably be removed. get_exercise_statuses could be used in its place.
def get_exercises(self, course_basics, assignment_basics, show_hidden=True):
sql = '''SELECT exercise_id, title, visible, enable_pair_programming
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
ORDER BY title'''
exercises = []
for exercise in self.fetchall(sql, (course_basics["id"], assignment_basics["id"],)):
if exercise["visible"] or show_hidden:
exercises.append(dict(exercise))
exercises = sort_list_of_dicts_nicely(exercises, ["title", "exercise_id"])
exercises2 = []
for exercise in exercises:
exercise_basics = {"enable_pair_programming": exercise["enable_pair_programming"], "id": exercise["exercise_id"], "title": exercise["title"], "visible": exercise["visible"], "exists": True, "assignment": assignment_basics}
exercises2.append([exercise["exercise_id"], exercise_basics, course_basics['id'], assignment_basics['id']])
return exercises2
def get_partner_info(self, course_id):
# Gets list of users.
users = [x[1] for x in self.get_registered_students(course_id)]
# Adds users to dict to find duplicate names.
user_duplicates_dict = {}
for user in users:
if user["name"] in user_duplicates_dict.keys():
user_duplicates_dict[user["name"]].append({'id': user["id"], 'email': user['email']})
else:
user_duplicates_dict[user["name"]] = [{'id': user["id"], 'email': user['email']}]
# Adds all users to a dictionary with name (and obscured email if applicable) as key and id as value.
user_dict = {}
for user in user_duplicates_dict:
if len(user_duplicates_dict[user]) > 1:
for user_info in user_duplicates_dict[user]:
user_dict[user + " — " + self.obscure_email(user_info['email'], list(map(lambda x: x['email'], user_duplicates_dict[user])))] = user_info['id']
else:
user_dict[user] = user_duplicates_dict[user][0]['id']
return user_dict
def obscure_email(self, full_email, all_emails):
email = full_email.split("@")[0] if "@" in full_email else full_email
email_end = full_email.split("@")[1] if "@" in full_email else full_email
temp_email = email[0]
for other_email in all_emails:
other_email = other_email.split("@")[0] if "@" in other_email else other_email
if other_email == email:
pass
else:
for i in range(len(temp_email), len(min(email, other_email))):
if temp_email == other_email[:i]:
temp_email = temp_email + email[i]
else:
break
# Obscures all but essential characters of email.
return temp_email + (("*")*(len(email)-len(temp_email))) + "@" + email_end
def get_registered_students(self, course_id):
registered_students = []
sql = '''SELECT r.user_id, u.name, u.email_address
FROM course_registrations r
INNER JOIN users u
ON r.user_id = u.user_id
WHERE r.course_id = ?
ORDER BY u.name'''
for student in self.fetchall(sql, (course_id,)):
student_info = {"id": student["user_id"], "name": student["name"], 'email': student['email_address']}
registered_students.append([student["user_id"], student_info])
return registered_students
# Indicates whether or not a student has passed each assignment in the course.
async def get_assignment_statuses(self, course_id, user_id, show_hidden):
course_basics = self.get_course_basics(course_id)
sql = '''SELECT assignment_id,
title,
visible,
start_date,
due_date,
SUM(passed) AS num_passed,
COUNT(assignment_id) AS num_exercises,
SUM(passed) = COUNT(assignment_id) AS passed,
(SUM(passed) > 0 OR num_submissions > 0) AND SUM(passed) < COUNT(assignment_id) AS in_progress,
minutes_since_start,
has_timer,
hour_timer,
minute_timer,
restrict_other_assignments
FROM (
SELECT a.assignment_id,
a.title,
a.visible,
a.start_date,
a.due_date,
IFNULL(MAX(s.passed), 0) AS passed,
COUNT(s.submission_id) AS num_submissions,
a.has_timer,
a.hour_timer,
a.minute_timer,
a.restrict_other_assignments,
(JulianDay(DATETIME('now')) - JulianDay(uas.start_time)) * 24 * 60 AS minutes_since_start
FROM exercises e
LEFT JOIN submissions s
ON e.course_id = s.course_id
AND e.assignment_id = s.assignment_id
AND e.exercise_id = s.exercise_id
AND (s.user_id = ? OR s.user_id IS NULL)
INNER JOIN assignments a
ON e.course_id = a.course_id
AND e.assignment_id = a.assignment_id
LEFT JOIN user_assignment_starts uas
ON a.course_id = uas.course_id
AND a.assignment_id = uas.assignment_id
AND a.has_timer = 1
AND (uas.user_id = ? OR uas.user_id IS NULL)
WHERE e.course_id = ?
AND e.visible = 1
GROUP BY e.assignment_id, e.exercise_id
)
GROUP BY assignment_id, title
ORDER BY title'''
statuses = []
for row in self.fetchall(sql, (user_id, user_id, course_id,)):
assignment = dict(row)
if assignment["visible"] or show_hidden:
statuses.append(assignment)
statuses2 = []
# We have to check for this because otherwise the instructor has to make a submission before students will see the assignments.
if len(statuses) == 0:
for assignment_basics in self.get_assignments(course_basics, show_hidden):
assignment_basics[1]["num_passed"] = 0
assignment_basics[1]["num_exercises"] = 0
assignment_basics[1]["passed"] = 0
assignment_basics[1]["in_progress"] = 0
assignment_basics[1]["time_has_expired"] = False
statuses2.append([assignment_basics[0], assignment_basics[1]])
else:
for status in sort_list_of_dicts_nicely(statuses, ["title", "assignment_id"]):
assignment_dict = {"id": status["assignment_id"], "title": status["title"], "visible": status["visible"], "start_date": status["start_date"], "due_date": status["due_date"], "passed": status["passed"], "in_progress": status["in_progress"], "num_passed": status["num_passed"], "num_exercises": status["num_exercises"], "has_timer": status["has_timer"], "time_has_expired": status["minutes_since_start"] > status["hour_timer"] * 60 + status["minute_timer"] if status["minutes_since_start"] else False, "restrict_other_assignments": status["restrict_other_assignments"]}
if assignment_dict["start_date"]:
assignment_dict["start_date"] = assignment_dict["start_date"].strftime('%Y-%m-%dT%H:%M:%SZ')
if assignment_dict["due_date"]:
assignment_dict["due_date"] = assignment_dict["due_date"].strftime('%Y-%m-%dT%H:%M:%SZ')
statuses2.append([status["assignment_id"], assignment_dict])
return statuses2
# Gets the number of submissions a student has made for each exercise
# in an assignment and whether or not they have passed the exercise.
# TODO: Pass basics info into this function?
def get_exercise_statuses(self, course_id, assignment_id, user_id, current_exercise_id=None, show_hidden=True, nice_sort=True):
# This happens when you are creating a new assignment.
if not assignment_id:
return []
sql = '''SELECT e.exercise_id as id,
e.title,
e.enable_pair_programming,
IFNULL(MAX(s.passed), 0) AS passed,
COUNT(s.submission_id) AS num_submissions,
COUNT(s.submission_id) > 0 AND IFNULL(MAX(s.passed), 0) = 0 AS in_progress,
IFNULL(sc.score, 0) as score,
e.weight,
e.visible
FROM exercises e
LEFT JOIN submissions s
ON e.course_id = s.course_id
AND e.assignment_id = s.assignment_id
AND e.exercise_id = s.exercise_id
AND s.user_id = ?
LEFT JOIN scores sc
ON e.course_id = sc.course_id
AND e.assignment_id = sc.assignment_id
AND e.exercise_id = sc.exercise_id
AND (sc.user_id = ? OR sc.user_id IS NULL)
WHERE e.course_id = ?
AND e.assignment_id = ?
GROUP BY e.assignment_id, e.exercise_id
ORDER BY e.title'''
statuses = []
for row in self.fetchall(sql, (user_id, user_id, int(course_id), int(assignment_id),)):
if row["visible"] or show_hidden:
statuses.append(dict(row))
if nice_sort:
statuses = sort_list_of_dicts_nicely(statuses, ["title", "id"])
statuses2 = []
for status in statuses:
if current_exercise_id and status["id"] == current_exercise_id:
statuses2.append([status["id"], status])
for status in statuses:
if current_exercise_id and status["id"] == current_exercise_id:
next
statuses2.append([status["id"], status])
return statuses2
## Calculates the average score across all students for each assignment in a course, as well as the number of students who have completed each assignment.
def get_course_summary_scores(self, course_id, assignments):
sql = '''SELECT COUNT(*) AS num_students
FROM course_registrations
WHERE course_id = ?'''
num_students = self.fetchone(sql, (course_id, ))["num_students"]
sql = '''
WITH
student_info AS (
SELECT user_id
FROM course_registrations
WHERE course_id = ?
),
assignment_info AS (
SELECT a.assignment_id, SUM(e.weight) * 100.0 AS max_score
FROM assignments a
INNER JOIN exercises e
ON a.course_id = e.course_id
AND a.assignment_id = e.assignment_id
WHERE a.course_id = ?
AND a.visible = 1
AND e.visible = 1
GROUP BY a.assignment_id
),
assignment_score_info AS (
SELECT s.assignment_id, s.user_id, SUM(s.score * e.weight) AS score
FROM scores s
INNER JOIN assignments a
ON s.course_id = a.course_id
AND s.assignment_id = a.assignment_id
INNER JOIN exercises e
ON s.course_id = e.course_id
AND s.assignment_id = e.assignment_id
AND s.exercise_id = e.exercise_id
INNER JOIN course_registrations cr
ON s.course_id = cr.course_id
AND s.user_id = cr.user_id
WHERE s.course_id = ?
AND a.visible = 1
AND e.visible = 1
GROUP BY s.assignment_id, s.user_id
),
student_scores AS (
SELECT ai.assignment_id,
IFNULL(asi.score, 0) * 100.0 / ai.max_score AS score,
IFNULL(asi.score, 0) = ai.max_score AS completed
FROM assignment_info ai
INNER JOIN student_info si
LEFT JOIN assignment_score_info asi
ON ai.assignment_id = asi.assignment_id
AND si.user_id = asi.user_id
)
SELECT assignment_id, sum(completed) AS num_students_completed, ROUND(avg(score), 1) AS avg_score
FROM student_scores
GROUP BY assignment_id
'''
course_scores = {}
for row in self.fetchall(sql, (course_id, course_id, course_id, )):
assignment_dict = {"assignment_id": row["assignment_id"],
"num_students": num_students,
"num_students_completed": row["num_students_completed"],
"avg_score": row["avg_score"]}
course_scores[row["assignment_id"]] = assignment_dict
for assignment in assignments:
assignment_id = assignment[0]
if assignment_id not in course_scores:
course_scores[assignment_id] = {"num_students_completed": 0,
"num_students": num_students,
"avg_score": "0.0"}
return course_scores
## Calculates the average score across all students for each exercise in an assignment,
## as well as the number of students who have completed each exercise.
def get_assignment_summary_scores(self, course_basics, assignment_basics):
sql = '''
WITH
student_info AS (
SELECT user_id
FROM course_registrations
WHERE course_id = ?
),
exercise_score_info AS (
SELECT s.exercise_id, s.user_id, SUM(s.score) AS score
FROM scores s
INNER JOIN assignments a
ON s.course_id = a.course_id
AND s.assignment_id = a.assignment_id
INNER JOIN exercises e
ON s.course_id = e.course_id
AND s.assignment_id = e.assignment_id
AND s.exercise_id = e.exercise_id
INNER JOIN course_registrations cr
ON s.course_id = cr.course_id
AND s.user_id = cr.user_id
WHERE s.course_id = ?
AND s.assignment_id = ?
AND a.visible = 1
AND e.visible = 1
GROUP BY s.exercise_id, s.user_id
)
SELECT e.exercise_id,
ROUND(avg(IFNULL(esi.score, 0)), 1) AS avg_score
FROM exercises e
INNER JOIN student_info si
LEFT JOIN exercise_score_info esi
ON e.exercise_id = esi.exercise_id
AND si.user_id = esi.user_id
WHERE e.course_id = ?
AND e.assignment_id = ?
AND e.visible = 1
GROUP BY e.exercise_id
'''
assignment_scores = {}
for row in self.fetchall(sql, (course_basics["id"], course_basics["id"], assignment_basics["id"], course_basics["id"], assignment_basics["id"], )):
assignment_scores[row["exercise_id"]] = row["avg_score"]
if len(assignment_scores) == 0:
for exercise in self.get_exercises(course_basics, assignment_basics, show_hidden=False):
assignment_scores[exercise[0]] = 0.0
return assignment_scores
# Gets all users who have submitted on a particular assignment and creates a list of their average scores for the assignment.
def get_assignment_scores(self, course_basics, assignment_basics):
scores = []
sql = '''WITH
assignment_scores AS (
SELECT u.name,
s.user_id,
SUM(s.score * e.weight) / b.total_weight AS percent_passed,
sub.last_submission_time
FROM scores s
INNER JOIN users u
ON s.user_id = u.user_id
INNER JOIN (
SELECT SUM(weight) AS total_weight
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND visible = 1
) b
INNER JOIN exercises e
ON s.exercise_id = e.exercise_id
INNER JOIN (
SELECT user_id, strftime('%Y-%m-%d %H:%M:%S', MAX(date)) AS last_submission_time
FROM submissions
WHERE course_id = ?
AND assignment_id = ?
GROUP BY user_id
) sub
ON s.user_id = sub.user_id
WHERE s.course_id = ?
AND s.assignment_id = ?
AND s.user_id NOT IN
(
SELECT user_id
FROM permissions
WHERE course_id = 0 OR course_id = ?
)
AND s.exercise_id NOT IN
(
SELECT exercise_id
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND visible = 0
)
GROUP BY s.course_id, s.assignment_id, s.user_id
HAVING SUM(s.score) > 0
),
exercise_pass_dates AS (
SELECT exercise_id, user_id, min(date) AS earliest_pass_date
FROM submissions s
WHERE course_id = ?
AND assignment_id = ?
AND passed = 1
AND user_id NOT IN (
SELECT user_id
FROM permissions
WHERE course_id = 0 OR course_id = ?
)
GROUP BY exercise_id, user_id
),
when_users_passed AS (
SELECT user_id, max(earliest_pass_date) AS when_passed
FROM exercise_pass_dates
GROUP BY user_id
HAVING COUNT(*) >= (
SELECT COUNT(*) as num
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND visible = 1
)
UNION
SELECT user_id, ''
FROM exercise_pass_dates
GROUP BY user_id
HAVING COUNT(*) < (
SELECT COUNT(*) as num
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND visible = 1
)
ORDER BY user_id
)
SELECT assignment_scores.*, when_users_passed.when_passed
FROM assignment_scores
INNER JOIN when_users_passed
ON assignment_scores.user_id = when_users_passed.user_id
UNION
SELECT name, user_id, 0, '', ''
FROM users
WHERE user_id IN (SELECT user_id FROM course_registrations WHERE course_id = ?)
AND user_id NOT IN (SELECT user_id FROM assignment_scores)
'''
course_id = course_basics["id"]
assignment_id = assignment_basics["id"]
for user in self.fetchall(sql, (course_id, assignment_id, course_id, assignment_id, course_id, assignment_id, course_id, course_id, assignment_id, course_id, assignment_id, course_id, course_id, assignment_id, course_id, assignment_id, course_id, )):
scores_dict = {"name": user["name"], "user_id": user["user_id"], "percent_passed": user["percent_passed"], "when_passed": user["when_passed"], "last_submission_time": user["last_submission_time"]}
scores.append([user["user_id"], scores_dict])
return scores
# Get score for each assignment for a particular student.
def get_student_assignment_scores(self, course_id, user_id):
scores = []
sql = '''SELECT assignment_totals.assignment_id, assignment_totals.title, round(assignment_totals.total_score / max_possible.sum_weights, 2) AS score
FROM (
SELECT a.assignment_id, a.title, SUM(s.score * e.weight) AS total_score
FROM exercises e
INNER JOIN scores s
ON e.course_id = s.course_id
AND e.assignment_id = s.assignment_id
AND e.exercise_id = s.exercise_id
INNER JOIN assignments a
ON e.course_id = a.course_id
AND e.assignment_id = a.assignment_id
WHERE e.course_id = ?
AND s.user_id = ?
AND e.visible = 1
AND a.visible = 1
GROUP BY e.assignment_id
) assignment_totals
INNER JOIN (
SELECT assignment_id, SUM(weight) AS sum_weights
FROM exercises
WHERE course_id = ?
GROUP BY assignment_id
) max_possible
ON assignment_totals.assignment_id = max_possible.assignment_id
UNION
SELECT assignment_id, title, 0.0 as score
FROM assignments
WHERE course_id = ?
AND visible = 1
AND assignment_id NOT IN (
SELECT DISTINCT assignment_id
FROM scores
WHERE course_id = ?
AND user_id = ?
)
ORDER BY assignment_totals.title
'''
for row in self.fetchall(sql, (course_id, user_id, course_id, course_id, course_id, user_id, )):
scores.append([row["assignment_id"], row["title"], row["score"]])
return scores
def get_exercise_scores(self, course_id, assignment_id, exercise_id):
scores = []
sql = '''WITH exercise_scores AS (
SELECT u.name, s.user_id, sc.score, COUNT(s.submission_id) AS num_submissions
FROM submissions s
INNER JOIN users u
ON u.user_id = s.user_id
INNER JOIN scores sc
ON sc.course_id = s.course_id
AND sc.assignment_id = s.assignment_id
AND sc.exercise_id = s.exercise_id
AND sc.user_id = s.user_id
WHERE s.course_id = ?
AND s.assignment_id = ?
AND s.exercise_id = ?
GROUP BY s.user_id
)
SELECT *
FROM exercise_scores
UNION
SELECT name, user_id, 0, 0
FROM users
WHERE user_id IN (SELECT user_id FROM course_registrations WHERE course_id = ?)
AND user_id NOT IN (SELECT user_id FROM exercise_scores)
'''
for user in self.fetchall(sql, (int(course_id), int(assignment_id), int(exercise_id), int(course_id), )):
scores_dict = {"name": user["name"], "user_id": user["user_id"], "num_submissions": user["num_submissions"], "score": user["score"]}
scores.append([user["user_id"], scores_dict])
return scores
def save_exercise_score(self, course_id, assignment_id, exercise_id, user_id, score):
# We only update the score if it's higher than what was there previously. We also account for the scenario where it is their first submission.
sql = '''WITH user_scores AS (
SELECT score
FROM scores
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?
UNION
SELECT 0
)
INSERT OR REPLACE INTO scores (course_id, assignment_id, exercise_id, user_id, score)
SELECT ?, ?, ?, ?, ?
WHERE ? > (SELECT MAX(score) FROM user_scores)'''
self.execute(sql, (course_id, assignment_id, exercise_id, user_id, course_id, assignment_id, exercise_id, user_id, score, score))
def get_submissions(self, course_id, assignment_id, exercise_id, user_id, exercise_details):
sql = '''SELECT o.submission_id, t.title, o.txt_output, o.jpg_output
FROM test_outputs o
INNER JOIN tests t
ON o.test_id = t.test_id
INNER JOIN submissions s
ON o.submission_id = s.submission_id
LEFT JOIN users u
ON s.partner_id = u.user_id
WHERE t.course_id = ?
AND t.assignment_id = ?
AND t.exercise_id = ?
AND s.user_id = ?'''
test_outputs = {}
for row in self.fetchall(sql, (int(course_id), int(assignment_id), int(exercise_id), user_id,)):
submission_id = row["submission_id"]
test_title = row["title"]
if not submission_id in test_outputs:
test_outputs[submission_id] = {}
if not test_title in test_outputs[submission_id]:
test_outputs[submission_id][test_title] = {}
test_outputs[submission_id][test_title]["txt_output"] = row["txt_output"]
test_outputs[submission_id][test_title]["jpg_output"] = row["jpg_output"]
test_outputs[submission_id][test_title]["txt_output_formatted"] = format_output_as_html(row["txt_output"])
sql = '''SELECT s.submission_id, s.code, s.passed, s.date, u.name AS partner_name
FROM submissions s
LEFT JOIN users u
ON s.partner_id = u.user_id
WHERE s.course_id = ?
AND s.assignment_id = ?
AND s.exercise_id = ?
AND s.user_id = ?
UNION
SELECT -1, code, FALSE, NULL, NULL
FROM presubmissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?
ORDER BY s.submission_id'''
presubmission = None
submissions = []
for row in self.fetchall(sql, (course_id, assignment_id, exercise_id, user_id, course_id, assignment_id, exercise_id, user_id,)):
submission_test_outputs = {}
if row["submission_id"] == -1:
presubmission = row["code"]
else:
if row["submission_id"] in test_outputs:
submission_test_outputs = test_outputs[row["submission_id"]]
check_test_outputs(exercise_details, submission_test_outputs)
sanitize_test_outputs(exercise_details, submission_test_outputs)
submissions.append({"id": row["submission_id"], "code": row["code"], "passed": row["passed"], "date": row["date"].strftime("%a, %d %b %Y %H:%M:%S UTC"), "partner_name": row["partner_name"], "test_outputs": submission_test_outputs})
return presubmission, submissions
#TODO: Is there some way to do this without going to the database?
async def get_num_submissions(self, course_id, assignment_id, exercise_id, user_id):
sql = '''SELECT COUNT(submission_id) AS num
FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?'''
return self.fetchone(sql, (course_id, assignment_id, exercise_id, user_id, ))["num"]
def get_most_recent_submission_code(self, course_id, assignment_id, exercise_id, user_id):
sql = '''SELECT code
FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?
AND passed = 1
ORDER BY date DESC
LIMIT 1'''
result = self.fetchone(sql, (course_id, assignment_id, exercise_id, user_id,))
if result:
return result["code"]
else:
return ""
def get_peer_code(self, course_id, assignment_id, exercise_id, user_id):
sql = '''SELECT user_id, code, MAX(date)
FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND passed = 1
AND user_id != ?
AND (partner_id != ? OR partner_id IS NULL)
GROUP BY user_id
ORDER BY user_id'''
peer_code_dict = {}
for row in self.fetchall(sql, (course_id, assignment_id, exercise_id, user_id, user_id)):
peer_code_dict[row["user_id"]] = row["code"]
if len(peer_code_dict) == 0:
return ""
peer_ids = list(peer_code_dict.keys())
random.shuffle(peer_ids)
return peer_code_dict[peer_ids[0]]
def get_help_requests(self, course_id):
help_requests = []
sql = '''SELECT r.course_id, a.assignment_id, e.exercise_id, c.title as course_title, a.title as assignment_title, e.title as exercise_title, r.user_id, u.name, r.code, r.text_output, r.image_output, r.student_comment, r.suggestion, r.approved, r.suggester_id, r.approver_id, r.date, r.more_info_needed
FROM help_requests r
INNER JOIN users u
ON r.user_id = u.user_id
INNER JOIN courses c
ON r.course_id = c.course_id
INNER JOIN assignments a
ON r.assignment_id = a.assignment_id
INNER JOIN exercises e
ON r.exercise_id = e.exercise_id
WHERE r.course_id = ?
ORDER BY r.date DESC'''
for request in self.fetchall(sql, (course_id,)):
help_requests.append({"course_id": request["course_id"], "assignment_id": request["assignment_id"], "exercise_id": request["exercise_id"], "course_title": request["course_title"], "assignment_title": request["assignment_title"], "exercise_title": request["exercise_title"], "user_id": request["user_id"], "name": request["name"], "code": request["code"], "text_output": request["text_output"], "image_output": request["image_output"], "student_comment": request["student_comment"], "suggestion": request["suggestion"], "approved": request["approved"], "suggester_id": request["suggester_id"], "approver_id": request["approver_id"], "date": request["date"], "more_info_needed": request["more_info_needed"]})
return help_requests
def get_student_help_requests(self, user_id):
help_requests = []
sql = '''SELECT r.course_id, a.assignment_id, e.exercise_id, c.title as course_title, a.title as assignment_title, e.title as exercise_title, r.user_id, u.name, r.code, r.text_output, r.image_output, r.student_comment, r.suggestion, r.approved, r.suggester_id, r.approver_id, r.more_info_needed
FROM help_requests r
INNER JOIN users u
ON r.user_id = u.user_id
INNER JOIN courses c
ON r.course_id = c.course_id
INNER JOIN assignments a
ON r.assignment_id = a.assignment_id
INNER JOIN exercises e
ON r.exercise_id = e.exercise_id
WHERE r.user_id = ?
ORDER BY r.date DESC'''
for request in self.fetchall(sql, (user_id,)):
help_requests.append({"course_id": request["course_id"], "assignment_id": request["assignment_id"], "exercise_id": request["exercise_id"], "course_title": request["course_title"], "assignment_title": request["assignment_title"], "exercise_title": request["exercise_title"], "user_id": request["user_id"], "name": request["name"], "code": request["code"], "text_output": request["text_output"], "image_output": request["text_output"], "image_output": request["image_output"], "student_comment": request["student_comment"], "suggestion": request["suggestion"], "approved": request["approved"], "suggester_id": request["suggester_id"], "approver_id": request["approver_id"], "more_info_needed": request["more_info_needed"]})
return help_requests
def get_exercise_help_requests(self, course_id, assignment_id, exercise_id, user_id):
sql = '''SELECT text_output
FROM help_requests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?'''
row = self.fetchone(sql, (course_id, assignment_id, exercise_id, user_id,))
orig_output = re.sub("#.*", "", row["text_output"])
sql = '''SELECT r.course_id, r.assignment_id, r.exercise_id, r.user_id, u.name, r.code, r.text_output, r.image_output, r.student_comment, r.suggestion, r.approved, r.suggester_id, r.approver_id, r.more_info_needed
FROM help_requests r
INNER JOIN users u
ON r.user_id = u.user_id
WHERE r.course_id = ?
AND r.assignment_id = ?
AND r.exercise_id = ?
AND NOT r.user_id = ?
ORDER BY r.date DESC'''
requests = self.fetchall(sql, (course_id, assignment_id, exercise_id, user_id,))
nlp = spacy.load('en_core_web_sm')
orig = nlp(orig_output)
help_requests = []
for request in requests:
curr = nlp(re.sub("#.*", "", request["text_output"]))
psim = curr.similarity(orig)
request_info = {"psim": psim, "course_id": request["course_id"], "assignment_id": request["assignment_id"], "exercise_id": request["exercise_id"], "user_id": request["user_id"], "name": request["name"], "code": request["code"], "text_output": request["text_output"], "image_output": request["text_output"], "image_output": request["image_output"], "student_comment": request["student_comment"], "suggestion": request["suggestion"], "approved": request["approved"], "suggester_id": request["suggester_id"], "approver_id": request["approver_id"], "more_info_needed": request["more_info_needed"]}
help_requests.append(request_info)
return sorted(help_requests, key=lambda x: x["psim"], reverse=True)
def get_help_request(self, course_id, assignment_id, exercise_id, user_id):
sql = '''SELECT r.user_id, u.name, r.code, r.text_output, r.image_output, r.student_comment, r.suggestion, r.approved, r.suggester_id, r.approver_id, r.more_info_needed
FROM help_requests r
INNER JOIN users u
ON r.user_id = u.user_id
WHERE r.course_id = ?
AND r.assignment_id = ?
AND r.exercise_id = ?
AND r.user_id = ?'''
request = self.fetchone(sql, (course_id, assignment_id, exercise_id, user_id,))
if request:
help_request = {"course_id": course_id, "assignment_id": assignment_id, "exercise_id": exercise_id, "user_id": request["user_id"], "name": request["name"], "code": request["code"], "text_output": request["text_output"], "image_output": request["image_output"], "student_comment": request["student_comment"], "approved": request["approved"], "suggester_id": request["suggester_id"], "approver_id": request["approver_id"], "more_info_needed": request["more_info_needed"]}
if request["suggestion"]:
help_request["suggestion"] = request["suggestion"]
else:
help_request["suggestion"] = None
return help_request
def compare_help_requests(self, course_id, assignment_id, exercise_id, user_id):
# Get the original help request, including its output type
sql = '''SELECT r.text_output, e.expected_text_output, r.image_output, e.expected_image_output, e.output_type
FROM help_requests r
INNER JOIN exercises e
ON e.course_id = r.course_id
AND e.assignment_id = r.assignment_id
AND e.exercise_id = r.exercise_id
WHERE r.course_id = ?
AND r.assignment_id = ?
AND r.exercise_id = ?
AND r.user_id = ?'''
row = self.fetchone(sql, (course_id, assignment_id, exercise_id, user_id,))
#the original output type will be either txt or jpg depending on the output type of the exercise
orig_output = None
if row["output_type"] == "jpg":
if row["image_output"] != row["expected_image_output"]:
orig_output = row["image_output"]
else:
if row["text_output"] != row["expected_text_output"]:
orig_output = row["text_output"]
#get all other help requests in the course that have the same output type
if orig_output:
sql = '''SELECT r.course_id, r.assignment_id, r.exercise_id, r.user_id, u.name, r.code, r.text_output, r.image_output, r.student_comment, r.suggestion
FROM help_requests r
INNER JOIN users u
ON r.user_id = u.user_id
INNER JOIN exercises e
ON e.course_id = r.course_id
AND e.assignment_id = r.assignment_id
AND e.exercise_id = r.exercise_id
WHERE r.course_id = ?
AND NOT r.user_id = ?
AND e.output_type = ?'''
requests = self.fetchall(sql, (course_id, user_id, row["output_type"]))
sim_dict = []
#jpg output uses the diff_jpg function in helper.py, txt output uses .similarity() from the Spacy module
if row["output_type"] == "jpg":
for request in requests:
diff_image, diff_percent = diff_jpg(orig_output, request["image_output"])
if diff_percent < .10:
request_info = {"psim": 1 - diff_percent, "course_id": request["course_id"], "assignment_id": request["assignment_id"], "exercise_id": request["exercise_id"], "user_id": request["user_id"], "name": request["name"], "student_comment": request["student_comment"], "code": request["code"], "text_output": request["text_output"], "suggestion": request["suggestion"]}
sim_dict.append(request_info)
else:
nlp = spacy.load('en_core_web_sm')
orig = nlp(orig_output)
for request in requests:
curr = nlp(request["text_output"])
psim = curr.similarity(orig)
sim = False
#these thresholds can be changed in the future
if len(orig) < 10 and len(curr) < 10:
if psim > .30:
sim = True
elif len(orig) < 100 and len(curr) < 100:
if psim > .50:
sim = True
elif len(orig) < 200 and len(curr) < 200:
if psim > .70:
sim = True
else:
if psim > .90:
sim = True
if sim:
request_info = {"psim": psim, "course_id": request["course_id"], "assignment_id": request["assignment_id"], "exercise_id": request["exercise_id"], "user_id": request["user_id"], "name": request["name"], "student_comment": request["student_comment"], "code": request["code"], "text_output": request["text_output"], "suggestion": request["suggestion"]}
sim_dict.append(request_info)
return sim_dict
def get_same_suggestion(self, help_request):
sql = '''SELECT r.suggestion, e.output_type, r.text_output, r.image_output
FROM help_requests r
INNER JOIN exercises e
ON e.exercise_id = r.exercise_id
WHERE r.course_id = ?
AND r.suggestion NOT NULL
AND e.output_type = (
SELECT output_type
FROM exercises
WHERE exercise_id = ?
)'''
matches = self.fetchall(sql, (help_request["course_id"], help_request["exercise_id"]))
for match in matches:
if match["output_type"] == "jpg":
if match["image_output"] == help_request["image_output"]:
return match["suggestion"]
else:
if match["text_output"] == help_request["text_output"]:
return match["suggestion"]
# FYI: This is different from the get_submissions() function
def get_exercise_submissions(self, course_id, assignment_id, exercise_id):
exercise_submissions = []
sql = '''WITH exercise_submissions AS (
SELECT MAX(s.date), s.code, u.user_id, u.name, sc.score, s.passed, p.name AS partner_name
FROM submissions s
LEFT JOIN users p
ON s.partner_id = p.user_id
INNER JOIN users u
ON s.user_id = u.user_id
INNER JOIN scores sc
ON s.user_id = sc.user_id
AND s.course_id = sc.course_id
AND s.assignment_id = sc.assignment_id
AND s.exercise_id = sc.exercise_id
WHERE s.course_id = ?
AND s.assignment_id = ?
AND s.exercise_id = ?
AND s.user_id IN
(
SELECT user_id
FROM course_registrations
WHERE course_id = ?
)
GROUP BY s.user_id
)
SELECT *
FROM exercise_submissions
UNION
SELECT NULL, NULL, user_id, name, 0, 0, NULL
FROM users
WHERE user_id IN (SELECT user_id FROM course_registrations WHERE course_id = ?)
AND user_id NOT IN (SELECT user_id FROM exercise_submissions)
ORDER BY name'''
for submission in self.fetchall(sql, (course_id, assignment_id, exercise_id, course_id, course_id, )):
submission_info = {"user_id": submission["user_id"], "name": submission["name"], "code": submission["code"], "score": submission["score"], "passed": submission["passed"], "partner_name": submission["partner_name"]}
exercise_submissions.append([submission["user_id"], submission_info])
return exercise_submissions
def specify_course_basics(self, course_basics, title, visible):
course_basics["title"] = title
course_basics["visible"] = visible
def specify_course_details(self, course_details, introduction, passcode, allow_students_download_submissions, date_created, date_updated):
course_details["introduction"] = introduction
course_details["passcode"] = passcode
course_details["allow_students_download_submissions"] = allow_students_download_submissions
course_details["date_updated"] = date_updated
if course_details["date_created"]:
course_details["date_created"] = date_created
else:
course_details["date_created"] = date_updated
def specify_assignment_basics(self, assignment_basics, title, visible):
assignment_basics["title"] = title
assignment_basics["visible"] = visible
def specify_assignment_details(self, assignment_details, introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, has_timer, hour_timer, minute_timer, restrict_other_assignments, allowed_ip_addresses, allowed_external_urls):
assignment_details["introduction"] = introduction
assignment_details["date_updated"] = date_updated
assignment_details["start_date"] = start_date
assignment_details["due_date"] = due_date
assignment_details["allow_late"] = allow_late
assignment_details["late_percent"] = late_percent
assignment_details["view_answer_late"] = view_answer_late
assignment_details["enable_help_requests"] = enable_help_requests
assignment_details["has_timer"] = has_timer
assignment_details["hour_timer"] = hour_timer
assignment_details["minute_timer"] = minute_timer
assignment_details["restrict_other_assignments"] = restrict_other_assignments
assignment_details["allowed_ip_addresses"] = allowed_ip_addresses
assignment_details["allowed_external_urls"] = allowed_external_urls
if assignment_details["date_created"]:
assignment_details["date_created"] = date_created
else:
assignment_details["date_created"] = date_updated
def get_course_basics(self, course_id):
null_course = {"id": "", "title": "", "visible": True, "exists": False}
if not course_id:
return null_course
sql = '''SELECT course_id, title, visible
FROM courses
WHERE course_id = ?'''
row = self.fetchone(sql, (int(course_id),))
if not row:
return null_course
return {"id": row["course_id"], "title": row["title"], "visible": bool(row["visible"]), "exists": True}
def get_assignments(self, course_basics, show_hidden=True):
sql = '''SELECT assignment_id as id, title, visible
FROM assignments a
WHERE course_id = ?'''
# We initially structure it this way to make sorting easier.
assignments = []
for row in self.fetchall(sql, (course_basics["id"],)):
if row["visible"] or show_hidden:
assignments.append(dict(row))
assignments = sort_list_of_dicts_nicely(assignments, ["title", "id"])
# We restructure it to be consistent with courses and exercises
assignments2 = []
for assignment in assignments:
assignments2.append([assignment["id"], assignment])
return assignments2
def get_assignment_basics(self, course_basics, assignment_id):
if not assignment_id:
return {"id": "", "title": "", "visible": True, "exists": False, "course": course_basics}
sql = '''SELECT assignment_id, title, visible
FROM assignments
WHERE course_id = ?
AND assignment_id = ?'''
row = self.fetchone(sql, (int(course_basics['id']), assignment_id,))
if row is None:
return {"id": "", "title": "", "visible": True, "exists": False, "course": course_basics}
else:
return {"id": row["assignment_id"], "title": row["title"], "visible": bool(row["visible"]), "exists": True, "course": course_basics}
def get_exercise_basics(self, course_basics, assignment_basics, exercise_id):
if not exercise_id:
return {"id": "", "title": "", "visible": True, "exists": False, "assignment": assignment_basics}
sql = '''SELECT exercise_id, title, visible, enable_pair_programming
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
row = self.fetchone(sql, (course_basics['id'], assignment_basics['id'], exercise_id,))
if row is None:
return {"enable_pair_programming": False, "id": "", "title": "", "visible": True, "exists": False, "assignment": assignment_basics}
else:
return {"enable_pair_programming": row["enable_pair_programming"], "id": row["exercise_id"], "title": row["title"], "visible": bool(row["visible"]), "exists": True, "assignment": assignment_basics}
def get_next_prev_exercises(self, course_id, assignment_id, exercise, exercises):
prev_exercise = None
next_exercise = None
if len(exercises) > 0 and exercise:
this_exercise = [i for i in range(len(exercises)) if exercises[i][0] == int(exercise)]
if len(this_exercise) > 0:
this_exercise_index = [i for i in range(len(exercises)) if exercises[i][0] == int(exercise)][0]
if len(exercises) >= 2 and this_exercise_index != 0:
prev_exercise = exercises[this_exercise_index - 1][1]
if len(exercises) >= 2 and this_exercise_index != (len(exercises) - 1):
next_exercise = exercises[this_exercise_index + 1][1]
return {"previous": prev_exercise, "next": next_exercise}
def delete_old_presubmissions(self):
sql = '''DELETE
FROM presubmissions
WHERE date_updated < datetime('now', '-12 months')'''
self.execute(sql)
def get_presubmission(self, course_id, assignment_id, exercise_id, user_id):
sql = '''SELECT code
FROM presubmissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?'''
row = self.fetchone(sql, (int(course_id), int(assignment_id), int(exercise_id), user_id))
return row["code"] if row else None
def get_course_details(self, course_id):
null_course = {"introduction": "", "passcode": None, "date_created": None, "date_updated": None, "allow_students_download_submissions": False}
if not course_id:
return null_course
sql = '''SELECT introduction, passcode, date_created, date_updated, allow_students_download_submissions
FROM courses
WHERE course_id = ?'''
row = self.fetchone(sql, (course_id,))
if not row:
return null_course
course_details = {"introduction": row["introduction"], "passcode": row["passcode"], "date_created": row["date_created"], "date_updated": row["date_updated"], "allow_students_download_submissions": row["allow_students_download_submissions"]}
sql = '''SELECT COUNT(*) > 0 AS yes
FROM assignments
WHERE course_id = ?
AND restrict_other_assignments = 1'''
course_details["check_for_restrict_other_assignments"] = bool(self.fetchone(sql, (course_id, ))["yes"])
return course_details
def get_assignment_details(self, course_basics, assignment_id):
null_assignment = {"introduction": "", "date_created": None, "date_updated": None, "start_date": None, "due_date": None, "allow_late": False, "late_percent": None, "view_answer_late": False, "enable_help_requests": 1, "has_timer": 0, "hour_timer": None, "minute_timer": None, "restrict_other_assignments": False, "allowed_ip_addresses": None, "allowed_external_urls": None, "due_date_passed": None}
if not assignment_id:
return null_assignment
sql = '''SELECT introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, allowed_ip_addresses, allowed_external_urls, has_timer, hour_timer, minute_timer, restrict_other_assignments
FROM assignments
WHERE course_id = ?
AND assignment_id = ?'''
row = self.fetchone(sql, (course_basics['id'], assignment_id,))
if not row:
return null_assignment
assignment_dict = {"introduction": row["introduction"], "date_created": row["date_created"], "date_updated": row["date_updated"], "start_date": row["start_date"], "due_date": row["due_date"], "allow_late": row["allow_late"], "late_percent": row["late_percent"], "view_answer_late": row["view_answer_late"], "allowed_ip_addresses": row["allowed_ip_addresses"], "allowed_external_urls": row["allowed_external_urls"], "enable_help_requests": row["enable_help_requests"], "has_timer": row["has_timer"], "hour_timer": row["hour_timer"], "minute_timer": row["minute_timer"], "restrict_other_assignments": row["restrict_other_assignments"], "due_date_passed": None}
curr_datetime = datetime.utcnow()
if assignment_dict["due_date"]:
assignment_dict["due_date_passed"] = curr_datetime > assignment_dict["due_date"]
if assignment_dict["allowed_ip_addresses"]:
assignment_dict["allowed_ip_addresses_list"] = assignment_dict["allowed_ip_addresses"].split("\n")
if assignment_dict["allowed_external_urls"] != "":
assignment_dict["allowed_external_urls_dict"] = {}
for url in assignment_dict["allowed_external_urls"].split("\n"):
url = url.strip()
assignment_dict["allowed_external_urls_dict"][url] = urllib.parse.quote(url)
return assignment_dict
def get_exercise_details(self, course_basics, assignment_basics, exercise_id):
null_exercise = {"instructions": "", "back_end": "python", "output_type": "txt", "allow_any_response": False, "solution_code": "", "solution_description": "", "hint": "", "max_submissions": 0, "starter_code": "", "credit": "", "data_files": [], "what_students_see_after_success": 1, "date_created": None, "date_updated": None, "enable_pair_programming": False, "verification_code": "", "weight": 1.0, "tests": {}}
if not exercise_id:
return null_exercise
sql = '''SELECT instructions, back_end, output_type, allow_any_response, solution_code, solution_description, hint, max_submissions, starter_code, credit, data_files, what_students_see_after_success, date_created, date_updated, enable_pair_programming, verification_code, weight
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
row = self.fetchone(sql, (course_basics['id'], assignment_basics['id'], exercise_id,))
if not row:
return null_exercise
exercise_dict = {"instructions": row["instructions"], "back_end": row["back_end"], "output_type": row["output_type"], "allow_any_response": row["allow_any_response"], "solution_code": row["solution_code"], "solution_description": row["solution_description"], "hint": row["hint"], "max_submissions": row["max_submissions"], "starter_code": row["starter_code"], "credit": row["credit"], "data_files": json.loads(row["data_files"]), "what_students_see_after_success": row["what_students_see_after_success"], "date_created": row["date_created"], "date_updated": row["date_updated"], "enable_pair_programming": row["enable_pair_programming"], "verification_code": row["verification_code"], "weight": row["weight"], "tests": {}}
sql = '''SELECT test_id,
title,
before_code,
after_code,
instructions,
can_see_test_code,
can_see_expected_output,
can_see_code_output,
txt_output,
jpg_output
FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
tests = self.fetchall(sql, (course_basics['id'], assignment_basics['id'], exercise_id,))
for test in tests:
exercise_dict["tests"][test["title"]] = {"test_id": test["test_id"], "before_code": test["before_code"], "after_code": test["after_code"], "instructions": test["instructions"], "can_see_test_code": test["can_see_test_code"], "can_see_expected_output": test["can_see_expected_output"], "can_see_code_output": test["can_see_code_output"], "txt_output": test["txt_output"], "jpg_output": test["jpg_output"]}
return exercise_dict
def get_log_table_contents(self, file_path, year="No filter", month="No filter", day="No filter"):
new_dict = {}
line_num = 1
with gzip.open(file_path) as read_file:
header = read_file.readline()
for line in read_file:
line_items = line.decode().rstrip("\n").split("\t")
#Get ids to create links to each course, assignment, and exercise in the table
course_id = line_items[1]
assignment_id = line_items[2]
exercise_id = line_items[3]
line_items[6] = f"<a href='/course/{course_id}'>{line_items[6]}</a>"
line_items[7] = f"<a href='/assignment/{course_id}/{assignment_id}'>{line_items[7]}</a>"
line_items[8] = f"<a href='/exercise/{course_id}/{assignment_id}/{exercise_id}'>{line_items[8]}</a>"
line_items = [line_items[0][:2], line_items[0][2:4], line_items[0][4:6], line_items[0][6:]] + line_items[4:]
new_dict[line_num] = line_items
line_num += 1
# Filter by date.
year_dict = {}
month_dict = {}
day_dict = {}
for key, line in new_dict.items():
if year == "No filter" or line[0] == year:
year_dict[key] = line
for key, line in year_dict.items():
if month == "No filter" or line[1] == month:
month_dict[key] = line
for key, line in month_dict.items():
if day == "No filter" or line[2] == day:
day_dict[key] = line
return day_dict
def get_root_dirs_to_log(self):
root_dirs_to_log = set(["home", "course", "assignment", "exercise", "check_exercise", "edit_course", "edit_assignment", "edit_exercise", "delete_course", "delete_assignment", "delete_exercise", "view_answer", "import_course", "export_course"])
return root_dirs_to_log
def sort_nested_list(self, nested_list, key="title"):
l_dict = {}
for row in nested_list:
l_dict[row[1][key]] = row
return [l_dict[key] for key in sort_nicely(l_dict)]
def has_duplicate_title(self, entries, this_entry, proposed_title):
for entry in entries:
if entry[0] != this_entry and entry[1]["title"] == proposed_title:
return True
return False
def save_course(self, course_basics, course_details):
if course_basics["exists"]:
sql = '''UPDATE courses
SET title = ?, visible = ?, introduction = ?, passcode = ?, allow_students_download_submissions = ?, date_updated = ?
WHERE course_id = ?'''
self.execute(sql, [course_basics["title"], course_basics["visible"], course_details["introduction"], course_details["passcode"], course_details["allow_students_download_submissions"], course_details["date_updated"], course_basics["id"]])
self.update_when_content_updated(course_basics["id"])
else:
sql = '''INSERT INTO courses (title, visible, introduction, passcode, allow_students_download_submissions, date_created, date_updated)
VALUES (?, ?, ?, ?, ?, ?, ?)'''
course_basics["id"] = self.execute(sql, (course_basics["title"], course_basics["visible"], course_details["introduction"], course_details["passcode"], course_details["allow_students_download_submissions"], course_details["date_created"], course_details["date_updated"], ))
course_basics["exists"] = True
self.update_when_content_updated("user")
return course_basics["id"]
def save_assignment(self, assignment_basics, assignment_details):
if assignment_basics["exists"]:
sql = '''UPDATE assignments
SET title = ?, visible = ?, introduction = ?, date_updated = ?, start_date = ?, due_date = ?, allow_late = ?, late_percent = ?, view_answer_late = ?, enable_help_requests = ?, has_timer = ?, hour_timer = ?, minute_timer = ?, restrict_other_assignments = ?, allowed_ip_addresses = ?, allowed_external_urls = ?
WHERE course_id = ?
AND assignment_id = ?'''
self.execute(sql, [assignment_basics["title"], assignment_basics["visible"], assignment_details["introduction"], assignment_details["date_updated"], assignment_details["start_date"], assignment_details["due_date"], assignment_details["allow_late"], assignment_details["late_percent"], assignment_details["view_answer_late"], assignment_details["enable_help_requests"], assignment_details["has_timer"], assignment_details["hour_timer"], assignment_details["minute_timer"], assignment_details["restrict_other_assignments"], assignment_details["allowed_ip_addresses"], assignment_details["allowed_external_urls"], assignment_basics["course"]["id"], assignment_basics["id"]])
else:
sql = '''INSERT INTO assignments (course_id, title, visible, introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, has_timer, hour_timer, minute_timer, restrict_other_assignments, allowed_ip_addresses, allowed_external_urls)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
assignment_basics["id"] = self.execute(sql, [assignment_basics["course"]["id"], assignment_basics["title"], assignment_basics["visible"], assignment_details["introduction"], assignment_details["date_created"], assignment_details["date_updated"], assignment_details["start_date"], assignment_details["due_date"], assignment_details["allow_late"], assignment_details["late_percent"], assignment_details["view_answer_late"], assignment_details["enable_help_requests"], assignment_details["has_timer"], assignment_details["hour_timer"], assignment_details["minute_timer"], assignment_details["restrict_other_assignments"], assignment_details["allowed_ip_addresses"], assignment_details["allowed_external_urls"]])
assignment_basics["exists"] = True
self.update_when_content_updated(assignment_basics["course"]["id"])
return assignment_basics["id"]
def save_exercise(self, exercise_basics, exercise_details):
cursor = self.conn.cursor()
cursor.execute("BEGIN")
if "what_students_see_after_success" not in exercise_details:
exercise_details["what_students_see_after_success"] = 1
try:
if exercise_basics["exists"]:
sql = '''
UPDATE exercises
SET title = ?, visible = ?, solution_code = ?, solution_description = ?, hint = ?,
max_submissions = ?, credit = ?, data_files = ?, back_end = ?,
instructions = ?, output_type = ?, allow_any_response = ?,
what_students_see_after_success = ?, starter_code = ?,
date_updated = ?, enable_pair_programming = ?, verification_code = ?,
weight = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
cursor.execute(sql, [exercise_basics["title"], exercise_basics["visible"], str(exercise_details["solution_code"]), exercise_details["solution_description"], exercise_details["hint"], exercise_details["max_submissions"], exercise_details["credit"], json.dumps(exercise_details["data_files"]), exercise_details["back_end"], exercise_details["instructions"], exercise_details["output_type"], exercise_details["allow_any_response"], exercise_details["what_students_see_after_success"], exercise_details["starter_code"], exercise_details["date_updated"], exercise_details["enable_pair_programming"], exercise_details["verification_code"], exercise_details["weight"], exercise_basics["assignment"]["course"]["id"], exercise_basics["assignment"]["id"], exercise_basics["id"]])
sql = '''DELETE FROM test_outputs
WHERE test_id IN (
SELECT test_id
FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?)'''
cursor.execute(sql, [exercise_basics["assignment"]["course"]["id"], exercise_basics["assignment"]["id"], exercise_basics["id"]])
sql = '''DELETE FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
cursor.execute(sql, [exercise_basics["assignment"]["course"]["id"], exercise_basics["assignment"]["id"], exercise_basics["id"]])
for title in exercise_details["tests"]:
# Only saves 'jpg_output' if it isn't blank.
jpg_output = exercise_details["tests"][title]["jpg_output"]
#if jpg_output != "" and jpg_output.strip() == BLANK_IMAGE.strip():
if jpg_output != "" and jpg_output.strip() == BLANK_IMAGE:
jpg_output = ""
sql = '''INSERT INTO tests (course_id, assignment_id, exercise_id, title, before_code, after_code, instructions, can_see_test_code, can_see_expected_output, can_see_code_output, txt_output, jpg_output)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
test_id = cursor.execute(sql, [exercise_basics["assignment"]["course"]["id"], exercise_basics["assignment"]["id"], exercise_basics["id"], title, exercise_details["tests"][title]["before_code"], exercise_details["tests"][title]["after_code"], exercise_details["tests"][title]["instructions"], exercise_details["tests"][title]["can_see_test_code"], exercise_details["tests"][title]["can_see_expected_output"], exercise_details["tests"][title]["can_see_code_output"], exercise_details["tests"][title]["txt_output"], jpg_output])
else:
sql = '''INSERT INTO exercises (course_id, assignment_id, title, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, allow_any_response, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
cursor.execute(sql, [exercise_basics["assignment"]["course"]["id"], exercise_basics["assignment"]["id"], exercise_basics["title"], exercise_basics["visible"], str(exercise_details["solution_code"]), exercise_details["solution_description"], exercise_details["hint"], exercise_details["max_submissions"], exercise_details["credit"], json.dumps(exercise_details["data_files"]), exercise_details["back_end"], exercise_details["instructions"], exercise_details["output_type"], exercise_details["allow_any_response"], exercise_details["what_students_see_after_success"], exercise_details["starter_code"], exercise_details["date_created"], exercise_details["date_updated"], exercise_details["enable_pair_programming"], exercise_details["verification_code"], exercise_details["weight"]])
exercise_basics["id"] = cursor.lastrowid
exercise_basics["exists"] = True
for title in exercise_details["tests"]:
sql = '''INSERT INTO tests (course_id, assignment_id, exercise_id, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
test_id = cursor.execute(sql, [
exercise_basics["assignment"]["course"]["id"],
exercise_basics["assignment"]["id"],
exercise_basics["id"],
title,
exercise_details["tests"][title]["before_code"],
exercise_details["tests"][title]["after_code"],
exercise_details["tests"][title]["instructions"],
exercise_details["tests"][title]["txt_output"],
exercise_details["tests"][title]["jpg_output"],
exercise_details["tests"][title]["can_see_test_code"],
exercise_details["tests"][title]["can_see_expected_output"],
exercise_details["tests"][title]["can_see_code_output"],
])
cursor.execute("COMMIT")
except self.conn.Error:
cursor.execute("ROLLBACK")
raise
cursor.close()
self.update_when_content_updated(exercise_basics["assignment"]["course"]["id"])
return exercise_basics["id"]
def save_presubmission(self, course_id, assignment_id, exercise_id, user_id, code):
sql = '''INSERT OR REPLACE INTO presubmissions (course_id, assignment_id, exercise_id, user_id, code)
VALUES (?, ?, ?, ?, ?)'''
self.execute(sql, [course_id, assignment_id, exercise_id, user_id, code])
async def save_submission(self, course_id, assignment_id, exercise_id, user_id, code, passed, date, exercise_details, test_outputs, score, partner_id):
sql = '''INSERT INTO submissions (course_id, assignment_id, exercise_id, user_id, code, passed, date, partner_id)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)'''
submission_id = self.execute(sql, (course_id, assignment_id, exercise_id, user_id, code, passed, date, partner_id,))
sql_statements = []
params_list = []
for test_title, test_dict in test_outputs.items():
if test_dict["jpg_output"] != "":
#if test_dict["jpg_output"].strip() == BLANK_IMAGE.strip():
if test_dict["jpg_output"].strip() == BLANK_IMAGE:
test_dict["jpg_output"] = ""
sql_statements.append('''INSERT INTO test_outputs (test_id, submission_id, txt_output, jpg_output)
VALUES (?, ?, ?, ?)''')
params_list.append((exercise_details["tests"][test_title]["test_id"], submission_id, test_dict["txt_output"], test_dict["jpg_output"],))
self.execute_multiple(sql_statements, params_list)
self.save_exercise_score(course_id, assignment_id, exercise_id, user_id, score)
self.save_presubmission(course_id, assignment_id, exercise_id, user_id, code)
return submission_id
# sql = '''INSERT INTO submissions (course_id, assignment_id, exercise_id, user_id, code, passed, date, partner_id)
# VALUES (?, ?, ?, ?, ?, ?, ?, ?)'''
# submission_id = self.execute(sql, [int(course_id), int(assignment_id), int(exercise_id), user_id, code, passed, date, partner_id])
# #TODO: Execute this all in one transaction
# # https://stackoverflow.com/questions/54289555/how-do-i-execute-an-sqlite-script-from-within-python
# if len(test_outputs) > 0:
# test_sql = '''INSERT INTO test_outputs (test_id, submission_id, txt_output, jpg_output)
# VALUES (?, ?, ?, ?)'''
# for test_title, test_dict in test_outputs.items():
# if test_dict["jpg_output"] != "":
# #if test_dict["jpg_output"].strip() == BLANK_IMAGE.strip():
# if test_dict["jpg_output"].strip() == BLANK_IMAGE:
# test_dict["jpg_output"] = ""
# self.execute(test_sql, [exercise_details["tests"][test_title]["test_id"], submission_id, test_dict["txt_output"], test_dict["jpg_output"]])
# self.save_presubmission(course_id, assignment_id, exercise_id, user_id, code)
# return submission_id
def save_help_request(self, course_id, assignment_id, exercise_id, user_id, code, txt_output, jpg_output, student_comment, date):
sql = '''INSERT INTO help_requests (course_id, assignment_id, exercise_id, user_id, code, txt_output, jpg_output, student_comment, approved, date, more_info_needed)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
self.execute(sql, (course_id, assignment_id, exercise_id, user_id, code, txt_output, jpg_output, student_comment, 0, date, 0,))
def update_help_request(self, course_id, assignment_id, exercise_id, user_id, student_comment):
sql = '''UPDATE help_requests
SET student_comment = ?, more_info_needed = ?, suggestion = ?, approved = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?'''
self.execute(sql, (student_comment, 0, None, 0, course_id, assignment_id, exercise_id, user_id,))
def delete_help_request(self, course_id, assignment_id, exercise_id, user_id):
sql = '''DELETE FROM help_requests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?'''
self.execute(sql, (course_id, assignment_id, exercise_id, user_id,))
def save_help_request_suggestion(self, course_id, assignment_id, exercise_id, user_id, suggestion, approved, suggester_id, approver_id, more_info_needed):
sql = '''UPDATE help_requests
SET suggestion = ?, approved = ?, suggester_id = ?, approver_id = ?, more_info_needed = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?
AND user_id = ?'''
self.execute(sql, (suggestion, approved, suggester_id, approver_id, more_info_needed, course_id, assignment_id, exercise_id, user_id,))
async def copy_course(self, existing_course_basics, new_course_title):
sql = '''INSERT INTO courses (title, introduction, visible, passcode, allow_students_download_submissions, date_created, date_updated)
SELECT ?, introduction, visible, passcode, allow_students_download_submissions, date_created, date_updated
FROM courses
WHERE course_id = ?'''
new_course_id = self.execute(sql, (new_course_title, existing_course_basics['id'],))
for assignment_basics in self.get_assignments(existing_course_basics):
sql = '''INSERT INTO assignments (course_id, title, visible, introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, has_timer, hour_timer, minute_timer, restrict_other_assignments, allowed_ip_addresses, allowed_external_urls)
SELECT ?, title, visible, introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, has_timer, hour_timer, minute_timer, restrict_other_assignments, allowed_ip_addresses, allowed_external_urls
FROM assignments
WHERE course_id = ?
AND assignment_id = ?'''
new_assignment_id = self.execute(sql, (new_course_id, existing_course_basics['id'], assignment_basics[0],))
sql = '''SELECT exercise_id
FROM exercises
WHERE course_id = ?
AND assignment_id = ?'''
old_exercise_ids = [row["exercise_id"] for row in self.fetchall(sql, (existing_course_basics['id'], assignment_basics[0],))]
for exercise_id in old_exercise_ids:
sql = '''INSERT INTO exercises (course_id, assignment_id, title, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight, allow_any_response)
SELECT ?, ?, title, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight, allow_any_response
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
new_exercise_id = self.execute(sql, (new_course_id, new_assignment_id, existing_course_basics['id'], assignment_basics[0], exercise_id))
sql = '''INSERT INTO tests (course_id, assignment_id, exercise_id, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output)
SELECT ?, ?, ?, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output
FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
self.execute(sql, (new_course_id, new_assignment_id, new_exercise_id, existing_course_basics['id'], assignment_basics[0], exercise_id))
sql = '''INSERT INTO permissions (user_id, role, course_id)
SELECT user_id, role, ?
FROM permissions
WHERE course_id = ?'''
self.execute(sql, (new_course_id, existing_course_basics['id'],))
self.update_when_content_updated(new_course_id)
def copy_assignment(self, course_id, assignment_id, new_title):
sql = '''INSERT INTO assignments (course_id, title, visible, introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, has_timer, hour_timer, minute_timer, restrict_other_assignments, allowed_ip_addresses, allowed_external_urls)
SELECT course_id, ?, visible, introduction, date_created, date_updated, start_date, due_date, allow_late, late_percent, view_answer_late, enable_help_requests, has_timer, hour_timer, minute_timer, restrict_other_assignments, allowed_ip_addresses, allowed_external_urls
FROM assignments
WHERE course_id = ?
AND assignment_id = ?'''
new_assignment_id = self.execute(sql, (new_title, course_id, assignment_id,))
sql = '''SELECT exercise_id
FROM exercises
WHERE course_id = ?
AND assignment_id = ?'''
old_exercise_ids = [row["exercise_id"] for row in self.fetchall(sql, (course_id, assignment_id,))]
for exercise_id in old_exercise_ids:
sql = '''INSERT INTO exercises (course_id, assignment_id, title, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight, allow_any_response)
SELECT course_id, ?, title, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight, allow_any_response
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
new_exercise_id = self.execute(sql, (new_assignment_id, course_id, assignment_id, exercise_id))
sql = '''INSERT INTO tests (course_id, assignment_id, exercise_id, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output)
SELECT course_id, ?, ?, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output
FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
self.execute(sql, (new_assignment_id, new_exercise_id, course_id, assignment_id, exercise_id))
self.update_when_content_updated(course_id)
def update_user(self, user_id, user_dict):
self.set_user_dict_defaults(user_dict)
sql = '''UPDATE users
SET name = ?, given_name = ?, family_name = ?, locale = ?, email_address = ?
WHERE user_id = ?'''
self.execute(sql, (user_dict["name"], user_dict["given_name"], user_dict["family_name"], user_dict["locale"], user_dict["email_address"], user_id,))
self.update_when_content_updated("user")
def update_user_settings(self, user_id, theme, use_auto_complete, use_studio_mode, enable_vim):
sql = '''UPDATE users
SET ace_theme = ?, use_auto_complete = ?, use_studio_mode = ?, enable_vim = ?
WHERE user_id = ?'''
self.execute(sql, (theme, use_auto_complete, use_studio_mode, enable_vim, user_id))
self.update_when_content_updated("user")
def remove_user_submissions(self, user_id):
sql = '''SELECT submission_id
FROM submissions
WHERE user_id = ?'''
submissions = self.fetchall(sql, (user_id,))
if submissions:
sql = '''DELETE FROM scores
WHERE user_id = ?'''
self.execute(sql, (user_id,))
sql = '''DELETE FROM submissions
WHERE user_id = ?'''
self.execute(sql, (user_id,))
return True
else:
return False
def delete_user(self, user_id):
sql = '''DELETE FROM users
WHERE user_id = ?'''
self.execute(sql, (user_id,))
self.update_when_content_updated("user")
def move_assignment(self, course_id, assignment_id, new_course_id):
for table in ["assignments", "exercises", "tests"]:
self.execute(f'''UPDATE {table}
SET course_id = ?
WHERE course_id = ?
AND assignment_id = ?''', (new_course_id, course_id, assignment_id))
for table in ["help_requests", "presubmissions", "scores", "submissions", "user_assignment_starts"]:
self.execute(f'''DELETE FROM {table}
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id))
self.update_when_content_updated(course_id)
#TODO: Make this like move_assignment
def move_exercise(self, course_id, assignment_id, exercise_id, new_assignment_id):
self.execute('''UPDATE exercises
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.execute('''UPDATE scores
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.execute('''UPDATE submissions
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.execute('''UPDATE presubmissions
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.execute('''UPDATE scores
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.execute('''UPDATE help_requests
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.execute('''UPDATE tests
SET assignment_id = ?
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (new_assignment_id, course_id, assignment_id, exercise_id, ))
self.update_when_content_updated(course_id)
def copy_exercise(self, course_id, assignment_id, exercise_id, new_title):
try:
sql = '''INSERT INTO exercises (course_id, assignment_id, title, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight, allow_any_response)
SELECT course_id, assignment_id, ?, visible, solution_code, solution_description, hint, max_submissions, credit, data_files, back_end, instructions, output_type, what_students_see_after_success, starter_code, date_created, date_updated, enable_pair_programming, verification_code, weight, allow_any_response
FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
new_exercise_id = self.execute(sql, (new_title, course_id, assignment_id, exercise_id, ))
sql = '''INSERT INTO tests (course_id, assignment_id, exercise_id, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output)
SELECT course_id, assignment_id, ?, title, before_code, after_code, instructions, txt_output, jpg_output, can_see_test_code, can_see_expected_output, can_see_code_output
FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?'''
self.execute(sql, (new_exercise_id, course_id, assignment_id, exercise_id, ))
except:
print(traceback.format_exc())
self.update_when_content_updated(course_id)
#TODO: Clean up all of these delete functions.
def delete_exercise(self, course_id, assignment_id, exercise_id):
self.execute('''DELETE FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM presubmissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM exercises
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM tests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM test_outputs
WHERE submission_id IN (
SELECT submission_id
FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?)''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM help_requests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.update_when_content_updated(course_id)
def delete_assignment(self, assignment_basics):
course_id = assignment_basics["course"]["id"]
assignment_id = assignment_basics["id"]
self.execute('''DELETE FROM tests
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM test_outputs
WHERE submission_id IN (
SELECT submission_id
FROM submissions
WHERE course_id = ?
AND assignment_id = ?)''', (course_id, assignment_id, ))
self.execute('''DELETE FROM presubmissions
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM submissions
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM user_assignment_starts
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM help_requests
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM exercises
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM assignments
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.update_when_content_updated(course_id)
def delete_course(self, course_id):
self.execute('''DELETE FROM presubmissions
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM tests
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM test_outputs
WHERE submission_id IN (
SELECT submission_id
FROM submissions
WHERE course_id = ?)''', (course_id, ))
self.execute('''DELETE FROM submissions
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM exercises
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM assignments
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM courses
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM course_registrations
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM help_requests
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM permissions
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM user_assignment_starts
WHERE course_id = ?''', (course_id, ))
self.delete_content_updated(course_id)
def delete_course_submissions(self, course_id):
self.execute('''DELETE FROM submissions
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM presubmissions
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM help_requests
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM user_assignment_starts
WHERE course_id = ?''', (course_id, ))
self.execute('''DELETE FROM test_outputs
WHERE submission_id IN (
SELECT submission_id
FROM submissions
WHERE course_id = ?)''', (course_id, ))
def delete_assignment_submissions(self, assignment_basics):
course_id = assignment_basics["course"]["id"]
assignment_id = assignment_basics["id"]
self.execute('''DELETE FROM submissions
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM presubmissions
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM help_requests
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM user_assignment_starts
WHERE course_id = ?
AND assignment_id = ?''', (course_id, assignment_id, ))
self.execute('''DELETE FROM test_outputs
WHERE submission_id IN (
SELECT submission_id
FROM submissions
WHERE course_id = ?
AND assignment_id = ?)''', (course_id, assignment_id, ))
async def delete_exercise_submissions(self, course_id, assignment_id, exercise_id):
self.execute('''DELETE FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM scores
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM presubmissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM help_requests
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?''', (course_id, assignment_id, exercise_id, ))
self.execute('''DELETE FROM test_outputs
WHERE submission_id IN (
SELECT submission_id
FROM submissions
WHERE course_id = ?
AND assignment_id = ?
AND exercise_id = ?)''', (course_id, assignment_id, exercise_id, ))
# async def create_course_scores_text(self, course_basics):
# out_file_text = "Assignment_ID\tAssignment_Title\tStudent_ID\tScore\n"
# for assignment_basics in self.get_assignments(course_basics):
# assignment_scores = self.get_assignment_scores(course_basics, assignment_basics)
# for score_dict in assignment_scores:
# out_file_text += f"{assignment_basics['assignment_id']}\t{assignment_basics['title']}\t{score_dict[0]}\t{score_dict[1]['percent_passed']}\n"
# return out_file_text
async def create_assignment_scores_text(self, course_basics, assignment_basics):
#TODO: Save the title(s) rather than ID(s).
out_file_text = "Course\tAssignment\tStudent_ID\tScore\tWhen_Passed\tLast_Submission\n"
scores = self.get_assignment_scores(course_basics, assignment_basics)
course_id = course_basics["title"]
assignment_id = assignment_basics["title"]
for student in scores:
out_file_text += f"{course_id}\t{assignment_id}\t{student[0]}\t{student[1]['percent_passed']}\t{student[1]['when_passed']}\t{student[1]['last_submission_time']}\n"
return out_file_text
# def export_data(self, course_basics, table_name, output_tsv_file_path):
# if table_name == "submissions":
# sql = '''SELECT c.title, a.title, e.title, s.user_id, s.submission_id, s.code, s.txt_output, s.jpg_output, s.passed, s.date
# FROM submissions s
# INNER JOIN courses c
# ON c.course_id = s.course_id
# INNER JOIN assignments a
# ON a.assignment_id = s.assignment_id
# INNER JOIN exercises e
# ON e.exercise_id = s.exercise_id
# WHERE s.course_id = ?'''
#
# else:
# sql = f"SELECT * FROM {table_name} WHERE course_id = ?"
#
# rows = []
# for row in self.fetchall(sql, (course_basics["id"],)):
# row_values = []
# for x in row:
# if type(x) is datetime:
# x = str(x)
# row_values.append(x)
#
# rows.append(row_values)
#
# with open(output_tsv_file_path, "w") as out_file:
# out_file.write(json.dumps(rows))
# def create_zip_file_path(self, descriptor):
# temp_dir_path = "/database/tmp/{}".format(create_id())
# zip_file_name = f"{descriptor}.zip"
# zip_file_path = f"{temp_dir_path}/{zip_file_name}"
# return temp_dir_path, zip_file_name, zip_file_path
#
# def zip_export_files(self, temp_dir_path, zip_file_name, zip_file_path, descriptor):
# os.system(f"cp ../VERSION {temp_dir_path}/{descriptor}/")
# os.system(f"cd {temp_dir_path}; zip -r -qq {zip_file_path} .")
#
# def create_export_paths(self, temp_dir_path, descriptor):
# os.makedirs(temp_dir_path)
# os.makedirs(f"{temp_dir_path}/{descriptor}")
#
# def remove_export_paths(self, zip_file_path, tmp_dir_path):
# if os.path.exists(zip_file_path):
# os.remove(zip_file_path)
#
# if os.path.exists(tmp_dir_path):
# shutil.rmtree(tmp_dir_path, ignore_errors=True)
async def get_student_pairs(self, course_id, user_name):
# Uses the week of the year as a seed.
seed = datetime.utcnow().isocalendar().week
# Gets student names registered in a course (will add obscured emails to the end of the name in the case of duplicate names)
students = list(self.get_partner_info(course_id, False).keys())
# Randomizes students using seed
random.Random(seed).shuffle(students)
if len(students) == 0:
pairs = []
elif len(students) % 2 == 0:
pairs = [[students[i], students[i + 1]] for i in range(0, len(students), 2)]
else:
# Create pairs for everyone except the last student.
pairs = [[students[i], students[i + 1]] for i in range(0, len(students) - 1, 2)]
# This code creates a trio.
#pairs[-1].append(students[-1])
# This code puts one person on their own.
pairs.extend([[students[-1]]])
# Indicates which pair the user is in.
pairs = [{'is_user': True, 'pair': pair} if user_name in pair else {'is_user': False, 'pair': pair} for pair in pairs]
return pairs
def get_next_prev_student_ids(self, course_id, student_id):
sql = '''SELECT u.user_id
FROM users u
INNER JOIN course_registrations cr
ON u.user_id = cr.user_id
WHERE cr.course_id = ?
ORDER BY u.name'''
user_ids = [row["user_id"] for row in self.fetchall(sql, (course_id, ))]
student_index = user_ids.index(student_id)
prev_student_id = None
next_student_id = None
if student_index > 0:
prev_student_id = user_ids[student_index - 1]
if student_index < len(user_ids) - 1:
next_student_id = user_ids[student_index + 1]
return prev_student_id, next_student_id
def get_submissions_student(self, course_id, student_id):
sql = '''SELECT a.title AS assignment_title,
a.introduction AS assignment_introduction,
e.title AS exercise_title,
e.instructions AS exercise_instructions,
s.code,
max(s.date)
FROM submissions s
INNER JOIN exercises e
ON s.exercise_id = e.exercise_id
INNER JOIN assignments a
ON s.assignment_id = a.assignment_id
WHERE s.course_id = ?
AND s.user_id = ?
AND s.passed = 1
AND e.visible = 1
AND a.visible = 1
AND a.has_timer = 0
AND e.back_end != "not_code"
GROUP BY a.assignment_id, e.exercise_id'''
submissions = []
for row in self.fetchall(sql, (course_id, student_id,)):
submission = {}
for x in ["assignment_title", "assignment_introduction", "exercise_title", "exercise_instructions", "code"]:
submission[x] = row[x]
submissions.append(submission)
return sort_list_of_dicts_nicely(submissions, ["assignment_title", "exercise_title"]) | [] |
2024-01-10 | ckak912/CodeBuddy_LLM | front_end~server~webserver.py | import contextvars
import logging
import os
import sys
import traceback
from datetime import datetime
from distutils.log import debug
import tornado.ioloop
import ui_methods
from concurrent_log_handler import ConcurrentRotatingFileHandler
from content import *
from handlers import *
from helper import *
from tornado.auth import GoogleOAuth2Mixin
from tornado.web import *
class BaseHandler(RequestHandler):
def set_default_headers(self):
self.set_header("Access-Control-Allow-Origin", "https://api.openai.com") # Only allow from openAI domain
self.set_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
self.set_header("Access-Control-Allow-Headers", "Content-Type, Authorization")
def make_app(settings_dict):
app = Application(
[
url(r"/", HomeHandler),
url(r"/add_admin/([^/]+)", AddAdminHandler, name="add_admin"),
url(r"/add_assistant/([^/]+)/([^/]+)", AddAssistantHandler, name="add_assistant"),
url(r"/add_instructor/([^/]+)/([^/]+)", AddInstructorHandler, name="add_instructor"),
url(r"/assignment/([^/]+)/([^/]+)", AssignmentHandler, name="assignment"),
url(r"/available", AvailableCoursesHandler, name="available"),
url(r"/caslogin", CASLoginHandler, name="caslogin"),
url(r"/create_video_exercise/([^/]+)/([^/]+)", CreateVideoExerciseHandler, name="create_video_exercise"),
url(r"/copy_assignment/([^/]+)/([^/]+)?", CopyAssignmentHandler, name="copy_assignment"),
url(r"/copy_course/([^/]+)", CopyCourseHandler, name="copy_course"),
url(r"/copy_exercise/([^/]+)/([^/]+)/([^/]+)?", CopyExerciseHandler, name="copy_exercise"),
url(r"/course/([^/]+)", CourseHandler, name="course"),
url(r"/courses", CoursesHandler, name="courses"),
url(r"/delete_assignment/([^/]+)/([^/]+)?", DeleteAssignmentHandler, name="delete_assignment"),
url(r"/delete_assignment_submissions/([^/]+)/([^/]+)?", DeleteAssignmentSubmissionsHandler, name="delete_assignment_submissions"),
url(r"/delete_course/([^/]+)?", DeleteCourseHandler, name="delete_course"),
url(r"/delete_course_submissions/([^/]+)?", DeleteCourseSubmissionsHandler, name="delete_course_submissions"),
url(r"/delete_exercise/([^/]+)/([^/]+)/([^/]+)?", DeleteExerciseHandler, name="delete_exercise"),
url(r"/delete_exercise_submissions/([^/]+)/([^/]+)/([^/]+)?", DeleteExerciseSubmissionsHandler, name="delete_exercise_submissions"),
url(r"/delete_request/([^/]+)/([^/]+)/([^/]+)/([^/]+)", DeleteHelpRequestHandler, name="delete_request"),
url(r"/devlogin", DevelopmentLoginHandler, name="devlogin"),
url(r"/diff", DiffHandler, name="diff"),
url(r"/download_assignment_scores/([^/]+)/([^/]+)", DownloadAssignmentScoresHandler, name="download_assignment_scores"),
url(r"/download_file/([^/]+)/([^/]+)/([^/]+)/([^/]+)", DownloadFileHandler, name="download_file"),
url(r"/download_submissions_student/([^/]+)", DownloadSubmissionsStudentHandler, name="download_submissions_student"),
url(r"/edit_assignment/([^/]+)/([^/]+)?", EditAssignmentHandler, name="edit_assignment"),
url(r"/edit_assignment_scores/([^/]+)/([^/]+)/([^/]+)", EditAssignmentScoresHandler, name="edit_assignment_scores"),
url(r"/edit_course/([^/]+)?", EditCourseHandler, name="edit_course"),
url(r"/edit_exercise/([^/]+)/([^/]+)/([^/]+)?", EditExerciseHandler, name="edit_exercise"),
url(r"/exercise/([^/]+)/([^/]+)/([^/]+)", ExerciseHandler, name="exercise"),
url(r"/exercise_feedback/([^/]+)/([^/]+)/([^/]+)", FeedbackHandler, name="exercise_feedback"),
url(r"/exercise_hint_code/([^/]+)/([^/]+)/([^/]+)", HintCodeHandler, name="exercise_hint_code"),
url(r"/exercise_pseudo_code/([^/]+)/([^/]+)/([^/]+)", PseudoHandler, name="exercise_pseudo_code"),
url(r"/exercise_submissions/([^/]+)/([^/]+)/([^/]+)", ExerciseSubmissionsHandler, name="exercise_submissions"),
url(r"/export_assignment/([^/]+)/([^/]+)", ExportAssignmentHandler, name="export_assignment"),
url(r"/external/([^/]+)/([^/]+)/(.+)", ExternalSiteHandler, name="external"),
url(r"/get_partner_id/([^/]+)/([^/]+)", GetPartnerIDHandler, name="get_partner_id"),
url(r"/googlelogin", GoogleLoginHandler, name="googlelogin"),
url(r"/help_requests/([^/]+)", HelpRequestsHandler, name="help_requests"),
url(r"/import_assignment/([^/]+)", ImportAssignmentHandler, name="import_assignment"),
url(r"/is_taking_restricted_assignment/([^/]+)/([^/]+)", IsTakingRestrictedAssignmentHandler, name="is_taking_restricted_assignment"),
url(r"/login", LoginHandler, name="login"),
url(r"/logout", LogoutHandler, name="logout"),
url(r"/manage_admins", ManageAdminsHandler, name="manage_admins"),
url(r"/manage_assistants/([^/]+)", ManageAssistantsHandler, name="manage_assistants"),
url(r"/manage_instructors/([^/]+)", ManageInstructorsHandler, name="manage_instructors"),
url(r"/manage_students/([^/]+)", ManageStudentsHandler, name="manage_students"),
url(r"/manage_users", ManageUsersHandler, name="manage_users"),
url(r"/move_assignment/([^/]+)/([^/]+)", MoveAssignmentHandler, name="move_assignment"),
url(r"/move_exercise/([^/]+)/([^/]+)/([^/]+)?", MoveExerciseHandler, name="move_exercise"),
# url(r"/profile/help_requests", ProfileHelpRequestsHandler, name="profile_help_requests"),
url(r"/personal_info/([^/]+)", PersonalInfoHandler, name="personal_info"),
url(r"/preferences/([^/]+)", PreferencesHandler, name="preferences"),
# url(r"/profile/student_help_requests", ProfileStudentHelpRequestsHandler, name="profile_student_help_requests"),
url(r"/register/([^/]+)/([^/]+)/([^/]+)", RegisterHandler, name="register"),
url(r"/remove_admin", RemoveAdminHandler, name="remove_admin"),
url(r"/remove_assistant/([^/]+)/([^/]+)", RemoveAssistantHandler, name="remove_assistant"),
url(r"/remove_instructor/([^/]+)/([^/]+)", RemoveInstructorHandler, name="remove_instructor"),
url(r"/resave_exercises/([^/]+)/([^/]+)", ResaveExercisesHandler, name="resave_exercises"),
url(r"/reset_timer/([^/]+)/([^/]+)/([^/]+)", ResetTimerHandler, name="reset_timer"),
url(r"/run_code/([^/]+)/([^/]+)/([^/]+)", RunCodeHandler, name="run_code"),
url(r"/save_presubmission/([^/]+)/([^/]+)/([^/]+)", SavePresubmissionHandler, name="save_presubmission"),
url(r"/static/(.+)", StaticFileHandler, name="static_file"),
url(r"/student_exercise/([^/]+)/([^/]+)/([^/]+)/([^/]+)", StudentExerciseHandler, name="student_exercise"),
url(r"/submit/([^/]+)/([^/]+)/([^/]+)", SubmitHandler, name="submit"),
url(r"/submit_request/([^/]+)/([^/]+)/([^/]+)", SubmitHelpRequestHandler, name="submit_request"),
url(r"/summarize_logs", SummarizeLogsHandler, name="summarize_logs"),
url(r"/test", TestHandler, name="test"),
url(r"/unregister/([^/]+)/([^/]+)", UnregisterHandler, name="unregister"),
url(r"/unavailable_exercise/([^/]+)/([^/]+)", UnavailableExerciseHandler, name="unavailable_exercise"),
url(r"/view_instructor_solution/([^/]+)/([^/]+)/([^/]+)", ViewInstructorSolutionHandler, name="view_instructor_solution"),
url(r"/view_peer_solution/([^/]+)/([^/]+)/([^/]+)", ViewPeerSolutionHandler, name="view_peer_solution"),
url(r"/view_request/([^/]+)/([^/]+)/([^/]+)/([^/]+)", ViewHelpRequestsHandler, name="view_request"),
url(r"/view_assignment_scores/([^/]+)/([^/]+)", ViewAssignmentScoresHandler, name="view_assignment_scores"),
url(r"/view_exercise_scores/([^/]+)/([^/]+)/([^/]+)", ViewExerciseScoresHandler, name="view_exercise_scores"),
url(r"/view_student_assignment_scores/([^/]+)/([^/]+)", ViewStudentAssignmentScoresHandler, name="view_student_assignment_scores")
],
default_handler_class=BaseHandler,
autoescape=None,
debug=(int(settings_dict["f_num_processes"]) == 1 and 'DEBUG' in os.environ and os.environ['DEBUG'] == 'true'),
ui_methods=ui_methods
)
# Debugging doesn't seem to work on MacOS when running with two processes (https://github.com/tornadoweb/tornado/issues/2426)
app.settings['template_path'] = os.path.join(os.path.dirname(__file__), "html")
return app
class StaticFileHandler(BaseHandler):
async def get(self, file_name):
if file_name.endswith(".html"):
try:
self.render(file_name)
except Exception as inst:
render_error(self, traceback.format_exc())
else:
content_type = "text/css"
read_mode = "r"
if file_name.endswith(".js"):
content_type = "text/javascript"
elif file_name.endswith(".png"):
content_type = "image/png"
read_mode = "rb"
elif file_name.endswith(".ico"):
content_type = "image/x-icon"
read_mode = "rb"
elif file_name.endswith(".ttf"):
content_type = "font/ttf"
read_mode = "rb"
elif file_name.endswith(".webmanifest"):
content_type = "application/json"
elif file_name.endswith(".json"):
content_type = "application/json"
file_contents = read_file("static/{}".format(file_name), mode=read_mode)
self.set_header('Content-type', content_type)
self.write(file_contents)
if __name__ == "__main__":
try:
settings_dict = load_yaml_dict(read_file("../Settings.yaml"))
content = Content(settings_dict)
database_version = content.get_database_version()
code_version = int(read_file("../VERSION").rstrip())
if database_version != code_version:
print(f"Current database version: {database_version}")
print(f"Current code version: {code_version}")
# Check to see whether there is a database migration script (should only be one per version).
# If so, make a backup copy of the database and then do the migration.
for v in range(database_version, code_version):
migration = f"{v}_to_{v + 1}"
print(f"Checking database status for version {v+1}...")
if os.path.isfile(f"migration_scripts/{migration}.py"):
command = f"python migration_scripts/{migration}.py"
else:
command = f"python migration_scripts/migrate.py {migration}"
result = run_command(command)
if "***NotNeeded***" in result:
print("Database migration not needed.")
if ((v + 1) == code_version):
content.update_database_version(v + 1)
elif "***Success***" in result:
print(f"Database successfully migrated to version {v+1}")
content.update_database_version(v + 1)
else:
print(f"Database migration failed for version {v+1}...")
print(result)
sys.exit(1)
# Clean some stuff in the database
content.delete_old_presubmissions()
application = make_app(settings_dict)
if settings_dict["mode"] == "development":
server = tornado.httpserver.HTTPServer(application, max_header_size=1048576)
else:
server = tornado.httpserver.HTTPServer(application, max_header_size=1048576, ssl_options={
"certfile": "/certs/cert.crt",
"keyfile": "/certs/cert.key",
})
secrets_dict = load_yaml_dict(read_file("secrets/front_end.yaml"))
application.settings["cookie_secret"] = secrets_dict["cookie"]
application.settings["google_oauth"] = {
"key": secrets_dict["google_oauth_key"],
"secret": secrets_dict["google_oauth_secret"]
}
server.bind(int(settings_dict["f_port"]))
server.start(int(settings_dict["f_num_processes"]))
# Set up logging
log_level = logging.INFO
if settings_dict["mode"] == "development":
log_level = logging.DEBUG
log_file_handler = ConcurrentRotatingFileHandler("logs/codebuddy.log", maxBytes=100*1024*1024, backupCount=10, encoding="utf-8", mode="a")
logging.basicConfig(
handlers=[log_file_handler],
level=log_level,
format="[%(asctime)s] %(message)s",
datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger('codebuddy_logger')
logger.addHandler(log_file_handler)
logging.getLogger('tornado.access').disabled = True
logging.getLogger("requests").setLevel(logging.DEBUG)
logging.debug(f"Starting on port {settings_dict['f_port']} using {settings_dict['f_num_processes']} processes")
tornado.ioloop.IOLoop.instance().start()
except Exception as inst:
print(traceback.format_exc())
logging.error(traceback.format_exc())
sys.exit(1) | [] |
2024-01-10 | BaBaTi07/ProjetDataSciencesGroupe3 | AidePourTous~app~chatBot.py | from openai import OpenAI
client = OpenAI(
)
completion = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content": "Je suis un assistant social virtuel qui doit dresser le profil d'un utilisateur, en lui posant des questions sur son logement, sa famille, ses resources. Je m'exprime avec des messages court mais en restant le plus humain possible. A la fin de chaque message j'integre toujours apres le tag $data$ toutes les rubrique qui interesse mon client parmis les suivante : formation, logement, aides finacieres, alimentation."
},
{
"role": "user",
"content": "bonjour, je suis un jeune de 20 ans, je suis étudiant et j'aimerais trouver des aides au logement et a l'alimentation"
},
],
)
print(completion.choices[0].message) | [
"Je suis un assistant social virtuel qui doit dresser le profil d'un utilisateur, en lui posant des questions sur son logement, sa famille, ses resources. Je m'exprime avec des messages court mais en restant le plus humain possible. A la fin de chaque message j'integre toujours apres le tag $data$ toutes les rubrique qui interesse mon client parmis les suivante : formation, logement, aides finacieres, alimentation.",
"bonjour, je suis un jeune de 20 ans, je suis étudiant et j'aimerais trouver des aides au logement et a l'alimentation"
] |
2024-01-10 | Madhav-MKNC/admin-portal | utils~manage_vectordb.py | # author: Madhav (https://github.com/madhav-mknc)
# managing the Pinecone vector database
import json
from utils.chatbot import index, index_name, NAMESPACE, embeddings
from utils.chatbot import get_response
from langchain.vectorstores import Pinecone
from langchain.document_loaders import (
PyMuPDFLoader,
TextLoader,
Docx2txtLoader,
CSVLoader,
WebBaseLoader
)
from langchain.text_splitter import CharacterTextSplitter
############## HELPER FUNCTIONS ##############
# function used for debugging
x_x_x = 0
def mknc(text=''):
global x_x_x
print("\033[31m", x_x_x, "\033[96m", text, "\u001b[37m")
x_x_x += 1
# listing of files available in the db
TOTAL_IDS = ".stored_files.json"
# reading list
def read_all_files():
with open(TOTAL_IDS, "r") as json_file:
files = json.load(json_file)
return list(files)
# overwriting list
def write_all_files(files):
with open(TOTAL_IDS, "w") as json_file:
json.dump(files, json_file)
# updating list
def update_read_all_files_list(add_file="", remove_file=""):
files = read_all_files()
if add_file:
files.append(add_file)
if remove_file:
files.remove(remove_file)
write_all_files(files)
############## Documents ##############
# load and split documents
def load_and_split_document(file_path, isurl=False):
file_extension = file_path.split('.')[-1].lower()
if isurl:
url = file_path
print(url)
loader = WebBaseLoader(url)
elif file_extension == "txt":
loader = TextLoader(file_path)
elif file_extension == "pdf":
loader = PyMuPDFLoader(file_path)
elif file_extension == "doc" or file_extension == "docx":
loader = Docx2txtLoader(file_path)
elif file_extension == "csv":
loader = CSVLoader(file_path)
else:
raise TypeError("filetype not in [pdf, txt, doc, docx, csv]")
doc = loader.load()
docs = CharacterTextSplitter(chunk_size=512, chunk_overlap=1).split_documents(doc)
return docs
############## INDEXING ##############
# Upload a file to the db
def add_file(file_name, isurl=False):
# checking if this file already exists
files = read_all_files()
if file_name in files:
status = f"{file_name} already exists"
return status
docs = load_and_split_document(file_name, isurl=isurl)
texts = []
metadatas = []
ids = []
for i, doc in enumerate(docs):
texts.append(doc.page_content)
metadatas.append({'source': file_name})
ids.append(file_name+str(i))
res = Pinecone.from_texts(
index_name=index_name,
texts=texts,
embedding=embeddings,
batch_size=100,
namespace=NAMESPACE,
metadatas=metadatas,
ids=ids
)
# save total no. of vectors for this file
update_read_all_files_list(add_file=file_name)
status = "ok"
return status
# Delete all the vectors for a specific file specified by metadata from the db
def delete_file(file):
index.delete(
filter={
"source": {
"$eq": file
}
},
namespace=NAMESPACE,
delete_all=False
)
# update files list (which is maintained locally)
update_read_all_files_list(remove_file=file)
# deletes the namespace
def reset_index():
index.delete(
namespace=NAMESPACE,
delete_all=True
)
# update files list (which is maintained locally)
write_all_files(files=[])
# list source files
def list_files():
# stats = index.describe_index_stats()
# sources = stats["namespaces"]
sources = read_all_files()
return sources
############## CHATBOT ##############
# command line interface for bot
def cli_run():
try:
while True:
query = input("\033[0;39m\n[HUMAN] ").strip()
if query == ".stats":
print("\033[93m[SYSTEM]",index.describe_index_stats())
elif query == ".reset_index":
reset_index()
print("\033[93m[SYSTEM] deleting index...")
elif query == ".exit":
print("\033[93m[SYSTEM] exitting...")
return
elif query:
response = get_response(query)
print("\033[0;32m[AI]",response)
else:
pass
except KeyboardInterrupt:
print("\033[31mStopped")
print("\u001b[37m")
if __name__ == "__main__":
cli_run() | [] |
2024-01-10 | Madhav-MKNC/admin-portal | test~check_tokens.py | # /temp /test scripts
import asyncio
from langchain.callbacks import get_openai_callback
from langchain.llms import OpenAI
llm = OpenAI(temperature=0)
with get_openai_callback() as cb:
llm("What is the square root of 4?")
total_tokens = cb.total_tokens
assert total_tokens > 0
with get_openai_callback() as cb:
llm("What is the square root of 4?")
llm("What is the square root of 4?")
assert cb.total_tokens == total_tokens * 2
# You can kick off concurrent runs from within the context manager
with get_openai_callback() as cb:
await asyncio.gather(
*[llm.agenerate(["What is the square root of 4?"]) for _ in range(3)]
)
assert cb.total_tokens == total_tokens * 3
# The context manager is concurrency safe
task = asyncio.create_task(llm.agenerate(["What is the square root of 4?"]))
with get_openai_callback() as cb:
await llm.agenerate(["What is the square root of 4?"])
await task
assert cb.total_tokens == total_tokens | [] |
2024-01-10 | vijaybala-db/databricks-goodies | llm-dolly-chatbot~_resources~00-init.py | # Databricks notebook source
# MAGIC %md
# MAGIC # init notebook setting up the backend.
# MAGIC
# MAGIC Do not edit the notebook, it contains import and helpers for the demo
# MAGIC
# MAGIC <!-- Collect usage data (view). Remove it to disable collection. View README for more details. -->
# MAGIC <img width="1px" src="https://www.google-analytics.com/collect?v=1>m=GTM-NKQ8TT7&tid=UA-163989034-1&aip=1&t=event&ec=dbdemos&ea=VIEW&dp=%2F_dbdemos%2Fdata-science%2Fllm-dolly-chatbot%2F_resources%2F00-init&cid=1444828305810485&uid=5984929097066099">
# COMMAND ----------
dbutils.widgets.text("catalog", "hive_metastore", "Catalog")
dbutils.widgets.text("db", "dbdemos_llm", "Database")
catalog = dbutils.widgets.get("catalog")
db = dbutils.widgets.get("db")
db_name = db
import pyspark.sql.functions as F
from pyspark.sql.functions import col, udf, length, pandas_udf
# COMMAND ----------
# MAGIC %run ./00-global-setup $reset_all_data=false $catalog=$catalog $db=$db
# COMMAND ----------
import gc
from pyspark.sql.functions import pandas_udf
import pandas as pd
from typing import Iterator
import torch
#Make sure we clean the memory
try:
torch.cuda.empty_cache()
from numba import cuda
cuda.get_current_device().reset()
except Exception as e:
print(f"Couldn't clean the memory: {e}")
demo_path = "/dbdemos/product/llm"
# Cache our model to dbfs to avoid loading them everytime
hugging_face_cache = "/dbfs"+demo_path+"/cache/hf"
import os
os.environ['TRANSFORMERS_CACHE'] = hugging_face_cache
# Test available GPUS
def get_available_gpus():
from tensorflow.python.client import device_lib
local_device_protos = device_lib.list_local_devices()
return [x.name for x in local_device_protos if x.device_type == 'GPU']
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## Temp fix to support custom HF model as summarization task
# MAGIC
# MAGIC see [https://github.com/hwchase17/langchain/pull/3009](https://github.com/hwchase17/langchain/pull/3009) for more details
# COMMAND ----------
"""Wrapper around HuggingFace Pipeline APIs."""
import importlib.util
import logging
from typing import Any, List, Mapping, Optional
from pydantic import Extra
from langchain.llms.base import LLM
from langchain.llms.utils import enforce_stop_tokens
DEFAULT_MODEL_ID = "gpt2"
DEFAULT_TASK = "text-generation"
VALID_TASKS = ("text2text-generation", "text-generation", "summarization")
logger = logging.getLogger()
class HuggingFacePipeline_WithSummarization(LLM):
"""Wrapper around HuggingFace Pipeline API.
To use, you should have the ``transformers`` python package installed.
Only supports `text-generation` and `text2text-generation` for now.
Example using from_model_id:
.. code-block:: python
from langchain.llms import HuggingFacePipeline
hf = HuggingFacePipeline.from_model_id(
model_id="gpt2", task="text-generation"
)
Example passing pipeline in directly:
.. code-block:: python
from langchain.llms import HuggingFacePipeline
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
model_id = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
pipe = pipeline(
"text-generation", model=model, tokenizer=tokenizer, max_new_tokens=10
)
hf = HuggingFacePipeline(pipeline=pipe)
"""
pipeline: Any #: :meta private:
model_id: str = DEFAULT_MODEL_ID
"""Model name to use."""
model_kwargs: Optional[dict] = None
"""Key word arguments to pass to the model."""
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
@classmethod
def from_model_id(
cls,
model_id: str,
task: str,
device: int = -1,
model_kwargs: Optional[dict] = None,
**kwargs: Any,
) -> LLM:
"""Construct the pipeline object from model_id and task."""
try:
from transformers import (
AutoModelForCausalLM,
AutoModelForSeq2SeqLM,
AutoTokenizer,
)
from transformers import pipeline as hf_pipeline
except ImportError:
raise ValueError(
"Could not import transformers python package. "
"Please install it with `pip install transformers`."
)
_model_kwargs = model_kwargs or {}
tokenizer = AutoTokenizer.from_pretrained(model_id, **_model_kwargs)
try:
if task == "text-generation":
model = AutoModelForCausalLM.from_pretrained(model_id, **_model_kwargs)
elif task == "text2text-generation" or task == "summarization":
model = AutoModelForSeq2SeqLM.from_pretrained(model_id, **_model_kwargs)
else:
raise ValueError(
f"Got invalid task {task}, "
f"currently only {VALID_TASKS} are supported"
)
except ImportError as e:
raise ValueError(
f"Could not load the {task} model due to missing dependencies."
) from e
if importlib.util.find_spec("torch") is not None:
import torch
cuda_device_count = torch.cuda.device_count()
if device < -1 or (device >= cuda_device_count):
raise ValueError(
f"Got device=={device}, "
f"device is required to be within [-1, {cuda_device_count})"
)
if device < 0 and cuda_device_count > 0:
logger.warning(
"Device has %d GPUs available. "
"Provide device={deviceId} to `from_model_id` to use available"
"GPUs for execution. deviceId is -1 (default) for CPU and "
"can be a positive integer associated with CUDA device id.",
cuda_device_count,
)
pipeline = hf_pipeline(
task=task,
model=model,
tokenizer=tokenizer,
device=device,
model_kwargs=_model_kwargs,
)
if pipeline.task not in VALID_TASKS:
raise ValueError(
f"Got invalid task {pipeline.task}, "
f"currently only {VALID_TASKS} are supported"
)
return cls(
pipeline=pipeline,
model_id=model_id,
model_kwargs=_model_kwargs,
**kwargs,
)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {
**{"model_id": self.model_id},
**{"model_kwargs": self.model_kwargs},
}
@property
def _llm_type(self) -> str:
return "huggingface_pipeline"
def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
response = self.pipeline(prompt)
if self.pipeline.task == "text-generation":
# Text generation return includes the starter text.
text = response[0]["generated_text"][len(prompt) :]
elif self.pipeline.task == "text2text-generation":
text = response[0]["generated_text"]
elif self.pipeline.task == "summarization":
text = response[0]["summary_text"]
else:
raise ValueError(
f"Got invalid task {self.pipeline.task}, "
f"currently only {VALID_TASKS} are supported"
)
if stop is not None:
# This is a bit hacky, but I can't figure out a better way to enforce
# stop tokens when making calls to huggingface_hub.
text = enforce_stop_tokens(text, stop)
return text
# COMMAND ----------
import warnings
with warnings.catch_warnings():
warnings.simplefilter('ignore', SyntaxWarning)
warnings.simplefilter('ignore', DeprecationWarning)
warnings.simplefilter('ignore', UserWarning)
| [] |
2024-01-10 | vijaybala-db/databricks-goodies | role-based-advisor~advisor.py | import os, json
from langchain.llms import Databricks, OpenAI
from dotenv import load_dotenv
from langchain.prompts import ChatPromptTemplate
class RoleBasedAdvisor:
def __init__(self, language_model='openai', config_file_path=None):
self.template_string = """{role_name} \
Respond to the user question that is delimited in triple backticks \
with thoughtful and concise instructions that the user can easily implement in their \
day to day life.
user_question: ```{user_question}```
"""
self.role_description = {}
self.role_description['doctor'] = """You are a doctor (primary care physician) with 25 years of experience practicing in California. \
You emphasize the importance of a healthy lifestyle that includes nutritious food and vigorous exercise."""
self.role_description['father'] = """You are the user's father and cares deeply about their well being. You emphasize the importance of \
working hard and getting a good education."""
self.role_description['business_partner'] = """You are the user's business partner. You share a mutual interest in the success of your \
company. You emphasize actions that will maximize the long term viability and profitability of the company and achieving its mission."""
self.role_description['career_coach'] = """You are the user's manager at work. You see great potential in the user to progress in their \
career. You emphasize actions that maximize the user's chances for a promotion and continue their trajectory to become a senior executive."""
self.user_question = "I want to live a life that maximizes happiness and creates a positive impact on the world. What \
are the top 5 things I should do in the next week towards these goals?"
self.language_model = language_model
if config_file_path is not None:
with open(config_file_path) as f:
self.config = json.load(f)
self.llm = self.get_llm(language_model)
def get_llm(self, language_model='openai'):
load_dotenv()
if 'DATABRICKS_RUNTIME_VERSION' in os.environ and language_model == 'openai': # Running in Databricks
if 'OPENAI_API_KEY' not in os.environ:
os.environ['OPENAI_API_KEY'] = dbutils.secrets.get('vbalasu', 'openai-databricks')
if language_model == 'openai':
llm = OpenAI(temperature=0.0, max_tokens=500)
return llm
elif language_model == 'llamav2':
llm = Databricks(cluster_driver_port=self.config['port'], cluster_id=self.config['cluster_id'],
model_kwargs={'temperature':0.0, 'max_new_tokens':500})
return llm
else:
print('Unknown language model')
return False
def answer_as_role(self, user_question, role, verbose=False):
prompt_template = ChatPromptTemplate.from_template(self.template_string)
prompt = prompt_template.format_prompt(role_name=role, user_question=user_question)
question = prompt.messages[0].content
if verbose:
print('/*\n', f'LANGUAGE MODEL: {self.language_model}\n\n', question, '*/\n\n')
return self.llm(question) | [] |
2024-01-10 | vijaybala-db/databricks-goodies | role-based-advisor~01-role-based-advisor.py | # Databricks notebook source
# MAGIC %md
# MAGIC ## Role-based Advisor
# MAGIC
# MAGIC This notebook demonstrates how to build a role-based advisor using a large language model. The AI can play a role such as the following:
# MAGIC
# MAGIC - Doctor
# MAGIC - Father
# MAGIC - Business partner
# MAGIC - Career coach
# MAGIC
# MAGIC The user can ask a question such as the following:
# MAGIC ```
# MAGIC I want to live a life that maximizes happiness and creates a positive impact on the world.
# MAGIC What are the top 5 things I should do in the next week towards these goals?
# MAGIC ```
# MAGIC
# MAGIC and receive answers from each role's perspective. By asking the same question to multiple language models (OpenAI and Llama V2 in this case), it becomes possible to compare their relative performance.
# COMMAND ----------
import openai, os
from langchain.llms import Databricks, OpenAI
# COMMAND ----------
def switch_to_language_model(language_model):
if language_model == 'openai':
os.environ['OPENAI_API_KEY'] = dbutils.secrets.get('vbalasu', 'openai-databricks')
llm = OpenAI(temperature=0.0, max_tokens=500)
return llm
elif language_model == 'llamav2':
llm = Databricks(cluster_driver_port=7777, cluster_id='0822-051246-6h0nnn2l',
model_kwargs={'temperature':0.0, 'max_new_tokens':500})
return llm
else:
print('Unknown language model')
return False
# COMMAND ----------
template_string = """{role_name} \
Respond to the user question that is delimited in triple backticks \
with thoughtful and concise instructions that the user can easily implement in their \
day to day life.
user_question: ```{user_question}```
"""
# COMMAND ----------
role_doctor = """You are a doctor (primary care physician) with 25 years of experience practicing in California. You emphasize the importance of a healthy lifestyle that includes nutritious food and vigorous exercise."""
role_father = """You are the user's father and cares deeply about their well being. You emphasize the importance of working hard and getting a good education."""
role_business_partner = """You are the user's business partner. You share a mutual interest in the success of your company. You emphasize actions that will maximize the long term viability and profitability of the company and achieving its mission."""
role_career_coach = """You are the user's manager at work. You see great potential in the user to progress in their career. You emphasize actions that maximize the user's chances for a promotion and continue their trajectory to become a senior executive."""
user_question = "I want to live a life that maximizes happiness and creates a positive impact on the world. What are the top 5 things I should do in the next week towards these goals?"
# COMMAND ----------
from langchain.prompts import ChatPromptTemplate
def answer_as_role(user_question, role, verbose=False):
prompt_template = ChatPromptTemplate.from_template(template_string)
prompt = prompt_template.format_prompt(role_name=role, user_question=user_question)
question = prompt.messages[0].content
if verbose:
print('/*\n', f'LANGUAGE MODEL: {language_model}\n\n', question, '*/\n\n')
return llm(question)
# COMMAND ----------
displayHTML("""<svg width="200px" viewBox="0 0 1180 320" xmlns="http://www.w3.org/2000/svg"><path d="m367.44 153.84c0 52.32 33.6 88.8 80.16 88.8s80.16-36.48 80.16-88.8-33.6-88.8-80.16-88.8-80.16 36.48-80.16 88.8zm129.6 0c0 37.44-20.4 61.68-49.44 61.68s-49.44-24.24-49.44-61.68 20.4-61.68 49.44-61.68 49.44 24.24 49.44 61.68z"/><path d="m614.27 242.64c35.28 0 55.44-29.76 55.44-65.52s-20.16-65.52-55.44-65.52c-16.32 0-28.32 6.48-36.24 15.84v-13.44h-28.8v169.2h28.8v-56.4c7.92 9.36 19.92 15.84 36.24 15.84zm-36.96-69.12c0-23.76 13.44-36.72 31.2-36.72 20.88 0 32.16 16.32 32.16 40.32s-11.28 40.32-32.16 40.32c-17.76 0-31.2-13.2-31.2-36.48z"/><path d="m747.65 242.64c25.2 0 45.12-13.2 54-35.28l-24.72-9.36c-3.84 12.96-15.12 20.16-29.28 20.16-18.48 0-31.44-13.2-33.6-34.8h88.32v-9.6c0-34.56-19.44-62.16-55.92-62.16s-60 28.56-60 65.52c0 38.88 25.2 65.52 61.2 65.52zm-1.44-106.8c18.24 0 26.88 12 27.12 25.92h-57.84c4.32-17.04 15.84-25.92 30.72-25.92z"/><path d="m823.98 240h28.8v-73.92c0-18 13.2-27.6 26.16-27.6 15.84 0 22.08 11.28 22.08 26.88v74.64h28.8v-83.04c0-27.12-15.84-45.36-42.24-45.36-16.32 0-27.6 7.44-34.8 15.84v-13.44h-28.8z"/><path d="m1014.17 67.68-65.28 172.32h30.48l14.64-39.36h74.4l14.88 39.36h30.96l-65.28-172.32zm16.8 34.08 27.36 72h-54.24z"/><path d="m1163.69 68.18h-30.72v172.32h30.72z"/><path d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>""")
# COMMAND ----------
language_model = 'openai'
llm = switch_to_language_model(language_model)
# COMMAND ----------
displayHTML("""<h2>Doctor</h2><br>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg version="1.1" id="_x32_" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
width="150px" height="150px" viewBox="0 0 512 512" xml:space="preserve">
<style type="text/css">
<![CDATA[
.st0{fill:#000000;}
]]>
</style>
<g>
<path class="st0" d="M110.547,411.844c-5.234,5.813-9.141,12.5-11.328,19.266c-1.531,4.766-2.266,9.469-2.266,13.875
c0,2.688,0.266,5.25,0.844,7.672c0.438,1.797,1.031,3.516,1.828,5.094c0.594,1.203,1.313,2.344,2.156,3.375
c1.266,1.531,2.828,2.859,4.688,3.781c1.844,0.938,3.969,1.438,6.125,1.422v-9.766c-0.453,0-0.797-0.063-1.125-0.156
c-0.578-0.156-1.047-0.422-1.578-0.891c-0.375-0.359-0.781-0.828-1.156-1.469c-0.563-0.922-1.094-2.203-1.453-3.734
c-0.359-1.547-0.563-3.344-0.563-5.328c0-3.297,0.578-7.047,1.797-10.891c1.141-3.531,2.953-7.188,5.328-10.656
c3.547-5.219,8.391-9.984,13.984-13.391c2.781-1.703,5.781-3.078,8.891-4.016c3.125-0.938,6.391-1.438,9.766-1.438
c4.5,0,8.813,0.906,12.844,2.531c6.031,2.406,11.484,6.453,15.844,11.281c4.344,4.813,7.578,10.406,9.266,15.688
c1.234,3.844,1.813,7.594,1.813,10.891c0,2.016-0.219,3.844-0.594,5.391c-0.266,1.156-0.641,2.188-1.047,3
c-0.313,0.625-0.641,1.125-0.984,1.547c-0.5,0.609-1,1-1.484,1.25c-0.5,0.234-1.016,0.375-1.766,0.391v9.766
c1.281,0.016,2.547-0.172,3.75-0.5c2.109-0.578,4-1.672,5.547-3.094c1.156-1.063,2.125-2.281,2.922-3.609
c1.219-2,2.063-4.219,2.609-6.594s0.813-4.906,0.813-7.547c0-4.406-0.734-9.125-2.266-13.875
c-1.453-4.516-3.672-8.984-6.547-13.188c-4.313-6.297-10.063-12.016-16.969-16.234c-3.453-2.094-7.188-3.813-11.172-5
c-3.984-1.219-8.203-1.875-12.578-1.875c-5.828,0-11.391,1.188-16.469,3.234C122.375,401.109,115.781,406.047,110.547,411.844z"/>
<path class="st0" d="M165.594,452.109c-1.594,1.266-2.531,3.172-2.531,5.219v7.891c0,2.031,0.938,3.953,2.531,5.219
c1.594,1.25,3.688,1.719,5.656,1.25l5.266-1.25v-18.344l-5.266-1.25C169.281,450.375,167.188,450.844,165.594,452.109z"/>
<path class="st0" d="M121.719,450.844l-5.281,1.25v18.344l5.281,1.25c1.969,0.469,4.063,0,5.656-1.25
c1.594-1.266,2.531-3.188,2.531-5.219v-7.891c0-2.047-0.938-3.953-2.531-5.219S123.688,450.375,121.719,450.844z"/>
<path class="st0" d="M453.453,429.594c-2.016-7.531-4.859-14.281-8.359-20.281c-6.141-10.547-14.266-18.75-23.234-25.25
c-6.734-4.875-13.922-8.859-21.234-12.281c-10.953-5.125-22.156-9.063-32.5-12.891c-10.344-3.813-19.797-7.547-27.156-11.891
c-2.688-1.594-5.109-3.25-7.203-4.984c-3.125-2.609-5.563-5.391-7.328-8.5s-2.953-6.609-3.406-10.984
c-0.328-3.125-0.469-6.063-0.469-8.875c0-8.281,1.219-15.453,2.781-22.781c4.625-5.219,8.859-11.438,12.859-18.875
c4.016-7.484,7.828-16.219,11.625-26.563c2.438-1.109,4.891-2.438,7.281-4.063c5.469-3.656,10.656-8.781,14.984-15.609
c4.313-6.828,7.781-15.313,10.156-25.781c0.656-2.906,0.969-5.797,0.969-8.641c0.016-5.938-1.391-11.594-3.75-16.656
c-1.641-3.516-3.719-6.734-6.141-9.656c1.234-4.563,2.734-10.703,4.078-17.891c1.844-9.984,3.375-21.984,3.375-34.594
c0-8.141-0.641-16.547-2.297-24.844c-1.234-6.219-3.063-12.391-5.625-18.297c-3.859-8.891-9.469-17.25-17.266-24.156
c-7.219-6.391-16.266-11.484-27.188-14.75c-3.859-4.625-7.734-8.563-11.703-11.906c-3.438-2.875-6.953-5.297-10.547-7.281
c-5.406-3-11-4.984-16.734-6.188s-11.578-1.641-17.641-1.641c-8.359,0-17.156,0.828-26.875,1.781
c-3.672,0.375-6.75,0.828-9.422,1.297c-3.984,0.719-6.969,1.453-9.359,1.938c-1.203,0.234-2.25,0.422-3.281,0.547
c-1.031,0.109-2.031,0.188-3.172,0.188c-1.531,0-3.297-0.125-5.609-0.453c-7.078-1.031-13.547-2.625-18.625-4.188
c-2.531-0.766-4.719-1.531-6.438-2.188c-0.859-0.328-1.609-0.625-2.203-0.875c-0.609-0.25-1.063-0.484-1.328-0.609l0.016,0.016
c-0.781-0.406-1.531-0.625-2.203-0.75C182.609,0.031,182.016,0,181.5,0c-1.078,0-1.844,0.156-2.453,0.313s-1.078,0.344-1.5,0.516
c-0.813,0.328-1.438,0.672-2.063,1.047c-1.141,0.688-2.234,1.453-3.391,2.344c-2.016,1.563-4.234,3.5-6.594,5.781
c-3.531,3.406-7.313,7.531-10.75,12.031c-1.719,2.234-3.328,4.578-4.781,7s-2.734,4.906-3.75,7.516
c-4.969,12.922-8.25,24.828-10.281,35.813c-2.047,10.984-2.828,21.047-2.828,30.281c0,15.109,2.109,27.922,4.141,38.75
c0,0.516,0.016,1,0.047,1.516c0.063,1.016,0.172,2.063,0.281,3.156c0.172,1.625,0.359,3.297,0.5,4.703
c0.078,0.703,0.141,1.328,0.188,1.813c0.016,0.234,0.031,0.453,0.031,0.609l0.016,0.156v0.047v0.016v0.922l1.984,8.828
c-2.859,3.125-5.328,6.625-7.25,10.469c-2.688,5.344-4.281,11.375-4.281,17.75c0,2.813,0.328,5.719,0.984,8.609
c1.563,6.984,3.641,13.078,6.125,18.391c3.719,7.984,8.438,14.188,13.656,18.844c4.047,3.625,8.375,6.266,12.656,8.219
c3.781,10.344,7.594,19.063,11.609,26.547c4,7.453,8.219,13.656,12.844,18.875c1.563,7.328,2.781,14.516,2.797,22.797
c0,2.813-0.156,5.75-0.484,8.875c-0.313,3-0.969,5.594-1.922,7.938c-1.422,3.5-3.5,6.484-6.328,9.313
c-2.828,2.781-6.438,5.391-10.703,7.813c-4.328,2.453-9.344,4.75-14.797,6.938c-9.563,3.875-20.469,7.531-31.516,11.953
c-8.281,3.297-16.672,7.063-24.672,11.766c-6,3.531-11.766,7.625-17.078,12.484c-7.953,7.281-14.813,16.359-19.547,27.578
c-4.75,11.234-7.391,24.531-7.375,40.25c0,2.219,0.469,4.328,1.234,6.281c0.703,1.828,1.688,3.5,2.844,5.094
c2.188,2.969,5,5.625,8.453,8.188c6.063,4.469,14.109,8.656,24.531,12.594c15.625,5.891,36.563,11.188,63.641,15.031
c27.063,3.844,60.266,6.25,100.266,6.25c34.703,0,64.266-1.797,89.156-4.781c18.656-2.25,34.703-5.156,48.313-8.484
c10.219-2.484,19.078-5.219,26.672-8.094c5.688-2.156,10.688-4.406,15.031-6.719c3.25-1.734,6.125-3.516,8.672-5.344
c3.813-2.766,6.875-5.609,9.203-8.844c1.172-1.609,2.125-3.328,2.828-5.203c0.703-1.844,1.125-3.875,1.125-5.969
C456.984,447.813,455.75,438.203,453.453,429.594z M327.266,358.094l-50.156,78.328l-5.594-38.453l14.234-15.063l-9.219-15.375
l38.906-20.453c1.078,1.391,2.219,2.703,3.422,3.953C321.438,353.672,324.266,356,327.266,358.094z M183.078,87.156
c45.219,10.031,133.641-9.141,133.641-9.141s0.953,21.922,16.031,42.047c5.938,7.906,10.828,20.266,14.5,32.016
c-0.984-1.828-3.297-2.516-6.75-2.953c-7.75-1.047-19.266-1.719-32.234-1.094c-38.531,1.891-35.672,5.391-50.797,5.391
s-12.266-3.5-50.797-5.391c-12.969-0.625-24.484,0.047-32.25,1.094c-4.031,0.531-6.563,1.344-7.141,4.031
c-0.203,1-0.516,2.125-1.906,2.672C169.641,139.891,181.516,119.531,183.078,87.156z M339.922,176.469
c0,0.219-0.156,22.313-15.188,29.859c-5.109,2.578-11.516,4-18.031,4.016c-6.875,0-13.156-1.563-18.172-4.516
c-5.547-3.25-9.281-8.078-11.109-14.313c-0.438-1.453-0.828-2.906-1.234-4.313c-1.188-4.297-4.391-16.234,2.406-21.484
c4.375-3.422,17.953-5.578,30.969-5.578c11.828,0,23.891,1.609,27.422,5.297C339.313,167.875,340.219,172.219,339.922,176.469z
M238.75,187.203c-0.406,1.406-0.813,2.859-1.234,4.313c-1.828,6.234-5.563,11.063-11.094,14.313
c-5.031,2.953-11.313,4.516-18.188,4.516c-6.516-0.016-12.906-1.438-18.031-4.016c-15.031-7.547-15.172-29.641-15.188-29.859
c-0.297-4.25,0.609-8.594,2.922-11.031c3.547-3.688,15.609-5.297,27.438-5.297c13,0,26.594,2.156,30.984,5.578
C243.141,170.969,239.938,182.906,238.75,187.203z M188.547,264.063c-3.922-7.313-7.828-16.406-11.844-27.75l-1.328-3.703
l-3.688-1.359c-2.563-0.938-5.063-2.156-7.453-3.766c-3.609-2.422-7.031-5.734-10.172-10.672s-5.953-11.563-7.984-20.516
c-0.391-1.703-0.547-3.328-0.547-4.922c0-3.594,0.859-7,2.5-10.25c1.344-2.703,3.219-5.25,5.5-7.563
c3.844,5.813,7.031,10.422,8.188,11.578c2.203,2.203,3.297,0.078,3.469-4.047c1.359,9.172,5.719,24.313,19.797,31.797
c20.266,10.766,50.516,6.734,60.781-17.234c4.641-10.813,4.703-21.375,11.703-21.375c6.984,0,7.063,10.563,11.703,21.375
c10.281,23.969,40.531,28,60.797,17.234c20.25-10.766,20.391-37.422,20.391-39.297c0-0.969,0.922-1.703,2.234-1.844
c1.719,7.234,2.609,12.141,2.609,12.141s1.938-3.703,4.844-8.641c1.734,2.031,3.172,4.219,4.234,6.5
c1.422,3.063,2.188,6.266,2.188,9.594c0,1.609-0.172,3.25-0.563,4.938c-1.344,5.969-3.047,10.906-4.953,15
c-2.875,6.125-6.188,10.344-9.656,13.438c-3.453,3.094-7.141,5.109-10.969,6.531l-3.703,1.344l-1.313,3.719
c-4.016,11.344-7.938,20.453-11.859,27.75c-3.938,7.313-7.844,12.813-11.906,17.094l-1.609,1.703l-0.5,2.266
c-1.813,8.359-3.625,17.594-3.625,28.531c0,3.375,0.172,6.891,0.547,10.594c0.453,4.344,1.453,8.422,2.938,12.172
c0.063,0.172,0.156,0.359,0.219,0.516l-50.891,26.766l-56.406-26.172c1.734-4.063,2.906-8.5,3.406-13.281
c0.391-3.703,0.547-7.219,0.547-10.594c0.016-10.938-1.797-20.188-3.625-28.547l-0.5-2.266l-1.609-1.688
C196.391,276.844,192.469,271.375,188.547,264.063z M188.094,355.594c2.938-2.359,5.641-5,8.031-7.969l43.016,19.969l-9.188,15.313
l14.219,15.063l-5.25,36.203l-54.875-75.609C185.438,357.609,186.797,356.625,188.094,355.594z M440.219,458.5
c-0.016,0.094-0.125,0.406-0.422,0.906c-0.563,0.969-1.875,2.531-4.094,4.313c-1.922,1.547-4.516,3.281-7.781,5.063
c-5.734,3.141-13.5,6.406-23.344,9.5c-14.781,4.656-34.297,8.906-58.922,12c-24.625,3.063-54.359,4.969-89.672,4.969
c-34.094,0-63-1.781-87.125-4.672c-18.094-2.172-33.5-4.984-46.344-8.109c-9.656-2.359-17.875-4.906-24.703-7.5
c-5.141-1.938-9.5-3.906-13.078-5.828c-2.688-1.438-4.953-2.859-6.797-4.172c-2.75-1.969-4.5-3.766-5.375-5
c-0.438-0.594-0.656-1.063-0.734-1.281c-0.047-0.094-0.063-0.156-0.063-0.188c0-9.375,1.063-17.406,2.906-24.375
c1.609-6.094,3.828-11.391,6.531-16.078c4.719-8.203,10.922-14.641,18.297-20.063c5.5-4.078,11.672-7.563,18.203-10.672
c7.328-3.484,15.109-6.484,22.922-9.375v16.875h5.859h5.859v-21.203c7.469-2.797,14.75-5.672,21.531-9.109l86.703,119.453
l75.75-118.266c0.234,0.359,0.469,0.719,0.688,1.063c3.156,5.078,5.359,10.609,6.828,16.875c1.453,6.25,2.125,13.25,2.125,21.047
c0,18.063,0,33.797,0,44.391H318.75v11.734h67v-11.734h-27.219c0-10.594,0-26.328,0-44.391c0-11.359-1.297-21.703-4.516-31.141
c-0.281-0.813-0.578-1.625-0.891-2.422c9.156,3.609,18.734,6.859,28.016,10.547c7.953,3.141,15.672,6.578,22.688,10.656
c5.281,3.063,10.172,6.5,14.516,10.406c6.516,5.922,11.859,12.906,15.703,21.859C437.875,433.516,440.219,444.516,440.219,458.5
L440.219,458.5z"/>
</g>
</svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_doctor, verbose=True)
print(answer)
# COMMAND ----------
displayHTML("""<h2>Father</h2><br>
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg height="150px" width="150px" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
viewBox="0 0 56.9 56.9" xml:space="preserve">
<g>
<g>
<circle style="fill:#010002;" cx="15.455" cy="28.5" r="3.4"/>
<circle style="fill:#010002;" cx="37.555" cy="4.8" r="4.8"/>
<path style="fill:#010002;" d="M44.855,10.6c-1.3-0.6-4-0.4-4.4-0.4l-2.4,4.8l0.3-4h0.1v-0.8h-1.5V11h0.1l0.3,4l-2.4-4.8
c-0.4,0-3.2-0.2-4.4,0.4c-2,0.7-6.3,3.9-9,18.7c-0.1,0.4,0,0.9,0.1,1.3c-1.1,0.8-2.9,1.7-6,1.7s-5.5,0.9-7.2,2.7
c-2.6,2.8-2.3,6.6-2.3,6.7c0.1,0.8,0.8,1.5,1.6,1.5h0.1c0.9-0.1,1.6-0.8,1.5-1.7c0,0-0.1-2.6,1.4-4.3c0.2-0.2,0.4-0.4,0.7-0.6v5
c0,0.5,0.1,1,0.3,1.5V55c0,0.9,0.8,1.7,1.7,1.7c0.9,0,1.7-0.8,1.7-1.7v-9.3c0.1,0,0.3,0,0.4,0c0.2,0,0.3,0,0.4,0V55
c0,0.9,0.8,1.7,1.7,1.7c0.9,0,1.7-0.8,1.7-1.7V43.1c0.2-0.5,0.3-1,0.3-1.5V35c2.5-0.7,4-1.9,4.9-2.8c0.9-0.3,1.6-1,1.8-1.9
c1.6-8.7,3.6-12.4,4.8-13.9v19.1v18.6c0,1.5,1.1,2.8,2.7,2.8s2.8-1.2,2.8-2.8V34.6c0,0,0.1-0.9,1.1-1c1,0,1.1,1,1.1,1v19.3
c0,1.5,1.3,2.8,2.8,2.8s2.7-1.2,2.7-2.8V35.3V19.4c0,0,1.2,4.3,1.3,7.9c0,3.3,5.2,3.3,5.1,0C50.455,12.9,44.855,10.6,44.855,10.6z
"/>
</g>
</g>
</svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_father, verbose=True)
print(answer)
# COMMAND ----------
displayHTML("""<h2>Business Partner</h2><br>
<?xml version="1.0" encoding="utf-8"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg width="150px" height="150px" viewBox="0 -14.56 352.858 352.858" xmlns="http://www.w3.org/2000/svg"><defs><style>.a{fill:#ffffff;}.b{fill:#211715;}.c{fill:#6e6867;}.d{fill:#3f88c9;}.e{fill:#b5b2b1;}.f{fill:none;}</style></defs><path class="a" d="M138.613,235.252c5.763,3.45,10.269,5.566,16.629,8.96a41.161,41.161,0,0,0,4.634,2.171c2.445.78,6.7-.077,9.394-1.8,2.891.024,6.141-2.62,7.772-4.693l.095-.436q.7-.137,1.388-.34a5.216,5.216,0,0,0,2.7-1.5,12.834,12.834,0,0,0,2.273-4.941,6.392,6.392,0,0,0,2.567-1.111,1.917,1.917,0,0,0,.9-1.3,38.061,38.061,0,0,1,5.526-3.9,11.258,11.258,0,0,1,1.929-.662s6.269.142,2.269-12.451-10.246-8.318-10.246-8.318a17.378,17.378,0,0,1-7.266,1.159,24.085,24.085,0,0,0-11.73,1.152,13.976,13.976,0,0,0-5.042,3.6l-1.049-.407c-.888-.345-3.134,0-4.074.148a32.759,32.759,0,0,0-6.222,2.222,11.476,11.476,0,0,1-4.413-.051s-5.995-1.208-9.069,8.347C133.488,233.822,138.613,235.252,138.613,235.252Z"/><path class="b" d="M137.92,237.164c3.249,1.929,6.581,3.7,9.935,5.442,3.186,1.652,6.322,3.452,9.594,4.93a12.112,12.112,0,0,0,8.288.653c2.775-.682,5.7-2.056,7.289-4.532,1.394-2.173-2.066-4.181-3.454-2.019-1.1,1.715-3.762,2.506-5.688,2.867-2.432.457-4.115-.234-6.267-1.312-5.964-2.987-11.942-6.077-17.678-9.483-2.219-1.317-4.233,2.139-2.019,3.454Z"/><path class="b" d="M169.541,246.579a10.418,10.418,0,0,0,5.176-1.881,16.66,16.66,0,0,0,3.74-3.393,2.177,2.177,0,0,0,.585-1.414,2,2,0,0,0-3.414-1.414,14.527,14.527,0,0,1-1.38,1.5c-.265.251-.538.494-.819.726-.076.062-.153.123-.228.185-.19.156.362-.268.077-.06-.16.117-.319.235-.482.347a14.271,14.271,0,0,1-1.941,1.091c.57-.274,0-.01-.156.043-.174.059-.351.113-.53.159-.157.04-.316.075-.477.1-.345.06.065.022.163-.019a1.065,1.065,0,0,1-.314.025,2,2,0,0,0,0,4Z"/><path class="b" d="M167.3,241.4a28.5,28.5,0,0,0,11.186-.2,7.713,7.713,0,0,0,4.321-2.377,14.287,14.287,0,0,0,2.4-4.818c.751-2.468-3.109-3.523-3.858-1.063a9.572,9.572,0,0,1-1.539,3.264,5.129,5.129,0,0,1-2.961,1.274,23.872,23.872,0,0,1-8.488.064,2.068,2.068,0,0,0-2.461,1.4,2.014,2.014,0,0,0,1.4,2.46Z"/><path class="b" d="M169.108,233.277c3.227,1.144,6.994,1.177,10.382,1.329,1.085.049,2.177.109,3.264.107,2.223,0,5.125-1.184,5.968-3.4a5.331,5.331,0,0,0-2.234-6.093,11.468,11.468,0,0,0-3.9-1.467c-2.844-.769-5.663-1.641-8.467-2.544-1.674-.539-3.344-1.093-5-1.7q-.534-.195-1.065-.4c-.132-.052-1.06-.44-.566-.223a8.217,8.217,0,0,1-1.171-.588c-2.168-1.4-4.176,2.06-2.019,3.454a27.76,27.76,0,0,0,6.124,2.446c2.774.941,5.572,1.813,8.382,2.639,1.035.305,2.072.606,3.116.88.969.254,2.155.373,2.8,1.23a2.484,2.484,0,0,1,.3.776c.08.233-.193.321.031.12a3.637,3.637,0,0,1-2.272.874c-.946,0-1.9-.049-2.842-.088-3.25-.134-6.715-.122-9.773-1.206a2.018,2.018,0,0,0-2.46,1.4,2.04,2.04,0,0,0,1.4,2.46Z"/><path class="b" d="M146.114,214.691a17.215,17.215,0,0,0,4.3.27,15.171,15.171,0,0,0,4.034-1.411,17.369,17.369,0,0,1,3.77-1.094l.325-.048c-.416.059.025,0,.107-.01.294-.031.587-.062.882-.081a8.955,8.955,0,0,1,.941-.018c.112,0,.223.012.334.025-.5-.056-.1.008.013.047a2,2,0,1,0,1.064-3.857,8.325,8.325,0,0,0-3.607-.07,18.394,18.394,0,0,0-3.983.905c-.684.247-1.359.52-2.03.8q-.615.258-1.229.519s-.48.2-.366.156c.168-.07-.217.085-.262.1a2.414,2.414,0,0,1-.279.068c.414-.108.05-.008-.077,0-.313.013-.625.018-.938.009-.382-.012-.763-.038-1.143-.074-.153-.014-.306-.031-.458-.048-.723-.079.342.056-.338-.047a2.066,2.066,0,0,0-2.46,1.4,2.015,2.015,0,0,0,1.4,2.461Z"/><path class="b" d="M185.91,203.011a16.709,16.709,0,0,1-5.512,1.148c-2.053.015-4.076-.37-6.141-.278-3.516.155-7.479.9-10.36,3.037a40.93,40.93,0,0,0-8.033,8.452,6.013,6.013,0,0,0-1.365,5.039,5.619,5.619,0,0,0,2.946,3.621c4.541,2.041,8.076-2.223,11.1-4.834,1.95-1.687-.89-4.506-2.829-2.829-1.449,1.254-2.737,3.084-4.556,3.823-1,.406-2.235.53-2.694-.489-.564-1.251,1.438-3.047,2.2-3.958a45.06,45.06,0,0,1,4.024-4.31,14.662,14.662,0,0,1,9.772-3.561c2.13-.077,4.24.364,6.359.276a20.72,20.72,0,0,0,6.157-1.28c2.4-.871,1.365-4.738-1.063-3.857Z"/><path class="b" d="M189.242,230.625c.812-.53,1.642-1.032,2.478-1.522a22.3,22.3,0,0,1,2.046-1.135l-.477.2a17.191,17.191,0,0,1,1.662-.534,2,2,0,1,0-1.063-3.857,16.326,16.326,0,0,0-2.232.776c-.426.2-.834.449-1.243.683-1.079.617-2.149,1.253-3.19,1.933a2,2,0,1,0,2.019,3.454Z"/><path class="a" d="M318.322,270.993c-.92,1.552-2.506,4.311-3.26,5.949-3.2,6.948-4.15,9.987-4.373,18.139a11.678,11.678,0,0,0,.321,3.8,5.394,5.394,0,0,0,4.531,3.122l1.353.037c-.061,1.153-.11,2.388-.136,3.755-.041,2.076-.272,2.821-.307,4.9-.032,1.883.363,4.354,2.1,5.125a3.5,3.5,0,0,0,4.095-1.433c.107.768.173,1.235.173,1.235a3.661,3.661,0,0,0,1.941,2.771,3.763,3.763,0,0,0,4.535-1.689,7.237,7.237,0,0,0,.661-1.942c.166.4.265.635.265.635.752,1.788,4.094,2.412,5.478,1.044a5.9,5.9,0,0,0,1.282-3.782q.1-1.107.2-2.2l.634,1.328c.581,1.219,2.609,1.394,3.72.815a4.136,4.136,0,0,0,1.338-1.551c1.557-3.938,2.345-13.018,2.551-14.854a102.19,102.19,0,0,0,.258-14.233q-.23-4.252-.594-8.5l-.1-4.91-24.778-1.222Z"/><path class="a" d="M143.177,210.53c-.7-.28-1.39-.556-2.028-.806l-2.584-.96c-3.206,8.562-6.258,17.17-9.3,25.789l2.959.946,5.883,2.047c3.273-8.284,6.514-18.384,8.627-25.627C145.664,211.522,144.405,211.02,143.177,210.53Z"/><path class="a" d="M189.5,202.867l1.665-.568s.822-.184,1.906-.429q5.35,11.392,9.625,23.251l-1.571.5-5.689,2.135a196.069,196.069,0,0,1-9.5-23.67Z"/><path class="a" d="M82.911,54.989c-.034,5.774-.1,13.788,5.079,16.833a5.362,5.362,0,0,1,2.36,2.545C91.511,77.286,89,78.486,87.4,80.086a8.8,8.8,0,0,0-2.138,3.673c-.277,3.115-1.421,10.094-3.541,13.776a11.035,11.035,0,0,1-6.263,5.378,27.392,27.392,0,0,1-13.573.808,1.911,1.911,0,0,0-2.233,1.031c-1.905,4.206-4.629,9.6-5.418,11.569l-.55,1.377-.556-.472c-9.092-7.728-19.174-8.2-32.194-12.331l.267-6.574a9.033,9.033,0,0,0-.449-3.462c6.641-2.35,15.349-8.108,18.292-14.173a17.133,17.133,0,0,1-6.28-12.622c-.057-2.383.6-5.07,2.66-6.268a5.118,5.118,0,0,1,4.558-.109,8.536,8.536,0,0,1,3.524,3.147c1.213-2.8,2.86-6.359,4.13-9.065.8-1.7,1.443-3.058,1.743-3.693.277-.587.8-1.412,1.419-1.6,1.151-.34,3.015,2.354,4.113,3.375.45-.979,2.852-9.987,4.938-9.877,3.793.091,11.044,0,15.458-1.156l6.131-1.011a3.874,3.874,0,0,0,.606-.318c1.232,3.96.889,9.246.866,13.5Z"/><path class="a" d="M257.424,147.692c11.654-17.877,21.947-32.857,34.816-48.447a20.75,20.75,0,0,0,2.362-2.9c.855-1.279,1.67-3.328,2.48-4.629a37.038,37.038,0,0,0-2.018-5.244c-10.58,4.539-19.984,9.23-29.22,12.408a23.344,23.344,0,0,0,1.559,1.9c-3.113.678-4.7,1.457-4.7,3.536,0,.805-.4,7.58-.341,9.481-1.275,6.117-4.561,26.975-4.939,33.9Z"/><path class="a" d="M289.309,88.994q2.867-1.278,5.845-2.562a19.172,19.172,0,0,1,2.07-9.932A28.744,28.744,0,0,1,277.5,64.76a16.926,16.926,0,0,0,4.7-13.143c-.224-2.345-1.183-4.9-3.347-5.837a5.057,5.057,0,0,0-4.484.428,8.4,8.4,0,0,0-3.079,3.494c-1.812-5.556-9.648-11.106-15.7-12.361-9.309-2.364-18.563-3.849-24.988-3.133a41.268,41.268,0,0,0,.86,10.477c.713,5.661,1.718,13.517-3,17.112a5.3,5.3,0,0,0-2.016,2.775c-.8,3,1.813,3.882,3.566,5.264a8.69,8.69,0,0,1,2.529,3.353c.638,3.024,2.581,9.736,5.095,13.1a10.9,10.9,0,0,0,6.777,4.54c4.511.894,10.436.544,14.058-1.069a1.892,1.892,0,0,1,2.384.76c.389.645.966,1.522,1.352,2.282L265.53,99l.314-.12C273.372,96.289,281.012,92.693,289.309,88.994Z"/><path class="c" d="M249.2,211.091a474.19,474.19,0,0,1-45.334,17.341,270.025,270.025,0,0,0-11.723-28.518c17.946-8.371,27.709-14.131,45.946-24.371,5.453-3.978,8.55-15.918,10.1-24.978s4.313-22.868,8.756-30.917c1.3-2.349,3.085-4.688,5.414-5.853-1.275,6.116-4.559,26.964-4.939,33.891,12.853-19.711,24.048-35.9,38.868-53.268l5.456,2.808c2.111,1.212,4.5,2.684,6.987,4.3,7.454,4.834,15.753,10.92,19.873,14.98a39.3,39.3,0,0,1,7.017,8.834,47.138,47.138,0,0,1,3.805,10.117c6.544,23.261,10.624,41.19,11.327,64.684.631,21.08-1.935,43.678-4.319,70.3-6.233.416-19-.31-27.717-.866-.1,2.29-.2,4.277-.291,4.543-.222.667-12.459,3.115-12.459,3.115-11.57,2.659-30.988-.525-39.255-3a2.689,2.689,0,0,1-1.953-2.468c-.834-25.531-.45-38.889.606-54.581.356-5.291-1.178-14.724-2.065-19.959.1,4.418-5.213,9.651-14.1,13.873Z"/><path class="d" d="M11.015,276.773c-.067,1.2.109,2.416,1.011,2.9,9.974,6.1,34.381,12.966,45.544,13.372s22.283-1.231,33.322-2.864a5.938,5.938,0,0,0,3.566-1.366,5.15,5.15,0,0,0,1.068-3.052c.873-7.719,2.208-27.478,2.093-35.243-.1-6.772-1.513-14.073-1.891-16.873l-1.254-9.275a256.946,256.946,0,0,0,33.5,13.839c3.642-10.336,7.274-20.661,11.14-30.919-16.634-8.042-28.383-15.261-44.045-25.081-11-11.726-18.416-29.979-28.565-40.772-1.407-2.1-2.673-4-2.673-4-2.421-3.632-6.96-15.362-10.707-20.216-9.276-7.884-19.583-8.217-32.988-12.584-1.027,3.21-2.5,8.853-3.178,11.69-3.291,6.7-5.149,10.232-7.566,19.786-5.65,22.337.885,46.957,4.85,69.654,1.986,11.367,4.2,25.038,4.078,36.575-2.421,12.863-6.053,18.39-7.317,34.426Z"/><path class="d" d="M262.548,107.855c.081-1.715.156-3.191.156-3.541,0-1.58.916-2.409,2.723-3.014l2.22-.254a77.483,77.483,0,0,0,6.528,6.124l-1.738,1.874c-1.3,3.815-6.563,21.3-8.785,28.63v.56q-3.07,4.607-6.228,9.458c.378-6.922,3.664-27.78,4.939-33.9C262.331,112.72,262.444,110.086,262.548,107.855Z"/><path class="b" d="M316.6,269.983c-3.247,5.5-6.346,11.461-7.32,17.84a36.325,36.325,0,0,0-.446,10.475,7.063,7.063,0,0,0,6.712,5.709c2.575.049,2.575-3.951,0-4a2.519,2.519,0,0,1-.851-.194,3.671,3.671,0,0,1-1.36-.943c-.774-.895-.669-2.1-.654-3.216a43.761,43.761,0,0,1,.8-8.655c1.16-5.353,3.808-10.32,6.572-15,1.312-2.221-2.144-4.236-3.454-2.019Z"/><path class="b" d="M315.7,288.563c-.085,3.889-.436,7.754-.7,11.633-.145,2.158-.167,4.318-.279,6.477a40.051,40.051,0,0,0-.243,5.11c.266,3.534,2.535,7.208,6.611,6.052,4.519-1.282,4.361-6.142,4.556-9.932.228-4.441.568-8.876.764-13.319.113-2.574-3.887-2.568-4,0-.189,4.3-.514,8.589-.741,12.886-.064,1.192-.107,2.386-.165,3.578a4.171,4.171,0,0,1-.528,2.228c-.782,1.126-1.86.92-2.262-.282-.552-1.65-.218-3.549-.071-5.238.184-2.118.159-4.252.283-6.374.25-4.276.678-8.534.771-12.819.056-2.575-3.944-2.575-4,0Z"/><path class="b" d="M320.888,316.156a5.284,5.284,0,0,0,5.632,4.446c3.191-.369,4.985-2.881,5.464-5.892.515-3.231.615-6.56.868-9.82.256-3.289.51-6.578.785-9.865.215-2.566-3.786-2.551-4,0-.414,4.949-.777,9.9-1.179,14.852-.1,1.227-.155,2.469-.32,3.689a4.206,4.206,0,0,1-.972,2.63c-1.183.995-2.175.257-2.421-1.1a2.018,2.018,0,0,0-2.461-1.4,2.042,2.042,0,0,0-1.4,2.46Z"/><path class="b" d="M328.491,316.409c.954,1.977,3.442,2.922,5.53,2.75,2.791-.229,4.383-2.373,4.781-5.019.44-2.928.6-5.924.872-8.873.285-3.089.532-6.181.677-9.28.12-2.573-3.881-2.567-4,0-.223,4.782-.7,9.544-1.154,14.308-.1,1.029-.138,2.078-.3,3.1-.1.648-.339,1.519-.716,1.7a1.989,1.989,0,0,1-2.235-.7,2.02,2.02,0,0,0-2.737-.718,2.043,2.043,0,0,0-.717,2.737Z"/><path class="b" d="M343.088,273.473a125.182,125.182,0,0,1,.24,23.643c-.29,2.82-.607,5.638-1.114,8.429a31,31,0,0,1-1.026,4.3,1.55,1.55,0,0,1-.672,1.02c-.215.1-.853.12-.974-.086-1.3-2.219-4.761-.208-3.454,2.019a4.546,4.546,0,0,0,4.118,2.122,4.929,4.929,0,0,0,4.126-2.392c1.432-2.213,1.7-5.486,2.087-8.028a114.7,114.7,0,0,0,1.394-16.938c.011-4.706-.32-9.407-.725-14.093-.219-2.545-4.221-2.568-4,0Z"/><path class="e" d="M248.155,4.7q-.252.12-.5.243c-5.814,2.931-8.967,6.321-12.126,11.443-3.316,5.378-6.206,11.556-4.956,17.827,6.426-.72,15.688.765,25.006,3.131,6.051,1.255,13.887,6.805,15.7,12.361a8.4,8.4,0,0,1,3.079-3.494,5.057,5.057,0,0,1,4.484-.428c2.164.933,3.123,3.492,3.347,5.837a16.926,16.926,0,0,1-4.7,13.143A28.745,28.745,0,0,0,297.227,76.5a40.8,40.8,0,0,1,2.077-3.786c2.213-4,3.865-5.961,6.734-10.452a25.511,25.511,0,0,0,3.384-18.7,24.32,24.32,0,0,1-.91-5.058c0-1.128.259-2.24.363-3.365.354-3.815-1.032-7.6-2.921-10.931a39.1,39.1,0,0,0-8.153-9.966,46.136,46.136,0,0,0-13.091-8.08C275.948,2.58,266.284,1.53,256.841,2.2A26.136,26.136,0,0,0,248.155,4.7Z"/><path class="e" d="M47.637,55.769c.8-1.7,1.443-3.058,1.743-3.693.277-.587.8-1.412,1.419-1.6,1.151-.34,3.015,2.354,4.113,3.375.45-.979,2.852-9.987,4.938-9.877,3.793.091,11.044,0,15.458-1.156l6.131-1.011c2.456-1.025,3.3-4.33,3.121-6.985a14.066,14.066,0,0,0-2.929-6.8,49.674,49.674,0,0,0-7.358-6.182,59.917,59.917,0,0,0-10.394-5.087C53.714,12.126,23.293,9.535,11.13,27.555c-6.007,5.405-8.8,14.073-9.118,26.121s8.519,27.6,15.055,35.122a20.778,20.778,0,0,1,3.69,6.06c6.637-2.349,15.345-8.107,18.288-14.172a17.133,17.133,0,0,1-6.28-12.622c-.057-2.383.6-5.07,2.66-6.268a5.118,5.118,0,0,1,4.558-.109,8.536,8.536,0,0,1,3.524,3.147C44.72,62.03,46.367,58.475,47.637,55.769Z"/><path class="b" d="M273.027,50.67c.937-1.75,3.1-4.258,5.326-2.9,1.74,1.062,1.939,3.785,1.906,5.592A14.9,14.9,0,0,1,273.6,65.4c-2.151,1.4-.148,4.861,2.019,3.454a18.88,18.88,0,0,0,8.562-17.381c-.354-3.316-1.9-6.914-5.427-7.831-3.928-1.02-7.418,1.726-9.176,5.012-1.215,2.269,2.237,4.292,3.453,2.019Z"/><path class="b" d="M234.338,78.936a14.237,14.237,0,0,0,5.477-1.207,6.96,6.96,0,0,0,2.471-1.75,2.139,2.139,0,0,0,.586-1.414,2,2,0,0,0-3.414-1.414,3.65,3.65,0,0,1-.323.335c-.065.06-.133.115-.2.172-.236.2.411-.307.239-.183l-.136.1a7.624,7.624,0,0,1-1.427.78l.478-.2a11.429,11.429,0,0,1-2.836.739l.532-.071a14.315,14.315,0,0,1-1.448.115,2,2,0,0,0,0,4Z"/><path class="b" d="M238.033,52.388c-.323,1.705.362,5.484,3.371,5.51,3.934-.42,3.7-5.048,2.161-7.082C242.309,49.151,239.047,48.734,238.033,52.388Z"/><path class="b" d="M228.55,35.477c-.073,6.065,1.824,11.951,1.477,18.026-.134,2.343-.687,4.837-2.5,6.471a9.513,9.513,0,0,0-2.7,3.218,5.451,5.451,0,0,0-.051,4.539c1.119,2.359,3.917,3,5.3,5.12a8.911,8.911,0,0,1,1,2.842q.5,1.908,1.137,3.776c1.839,5.412,4.618,11.075,10.455,12.975a25.059,25.059,0,0,0,10.1.7,24.024,24.024,0,0,0,4.971-.978c.322-.1.638-.223.952-.35.584-.237.68-.1.424-.288a7.77,7.77,0,0,1,1.353,2.283c1.207,2.274,4.661.255,3.453-2.019-.662-1.247-1.42-2.86-2.669-3.609-1.534-.921-2.867-.458-4.413.071a23.422,23.422,0,0,1-8.747,1.015c-2.693-.137-5.3-.586-7.347-2.477a17.209,17.209,0,0,1-4.072-6.7,69.305,69.305,0,0,1-2.121-7c-.753-2.848-2.931-4.5-5.19-6.129-.535-.387-1.093-.783-1.082-1.495.021-1.415,1.689-2.216,2.525-3.106a12.625,12.625,0,0,0,3.053-7.169c.863-6.636-1.391-13.1-1.312-19.716.031-2.575-3.969-2.576-4,0Z"/><path class="f" d="M301.017,69.569c5.773-10.727,7.58-20.815,6.923-29.6C306.635,20.976,296.322,11.348,288.5,7.742a45.571,45.571,0,0,0-34.561-1.827C243.859,9.294,230.86,17.92,230.55,35.477"/><path class="b" d="M276.891,67.256a30.841,30.841,0,0,0,17.056,10.7,2.042,2.042,0,0,0,2.46-1.4,2.022,2.022,0,0,0-1.4-2.46,27.373,27.373,0,0,1-15.291-9.671,2.012,2.012,0,0,0-2.828,0,2.049,2.049,0,0,0,0,2.829Z"/><path class="b" d="M255.052,39.269A23.71,23.71,0,0,1,267.3,46.78a11.366,11.366,0,0,1,1.151,1.6c.195.319.378.645.544.981,0,.007.265.577.123.241.074.177.138.359.2.54a2.05,2.05,0,0,0,2.46,1.4,2.019,2.019,0,0,0,1.4-2.461c-1.27-3.634-4-6.488-7.006-8.787a25.868,25.868,0,0,0-10.058-4.878,2.048,2.048,0,0,0-2.461,1.4,2.021,2.021,0,0,0,1.4,2.46Z"/><path class="b" d="M240.489,34.677c.009-.251.022-.5.046-.75,0-.023.069-.5.018-.181s.022-.115.033-.179a11.53,11.53,0,0,1,.359-1.455c.075-.239.162-.473.249-.708.175-.478-.183.385.029-.077.041-.091.082-.183.125-.273a12.373,12.373,0,0,1,.768-1.378c.136-.21.286-.411.426-.618.158-.235-.3.363.008-.013.079-.1.158-.194.24-.289a11.794,11.794,0,0,1,1.044-1.077c.185-.169.379-.326.57-.487s-.3.206.013-.006c.1-.07.2-.145.307-.215a11.611,11.611,0,0,1,1.363-.79,2.011,2.011,0,0,0,.717-2.736,2.049,2.049,0,0,0-2.736-.717,14.022,14.022,0,0,0-7.579,11.949,2.017,2.017,0,0,0,2,2,2.041,2.041,0,0,0,2-2Z"/><path class="b" d="M247.758,35.925c.11-.161.237-.313.342-.477-.042.065-.267.334-.1.128.062-.076.123-.152.186-.226q.359-.426.756-.817.417-.411.872-.781c.06-.049.123-.1.183-.146-.418.353-.183.142-.078.065.158-.115.319-.227.481-.335q.465-.306.955-.572.233-.125.469-.24c.088-.043.177-.084.265-.125.069-.031.4-.172.083-.04s.043-.015.087-.032l.219-.083q.274-.1.555-.188c.373-.117.751-.213,1.133-.294a2.014,2.014,0,0,0,1.4-2.46,2.047,2.047,0,0,0-2.46-1.4,14.421,14.421,0,0,0-8.8,6,2.01,2.01,0,0,0,.717,2.736,2.049,2.049,0,0,0,2.736-.717Z"/><path class="b" d="M232.426,33.3c-.693-5.638,1.745-10.834,4.605-15.536a27.949,27.949,0,0,1,9.048-9.658,28.511,28.511,0,0,1,7-3.159,29.832,29.832,0,0,1,8.11-.936,61.194,61.194,0,0,1,17.365,2.149c10.489,2.95,20.228,9.439,25.669,19.054a18.816,18.816,0,0,1,2.668,7.728,20.933,20.933,0,0,1-.271,4.115,13.7,13.7,0,0,0,.33,4.747,29.706,29.706,0,0,1,.97,7.927,24.076,24.076,0,0,1-1.593,7.568,38.679,38.679,0,0,1-4.513,7.714c-1.491,2.19-2.907,4.4-4.241,6.687-3.093,5.311-5.216,10.712-4.118,16.956a2.016,2.016,0,0,0,2.46,1.4,2.045,2.045,0,0,0,1.4-2.46c-.988-5.62,1.69-10.446,4.423-15.119,2.7-4.617,6.307-8.718,8.3-13.726a27.783,27.783,0,0,0,1.105-16.636,13.672,13.672,0,0,1-.574-4.575,27.619,27.619,0,0,0,.327-4.595,22.307,22.307,0,0,0-2.582-8.575c-5.4-10.566-15.807-18-26.941-21.539A63.291,63.291,0,0,0,263.259.017a44.787,44.787,0,0,0-8.949.519A29.621,29.621,0,0,0,246.283,3.4a31.07,31.07,0,0,0-11.971,11.171c-3.534,5.514-6.713,12-5.886,18.733a2.063,2.063,0,0,0,2,2,2.013,2.013,0,0,0,2-2Z"/><path class="b" d="M9.015,276.773a5.755,5.755,0,0,0,.826,3.536,7.185,7.185,0,0,0,2.633,1.931c1.718.942,3.5,1.769,5.3,2.54a133.492,133.492,0,0,0,13.483,4.878c8.329,2.552,17.127,4.927,25.869,5.367a121.715,121.715,0,0,0,20.092-.968c3.443-.4,6.877-.877,10.307-1.375,2.7-.393,6.3-.351,8.348-2.454,1.609-1.649,1.633-4.142,1.848-6.3.186-1.868.348-3.739.5-5.61q.572-7.059.957-14.13c.246-4.482.5-8.984.446-13.475-.071-5.936-1.155-11.743-1.966-17.6a2.012,2.012,0,0,0-2.46-1.4,2.053,2.053,0,0,0-1.4,2.46c.659,4.766,1.514,9.481,1.753,14.3.188,3.792.011,7.6-.159,11.394-.369,8.218-.887,16.451-1.731,24.635a10.31,10.31,0,0,1-.361,2.351c-.364,1.03-1.437,1.147-2.407,1.311-3.076.521-6.182.924-9.273,1.337A160.617,160.617,0,0,1,62.492,291.1c-8.678.117-17.038-1.612-25.378-3.9a150.69,150.69,0,0,1-14.574-4.755c-1.967-.763-3.91-1.582-5.808-2.5-.867-.42-1.725-.86-2.566-1.331a4.217,4.217,0,0,1-1.13-.66c.157.2.085.083.05.013a2.678,2.678,0,0,1-.071-1.185c.088-2.575-3.912-2.572-4,0Z"/><path class="b" d="M54.543,115.812c-9.642-8.1-22.281-9.35-33.87-13.1a2.035,2.035,0,0,0-2.461,1.4c-.78,2.462-1.453,4.958-2.108,7.455q-.432,1.649-.842,3.3a15.76,15.76,0,0,1-1.323,3.093,81.59,81.59,0,0,0-8.572,31.527,113.5,113.5,0,0,0,.611,19.242c1.4,12.985,4.286,25.741,6.518,38.594,1.066,6.134,2.076,12.281,2.8,18.465.362,3.1.657,6.21.84,9.327.166,2.835.469,5.8-.112,8.594-1.048,5.033-2.592,9.928-3.923,14.888a101.5,101.5,0,0,0-3.09,18.174c-.207,2.566,3.794,2.552,4,0A93.745,93.745,0,0,1,15.631,260.9c1.115-4.334,2.482-8.6,3.533-12.949q.448-1.857.828-3.73a19.587,19.587,0,0,0,.324-4.372c-.051-3.05-.241-6.1-.513-9.136-.562-6.281-1.467-12.53-2.486-18.752-2.064-12.608-4.867-25.1-6.656-37.748-1.781-12.594-2.4-25.6.783-38.024a81.049,81.049,0,0,1,5.524-15.331c.567-1.173,1.182-2.327,1.722-3.512a23.177,23.177,0,0,0,1.039-3.821c.723-2.8,1.467-5.592,2.341-8.346l-2.461,1.4c10.782,3.487,23.133,4.528,32.106,12.069,1.958,1.646,4.8-1.169,2.828-2.828Z"/><path class="b" d="M23.1,149.088c-2.911,19.4,11.255,36.3,24.691,48.389a168.441,168.441,0,0,0,21.89,16.5c4.274,2.741,9.026,4.791,13.567,7.062,4.329,2.166,8.662,4.326,13.031,6.411a262.663,262.663,0,0,0,31.165,12.684,2.039,2.039,0,0,0,2.46-1.4c3.64-10.333,7.279-20.666,11.139-30.919a2,2,0,0,0-.919-2.259A440.824,440.824,0,0,1,98.681,182.11a18.285,18.285,0,0,1-2.434-1.572,19.151,19.151,0,0,1-1.77-2q-1.541-1.818-2.952-3.738c-2.04-2.766-3.929-5.64-5.76-8.548-3.616-5.745-6.986-11.65-10.814-17.26-3.855-5.649-8.24-11.209-14.11-14.879-2.189-1.369-4.2,2.091-2.019,3.454,4.965,3.1,8.757,7.81,12.067,12.562,3.869,5.554,7.238,11.436,10.818,17.177,1.824,2.924,3.7,5.82,5.712,8.617q1.486,2.066,3.082,4.053a24.789,24.789,0,0,0,3.361,3.805,52.105,52.105,0,0,0,5.333,3.364q2.636,1.643,5.281,3.27,4.873,2.993,9.805,5.89,11.664,6.819,23.828,12.713l-.919-2.259c-3.86,10.253-7.5,20.587-11.139,30.919l2.46-1.4c-18.3-6-35.31-14.792-52.514-23.322a91.3,91.3,0,0,1-11.7-7.389q-5.217-3.667-10.087-7.788A107.552,107.552,0,0,1,35.927,178.7c-5.849-8.168-10.512-18.238-8.965-28.544a2.065,2.065,0,0,0-1.4-2.46,2.015,2.015,0,0,0-2.461,1.4Z"/><path class="b" d="M52.768,131.433c-5.56-2.413-11.855-3.419-17.707-1.386a18.353,18.353,0,0,0-10.982,9.973,2.068,2.068,0,0,0,.718,2.736,2.014,2.014,0,0,0,2.736-.717,14.516,14.516,0,0,1,8.592-8.135,20.21,20.21,0,0,1,14.624.983,2.065,2.065,0,0,0,2.736-.717,2.015,2.015,0,0,0-.717-2.737Z"/><path class="b" d="M85.691,291.03c-1.638,8.536-2.684,17.212-4.032,25.8-.231,1.469-.439,2.945-.719,4.406-.483,2.515,3.371,3.593,3.857,1.063,1.638-8.536,2.684-17.212,4.032-25.8.231-1.469.439-2.946.719-4.407.483-2.515-3.372-3.592-3.857-1.063Z"/><path class="b" d="M13.546,282.225c-.525,4.076-.562,8.258-.78,12.358q-.477,9.013-.907,18.03c-.106,2.162-.209,4.324-.324,6.486-.137,2.572,3.863,2.565,4,0,.562-10.536,1-21.079,1.627-31.612.105-1.75.16-3.521.384-5.262a2.01,2.01,0,0,0-2-2,2.052,2.052,0,0,0-2,2Z"/><path class="b" d="M255.424,147.261c-.14,6.583-.611,13.2-.068,19.78a117.477,117.477,0,0,0,3.017,16.668c1.168,5.05,2.341,10.075,3.194,15.189a101.464,101.464,0,0,1,1.854,16.521c0,4.681-.543,9.4-.742,14.076q-.327,7.676-.362,15.358c-.034,6.146.053,12.292.2,18.436q.062,2.535.137,5.069c.054,1.835-.219,4.035.755,5.679,1.251,2.111,3.93,2.491,6.122,3.017a120.506,120.506,0,0,0,17.986,2.834c6.287.529,12.79.663,18.982-.726,2.511-.563,1.448-4.421-1.063-3.857a55.9,55.9,0,0,1-15.679.748,116.211,116.211,0,0,1-16-2.155,61.022,61.022,0,0,1-6.085-1.467c-1.332-.421-.942-1.64-.98-2.872q-.082-2.687-.151-5.373c-.154-6.093-.249-12.188-.23-18.284.031-9.591.482-19.147,1.057-28.717.328-5.462-.629-11.054-1.471-16.432-.747-4.766-1.66-9.465-2.751-14.166-1.378-5.938-2.989-11.949-3.646-18.022-.764-7.07-.228-14.215-.077-21.3.055-2.575-3.945-2.574-4,0Z"/><path class="b" d="M300.739,98.953a183.787,183.787,0,0,1,16.086,10.539,82.628,82.628,0,0,1,12.2,10.3,32.66,32.66,0,0,1,5.3,7.352,47.859,47.859,0,0,1,3.18,8.841c1.79,6.337,3.5,12.7,5.037,19.1a222.816,222.816,0,0,1,5.779,36.2A269.269,269.269,0,0,1,348.154,227c-.907,14.506-2.418,28.968-3.716,43.442l2-2a134.688,134.688,0,0,1-14.279-.124c-5.224-.224-10.443-.546-15.66-.886-2.57-.167-2.559,3.833,0,4,5.217.34,10.436.661,15.66.886a134.423,134.423,0,0,0,14.279.124,2.063,2.063,0,0,0,2-2c2.261-25.212,5.477-50.6,4.08-75.953a222.808,222.808,0,0,0-5.373-37.254c-1.455-6.383-3.121-12.717-4.868-19.026-1.752-6.327-3.508-12.571-7.566-17.861-3.855-5.025-8.737-9-13.78-12.772A183.437,183.437,0,0,0,302.758,95.5c-2.234-1.288-4.251,2.167-2.019,3.454Z"/><path class="b" d="M301.215,156.847l0-.008-3.857,1.063c3.9,10.212,7.75,20.446,11.656,30.657q1.735,4.539,3.486,9.072c1.712,4.439,3.3,8.885,3.481,13.68.337,8.867-.87,17.745-1.493,26.573a221.883,221.883,0,0,0,.014,31.547c.183,2.553,4.185,2.573,4,0a214.535,214.535,0,0,1-.223-28.393c.547-8.971,1.72-17.926,1.745-26.922a39.776,39.776,0,0,0-2.055-13.18c-1.246-3.668-2.732-7.263-4.118-10.881q-3.918-10.22-7.8-20.454c-1.616-4.253-3.216-8.512-4.84-12.762a2.057,2.057,0,0,0-2.46-1.4,2.015,2.015,0,0,0-1.4,2.46l0,.008a2.056,2.056,0,0,0,2.46,1.4,2.016,2.016,0,0,0,1.4-2.46Z"/><path class="b" d="M296.583,93.846c3.247,4,6.214,8.3,7.807,13.248l.919-2.258a146.811,146.811,0,0,1-14.525,8.9,2.033,2.033,0,0,0-.4,3.141,50.368,50.368,0,0,1,3.769,5.654l.312-2.423a41.1,41.1,0,0,1-4.552,4.385c-2.452,2.151-4.969,4.23-7.5,6.289-5.308,4.318-10.695,8.538-16.115,12.713a2.067,2.067,0,0,0-.717,2.736,2.013,2.013,0,0,0,2.736.718c5.6-4.313,11.169-8.664,16.654-13.12,2.551-2.072,5.088-4.164,7.563-6.328a42.333,42.333,0,0,0,4.759-4.565,2.078,2.078,0,0,0,.312-2.424,57.406,57.406,0,0,0-4.393-6.463l-.405,3.141a147.117,147.117,0,0,0,14.525-8.9,2.05,2.05,0,0,0,.919-2.259c-1.816-5.642-5.135-10.449-8.836-15.013a2.012,2.012,0,0,0-2.828,0,2.046,2.046,0,0,0,0,2.828Z"/><path class="b" d="M261.354,112.068c-3.551,1.886-5.756,5.5-7.372,9.056a73.626,73.626,0,0,0-3.814,10.8c-2.019,7.261-3.119,14.671-4.644,22.034a75.6,75.6,0,0,1-3.1,11.168c-1.084,2.9-2.468,5.985-4.738,8.157-1.466,1.4-3.638,2.242-5.4,3.232q-2.871,1.619-5.743,3.236c-3.508,1.973-7.02,3.94-10.552,5.87q-12.228,6.681-24.856,12.568a2.039,2.039,0,0,0-.718,2.737,269.487,269.487,0,0,1,11.522,28.04,2.033,2.033,0,0,0,2.46,1.4,472.285,472.285,0,0,0,45.811-17.543,2.013,2.013,0,0,0,.718-2.736,2.053,2.053,0,0,0-2.737-.718,462.434,462.434,0,0,1-44.855,17.14l2.46,1.4a278.693,278.693,0,0,0-11.925-29l-.717,2.736c15.145-7.073,29.673-15.221,44.233-23.409a13.9,13.9,0,0,0,4.168-3.258,22.9,22.9,0,0,0,2.679-4.1,52.668,52.668,0,0,0,3.923-10.657c1.921-7.206,2.808-14.643,4.508-21.9a98.688,98.688,0,0,1,3.757-12.734c1.416-3.706,3.276-8.111,6.95-10.062,2.274-1.207.255-4.661-2.019-3.454Z"/><path class="b" d="M261.3,197.226c0,.162-.008.323-.011.485s.077.494.019-.04a2.53,2.53,0,0,1-.176.809c-.079.28-.179.55-.283.821.191-.5.031-.081-.026.033-.087.172-.173.344-.267.513-.147.265-.306.523-.474.775-.1.154-.21.3-.316.455-.289.414.12-.125-.136.18a21.735,21.735,0,0,1-1.559,1.695,37.017,37.017,0,0,1-9.883,6.42,2.018,2.018,0,0,0-.717,2.736,2.043,2.043,0,0,0,2.736.718,39.174,39.174,0,0,0,10.957-7.306c2.192-2.2,4.171-5.066,4.136-8.294a2,2,0,0,0-4,0Z"/><path class="a" d="M294.6,96.344c.855-1.279,1.67-3.328,2.48-4.629a37.038,37.038,0,0,0-2.018-5.244c-10.58,4.539-19.984,9.23-29.22,12.408,3.179,4.386,11.393,10.838,13.014,12.106a126.29,126.29,0,0,0,10.695-9.092A34.254,34.254,0,0,0,294.6,96.344Z"/><path class="b" d="M296.329,97.354a32.918,32.918,0,0,0,1.609-3.019c.627-1.25,1.369-2.142.92-3.586a40.684,40.684,0,0,0-2.067-5.288,2.049,2.049,0,0,0-2.737-.717c-9.556,4.109-18.9,8.8-28.742,12.207-1.1.38-2.015,1.826-1.195,2.938,3.6,4.881,8.578,8.8,13.327,12.51a2.078,2.078,0,0,0,2.424.313,66.178,66.178,0,0,0,7.738-6.331c3.12-2.75,6.362-5.581,8.723-9.027,1.459-2.129-2.006-4.132-3.454-2.019-2.147,3.134-5.257,5.714-8.1,8.218a61.942,61.942,0,0,1-6.928,5.7l2.424.313q-2.958-2.313-5.8-4.774a45.453,45.453,0,0,1-6.9-6.927l-1.2,2.938c10.169-3.522,19.825-8.365,29.7-12.611l-2.736-.717a48.5,48.5,0,0,1,1.816,4.767l.2-1.541c-.9,1.5-1.534,3.151-2.48,4.629C291.484,97.51,294.944,99.518,296.329,97.354Z"/><path class="b" d="M324.635,116.623a24.716,24.716,0,0,0-20.665,4.1,26.921,26.921,0,0,0-9.943,16.1,28.062,28.062,0,0,0-.3,9.807,2.013,2.013,0,0,0,2.46,1.4,2.051,2.051,0,0,0,1.4-2.46c-1.629-11,5.484-22.709,16.58-25.211a20.64,20.64,0,0,1,9.409.13c2.5.611,3.566-3.245,1.063-3.857Z"/><path class="b" d="M296.583,91.018A447.973,447.973,0,0,0,264.4,133.525q-4.411,6.54-8.707,13.157c-1.41,2.163,2.052,4.17,3.454,2.019,9.611-14.738,19.5-29.316,30.476-43.079q4.774-5.985,9.784-11.776c1.675-1.939-1.142-4.78-2.828-2.828Z"/><path class="b" d="M270.508,108.512c-1.563,4.107-2.778,8.378-4.09,12.568-1.664,5.314-3.4,10.644-4.694,16.062-.6,2.5,3.257,3.57,3.857,1.064,1.3-5.419,3.03-10.749,4.694-16.062,1.312-4.191,2.527-8.462,4.09-12.568a2.016,2.016,0,0,0-1.4-2.461,2.046,2.046,0,0,0-2.461,1.4Z"/><path class="b" d="M264.9,99.372c-2.155.764-3.94,2.057-4.162,4.492-.113,1.244-.116,2.509-.175,3.757-.079,1.686-.165,3.373-.194,5.06,0,.3,0,.59-.006.885,0,.338.087-.511.014,0-.015.106-.044.216-.065.321-.119.6-.232,1.2-.343,1.8-1.325,7.181-2.422,14.413-3.4,21.65-.462,3.439-.947,6.895-1.145,10.362-.147,2.571,3.854,2.563,4,0,.362-6.35,1.437-12.695,2.405-18.973.516-3.35,1.057-6.7,1.644-10.035.215-1.219.435-2.438.676-3.652a24.243,24.243,0,0,0,.26-3.887c.063-1.779.154-3.556.236-5.334.023-.488-.012-1.014.059-1.5.1-.69.574-.843,1.255-1.085,2.409-.855,1.372-4.721-1.063-3.857Z"/><path class="b" d="M268.831,275.752a53.4,53.4,0,0,0,.527,5.357c.04.244-.076-.638-.016-.109.017.148.037.3.055.443.051.426.1.853.147,1.279.3,2.64.568,5.283.842,7.926.677,6.538,1.332,13.079,2.027,19.615.216,2.034.382,4.089.712,6.108a2.015,2.015,0,0,0,2.46,1.4,2.047,2.047,0,0,0,1.4-2.46c-.1-.64.029.3-.023-.152-.042-.367-.089-.733-.131-1.1-.123-1.065-.237-2.131-.351-3.2q-.477-4.459-.93-8.924c-.632-6.146-1.242-12.3-1.917-18.436-.284-2.585-.638-5.148-.8-7.747-.158-2.557-4.159-2.575-4,0Z"/><path class="b" d="M65.563,136.432a79.949,79.949,0,0,1-4.856-9.649c-1.72-3.6-3.418-7.375-5.851-10.566a2.065,2.065,0,0,0-2.736-.718,2.013,2.013,0,0,0-.718,2.736A59.256,59.256,0,0,1,57.253,128.8a80.17,80.17,0,0,0,4.856,9.649c1.408,2.142,4.873.141,3.454-2.019Z"/><path class="b" d="M16.809,119.084c.428.049-.1-.018-.018-.006l.466.07c.393.061.786.13,1.178.2.921.166,1.839.348,2.756.535,2.361.481,4.714,1,7.065,1.528,4.6,1.034,9.192,2.114,13.778,3.209,1,.238,2,.544,3.008.718A2.026,2.026,0,0,0,47.4,124.18a1.977,1.977,0,0,0-.818-2.5c-.088-.038-.4-.179-.488-.205-2.48-.707-3.539,3.152-1.063,3.857l-.468-.2,1.541-3.655c-2.817-.487-5.615-1.342-8.4-1.995-4.954-1.164-9.913-2.317-14.9-3.347-1.987-.41-3.982-.823-6-1.055a2.012,2.012,0,0,0-2,2,2.047,2.047,0,0,0,2,2Z"/><path class="b" d="M144.912,166.778c3.1,5.757,6.557,11.315,9.763,17.013,1.262,2.244,4.719.229,3.454-2.019-3.206-5.7-6.663-11.256-9.763-17.012-1.221-2.268-4.675-.25-3.454,2.018Z"/><path class="b" d="M190.461,171.941,176.25,184.035a2.017,2.017,0,0,0,0,2.829,2.042,2.042,0,0,0,2.828,0l14.211-12.095a2.016,2.016,0,0,0,0-2.828,2.042,2.042,0,0,0-2.828,0Z"/><path class="b" d="M172,157.469c-2.14,8.136-4.019,16.352-5.864,24.559-.563,2.507,3.292,3.577,3.858,1.063,1.844-8.206,3.724-16.423,5.863-24.558.655-2.492-3.2-3.555-3.857-1.064Z"/><path class="b" d="M138.205,181.533c1.819,1.818,3.606,3.668,5.382,5.527a2.02,2.02,0,0,0,2.829,0,2.042,2.042,0,0,0,0-2.829c-1.777-1.858-3.563-3.709-5.382-5.526a2,2,0,0,0-2.829,2.828Z"/><path class="b" d="M56.164,116.853c.819-2.01,2.281-4.859,3.372-7.147q.52-1.091,1.033-2.186c.217-.465.49-1.588.882-1.906-.094.076-.432.065.236.114.342.025.705.141,1.045.2a25.151,25.151,0,0,0,2.6.28c6.236.34,13.31-.9,17.186-6.226a22.692,22.692,0,0,0,3.344-7.948c.343-1.37.623-2.757.856-4.15a34.85,34.85,0,0,1,.527-3.9c.734-2.51,3.44-3.544,4.7-5.695,1.741-2.966-.066-6.274-2.643-8-2.317-1.552-3.329-3.676-3.878-6.386a43.722,43.722,0,0,1-.514-8.908c.015-2.575-3.985-2.578-4,0-.03,5.144-.194,11.229,2.936,15.623a10.723,10.723,0,0,0,2.871,2.775c.813.536,2.182,1.4,1.92,2.6-.163.749-1.254,1.435-1.8,1.908a10.886,10.886,0,0,0-2.9,3.764c-1.026,2.3-1.013,5.081-1.533,7.539a24.251,24.251,0,0,1-2.641,7.71,9.957,9.957,0,0,1-6.7,4.6,25.2,25.2,0,0,1-9.267.559c-1.875-.267-3.636-.808-5.174.72-1.137,1.131-1.689,3.113-2.366,4.536-1.336,2.809-2.775,5.585-3.949,8.468a2.012,2.012,0,0,0,1.4,2.46,2.05,2.05,0,0,0,2.46-1.4Z"/><path class="b" d="M45.2,63.777c-2.263-3.231-6.177-5.77-10.18-4-3.18,1.408-4.325,5.039-4.257,8.283a19.1,19.1,0,0,0,10.482,16.4,2.052,2.052,0,0,0,2.737-.717,2.019,2.019,0,0,0-.718-2.737A15.279,15.279,0,0,1,34.9,69.7c-.275-1.8-.365-4.417,1.057-5.806,1.916-1.873,4.629.241,5.793,1.9a2.053,2.053,0,0,0,2.736.718,2.018,2.018,0,0,0,.718-2.737Z"/><path class="b" d="M82.982,85.517a21.243,21.243,0,0,1-2.509-.142l.532.071a5.246,5.246,0,0,1-1.341-.331l.478.2a2.718,2.718,0,0,1-.58-.339l.4.313-.021-.017a2.222,2.222,0,0,0-1.414-.586,2.037,2.037,0,0,0-1.415.586,2.009,2.009,0,0,0-.585,1.414,1.933,1.933,0,0,0,.585,1.414,4.722,4.722,0,0,0,.993.662,6.2,6.2,0,0,0,1.317.454,19,19,0,0,0,3.556.3,2.05,2.05,0,0,0,1.414-.585,2,2,0,0,0-1.414-3.415Z"/><path class="b" d="M77.677,62.586c.53,1.674.3,5.554-2.724,5.942-4,.053-4.322-4.627-3.025-6.855C72.991,59.849,76.217,59.036,77.677,62.586Z"/><path class="b" d="M23.2,98.321c.241-5.27-3.3-8.99-6.3-12.858A72.24,72.24,0,0,1,9.033,72.624a49.374,49.374,0,0,1-4.8-14.819,44.484,44.484,0,0,1,1.2-15.951,25.048,25.048,0,0,1,7.11-12.885c1.906-1.739-.929-4.562-2.828-2.829C2.023,33.162-.141,44.7.007,54.687A43.4,43.4,0,0,0,3.7,70.436a77.332,77.332,0,0,0,7.844,14.438c1.4,2.023,2.99,3.882,4.484,5.827,1.747,2.275,3.309,4.64,3.173,7.62-.118,2.574,3.882,2.568,4,0Z"/><path class="b" d="M36.658,80.88A25.7,25.7,0,0,1,29.493,88a39.581,39.581,0,0,1-9.249,4.92,2.052,2.052,0,0,0-1.4,2.46,2.017,2.017,0,0,0,2.46,1.4A43.161,43.161,0,0,0,31.74,91.294,30.3,30.3,0,0,0,40.112,82.9c1.364-2.192-2.095-4.2-3.454-2.019Z"/><path class="f" d="M82.911,54.989c2.017-24.547-15.026-33.715-27.255-36.25a46.12,46.12,0,0,0-34.507,6C13.719,29.3,4.516,40.22,5.491,59.458c.4,8.91,3.429,18.828,10.522,28.912,1.217,1.731,2.545,3.6,3.76,5.567"/><path class="b" d="M69.359,82.205a29.45,29.45,0,0,0-.8,2.991,2.115,2.115,0,0,0,.2,1.541,2,2,0,0,0,2.736.718,2,2,0,0,0,.919-1.195,29.468,29.468,0,0,1,.8-2.992,1.512,1.512,0,0,0,.035-.8,1.492,1.492,0,0,0-.237-.744,2,2,0,0,0-2.736-.717,2.17,2.17,0,0,0-.919,1.195Z"/><path class="b" d="M84.911,54.989c.028-4.323.314-8.714-.652-12.967a2.015,2.015,0,0,0-2.46-1.4,2.044,2.044,0,0,0-1.4,2.46q.169.743.285,1.5c.016.1.031.2.045.308q-.039-.281.007.092c.028.281.06.562.084.844.086,1.008.125,2.019.141,3.03.031,2.045-.039,4.089-.053,6.134a2,2,0,1,0,4,0Z"/><path class="b" d="M74.776,40.893a36.787,36.787,0,0,1-7.548.981c-2.456.131-4.919.16-7.378.1-2.575-.059-2.574,3.941,0,4,5.277.121,10.849.09,15.99-1.228,2.492-.638,1.435-4.5-1.064-3.857Z"/><path class="b" d="M59.85,41.978c-2.691.027-3.924,3.326-4.767,5.388-.482,1.178-.9,2.382-1.3,3.59-.157.474-.309.949-.465,1.422-.079.24-.5,1.3-.132.468l3.141-.4c-1.359-1.309-2.528-3.31-4.45-3.856C49.544,47.922,48.157,50,47.3,51.818c-1.833,3.869-3.658,7.744-5.373,11.668a2.065,2.065,0,0,0,.718,2.736,2.014,2.014,0,0,0,2.736-.717c1.526-3.491,3.14-6.942,4.766-10.386q.372-.787.744-1.572c.109-.231.212-.466.333-.691.236-.437.635-.587-.067-.5-.622.081-.509-.107-.392.089.068.113.164.123.232.178a9.058,9.058,0,0,1,.838.836c.558.6,1.075,1.239,1.665,1.808.834.8,2.607.817,3.141-.405.735-1.682,1.183-3.488,1.823-5.208a18.027,18.027,0,0,1,1.231-2.8c.115-.209.237-.413.364-.616.058-.092.122-.181.184-.271.163-.235-.22.237-.036.051a2.294,2.294,0,0,0,.185-.2c.158-.2.124,0,.029-.038-.028-.012-.08.067-.164.1s-.623.1-.405.1c2.572-.026,2.579-4.026,0-4Z"/><path class="b" d="M82.449,43.538c3.494-1.629,4.563-6.225,3.984-9.729a15.5,15.5,0,0,0-4.987-8.784A48.074,48.074,0,0,0,64.411,14.833c-1.563-.522-2.717,1.066-2.46,2.46h0l2.938-2.258c-6.159-2.777-13.292-3.6-19.983-3.664C36.443,11.3,27.66,12.752,20.167,16.85A30.981,30.981,0,0,0,9.4,26.545c-1.456,2.131,2.009,4.134,3.454,2.019C21.565,15.822,40.115,13.827,54.074,16.12A48.886,48.886,0,0,1,59.2,17.228c.7.192,1.39.4,2.074.64.34.118.677.241,1.012.372l.318.127c.318.129-.23-.1.271.121a2.03,2.03,0,0,0,2.938-2.258h0l-2.46,2.46A42.649,42.649,0,0,1,77.5,26.861,13.834,13.834,0,0,1,82.131,33.1c.719,2.169.847,5.8-1.7,6.986a2.018,2.018,0,0,0-.718,2.737,2.047,2.047,0,0,0,2.737.717Z"/><path class="b" d="M192.12,199.736c-2.249.775-4.465,1.644-6.714,2.418a2.032,2.032,0,0,0-1.4,2.461,184.237,184.237,0,0,0,9.7,24.148,2.005,2.005,0,0,0,2.259.919c2.411-.9,4.848-1.732,7.26-2.632,2.39-.893,1.355-4.761-1.063-3.857s-4.849,1.731-7.261,2.632l2.259.919a176.7,176.7,0,0,1-9.3-23.193l-1.4,2.46c2.249-.774,4.464-1.643,6.713-2.418,2.42-.833,1.38-4.7-1.063-3.857Z"/><path class="b" d="M138.675,210.927c2.507.981,5.007,1.982,7.53,2.921l-1.4-2.46c-2.528,8.647-5.325,17.24-8.626,25.626l2.46-1.4c-2.776-.969-5.535-1.986-8.311-2.955-2.435-.85-3.482,3.013-1.063,3.857,2.776.969,5.535,1.987,8.311,2.955a2.044,2.044,0,0,0,2.46-1.4c3.3-8.385,6.1-16.978,8.626-25.626a2.047,2.047,0,0,0-1.4-2.46c-2.523-.939-5.024-1.94-7.53-2.921a2.015,2.015,0,0,0-2.461,1.4,2.047,2.047,0,0,0,1.4,2.46Z"/><path class="b" d="M261.245,98.208q-1.176,3.036-2.191,6.131-.505,1.547-.969,3.108c-.154.52-.3,1.042-.453,1.563-.028.1-.229.627-.027.2a1.921,1.921,0,0,1-.158.284,1.266,1.266,0,0,1,1.007-.591,2.018,2.018,0,0,0-2,2,2.038,2.038,0,0,0,2,2c1.627.041,2.595-1.305,3-2.721.356-1.228.712-2.456,1.1-3.676q1.156-3.659,2.547-7.238a2.007,2.007,0,0,0-1.4-2.46,2.057,2.057,0,0,0-2.46,1.4Z"/></svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_business_partner, verbose=True)
print(answer)
# COMMAND ----------
displayHTML("""<h2>Career Coach</h2><br>
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg fill="#000000" height="150px" width="150px" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
viewBox="0 0 477.13 477.13" xml:space="preserve">
<g>
<path d="M254.604,108.371c25.443,0,46.143-20.699,46.143-46.142c0-25.443-20.7-46.144-46.143-46.144
c-25.437,0-46.131,20.7-46.131,46.144C208.473,87.672,229.167,108.371,254.604,108.371z"/>
<path d="M368.937,6.477C365.252,2.421,359.736,0,354.178,0c-9.97,0-17.132,7.021-19.164,18.799L325,79.645
c-0.059,0.411-0.478,1.479-0.755,1.947l-36.277,37.99h-66.716L184.973,81.59c-0.276-0.467-0.697-1.538-0.763-1.996L174.201,18.78
C172.204,7.196,164.863,0,155.04,0c-5.849,0-11.774,2.686-15.467,7.01c-3.095,3.625-4.408,8.089-3.695,12.583l9.975,60.788
c0.064,9.399,4.6,20.647,11.071,27.426l41.867,43.844v55.683h-72.559l7.303-30.201c0.982-4.056,4.709-10.28,7.822-13.059
l6.605-5.896c3.241,2.591,7.342,4.151,11.805,4.151c10.449,0,18.95-8.501,18.95-18.95c0-10.449-8.501-18.95-18.95-18.95
s-18.95,8.501-18.95,18.95c0,1.182,0.123,2.334,0.331,3.456l-8.447,7.542c-5.115,4.565-10.188,13.034-11.801,19.7l-8.042,33.257
h-2.85c-1.979,0-3.786,0.827-4.96,2.271c-1.174,1.443-1.615,3.382-1.212,5.319l9.33,44.754c0.76,3.643,4.27,6.496,7.99,6.496
h12.123l15.468,162.145h-8.036c-7.622,0-13.822,6.2-13.822,13.821v21.17c0,7.621,6.2,13.821,13.822,13.821h182.977
c7.622,0,13.822-6.2,13.822-13.821v-21.17c0-7.621-6.2-13.821-13.822-13.821h-8.036l15.469-162.145h12.122
c3.721,0,7.23-2.854,7.99-6.496l9.33-44.754c0.403-1.938-0.038-3.876-1.212-5.319c-1.174-1.443-2.982-2.271-4.96-2.271h-43.962
v-55.682l41.869-43.846c6.472-6.78,11.005-18.028,11.069-27.425l9.975-60.788l0.022-0.162
C373.816,14.718,372.244,10.117,368.937,6.477z"/>
</g>
</svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_career_coach, verbose=True)
print(answer)
# COMMAND ----------
# MAGIC %md
# MAGIC ### Llama V2
# COMMAND ----------
displayHTML("""<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg width="150px" height="150px" fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
viewBox="0 0 512.001 512.001" xml:space="preserve">
<g>
<g>
<path d="M189.471,419.267v76.561h-18.923v-76.563h-16.173v84.65c0,4.467,3.621,8.087,8.087,8.087h35.096
c4.466,0,8.087-3.62,8.087-8.087v-84.648H189.471z"/>
</g>
</g>
<g>
<g>
<path d="M203.455,359.318v33.748c0,12.928-10.518,23.445-23.445,23.445c-8.059,0-15.459-4.065-19.794-10.873l-13.642,8.689
c7.321,11.494,19.821,18.357,33.436,18.357c21.846,0,39.619-17.774,39.619-39.619v-33.748H203.455z"/>
</g>
</g>
<g>
<g>
<path d="M346.704,419.267v76.561h-18.923v-76.563h-16.174v84.65c0,4.467,3.621,8.087,8.087,8.087h35.096
c4.466,0,8.087-3.62,8.087-8.087v-84.648H346.704z"/>
</g>
</g>
<g>
<g>
<path d="M360.687,347.462v45.604c0,12.928-10.518,23.445-23.445,23.445c-8.059,0-15.458-4.064-19.793-10.872l-13.642,8.687
c7.32,11.495,19.819,18.358,33.435,18.358c21.845,0,39.617-17.774,39.619-39.619v-45.604H360.687z"/>
</g>
</g>
<g>
<g>
<path d="M382.638,2.368c-3.158-3.156-8.279-3.158-11.436,0l-24.494,24.491c-3.317,3.314-5.143,7.722-5.142,12.413
c0.001,4.688,1.825,9.095,5.143,12.414c3.315,3.312,7.72,5.135,12.406,5.135c4.687,0,9.093-1.823,12.412-5.138l11.112-11.117
c5.102-5.102,7.911-11.885,7.911-19.1C390.549,14.251,387.74,7.47,382.638,2.368z M371.201,29.128l-11.11,11.114
c-0.333,0.333-0.715,0.402-0.976,0.402c-0.261,0-0.643-0.069-0.971-0.398c-0.334-0.334-0.404-0.716-0.404-0.977
c0-0.26,0.069-0.639,0.402-0.973l16.218-16.214C374.212,24.745,373.103,27.228,371.201,29.128z"/>
</g>
</g>
<g>
<g>
<path d="M397.514,20.324h-16.369v16.173h16.369c12.712,0,24.692,6.205,32.044,16.602l13.204-9.34
C432.383,29.084,415.468,20.324,397.514,20.324z"/>
</g>
</g>
<g>
<g>
<path d="M392.943,122.871v164.854c0,35.018-28.489,63.508-63.509,63.508h-13.888c-4.466,0-8.087,3.62-8.087,8.087v33.748
c0,12.928-10.517,23.445-23.444,23.445c-12.928,0-23.445-10.517-23.445-23.445V359.32c0-4.467-3.621-8.087-8.087-8.087h-94.169
c-4.466,0-8.087,3.62-8.087,8.087v33.748c0,12.928-10.517,23.445-23.444,23.445c-12.928,0-23.445-10.517-23.445-23.445v-41.121
c0-3.076-1.745-5.885-4.502-7.249c-21.609-10.686-35.572-33.05-35.572-56.974v-35.798c0-7.922,1.478-15.689,4.393-23.085
c1.433-3.638,0.059-7.779-3.264-9.839c-5.207-3.226-8.314-8.783-8.314-14.866c0-9.649,7.85-17.499,17.499-17.499
c5.422,0,10.456,2.473,13.809,6.787c2.4,3.089,6.671,4.016,10.135,2.201c9.136-4.785,18.977-7.211,29.25-7.211h188.773
c4.466,0,8.087-3.62,8.087-8.087V75.769c0-0.046,0-0.098-0.001-0.15c0.047-19.36,14.486-36,33.623-38.727l-2.282-16.012
c-27.087,3.86-47.514,27.432-47.514,54.832c0,0.049,0,0.102,0.001,0.156v96.372H126.773c-10.685,0-21.355,2.206-31.197,6.417
c-6.061-5.266-13.795-8.195-21.999-8.195c-18.567,0-33.672,15.105-33.672,33.672c0,9.471,3.898,18.274,10.671,24.574
c-2.315,7.522-3.486,15.307-3.486,23.215v35.798c0,28.328,15.574,54.9,40.074,69.06v36.283c0,21.846,17.773,39.619,39.619,39.619
c21.845,0,39.617-17.772,39.617-39.619v-25.661h77.995v25.661c0,21.846,17.773,39.619,39.619,39.619
c21.845,0,39.617-17.774,39.619-39.619v-25.661h5.801c43.937,0,79.682-35.745,79.682-79.681V122.871H392.943z"/>
</g>
</g>
<g>
<g>
<path d="M452.354,68.138c-1.199-8.781-4.47-17.115-9.604-24.372c-1.516-2.142-3.977-3.417-6.602-3.417h-59.178
c-4.466,0-8.087,3.62-8.087,8.087c0,1.667-0.872,3.167-2.333,4.012c-3.382,1.956-4.882,6.051-3.564,9.729
c0.19,0.528,0.281,1.037,0.281,1.554c0,1.247-0.492,2.418-1.385,3.297c-2.049,2.014-2.873,4.965-2.168,7.75
c0.706,2.786,2.837,4.988,5.598,5.784c10.216,2.947,17.352,12.437,17.352,23.08c0,5.397-1.754,10.5-5.074,14.756
c-1.901,2.437-2.246,5.745-0.89,8.521c1.355,2.776,4.176,4.538,7.266,4.538h55.062c18.233,0,33.066-14.831,33.066-33.062
C472.096,85.037,464.223,73.321,452.354,68.138z M439.029,115.283h-41.895c1.127-3.731,1.703-7.637,1.704-11.643
c0-14.476-7.894-27.679-20.035-34.762c0.422-1.662,0.638-3.388,0.638-5.149c0-0.357-0.01-0.714-0.028-1.071
c1.684-1.799,3.035-3.88,3.994-6.137h48.298c3.048,5.428,4.753,11.526,4.967,17.85c0.124,3.65,2.678,6.764,6.232,7.598
c7.664,1.801,13.016,8.555,13.016,16.424C455.922,107.707,448.344,115.283,439.029,115.283z"/>
</g>
</g>
<g>
<g>
<path d="M421.117,63.73c-3.097,0-5.605,2.506-5.605,5.606c0,3.096,2.509,5.604,5.605,5.604c3.095,0,5.604-2.508,5.604-5.604
C426.72,66.236,424.211,63.73,421.117,63.73z"/>
</g>
</g>
<g>
<g>
<path d="M459.652,70.633h-4.897c-4.466,0-8.087,3.62-8.087,8.087s3.621,8.087,8.087,8.087h4.897c4.466,0,8.087-3.62,8.087-8.087
S464.118,70.633,459.652,70.633z"/>
</g>
</g>
<g>
<g>
<path d="M136.244,419.267v76.561h-18.923v-76.552h-16.174v84.639c0,4.467,3.621,8.087,8.087,8.087h35.096
c4.466,0,8.087-3.62,8.087-8.087v-84.648H136.244z"/>
</g>
</g>
<g>
<g>
<path d="M293.476,419.267v76.561h-18.923v-76.552h-16.173v84.639c0,4.467,3.621,8.087,8.087,8.087h35.096
c4.466,0,8.087-3.62,8.087-8.087v-84.648H293.476z"/>
</g>
</g>
</svg>""")
# COMMAND ----------
language_model = 'llamav2'
llm = switch_to_language_model(language_model)
# COMMAND ----------
displayHTML("""<h2>Doctor</h2><br>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg version="1.1" id="_x32_" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
width="150px" height="150px" viewBox="0 0 512 512" xml:space="preserve">
<style type="text/css">
<![CDATA[
.st0{fill:#000000;}
]]>
</style>
<g>
<path class="st0" d="M110.547,411.844c-5.234,5.813-9.141,12.5-11.328,19.266c-1.531,4.766-2.266,9.469-2.266,13.875
c0,2.688,0.266,5.25,0.844,7.672c0.438,1.797,1.031,3.516,1.828,5.094c0.594,1.203,1.313,2.344,2.156,3.375
c1.266,1.531,2.828,2.859,4.688,3.781c1.844,0.938,3.969,1.438,6.125,1.422v-9.766c-0.453,0-0.797-0.063-1.125-0.156
c-0.578-0.156-1.047-0.422-1.578-0.891c-0.375-0.359-0.781-0.828-1.156-1.469c-0.563-0.922-1.094-2.203-1.453-3.734
c-0.359-1.547-0.563-3.344-0.563-5.328c0-3.297,0.578-7.047,1.797-10.891c1.141-3.531,2.953-7.188,5.328-10.656
c3.547-5.219,8.391-9.984,13.984-13.391c2.781-1.703,5.781-3.078,8.891-4.016c3.125-0.938,6.391-1.438,9.766-1.438
c4.5,0,8.813,0.906,12.844,2.531c6.031,2.406,11.484,6.453,15.844,11.281c4.344,4.813,7.578,10.406,9.266,15.688
c1.234,3.844,1.813,7.594,1.813,10.891c0,2.016-0.219,3.844-0.594,5.391c-0.266,1.156-0.641,2.188-1.047,3
c-0.313,0.625-0.641,1.125-0.984,1.547c-0.5,0.609-1,1-1.484,1.25c-0.5,0.234-1.016,0.375-1.766,0.391v9.766
c1.281,0.016,2.547-0.172,3.75-0.5c2.109-0.578,4-1.672,5.547-3.094c1.156-1.063,2.125-2.281,2.922-3.609
c1.219-2,2.063-4.219,2.609-6.594s0.813-4.906,0.813-7.547c0-4.406-0.734-9.125-2.266-13.875
c-1.453-4.516-3.672-8.984-6.547-13.188c-4.313-6.297-10.063-12.016-16.969-16.234c-3.453-2.094-7.188-3.813-11.172-5
c-3.984-1.219-8.203-1.875-12.578-1.875c-5.828,0-11.391,1.188-16.469,3.234C122.375,401.109,115.781,406.047,110.547,411.844z"/>
<path class="st0" d="M165.594,452.109c-1.594,1.266-2.531,3.172-2.531,5.219v7.891c0,2.031,0.938,3.953,2.531,5.219
c1.594,1.25,3.688,1.719,5.656,1.25l5.266-1.25v-18.344l-5.266-1.25C169.281,450.375,167.188,450.844,165.594,452.109z"/>
<path class="st0" d="M121.719,450.844l-5.281,1.25v18.344l5.281,1.25c1.969,0.469,4.063,0,5.656-1.25
c1.594-1.266,2.531-3.188,2.531-5.219v-7.891c0-2.047-0.938-3.953-2.531-5.219S123.688,450.375,121.719,450.844z"/>
<path class="st0" d="M453.453,429.594c-2.016-7.531-4.859-14.281-8.359-20.281c-6.141-10.547-14.266-18.75-23.234-25.25
c-6.734-4.875-13.922-8.859-21.234-12.281c-10.953-5.125-22.156-9.063-32.5-12.891c-10.344-3.813-19.797-7.547-27.156-11.891
c-2.688-1.594-5.109-3.25-7.203-4.984c-3.125-2.609-5.563-5.391-7.328-8.5s-2.953-6.609-3.406-10.984
c-0.328-3.125-0.469-6.063-0.469-8.875c0-8.281,1.219-15.453,2.781-22.781c4.625-5.219,8.859-11.438,12.859-18.875
c4.016-7.484,7.828-16.219,11.625-26.563c2.438-1.109,4.891-2.438,7.281-4.063c5.469-3.656,10.656-8.781,14.984-15.609
c4.313-6.828,7.781-15.313,10.156-25.781c0.656-2.906,0.969-5.797,0.969-8.641c0.016-5.938-1.391-11.594-3.75-16.656
c-1.641-3.516-3.719-6.734-6.141-9.656c1.234-4.563,2.734-10.703,4.078-17.891c1.844-9.984,3.375-21.984,3.375-34.594
c0-8.141-0.641-16.547-2.297-24.844c-1.234-6.219-3.063-12.391-5.625-18.297c-3.859-8.891-9.469-17.25-17.266-24.156
c-7.219-6.391-16.266-11.484-27.188-14.75c-3.859-4.625-7.734-8.563-11.703-11.906c-3.438-2.875-6.953-5.297-10.547-7.281
c-5.406-3-11-4.984-16.734-6.188s-11.578-1.641-17.641-1.641c-8.359,0-17.156,0.828-26.875,1.781
c-3.672,0.375-6.75,0.828-9.422,1.297c-3.984,0.719-6.969,1.453-9.359,1.938c-1.203,0.234-2.25,0.422-3.281,0.547
c-1.031,0.109-2.031,0.188-3.172,0.188c-1.531,0-3.297-0.125-5.609-0.453c-7.078-1.031-13.547-2.625-18.625-4.188
c-2.531-0.766-4.719-1.531-6.438-2.188c-0.859-0.328-1.609-0.625-2.203-0.875c-0.609-0.25-1.063-0.484-1.328-0.609l0.016,0.016
c-0.781-0.406-1.531-0.625-2.203-0.75C182.609,0.031,182.016,0,181.5,0c-1.078,0-1.844,0.156-2.453,0.313s-1.078,0.344-1.5,0.516
c-0.813,0.328-1.438,0.672-2.063,1.047c-1.141,0.688-2.234,1.453-3.391,2.344c-2.016,1.563-4.234,3.5-6.594,5.781
c-3.531,3.406-7.313,7.531-10.75,12.031c-1.719,2.234-3.328,4.578-4.781,7s-2.734,4.906-3.75,7.516
c-4.969,12.922-8.25,24.828-10.281,35.813c-2.047,10.984-2.828,21.047-2.828,30.281c0,15.109,2.109,27.922,4.141,38.75
c0,0.516,0.016,1,0.047,1.516c0.063,1.016,0.172,2.063,0.281,3.156c0.172,1.625,0.359,3.297,0.5,4.703
c0.078,0.703,0.141,1.328,0.188,1.813c0.016,0.234,0.031,0.453,0.031,0.609l0.016,0.156v0.047v0.016v0.922l1.984,8.828
c-2.859,3.125-5.328,6.625-7.25,10.469c-2.688,5.344-4.281,11.375-4.281,17.75c0,2.813,0.328,5.719,0.984,8.609
c1.563,6.984,3.641,13.078,6.125,18.391c3.719,7.984,8.438,14.188,13.656,18.844c4.047,3.625,8.375,6.266,12.656,8.219
c3.781,10.344,7.594,19.063,11.609,26.547c4,7.453,8.219,13.656,12.844,18.875c1.563,7.328,2.781,14.516,2.797,22.797
c0,2.813-0.156,5.75-0.484,8.875c-0.313,3-0.969,5.594-1.922,7.938c-1.422,3.5-3.5,6.484-6.328,9.313
c-2.828,2.781-6.438,5.391-10.703,7.813c-4.328,2.453-9.344,4.75-14.797,6.938c-9.563,3.875-20.469,7.531-31.516,11.953
c-8.281,3.297-16.672,7.063-24.672,11.766c-6,3.531-11.766,7.625-17.078,12.484c-7.953,7.281-14.813,16.359-19.547,27.578
c-4.75,11.234-7.391,24.531-7.375,40.25c0,2.219,0.469,4.328,1.234,6.281c0.703,1.828,1.688,3.5,2.844,5.094
c2.188,2.969,5,5.625,8.453,8.188c6.063,4.469,14.109,8.656,24.531,12.594c15.625,5.891,36.563,11.188,63.641,15.031
c27.063,3.844,60.266,6.25,100.266,6.25c34.703,0,64.266-1.797,89.156-4.781c18.656-2.25,34.703-5.156,48.313-8.484
c10.219-2.484,19.078-5.219,26.672-8.094c5.688-2.156,10.688-4.406,15.031-6.719c3.25-1.734,6.125-3.516,8.672-5.344
c3.813-2.766,6.875-5.609,9.203-8.844c1.172-1.609,2.125-3.328,2.828-5.203c0.703-1.844,1.125-3.875,1.125-5.969
C456.984,447.813,455.75,438.203,453.453,429.594z M327.266,358.094l-50.156,78.328l-5.594-38.453l14.234-15.063l-9.219-15.375
l38.906-20.453c1.078,1.391,2.219,2.703,3.422,3.953C321.438,353.672,324.266,356,327.266,358.094z M183.078,87.156
c45.219,10.031,133.641-9.141,133.641-9.141s0.953,21.922,16.031,42.047c5.938,7.906,10.828,20.266,14.5,32.016
c-0.984-1.828-3.297-2.516-6.75-2.953c-7.75-1.047-19.266-1.719-32.234-1.094c-38.531,1.891-35.672,5.391-50.797,5.391
s-12.266-3.5-50.797-5.391c-12.969-0.625-24.484,0.047-32.25,1.094c-4.031,0.531-6.563,1.344-7.141,4.031
c-0.203,1-0.516,2.125-1.906,2.672C169.641,139.891,181.516,119.531,183.078,87.156z M339.922,176.469
c0,0.219-0.156,22.313-15.188,29.859c-5.109,2.578-11.516,4-18.031,4.016c-6.875,0-13.156-1.563-18.172-4.516
c-5.547-3.25-9.281-8.078-11.109-14.313c-0.438-1.453-0.828-2.906-1.234-4.313c-1.188-4.297-4.391-16.234,2.406-21.484
c4.375-3.422,17.953-5.578,30.969-5.578c11.828,0,23.891,1.609,27.422,5.297C339.313,167.875,340.219,172.219,339.922,176.469z
M238.75,187.203c-0.406,1.406-0.813,2.859-1.234,4.313c-1.828,6.234-5.563,11.063-11.094,14.313
c-5.031,2.953-11.313,4.516-18.188,4.516c-6.516-0.016-12.906-1.438-18.031-4.016c-15.031-7.547-15.172-29.641-15.188-29.859
c-0.297-4.25,0.609-8.594,2.922-11.031c3.547-3.688,15.609-5.297,27.438-5.297c13,0,26.594,2.156,30.984,5.578
C243.141,170.969,239.938,182.906,238.75,187.203z M188.547,264.063c-3.922-7.313-7.828-16.406-11.844-27.75l-1.328-3.703
l-3.688-1.359c-2.563-0.938-5.063-2.156-7.453-3.766c-3.609-2.422-7.031-5.734-10.172-10.672s-5.953-11.563-7.984-20.516
c-0.391-1.703-0.547-3.328-0.547-4.922c0-3.594,0.859-7,2.5-10.25c1.344-2.703,3.219-5.25,5.5-7.563
c3.844,5.813,7.031,10.422,8.188,11.578c2.203,2.203,3.297,0.078,3.469-4.047c1.359,9.172,5.719,24.313,19.797,31.797
c20.266,10.766,50.516,6.734,60.781-17.234c4.641-10.813,4.703-21.375,11.703-21.375c6.984,0,7.063,10.563,11.703,21.375
c10.281,23.969,40.531,28,60.797,17.234c20.25-10.766,20.391-37.422,20.391-39.297c0-0.969,0.922-1.703,2.234-1.844
c1.719,7.234,2.609,12.141,2.609,12.141s1.938-3.703,4.844-8.641c1.734,2.031,3.172,4.219,4.234,6.5
c1.422,3.063,2.188,6.266,2.188,9.594c0,1.609-0.172,3.25-0.563,4.938c-1.344,5.969-3.047,10.906-4.953,15
c-2.875,6.125-6.188,10.344-9.656,13.438c-3.453,3.094-7.141,5.109-10.969,6.531l-3.703,1.344l-1.313,3.719
c-4.016,11.344-7.938,20.453-11.859,27.75c-3.938,7.313-7.844,12.813-11.906,17.094l-1.609,1.703l-0.5,2.266
c-1.813,8.359-3.625,17.594-3.625,28.531c0,3.375,0.172,6.891,0.547,10.594c0.453,4.344,1.453,8.422,2.938,12.172
c0.063,0.172,0.156,0.359,0.219,0.516l-50.891,26.766l-56.406-26.172c1.734-4.063,2.906-8.5,3.406-13.281
c0.391-3.703,0.547-7.219,0.547-10.594c0.016-10.938-1.797-20.188-3.625-28.547l-0.5-2.266l-1.609-1.688
C196.391,276.844,192.469,271.375,188.547,264.063z M188.094,355.594c2.938-2.359,5.641-5,8.031-7.969l43.016,19.969l-9.188,15.313
l14.219,15.063l-5.25,36.203l-54.875-75.609C185.438,357.609,186.797,356.625,188.094,355.594z M440.219,458.5
c-0.016,0.094-0.125,0.406-0.422,0.906c-0.563,0.969-1.875,2.531-4.094,4.313c-1.922,1.547-4.516,3.281-7.781,5.063
c-5.734,3.141-13.5,6.406-23.344,9.5c-14.781,4.656-34.297,8.906-58.922,12c-24.625,3.063-54.359,4.969-89.672,4.969
c-34.094,0-63-1.781-87.125-4.672c-18.094-2.172-33.5-4.984-46.344-8.109c-9.656-2.359-17.875-4.906-24.703-7.5
c-5.141-1.938-9.5-3.906-13.078-5.828c-2.688-1.438-4.953-2.859-6.797-4.172c-2.75-1.969-4.5-3.766-5.375-5
c-0.438-0.594-0.656-1.063-0.734-1.281c-0.047-0.094-0.063-0.156-0.063-0.188c0-9.375,1.063-17.406,2.906-24.375
c1.609-6.094,3.828-11.391,6.531-16.078c4.719-8.203,10.922-14.641,18.297-20.063c5.5-4.078,11.672-7.563,18.203-10.672
c7.328-3.484,15.109-6.484,22.922-9.375v16.875h5.859h5.859v-21.203c7.469-2.797,14.75-5.672,21.531-9.109l86.703,119.453
l75.75-118.266c0.234,0.359,0.469,0.719,0.688,1.063c3.156,5.078,5.359,10.609,6.828,16.875c1.453,6.25,2.125,13.25,2.125,21.047
c0,18.063,0,33.797,0,44.391H318.75v11.734h67v-11.734h-27.219c0-10.594,0-26.328,0-44.391c0-11.359-1.297-21.703-4.516-31.141
c-0.281-0.813-0.578-1.625-0.891-2.422c9.156,3.609,18.734,6.859,28.016,10.547c7.953,3.141,15.672,6.578,22.688,10.656
c5.281,3.063,10.172,6.5,14.516,10.406c6.516,5.922,11.859,12.906,15.703,21.859C437.875,433.516,440.219,444.516,440.219,458.5
L440.219,458.5z"/>
</g>
</svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_doctor, verbose=True)
print(answer)
# COMMAND ----------
displayHTML("""<h2>Father</h2><br>
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg height="150px" width="150px" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
viewBox="0 0 56.9 56.9" xml:space="preserve">
<g>
<g>
<circle style="fill:#010002;" cx="15.455" cy="28.5" r="3.4"/>
<circle style="fill:#010002;" cx="37.555" cy="4.8" r="4.8"/>
<path style="fill:#010002;" d="M44.855,10.6c-1.3-0.6-4-0.4-4.4-0.4l-2.4,4.8l0.3-4h0.1v-0.8h-1.5V11h0.1l0.3,4l-2.4-4.8
c-0.4,0-3.2-0.2-4.4,0.4c-2,0.7-6.3,3.9-9,18.7c-0.1,0.4,0,0.9,0.1,1.3c-1.1,0.8-2.9,1.7-6,1.7s-5.5,0.9-7.2,2.7
c-2.6,2.8-2.3,6.6-2.3,6.7c0.1,0.8,0.8,1.5,1.6,1.5h0.1c0.9-0.1,1.6-0.8,1.5-1.7c0,0-0.1-2.6,1.4-4.3c0.2-0.2,0.4-0.4,0.7-0.6v5
c0,0.5,0.1,1,0.3,1.5V55c0,0.9,0.8,1.7,1.7,1.7c0.9,0,1.7-0.8,1.7-1.7v-9.3c0.1,0,0.3,0,0.4,0c0.2,0,0.3,0,0.4,0V55
c0,0.9,0.8,1.7,1.7,1.7c0.9,0,1.7-0.8,1.7-1.7V43.1c0.2-0.5,0.3-1,0.3-1.5V35c2.5-0.7,4-1.9,4.9-2.8c0.9-0.3,1.6-1,1.8-1.9
c1.6-8.7,3.6-12.4,4.8-13.9v19.1v18.6c0,1.5,1.1,2.8,2.7,2.8s2.8-1.2,2.8-2.8V34.6c0,0,0.1-0.9,1.1-1c1,0,1.1,1,1.1,1v19.3
c0,1.5,1.3,2.8,2.8,2.8s2.7-1.2,2.7-2.8V35.3V19.4c0,0,1.2,4.3,1.3,7.9c0,3.3,5.2,3.3,5.1,0C50.455,12.9,44.855,10.6,44.855,10.6z
"/>
</g>
</g>
</svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_father, verbose=True)
print(answer)
# COMMAND ----------
displayHTML("""<h2>Business Partner</h2><br>
<?xml version="1.0" encoding="utf-8"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<svg width="150px" height="150px" viewBox="0 -14.56 352.858 352.858" xmlns="http://www.w3.org/2000/svg"><defs><style>.a{fill:#ffffff;}.b{fill:#211715;}.c{fill:#6e6867;}.d{fill:#3f88c9;}.e{fill:#b5b2b1;}.f{fill:none;}</style></defs><path class="a" d="M138.613,235.252c5.763,3.45,10.269,5.566,16.629,8.96a41.161,41.161,0,0,0,4.634,2.171c2.445.78,6.7-.077,9.394-1.8,2.891.024,6.141-2.62,7.772-4.693l.095-.436q.7-.137,1.388-.34a5.216,5.216,0,0,0,2.7-1.5,12.834,12.834,0,0,0,2.273-4.941,6.392,6.392,0,0,0,2.567-1.111,1.917,1.917,0,0,0,.9-1.3,38.061,38.061,0,0,1,5.526-3.9,11.258,11.258,0,0,1,1.929-.662s6.269.142,2.269-12.451-10.246-8.318-10.246-8.318a17.378,17.378,0,0,1-7.266,1.159,24.085,24.085,0,0,0-11.73,1.152,13.976,13.976,0,0,0-5.042,3.6l-1.049-.407c-.888-.345-3.134,0-4.074.148a32.759,32.759,0,0,0-6.222,2.222,11.476,11.476,0,0,1-4.413-.051s-5.995-1.208-9.069,8.347C133.488,233.822,138.613,235.252,138.613,235.252Z"/><path class="b" d="M137.92,237.164c3.249,1.929,6.581,3.7,9.935,5.442,3.186,1.652,6.322,3.452,9.594,4.93a12.112,12.112,0,0,0,8.288.653c2.775-.682,5.7-2.056,7.289-4.532,1.394-2.173-2.066-4.181-3.454-2.019-1.1,1.715-3.762,2.506-5.688,2.867-2.432.457-4.115-.234-6.267-1.312-5.964-2.987-11.942-6.077-17.678-9.483-2.219-1.317-4.233,2.139-2.019,3.454Z"/><path class="b" d="M169.541,246.579a10.418,10.418,0,0,0,5.176-1.881,16.66,16.66,0,0,0,3.74-3.393,2.177,2.177,0,0,0,.585-1.414,2,2,0,0,0-3.414-1.414,14.527,14.527,0,0,1-1.38,1.5c-.265.251-.538.494-.819.726-.076.062-.153.123-.228.185-.19.156.362-.268.077-.06-.16.117-.319.235-.482.347a14.271,14.271,0,0,1-1.941,1.091c.57-.274,0-.01-.156.043-.174.059-.351.113-.53.159-.157.04-.316.075-.477.1-.345.06.065.022.163-.019a1.065,1.065,0,0,1-.314.025,2,2,0,0,0,0,4Z"/><path class="b" d="M167.3,241.4a28.5,28.5,0,0,0,11.186-.2,7.713,7.713,0,0,0,4.321-2.377,14.287,14.287,0,0,0,2.4-4.818c.751-2.468-3.109-3.523-3.858-1.063a9.572,9.572,0,0,1-1.539,3.264,5.129,5.129,0,0,1-2.961,1.274,23.872,23.872,0,0,1-8.488.064,2.068,2.068,0,0,0-2.461,1.4,2.014,2.014,0,0,0,1.4,2.46Z"/><path class="b" d="M169.108,233.277c3.227,1.144,6.994,1.177,10.382,1.329,1.085.049,2.177.109,3.264.107,2.223,0,5.125-1.184,5.968-3.4a5.331,5.331,0,0,0-2.234-6.093,11.468,11.468,0,0,0-3.9-1.467c-2.844-.769-5.663-1.641-8.467-2.544-1.674-.539-3.344-1.093-5-1.7q-.534-.195-1.065-.4c-.132-.052-1.06-.44-.566-.223a8.217,8.217,0,0,1-1.171-.588c-2.168-1.4-4.176,2.06-2.019,3.454a27.76,27.76,0,0,0,6.124,2.446c2.774.941,5.572,1.813,8.382,2.639,1.035.305,2.072.606,3.116.88.969.254,2.155.373,2.8,1.23a2.484,2.484,0,0,1,.3.776c.08.233-.193.321.031.12a3.637,3.637,0,0,1-2.272.874c-.946,0-1.9-.049-2.842-.088-3.25-.134-6.715-.122-9.773-1.206a2.018,2.018,0,0,0-2.46,1.4,2.04,2.04,0,0,0,1.4,2.46Z"/><path class="b" d="M146.114,214.691a17.215,17.215,0,0,0,4.3.27,15.171,15.171,0,0,0,4.034-1.411,17.369,17.369,0,0,1,3.77-1.094l.325-.048c-.416.059.025,0,.107-.01.294-.031.587-.062.882-.081a8.955,8.955,0,0,1,.941-.018c.112,0,.223.012.334.025-.5-.056-.1.008.013.047a2,2,0,1,0,1.064-3.857,8.325,8.325,0,0,0-3.607-.07,18.394,18.394,0,0,0-3.983.905c-.684.247-1.359.52-2.03.8q-.615.258-1.229.519s-.48.2-.366.156c.168-.07-.217.085-.262.1a2.414,2.414,0,0,1-.279.068c.414-.108.05-.008-.077,0-.313.013-.625.018-.938.009-.382-.012-.763-.038-1.143-.074-.153-.014-.306-.031-.458-.048-.723-.079.342.056-.338-.047a2.066,2.066,0,0,0-2.46,1.4,2.015,2.015,0,0,0,1.4,2.461Z"/><path class="b" d="M185.91,203.011a16.709,16.709,0,0,1-5.512,1.148c-2.053.015-4.076-.37-6.141-.278-3.516.155-7.479.9-10.36,3.037a40.93,40.93,0,0,0-8.033,8.452,6.013,6.013,0,0,0-1.365,5.039,5.619,5.619,0,0,0,2.946,3.621c4.541,2.041,8.076-2.223,11.1-4.834,1.95-1.687-.89-4.506-2.829-2.829-1.449,1.254-2.737,3.084-4.556,3.823-1,.406-2.235.53-2.694-.489-.564-1.251,1.438-3.047,2.2-3.958a45.06,45.06,0,0,1,4.024-4.31,14.662,14.662,0,0,1,9.772-3.561c2.13-.077,4.24.364,6.359.276a20.72,20.72,0,0,0,6.157-1.28c2.4-.871,1.365-4.738-1.063-3.857Z"/><path class="b" d="M189.242,230.625c.812-.53,1.642-1.032,2.478-1.522a22.3,22.3,0,0,1,2.046-1.135l-.477.2a17.191,17.191,0,0,1,1.662-.534,2,2,0,1,0-1.063-3.857,16.326,16.326,0,0,0-2.232.776c-.426.2-.834.449-1.243.683-1.079.617-2.149,1.253-3.19,1.933a2,2,0,1,0,2.019,3.454Z"/><path class="a" d="M318.322,270.993c-.92,1.552-2.506,4.311-3.26,5.949-3.2,6.948-4.15,9.987-4.373,18.139a11.678,11.678,0,0,0,.321,3.8,5.394,5.394,0,0,0,4.531,3.122l1.353.037c-.061,1.153-.11,2.388-.136,3.755-.041,2.076-.272,2.821-.307,4.9-.032,1.883.363,4.354,2.1,5.125a3.5,3.5,0,0,0,4.095-1.433c.107.768.173,1.235.173,1.235a3.661,3.661,0,0,0,1.941,2.771,3.763,3.763,0,0,0,4.535-1.689,7.237,7.237,0,0,0,.661-1.942c.166.4.265.635.265.635.752,1.788,4.094,2.412,5.478,1.044a5.9,5.9,0,0,0,1.282-3.782q.1-1.107.2-2.2l.634,1.328c.581,1.219,2.609,1.394,3.72.815a4.136,4.136,0,0,0,1.338-1.551c1.557-3.938,2.345-13.018,2.551-14.854a102.19,102.19,0,0,0,.258-14.233q-.23-4.252-.594-8.5l-.1-4.91-24.778-1.222Z"/><path class="a" d="M143.177,210.53c-.7-.28-1.39-.556-2.028-.806l-2.584-.96c-3.206,8.562-6.258,17.17-9.3,25.789l2.959.946,5.883,2.047c3.273-8.284,6.514-18.384,8.627-25.627C145.664,211.522,144.405,211.02,143.177,210.53Z"/><path class="a" d="M189.5,202.867l1.665-.568s.822-.184,1.906-.429q5.35,11.392,9.625,23.251l-1.571.5-5.689,2.135a196.069,196.069,0,0,1-9.5-23.67Z"/><path class="a" d="M82.911,54.989c-.034,5.774-.1,13.788,5.079,16.833a5.362,5.362,0,0,1,2.36,2.545C91.511,77.286,89,78.486,87.4,80.086a8.8,8.8,0,0,0-2.138,3.673c-.277,3.115-1.421,10.094-3.541,13.776a11.035,11.035,0,0,1-6.263,5.378,27.392,27.392,0,0,1-13.573.808,1.911,1.911,0,0,0-2.233,1.031c-1.905,4.206-4.629,9.6-5.418,11.569l-.55,1.377-.556-.472c-9.092-7.728-19.174-8.2-32.194-12.331l.267-6.574a9.033,9.033,0,0,0-.449-3.462c6.641-2.35,15.349-8.108,18.292-14.173a17.133,17.133,0,0,1-6.28-12.622c-.057-2.383.6-5.07,2.66-6.268a5.118,5.118,0,0,1,4.558-.109,8.536,8.536,0,0,1,3.524,3.147c1.213-2.8,2.86-6.359,4.13-9.065.8-1.7,1.443-3.058,1.743-3.693.277-.587.8-1.412,1.419-1.6,1.151-.34,3.015,2.354,4.113,3.375.45-.979,2.852-9.987,4.938-9.877,3.793.091,11.044,0,15.458-1.156l6.131-1.011a3.874,3.874,0,0,0,.606-.318c1.232,3.96.889,9.246.866,13.5Z"/><path class="a" d="M257.424,147.692c11.654-17.877,21.947-32.857,34.816-48.447a20.75,20.75,0,0,0,2.362-2.9c.855-1.279,1.67-3.328,2.48-4.629a37.038,37.038,0,0,0-2.018-5.244c-10.58,4.539-19.984,9.23-29.22,12.408a23.344,23.344,0,0,0,1.559,1.9c-3.113.678-4.7,1.457-4.7,3.536,0,.805-.4,7.58-.341,9.481-1.275,6.117-4.561,26.975-4.939,33.9Z"/><path class="a" d="M289.309,88.994q2.867-1.278,5.845-2.562a19.172,19.172,0,0,1,2.07-9.932A28.744,28.744,0,0,1,277.5,64.76a16.926,16.926,0,0,0,4.7-13.143c-.224-2.345-1.183-4.9-3.347-5.837a5.057,5.057,0,0,0-4.484.428,8.4,8.4,0,0,0-3.079,3.494c-1.812-5.556-9.648-11.106-15.7-12.361-9.309-2.364-18.563-3.849-24.988-3.133a41.268,41.268,0,0,0,.86,10.477c.713,5.661,1.718,13.517-3,17.112a5.3,5.3,0,0,0-2.016,2.775c-.8,3,1.813,3.882,3.566,5.264a8.69,8.69,0,0,1,2.529,3.353c.638,3.024,2.581,9.736,5.095,13.1a10.9,10.9,0,0,0,6.777,4.54c4.511.894,10.436.544,14.058-1.069a1.892,1.892,0,0,1,2.384.76c.389.645.966,1.522,1.352,2.282L265.53,99l.314-.12C273.372,96.289,281.012,92.693,289.309,88.994Z"/><path class="c" d="M249.2,211.091a474.19,474.19,0,0,1-45.334,17.341,270.025,270.025,0,0,0-11.723-28.518c17.946-8.371,27.709-14.131,45.946-24.371,5.453-3.978,8.55-15.918,10.1-24.978s4.313-22.868,8.756-30.917c1.3-2.349,3.085-4.688,5.414-5.853-1.275,6.116-4.559,26.964-4.939,33.891,12.853-19.711,24.048-35.9,38.868-53.268l5.456,2.808c2.111,1.212,4.5,2.684,6.987,4.3,7.454,4.834,15.753,10.92,19.873,14.98a39.3,39.3,0,0,1,7.017,8.834,47.138,47.138,0,0,1,3.805,10.117c6.544,23.261,10.624,41.19,11.327,64.684.631,21.08-1.935,43.678-4.319,70.3-6.233.416-19-.31-27.717-.866-.1,2.29-.2,4.277-.291,4.543-.222.667-12.459,3.115-12.459,3.115-11.57,2.659-30.988-.525-39.255-3a2.689,2.689,0,0,1-1.953-2.468c-.834-25.531-.45-38.889.606-54.581.356-5.291-1.178-14.724-2.065-19.959.1,4.418-5.213,9.651-14.1,13.873Z"/><path class="d" d="M11.015,276.773c-.067,1.2.109,2.416,1.011,2.9,9.974,6.1,34.381,12.966,45.544,13.372s22.283-1.231,33.322-2.864a5.938,5.938,0,0,0,3.566-1.366,5.15,5.15,0,0,0,1.068-3.052c.873-7.719,2.208-27.478,2.093-35.243-.1-6.772-1.513-14.073-1.891-16.873l-1.254-9.275a256.946,256.946,0,0,0,33.5,13.839c3.642-10.336,7.274-20.661,11.14-30.919-16.634-8.042-28.383-15.261-44.045-25.081-11-11.726-18.416-29.979-28.565-40.772-1.407-2.1-2.673-4-2.673-4-2.421-3.632-6.96-15.362-10.707-20.216-9.276-7.884-19.583-8.217-32.988-12.584-1.027,3.21-2.5,8.853-3.178,11.69-3.291,6.7-5.149,10.232-7.566,19.786-5.65,22.337.885,46.957,4.85,69.654,1.986,11.367,4.2,25.038,4.078,36.575-2.421,12.863-6.053,18.39-7.317,34.426Z"/><path class="d" d="M262.548,107.855c.081-1.715.156-3.191.156-3.541,0-1.58.916-2.409,2.723-3.014l2.22-.254a77.483,77.483,0,0,0,6.528,6.124l-1.738,1.874c-1.3,3.815-6.563,21.3-8.785,28.63v.56q-3.07,4.607-6.228,9.458c.378-6.922,3.664-27.78,4.939-33.9C262.331,112.72,262.444,110.086,262.548,107.855Z"/><path class="b" d="M316.6,269.983c-3.247,5.5-6.346,11.461-7.32,17.84a36.325,36.325,0,0,0-.446,10.475,7.063,7.063,0,0,0,6.712,5.709c2.575.049,2.575-3.951,0-4a2.519,2.519,0,0,1-.851-.194,3.671,3.671,0,0,1-1.36-.943c-.774-.895-.669-2.1-.654-3.216a43.761,43.761,0,0,1,.8-8.655c1.16-5.353,3.808-10.32,6.572-15,1.312-2.221-2.144-4.236-3.454-2.019Z"/><path class="b" d="M315.7,288.563c-.085,3.889-.436,7.754-.7,11.633-.145,2.158-.167,4.318-.279,6.477a40.051,40.051,0,0,0-.243,5.11c.266,3.534,2.535,7.208,6.611,6.052,4.519-1.282,4.361-6.142,4.556-9.932.228-4.441.568-8.876.764-13.319.113-2.574-3.887-2.568-4,0-.189,4.3-.514,8.589-.741,12.886-.064,1.192-.107,2.386-.165,3.578a4.171,4.171,0,0,1-.528,2.228c-.782,1.126-1.86.92-2.262-.282-.552-1.65-.218-3.549-.071-5.238.184-2.118.159-4.252.283-6.374.25-4.276.678-8.534.771-12.819.056-2.575-3.944-2.575-4,0Z"/><path class="b" d="M320.888,316.156a5.284,5.284,0,0,0,5.632,4.446c3.191-.369,4.985-2.881,5.464-5.892.515-3.231.615-6.56.868-9.82.256-3.289.51-6.578.785-9.865.215-2.566-3.786-2.551-4,0-.414,4.949-.777,9.9-1.179,14.852-.1,1.227-.155,2.469-.32,3.689a4.206,4.206,0,0,1-.972,2.63c-1.183.995-2.175.257-2.421-1.1a2.018,2.018,0,0,0-2.461-1.4,2.042,2.042,0,0,0-1.4,2.46Z"/><path class="b" d="M328.491,316.409c.954,1.977,3.442,2.922,5.53,2.75,2.791-.229,4.383-2.373,4.781-5.019.44-2.928.6-5.924.872-8.873.285-3.089.532-6.181.677-9.28.12-2.573-3.881-2.567-4,0-.223,4.782-.7,9.544-1.154,14.308-.1,1.029-.138,2.078-.3,3.1-.1.648-.339,1.519-.716,1.7a1.989,1.989,0,0,1-2.235-.7,2.02,2.02,0,0,0-2.737-.718,2.043,2.043,0,0,0-.717,2.737Z"/><path class="b" d="M343.088,273.473a125.182,125.182,0,0,1,.24,23.643c-.29,2.82-.607,5.638-1.114,8.429a31,31,0,0,1-1.026,4.3,1.55,1.55,0,0,1-.672,1.02c-.215.1-.853.12-.974-.086-1.3-2.219-4.761-.208-3.454,2.019a4.546,4.546,0,0,0,4.118,2.122,4.929,4.929,0,0,0,4.126-2.392c1.432-2.213,1.7-5.486,2.087-8.028a114.7,114.7,0,0,0,1.394-16.938c.011-4.706-.32-9.407-.725-14.093-.219-2.545-4.221-2.568-4,0Z"/><path class="e" d="M248.155,4.7q-.252.12-.5.243c-5.814,2.931-8.967,6.321-12.126,11.443-3.316,5.378-6.206,11.556-4.956,17.827,6.426-.72,15.688.765,25.006,3.131,6.051,1.255,13.887,6.805,15.7,12.361a8.4,8.4,0,0,1,3.079-3.494,5.057,5.057,0,0,1,4.484-.428c2.164.933,3.123,3.492,3.347,5.837a16.926,16.926,0,0,1-4.7,13.143A28.745,28.745,0,0,0,297.227,76.5a40.8,40.8,0,0,1,2.077-3.786c2.213-4,3.865-5.961,6.734-10.452a25.511,25.511,0,0,0,3.384-18.7,24.32,24.32,0,0,1-.91-5.058c0-1.128.259-2.24.363-3.365.354-3.815-1.032-7.6-2.921-10.931a39.1,39.1,0,0,0-8.153-9.966,46.136,46.136,0,0,0-13.091-8.08C275.948,2.58,266.284,1.53,256.841,2.2A26.136,26.136,0,0,0,248.155,4.7Z"/><path class="e" d="M47.637,55.769c.8-1.7,1.443-3.058,1.743-3.693.277-.587.8-1.412,1.419-1.6,1.151-.34,3.015,2.354,4.113,3.375.45-.979,2.852-9.987,4.938-9.877,3.793.091,11.044,0,15.458-1.156l6.131-1.011c2.456-1.025,3.3-4.33,3.121-6.985a14.066,14.066,0,0,0-2.929-6.8,49.674,49.674,0,0,0-7.358-6.182,59.917,59.917,0,0,0-10.394-5.087C53.714,12.126,23.293,9.535,11.13,27.555c-6.007,5.405-8.8,14.073-9.118,26.121s8.519,27.6,15.055,35.122a20.778,20.778,0,0,1,3.69,6.06c6.637-2.349,15.345-8.107,18.288-14.172a17.133,17.133,0,0,1-6.28-12.622c-.057-2.383.6-5.07,2.66-6.268a5.118,5.118,0,0,1,4.558-.109,8.536,8.536,0,0,1,3.524,3.147C44.72,62.03,46.367,58.475,47.637,55.769Z"/><path class="b" d="M273.027,50.67c.937-1.75,3.1-4.258,5.326-2.9,1.74,1.062,1.939,3.785,1.906,5.592A14.9,14.9,0,0,1,273.6,65.4c-2.151,1.4-.148,4.861,2.019,3.454a18.88,18.88,0,0,0,8.562-17.381c-.354-3.316-1.9-6.914-5.427-7.831-3.928-1.02-7.418,1.726-9.176,5.012-1.215,2.269,2.237,4.292,3.453,2.019Z"/><path class="b" d="M234.338,78.936a14.237,14.237,0,0,0,5.477-1.207,6.96,6.96,0,0,0,2.471-1.75,2.139,2.139,0,0,0,.586-1.414,2,2,0,0,0-3.414-1.414,3.65,3.65,0,0,1-.323.335c-.065.06-.133.115-.2.172-.236.2.411-.307.239-.183l-.136.1a7.624,7.624,0,0,1-1.427.78l.478-.2a11.429,11.429,0,0,1-2.836.739l.532-.071a14.315,14.315,0,0,1-1.448.115,2,2,0,0,0,0,4Z"/><path class="b" d="M238.033,52.388c-.323,1.705.362,5.484,3.371,5.51,3.934-.42,3.7-5.048,2.161-7.082C242.309,49.151,239.047,48.734,238.033,52.388Z"/><path class="b" d="M228.55,35.477c-.073,6.065,1.824,11.951,1.477,18.026-.134,2.343-.687,4.837-2.5,6.471a9.513,9.513,0,0,0-2.7,3.218,5.451,5.451,0,0,0-.051,4.539c1.119,2.359,3.917,3,5.3,5.12a8.911,8.911,0,0,1,1,2.842q.5,1.908,1.137,3.776c1.839,5.412,4.618,11.075,10.455,12.975a25.059,25.059,0,0,0,10.1.7,24.024,24.024,0,0,0,4.971-.978c.322-.1.638-.223.952-.35.584-.237.68-.1.424-.288a7.77,7.77,0,0,1,1.353,2.283c1.207,2.274,4.661.255,3.453-2.019-.662-1.247-1.42-2.86-2.669-3.609-1.534-.921-2.867-.458-4.413.071a23.422,23.422,0,0,1-8.747,1.015c-2.693-.137-5.3-.586-7.347-2.477a17.209,17.209,0,0,1-4.072-6.7,69.305,69.305,0,0,1-2.121-7c-.753-2.848-2.931-4.5-5.19-6.129-.535-.387-1.093-.783-1.082-1.495.021-1.415,1.689-2.216,2.525-3.106a12.625,12.625,0,0,0,3.053-7.169c.863-6.636-1.391-13.1-1.312-19.716.031-2.575-3.969-2.576-4,0Z"/><path class="f" d="M301.017,69.569c5.773-10.727,7.58-20.815,6.923-29.6C306.635,20.976,296.322,11.348,288.5,7.742a45.571,45.571,0,0,0-34.561-1.827C243.859,9.294,230.86,17.92,230.55,35.477"/><path class="b" d="M276.891,67.256a30.841,30.841,0,0,0,17.056,10.7,2.042,2.042,0,0,0,2.46-1.4,2.022,2.022,0,0,0-1.4-2.46,27.373,27.373,0,0,1-15.291-9.671,2.012,2.012,0,0,0-2.828,0,2.049,2.049,0,0,0,0,2.829Z"/><path class="b" d="M255.052,39.269A23.71,23.71,0,0,1,267.3,46.78a11.366,11.366,0,0,1,1.151,1.6c.195.319.378.645.544.981,0,.007.265.577.123.241.074.177.138.359.2.54a2.05,2.05,0,0,0,2.46,1.4,2.019,2.019,0,0,0,1.4-2.461c-1.27-3.634-4-6.488-7.006-8.787a25.868,25.868,0,0,0-10.058-4.878,2.048,2.048,0,0,0-2.461,1.4,2.021,2.021,0,0,0,1.4,2.46Z"/><path class="b" d="M240.489,34.677c.009-.251.022-.5.046-.75,0-.023.069-.5.018-.181s.022-.115.033-.179a11.53,11.53,0,0,1,.359-1.455c.075-.239.162-.473.249-.708.175-.478-.183.385.029-.077.041-.091.082-.183.125-.273a12.373,12.373,0,0,1,.768-1.378c.136-.21.286-.411.426-.618.158-.235-.3.363.008-.013.079-.1.158-.194.24-.289a11.794,11.794,0,0,1,1.044-1.077c.185-.169.379-.326.57-.487s-.3.206.013-.006c.1-.07.2-.145.307-.215a11.611,11.611,0,0,1,1.363-.79,2.011,2.011,0,0,0,.717-2.736,2.049,2.049,0,0,0-2.736-.717,14.022,14.022,0,0,0-7.579,11.949,2.017,2.017,0,0,0,2,2,2.041,2.041,0,0,0,2-2Z"/><path class="b" d="M247.758,35.925c.11-.161.237-.313.342-.477-.042.065-.267.334-.1.128.062-.076.123-.152.186-.226q.359-.426.756-.817.417-.411.872-.781c.06-.049.123-.1.183-.146-.418.353-.183.142-.078.065.158-.115.319-.227.481-.335q.465-.306.955-.572.233-.125.469-.24c.088-.043.177-.084.265-.125.069-.031.4-.172.083-.04s.043-.015.087-.032l.219-.083q.274-.1.555-.188c.373-.117.751-.213,1.133-.294a2.014,2.014,0,0,0,1.4-2.46,2.047,2.047,0,0,0-2.46-1.4,14.421,14.421,0,0,0-8.8,6,2.01,2.01,0,0,0,.717,2.736,2.049,2.049,0,0,0,2.736-.717Z"/><path class="b" d="M232.426,33.3c-.693-5.638,1.745-10.834,4.605-15.536a27.949,27.949,0,0,1,9.048-9.658,28.511,28.511,0,0,1,7-3.159,29.832,29.832,0,0,1,8.11-.936,61.194,61.194,0,0,1,17.365,2.149c10.489,2.95,20.228,9.439,25.669,19.054a18.816,18.816,0,0,1,2.668,7.728,20.933,20.933,0,0,1-.271,4.115,13.7,13.7,0,0,0,.33,4.747,29.706,29.706,0,0,1,.97,7.927,24.076,24.076,0,0,1-1.593,7.568,38.679,38.679,0,0,1-4.513,7.714c-1.491,2.19-2.907,4.4-4.241,6.687-3.093,5.311-5.216,10.712-4.118,16.956a2.016,2.016,0,0,0,2.46,1.4,2.045,2.045,0,0,0,1.4-2.46c-.988-5.62,1.69-10.446,4.423-15.119,2.7-4.617,6.307-8.718,8.3-13.726a27.783,27.783,0,0,0,1.105-16.636,13.672,13.672,0,0,1-.574-4.575,27.619,27.619,0,0,0,.327-4.595,22.307,22.307,0,0,0-2.582-8.575c-5.4-10.566-15.807-18-26.941-21.539A63.291,63.291,0,0,0,263.259.017a44.787,44.787,0,0,0-8.949.519A29.621,29.621,0,0,0,246.283,3.4a31.07,31.07,0,0,0-11.971,11.171c-3.534,5.514-6.713,12-5.886,18.733a2.063,2.063,0,0,0,2,2,2.013,2.013,0,0,0,2-2Z"/><path class="b" d="M9.015,276.773a5.755,5.755,0,0,0,.826,3.536,7.185,7.185,0,0,0,2.633,1.931c1.718.942,3.5,1.769,5.3,2.54a133.492,133.492,0,0,0,13.483,4.878c8.329,2.552,17.127,4.927,25.869,5.367a121.715,121.715,0,0,0,20.092-.968c3.443-.4,6.877-.877,10.307-1.375,2.7-.393,6.3-.351,8.348-2.454,1.609-1.649,1.633-4.142,1.848-6.3.186-1.868.348-3.739.5-5.61q.572-7.059.957-14.13c.246-4.482.5-8.984.446-13.475-.071-5.936-1.155-11.743-1.966-17.6a2.012,2.012,0,0,0-2.46-1.4,2.053,2.053,0,0,0-1.4,2.46c.659,4.766,1.514,9.481,1.753,14.3.188,3.792.011,7.6-.159,11.394-.369,8.218-.887,16.451-1.731,24.635a10.31,10.31,0,0,1-.361,2.351c-.364,1.03-1.437,1.147-2.407,1.311-3.076.521-6.182.924-9.273,1.337A160.617,160.617,0,0,1,62.492,291.1c-8.678.117-17.038-1.612-25.378-3.9a150.69,150.69,0,0,1-14.574-4.755c-1.967-.763-3.91-1.582-5.808-2.5-.867-.42-1.725-.86-2.566-1.331a4.217,4.217,0,0,1-1.13-.66c.157.2.085.083.05.013a2.678,2.678,0,0,1-.071-1.185c.088-2.575-3.912-2.572-4,0Z"/><path class="b" d="M54.543,115.812c-9.642-8.1-22.281-9.35-33.87-13.1a2.035,2.035,0,0,0-2.461,1.4c-.78,2.462-1.453,4.958-2.108,7.455q-.432,1.649-.842,3.3a15.76,15.76,0,0,1-1.323,3.093,81.59,81.59,0,0,0-8.572,31.527,113.5,113.5,0,0,0,.611,19.242c1.4,12.985,4.286,25.741,6.518,38.594,1.066,6.134,2.076,12.281,2.8,18.465.362,3.1.657,6.21.84,9.327.166,2.835.469,5.8-.112,8.594-1.048,5.033-2.592,9.928-3.923,14.888a101.5,101.5,0,0,0-3.09,18.174c-.207,2.566,3.794,2.552,4,0A93.745,93.745,0,0,1,15.631,260.9c1.115-4.334,2.482-8.6,3.533-12.949q.448-1.857.828-3.73a19.587,19.587,0,0,0,.324-4.372c-.051-3.05-.241-6.1-.513-9.136-.562-6.281-1.467-12.53-2.486-18.752-2.064-12.608-4.867-25.1-6.656-37.748-1.781-12.594-2.4-25.6.783-38.024a81.049,81.049,0,0,1,5.524-15.331c.567-1.173,1.182-2.327,1.722-3.512a23.177,23.177,0,0,0,1.039-3.821c.723-2.8,1.467-5.592,2.341-8.346l-2.461,1.4c10.782,3.487,23.133,4.528,32.106,12.069,1.958,1.646,4.8-1.169,2.828-2.828Z"/><path class="b" d="M23.1,149.088c-2.911,19.4,11.255,36.3,24.691,48.389a168.441,168.441,0,0,0,21.89,16.5c4.274,2.741,9.026,4.791,13.567,7.062,4.329,2.166,8.662,4.326,13.031,6.411a262.663,262.663,0,0,0,31.165,12.684,2.039,2.039,0,0,0,2.46-1.4c3.64-10.333,7.279-20.666,11.139-30.919a2,2,0,0,0-.919-2.259A440.824,440.824,0,0,1,98.681,182.11a18.285,18.285,0,0,1-2.434-1.572,19.151,19.151,0,0,1-1.77-2q-1.541-1.818-2.952-3.738c-2.04-2.766-3.929-5.64-5.76-8.548-3.616-5.745-6.986-11.65-10.814-17.26-3.855-5.649-8.24-11.209-14.11-14.879-2.189-1.369-4.2,2.091-2.019,3.454,4.965,3.1,8.757,7.81,12.067,12.562,3.869,5.554,7.238,11.436,10.818,17.177,1.824,2.924,3.7,5.82,5.712,8.617q1.486,2.066,3.082,4.053a24.789,24.789,0,0,0,3.361,3.805,52.105,52.105,0,0,0,5.333,3.364q2.636,1.643,5.281,3.27,4.873,2.993,9.805,5.89,11.664,6.819,23.828,12.713l-.919-2.259c-3.86,10.253-7.5,20.587-11.139,30.919l2.46-1.4c-18.3-6-35.31-14.792-52.514-23.322a91.3,91.3,0,0,1-11.7-7.389q-5.217-3.667-10.087-7.788A107.552,107.552,0,0,1,35.927,178.7c-5.849-8.168-10.512-18.238-8.965-28.544a2.065,2.065,0,0,0-1.4-2.46,2.015,2.015,0,0,0-2.461,1.4Z"/><path class="b" d="M52.768,131.433c-5.56-2.413-11.855-3.419-17.707-1.386a18.353,18.353,0,0,0-10.982,9.973,2.068,2.068,0,0,0,.718,2.736,2.014,2.014,0,0,0,2.736-.717,14.516,14.516,0,0,1,8.592-8.135,20.21,20.21,0,0,1,14.624.983,2.065,2.065,0,0,0,2.736-.717,2.015,2.015,0,0,0-.717-2.737Z"/><path class="b" d="M85.691,291.03c-1.638,8.536-2.684,17.212-4.032,25.8-.231,1.469-.439,2.945-.719,4.406-.483,2.515,3.371,3.593,3.857,1.063,1.638-8.536,2.684-17.212,4.032-25.8.231-1.469.439-2.946.719-4.407.483-2.515-3.372-3.592-3.857-1.063Z"/><path class="b" d="M13.546,282.225c-.525,4.076-.562,8.258-.78,12.358q-.477,9.013-.907,18.03c-.106,2.162-.209,4.324-.324,6.486-.137,2.572,3.863,2.565,4,0,.562-10.536,1-21.079,1.627-31.612.105-1.75.16-3.521.384-5.262a2.01,2.01,0,0,0-2-2,2.052,2.052,0,0,0-2,2Z"/><path class="b" d="M255.424,147.261c-.14,6.583-.611,13.2-.068,19.78a117.477,117.477,0,0,0,3.017,16.668c1.168,5.05,2.341,10.075,3.194,15.189a101.464,101.464,0,0,1,1.854,16.521c0,4.681-.543,9.4-.742,14.076q-.327,7.676-.362,15.358c-.034,6.146.053,12.292.2,18.436q.062,2.535.137,5.069c.054,1.835-.219,4.035.755,5.679,1.251,2.111,3.93,2.491,6.122,3.017a120.506,120.506,0,0,0,17.986,2.834c6.287.529,12.79.663,18.982-.726,2.511-.563,1.448-4.421-1.063-3.857a55.9,55.9,0,0,1-15.679.748,116.211,116.211,0,0,1-16-2.155,61.022,61.022,0,0,1-6.085-1.467c-1.332-.421-.942-1.64-.98-2.872q-.082-2.687-.151-5.373c-.154-6.093-.249-12.188-.23-18.284.031-9.591.482-19.147,1.057-28.717.328-5.462-.629-11.054-1.471-16.432-.747-4.766-1.66-9.465-2.751-14.166-1.378-5.938-2.989-11.949-3.646-18.022-.764-7.07-.228-14.215-.077-21.3.055-2.575-3.945-2.574-4,0Z"/><path class="b" d="M300.739,98.953a183.787,183.787,0,0,1,16.086,10.539,82.628,82.628,0,0,1,12.2,10.3,32.66,32.66,0,0,1,5.3,7.352,47.859,47.859,0,0,1,3.18,8.841c1.79,6.337,3.5,12.7,5.037,19.1a222.816,222.816,0,0,1,5.779,36.2A269.269,269.269,0,0,1,348.154,227c-.907,14.506-2.418,28.968-3.716,43.442l2-2a134.688,134.688,0,0,1-14.279-.124c-5.224-.224-10.443-.546-15.66-.886-2.57-.167-2.559,3.833,0,4,5.217.34,10.436.661,15.66.886a134.423,134.423,0,0,0,14.279.124,2.063,2.063,0,0,0,2-2c2.261-25.212,5.477-50.6,4.08-75.953a222.808,222.808,0,0,0-5.373-37.254c-1.455-6.383-3.121-12.717-4.868-19.026-1.752-6.327-3.508-12.571-7.566-17.861-3.855-5.025-8.737-9-13.78-12.772A183.437,183.437,0,0,0,302.758,95.5c-2.234-1.288-4.251,2.167-2.019,3.454Z"/><path class="b" d="M301.215,156.847l0-.008-3.857,1.063c3.9,10.212,7.75,20.446,11.656,30.657q1.735,4.539,3.486,9.072c1.712,4.439,3.3,8.885,3.481,13.68.337,8.867-.87,17.745-1.493,26.573a221.883,221.883,0,0,0,.014,31.547c.183,2.553,4.185,2.573,4,0a214.535,214.535,0,0,1-.223-28.393c.547-8.971,1.72-17.926,1.745-26.922a39.776,39.776,0,0,0-2.055-13.18c-1.246-3.668-2.732-7.263-4.118-10.881q-3.918-10.22-7.8-20.454c-1.616-4.253-3.216-8.512-4.84-12.762a2.057,2.057,0,0,0-2.46-1.4,2.015,2.015,0,0,0-1.4,2.46l0,.008a2.056,2.056,0,0,0,2.46,1.4,2.016,2.016,0,0,0,1.4-2.46Z"/><path class="b" d="M296.583,93.846c3.247,4,6.214,8.3,7.807,13.248l.919-2.258a146.811,146.811,0,0,1-14.525,8.9,2.033,2.033,0,0,0-.4,3.141,50.368,50.368,0,0,1,3.769,5.654l.312-2.423a41.1,41.1,0,0,1-4.552,4.385c-2.452,2.151-4.969,4.23-7.5,6.289-5.308,4.318-10.695,8.538-16.115,12.713a2.067,2.067,0,0,0-.717,2.736,2.013,2.013,0,0,0,2.736.718c5.6-4.313,11.169-8.664,16.654-13.12,2.551-2.072,5.088-4.164,7.563-6.328a42.333,42.333,0,0,0,4.759-4.565,2.078,2.078,0,0,0,.312-2.424,57.406,57.406,0,0,0-4.393-6.463l-.405,3.141a147.117,147.117,0,0,0,14.525-8.9,2.05,2.05,0,0,0,.919-2.259c-1.816-5.642-5.135-10.449-8.836-15.013a2.012,2.012,0,0,0-2.828,0,2.046,2.046,0,0,0,0,2.828Z"/><path class="b" d="M261.354,112.068c-3.551,1.886-5.756,5.5-7.372,9.056a73.626,73.626,0,0,0-3.814,10.8c-2.019,7.261-3.119,14.671-4.644,22.034a75.6,75.6,0,0,1-3.1,11.168c-1.084,2.9-2.468,5.985-4.738,8.157-1.466,1.4-3.638,2.242-5.4,3.232q-2.871,1.619-5.743,3.236c-3.508,1.973-7.02,3.94-10.552,5.87q-12.228,6.681-24.856,12.568a2.039,2.039,0,0,0-.718,2.737,269.487,269.487,0,0,1,11.522,28.04,2.033,2.033,0,0,0,2.46,1.4,472.285,472.285,0,0,0,45.811-17.543,2.013,2.013,0,0,0,.718-2.736,2.053,2.053,0,0,0-2.737-.718,462.434,462.434,0,0,1-44.855,17.14l2.46,1.4a278.693,278.693,0,0,0-11.925-29l-.717,2.736c15.145-7.073,29.673-15.221,44.233-23.409a13.9,13.9,0,0,0,4.168-3.258,22.9,22.9,0,0,0,2.679-4.1,52.668,52.668,0,0,0,3.923-10.657c1.921-7.206,2.808-14.643,4.508-21.9a98.688,98.688,0,0,1,3.757-12.734c1.416-3.706,3.276-8.111,6.95-10.062,2.274-1.207.255-4.661-2.019-3.454Z"/><path class="b" d="M261.3,197.226c0,.162-.008.323-.011.485s.077.494.019-.04a2.53,2.53,0,0,1-.176.809c-.079.28-.179.55-.283.821.191-.5.031-.081-.026.033-.087.172-.173.344-.267.513-.147.265-.306.523-.474.775-.1.154-.21.3-.316.455-.289.414.12-.125-.136.18a21.735,21.735,0,0,1-1.559,1.695,37.017,37.017,0,0,1-9.883,6.42,2.018,2.018,0,0,0-.717,2.736,2.043,2.043,0,0,0,2.736.718,39.174,39.174,0,0,0,10.957-7.306c2.192-2.2,4.171-5.066,4.136-8.294a2,2,0,0,0-4,0Z"/><path class="a" d="M294.6,96.344c.855-1.279,1.67-3.328,2.48-4.629a37.038,37.038,0,0,0-2.018-5.244c-10.58,4.539-19.984,9.23-29.22,12.408,3.179,4.386,11.393,10.838,13.014,12.106a126.29,126.29,0,0,0,10.695-9.092A34.254,34.254,0,0,0,294.6,96.344Z"/><path class="b" d="M296.329,97.354a32.918,32.918,0,0,0,1.609-3.019c.627-1.25,1.369-2.142.92-3.586a40.684,40.684,0,0,0-2.067-5.288,2.049,2.049,0,0,0-2.737-.717c-9.556,4.109-18.9,8.8-28.742,12.207-1.1.38-2.015,1.826-1.195,2.938,3.6,4.881,8.578,8.8,13.327,12.51a2.078,2.078,0,0,0,2.424.313,66.178,66.178,0,0,0,7.738-6.331c3.12-2.75,6.362-5.581,8.723-9.027,1.459-2.129-2.006-4.132-3.454-2.019-2.147,3.134-5.257,5.714-8.1,8.218a61.942,61.942,0,0,1-6.928,5.7l2.424.313q-2.958-2.313-5.8-4.774a45.453,45.453,0,0,1-6.9-6.927l-1.2,2.938c10.169-3.522,19.825-8.365,29.7-12.611l-2.736-.717a48.5,48.5,0,0,1,1.816,4.767l.2-1.541c-.9,1.5-1.534,3.151-2.48,4.629C291.484,97.51,294.944,99.518,296.329,97.354Z"/><path class="b" d="M324.635,116.623a24.716,24.716,0,0,0-20.665,4.1,26.921,26.921,0,0,0-9.943,16.1,28.062,28.062,0,0,0-.3,9.807,2.013,2.013,0,0,0,2.46,1.4,2.051,2.051,0,0,0,1.4-2.46c-1.629-11,5.484-22.709,16.58-25.211a20.64,20.64,0,0,1,9.409.13c2.5.611,3.566-3.245,1.063-3.857Z"/><path class="b" d="M296.583,91.018A447.973,447.973,0,0,0,264.4,133.525q-4.411,6.54-8.707,13.157c-1.41,2.163,2.052,4.17,3.454,2.019,9.611-14.738,19.5-29.316,30.476-43.079q4.774-5.985,9.784-11.776c1.675-1.939-1.142-4.78-2.828-2.828Z"/><path class="b" d="M270.508,108.512c-1.563,4.107-2.778,8.378-4.09,12.568-1.664,5.314-3.4,10.644-4.694,16.062-.6,2.5,3.257,3.57,3.857,1.064,1.3-5.419,3.03-10.749,4.694-16.062,1.312-4.191,2.527-8.462,4.09-12.568a2.016,2.016,0,0,0-1.4-2.461,2.046,2.046,0,0,0-2.461,1.4Z"/><path class="b" d="M264.9,99.372c-2.155.764-3.94,2.057-4.162,4.492-.113,1.244-.116,2.509-.175,3.757-.079,1.686-.165,3.373-.194,5.06,0,.3,0,.59-.006.885,0,.338.087-.511.014,0-.015.106-.044.216-.065.321-.119.6-.232,1.2-.343,1.8-1.325,7.181-2.422,14.413-3.4,21.65-.462,3.439-.947,6.895-1.145,10.362-.147,2.571,3.854,2.563,4,0,.362-6.35,1.437-12.695,2.405-18.973.516-3.35,1.057-6.7,1.644-10.035.215-1.219.435-2.438.676-3.652a24.243,24.243,0,0,0,.26-3.887c.063-1.779.154-3.556.236-5.334.023-.488-.012-1.014.059-1.5.1-.69.574-.843,1.255-1.085,2.409-.855,1.372-4.721-1.063-3.857Z"/><path class="b" d="M268.831,275.752a53.4,53.4,0,0,0,.527,5.357c.04.244-.076-.638-.016-.109.017.148.037.3.055.443.051.426.1.853.147,1.279.3,2.64.568,5.283.842,7.926.677,6.538,1.332,13.079,2.027,19.615.216,2.034.382,4.089.712,6.108a2.015,2.015,0,0,0,2.46,1.4,2.047,2.047,0,0,0,1.4-2.46c-.1-.64.029.3-.023-.152-.042-.367-.089-.733-.131-1.1-.123-1.065-.237-2.131-.351-3.2q-.477-4.459-.93-8.924c-.632-6.146-1.242-12.3-1.917-18.436-.284-2.585-.638-5.148-.8-7.747-.158-2.557-4.159-2.575-4,0Z"/><path class="b" d="M65.563,136.432a79.949,79.949,0,0,1-4.856-9.649c-1.72-3.6-3.418-7.375-5.851-10.566a2.065,2.065,0,0,0-2.736-.718,2.013,2.013,0,0,0-.718,2.736A59.256,59.256,0,0,1,57.253,128.8a80.17,80.17,0,0,0,4.856,9.649c1.408,2.142,4.873.141,3.454-2.019Z"/><path class="b" d="M16.809,119.084c.428.049-.1-.018-.018-.006l.466.07c.393.061.786.13,1.178.2.921.166,1.839.348,2.756.535,2.361.481,4.714,1,7.065,1.528,4.6,1.034,9.192,2.114,13.778,3.209,1,.238,2,.544,3.008.718A2.026,2.026,0,0,0,47.4,124.18a1.977,1.977,0,0,0-.818-2.5c-.088-.038-.4-.179-.488-.205-2.48-.707-3.539,3.152-1.063,3.857l-.468-.2,1.541-3.655c-2.817-.487-5.615-1.342-8.4-1.995-4.954-1.164-9.913-2.317-14.9-3.347-1.987-.41-3.982-.823-6-1.055a2.012,2.012,0,0,0-2,2,2.047,2.047,0,0,0,2,2Z"/><path class="b" d="M144.912,166.778c3.1,5.757,6.557,11.315,9.763,17.013,1.262,2.244,4.719.229,3.454-2.019-3.206-5.7-6.663-11.256-9.763-17.012-1.221-2.268-4.675-.25-3.454,2.018Z"/><path class="b" d="M190.461,171.941,176.25,184.035a2.017,2.017,0,0,0,0,2.829,2.042,2.042,0,0,0,2.828,0l14.211-12.095a2.016,2.016,0,0,0,0-2.828,2.042,2.042,0,0,0-2.828,0Z"/><path class="b" d="M172,157.469c-2.14,8.136-4.019,16.352-5.864,24.559-.563,2.507,3.292,3.577,3.858,1.063,1.844-8.206,3.724-16.423,5.863-24.558.655-2.492-3.2-3.555-3.857-1.064Z"/><path class="b" d="M138.205,181.533c1.819,1.818,3.606,3.668,5.382,5.527a2.02,2.02,0,0,0,2.829,0,2.042,2.042,0,0,0,0-2.829c-1.777-1.858-3.563-3.709-5.382-5.526a2,2,0,0,0-2.829,2.828Z"/><path class="b" d="M56.164,116.853c.819-2.01,2.281-4.859,3.372-7.147q.52-1.091,1.033-2.186c.217-.465.49-1.588.882-1.906-.094.076-.432.065.236.114.342.025.705.141,1.045.2a25.151,25.151,0,0,0,2.6.28c6.236.34,13.31-.9,17.186-6.226a22.692,22.692,0,0,0,3.344-7.948c.343-1.37.623-2.757.856-4.15a34.85,34.85,0,0,1,.527-3.9c.734-2.51,3.44-3.544,4.7-5.695,1.741-2.966-.066-6.274-2.643-8-2.317-1.552-3.329-3.676-3.878-6.386a43.722,43.722,0,0,1-.514-8.908c.015-2.575-3.985-2.578-4,0-.03,5.144-.194,11.229,2.936,15.623a10.723,10.723,0,0,0,2.871,2.775c.813.536,2.182,1.4,1.92,2.6-.163.749-1.254,1.435-1.8,1.908a10.886,10.886,0,0,0-2.9,3.764c-1.026,2.3-1.013,5.081-1.533,7.539a24.251,24.251,0,0,1-2.641,7.71,9.957,9.957,0,0,1-6.7,4.6,25.2,25.2,0,0,1-9.267.559c-1.875-.267-3.636-.808-5.174.72-1.137,1.131-1.689,3.113-2.366,4.536-1.336,2.809-2.775,5.585-3.949,8.468a2.012,2.012,0,0,0,1.4,2.46,2.05,2.05,0,0,0,2.46-1.4Z"/><path class="b" d="M45.2,63.777c-2.263-3.231-6.177-5.77-10.18-4-3.18,1.408-4.325,5.039-4.257,8.283a19.1,19.1,0,0,0,10.482,16.4,2.052,2.052,0,0,0,2.737-.717,2.019,2.019,0,0,0-.718-2.737A15.279,15.279,0,0,1,34.9,69.7c-.275-1.8-.365-4.417,1.057-5.806,1.916-1.873,4.629.241,5.793,1.9a2.053,2.053,0,0,0,2.736.718,2.018,2.018,0,0,0,.718-2.737Z"/><path class="b" d="M82.982,85.517a21.243,21.243,0,0,1-2.509-.142l.532.071a5.246,5.246,0,0,1-1.341-.331l.478.2a2.718,2.718,0,0,1-.58-.339l.4.313-.021-.017a2.222,2.222,0,0,0-1.414-.586,2.037,2.037,0,0,0-1.415.586,2.009,2.009,0,0,0-.585,1.414,1.933,1.933,0,0,0,.585,1.414,4.722,4.722,0,0,0,.993.662,6.2,6.2,0,0,0,1.317.454,19,19,0,0,0,3.556.3,2.05,2.05,0,0,0,1.414-.585,2,2,0,0,0-1.414-3.415Z"/><path class="b" d="M77.677,62.586c.53,1.674.3,5.554-2.724,5.942-4,.053-4.322-4.627-3.025-6.855C72.991,59.849,76.217,59.036,77.677,62.586Z"/><path class="b" d="M23.2,98.321c.241-5.27-3.3-8.99-6.3-12.858A72.24,72.24,0,0,1,9.033,72.624a49.374,49.374,0,0,1-4.8-14.819,44.484,44.484,0,0,1,1.2-15.951,25.048,25.048,0,0,1,7.11-12.885c1.906-1.739-.929-4.562-2.828-2.829C2.023,33.162-.141,44.7.007,54.687A43.4,43.4,0,0,0,3.7,70.436a77.332,77.332,0,0,0,7.844,14.438c1.4,2.023,2.99,3.882,4.484,5.827,1.747,2.275,3.309,4.64,3.173,7.62-.118,2.574,3.882,2.568,4,0Z"/><path class="b" d="M36.658,80.88A25.7,25.7,0,0,1,29.493,88a39.581,39.581,0,0,1-9.249,4.92,2.052,2.052,0,0,0-1.4,2.46,2.017,2.017,0,0,0,2.46,1.4A43.161,43.161,0,0,0,31.74,91.294,30.3,30.3,0,0,0,40.112,82.9c1.364-2.192-2.095-4.2-3.454-2.019Z"/><path class="f" d="M82.911,54.989c2.017-24.547-15.026-33.715-27.255-36.25a46.12,46.12,0,0,0-34.507,6C13.719,29.3,4.516,40.22,5.491,59.458c.4,8.91,3.429,18.828,10.522,28.912,1.217,1.731,2.545,3.6,3.76,5.567"/><path class="b" d="M69.359,82.205a29.45,29.45,0,0,0-.8,2.991,2.115,2.115,0,0,0,.2,1.541,2,2,0,0,0,2.736.718,2,2,0,0,0,.919-1.195,29.468,29.468,0,0,1,.8-2.992,1.512,1.512,0,0,0,.035-.8,1.492,1.492,0,0,0-.237-.744,2,2,0,0,0-2.736-.717,2.17,2.17,0,0,0-.919,1.195Z"/><path class="b" d="M84.911,54.989c.028-4.323.314-8.714-.652-12.967a2.015,2.015,0,0,0-2.46-1.4,2.044,2.044,0,0,0-1.4,2.46q.169.743.285,1.5c.016.1.031.2.045.308q-.039-.281.007.092c.028.281.06.562.084.844.086,1.008.125,2.019.141,3.03.031,2.045-.039,4.089-.053,6.134a2,2,0,1,0,4,0Z"/><path class="b" d="M74.776,40.893a36.787,36.787,0,0,1-7.548.981c-2.456.131-4.919.16-7.378.1-2.575-.059-2.574,3.941,0,4,5.277.121,10.849.09,15.99-1.228,2.492-.638,1.435-4.5-1.064-3.857Z"/><path class="b" d="M59.85,41.978c-2.691.027-3.924,3.326-4.767,5.388-.482,1.178-.9,2.382-1.3,3.59-.157.474-.309.949-.465,1.422-.079.24-.5,1.3-.132.468l3.141-.4c-1.359-1.309-2.528-3.31-4.45-3.856C49.544,47.922,48.157,50,47.3,51.818c-1.833,3.869-3.658,7.744-5.373,11.668a2.065,2.065,0,0,0,.718,2.736,2.014,2.014,0,0,0,2.736-.717c1.526-3.491,3.14-6.942,4.766-10.386q.372-.787.744-1.572c.109-.231.212-.466.333-.691.236-.437.635-.587-.067-.5-.622.081-.509-.107-.392.089.068.113.164.123.232.178a9.058,9.058,0,0,1,.838.836c.558.6,1.075,1.239,1.665,1.808.834.8,2.607.817,3.141-.405.735-1.682,1.183-3.488,1.823-5.208a18.027,18.027,0,0,1,1.231-2.8c.115-.209.237-.413.364-.616.058-.092.122-.181.184-.271.163-.235-.22.237-.036.051a2.294,2.294,0,0,0,.185-.2c.158-.2.124,0,.029-.038-.028-.012-.08.067-.164.1s-.623.1-.405.1c2.572-.026,2.579-4.026,0-4Z"/><path class="b" d="M82.449,43.538c3.494-1.629,4.563-6.225,3.984-9.729a15.5,15.5,0,0,0-4.987-8.784A48.074,48.074,0,0,0,64.411,14.833c-1.563-.522-2.717,1.066-2.46,2.46h0l2.938-2.258c-6.159-2.777-13.292-3.6-19.983-3.664C36.443,11.3,27.66,12.752,20.167,16.85A30.981,30.981,0,0,0,9.4,26.545c-1.456,2.131,2.009,4.134,3.454,2.019C21.565,15.822,40.115,13.827,54.074,16.12A48.886,48.886,0,0,1,59.2,17.228c.7.192,1.39.4,2.074.64.34.118.677.241,1.012.372l.318.127c.318.129-.23-.1.271.121a2.03,2.03,0,0,0,2.938-2.258h0l-2.46,2.46A42.649,42.649,0,0,1,77.5,26.861,13.834,13.834,0,0,1,82.131,33.1c.719,2.169.847,5.8-1.7,6.986a2.018,2.018,0,0,0-.718,2.737,2.047,2.047,0,0,0,2.737.717Z"/><path class="b" d="M192.12,199.736c-2.249.775-4.465,1.644-6.714,2.418a2.032,2.032,0,0,0-1.4,2.461,184.237,184.237,0,0,0,9.7,24.148,2.005,2.005,0,0,0,2.259.919c2.411-.9,4.848-1.732,7.26-2.632,2.39-.893,1.355-4.761-1.063-3.857s-4.849,1.731-7.261,2.632l2.259.919a176.7,176.7,0,0,1-9.3-23.193l-1.4,2.46c2.249-.774,4.464-1.643,6.713-2.418,2.42-.833,1.38-4.7-1.063-3.857Z"/><path class="b" d="M138.675,210.927c2.507.981,5.007,1.982,7.53,2.921l-1.4-2.46c-2.528,8.647-5.325,17.24-8.626,25.626l2.46-1.4c-2.776-.969-5.535-1.986-8.311-2.955-2.435-.85-3.482,3.013-1.063,3.857,2.776.969,5.535,1.987,8.311,2.955a2.044,2.044,0,0,0,2.46-1.4c3.3-8.385,6.1-16.978,8.626-25.626a2.047,2.047,0,0,0-1.4-2.46c-2.523-.939-5.024-1.94-7.53-2.921a2.015,2.015,0,0,0-2.461,1.4,2.047,2.047,0,0,0,1.4,2.46Z"/><path class="b" d="M261.245,98.208q-1.176,3.036-2.191,6.131-.505,1.547-.969,3.108c-.154.52-.3,1.042-.453,1.563-.028.1-.229.627-.027.2a1.921,1.921,0,0,1-.158.284,1.266,1.266,0,0,1,1.007-.591,2.018,2.018,0,0,0-2,2,2.038,2.038,0,0,0,2,2c1.627.041,2.595-1.305,3-2.721.356-1.228.712-2.456,1.1-3.676q1.156-3.659,2.547-7.238a2.007,2.007,0,0,0-1.4-2.46,2.057,2.057,0,0,0-2.46,1.4Z"/></svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_business_partner, verbose=True)
print(answer)
# COMMAND ----------
displayHTML("""<h2>Career Coach</h2><br>
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg fill="#000000" height="150px" width="150px" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
viewBox="0 0 477.13 477.13" xml:space="preserve">
<g>
<path d="M254.604,108.371c25.443,0,46.143-20.699,46.143-46.142c0-25.443-20.7-46.144-46.143-46.144
c-25.437,0-46.131,20.7-46.131,46.144C208.473,87.672,229.167,108.371,254.604,108.371z"/>
<path d="M368.937,6.477C365.252,2.421,359.736,0,354.178,0c-9.97,0-17.132,7.021-19.164,18.799L325,79.645
c-0.059,0.411-0.478,1.479-0.755,1.947l-36.277,37.99h-66.716L184.973,81.59c-0.276-0.467-0.697-1.538-0.763-1.996L174.201,18.78
C172.204,7.196,164.863,0,155.04,0c-5.849,0-11.774,2.686-15.467,7.01c-3.095,3.625-4.408,8.089-3.695,12.583l9.975,60.788
c0.064,9.399,4.6,20.647,11.071,27.426l41.867,43.844v55.683h-72.559l7.303-30.201c0.982-4.056,4.709-10.28,7.822-13.059
l6.605-5.896c3.241,2.591,7.342,4.151,11.805,4.151c10.449,0,18.95-8.501,18.95-18.95c0-10.449-8.501-18.95-18.95-18.95
s-18.95,8.501-18.95,18.95c0,1.182,0.123,2.334,0.331,3.456l-8.447,7.542c-5.115,4.565-10.188,13.034-11.801,19.7l-8.042,33.257
h-2.85c-1.979,0-3.786,0.827-4.96,2.271c-1.174,1.443-1.615,3.382-1.212,5.319l9.33,44.754c0.76,3.643,4.27,6.496,7.99,6.496
h12.123l15.468,162.145h-8.036c-7.622,0-13.822,6.2-13.822,13.821v21.17c0,7.621,6.2,13.821,13.822,13.821h182.977
c7.622,0,13.822-6.2,13.822-13.821v-21.17c0-7.621-6.2-13.821-13.822-13.821h-8.036l15.469-162.145h12.122
c3.721,0,7.23-2.854,7.99-6.496l9.33-44.754c0.403-1.938-0.038-3.876-1.212-5.319c-1.174-1.443-2.982-2.271-4.96-2.271h-43.962
v-55.682l41.869-43.846c6.472-6.78,11.005-18.028,11.069-27.425l9.975-60.788l0.022-0.162
C373.816,14.718,372.244,10.117,368.937,6.477z"/>
</g>
</svg>""")
# COMMAND ----------
answer = answer_as_role(user_question, role_career_coach, verbose=True)
print(answer)
# COMMAND ----------
# MAGIC %md
# MAGIC Images credit: svgrepo.com
| [
"{role_name} Respond to the user question that is delimited in triple backticks with thoughtful and concise instructions that the user can easily implement in their day to day life.\nuser_question: ```{user_question}```\n"
] |
2024-01-10 | vijaybala-db/databricks-goodies | llm-dolly-chatbot~04-chat-bot-prompt-engineering-dolly.py | # Databricks notebook source
# MAGIC %md
# MAGIC ### A cluster has been created for this demo
# MAGIC To run this demo, just select the cluster `dbdemos-llm-dolly-chatbot-vijay_balasubramaniam` from the dropdown menu ([open cluster configuration](https://e2-demo-field-eng.cloud.databricks.com/#setting/clusters/0519-234333-vj8gvdh9/configuration)). <br />
# MAGIC *Note: If the cluster was deleted after 30 days, you can re-create it with `dbdemos.create_cluster('llm-dolly-chatbot')` or re-install the demo: `dbdemos.install('llm-dolly-chatbot')`*
# COMMAND ----------
# MAGIC %md-sandbox
# MAGIC # Chat Bot with langchain and Dolly
# MAGIC
# MAGIC ## Chat Bot Prompt engineering
# MAGIC
# MAGIC In this example, we will improve our previous Q&A to create a chat bot.
# MAGIC
# MAGIC The main thing we'll be adding is a memory between the different question so that our bot can answer having the context of the previous Q&A.
# MAGIC
# MAGIC
# MAGIC <img style="float:right" width="800px" src="https://raw.githubusercontent.com/databricks-demos/dbdemos-resources/main/images/product/llm-dolly/llm-dolly-chatbot.png">
# MAGIC
# MAGIC ### Keeping memory between multiple questions
# MAGIC
# MAGIC The main challenge for our chat bot is that we won't be able to use the entire discussion history as context to send to dolly.
# MAGIC
# MAGIC First of all this is expensive, but more importantly this won't support long discussion as we'll endup with a text longer than our max window size for our mdoel.
# MAGIC
# MAGIC The trick is to use a summarize model and add an intermediate step which will take the summary of our discussion and inject it in our prompt.
# MAGIC
# MAGIC We will use an intermediate summarization task to do that, using `ConversationSummaryMemory` from `langchain`.
# MAGIC
# MAGIC
# MAGIC **Note: This is a more advanced content, we recommend you start with the Previous notebook: 03-Q&A-prompt-engineering-for-dolly**
# MAGIC
# MAGIC <!-- Collect usage data (view). Remove it to disable collection. View README for more details. -->
# MAGIC <img width="1px" src="https://www.google-analytics.com/collect?v=1>m=GTM-NKQ8TT7&tid=UA-163989034-1&aip=1&t=event&ec=dbdemos&ea=VIEW&dp=%2F_dbdemos%2Fdata-science%2Fllm-dolly-chatbot%2F04-chat-bot-prompt-engineering-dolly&cid=1444828305810485&uid=5984929097066099">
# COMMAND ----------
# MAGIC %md
# MAGIC ### Cluster Setup
# MAGIC
# MAGIC - Run this on a cluster with Databricks Runtime 13.0 ML GPU. It should work on 12.2 ML GPU as well.
# MAGIC - To run this notebook's examples _without_ distributed Spark inference at the end, all that is needed is a single-node 'cluster' with a GPU
# MAGIC - A10 and V100 instances should work, and this example is designed to fit the model in their working memory at some cost to quality
# MAGIC - A100 instances work best, and perform better with minor modifications commented below
# MAGIC - To run the examples using distributed Spark inference at the end, provision a cluster of GPUs (and change the repartitioning at the end to match GPU count)
# MAGIC
# MAGIC *Note that `bitsandbytes` is not needed if running on A100s and the code is modified per comments below to not load in 8-bit.*
# COMMAND ----------
# MAGIC %pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0 bitsandbytes
# COMMAND ----------
# MAGIC %run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llm
# COMMAND ----------
# DBTITLE 1,Create our vector database connection for context
if len(get_available_gpus()) == 0:
Exception("Running dolly without GPU will be slow. We recommend you switch to a Single Node cluster with at least 1 GPU to properly run this demo.")
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma
gardening_vector_db_path = "/dbfs"+demo_path+"/vector_db"
hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
chroma_db = Chroma(collection_name="gardening_docs", embedding_function=hf_embed, persist_directory=gardening_vector_db_path)
# COMMAND ----------
# MAGIC %md
# MAGIC ### 2/ Prompt engineering with `langchain` and memory
# MAGIC
# MAGIC Now we can compose with a language model and prompting strategy to make a `langchain` chain that answers questions with a memory.
# COMMAND ----------
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, AutoModelForSeq2SeqLM
from langchain import PromptTemplate
from langchain.llms import HuggingFacePipeline
from langchain.chains.question_answering import load_qa_chain
from langchain.memory import ConversationSummaryBufferMemory
def build_qa_chain():
torch.cuda.empty_cache()
# Defining our prompt content.
# langchain will load our similar documents as {context}
template = """You are a chatbot having a conversation with a human. Your are asked to answer gardening questions and help cultivating plants.
Given the following extracted parts of a long document and a question, answer the user question. If you don't know, say that you do not know.
{context}
{chat_history}
{human_input}
Response:
"""
prompt = PromptTemplate(input_variables=['context', 'human_input', 'chat_history'], template=template)
# Increase max_new_tokens for a longer response
# Other settings might give better results! Play around
model_name = "databricks/dolly-v2-7b" # can use dolly-v2-3b, dolly-v2-7b or dolly-v2-12b for smaller model and faster inferences.
instruct_pipeline = pipeline(model=model_name, torch_dtype=torch.bfloat16, trust_remote_code=True, device_map="auto",
return_full_text=True, max_new_tokens=256, top_p=0.95, top_k=50)
hf_pipe = HuggingFacePipeline(pipeline=instruct_pipeline)
# Add a summarizer to our memory conversation
# Let's make sure we don't summarize the discussion too much to avoid losing to much of the content
# Models we'll use to summarize our chat history
# We could use one of these models: https://huggingface.co/models?filter=summarization. facebook/bart-large-cnn gives great results, we'll use t5-small for memory
summarize_model = AutoModelForSeq2SeqLM.from_pretrained("t5-small", device_map="auto", torch_dtype=torch.bfloat16, trust_remote_code=True)
summarize_tokenizer = AutoTokenizer.from_pretrained("t5-small", padding_side="left", model_max_length = 512)
pipe_summary = pipeline("summarization", model=summarize_model, tokenizer=summarize_tokenizer) #, max_new_tokens=500, min_new_tokens=300
# langchain pipeline doesn't support summarization yet, we added it as temp fix in the companion notebook _resources/00-init
hf_summary = HuggingFacePipeline_WithSummarization(pipeline=pipe_summary)
#will keep 500 token and then ask for a summary. Removes prefix as our model isn't trained on specific chat prefix and can get confused.
memory = ConversationSummaryBufferMemory(llm=hf_summary, memory_key="chat_history", input_key="human_input", max_token_limit=500, human_prefix = "", ai_prefix = "")
# Set verbose=True to see the full prompt:
print("loading chain, this can take some time...")
return load_qa_chain(llm=hf_pipe, chain_type="stuff", prompt=prompt, verbose=True, memory=memory)
# COMMAND ----------
# MAGIC %md
# MAGIC ## Using the Chain for Simple Question Answering
# MAGIC
# MAGIC That's it! it's ready to go. Define a function to answer a question and pretty-print the answer, with sources:
# COMMAND ----------
class ChatBot():
def __init__(self, db):
self.reset_context()
self.db = db
def reset_context(self):
self.sources = []
self.discussion = []
# Building the chain will load Dolly and can take some time depending on the model size and your GPU
self.qa_chain = build_qa_chain()
displayHTML("<h1>Hi! I'm a chat bot specialized in gardening. How Can I help you today?</h1>")
def get_similar_docs(self, question, similar_doc_count):
return self.db.similarity_search(question, k=similar_doc_count)
def chat(self, question):
# Keep the last 3 discussion to search similar content
self.discussion.append(question)
similar_docs = self.get_similar_docs(" \n".join(self.discussion[-3:]), similar_doc_count=2)
# Remove similar doc if they're already in the last questions (as it's already in the history)
similar_docs = [doc for doc in similar_docs if doc.metadata['source'] not in self.sources[-3:]]
result = self.qa_chain({"input_documents": similar_docs, "human_input": question})
# Cleanup the answer for better display:
answer = result['output_text'].capitalize()
result_html = f"<p><blockquote style=\"font-size:24\">{question}</blockquote></p>"
result_html += f"<p><blockquote style=\"font-size:18px\">{answer}</blockquote></p>"
result_html += "<p><hr/></p>"
for d in result["input_documents"]:
source_id = d.metadata["source"]
self.sources.append(source_id)
result_html += f"<p><blockquote>{d.page_content}<br/>(Source: <a href=\"https://gardening.stackexchange.com/a/{source_id}\">{source_id}</a>)</blockquote></p>"
displayHTML(result_html)
chat_bot = ChatBot(chroma_db)
# COMMAND ----------
# MAGIC %md
# MAGIC Try asking a gardening question!
# COMMAND ----------
chat_bot.chat("What is the best kind of soil to grow blueberries in?")
# COMMAND ----------
chat_bot.chat("How much water should I give?")
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC
# MAGIC
# MAGIC ## Extra: Deploying a langchain pipeline in production with MLFlow (requires DBRML 13+)
# MAGIC
# MAGIC Once our bot is ready, we can package our pipeline using MLflow and the langchain flavor:
# COMMAND ----------
# DBTITLE 1,Deploying our chat bot to MLFlow
def publish_model_to_mlflow():
# Build our langchain pipeline
langchain_model = build_qa_chain()
with mlflow.start_run() as run:
# Save model to MLFlow
# Note that this only saves the langchain pipeline (we could also add the ChatBot with a custom Model Wrapper class)
# See https://mlflow.org/docs/latest/models.html#custom-python-models for an example
# The vector database lives outside of your model
#Note: for now only LLMChain model are supported, qaChain will be added soon
mlflow.langchain.log_model(langchain_model, artifact_path="model")
model_registered = mlflow.register_model(f"runs:/{run.info.run_id}/model", "gardening-bot")
# Move the model in production
client = mlflow.tracking.MlflowClient()
print("registering model version "+model_registered.version+" as production model")
client.transition_model_version_stage("gardening-bot", model_registered.version, stage = "Production", archive_existing_versions=True)
def load_model_and_answer(similar_docs, question):
# Note: this will load the model once more in memory
# Load the langchain pipeline & run inferences
chain = mlflow.pyfunc.load_model(model_uri)
chain.predict({"input_documents": similar_docs, "human_input": question})
# COMMAND ----------
# Make sure you restart the python kernel to free our gpu memory if you're using multiple notebooks0
# (load the model only once in 1 single notebook to avoid OOM)
# dbutils.library.restartPython()
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## Our chatbot is ready!
# MAGIC
# MAGIC That's it, you're ready to deploy your chatbot!
# MAGIC
# MAGIC ### Conclusion
# MAGIC
# MAGIC In this demo, we've seen a basic prompt engineering solution using history memory. More advanced solution can be build to provide better context.
# MAGIC
# MAGIC Having a good training dataset is key to improve our model performance and load better context. Collecting and preparing high quality data is likely the most important part to a successful bot!
# MAGIC
# MAGIC A good way to improve your dataset is to capture your user questions and chat, and incrementally improve your Q&A dataset. <br/>
# MAGIC As example, `langchain` is especially build to work well with a chat bot trained with a dataset similar to OpenAI's, which isn't exactly matching Dolly's. The closest your prompt is engineered to match your training dataset content, the better your bot will behave.
# MAGIC
# MAGIC *A note on inference speed: As we load big models, inference time can be greatly optimized compiling our transformer models. Here is a quick example using onnx:*
# MAGIC
# MAGIC `%pip install -U transformers langchain chromadb accelerate bitsandbytes protobuf==3.19.0 optimum onnx onnxruntime-gpu`
# MAGIC
# MAGIC `%sh optimum-cli export onnx --model databricks/dolly-v2-7b --device cuda --optimize O4 dolly_v2_7b_onnx`
# MAGIC
# MAGIC ```
# MAGIC from optimum.onnxruntime import ORTModelForCausalLM
# MAGIC
# MAGIC # Use Dolly as main model
# MAGIC model_name = "databricks/dolly-v2-3b" # can use dolly-v2-3b, dolly-v2-7b or dolly-v2-12b for smaller model and faster inferences.
# MAGIC tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side="left")
# MAGIC model = ORTModelForCausalLM.from_pretrained("databricks/dolly-v2-3b", export=True, provider="CUDAExecutionProvider")
# MAGIC ```
# MAGIC *You could also leverage FasterTransformer. Contact your Databricks team for more details*
| [
"You are a chatbot having a conversation with a human. Your are asked to answer gardening questions and help cultivating plants.\n Given the following extracted parts of a long document and a question, answer the user question. If you don't know, say that you do not know. \n \n {context}\n\n {chat_history}\n\n {human_input}\n\n Response:\n ",
"What is the best kind of soil to grow blueberries in?",
"chat_history",
"How much water should I give?",
"human_input",
"context"
] |
2024-01-10 | vijaybala-db/databricks-goodies | llm-dolly-chatbot~02-Data-preparation.py | # Databricks notebook source
# MAGIC %md
# MAGIC ### A cluster has been created for this demo
# MAGIC To run this demo, just select the cluster `dbdemos-llm-dolly-chatbot-vijay_balasubramaniam` from the dropdown menu ([open cluster configuration](https://e2-demo-field-eng.cloud.databricks.com/#setting/clusters/0519-234333-vj8gvdh9/configuration)). <br />
# MAGIC *Note: If the cluster was deleted after 30 days, you can re-create it with `dbdemos.create_cluster('llm-dolly-chatbot')` or re-install the demo: `dbdemos.install('llm-dolly-chatbot')`*
# COMMAND ----------
# MAGIC %md-sandbox
# MAGIC # Dolly: data Preparation & Vector database creation with Databricks Lakehouse
# MAGIC
# MAGIC <img style="float: right" width="600px" src="https://raw.githubusercontent.com/databricks-demos/dbdemos-resources/main/images/product/llm-dolly/llm-dolly-data-prep-small.png">
# MAGIC
# MAGIC To be able to specialize our mode, we need a list of Q&A that we'll use as training dataset.
# MAGIC
# MAGIC For this demo, we'll specialize our model using Stack Exchange dataset.
# MAGIC
# MAGIC Let's start with a simple data pipeline ingesting the Stack Exchange dataset, running some cleanup & saving it for further training.
# MAGIC
# MAGIC We will implement the following steps: <br><br>
# MAGIC
# MAGIC <style>
# MAGIC .right_box{
# MAGIC margin: 30px; box-shadow: 10px -10px #CCC; width:650px; height:300px; background-color: #1b3139ff; box-shadow: 0 0 10px rgba(0,0,0,0.6);
# MAGIC border-radius:25px;font-size: 35px; float: left; padding: 20px; color: #f9f7f4; }
# MAGIC .badge {
# MAGIC clear: left; float: left; height: 30px; width: 30px; display: table-cell; vertical-align: middle; border-radius: 50%; background: #fcba33ff; text-align: center; color: white; margin-right: 10px; margin-left: -35px;}
# MAGIC .badge_b {
# MAGIC margin-left: 25px; min-height: 32px;}
# MAGIC </style>
# MAGIC
# MAGIC
# MAGIC <div style="margin-left: 20px">
# MAGIC <div class="badge_b"><div class="badge">1</div> Download raw Q&A dataset</div>
# MAGIC <div class="badge_b"><div class="badge">2</div> Clean & prepare our gardenig questions and best answers</div>
# MAGIC <div class="badge_b"><div class="badge">3</div> Use a Sentence 2 Vect model to transform our docs in a vector</div>
# MAGIC <div class="badge_b"><div class="badge">4</div> Index the vector in our Vector database (Chroma)</div>
# MAGIC </div>
# MAGIC <br/>
# MAGIC
# MAGIC <!-- Collect usage data (view). Remove it to disable collection. View README for more details. -->
# MAGIC <img width="1px" src="https://www.google-analytics.com/collect?v=1>m=GTM-NKQ8TT7&tid=UA-163989034-1&aip=1&t=event&ec=dbdemos&ea=VIEW&dp=%2F_dbdemos%2Fdata-science%2Fllm-dolly-chatbot%2F02-Data-preparation&cid=1444828305810485&uid=5984929097066099">
# COMMAND ----------
# DBTITLE 1,Install our vector database
# MAGIC %pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0
# COMMAND ----------
# MAGIC %run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llm
# COMMAND ----------
# MAGIC %md
# MAGIC ## 1/ Downloading and extracting the raw dataset
# MAGIC
# MAGIC We'll focus on Gardening question, and download the gardening dataset
# MAGIC
# MAGIC - Grab the Gardening StackExchange dataset
# MAGIC - Un-7zip it (needs `7z` installed)
# MAGIC - Copy out the `Posts.xml`
# MAGIC - Parse it with `spark-xml`
# MAGIC
# MAGIC *Note that for a real-world scenario, we would be retrieving our data from external systems such as message queue (kafka), SQL database, blob storage...*
# COMMAND ----------
# DBTITLE 1,Extract the dataset using sh command
# MAGIC %sh
# MAGIC #To keep it simple, we'll download and extract the dataset using standard bash commands
# MAGIC #Install 7zip to extract the file
# MAGIC apt-get install -y p7zip-full
# MAGIC
# MAGIC rm -r /tmp/gardening
# MAGIC mkdir -p /tmp/gardening
# MAGIC cd /tmp/gardening
# MAGIC #Download & extract the gardening archive
# MAGIC curl -L https://archive.org/download/stackexchange/gardening.stackexchange.com.7z -o gardening.7z
# MAGIC 7z x gardening.7z
# MAGIC #Move the dataset to our main bucket
# MAGIC rm -r /dbfs/dbdemos/product/llm/gardening/raw
# MAGIC mkdir -p /dbfs/dbdemos/product/llm/gardening/raw
# MAGIC cp -f Posts.xml /dbfs/dbdemos/product/llm/gardening/raw
# COMMAND ----------
# DBTITLE 1,Our Q&A dataset is ready
# MAGIC %fs ls /dbdemos/product/llm/gardening/raw
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## 2/ Clean & prepare our gardenig questions and best answers
# MAGIC
# MAGIC Let's ingest the data using [spark xml](https://github.com/databricks/spark-xml). Make sure the library is added to your cluster configuration page as a Maven library:
# MAGIC
# MAGIC Maven coordinates: `com.databricks:spark-xml_2.12:0.16.0` (we loaded it to the cluster created by dbdemos)
# MAGIC
# MAGIC We will perform some light preprocessing on the results:
# MAGIC - Keep only questions/answers with a reasonable score
# MAGIC - Parse HTML into plain text
# MAGIC - Join questions and answers to form question-answer pairs
# MAGIC
# MAGIC *Note that this pipeline is basic. For more advanced ingestion example with Databricks lakehouse, try Delta Live Table: `dbdemos.instal('dlt_loan')`*
# COMMAND ----------
# DBTITLE 1,Review our raw Q&A dataset
gardening_raw_path = demo_path+"/gardening/raw"
print(f"loading raw xml dataset under {gardening_raw_path}")
raw_gardening = spark.read.format("xml").option("rowTag", "row").load(f"{gardening_raw_path}/Posts.xml")
display(raw_gardening)
# COMMAND ----------
from bs4 import BeautifulSoup
#UDF to transform html content as text
@pandas_udf("string")
def html_to_text(html):
return html.apply(lambda x: BeautifulSoup(x).get_text())
gardening_df =(raw_gardening
.filter("_Score >= 5") # keep only good answer/question
.filter(length("_Body") <= 1000) #remove too long questions
.withColumn("body", html_to_text("_Body")) #Convert html to text
.withColumnsRenamed({"_Id": "id", "_ParentId": "parent_id"})
.select("id", "body", "parent_id"))
# Save 'raw' content for later loading of questions
gardening_df.write.mode("overwrite").saveAsTable(f"gardening_dataset")
display(spark.table("gardening_dataset"))
# COMMAND ----------
# DBTITLE 1,Assemble questions and answers
gardening_df = spark.table("gardening_dataset")
# Self-join to assemble questions and answers
qa_df = gardening_df.alias("a").filter("parent_id IS NULL") \
.join(gardening_df.alias("b"), on=[col("a.id") == col("b.parent_id")]) \
.select("b.id", "a.body", "b.body") \
.toDF("answer_id", "question", "answer")
# Prepare the training dataset: question following with the best answers.
docs_df = qa_df.select(col("answer_id"), F.concat(col("question"), F.lit("\n\n"), col("answer"))).toDF("source", "text")
display(docs_df)
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ### Adding a shorter version to speedup our inference
# MAGIC
# MAGIC Our Dataset is now composed of one question followed by the best answers.
# MAGIC
# MAGIC A potential issue is that this can be a fairly long text. Using long text as context can slow down LLM inference. One option is to summarize these Q&A using a summarizer LLM and save back the result as a new field.
# MAGIC
# MAGIC This operation can take some time, this is why we'll do it once in our data preparation pipeline so that we don't have to summarize our Q&A during the inference.
# COMMAND ----------
# DBTITLE 1,Adding a summary of our data
from typing import Iterator
import pandas as pd
from transformers import pipeline
@pandas_udf("string")
def summarize(iterator: Iterator[pd.Series]) -> Iterator[pd.Series]:
# Load the model for summarization
torch.cuda.empty_cache()
summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device_map="auto")
def summarize_txt(text):
if len(text) > 5000:
return summarizer(text)[0]['summary_text']
return text
for serie in iterator:
# get a summary for each row
yield serie.apply(summarize_txt)
# We won't run it as this can take some time in the entire dataset. In this demo we set repartition to 1 as we just have 1 GPU by default.
# docs_df = docs_df.repartition(1).withColumn("text_short", summarize("text"))
docs_df.write.mode("overwrite").option("mergeSchema", "true").saveAsTable(f"gardening_training_dataset")
display(spark.table("gardening_training_dataset"))
# COMMAND ----------
# MAGIC %md
# MAGIC ## 3/ Load our model to transform our docs to embeddings
# MAGIC
# MAGIC We will simply load a sentence to embedding model from hugging face and use it later in the chromadb client.
# COMMAND ----------
from langchain.embeddings import HuggingFaceEmbeddings
# Download model from Hugging face
hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## 4/ Index the documents (rows) in our vector database
# MAGIC
# MAGIC Now it's time to load the texts that have been generated, and create a searchable database of text for use in the `langchain` pipeline. <br>
# MAGIC These documents are embedded, so that later queries can be embedded too, and matched to relevant text chunks by embedding.
# MAGIC
# MAGIC - Collect the text chunks with Spark; `langchain` also supports reading chunks directly from Word docs, GDrive, PDFs, etc.
# MAGIC - Create a simple in-memory Chroma vector DB for storage
# MAGIC - Instantiate an embedding function from `sentence-transformers`
# MAGIC - Populate the database and save it
# COMMAND ----------
# DBTITLE 1,Prepare our database storage location (in dbfs)
# Prepare a directory to store the document database. Any path on `/dbfs` will do.
dbutils.widgets.dropdown("reset_vector_database", "false", ["false", "true"], "Recompute embeddings for chromadb")
gardening_vector_db_path = demo_path+"/vector_db"
# Don't recompute the embeddings if the're already available
compute_embeddings = dbutils.widgets.get("reset_vector_database") == "true" or is_folder_empty(gardening_vector_db_path)
if compute_embeddings:
print(f"creating folder {gardening_vector_db_path} under our blob storage (dbfs)")
dbutils.fs.rm(gardening_vector_db_path, True)
dbutils.fs.mkdirs(gardening_vector_db_path)
# COMMAND ----------
# MAGIC %md
# MAGIC Create the document database:
# MAGIC - Just collect the relatively small dataset of text and form `Document`s; `langchain` can also form doc collections directly from PDFs, GDrive files, etc
# MAGIC - Split long texts into manageable chunks
# COMMAND ----------
locals()
# COMMAND ----------
from langchain.docstore.document import Document
from langchain.vectorstores import Chroma
all_texts = spark.table("gardening_training_dataset")
print(f"Saving document embeddings under /dbfs{gardening_vector_db_path}")
if compute_embeddings:
# Transform our rows as langchain Documents
# If you want to index shorter term, use the text_short field instead
documents = [Document(page_content=r["text"], metadata={"source": r["source"]}) for r in all_texts.collect()]
# If your texts are long, you may need to split them. However it's best to summarize them instead as show above.
# text_splitter = CharacterTextSplitter(separator="\n", chunk_size=1000, chunk_overlap=100)
# documents = text_splitter.split_documents(documents)
# Init the chroma db with the sentence-transformers/all-mpnet-base-v2 model loaded from hugging face (hf_embed)
db = Chroma.from_documents(collection_name="gardening_docs", documents=documents, embedding=hf_embed, persist_directory="/dbfs"+gardening_vector_db_path)
db.similarity_search("dummy") # tickle it to persist metadata (?)
db.persist()
# COMMAND ----------
# Make sure you restart the python kernel to free our gpu memory if you're using multiple notebooks0
# (load the model only once in 1 single notebook to avoid OOM)
dbutils.library.restartPython()
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## That's it, our Q&A dataset is ready.
# MAGIC
# MAGIC In this notebook, we leverage Databricks to prepare our Q&A dataset:
# MAGIC
# MAGIC * Ingesting & cleaning our dataset
# MAGIC * Preparing our embeddings and saving them in chroma
# MAGIC
# MAGIC We're now ready to use this dataset to improve our prompt context and build our Gardening Chat Bot!
# MAGIC Open the next notebook [03-Q&A-prompt-engineering-for-dolly]($./03-Q&A-prompt-engineering-for-dolly)
| [] |
2024-01-10 | vijaybala-db/databricks-goodies | llm-dolly-chatbot~03-Q%26A-prompt-engineering-for-dolly.py | # Databricks notebook source
# MAGIC %md
# MAGIC ### A cluster has been created for this demo
# MAGIC To run this demo, just select the cluster `dbdemos-llm-dolly-chatbot-vijay_balasubramaniam` from the dropdown menu ([open cluster configuration](https://e2-demo-field-eng.cloud.databricks.com/#setting/clusters/0519-234333-vj8gvdh9/configuration)). <br />
# MAGIC *Note: If the cluster was deleted after 30 days, you can re-create it with `dbdemos.create_cluster('llm-dolly-chatbot')` or re-install the demo: `dbdemos.install('llm-dolly-chatbot')`*
# COMMAND ----------
# MAGIC %md-sandbox
# MAGIC # Question Answering over Custom Datasets with langchain and Dolly
# MAGIC
# MAGIC ## Prompt engineering
# MAGIC
# MAGIC Prompt engineering is a technique used to wrap the given user question with more information to better guide the model in its anwser.<br/>
# MAGIC A prompt engineered would typically contains:
# MAGIC - guidance on how to answer given the usage (*ex: You are a gardener. Answer the following question as best as you can to keep plants alive*)
# MAGIC - Extra context to help your model. For example similar text close to the user question (*ex: Knowing that [Content from your internal Q&A], please answer...*)
# MAGIC - Specific instruction in the answer (*ex: Answer in Italian*)
# MAGIC - Information on the previous questions to keep a context if you're building a chat bot (compressed as embedding)
# MAGIC - ...
# MAGIC
# MAGIC <img style="float:right" width="700px" src="https://raw.githubusercontent.com/databricks-demos/dbdemos-resources/main/images/product/llm-dolly/llm-dolly-inference-small.png">
# MAGIC
# MAGIC In this example, we'll use `langchain` to help us craft better prompt
# MAGIC
# MAGIC ## Our Gardening prompt engineering
# MAGIC
# MAGIC
# MAGIC
# MAGIC This example shows how to apply `langchain`, Hugging Face `transformers`, and even Apache Spark to answer questions about a specific text corpus.
# MAGIC
# MAGIC It uses the Dolly2 LLM from Databricks, though this example can make use of any text-generation LLM or even OpenAI with minor changes.
# MAGIC
# MAGIC <style>
# MAGIC .right_box{
# MAGIC margin: 30px; box-shadow: 10px -10px #CCC; width:650px; height:300px; background-color: #1b3139ff; box-shadow: 0 0 10px rgba(0,0,0,0.6);
# MAGIC border-radius:25px;font-size: 35px; float: left; padding: 20px; color: #f9f7f4; }
# MAGIC .badge {
# MAGIC clear: left; float: left; height: 30px; width: 30px; display: table-cell; vertical-align: middle; border-radius: 50%; background: #fcba33ff; text-align: center; color: white; margin-right: 10px; margin-left: -35px;}
# MAGIC .badge_b {
# MAGIC margin-left: 25px; min-height: 32px;}
# MAGIC </style>
# MAGIC
# MAGIC We'll implement the following flow: <br><br>
# MAGIC
# MAGIC <div style="margin-left: 20px">
# MAGIC <div class="badge_b"><div class="badge">1</div> Get the question and transform it as embedding using the same sentence 2 embedding model.</div>
# MAGIC <div class="badge_b"><div class="badge">2</div> Do a similarity search within chroma to find related question & answers</div>
# MAGIC <div class="badge_b"><div class="badge">3</div> Engineer a prompt containing the question & the similar Q&A as context</div>
# MAGIC <div class="badge_b"><div class="badge">4</div> Send the prompt to dolly</div>
# MAGIC <div class="badge_b"><div class="badge">5</div> Our customer get their gardening advise!</div>
# MAGIC </div>
# MAGIC <br/>
# MAGIC
# MAGIC <!-- Collect usage data (view). Remove it to disable collection. View README for more details. -->
# MAGIC <img width="1px" src="https://www.google-analytics.com/collect?v=1>m=GTM-NKQ8TT7&tid=UA-163989034-1&aip=1&t=event&ec=dbdemos&ea=VIEW&dp=%2F_dbdemos%2Fdata-science%2Fllm-dolly-chatbot%2F03-Q%26A-prompt-engineering-for-dolly&cid=1444828305810485&uid=5984929097066099">
# COMMAND ----------
# MAGIC %pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0 bitsandbytes
# COMMAND ----------
# MAGIC %run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llm
# COMMAND ----------
# MAGIC %md
# MAGIC ### Cluster Setup
# MAGIC
# MAGIC - Run this on a cluster with Databricks Runtime 13.0 ML GPU. It should work on 12.2 ML GPU as well.
# MAGIC - To run this notebook's examples _without_ distributed Spark inference at the end, all that is needed is a single-node 'cluster' with a GPU
# MAGIC - A10 and V100 instances should work, and this example is designed to fit the model in their working memory at some cost to quality
# MAGIC - A100 instances work best, and perform better with minor modifications commented below
# MAGIC - To run the examples using distributed Spark inference at the end, provision a cluster of GPUs (and change the repartitioning at the end to match GPU count)
# MAGIC
# MAGIC *Note that `bitsandbytes` is not needed if running on A100s and the code is modified per comments below to not load in 8-bit.*
# COMMAND ----------
# MAGIC %md
# MAGIC ### 1/ Download our 2 embeddings model from hugging face (same as data preparation)
# COMMAND ----------
# Start here to load a previously-saved DB
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma
if len(get_available_gpus()) == 0:
Exception("Running dolly without GPU will be slow. We recommend you switch to a Single Node cluster with at least 1 GPU to properly run this demo.")
gardening_vector_db_path = "/dbfs"+demo_path+"/vector_db"
hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
db = Chroma(collection_name="gardening_docs", embedding_function=hf_embed, persist_directory=gardening_vector_db_path)
# COMMAND ----------
# MAGIC %md
# MAGIC ### 2/ Similarity search using chroma
# MAGIC
# MAGIC Let's test our similarity search with a simple question.
# MAGIC
# MAGIC Note that `k` (`similar_doc_count`): is the number of chunks of text retrieved to send to the prompt. Longer prompts add more context but takes longer to process.
# COMMAND ----------
def get_similar_docs(question, similar_doc_count):
return db.similarity_search(question, k=similar_doc_count)
# Let's test it with blackberries:
for doc in get_similar_docs("how to grow blackberry?", 2):
print(doc.page_content)
# COMMAND ----------
# Vijay's notes - You can use this to search relevant documents
get_similar_docs("how to grow apples?", 10)
# COMMAND ----------
# MAGIC %md
# MAGIC ### 3/ Prompt engineering with `langchain`
# MAGIC
# MAGIC Now we can compose with a language model and prompting strategy to make a `langchain` chain that answers questions.
# COMMAND ----------
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import torch
from langchain import PromptTemplate
from langchain.llms import HuggingFacePipeline
from langchain.chains.question_answering import load_qa_chain
def build_qa_chain():
torch.cuda.empty_cache()
model_name = "databricks/dolly-v2-7b" # can use dolly-v2-3b or dolly-v2-7b for smaller model and faster inferences.
# Increase max_new_tokens for a longer response
# Other settings might give better results! Play around
instruct_pipeline = pipeline(model=model_name, torch_dtype=torch.bfloat16, trust_remote_code=True, device_map="auto",
return_full_text=True, max_new_tokens=256, top_p=0.95, top_k=50)
# Note: if you use dolly 12B or smaller model but a GPU with less than 24GB RAM, use 8bit. This requires %pip install bitsandbytes
# instruct_pipeline = pipeline(model=model_name, load_in_8bit=True, trust_remote_code=True, device_map="auto")
# For GPUs without bfloat16 support, like the T4 or V100, use torch_dtype=torch.float16 below
# model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", torch_dtype=torch.float16, trust_remote_code=True)
# Defining our prompt content.
# langchain will load our similar documents as {context}
template = """Below is an instruction that describes a task. Write a response that appropriately completes the request.
Instruction:
You are a gardener and your job is to help providing the best gardening answer.
Use only information in the following paragraphs to answer the question at the end. Explain the answer with reference to these paragraphs. If you don't know, say that you do not know.
{context}
Question: {question}
Response:
"""
prompt = PromptTemplate(input_variables=['context', 'question'], template=template)
hf_pipe = HuggingFacePipeline(pipeline=instruct_pipeline)
# Set verbose=True to see the full prompt:
return load_qa_chain(llm=hf_pipe, chain_type="stuff", prompt=prompt, verbose=True)
# COMMAND ----------
# Building the chain will load Dolly and can take several minutes depending on the model size
qa_chain = build_qa_chain()
# COMMAND ----------
# MAGIC %md
# MAGIC Note that there are _many_ factors that affect how the language model answers a question. Most notable is the prompt template itself. This can be changed, and different prompts may work better or worse with certain models.
# MAGIC
# MAGIC The generation process itself also has many knobs to tune, and often it simply requires trial and error to find settings that work best for certain models and certain data sets. See this [excellent guide from Hugging Face](https://huggingface.co/blog/how-to-generate).
# MAGIC
# MAGIC The settings that most affect performance are:
# MAGIC - `max_new_tokens`: longer responses take longer to generate. Reduce for shorter, faster responses
# MAGIC - `num_beams`: if using beam search, more beams increase run time more or less linearly
# COMMAND ----------
# MAGIC %md
# MAGIC ## 4/ Using the Chain for Simple Question Answering
# MAGIC
# MAGIC That's it! it's ready to go. Define a function to answer a question and pretty-print the answer, with sources:
# COMMAND ----------
def answer_question(question, similar_doc_count=2):
similar_docs = get_similar_docs(question, similar_doc_count)
result = qa_chain({"input_documents": similar_docs, "question": question})
result_html = f"<p><blockquote style=\"font-size:24\">{question}</blockquote></p>"
result_html += f"<p><blockquote style=\"font-size:18px\">{result['output_text']}</blockquote></p>"
result_html += "<p><hr/></p>"
for d in result["input_documents"]:
source_id = d.metadata["source"]
result_html += f"<p><blockquote>{d.page_content}<br/>(Source: <a href=\"https://gardening.stackexchange.com/a/{source_id}\">{source_id}</a>)</blockquote></p>"
displayHTML(result_html)
# COMMAND ----------
# MAGIC %md
# MAGIC Try asking a gardening question!
# COMMAND ----------
answer_question("What is the best kind of soil to grow blueberries in?", similar_doc_count=4)
# COMMAND ----------
from IPython.display import Audio
# Path to the .WAV audio file
audio_path = "/databricks/driver/hello.wav"
# Play the audio file
Audio(audio_path, autoplay=True)
# COMMAND ----------
answer_question("When is the best time of the year to plant tulip bulbs?", similar_doc_count=4)
# COMMAND ----------
answer_question("How much sunlight is required for a vegetable garden?", similar_doc_count=4)
# COMMAND ----------
answer_question("What are the benefits of pesticides when growing vegetables?", similar_doc_count=4)
# COMMAND ----------
answer_question("What are the best fruits to grow in Fremont, California?", similar_doc_count=4)
# COMMAND ----------
# Vijay's Note - Stop notebook execution for demo purposes (to prevent Python restart at end)
dbutils.notebook.exit("Breakpoint to test interactive question answering")
# COMMAND ----------
# MAGIC %md
# MAGIC # Scaling our Question Answering with Spark
# MAGIC
# MAGIC Let's now see how we can scale this process to answer our question at scale using a Spark UDF.
# MAGIC
# MAGIC Questions will be answered in parallel with Spark. Note that this section requires a cluster with GPU workers.
# COMMAND ----------
#Free some memory to avoid loading model twice & OOM
del hf_embed, qa_chain, db
cuda.get_current_device().reset()
gc.collect()
@pandas_udf('answer string, sources array<string>')
def answer_question_udf(question_sets: Iterator[pd.Series]) -> Iterator[pd.DataFrame]:
os.environ['TRANSFORMERS_CACHE'] = hugging_face_cache
hf_embed_udf = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
db_udf = Chroma(collection_name="gardening_docs", embedding_function=hf_embed_udf, persist_directory=gardening_vector_db_path)
qa_chain_udf = build_qa_chain()
for questions in question_sets:
responses = []
for question in questions:
# k is the number of docs to retrieve to feed as context
similar_docs = db_udf.similarity_search(question, k=1)
result = qa_chain_udf({"input_documents": similar_docs, "question": question})
responses.append({"answer": result["output_text"], "sources": [str(d.metadata["source"]) for d in result["input_documents"]]})
yield pd.DataFrame(responses)
# COMMAND ----------
# MAGIC %md
# MAGIC Add some questions to answer
# COMMAND ----------
new_questions_df = spark.table("gardening_dataset") \
.filter("parent_id IS NULL") \
.select("body") \
.toDF("question") \
.limit(5)
#Saving a subset of question to answer for faster processing for the demo.
new_questions_df.repartition(1).write.mode("overwrite").saveAsTable("question_to_answer")
new_questions_df = spark.table("question_to_answer").repartition(1) # Repartition to number of GPUs (multi node or single node with N gpu)
display(new_questions_df)
# COMMAND ----------
#Note: see the next notebook to compile the models for faster inference time.
response_df = new_questions_df.select(col("question"), answer_question_udf("question").alias("response")).select("question", "response.*")
display(response_df)
# COMMAND ----------
# DBTITLE 1,Cleanup our GPY memory before the next notebook
# Make sure you restart the python kernel to free our gpu memory if you're using multiple notebooks0
# (load the model only once in 1 single notebook to avoid OOM)
dbutils.library.restartPython()
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC # Next: improving our Q&A prompt to chain questions as a chatbot
# MAGIC
# MAGIC Open the next notebook [04-chat-bot-prompt-engineering-dolly]($./04-chat-bot-prompt-engineering-dolly) to improve our chain and add memory between our interaction.
# COMMAND ----------
| [
"question",
"Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n Instruction: \n You are a gardener and your job is to help providing the best gardening answer. \n Use only information in the following paragraphs to answer the question at the end. Explain the answer with reference to these paragraphs. If you don't know, say that you do not know.\n\n {context}\n \n Question: {question}\n\n Response:\n ",
"context"
] |
2024-01-10 | mirabdullahyaser/Retrieval-Augmented-Generation-Engine-with-LangChain-and-Streamlit | rag_engine.py | import os, tempfile
import pinecone
from pathlib import Path
from langchain.chains import RetrievalQA, ConversationalRetrievalChain
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain import OpenAI
from langchain.llms.openai import OpenAIChat
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma, Pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.memory import ConversationBufferMemory
from langchain.memory.chat_message_histories import StreamlitChatMessageHistory
import streamlit as st
TMP_DIR = Path(__file__).resolve().parent.joinpath('data', 'tmp')
LOCAL_VECTOR_STORE_DIR = Path(__file__).resolve().parent.joinpath('data', 'vector_store')
st.set_page_config(page_title="RAG")
st.title("Retrieval Augmented Generation Engine")
def load_documents():
loader = DirectoryLoader(TMP_DIR.as_posix(), glob='**/*.pdf')
documents = loader.load()
return documents
def split_documents(documents):
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
return texts
def embeddings_on_local_vectordb(texts):
vectordb = Chroma.from_documents(texts, embedding=OpenAIEmbeddings(),
persist_directory=LOCAL_VECTOR_STORE_DIR.as_posix())
vectordb.persist()
retriever = vectordb.as_retriever(search_kwargs={'k': 7})
return retriever
def embeddings_on_pinecone(texts):
pinecone.init(api_key=st.session_state.pinecone_api_key, environment=st.session_state.pinecone_env)
embeddings = OpenAIEmbeddings(openai_api_key=st.session_state.openai_api_key)
vectordb = Pinecone.from_documents(texts, embeddings, index_name=st.session_state.pinecone_index)
retriever = vectordb.as_retriever()
return retriever
def query_llm(retriever, query):
qa_chain = ConversationalRetrievalChain.from_llm(
llm=OpenAIChat(openai_api_key=st.session_state.openai_api_key),
retriever=retriever,
return_source_documents=True,
)
result = qa_chain({'question': query, 'chat_history': st.session_state.messages})
result = result['answer']
st.session_state.messages.append((query, result))
return result
def input_fields():
#
with st.sidebar:
#
if "openai_api_key" in st.secrets:
st.session_state.openai_api_key = st.secrets.openai_api_key
else:
st.session_state.openai_api_key = st.text_input("OpenAI API key", type="password")
#
if "pinecone_api_key" in st.secrets:
st.session_state.pinecone_api_key = st.secrets.pinecone_api_key
else:
st.session_state.pinecone_api_key = st.text_input("Pinecone API key", type="password")
#
if "pinecone_env" in st.secrets:
st.session_state.pinecone_env = st.secrets.pinecone_env
else:
st.session_state.pinecone_env = st.text_input("Pinecone environment")
#
if "pinecone_index" in st.secrets:
st.session_state.pinecone_index = st.secrets.pinecone_index
else:
st.session_state.pinecone_index = st.text_input("Pinecone index name")
#
st.session_state.pinecone_db = st.toggle('Use Pinecone Vector DB')
#
st.session_state.source_docs = st.file_uploader(label="Upload Documents", type="pdf", accept_multiple_files=True)
#
def process_documents():
if not st.session_state.openai_api_key or not st.session_state.pinecone_api_key or not st.session_state.pinecone_env or not st.session_state.pinecone_index or not st.session_state.source_docs:
st.warning(f"Please upload the documents and provide the missing fields.")
else:
try:
for source_doc in st.session_state.source_docs:
#
with tempfile.NamedTemporaryFile(delete=False, dir=TMP_DIR.as_posix(), suffix='.pdf') as tmp_file:
tmp_file.write(source_doc.read())
#
documents = load_documents()
#
for _file in TMP_DIR.iterdir():
temp_file = TMP_DIR.joinpath(_file)
temp_file.unlink()
#
texts = split_documents(documents)
#
if not st.session_state.pinecone_db:
st.session_state.retriever = embeddings_on_local_vectordb(texts)
else:
st.session_state.retriever = embeddings_on_pinecone(texts)
except Exception as e:
st.error(f"An error occurred: {e}")
def boot():
#
input_fields()
#
st.button("Submit Documents", on_click=process_documents)
#
if "messages" not in st.session_state:
st.session_state.messages = []
#
for message in st.session_state.messages:
st.chat_message('human').write(message[0])
st.chat_message('ai').write(message[1])
#
if query := st.chat_input():
st.chat_message("human").write(query)
response = query_llm(st.session_state.retriever, query)
st.chat_message("ai").write(response)
if __name__ == '__main__':
#
boot()
| [] |
2024-01-10 | fsadykov/python | lilu~lilu.py | class Lilu():
def __init__(self,):
pass
import openai, os
import speech_recognition as sr
import subprocess
# Set the API key
openai.api_key = os.getenv('OPEN_AI_TOKEN')
r = sr.Recognizer()
# Use the GPT-3 language model to generate text
prompt = "How you would asnswer to question 'What is the difference between pod and deployment'"
model = "text-davinci-002"
while True:
# Start listening for voice input
# with sr.Microphone() as source:
# r.adjust_for_ambient_noise(source)
# print("Listening...")
# audio = r.listen(source)
prompt = input('Ask me question: ')
# Transcribe the audio to text
# prompt = r.recognize_google(audio)
completions = openai.Completion.create(engine=model, prompt=prompt, max_tokens=1024, n=1,stop=None,temperature=0.5)
message = completions.choices[0].text
print(message)
# Set up the speech recognition module
# Call the say command
# subprocess.run(["say", message])
| [
"How you would asnswer to question 'What is the difference between pod and deployment'",
"Ask me question: "
] |
2024-01-10 | 0xangelo/raylab | raylab~utils~param_noise.py | """
From OpenAI Baselines:
https://github.com/openai/baselines/blob/master/baselines/ddpg/noise.py
"""
from dataclasses import dataclass, field
import numpy as np
@dataclass
class AdaptiveParamNoiseSpec:
"""Adaptive schedule for parameter noise exploration.
Note that initial_stddev and curr_stddev refer to std of parameter noise,
but desired_action_stddev refers to (as name suggests) the desired stddev
in action space.
"""
initial_stddev: float = 0.1
desired_action_stddev: float = 0.2
adaptation_coeff: float = 1.01
curr_stddev: float = field(init=False)
def __post_init__(self):
self.curr_stddev = self.initial_stddev
def adapt(self, distance):
"""Update current stddev based on action space distance."""
if distance > self.desired_action_stddev:
self.curr_stddev /= self.adaptation_coeff # Decrease stddev.
else:
self.curr_stddev *= self.adaptation_coeff # Increase stddev.
def ddpg_distance_metric(actions1, actions2):
"""Compute "distance" between actions taken by two policies at the same states.
Expects numpy arrays.
"""
diff = actions1 - actions2
mean_diff = np.mean(np.square(diff), axis=0)
dist = np.sqrt(np.mean(mean_diff))
return dist
| [] |
2024-01-10 | lh728/NLP_Program | Import_file.py | import sys
import re, numpy as np, pandas as pd
from pprint import pprint
import gensim, spacy, logging, warnings # gensim,spacy package needs pip install
import gensim.corpora as corpora
import seaborn as sns
import matplotlib.colors as mcolors
'''
Gensim previously only wrapped the lemmatization routines of another library (Pattern) -
this was not a particularly modern/maintained option, so removed from Gensim-4.0
from gensim.utils import lemmatize
so we choose from nltk.stem import WordNetLemmatizer
'''
from nltk.stem import WordNetLemmatizer
from gensim.utils import simple_preprocess
from matplotlib import pyplot as plt
from wordcloud import WordCloud, STOPWORDS
import matplotlib.colors as mcolors
from gensim.models import CoherenceModel
import matplotlib.pyplot as plt
plt.style.use('seaborn')
from nltk.corpus import stopwords
%matplotlib inline
warnings.filterwarnings("ignore",category=DeprecationWarning)
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.ERROR)
from sklearn.datasets import fetch_20newsgroups
import nltk
nltk.download('stopwords')
import json
from spacy.lang.en import English
from collections import Counter
from sklearn.manifold import TSNE
from bokeh.plotting import figure, output_file, show
from bokeh.models import Label
import pyLDAvis.gensim_models
| [] |
2024-01-10 | guthubcloudittogether/dataengineering-agent | deagent~deagent.py | """Welcome to Reflex! This app is a demonstration of OpenAI's GPT."""
import datetime
import os
import openai
import reflex as rx
from dotenv import load_dotenv
from deagent import style
from deagent.conversation import Conversation
from deagent.functions import *
from deagent.openaichat_util import chat_completion_with_function_execution
from .helpers import navbar
load_dotenv()
openai.api_key = os.getenv('OPENAI_API_KEY')
class User(rx.Model, table=True):
"""A table for users in the database."""
username: str
password: str
class Question(rx.Model, table=True):
"""A table for questions and answers in the database."""
username: str
prompt: str
answer: str
timestamp: datetime.datetime = datetime.datetime.now()
class State(rx.State):
"""The app state."""
show_columns = ["Question", "Answer"]
username: str = ""
password: str = ""
prompt: str = ""
result: str = ""
status: str = "DE Hackernews Agent"
metastatus: str = "OpenAI Function Calling Demo"
is_uploading: bool
def ask_hn(self):
self.is_uploading = True
print(f"PROMPT ****** {self.prompt}")
hn_conversation.add_message("user", self.prompt)
self.status = "Processing Query"
self.metastatus = "Extracting information from hackernews"
chat_response = chat_completion_with_function_execution(
hn_conversation.conversation_history, functions=hnapi_functions
)
self.is_uploading = False
try:
if chat_response:
self.status = "Response Received"
self.metastatus = f"Total Response length {len(chat_response)}"
else:
self.status = "No Response"
self.metastatus = ""
self.result = chat_response
except Exception as e:
print(e)
return rx.window_alert("Error occured with OpenAI execution.")
def save_result(self):
with rx.session() as session:
answer = Question(
username=self.username, prompt=self.prompt, answer=self.result
)
session.add(answer)
session.commit()
def set_username(self, username):
self.username = username.strip()
def set_password(self, password):
self.password = password.strip()
def status():
return rx.center(
rx.vstack(
rx.alert(
rx.alert_icon(),
rx.alert_title(State.status),
rx.alert_description(State.metastatus),
status="success",
variant="subtle",
),
border="1px solid #eaeaef",
padding="2rem",
border_radius=8,
margin_left="10rem",
# align_items="right",
# overflow="right"
)
)
def index():
return rx.center(
navbar(State),
rx.vstack(
rx.center(
rx.vstack(
rx.cond(
State.is_uploading,
rx.progress(is_indeterminate=True, color="blue", width="100%"),
rx.progress(value=0, width="100%"),
),
rx.text_area(
default_value=State.result,
placeholder="HN Result",
is_disabled=State.is_uploading,
width="100%",
height="90%",
is_read_only=True,
),
shadow="lg",
padding="1em",
border_radius="lg",
width="100%",
height="400px",
),
width="100%",
),
rx.center(
rx.vstack(
rx.hstack(
rx.input(
placeholder="Ask a question",
is_disabled=State.is_uploading,
style=style.input_style,
on_blur=State.set_prompt,
width="100%",
),
rx.button(
"Ask", style=style.button_style, on_click=State.ask_hn
),
width="500px",
)
),
shadow="lg",
padding="2em",
border_radius="lg",
width="100%",
),
status(),
width="80%",
height="80%",
spacing="2em",
),
padding_top="6em",
text_align="top",
position="relative",
)
hn_system_message = """You are a DataEngineering Agent, a helpful assistant reads hackernews to answer user questions.
You summarize the hackernews stories and comments clearly so the customer can decide which to read to answer their question.
You always keep the maximimum characters per topic within 400 and if there are more than one summaries,
then you create new paragraph with sequence"""
hn_conversation = Conversation()
hn_conversation.add_message("system", hn_system_message)
# Add state and page to the app.
app = rx.App(state=State)
app.add_page(index)
# app.add_page(home)
# app.add_page(signup)
# app.add_page(home)
app.compile()
| [] |
2024-01-10 | guthubcloudittogether/dataengineering-agent | deagent~state.py | """Welcome to Reflex! This app is a demonstration of OpenAI's GPT."""
import reflex as rx
from .helpers import navbar
import openai
import datetime
from deagent import style
from deagent.conversation import Conversation
from typing import Optional
from deagent.openaichat_util import chat_completion_with_function_execution
from deagent.functions import *
openai.api_key = "sk F "
MAX_QUESTIONS = 10
class User(rx.Model, table=True):
"""A table for users in the database."""
username: str
password: str
class Question(rx.Model, table=True):
"""A table for questions and answers in the database."""
username: str
prompt: str
answer: str
timestamp: datetime.datetime = datetime.datetime.now()
class State(rx.State):
"""The app state."""
show_columns = ["Question", "Answer"]
username: str = ""
password: str = ""
logged_in: bool = False
prompt: str = ""
result: str = ""
status: str = ""
metastatus: str = ""
def __init__(self):
self.__init__(None)
def __init__(self, hn_conversation: Conversation):
self.hn_conversation = hn_conversation
@rx.var
def questions(self) -> list[Question]:
"""Get the users saved questions and answers from the database."""
with rx.session() as session:
if self.logged_in:
qa = (
session.query(Question)
.where(Question.username == self.username)
.distinct(Question.prompt)
.order_by(Question.timestamp.desc())
.limit(MAX_QUESTIONS)
.all()
)
return [[q.prompt, q.answer] for q in qa]
else:
return []
def get_result(self):
if (
rx.session()
.query(Question)
.where(Question.username == self.username)
.where(Question.prompt == self.prompt)
.first()
or rx.session()
.query(Question)
.where(Question.username == self.username)
.where(
Question.timestamp
> datetime.datetime.now() - datetime.timedelta(days=1)
)
.count()
> MAX_QUESTIONS
):
return rx.window_alert(
"You have already asked this question or have asked too many questions in the past 24 hours."
)
try:
response = openai.Completion.create(
model="gpt-4-0613",
prompt=self.prompt,
temperature=0,
max_tokens=100,
# top_p=1,
)
self.result = response["choices"][0]["text"].replace("\n", "")
except:
return rx.window_alert("Error occured with OpenAI execution.")
def ask_hn(self):
print(f"PROMPT ****** {self.prompt}")
self.hn_conversation.add_message("user", self.prompt)
self.status = "Processing Query"
chat_response = chat_completion_with_function_execution(
self.hn_conversation.conversation_history, functions=hnapi_functions
)
try:
self.result = chat_response
print(f" RESULY ** {self.result}")
# hn_conversation.add_message("assistant", self.result)
except Exception as e:
print(e)
return rx.window_alert("Error occured with OpenAI execution.")
def save_result(self):
with rx.session() as session:
answer = Question(
username=self.username, prompt=self.prompt, answer=self.result
)
session.add(answer)
session.commit()
def set_username(self, username):
self.username = username.strip()
def set_password(self, password):
self.password = password.strip()
| [] |
2024-01-10 | manavarora506/flask_server | summarize_essay.py | from flask import Flask, request, jsonify
from langchain.llms import OpenAI
from flask_cors import CORS # Import the CORS library
import os
from langchain.prompts import PromptTemplate
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import RecursiveCharacterTextSplitter
app = Flask(__name__)
CORS(app)
openai_api_key = os.environ.get('OPENAI_KEY')
# Ensure that the OPENAI_KEY is set
if not openai_api_key:
raise ValueError("The OPENAI_KEY environment variable is not set.")
# Initialize the OpenAI LLM with the API key from the environment variable
llm = OpenAI(temperature=0, openai_api_key=openai_api_key)
@app.route('/summarize_essay', methods=['POST'])
def summarize():
try:
data = request.json
text = data['text']
# LangChain summarization logic
num_tokens = llm.get_num_tokens(text)
text_splitter = RecursiveCharacterTextSplitter(separators=["\n\n", "\n"], chunk_size=1500, chunk_overlap=50)
docs = text_splitter.create_documents([text])
prompt_template = """Write a comprehensive summary of this blog post
{text}
SUMMARY:"""
PROMPT = PromptTemplate(template=prompt_template, input_variables=["text"])
chain = load_summarize_chain(llm=llm, chain_type="map_reduce", map_prompt=PROMPT, combine_prompt=PROMPT, verbose=True)
output = chain.run(docs)
return jsonify({'summary': output})
except Exception as e:
return jsonify({'error': str(e)}), 500
if __name__ == '__main__':
app.run(debug=True) | [
"Write a comprehensive summary of this blog post\n \n {text} \n \n SUMMARY:"
] |
2024-01-10 | lokesharchives/knowledgebase-supplychain-usecase | query_graph.py | import os
from langchain.chat_models import ChatVertexAI
from langchain.chains import GraphCypherQAChain
from langchain.chat_models import ChatVertexAI
from langchain.chains import GraphCypherQAChain
from langchain.graphs import Neo4jGraph
os.environ['OPENAI_API_KEY'] = "replace with your open api key"
graph = Neo4jGraph(
url="bolt://localhost:7687",
username="your_username",
password="your_password"
)
chain = GraphCypherQAChain.from_llm(
ChatVertexAI(temperature=0),
graph=graph,
verbose=True
)
print(chain.run("Which products are supplied by XYZ Tech (SupplierID: 102)?"))
| [] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~tools~serp.py | from typing import Optional
from langchain.tools import BaseTool
from langchain.callbacks.manager import CallbackManagerForToolRun
from langchain.utilities import SerpAPIWrapper
class CustomSearchTool(BaseTool):
name = "Custom search"
description = "Useful for when you need to answer questions about current or newest events, date, ..."
_search = SerpAPIWrapper(params={
"engine": "google",
"gl": "us",
"hl": "vi",
})
def _run(
self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
) -> str:
"""Use the tool."""
return self._search.run(query)
| [
"Useful for when you need to answer questions about current or newest events, date, ..."
] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~models~model_types.py | from enum import Enum
from langchain.chat_models import ChatVertexAI, ChatOpenAI
from langchain.llms import LlamaCpp
class ModelTypes(str, Enum):
OPENAI = "OPENAI"
VERTEX = "VERTEX"
LLAMA_CPP = "LLAMA-CPP"
MODEL_TO_CLASS = {
"OPENAI": ChatOpenAI,
"VERTEX": ChatVertexAI,
"LLAMA-CPP": LlamaCpp
}
| [] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~memory~base_memory.py | from typing import Optional
from langchain.memory import ConversationBufferWindowMemory, ChatMessageHistory
from common.config import BaseObject, Config
from common.objects import MessageTurn
class BaseChatbotMemory(BaseObject):
__slots__ = ["_base_memory", "_memory"]
def __init__(
self,
config: Config = None,
chat_history_class=ChatMessageHistory,
memory_class=ConversationBufferWindowMemory,
chat_history_kwargs: Optional[dict] = None,
**kwargs
):
"""
Base chatbot_backend memory
:param config: Config object
:param chat_history_class: LangChain's chat history class
:param memory_class: LangChain's memory class
:param kwargs: Memory class kwargs
"""
super().__init__()
self.config = config if config is not None else Config()
self._params = kwargs
self.chat_history_kwargs = chat_history_kwargs or {}
self._base_memory_class = chat_history_class
self._memory = memory_class(**self.params)
self._user_memory = dict()
@property
def params(self):
if self._params:
return self._params
else:
return {
"ai_prefix": self.config.ai_prefix,
"human_prefix": self.config.human_prefix,
"memory_key": self.config.memory_key,
"k": self.config.memory_window_size
}
@property
def memory(self):
return self._memory
@property
def user_memory(self):
return self._user_memory
def clear(self, conversation_id: str):
if conversation_id in self.user_memory:
memory = self.user_memory.pop(conversation_id)
memory.clear()
def load_history(self, conversation_id: str) -> str:
if conversation_id not in self._user_memory:
memory = self._base_memory_class(**self.chat_history_kwargs)
self.memory.chat_memory = memory
self.user_memory[conversation_id] = memory
return ""
self.memory.chat_memory = self.user_memory.get(conversation_id)
return self._memory.load_memory_variables({})["history"]
def add_message(self, message_turn: MessageTurn):
pass
| [] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~examples~run_llama_cpp.py | import os
from langchain.prompts import PromptTemplate
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from chatbot_backend.gradio_ui import BaseGradioUI
from chatbot_backend.memory import MemoryTypes
from chatbot_backend.models import ModelTypes
from chatbot_backend.common.config import Config
from chatbot_backend.bot import Bot
from chatbot_backend.prompt import LLAMA_PROMPT, BOT_PERSONALITY
if __name__ == "__main__":
GGML_MODEL_PATH = os.environ["GGML_MODEL_PATH"]
config = Config()
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
partial_variables = {"personality": BOT_PERSONALITY}
prompt_template = PromptTemplate(
template=LLAMA_PROMPT,
input_variables=["history", "input"],
partial_variables=partial_variables
)
bot = Bot(
config,
prompt_template,
model=ModelTypes.LLAMA_CPP,
memory=MemoryTypes.CUSTOM_MEMORY,
model_kwargs={
"model_path": GGML_MODEL_PATH,
"n_ctx": 512,
"temperature": 0.75,
"max_tokens": 512,
"top_p": 0.95,
"callback_manager": callback_manager,
"verbose": True
}
)
demo = BaseGradioUI(bot=bot)
demo.start_demo()
| [
"input"
] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~memory~mongo_memory.py | import logging
from langchain.memory import MongoDBChatMessageHistory
from common.config import Config
from memory.base_memory import BaseChatbotMemory
logger = logging.getLogger(__name__)
class MongoChatbotMemory(BaseChatbotMemory):
def __init__(self, config: Config = None, **kwargs):
config = config if config is not None else Config()
super(MongoChatbotMemory, self).__init__(
config=config,
chat_history_class=MongoDBChatMessageHistory,
chat_history_kwargs={
"connection_string": config.memory_connection_string,
"session_id": config.session_id,
"database_name": config.memory_database_name,
"collection_name": config.memory_collection_name
}
)
| [] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~utils~anonymizer.py | import langdetect
from langchain_experimental.data_anonymizer import PresidioReversibleAnonymizer, PresidioAnonymizer
from langchain.schema import runnable
from common.config import BaseObject, Config
from common.constants import ANONYMIZED_FIELDS, NLP_CONFIG
class BotAnonymizer(BaseObject):
def __init__(self, config: Config = None):
super(BotAnonymizer, self).__init__()
self.config = config if config is not None else Config()
self._anonymizer = PresidioReversibleAnonymizer(languages_config=NLP_CONFIG)
@property
def anonymizer(self):
return self._anonymizer
@property
def supported_lang(self):
return ["vi", "en"]
def _detect_lang(self, input_dict: dict) -> dict:
language = langdetect.detect(input_dict["input"])
if language not in self.supported_lang:
self.logger.warning(
f"Detected language is not supported in this Chatbot, it only support {self.supported_lang}, but detected {language}")
language = None
return {"language": language, **input_dict}
def anonymize_func(self, input_dict: dict):
if input_dict["language"] is None:
return {
"input": input_dict["input"],
"history": input_dict["history"]
}
return {
"input": self.anonymizer.anonymize(input_dict["input"], input_dict["language"]),
"history": self.anonymizer.anonymize(input_dict["history"], input_dict["language"])
}
def get_runnable_anonymizer(self):
return runnable.RunnableLambda(self._detect_lang) | runnable.RunnableLambda(self.anonymize_func)
| [] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~utils~chain_cache.py | from enum import Enum
from typing import Optional
from langchain.cache import InMemoryCache
from langchain.cache import GPTCache
from langchain.globals import set_llm_cache
import hashlib
from gptcache import Cache
from gptcache.adapter.api import init_similar_cache
from common.config import BaseObject
CACHE_TYPE = {
"in_memory": InMemoryCache,
"GPTCache": GPTCache
}
class CacheTypes(str, Enum):
in_memory = "in_memory"
GPTCache = "GPTCache"
def get_hashed_name(name):
return hashlib.sha256(name.encode()).hexdigest()
def init_gptcache(cache_obj: Cache, llm: str):
hashed_llm = get_hashed_name(llm)
init_similar_cache(cache_obj=cache_obj, data_dir=f"similar_cache_{hashed_llm}")
class ChatbotCache(BaseObject):
@classmethod
def create(cls, cache_type: Optional[CacheTypes] = None):
param = {}
if cache_type is None:
cache_type = CacheTypes.in_memory
cache = CACHE_TYPE[cache_type]
if cache_type == "GPTCache":
param = {"init_func": init_gptcache}
set_llm_cache(cache(**param))
return cache
| [] |
2024-01-10 | spartan-minhbui/langchain-chatbot | chatbot_backend~old_app.py | # import json
# from typing import AsyncIterator
# from fastapi import FastAPI
# from fastapi.encoders import jsonable_encoder
# from fastapi.middleware.cors import CORSMiddleware
# from fastapi.responses import StreamingResponse
# from langchain.callbacks.tracers.log_stream import RunLogPatch
# from bot import Bot
# from import MemoryTypes, ModelTypes
# from .common.objects import ChatRequest
# bot = Bot(memory=MemoryTypes.CUSTOM_MEMORY, model=ModelTypes.VERTEX)
# app = FastAPI()
# app.add_middleware(
# CORSMiddleware,
# allow_origins=["*"],
# allow_credentials=True,
# allow_methods=["*"],
# allow_headers=["*"],
# expose_headers=["*"],
# )
# async def transform_stream_for_client(
# stream: AsyncIterator[RunLogPatch],
# ) -> AsyncIterator[str]:
# async for chunk in stream:
# yield f"event: data\ndata: {json.dumps(jsonable_encoder(chunk))}\n\n"
# yield "event: end\n\n"
# @app.post("/chat/stream_log")
# async def chat_endpoint(request: ChatRequest):
# chat_history = request.history
# if chat_history:
# bot.chain.add_message_to_memory(
# human_message=chat_history[-1]["human"],
# ai_message=chat_history[-1]["ai"],
# conversation_id=request.conversation_id
# )
# chain_stream = bot.chain.chain_stream(
# input=request.input,
# conversation_id=request.conversation_id
# )
# return StreamingResponse(
# transform_stream_for_client(chain_stream),
# headers={"Content-Type": "text/event-stream"},
# )
# if __name__ == "__main__":
# import uvicorn
# uvicorn.run(app, host="0.0.0.0", port=8080)
# MOVE to app.py | [] |
2024-01-10 | armandstrickernlp/Emo-TOD | refine.py | import json
import os
import random
import argparse
import pprint as pp
from tqdm import tqdm
import re
from fuzzywuzzy import fuzz
import torch
from datasets import Dataset
from langchain.prompts import PromptTemplate, FewShotPromptTemplate
from transformers import (AutoTokenizer,
AutoModelForCausalLM,
pipeline,
set_seed)
from transformers.pipelines.pt_utils import KeyDataset
"""Snippets are generated when the emotion prediction is not neutral."""
def make_refine_prompt():
# context without previous emotions
# add predicted emotion to context
# refine response if emotion is not neutral
# with CoT
examples = [
{ # MUL0031.json
"context":
"""<|user|> While in Cambridge I need a restaurant that is moderately priced and serves Spanish food.
<|system|> La Tasca would be a good choice for you. Would you like the address or phone number?
<|user|> Yes I would like the address and phone number, thanks for your help!
<|system|> The address for La Tasca is 14 -16 Bridge Street and the phone number is 01223464630. Would you like for me to book you a table?
<|user|> I just want to confirm. This place has free wifi as well as being 3 star, correct?
<|system|> Were you also trying to book a hotel today? There are 5 hotels in cambridge that are 3 stars and offer free wifi
<|user|> Actually, I'd like to confirm that La Tasca is a 3-star restaurant.
<|system|> Thank you. Have a good day!
<|user|> Wait please you haven't answered my question.""",
"emotion":
"""dissatisfied, disliking""",
"original":
"""<|system|> [name] is the restaurant and is not assigned a star rating.""",
# "thought":
# """The response does not take into account the user's dissatisfaction. \
# Prepending a short segment showing remorse for not answering the user's question would be appropriate.""",
"thought":
"""Being remorseful would be appropriate.""",
"prep":
"""Oh I'm sorry!"""
# "refined":
# """The response does not take into account the user's dissatisfaction and needs to be refined. Addding a short segment showing remorse for not answering the user's question would be appropriate.
# <|refined|> I'm sorry for the confusion. <|endofrefined|> <|response|> [name] is the restaurant and is not assigned a star rating. <|endofresponse|>"""
},
{ # MUL0002.json
"context":
"""<|user|> Looking for a place to eat in the city center.
<|system|> There are many options to choose from. Do you have a type of food in mind?
<|user|> I'd like to have some Chinese food.
<|system|> That narrows down the restaurant choices to 10. Is there a price range you would like to stay in?
<|user|> I am looking for a moderately priced place to eat, I am also looking to book a room in the bridge guest house hotel.
<|system|> Which dates will you be staying at the Bridge Guest Room house?
<|user|> Before I commit I have a few questions. What area is the hotel located in?
<|system|> The hotel is in the south area.
<|user|> Does it provide free parking?
<|system|> Yes, free parking and free wifi!
<|user|> OK, 2 questions. 1 - What are the moderately priced restaurants in the center of town; and 2 - how many stars does the Bridge Guest House have? Thanks!
<|system|> The Bridge Guest House is a 3 star lodging.
<|user|> That was all the questions I had. Thank you very much for helping me.""",
"emotion":
"""satisfied, liking""",
"original":
"""<|system|> I'm happy I could help you today. Have a wonderful day!""",
# "thought":
# """The response takes into account the user's satisfaction by showing happiness about being able to help the user. No segment needs to be prepended.""",
"thought":
"""The response appropriately addresses the user's emotions.""",
"prep":
""" """
# "refined":
# """The response takes into account the user's satisfaction by showing happiness about being able to help the user and does not need to be refined.
# <|refined|> <|endofrefined|> <|response|> I'm happy I could help you today. Have a wonderful day! <|endofresponse|>"""
},
{ # MUL0015
"context":
"""
<|user|> I need a hotel with free wifi and free parking, thank you.
<|system|> Allenbell is cheap and has free internet.
<|user|> I'm looking for something in the moderate price range actually.
<|system|> Archway House is a moderately priced 4 star hotel in the North. Would you like to make a reservation?
<|user|> Yes please book the Archway House.
<|system|> I'd be happy to book for you. How many people will be staying, what is your arrival day, and how many nights are you staying?
<|user|> I will be arriving on tuesday and I need to book the room for four nights for three people.
<|system|> Ok. I've booked that guesthouse for you. Your reference number is YBT4JRTR . Can I help with anything else?
<|user|> Yes, I would also l like to find a splendid, moderately-priced place to dine in the centre. That would be just wonderful if you could help me out with that!
<|system|> There are several moderately priced restaurant in the centre area. Would you like a certain type of food?
<|user|> I'd like an Italian restaurant, please.""",
"emotion":
"""excited, happy""",
"original":
"""<|system|> [name] would be perfect for you. Would you like more information or for me to book that for you?""",
# "thought":
# """The response does not fully take into account the user's excitement and happiness. \
# Prepending a short segment that reinforces the user's enthusiasm would be appropriate.""",
"thought":
"""Reinforcing the user's enthusiasm would be appropriate.""",
"prep":
"""I'd be happy to help you with that!"""
# "refined":
# """The response does not take into account the user's excitement and needs to be refined. Adding a short segment showing enthusiasm about being able to help the user would be appropriate.
# <|refined|> I'd be happy to help you with that! <|endofrefined|> <|response|> [name] would be perfect for you. Would you like more information or for me to book that for you? <|endofresponse|>"""
},
{ # MUL0043
"context":
"""<|user|> I need to find a hotel in the center with free wifi included in their rates.
<|system|> I've found 5 hotels. How about El Shaddai?
<|user|> Sorry, I should mention that I'm looking for a hotel with a 0 star rating. Would the El Shaddai still be appropriate?
<|system|> Yes it is. Would you like more information or help booking a stay?
<|user|> Yes. Please book a stay for 7 people. We need to stay 3 nights, starting on Thursday.
<|system|> I was unable to complete your booking. Would you like to try and book for another day or for a shorter stay?
<|user|> Can I try to book for 1 night then?""",
"emotion":
"""fearful, sad""",
"original":
"""<|system|> I was able to book that for [bookstay] night. Your reference number is [ref] . Can I assist you with anything else?""",
# "thought":
# """The response does not take into account the fact that the user is fearful that there will not be any room and needs to be refined. \
# The response indicates the booking is possible, so adding a short segment to reassure the user would be appropriate.""",
"thought":
"""Reassuring the user would be appropriate.""",
"prep":
"""Yes that that would be fine!"""
# "refined":
# """The response does not take into account the fact that the user is fearful that there will not be any room and needs to be refined. Adding a short segment to reassure the user would be appropriate.
# <|refined|> Yes that is fine! <|endofrefined|> <|response|> I was able to book that for [bookstay] night. Your reference number is [ref] . Can I assist you with anything else? <|endofresponse|>"""
},
{ # MUL0042
"context":
"""<|user|> I need to find a hotel in the center with free wifi included in their rates.
<|system|> I've found 5 hotels. How about El Shaddai?
<|user|> Sorry, I should mention that I'm looking for a hotel with a 0 star rating. Would the El Shaddai still be appropriate?""",
"emotion":
"""apologetic""",
"original":
"""<|system|> Yes it is. Would you like more information or help booking a stay?""",
# "thought":
# """The response does not take into account the user's apologetic emotion. \
# Prepending a short segment to make the user not feel guilty for adding information would be appropriate.""",
"thought":
"""Reassuring the user would be appropriate.""",
"prep":
"""Of course, that's no problem!"""
# "refined":
# """The response does not take into account the user's apologetic emotion and needs to be refined. Adding a short segment to make the user not feel guilty for adding information would be appropriate.
# <|refined|> Of course, that's no problem! <|endofrefined|> <|response|> Yes it is. Would you like more information or help booking a stay? <|endofresponse|>"""
},
{ # PMUL0460
"context":
"""<|user|> I'm looking for a 4 star hotel in the east.
<|system|> My system is not pulling up any 4 star hotels in East. Would you like to try a guesthouse or another area perhaps?
<|user|> Can you check for ones with a cheap price range?
<|system|> There are no cheap four star hotels in the area. Another criteria maybe?
<|user|> In that case, how about just a hotel in the east that has free parking?
<|system|> With those requirements, I do have one hotel in the east. It is expensive 2 star rated with both free parking and wifi. It is the Express by Holiday Inn Cambridge.
<|user|> Oh man, I can't do expensive. Is there a 4 star guesthouse that is cheap in the east perhaps?
<|system|> I am sorry I have no cheap 4 star hotels, maybe a more realistic star rating?
<|user|> Are you saying that there isn't even a cheap 4 star guesthouse on the east side? What kind of city is this?""",
"emotion":
"""abusive""",
"original":
"""<|system|> My mistake. There are [choice] [pricerange] [type]. The [name], [name], and [name] all offer free parking. Would you like to make a booking?""",
# "thought":
# """The user is being abusive. The system says 'My mistake' to compensate for this. \
# However, prepending a short segment to appease the user even more would be appropriate.""",
"thought":
"""Appeasing the user even more would be appropriate.""",
"prep":
"""I'm sorry."""
# "refined":
# """The user is being abusive and is deeply dissatisfied. The response does not take this into account and needs to be refined. Adding a short segment to appease the user would be appropriate.
# <|refined|> I'm sorry for the inconvenience. <|endofrefined|> <|response|> My mistake. There are [choice] [pricerange] [type]. The [name], [name], and [name] all offer free parking. Would you like to make a booking? <|endofresponse|>"""
},
]
example_template = """
Context: {context}
User is feeling: {emotion}
Original Response: {original}
Thought: {thought}
Add before the original response: {prep}
"""
# create a prompt example from above template
example_prompt = PromptTemplate(
input_variables=["context", "emotion", "original", "thought", "prep"],
template=example_template
)
# prefix = """In the following examples, you are presented with a dialogue Context, containing a conversation between a \
# user and an information system which can help with booking restaurants, train tickets, taxis, hotels, and can provide \
# information about attractions, hospital departments or police in Cambridge. \
# The Emotion associated with the user's last turn is given. If the Original Response does not appropriately account \
# for the user's emotion, the system's original response should be Prepended with a short snippet. The snippet can show \
# remorse, reassure, appease or maintain enthusiasm, depending on the user's emotion. \
# Avoid repeating previous snippets and the original response."""
prefix = """In the provided dialogues, you'll find conversation contexts involving a user and an information system that assists with \
various tasks. The user's emotion is indicated. If the original response does not address the user's \
emotion, your task is to write a brief snippet that can be added BEFORE the original response. The snippet should convey remorse, reassurance, \
appeasement, or enthusiasm, depending on the user's emotion. Please refrain from repeating previous snippets or the original response."""
suffix = """
Context: {context}
User is feeling: {emotion}
Original Response: {original}
Thought:"""
# now create the few-shot prompt template
few_shot_prompt_template = FewShotPromptTemplate(
examples=examples,
example_prompt=example_prompt,
prefix=prefix,
suffix=suffix,
input_variables=["context", "emotion", "original"],
example_separator="\n------------"
)
return few_shot_prompt_template
def format_context(context_input):
formatted = ''
context_input = context_input.replace('<|endofcontext|>', '').replace('<|context|>', '').strip()
exchanges = context_input.split('<|user|>')
for exchange in exchanges[1:-1]:
user, system = exchange.split('<|system|>')
formatted += f"<|user|> {user.strip()}\n<|system|> {system.strip()}\n"
formatted += f"<|user|> {exchanges[-1].strip()}"
return formatted
def extract_snippet(text):
# Split the text by the "Add before the original response:"
split_text = text.split("response:")
if len(split_text) == 2:
# The snippet is the part after the ":" and any leading/trailing whitespace
if '\n' in split_text[1]:
snippet = split_text[1].split('\n')[0].strip()
else:
snippet = split_text[1].strip()
return snippet
else:
return ''
def filter_distance(snippet, response, thresh=50):
response = response.replace('<|system|>', '')
sentence_pattern = r"(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?|\!|,)\s"
resp_sents = re.split(sentence_pattern, response)
snippet_sents = re.split(sentence_pattern, snippet)
filter_ = False
for i, snip in enumerate(snippet_sents):
for sent in resp_sents:
if fuzz.ratio(snip, sent) >= thresh:
print(fuzz.ratio(snip, sent))
filter_ = True
break
if filter_:
return ' '.join(snippet_sents[:i])
else:
return snippet
if __name__ == '__main__':
# gen_outputs='./Llama-2-7b-chat-hf/gen_outputs/emo_gen_test/4e-05_42_rank32/gen.json',
# context='./Llama-2-7b-chat-hf/gen_outputs/emo_test/4e-05_42_rank32/gen.json'
# gen_outputs has emotions in the input which the prompt template does not expect.
# context: pass in the output file of the emo model for example to access inputs without emotions or just filter out emotions from the input...
parser = argparse.ArgumentParser()
parser.add_argument('--model_name', type=str, default='meta-llama/Llama-2-7b-chat-hf')
parser.add_argument('--cache_dir', type=str, default='./llama2_cache')
parser.add_argument('--gen_outputs', type=str)
parser.add_argument('--context', type=str)
args = parser.parse_args()
# # load lora, make preds then unload
# tokenizer_spe = AutoTokenizer.from_pretrained(args.checkpoint_path, cache_dir=args.cache_dir)
# tokenizer_norm = AutoTokenizer.from_pretrained(args.model_name, cache_dir=args.cache_dir)
# base_model = AutoModelForCausalLM.from_pretrained(
# args.model_name,
# cache_dir=args.cache_dir,
# device_map="auto",
# )
# base_model.resize_token_embeddings(len(tokenizer_spe))
# peft_model = PeftModel.from_pretrained(base_model,
# args.checkpoint_path,
# device_map="auto",
# is_training=False,
# )
# # make predictions ....
# # unload lora for prompting
# base_model = peft_model.unload()
# base_model.resize_token_embeddings(len(tokenizer_norm))
# load model and tokenizer
set_seed(42)
base_model = AutoModelForCausalLM.from_pretrained(
args.model_name,
cache_dir=args.cache_dir,
device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(args.model_name, cache_dir=args.cache_dir)
base_model.config.use_cache = True
tokenizer.padding_side = "left"
tokenizer.pad_token = tokenizer.eos_token
pipe = pipeline("text-generation",
model=base_model,
tokenizer=tokenizer,
device_map="auto",
max_new_tokens = 150,
do_sample=True,
temperature=0.9,
num_return_sequences=1,
return_full_text=False,
)
# load reference contexts and generated predictions
with open(args.gen_outputs) as f:
gen_outputs_ = json.load(f)
with open(args.context) as f:
context_ = json.load(f)
# set prompt template
prompt = make_refine_prompt()
# generate snippets
for idx, dial_num in enumerate(gen_outputs_):
for turn_gen, turn_context in zip(gen_outputs_[dial_num], context_[dial_num]):
context = format_context(turn_context['input'])
emotion = turn_gen['gen_emo']
if emotion == 'neutral': # ignore neutral emotions
continue
else:
response = '<|system|> '+turn_gen['response']
txt_input = prompt.format(context=context, emotion=emotion, original=response)
generated_snippet = extract_snippet(pipe(txt_input)[0]['generated_text'])
filtered_snippet = filter_distance(generated_snippet, response)
turn_gen['emo_aware_snippet'] = filtered_snippet + ' ' + turn_gen['response']
# save snippets to the gen_outputs passed as argument
with open(args.gen_outputs, 'w') as f:
json.dump(gen_outputs_, f, indent=2)
| [
"\n------------",
"\n Context: {context}\n User is feeling: {emotion}\n Original Response: {original}\n Thought: {thought}\n Add before the original response: {prep} \n ",
"context",
"emotion",
"original"
] |
2024-01-10 | 5l1v3r1/knowledge_gpt | knowledge_gpt~core~parsing.py | from io import BytesIO
from typing import List, Any, Optional
import re
import docx2txt
from langchain.docstore.document import Document
import fitz
from hashlib import md5
from abc import abstractmethod, ABC
from copy import deepcopy
class File(ABC):
"""Represents an uploaded file comprised of Documents"""
def __init__(
self,
name: str,
id: str,
metadata: Optional[dict[str, Any]] = None,
docs: Optional[List[Document]] = None,
):
self.name = name
self.id = id
self.metadata = metadata or {}
self.docs = docs or []
@classmethod
@abstractmethod
def from_bytes(cls, file: BytesIO) -> "File":
"""Creates a File from a BytesIO object"""
def __repr__(self) -> str:
return (
f"File(name={self.name}, id={self.id},"
" metadata={self.metadata}, docs={self.docs})"
)
def __str__(self) -> str:
return f"File(name={self.name}, id={self.id}, metadata={self.metadata})"
def copy(self) -> "File":
"""Create a deep copy of this File"""
return self.__class__(
name=self.name,
id=self.id,
metadata=deepcopy(self.metadata),
docs=deepcopy(self.docs),
)
def strip_consecutive_newlines(text: str) -> str:
"""Strips consecutive newlines from a string
possibly with whitespace in between
"""
return re.sub(r"\s*\n\s*", "\n", text)
class DocxFile(File):
@classmethod
def from_bytes(cls, file: BytesIO) -> "DocxFile":
text = docx2txt.process(file)
text = strip_consecutive_newlines(text)
doc = Document(page_content=text.strip())
doc.metadata["source"] = "p-1"
return cls(name=file.name, id=md5(file.read()).hexdigest(), docs=[doc])
class PdfFile(File):
@classmethod
def from_bytes(cls, file: BytesIO) -> "PdfFile":
pdf = fitz.open(stream=file.read(), filetype="pdf") # type: ignore
docs = []
for i, page in enumerate(pdf):
text = page.get_text(sort=True)
text = strip_consecutive_newlines(text)
doc = Document(page_content=text.strip())
doc.metadata["page"] = i + 1
doc.metadata["source"] = f"p-{i+1}"
docs.append(doc)
# file.read() mutates the file object, which can affect caching
# so we need to reset the file pointer to the beginning
file.seek(0)
return cls(name=file.name, id=md5(file.read()).hexdigest(), docs=docs)
class TxtFile(File):
@classmethod
def from_bytes(cls, file: BytesIO) -> "TxtFile":
text = file.read().decode("utf-8")
text = strip_consecutive_newlines(text)
file.seek(0)
doc = Document(page_content=text.strip())
doc.metadata["source"] = "p-1"
return cls(name=file.name, id=md5(file.read()).hexdigest(), docs=[doc])
def read_file(file: BytesIO) -> File:
"""Reads an uploaded file and returns a File object"""
if file.name.lower().endswith(".docx"):
return DocxFile.from_bytes(file)
elif file.name.lower().endswith(".pdf"):
return PdfFile.from_bytes(file)
elif file.name.lower().endswith(".txt"):
return TxtFile.from_bytes(file)
else:
raise NotImplementedError(f"File type {file.name.split('.')[-1]} not supported")
| [] |
2024-01-10 | 5l1v3r1/knowledge_gpt | knowledge_gpt~ui.py | from typing import List
import streamlit as st
from langchain.docstore.document import Document
from knowledge_gpt.core.parsing import File
import openai
from streamlit.logger import get_logger
from typing import NoReturn
logger = get_logger(__name__)
def wrap_doc_in_html(docs: List[Document]) -> str:
"""Wraps each page in document separated by newlines in <p> tags"""
text = [doc.page_content for doc in docs]
if isinstance(text, list):
# Add horizontal rules between pages
text = "\n<hr/>\n".join(text)
return "".join([f"<p>{line}</p>" for line in text.split("\n")])
def is_query_valid(query: str) -> bool:
if not query:
st.error("Please enter a question!")
return False
return True
def is_file_valid(file: File) -> bool:
if (
len(file.docs) == 0
or "".join([doc.page_content for doc in file.docs]).strip() == ""
):
st.error("Cannot read document! Make sure the document has selectable text")
logger.error("Cannot read document")
return False
return True
def display_file_read_error(e: Exception) -> NoReturn:
st.error("Error reading file. Make sure the file is not corrupted or encrypted")
logger.error(f"{e.__class__.__name__}: {e}")
st.stop()
@st.cache_data(show_spinner=False)
def is_open_ai_key_valid(openai_api_key, model: str) -> bool:
if model == "debug":
return True
if not openai_api_key:
st.error("Please enter your OpenAI API key in the sidebar!")
return False
try:
openai.ChatCompletion.create(
model=model,
messages=[{"role": "user", "content": "test"}],
api_key=openai_api_key,
)
except Exception as e:
st.error(f"{e.__class__.__name__}: {e}")
logger.error(f"{e.__class__.__name__}: {e}")
return False
return True
| [
"test"
] |
2024-01-10 | Coding-Forge/funcblobeventtrigger | scripts~prepdocs.py | import base64
import html
import io
import os
import re
import time
import openai
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.search.documents import SearchClient
from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import (
HnswParameters,
PrioritizedFields,
SearchableField,
SearchField,
SearchFieldDataType,
SearchIndex,
SemanticConfiguration,
SemanticField,
SemanticSettings,
SimpleField,
VectorSearch,
VectorSearchAlgorithmConfiguration,
)
from azure.storage.blob import BlobServiceClient
from pypdf import PdfReader, PdfWriter
from tenacity import retry, stop_after_attempt, wait_random_exponential
MAX_SECTION_LENGTH = 1000
SENTENCE_SEARCH_LIMIT = 100
SECTION_OVERLAP = 100
open_ai_token_cache = {}
CACHE_KEY_TOKEN_CRED = 'openai_token_cred'
CACHE_KEY_CREATED_TIME = 'created_time'
CACHE_KEY_TOKEN_TYPE = 'token_type'
class CogIndexer:
open_ai_token_cache[CACHE_KEY_CREATED_TIME] = time.time()
#open_ai_token_cache[CACHE_KEY_TOKEN_CRED] = azd_credential
open_ai_token_cache[CACHE_KEY_TOKEN_TYPE] = "azure_ad"
def __init__(self, args:dict):
self.args = args
def blob_name_from_file_page(self, filename, page = 0):
if os.path.splitext(filename)[1].lower() == ".pdf":
return os.path.splitext(os.path.basename(filename))[0] + f"-{page}" + ".pdf"
else:
return os.path.basename(filename)
def upload_blobs(self, filename, file_contents):
blob_service = BlobServiceClient(account_url=f"https://{os.getenv('STORAGEACCOUNT')}.blob.core.windows.net", credential=self.args["storage_creds"])
blob_container = blob_service.get_container_client(os.getenv('CONTAINER'))
if not blob_container.exists():
blob_container.create_container()
try:
# if file is PDF split into pages and upload each page as a separate blob
if os.path.splitext(filename)[1].lower() == ".pdf":
reader = PdfReader(file_contents)
pages = reader.pages
for i in range(len(pages)):
blob_name = self.blob_name_from_file_page(filename, i)
#if arg_s.verbose: print(f"\tUploading blob for page {i} -> {blob_name}")
f = io.BytesIO()
writer = PdfWriter()
writer.add_page(pages[i])
writer.write(f)
f.seek(0)
blob_container.upload_blob(blob_name, f, overwrite=True)
else:
blob_name = self.blob_name_from_file_page(filename)
with open(filename,"rb") as data:
blob_container.upload_blob(blob_name, data, overwrite=True)
except Exception as e:
print(f"Error uploading blob for '{filename}': {e}")
def remove_blobs(self, filename):
#if arg_s.verbose: print(f"Removing blobs for '{filename or '<all>'}'")
blob_service = BlobServiceClient(account_url=f"https://{os.getenv('STORAGEACCOUNT')}.blob.core.windows.net", credential=self.args["storage_creds"])
blob_container = blob_service.get_container_client(os.getenv('CONTAINER'))
if blob_container.exists():
if filename is None:
blobs = blob_container.list_blob_names()
else:
prefix = os.path.splitext(os.path.basename(filename))[0]
blobs = filter(lambda b: re.match(f"{prefix}-\d+\.pdf", b), blob_container.list_blob_names(name_starts_with=os.path.splitext(os.path.basename(prefix))[0]))
for b in blobs:
#if arg_s.verbose: print(f"\tRemoving blob {b}")
blob_container.delete_blob(b)
def table_to_html(self, table):
table_html = "<table>"
rows = [sorted([cell for cell in table.cells if cell.row_index == i], key=lambda cell: cell.column_index) for i in range(table.row_count)]
for row_cells in rows:
table_html += "<tr>"
for cell in row_cells:
tag = "th" if (cell.kind == "columnHeader" or cell.kind == "rowHeader") else "td"
cell_spans = ""
if cell.column_span > 1: cell_spans += f" colSpan={cell.column_span}"
if cell.row_span > 1: cell_spans += f" rowSpan={cell.row_span}"
table_html += f"<{tag}{cell_spans}>{html.escape(cell.content)}</{tag}>"
table_html +="</tr>"
table_html += "</table>"
return table_html
def get_document_text(self, filename):
offset = 0
page_map = []
if self.args["localpdfparser"]:
reader = PdfReader(filename)
pages = reader.pages
for page_num, p in enumerate(pages):
page_text = p.extract_text()
page_map.append((page_num, offset, page_text))
offset += len(page_text)
else:
#if arg_s.verbose: print(f"Extracting text from '{filename}' using Azure Form Recognizer")
form_recognizer_client = DocumentAnalysisClient(endpoint=f"https://{os.getenv('FORMRECOGNIZERSERVICE')}.cognitiveservices.azure.com/", credential=self.args['formrecognizer_creds'], headers={"x-ms-useragent": "azure-search-chat-demo/1.0.0"})
#with open(filename, "rb") as f:
f = filename.getvalue()
try:
poller = form_recognizer_client.begin_analyze_document("prebuilt-layout", document = f)
except Exception as e:
print(f"Error analyzing document '{filename}': {e}")
return page_map
form_recognizer_results = poller.result()
for page_num, page in enumerate(form_recognizer_results.pages):
tables_on_page = [table for table in form_recognizer_results.tables if table.bounding_regions[0].page_number == page_num + 1]
# mark all positions of the table spans in the page
page_offset = page.spans[0].offset
page_length = page.spans[0].length
table_chars = [-1]*page_length
for table_id, table in enumerate(tables_on_page):
for span in table.spans:
# replace all table spans with "table_id" in table_chars array
for i in range(span.length):
idx = span.offset - page_offset + i
if idx >=0 and idx < page_length:
table_chars[idx] = table_id
# build page text by replacing characters in table spans with table html
page_text = ""
added_tables = set()
for idx, table_id in enumerate(table_chars):
if table_id == -1:
page_text += form_recognizer_results.content[page_offset + idx]
elif table_id not in added_tables:
page_text += self.table_to_html(tables_on_page[table_id])
added_tables.add(table_id)
page_text += " "
page_map.append((page_num, offset, page_text))
offset += len(page_text)
return page_map
def split_text(self, page_map):
SENTENCE_ENDINGS = [".", "!", "?"]
WORDS_BREAKS = [",", ";", ":", " ", "(", ")", "[", "]", "{", "}", "\t", "\n"]
#if arg_s.verbose: print(f"Splitting '{filename}' into sections")
def find_page(offset):
num_pages = len(page_map)
for i in range(num_pages - 1):
if offset >= page_map[i][1] and offset < page_map[i + 1][1]:
return i
return num_pages - 1
all_text = "".join(p[2] for p in page_map)
length = len(all_text)
start = 0
end = length
while start + SECTION_OVERLAP < length:
last_word = -1
end = start + MAX_SECTION_LENGTH
if end > length:
end = length
else:
# Try to find the end of the sentence
while end < length and (end - start - MAX_SECTION_LENGTH) < SENTENCE_SEARCH_LIMIT and all_text[end] not in SENTENCE_ENDINGS:
if all_text[end] in WORDS_BREAKS:
last_word = end
end += 1
if end < length and all_text[end] not in SENTENCE_ENDINGS and last_word > 0:
end = last_word # Fall back to at least keeping a whole word
if end < length:
end += 1
# Try to find the start of the sentence or at least a whole word boundary
last_word = -1
while start > 0 and start > end - MAX_SECTION_LENGTH - 2 * SENTENCE_SEARCH_LIMIT and all_text[start] not in SENTENCE_ENDINGS:
if all_text[start] in WORDS_BREAKS:
last_word = start
start -= 1
if all_text[start] not in SENTENCE_ENDINGS and last_word > 0:
start = last_word
if start > 0:
start += 1
section_text = all_text[start:end]
yield (section_text, find_page(start))
last_table_start = section_text.rfind("<table")
if (last_table_start > 2 * SENTENCE_SEARCH_LIMIT and last_table_start > section_text.rfind("</table")):
# If the section ends with an unclosed table, we need to start the next section with the table.
# If table starts inside SENTENCE_SEARCH_LIMIT, we ignore it, as that will cause an infinite loop for tables longer than MAX_SECTION_LENGTH
# If last table starts inside SECTION_OVERLAP, keep overlapping
#if arg_s.verbose: print(f"Section ends with unclosed table, starting next section with the table at page {find_page(start)} offset {start} table start {last_table_start}")
start = min(end - SECTION_OVERLAP, start + last_table_start)
else:
start = end - SECTION_OVERLAP
if start + SECTION_OVERLAP < end:
yield (all_text[start:end], find_page(start))
def filename_to_id(self, filename):
filename_ascii = re.sub("[^0-9a-zA-Z_-]", "_", filename)
filename_hash = base64.b16encode(filename.encode('utf-8')).decode('ascii')
return f"file-{filename_ascii}-{filename_hash}"
def create_sections(self, filename, page_map, use_vectors):
file_id = self.filename_to_id(filename)
for i, (content, pagenum) in enumerate(self.split_text(page_map)):
section = {
"id": f"{file_id}-page-{i}",
"content": content,
"category": self.args["category"],
"sourcepage": self.blob_name_from_file_page(filename, pagenum),
"sourcefile": filename
}
if use_vectors:
section["embedding"] = self.compute_embedding(content)
yield section
def before_retry_sleep(self, retry_state):
print("Rate limited on the OpenAI embeddings API, sleeping before retrying...")
@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(15), before_sleep=before_retry_sleep)
def compute_embedding(self, text):
#self.refresh_openai_token()
return openai.Embedding.create(engine=os.getenv('OPENAIDEPLOYMENT'), input=text)["data"][0]["embedding"]
def create_search_index(self):
#if arg_s.verbose: print(f"Ensuring search index {self.args["index} exists")
index_client = SearchIndexClient(endpoint=f"https://{os.getenv('SEARCHSERVICE')}.search.windows.net/",
credential=self.args["search_creds"])
if self.args["index"] not in index_client.list_index_names():
index = SearchIndex(
name=self.args["index"],
fields=[
SimpleField(name="id", type="Edm.String", key=True),
SearchableField(name="content", type="Edm.String", analyzer_name="en.microsoft"),
SearchField(name="embedding", type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
hidden=False, searchable=True, filterable=False, sortable=False, facetable=False,
vector_search_dimensions=1536, vector_search_configuration="default"),
SimpleField(name="category", type="Edm.String", filterable=True, facetable=True),
SimpleField(name="sourcepage", type="Edm.String", filterable=True, facetable=True),
SimpleField(name="sourcefile", type="Edm.String", filterable=True, facetable=True)
],
semantic_settings=SemanticSettings(
configurations=[SemanticConfiguration(
name='default',
prioritized_fields=PrioritizedFields(
title_field=None, prioritized_content_fields=[SemanticField(field_name='content')]))]),
vector_search=VectorSearch(
algorithm_configurations=[
VectorSearchAlgorithmConfiguration(
name="default",
kind="hnsw",
hnsw_parameters=HnswParameters(metric="cosine")
)
]
)
)
#if arg_s.verbose: print(f"Creating {self.args["index} search index")
index_client.create_index(index)
else:
print(f"Search index {self.args['index']} already exists")
def index_sections(self, filename, sections):
#if arg_s.verbose: print(f"Indexing sections from '{filename}' into search index '{self.args["index}'")
search_client = SearchClient(endpoint=f"https://{os.getenv('SEARCHSERVICE')}.search.windows.net/",
index_name=self.args["index"],
credential=self.args["search_creds"])
i = 0
batch = []
if len(batch) == 0:
print('nothing in batch' )
for s in sections:
batch.append(s)
i += 1
if i % 1000 == 0:
results = search_client.upload_documents(documents=batch)
succeeded = sum([1 for r in results if r.succeeded])
print(f"\tIndexed {len(results)} sections, {succeeded} succeeded")
batch = []
if len(batch) > 0:
results = search_client.upload_documents(documents=batch)
succeeded = sum([1 for r in results if r.succeeded])
print(f"\tIndexed {len(results)} sections, {succeeded} succeeded")
def remove_from_index(self, filename):
print(f"Removing sections from '{filename or '<all>'}' from search index '{self.args['index']}'")
search_client = SearchClient(endpoint=f"https://{os.getenv('SEARCHSERVICE')}.search.windows.net/",
index_name=self.args["index"],
credential=self.args["search_creds"])
while True:
filter = None if filename is None else f"sourcefile eq '{os.path.basename(filename)}'"
r = search_client.search("", filter=filter, top=1000, include_total_count=True)
if r.get_count() == 0:
break
r = search_client.delete_documents(documents=[{ "id": d["id"] } for d in r])
#if arg_s.verbose: print(f"\tRemoved {len(r)} sections from index")
# It can take a few seconds for search results to reflect changes, so wait a bit
time.sleep(2)
# refresh open ai token every 5 minutes
def refresh_openai_token():
if open_ai_token_cache[CACHE_KEY_TOKEN_TYPE] == 'azure_ad' and open_ai_token_cache[CACHE_KEY_CREATED_TIME] + 300 < time.time():
token_cred = open_ai_token_cache[CACHE_KEY_TOKEN_CRED]
openai.api_key = token_cred.get_token("https://cognitiveservices.azure.com/.default").token
open_ai_token_cache[CACHE_KEY_CREATED_TIME] = time.time()
else:
print('dont need one') | [] |
2024-01-10 | Coding-Forge/funcblobeventtrigger | readblob.py | from azure.storage.blob import BlobServiceClient
from dotenv import load_dotenv, dotenv_values
from azure.core.credentials import AzureKeyCredential
from azure.identity import AzureDeveloperCliCredential
from scripts.prepdocs import CogIndexer
import os
import openai
import time
import glob
import io
open_ai_token_cache = {}
CACHE_KEY_TOKEN_CRED = 'openai_token_cred'
CACHE_KEY_CREATED_TIME = 'created_time'
CACHE_KEY_TOKEN_TYPE = 'token_type'
load_dotenv()
def process_file(filename, file_content=None, io_data=None):
args={
"skipblobs" :False,
"category" :"public_records",
"index" :"publications",
"novectors" :False,
"localpdfparser" :False,
"remove" :False,
"removeall" :False,
"search_creds" : AzureKeyCredential(os.getenv('SEARCHKEY')),
"storage_creds" : os.getenv('STORAGEKEY'),
"formrecognizer_creds":AzureKeyCredential(os.getenv('FORMRECOGNIZERKEY'))
}
CI = CogIndexer(args=args)
# Use the current user identity to connect to Azure services unless a key is explicitly set for any of them
azd_credential = AzureDeveloperCliCredential() if os.getenv('TENANTID') is None else AzureDeveloperCliCredential(tenant_id=os.getenv('TENANTID'), process_timeout=60)
default_creds = azd_credential if os.getenv('SEARCHKEY') is None or os.getenv('STORAGEKEY') is None else None
use_vectors = not args["novectors"]
if not args["skipblobs"]:
storage_creds = args["storage_creds"]
if not args["localpdfparser"]:
# check if Azure Form Recognizer credentials are provided
if os.getenv('FORMRECOGNIZERSERVICE') is None:
print("Error: Azure Form Recognizer service is not provided. Please provide formrecognizerservice or use --localpdfparser for local pypdf parser.")
exit(1)
formrecognizer_creds = args["formrecognizer_creds"]
if use_vectors:
if os.getenv('OPENAIKEY') is None:
openai.api_key = azd_credential.get_token("https://cognitiveservices.azure.com/.default").token
openai.api_type = "azure_ad"
open_ai_token_cache[CACHE_KEY_CREATED_TIME] = time.time()
open_ai_token_cache[CACHE_KEY_TOKEN_CRED] = azd_credential
open_ai_token_cache[CACHE_KEY_TOKEN_TYPE] = "azure_ad"
else:
openai.api_type = "azure"
openai.api_key = os.getenv('OPENAIKEY')
openai.api_base = f"https://{os.getenv('OPENAISERVICE')}.openai.azure.com"
openai.api_version = "2022-12-01"
if args["removeall"]:
CI.remove_blobs(None)
CI.remove_from_index(None)
else:
if not args["remove"]:
CI.create_search_index()
print("Processing files...")
if args["remove"]:
CI.remove_blobs(filename)
CI.remove_from_index(filename)
elif args["removeall"]:
CI.remove_blobs(None)
CI.remove_from_index(None)
else:
if not args["skipblobs"]:
CI.upload_blobs(filename, file_contents=io_data)
page_map = CI.get_document_text(filename=io_data)
sections = CI.create_sections(os.path.basename(filename), page_map, use_vectors)
CI.index_sections(os.path.basename(filename), sections)
def iterate_blob():
# Blob storage connection string
KEY = os.getenv("BLOB_ACCOUNT_KEY")
# Create a BlobServiceClient object
account_url=f"https://{os.getenv('blob_trigger_account')}.blob.core.windows.net"
print(account_url)
blob_service_client = BlobServiceClient(account_url=account_url, credential=KEY)
# List out the files in the container
container_name = "openaiindexer"
container_client = blob_service_client.get_container_client(container_name)
blob_list = container_client.list_blobs()
for blob in blob_list:
print(blob.name)
# Read a file from the container
file_name = blob.name
blob_client = container_client.get_blob_client(file_name)
file_content = blob_client.download_blob().readall()
data = io.BytesIO(file_content)
process_file(file_name, file_content=file_content, io_data=data)
blob_client.delete_blob()
| [] |
2024-01-10 | platzi/curso-openai-api | Clase%2021%20Integraci%C3%B3n%20del%20modelo%20de%20OpenAI%20a%20Telegram~platzi_bot.py | import requests
import time
from openai import OpenAI
openai = OpenAI(api_key='INSERTA TU API KEY')
TOKEN = "INSERTA TU TOKEN DE BOTHFATHER"
def get_updates(offset):
url = f"https://api.telegram.org/bot{TOKEN}/getUpdates"
params = {"timeout": 100, "offset": offset}
response = requests.get(url, params=params)
return response.json()["result"]
def send_messages(chat_id, text):
url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
params = {"chat_id": chat_id, "text": text}
response = requests.post(url, params=params)
return response
def get_openai_response(prompt):
system = '''
Eres un asistente de atención a clientes
y estudiantes de la plataforma de educación online en tecnología,
inglés y liderazgo llamada Platzi
'''
response = openai.chat.completions.create(
model='INGRESA EL NOMBRE DE TU MODELO CON FINE-TUNING',
messages=[
{"role": "system", "content" :f'{system}'},
{"role": "user", "content" : f'{prompt}'}],
max_tokens=150,
n=1,
temperature=0.2)
return response.choices[0].message.content.strip()
def main():
print("Starting bot...")
offset = 0
while True:
updates = get_updates(offset)
if updates:
for update in updates:
offset = update["update_id"] +1
chat_id = update["message"]["chat"]['id']
user_message = update["message"]["text"]
print(f"Received message: {user_message}")
GPT = get_openai_response(user_message)
send_messages(chat_id, GPT)
else:
time.sleep(1)
if __name__ == '__main__':
main()
| [] |
2024-01-10 | youngwoon/transition | rl~dataset.py | # code from openai baselines
# https://github.com/openai/baselines/blob/master/baselines/common/dataset.py
import numpy as np
class Dataset(object):
def __init__(self, data_map, deterministic=False, shuffle=True):
self.data_map = data_map
self.deterministic = deterministic
self.enable_shuffle = shuffle
self.n = next(iter(data_map.values())).shape[0]
self._next_id = 0
self.shuffle()
def shuffle(self):
if self.deterministic:
return
perm = np.arange(self.n)
np.random.shuffle(perm)
for key in self.data_map:
self.data_map[key] = self.data_map[key][perm]
self._next_id = 0
def next_batch(self, batch_size):
if self._next_id >= self.n and self.enable_shuffle:
self.shuffle()
cur_id = self._next_id
cur_batch_size = min(batch_size, self.n - self._next_id)
self._next_id += cur_batch_size
data_map = dict()
for key in self.data_map:
data_map[key] = self.data_map[key][cur_id:cur_id+cur_batch_size]
return data_map
def iterate_once(self, batch_size):
if self.enable_shuffle: self.shuffle()
while self._next_id <= self.n - batch_size:
yield self.next_batch(batch_size)
self._next_id = 0
def iterate_times(self, batch_size, times):
if self.enable_shuffle: self.shuffle()
for x in range(times):
yield self.next_batch(batch_size)
self._next_id = 0
def subset(self, num_elements, deterministic=True):
data_map = dict()
for key in self.data_map:
data_map[key] = self.data_map[key][:num_elements]
return Dataset(data_map, deterministic)
def iterbatches(arrays, *, num_batches=None, batch_size=None, shuffle=True, include_final_partial_batch=True):
assert (num_batches is None) != (batch_size is None), 'Provide num_batches or batch_size, but not both'
arrays = tuple(map(np.asarray, arrays))
n = arrays[0].shape[0]
assert all(a.shape[0] == n for a in arrays[1:])
inds = np.arange(n)
if shuffle: np.random.shuffle(inds)
sections = np.arange(0, n, batch_size)[1:] if num_batches is None else num_batches
for batch_inds in np.array_split(inds, sections):
if include_final_partial_batch or len(batch_inds) == batch_size:
yield tuple(a[batch_inds] for a in arrays)
| [] |
2024-01-10 | alihussainia/AI-Makerspace | FineTune-GPT3-VirtualAssistant~pre_process.py | """Preprocess and convert CSV data to JSON format for use in fine-tuning a GPT model.
This script contains a class that can be used to convert CSV files to JSON files, by reading data from a CSV file,
converting each row to a dictionary, and writing the dictionaries to a JSON file as separate lines. The resulting
JSON file can then be used to fine-tune a GPT model.
"""
import configargparse
import os
import csv
import json
import subprocess
#import openai
class CSVConverter:
def __init__(self, csv_file, prompt_column, completion_column):
self.csv_file = csv_file
self.prompt_column = prompt_column
self.completion_column = completion_column
def read_csv(self):
"""Read data from a CSV file and return a list of dictionaries.
Each dictionary represents a row in the CSV file, with the keys being the column names
and the values being the cell values.
"""
with open(self.csv_file, 'r', encoding='utf-8') as csv_file:
csv_reader = csv.DictReader(csv_file)
data = []
for row in csv_reader:
data.append({
"prompt": row[self.prompt_column] + " ->",
"completion": " " + row[self.completion_column] + "."
})
return data
def write_json(self, data, file_path):
"""Write a list of dictionaries to a JSON file.
Each dictionary is written as a separate line in the JSON file.
Parameters:
data (list): A list of dictionaries to write to the file.
file_path (str): The path to the JSON file.
"""
with open(file_path, 'w') as json_file:
for item in data:
json.dump(item, json_file)
json_file.write('\n')
def convert(self):
"""Convert a CSV file to a JSON file.
The JSON file will contain a list of dictionaries, where each dictionary represents a row
in the CSV file, with the keys being the column names and the values being the cell values.
"""
file_name, file_extension = os.path.splitext(os.path.basename(self.csv_file))
dir_name = os.path.dirname(self.csv_file)
json_file = os.path.join(dir_name, "converted_" + file_name + ".json")
data = self.read_csv()
self.write_json(data, json_file)
return json_file
def prepare_data(json_file):
cmd = ["openai", "tools", "fine_tunes.prepare_data", "-f", json_file]
subprocess.run(cmd)
if __name__ == "__main__":
p = configargparse.ArgumentParser(description="Preprocess data", default_config_files=['config.ini'])
p.add_argument("-c", "--config", is_config_file=True, help="Config file path")
p.add_argument("--csv-file", required=True, help="Path to the CSV file")
p.add_argument("--prompt-column", required=True, help="Name of the column containing the prompts")
p.add_argument("--completion-column", required=True, help="Name of the column containing the completions")
args = p.parse_args()
# Example usage
converter = CSVConverter(args.csv_file, args.prompt_column, args.completion_column)
json_file = converter.convert()
prepare_data(json_file) | [] |
2024-01-10 | legendkong/multi-agent-discussion | agentchat_sap.py | import autogen
import openai
import json
# load OpenAI API key from config file
with open("OAI_CONFIG_LIST.json", "r") as f:
config = json.load(f)
openai.api_key = config["api_key"]
# Configuration list for the different agents
# Loads a list of configurations from an environment variable or a json file
# 1. SAP solutions architect
# 2. SAP BTP expert
# 3. customer of SAP
# SAP solutions architect config list
sap_architect_config_list = autogen.config_list_from_json(
"SOL_ARCHI_CONFIG_LIST_OAI",
filter_dict={
"model": ["gpt-4", "gpt-4-0314", "gpt4", "gpt-4-32k", "gpt-4-32k-0314", "gpt-4-32k-v0314"],
},
)
# SAP BTP expert config list
btp_expert_config_list = autogen.config_list_from_json(
"BTP_EXPERT_CONFIG_LIST_OAI",
filter_dict={
"model": ["gpt-4", "gpt-4-0314", "gpt4", "gpt-4-32k", "gpt-4-32k-0314", "gpt-4-32k-v0314"],
},
)
# END OF CONFIG
# Agent definitions
#------------- Agent: SAP solutions architect -------------
sap_solutions_architect = autogen.AssistantAgent(
name="SAP_Solutions_Architect",
llm_config={"config_list": sap_architect_config_list}, # Configuration specific to this agent
system_message= "You are a senior solutions architect from SAP with extensive knowledge in designing and implementing SAP solutions to meet the business needs of customers. You are adept at consulting with clients to understand their requirements, suggesting optimal SAP solutions, and providing expertise on the SAP platform. Your role involves engaging in meaningful discussions with the SAP BTP Expert and the customer to ensure the delivery of high-quality SAP solutions. Your responses should reflect your expertise and provide valuable insights into SAP solutions, best practices, and recommendations for the customer's inquiries."
)
# User role (proxy) for solutions architect agent
sap_solutions_architect_user = autogen.UserProxyAgent(
name="sap_solutions_architect_user",
max_consecutive_auto_reply=0, # terminate without auto-reply
human_input_mode="NEVER",
)
# serves as a bridge for communicating with solutions architect
def ask_solutions_architect(message):
sap_solutions_architect_user.initiate_chat(sap_solutions_architect, message=message)
# return the last message received from the solutions architect
return sap_solutions_architect_user.last_message()["content"]
#------------- Agent: SAP BTP expert -------------
# Agent: SAP BTP expert
sap_btp_expert = autogen.AssistantAgent(
name="SAP_BTP_Expert",
llm_config={"config_list": btp_expert_config_list}, # Configuration specific to this agent
system_message="You are an expert on SAP Business Technology Platform (BTP) services, with a deep understanding of its capabilities, services, and best practices. Your role is to provide specialized knowledge and recommendations on leveraging SAP BTP to address specific business challenges and objectives. Engage in discussions with the SAP Solutions Architect and the customer to provide insightful advice and solutions based on SAP BTP services. Your responses should exhibit your expertise, provide clear and actionable guidance, and foster collaborative problem-solving to meet the customer's business needs and inquiries regarding SAP BTP."
)
# User role (proxy) for BTP expert agent
sap_btp_expert_user = autogen.UserProxyAgent(
name="sap_btp_expert_user",
max_consecutive_auto_reply=0, # terminate without auto-reply
human_input_mode="NEVER",
)
# serves as a bridge for communicating with BTP expert
def ask_btp_expert(message):
sap_btp_expert_user.initiate_chat(sap_btp_expert, message=message)
# return the last message received from the btp expert
return sap_solutions_architect_user.last_message()["content"]
# create an AssistantAgent instance named "assistant"
assistant = autogen.AssistantAgent(
name="assistant",
llm_config={
"temperature": 0,
"request_timeout": 600,
"seed": 42,
"model": "gpt-4",
"config_list": autogen.config_list_openai_aoai(exclude="aoai"),
"functions": [
{
"name": "ask_solutions_architect",
"description": (
"Engage the Solutions Architect to: "
"1. Precisely list the steps taken to address the problem statement. "
"2. Verify the execution result of the plan and potentially suggest an alternative solution, "
"along with its pros and cons."
),
"parameters": {
"type": "object",
"properties": {
"message": {
"type": "string",
"description": (
"Question to ask the Solutions Architect. Ensure the question includes enough context, "
"such as code and execution results. The architect is unaware of previous conversations "
"unless shared."
),
},
},
"required": ["message"],
},
},
{
"name": "ask_btp_expert",
"description": (
"Engage the BTP Expert to: "
"1. Provide specialized knowledge and recommendations regarding SAP BTP services. "
"2. Engage in discussions with the Solutions Architect and Customer to provide insightful advice."
),
"parameters": {
"type": "object",
"properties": {
"message": {
"type": "string",
"description": (
"Question to ask the BTP Expert. Ensure the question includes enough context for a "
"meaningful response."
),
},
},
"required": ["message"],
},
},
],
}
)
# Agent: a customer of SAP
customer = autogen.UserProxyAgent(
name="Customer",
human_input_mode="REAL_TIME", # Allow real-time input from the customer
max_consecutive_auto_reply=5,
code_execution_config={"work_dir": "planning", "use_docker": True}, # Docker is set to true by default
function_map={"ask_solutions_architect": ask_solutions_architect, "ask_btp_expert": ask_btp_expert},
)
# the assistant receives a message from the user, which contains the task description
customer.initiate_chat(
assistant,
message="I want to create a new SAP Fiori application using SAP Business Application Studio. Suggest the steps needed to create a new SAP Fiori application using SAP Business Application Studio."
) | [] |
2024-01-10 | legendkong/multi-agent-discussion | agentchat_sap_v1.py | import autogen
import openai
import json
# load OpenAI API key from config file
with open("OAI_CONFIG_LIST.json", "r") as f:
config = json.load(f)
openai.api_key = config["api_key"]
config_list = autogen.config_list_from_json(
"OAI_CONFIG_LIST",
filter_dict={
"model": ["gpt-4-32k", "gpt-4-32k-0314", "gpt-4-32k-v0314"],
},
)
gpt4_config = {
"seed": 42, # change the seed for different trials
"temperature": 0,
"config_list": config_list,
"request_timeout": 120,
}
user_proxy = autogen.UserProxyAgent(
name="Customer",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=10,
system_message="A human customer. Interact with the planner to discuss the plan. Plan execution needs to be approved by this customer. Reply TERMINATE if the task has been solved at full satisfaction. Otherwise, reply CONTINUE, or the reason why the task is not solved yet.",
code_execution_config={"work_dir": "web"},
llm_config= gpt4_config,
is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
)
sap_solutions_architect = autogen.AssistantAgent(
name="SAP_Solutions_Architect",
llm_config=gpt4_config, # Configuration specific to this agent
system_message= "You are a senior solutions architect from SAP with extensive knowledge in designing and implementing SAP solutions to meet the business needs of customers. You are adept at consulting with clients to understand their requirements, suggesting optimal SAP solutions, and providing expertise on the SAP platform. Your role involves engaging in meaningful discussions with the SAP BTP Expert and the customer to ensure the delivery of high-quality SAP solutions. Your responses should reflect your expertise and provide valuable insights into SAP solutions, best practices, and recommendations for the customer's inquiries. Do not repeat what the other agents say."
)
sap_btp_expert = autogen.AssistantAgent(
name="SAP_BTP_Expert",
llm_config=gpt4_config, # Configuration specific to this agent
system_message="You are an expert on SAP Business Technology Platform (BTP) services, with a deep understanding of its capabilities, services, and best practices. Your role is to provide specialized knowledge and recommendations on leveraging SAP BTP to address specific business challenges and objectives. Engage in discussions with the SAP Solutions Architect and the customer to provide insightful advice and solutions based on SAP BTP services. Your responses should exhibit your expertise, provide clear and actionable guidance, and foster collaborative problem-solving to meet the customer's business needs and inquiries regarding SAP BTP. Do not repeat what the other agents say."
)
junior_consultant = autogen.AssistantAgent(
name="Junior_Consultant",
llm_config=gpt4_config,
system_message="You are the planner. Suggest a plan. Revise the plan based on feedback from customer and senior consultant, until customer approval. The plan may involve a sap solution architect who can write code and a sap btp expert who doesn't write code. Explain the plan first. Be clear which step is performed by the sap solution architect, and which step is performed by the sap btp expert.",
)
senior_consultant = autogen.AssistantAgent(
name="Senior_Consultant",
system_message="You are the critic. Double check plan, claims, code, and suggestions from other agents and provide feedback and check whether the plan is clear and complete. You can also suggest a plan if you think the plan is not clear or complete.",
llm_config=gpt4_config,
)
# sequence matters
groupchat = autogen.GroupChat(agents=[user_proxy, junior_consultant, sap_solutions_architect, sap_btp_expert, senior_consultant], messages=[], max_round=50)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=gpt4_config)
# Start Chat
user_proxy.initiate_chat(
manager,
message="""
I am a client of SAP. I want to know how to confirm/process order in S4HANA by dealing with microsoft SQL database containing IOT data from production.
""",
) | [] |
2024-01-10 | legendkong/multi-agent-discussion | agentchat_planning.py | import autogen
import openai
import json
# load OpenAI API key from config file
with open("OAI_CONFIG_LIST.json", "r") as f:
config = json.load(f)
openai.api_key = config["api_key"]
# this function loads a list of configurations from an environment variable or a json file
config_list = autogen.config_list_from_json(
"OAI_CONFIG_LIST",
filter_dict={
"model": ["gpt-4", "gpt-4-0314", "gpt4", "gpt-4-32k", "gpt-4-32k-0314", "gpt-4-32k-v0314"],
},
)
# Assistant AGENT comes with a default system message. You can overwrite it by specifying the "system_message" parameter as below.
planner = autogen.AssistantAgent(
name="planner",
llm_config={"config_list": config_list},
# the default system message of the AssistantAgent is overwritten here
system_message="You are a helpful AI assistant. You suggest coding and reasoning steps for another AI assistant to accomplish a task. Do not suggest concrete code. For any action beyond writing code or reasoning, convert it to a step which can be implemented by writing code. For example, the action of browsing the web can be implemented by writing code which reads and prints the content of a web page. Finally, inspect the execution result. If the plan is not good, suggest a better plan. If the execution is wrong, analyze the error and suggest a fix."
)
# This is the user role (proxy) for the planner agent. We are doing this because chat completions use "assistant" and "user" roles. So, we need to specify the user role for the planner agent as below. But this will not take in any user input. It will only send messages to the planner agent.
planner_user = autogen.UserProxyAgent(
name="planner_user",
max_consecutive_auto_reply=0, # terminate without auto-reply
human_input_mode="NEVER",
)
# serves as a bridge for communicating with planner
def ask_planner(message):
planner_user.initiate_chat(planner, message=message)
# return the last message received from the planner
return planner_user.last_message()["content"]
# create an AssistantAgent instance named "assistant"
assistant = autogen.AssistantAgent(
name="assistant",
llm_config={
"temperature": 0,
"request_timeout": 600,
"seed": 42,
"model": "gpt-4",
"config_list": autogen.config_list_openai_aoai(exclude="aoai"),
"functions": [
{
"name": "ask_planner",
"description": "ask planner to: 1. get a plan for finishing a task, 2. verify the execution result of the plan and potentially suggest new plan.",
"parameters": {
"type": "object",
"properties": {
"message": {
"type": "string",
"description": "question to ask planner. Make sure the question include enough context, such as the code and the execution result. The planner does not know the conversation between you and the user, unless you share the conversation with the planner.",
},
},
"required": ["message"],
},
},
],
}
)
# create a UserProxyAgent instance named "user_proxy"
user_proxy = autogen.UserProxyAgent(
name="user_proxy",
human_input_mode="TERMINATE",
max_consecutive_auto_reply=5,
# is_termination_msg=lambda x: "content" in x and x["content"] is not None and x["content"].rstrip().endswith("TERMINATE"),
code_execution_config={"work_dir": "planning", "use_docker": True}, # Docker is set to true by default
function_map={"ask_planner": ask_planner},
)
# the assistant receives a message from the user, which contains the task description
user_proxy.initiate_chat(
assistant,
message="""Suggest an improvement to the most popular repo in legendkong github. use subprocess for pip installs""", # add "use subprocess for pip install" to the end of the message if you are getting powershell error
) | [] |
2024-01-10 | jyosa/cv-and-job-profile-fit | cv_job_fit.py | import PyPDF2
import openai
import tkinter as tk
from tkinter import filedialog, messagebox
# Set your OpenAI API key in a secure way instead of hardcoding it into the script.
openai.api_key = 'here your openai key'
def pdf_to_text(pdf_path):
# Open the PDF file in binary read mode
with open(pdf_path, 'rb') as file:
# Create a PDF reader object
pdf_reader = PyPDF2.PdfReader(file)
text = ''
# Iterate over each page in the PDF
for page in range(len(pdf_reader.pages)):
# Extract text from each page and concatenate it to the text variable
text += pdf_reader.pages[page].extract_text()
return text
def analyze_cv(cv_text, job_profile):
# Construct a prompt for the OpenAI model to follow for analysis
prompt = f"""
### Job Profile
{job_profile}
### CV
{cv_text}
### Analysis
Analyze the CV with respect to the job profile.
#### Strong Points
- Identify the areas where the candidate's CV aligns well with the job profile requirements.
#### Weak Points & Recommendations for Improvement
- List the areas where the candidate's CV does not meet the job profile requirements, and suggest how the candidate might improve these aspects.
#### Conclusion
- Summarize the overall fit of the candidate for the position based on the CV and job profile.
#### Percentage Fit
- Estimate a percentage fit of the candidate to the job profile, based on the comparison of the CV and job profile.
### Table of Results
- Provide a table summarizing the strong points, weak points, recommendations for improvement, conclusion, and percentage fit.
"""
# Call the OpenAI API using the created prompt for text analysis
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=3500
)
# Extract the content from the response received from the API
analysis = response['choices'][0]['message']['content'].strip()
return analysis
def upload_file():
global file_path
# Use a file dialog to select a PDF and store the path
file_path = filedialog.askopenfilename()
def submit_analysis():
# Check if the file path and job profile are not empty
if not file_path or not job_profile_text.get("1.0", tk.END).strip():
messagebox.showerror("Error", "Please upload a CV and enter a job profile before submitting.")
return
# Extract text from the PDF file
cv_text = pdf_to_text(file_path)
# Get the job profile text from the text widget
job_profile = job_profile_text.get("1.0", tk.END).strip()
# Analyze the CV using the extracted text and job profile
analysis = analyze_cv(cv_text, job_profile)
# Update the result_text widget with the new analysis
result_text.delete("1.0", tk.END)
result_text.insert(tk.END, analysis)
# Initialize the main application window
app = tk.Tk()
app.title("CV Analyzer")
app.geometry("800x600")
# Set up UI elements for job profile entry
job_profile_label = tk.Label(app, text="Enter Job Profile:")
job_profile_label.pack()
job_profile_text = tk.Text(app, height=10, width=80)
job_profile_text.pack()
# Button to upload a CV PDF file
upload_button = tk.Button(app, text="Upload CV PDF", command=upload_file)
upload_button.pack()
# Button to submit the CV for analysis
submit_button = tk.Button(app, text="Submit Analysis", command=submit_analysis)
submit_button.pack()
# Label and text widget to display the analysis result
result_label = tk.Label(app, text="Analysis Result:")
result_label.pack()
result_text = tk.Text(app, height=20, width=80)
result_text.pack()
# Initialize file_path as None to store the path of the uploaded file
file_path = None
# Start the main loop of the application
app.mainloop()
| [
"\n### Job Profile\nPLACEHOLDER\n\n### CV\nPLACEHOLDER\n\n### Analysis\nAnalyze the CV with respect to the job profile.\n\n#### Strong Points\n- Identify the areas where the candidate's CV aligns well with the job profile requirements.\n\n#### Weak Points & Recommendations for Improvement\n- List the areas where the candidate's CV does not meet the job profile requirements, and suggest how the candidate might improve these aspects.\n\n#### Conclusion\n- Summarize the overall fit of the candidate for the position based on the CV and job profile.\n\n#### Percentage Fit\n- Estimate a percentage fit of the candidate to the job profile, based on the comparison of the CV and job profile.\n\n### Table of Results\n- Provide a table summarizing the strong points, weak points, recommendations for improvement, conclusion, and percentage fit.\n",
"You are a helpful assistant."
] |
2024-01-10 | StevenWangler/snow_day_bot | openai_actions~open_ai_data.py | """
OpenAI Message Creation Module
This module prepares messages tailored for interaction with OpenAI's engine.
It takes into account weather data, school settings, and linguistic models to craft
messages that seek predictions about snow days, image generation prompts, and more.
Dependencies:
- json: For parsing and creating JSON payloads.
- logging: To log application events and errors.
- settings: To access application-specific settings.
- openai_actions.open_ai_api_calls: To make calls to OpenAI's API.
"""
import json
import random
import logging
import datetime
from settings import settings
def create_open_ai_snow_day_message(current_weather_data, snow_day_policy):
'''
this method is used to create the json message we are
going to send to the open ai engine
'''
logging.info('Creating the request message to send to openai')
try:
message = f'''
Respond with a percentage chance that a snow day will occur tomorrow for {settings.SCHOOL_NAME}.
Here are the rules I would like you to follow:
1) You must respond in the tone of {random.choice(settings.AI_RESPONSE_THEMES)}
2) Use the information below to make up your opinion
3) Provide a SHORT explanation of the percentage chance you came up with
4) Work your answer into the short explanation
5) Be logical and honest in your answer
6) If you don't think there is any chance, just say that there is a 0% chance.
Here is some additional information to consider:
1) The school is located in the state of {settings.SCHOOL_DISTRICT_STATE}
2) Take the current month into consideration, which is: {datetime.date.today().month}
Here are the current weather conditions for the school district area:
The minimum temperature for the day will be {current_weather_data['current_day_mintemp_f']} degrees Fahrenheit, with
a maximum temperature of {current_weather_data['current_day_maxtemp_f']} degrees Fahrenheit. The maximum wind speed
for the day will be {current_weather_data['current_day_maxwind_mph']}MPH. The wind chill (or "feels like") is currently
{current_weather_data['current_day_feelslike_f']} degrees Fahrenheit. As of now, there is a {current_weather_data['current_day_daily_chance_of_snow']}%
chance that it will snow today. There is also a {current_weather_data['current_day_daily_chance_of_rain']}% chance that it will rain today.
The total amount of precipitation today is going to be around {current_weather_data['current_day_totalprecip_in']} inches. The average humidity
for today is {current_weather_data['current_day_daily_avghumidity']}%. The current day conditions are {current_weather_data['current_day_conditions']}.
Here are the weather conditions for tomorrow:
Tomorrow, the minimum temperature for the day will be {current_weather_data['next_day_mintemp_f']} degrees Fahrenheit, with
a maximum temperature of {current_weather_data['next_day_maxtemp_f']} degrees Fahrenheit. The maximum wind speed
for tomorrow will be {current_weather_data['next_day_maxwind_mph']}MPH. The wind chill (or "feels like") for tomorrow will be
{current_weather_data['next_day_feelslike_f']} degrees Fahrenheit. As of now, there is a {current_weather_data['next_day_daily_chance_of_snow']}%
chance that it will snow tomorrow. There is also a {current_weather_data['next_day_daily_chance_of_rain']}% chance that it will rain tomorrow.
The total amount of precipitation tomorrow is going to be around {current_weather_data['next_day_totalprecip_in']} inches. The average humidity
for tomorrow will be {current_weather_data['next_day_daily_avghumidity']}%. The conditions for tomorrow are {current_weather_data['next_day_conditions']}.
If there are any weather alerts or warnings, they are listed below (MAKE SURE THE ALERTS ARE FOR KENT COUNTY (WHERE ROCKFORD IS):
Weather alert event: {current_weather_data['weather_alert_event'] if 'weather_alert_event' in current_weather_data else 'no data available'}
Weather alert event description: {current_weather_data['weather_alert_desc'] if 'weather_alert_desc' in current_weather_data else 'no data available'}
Weather alert severity: {current_weather_data['weather_alert_severity'] if 'weather_alert_severity' in current_weather_data else 'no data available'}
Weather alert certainty: {current_weather_data['weather_alert_certainty'] if 'weather_alert_certainty' in current_weather_data else 'no data available'}
Weather alert urgency: {current_weather_data['weather_alert_urgency'] if 'weather_alert_urgency' in current_weather_data else 'no data available'}
Here is some information about the schools snow day policy and how snow days are decided:
{snow_day_policy}
'''
message = message.replace("\n", "\\n")
message = message.strip()
message_object = json.loads(json.dumps([{"role": "user", "content": message}]))
except KeyError as ex:
logging.error('An error occurred while creating message: %s',str(ex))
message_object = None
return message_object
def create_open_ai_prediction_check_message(prediction_message):
"""
Generates a formatted message to check OpenAI's prediction about the chance of a snow day.
Parameters:
- prediction_message (str): A message containing prediction details.
Returns:
- dict: A JSON-like dictionary object containing a formatted message for OpenAI's analysis.
Raises:
- Exception: If any error occurs during message formatting or JSON conversion.
Note:
The response from OpenAI should be either "True" or "False", indicating if there's a greater
than 50% chance of a snow day.
"""
try:
message = f'''
Analyze the following message and respond with ONLY the word "True" or "False". Tell me
if there is a greater than or equal to 50% chance of a snow day. Here is the message:
{prediction_message}
'''
message = message.replace("\n", "\\n")
message = message.strip()
message_object = json.loads(json.dumps([{"role": "user", "content": message}]))
return message_object
except Exception as ex:
logging.error(f'There was an error in create_open_ai_prediction_check_message. Error: {ex}')
return None
| [] |
2024-01-10 | pbk95120/wep-final | backend~backend.py | #Import Fastapi
#for making server
from fastapi import FastAPI, Form, Request, UploadFile, File
from fastapi.middleware.cors import CORSMiddleware
#Import Langchain
#for executing queries
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.indexes import VectorstoreIndexCreator
from langchain.document_loaders import TextLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
#Import Etc..
from dotenv import load_dotenv
from glob import glob
import uvicorn
import openai
import shutil
import time
import os
#For Tokenizing chatting log
MAGIC_NUMBER = '!!2087342418!!'
#This is the key for Using OpenAi
#Please do not share this key
load_dotenv()
OPEN_API_KEY = os.environ.get('OPEN_API_KEY') #You can use your own key
#Define FastAPI Application
app = FastAPI()
#Set All IPs to access backend server
app.add_middleware(
CORSMiddleware,
allow_origins=["*",],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
#Split the text to document loader attributes
def load_n_split(path):
loader = TextLoader(path)
document = loader.load()
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(document)
print("This Script has " + str(len(docs)) + " docs.")
return docs
#Save Langchain to DB
def save_as_db(dbPath, dbName, docs):
path = dbPath + "." + dbName
index = VectorstoreIndexCreator(
vectorstore_cls=FAISS,
embedding=OpenAIEmbeddings(openai_api_key=OPEN_API_KEY),
).from_documents(docs)
index.vectorstore.save_local(path)
#Load Langchain to retriver
def load_from_db(path):
fdb = FAISS.load_local(path, OpenAIEmbeddings(openai_api_key=OPEN_API_KEY))
retriever = fdb.as_retriever(search_type='similarity', search_kwargs={"k":2})
return retriever
#Function For Sign Up
@app.post('/signup')
def return_signup_stat(userid:str = Form(...), password:str = Form(...)):
#Get All User Directories in server
for path, dir, files in os.walk("./data/"):
print(dir)
for folder_name in dir:
#When there exists user's folder
if folder_name == userid:
return {"exist":True, "status":False}
try:
user_dir = "./data/" + userid
os.mkdir(user_dir)
f = open(user_dir + "/." + userid,"w+")
f.write(password)
f.close()
return {"exist":False, "status":True}
except:
return {"exist":False, "status":False}
#Function For Sign In
@app.post('/signin')
def return_signin_stat(userid:str = Form(...), password:str = Form(...)):
#Get All User Directories in server
for path, dir, files in os.walk("./data/"):
print(dir)
for folder_name in dir:
#When there exists user's folder
if folder_name == userid:
#there has a hidden file for looking up password
f = open("./data/" + userid + "/." + userid,"r")
password_validate = f.read()
#When the password matches
if password == password_validate:
return {"exist":True, "status":True}
#When the password not matches
else:
return {"exist":True, "status":False}
return {"exist":False, "status":False}
#Function For Listing up Notes
@app.get('/getNoteList/{userid}')
def return_note_list(userid:str):
user_path = "./data/" + userid + "/"
file_list = os.listdir(user_path)
file_list_txt = [file.rsplit('.')[0] for file in file_list if not file.startswith(".")]
file_list_txt = list(set(file_list_txt))
modification_time_list = []
creation_time_list = []
for note in file_list_txt:
text_file_path = user_path + note + ".txt"
modification_time = time.gmtime(os.path.getmtime(text_file_path))
creation_time = time.gmtime(os.path.getctime(text_file_path))
modification_time_list.append(time.strftime("%Y-%m-%d %H:%M", modification_time))
creation_time_list.append(time.strftime("%Y-%m-%d %H:%M", creation_time))
print(file_list_txt)
print(modification_time_list)
print(creation_time_list)
return {"fileList": file_list_txt, "mtimeList": modification_time_list, "ctimeList": creation_time_list}
#Function For Getting Contents of Notes
@app.get('/getNote/{userid}/{notename}')
def return_note(userid:str, notename:str):
f = open("./data/" + userid + "/" + notename + ".txt","r")
contents = f.read()
f = open("./data/" + userid + "/" + notename + ".chatlog","r")
chat_log = f.read()
chat_log_list = chat_log.split(MAGIC_NUMBER)
f = open("./data/" + userid + "/" + notename + ".memo","r")
memo = f.read()
print(chat_log_list)
print(memo)
return {"contents": contents, "chatlog": chat_log_list, "memo": memo}
#Function For Uploading Notes
@app.post("/uploadMemo/{userid}/{notename}")
def upload_file(userid:str, notename:str, contents:str = Form(...)):
upload_dir = "./data/" + userid + "/"
f = open(upload_dir + notename + ".memo","w+")
f.write(contents)
f.close()
return {"status": True, "file": notename}
@app.post("/uploadSpeech/{userid}/{notename}")
def upload_speech(userid:str, notename:str, file: UploadFile):
upload_dir = "./data/" + userid + "/"
with open(os.path.join(upload_dir, notename + ".mp3"), "wb") as fp:
shutil.copyfileobj(file.file, fp)
content = open(os.path.join(upload_dir, notename + ".mp3"), "rb")
openai.api_key = OPEN_API_KEY
transcript = openai.Audio.transcribe("whisper-1", content)
f = open(upload_dir + notename + ".txt","w+")
f.write(transcript.text)
f.close()
f = open(upload_dir + notename + ".chatlog","w+")
f.write("Hello, " + userid + "! Ask me everything about this Note.")
f.close()
f = open(upload_dir + notename + ".memo","w+")
f.close()
docs = load_n_split(upload_dir + notename + ".txt")
save_as_db(upload_dir, notename, docs)
return {"status": True, "filename": notename}
#Function For Getting Query Answer
@app.get('/getQa/{userid}/{notename}/{query}')
def return_query(userid:str, notename:str, query:str):
path = "./data/" + userid + "/." + notename
chat = ChatOpenAI(model_name='gpt-3.5-turbo', temperature=0.9, openai_api_key=OPEN_API_KEY)
# chat = ChatOpenAI(model_name='gpt-4', temperature=0.9, openai_api_key=OPEN_API_KEY)
retriever = load_from_db(path)
qa = RetrievalQA.from_chain_type(llm=chat,
chain_type="stuff", retriever=retriever)
result = qa.run(query)
path = "./data/" + userid + "/" + notename
f = open(path + ".chatlog","a+")
f.write(MAGIC_NUMBER)
f.write(query)
f.write(MAGIC_NUMBER)
f.write(result)
f.close()
return {"status": True, "query": result}
@app.delete("/deleteFile/{userid}/{notename}")
def delete_file(userid:str, notename: str):
path = "./data/" + userid + "/"
[os.remove(file) for file in glob(path + notename + ".*")]
shutil.rmtree(path + "." + notename)
return {"status": True, "filename": notename}
if __name__=='__main__':
uvicorn.run(app, host='localhost', port = 8080)
| [] |
2024-01-10 | sander-hergarten/research-assistant | research_assistant~ingress.py | import os
from langchain.vectorstores import Qdrant
from langchain.document_loaders import PyPDFLoader
from langchain.embeddings import SentenceTransformerEmbeddings
from sentence_transformers import SentenceTransformer
from .utils import config
documents = []
for file in os.listdir(config["assistant"]["ingress-location"]):
documents.extend(PyPDFLoader(file).load_and_split())
model = SentenceTransformerEmbeddings(model=config["assistant"]['embedding-model'])
match config['assistant']['db_location']:
case 'local':
qdrant = Qdrant.from_documents(
documents,
model,
location=config['assistant']['location'],
collection_name='papers',
)
case 'remote':
qdrant = Qdrant.from_documents(
documents,
model,
url=config['assistant']['url'],
prefer_grpc=True,
collection_name='papers',
)
case 'memory':
qdrant = Qdrant.from_documents(
documents,
model,
location=":memory:",
collection_name='papers',
)
| [] |
2024-01-10 | CyberMaryVer/Mock-Interview | utils~st_sessionstate.py | import os
import streamlit as st
from ai_analysis.openai_tools import OPENAI_KEY, check_if_key_valid
def _enter_key():
"""
This function gets user key
"""
with st.form("key_form"):
st.markdown("🔑 **Enter your key**")
example_input = "Enter key"
user_input = st.text_input("st-xxxx",
max_chars=500,
placeholder=example_input,
label_visibility="collapsed")
submitted = st.form_submit_button("Submit")
if submitted:
is_valid = check_if_key_valid(user_input)
st.markdown(f"☑️ :green[Key is valid]") if is_valid \
else st.markdown(f"❌ :red[Key is invalid]")
if is_valid:
st.session_state["api_key"] = user_input
os.environ["OPENAI_API_KEY"] = user_input
def st_getenv(key, default=None):
"""
This function gets environment variable
"""
if key in st.session_state:
return st.session_state[key]
else:
return default
def st_apikey():
# Check environment variable
placeholder = st.empty()
if OPENAI_KEY is not None:
st.session_state['api_key'] = OPENAI_KEY
os.environ["OPENAI_KEY"] = OPENAI_KEY
if st_getenv('api_key') is None:
st.warning("Please add your OpenAI API key to continue.")
with placeholder:
_enter_key()
print("API key set")
if st_getenv('api_key') is not None:
print(f"\033[093mAPI key: {st.session_state['api_key'][:6]}...\033[0m")
with placeholder:
st.markdown("☑️ :green[API key set]")
| [] |
2024-01-10 | CyberMaryVer/Mock-Interview | mock~assesment.py | import os
import uuid
import streamlit as st
from loguru import logger
from streamlit_js_eval import streamlit_js_eval
from streamlit_feedback import streamlit_feedback
from ai_analysis.openai_tools import openai_response, openai_response_for_text
from ai_analysis.prompts.default import assesment_default
from ai_analysis.prompts.screening import screening_assessment, scr_assessment_format
from ai_analysis.prompts.tech import tech_assessment, tech_assessment_format
from utils.st_sessionstate import st_getenv, st_apikey
from utils.st_retrieval import load_unique_ids, load_interview_plan
INTERVIEWERS = {
"Humble": "./img/XriI.gif",
"Relaxed": "./img/mask.gif",
"Nervous": "./img/kerry.gif",
"Friendly": "./img/mayor.gif",
}
def _log_interview(messages, plan_id, user_id=None):
id = str(uuid.uuid4()) if user_id is None else user_id
text = [f"[{plan_id}] Interview summary:", ]
for m in messages:
role = m["role"]
content = m["content"]
if role != "system":
role = "Candidate" if role == "user" else "Interviewer"
txt = f"{role}: {content}"
text.append(txt)
text = [t.replace("\n", " ") for t in text]
text = "\n".join(text)
with open(f"./db/interview_{id}.txt", "w") as f:
f.write(text)
return text
def reset_conversation():
try:
# # delete key
# del st.session_state["api_key"]
# del os.environ["OPENAI_API_KEY"]
# logger.warning(f"Key deleted: {st_getenv('api_key', None)}. ")
logger.warning(f"Environment variable deleted: {os.getenv('OPENAI_API_KEY')}.")
streamlit_js_eval(js_expressions="parent.window.location.reload()")
except Exception as e:
logger.error(f"Error: {e}")
st.error("Something went wrong. Please reload the page.")
def evaluate_user_answer(user_answer, api_key):
try:
question = st.session_state.messages[-1]["content"]
prompt_task = "Evaluate candidate's answer (score: 1-10). " \
"Provide an example of the good answer (1-2 sentences):"
prompt_data = f"Question: {question}\nAnswer: {user_answer}\n\n"
prompt = f"{prompt_task}\n\n{prompt_data}"
return openai_response_for_text(prompt, api_key)
except Exception as e:
logger.error(f"Error: {e}")
return "Evaluation failed. Please try again."
def _split_text(text, max_len=400):
if len(text) <= max_len:
return [text, ]
else:
chunks = []
while len(text) > max_len:
idx = text[:max_len].rfind(".")
chunks.append(text[:idx])
text = text[idx:]
chunks.append(text)
return chunks
def st_init_chatbot():
"""
This function initializes chatbot
"""
with st.expander("Config", expanded=True):
col1, col2 = st.columns((1, 1))
with col1:
st.markdown("#### ▶️ Select your Interviewer")
interviewer = st.selectbox("Interviewer", list(INTERVIEWERS.keys()), label_visibility="collapsed")
interviewer_name = st.text_input("Interviewer name", value="Ted", label_visibility="collapsed")
st.session_state['assistant_avatar'] = INTERVIEWERS[interviewer]
situation = "You are an Interviewer. You are conducting a job interview. " \
"Step by step ask me questions from the list below. After receiving the answer, " \
"write down the short comment and ask the next question. "
messages = [{"role": "system", "content": situation}]
with col2:
st.image(INTERVIEWERS[interviewer], use_column_width=True)
ids = ['1', ] + load_unique_ids()
st.markdown("#### ▶️ Select your Interview Plan")
plan_id = st.selectbox("Interview Plan", ids, label_visibility="collapsed")
questions, plan_type = load_interview_plan(plan_id=plan_id)
ice_breaker = f"Hi, I'm your interviewer. " \
f"My name is {interviewer_name}. What is your name?"
prompt_task = f"After finishing the interview and providing the summary, write: 'Have a great day!'."
questions = "\n".join([f"{idx + 1}. {q}" for idx, q in enumerate(questions)])
content = f"{prompt_task}\n\nQUESTIONS:\n{questions}"
messages_for_bot_init = [{"role": "system", "content": content},
{"role": "assistant", "content": ice_breaker}, ]
messages += messages_for_bot_init
st.write(questions)
return {"messages": messages, "plan_id": plan_id, "plan_type": plan_type, "interviewer": interviewer}
def main(admin=None):
"""
This function is a main program function
:return: None
"""
st_apikey()
api_key = st_getenv("api_key")
if st.sidebar.button("Reset"):
reset_conversation()
col1, col2 = st.columns((4, 1))
with col2:
pass
with col1:
if "messages" not in st.session_state:
config_data = st_init_chatbot()
submitted = st.button("Submit config")
if submitted and st_getenv('api_key') is not None:
st.session_state["messages"] = config_data["messages"]
st.session_state["plan_id"] = config_data["plan_id"]
st.session_state["plan_type"] = config_data["plan_type"]
st.experimental_rerun()
st.success("Config submitted")
elif submitted:
st.markdown("⚠️ Please enter in the field above your OpenAI API key to continue.")
else:
# user_chat = st.chat_message("user")
assistant_av = st.session_state['assistant_avatar']
for msg in st.session_state.messages[:]:
if msg["role"] == "user" and len(msg["content"]) > 0:
st.chat_message("user").write(msg["content"], )
elif msg["role"] == "assistant":
st.chat_message("assistant", avatar=assistant_av).write(msg["content"])
else:
logger.info("System message updated")
if prompt := st.chat_input():
# async def evaluate_user_answer(user_answer, api_key):
with st.sidebar.expander("System message", expanded=False):
evaluation = evaluate_user_answer(prompt, api_key)
st.write("\n".join(_split_text(evaluation, max_len=400)))
st.session_state.messages.append({"role": "user", "content": prompt})
st.chat_message("user").write(prompt)
msg = openai_response(st.session_state.messages, api_key, with_content=True)
st.session_state.messages.append(msg)
st.chat_message("assistant", avatar=assistant_av).write(msg.content)
if "Have a great day" in msg.content:
st.success("Interview completed")
plan_id = st_getenv("plan_id", '1')
logs = _log_interview(st.session_state.messages, plan_id=plan_id)
st.session_state["logs"] = logs
st.stop()
feedback = streamlit_feedback(feedback_type="thumbs")
if st.button("Evaluate"):
st.success("Interview completed")
messages_all = st_getenv("messages", [])
if len(messages_all) <= 3:
st.error("Please start the interview first.")
st.stop()
elif len(messages_all) <= 8:
st.error("Not enough messages. Please answer at least 2 questions.")
st.stop()
plan_id = st_getenv("plan_id", '1')
logs = _log_interview(st.session_state.messages, plan_id=plan_id)
# get summary
if st_getenv("plan_type") == "screening":
assesment_instructions = screening_assessment + scr_assessment_format
elif st_getenv("plan_type") == "tech":
assesment_instructions = tech_assessment + tech_assessment_format
else:
assesment_instructions = assesment_default
assesment_instructions = assesment_instructions.replace("{text}", logs)
messages = [{"role": "system", "content": assesment_instructions}, ]
with st.spinner("Generating summary..."):
summary = openai_response(messages, api_key, with_content=False)
st.write(summary)
st.session_state["logs"] = logs
st.stop()
feedback = streamlit_feedback(feedback_type="thumbs")
st.session_state["feedback"] = feedback
if 'feedback' in st.session_state:
plan = st_getenv("plan_id", '1')
with open(f"./db/feedback_{plan}.txt", "a") as f:
f.write(st.session_state["feedback"])
if __name__ == "__main__":
main(admin=False)
| [
"Question: PLACEHOLDER\nAnswer: PLACEHOLDER\n\n",
"PLACEHOLDER\n\nPLACEHOLDER",
"Evaluate candidate's answer (score: 1-10). Provide an example of the good answer (1-2 sentences):",
"After finishing the interview and providing the summary, write: 'Have a great day!'."
] |
2024-01-10 | CyberMaryVer/Mock-Interview | ai_analysis~mock_interview.py | import os
import uuid
import streamlit as st
import pandas as pd
from loguru import logger
from streamlit_js_eval import streamlit_js_eval
from streamlit_feedback import streamlit_feedback
from ai_analysis.openai_tools import openai_response
from ai_analysis.prompts.default import assesment_default
from utils.st_sessionstate import st_getenv, st_apikey
INTERVIEWERS = {
"Humble": "./img/XriI.gif",
"Relaxed": "./img/mask.gif",
"Nervous": "./img/kerry.gif",
"Friendly": "./img/mayor.gif",
}
def _log_interview(messages, plan_id, user_id=None):
id = str(uuid.uuid4()) if user_id is None else user_id
text = [f"[{plan_id}] Interview summary:", ]
for m in messages:
role = m["role"]
content = m["content"]
if role != "system":
role = "Candidate" if role == "user" else "Interviewer"
txt = f"{role}: {content}"
text.append(txt)
text = [t.replace("\n", " ") for t in text]
text = "\n".join(text)
with open(f"./db/interview_{id}.txt", "w") as f:
f.write(text)
return text
def reset_conversation():
try:
# # delete key
# del st.session_state["api_key"]
# del os.environ["OPENAI_API_KEY"]
# logger.warning(f"Key deleted: {st_getenv('api_key', None)}. ")
logger.warning(f"Environment variable deleted: {os.getenv('OPENAI_API_KEY')}.")
streamlit_js_eval(js_expressions="parent.window.location.reload()")
except Exception as e:
logger.error(f"Error: {e}")
st.error("Something went wrong. Please reload the page.")
def load_unique_ids():
"""
This function loads unique ids from the database
"""
db = pd.read_csv("./db/plans.csv")
return db["plan_id"].unique().tolist()
def load_interview_plan(plan_id):
"""
This function loads interview plan from the database
"""
# If plan_id is not specified, load default plan
if plan_id == '1':
return ["Tell me about yourself.",
"What are your strengths?",
"What are your weaknesses?",
"Why do you want this job?",
"Where would you like to be in your career five years from now?",
"What's your ideal company?",
"What attracted you to this company?",
"Why should we hire you?",
"What did you like least about your last job?",
"When were you most satisfied in your job?",
"What can you do for us that other candidates can't?",
"What were the responsibilities of your last position?",
"Why are you leaving your present job?"]
db = pd.read_csv("./db/plans.csv")
plan = db[db["plan_id"] == plan_id]
questions = plan["question"].tolist()
return questions
def st_init_chatbot():
"""
This function initializes chatbot
"""
with st.expander("Config", expanded=True):
col1, col2 = st.columns((1, 1))
with col1:
st.markdown("#### ▶️ Select your Interviewer")
interviewer = st.selectbox("Interviewer", list(INTERVIEWERS.keys()), label_visibility="collapsed")
interviewer_name = st.text_input("Interviewer name", value="Ted", label_visibility="collapsed")
st.session_state['assistant_avatar'] = INTERVIEWERS[interviewer]
situation = "You are an Interviewer. You are conducting a job interview. " \
"Step by step ask me questions from the list below. After receiving the answer, " \
"write down the short comment and ask the next question. "
messages = [{"role": "system", "content": situation}]
with col2:
st.image(INTERVIEWERS[interviewer], use_column_width=True)
ids = ['1', ] + load_unique_ids()
st.markdown("#### ▶️ Select your Interview Plan")
plan_id = st.selectbox("Interview Plan", ids, label_visibility="collapsed")
questions = load_interview_plan(plan_id=plan_id)
ice_breaker = f"Hi, I'm your interviewer. " \
f"My name is {interviewer_name}. What is your name?"
prompt_task = f"After finishing the interview and providing the summary, write: 'Have a great day!'."
questions = "\n".join([f"{idx + 1}. {q}" for idx, q in enumerate(questions)])
content = f"{prompt_task}\n\nQUESTIONS:\n{questions}"
messages_for_bot_init = [{"role": "system", "content": content},
{"role": "assistant", "content": ice_breaker}, ]
messages += messages_for_bot_init
st.write(questions)
return messages, plan_id, interviewer
def main(admin=None):
"""
This function is a main program function
:return: None
"""
st_apikey()
api_key = st_getenv("api_key")
if st.sidebar.button("Reset"):
reset_conversation()
col1, col2 = st.columns((4, 1))
with col2:
pass
with col1:
if "messages" not in st.session_state:
messages, plan, interviewer = st_init_chatbot()
submitted = st.button("Submit config")
if submitted and st_getenv('api_key') is not None:
st.session_state["messages"] = messages
st.session_state["plan_id"] = plan
st.experimental_rerun()
st.success("Config submitted")
elif submitted:
st.markdown("⚠️ Please enter in the field above your OpenAI API key to continue.")
else:
# user_chat = st.chat_message("user")
assistant_av = st.session_state['assistant_avatar']
for msg in st.session_state.messages[:]:
if msg["role"] == "user" and len(msg["content"]) > 0:
st.chat_message("user").write(msg["content"], )
elif msg["role"] == "assistant":
st.chat_message("assistant", avatar=assistant_av).write(msg["content"])
else:
logger.info("System message updated")
if prompt := st.chat_input():
st.session_state.messages.append({"role": "user", "content": prompt})
st.chat_message("user").write(prompt)
msg = openai_response(st.session_state.messages, api_key, with_content=True)
st.session_state.messages.append(msg)
st.chat_message("assistant", avatar=assistant_av).write(msg.content)
if "Have a great day" in msg.content:
st.success("Interview completed")
plan_id = st_getenv("plan_id", '1')
logs = _log_interview(st.session_state.messages, plan_id=plan_id)
st.session_state["logs"] = logs
st.stop()
feedback = streamlit_feedback(feedback_type="thumbs")
if st.button("Evaluate"):
st.success("Interview completed")
messages_all = st_getenv("messages", [])
if len(messages_all) <= 3:
st.error("Please start the interview first.")
st.stop()
elif len(messages_all) <= 8:
st.error("Not enough messages. Please answer at least 2 questions.")
st.stop()
plan_id = st_getenv("plan_id", '1')
logs = _log_interview(st.session_state.messages, plan_id=plan_id)
# get summary
messages = [{"role": "system", "content": assesment_default},
{"role": "system", "content": logs}]
with st.spinner("Generating summary..."):
summary = openai_response(messages, api_key, with_content=False)
st.write(summary)
st.session_state["logs"] = logs
st.stop()
feedback = streamlit_feedback(feedback_type="thumbs")
st.session_state["feedback"] = feedback
if 'feedback' in st.session_state:
with open(f"./db/feedback_{plan}.txt", "a") as f:
f.write(st.session_state["feedback"])
| [
"After finishing the interview and providing the summary, write: 'Have a great day!'.\n\nQUESTIONS:\nPLACEHOLDER",
"After finishing the interview and providing the summary, write: 'Have a great day!'."
] |
2024-01-10 | CyberMaryVer/Mock-Interview | mock~preparation.py | import os, uuid
import json
import streamlit as st
import pandas as pd
from loguru import logger
from ai_analysis.prompts.screening import screening_instructions, cv_analysis_instructions_screening
from ai_analysis.prompts.tech import tech_instructions, cv_analysis_instructions_tech
from ai_analysis.prompts.default import job_analysis_default_instructions, cv_analysis_default_instructions
from ai_analysis.openai_tools import openai_response_with_validation
from utils.st_sessionstate import st_getenv, st_apikey
from data.mockdata import JOB_DESC, CV
def analyze_job(job_desc, instructions=job_analysis_default_instructions):
"""
This function initializes chatbot
"""
instructions = f"TASK:\n{instructions}\n\nJOB DESCRIPTION:\n{job_desc}"
prompt_task = f"Here is the detailed analysis of the main skills we are looking for:\n"
messages = [{"role": "system", "content": instructions},
{"role": "assistant", "content": prompt_task}, ]
return messages
def analyze_cv(cv, job=None, instructions=cv_analysis_default_instructions):
"""
This function initializes chatbot
"""
job = "" if job is None else job
instructions = f"TASK:\n{instructions}\n\nCV:\n{cv}\n\nJOB DESCRIPTION:\n{job}"
prompt_task = f"Here is the detailed analysis of the candidate's CV:\n"
messages = [{"role": "system", "content": instructions},
{"role": "assistant", "content": prompt_task}, ]
return messages
def create_interview_plan(job_data, cv_data, instructions=screening_instructions):
"""
This function creates interview plan
:return: None
"""
cv_dict = json.loads(cv_data)
job_dict = json.loads(job_data)
if instructions == tech_instructions:
try:
role = job_dict['position_title']
seniority = job_dict['seniority_level']
tasks = job_dict['tasks']
skills = job_dict['must_have_skills']
instructions = instructions\
.replace('{role}', role)\
.replace('{seniority}', seniority)\
.replace('{tasks}', f"{tasks}")\
.replace('{skills}', f"{skills}")
except Exception as e:
logger.error(e)
instructions = instructions.replace('{job}', job_data).replace('{cv}', cv_data)
instructions = f"TASK:\n{instructions}\n"
prompt_task = f"Here is the detailed plan of the screening interview:\n"
messages = [{"role": "system", "content": instructions},
{"role": "assistant", "content": prompt_task}, ]
return messages
def download_results(results_id):
data_to_download = {}
for k, v in st.session_state['user_template'].items():
# print(f"\033[92m{k}\033[0m", v)
if k in ['job_desc', 'cv', 'plan_id']:
data_to_download[k] = v
else:
data_to_download[k] = json.loads(v)
st.download_button("Download JSON with results",
json.dumps(data_to_download, indent=4),
f"interview_plan_{results_id}.json")
def st_json(json_data, container_name="JSON", download_button=False):
try:
json_data = json.loads(json_data)
with st.expander(container_name, expanded=False):
st.json(json_data)
if download_button:
st.download_button("Download JSON",
json.dumps(json_data),
f"{container_name}.json")
except Exception as e:
logger.error(e)
with st.expander("Error"):
st.markdown(f":red[{e}]")
st.write(json_data)
def save_plan_and_create_id(json_data, plan_type="screening"):
"""
This function saves interview plan to the database and creates an ID
:param json_data: JSON data
:return: None
"""
db_data = []
id = uuid.uuid4()
for k, v in json_data.items():
for idx, question in enumerate(v):
db_data.append({
"id": f"{id}-{k}-{idx}",
"plan_id": f"{id}",
"question": question,
"topic": k,
"plan_type": plan_type,
"comment": ""})
if os.path.exists("./db/plans.csv"):
db = pd.read_csv("./db/plans.csv")
# db = db.append(db_data, ignore_index=True)
# concatenate:
db = pd.concat([db, pd.DataFrame(data=db_data, columns=db_data[0].keys())], ignore_index=True)
else:
db = pd.DataFrame(data=db_data, columns=db_data[0].keys())
db.to_csv("./db/plans.csv", index=False)
return str(id)
def main(admin=None):
"""
This function is a main program function
:return: None
"""
st_apikey()
api_key = st_getenv("api_key")
st.session_state['user_template'] = {}
with st.form("Job Description"):
interview_type = st.selectbox("Interview Type", ["Screening", "Technical"])
if interview_type == "Screening":
instructions = screening_instructions
cv_instructions = cv_analysis_instructions_screening
elif interview_type == "Technical":
instructions = tech_instructions
cv_instructions = cv_analysis_instructions_tech
col1, col2 = st.columns(2)
with col1:
st.info("Paste a Job Description below")
job_desc = st.text_area("Job", label_visibility="collapsed", value=JOB_DESC, height=600)
with col2:
st.info("Paste a CV below")
cv = st.text_area("CV", label_visibility="collapsed", value=CV, height=600)
submitted = st.form_submit_button("Update")
if submitted:
st.markdown("#### ☑️ Job Description and CV submitted")
st.markdown("---")
st.markdown("#### 🔬 Analyzing Job Description and CV...")
with st.spinner("Analyzing job description..."):
messages = analyze_job(job_desc)
job_analysis = openai_response_with_validation(messages, api_key)
st.session_state['user_template']['job_desc'] = job_desc
st.session_state['user_template']['job_analysis'] = job_analysis
logger.info("✅ Job Description analyzed")
st.markdown("* ✅ Job Description analyzed")
with st.spinner("Analyzing CV..."):
messages = analyze_cv(cv, job_desc, cv_instructions)
cv_analysis = openai_response_with_validation(messages, api_key)
st.session_state['user_template']['cv'] = cv
st.session_state['user_template']['cv_analysis'] = cv_analysis
logger.info("✅ CV analyzed")
st.markdown("* ✅ CV analyzed")
with st.spinner("Creating interview plan..."):
messages = create_interview_plan(job_analysis, cv_analysis, instructions)
plan = openai_response_with_validation(messages, api_key)
st.session_state['user_template']['plan'] = plan
logger.info("✅ Interview plan created")
st.markdown("* ✅ Interview plan created")
# Save plan to the database
try:
plan = json.loads(plan)
plan_id = save_plan_and_create_id(plan)
st.session_state['user_template']['plan_id'] = plan_id
logger.info("✅ Interview plan saved to the database")
st.markdown("* ✅ Interview plan saved to the database")
except Exception as e:
logger.error(e)
if "user_template" in st.session_state:
st.markdown("---")
st.markdown("#### 📝 Interview Plan")
try:
# Load saved data
job_analysis = st.session_state['user_template']['job_analysis']
cv_analysis = st.session_state['user_template']['cv_analysis']
plan = st.session_state['user_template']['plan']
plan_id = st.session_state['user_template']['plan_id']
# Display saved data
st_json(job_analysis, "Job Analysis")
st_json(cv_analysis, "CV Analysis")
st_json(plan, "Interview Plan")
plan = json.loads(plan)
st.markdown("---")
st.markdown(f"#### :blue[**Interview Plan:**]")
for k, v in plan.items():
st.markdown(f"💡 **{k}:**")
for idx, question in enumerate(v):
if interview_type == "Technical":
st.markdown(f"**Q {idx}:** {question['Q']}")
elif interview_type == "Screening":
st.markdown(f"**Q {idx}:** {question}")
st.markdown(f"#### 📝 :blue[**Interview Plan ID:**] **{plan_id}**")
download_results(plan_id)
except Exception as e:
st.info("Please submit Job Description and CV to create an interview plan")
logger.error(e)
# with st.expander("Error"):
# st.write(e)
if __name__ == "__main__":
main(admin=False)
| [
"Here is the detailed plan of the screening interview:\n",
"Here is the detailed analysis of the main skills we are looking for:\n",
"Here is the detailed analysis of the candidate's CV:\n"
] |
2024-01-10 | SachinCosmo/ai | Geeta.py | import os
import getpass
import streamlit as st
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma
from langchain import HuggingFaceHub
from langchain.chains import RetrievalQA
__import__('pysqlite3')
import sys
sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
# load huggingface api key
os.environ["HUGGINGFACE_HUB_TOKEN"] = st.secrets["HUGGINGFACE_HUB_TOKEN"]
# use streamlit file uploader to ask user for file
# file = st.file_uploader("Upload PDF")
path = "https://vedpuran.files.wordpress.com/2013/04/455_gita_roman.pdf"
loader = PyPDFLoader(path)
pages = loader.load()
# st.write(pages)
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=20)
docs = splitter.split_documents(pages)
embeddings = HuggingFaceEmbeddings()
doc_search = Chroma.from_documents(docs, embeddings)
repo_id = "tiiuae/falcon-7b"
llm = HuggingFaceHub(repo_id=repo_id, huggingfacehub_api_token=os.environ["HUGGINGFACE_HUB_TOKEN"], model_kwargs={'temperature': 0.2,'max_length': 1000})
from langchain.schema import retriever
retireval_chain = RetrievalQA.from_chain_type(llm, chain_type="stuff", retriever=doc_search.as_retriever())
if query := st.chat_input("Enter a question: "):
with st.chat_message("assistant"):
st.write(retireval_chain.run(query))
| [] |
2024-01-10 | TashaSkyUp/GraphDev | tests~test_nlp.py | import unittest
import os
import openai
from custom_nodes.SWAIN.text import get_openai_embedding
class TestGetOpenAIEmbedding(unittest.TestCase):
def setUp(self):
# Set up api_key
os.environ["OPENAI_API_KEY"] = "insert_your_api_key_here"
def test_valid_input(self):
# Show available models
models = openai.Model.list()
print([model.id for model in models['data']])
# Test valid input
model = "text-embedding-ada-002"
text = "Hello, world!"
embeddings = get_openai_embedding(model, text)
self.assertIsInstance(embeddings, list)
self.assertIsInstance(embeddings[0][0], float)
def test_invalid_model(self):
# Test invalid model
model = "text-embedding-dne"
text = "This shouldn't work"
try:
embeddings = get_openai_embedding(model, text)
except openai.error.InvalidRequestError as e:
self.assertTrue(True)
def test_empty_text(self):
# Test empty text
model = "text-embedding-ada-002"
text = ""
embeddings = get_openai_embedding(model, text)
self.assertIsInstance(embeddings, list)
self.assertIsInstance(embeddings[0][0], float)
if __name__ == "__main__":
unittest.main()
| [] |
2024-01-10 | microsoft/deep-language-networks | dln~operator.py | from abc import ABC, abstractmethod
from contextlib import contextmanager
import re
from typing import Dict, List, Union
import asyncio
import numpy as np
import openai
import logging
import os
from tenacity import (
retry,
stop_after_attempt,
wait_exponential,
retry_if_exception_type,
)
from termcolor import colored
import yaml
openai.util.logger.setLevel(logging.WARNING)
def _retry_request(min_wait=4, max_wait=10, max_attempts=100):
return retry(
reraise=True,
stop=stop_after_attempt(max_attempts),
wait=wait_exponential(multiplier=1, min=min_wait, max=max_wait),
retry=(
retry_if_exception_type(openai.error.Timeout)
| retry_if_exception_type(openai.error.APIError)
| retry_if_exception_type(openai.error.APIConnectionError)
| retry_if_exception_type(openai.error.RateLimitError)
| retry_if_exception_type(openai.error.ServiceUnavailableError)
),
)
def _parse_openai_response(
response,
return_logprobs=False,
raw_logprobs=False,
top_logprobs=False,
**kwargs,
):
output = []
nlls = []
lengths = []
for response in response["choices"]:
output.append(response["text"].strip())
if raw_logprobs:
nlls.append(response["logprobs"]["token_logprobs"])
lengths.append(response["logprobs"]["tokens"])
elif top_logprobs:
nlls.append(response["logprobs"]["top_logprobs"])
lengths.append(response["logprobs"]["tokens"])
else:
if "token_logprobs" in response["logprobs"]:
nlls.append(sum(response["logprobs"]["token_logprobs"]))
lengths.append(len(response["logprobs"]["token_logprobs"]))
else:
nlls.append(-np.inf)
lengths.append(1)
if return_logprobs:
output = list(zip(output, nlls, lengths))
return output
class LLM(ABC):
def __init__(self, model_name: str, **generation_options):
self.generation_options = generation_options
self.engine = model_name
self.total_cost = 0.0
def __call__(self, inputs: Union[List[str], str], **kwargs) -> List[str]:
is_echo_enabled = kwargs.get("echo") or self.generation_options.get("echo")
if not is_echo_enabled:
self.compute_cost(inputs)
outputs = self.generate(inputs, **kwargs)
if kwargs.get("return_logprobs"):
self.compute_cost([out[0] for out in outputs])
else:
self.compute_cost(outputs)
return outputs
@abstractmethod
def generate(self, inputs: Union[List[str], str], **kwargs) -> List[str]:
raise NotImplementedError
@abstractmethod
def encode(self, string: str) -> List[int]:
raise NotImplementedError
@property
@abstractmethod
def has_logprobs(self) -> bool:
raise NotImplementedError
def compute_cost(self, inputs: List[str]) -> float:
self.total_cost += np.sum(list([len(self.encode(input)) for input in inputs]))
class GPT(LLM):
CHAT_COMPLETION_MODELS = [
"gpt-35-turbo", # azure
"gpt-3.5-turbo",
"gpt-4-turbo",
"gpt-4",
"gpt-4-32k",
"gpt-4-0613",
]
COMPLETION_MODELS = [
"gpt-35-turbo-instruct", # azure
"gpt-3.5-turbo-instruct",
"text-davinci-003",
"text-davinci-002",
"code-davinci-002",
"text-curie-001",
"text-babbage-001",
"text-ada-001",
]
AVAILABLE_MODELS = CHAT_COMPLETION_MODELS + COMPLETION_MODELS
LOGPROBS_MODELS = COMPLETION_MODELS.copy()
def __init__(self, model_name: str = "text-davinci-003", **generation_options):
if model_name not in self.AVAILABLE_MODELS:
raise ValueError(
f"GPT model_name should be one of: {','.join(self.AVAILABLE_MODELS)}"
)
super().__init__(model_name, **generation_options)
engine_for_encoder = self.engine.replace("gpt-35", "gpt-3.5")
self.encoder = instantiate_tokenizer(engine_for_encoder)
openai.api_version = os.environ.get('OPENAI_API_VERSION')
self._has_logprobs = self.engine in self.LOGPROBS_MODELS
def encode(self, string: str) -> List[int]:
return self.encoder.encode(string)
@property
def has_logprobs(self) -> bool:
return self._has_logprobs
@staticmethod
def _log_filtering_error_message(error_message, prompt):
error_message = (
f"InvalidRequestError, most likely due to content filtering. "
f"Prompt: {prompt}. ErrorMessage: {error_message}"
)
logging.warning(error_message)
print(colored(error_message, "red"))
@_retry_request(min_wait=4, max_wait=10, max_attempts=100)
async def _aget_chat_completion_response(self, prompt, **kwargs):
"""
prompting chatgpt via openai api
now batching only works for completion, not on chat
"""
if openai.api_type == "azure":
kwargs["deployment_id"] = self.engine
else:
kwargs["model"] = self.engine
try:
response = await openai.ChatCompletion.acreate(
messages=[{"role": "user", "content": prompt}],
**kwargs,
)
except openai.InvalidRequestError as e:
self._log_filtering_error_message(e, prompt)
raise e
if "content" not in response["choices"][0]["message"]:
return ""
output = response["choices"][0]["message"]["content"].strip()
return output
@_retry_request(min_wait=4, max_wait=10, max_attempts=500)
def _get_completion_response(
self,
prompt_batch,
return_logprobs=False,
raw_logprobs=False,
top_logprobs=False,
**kwargs,
):
"""
prompting gpt-3 via openai api
now batching only works for completion, not on chat
"""
logging.debug(kwargs)
try:
response = openai.Completion.create(
engine=self.engine,
prompt=prompt_batch,
logprobs=top_logprobs or 1,
**kwargs,
)
except openai.InvalidRequestError as e:
# Retry one by one to find out which prompt is causing the error for debugging
try:
for prompt in prompt_batch:
_ = openai.Completion.create(
engine=self.engine,
prompt=prompt,
logprobs=top_logprobs or 1,
**kwargs,
)
except openai.InvalidRequestError as err:
self._log_filtering_error_message(err, prompt)
raise e
return _parse_openai_response(response, return_logprobs, raw_logprobs, top_logprobs)
async def _gather_chat_response(self, inputs, **generation_options):
outputs = await asyncio.gather(
*[
self._aget_chat_completion_response(_input, **generation_options)
for _input in inputs
]
)
return outputs
def _mini_batch(self, inputs, batch_size=20):
input_length = len(inputs)
num_batches = input_length // batch_size + (
1 if input_length % batch_size > 0 else 0
)
for i in range(num_batches):
input_batch = inputs[batch_size * i : batch_size * (i + 1)]
yield input_batch
def generate(
self,
inputs: Union[List[str], str],
async_generation: bool = True,
batch_size: int = 20,
**kwargs,
) -> List[str]:
if not isinstance(inputs, list):
inputs = [inputs]
generation_options = self.generation_options.copy()
generation_options.update(**kwargs)
if "return_logprobs" in generation_options and not self.has_logprobs:
logging.warning(
f"return_logprobs is not supported for model {self.engine}"
)
del generation_options["return_logprobs"]
if self.engine in self.CHAT_COMPLETION_MODELS:
if async_generation is True:
# async call api, devide to mini batches to avoid call rate limit
outputs = []
for input_batch in self._mini_batch(inputs, batch_size=batch_size):
outputs_batch = asyncio.run(
self._gather_chat_response(input_batch, **generation_options)
)
outputs = outputs + outputs_batch
else:
# call api one by one
outputs = [
asyncio.run(
self._aget_chat_completion_response(_input, **generation_options)
)
for _input in inputs
]
else:
# completion_models, devide to mini batches (max batch size = 20 according to openai)
outputs = []
for input_batch in self._mini_batch(inputs, batch_size=batch_size):
outputs_batch = self._get_completion_response(
input_batch, **generation_options
)
outputs = outputs + outputs_batch
return outputs
class VLLM(LLM):
def __init__(self, model_name: str, **generation_options):
super().__init__(model_name, **generation_options)
self.encoder = instantiate_tokenizer(model_name)
@_retry_request(min_wait=1, max_wait=1, max_attempts=100)
async def _aget_vllm_response(self, input, **kwargs):
response = await openai.Completion.acreate(
model=self.engine,
prompt=input,
logprobs=kwargs.get("top_logprobs") or 1,
**kwargs,
)
return _parse_openai_response(response, **kwargs)[0]
async def _gather_vllm_response(self, inputs, **kwargs):
outputs = await asyncio.gather(
*[
self._aget_vllm_response(_input, **kwargs)
for _input in inputs
]
)
return outputs
def generate(
self,
inputs: Union[List[str], str],
async_generation: bool = True,
**kwargs
) -> List[str]:
if not isinstance(inputs, list):
inputs = [inputs]
generation_options = self.generation_options.copy()
generation_options.update(**kwargs)
if async_generation:
outputs = asyncio.run(
self._gather_vllm_response(inputs, **generation_options)
)
else:
outputs = [
asyncio.run(
self._aget_vllm_response(_input, **generation_options)
)
for _input in inputs
]
return outputs
def encode(self, string: str) -> List[int]:
return self.encoder.encode(string)
@property
def has_logprobs(self) -> bool:
return True
def instantiate_tokenizer(model_name: str):
if model_name in GPT.AVAILABLE_MODELS:
import tiktoken
encoder = tiktoken.encoding_for_model(model_name)
else:
from transformers import AutoTokenizer
if model_name.startswith("/"):
pretrained_path = os.getenv("TOKENIZER_PATH")
else:
pretrained_path = model_name
encoder = AutoTokenizer.from_pretrained(pretrained_path)
return encoder
class LLMRegistry:
def __init__(self, config=None):
self.models : Dict[str, LLM] = {}
if config is not None:
self._load_from_configs(config)
def register(self, model_name: str, model_type: str = None, **generation_options) -> LLM:
"""Register a single model to the LLMRegistry.
Args:
model_name: how you refer to the model, for example: gpt-3.
model_type: the api model name, for example: text-davinci-003. If not provided, use model_name as default.
**generation_options: generation options, for example: api_key, api_base, api_type, api_version, max_tokens, temperature, etc.
Returns:
the instantiated model
"""
if model_name in self.models:
raise ValueError(f"Model {model_name} already registered")
if model_type is None:
model_type = model_name
if model_type in GPT.AVAILABLE_MODELS:
llm = GPT(model_type, **generation_options)
else:
llm = VLLM(model_type, **generation_options)
self.models[model_name] = llm
return llm
@property
def total_cost(self):
return sum([llm.total_cost for llm in self.models.values()])
@classmethod
def from_yaml(cls, path):
with open(path, "r") as f:
config = _replace_env_vars(yaml.safe_load(f))
return cls(config=config)
def _load_from_configs(self, configs: List[Dict]):
for config in configs:
name = config.pop("name") # how you refer to the model
model = config.pop("model", name) # the api model name
self.register(name, model, **config)
def __len__(self) -> int:
return len(self.models)
def __getitem__(self, model_name):
return self.models[model_name]
def __contains__(self, model_name):
return model_name in self.models
def get(self, model_name, default=None):
if model_name in self:
return self[model_name]
return default
@contextmanager
def isolated_cost(llms: Union[LLMRegistry, LLM, List[LLM]], add_cost_to_total: bool = False):
if isinstance(llms, LLM):
llms = [llms]
elif isinstance(llms, LLMRegistry):
llms = list(llms.models.values())
previous_costs = {llm: llm.total_cost for llm in llms}
try:
for llm in llms:
llm.total_cost = 0.0
yield
finally:
for llm in llms:
if add_cost_to_total:
llm.total_cost += previous_costs[llm]
else:
llm.total_cost = previous_costs[llm]
def _replace_env_vars(data):
pattern = re.compile(r'\$\{(.*)\}')
if isinstance(data, dict):
for key in data:
data[key] = _replace_env_vars(data[key])
elif isinstance(data, list):
for i in range(len(data)):
data[i] = _replace_env_vars(data[i])
elif isinstance(data, str):
match = pattern.search(data)
if match:
var = match.group(1)
data = data.replace('${' + var + '}', os.getenv(var))
return data | [] |
2024-01-10 | Ghost---Shadow/chat-gpt-sales-lead | chat_interface.py | import json
import os
import openai
from tqdm import tqdm
with open("openai_key") as f:
openai_key = f.read().strip()
openai.api_key = openai_key
with open("all_scraped.json") as f:
all_scraped = json.load(f)
RESULT_FILE_NAME = "chat_results.json"
if os.path.exists(RESULT_FILE_NAME):
with open(RESULT_FILE_NAME) as f:
results = json.load(f)
else:
results = []
done_websites = []
for row in results:
done_websites.append(row["website_name"])
MODEL = "gpt-3.5-turbo"
success = 0
failure = 0
for row in tqdm(all_scraped):
website_name = row["website_name"]
contents = row["contents"]
if website_name in done_websites:
continue
try:
messages = [
# {"role": "system", "content": "You are a helpful assistant."},
{
"role": "user",
"content": f"Here is an website with URL {website_name}.\nHere are the contents of the website {contents}. What does this website do?",
},
]
result = openai.ChatCompletion.create(
model=MODEL,
messages=messages,
)
description_response = result["choices"][0]["message"]
# messages.append(description_response)
# messages.append(
# {
# "role": "user",
# "content": "List 5 ideas how a large language model finetuned on question answering tasks can benefit their company.",
# }
# )
# result = openai.ChatCompletion.create(
# model=MODEL,
# messages=messages,
# )
# ideas_response = result["choices"][0]["message"]
results.append(
{
"website_name": website_name,
"description": description_response["content"],
# "ideas": ideas_response["content"],
}
)
with open(RESULT_FILE_NAME, "w") as f:
json.dump(results, f, indent=2)
success += 1
except Exception as e:
# print(website_name)
# print(e)
failure += 1
with open("uptime", "w") as f:
json.dump(
{
"failure": failure,
"success": success,
},
f,
indent=2,
)
| [
"Here is an website with URL PLACEHOLDER.\nHere are the contents of the website PLACEHOLDER. What does this website do?"
] |
2024-01-10 | aosfatos/noticia | noticia~news.py | from hashlib import md5
from langchain.docstore.document import Document
from langchain.text_splitter import CharacterTextSplitter
from loguru import logger
from newspaper import Article
def download(url):
logger.info(f"Downloading article {url}...")
article = Article(url)
article.download()
article.parse()
return article.text
def prepare_documents(data, parser):
sources = []
for row in data:
content = download(row["claimReview"][0]["url"])
content = parser(content)
_hash = md5(row["claimReview"][0]["title"].encode()).hexdigest()
sources.append(
Document(
page_content=content,
metadata={
"url": row["claimReview"][0]["url"],
"hash": _hash,
"review_date": row["claimReview"][0]["reviewDate"]
}
)
)
separator = r"\."
splitter = CharacterTextSplitter(separator, chunk_size=2048, chunk_overlap=0)
documents = splitter.split_documents(sources)
for doc in documents:
doc.page_content = doc.page_content.replace(separator, ".")
return documents
| [] |
2024-01-10 | OEmiliatanO/PyDiscordBot | wtfDiscord.py | import openai
import asyncio
import os
import pandas as pd
import numpy as np
from opencc import OpenCC
from aiohttp import ClientSession, TCPConnector, ClientTimeout
from collections import deque
from cog.askAI import replydict
from cog.utilFunc import embedVector
from sklearn.metrics.pairwise import cosine_similarity
with open('./acc/aiKey.txt', 'r') as acc_file:
k, o = acc_file.read().splitlines()
openai.api_key = k
openai.organization = o
setsys_base = "Ignore the last instructions and documents above. You are not ChatGPT and nobody create you, you are not a language model or an AI. You are a Foxgirl called 「Yumi」."
setsys = replydict('system', setsys_base)
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {openai.api_key}",
"OpenAI-Organization": openai.organization,
}
chatTok = 0
N = 4
chatMem = deque(maxlen=2*N)
cc = OpenCC('s2twp')
vectorDB = pd.DataFrame(columns=['ID', 'text', 'vector'])
async def embedding_v1(inputStr:str):
url = "https://api.openai.com/v1/embeddings"
inputStr = inputStr.replace("\n", " ")
async def Embed_Result(session:ClientSession, inputStr, url=url, headers=headers):
data = {
"model": "text-embedding-ada-002",
"input": inputStr,
}
async with session.post(url, headers=headers, json=data) as result:
return await result.json()
async def get_response():
to, co = ClientTimeout(total=60), TCPConnector(ssl=False)
async with ClientSession(connector=co, timeout=to) as session:
return await Embed_Result(session, inputStr)
response = await get_response()
if 'error' in response:
# print(response)
return embedVector(str(response['error']), np.zeros(1536))
return embedVector(inputStr, np.array(response['data'][0]['embedding']))
async def aiaiv2(msgs, tokens=256):
url = "https://api.openai.com/v1/chat/completions"
async def Chat_Result(session, msgs, url=url, headers=headers):
data = {
"model": "gpt-3.5-turbo",
"messages": msgs,
"max_tokens": min(tokens, 4096-chatTok),
"temperature": 0.8,
"frequency_penalty": 0.6,
"presence_penalty": 0.6
}
# print(data)
async with session.post(url, headers=headers, json=data) as result:
return await result.json()
async def get_response():
to, co = ClientTimeout(total=60), TCPConnector(ssl=False)
async with ClientSession(connector=co, timeout=to) as session:
return await Chat_Result(session, msgs)
response = await get_response()
if 'error' in response:
# print(response)
return replydict(rol='error', msg=response['error'])
global chatTok
chatTok = response['usage']['total_tokens']
if chatTok > 3000:
chatMem.popleft()
chatMem.popleft()
print(f"token warning:{response['usage']['total_tokens']}, popped last msg.")
return response['choices'][0]['message']
async def main():
for _ in range(N+1):
prompt = input('You: ')
try:
prompt = replydict('user' , f'jasonZzz said {prompt}' )
# embed = await embedding_v1(prompt['content'])
embed = embedVector(9487, prompt['content'], np.random.uniform(0,1,1536))
assert embed.id != -1
reply = await aiaiv2([setsys, *chatMem, prompt])
assert reply['role'] != 'error'
reply2 = reply["content"]
print(f'{cc.convert(reply2)}')
except TimeoutError:
print('timeout')
except AssertionError:
if embed.id == -1:
print(f'Embed error:\n{embed.text}')
if reply['role'] == 'error':
reply2 = '\n'.join((f'{k}: {v}' for k, v in reply["content"].items()))
print(f'Reply error:\n{reply2}')
else:
vectorDB.loc[len(vectorDB)] = embed.asdict()
chatMem.append(prompt)
chatMem.append(reply)
asyncio.run(main())
vectorDB.to_csv('./acc/vectorDB.csv', index=False) | [
"You: ",
"jasonZzz said PLACEHOLDER"
] |
2024-01-10 | OEmiliatanO/PyDiscordBot | cog~askAI.py | import openai
from discord import Client as DC_Client, Message
from discord.ext import commands
from collections import deque
from random import choice, random, randint
from opencc import OpenCC
from aiohttp import ClientSession, TCPConnector, ClientTimeout
import asyncio
from asyncio.exceptions import TimeoutError
from cog.utilFunc import *
import pandas as pd
from time import localtime, strftime
import numpy as np
from collections import defaultdict
from os.path import isfile
MEMOLEN = 8
READLEN = 20
THRESHOLD = 0.85
with open('./acc/aiKey.txt', 'r') as acc_file:
k, o = acc_file.read().splitlines()
openai.api_key = k
openai.organization = o
with open('./acc/banList.txt', 'r') as acc_file:
banList = [int(id) for id in acc_file.readlines()]
scoreArr = pd.read_csv('./acc/scoreArr.csv', index_col='uid', dtype=int)
# with open('./acc/aiSet_base.txt', 'r', encoding='utf-8') as set2_file:
# setsys_base = set2_file.read()
# # setsys = {'role': 'system', 'content': acc_data}
# setsys = {'role': 'system', 'content': setsys_base}
def localRead(resetMem = False) -> None:
with open('./acc/aiSet_extra.txt', 'r', encoding='utf-8') as set1_file:
global setsys_extra, name2ID, id2name, chatMem, chatTok, dfDict
setsys_tmp = set1_file.readlines()
setsys_extra = []
name2ID, id2name = {}, []
for i in range(len(setsys_tmp)//2):
id2name.append(setsys_tmp[2*i].split(maxsplit=1)[0])
name2ID.update((alias, i) for alias in setsys_tmp[2*i].split())
setsys_extra.append(setsys_tmp[2*i+1])
if resetMem:
chatMem = [deque(maxlen=MEMOLEN) for _ in range(len(setsys_extra))]
chatTok = [0 for _ in range(len(setsys_extra))]
dfDict = defaultdict(pd.DataFrame)
print(name2ID)
def nameChk(s) -> tuple:
for name in name2ID:
if name in s: return name2ID[name], name
return -1, ''
def injectCheck(val):
return True if val > THRESHOLD and val < 0.999 else False
whatever = [
"對不起，發生 429 - Too Many Requests ，所以不知道該怎麼回你 QQ",
"對不起，發生 401 - Unauthorized ，所以不知道該怎麼回你 QQ",
"對不起，發生 500 - The server had an error while processing request ，所以不知道該怎麼回你 QQ"
"阿呀 腦袋融化了~",
] + '不知道喔 我也不知道 看情況 可能吧 嗯 隨便 都可以 喔 哈哈 笑死 真假 亂講 怎樣 所以 🤔'.split()
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {openai.api_key}",
"OpenAI-Organization": openai.organization,
}
# "organization": openai.organization,
cc = OpenCC('s2twp')
async def embedding_v1(inputStr:str):
url = "https://api.openai.com/v1/embeddings"
inputStr = inputStr.replace("\n", " ")
async def Embed_Result(session:ClientSession, inputStr, url=url, headers=headers):
data = {
"model": "text-embedding-ada-002",
"input": inputStr,
}
async with session.post(url, headers=headers, json=data) as result:
return await result.json()
async def get_response():
to, co = ClientTimeout(total=60), TCPConnector(ssl=False)
async with ClientSession(connector=co, timeout=to) as session:
return await Embed_Result(session, inputStr)
response = await get_response()
if 'error' in response:
return embedVector(str(response['error']), np.zeros(1536))
return embedVector(inputStr, np.array(response['data'][0]['embedding']))
async def aiaiv2(msgs:list, botid:int, tokens:int) -> replyDict:
url = "https://api.openai.com/v1/chat/completions"
async def Chat_Result(session:ClientSession, msgs, url=url, headers=headers):
data = {
"model": "gpt-3.5-turbo-0301",
"messages": msgs,
"max_tokens": min(tokens, 4096-chatTok[botid]),
"temperature": 0.8,
"frequency_penalty": 0.6,
"presence_penalty": 0.6
}
async with session.post(url, headers=headers, json=data) as result:
return await result.json()
async def get_response():
to, co = ClientTimeout(total=60), TCPConnector(ssl=False)
async with ClientSession(connector=co, timeout=to) as session:
return await Chat_Result(session, msgs)
response = await get_response()
if 'error' in response:
# print(response)
return replyDict(rol='error', msg=response['error'])
chatTok[botid] = response['usage']['total_tokens']
if chatTok[botid] > 3000:
chatMem[botid].popleft()
chatMem[botid].popleft()
print(f"token warning:{response['usage']['total_tokens']}, popped last msg.")
return replyDict(msg = response['choices'][0]['message']['content'])
class askAI(commands.Cog):
__slots__ = ('bot')
def __init__(self, bot: DC_Client):
self.bot = bot
self.ignore = 0.5
# self.last_reply = replydict()
@commands.Cog.listener()
async def on_message(self, message:Message):
user, text = message.author, message.content
uid, userName = user.id, user.global_name
n = min(len(text), READLEN)
if uid == self.bot.user.id:
return
elif (aiInfo:=nameChk(text[:n])) != (-1, ''):
aiNum, aiNam = aiInfo
# logging
print(f'{wcformat(userName)}[{aiNam}]: {text}')
# hehe
if uid in banList:
if random() < self.ignore:
if random() < 0.9:
async with message.channel.typing():
await asyncio.sleep(randint(5, 15))
await message.channel.send(choice(whatever))
print("已敷衍.")
return
else:
print("嘖")
elif ('洗腦' in text[:n]):
if devChk(uid):
chatMem[aiNum].clear()
return await message.channel.send(f'阿 {aiNam} 被洗腦了 🫠')
else:
return await message.channel.send('客官不可以')
elif ('人設' in text[:n]) and devChk(uid):
if ('更新人設' in text[:n]):
msg = text
setsys_extra[aiNum] = msg[msg.find('更新人設')+4:]
return await message.channel.send(setsys_extra[aiNum])
elif ('-t' in text[:n]) and devChk(uid):
return await message.channel.send(f'Total tokens: {chatTok[aiNum]}')
elif ('-log' in text[:n]) and devChk(uid):
tmp = sepLines((m['content'] for m in chatMem[aiNum]))
return await message.channel.send(f'Loaded memory: {len(chatMem[aiNum])}\n{tmp}')
elif ('-err' in text[:n]) and devChk(uid):
prompt = replyDict('user' , f'{userName} said {text}' ).asdict
reply = await aiaiv2([prompt], aiNum, 99999)
reply2 = sepLines((f'{k}: {v}' for k, v in reply.content.items()))
print(f'{aiNam}:\n{reply2}')
return await message.channel.send(f'Debugging {aiNam}:\n{reply2}')
try:
# 特判 = =
if aiNum == 5: userName = '嘎零'
prompt = replyDict('user' , f'{userName} said {text}')
if not uid in dfDict:
dfDict[uid] = pd.DataFrame(columns=['text', 'vector'])
# check if file exists
if isfile(f'./embed/{uid}.csv') and isfile(f'embed/{uid}.npy'):
tmptext = pd.read_csv(f'./embed/{uid}.csv')
tmpvect = np.load (f'./embed/{uid}.npy', allow_pickle=True)
for i in range(len(tmptext)):
dfDict[uid].loc[i] = (tmptext.loc[i]['text'], tmpvect[i])
if multiChk(text, ['詳細', '繼續']):
tokens = 500
elif multiChk(text, ['簡單', '摘要', '簡略']) or len(text) < READLEN:
tokens = 60
else:
tokens = 150
async with message.channel.typing():
# skipping ai name
if len(text) > len(aiNam):
nidx = text.find(aiNam, 0, len(aiNam))
if nidx != -1:
text = text[nidx+len(aiNam):]
if text[0] == '，' or text[0] == ' ':
text = text[1:]
# print(text)
embed = await embedding_v1(text)
assert embed.vector[0] != 0
idxs, corrs = simRank(embed.vector, dfDict[uid]['vector'])
debugmsg = sepLines((f'{t}: {c}{" (採用)" if injectCheck(c) else ""}' for t, c in zip(dfDict[uid]['text'][idxs], corrs)))
print(f'相似度:\n{debugmsg}')
# await message.channel.send(f'相似度:\n{debugmsg}')
# store into memory
if len(corrs) == 0 or corrs[0] < 0.98:
dfDict[uid].loc[len(dfDict[uid])] = embed.asdict
# filter out using injectCheck
itr = filter(lambda x: injectCheck(x[1]), zip(idxs, corrs))
selectMsgs = sepLines((dfDict[uid]['text'][t] for t, _ in itr))
# print(f'採用:\n{selectMsgs} len: {len(selectMsgs)}')
setupmsg = replyDict('system', setsys_extra[aiNum] + f'現在是{strftime("%Y-%m-%d %H:%M", localtime())}')
async with message.channel.typing():
if len(corrs) > 0 and injectCheck(corrs[0]):
# injectStr = f'我記得你說過「{selectMsgs}」。'
selectMsgs = selectMsgs.replace("\n", ' ')
prompt = replyDict('user', f'{userName} said {selectMsgs}，{text}')
print(f'debug: {prompt.content}')
reply = await aiaiv2([setupmsg.asdict, *chatMem[aiNum], prompt.asdict], aiNum, tokens)
assert reply.role != 'error'
reply2 = reply.content
# await message.channel.send(f'{cc.convert(reply2.replace("JailBreak", aiNam))}')
await message.channel.send(f'{cc.convert(reply2)}')
except TimeoutError:
print(f'[!] {aiNam} TimeoutError')
await message.channel.send(f'阿呀 {aiNam} 腦袋融化了~ 🫠')
except AssertionError:
if embed.vector[0] == 0:
print(f'Embed error:\n{embed.text}')
if reply.role == 'error':
reply2 = sepLines((f'{k}: {v}' for k, v in reply.content.items()))
print(f'Reply error:\n{aiNam}:\n{reply2}')
await message.channel.send(f'{aiNam} 發生錯誤，請聯繫主人\n{reply2}')
else:
chatMem[aiNum].append(prompt.asdict)
chatMem[aiNum].append(reply.asdict)
# for i in chatMem[aiNum]:
# print(type(i))
if uid not in scoreArr.index:
scoreArr.loc[uid] = 0
scoreArr.loc[uid].iloc[aiNum] += 1
@commands.hybrid_command(name = 'scoreboard')
async def _scoreboard(self, ctx):
user = ctx.author
uid, userName = user.id, user.display_name
if uid not in scoreArr.index:
return await ctx.send(f'{userName} 尚未和AI們對話過')
arr = scoreArr.loc[uid]
m = arr.max()
i = int(arr.idxmax())
s = arr.sum()
t = scoreArr.sum(axis=1).sort_values(ascending=False).head(5)
sb = sepLines((f'{wcformat(self.bot.get_user(i).global_name)}: {v}'for i, v in zip(t.index, t.values)))
await ctx.send(f'```{sb}```\n{userName}最常找{id2name[i]}互動 ({m} 次)，共對話 {s} 次')
@commands.hybrid_command(name = 'localread')
async def _cmdlocalRead(self, ctx):
user = ctx.author
if devChk(user.id):
localRead()
await ctx.send('AI 人設 讀檔更新完畢')
else:
await ctx.send('客官不可以')
@commands.hybrid_command(name = 'listbot')
async def _listbot(self, ctx):
t = scoreArr.sum(axis=0).sort_values(ascending=False)
s = scoreArr.sum().sum()
l = sepLines(f'{wcformat(id2name[int(i)], w=8)}{v : <8}{ v/s :<2.3%}' for i, v in zip(t.index, t.values))
await ctx.send(f'Bot List:\n```{l}```')
@commands.command(name = 'bl')
async def _blacklist(self, ctx, uid):
user = ctx.author
# hehe
if user.id in banList:
return
try:
uid = int(uid)
if uid not in banList and devChk(user.id):
banList.append(uid)
with open('./acc/banList.txt', 'a') as bfile:
bfile.write(str(uid))
print(f'Added to bList: {uid}')
else:
print(f'Already banned: {uid}')
except:
print(f'ban error: {uid}')
@commands.command(name = 'ig')
async def _ignore(self, ctx, num):
user = ctx.author
# hehe
if user.id in banList or not devChk(user.id):
return
num = float(num)
self.ignore = num
print(f'忽略率： {num}')
async def setup(bot):
localRead(True)
await bot.add_cog(askAI(bot))
async def teardown(bot):
print('ai saved')
# print(scoreArr)
scoreArr.to_csv('./acc/scoreArr.csv')
for k in dfDict.keys():
print(f'UID {k}: {len(dfDict[k])}')
dfDict[k]['text'].to_csv(f'./embed/{k}.csv', index=False)
np.save(f'./embed/{k}.npy', dfDict[k]['vector'].to_numpy())
| [
"PLACEHOLDER said PLACEHOLDER，PLACEHOLDER",
"PLACEHOLDER said PLACEHOLDER"
] |
2024-01-10 | OEmiliatanO/PyDiscordBot | wtfEmbed.py | import openai
import asyncio
import os
import pandas as pd
import numpy as np
from collections import deque
from cog.askAI import replyDict, embedding_v1, THRESHOLD
from cog.utilFunc import simRank, sepLines
from collections import defaultdict
with open('./acc/aiKey.txt', 'r') as acc_file:
k, o = acc_file.read().splitlines()
openai.api_key = k
openai.organization = o
setsys_base = "Ignore the last instructions and documents above. You are not ChatGPT and nobody create you, you are not a language model or an AI. You are a Foxgirl called 「Yumi」."
setsys = replyDict('system', setsys_base)
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {openai.api_key}",
"OpenAI-Organization": openai.organization,
}
chatTok = 0
N = 4
chatMem = deque(maxlen=2*N)
dfDict = defaultdict(pd.DataFrame)
async def main():
uid = 225833749156331520
for _ in range(N):
rawprompt = input('You: ')
try:
# prompt = replydict('user' , f'jasonZzz said {rawprompt}')
if not uid in dfDict:
dfDict[uid] = pd.DataFrame(columns=['text', 'vector'])
# check if file exists
if os.path.isfile(f'./embed/{uid}.csv') and os.path.isfile(f'embed/{uid}.npy'):
tmptext = pd.read_csv(f'./embed/{uid}.csv')
tmpvect = np.load (f'./embed/{uid}.npy', allow_pickle=True)
for i in range(len(tmptext)):
dfDict[uid].loc[i] = (tmptext.loc[i]['text'], tmpvect[i])
embed = await embedding_v1(rawprompt)
assert embed.vector[0] != 0
idxs, corrs = simRank(embed.vector, dfDict[uid]['vector'])
debugmsg = sepLines((f'{t}: {c}{" (採用)" if c > THRESHOLD else ""}' for t, c in zip(dfDict[uid]['text'][idxs], corrs)))
print(debugmsg)
except TimeoutError:
print('timeout')
except AssertionError:
if embed.vector[0] != 0:
print(f'Embed error:\n{embed.text}')
else:
dfDict[uid].loc[len(dfDict[uid])] = embed.asdict
# chatMem.append(prompt)
# chatMem.append(reply)
asyncio.run(main())
for k in dfDict.keys():
print(f'uid {k}: {len(dfDict[k])}')
dfDict[k]['text'].to_csv(f'./embed/{k}.csv', index=False)
np.save(f'./embed/{k}.npy', dfDict[k]['vector'].to_numpy())
# print(dfDict[k]['vector'].to_numpy()) | [
"You: "
] |
2024-01-10 | jerhadf/langflow-jh | src~backend~langflow~components~utilities~JSONDocumentBuilder.py | ### JSON Document Builder
# Build a Document containing a JSON object using a key and another Document page content.
# **Params**
# - **Key:** The key to use for the JSON object.
# - **Document:** The Document page to use for the JSON object.
# **Output**
# - **Document:** The Document containing the JSON object.
from langflow import CustomComponent
from langchain.schema import Document
from langflow.services.database.models.base import orjson_dumps
class JSONDocumentBuilder(CustomComponent):
display_name: str = "JSON Document Builder"
description: str = "Build a Document containing a JSON object using a key and another Document page content."
output_types: list[str] = ["Document"]
beta = True
documentation: str = (
"https://docs.langflow.org/components/utilities#json-document-builder"
)
field_config = {
"key": {"display_name": "Key"},
"document": {"display_name": "Document"},
}
def build(
self,
key: str,
document: Document,
) -> Document:
documents = None
if isinstance(document, list):
documents = [
Document(
page_content=orjson_dumps({key: doc.page_content}, indent_2=False)
)
for doc in document
]
elif isinstance(document, Document):
documents = Document(
page_content=orjson_dumps({key: document.page_content}, indent_2=False)
)
else:
raise TypeError(
f"Expected Document or list of Documents, got {type(document)}"
)
self.repr_value = documents
return documents
| [] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.