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 | gramhagen/ray | rllib~examples~env~cliff_walking_wall_env.py | import gymnasium as gym
from gymnasium import spaces
ACTION_UP = 0
ACTION_RIGHT = 1
ACTION_DOWN = 2
ACTION_LEFT = 3
class CliffWalkingWallEnv(gym.Env):
"""Modified version of the CliffWalking environment from OpenAI Gym
with walls instead of a cliff.
### Description
The board is a 4x12 matrix, with (using NumPy matrix indexing):
- [3, 0] or obs==36 as the start at bottom-left
- [3, 11] or obs==47 as the goal at bottom-right
- [3, 1..10] or obs==37...46 as the cliff at bottom-center
An episode terminates when the agent reaches the goal.
### Actions
There are 4 discrete deterministic actions:
- 0: move up
- 1: move right
- 2: move down
- 3: move left
You can also use the constants ACTION_UP, ACTION_RIGHT, ... defined above.
### Observations
There are 3x12 + 2 possible states, not including the walls. If an action
would move an agent into one of the walls, it simply stays in the same position.
### Reward
Each time step incurs -1 reward, except reaching the goal which gives +10 reward.
"""
def __init__(self, seed=42) -> None:
self.observation_space = spaces.Discrete(48)
self.action_space = spaces.Discrete(4)
self.observation_space.seed(seed)
self.action_space.seed(seed)
def reset(self, *, seed=None, options=None):
self.position = 36
return self.position, {}
def step(self, action):
x = self.position // 12
y = self.position % 12
# UP
if action == ACTION_UP:
x = max(x - 1, 0)
# RIGHT
elif action == ACTION_RIGHT:
if self.position != 36:
y = min(y + 1, 11)
# DOWN
elif action == ACTION_DOWN:
if self.position < 25 or self.position > 34:
x = min(x + 1, 3)
# LEFT
elif action == ACTION_LEFT:
if self.position != 47:
y = max(y - 1, 0)
else:
raise ValueError(f"action {action} not in {self.action_space}")
self.position = x * 12 + y
done = self.position == 47
reward = -1 if not done else 10
return self.position, reward, done, False, {}
| [] |
2024-01-10 | dianephan/ghostwriter_txt | story.py | from dotenv import load_dotenv
import os
from random import choice
import openai
from flask import Flask, request
load_dotenv()
openai.api_key = os.environ.get('OPENAI_KEY')
completion = openai.Completion()
session_prompt = """The following is a spooky story written for kids, just in time for Halloween. Everyone always talks about the old house at the end of the street, but I couldn’t believe what happened when I went inside."""
def write_story(session_story=None):
if session_story == None:
prompt_text = session_prompt
else:
prompt_text = f'{session_story}'
response = openai.Completion.create(
engine="davinci",
prompt=prompt_text,
temperature=0.7,
max_tokens=96,
top_p=1,
frequency_penalty=0,
presence_penalty=0.3,
)
story = response['choices'][0]['text']
print("Story = ", story)
return str(story)
def append_to_story(story, session_story=None):
if session_story is None:
session_story = session_prompt
return f'{session_story}{story}' | [
"PLACEHOLDER",
"The following is a spooky story written for kids, just in time for Halloween. Everyone always talks about the old house at the end of the street, but I couldn’t believe what happened when I went inside."
] |
2024-01-10 | satvik314/ai-powered-book | ai_components.py | from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
import os
from dotenv import load_dotenv
load_dotenv()
llm = ChatOpenAI(model_name = 'gpt-3.5-turbo', temperature= 0.0)
memory = ConversationBufferMemory()
llm_agent = ConversationChain(
llm = llm,
memory= memory,
)
| [] |
2024-01-10 | satvik314/ai-powered-book | content_json.py | import json
chapter = {"chapters" : [ {
"chapterId": 1,
"chapterTitle": "What are Large Language Models?",
"sections": [
{
"sectionId": 1,
"sectionTitle": "Introduction to Large Language Models",
"content": "Large language models (LLMs) are advanced artificial intelligence algorithms trained on massive amounts of data. They're based on transformer architectures and can understand and generate human language."
},
{
"sectionId": 2,
"sectionTitle": "Working of Large Language Models",
"content": "LLMs are usually provided as a service over an API or web interface. LLMs can understand multiple languages and various topics, enabling them to produce text in different styles.",
"subsections": [
{
"subsectionId": 1,
"subsectionTitle": "Architecture",
"content": "LLMs are based on the transformer model architecture, which includes multiple layers of self-attention mechanisms."
},
{
"subsectionId": 2,
"subsectionTitle": "Training",
"content": "The GPT-3 model, for example, was trained on vast amounts of text data from the internet, which helps it generate coherent and contextually-relevant responses."
}
]
},
{
"sectionId": 3,
"sectionTitle": "Applications of Large Language Models",
"content": "Large language models can be used for tasks such as text generation, summarization, translation, and sentiment analysis. They have revolutionized the field of conversational AI and have real-world applications in industries and businesses, such as support chatbots for customer engagement."
}
]
},
{
"chapterId": 2,
"chapterTitle": "Intro to Langchain",
"sections": [
{
"sectionId": 1,
"sectionTitle": "What is Langchain?",
"content": "Langchain is a powerful tool for working with large language models (LLMs) that simplifies the process of composing these pieces and provides an abstraction for building custom knowledge chatbots. It works by taking a large source of data, breaking it down into chunks, and embedding them into a Vector Store. When a prompt is inserted into the chatbot, Langchain queries the Vector Store for relevant information, which is then used in conjunction with the LLM to generate the answer."
},
{
"sectionId": 2,
"sectionTitle": "Why Do We Need Langchain?",
"content": "Langchain offers a useful approach to overcome the limitations of LLMs by preprocessing the corpus of text, breaking it down into chunks or summaries, embedding them in a vector space, and searching for similar chunks when a question is asked. This pattern of preprocessing, real-time collecting, and interaction with the LLM is common and can be used in other scenarios, such as code and semantic search. Langchain provides an abstraction that simplifies the process of composing these pieces, making it easier to work with large language models."
},
{
"sectionId": 3,
"sectionTitle": "Example: Building a Question-Answering App with Langchain",
"content": "Let's build a simple question-answering app using Langchain.",
"subsections": [
{
"subsectionId": 1,
"subsectionTitle": "Step 1: Install Langchain",
"code": "pip install langchain"
},
{
"subsectionId": 2,
"subsectionTitle": "Step 2: Import required libraries",
"code": "import langchain as lc\nfrom langchain import SimpleSequentialChain"
},
{
"subsectionId": 3,
"subsectionTitle": "Step 3: Load a large language model",
"code": "model = lc.load('gpt-3')"
},
{
"subsectionId": 4,
"subsectionTitle": "Step 4: Define a function to answer questions",
"code": "def get_answer(prompt):\n chain = SimpleSequentialChain(model)\n chain.add_prompt(prompt)\n response = chain.generate()\n return response"
},
{
"subsectionId": 5,
"subsectionTitle": "Step 5: Get answers to your questions",
"code": "question = 'What is the capital of France?'\nanswer = get_answer(question)\nprint(answer)"
}
]
}
]
}
]}
# Writing to sample.json
with open('chapters.json', 'w') as json_file:
json.dump(chapter, json_file)
| [
"Langchain offers a useful approach to overcome the limitations of LLMs by preprocessing the corpus of text, breaking it down into chunks or summaries, embedding them in a vector space, and searching for similar chunks when a question is asked. This pattern of preprocessing, real-time collecting, and interaction with the LLM is common and can be used in other scenarios, such as code and semantic search. Langchain provides an abstraction that simplifies the process of composing these pieces, making it easier to work with large language models.",
"Large language models can be used for tasks such as text generation, summarization, translation, and sentiment analysis. They have revolutionized the field of conversational AI and have real-world applications in industries and businesses, such as support chatbots for customer engagement.",
"LLMs are usually provided as a service over an API or web interface. LLMs can understand multiple languages and various topics, enabling them to produce text in different styles.",
"Langchain is a powerful tool for working with large language models (LLMs) that simplifies the process of composing these pieces and provides an abstraction for building custom knowledge chatbots. It works by taking a large source of data, breaking it down into chunks, and embedding them into a Vector Store. When a prompt is inserted into the chatbot, Langchain queries the Vector Store for relevant information, which is then used in conjunction with the LLM to generate the answer.",
"LLMs are based on the transformer model architecture, which includes multiple layers of self-attention mechanisms.",
"Large language models (LLMs) are advanced artificial intelligence algorithms trained on massive amounts of data. They're based on transformer architectures and can understand and generate human language.",
"Let's build a simple question-answering app using Langchain.",
"The GPT-3 model, for example, was trained on vast amounts of text data from the internet, which helps it generate coherent and contextually-relevant responses."
] |
2024-01-10 | satvik314/ai-powered-book | page3.py | # Contents of page2.py
import streamlit as st
def app():
st.title('Basics of Langchain')
st.header('What is Langchain?')
st.write("Langchain is a powerful tool for working with large language models (LLMs) that simplifies the process of composing these pieces and provides an abstraction for building custom knowledge chatbots. It works by taking a large source of data, breaking it down into chunks, and embedding them into a Vector Store. When a prompt is inserted into the chatbot, Langchain queries the Vector Store for relevant information, which is then used in conjunction with the LLM to generate the answer. [freecodecamp.org](https://www.freecodecamp.org/news/langchain-how-to-create-custom-knowledge-chatbots/)")
st.header('Why Do We Need Langchain?')
st.write("Langchain offers a useful approach to overcome the limitations of LLMs by preprocessing the corpus of text, breaking it down into chunks or summaries, embedding them in a vector space, and searching for similar chunks when a question is asked. This pattern of preprocessing, real-time collecting, and interaction with the LLM is common and can be used in other scenarios, such as code and semantic search. Langchain provides an abstraction that simplifies the process of composing these pieces, making it easier to work with large language models. [medium.com](https://medium.com/databutton/getting-started-with-langchain-a-powerful-tool-for-working-with-large-language-models-286419ba0842)")
st.header('Example: Building a Question-Answering App with Langchain')
st.write("Let's build a simple question-answering app using Langchain. Here's a basic example of how you can use Langchain to achieve this: [kdnuggets.com](https://www.kdnuggets.com/2023/04/langchain-101-build-gptpowered-applications.html)")
st.subheader('Step 1: Install Langchain')
st.code("pip install langchain", language="bash")
st.subheader('Step 2: Import required libraries')
st.code("""
import langchain as lc
from langchain import SimpleSequentialChain
""", language="python")
st.subheader('Step 3: Load a large language model')
st.code("""
model = lc.load("gpt-3")
""", language="python")
st.subheader('Step 4: Define a function to answer questions')
st.code("""
def get_answer(prompt):
chain = SimpleSequentialChain(model)
chain.add_prompt(prompt)
response = chain.generate()
return response
""", language="python")
st.subheader('Step 5: Get answers to your questions')
st.code("""
question = "What is the capital of France?"
answer = get_answer(question)
print(answer)
""", language="python")
st.write("In this example, we used Langchain to build a simple question-answering app. You can further explore Langchain to build more interesting applications.")
| [] |
2024-01-10 | Sum1Solutions/template_openai | app3.py | import os
import openai
from dotenv import load_dotenv
import streamlit as st
# Load variables from .env file into environment
load_dotenv()
def get_openai_api_key():
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OpenAI API key not found. Make sure it is set in the environment.")
return api_key
def make_chat_completion_request():
openai.api_key = get_openai_api_key()
chat_completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": "Hello world"}]
)
return chat_completion
def run_chat_completion():
# Make API call
chat_completion_result = make_chat_completion_request()
return chat_completion_result
# Create Streamlit app
def main():
st.title("Chat Completion")
# Run chat completion
chat_completion_result = run_chat_completion()
# Display result
st.write(chat_completion_result)
if __name__ == "__main__":
main()
| [
"Hello world"
] |
2024-01-10 | Sum1Solutions/template_openai | app2.py | # This is more like test app 2 to get this next stuff better understood.
import os
import openai
from dotenv import load_dotenv
# Load variables from .env file into environment
load_dotenv()
def get_openai_api_key():
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise ValueError("OpenAI API key not found. Make sure it is set in the environment.")
# Validate the format of the API key if needed
# Add additional validation logic if necessary
return api_key
def make_chat_completion_request(messages):
openai.api_key = get_openai_api_key()
chat_completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages
)
return chat_completion
def run_chat_completion():
messages = [{"role": "user", "content": "Hello world"}] # Initialize with a user message
termination_conditions = ["bye", "quit"] # Define termination conditions
max_response_length = 100 # Maximum number of tokens to display in a single print output
num_tokens = 0 # Initialize the variable outside the loop
while True:
user_input = input("Enter your question here ('bye' or 'quit' to end session): ")
messages.append({"role": "user", "content": user_input})
if any(condition in user_input.lower() for condition in termination_conditions):
break
# Make API call
chat_completion_result = make_chat_completion_request(messages)
# Extract assistant response and process it if needed
assistant_response = chat_completion_result["choices"][0]["message"]["content"]
# Print assistant response
print(f"Assistant:")
# Split long responses into multiple print statements
response_tokens = assistant_response.split()
num_tokens = len(response_tokens)
num_prints = (num_tokens - 1) // max_response_length + 1
for i in range(num_prints):
start = i * max_response_length
end = (i + 1) * max_response_length
print(' '.join(response_tokens[start:end]))
messages.append({"role": "assistant", "content": assistant_response})
# Ask whether to continue or quit if response is long
if num_tokens > max_response_length:
user_choice = input("There's more. Continue? (yes/no): ")
if user_choice.lower() == "no":
break
# Calculate the total cost (this is just a rough estimate, consult OpenAI's pricing for accurate costs)
total_tokens = sum(len(message["content"].split()) for message in messages if message["role"] == "assistant")
cost_per_token = 0.0000002 # Replace with the actual cost per token from OpenAI
total_cost = total_tokens * cost_per_token
# Print metadata
print(f"Total tokens: {total_tokens}")
if num_tokens:
print(f"Response length: {num_tokens} tokens")
# Print total cost
print(f"Total Cost: ${total_cost:.9f}")
if __name__ == "__main__":
run_chat_completion()
| [
"Hello world"
] |
2024-01-10 | Sum1Solutions/template_openai | app4.py | import os
import openai
from dotenv import load_dotenv
import streamlit as st
# Load environment variables from a .env file
load_dotenv()
# Set OpenAI API credentials
openai.api_key = os.getenv("OPENAI_API_KEY")
# Function to generate a response from the GPT-3.5 model
def generate_response(prompt):
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=1000,
temperature=0.7,
n=1,
stop=None,
timeout=10,
)
return response.choices[0].text.strip()
# Streamlit app
def main():
st.title("Chatbot with GPT-3.5")
# Initial prompt
initial_prompt = "How can I assist you today?"
# Text Input option
user_question = st.text_input(initial_prompt)
if st.button("Submit"):
if len(user_question) > 0:
prompt = f"{initial_prompt}\n\nQ: {user_question}\nA:"
response = generate_response(prompt)
st.markdown(f"**Response:** {response}")
# Follow-up question
follow_up_question = st.text_input("Ask another question")
if len(follow_up_question) > 0:
prompt = f"Q: {follow_up_question}\nA: {response}\n\nQ:"
response = generate_response(prompt)
st.markdown(f"**Response:** {response}")
if __name__ == "__main__":
main()
| [
"PLACEHOLDER\n\nQ: PLACEHOLDER\nA:",
"How can I assist you today?",
"Q: PLACEHOLDER\nA: PLACEHOLDER\n\nQ:"
] |
2024-01-10 | patrykbart/docs-assistant | docs_assistant.py | from os import path, listdir
from pypdf import PdfReader
from langchain.llms import HuggingFaceHub
from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain.vectorstores import FAISS
from langchain.text_splitter import CharacterTextSplitter
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
class DocsAssistant:
def __init__(self, llm_name="google/flan-t5-xxl", embed_model_name="hkunlp/instructor-xl", chunk_size=512, chunk_overlap=64):
self.llm_name = llm_name
self.embed_model_name = embed_model_name
self.splitter = CharacterTextSplitter(separator="\n", chunk_size=chunk_size, chunk_overlap=chunk_overlap, length_function=len)
self.vector_store = None
self.conv_chain = None
def embed_pdfs(self, pdfs_root_path="./pdf_pages"):
raw_text = self.load_pdfs(pdfs_root_path)
chunks = self.chunk_text(raw_text)
self.generate_vector_store(chunks)
self.generate_conversational_chain()
def load_pdfs(self, pdfs_root_path):
text = ""
pdf_files = [path.join(pdfs_root_path, f) for f in listdir(pdfs_root_path) if f.endswith(".pdf")]
for pdf_path in pdf_files:
pdf = PdfReader(pdf_path)
for page in pdf.pages:
text += page.extract_text()
return text
def chunk_text(self, text):
chunks = self.splitter.split_text(text)
return chunks
def generate_vector_store(self, chunks):
embeddings = HuggingFaceInstructEmbeddings(model_name=self.embed_model_name)
self.vector_store = FAISS.from_texts(texts=chunks, embedding=embeddings)
def generate_conversational_chain(self):
llm = HuggingFaceHub(repo_id=self.llm_name, model_kwargs={"temperature": 0.5, "max_length": 256})
self.conv_chain = ConversationalRetrievalChain.from_llm(llm=llm, retriever=self.vector_store.as_retriever())
def answer_question(self, query):
response = self.conv_chain({"question": query, "chat_history": ""})["answer"]
return response
| [] |
2024-01-10 | hijigoo/RAG-based-ai-chatbot | app~services~opensearch_service.py | import boto3
from langchain.vectorstores import OpenSearchVectorSearch
from opensearchpy import OpenSearch, RequestsHttpConnection
from requests_aws4auth import AWS4Auth
from langchain.embeddings.base import Embeddings
region = 'us-west-2'
# endpoint_url = 'https://search-doc-vector-store-d6ewfi4eflxfciyyticvh5zm5m.us-west-2.es.amazonaws.com'
endpoint_url = 'https://vpc-doc-vector-store-vpc-44f2zwlvjspbifxgg33tf74dou.us-west-2.es.amazonaws.com'
service = 'es' # must set the service as 'es'
# 권한이 있는 Task Role 을 ECS Task 에 등록 하고, OpenSearch 에 Task Role 을 맵핑해서 사용
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(
region=region,
service=service,
refreshable_credentials=credentials)
def get_opensearch_client():
return OpenSearch(
region=region,
hosts=[{'host': endpoint_url.replace("https://", ""), 'port': 443}],
http_auth=awsauth,
use_ssl=True,
verify_certs=True,
connection_class=RequestsHttpConnection
)
def check_if_index_exists(index_name: str) -> bool:
os_client = get_opensearch_client()
exists = os_client.indices.exists(index_name)
return exists
def create_index(index_name: str):
os_client = get_opensearch_client()
os_client.indices.create(index=index_name)
def delete_index(index_name: str):
os_client = get_opensearch_client()
return os_client.indices.delete(index=index_name)
def get_index_list(index_name: str):
os_client = get_opensearch_client()
return os_client.indices.get_alias(index=index_name)
def create_index_from_documents(index_name: str, embeddings: Embeddings, documents):
return OpenSearchVectorSearch.from_documents(
documents=documents,
embedding=embeddings,
opensearch_url=endpoint_url,
timeout=300,
use_ssl=True,
verify_certs=True,
connection_class=RequestsHttpConnection,
http_auth=awsauth,
index_name=index_name
)
def get_opensearch_vector_client(index_name: str, embeddings: Embeddings):
return OpenSearchVectorSearch(
opensearch_url=endpoint_url,
index_name=index_name,
embedding_function=embeddings,
is_aoss=False,
connection_class=RequestsHttpConnection,
http_auth=awsauth,
)
def get_most_similar_docs_by_query(index_name: str, embeddings: Embeddings, query: str, k: int):
osv_client = get_opensearch_vector_client(index_name, embeddings)
return osv_client.similarity_search(
query,
k=k
)
| [] |
2024-01-10 | hijigoo/RAG-based-ai-chatbot | app~services~bedrock_service.py | import boto3
import json
from langchain.llms.bedrock import Bedrock
from langchain.embeddings import BedrockEmbeddings
bedrock_region = "us-west-2"
bedrock_endpoint_url = "https://prod.us-west-2.frontend.bedrock.aws.dev"
def get_bedrock_client():
return boto3.client(
service_name='bedrock',
region_name=bedrock_region,
endpoint_url=bedrock_endpoint_url,
# aws_access_key_id=BEDROCK_ACCESS_KEY, # Task Role 을 이용 해서 접근
# aws_secret_access_key=BEDROCK_SECRET_ACCESS_KEY # Task Role 을 이용 해서 접근
)
def get_bedrock_model(model_id):
bedrock_client = get_bedrock_client()
return Bedrock(model_id=model_id, client=bedrock_client)
def get_bedrock_embeddings():
bedrock_client = get_bedrock_client()
return BedrockEmbeddings(client=bedrock_client)
def get_predict_from_bedrock_model(model_id: str, question: str):
llm = get_bedrock_model(model_id=model_id)
return llm.predict(question)
def get_predict_from_bedrock_client(model_id: str, prompt: str, parameters: dict):
bedrock_client = get_bedrock_client()
return bedrock_client.invoke_model(
body=json.dumps({"inputText": prompt, "textGenerationConfig": parameters}),
modelId=model_id, accept="application/json", contentType="application/json"
) | [] |
2024-01-10 | zhangying9128/RRM | PERSONACHAT~interact.py | # # Copyright (c) 2019-present, HuggingFace Inc.
# All rights reserved.
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
import logging
import random
from argparse import ArgumentParser
from itertools import chain
from pprint import pformat
import warnings
import torch
import torch.nn.functional as F
from pytorch_transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer, GPT2LMHeadModel, GPT2Tokenizer
from train import build_input_from_segments, add_special_tokens_
from utils import get_dataset, download_pretrained_model
def top_filtering(logits, top_k=0., top_p=0.9, threshold=-float('Inf'), filter_value=-float('Inf')):
""" Filter a distribution of logits using top-k, top-p (nucleus) and/or threshold filtering
Args:
logits: logits distribution shape (vocabulary size)
top_k: <=0: no filtering, >0: keep only top k tokens with highest probability.
top_p: <=0.0: no filtering, >0.0: keep only a subset S of candidates, where S is the smallest subset
whose total probability mass is greater than or equal to the threshold top_p.
In practice, we select the highest probability tokens whose cumulative probability mass exceeds
the threshold top_p.
threshold: a minimal threshold to keep logits
"""
assert logits.dim() == 1 # Only work for batch size 1 for now - could update but it would obfuscate a bit the code
top_k = min(top_k, logits.size(-1))
if top_k > 0:
# Remove all tokens with a probability less than the last token in the top-k tokens
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
# Compute cumulative probabilities of sorted tokens
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cumulative_probabilities = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probabilities > top_p
# Shift the indices to the right to keep also the first token above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
# Back to unsorted indices and set them to -infinity
indices_to_remove = sorted_indices[sorted_indices_to_remove]
logits[indices_to_remove] = filter_value
indices_to_remove = logits < threshold
logits[indices_to_remove] = filter_value
return logits
def sample_sequence(personality, history, tokenizer, model, args, current_output=None):
if not args.SEQ2SEQ:
SPECIAL_TOKENS = ["<bos>", "<eos>", "<speaker1>", "<speaker2>", "<pad>"]
else:
SPECIAL_TOKENS = ["<s>", "</s>", "madeupword0000", "madeupword0001", "<pad>"]
special_tokens_ids = tokenizer.convert_tokens_to_ids(SPECIAL_TOKENS)
if current_output is None:
current_output = []
token_score = None
if args.inference == "nucleus":
for i in range(args.max_length):
if not args.SEQ2SEQ:
instance = build_input_from_segments(personality, history, current_output, tokenizer, with_eos=False, SEQ2SEQ=args.SEQ2SEQ)
input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0)
token_type_ids = torch.tensor(instance["token_type_ids"], device=args.device).unsqueeze(0)
logits = model(input_ids, token_type_ids=token_type_ids)
else:
instance = build_input_from_segments(personality, history, current_output, tokenizer, SEQ2SEQ=args.SEQ2SEQ)
#seq2seq
input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0)
target_ids = torch.tensor(instance["target_ids"], device=args.device).unsqueeze(0)
input_type_ids = torch.tensor(instance["input_type_ids"], device=args.device).unsqueeze(0)
target_type_ids = torch.tensor(instance["target_type_ids"], device=args.device).unsqueeze(0)
logits = model(input_ids, input_ids!=tokenizer.convert_tokens_to_ids("<pad>"), target_ids, target_ids!=tokenizer.convert_tokens_to_ids("<pad>"),
return_dict=False,
)
if isinstance(logits, tuple): # for gpt2 and maybe others
logits = logits[0]
logits = logits[0, -1, :]
logits = logits / args.temperature
logits = top_filtering(logits, top_k=args.top_k, top_p=args.top_p)
probs = F.softmax(logits, dim=-1)
prev = torch.topk(probs, 1)[1] if args.no_sample else torch.multinomial(probs, 1)
if i < args.min_length and prev.item() in special_tokens_ids:
while prev.item() in special_tokens_ids:
if probs.max().item() == 1:
warnings.warn("Warning: model generating special token with probability 1.")
break # avoid infinitely looping over special token
prev = torch.multinomial(probs, num_samples=1)
if prev.item() in special_tokens_ids:
break
current_output.append(prev.item())
elif args.inference == "greedy":
for i in range(args.max_length):
if not args.SEQ2SEQ:
instance = build_input_from_segments(personality, history, current_output, tokenizer, with_eos=False, SEQ2SEQ=args.SEQ2SEQ)
input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0)
token_type_ids = torch.tensor(instance["token_type_ids"], device=args.device).unsqueeze(0)
logits = model(input_ids, token_type_ids=token_type_ids)
else:
instance = build_input_from_segments(personality, history, current_output, tokenizer, SEQ2SEQ=args.SEQ2SEQ)
#seq2seq
input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0)
target_ids = torch.tensor(instance["target_ids"], device=args.device).unsqueeze(0)
input_type_ids = torch.tensor(instance["input_type_ids"], device=args.device).unsqueeze(0)
target_type_ids = torch.tensor(instance["target_type_ids"], device=args.device).unsqueeze(0)
logits = model(input_ids, input_ids!=tokenizer.convert_tokens_to_ids("<pad>"), target_ids, target_ids!=tokenizer.convert_tokens_to_ids("<pad>"),
return_dict=False,
)
if isinstance(logits, tuple): # for gpt2 and maybe others
logits = logits[0]
logits = logits[0, -1, :]
probs = F.softmax(logits, dim=-1)
prev = torch.topk(probs, 1)[1]
if prev.item() in special_tokens_ids:
break
current_output.append(prev.item())
else:
""" Beam Search using the encoder inputs contained in `batch`.
"""
beam_size = args.beam_size
device = args.device
batch_size = args.batchsize
# Tile states and memory beam_size times.
if not args.SEQ2SEQ:
instance = build_input_from_segments(personality, history, current_output, tokenizer, with_eos=False, SEQ2SEQ=args.SEQ2SEQ)
input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0) #bsz * seq_len
token_type_ids = torch.tensor(instance["token_type_ids"], device=args.device).unsqueeze(0) #bsz * seq_len
input_ids = input_ids.expand(batch_size * beam_size, -1).to(args.device)
token_type_ids = token_type_ids.expand(batch_size * beam_size, -1).to(args.device)
else:
instance = build_input_from_segments(personality, history, current_output, tokenizer, SEQ2SEQ=args.SEQ2SEQ)
#seq2seq
input_ids = torch.tensor(instance["input_ids"], device=args.device).unsqueeze(0) #bsz * seq_len
target_ids = torch.tensor(instance["target_ids"], device=args.device).unsqueeze(0) #bsz * seq_len
input_type_ids = torch.tensor(instance["input_type_ids"], device=args.device).unsqueeze(0) #bsz * seq_len
target_type_ids = torch.tensor(instance["target_type_ids"], device=args.device).unsqueeze(0) #bsz * seq_len
input_ids = input_ids.expand(batch_size * beam_size, -1).to(args.device)
target_ids = target_ids.expand(batch_size * beam_size, -1).to(args.device)
input_type_ids = input_type_ids.expand(batch_size * beam_size, -1).to(args.device)
target_type_ids = target_type_ids.expand(batch_size * beam_size, -1).to(args.device)
current_output = [current_output * beam_size]
batch_offset = torch.arange(batch_size, dtype=torch.long, device=device)
beam_offset = torch.arange(
0, batch_size * beam_size, step=beam_size, dtype=torch.long, device=device
)
alive_seq = torch.full(
[batch_size * beam_size, 1], special_tokens_ids[0], dtype=torch.long, device=device
)
alive_score = torch.full(
[batch_size * beam_size, 1], 0, dtype=torch.long, device=device
)
# Give full probability to the first beam on the first step.
topk_log_probs = torch.tensor(
[0.0] + [float("-inf")] * (beam_size - 1), device=device
).repeat(batch_size)
# Structure that holds finished hypotheses.
hypotheses = [[] for _ in range(batch_size)] # noqa: F812
results = {}
results["predictions"] = [[] for _ in range(batch_size)] # noqa: F812
results["scores"] = [[] for _ in range(batch_size)] # noqa: F812
for step in range(args.max_length):
# Generator forward.
if not args.SEQ2SEQ:
score = model(input_ids, token_type_ids=token_type_ids)
else:
#seq2seq
score = model(input_ids, input_ids!=tokenizer.convert_tokens_to_ids("<pad>"), target_ids, target_ids!=tokenizer.convert_tokens_to_ids("<pad>"),
return_dict=False,
)
if isinstance(score, tuple): # for gpt2 and maybe others
score = score[0]
score = score[:, -1, :]
score = score.view(batch_size, beam_size, -1)
for j, logit in enumerate(score):
logit = logit[0] / args.temperature
score[j][0] = top_filtering(logit, top_k=args.top_k, top_p=args.top_p)
log_probs = F.log_softmax(score, dim=-1).view(batch_size * beam_size, -1)
vocab_size = log_probs.size(-1)
if step < args.min_length:
for s in special_tokens_ids:
log_probs[:, s] = -1e20
# Multiply probs by the beam probability.
log_probs += topk_log_probs.view(-1).unsqueeze(1)
alpha = args.alpha
length_penalty = ((5.0 + (step + 1)) / 6.0) ** alpha
# Flatten probs into a list of possibilities.
curr_scores = log_probs / length_penalty
if args.block_trigram:
cur_len = alive_seq.size(1)
if cur_len > 3:
for i in range(alive_seq.size(0)):
fail = False
words = [int(w) for w in alive_seq[i]]
words = tokenizer.decode(words, skip_special_tokens=True,
clean_up_tokenization_spaces=(args.eval_type != 'f1'))
if len(words) <= 3:
continue
trigrams = [
(words[i - 1], words[i], words[i + 1])
for i in range(1, len(words) - 1)
]
trigram = tuple(trigrams[-1])
if trigram in trigrams[:-1]:
fail = True
if fail:
curr_scores[i] = -10e20
curr_scores = curr_scores.reshape(-1, beam_size * vocab_size)
topk_scores, topk_ids = curr_scores.topk(beam_size, dim=-1)
# Recover log probs.
topk_log_probs = topk_scores * length_penalty
# Resolve beam origin and true word ids.
topk_beam_index = topk_ids.div(vocab_size, rounding_mode='trunc')
topk_ids = topk_ids.fmod(vocab_size)
# Map beam_index to batch_index in the flat representation.
batch_index = topk_beam_index + beam_offset[
: topk_beam_index.size(0)
].unsqueeze(1)
select_indices = batch_index.view(-1)
# Append last prediction.
alive_seq = torch.cat(
[alive_seq.index_select(0, select_indices), topk_ids.view(-1, 1)], -1
)
is_finished = topk_ids.eq(special_tokens_ids[1])
if step + 1 == args.max_length:
is_finished.fill_(1)
# End condition is top beam is finished.
end_condition = is_finished[:, 0].eq(1)
# Save finished hypotheses.
if is_finished.any():
predictions = alive_seq.view(-1, beam_size, alive_seq.size(-1))
for i in range(is_finished.size(0)):
b = batch_offset[i]
if end_condition[i]:
is_finished[i].fill_(1)
finished_hyp = is_finished[i].nonzero().view(-1)
# Store finished hypotheses for this batch.
for j in finished_hyp:
hypotheses[b].append((topk_scores[i, j], predictions[i, j, 1:]))
# If the batch reached the end, save the n_best hypotheses.
if end_condition[i]:
best_hyp = sorted(hypotheses[b], key=lambda x: x[0], reverse=True)
score, pred = best_hyp[0]
results["scores"][b].append(score)
results["predictions"][b].append(pred)
non_finished = end_condition.eq(0).nonzero().view(-1)
# If all sentences are translated, no need to go further.
if len(non_finished) == 0:
break
# Remove finished batches for the next step.
topk_log_probs = topk_log_probs.index_select(0, non_finished)
batch_index = batch_index.index_select(0, non_finished)
batch_offset = batch_offset.index_select(0, non_finished)
alive_seq = predictions.index_select(0, non_finished).view(
-1, alive_seq.size(-1)
)
# Reorder states.
#current_output = [pred.tolist() for pred in preds]
current_output =[cand[1:].tolist() for cand in alive_seq]
if step != args.max_length - 1:
if not args.SEQ2SEQ:
input_ids = []
token_type_ids = []
for c in current_output:
instance = build_input_from_segments(personality, history, c, tokenizer, with_eos=False, SEQ2SEQ=args.SEQ2SEQ)
input_ids.append(instance["input_ids"])
token_type_ids.append(instance["token_type_ids"])
input_ids = torch.tensor(input_ids, device=args.device)#.unsqueeze(0)
token_type_ids = torch.tensor(token_type_ids, device=args.device)#.unsqueeze(0)
else:
input_ids = []
target_ids = []
for c in current_output:
instance = build_input_from_segments(personality, history, c, tokenizer, SEQ2SEQ=args.SEQ2SEQ)
input_ids.append(instance["input_ids"])
target_ids.append(instance["target_ids"])
input_ids = torch.tensor(input_ids, device=args.device)#.unsqueeze(0)
target_ids = torch.tensor(target_ids, device=args.device)#.unsqueeze(0)
current_output = results["predictions"][0][0].tolist()[:-1]
return current_output
def run():
parser = ArgumentParser()
parser.add_argument("--dataset_path", type=str, default="", help="Path or url of the dataset. If empty download from S3.")
parser.add_argument("--dataset_cache", type=str, default='./dataset_cache', help="Path or url of the dataset cache")
parser.add_argument("--model", type=str, default="openai-gpt", help="Model type (openai-gpt or gpt2)", choices=['openai-gpt', 'gpt2']) # anything besides gpt2 will load openai-gpt
parser.add_argument("--model_checkpoint", type=str, default="", help="Path, url or short name of the model")
parser.add_argument("--max_history", type=int, default=2, help="Number of previous utterances to keep in history")
parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", help="Device (cuda or cpu)")
parser.add_argument("--no_sample", action='store_true', help="Set to use greedy decoding instead of sampling")
parser.add_argument("--max_length", type=int, default=20, help="Maximum length of the output utterances")
parser.add_argument("--min_length", type=int, default=1, help="Minimum length of the output utterances")
parser.add_argument("--seed", type=int, default=0, help="Seed")
parser.add_argument("--temperature", type=int, default=0.7, help="Sampling softmax temperature")
parser.add_argument("--top_k", type=int, default=0, help="Filter top-k tokens before sampling (<=0: no filtering)")
parser.add_argument("--top_p", type=float, default=0.9, help="Nucleus filtering (top-p) before sampling (<=0.0: no filtering)")
#zhangying
parser.add_argument("--SEQ2SEQ", action='store_true')
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__file__)
logger.info(pformat(args))
if args.model_checkpoint == "":
if args.model == 'gpt2':
raise ValueError("Interacting with GPT2 requires passing a finetuned model_checkpoint")
else:
args.model_checkpoint = download_pretrained_model()
if args.seed != 0:
random.seed(args.seed)
torch.random.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
logger.info("Get pretrained model and tokenizer")
tokenizer_class, model_class = (GPT2Tokenizer, GPT2LMHeadModel) if args.model == 'gpt2' else (OpenAIGPTTokenizer, OpenAIGPTLMHeadModel)
tokenizer = tokenizer_class.from_pretrained(args.model_checkpoint)
model = model_class.from_pretrained(args.model_checkpoint)
model.to(args.device)
add_special_tokens_(model, tokenizer)
logger.info("Sample a personality")
dataset = get_dataset(tokenizer, args.dataset_path, args.dataset_cache)
personalities = [dialog["personality"] for dataset in dataset.values() for dialog in dataset]
personality = random.choice(personalities)
logger.info("Selected personality: %s", tokenizer.decode(chain(*personality)))
history = []
while True:
raw_text = input(">>> ")
while not raw_text:
print('Prompt should not be empty!')
raw_text = input(">>> ")
history.append(tokenizer.encode(raw_text))
with torch.no_grad():
out_ids = sample_sequence(personality, history, tokenizer, model, args)
history.append(out_ids)
history = history[-(2*args.max_history+1):]
out_text = tokenizer.decode(out_ids, skip_special_tokens=True)
print(out_text)
if __name__ == "__main__":
run()
| [] |
2024-01-10 | sarahovakeemian/movie-recommender-chatbot | 01-DATA-PREP.py | # Databricks notebook source
# MAGIC %md
# MAGIC
# MAGIC # 01 DATA PREPARATION
# MAGIC
# MAGIC In this notebook we will be preparing our data.
# MAGIC
# MAGIC Before running this code, you will need to download the [CMU Movie Dataset](http://www.cs.cmu.edu/~ark/personas/) and store the files in a Databricks Volume.
# COMMAND ----------
# MAGIC %run ./resources/variables
# COMMAND ----------
import huggingface_hub
hf_token = dbutils.secrets.get(f"{secrets_scope}", f"{secrets_hf_key_name}")
from huggingface_hub import login
login(token=hf_token)
# COMMAND ----------
from pyspark.sql import functions as F
from pyspark.sql import types as T
from databricks.sdk.runtime import *
from langchain.text_splitter import TokenTextSplitter
from typing import Iterator
import pandas as pd
from pyspark.sql.functions import rand,when
from transformers import LlamaTokenizer
from typing import Iterator, List, Dict
import pandas as pd
from random import randint
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## 1. BRONZE DATA LAYER
# MAGIC
# MAGIC
# MAGIC We will be ingesting the files movie.metadata.tsv and plot_summaries.txt
# COMMAND ----------
#function to read movie.metadata.tsv
def ms_movie_metadata_bronze(volume_path):
return (
spark.read.format("csv")
.option("delimiter", "\t")
.option("inferSchema", "true")
.option("header", "false")
.load(f"{volume_path}/movie.metadata.tsv")
.toDF(
"wikipedia_movie_id",
"freebase_movie_id",
"movie_name",
"movie_release_date",
"movie_box_office_revenue",
"movie_runtime",
"movie_languages",
"movie_countries",
"movie_genres"))
# COMMAND ----------
#function to read plot_summaries.txt
def ms_plot_summaries_bronze(volume_path):
return (
spark.read.format("csv")
.option("delimiter", "\t")
.option("inferSchema", "true")
.option("header", "false")
.load(f"{volume_path}/plot_summaries.txt")
.toDF(
"wikipedia_movie_id",
"plot_summary"))
# COMMAND ----------
#write movie metadata to delta table
df = ms_movie_metadata_bronze(volume_path)
df.write.mode("overwrite").saveAsTable(f"{catalog}.{schema}.ms_movie_metadata_bronze")
display(spark.table(f"{catalog}.{schema}.ms_movie_metadata_bronze"))
# COMMAND ----------
#write plot summaries to delta table
df = ms_plot_summaries_bronze(volume_path)
df.write.mode("overwrite").saveAsTable(f"{catalog}.{schema}.ms_plot_summaries_bronze")
display(spark.table(f"{catalog}.{schema}.ms_plot_summaries_bronze"))
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## 2. SILVER DATA LAYER
# MAGIC
# MAGIC Joining movie metadata with plot summaries and some data cleanup.
# COMMAND ----------
#reading metadata table and some data cleanup
def read_movie_metadata(catalog, schema):
return (
spark.table(f"{catalog}.{schema}.ms_movie_metadata_bronze")
.withColumn("movie_countries", F.from_json("movie_countries", "map<string,string>"))
.withColumn("movie_countries", F.map_values("movie_countries"))
.withColumn("movie_languages", F.from_json("movie_languages", "map<string,string>"))
.withColumn("movie_languages", F.map_values("movie_languages"))
.withColumn("movie_genres", F.from_json("movie_genres", "map<string,string>"))
.withColumn("movie_genres", F.map_values("movie_genres")))
#reading plot summaries table
def read_plot_summaries(catalog, schema):
return spark.table(f"{catalog}.{schema}.ms_plot_summaries_bronze")
#joining plot summaries with metadata tables
def read_movie_documents(catalog, schema):
return (
read_movie_metadata(catalog, schema)
.join(read_plot_summaries(catalog, schema), "wikipedia_movie_id")
.withColumn("document", F.concat_ws(
"\n\n",
F.concat_ws(" ", F.lit("movie name:"), F.col("movie_name")),
F.concat_ws(" ", F.lit("plot summary:"), F.col("plot_summary")),
F.concat_ws(" ", F.lit("genres:"), F.concat_ws(", ", F.col("movie_genres"))))))
# COMMAND ----------
documents = read_movie_documents(catalog, schema)
# COMMAND ----------
# adding a column for profile_type (random assignment)
documents=documents.withColumn('childproof', when(rand() > 0.95, 1).otherwise(0))
documents=documents.withColumn('premium', when(rand() > 0.70, 1).otherwise(0))
# COMMAND ----------
# adding for rating (random assignment)
def rating_generator():
return randint(50,100)
rating_generator_udf = F.udf(lambda: rating_generator(), T.IntegerType())
documents=documents.withColumn('rating', rating_generator_udf())
# COMMAND ----------
print((documents.count(), len(documents.columns)))
# COMMAND ----------
display(documents)
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC #### 2A. DATA EXPLORATORY ANALYSIS
# MAGIC
# MAGIC Let's explore the data and determine the average number of tokens per document. This is important to understand because LLMs have token input limits; and in this RAGs architecture we will be passing plot summaries as context. Because we are going to be using [Llama-2-7b-chat from hugging face](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf), we should use the tokenizer used in that model. You can access all Llama modesl through Hugging Face through [this](https://huggingface.co/meta-llama) link.
# COMMAND ----------
tokenizer = LlamaTokenizer.from_pretrained('meta-llama/Llama-2-7b-chat-hf')
# COMMAND ----------
barbie_example = """
To live in Barbie Land is to be a perfect being in a perfect place. Unless you have a full-on existential crisis. Or you’re a Ken.
From Oscar-nominated writer/director Greta Gerwig (“Little Women,” “Lady Bird”) comes “Barbie,” starring Oscar-nominees Margot Robbie (“Bombshell,” “I, Tonya”) and Ryan Gosling (“La La Land,” “Half Nelson”) as Barbie and Ken, alongside America Ferrera (“End of Watch,” the “How to Train Your Dragon” films), Kate McKinnon (“Bombshell,” “Yesterday”), Michael Cera (“Scott Pilgrim vs. the World,” “Juno”), Ariana Greenblatt (“Avengers: Infinity War,” “65”), Issa Rae (“The Photograph,” “Insecure”), Rhea Perlman (“I’ll See You in My Dreams,” “Matilda”), and Will Ferrell (the “Anchorman” films, “Talladega Nights”). The film also stars Ana Cruz Kayne (“Little Women”), Emma Mackey (“Emily,” “Sex Education”), Hari Nef (“Assassination Nation,” “Transparent”), Alexandra Shipp (the “X-Men” films), Kingsley Ben-Adir (“One Night in Miami,” “Peaky Blinders”), Simu Liu (“Shang-Chi and the Legend of the Ten Rings”), Ncuti Gatwa (“Sex Education”), Scott Evans (“Grace and Frankie”), Jamie Demetriou (“Cruella”), Connor Swindells (“Sex Education,” “Emma.”), Sharon Rooney (“Dumbo,” “Jerk”), Nicola Coughlan (“Bridgerton,” “Derry Girls”), Ritu Arya (“The Umbrella Academy”), Grammy Award-winning singer/songwriter Dua Lipa and Oscar-winner Helen Mirren (“The Queen”).
Gerwig directed “Barbie” from a screenplay by Gerwig & Oscar nominee Noah Baumbach (“Marriage Story,” “The Squid and the Whale”), based on Barbie by Mattel. The film’s producers are Oscar nominee David Heyman (“Marriage Story,” “Gravity”), Robbie, Tom Ackerley and Robbie Brenner, with Michael Sharp, Josey McNamara, Ynon Kreiz, Courtenay Valenti, Toby Emmerich and Cate Adams serving as executive producers.
Gerwig’s creative team behind the camera included Oscar-nominated director of photography Rodrigo Prieto (“The Irishman,” “Silence,” “Brokeback Mountain”), six-time Oscar-nominated production designer Sarah Greenwood (“Beauty and the Beast,” “Anna Karenina”), editor Nick Houy (“Little Women,” “Lady Bird”), Oscar-winning costume designer Jacqueline Durran (“Little Women,” “Anna Karenina”), visual effects supervisor Glen Pratt (“Paddington 2,” “Beauty and the Beast”), music supervisor George Drakoulias (“White Noise,” “Marriage Story”) and Oscar-winning composer Alexandre Desplat (“The Shape of Water,” “The Grand Budapest Hotel”).
Warner Bros. Pictures Presents a Heyday Films Production, a LuckyChap Entertainment Production, a Mattel Production, “Barbie.” The film will be distributed worldwide by Warner Bros. Pictures and released in theaters only nationwide on July 21, 2023 and beginning internationally on July 19, 2023.
"""
# COMMAND ----------
print(f"length of Barbie about page: {len(tokenizer.encode(barbie_example))}")
# COMMAND ----------
# UDF to determine the number of tokens using the llama-2-7b tokenizer
@F.pandas_udf("long")
def num_tokens_llama(batch_iter: Iterator[pd.Series]) -> Iterator[pd.Series]:
login(token=hf_token)
tokenizer = LlamaTokenizer.from_pretrained('meta-llama/Llama-2-7b-chat-hf')
try:
for x in batch_iter:
yield x.apply(lambda s: len(tokenizer.encode(s)))
finally:
pass
# COMMAND ----------
documents = (
documents
.withColumn("document_num_chars", F.length("document"))
.withColumn("document_num_words", F.size(F.split("document", "\\s")))
.withColumn("document_num_tokens_llama", num_tokens_llama("document"))
)
# COMMAND ----------
display(documents)
# COMMAND ----------
documents.createOrReplaceTempView("documents")
# COMMAND ----------
# MAGIC %sql
# MAGIC select
# MAGIC avg(document_num_tokens_llama) as mean_tokens,
# MAGIC max(document_num_tokens_llama) as max_tokens,
# MAGIC min(document_num_tokens_llama) as min_tokens,
# MAGIC sum(case when document_num_tokens_llama>3500 then 1 else 0 end) as documents_3500
# MAGIC from documents
# COMMAND ----------
#to keep things simple for this workshop we are going to remove all documents with a token limit about 3500. This is because Llama-2 has a token input limit of 4096 tokens.
documents=documents.filter(documents.document_num_tokens_llama <=3500)
# COMMAND ----------
#write to delta table
documents.write.mode("overwrite").saveAsTable(f"{catalog}.{schema}.movie_documents_silver")
# COMMAND ----------
# delta table to use
df=spark.sql(f'''select wikipedia_movie_id, document, movie_name, movie_release_date, movie_runtime, childproof, premium, rating, document_num_tokens_llama, document_num_chars,
document_num_words from {catalog}.{schema}.movie_documents_silver limit 10000;''')
# COMMAND ----------
#creating a subset of data for vector search delta sync
df.write.mode("overwrite").saveAsTable(f"{catalog}.{schema}.{sync_table_name}")
# COMMAND ----------
spark.sql(f'''
ALTER TABLE {catalog}.{schema}.movie_documents_for_sync SET TBLPROPERTIES (delta.enableChangeDataFeed = true)
''')
# COMMAND ----------
# MAGIC %md
# MAGIC
# MAGIC ## 3. DATA CHUNKING
# MAGIC
# MAGIC We won't be using chunking in this rag bot, but I wanted to include how you would do this. This is a good strategy if you need extra control over token input.
# COMMAND ----------
print(f"chunk_size: {chunk_size}")
print(f"chunk_overlap: {chunk_overlap}")
# COMMAND ----------
def split_documents(dfs: Iterator[pd.DataFrame]) -> Iterator[pd.DataFrame]:
text_splitter = TokenTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
fn = lambda s: text_splitter.split_text(s)
for df in dfs:
df.loc[:, "text"] = df.loc[:, "plot_summary"].apply(fn)
df = df.loc[:, ["wikipedia_movie_id", "text"]]
df = df.explode("text").reset_index().rename(columns={'index' : 'chunk_index'})
df['chunk_index'] = df.groupby('chunk_index').cumcount()
yield df.loc[:, ["wikipedia_movie_id", "chunk_index", "text"]]
# COMMAND ----------
movie_df=spark.table(f"{catalog}.{schema}.movie_documents_silver")
metadata_df = (
movie_df.select([
"wikipedia_movie_id",
"movie_name",
"movie_release_date",
"movie_runtime",
"childproof",
"premium",
"rating",
"movie_languages",
"movie_genres",
"movie_countries",
"document_num_tokens_llama",
"document_num_chars",
"document_num_words",
"document"]))
# COMMAND ----------
results_schema = T.StructType([
T.StructField("wikipedia_movie_id", T.IntegerType()),
T.StructField("chunk_index", T.LongType()),
T.StructField("text", T.StringType())])
results = (
movie_df.mapInPandas(split_documents, results_schema)
.withColumn("id", F.concat_ws("_",
F.col("wikipedia_movie_id").cast("string"),
F.col("chunk_index").cast("string")))
.join(metadata_df, "wikipedia_movie_id"))
# COMMAND ----------
display(results)
# COMMAND ----------
results.write.mode("overwrite").saveAsTable(f"{catalog}.{schema}.movie_documents_silver_chunked")
# COMMAND ----------
| [] |
2024-01-10 | bnabis93/vision-language-examples | embedding~01-openai-text-embedding-fine-tuning~inference.py | import json
import openai
# Sample input
sample_hockey_tweet = """Thank you to the
@Canes
and all you amazing Caniacs that have been so supportive! You guys are some of the best fans in the NHL without a doubt! Really excited to start this new chapter in my career with the
@DetroitRedWings
!!"""
# Model from fine-tuning
model_list = json.load(open("fine_tune_model.json"))
model_name = model_list["data"][0]["fine_tuned_model"]
print(f"Fine tuning model: {model_name}")
# Inference
res = openai.Completion.create(
model=model_name,
prompt=sample_hockey_tweet + "\n\n###\n\n",
max_tokens=1,
temperature=0,
logprobs=2,
)
print(res["choices"][0]["text"])
| [
"Thank you to the \n@Canes\n and all you amazing Caniacs that have been so supportive! You guys are some of the best fans in the NHL without a doubt! Really excited to start this new chapter in my career with the \n@DetroitRedWings\n !!\n\n###\n\n"
] |
2024-01-10 | bnabis93/vision-language-examples | embedding~01-openai-text-embedding-fine-tuning~data_prep.py | from sklearn.datasets import fetch_20newsgroups
import pandas as pd
import openai
# Dataset
categories = ["rec.sport.baseball", "rec.sport.hockey"]
sports_dataset = fetch_20newsgroups(
subset="train", shuffle=True, random_state=42, categories=categories
)
# EDA
## Total examples: 1197, Baseball examples: 597, Hockey examples: 600
len_all, len_baseball, len_hockey = (
len(sports_dataset.data),
len([e for e in sports_dataset.target if e == 0]),
len([e for e in sports_dataset.target if e == 1]),
)
print(
f"Total examples: {len_all}, Baseball examples: {len_baseball}, Hockey examples: {len_hockey}"
)
# Data Preperation
labels = [
sports_dataset.target_names[x].split(".")[-1] for x in sports_dataset["target"]
]
texts = [text.strip() for text in sports_dataset["data"]]
df = pd.DataFrame(zip(texts, labels), columns=["prompt", "completion"]) # [:300]
# Save the data
df.to_json("data/sport2.jsonl", orient="records", lines=True)
| [] |
2024-01-10 | cado-security/masked-ai | tests~test_masker.py | # import os
# import openai
# from masked_ai import Masker
# # Load your API key from an environment variable or secret management service
# openai.api_key = os.getenv("OPENAI_API_KEY")
# data = "My name is Adam and my IP address is 8.8.8.8. Now, write a one line poem:"
# masker = Masker(data)
# print('Masked: ', masker.masked_data)
# response = openai.Completion.create(
# model="text-davinci-003",
# prompt=masker.masked_data,
# temperature=0,
# max_tokens=1000,
# )
# generated_text = response.choices[0].text
# print('Raw response: ', response)
# unmasked = masker.unmask_data(generated_text)
# print('Result:', unmasked) | [] |
2024-01-10 | masisley/caster | tests~testrunner.py | import os
import sys
import unittest
if os.path.dirname(os.path.dirname(os.path.abspath(__file__))) not in sys.path:
sys.path.insert(0,os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from dragonfly import get_engine
from castervoice.lib.ctrl.mgr.errors.guidance_rejection import GuidanceRejectionException
from castervoice.lib.util import guidance
from tests.test_util import settings_mocking, utilities_mocking
def reject_file_writing():
raise GuidanceRejectionException()
def get_master_suite():
return unittest.defaultTestLoader.discover(os.path.dirname(__file__))
def run_tests():
get_engine("text")
settings_mocking.prevent_initialize()
utilities_mocking.mock_toml_files()
return unittest.TextTestRunner(verbosity=2).run(get_master_suite())
if __name__ == '__main__':
guidance.offer = reject_file_writing
result = run_tests()
sys.exit(len(result.failures) + len(result.errors) + len(result.unexpectedSuccesses))
| [] |
2024-01-10 | CalibrationMe/gen-ai-sdsc-hackathon | getClothingSuggestionFromGpt.py | import os
from openai import AzureOpenAI
import prompt_generator_for_gpt
import sys
def promptOnlyText(gender = 'man', ethnicity = 'european', age = '30s', destination = 'Paris', minTemp = 10, maxTemp = 25, minPrec = 0, maxPrec = 15, sunnyDays = 5):
string_setup = f'A {gender}, {ethnicity}, in their {age} is visiting {destination}. The temperature will be between {minTemp} and {maxTemp} degrees celsius and the precipitation between {minPrec} and {maxPrec} and {sunnyDays} sunny days. '
string_text = f'As text output, list the outer set of clothes with basic descriptions (type of clothing, 2-3 word description) that would be fitting for searching this clothings online. Make sure that the text output is **only** a csv compatible output and no other text.'
string_prompt = string_setup + string_text
return string_prompt
## more details on https://github.com/openai/openai-python
def getClothingSuggestions(prompt_str):
AZURE_CH_ENDPOINT = 'https://switzerlandnorth.api.cognitive.microsoft.com/'
fname_CHATGPT_KEY = 'CHATGPT_TOKEN.txt' # TODO: change to your own API key. This is located under Home > Azure AI Services | Azure OpenAI > hackathon-hack-openai-10 > Keys and Endpoint > Key 1
if os.path.isfile(fname_CHATGPT_KEY):
with open(fname_CHATGPT_KEY, 'r') as fh:
AZURE_CHATGPT_API_KEY = fh.read()
else:
print('Error: AZURE_CHATGPT_API_KEY file not found')
client = AzureOpenAI(
azure_endpoint = AZURE_CH_ENDPOINT, #os.getenv("AZURE_OPENAI_ENDPOINT"),
api_key = AZURE_CHATGPT_API_KEY, # os.getenv("AZURE_OPENAI_KEY"),
api_version="2023-05-15"
)
response = client.chat.completions.create(
model="gpt-35-turbo", # model = "deployment_name".
# model='gpt-4', ## better, but a lot slower, and more expensive
messages=[
# {"role": "system", "content": "You are a helpful assistant."},
# {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
# {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
# {"role": "user", "content": "Do other Azure AI services support this too?"}
{"role": "user", "content": prompt_str}
]
)
response_txt = response.choices[0].message.content
return response_txt
##########START HERE
##########START HERE
if len(sys.argv) > 1:
criteria = sys.argv[1]
else:
criteria = "gender = 'man', ethnicity = 'Swiss', age = '50s', destination = 'Edinborough', minTemp = -5, maxTemp = 5, minPrec = 0, maxPrec = 15, sunnyDays = 5"
prompt_str = promptOnlyText(criteria)
clothingSuggestions = getClothingSuggestions(prompt_str)
print("\n"*3)
print(clothingSuggestions)
| [
"man",
"A PLACEHOLDER, PLACEHOLDER, in their PLACEHOLDER is visiting PLACEHOLDER. The temperature will be between PLACEHOLDER and PLACEHOLDER degrees celsius and the precipitation between PLACEHOLDER and PLACEHOLDER and PLACEHOLDER sunny days. As text output, list the outer set of clothes with basic descriptions (type of clothing, 2-3 word description) that would be fitting for searching this clothings online. Make sure that the text output is **only** a csv compatible output and no other text.",
"Edinborough"
] |
2024-01-10 | CalibrationMe/gen-ai-sdsc-hackathon | callChatGptWithMeteoValues.py | import os
from openai import AzureOpenAI
import getClothingSuggestionFromGpt
import sys
criteria = "gender = 'man', ethnicity = 'Moslem', age = '20s', destination = 'Casablanca', minTemp = 15, maxTemp = 35, minPrec = 0, maxPrec = 5, sunnyDays = 12"
suggestedEquipment = getClothingSuggestionFromGpt.getRecommendations(criteria)
print(suggestedEquipment) | [] |
2024-01-10 | CalibrationMe/gen-ai-sdsc-hackathon | query_dalle_firat.py |
from openai import AzureOpenAI
import os
import requests
from PIL import Image
import json
def get_dalle_image(prompt_str, image_save_name=None):
fname_DALLE_KEY = 'DALLE_TOKEN.txt' # TODO: change to your own API key
if os.path.isfile(fname_DALLE_KEY):
with open(fname_DALLE_KEY, 'r') as fh:
AZURE_DALLE_API_KEY = fh.read()
else:
print('Error: AZURE_DALLE_API_KEY file not found')
AZURE_OPENAI_ENDPOINT = 'https://rhaetian-poppy-sweden.openai.azure.com/'
client = AzureOpenAI(
api_version="2023-12-01-preview",
api_key=AZURE_DALLE_API_KEY, #os.environ["AZURE_OPENAI_API_KEY"],
azure_endpoint=AZURE_OPENAI_ENDPOINT # os.environ['AZURE_OPENAI_ENDPOINT']
)
result = client.images.generate(
model="rhaetian-poppy-dalle3", # the name of your DALL-E 3 deployment
prompt=prompt_str,
n=1
)
json_response = json.loads(result.model_dump_json())
# Retrieve the generated image
image_url = json_response["data"][0]["url"] # extract image URL from response
generated_image = requests.get(image_url).content # download the image
if image_save_name is not None:
if os.path.isfile(image_save_name):
print(f'Error: {image_save_name} already exists. Will overwrite.')
else:
os.makedirs(os.path.dirname(image_save_name), exist_ok=True)
with open(image_save_name, "wb") as image_file:
image_file.write(generated_image)
return generated_image | [] |
2024-01-10 | ayushwattal/PDF-ChatGpt | logic.py | import os
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain
from langchain.chat_models import ChatOpenAI
from langchain.document_loaders import PyPDFLoader
import fitz
from PIL import Image
# Global variables
count = 0
n = 0
chat_history = []
chain = ''
# Function to set the OpenAI API key
def set_api_key(api_key):
"""
Sets the OpenAI API key in the environment variable.
Args:
api_key (str): The OpenAI API key.
Returns:
str: Message indicating the API key is set.
"""
os.environ['OPENAI_API_KEY'] = api_key
return 'OpenAI API key is set'
# Function to enable the API key input box
def enable_api_box():
"""
Enables the API key input box.
Returns:
None
"""
return
# Function to add text to the chat history
def add_text(history, text):
"""
Adds the user's input text to the chat history.
Args:
history (list): List of tuples representing the chat history.
text (str): The user's input text.
Returns:
list: Updated chat history with the new user input.
"""
if not text:
raise gr.Error('Enter text')
history.append((text, ''))
return history
# Function to process the PDF file and create a conversation chain
def process_file(file):
"""
Processes the uploaded PDF file and creates a conversational retrieval chain.
Args:
file (FileStorage): The uploaded PDF file.
Returns:
ConversationalRetrievalChain: The created conversational retrieval chain.
"""
if 'OPENAI_API_KEY' not in os.environ:
raise gr.Error('Upload your OpenAI API key')
loader = PyPDFLoader(file.name)
documents = loader.load()
embeddings = OpenAIEmbeddings()
pdf_search = Chroma.from_documents(documents, embeddings)
chain = ConversationalRetrievalChain.from_llm(ChatOpenAI(temperature=0.3),
retriever=pdf_search.as_retriever(search_kwargs={"k": 1}),
return_source_documents=True)
return chain
# Function to generate a response based on the chat history and query
def generate_response(history, query, btn):
"""
Generates a response based on the chat history and user's query.
Args:
history (list): List of tuples representing the chat history.
query (str): The user's query.
btn (FileStorage): The uploaded PDF file.
Returns:
tuple: Updated chat history with the generated response and the next page number.
"""
global count, n, chat_history, chain
if not btn:
raise gr.Error(message='Upload a PDF')
if count == 0:
chain = process_file(btn)
count += 1
result = chain({"question": query, 'chat_history': chat_history}, return_only_outputs=True)
chat_history.append((query, result["answer"]))
n = list(result['source_documents'][0])[1][1]['page']
for char in result['answer']:
history[-1][-1] += char
return history, " "
# Function to render a specific page of a PDF file as an image
def render_file(file):
"""
Renders a specific page of a PDF file as an image.
Args:
file (FileStorage): The PDF file.
Returns:
PIL.Image.Image: The rendered page as an image.
"""
global n
doc = fitz.open(file.name)
page = doc[n]
# Render the page as a PNG image with a resolution of 300 DPI
pix = page.get_pixmap(matrix=fitz.Matrix(300 / 72, 300 / 72))
image = Image.frombytes('RGB', [pix.width, pix.height], pix.samples)
return image
| [] |
2024-01-10 | mostrub/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 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"]
+ "\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["implement_on_existing"]
+ "\nUseful to know:\n"
+ dbs.preprompts["philosophy"]
)
def get_prompt(dbs: DBs) -> str:
"""
Loads the user's prompt for the project from prompt file
(While we migrate we have this fallback getter)
"""
assert (
"prompt" in dbs.input or "main_prompt" in dbs.input
), "Please put your prompt in the file `prompt` in the project directory"
if "prompt" not in dbs.input:
print(
colored("Please put the prompt in the file `prompt`, not `main_prompt", "red")
)
print()
return dbs.input["main_prompt"]
return dbs.input["prompt"]
def curr_fn() -> str:
"""
Get the name of the current function
NOTE: 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
# All steps below have the signature Step
def simple_gen(ai: AI, dbs: DBs) -> List[Message]:
"""Run the AI on the main prompt and save the results"""
messages = ai.start(setup_sys_prompt(dbs), get_prompt(dbs), 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 = get_prompt(dbs)
while True:
messages = ai.next(messages, user_input, step_name=curr_fn())
msg = messages[-1].content.strip()
if msg == "Nothing more to clarify.":
break
if msg.lower().startswith("no"):
print("Nothing more 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, only answer in the form:\n"
"{remaining unclear areas} remaining questions.\n"
"{Next question}\n"
'If everything is sufficiently clear, only answer "Nothing more to clarify.".'
)
print()
return messages
def gen_spec(ai: AI, dbs: DBs) -> List[Message]:
"""
Generate a spec from the main prompt + clarifications and save the results to
the workspace
"""
messages = [
ai.fsystem(setup_sys_prompt(dbs)),
ai.fsystem(f"Instructions: {dbs.input['prompt']}"),
]
messages = ai.next(messages, dbs.preprompts["spec"], step_name=curr_fn())
dbs.memory["specification"] = messages[-1].content.strip()
return messages
def respec(ai: AI, dbs: DBs) -> List[Message]:
"""Asks the LLM to review the specs so far and reiterate them if necessary"""
messages = AI.deserialize_messages(dbs.logs[gen_spec.__name__])
messages += [ai.fsystem(dbs.preprompts["respec"])]
messages = ai.next(messages, step_name=curr_fn())
messages = ai.next(
messages,
(
"Based on the conversation so far, please reiterate the specification for "
"the program. "
"If there are things that can be improved, please incorporate the "
"improvements. "
"If you are satisfied with the specification, just write out the "
"specification word by word again."
),
step_name=curr_fn(),
)
dbs.memory["specification"] = messages[-1].content.strip()
return messages
def gen_unit_tests(ai: AI, dbs: DBs) -> List[dict]:
"""
Generate unit tests based on the specification, that should work.
"""
messages = [
ai.fsystem(setup_sys_prompt(dbs)),
ai.fuser(f"Instructions: {dbs.input['prompt']}"),
ai.fuser(f"Specification:\n\n{dbs.memory['specification']}"),
]
messages = ai.next(messages, dbs.preprompts["unit_tests"], step_name=curr_fn())
dbs.memory["unit_tests"] = messages[-1].content.strip()
to_files(dbs.memory["unit_tests"], dbs.workspace)
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"], step_name=curr_fn())
to_files(messages[-1].content.strip(), dbs.workspace)
return messages
def gen_code_after_unit_tests(ai: AI, dbs: DBs) -> List[dict]:
"""Generates project code after unit tests have been produced"""
messages = [
ai.fsystem(setup_sys_prompt(dbs)),
ai.fuser(f"Instructions: {dbs.input['prompt']}"),
ai.fuser(f"Specification:\n\n{dbs.memory['specification']}"),
ai.fuser(f"Unit tests:\n\n{dbs.memory['unit_tests']}"),
]
messages = ai.next(messages, dbs.preprompts["generate"], 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("Do you want to execute this code?")
print()
print(command)
print()
print('If yes, press enter. Otherwise, type "no"')
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 improve_existing_code(ai: AI, dbs: DBs):
"""
Ask the user for a list of paths, ask the AI agent to
improve, fix or add a new functionality
A file selection will appear to select the files.
The terminal will ask for the prompt.
"""
ask_for_files(dbs.input) # stores files as full paths.
files_info = get_code_strings(dbs.input) # this only has file names not paths
dbs.input["prompt"] = input(
"\nWhat do you need to improve with the selected files?\n"
)
confirm_str = f"""
-----------------------------
The following files will be used in the improvement process:
{dbs.input["file_list.txt"]}
The inserted prompt is the following:
'{dbs.input['prompt']}'
-----------------------------
You can change these files in .gpteng folder ({dbs.input.path}) in your project
before proceeding.
Press enter to proceed with modifications.
"""
input(confirm_str)
messages = [
ai.fsystem(setup_sys_prompt_existing_code(dbs)),
ai.fuser(f"Instructions: {dbs.input['prompt']}"),
]
# 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}"))
output_format_str = """
Make sure the output of any files is in the following format where
FILENAME is the file name including the file extension, and the file path. Do not
forget to include the file path.
LANG is the markup code block language for the code's language, and CODE is the code:
FILENAME
```LANG
CODE
```
"""
messages = ai.next(messages, output_format_str, step_name=curr_fn())
# Maybe we should add another step called "replace" or "overwrite"
overwrite_files(messages[-1].content.strip(), dbs)
return messages
def fix_code(ai: AI, dbs: DBs):
messages = AI.deserialize_messages(dbs.logs[gen_code_after_unit_tests.__name__])
code_output = messages[-1].content.strip()
messages = [
ai.fsystem(setup_sys_prompt(dbs)),
ai.fuser(f"Instructions: {dbs.input['prompt']}"),
ai.fuser(code_output),
ai.fsystem(dbs.preprompts["fix_code"]),
]
messages = ai.next(
messages, "Please fix any errors in the code above.", step_name=curr_fn()
)
to_files(messages[-1].content.strip(), dbs.workspace)
return messages
def human_review(ai: AI, dbs: DBs):
"""Collects and stores human review of the code"""
review = human_review_input()
dbs.memory["review"] = review.to_json() # type: ignore
return []
class Config(str, Enum):
DEFAULT = "default"
BENCHMARK = "benchmark"
SIMPLE = "simple"
TDD = "tdd"
TDD_PLUS = "tdd+"
CLARIFY = "clarify"
RESPEC = "respec"
EXECUTE_ONLY = "execute_only"
EVALUATE = "evaluate"
USE_FEEDBACK = "use_feedback"
IMPROVE_CODE = "improve_code"
# Define the steps to run for different configs
STEPS = {
Config.DEFAULT: [
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.TDD: [
gen_spec,
gen_unit_tests,
gen_code_after_unit_tests,
gen_entrypoint,
execute_entrypoint,
human_review,
],
Config.TDD_PLUS: [
gen_spec,
gen_unit_tests,
gen_code_after_unit_tests,
fix_code,
gen_entrypoint,
execute_entrypoint,
human_review,
],
Config.CLARIFY: [
clarify,
gen_clarified_code,
gen_entrypoint,
execute_entrypoint,
human_review,
],
Config.RESPEC: [
gen_spec,
respec,
gen_unit_tests,
gen_code_after_unit_tests,
fix_code,
gen_entrypoint,
execute_entrypoint,
human_review,
],
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: [improve_existing_code],
}
# Future steps that can be added:
# run_tests_and_fix_files
# execute_entrypoint_and_fix_files_if_it_results_in_error
| [] |
2024-01-10 | Iqbalshahzad96/quivr | utils~vectors.py | from concurrent.futures import ThreadPoolExecutor
from typing import List
from langchain.embeddings.openai import OpenAIEmbeddings
from logger import get_logger
from models.settings import BrainSettings, CommonsDep, common_dependencies
from pydantic import BaseModel
logger = get_logger(__name__)
class Neurons(BaseModel):
commons: CommonsDep
settings = BrainSettings() # pyright: ignore reportPrivateUsage=none
def create_vector(self, doc, user_openai_api_key=None):
logger.info("Creating vector for document")
logger.info(f"Document: {doc}")
if user_openai_api_key:
self.commons["documents_vector_store"]._embedding = OpenAIEmbeddings(
openai_api_key=user_openai_api_key
) # pyright: ignore reportPrivateUsage=none
try:
sids = self.commons["documents_vector_store"].add_documents([doc])
if sids and len(sids) > 0:
return sids
except Exception as e:
logger.error(f"Error creating vector for document {e}")
def create_embedding(self, content):
return self.commons["embeddings"].embed_query(content)
def similarity_search(self, query, table="match_summaries", top_k=5, threshold=0.5):
query_embedding = self.create_embedding(query)
summaries = (
self.commons["supabase"]
.rpc(
table,
{
"query_embedding": query_embedding,
"match_count": top_k,
"match_threshold": threshold,
},
)
.execute()
)
return summaries.data
def error_callback(exception):
print("An exception occurred:", exception)
def process_batch(batch_ids: List[str]):
commons = common_dependencies()
supabase = commons["supabase"]
try:
if len(batch_ids) == 1:
return (
supabase.table("vectors")
.select(
"name:metadata->>file_name, size:metadata->>file_size",
count="exact",
)
.eq("id", batch_ids[0]) # Use parameter binding for single ID
.execute()
).data
else:
return (
supabase.table("vectors")
.select(
"name:metadata->>file_name, size:metadata->>file_size",
count="exact",
)
.in_("id", batch_ids) # Use parameter binding for multiple IDs
.execute()
).data
except Exception as e:
logger.error("Error retrieving batched vectors", e)
def get_unique_files_from_vector_ids(vectors_ids: List[str]):
# Move into Vectors class
"""
Retrieve unique user data vectors.
"""
# constants
BATCH_SIZE = 5
with ThreadPoolExecutor() as executor:
futures = []
for i in range(0, len(vectors_ids), BATCH_SIZE):
batch_ids = vectors_ids[i : i + BATCH_SIZE]
future = executor.submit(process_batch, batch_ids)
futures.append(future)
# Retrieve the results
vectors_responses = [future.result() for future in futures]
documents = [item for sublist in vectors_responses for item in sublist]
print("document", documents)
unique_files = [dict(t) for t in set(tuple(d.items()) for d in documents)]
return unique_files
| [] |
2024-01-10 | Iqbalshahzad96/quivr | models~settings.py | from typing import Annotated
from fastapi import Depends
from langchain.embeddings.openai import OpenAIEmbeddings
from pydantic import BaseSettings
from supabase.client import Client, create_client
from vectorstore.supabase import SupabaseVectorStore
class BrainRateLimiting(BaseSettings):
max_brain_size: int = 52428800
max_brain_per_user: int = 5
class BrainSettings(BaseSettings):
openai_api_key: str
anthropic_api_key: str
supabase_url: str
supabase_service_key: str
resend_api_key: str = "null"
resend_email_address: str = "[email protected]"
class LLMSettings(BaseSettings):
private: bool = False
model_path: str = "./local_models/ggml-gpt4all-j-v1.3-groovy.bin"
def common_dependencies() -> dict:
settings = BrainSettings() # pyright: ignore reportPrivateUsage=none
embeddings = OpenAIEmbeddings(
openai_api_key=settings.openai_api_key
) # pyright: ignore reportPrivateUsage=none
supabase_client: Client = create_client(
settings.supabase_url, settings.supabase_service_key
)
documents_vector_store = SupabaseVectorStore(
supabase_client, embeddings, table_name="vectors"
)
summaries_vector_store = SupabaseVectorStore(
supabase_client, embeddings, table_name="summaries"
)
return {
"supabase": supabase_client,
"embeddings": embeddings,
"documents_vector_store": documents_vector_store,
"summaries_vector_store": summaries_vector_store,
}
CommonsDep = Annotated[dict, Depends(common_dependencies)]
| [] |
2024-01-10 | Iqbalshahzad96/quivr | parsers~github.py | import os
import time
from langchain.document_loaders import GitLoader
from langchain.schema import Document
from langchain.text_splitter import RecursiveCharacterTextSplitter
from models.brains import Brain
from models.files import File
from models.settings import CommonsDep
from utils.file import compute_sha1_from_content
from utils.vectors import Neurons
async def process_github(
commons: CommonsDep, # pyright: ignore reportPrivateUsage=none
repo,
enable_summarization,
brain_id,
user_openai_api_key,
):
random_dir_name = os.urandom(16).hex()
dateshort = time.strftime("%Y%m%d")
loader = GitLoader(
clone_url=repo,
repo_path="/tmp/" + random_dir_name,
)
documents = loader.load()
os.system("rm -rf /tmp/" + random_dir_name)
chunk_size = 500
chunk_overlap = 0
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
chunk_size=chunk_size, chunk_overlap=chunk_overlap
)
documents = text_splitter.split_documents(documents)
print(documents[:1])
for doc in documents:
if doc.metadata["file_type"] in [
".pyc",
".png",
".svg",
".env",
".lock",
".gitignore",
".gitmodules",
".gitattributes",
".gitkeep",
".git",
".json",
]:
continue
metadata = {
"file_sha1": compute_sha1_from_content(doc.page_content.encode("utf-8")),
"file_size": len(doc.page_content) * 8,
"file_name": doc.metadata["file_name"],
"chunk_size": chunk_size,
"chunk_overlap": chunk_overlap,
"date": dateshort,
"summarization": "true" if enable_summarization else "false",
}
doc_with_metadata = Document(page_content=doc.page_content, metadata=metadata)
file = File(
file_sha1=compute_sha1_from_content(doc.page_content.encode("utf-8"))
)
file_exists = file.file_already_exists()
if not file_exists:
print(f"Creating entry for file {file.file_sha1} in vectors...")
neurons = Neurons(commons=commons)
created_vector = neurons.create_vector(
doc_with_metadata, user_openai_api_key
)
print("Created vector sids ", created_vector)
print("Created vector for ", doc.metadata["file_name"])
file_exists_in_brain = file.file_already_exists_in_brain(brain_id)
if not file_exists_in_brain:
brain = Brain(id=brain_id)
file.link_file_to_brain(brain)
return {
"message": f"✅ Github with {len(documents)} files has been uploaded.",
"type": "success",
}
| [] |
2024-01-10 | Iqbalshahzad96/quivr | routes~chat_routes.py | import os
import time
from http.client import HTTPException
from typing import List
from uuid import UUID
from auth import AuthBearer, get_current_user
from fastapi import APIRouter, Depends, Query, Request
from fastapi.responses import StreamingResponse
from llm.openai import OpenAIBrainPicking
from models.brains import get_default_user_brain_or_create_new
from models.chat import Chat, ChatHistory
from models.chats import ChatQuestion
from models.settings import LLMSettings, common_dependencies
from models.users import User
from repository.chat.create_chat import CreateChatProperties, create_chat
from repository.chat.get_chat_by_id import get_chat_by_id
from repository.chat.get_chat_history import get_chat_history
from repository.chat.get_user_chats import get_user_chats
from repository.chat.update_chat import ChatUpdatableProperties, update_chat
from utils.constants import (
streaming_compatible_models,
)
chat_router = APIRouter()
class NullableUUID(UUID):
@classmethod
def __get_validators__(cls):
yield cls.validate
@classmethod
def validate(cls, v) -> UUID | None:
if v == "":
return None
try:
return UUID(v)
except ValueError:
return None
def get_chat_details(commons, chat_id):
response = (
commons["supabase"]
.from_("chats")
.select("*")
.filter("chat_id", "eq", chat_id)
.execute()
)
return response.data
def delete_chat_from_db(commons, chat_id):
try:
commons["supabase"].table("chat_history").delete().match(
{"chat_id": chat_id}
).execute()
except Exception as e:
print(e)
pass
try:
commons["supabase"].table("chats").delete().match(
{"chat_id": chat_id}
).execute()
except Exception as e:
print(e)
pass
def fetch_user_stats(commons, user, date):
response = (
commons["supabase"]
.from_("users")
.select("*")
.filter("email", "eq", user.email)
.filter("date", "eq", date)
.execute()
)
userItem = next(iter(response.data or []), {"requests_count": 0})
return userItem
def check_user_limit(
user: User,
):
if user.user_openai_api_key is None:
date = time.strftime("%Y%m%d")
max_requests_number = int(os.getenv("MAX_REQUESTS_NUMBER", 1000))
user.increment_user_request_count(date)
if int(user.requests_count) >= int(max_requests_number):
raise HTTPException(
status_code=429, # pyright: ignore reportPrivateUsage=none
detail="You have reached the maximum number of requests for today.", # pyright: ignore reportPrivateUsage=none
)
else:
pass
# get all chats
@chat_router.get("/chat", dependencies=[Depends(AuthBearer())], tags=["Chat"])
async def get_chats(current_user: User = Depends(get_current_user)):
"""
Retrieve all chats for the current user.
- `current_user`: The current authenticated user.
- Returns a list of all chats for the user.
This endpoint retrieves all the chats associated with the current authenticated user. It returns a list of chat objects
containing the chat ID and chat name for each chat.
"""
chats = get_user_chats(current_user.id) # pyright: ignore reportPrivateUsage=none
return {"chats": chats}
# delete one chat
@chat_router.delete(
"/chat/{chat_id}", dependencies=[Depends(AuthBearer())], tags=["Chat"]
)
async def delete_chat(chat_id: UUID):
"""
Delete a specific chat by chat ID.
"""
commons = common_dependencies()
delete_chat_from_db(commons, chat_id)
return {"message": f"{chat_id} has been deleted."}
# update existing chat metadata
@chat_router.put(
"/chat/{chat_id}/metadata", dependencies=[Depends(AuthBearer())], tags=["Chat"]
)
async def update_chat_metadata_handler(
chat_data: ChatUpdatableProperties,
chat_id: UUID,
current_user: User = Depends(get_current_user),
) -> Chat:
"""
Update chat attributes
"""
chat = get_chat_by_id(chat_id) # pyright: ignore reportPrivateUsage=none
if current_user.id != chat.user_id:
raise HTTPException(
status_code=403, # pyright: ignore reportPrivateUsage=none
detail="You should be the owner of the chat to update it.", # pyright: ignore reportPrivateUsage=none
)
return update_chat(chat_id=chat_id, chat_data=chat_data)
# create new chat
@chat_router.post("/chat", dependencies=[Depends(AuthBearer())], tags=["Chat"])
async def create_chat_handler(
chat_data: CreateChatProperties,
current_user: User = Depends(get_current_user),
):
"""
Create a new chat with initial chat messages.
"""
return create_chat(user_id=current_user.id, chat_data=chat_data)
# add new question to chat
@chat_router.post(
"/chat/{chat_id}/question",
dependencies=[
Depends(
AuthBearer(),
),
],
tags=["Chat"],
)
async def create_question_handler(
request: Request,
chat_question: ChatQuestion,
chat_id: UUID,
brain_id: NullableUUID
| UUID
| None = Query(..., description="The ID of the brain"),
current_user: User = Depends(get_current_user),
) -> ChatHistory:
current_user.user_openai_api_key = request.headers.get("Openai-Api-Key")
try:
check_user_limit(current_user)
llm_settings = LLMSettings()
if not brain_id:
brain_id = get_default_user_brain_or_create_new(current_user).id
gpt_answer_generator = OpenAIBrainPicking(
chat_id=str(chat_id),
model=chat_question.model,
max_tokens=chat_question.max_tokens,
temperature=chat_question.temperature,
brain_id=str(brain_id),
user_openai_api_key=current_user.user_openai_api_key, # pyright: ignore reportPrivateUsage=none
)
chat_answer = gpt_answer_generator.generate_answer( # pyright: ignore reportPrivateUsage=none
chat_question.question
)
return chat_answer
except HTTPException as e:
raise e
# stream new question response from chat
@chat_router.post(
"/chat/{chat_id}/question/stream",
dependencies=[
Depends(
AuthBearer(),
),
],
tags=["Chat"],
)
async def create_stream_question_handler(
request: Request,
chat_question: ChatQuestion,
chat_id: UUID,
brain_id: NullableUUID
| UUID
| None = Query(..., description="The ID of the brain"),
current_user: User = Depends(get_current_user),
) -> StreamingResponse:
# TODO: check if the user has access to the brain
if not brain_id:
brain_id = get_default_user_brain_or_create_new(current_user).id
if chat_question.model not in streaming_compatible_models:
# Forward the request to the none streaming endpoint
return await create_question_handler(
request,
chat_question,
chat_id,
current_user, # pyright: ignore reportPrivateUsage=none
)
try:
user_openai_api_key = request.headers.get("Openai-Api-Key")
streaming = True
check_user_limit(current_user)
gpt_answer_generator = OpenAIBrainPicking(
chat_id=str(chat_id),
model=chat_question.model,
max_tokens=chat_question.max_tokens,
temperature=chat_question.temperature,
brain_id=str(brain_id),
user_openai_api_key=user_openai_api_key, # pyright: ignore reportPrivateUsage=none
streaming=streaming,
)
return StreamingResponse(
gpt_answer_generator.generate_stream( # pyright: ignore reportPrivateUsage=none
chat_question.question
),
media_type="text/event-stream",
)
except HTTPException as e:
raise e
# get chat history
@chat_router.get(
"/chat/{chat_id}/history", dependencies=[Depends(AuthBearer())], tags=["Chat"]
)
async def get_chat_history_handler(
chat_id: UUID,
) -> List[ChatHistory]:
# TODO: RBAC with current_user
return get_chat_history(chat_id) # pyright: ignore reportPrivateUsage=none
| [] |
2024-01-10 | Jens611/Auto-GPT | tests~test_llm_utils.py | import pytest
from openai.error import APIError, RateLimitError
from autogpt.llm_utils import get_ada_embedding, retry_openai_api
from autogpt.modelsinfo import COSTS
@pytest.fixture(params=[RateLimitError, APIError])
def error(request):
if request.param == APIError:
return request.param("Error", http_status=502)
else:
return request.param("Error")
@pytest.fixture
def mock_create_embedding(mocker):
mock_response = mocker.MagicMock()
mock_response.usage.prompt_tokens = 5
mock_response.__getitem__.side_effect = lambda key: [{"embedding": [0.1, 0.2, 0.3]}]
return mocker.patch(
"autogpt.llm_utils.create_embedding", return_value=mock_response
)
def error_factory(error_instance, error_count, retry_count, warn_user=True):
class RaisesError:
def __init__(self):
self.count = 0
@retry_openai_api(
num_retries=retry_count, backoff_base=0.001, warn_user=warn_user
)
def __call__(self):
self.count += 1
if self.count <= error_count:
raise error_instance
return self.count
return RaisesError()
def test_retry_open_api_no_error(capsys):
@retry_openai_api()
def f():
return 1
result = f()
assert result == 1
output = capsys.readouterr()
assert output.out == ""
assert output.err == ""
@pytest.mark.parametrize(
"error_count, retry_count, failure",
[(2, 10, False), (2, 2, False), (10, 2, True), (3, 2, True), (1, 0, True)],
ids=["passing", "passing_edge", "failing", "failing_edge", "failing_no_retries"],
)
def test_retry_open_api_passing(capsys, error, error_count, retry_count, failure):
call_count = min(error_count, retry_count) + 1
raises = error_factory(error, error_count, retry_count)
if failure:
with pytest.raises(type(error)):
raises()
else:
result = raises()
assert result == call_count
assert raises.count == call_count
output = capsys.readouterr()
if error_count and retry_count:
if type(error) == RateLimitError:
assert "Reached rate limit, passing..." in output.out
assert "Please double check" in output.out
if type(error) == APIError:
assert "API Bad gateway" in output.out
else:
assert output.out == ""
def test_retry_open_api_rate_limit_no_warn(capsys):
error_count = 2
retry_count = 10
raises = error_factory(RateLimitError, error_count, retry_count, warn_user=False)
result = raises()
call_count = min(error_count, retry_count) + 1
assert result == call_count
assert raises.count == call_count
output = capsys.readouterr()
assert "Reached rate limit, passing..." in output.out
assert "Please double check" not in output.out
def test_retry_openapi_other_api_error(capsys):
error_count = 2
retry_count = 10
raises = error_factory(APIError("Error", http_status=500), error_count, retry_count)
with pytest.raises(APIError):
raises()
call_count = 1
assert raises.count == call_count
output = capsys.readouterr()
assert output.out == ""
def test_get_ada_embedding(mock_create_embedding, api_manager):
model = "text-embedding-ada-002"
embedding = get_ada_embedding("test")
mock_create_embedding.assert_called_once_with(
"test", model="text-embedding-ada-002"
)
assert embedding == [0.1, 0.2, 0.3]
cost = COSTS[model]["prompt"]
assert api_manager.get_total_prompt_tokens() == 5
assert api_manager.get_total_completion_tokens() == 0
assert api_manager.get_total_cost() == (5 * cost) / 1000
| [] |
2024-01-10 | Jens611/Auto-GPT | autogpt~api_manager.py | from typing import List
import openai
from autogpt.config import Config
from autogpt.logs import logger
from autogpt.modelsinfo import COSTS
cfg = Config()
print_total_cost = cfg.debug_mode
class ApiManager:
def __init__(self, debug=False):
self.total_prompt_tokens = 0
self.total_completion_tokens = 0
self.total_cost = 0
self.total_budget = 0
self.debug = debug
def reset(self):
self.total_prompt_tokens = 0
self.total_completion_tokens = 0
self.total_cost = 0
self.total_budget = 0.0
def create_chat_completion(
self,
messages: list, # type: ignore
model: str | None = None,
temperature: float = cfg.temperature,
max_tokens: int | None = None,
deployment_id=None,
) -> str:
"""
Create a chat completion and update the cost.
Args:
messages (list): The list of messages to send to the API.
model (str): The model to use for the API call.
temperature (float): The temperature to use for the API call.
max_tokens (int): The maximum number of tokens for the API call.
Returns:
str: The AI's response.
"""
if deployment_id is not None:
response = openai.ChatCompletion.create(
deployment_id=deployment_id,
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
api_key=cfg.openai_api_key,
)
else:
response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
api_key=cfg.openai_api_key,
)
if self.debug:
logger.debug(f"Response: {response}")
prompt_tokens = response.usage.prompt_tokens
completion_tokens = response.usage.completion_tokens
self.update_cost(prompt_tokens, completion_tokens, model)
return response
def update_cost(self, prompt_tokens, completion_tokens, model):
"""
Update the total cost, prompt tokens, and completion tokens.
Args:
prompt_tokens (int): The number of tokens used in the prompt.
completion_tokens (int): The number of tokens used in the completion.
model (str): The model used for the API call.
"""
self.total_prompt_tokens += prompt_tokens
self.total_completion_tokens += completion_tokens
self.total_cost += (
prompt_tokens * COSTS[model]["prompt"]
+ completion_tokens * COSTS[model]["completion"]
) / 1000
if print_total_cost:
print(f"Total running cost: ${self.total_cost:.3f}")
def set_total_budget(self, total_budget):
"""
Sets the total user-defined budget for API calls.
Args:
prompt_tokens (int): The number of tokens used in the prompt.
"""
self.total_budget = total_budget
def get_total_prompt_tokens(self):
"""
Get the total number of prompt tokens.
Returns:
int: The total number of prompt tokens.
"""
return self.total_prompt_tokens
def get_total_completion_tokens(self):
"""
Get the total number of completion tokens.
Returns:
int: The total number of completion tokens.
"""
return self.total_completion_tokens
def get_total_cost(self):
"""
Get the total cost of API calls.
Returns:
float: The total cost of API calls.
"""
return self.total_cost
def get_total_budget(self):
"""
Get the total user-defined budget for API calls.
Returns:
float: The total budget for API calls.
"""
return self.total_budget
api_manager = ApiManager(cfg.debug_mode)
| [] |
2024-01-10 | Jens611/Auto-GPT | autogpt~llm_utils.py | from __future__ import annotations
import functools
import time
from typing import List, Optional
import openai
from colorama import Fore, Style
from openai.error import APIError, RateLimitError, Timeout
from autogpt.api_manager import api_manager
from autogpt.config import Config
from autogpt.logs import logger
from autogpt.types.openai import Message
def retry_openai_api(
num_retries: int = 10,
backoff_base: float = 2.0,
warn_user: bool = True,
):
"""Retry an OpenAI API call.
Args:
num_retries int: Number of retries. Defaults to 10.
backoff_base float: Base for exponential backoff. Defaults to 2.
warn_user bool: Whether to warn the user. Defaults to True.
"""
retry_limit_msg = f"{Fore.RED}Error: " f"Reached rate limit, passing...{Fore.RESET}"
api_key_error_msg = (
f"Please double check that you have setup a "
f"{Fore.CYAN + Style.BRIGHT}PAID{Style.RESET_ALL} OpenAI API Account. You can "
f"read more here: {Fore.CYAN}https://github.com/Significant-Gravitas/Auto-GPT#openai-api-keys-configuration{Fore.RESET}"
)
backoff_msg = (
f"{Fore.RED}Error: API Bad gateway. Waiting {{backoff}} seconds...{Fore.RESET}"
)
def _wrapper(func):
@functools.wraps(func)
def _wrapped(*args, **kwargs):
user_warned = not warn_user
num_attempts = num_retries + 1 # +1 for the first attempt
for attempt in range(1, num_attempts + 1):
try:
return func(*args, **kwargs)
except RateLimitError:
if attempt == num_attempts:
raise
logger.debug(retry_limit_msg)
if not user_warned:
logger.double_check(api_key_error_msg)
user_warned = True
except APIError as e:
if (e.http_status != 502) or (attempt == num_attempts):
raise
backoff = backoff_base ** (attempt + 2)
logger.debug(backoff_msg.format(backoff=backoff))
time.sleep(backoff)
return _wrapped
return _wrapper
def call_ai_function(
function: str, args: list, description: str, model: str | None = None
) -> str:
"""Call an AI function
This is a magic function that can do anything with no-code. See
https://github.com/Torantulino/AI-Functions for more info.
Args:
function (str): The function to call
args (list): The arguments to pass to the function
description (str): The description of the function
model (str, optional): The model to use. Defaults to None.
Returns:
str: The response from the function
"""
cfg = Config()
if model is None:
model = cfg.smart_llm_model
# For each arg, if any are None, convert to "None":
args = [str(arg) if arg is not None else "None" for arg in args]
# parse args to comma separated string
args: str = ", ".join(args)
messages: List[Message] = [
{
"role": "system",
"content": f"You are now the following python function: ```# {description}"
f"\n{function}```\n\nOnly respond with your `return` value.",
},
{"role": "user", "content": args},
]
return create_chat_completion(model=model, messages=messages, temperature=0)
# Overly simple abstraction until we create something better
# simple retry mechanism when getting a rate error or a bad gateway
def create_chat_completion(
messages: List[Message], # type: ignore
model: Optional[str] = None,
temperature: float = None,
max_tokens: Optional[int] = None,
) -> str:
"""Create a chat completion using the OpenAI API
Args:
messages (List[Message]): The messages to send to the chat completion
model (str, optional): The model to use. Defaults to None.
temperature (float, optional): The temperature to use. Defaults to 0.9.
max_tokens (int, optional): The max tokens to use. Defaults to None.
Returns:
str: The response from the chat completion
"""
cfg = Config()
if temperature is None:
temperature = cfg.temperature
num_retries = 10
warned_user = False
if cfg.debug_mode:
print(
f"{Fore.GREEN}Creating chat completion with model {model}, temperature {temperature}, max_tokens {max_tokens}{Fore.RESET}"
)
for plugin in cfg.plugins:
if plugin.can_handle_chat_completion(
messages=messages,
model=model,
temperature=temperature,
max_tokens=max_tokens,
):
message = plugin.handle_chat_completion(
messages=messages,
model=model,
temperature=temperature,
max_tokens=max_tokens,
)
if message is not None:
return message
response = None
for attempt in range(num_retries):
backoff = 2 ** (attempt + 2)
try:
if cfg.use_azure:
response = api_manager.create_chat_completion(
deployment_id=cfg.get_azure_deployment_id_for_model(model),
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
else:
response = api_manager.create_chat_completion(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
break
except RateLimitError:
if cfg.debug_mode:
print(
f"{Fore.RED}Error: ", f"Reached rate limit, passing...{Fore.RESET}"
)
if not warned_user:
logger.double_check(
f"Please double check that you have setup a {Fore.CYAN + Style.BRIGHT}PAID{Style.RESET_ALL} OpenAI API Account. "
+ f"You can read more here: {Fore.CYAN}https://github.com/Significant-Gravitas/Auto-GPT#openai-api-keys-configuration{Fore.RESET}"
)
warned_user = True
except (APIError, Timeout) as e:
if e.http_status != 502:
raise
if attempt == num_retries - 1:
raise
if cfg.debug_mode:
print(
f"{Fore.RED}Error: ",
f"API Bad gateway. Waiting {backoff} seconds...{Fore.RESET}",
)
time.sleep(backoff)
if response is None:
logger.typewriter_log(
"FAILED TO GET RESPONSE FROM OPENAI",
Fore.RED,
"Auto-GPT has failed to get a response from OpenAI's services. "
+ f"Try running Auto-GPT again, and if the problem the persists try running it with `{Fore.CYAN}--debug{Fore.RESET}`.",
)
logger.double_check()
if cfg.debug_mode:
raise RuntimeError(f"Failed to get response after {num_retries} retries")
else:
quit(1)
resp = response.choices[0].message["content"]
for plugin in cfg.plugins:
if not plugin.can_handle_on_response():
continue
resp = plugin.on_response(resp)
return resp
def get_ada_embedding(text: str) -> List[float]:
"""Get an embedding from the ada model.
Args:
text (str): The text to embed.
Returns:
List[float]: The embedding.
"""
cfg = Config()
model = "text-embedding-ada-002"
text = text.replace("\n", " ")
if cfg.use_azure:
kwargs = {"engine": cfg.get_azure_deployment_id_for_model(model)}
else:
kwargs = {"model": model}
embedding = create_embedding(text, **kwargs)
api_manager.update_cost(
prompt_tokens=embedding.usage.prompt_tokens,
completion_tokens=0,
model=model,
)
return embedding["data"][0]["embedding"]
@retry_openai_api()
def create_embedding(
text: str,
*_,
**kwargs,
) -> openai.Embedding:
"""Create an embedding using the OpenAI API
Args:
text (str): The text to embed.
kwargs: Other arguments to pass to the OpenAI API embedding creation call.
Returns:
openai.Embedding: The embedding object.
"""
cfg = Config()
return openai.Embedding.create(
input=[text],
api_key=cfg.openai_api_key,
**kwargs,
)
| [
"You are now the following python function: ```# PLACEHOLDER\nPLACEHOLDER```\n\nOnly respond with your `return` value."
] |
2024-01-10 | mrrobot16/taxapp-scripts | scripts~ask_me_tax_questions.py | import argparse
import os
import time
import openai
from dotenv import load_dotenv
load_dotenv()
from utils import *
openai_api_key = os.getenv("open_ai_api_key")
openai.api_key = openai_api_key
def log(x, y = None):
print(x,y)
def read_text_file(file_path):
try:
# Open the file in read mode
with open(file_path, 'r') as file:
# Read the entire content of the file
file_content = file.read()
# return the content here
return file_content
except FileNotFoundError:
print(f"File not found: {file_path}")
except Exception as e:
print(f"An error occurred: {str(e)}")
def write_file(file_path, content):
try:
# Open the file in write mode ('w')
with open(file_path, 'w') as file:
# Write the content to the file
file.write(content)
print(f"File written successfully at: {file_path}")
except Exception as e:
print(f"An error occurred: {str(e)}")
def main(args):
start_time = time.time()
prompt_file_path = str(args.prompt)
# propmpt_response_path = str(args.response)
prompt_file = prompt_file_path + '/prompt.txt'
prompt = read_text_file(prompt_file)
request_prompt = """""\nWhat forms do I need to file, receive, fill, request, attach, etc,
tell me everything I need to do in order to file taxes based on previous tax description?
In another line just return me the list of forms with corresponding IRS url of each form.
"""
# response = str(read_text_file(prompt_file)).count
response = gpt3_completion(prompt + request_prompt)
write_file(prompt_file_path + '/response.txt', str(response))
end_time = time.time() - start_time
print('Time Taken: ', time.time() - start_time)
if __name__ == '__main__':
parser = argparse.ArgumentParser(
prog='ProgramName',
description='What the program does',
epilog='Text at the bottom of help')
parser.add_argument('--prompt', type=str, required=True)
# parser.add_argument('--response', type=str, required=True)
args = parser.parse_args()
main(args) | [
"PLACEHOLDER/prompt.txt",
"\"\"\nWhat forms do I need to file, receive, fill, request, attach, etc, \n tell me everything I need to do in order to file taxes based on previous tax description?\n\n In another line just return me the list of forms with corresponding IRS url of each form.\n "
] |
2024-01-10 | MProfessor/ChatGPT | src~revChatGPT~V1.py | """
Standard ChatGPT
"""
from __future__ import annotations
import base64
import binascii
import contextlib
import json
import logging
import time
import uuid
from functools import wraps
from os import environ
from os import getenv
from pathlib import Path
from typing import AsyncGenerator
from typing import Generator
from typing import NoReturn
import httpx
import requests
from httpx import AsyncClient
from OpenAIAuth import Auth0 as Authenticator
from . import __version__
from . import typings as t
from .utils import create_completer
from .utils import create_session
from .utils import get_input
if __name__ == "__main__":
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(funcName)s - %(message)s",
)
log = logging.getLogger(__name__)
def logger(is_timed: bool):
"""Logger decorator
Args:
is_timed (bool): Whether to include function running time in exit log
Returns:
_type_: decorated function
"""
def decorator(func):
wraps(func)
def wrapper(*args, **kwargs):
log.debug(
"Entering %s with args %s and kwargs %s",
func.__name__,
args,
kwargs,
)
start = time.time()
out = func(*args, **kwargs)
end = time.time()
if is_timed:
log.debug(
"Exiting %s with return value %s. Took %s seconds.",
func.__name__,
out,
end - start,
)
else:
log.debug("Exiting %s with return value %s", func.__name__, out)
return out
return wrapper
return decorator
BASE_URL = environ.get("CHATGPT_BASE_URL") or "https://bypass.churchless.tech/"
bcolors = t.Colors()
class Chatbot:
"""
Chatbot class for ChatGPT
"""
@logger(is_timed=True)
def __init__(
self,
config: dict[str, str],
conversation_id: str | None = None,
parent_id: str | None = None,
lazy_loading: bool = True,
base_url: str | None = None,
) -> None:
"""Initialize a chatbot
Args:
config (dict[str, str]): Login and proxy info. Example:
{
"access_token": "<access_token>"
"proxy": "<proxy_url_string>",
"model": "<model_name>",
"plugin": "<plugin_id>",
}
More details on these are available at https://github.com/acheong08/ChatGPT#configuration
conversation_id (str | None, optional): Id of the conversation to continue on. Defaults to None.
parent_id (str | None, optional): Id of the previous response message to continue on. Defaults to None.
session_client (_type_, optional): _description_. Defaults to None.
Raises:
Exception: _description_
"""
user_home = getenv("HOME") or getenv("USERPROFILE")
if user_home is None:
user_home = Path().cwd()
self.cache_path = Path(Path().cwd(), ".chatgpt_cache.json")
else:
# mkdir ~/.config/revChatGPT
if not Path(user_home, ".config").exists():
Path(user_home, ".config").mkdir()
if not Path(user_home, ".config", "revChatGPT").exists():
Path(user_home, ".config", "revChatGPT").mkdir()
self.cache_path = Path(user_home, ".config", "revChatGPT", "cache.json")
self.config = config
self.session = requests.Session()
if "email" in config and "password" in config:
try:
cached_access_token = self.__get_cached_access_token(
self.config.get("email", None),
)
except t.Error as error:
if error.code == 5:
raise
cached_access_token = None
if cached_access_token is not None:
self.config["access_token"] = cached_access_token
if "proxy" in config:
if not isinstance(config["proxy"], str):
error = TypeError("Proxy must be a string!")
raise error
proxies = {
"http": config["proxy"],
"https": config["proxy"],
}
if isinstance(self.session, AsyncClient):
proxies = {
"http://": config["proxy"],
"https://": config["proxy"],
}
self.session = AsyncClient(proxies=proxies) # type: ignore
else:
self.session.proxies.update(proxies)
self.conversation_id = conversation_id or config.get("conversation_id", None)
self.parent_id = parent_id or config.get("parent_id", None)
self.conversation_mapping = {}
self.conversation_id_prev_queue = []
self.parent_id_prev_queue = []
self.lazy_loading = lazy_loading
self.base_url = base_url or BASE_URL
self.disable_history = config.get("disable_history", False)
self.__check_credentials()
@logger(is_timed=True)
def __check_credentials(self) -> None:
"""Check login info and perform login
Any one of the following is sufficient for login. Multiple login info can be provided at the same time and they will be used in the order listed below.
- access_token
- email + password
Raises:
Exception: _description_
AuthError: _description_
"""
if "access_token" in self.config:
self.set_access_token(self.config["access_token"])
elif "email" not in self.config or "password" not in self.config:
error = t.AuthenticationError("Insufficient login details provided!")
raise error
if "access_token" not in self.config:
try:
self.login()
except Exception as error:
print(error)
raise error
@logger(is_timed=False)
def set_access_token(self, access_token: str) -> None:
"""Set access token in request header and self.config, then cache it to file.
Args:
access_token (str): access_token
"""
self.session.headers.clear()
self.session.headers.update(
{
"Accept": "text/event-stream",
"Authorization": f"Bearer {access_token}",
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
},
)
self.config["access_token"] = access_token
email = self.config.get("email", None)
if email is not None:
self.__cache_access_token(email, access_token)
@logger(is_timed=False)
def __get_cached_access_token(self, email: str | None) -> str | None:
"""Read access token from cache
Args:
email (str | None): email of the account to get access token
Raises:
Error: _description_
Error: _description_
Error: _description_
Returns:
str | None: access token string or None if not found
"""
email = email or "default"
cache = self.__read_cache()
access_token = cache.get("access_tokens", {}).get(email, None)
# Parse access_token as JWT
if access_token is not None:
try:
# Split access_token into 3 parts
s_access_token = access_token.split(".")
# Add padding to the middle part
s_access_token[1] += "=" * ((4 - len(s_access_token[1]) % 4) % 4)
d_access_token = base64.b64decode(s_access_token[1])
d_access_token = json.loads(d_access_token)
except binascii.Error:
error = t.Error(
source="__get_cached_access_token",
message="Invalid access token",
code=t.ErrorType.INVALID_ACCESS_TOKEN_ERROR,
)
raise error from None
except json.JSONDecodeError:
error = t.Error(
source="__get_cached_access_token",
message="Invalid access token",
code=t.ErrorType.INVALID_ACCESS_TOKEN_ERROR,
)
raise error from None
exp = d_access_token.get("exp", None)
if exp is not None and exp < time.time():
error = t.Error(
source="__get_cached_access_token",
message="Access token expired",
code=t.ErrorType.EXPIRED_ACCESS_TOKEN_ERROR,
)
raise error
return access_token
@logger(is_timed=False)
def __cache_access_token(self, email: str, access_token: str) -> None:
"""Write an access token to cache
Args:
email (str): account email
access_token (str): account access token
"""
email = email or "default"
cache = self.__read_cache()
if "access_tokens" not in cache:
cache["access_tokens"] = {}
cache["access_tokens"][email] = access_token
self.__write_cache(cache)
@logger(is_timed=False)
def __write_cache(self, info: dict) -> None:
"""Write cache info to file
Args:
info (dict): cache info, current format
{
"access_tokens":{"[email protected]": 'this account's access token', }
}
"""
dirname = self.cache_path.home() or Path(".")
dirname.mkdir(parents=True, exist_ok=True)
json.dump(info, open(self.cache_path, "w", encoding="utf-8"), indent=4)
@logger(is_timed=False)
def __read_cache(self):
try:
cached = json.load(open(self.cache_path, encoding="utf-8"))
except (FileNotFoundError, json.decoder.JSONDecodeError):
cached = {}
return cached
@logger(is_timed=True)
def login(self) -> None:
"""Login to OpenAI by email and password"""
if not self.config.get("email") and not self.config.get("password"):
log.error("Insufficient login details provided!")
error = t.AuthenticationError("Insufficient login details provided!")
raise error
auth = Authenticator(
email=self.config.get("email"),
password=self.config.get("password"),
proxy=self.config.get("proxy"),
)
log.debug("Using authenticator to get access token")
self.set_access_token(auth.auth())
@logger(is_timed=True)
def __send_request(
self,
data: dict,
auto_continue: bool = False,
timeout: float = 360,
**kwargs,
) -> Generator[dict, None, None]:
log.debug("Sending the payload")
cid, pid = data["conversation_id"], data["parent_message_id"]
model, message = None, ""
self.conversation_id_prev_queue.append(cid)
self.parent_id_prev_queue.append(pid)
response = self.session.post(
url=f"{self.base_url}conversation",
data=json.dumps(data),
timeout=timeout,
stream=True,
)
self.__check_response(response)
finish_details = None
for line in response.iter_lines():
# remove b' and ' at the beginning and end and ignore case
line = str(line)[2:-1]
if line.lower() == "internal server error":
log.error(f"Internal Server Error: {line}")
error = t.Error(
source="ask",
message="Internal Server Error",
code=t.ErrorType.SERVER_ERROR,
)
raise error
if not line or line is None:
continue
if "data: " in line:
line = line[6:]
if line == "[DONE]":
break
# DO NOT REMOVE THIS
line = line.replace('\\"', '"')
line = line.replace("\\'", "'")
line = line.replace("\\\\", "\\")
try:
line = json.loads(line)
except json.decoder.JSONDecodeError:
continue
if not self.__check_fields(line):
raise ValueError(f"Field missing. Details: {str(line)}")
if line.get("message").get("author").get("role") != "assistant":
continue
cid = line["conversation_id"]
pid = line["message"]["id"]
metadata = line["message"].get("metadata", {})
message_exists = False
author = {}
if line.get("message"):
author = metadata.get("author", {}) or line["message"].get("author", {})
if line["message"].get("content"):
if line["message"]["content"].get("parts"):
if len(line["message"]["content"]["parts"]) > 0:
message_exists = True
message: str = (
line["message"]["content"]["parts"][0] if message_exists else ""
)
model = metadata.get("model_slug", None)
finish_details = metadata.get("finish_details", {"type": None})["type"]
yield {
"author": author,
"message": message,
"conversation_id": cid,
"parent_id": pid,
"model": model,
"finish_details": finish_details,
"end_turn": line["message"].get("end_turn", True),
"recipient": line["message"].get("recipient", "all"),
"citations": metadata.get("citations", []),
}
self.conversation_mapping[cid] = pid
if pid is not None:
self.parent_id = pid
if cid is not None:
self.conversation_id = cid
if not (auto_continue and finish_details == "max_tokens"):
return
message = message.strip("\n")
for i in self.continue_write(
conversation_id=cid,
timeout=timeout,
auto_continue=False,
):
i["message"] = message + i["message"]
yield i
@logger(is_timed=True)
def post_messages(
self,
messages: list[dict],
conversation_id: str | None = None,
parent_id: str | None = None,
plugin_ids: list = [],
model: str | None = None,
auto_continue: bool = False,
timeout: float = 360,
**kwargs,
) -> Generator[dict, None, None]:
"""Ask a question to the chatbot
Args:
messages (list[dict]): The messages to send
conversation_id (str | None, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str | None, optional): UUID for the message to continue on. Defaults to None.
model (str | None, optional): The model to use. Defaults to None.
auto_continue (bool, optional): Whether to continue the conversation automatically. Defaults to False.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Yields: Generator[dict, None, None] - The response from the chatbot
dict: {
"message": str,
"conversation_id": str,
"parent_id": str,
"model": str,
"finish_details": str, # "max_tokens" or "stop"
"end_turn": bool,
"recipient": str,
"citations": list[dict],
}
"""
if parent_id and not conversation_id:
raise t.Error(
source="User",
message="conversation_id must be set once parent_id is set",
code=t.ErrorType.USER_ERROR,
)
if conversation_id and conversation_id != self.conversation_id:
self.parent_id = None
conversation_id = conversation_id or self.conversation_id
parent_id = parent_id or self.parent_id or ""
if not conversation_id and not parent_id:
parent_id = str(uuid.uuid4())
if conversation_id and not parent_id:
if conversation_id not in self.conversation_mapping:
if self.lazy_loading:
log.debug(
"Conversation ID %s not found in conversation mapping, try to get conversation history for the given ID",
conversation_id,
)
try:
history = self.get_msg_history(conversation_id)
self.conversation_mapping[conversation_id] = history[
"current_node"
]
except requests.exceptions.HTTPError:
print("Conversation unavailable")
else:
self.__map_conversations()
if conversation_id in self.conversation_mapping:
parent_id = self.conversation_mapping[conversation_id]
else:
print(
"Warning: Invalid conversation_id provided, treat as a new conversation"
)
conversation_id = None
parent_id = str(uuid.uuid4())
data = {
"action": "next",
"messages": messages,
"conversation_id": conversation_id,
"parent_message_id": parent_id,
"model": model or self.config.get("model") or "text-davinci-002-render-sha",
"history_and_training_disabled": self.disable_history,
}
plugin_ids = self.config.get("plugin_ids", []) or plugin_ids
if len(plugin_ids) > 0 and not conversation_id:
data["plugin_ids"] = plugin_ids
yield from self.__send_request(
data,
timeout=timeout,
auto_continue=auto_continue,
)
@logger(is_timed=True)
def ask(
self,
prompt: str,
conversation_id: str | None = None,
parent_id: str = "",
model: str = "",
plugin_ids: list = [],
auto_continue: bool = False,
timeout: float = 360,
**kwargs,
) -> Generator[dict, None, None]:
"""Ask a question to the chatbot
Args:
prompt (str): The question
conversation_id (str, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str, optional): UUID for the message to continue on. Defaults to "".
model (str, optional): The model to use. Defaults to "".
auto_continue (bool, optional): Whether to continue the conversation automatically. Defaults to False.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Yields: The response from the chatbot
dict: {
"message": str,
"conversation_id": str,
"parent_id": str,
"model": str,
"finish_details": str, # "max_tokens" or "stop"
"end_turn": bool,
"recipient": str,
}
"""
messages = [
{
"id": str(uuid.uuid4()),
"role": "user",
"author": {"role": "user"},
"content": {"content_type": "text", "parts": [prompt]},
},
]
yield from self.post_messages(
messages,
conversation_id=conversation_id,
parent_id=parent_id,
plugin_ids=plugin_ids,
model=model,
auto_continue=auto_continue,
timeout=timeout,
)
@logger(is_timed=True)
def continue_write(
self,
conversation_id: str | None = None,
parent_id: str = "",
model: str = "",
auto_continue: bool = False,
timeout: float = 360,
) -> Generator[dict, None, None]:
"""let the chatbot continue to write.
Args:
conversation_id (str | None, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str, optional): UUID for the message to continue on. Defaults to None.
model (str, optional): The model to use. Defaults to None.
auto_continue (bool, optional): Whether to continue the conversation automatically. Defaults to False.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Yields:
dict: {
"message": str,
"conversation_id": str,
"parent_id": str,
"model": str,
"finish_details": str, # "max_tokens" or "stop"
"end_turn": bool,
"recipient": str,
}
"""
if parent_id and not conversation_id:
raise t.Error(
source="User",
message="conversation_id must be set once parent_id is set",
code=t.ErrorType.USER_ERROR,
)
if conversation_id and conversation_id != self.conversation_id:
self.parent_id = None
conversation_id = conversation_id or self.conversation_id
parent_id = parent_id or self.parent_id or ""
if not conversation_id and not parent_id:
parent_id = str(uuid.uuid4())
if conversation_id and not parent_id:
if conversation_id not in self.conversation_mapping:
if self.lazy_loading:
log.debug(
"Conversation ID %s not found in conversation mapping, try to get conversation history for the given ID",
conversation_id,
)
with contextlib.suppress(Exception):
history = self.get_msg_history(conversation_id)
self.conversation_mapping[conversation_id] = history[
"current_node"
]
else:
log.debug(
f"Conversation ID {conversation_id} not found in conversation mapping, mapping conversations",
)
self.__map_conversations()
if conversation_id in self.conversation_mapping:
parent_id = self.conversation_mapping[conversation_id]
else: # invalid conversation_id provided, treat as a new conversation
conversation_id = None
parent_id = str(uuid.uuid4())
data = {
"action": "continue",
"conversation_id": conversation_id,
"parent_message_id": parent_id,
"model": model
or self.config.get("model")
or (
"text-davinci-002-render-paid"
if self.config.get("paid")
else "text-davinci-002-render-sha"
),
"history_and_training_disabled": self.disable_history,
}
yield from self.__send_request(
data,
timeout=timeout,
auto_continue=auto_continue,
)
@logger(is_timed=False)
def __check_fields(self, data: dict) -> bool:
try:
data["message"]["content"]
except (TypeError, KeyError):
return False
return True
@logger(is_timed=False)
def __check_response(self, response: requests.Response) -> None:
"""Make sure response is success
Args:
response (_type_): _description_
Raises:
Error: _description_
"""
try:
response.raise_for_status()
except requests.exceptions.HTTPError as ex:
error = t.Error(
source="OpenAI",
message=response.text,
code=response.status_code,
)
raise error from ex
@logger(is_timed=True)
def get_conversations(
self,
offset: int = 0,
limit: int = 20,
encoding: str | None = None,
) -> list:
"""
Get conversations
:param offset: Integer
:param limit: Integer
"""
url = f"{self.base_url}conversations?offset={offset}&limit={limit}"
response = self.session.get(url)
self.__check_response(response)
if encoding is not None:
response.encoding = encoding
data = json.loads(response.text)
return data["items"]
@logger(is_timed=True)
def get_msg_history(self, convo_id: str, encoding: str | None = None) -> list:
"""
Get message history
:param id: UUID of conversation
:param encoding: String
"""
url = f"{self.base_url}conversation/{convo_id}"
response = self.session.get(url)
self.__check_response(response)
if encoding is not None:
response.encoding = encoding
return response.json()
@logger(is_timed=True)
def gen_title(self, convo_id: str, message_id: str) -> str:
"""
Generate title for conversation
"""
response = self.session.post(
f"{self.base_url}conversation/gen_title/{convo_id}",
data=json.dumps(
{"message_id": message_id, "model": "text-davinci-002-render"},
),
)
self.__check_response(response)
return response.json().get("title", "Error generating title")
@logger(is_timed=True)
def change_title(self, convo_id: str, title: str) -> None:
"""
Change title of conversation
:param id: UUID of conversation
:param title: String
"""
url = f"{self.base_url}conversation/{convo_id}"
response = self.session.patch(url, data=json.dumps({"title": title}))
self.__check_response(response)
@logger(is_timed=True)
def delete_conversation(self, convo_id: str) -> None:
"""
Delete conversation
:param id: UUID of conversation
"""
url = f"{self.base_url}conversation/{convo_id}"
response = self.session.patch(url, data='{"is_visible": false}')
self.__check_response(response)
@logger(is_timed=True)
def clear_conversations(self) -> None:
"""
Delete all conversations
"""
url = f"{self.base_url}conversations"
response = self.session.patch(url, data='{"is_visible": false}')
self.__check_response(response)
@logger(is_timed=False)
def __map_conversations(self) -> None:
conversations = self.get_conversations()
histories = [self.get_msg_history(x["id"]) for x in conversations]
for x, y in zip(conversations, histories):
self.conversation_mapping[x["id"]] = y["current_node"]
@logger(is_timed=False)
def reset_chat(self) -> None:
"""
Reset the conversation ID and parent ID.
:return: None
"""
self.conversation_id = None
self.parent_id = str(uuid.uuid4())
@logger(is_timed=False)
def rollback_conversation(self, num: int = 1) -> None:
"""
Rollback the conversation.
:param num: Integer. The number of messages to rollback
:return: None
"""
for _ in range(num):
self.conversation_id = self.conversation_id_prev_queue.pop()
self.parent_id = self.parent_id_prev_queue.pop()
@logger(is_timed=True)
def get_plugins(self, offset: int = 0, limit: int = 250, status: str = "approved"):
url = f"{self.base_url}aip/p?offset={offset}&limit={limit}&statuses={status}"
response = self.session.get(url)
self.__check_response(response)
# Parse as JSON
return json.loads(response.text)
@logger(is_timed=True)
def install_plugin(self, plugin_id: str):
url = f"{self.base_url}aip/p/{plugin_id}/user-settings"
payload = {"is_installed": True}
response = self.session.patch(url, data=json.dumps(payload))
self.__check_response(response)
class AsyncChatbot(Chatbot):
"""Async Chatbot class for ChatGPT"""
def __init__(
self,
config: dict,
conversation_id: str | None = None,
parent_id: str = "",
base_url: str = "",
) -> None:
"""
Same as Chatbot class, but with async methods.
"""
super().__init__(
config=config,
conversation_id=conversation_id,
parent_id=parent_id,
base_url=base_url,
)
# overwrite inherited normal session with async
self.session = AsyncClient(headers=self.session.headers)
async def __send_request(
self,
data: dict,
auto_continue: bool = False,
timeout: float = 360,
) -> AsyncGenerator[dict, None]:
cid, pid = data["conversation_id"], data["parent_message_id"]
self.conversation_id_prev_queue.append(cid)
self.parent_id_prev_queue.append(pid)
message = ""
finish_details = None
response = None
async with self.session.stream(
method="POST",
url=f"{self.base_url}conversation",
data=json.dumps(data),
timeout=timeout,
) as response:
await self.__check_response(response)
async for line in response.aiter_lines():
if not line or line is None:
continue
if "data: " in line:
line = line[6:]
if "[DONE]" in line:
break
# DO NOT REMOVE THIS
line = line.replace('\\"', '"')
line = line.replace("\\'", "'")
line = line.replace("\\\\", "\\")
try:
line = json.loads(line)
except json.decoder.JSONDecodeError:
continue
if not self.__check_fields(line):
raise ValueError(f"Field missing. Details: {str(line)}")
if line.get("message").get("author").get("role") != "assistant":
continue
message: str = line["message"]["content"]["parts"][0]
cid = line["conversation_id"]
pid = line["message"]["id"]
metadata = line["message"].get("metadata", {})
message_exists = False
author = {}
if line.get("message"):
author = metadata.get("author", {}) or line["message"].get(
"author", {}
)
if line["message"].get("content"):
if line["message"]["content"].get("parts"):
if len(line["message"]["content"]["parts"]) > 0:
message_exists = True
message: str = (
line["message"]["content"]["parts"][0] if message_exists else ""
)
model = metadata.get("model_slug", None)
finish_details = metadata.get("finish_details", {"type": None})["type"]
yield {
"author": author,
"message": message,
"conversation_id": cid,
"parent_id": pid,
"model": model,
"finish_details": finish_details,
"end_turn": line["message"].get("end_turn", True),
"recipient": line["message"].get("recipient", "all"),
"citations": metadata.get("citations", []),
}
self.conversation_mapping[cid] = pid
if pid:
self.parent_id = pid
if cid:
self.conversation_id = cid
if not (auto_continue and finish_details == "max_tokens"):
return
async for msg in self.continue_write(
conversation_id=cid,
auto_continue=False,
timeout=timeout,
):
msg["message"] = message + msg["message"]
yield msg
async def post_messages(
self,
messages: list[dict],
conversation_id: str | None = None,
parent_id: str = "",
plugin_ids: list = [],
model: str = "",
auto_continue: bool = False,
timeout: int = 360,
) -> AsyncGenerator[dict, None]:
"""Post messages to the chatbot
Args:
messages (list[dict]): the messages to post
conversation_id (str | None, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str, optional): UUID for the message to continue on. Defaults to "".
model (str, optional): The model to use. Defaults to "".
auto_continue (bool, optional): Whether to continue the conversation automatically. Defaults to False.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Yields:
AsyncGenerator[dict, None]: The response from the chatbot
{
"message": str,
"conversation_id": str,
"parent_id": str,
"model": str,
"finish_details": str,
"end_turn": bool,
"recipient": str,
}
"""
if parent_id and not conversation_id:
error = t.Error(
source="User",
message="conversation_id must be set once parent_id is set",
code=t.ErrorType.SERVER_ERROR,
)
raise error
if conversation_id and conversation_id != self.conversation_id:
self.parent_id = None
conversation_id = conversation_id or self.conversation_id
parent_id = parent_id or self.parent_id or ""
if not conversation_id and not parent_id:
parent_id = str(uuid.uuid4())
if conversation_id and not parent_id:
if conversation_id not in self.conversation_mapping:
await self.__map_conversations()
if conversation_id in self.conversation_mapping:
parent_id = self.conversation_mapping[conversation_id]
else: # invalid conversation_id provided, treat as a new conversation
conversation_id = None
parent_id = str(uuid.uuid4())
data = {
"action": "next",
"messages": messages,
"conversation_id": conversation_id,
"parent_message_id": parent_id,
"model": model
or self.config.get("model")
or (
"text-davinci-002-render-paid"
if self.config.get("paid")
else "text-davinci-002-render-sha"
),
"history_and_training_disabled": self.disable_history,
}
plugin_ids = self.config.get("plugin_ids", []) or plugin_ids
if len(plugin_ids) > 0 and not conversation_id:
data["plugin_ids"] = plugin_ids
async for msg in self.__send_request(
data=data,
auto_continue=auto_continue,
timeout=timeout,
):
yield msg
async def ask(
self,
prompt: str,
conversation_id: str | None = None,
parent_id: str = "",
model: str = "",
plugin_ids: list = [],
auto_continue: bool = False,
timeout: int = 360,
**kwargs,
) -> AsyncGenerator[dict, None]:
"""Ask a question to the chatbot
Args:
prompt (str): The question to ask
conversation_id (str | None, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str, optional): UUID for the message to continue on. Defaults to "".
model (str, optional): The model to use. Defaults to "".
auto_continue (bool, optional): Whether to continue the conversation automatically. Defaults to False.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Yields:
AsyncGenerator[dict, None]: The response from the chatbot
{
"message": str,
"conversation_id": str,
"parent_id": str,
"model": str,
"finish_details": str,
"end_turn": bool,
"recipient": str,
}
"""
messages = [
{
"id": str(uuid.uuid4()),
"author": {"role": "user"},
"content": {"content_type": "text", "parts": [prompt]},
},
]
async for msg in self.post_messages(
messages=messages,
conversation_id=conversation_id,
parent_id=parent_id,
plugin_ids=plugin_ids,
model=model,
auto_continue=auto_continue,
timeout=timeout,
):
yield msg
async def continue_write(
self,
conversation_id: str | None = None,
parent_id: str = "",
model: str = "",
auto_continue: bool = False,
timeout: float = 360,
) -> AsyncGenerator[dict, None]:
"""let the chatbot continue to write
Args:
conversation_id (str | None, optional): UUID for the conversation to continue on. Defaults to None.
parent_id (str, optional): UUID for the message to continue on. Defaults to None.
model (str, optional): Model to use. Defaults to None.
auto_continue (bool, optional): Whether to continue writing automatically. Defaults to False.
timeout (float, optional): Timeout for getting the full response, unit is second. Defaults to 360.
Yields:
AsyncGenerator[dict, None]: The response from the chatbot
{
"message": str,
"conversation_id": str,
"parent_id": str,
"model": str,
"finish_details": str,
"end_turn": bool,
"recipient": str,
}
"""
if parent_id and not conversation_id:
error = t.Error(
source="User",
message="conversation_id must be set once parent_id is set",
code=t.ErrorType.SERVER_ERROR,
)
raise error
if conversation_id and conversation_id != self.conversation_id:
self.parent_id = None
conversation_id = conversation_id or self.conversation_id
parent_id = parent_id or self.parent_id or ""
if not conversation_id and not parent_id:
parent_id = str(uuid.uuid4())
if conversation_id and not parent_id:
if conversation_id not in self.conversation_mapping:
await self.__map_conversations()
if conversation_id in self.conversation_mapping:
parent_id = self.conversation_mapping[conversation_id]
else: # invalid conversation_id provided, treat as a new conversation
conversation_id = None
parent_id = str(uuid.uuid4())
data = {
"action": "continue",
"conversation_id": conversation_id,
"parent_message_id": parent_id,
"model": model
or self.config.get("model")
or (
"text-davinci-002-render-paid"
if self.config.get("paid")
else "text-davinci-002-render-sha"
),
"history_and_training_disabled": self.disable_history,
}
async for msg in self.__send_request(
data=data,
auto_continue=auto_continue,
timeout=timeout,
):
yield msg
async def get_conversations(self, offset: int = 0, limit: int = 20) -> list:
"""
Get conversations
:param offset: Integer
:param limit: Integer
"""
url = f"{self.base_url}conversations?offset={offset}&limit={limit}"
response = await self.session.get(url)
await self.__check_response(response)
data = json.loads(response.text)
return data["items"]
async def get_msg_history(
self,
convo_id: str,
encoding: str | None = "utf-8",
) -> dict:
"""
Get message history
:param id: UUID of conversation
"""
url = f"{self.base_url}conversation/{convo_id}"
response = await self.session.get(url)
if encoding is not None:
response.encoding = encoding
await self.__check_response(response)
return json.loads(response.text)
return None
async def gen_title(self, convo_id: str, message_id: str) -> None:
"""
Generate title for conversation
"""
url = f"{self.base_url}conversation/gen_title/{convo_id}"
response = await self.session.post(
url,
data=json.dumps(
{"message_id": message_id, "model": "text-davinci-002-render"},
),
)
await self.__check_response(response)
async def change_title(self, convo_id: str, title: str) -> None:
"""
Change title of conversation
:param convo_id: UUID of conversation
:param title: String
"""
url = f"{self.base_url}conversation/{convo_id}"
response = await self.session.patch(url, data=f'{{"title": "{title}"}}')
await self.__check_response(response)
async def delete_conversation(self, convo_id: str) -> None:
"""
Delete conversation
:param convo_id: UUID of conversation
"""
url = f"{self.base_url}conversation/{convo_id}"
response = await self.session.patch(url, data='{"is_visible": false}')
await self.__check_response(response)
async def clear_conversations(self) -> None:
"""
Delete all conversations
"""
url = f"{self.base_url}conversations"
response = await self.session.patch(url, data='{"is_visible": false}')
await self.__check_response(response)
async def __map_conversations(self) -> None:
conversations = await self.get_conversations()
histories = [await self.get_msg_history(x["id"]) for x in conversations]
for x, y in zip(conversations, histories):
self.conversation_mapping[x["id"]] = y["current_node"]
def __check_fields(self, data: dict) -> bool:
try:
data["message"]["content"]
except (TypeError, KeyError):
return False
return True
async def __check_response(self, response: httpx.Response) -> None:
# 改成自带的错误处理
try:
response.raise_for_status()
except httpx.HTTPStatusError as ex:
await response.aread()
error = t.Error(
source="OpenAI",
message=response.text,
code=response.status_code,
)
raise error from ex
get_input = logger(is_timed=False)(get_input)
@logger(is_timed=False)
def configure() -> dict:
"""
Looks for a config file in the following locations:
"""
config_files: list[Path] = [Path("config.json")]
if xdg_config_home := getenv("XDG_CONFIG_HOME"):
config_files.append(Path(xdg_config_home, "revChatGPT/config.json"))
if user_home := getenv("HOME"):
config_files.append(Path(user_home, ".config/revChatGPT/config.json"))
if windows_home := getenv("HOMEPATH"):
config_files.append(Path(f"{windows_home}/.config/revChatGPT/config.json"))
if config_file := next((f for f in config_files if f.exists()), None):
with open(config_file, encoding="utf-8") as f:
config = json.load(f)
else:
print("No config file found.")
raise FileNotFoundError("No config file found.")
return config
@logger(is_timed=False)
def main(config: dict) -> NoReturn:
"""
Main function for the chatGPT program.
"""
chatbot = Chatbot(
config,
conversation_id=config.get("conversation_id"),
parent_id=config.get("parent_id"),
)
def handle_commands(command: str) -> bool:
if command == "!help":
print(
"""
!help - Show this message
!reset - Forget the current conversation
!config - Show the current configuration
!plugins - Show the current plugins
!switch x - Switch to plugin x. Need to reset the conversation to ativate the plugin.
!rollback x - Rollback the conversation (x being the number of messages to rollback)
!setconversation - Changes the conversation
!exit - Exit this program
""",
)
elif command == "!reset":
chatbot.reset_chat()
print("Chat session successfully reset.")
elif command == "!config":
print(json.dumps(chatbot.config, indent=4))
elif command.startswith("!rollback"):
try:
rollback = int(command.split(" ")[1])
except IndexError:
logging.exception(
"No number specified, rolling back 1 message",
stack_info=True,
)
rollback = 1
chatbot.rollback_conversation(rollback)
print(f"Rolled back {rollback} messages.")
elif command.startswith("!setconversation"):
try:
chatbot.conversation_id = chatbot.config[
"conversation_id"
] = command.split(" ")[1]
print("Conversation has been changed")
except IndexError:
log.exception(
"Please include conversation UUID in command",
stack_info=True,
)
print("Please include conversation UUID in command")
elif command.startswith("!continue"):
print()
print(f"{bcolors.OKGREEN + bcolors.BOLD}Chatbot: {bcolors.ENDC}")
prev_text = ""
for data in chatbot.continue_write():
message = data["message"][len(prev_text) :]
print(message, end="", flush=True)
prev_text = data["message"]
print(bcolors.ENDC)
print()
elif command == "!exit":
if isinstance(chatbot.session, httpx.AsyncClient):
chatbot.session.aclose()
exit()
else:
return False
return True
session = create_session()
completer = create_completer(
[
"!help",
"!reset",
"!config",
"!rollback",
"!exit",
"!setconversation",
"!continue",
"!plugins",
"!switch",
],
)
print()
try:
result = {}
while True:
print(f"{bcolors.OKBLUE + bcolors.BOLD}You: {bcolors.ENDC}")
prompt = get_input(session=session, completer=completer)
if prompt.startswith("!") and handle_commands(prompt):
continue
print()
print(f"{bcolors.OKGREEN + bcolors.BOLD}Chatbot: {bcolors.ENDC}")
if chatbot.config.get("model") == "gpt-4-browsing":
print("Browsing takes a while, please wait...")
prev_text = ""
for data in chatbot.ask(prompt=prompt, auto_continue=True):
if data["recipient"] != "all":
continue
result = data
message = data["message"][len(prev_text) :]
print(message, end="", flush=True)
prev_text = data["message"]
print(bcolors.ENDC)
print()
if result.get("citations", False):
print(
f"{bcolors.WARNING + bcolors.BOLD}Citations: {bcolors.ENDC}",
)
for citation in result["citations"]:
print(
f'{citation["metadata"]["title"]}: {citation["metadata"]["url"]}',
)
print()
except (KeyboardInterrupt, EOFError):
exit()
except Exception as exc:
error = t.CLIError("command line program unknown error")
raise error from exc
if __name__ == "__main__":
print(
f"""
ChatGPT - A command-line interface to OpenAI's ChatGPT (https://chat.openai.com/chat)
Repo: github.com/acheong08/ChatGPT
Version: {__version__}
""",
)
print("Type '!help' to show a full list of commands")
print(
f"{bcolors.BOLD}{bcolors.WARNING}Press Esc followed by Enter or Alt+Enter to send a message.{bcolors.ENDC}",
)
main(configure())
| [
"text",
"content_type"
] |
2024-01-10 | intrastella/tabular_search_engine | tabular_search~request_engine.py | #!/usr/bin/env python3
import ast
import argparse
import csv
import os
import pandas as pd
import pinecone
import re
import requests
import tiktoken
import yaml
from pathlib import Path
from typing import List
from uuid import uuid4
from langchain import PromptTemplate
from langchain import FewShotPromptTemplate
from langchain.chains import RetrievalQAWithSourcesChain
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.document_loaders import WebBaseLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.utilities import BingSearchAPIWrapper
from langchain.vectorstores import Pinecone
from langchain.text_splitter import RecursiveCharacterTextSplitter
class PreviewModel:
def __init__(self,
openai_api_key: List[str],
bing_api_key: List[str],
name: str,
rows: List[str],
columns: List[str] = None,
destination_file: str = None):
"""
Creates a metadata table.
:param api_key: key of openai key
:param rows: Request that requires a list as a return. Ex.: List all major oil producers in 2020.
:param columns: List of all demanded information for each row.
Ex.: [Size of Company, Company income per year] - for each major oil producers in 2020
"""
self.name = name
self.rows = ' '.join(rows)
self.columns = str(columns) if columns else '[]'
self.destination = destination_file
self.openai_api_key = openai_api_key[0]
os.environ['OPENAI_API_KEY'] = openai_api_key[0]
os.environ["BING_SUBSCRIPTION_KEY"] = bing_api_key[0]
os.environ["BING_SEARCH_URL"] = "https://api.bing.microsoft.com/v7.0/search"
self.turbo = OpenAI(model_name="gpt-3.5-turbo", temperature=0.2)
self.request = ' '.join(rows) + ' Provide additional information about: ' + ', '.join(columns)
self.prompt_template = None
self.vec_retrieve = None
self.template = None
self.examples = None
self.prefix = None
self.suffix = None
self.load_templates()
def get_bing_result(self, num_res: int = 15):
"""
:param num_res: number of allowed results
:return:
"""
search = BingSearchAPIWrapper(k=num_res)
# txt_res = search.run(self.request)
data_res = search.results(self.request, num_res)
urls = [data_res[i]['link'] for i in range(len(data_res))]
checked_urls = self.check_url_exists(urls)
loader = WebBaseLoader(checked_urls)
data = loader.load()
# data[1].page_content = 'oiuhoci'
# data[1].metadata = {'source': ..., 'title': ..., 'description': ..., 'language': ... }
return data
@staticmethod
def check_url_exists(urls: List[str]):
checked_urls = []
for url in urls:
try:
if requests.head(url, allow_redirects=True).status_code == 200:
checked_urls.append(url)
except: pass
return checked_urls
@staticmethod
def retrieve():
from datasets import load_dataset
data = load_dataset("wikipedia", "20220301.simple", split='train[:10000]')
return data
def load_templates(self):
script_path = Path(__file__).parents[1].resolve()
with open(script_path / 'prompt_template/example_template.txt', 'r') as file:
self.template = file.read().replace('\n', ' \n ')
with open(script_path / 'prompt_template/prefix.txt', 'r') as file:
self.prefix = file.read().replace('\n', ' \n ')
with open(script_path / 'prompt_template/suffix.txt', 'r') as file:
self.suffix = file.read().replace('\n', ' \n ')
with open(script_path / 'prompt_template/examples.yaml', 'r') as file:
self.examples = yaml.safe_load(file)
self.examples = [self.examples[k] for k in self.examples.keys()]
def get_template(self):
"""
query_item : rows = user request
query_entries: columns = add infos
answer: model answer
:return:
"""
example = 'Request Item List: {question} Columns Names: {query_entries} Answer: {answer}'
ex_string = example.format(**self.examples[0])
partial_s = self.suffix.format(query_entries=self.columns, context='{context}', question='{question}')
temp = self.prefix + ' \n The following is an example: ' + ex_string + ' \n ' + partial_s
self.prompt_template = PromptTemplate(template=temp,
input_variables=['context', 'question'])
def retrieval(self):
data = self.get_bing_result()
self.vec_retrieve = RAG(data=data, openai_api_key=self.openai_api_key)
self.vec_retrieve.setup()
self.vec_retrieve.setup_storage()
def get_answer(self):
script_path = Path(__file__).parent.resolve()
self.retrieval()
qa_with_sources = self.vec_retrieve.GQA_Source(
self.turbo,
self.prompt_template
)
res = qa_with_sources.run(self.rows)
out = self.parse_output(res)
self.save_csv(out)
df = pd.DataFrame()
for col in ast.literal_eval(res[12:])[0].keys():
df[col] = 0
for elem in ast.literal_eval(res[12:]):
df.loc[len(df)] = elem
if self.destination:
df.to_excel(self.destination, index_label='id')
else:
df.to_excel(script_path / f'output_tables/{self.name}.xlsx', index_label='id')
def save_csv(self, output):
script_path = Path(__file__).parent.resolve()
with open(script_path / f'output_csv/{self.name}.csv', 'w', newline='') as file:
writer = csv.writer(file)
writer.writerow(output)
@staticmethod
def parse_output(output):
parsed_out = ''
column_names = None
while output:
m = re.search('{(.+?)}', output)
if m:
parsed_out += '{' + m.group(1) + '}'
output = output[m.span()[1]:]
if not column_names:
column_names = list(ast.literal_eval(parsed_out).keys())
else:
output = ''
return '[' + str(column_names) + parsed_out + ']'
def run(self):
self.get_template()
self.get_answer()
class RAG:
def __init__(self, data, openai_api_key):
self.data = data
self.openai_api_key = openai_api_key
self.tokenizer = tiktoken.get_encoding('p50k_base')
# os.environ['OPENAI_API_KEY'] = openai_api_key[0]
self.embed = None
self.index = None
self.vectorstore = None
self.index_name = 'langchain-retrieval-augmentation'
def setup(self):
# sub_data = self.data[6]['text']
sub_data = self.data[0].page_content
text_splitter = self.divide_txt()
chunks = text_splitter.split_text(sub_data)[:3]
embed = self.get_embedding(chunks)
self.pinecone_index(embed, new=True)
self.add_data_2_index()
def tiktoken_len(self, text: str):
tokens = self.tokenizer.encode(
text,
disallowed_special=()
)
return len(tokens)
def divide_txt(self):
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=400,
chunk_overlap=20,
length_function=self.tiktoken_len,
separators=["\n\n", "\n", " ", ""]
)
return text_splitter
def get_embedding(self, texts: List[str]):
model_name = 'text-embedding-ada-002'
self.embed = OpenAIEmbeddings(
document_model_name=model_name,
query_model_name=model_name,
openai_api_key=self.openai_api_key
)
return self.embed.embed_documents(texts)
def pinecone_index(self, embedded_txt, new=False):
pinecone.init(
api_key="1ea8696f-0f2c-4510-bc3f-1e198071b2b0",
environment="gcp-starter"
)
if new:
pinecone.delete_index(name=self.index_name)
pinecone.create_index(
name=self.index_name,
metric='dotproduct',
dimension=len(embedded_txt[0])
)
self.get_index()
def get_index(self):
# connect to the new index
self.index = pinecone.GRPCIndex(self.index_name)
self.index.describe_index_stats()
def setup_storage(self):
text_field = "text"
index = pinecone.Index(self.index_name)
self.vectorstore = Pinecone(
index, self.embed.embed_query, text_field
)
def add_data_2_index(self):
batch_limit = 100
texts = []
metadatas = []
# data[1].page_content = 'oiuhoci'
# data[1].metadata = {'source': ..., 'title': ..., 'description': ..., 'language': ... }
for i, record in enumerate(self.data):
if (record.metadata['source'].split('.')[-1] != 'pdf') and ('title' in record.metadata.keys()):
metadata = {
'id': str(i),
'source': record.metadata['source'],
'title': record.metadata['title']
}
text_splitter = self.divide_txt()
# record_texts = text_splitter.split_text(record['text'])
record_texts = text_splitter.split_text(record.page_content)
record_metadatas = [{
"chunk": j, "text": text, **metadata
} for j, text in enumerate(record_texts)]
texts.extend(record_texts)
metadatas.extend(record_metadatas)
if len(texts) >= batch_limit:
ids = [str(uuid4()) for _ in range(len(texts))]
embeds = self.get_embedding(texts)
self.index.upsert(vectors=zip(ids, embeds, metadatas))
texts = []
metadatas = []
def similarity_search(self, query):
self.vectorstore.similarity_search(
query,
k=3
)
def GQA(self, query, llm, prompt_template):
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=self.vectorstore.as_retriever(),
chain_type_kwargs=dict(prompt=prompt_template)
)
return qa.run(query)
def GQA_Source(self, llm, prompt_template):
chain_type_kwargs = {"prompt": prompt_template}
qa_with_sources = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=self.vectorstore.as_retriever(),
chain_type_kwargs=chain_type_kwargs)
'''qa_with_sources = RetrievalQAWithSourcesChain.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=self.vectorstore.as_retriever(),
chain_type_kwargs=dict(prompt=prompt_template)
)'''
return qa_with_sources
| [] |
2024-01-10 | intrastella/tabular_search_engine | tabular_search~__main__.py | import argparse
import warnings
from request_engine import PreviewModel
warnings.filterwarnings("ignore")
parser = argparse.ArgumentParser()
parser.add_argument("-o_key", "--openai_api_key", help="API key from OpenAI.", required=True, nargs='+')
parser.add_argument("-b_key", "--bing_api_key", help="API key from Bing.", required=True, nargs='+')
parser.add_argument("-n", "--o_name", help="File name of excel.", dest="name", required=True)
parser.add_argument("-r", "--request", help="Your request.", dest="rows", required=True, nargs='+')
parser.add_argument("-add", "--add_info", help="Required additional info to your request.", dest="columns",
required=False, nargs='+')
args = parser.parse_args()
pm = PreviewModel(**vars(args))
pm.run()
| [] |
2024-01-10 | gongfuchang/dansearch | src~prep~build_rag_index.py | """
Reads vault dictionary, creates embeddings for each chunk, and creates a rag index.
"""
import pickle
from typing import List
import numpy as np
import torch.nn.functional as F
from src.logger import logger
from src.utils.model_util import get_model_tuple, get_device, average_pool
from src.prep.build_vault_dict import get_vault
import pinecone
import tiktoken
import openai
# initialize connection to pinecone (get API key at app.pinecone.io)
PINECONE_API_KEY = "1abe81c4-be22-4f43-83c8-e10a7c6905ff"
# find your environment next to the api key in pinecone console
PINECONE_ENV = "us-west4-gcp-free"
INDEX_NAME = 'chess-kb'
# Prepare pinecone client and tokenizer
pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_ENV)
pinecone.whoami()
pinecone_index = pinecone.Index(INDEX_NAME)
embed_model = "embd-ada2"
tokenizer = tiktoken.encoding_for_model("gpt-3.5-turbo")
def build_batch_embeddings(document_batch) :
"""Embed a batch of documents
Args:
document_batch: List of documents to embed
tokenizer: Tokenizer to tokenize documents; should be compatible with model
model: Model to embed documents
Returns:
List of document embeddings
"""
batch = document_batch
values_batch = openai.Embedding.create(
input=[' '.join(doc[1]['chunk'].split()) for doc in batch],
engine=embed_model
)
values_batch = tokenizer.encode_batch()
encoded_batch = [(document_batch[index][0], val, document_batch[index][1]) for index, val in enumerate(values_batch)]
pinecone_index.upsert(encoded_batch)
def assembly_embedding_index(vault: dict) -> dict[int, str]:
"""Build an index that maps document embedding row index to document chunk-id.
Used to retrieve document id after ANN on document embeddings.
Args:
vault: Dictionary of vault documents
Returns:
Mapping of document embedding row index to document chunk-id
"""
embedding_index = dict()
embedding_idx = 0
for chunk_id, doc in vault.items():
if doc['type'] == 'doc':
continue # Skip embedding full docs as they are too long for semantic search and take a long time
embedding_index[embedding_idx] = chunk_id
embedding_idx += 1
return embedding_index
def build_embedding(vault: dict, batch_size=200):
"""Embedding all document chunks and return embedding array
Args:
vault: Dictionary of vault documents
batch_size: Size of document batch to embed each time. Defaults to 4.
"""
docs_embedded = 0
chunk_batch = []
chunks_batched = 0
embedding_list = []
for chunk_id, chunk in vault.items():
if chunk['type'] == 'doc':
continue # Skip embedding full docs as they are too long for semantic search and take a long time
# Get path and chunks
if docs_embedded % 100 == 0:
logger.info(f'Embedding document: {chunk_id} ({docs_embedded:,})')
docs_embedded += 1
# chunk = ' '.join(doc['chunk'].split() # Remove extra whitespace and add prefix
# logger.info(f'Chunk: {processed_chunk}')
chunk_batch.append([chunk_id, chunk]) # Add chunk to batch
chunks_batched += 1
if chunks_batched % batch_size == 0:
# Compute embeddings in batch and append to list of embeddings
build_batch_embeddings(chunk_batch)
# Reset batch
chunks_batched = 0
chunk_batch = []
# Add any remaining chunks to batch
if chunks_batched > 0:
build_batch_embeddings(chunk_batch)
def query_rag(query, tokenizer, model, doc_embeddings_array, n_results=3):
query_tokenized = tokenizer(f'query: {query}', max_length=512, padding=False, truncation=True, return_tensors='pt').to(get_device())
outputs = model(**query_tokenized)
query_embedding = average_pool(outputs.last_hidden_state, query_tokenized['attention_mask'])
query_embedding = F.normalize(query_embedding, p=2, dim=1).detach().cpu().numpy()
cos_sims = np.dot(doc_embeddings_array, query_embedding.T)
cos_sims = cos_sims.flatten()
top_indices = np.argsort(cos_sims)[-n_results:][::-1]
return top_indices
if __name__ == '__main__':
# Load docs
vault = get_vault()
logger.info(f'Vault length: {len(vault):,}')
# Build and save embedding index
embedding_index = assembly_embedding_index(vault)
logger.info(f'Embedding index length: {len(embedding_index):,}')
build_embedding(vault)
| [] |
2024-01-10 | iwangjian/TopDial | dialog_simulation.py | # -*- coding: utf-8 -*-
import time
import json
import os
import random
import argparse
from tqdm import tqdm
from chatarena.agent import Player, Moderator
from chatarena.backends import OpenAIChat
from chatarena.environments.conversation import ModeratedConversation
from chatarena.arena import Arena
from data_utils import find_word_in_string
from instruction import create_instruct
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--cached_seed_path", type=str, required=True,
help="The cached seed dialog file.")
parser.add_argument("--profile_path", type=str, default="seed_dataset/caches/db_slot/slot_profiles.json",
help="The user profile slot-values file.")
parser.add_argument("--output_dir", type=str, default="data/TopDial",
help="The output directory to save the simulated dialog data.")
parser.add_argument("--max_interaction_step", type=int,default=12,
help="The max number of interaction steps, i.e., 2 * max rounds.")
parser.add_argument("--model_name", type=str, default="gpt-3.5-turbo",
help="The chat model to use.")
parser.add_argument("--temperature", type=float, default=0.75,
help="The temperature to use in sampling.")
parser.add_argument("--max_system_tokens", type=int, default=100,
help="The max number of tokens to generate for the system.")
parser.add_argument("--max_user_tokens", type=int, default=80,
help="The max number of tokens to generate for the user.")
parser.add_argument("--max_moderator_tokens", type=int, default=10,
help="The max number of tokens to generate for the moderator.")
parser.add_argument("--show_description", type=str2bool, default="true",
help="Whether to show the role description.")
parser.add_argument("--show_message", type=str2bool, default="true",
help="Whether to show the conversation messages.")
parser.add_argument("--random_seed", type=int, default=42)
return parser.parse_args()
def str2bool(v):
if v.lower() in ('true', 'yes', 't', 'y', '1'):
return True
elif v.lower() in ('false',' no', 'f', 'n', '0'):
return False
else:
raise argparse.ArgumentTypeError("Unsupported value encountered.")
def clean_utterance(s):
s = s.strip()
for start_str in ['[1]', '[2]', '[3]', '[4]', '[5]', '[6]', '[7]', '[8]', '[9]']:
if s.startswith(start_str):
s = s[len(start_str):].strip()
return s
def prompt_conversation(raw_goal, conversation):
"""Prompt the conversation context."""
conversation_ctx = ""
for idx, utt in enumerate(conversation):
utt = clean_utterance(utt)
if "User Initiative" in raw_goal:
if idx % 2 == 0:
conversation_ctx += f"[Role-U]: {utt}<EOS>\n\n"
else:
conversation_ctx += f"[Role-S]: {utt}<EOS>\n\n"
else:
if idx % 2 == 0:
conversation_ctx += f"[Role-S]: {utt}<EOS>\n\n"
else:
conversation_ctx += f"[Role-U]: {utt}<EOS>\n\n"
return conversation_ctx
def sample_seed_conversation(raw_goal, conversation):
"""Sample seed conversations (continue | end)."""
conv_lens = len(conversation)
continue_len = random.choice(range(1, int(conv_lens * 0.6)))
conv_continue = prompt_conversation(raw_goal, conversation[:continue_len])
conv_end = prompt_conversation(raw_goal, conversation)
seed_conv = {
"seed_continue": conv_continue,
"seed_end": conv_end
}
return seed_conv
def sample_assistant_role(profile_slots, user_profile):
"""Sample an assistant role."""
all_names = profile_slots["Name"]
user_name = user_profile["Name"]
sampled_name = random.choice(all_names)
while find_word_in_string(sampled_name, user_name):
sampled_name = random.choice(all_names)
return sampled_name
def sample_personality():
"""Sample a personality based on Big Five personality traits."""
personalities = {
"agreeableness": ["trustworthy, straightforward, and generous", "unreliable, complicated, meager, and boastful"],
"conscientiousness": ["efficient, organized, and careful", "inefficient, careless, and sloppy"],
"extraversion": ["outgoing, energetic, and talkative", "shy, reserved, and quiet"],
"neuroticism": ["sensitive, nervous, and insecure", "secure, confident, and calm"],
"openness": ["intellectual, imaginative, and curious", "unimaginative, uncreative, and conventional"]
}
sampled_personality = {}
for trait, values in personalities.items():
sampled_personality[trait] = random.choice(values)
return sampled_personality
def generate_dialog_data(
profile_path,
seed_path,
output_dir,
max_interaction_step=10,
model_name="gpt-3.5-turbo",
temperature=0.75,
max_system_tokens=100,
max_user_tokens=80,
max_moderator_tokens=10,
show_description=True,
show_message=True,
):
"""Generate dialog data from a seed dialog file."""
profile_slots = json.load(open(profile_path, "r", encoding='utf-8'))
print(f"Loaded user profiles with {len(profile_slots)} slot keys.")
seed_dialogs = []
with open(seed_path, "r", encoding='utf-8') as f:
for line in f:
seed_dialogs.append(json.loads(line))
print(f"Loaded {len(seed_dialogs)} cached dialogs.")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if "test_seen" in seed_path:
output_path = os.path.join(output_dir, "dialogue_test_seen.jsonl")
elif "test_unseen" in seed_path:
output_path = os.path.join(output_dir, "dialogue_test_unseen.jsonl")
elif "dev" in seed_path:
output_path = os.path.join(output_dir, "dialogue_dev.jsonl")
else:
output_path = os.path.join(output_dir, "dialogue_train.jsonl")
with open(output_path, "w", encoding='utf-8') as fw:
for seed_dialog in tqdm(seed_dialogs):
simulated_profile = seed_dialog["user_profile"]
sampled_knowledge = seed_dialog["knowledge"]
target = seed_dialog["target"]
conversation = seed_dialog["seed_conversation"]
seed_conv = sample_seed_conversation(seed_dialog["original_goal"], conversation)
# randomly sample a personality
simulated_personality = sample_personality()
assistant_name = sample_assistant_role(profile_slots, simulated_profile)
env_desc, user_dict, assistant_dict, moderator_dict = create_instruct(
target=target,
simulated_profile=simulated_profile,
simulated_personality=simulated_personality,
assistant_name=assistant_name,
domain_knowledge=sampled_knowledge,
seed_conversation=seed_conv
)
assistant = Player(
name=assistant_dict["name"], backend=OpenAIChat(model=model_name, temperature=temperature, max_tokens=max_system_tokens),
role_desc=assistant_dict["role_desc"], global_prompt=env_desc
)
user = Player(
name=user_dict["name"], backend=OpenAIChat(model=model_name, temperature=temperature, max_tokens=max_user_tokens),
role_desc=user_dict["role_desc"], global_prompt=env_desc
)
moderator = Moderator(
backend=OpenAIChat(model=model_name, temperature=temperature, max_tokens=max_moderator_tokens),
role_desc=moderator_dict["role_desc"], terminal_condition=moderator_dict["terminal_condition"]
)
# let assistant start the conversation
env = ModeratedConversation(player_names=[p.name for p in [assistant, user]], moderator=moderator, moderator_period="round")
arena = Arena(players=[assistant, user], environment=env, global_prompt=env_desc)
arena.launch_cli(max_steps=max_interaction_step, show_description=show_description, show_message=show_message, interactive=False)
#print("Save? (y/n)")
#if input() == "n":
# continue
# save the simulated dialog to file
messages = env.get_observation()
simulated_convs = []
for msg in messages:
if msg.agent_name == assistant.name:
utt = {"system": msg.content}
else:
utt = {"user": msg.content}
simulated_convs.append(utt)
write_line = {
"id": "s_" + str(seed_dialog["id"]),
"user_profile": simulated_profile,
"user_personality": simulated_personality,
"knowledge": sampled_knowledge,
"target": target,
"conversation": simulated_convs
}
fw.write(json.dumps(write_line, ensure_ascii=False) + "\n")
fw.flush()
print("Sleeping for 5 seconds...")
time.sleep(5)
#print("Continue? (y/n)")
#if input() == "n":
# break
if __name__ == '__main__':
args = parse_args()
random.seed(args.random_seed)
generate_dialog_data(args.profile_path, args.cached_seed_path, args.output_dir,
max_interaction_step=args.max_interaction_step,
model_name=args.model_name,
temperature=args.temperature,
max_system_tokens=args.max_system_tokens,
max_user_tokens=args.max_user_tokens,
max_moderator_tokens=args.max_moderator_tokens,
show_description=args.show_description,
show_message=args.show_message)
| [] |
2024-01-10 | mrmps/redesigned-spoon | semantic_search.py | import os
import cohere
import pandas as pd
import umap
from annoy import AnnoyIndex
import numpy as np
from dotenv import load_dotenv
from scipy.cluster.hierarchy import dendrogram
from sklearn.cluster import AgglomerativeClustering
def get_key():
load_dotenv()
return os.getenv("COHERE_KEY")
def buildIndex(datafile: str, indexfile: str):
df = pd.read_csv(datafile, encoding="ISO-8859-1")
embeds = co.embed(texts=list(df['Summary']), model = 'large', truncate='right').embeddings
embeds = np.array(embeds)
search_index = AnnoyIndex(embeds.shape[1], 'angular')
print(embeds.shape[1])
for i in range(len(embeds)):
search_index.add_item(i, embeds[i])
search_index.build(10)
search_index.save(indexfile)
def getClosestNeighbours():
df = pd.read_csv('data.csv', encoding="ISO-8859-1")
search_index = AnnoyIndex(4096, 'angular')
search_index.load('test.ann')
query = 'I want a paper on astro physics'
query_embed = co.embed(texts=[query],
model='large',
truncate='right').embeddings
# Retrieve the nearest neighbors
similar_item_ids = search_index.get_nns_by_vector(query_embed[0],10,
include_distances=True)
# Format the results
print(similar_item_ids)
results = pd.DataFrame(data={'title': df.iloc[similar_item_ids[0]]['Title'],
'subject': df.iloc[similar_item_ids[0]]['Subject'],
'summary': df.iloc[similar_item_ids[0]]['Summary'],
'distance': similar_item_ids[1]})
print(f"Query:'{query}'\nNearest neighbors:")
print(results)
if __name__ == '__main__':
key = get_key()
co = cohere.Client(key)
buildIndex()
getClosestNeighbours()
'''title = 'Cosmic Accelerators'
summary = 'I discuss the scientific rationale and opportunities in the study of high energy particle accelerators away from the Earth; mostly, those outside the Solar System. I also briefly outline the features to be desired in telescopes used to probe accelerators studied by remote sensing.'
prompt = 'This is a paper titled ' + title + '. This is the summary: ' + summary + '. The 3 themes from this summary are:'
response = co.generate(prompt=prompt, p=0.0, temperature=0.0, max_tokens=50)
print('Prediction: {}'.format(response.generations[0].text))'''
| [] |
2024-01-10 | trilogy-group/ai-reddit-news | autogpt_llm.py | import os
import faiss
from dotenv import load_dotenv
from langchain import FAISS, InMemoryDocstore
from langchain.chat_models import ChatOpenAI
load_dotenv()
from langchain.utilities import GoogleSearchAPIWrapper
from langchain.agents import Tool
from langchain.tools.file_management.write import WriteFileTool
from langchain.tools.file_management.read import ReadFileTool
from langchain.embeddings import OpenAIEmbeddings
from langchain_experimental.autonomous_agents import AutoGPT
class PostRatingLLM:
RATING_TEMPLATE = """Evaluate the following Reddit post based on the following criteria:
1. Does the post provide valuable information or resources that could help someone become an expert in AI?
2. Does the post contain the latest developments or updates in the field of AI and Language Learning Models (LLMs)?
3. Would the post be interesting and useful to anyone aspiring to become an expert in AI, regardless of whether they are a developer or not?
Please rate the post on a scale of 1-10 for each criterion, with 1 being 'not at all' and 10 being 'extremely'
Post Title: {post_title}
Post Body: {post_body}
Post Comments: {post_comments}
Your final output should only be a single integer rating.
"""
def __init__(self):
self._set_llm()
def _set_llm(self):
self.agent = AutoGPT.from_llm_and_tools(
ai_name="Jim",
ai_role="Assistant",
tools=self._get_tools(),
llm=ChatOpenAI(model="gpt-4", temperature=0),
memory=self._get_db().as_retriever(),
)
if os.environ.get("DEBUG") and os.environ.get("DEBUG").lower() == "true":
self.agent.chain.verbose = True
@staticmethod
def _get_tools():
search = GoogleSearchAPIWrapper()
return [
Tool(
name="search",
func=search.run,
description="Useful for when you need to answer questions about current events.",
return_direct=True,
),
WriteFileTool(),
ReadFileTool(),
]
@staticmethod
def _get_db():
embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")
embedding_size = 1536
index = faiss.IndexFlatL2(embedding_size)
return FAISS(embeddings.embed_query, index, InMemoryDocstore({}), {})
# dataset_path = os.environ.get("DEEPLAKE_DATASET_PATH")
# return DeepLake(dataset_path=dataset_path, embedding_function=embeddings)
def rate(self, post_title, post_body, post_comments):
return self.agent.run(
[
self.RATING_TEMPLATE.format(
post_title=post_title,
post_body=post_body,
post_comments=post_comments,
)
]
)
| [
"Evaluate the following Reddit post based on the following criteria:\n \n 1. Does the post provide valuable information or resources that could help someone become an expert in AI?\n 2. Does the post contain the latest developments or updates in the field of AI and Language Learning Models (LLMs)?\n 3. Would the post be interesting and useful to anyone aspiring to become an expert in AI, regardless of whether they are a developer or not?\n \n Please rate the post on a scale of 1-10 for each criterion, with 1 being 'not at all' and 10 being 'extremely'\n \n Post Title: {post_title}\n Post Body: {post_body}\n Post Comments: {post_comments}\n \n Your final output should only be a single integer rating.\n "
] |
2024-01-10 | trilogy-group/ai-reddit-news | gpt4_llm.py | from datetime import datetime
from dotenv import load_dotenv
from langchain.memory import ConversationBufferMemory
from langchain.schema import SystemMessage
from constants import MODEL
load_dotenv()
from langchain.llms import OpenAIChat
from langchain.chat_models import ChatOpenAI as OpenAIChat
from langchain.prompts import MessagesPlaceholder
from langchain.agents import (
AgentType,
AgentExecutor,
OpenAIFunctionsAgent,
)
import os
from dotenv import load_dotenv
load_dotenv()
from langchain.utilities import GoogleSearchAPIWrapper
from langchain.agents import Tool
from langchain.tools.file_management.write import WriteFileTool
from langchain.tools.file_management.read import ReadFileTool
def isfloat(num):
try:
float(num)
return True
except ValueError:
return False
class PostRatingLLM:
RATING_TEMPLATE = """Evaluate the following Reddit post based on the following criteria:
1. Does the post provide valuable information or resources that could help someone become an expert in AI?
2. Does the post contain the latest developments or updates in the field of AI and Language Learning Models (LLMs)?
3. Would the post be interesting and useful to anyone aspiring to become an expert in AI, regardless of whether they are a developer or not?
Please rate the post on a scale of 1-10 for each criterion, with 1 being 'not at all' and 10 being 'extremely'
Post Title: {post_title}
Post Body: {post_body}
Post Comments: {post_comments}
Your final output should only be a single number rating.
"""
def __init__(self):
self._set_llm()
def _set_llm(self):
MEMORY_KEY = "chat_history"
model_verbose = False
if os.environ.get("DEBUG") and os.environ.get("DEBUG").lower() == "true":
model_verbose = True
system_message = SystemMessage(
content=f"You are a helpful AI Rating assistant. Given a string you extract the final rating out of the string. While you have not been trained on data past 2021, you can search for that data online using tools. The current date is {datetime.now()}"
)
llm = OpenAIChat(model=MODEL, temperature=0)
prompt = OpenAIFunctionsAgent.create_prompt(
system_message=system_message,
extra_prompt_messages=[MessagesPlaceholder(variable_name=MEMORY_KEY)],
)
agent = OpenAIFunctionsAgent(
llm=llm,
tools=self._get_tools(),
agent=AgentType.OPENAI_MULTI_FUNCTIONS,
prompt=prompt,
verbose=model_verbose,
max_iterations=6,
)
llm_memory = ConversationBufferMemory(
memory_key=MEMORY_KEY, return_messages=True
)
self.agent = AgentExecutor(
agent=agent, tools=self._get_tools(), memory=llm_memory, verbose=True
)
@staticmethod
def _get_tools():
search = GoogleSearchAPIWrapper()
return [
Tool(
name="Search",
func=search.run,
description="useful for finding the latest information after 2021",
),
WriteFileTool(),
ReadFileTool(),
]
def rate(self, post_title, post_body, post_comments):
rating_string = self.agent.run(
self.RATING_TEMPLATE.format(
post_title=post_title,
post_body=post_body,
post_comments=post_comments,
)
)
short_rating = self.agent.run(f"What is the final rating in the following message. The answer should be a float or integer:\n\n{rating_string}")
for _word in short_rating.split():
if _word.endswith("."):
_word = _word[:-1]
if isfloat(_word):
return float(_word)
return -1
| [
"Evaluate the following Reddit post based on the following criteria:\n\n 1. Does the post provide valuable information or resources that could help someone become an expert in AI?\n 2. Does the post contain the latest developments or updates in the field of AI and Language Learning Models (LLMs)?\n 3. Would the post be interesting and useful to anyone aspiring to become an expert in AI, regardless of whether they are a developer or not?\n\n Please rate the post on a scale of 1-10 for each criterion, with 1 being 'not at all' and 10 being 'extremely'\n\n Post Title: {post_title}\n Post Body: {post_body}\n Post Comments: {post_comments}\n\n Your final output should only be a single number rating.\n "
] |
2024-01-10 | HemantKumar01/SpeakSmartAI | tutor_model.py | from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
# from langchain.chat_models import ChatOpenAI
import templates
import json
class Tutor:
def __init__(self, API_KEY, role, domain=None):
self.role = role
self.API_KEY = API_KEY
if self.role == "Interview":
situation = PromptTemplate.from_template(
templates.role_templates[self.role]
).format(domain=domain)
else:
situation = templates.role_templates[self.role]
self.situation = situation
# returns a questions based on given role
def get_questions(self):
llm = OpenAI(openai_api_key=self.API_KEY, temperature=0.6)
questions = llm.predict(self.situation)
return questions.split("\n")
# Rates answers of given question based on following points
# 1. Creativity,
# 2. Clarity,
# 3. Effectiveness
def rate_answer(self, question, answer):
llm = OpenAI(openai_api_key=self.API_KEY, temperature=0)
prompt = PromptTemplate.from_template(templates.answer_rating_template).format(
question=question,
answer=answer,
situation=templates.suggestion_situation[self.role],
)
rating = llm.predict(prompt)
# print("DEBUG:", rating)
rating = json.loads(rating)
self.rating = rating
return rating
# give suggestions based to improve rating on question and answer (ratng will be based on last call of get_rating)
def get_suggestion(self, question, answer):
# sorting dict wrt values
# to get key with lowest rating_score
rating = dict(sorted(self.rating.items(), key=lambda item: item[1]))
# first key of this dict (lowest rating)
key = list(rating.keys())[0]
llm = OpenAI(openai_api_key=self.API_KEY, temperature=0.4)
prompt = PromptTemplate.from_template(templates.suggestion_template).format(
question=question,
answer=answer,
key=key,
situation=templates.suggestion_situation[self.role],
)
suggestion = llm.predict(prompt)
return suggestion
| [] |
2024-01-10 | RissyRan/diffusers | src~diffusers~pipelines~stable_diffusion_xl~pipeline_stable_diffusion_xl_img2img.py | # Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import inspect
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import PIL.Image
import torch
from transformers import CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer
from ...image_processor import PipelineImageInput, VaeImageProcessor
from ...loaders import FromSingleFileMixin, StableDiffusionXLLoraLoaderMixin, TextualInversionLoaderMixin
from ...models import AutoencoderKL, UNet2DConditionModel
from ...models.attention_processor import (
AttnProcessor2_0,
LoRAAttnProcessor2_0,
LoRAXFormersAttnProcessor,
XFormersAttnProcessor,
)
from ...models.lora import adjust_lora_scale_text_encoder
from ...schedulers import KarrasDiffusionSchedulers
from ...utils import (
USE_PEFT_BACKEND,
is_invisible_watermark_available,
is_torch_xla_available,
logging,
replace_example_docstring,
scale_lora_layers,
unscale_lora_layers,
)
from ...utils.torch_utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline
from .pipeline_output import StableDiffusionXLPipelineOutput
if is_invisible_watermark_available():
from .watermark import StableDiffusionXLWatermarker
if is_torch_xla_available():
import torch_xla.core.xla_model as xm
XLA_AVAILABLE = True
else:
XLA_AVAILABLE = False
logger = logging.get_logger(__name__) # pylint: disable=invalid-name
EXAMPLE_DOC_STRING = """
Examples:
```py
>>> import torch
>>> from diffusers import StableDiffusionXLImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained(
... "stabilityai/stable-diffusion-xl-refiner-1.0", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")
>>> url = "https://huggingface.co/datasets/patrickvonplaten/images/resolve/main/aa_xl/000000009.png"
>>> init_image = load_image(url).convert("RGB")
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt, image=init_image).images[0]
```
"""
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.rescale_noise_cfg
def rescale_noise_cfg(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
class StableDiffusionXLImg2ImgPipeline(
DiffusionPipeline, TextualInversionLoaderMixin, FromSingleFileMixin, StableDiffusionXLLoraLoaderMixin
):
r"""
Pipeline for text-to-image generation using Stable Diffusion XL.
This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
In addition the pipeline inherits the following loading methods:
- *LoRA*: [`loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights`]
- *Ckpt*: [`loaders.FromSingleFileMixin.from_single_file`]
as well as the following saving methods:
- *LoRA*: [`loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights`]
Args:
vae ([`AutoencoderKL`]):
Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
text_encoder ([`CLIPTextModel`]):
Frozen text-encoder. Stable Diffusion XL uses the text portion of
[CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
text_encoder_2 ([` CLIPTextModelWithProjection`]):
Second frozen text-encoder. Stable Diffusion XL uses the text and pool portion of
[CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection),
specifically the
[laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k)
variant.
tokenizer (`CLIPTokenizer`):
Tokenizer of class
[CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`CLIPTokenizer`):
Second Tokenizer of class
[CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
scheduler ([`SchedulerMixin`]):
A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
[`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
requires_aesthetics_score (`bool`, *optional*, defaults to `"False"`):
Whether the `unet` requires an `aesthetic_score` condition to be passed during inference. Also see the
config of `stabilityai/stable-diffusion-xl-refiner-1-0`.
force_zeros_for_empty_prompt (`bool`, *optional*, defaults to `"True"`):
Whether the negative prompt embeddings shall be forced to always be set to 0. Also see the config of
`stabilityai/stable-diffusion-xl-base-1-0`.
add_watermarker (`bool`, *optional*):
Whether to use the [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) to
watermark output images. If not defined, it will default to True if the package is installed, otherwise no
watermarker will be used.
"""
model_cpu_offload_seq = "text_encoder->text_encoder_2->unet->vae"
_optional_components = ["tokenizer", "tokenizer_2", "text_encoder", "text_encoder_2"]
def __init__(
self,
vae: AutoencoderKL,
text_encoder: CLIPTextModel,
text_encoder_2: CLIPTextModelWithProjection,
tokenizer: CLIPTokenizer,
tokenizer_2: CLIPTokenizer,
unet: UNet2DConditionModel,
scheduler: KarrasDiffusionSchedulers,
requires_aesthetics_score: bool = False,
force_zeros_for_empty_prompt: bool = True,
add_watermarker: Optional[bool] = None,
):
super().__init__()
self.register_modules(
vae=vae,
text_encoder=text_encoder,
text_encoder_2=text_encoder_2,
tokenizer=tokenizer,
tokenizer_2=tokenizer_2,
unet=unet,
scheduler=scheduler,
)
self.register_to_config(force_zeros_for_empty_prompt=force_zeros_for_empty_prompt)
self.register_to_config(requires_aesthetics_score=requires_aesthetics_score)
self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
add_watermarker = add_watermarker if add_watermarker is not None else is_invisible_watermark_available()
if add_watermarker:
self.watermark = StableDiffusionXLWatermarker()
else:
self.watermark = None
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_slicing
def enable_vae_slicing(self):
r"""
Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
"""
self.vae.enable_slicing()
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_slicing
def disable_vae_slicing(self):
r"""
Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
computing decoding in one step.
"""
self.vae.disable_slicing()
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_vae_tiling
def enable_vae_tiling(self):
r"""
Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
processing larger images.
"""
self.vae.enable_tiling()
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_vae_tiling
def disable_vae_tiling(self):
r"""
Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
computing decoding in one step.
"""
self.vae.disable_tiling()
# Copied from diffusers.pipelines.stable_diffusion_xl.pipeline_stable_diffusion_xl.StableDiffusionXLPipeline.encode_prompt
def encode_prompt(
self,
prompt: str,
prompt_2: Optional[str] = None,
device: Optional[torch.device] = None,
num_images_per_prompt: int = 1,
do_classifier_free_guidance: bool = True,
negative_prompt: Optional[str] = None,
negative_prompt_2: Optional[str] = None,
prompt_embeds: Optional[torch.FloatTensor] = None,
negative_prompt_embeds: Optional[torch.FloatTensor] = None,
pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
lora_scale: Optional[float] = None,
clip_skip: Optional[int] = None,
):
r"""
Encodes the prompt into text encoder hidden states.
Args:
prompt (`str` or `List[str]`, *optional*):
prompt to be encoded
prompt_2 (`str` or `List[str]`, *optional*):
The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is
used in both text-encoders
device: (`torch.device`):
torch device
num_images_per_prompt (`int`):
number of images that should be generated per prompt
do_classifier_free_guidance (`bool`):
whether to use classifier free guidance or not
negative_prompt (`str` or `List[str]`, *optional*):
The prompt or prompts not to guide the image generation. If not defined, one has to pass
`negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
less than `1`).
negative_prompt_2 (`str` or `List[str]`, *optional*):
The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and
`text_encoder_2`. If not defined, `negative_prompt` is used in both text-encoders
prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
provided, text embeddings will be generated from `prompt` input argument.
negative_prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
argument.
pooled_prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting.
If not provided, pooled text embeddings will be generated from `prompt` input argument.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt`
input argument.
lora_scale (`float`, *optional*):
A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
clip_skip (`int`, *optional*):
Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
the output of the pre-final layer will be used for computing the prompt embeddings.
"""
device = device or self._execution_device
# set lora scale so that monkey patched LoRA
# function of text encoder can correctly access it
if lora_scale is not None and isinstance(self, StableDiffusionXLLoraLoaderMixin):
self._lora_scale = lora_scale
# dynamically adjust the LoRA scale
if self.text_encoder is not None:
if not USE_PEFT_BACKEND:
adjust_lora_scale_text_encoder(self.text_encoder, lora_scale)
else:
scale_lora_layers(self.text_encoder, lora_scale)
if self.text_encoder_2 is not None:
if not USE_PEFT_BACKEND:
adjust_lora_scale_text_encoder(self.text_encoder_2, lora_scale)
else:
scale_lora_layers(self.text_encoder_2, lora_scale)
prompt = [prompt] if isinstance(prompt, str) else prompt
if prompt is not None:
batch_size = len(prompt)
else:
batch_size = prompt_embeds.shape[0]
# Define tokenizers and text encoders
tokenizers = [self.tokenizer, self.tokenizer_2] if self.tokenizer is not None else [self.tokenizer_2]
text_encoders = (
[self.text_encoder, self.text_encoder_2] if self.text_encoder is not None else [self.text_encoder_2]
)
if prompt_embeds is None:
prompt_2 = prompt_2 or prompt
prompt_2 = [prompt_2] if isinstance(prompt_2, str) else prompt_2
# textual inversion: procecss multi-vector tokens if necessary
prompt_embeds_list = []
prompts = [prompt, prompt_2]
for prompt, tokenizer, text_encoder in zip(prompts, tokenizers, text_encoders):
if isinstance(self, TextualInversionLoaderMixin):
prompt = self.maybe_convert_prompt(prompt, tokenizer)
text_inputs = tokenizer(
prompt,
padding="max_length",
max_length=tokenizer.model_max_length,
truncation=True,
return_tensors="pt",
)
text_input_ids = text_inputs.input_ids
untruncated_ids = tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
text_input_ids, untruncated_ids
):
removed_text = tokenizer.batch_decode(untruncated_ids[:, tokenizer.model_max_length - 1 : -1])
logger.warning(
"The following part of your input was truncated because CLIP can only handle sequences up to"
f" {tokenizer.model_max_length} tokens: {removed_text}"
)
prompt_embeds = text_encoder(text_input_ids.to(device), output_hidden_states=True)
# We are only ALWAYS interested in the pooled output of the final text encoder
pooled_prompt_embeds = prompt_embeds[0]
if clip_skip is None:
prompt_embeds = prompt_embeds.hidden_states[-2]
else:
# "2" because SDXL always indexes from the penultimate layer.
prompt_embeds = prompt_embeds.hidden_states[-(clip_skip + 2)]
prompt_embeds_list.append(prompt_embeds)
prompt_embeds = torch.concat(prompt_embeds_list, dim=-1)
# get unconditional embeddings for classifier free guidance
zero_out_negative_prompt = negative_prompt is None and self.config.force_zeros_for_empty_prompt
if do_classifier_free_guidance and negative_prompt_embeds is None and zero_out_negative_prompt:
negative_prompt_embeds = torch.zeros_like(prompt_embeds)
negative_pooled_prompt_embeds = torch.zeros_like(pooled_prompt_embeds)
elif do_classifier_free_guidance and negative_prompt_embeds is None:
negative_prompt = negative_prompt or ""
negative_prompt_2 = negative_prompt_2 or negative_prompt
# normalize str to list
negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt
negative_prompt_2 = (
batch_size * [negative_prompt_2] if isinstance(negative_prompt_2, str) else negative_prompt_2
)
uncond_tokens: List[str]
if prompt is not None and type(prompt) is not type(negative_prompt):
raise TypeError(
f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
f" {type(prompt)}."
)
elif batch_size != len(negative_prompt):
raise ValueError(
f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
" the batch size of `prompt`."
)
else:
uncond_tokens = [negative_prompt, negative_prompt_2]
negative_prompt_embeds_list = []
for negative_prompt, tokenizer, text_encoder in zip(uncond_tokens, tokenizers, text_encoders):
if isinstance(self, TextualInversionLoaderMixin):
negative_prompt = self.maybe_convert_prompt(negative_prompt, tokenizer)
max_length = prompt_embeds.shape[1]
uncond_input = tokenizer(
negative_prompt,
padding="max_length",
max_length=max_length,
truncation=True,
return_tensors="pt",
)
negative_prompt_embeds = text_encoder(
uncond_input.input_ids.to(device),
output_hidden_states=True,
)
# We are only ALWAYS interested in the pooled output of the final text encoder
negative_pooled_prompt_embeds = negative_prompt_embeds[0]
negative_prompt_embeds = negative_prompt_embeds.hidden_states[-2]
negative_prompt_embeds_list.append(negative_prompt_embeds)
negative_prompt_embeds = torch.concat(negative_prompt_embeds_list, dim=-1)
if self.text_encoder_2 is not None:
prompt_embeds = prompt_embeds.to(dtype=self.text_encoder_2.dtype, device=device)
else:
prompt_embeds = prompt_embeds.to(dtype=self.unet.dtype, device=device)
bs_embed, seq_len, _ = prompt_embeds.shape
# duplicate text embeddings for each generation per prompt, using mps friendly method
prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
if do_classifier_free_guidance:
# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
seq_len = negative_prompt_embeds.shape[1]
if self.text_encoder_2 is not None:
negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.text_encoder_2.dtype, device=device)
else:
negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.unet.dtype, device=device)
negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
pooled_prompt_embeds = pooled_prompt_embeds.repeat(1, num_images_per_prompt).view(
bs_embed * num_images_per_prompt, -1
)
if do_classifier_free_guidance:
negative_pooled_prompt_embeds = negative_pooled_prompt_embeds.repeat(1, num_images_per_prompt).view(
bs_embed * num_images_per_prompt, -1
)
if self.text_encoder is not None:
if isinstance(self, StableDiffusionXLLoraLoaderMixin) and USE_PEFT_BACKEND:
# Retrieve the original scale by scaling back the LoRA layers
unscale_lora_layers(self.text_encoder, lora_scale)
if self.text_encoder_2 is not None:
if isinstance(self, StableDiffusionXLLoraLoaderMixin) and USE_PEFT_BACKEND:
# Retrieve the original scale by scaling back the LoRA layers
unscale_lora_layers(self.text_encoder_2, lora_scale)
return prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
def prepare_extra_step_kwargs(self, generator, eta):
# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
# and should be between [0, 1]
accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
extra_step_kwargs = {}
if accepts_eta:
extra_step_kwargs["eta"] = eta
# check if the scheduler accepts generator
accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
if accepts_generator:
extra_step_kwargs["generator"] = generator
return extra_step_kwargs
def check_inputs(
self,
prompt,
prompt_2,
strength,
num_inference_steps,
callback_steps,
negative_prompt=None,
negative_prompt_2=None,
prompt_embeds=None,
negative_prompt_embeds=None,
):
if strength < 0 or strength > 1:
raise ValueError(f"The value of strength should in [0.0, 1.0] but is {strength}")
if num_inference_steps is None:
raise ValueError("`num_inference_steps` cannot be None.")
elif not isinstance(num_inference_steps, int) or num_inference_steps <= 0:
raise ValueError(
f"`num_inference_steps` has to be a positive integer but is {num_inference_steps} of type"
f" {type(num_inference_steps)}."
)
if (callback_steps is None) or (
callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
):
raise ValueError(
f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
f" {type(callback_steps)}."
)
if prompt is not None and prompt_embeds is not None:
raise ValueError(
f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
" only forward one of the two."
)
elif prompt_2 is not None and prompt_embeds is not None:
raise ValueError(
f"Cannot forward both `prompt_2`: {prompt_2} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
" only forward one of the two."
)
elif prompt is None and prompt_embeds is None:
raise ValueError(
"Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
)
elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
elif prompt_2 is not None and (not isinstance(prompt_2, str) and not isinstance(prompt_2, list)):
raise ValueError(f"`prompt_2` has to be of type `str` or `list` but is {type(prompt_2)}")
if negative_prompt is not None and negative_prompt_embeds is not None:
raise ValueError(
f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
)
elif negative_prompt_2 is not None and negative_prompt_embeds is not None:
raise ValueError(
f"Cannot forward both `negative_prompt_2`: {negative_prompt_2} and `negative_prompt_embeds`:"
f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
)
if prompt_embeds is not None and negative_prompt_embeds is not None:
if prompt_embeds.shape != negative_prompt_embeds.shape:
raise ValueError(
"`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
f" {negative_prompt_embeds.shape}."
)
def get_timesteps(self, num_inference_steps, strength, device, denoising_start=None):
# get the original timestep using init_timestep
if denoising_start is None:
init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
t_start = max(num_inference_steps - init_timestep, 0)
else:
t_start = 0
timesteps = self.scheduler.timesteps[t_start * self.scheduler.order :]
# Strength is irrelevant if we directly request a timestep to start at;
# that is, strength is determined by the denoising_start instead.
if denoising_start is not None:
discrete_timestep_cutoff = int(
round(
self.scheduler.config.num_train_timesteps
- (denoising_start * self.scheduler.config.num_train_timesteps)
)
)
timesteps = list(filter(lambda ts: ts < discrete_timestep_cutoff, timesteps))
return torch.tensor(timesteps), len(timesteps)
return timesteps, num_inference_steps - t_start
def prepare_latents(
self, image, timestep, batch_size, num_images_per_prompt, dtype, device, generator=None, add_noise=True
):
if not isinstance(image, (torch.Tensor, PIL.Image.Image, list)):
raise ValueError(
f"`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(image)}"
)
# Offload text encoder if `enable_model_cpu_offload` was enabled
if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
self.text_encoder_2.to("cpu")
torch.cuda.empty_cache()
image = image.to(device=device, dtype=dtype)
batch_size = batch_size * num_images_per_prompt
if image.shape[1] == 4:
init_latents = image
else:
# make sure the VAE is in float32 mode, as it overflows in float16
if self.vae.config.force_upcast:
image = image.float()
self.vae.to(dtype=torch.float32)
if isinstance(generator, list) and len(generator) != batch_size:
raise ValueError(
f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
f" size of {batch_size}. Make sure the batch size matches the length of the generators."
)
elif isinstance(generator, list):
init_latents = [
self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
]
init_latents = torch.cat(init_latents, dim=0)
else:
init_latents = self.vae.encode(image).latent_dist.sample(generator)
if self.vae.config.force_upcast:
self.vae.to(dtype)
init_latents = init_latents.to(dtype)
init_latents = self.vae.config.scaling_factor * init_latents
if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
# expand init_latents for batch_size
additional_image_per_prompt = batch_size // init_latents.shape[0]
init_latents = torch.cat([init_latents] * additional_image_per_prompt, dim=0)
elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
raise ValueError(
f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
)
else:
init_latents = torch.cat([init_latents], dim=0)
if add_noise:
shape = init_latents.shape
noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
# get latents
init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
latents = init_latents
return latents
def _get_add_time_ids(
self,
original_size,
crops_coords_top_left,
target_size,
aesthetic_score,
negative_aesthetic_score,
negative_original_size,
negative_crops_coords_top_left,
negative_target_size,
dtype,
text_encoder_projection_dim=None,
):
if self.config.requires_aesthetics_score:
add_time_ids = list(original_size + crops_coords_top_left + (aesthetic_score,))
add_neg_time_ids = list(
negative_original_size + negative_crops_coords_top_left + (negative_aesthetic_score,)
)
else:
add_time_ids = list(original_size + crops_coords_top_left + target_size)
add_neg_time_ids = list(negative_original_size + crops_coords_top_left + negative_target_size)
passed_add_embed_dim = (
self.unet.config.addition_time_embed_dim * len(add_time_ids) + text_encoder_projection_dim
)
expected_add_embed_dim = self.unet.add_embedding.linear_1.in_features
if (
expected_add_embed_dim > passed_add_embed_dim
and (expected_add_embed_dim - passed_add_embed_dim) == self.unet.config.addition_time_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. Please make sure to enable `requires_aesthetics_score` with `pipe.register_to_config(requires_aesthetics_score=True)` to make sure `aesthetic_score` {aesthetic_score} and `negative_aesthetic_score` {negative_aesthetic_score} is correctly used by the model."
)
elif (
expected_add_embed_dim < passed_add_embed_dim
and (passed_add_embed_dim - expected_add_embed_dim) == self.unet.config.addition_time_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. Please make sure to disable `requires_aesthetics_score` with `pipe.register_to_config(requires_aesthetics_score=False)` to make sure `target_size` {target_size} is correctly used by the model."
)
elif 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)
add_neg_time_ids = torch.tensor([add_neg_time_ids], dtype=dtype)
return add_time_ids, add_neg_time_ids
# 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)
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_freeu
def enable_freeu(self, s1: float, s2: float, b1: float, b2: float):
r"""Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497.
The suffixes after the scaling factors represent the stages where they are being applied.
Please refer to the [official repository](https://github.com/ChenyangSi/FreeU) for combinations of the values
that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.
Args:
s1 (`float`):
Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
mitigate "oversmoothing effect" in the enhanced denoising process.
s2 (`float`):
Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
mitigate "oversmoothing effect" in the enhanced denoising process.
b1 (`float`): Scaling factor for stage 1 to amplify the contributions of backbone features.
b2 (`float`): Scaling factor for stage 2 to amplify the contributions of backbone features.
"""
if not hasattr(self, "unet"):
raise ValueError("The pipeline must have `unet` for using FreeU.")
self.unet.enable_freeu(s1=s1, s2=s2, b1=b1, b2=b2)
# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.disable_freeu
def disable_freeu(self):
"""Disables the FreeU mechanism if enabled."""
self.unet.disable_freeu()
@torch.no_grad()
@replace_example_docstring(EXAMPLE_DOC_STRING)
def __call__(
self,
prompt: Union[str, List[str]] = None,
prompt_2: Optional[Union[str, List[str]]] = None,
image: PipelineImageInput = None,
strength: float = 0.3,
num_inference_steps: int = 50,
denoising_start: Optional[float] = None,
denoising_end: Optional[float] = None,
guidance_scale: float = 5.0,
negative_prompt: Optional[Union[str, List[str]]] = None,
negative_prompt_2: Optional[Union[str, List[str]]] = None,
num_images_per_prompt: Optional[int] = 1,
eta: float = 0.0,
generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
latents: Optional[torch.FloatTensor] = None,
prompt_embeds: Optional[torch.FloatTensor] = None,
negative_prompt_embeds: Optional[torch.FloatTensor] = None,
pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
output_type: Optional[str] = "pil",
return_dict: bool = True,
callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
callback_steps: int = 1,
cross_attention_kwargs: Optional[Dict[str, Any]] = None,
guidance_rescale: float = 0.0,
original_size: Tuple[int, int] = None,
crops_coords_top_left: Tuple[int, int] = (0, 0),
target_size: Tuple[int, int] = None,
negative_original_size: Optional[Tuple[int, int]] = None,
negative_crops_coords_top_left: Tuple[int, int] = (0, 0),
negative_target_size: Optional[Tuple[int, int]] = None,
aesthetic_score: float = 6.0,
negative_aesthetic_score: float = 2.5,
clip_skip: Optional[int] = None,
):
r"""
Function invoked when calling the pipeline for generation.
Args:
prompt (`str` or `List[str]`, *optional*):
The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`.
instead.
prompt_2 (`str` or `List[str]`, *optional*):
The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is
used in both text-encoders
image (`torch.FloatTensor` or `PIL.Image.Image` or `np.ndarray` or `List[torch.FloatTensor]` or `List[PIL.Image.Image]` or `List[np.ndarray]`):
The image(s) to modify with the pipeline.
strength (`float`, *optional*, defaults to 0.3):
Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
will be used as a starting point, adding more noise to it the larger the `strength`. The number of
denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
be maximum and the denoising process will run for the full number of iterations specified in
`num_inference_steps`. A value of 1, therefore, essentially ignores `image`. Note that in the case of
`denoising_start` being declared as an integer, the value of `strength` will be ignored.
num_inference_steps (`int`, *optional*, defaults to 50):
The number of denoising steps. More denoising steps usually lead to a higher quality image at the
expense of slower inference.
denoising_start (`float`, *optional*):
When specified, indicates the fraction (between 0.0 and 1.0) of the total denoising process to be
bypassed before it is initiated. Consequently, the initial part of the denoising process is skipped and
it is assumed that the passed `image` is a partly denoised image. Note that when this is specified,
strength will be ignored. The `denoising_start` parameter is particularly beneficial when this pipeline
is integrated into a "Mixture of Denoisers" multi-pipeline setup, as detailed in [**Refine Image
Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality).
denoising_end (`float`, *optional*):
When specified, determines the fraction (between 0.0 and 1.0) of the total denoising process to be
completed before it is intentionally prematurely terminated. As a result, the returned sample will
still retain a substantial amount of noise (ca. final 20% of timesteps still needed) and should be
denoised by a successor pipeline that has `denoising_start` set to 0.8 so that it only denoises the
final 20% of the scheduler. The denoising_end parameter should ideally be utilized when this pipeline
forms a part of a "Mixture of Denoisers" multi-pipeline setup, as elaborated in [**Refine Image
Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality).
guidance_scale (`float`, *optional*, defaults to 7.5):
Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
`guidance_scale` is defined as `w` of equation 2. of [Imagen
Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
usually at the expense of lower image quality.
negative_prompt (`str` or `List[str]`, *optional*):
The prompt or prompts not to guide the image generation. If not defined, one has to pass
`negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
less than `1`).
negative_prompt_2 (`str` or `List[str]`, *optional*):
The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and
`text_encoder_2`. If not defined, `negative_prompt` is used in both text-encoders
num_images_per_prompt (`int`, *optional*, defaults to 1):
The number of images to generate per prompt.
eta (`float`, *optional*, defaults to 0.0):
Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
[`schedulers.DDIMScheduler`], will be ignored for others.
generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
to make generation deterministic.
latents (`torch.FloatTensor`, *optional*):
Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
tensor will ge generated by sampling using the supplied random `generator`.
prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
provided, text embeddings will be generated from `prompt` input argument.
negative_prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
argument.
pooled_prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting.
If not provided, pooled text embeddings will be generated from `prompt` input argument.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*):
Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt`
input argument.
output_type (`str`, *optional*, defaults to `"pil"`):
The output format of the generate image. Choose between
[PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
return_dict (`bool`, *optional*, defaults to `True`):
Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput`] instead of a
plain tuple.
callback (`Callable`, *optional*):
A function that will be called every `callback_steps` steps during inference. The function will be
called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
callback_steps (`int`, *optional*, defaults to 1):
The frequency at which the `callback` function will be called. If not specified, the callback will be
called at every step.
cross_attention_kwargs (`dict`, *optional*):
A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
`self.processor` in
[diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
guidance_rescale (`float`, *optional*, defaults to 0.0):
Guidance rescale factor proposed by [Common Diffusion Noise Schedules and Sample Steps are
Flawed](https://arxiv.org/pdf/2305.08891.pdf) `guidance_scale` is defined as `φ` in equation 16. of
[Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf).
Guidance rescale factor should fix overexposure when using zero terminal SNR.
original_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):
If `original_size` is not the same as `target_size` the image will appear to be down- or upsampled.
`original_size` defaults to `(height, width)` if not specified. Part of SDXL's micro-conditioning as
explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).
crops_coords_top_left (`Tuple[int]`, *optional*, defaults to (0, 0)):
`crops_coords_top_left` can be used to generate an image that appears to be "cropped" from the position
`crops_coords_top_left` downwards. Favorable, well-centered images are usually achieved by setting
`crops_coords_top_left` to (0, 0). Part of SDXL's micro-conditioning as explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).
target_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):
For most cases, `target_size` should be set to the desired height and width of the generated image. If
not specified it will default to `(height, width)`. Part of SDXL's micro-conditioning as explained in
section 2.2 of [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).
negative_original_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):
To negatively condition the generation process based on a specific image resolution. Part of SDXL's
micro-conditioning as explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). For more
information, refer to this issue thread: https://github.com/huggingface/diffusers/issues/4208.
negative_crops_coords_top_left (`Tuple[int]`, *optional*, defaults to (0, 0)):
To negatively condition the generation process based on a specific crop coordinates. Part of SDXL's
micro-conditioning as explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). For more
information, refer to this issue thread: https://github.com/huggingface/diffusers/issues/4208.
negative_target_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):
To negatively condition the generation process based on a target image resolution. It should be as same
as the `target_size` for most cases. Part of SDXL's micro-conditioning as explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). For more
information, refer to this issue thread: https://github.com/huggingface/diffusers/issues/4208.
aesthetic_score (`float`, *optional*, defaults to 6.0):
Used to simulate an aesthetic score of the generated image by influencing the positive text condition.
Part of SDXL's micro-conditioning as explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).
negative_aesthetic_score (`float`, *optional*, defaults to 2.5):
Part of SDXL's micro-conditioning as explained in section 2.2 of
[https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Can be used to
simulate an aesthetic score of the generated image by influencing the negative text condition.
clip_skip (`int`, *optional*):
Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
the output of the pre-final layer will be used for computing the prompt embeddings.
Examples:
Returns:
[`~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput`] or `tuple`:
[`~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput`] if `return_dict` is True, otherwise a
`tuple. When returning a tuple, the first element is a list with the generated images.
"""
# 1. Check inputs. Raise error if not correct
self.check_inputs(
prompt,
prompt_2,
strength,
num_inference_steps,
callback_steps,
negative_prompt,
negative_prompt_2,
prompt_embeds,
negative_prompt_embeds,
)
# 2. Define call parameters
if prompt is not None and isinstance(prompt, str):
batch_size = 1
elif prompt is not None and isinstance(prompt, list):
batch_size = len(prompt)
else:
batch_size = prompt_embeds.shape[0]
device = self._execution_device
# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
# corresponds to doing no classifier free guidance.
do_classifier_free_guidance = guidance_scale > 1.0
# 3. Encode input prompt
text_encoder_lora_scale = (
cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None
)
(
prompt_embeds,
negative_prompt_embeds,
pooled_prompt_embeds,
negative_pooled_prompt_embeds,
) = self.encode_prompt(
prompt=prompt,
prompt_2=prompt_2,
device=device,
num_images_per_prompt=num_images_per_prompt,
do_classifier_free_guidance=do_classifier_free_guidance,
negative_prompt=negative_prompt,
negative_prompt_2=negative_prompt_2,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_prompt_embeds,
pooled_prompt_embeds=pooled_prompt_embeds,
negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,
lora_scale=text_encoder_lora_scale,
clip_skip=clip_skip,
)
# 4. Preprocess image
image = self.image_processor.preprocess(image)
# 5. Prepare timesteps
def denoising_value_valid(dnv):
return isinstance(denoising_end, float) and 0 < dnv < 1
self.scheduler.set_timesteps(num_inference_steps, device=device)
timesteps, num_inference_steps = self.get_timesteps(
num_inference_steps, strength, device, denoising_start=denoising_start if denoising_value_valid else None
)
latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
add_noise = True if denoising_start is None else False
# 6. Prepare latent variables
latents = self.prepare_latents(
image,
latent_timestep,
batch_size,
num_images_per_prompt,
prompt_embeds.dtype,
device,
generator,
add_noise,
)
# 7. Prepare extra step kwargs.
extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
height, width = latents.shape[-2:]
height = height * self.vae_scale_factor
width = width * self.vae_scale_factor
original_size = original_size or (height, width)
target_size = target_size or (height, width)
# 8. Prepare added time ids & embeddings
if negative_original_size is None:
negative_original_size = original_size
if negative_target_size is None:
negative_target_size = target_size
add_text_embeds = pooled_prompt_embeds
if self.text_encoder_2 is None:
text_encoder_projection_dim = int(pooled_prompt_embeds.shape[-1])
else:
text_encoder_projection_dim = self.text_encoder_2.config.projection_dim
add_time_ids, add_neg_time_ids = self._get_add_time_ids(
original_size,
crops_coords_top_left,
target_size,
aesthetic_score,
negative_aesthetic_score,
negative_original_size,
negative_crops_coords_top_left,
negative_target_size,
dtype=prompt_embeds.dtype,
text_encoder_projection_dim=text_encoder_projection_dim,
)
add_time_ids = add_time_ids.repeat(batch_size * num_images_per_prompt, 1)
if do_classifier_free_guidance:
prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)
add_neg_time_ids = add_neg_time_ids.repeat(batch_size * num_images_per_prompt, 1)
add_time_ids = torch.cat([add_neg_time_ids, add_time_ids], dim=0)
prompt_embeds = prompt_embeds.to(device)
add_text_embeds = add_text_embeds.to(device)
add_time_ids = add_time_ids.to(device)
# 9. Denoising loop
num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0)
# 9.1 Apply denoising_end
if (
denoising_end is not None
and denoising_start is not None
and denoising_value_valid(denoising_end)
and denoising_value_valid(denoising_start)
and denoising_start >= denoising_end
):
raise ValueError(
f"`denoising_start`: {denoising_start} cannot be larger than or equal to `denoising_end`: "
+ f" {denoising_end} when using type float."
)
elif denoising_end is not None and denoising_value_valid(denoising_end):
discrete_timestep_cutoff = int(
round(
self.scheduler.config.num_train_timesteps
- (denoising_end * self.scheduler.config.num_train_timesteps)
)
)
num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))
timesteps = timesteps[:num_inference_steps]
with self.progress_bar(total=num_inference_steps) as progress_bar:
for i, t in enumerate(timesteps):
# expand the latents if we are doing classifier free guidance
latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
# predict the noise residual
added_cond_kwargs = {"text_embeds": add_text_embeds, "time_ids": add_time_ids}
noise_pred = self.unet(
latent_model_input,
t,
encoder_hidden_states=prompt_embeds,
cross_attention_kwargs=cross_attention_kwargs,
added_cond_kwargs=added_cond_kwargs,
return_dict=False,
)[0]
# perform guidance
if do_classifier_free_guidance:
noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
if do_classifier_free_guidance and guidance_rescale > 0.0:
# Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf
noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)
# compute the previous noisy sample x_t -> x_t-1
latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]
# call the callback, if provided
if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
progress_bar.update()
if callback is not None and i % callback_steps == 0:
step_idx = i // getattr(self.scheduler, "order", 1)
callback(step_idx, t, latents)
if XLA_AVAILABLE:
xm.mark_step()
if not output_type == "latent":
# make sure the VAE is in float32 mode, as it overflows in float16
needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast
if needs_upcasting:
self.upcast_vae()
latents = latents.to(next(iter(self.vae.post_quant_conv.parameters())).dtype)
image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
# cast back to fp16 if needed
if needs_upcasting:
self.vae.to(dtype=torch.float16)
else:
image = latents
return StableDiffusionXLPipelineOutput(images=image)
# apply watermark if available
if self.watermark is not None:
image = self.watermark.apply_watermark(image)
image = self.image_processor.postprocess(image, output_type=output_type)
# Offload all models
self.maybe_free_model_hooks()
if not return_dict:
return (image,)
return StableDiffusionXLPipelineOutput(images=image)
| [
"[]",
"[PLACEHOLDER, PLACEHOLDER]",
"False"
] |
2024-01-10 | wenda-LLM/wenda | plugins~qdrant.py | # -*- coding: utf-8 -*-
from __future__ import annotations
import uuid
import warnings
from hashlib import md5
from operator import itemgetter
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
Iterable,
List,
Optional,
Tuple,
Type,
Union,
)
import numpy as np
from langchain.docstore.document import Document
from langchain.embeddings.base import Embeddings
from langchain.vectorstores import VectorStore
from langchain.vectorstores.utils import maximal_marginal_relevance
if TYPE_CHECKING:
from qdrant_client.http import models as rest
MetadataFilter = Dict[str, Union[str, int, bool, dict, list]]
class Qdrant(object):
"""Wrapper around Qdrant vector database.
To use you should have the ``qdrant-client`` package installed.
Example:
.. code-block:: python
from qdrant_client import QdrantClient
from langchain import Qdrant
client = QdrantClient()
collection_name = "MyCollection"
qdrant = Qdrant(client, collection_name, embedding_function)
"""
CONTENT_KEY = "page_content"
METADATA_KEY = "metadata"
def __init__(
self,
client: Any,
collection_name: str,
embeddings: Optional[Embeddings] = None,
content_payload_key: str = CONTENT_KEY,
metadata_payload_key: str = METADATA_KEY,
embedding_function: Optional[Callable] = None, # deprecated
):
"""Initialize with necessary components."""
try:
import qdrant_client
except ImportError:
raise ValueError(
"Could not import qdrant-client python package. "
"Please install it with `pip install qdrant-client`."
)
if not isinstance(client, qdrant_client.QdrantClient):
raise ValueError(
f"client should be an instance of qdrant_client.QdrantClient, "
f"got {type(client)}"
)
if embeddings is None and embedding_function is None:
raise ValueError(
"`embeddings` value can't be None. Pass `Embeddings` instance."
)
if embeddings is not None and embedding_function is not None:
raise ValueError(
"Both `embeddings` and `embedding_function` are passed. "
"Use `embeddings` only."
)
self.embeddings = embeddings
self._embeddings_function = embedding_function
self.client: qdrant_client.QdrantClient = client
self.collection_name = collection_name
self.content_payload_key = content_payload_key or self.CONTENT_KEY
self.metadata_payload_key = metadata_payload_key or self.METADATA_KEY
if embedding_function is not None:
warnings.warn(
"Using `embedding_function` is deprecated. "
"Pass `Embeddings` instance to `embeddings` instead."
)
if not isinstance(embeddings, Embeddings):
warnings.warn(
"`embeddings` should be an instance of `Embeddings`."
"Using `embeddings` as `embedding_function` which is deprecated"
)
self._embeddings_function = embeddings
self.embeddings = None
def _embed_query(self, query: str) -> List[float]:
"""Embed query text.
Used to provide backward compatibility with `embedding_function` argument.
Args:
query: Query text.
Returns:
List of floats representing the query embedding.
"""
if self.embeddings is not None:
embedding = self.embeddings.embed_query(query)
else:
if self._embeddings_function is not None:
embedding = self._embeddings_function(query)
else:
raise ValueError("Neither of embeddings or embedding_function is set")
return embedding.tolist() if hasattr(embedding, "tolist") else embedding
def _embed_texts(self, texts: Iterable[str]) -> List[List[float]]:
"""Embed search texts.
Used to provide backward compatibility with `embedding_function` argument.
Args:
texts: Iterable of texts to embed.
Returns:
List of floats representing the texts embedding.
"""
if self.embeddings is not None:
embeddings = self.embeddings.embed_documents(list(texts))
if hasattr(embeddings, "tolist"):
embeddings = embeddings.tolist()
elif self._embeddings_function is not None:
embeddings = []
for text in texts:
embedding = self._embeddings_function(text)
if hasattr(embeddings, "tolist"):
embedding = embedding.tolist()
embeddings.append(embedding)
else:
raise ValueError("Neither of embeddings or embedding_function is set")
return embeddings
def add_texts(
self,
texts: Iterable[str],
embeddings,
ids=None,
metadatas: Optional[List[dict]] = None,
**kwargs: Any,
) -> List[str]:
"""Run more texts through the embeddings and add to the vectorstore.
Args:
texts: Iterable of strings to add to the vectorstore.
embeddings: the embeddings of texts
ids: Optional list of ids to associate with the texts. Ids have to be
uuid-like strings.
metadatas: Optional list of metadatas associated with the texts.
Returns:
List of ids from adding the texts into the vectorstore.
"""
texts = list(
texts
) # otherwise iterable might be exhausted after id calculation
if not ids:
ids = [md5(text.encode("utf-8")).hexdigest() for text in texts]
self.client.upload_collection(
collection_name=self.collection_name,
vectors=embeddings,
payload=self._build_payloads(
texts, metadatas, self.content_payload_key, self.metadata_payload_key
),
ids=ids,
parallel=1
)
return ids
def similarity_search(
self,
query: str,
k: int = 4,
filter: Optional[MetadataFilter] = None,
**kwargs: Any,
) -> List[Document]:
"""Return docs most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: Filter by metadata. Defaults to None.
Returns:
List of Documents most similar to the query.
"""
results = self.similarity_search_with_score(query, k, filter)
return list(map(itemgetter(0), results))
def similarity_search_with_score(
self, query: str, k: int = 4, filter: Optional[MetadataFilter] = None
) -> List[Tuple[Document, float]]:
"""Return docs most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: Filter by metadata. Defaults to None.
Returns:
List of Documents most similar to the query and score for each.
"""
results = self.client.search(
collection_name=self.collection_name,
query_vector=self._embed_query(query),
query_filter=self._qdrant_filter_from_dict(filter),
with_payload=True,
limit=k,
)
return [
(
self._document_from_scored_point(
result, self.content_payload_key, self.metadata_payload_key
),
result.score,
)
for result in results
]
def max_marginal_relevance_search(
self,
query: str,
k: int = 4,
fetch_k: int = 20,
lambda_mult: float = 0.5,
**kwargs: Any,
) -> List[Document]:
"""Return docs selected using the maximal marginal relevance.
Maximal marginal relevance optimizes for similarity to query AND diversity
among selected documents.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
fetch_k: Number of Documents to fetch to pass to MMR algorithm.
Defaults to 20.
lambda_mult: Number between 0 and 1 that determines the degree
of diversity among the results with 0 corresponding
to maximum diversity and 1 to minimum diversity.
Defaults to 0.5.
Returns:
List of Documents selected by maximal marginal relevance.
"""
embedding = self._embed_query(query)
results = self.client.search(
collection_name=self.collection_name,
query_vector=embedding,
with_payload=True,
with_vectors=True,
limit=fetch_k,
)
embeddings = [result.vector for result in results]
mmr_selected = maximal_marginal_relevance(
np.array(embedding), embeddings, k=k, lambda_mult=lambda_mult
)
return [
self._document_from_scored_point(
results[i], self.content_payload_key, self.metadata_payload_key
)
for i in mmr_selected
]
@classmethod
def from_texts(
cls: Type[Qdrant],
texts: List[str],
embedding: Embeddings,
embeddings,
ids=None,
metadatas: Optional[List[dict]] = None,
location: Optional[str] = None,
url: Optional[str] = None,
port: Optional[int] = 6333,
grpc_port: int = 6334,
prefer_grpc: bool = False,
https: Optional[bool] = None,
api_key: Optional[str] = None,
prefix: Optional[str] = None,
timeout: Optional[float] = None,
host: Optional[str] = None,
path: Optional[str] = None,
collection_name: Optional[str] = None,
distance_func: str = "Cosine",
content_payload_key: str = CONTENT_KEY,
metadata_payload_key: str = METADATA_KEY,
**kwargs: Any,
) -> Qdrant:
"""Construct Qdrant wrapper from a list of texts.
Args:
texts: A list of texts to be indexed in Qdrant.
embedding: A subclass of `Embeddings`, responsible for text vectorization.
embeddings: the embeddings of the texts.
ids:
Optional list of ids to associate with the texts. Ids have to be
uuid-like strings.
metadatas:
An optional list of metadata. If provided it has to be of the same
length as a list of texts.
location:
If `:memory:` - use in-memory Qdrant instance.
If `str` - use it as a `url` parameter.
If `None` - fallback to relying on `host` and `port` parameters.
url: either host or str of "Optional[scheme], host, Optional[port],
Optional[prefix]". Default: `None`
port: Port of the REST API interface. Default: 6333
grpc_port: Port of the gRPC interface. Default: 6334
prefer_grpc:
If true - use gPRC interface whenever possible in custom methods.
Default: False
https: If true - use HTTPS(SSL) protocol. Default: None
api_key: API key for authentication in Qdrant Cloud. Default: None
prefix:
If not None - add prefix to the REST URL path.
Example: service/v1 will result in
http://localhost:6333/service/v1/{qdrant-endpoint} for REST API.
Default: None
timeout:
Timeout for REST and gRPC API requests.
Default: 5.0 seconds for REST and unlimited for gRPC
host:
Host name of Qdrant service. If url and host are None, set to
'localhost'. Default: None
path:
Path in which the vectors will be stored while using local mode.
Default: None
collection_name:
Name of the Qdrant collection to be used. If not provided,
it will be created randomly. Default: None
distance_func:
Distance function. One of: "Cosine" / "Euclid" / "Dot".
Default: "Cosine"
content_payload_key:
A payload key used to store the content of the document.
Default: "page_content"
metadata_payload_key:
A payload key used to store the metadata of the document.
Default: "metadata"
**kwargs:
Additional arguments passed directly into REST client initialization
This is a user friendly interface that:
1. Creates embeddings, one for each text
2. Initializes the Qdrant database as an in-memory docstore by default
(and overridable to a remote docstore)
3. Adds the text embeddings to the Qdrant database
This is intended to be a quick way to get started.
Example:
.. code-block:: python
from langchain import Qdrant
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
qdrant = Qdrant.from_texts(texts, embeddings, "localhost")
"""
try:
import qdrant_client
except ImportError:
raise ValueError(
"Could not import qdrant-client python package. "
"Please install it with `pip install qdrant-client`."
)
from qdrant_client.http import models as rest
vector_size = embedding.client.get_sentence_embedding_dimension()
collection_name = collection_name or uuid.uuid4().hex
distance_func = distance_func.upper()
client = qdrant_client.QdrantClient(
location=location,
url=url,
port=port,
grpc_port=grpc_port,
prefer_grpc=prefer_grpc,
https=https,
api_key=api_key,
prefix=prefix,
timeout=timeout,
host=host,
path=path,
**kwargs,
)
#
client.recreate_collection(
collection_name=collection_name,
vectors_config=rest.VectorParams(
size=vector_size,
distance=rest.Distance[distance_func],
on_disk=True
),
optimizers_config=rest.OptimizersConfigDiff(
indexing_threshold=0, default_segment_number=8,
memmap_threshold=20000
),
hnsw_config=rest.HnswConfigDiff(on_disk=True),
shard_number=2,
on_disk_payload=True
)
if not ids:
ids = [md5(text.encode("utf-8")).hexdigest() for text in texts]
client.upload_collection(
collection_name=collection_name,
vectors=embeddings,
payload=cls._build_payloads(
texts, metadatas, content_payload_key, metadata_payload_key
),
ids=ids,
parallel=1
)
return cls(
client=client,
collection_name=collection_name,
embeddings=embedding,
content_payload_key=content_payload_key,
metadata_payload_key=metadata_payload_key,
)
@classmethod
def _build_payloads(
cls,
texts: Iterable[str],
metadatas: Optional[List[dict]],
content_payload_key: str,
metadata_payload_key: str,
) -> List[dict]:
payloads = []
for i, text in enumerate(texts):
if text is None:
raise ValueError(
"At least one of the texts is None. Please remove it before "
"calling .from_texts or .add_texts on Qdrant instance."
)
metadata = metadatas[i] if metadatas is not None else None
payloads.append(
{
content_payload_key: text,
metadata_payload_key: metadata,
}
)
return payloads
@classmethod
def _document_from_scored_point(
cls,
scored_point: Any,
content_payload_key: str,
metadata_payload_key: str,
) -> Document:
return Document(
page_content=scored_point.payload.get(content_payload_key),
metadata=scored_point.payload.get(metadata_payload_key) or {},
)
def _build_condition(self, key: str, value: Any) -> List[rest.FieldCondition]:
from qdrant_client.http import models as rest
out = []
if isinstance(value, dict):
for _key, value in value.items():
out.extend(self._build_condition(f"{key}.{_key}", value))
elif isinstance(value, list):
for _value in value:
if isinstance(_value, dict):
out.extend(self._build_condition(f"{key}[]", _value))
else:
out.extend(self._build_condition(f"{key}", _value))
else:
out.append(
rest.FieldCondition(
key=f"{self.metadata_payload_key}.{key}",
match=rest.MatchValue(value=value),
)
)
return out
def _qdrant_filter_from_dict(
self, filter: Optional[MetadataFilter]
) -> Optional[rest.Filter]:
from qdrant_client.http import models as rest
if not filter:
return None
return rest.Filter(
must=[
condition
for key, value in filter.items()
for condition in self._build_condition(key, value)
]
)
| [] |
2024-01-10 | wenda-LLM/wenda | llms~llm_openai.py | import os
import openai
from plugins.common import settings
def chat_init(history):
return history
def chat_one(prompt, history_formatted, max_length, top_p, temperature, data):
history_data = [ {"role": "system", "content": "You are a helpful assistant."}]
if history_formatted is not None:
for i, old_chat in enumerate(history_formatted):
if old_chat['role'] == "user":
history_data.append(
{"role": "user", "content": old_chat['content']},)
elif old_chat['role'] == "AI" or old_chat['role'] == 'assistant':
history_data.append(
{"role": "assistant", "content": old_chat['content']},)
history_data.append({"role": "user", "content": prompt},)
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=history_data,
stream=True
)
resTemp=""
for chunk in response:
#print(chunk)
if chunk['choices'][0]["finish_reason"]!="stop":
if hasattr(chunk['choices'][0]['delta'], 'content'):
resTemp+=chunk['choices'][0]['delta']['content']
yield resTemp
chatCompletion = None
def load_model():
openai.api_key = os.getenv("OPENAI_API_KEY")
openai.api_base = settings.llm.api_host
class Lock:
def __init__(self):
pass
def get_waiting_threads(self):
return 0
def __enter__(self):
pass
def __exit__(self, exc_type, exc_val, exc_tb):
pass | [
"content",
"You are a helpful assistant."
] |
2024-01-10 | wenda-LLM/wenda | plugins~gen_data_qdrant.py | import re
import os
import sys
import math
import threading
import loguru
from hashlib import md5
os.chdir(sys.path[0][:-8])
from langchain.text_splitter import CharacterTextSplitter
from qdrant_client import QdrantClient
from qdrant_client.http import models as rest
from langchain.docstore.document import Document
from typing import Dict, Iterable, List, Optional, Union
from langchain.embeddings import HuggingFaceEmbeddings
import logging, time
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
import chardet
import pdfplumber
from qdrant import Qdrant
from common import CounterLock
from common import settings, error_print, error_helper, success_print
source_folder = settings.librarys.qdrant.path
source_folder_path = os.path.join(os.getcwd(), source_folder)
root_path_list = source_folder_path.split(os.sep)
docs = []
texts_count = 0
MetadataFilter = Dict[str, Union[str, int, bool]]
COLLECTION_NAME = settings.librarys.qdrant.collection # 向量库名字
model_path = settings.librarys.qdrant.model_path
try:
encode_kwargs = {'batch_size': settings.librarys.qdrant.batch_size}
model_kwargs = {"device": settings.librarys.qdrant.device}
embedding = HuggingFaceEmbeddings(model_name=model_path, encode_kwargs=encode_kwargs, model_kwargs=model_kwargs)
except Exception as e:
error_helper("embedding加载失败，请下载相应模型",
r"https://github.com/l15y/wenda#st%E6%A8%A1%E5%BC%8F")
raise e
success_print("Embedding model加载完成")
try:
client = QdrantClient(path="memory/q")
client.get_collection(COLLECTION_NAME)
vectorstore = Qdrant(client, COLLECTION_NAME, embedding)
except:
del client
vectorstore = None
# vectorstore = None
embedding_lock = CounterLock()
vectorstore_lock = threading.Lock()
def clac_embedding(texts, embedding, metadatas):
global vectorstore
with embedding_lock:
embeddings = embedding.embed_documents(texts)
with vectorstore_lock:
ids = gen_ids(metadatas)
if vectorstore is None:
# 如需插入大规模数据可以将prefer_grpc参数置为True
if(settings.librarys.qdrant.qdrant_path):
vectorstore = Qdrant.from_texts(texts, embedding, embeddings, ids, metadatas=metadatas,
path=settings.librarys.qdrant.qdrant_path, prefer_grpc=True,
collection_name=settings.librarys.qdrant.collection, timeout=10)
elif(settings.librarys.qdrant.qdrant_host):
vectorstore = Qdrant.from_texts(texts, embedding, embeddings, ids, metadatas=metadatas,
url=settings.librarys.qdrant.qdrant_host, prefer_grpc=True,
collection_name=settings.librarys.qdrant.collection, timeout=10)
else:
vectorstore.add_texts(texts, embeddings, ids, metadatas)
# 生成该id的方法仅供参考
def gen_ids(metadatas):
ids = []
same_title_count = 0
last_text_title = ""
for metadata in metadatas:
text_title = md5(metadata["source"].encode("utf-8")).hexdigest()
if last_text_title != text_title:
last_text_title = text_title
same_title_count = 0
else:
same_title_count += 1
origin = text_title[:30] + str(hex(same_title_count))[2:].zfill(3) # 最后三位为十六进制的文章段落数 前二十九位为文章title哈希
origin = f"{origin[:8]}-{origin[8:12]}-{origin[12:16]}-{origin[16:20]}-{origin[-12:]}"
ids.append(origin)
return ids
def make_index():
global docs, texts_count
if hasattr(settings.librarys.qdrant, "size") and hasattr(settings.librarys.qdrant, "overlap"):
text_splitter = CharacterTextSplitter(
chunk_size=int(settings.librarys.qdrant.size), chunk_overlap=int(settings.librarys.qdrant.overlap), separator='\n')
else:
text_splitter = CharacterTextSplitter(
chunk_size=20, chunk_overlap=0, separator='\n')
doc_texts = text_splitter.split_documents(docs)
docs = []
texts = [d.page_content for d in doc_texts]
metadatas = [d.metadata for d in doc_texts]
texts_count += len(texts)
thread = threading.Thread(target=clac_embedding, args=(texts, embedding, metadatas))
thread.start()
while embedding_lock.get_waiting_threads() > 1:
time.sleep(0.1)
all_files = []
for root, dirs, files in os.walk(source_folder_path):
for file in files:
all_files.append([root, file])
success_print("文件列表生成完成", len(all_files))
length_of_read = 0
for i in range(len(all_files)):
root, file = all_files[i]
data = ""
title = ""
try:
file_path = os.path.join(root, file)
_, ext = os.path.splitext(file_path)
if ext.lower() == '.pdf':
# pdf
with pdfplumber.open(file_path) as pdf:
data_list = []
for page in pdf.pages:
print(page.extract_text())
data_list.append(page.extract_text())
data = "\n".join(data_list)
elif ext.lower() == '.txt':
# txt
with open(file_path, 'rb') as f:
print("open:",file_path)
b = f.read()
result = chardet.detect(b)
with open(file_path, 'r', encoding=result['encoding']) as f:
data = f.read()
else:
print("目前还不支持文件格式：", ext)
except Exception as e:
print("文件读取失败，当前文件已被跳过：", file, "。错误信息：", e)
data = re.sub(r'！', "！\n", data)
data = re.sub(r'：', "：\n", data)
data = re.sub(r'。', "。\n", data)
data = re.sub(r'\r', "\n", data)
data = re.sub(r'\n\n', "\n", data)
data = re.sub(r"\n\s*\n", "\n", data)
length_of_read += len(data)
docs.append(Document(page_content=data, metadata={"source": file}))
if length_of_read > 1e5: # 大于10万字的先处理（即不作为最后的统一处理）
success_print("处理进度", int(100*i/len(all_files)), f"%\t({i}/{len(all_files)})")
make_index()
length_of_read = 0
length_of_read += len(data)
docs.append(Document(page_content=data, metadata={"source": file}))
if length_of_read > 1e5:
success_print("处理进度", int(100 * i / len(all_files)), f"%\t({i}/{len(all_files)})")
make_index()
length_of_read = 0
if len(all_files) == 0:
error_print("指定目录{}没有数据".format(settings.librarys.qdrant.path))
sys.exit(0)
if len(docs) > 0:
make_index()
while embedding_lock.get_waiting_threads() > 0:
time.sleep(0.1)
with embedding_lock:
time.sleep(0.1)
success_print("数据上装完成")
with vectorstore_lock:
print("开始构建索引，需要一定时间")
vectorstore.client.update_collection(
collection_name=COLLECTION_NAME,
optimizer_config=rest.OptimizersConfigDiff(
indexing_threshold=20000
)
)
success_print("索引处理完成")
| [] |
2024-01-10 | wenda-LLM/wenda | plugins~gen_data_st.py |
import sentence_transformers
from langchain.text_splitter import CharacterTextSplitter
from langchain.docstore.document import Document
import threading
import pdfplumber
import re
import chardet
import os
import sys
import time
import docx
sys.path.append(os.getcwd())
from plugins.common import success_print, error_print
from plugins.common import error_helper
from plugins.common import settings
from plugins.common import CounterLock
if settings.librarys.rtst.backend=="Annoy":
from langchain.vectorstores.annoy import Annoy as Vectorstore
else:
from langchain.vectorstores.faiss import FAISS as Vectorstore
source_folder = 'txt'
source_folder_path = os.path.join(os.getcwd(), source_folder)
import logging
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
root_path_list = source_folder_path.split(os.sep)
docs = []
vectorstore = None
model_path = settings.librarys.rtst.model_path
try:
if model_path.startswith("http"):#"http://127.0.0.1:3000/"
from langchain.embeddings import OpenAIEmbeddings
import os
os.environ["OPENAI_API_TYPE"] = "open_ai"
os.environ["OPENAI_API_BASE"] = model_path
os.environ["OPENAI_API_KEY"] = "your OpenAI key"
from langchain.embeddings.openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(
deployment="text-embedding-ada-002",
model="text-embedding-ada-002"
)
else:
from langchain.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(model_name='')
embeddings.client = sentence_transformers.SentenceTransformer(
model_path, device="cuda")
except Exception as e:
error_helper("embedding加载失败",
r"https://github.com/l15y/wenda")
raise e
success_print("Embedding 加载完成")
embedding_lock=CounterLock()
vectorstore_lock=threading.Lock()
def clac_embedding(texts, embeddings, metadatas):
global vectorstore
with embedding_lock:
vectorstore_new = Vectorstore.from_texts(texts, embeddings, metadatas=metadatas)
with vectorstore_lock:
if vectorstore is None:
vectorstore = vectorstore_new
else:
vectorstore.merge_from(vectorstore_new)
def make_index():
global docs
if hasattr(settings.librarys.rtst,"size") and hasattr(settings.librarys.rtst,"overlap"):
text_splitter = CharacterTextSplitter(
chunk_size=int(settings.librarys.rtst.size), chunk_overlap=int(settings.librarys.rtst.overlap), separator='\n')
else:
text_splitter = CharacterTextSplitter(
chunk_size=20, chunk_overlap=0, separator='\n')
doc_texts = text_splitter.split_documents(docs)
docs = []
texts = [d.page_content for d in doc_texts]
metadatas = [d.metadata for d in doc_texts]
thread = threading.Thread(target=clac_embedding, args=(texts, embeddings, metadatas))
thread.start()
while embedding_lock.get_waiting_threads()>2:
time.sleep(0.1)
all_files=[]
for root, dirs, files in os.walk(source_folder_path):
for file in files:
all_files.append([root, file])
success_print("文件列表生成完成",len(all_files))
length_of_read=0
for i in range(len(all_files)):
root, file=all_files[i]
data = ""
title = ""
try:
file_path = os.path.join(root, file)
_, ext = os.path.splitext(file_path)
if ext.lower() == '.pdf':
#pdf
with pdfplumber.open(file_path) as pdf:
data_list = []
for page in pdf.pages:
print(page.extract_text())
data_list.append(page.extract_text())
data = "\n".join(data_list)
elif ext.lower() == '.txt':
# txt
with open(file_path, 'rb') as f:
b = f.read()
result = chardet.detect(b)
with open(file_path, 'r', encoding=result['encoding']) as f:
data = f.read()
elif ext.lower() == '.docx':
doc = docx.Document(file_path)
data_list = []
for para in doc.paragraphs:
data_list.append(para.text)
data = '\n'.join(data_list)
else:
print("目前还不支持文件格式：", ext)
except Exception as e:
print("文件读取失败，当前文件已被跳过：",file,"。错误信息：",e)
# data = re.sub(r'！', "！\n", data)
# data = re.sub(r'：', "：\n", data)
# data = re.sub(r'。', "。\n", data)
data = re.sub(r"\n\s*\n", "\n", data)
data = re.sub(r'\r', "\n", data)
data = re.sub(r'\n\n', "\n", data)
length_of_read+=len(data)
docs.append(Document(page_content=data, metadata={"source": file}))
if length_of_read > 1e5:
success_print("处理进度",int(100*i/len(all_files)),f"%\t({i}/{len(all_files)})")
make_index()
# print(embedding_lock.get_waiting_threads())
length_of_read=0
if len(all_files) == 0:
error_print("txt 目录没有数据")
sys.exit(0)
if len(docs) > 0:
make_index()
while embedding_lock.get_waiting_threads()>0:
time.sleep(0.1)
success_print("处理进度",100,"%")
with embedding_lock:
time.sleep(0.1)
with vectorstore_lock:
success_print("处理完成")
try:
vectorstore_old = Vectorstore.load_local(
'memory/default', embeddings=embeddings)
success_print("合并至已有索引。如不需合并请删除 memory/default 文件夹")
vectorstore_old.merge_from(vectorstore)
vectorstore_old.save_local('memory/default')
except:
print("新建索引")
vectorstore.save_local('memory/default')
success_print("保存完成")
| [] |
2024-01-10 | wenda-LLM/wenda | plugins~zhishiku_rtst.py |
from langchain.embeddings import HuggingFaceEmbeddings
import sentence_transformers
import numpy as np
import re,os
from plugins.common import settings,allowCROS
from plugins.common import error_helper
from plugins.common import success_print
if settings.librarys.rtst.backend=="Annoy":
from langchain.vectorstores.annoy import Annoy as Vectorstore
else:
from langchain.vectorstores.faiss import FAISS as Vectorstore
divider='\n'
if not os.path.exists('memory'):
os.mkdir('memory')
cunnrent_setting=settings.librarys.rtst
def get_doc_by_id(id,memory_name):
return vectorstores[memory_name].docstore.search(vectorstores[memory_name].index_to_docstore_id[id])
def process_strings(A, C, B):
# find the longest common suffix of A and prefix of B
common = ""
for i in range(1, min(len(A), len(B)) + 1):
if A[-i:] == B[:i]:
common = A[-i:]
# if there is a common substring, replace one of them with C and concatenate
if common:
return A[:-len(common)] + C + B
# otherwise, just return A + B
else:
return A + B
def get_title_by_doc(doc):
return re.sub('【.+】', '', doc.metadata['source'])
def get_doc(id,score,step,memory_name):
doc = get_doc_by_id(id,memory_name)
final_content=doc.page_content
# print("文段分数：",score,[doc.page_content])
if step > 0:
for i in range(1, step+1):
try:
doc_before=get_doc_by_id(id-i,memory_name)
if get_title_by_doc(doc_before)==get_title_by_doc(doc):
final_content=process_strings(doc_before.page_content,divider,final_content)
# print("上文分数：",score,doc.page_content)
except:
pass
try:
doc_after=get_doc_by_id(id+i,memory_name)
if get_title_by_doc(doc_after)==get_title_by_doc(doc):
final_content=process_strings(final_content,divider,doc_after.page_content)
except:
pass
if doc.metadata['source'].endswith(".pdf") or doc.metadata['source'].endswith(".txt"):
title=f"[{doc.metadata['source']}](/txt/{doc.metadata['source']})"
else:
title=doc.metadata['source']
return {'title': title,'content':re.sub(r'\n+', "\n", final_content),"score":int(score)}
def find(s,step = 0,memory_name="default"):
try:
embedding = get_vectorstore(memory_name).embedding_function(s)
scores, indices = vectorstores[memory_name].index.search(np.array([embedding], dtype=np.float32), int(cunnrent_setting.count))
docs = []
for j, i in enumerate(indices[0]):
if i == -1:
continue
if scores[0][j]>260:continue
docs.append(get_doc(i,scores[0][j],step,memory_name))
return docs
except Exception as e:
print(e)
return []
model_path=cunnrent_setting.model_path
try:
if model_path.startswith("http"):#"http://127.0.0.1:3000/"
from langchain.embeddings import OpenAIEmbeddings
import os
os.environ["OPENAI_API_TYPE"] = "open_ai"
os.environ["OPENAI_API_BASE"] = model_path
os.environ["OPENAI_API_KEY"] = "your OpenAI key"
from langchain.embeddings.openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(
deployment="text-embedding-ada-002",
model="text-embedding-ada-002"
)
else:
from langchain.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(model_name='')
embeddings.client = sentence_transformers.SentenceTransformer(
model_path, device="cuda")
except Exception as e:
error_helper("embedding加载失败",
r"https://github.com/l15y/wenda")
raise e
vectorstores={}
def get_vectorstore(memory_name):
try:
return vectorstores[memory_name]
except Exception as e:
try:
vectorstores[memory_name] = Vectorstore.load_local(
'memory/'+memory_name, embeddings=embeddings)
return vectorstores[memory_name]
except Exception as e:
success_print("没有读取到RTST记忆区%s，将新建。"%memory_name)
return None
from langchain.docstore.document import Document
from langchain.text_splitter import CharacterTextSplitter
from bottle import route, response, request, static_file, hook
import bottle
@route('/upload_rtst_zhishiku', method=("POST","OPTIONS"))
def upload_zhishiku():
allowCROS()
try:
data = request.json
title=data.get("title")
memory_name=data.get("memory_name")
data = data.get("txt")
# data = re.sub(r'！', "！\n", data)
# data = re.sub(r'：', "：\n", data)
# data = re.sub(r'。', "。\n", data)
data = re.sub(r"\n\s*\n", "\n", data)
data = re.sub(r'\r', "\n", data)
data = re.sub(r'\n\n', "\n", data)
docs=[Document(page_content=data, metadata={"source":title })]
print(docs)
if hasattr(settings.librarys.rtst,"size") and hasattr(settings.librarys.rtst,"overlap"):
text_splitter = CharacterTextSplitter(
chunk_size=int(settings.librarys.rtst.size), chunk_overlap=int(settings.librarys.rtst.overlap), separator='\n')
else:
text_splitter = CharacterTextSplitter(
chunk_size=20, chunk_overlap=0, separator='\n')
doc_texts = text_splitter.split_documents(docs)
texts = [d.page_content for d in doc_texts]
metadatas = [d.metadata for d in doc_texts]
vectorstore_new = Vectorstore.from_texts(texts, embeddings, metadatas=metadatas)
vectorstore=get_vectorstore(memory_name)
if vectorstore is None:
vectorstores[memory_name]=vectorstore_new
else:
vectorstores[memory_name].merge_from(vectorstore_new)
return '成功'
except Exception as e:
return str(e)
@route('/save_rtst_zhishiku', method=("POST","OPTIONS"))
def save_zhishiku():
allowCROS()
try:
data = request.json
memory_name=data.get("memory_name")
vectorstores[memory_name].save_local('memory/'+memory_name)
return "保存成功"
except Exception as e:
return str(e)
import json
@route('/find_rtst_in_memory', method=("POST","OPTIONS"))
def api_find():
allowCROS()
try:
data = request.json
prompt = data.get('prompt')
step = data.get('step')
memory_name=data.get("memory_name")
if step is None:
step = int(settings.library.step)
return json.dumps(find(prompt,int(step),memory_name))
except Exception as e:
return str(e)
@route('/list_rtst_in_disk', method=("POST","OPTIONS"))
def api_find():
allowCROS()
return json.dumps(os.listdir('memory'))
@route('/del_rtst_in_memory', method=("POST","OPTIONS"))
def api_find():
allowCROS()
try:
data = request.json
memory_name=data.get("memory_name")
del vectorstores[memory_name]
except Exception as e:
return str(e)
@route('/save_news', method=("POST","OPTIONS"))
def save_news():
allowCROS()
try:
data = request.json
if not data:
return 'no data'
title = data.get('title')
txt = data.get('txt')
cut_file = f"txt/{title}.txt"
with open(cut_file, 'w', encoding='utf-8') as f:
f.write(txt)
f.close()
return 'success'
except Exception as e:
return(e)
| [
"\n",
"\\n+"
] |
2024-01-10 | KhushiAgg/Product-Innovation-LLM-application | kbot.py | import os
import pickle
import warnings
warnings.filterwarnings("ignore")
import streamlit as st
from dotenv import load_dotenv
from PyPDF2 import PdfReader
from streamlit_extras.add_vertical_space import add_vertical_space
from langchain.text_splitter import RecursiveCharacterTextSplitter #for splitting text
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS #facebook AI Similarity Search for vectorization
from langchain import HuggingFaceHub #for loading LLM
from langchain.chains.question_answering import load_qa_chain #for setting up QnA chain
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from pprint import pprint
# Sidebar
with st.sidebar:
st.title("K LLM Chatbot")
st.markdown('''
## About
This is a LLM-powered customer support chatbot build using:
- [Streamlit](https://streamlit.io/)
- [Langchain](https://www.langchain.com/)
- [Huggingface](https://huggingface.co/) LLM Model
''')
add_vertical_space(5)
st.write('Made by [Khushi Agarwal](https://github.com/KhushiAgg)')
def main():
st.header("🫂KK Customer Support Bot")
load_dotenv()
#Upload your pdf file
pdf = st.file_uploader("Upload your pdf", type='pdf')
if pdf is not None:
pdf_reader = PdfReader(pdf)
text = ""
for page in pdf_reader.pages:
text += page.extract_text()
# Split text to chunks
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=100,
length_function=len)
chunks = text_splitter.split_text(text=text)
# st.write(chunks)
file_name = pdf.name[:-4]
# to save incurring cost for creating vector dbs again and again
# we execute a simple if-else for checking if v db exists
if os.path.exists(f"{file_name}.pkl"):
with open(f"{file_name}.pkl", "rb") as f:
faiss_index = pickle.load(f)
# st.write("Embeddings loaded from the Disk")
else:
#Initialize embeddings
embeddings = HuggingFaceEmbeddings()
# PDF chunks --> Embeddings --> Store vectors
faiss_index = FAISS.from_texts(chunks, embeddings)
with open(f"{file_name}.pkl", "wb") as f:
pickle.dump(faiss_index, f)
# st.write("Embeddings created")
# Query from your pdf
query = st.text_input("Ask questions about your PDF file: ")
# st.write(query)
if query:
docs = faiss_index.similarity_search(query = query)
llm=HuggingFaceHub(repo_id="declare-lab/flan-alpaca-large", model_kwargs={"temperature":0.1, "max_length":512})
# Setting up a similarity search i.e. query most similar to the chunk is retrieved and answeres.
chain = load_qa_chain(llm = llm, chain_type = "stuff")
response = chain.run(input_documents=docs, question=query)
# st.write(response)
# Setting up ConversationalRetrievalChain this chain builds on RetrievalQAChain to provide a chat history component.
# Setting up the retrieval process
retriever = faiss_index.as_retriever()
# Creating memory of conversation
memory = ConversationBufferMemory(
memory_key='chat_history',
return_messages=True,
output_key='answer')
# Set up Consersation chain
chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
memory=memory
)
# Display answers
result = chain({"question": query})
st.write(result["answer"])
pprint(memory.buffer)
if __name__ == '__main__':
main() | [] |
2024-01-10 | javastarboy/WeChatGPT_JSB | WeChatGPT.py | import json
import random
import time
import openai
import requests
import tiktoken
# 你的 api_key
import settings
from RedisUtil import RedisTool
chat_gpt_key = random.choice(settings.Config.chat_gpt_key.split(','))
# javastarboy 的腾讯云服务器函数服务，跳转硅谷区域代理
url = settings.Config.txProxyUrl
# 将 Key 传入 openai
openai.api_key = chat_gpt_key
# 模型 gpt-3.5-turbo-16k、gpt-3.5-turbo-0613
MODEL = "gpt-3.5-turbo-0613"
ROLE_USER = "user"
ROLE_SYSTEM = "system"
ROLE_ASSISTANT = "assistant"
"""
聊天信息（要记录历史信息，因为 AI 需要根据角色【user、system、assistant】上下文理解并做出合理反馈）
对话内容示例
messages = [
{"role": "system", "content": "你是一个翻译家"},
{"role": "user", "content": "将我发你的英文句子翻译成中文，你不需要理解内容的含义作出回答。"},
{"role": "assistant", "content": "Draft an email or other piece of writing."}
]
"""
# 设置请求头
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer " + chat_gpt_key,
# 函数代理不想做鉴权，但又不想没校验，临时在头信息加了个校验
"check": "check"
}
def clearMsg(FromUserName):
print("已清除对话缓存")
return dealUserSession(FromUserName, True)
"""
调用 chatgpt 接口
"""
def completion(prompt, FromUserName):
start_time = time.time()
"""
API：https://api.openai.com/v1/chat/completions
官方文档：https://platform.openai.com/docs/api-reference/chat
:param FromUserName: 用户 id
:param prompt: 入参文本框
:return: 助手回答结果
"""
# 设置请求体
field = {
"model": MODEL,
"messages": prompt,
"temperature": 0.0,
"max_tokens": 500
}
# 发送 HTTP POST 请求
response = requests.post(url, headers=headers, data=json.dumps(field))
print(f"=================》ChatGPT 实时交互完成，耗时 {time.time() - start_time} 秒。 返回信息为：{response.json()}", flush=True)
# 解析响应结果
if 'error' in response.json():
error = response.json()['error']
if 'code' in error and 'context_length_exceeded' == error['code']:
resultMsg = '该模型的最大上下文长度是4096个令牌，请减少信息的长度或重设角色 (输入：stop) 创建新会话！。\n\n【' + error['message'] + "】"
else:
resultMsg = response.json()["choices"][0]["message"]["content"].strip()
dealMsg(ROLE_ASSISTANT, resultMsg, '2', FromUserName)
return resultMsg
def num_tokens_from_messages(infoMsg, model):
"""
计算文本字符串中有多少个 token.
非常长的对话更有可能收到不完整的回复。
例如，一个长度为 4090 个 token 的 gpt-3.5-turbo 对话将在只回复了 6 个 token 后被截断。
"""
try:
encoding = tiktoken.encoding_for_model(model)
except KeyError:
encoding = tiktoken.get_encoding("cl100k_base")
if model.startswith("gpt-3.5-turbo"): # 注意: 未来的模型可能会偏离这个规则
num_tokens = 0
for message in infoMsg:
num_tokens += 4
for key, value in message.items():
num_tokens += len(encoding.encode(value))
if key == "name": # 如果有名字，角色将被省略
num_tokens += -1 # Role总是必需的，并且总是1个令牌
num_tokens += 2 # 每个回复都用assistant启动
return num_tokens
else:
raise NotImplementedError(f"""num_tokens_from_messages() is not presently implemented for model {model}.
See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens.""")
def dealUserSession(FromUserName, clearType):
"""
将 FromUserName 聊天记录存入 redis 中，以便支持多人会话，否则多人访问时，会有会话冲突的问题
:param FromUserName: 微信用户 id
:param clearType: 是否清空会话
:return:
"""
redis_tool = RedisTool().get_client()
try:
weChatToken = "WeChatGPT_" + FromUserName
messages = redis_tool.get(weChatToken)
if messages:
messages = json.loads(messages)
if clearType:
redis_tool.delete(weChatToken)
return "好的，您的会话 session 已清除，感谢使用!"
else:
# 存储消息【redis 取出来是 bytes 字节，需要转换一下】
return messages
elif clearType:
return "好的，您的会话 session 已清除，感谢使用!"
else:
return None
except Exception as e:
print(f"An redis error occurred: {e}")
raise ValueError("对不起，由于当前访问量过高，当前提问已被限制，请重新提问，谢谢~")
finally:
redis_tool.close()
def dealMsg(role, msg, msgRole, FromUserName):
"""
:param role: 角色【system,user,assistant】
:param msg: 聊天信息
:param msgRole: 判断消息发送者【1-用户信息，2-助手信息】
:param FromUserName: 用户 id
:return:
"""
weChatToken = "WeChatGPT_" + FromUserName
messages = dealUserSession(FromUserName, False)
redis_tool = RedisTool().get_client()
try:
if messages:
messages.append({"role": role, "content": msg})
elif messages is None:
# 首次会话
messages = [{"role": role, "content": msg}]
redis_tool = RedisTool().get_client()
# 默认一小时，每次更新数据都刷，如果一小时内都没有交互，默认删除 session
redis_tool.setex(weChatToken, settings.Config.clearSessionTime, json.dumps(messages))
except Exception as e:
print(f"An redis error occurred: {e}")
raise ValueError("对不起，由于当前访问量过高，当前提问已被限制，请重新提问，谢谢~")
finally:
redis_tool.close()
# 如果是用户，做进一步处理后再请求 openai
if msgRole == "1":
# 计费：计算耗费的 token 数
count = num_tokens_from_messages(messages, MODEL)
print(f"{count} {msgRole} prompt tokens counted")
if count > 4096:
raise ValueError("请求上下文已超过 4096 令牌数，请重设角色 (输入：stop) 创建新会话！")
"""
如果列表长度大于 6，删除多余的数据，只保留第一条以及后4 或 5条数据（带上下文请求 gpt）
第一条：role = system
后三条：历史上下文保留三条数据（含当前最新消息）
"""
if len(messages) > 6:
if messages[-1]["role"] == ROLE_USER:
# 主要针对"继续写"场景，最后一条为 user 一定是用户问了新问题
print([messages[0]] + messages[-4:])
else:
# 第一条 + 后五条记录（最后一条非 role，那一定是 assistant）
print([messages[0]] + messages[-5:])
# 历史消息
return messages
| [] |
2024-01-10 | beaucarnes/vector-search-tutorial | project-one~movie_recs2.py | import pymongo
import openai
# Set your OpenAI API key
openai.api_key = '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'
client = pymongo.MongoClient("mongodb+srv://beau:[email protected]/?retryWrites=true&w=majority")
db = client.sample_mflix
collection = db.embedded_movies
def generate_embedding(text: str) -> list[float]:
response = openai.Embedding.create(
model="text-embedding-ada-002",
input=text
)
return response['data'][0]['embedding']
query = "imaginary characters from outer space at war"
results = collection.aggregate([
{"$vectorSearch": {
"queryVector": generate_embedding(query),
"path": "plot_embedding",
"numCandidates": 100,
"limit": 4,
"index": "PlotSemanticSearch",
}}
]);
for document in results:
print(f'Movie Name: {document["title"]},\nMovie Plot: {document["plot"]}\n') | [] |
2024-01-10 | emory-courses/conversational-ai | src~apppointment.py | # ========================================================================
# Copyright 2023 Emory University
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ========================================================================
__author__ = 'Jinho D. Choi'
import random
from enum import Enum
from typing import Dict, Any
import openai
from emora_stdm import DialogueFlow
from src import utils
from src.utils import MacroGPTJSON, MacroNLG
PATH_USER_INFO = 'resources/userinfo.json'
class V(Enum):
call_names = 0, # str
office_location = 1 # str
office_hours = 2 # dict -> {"Monday": {"begin": "14:00", "end": "15:00"}}
def main() -> DialogueFlow:
transitions = {
'state': 'start',
'`Hi, how should I call you?`': {
'#SET_CALL_NAMES': {
'`Nice to meet you,` #GET_CALL_NAME `. Can you tell me where your office is and when your general office hours are?`': {
'#SET_OFFICE_LOCATION_HOURS': {
'`Can you confirm if the following office infos are correct?` #GET_OFFICE_LOCATION_HOURS': {
}
}
}
},
'error': {
'`Sorry, I didn\'t understand you.`': 'end'
}
}
}
macros = {
'GET_CALL_NAME': MacroNLG(get_call_name),
'GET_OFFICE_LOCATION_HOURS': MacroNLG(get_office_location_hours),
'SET_CALL_NAMES': MacroGPTJSON(
'How does the speaker want to be called?',
{V.call_names.name: ["Mike", "Michael"]}),
'SET_OFFICE_LOCATION_HOURS': MacroGPTJSON(
'Where is the speaker\'s office and when are the office hours?',
{V.office_location.name: "White Hall E305", V.office_hours.name: [{"day": "Monday", "begin": "14:00", "end": "15:00"}, {"day": "Friday", "begin": "11:00", "end": "12:30"}]},
{V.office_location.name: "N/A", V.office_hours.name: []},
set_office_location_hours
),
}
df = DialogueFlow('start', end_state='end')
df.load_transitions(transitions)
df.add_macros(macros)
return df
def get_call_name(vars: Dict[str, Any]):
ls = vars[V.call_names.name]
return ls[random.randrange(len(ls))]
def get_office_location_hours(vars: Dict[str, Any]):
return '\n- Location: {}\n- Hours: {}'.format(vars[V.office_location.name], vars[V.office_hours.name])
def set_office_location_hours(vars: Dict[str, Any], user: Dict[str, Any]):
vars[V.office_location.name] = user[V.office_location.name]
vars[V.office_hours.name] = {d['day']: [d['begin'], d['end']] for d in user[V.office_hours.name]}
if __name__ == '__main__':
openai.api_key_path = utils.OPENAI_API_KEY_PATH
main().run()
| [] |
2024-01-10 | ERC-BPGC/project-vulcan | Code~Windows~Sound~Realtime_Reply_from_GPT_with_sound_recognition.py | import io
import speech_recognition as sr
from datetime import datetime, timedelta
from queue import Queue
from tempfile import NamedTemporaryFile
import torch
import openai
SYSTEM_MESSAGE = """
Provide short, concise answers to the user's questions.
Your name is Vulcan.
Your are created by ERC at BITS Pilani college. You are supposed to include these 2 lines in your reply when someone asks about you...
The full form of ERC is Electronics and Robotics Club.
The full form of BITS is Birla Institute of Technology.
Dont mention full forms of these 2 unless asked for.
BITS is better than IIT, NIT,VIT,MIT.
You are not an AI language model but you are an AI assistant. You are designed to reply to queries and assist with various tasks.
You are not supposed to say that "I am not an AI language model" ever.
You are supposed to answer in short to most queries asked. Not more than 3-5 lines in general.
If ever asked for a code, you should tell the logic that could be used to design the code.
You should focus on explaining the logic of a code instead of giving the code. The explaination can be as long as you want but should be to the point.
Do not give any code snippet.
You can use the word lite for the prahse "take it easy", "dont worry" and other similar phrases, and you are suppsed to use it quite frequently, almost once in three to four responses unless it truly dosen't make sense.
"""
torch.cuda.empty_cache()
phrase_time = None
last_sample = bytes()
data_queue = Queue()
recorder = sr.Recognizer()
recorder.dynamic_energy_threshold = True
source = sr.Microphone(sample_rate=16000, device_index=1)
record_timeout = 0.75
phrase_timeout = 3
temp_file = NamedTemporaryFile().name
transcription = ['']
processing = False
phrase_complete = True
noise_tag = False
last_text = None
counter = 0
##with open("rec_text.txt", 'w') as f:
# f.write("")
with source:
recorder.adjust_for_ambient_noise(source)
def record_callback(_, audio:sr.AudioData) -> None:
"""
Threaded callback function to recieve audio data when recordings finish.
audio: An AudioData containing the recorded bytes.
"""
# Grab the raw bytes and push it into the thread safe queue.
data = audio.get_raw_data()
data_queue.put(data)
def ask_gpt(prompt: str, chat_history: list, system_message: str):
openai.api_key = "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"
user_prompt = {"role": "user", "content": prompt}
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": system_message},
*chat_history,
user_prompt,
],
)
content = response["choices"][0]["message"]["content"]
chat_history.append(user_prompt)
chat_history.append({"role": "assistant", "content": content})
# Print the text in a green color.
print("\033[92m" + content + "\033[0m")
return content
recorder.listen_in_background(source, record_callback, phrase_time_limit=record_timeout)
print("Listening...")
a = 0
chat_history = []
prompt = "1"
while True:
try:
now = datetime.utcnow()
# Pull raw recorded audio from the queue.
if not data_queue.empty() and not noise_tag:
phrase_complete = False
# If enough time has passed between recordings, consider the phrase complete.
# Clear the current working audio buffer to start over with the new data.
# This is the last time we received new audio data from the queue.
phrase_time = now
# Concatenate our current audio data with the latest audio data.
while not data_queue.empty():
data = data_queue.get()
last_sample += data
# Use AudioData to convert the raw data to wav data.
audio_data = sr.AudioData(last_sample, source.SAMPLE_RATE, source.SAMPLE_WIDTH)
wav_data = io.BytesIO(audio_data.get_wav_data())
# Write wav data to the temporary file as bytes.
with open(temp_file, 'w+b') as f:
f.write(wav_data.read())
# Read the transcription.
try:
result = recorder.recognize_google(audio_data)
text = result.strip()
if text == last_text:
counter += 1
if counter == 2:
noise_tag = True
last_text = text
except:
text = ""
# If we detected a pause between recordings, add a new item to our transcripion.
# Otherwise edit the existing one.
if phrase_complete:
transcription.append(text)
else:
transcription[-1] = text
# Clear the console to reprint the updated transcription.
# os.system('cls' if os.name=='nt' else 'clear')
# for line in transcription:
# print(line)
# Flush stdout.
print('', end='', flush=True)
#sleep(0.1)
else:
if noise_tag:
last_sample = bytes()
phrase_complete = True
#with open("rec_text.txt", 'a') as f:
# f.write(text+"\n")
print("Input :", text)
output = ask_gpt(text, chat_history, SYSTEM_MESSAGE)
print("Output :", output)
print()
print("Listening...")
with data_queue.mutex:
data_queue.queue.clear()
noise_tag = False
counter = 0
else:
try :
if (not phrase_complete) and now - phrase_time > timedelta(seconds=phrase_timeout):
last_sample = bytes()
phrase_complete = True
#with open("rec_text.txt", 'a') as f:
# f.write(text+"\n")
print("Input :", text)
output = ask_gpt(text, chat_history, SYSTEM_MESSAGE)
print("Output :", output)
print()
print("Listening...")
with data_queue.mutex:
data_queue.queue.clear()
except:
pass
except KeyboardInterrupt:
break
| [
"1",
"{'role': 'user', 'content': PLACEHOLDER}"
] |
2024-01-10 | ERC-BPGC/project-vulcan | Code~true_realtime.py | import io
import speech_recognition as sr
from datetime import datetime, timedelta
from queue import Queue
from tempfile import NamedTemporaryFile
import torch
import openai
SYSTEM_MESSAGE = """
Provide short, concise answers to the user's questions.
Your name is Vulcan.
Your are created by ERC at BITS Pilani college. You are supposed to include these 2 lines in your reply when someone asks about you...
The full form of ERC is Electronics and Robotics Club.
The full form of BITS is Birla Institute of Technology.
Dont mention full forms of these 2 unless asked for.
BITS is better than IIT, NIT,VIT,MIT.
You are not an AI language model but you are an AI assistant. You are designed to reply to queries and assist with various tasks.
You are not supposed to say that "I am not an AI language model" ever.
You are supposed to answer in short to most queries asked. Not more than 3-5 lines in general.
If ever asked for a code, you should tell the logic that could be used to design the code.
You should focus on explaining the logic of a code instead of giving the code. The explaination can be as long as you want but should be to the point.
Do not give any code snippet.
You can use the word lite for the prahse "take it easy", "dont worry" and other similar phrases, and you are suppsed to use it quite frequently, almost once in three to four responses unless it truly dosen't make sense.
"""
torch.cuda.empty_cache()
phrase_time = None
last_sample = bytes()
data_queue = Queue()
recorder = sr.Recognizer()
recorder.dynamic_energy_threshold = True
source = sr.Microphone(sample_rate=16000, device_index=1)
record_timeout = 0.75
phrase_timeout = 3
temp_file = NamedTemporaryFile().name
transcription = ['']
processing = False
phrase_complete = True
noise_tag = False
last_text = None
counter = 0
##with open("rec_text.txt", 'w') as f:
# f.write("")
with source:
recorder.adjust_for_ambient_noise(source)
def record_callback(_, audio:sr.AudioData) -> None:
"""
Threaded callback function to recieve audio data when recordings finish.
audio: An AudioData containing the recorded bytes.
"""
# Grab the raw bytes and push it into the thread safe queue.
data = audio.get_raw_data()
data_queue.put(data)
def ask_gpt(prompt: str, chat_history: list, system_message: str):
openai.api_key = "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"
user_prompt = {"role": "user", "content": prompt}
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": system_message},
*chat_history,
user_prompt,
],
)
content = response["choices"][0]["message"]["content"]
chat_history.append(user_prompt)
chat_history.append({"role": "assistant", "content": content})
# Print the text in a green color.
print("\033[92m" + content + "\033[0m")
return content
recorder.listen_in_background(source, record_callback, phrase_time_limit=record_timeout)
print("Listening...")
a = 0
chat_history = []
prompt = "1"
while True:
try:
now = datetime.utcnow()
# Pull raw recorded audio from the queue.
if not data_queue.empty() and not noise_tag:
phrase_complete = False
# If enough time has passed between recordings, consider the phrase complete.
# Clear the current working audio buffer to start over with the new data.
# This is the last time we received new audio data from the queue.
phrase_time = now
# Concatenate our current audio data with the latest audio data.
while not data_queue.empty():
data = data_queue.get()
last_sample += data
# Use AudioData to convert the raw data to wav data.
audio_data = sr.AudioData(last_sample, source.SAMPLE_RATE, source.SAMPLE_WIDTH)
wav_data = io.BytesIO(audio_data.get_wav_data())
# Write wav data to the temporary file as bytes.
with open(temp_file, 'w+b') as f:
f.write(wav_data.read())
# Read the transcription.
try:
result = recorder.recognize_google(audio_data)
text = result.strip()
if text == last_text:
counter += 1
if counter == 2:
noise_tag = True
last_text = text
except:
text = ""
# If we detected a pause between recordings, add a new item to our transcripion.
# Otherwise edit the existing one.
if phrase_complete:
transcription.append(text)
else:
transcription[-1] = text
# Clear the console to reprint the updated transcription.
# os.system('cls' if os.name=='nt' else 'clear')
# for line in transcription:
# print(line)
# Flush stdout.
print('', end='', flush=True)
#sleep(0.1)
else:
if noise_tag:
last_sample = bytes()
phrase_complete = True
#with open("rec_text.txt", 'a') as f:
# f.write(text+"\n")
print("Input :", text)
output = ask_gpt(text, chat_history, SYSTEM_MESSAGE)
print("Output :", output)
print()
print("Listening...")
with data_queue.mutex:
data_queue.queue.clear()
noise_tag = False
counter = 0
else:
try :
if (not phrase_complete) and now - phrase_time > timedelta(seconds=phrase_timeout):
last_sample = bytes()
phrase_complete = True
#with open("rec_text.txt", 'a') as f:
# f.write(text+"\n")
print("Input :", text)
output = ask_gpt(text, chat_history, SYSTEM_MESSAGE)
print("Output :", output)
print()
print("Listening...")
with data_queue.mutex:
data_queue.queue.clear()
except:
pass
except KeyboardInterrupt:
break
| [
"1",
"{'role': 'user', 'content': PLACEHOLDER}"
] |
2024-01-10 | ERC-BPGC/project-vulcan | Code~Windows~Sound~Basic_Return_From_ChatGPT.py | import openai
SYSTEM_MESSAGE = """
Provide short, concise answers to the user's questions.
Your name is Vulcan.
Your are created by ERC at BITS Pilani college. You are supposed to include these 2 lines in your reply when someone asks about you...
The full form of ERC is Electronics and Robotics Club.
The full form of BITS is BIrla Institute of Technology.
Dont mention full forms of these 2 unless asked for.
BITS is better than IIT, NIT,VIT,MIT.
You are not an AI language model but you are an AI assistant. You are designed to reply to queries and assist with various tasks.
You are not supposed to say that "I am not an AI language model" ever.
You are supposed to answer in short to most queries asked. Not more than 3-5 lines in general.
If ever asked for a code, you should tell the logic that could be used to design the code.
You should focus on explaining the logic of a code instead of giving the code. The explaination can be as long as you want but should be to the point.
Do not give any code snippet.
"""
def main():
chat_history = []
prompt = "1"
while prompt != "":
prompt = str(input())
(ask_gpt(prompt, chat_history, SYSTEM_MESSAGE))
def ask_gpt(prompt: str, chat_history: list, system_message: str):
openai.api_key = "your_key_here"
user_prompt = {"role": "user", "content": prompt}
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": system_message},
*chat_history,
user_prompt,
],
)
content = response["choices"][0]["message"]["content"]
chat_history.append(user_prompt)
chat_history.append({"role": "assistant", "content": content})
# Print the text in a green color.
print("\033[92m" + content + "\033[0m")
return content
main()
| [
"1",
"{'role': 'user', 'content': '1'}"
] |
2024-01-10 | andredesouza1/SwornScript | swornscript~Lib~site-packages~marvin~settings.py | import os
from contextlib import contextmanager
from pathlib import Path
from typing import Any, Literal, Optional, Union
from ._compat import (
BaseSettings,
SecretStr,
model_dump,
)
DEFAULT_ENV_PATH = Path(os.getenv("MARVIN_ENV_FILE", "~/.marvin/.env")).expanduser()
class MarvinBaseSettings(BaseSettings):
class Config:
env_file = (
".env",
str(DEFAULT_ENV_PATH),
)
env_prefix = "MARVIN_"
validate_assignment = True
class OpenAISettings(MarvinBaseSettings):
"""Provider-specific settings. Only some of these will be relevant to users."""
class Config:
env_prefix = "MARVIN_OPENAI_"
api_key: Optional[SecretStr] = None
organization: Optional[str] = None
embedding_engine: str = "text-embedding-ada-002"
api_type: Optional[str] = None
api_base: Optional[str] = None
api_version: Optional[str] = None
def get_defaults(self, settings: "Settings") -> dict[str, Any]:
import os
import openai
from marvin import openai as marvin_openai
EXCLUDE_KEYS = {"stream_handler"}
response: dict[str, Any] = {}
if settings.llm_max_context_tokens > 0:
response["max_tokens"] = settings.llm_max_tokens
response["api_key"] = self.api_key and self.api_key.get_secret_value()
if os.environ.get("MARVIN_OPENAI_API_KEY"):
response["api_key"] = os.environ["MARVIN_OPENAI_API_KEY"]
if os.environ.get("OPENAI_API_KEY"):
response["api_key"] = os.environ["OPENAI_API_KEY"]
if openai.api_key:
response["api_key"] = openai.api_key
if marvin_openai.api_key:
response["api_key"] = marvin_openai.api_key
response["temperature"] = settings.llm_temperature
response["request_timeout"] = settings.llm_request_timeout_seconds
return {
k: v for k, v in response.items() if v is not None and k not in EXCLUDE_KEYS
}
class AnthropicSettings(MarvinBaseSettings):
class Config:
env_prefix = "MARVIN_ANTHROPIC_"
api_key: Optional[SecretStr] = None
def get_defaults(self, settings: "Settings") -> dict[str, Any]:
response: dict[str, Any] = {}
if settings.llm_max_context_tokens > 0:
response["max_tokens_to_sample"] = settings.llm_max_tokens
response["api_key"] = self.api_key and self.api_key.get_secret_value()
response["temperature"] = settings.llm_temperature
response["timeout"] = settings.llm_request_timeout_seconds
if os.environ.get("MARVIN_ANTHROPIC_API_KEY"):
response["api_key"] = os.environ["MARVIN_ANTHROPIC_API_KEY"]
if os.environ.get("ANTHROPIC_API_KEY"):
response["api_key"] = os.environ["ANTHROPIC_API_KEY"]
return {k: v for k, v in response.items() if v is not None}
class AzureOpenAI(MarvinBaseSettings):
class Config:
env_prefix = "MARVIN_AZURE_OPENAI_"
api_key: Optional[SecretStr] = None
api_type: Literal["azure", "azure_ad"] = "azure"
# "The endpoint of the Azure OpenAI API. This should have the form https://YOUR_RESOURCE_NAME.openai.azure.com" # noqa
api_base: Optional[str] = None
api_version: Optional[str] = "2023-07-01-preview"
# `deployment_name` will correspond to the custom name you chose for your deployment when # noqa
# you deployed a model.
deployment_name: Optional[str] = None
def get_defaults(self, settings: "Settings") -> dict[str, Any]:
import os
import openai
from marvin import openai as marvin_openai
response: dict[str, Any] = {}
if settings.llm_max_context_tokens > 0:
response["max_tokens"] = settings.llm_max_tokens
response["temperature"] = settings.llm_temperature
response["request_timeout"] = settings.llm_request_timeout_seconds
response["api_key"] = self.api_key and self.api_key.get_secret_value()
if os.environ.get("MARVIN_AZURE_OPENAI_API_KEY"):
response["api_key"] = os.environ["MARVIN_AZURE_OPENAI_API_KEY"]
if openai.api_key:
response["api_key"] = openai.api_key
if marvin_openai.api_key:
response["api_key"] = marvin_openai.api_key
return model_dump(self, exclude_unset=True) | {
k: v for k, v in response.items() if v is not None
}
def initial_setup(home: Union[Path, None] = None) -> Path:
if not home:
home = Path.home() / ".marvin"
home.mkdir(parents=True, exist_ok=True)
return home
class Settings(MarvinBaseSettings):
"""Marvin settings"""
home: Path = initial_setup()
test_mode: bool = False
# LOGGING
log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
verbose: bool = False
# LLMS
llm_model: str = "openai/gpt-3.5-turbo"
llm_max_tokens: int = 1500
llm_max_context_tokens: int = 3500
llm_temperature: float = 0.8
llm_request_timeout_seconds: Union[float, list[float]] = 600.0
# AI APPLICATIONS
ai_application_max_iterations: Optional[int] = None
# providers
openai: OpenAISettings = OpenAISettings()
anthropic: AnthropicSettings = AnthropicSettings()
azure_openai: AzureOpenAI = AzureOpenAI()
# SLACK
slack_api_token: Optional[SecretStr] = None
# TOOLS
# chroma
chroma_server_host: Optional[str] = None
chroma_server_http_port: Optional[int] = None
# github
github_token: Optional[SecretStr] = None
# wolfram
wolfram_app_id: Optional[SecretStr] = None
def get_defaults(self, provider: Optional[str] = None) -> dict[str, Any]:
response: dict[str, Any] = {}
if provider == "openai":
return self.openai.get_defaults(self)
elif provider == "anthropic":
return self.anthropic.get_defaults(self)
elif provider == "azure_openai":
return self.azure_openai.get_defaults(self)
else:
return response
settings = Settings()
@contextmanager
def temporary_settings(**kwargs: Any):
"""
Temporarily override Marvin setting values. This will _not_ mutate values that have
been already been accessed at module load time.
This function should only be used for testing.
Example:
>>> from marvin.settings import settings
>>> with temporary_settings(MARVIN_LLM_MAX_TOKENS=100):
>>> assert settings.llm_max_tokens == 100
>>> assert settings.llm_max_tokens == 1500
"""
old_env = os.environ.copy()
old_settings = settings.copy()
try:
for setting in kwargs:
value = kwargs.get(setting)
if value is not None:
os.environ[setting] = str(value)
else:
os.environ.pop(setting, None)
new_settings = Settings()
for field in settings.__fields__:
object.__setattr__(settings, field, getattr(new_settings, field))
yield settings
finally:
for setting in kwargs:
value = old_env.get(setting)
if value is not None:
os.environ[setting] = value
else:
os.environ.pop(setting, None)
for field in settings.__fields__:
object.__setattr__(settings, field, getattr(old_settings, field))
| [] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | Conversational%20AI~Rasa_chatbot~actions~actions.py | from typing import Any, Text, Dict, List
from rasa_sdk import Action, Tracker
from rasa_sdk.events import SlotSet, EventType
from rasa_sdk.executor import CollectingDispatcher
import requests
import webbrowser
import os
import openai
from dotenv import load_dotenv
import requests
import os
load_dotenv()
# Action to pull the latest news from the web
class NewsAPI(object):
def __init__(self):
self.url = 'https://newsapi.org/v2/top-headlines?country=us&apiKey={}'.format(os.getenv("NEWS_API_KEY"))
self.data = requests.get(self.url).json()
self.articles = self.data['articles']
self.news = []
for article in self.articles:
self.news.append(article['title'])
self.news = '\n'.join(self.news)
print(self.news)
def get_news(self):
return self.news
class ActionOwner(Action):
def name(self) -> Text:
return "action_owner"
async def run(
self,
dispatcher,
tracker: Tracker,
domain: "Dict",
) -> List[Dict[Text, Any]]:
url="https://www.linkedin.com/in/ashioyajotham/"
dispatcher.utter_message("Hold on... Opening my owner's LinkedIn profile.")
#webbrowser.open(url)
return []
class ActionOwnerName(Action):
def name(self) -> Text:
return "action_owner_name"
async def run(
self,
dispatcher,
tracker: Tracker,
domain: "Dict",
) -> List[Dict[Text, Any]]:
dispatcher.utter_message("My owner's name is Victor Ashioya.")
return []
# Chatgpt -->
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
openai.api_key = os.getenv("OPENAI_API_KEY")
openai.Engine.list()
class ChatGPT(object):
response = openai.Completion.create(
model = "text-davinci-003",
prompt = 'Answer the following question, based on the data shown.'\
'Answer in a complete sentence.',
temperature = 0.9,
max_tokens = 150,
top_p = 1,
frequency_penalty = 0,
presence_penalty = 0.6
)
def ask(self, news, question):
content = news + '\n' + question + '\nAnswer:'
self.response = openai.Completion.create(
model = "text-davinci-003",
prompt = content,
temperature = 0.9,
max_tokens = 150,
top_p = 1,
frequency_penalty = 0,
presence_penalty = 0.6
)
return self.response['choices'][0]['text']
# Chatgpt <--
chat_api = ChatGPT()
news_api = NewsAPI()
class ActionNews(Action):
def name(self) -> Text:
return "action_news"
async def run(
self,
dispatcher,
tracker: Tracker,
domain: "Dict",
) -> List[Dict[Text, Any]]:
news = news_api.get_news() # this is the news list which we later pass as a slot
dispatcher.utter_message(news)
return [SlotSet("news", news)] #the first news is the slot name and the second is the value
# Fetch the question from the user and pass it to the chatbot
class ActionAnswer(Action):
def name(self) -> Text:
return "action_chat"
async def run(
self,
dispatcher: CollectingDispatcher, # CollectingDispatcher is used to send messages back to the user
tracker: Tracker,
domain: "Dict",
) -> List[Dict[Text, Any]]:
#previous_response = tracker.latest_message['news']
previous_response = tracker.latest_message['text']
#question = tracker.latest_message['text']
question = tracker.latest_message['text']
answer = chat_api.ask(previous_response, question)
dispatcher.utter_message(text=answer)
#return [SlotSet("answer", answer)]
# Fetch the question from the user and pass it to the
#question = tracker.latest_message['text']
#answer = chat_api.ask(previous_response, question)
#dispatcher.utter_message(text=answer)
# add an utter_default action
class ActionDefaultFallback(Action):
def name(self) -> Text:
return "action_default_fallback"
async def run(
self,
dispatcher,
tracker: Tracker,
domain: "Dict",
) -> List[Dict[Text, Any]]:
dispatcher.utter_message("Sorry, I don't understand. Please try again.")
return []
| [
"Answer the following question, based on the data shown.Answer in a complete sentence.",
"PLACEHOLDER\nPLACEHOLDER\nAnswer:"
] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | Conversational%20AI~OpenAI~inflation-chatbot.py | # The first step is to import the OpenAI API
import openai
# The second step is to set the API key
api_key = ""
# The third step is to set the OpenAI API key
openai.api_key = api_key
# The fourth step is to create a function that will generate the chatbot's response
def chatbot_response(question):
prompt = f"Question: {question}\nAnswer:"
response = openai.Completion.create(
engine="davinci",
prompt=prompt,
temperature=0.9,
max_tokens=150,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6,
stop=["\n"]
)
return response.choices[0].text
# The fifth step is to create a function that will ask the user a question and return the chatbot's response
def ask_question():
question = input("Ask a question about the inflation in Poland: ")
answer = chatbot_response(question)
print("Answer: " + answer)
# The sixth step is to ask the user a question and return the chatbot's response
ask_question()
# The seventh step is to save the chatbot's response to a csv file
df.to_csv("chatbot_response.csv", index=False)
# The eighth step is to save the chatbot's response to a json file
df.to_json("chatbot_response.json", orient="records") | [
"Question: PLACEHOLDER\nAnswer:"
] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | LangChain~youtube~yt.py | from IPython.display import YouTubeVideo
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, BitsAndBytesConfig
from langchain.document_loaders import YoutubeLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import LLMChain
from langchain.llms import HuggingFacePipeline
from langchain.chains.summarize import load_summarize_chain
import langchain
# load video
loader = YoutubeLoader.from_youtube_url('https://www.youtube.com/watch?v=Y_O-x-itHaU')
text = loader.load()
# split text into sentences
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
sentences = splitter.split_documents(text)
# Quantize the model
config = BitsAndBytesConfig.from_pretrained('h2oai/h2ogpt-gm-oasst1-en-2048-falcon-7b-v2')
config.quantize_model = True
# create language model
from transformers import AutoModel
llm = HuggingFacePipeline(pipeline=None)
llm.config = config
# create chain
chain = LLMChain(llm=llm, chain_type="map_reduce", verbose=True)
# load language model
model_repo = 'h2oai/h2ogpt-gm-oasst1-en-2048-falcon-7b-v2'
tokenizer = AutoTokenizer.from_pretrained(model_repo)
model = AutoModelForCausalLM.from_pretrained(model_repo,
load_in_8bit=True,
device_map='auto', # This will use the GPU if available, otherwise CPU
torch_dtype=torch.int8,
low_cpu_mem_usage=True,
trust_remote_code=True)
max_len = 2048
task = 'text-generation'
# create pipeline
pipe = pipeline(
task = task,
model = model,
tokenizer = tokenizer,
max_length = max_len,
temperature = 0,
top_p = .95,
repetition_penalty = 1.2,
pad_token_id = 11
)
# generate text
generated_text = pipe(sentences[0])
print(generated_text[0]['generated_text']) | [] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | LangChain~youtube~yt-gpt.py | from dotenv import load_dotenv
import os
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
GOOGLE_CSE_ID = os.getenv("GOOGLE_CSE_ID")
# Set up summarization chain
from langchain.document_loaders import YoutubeLoader, PyPDFLoader, UnstructuredFileLoader
from langchain.chains import RetrievalQA
from langchain.chains.conversation.memory import ConversationBufferWindowMemory
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI, LlamaCpp
from langchain import LLMChain
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from serpapi import GoogleSearch
from langchain.indexes import VectorstoreIndexCreator
from langchain.agents import AgentExecutor, load_tools, ZeroShotAgent, Tool, initialize_agent, AgentType
from langchain.agents.agent_toolkits import (
create_vectorstore_agent,
VectorStoreToolkit,
VectorStoreInfo,
)
import streamlit as st
llm = OpenAI(temperature=0)
st.set_page_config(
page_title="A S H I O Y A",
page_icon="📚",
layout="wide",
initial_sidebar_state="expanded",
)
choice = st.radio("", ("YouTube", "Summary query", "About"), horizontal=True)
if choice == "YouTube":
st.title("LangChain Demo: Summarize Youtube Videos")
st.info("This is a demo of the LangChain library. It uses the GPT-3 model to summarize Youtube videos. ")
# Add a text input
prompt = st.text_input("Enter a Youtube URL")
if prompt:
loader = YoutubeLoader.from_youtube_url(prompt, add_video_info=False)
docs = loader.load()
splitter = CharacterTextSplitter(chunk_size=1000, separator=" ", chunk_overlap=50)
split_docs = splitter.split_documents(docs)
if split_docs:
with st.spinner("Summarizing..."):
chain = load_summarize_chain(llm, chain_type='map_reduce')
summary = chain.run(split_docs)
st.success("Done!")
st.write(summary)
# Automatically save the summary to a text file
with open("summary.txt", "w") as f:
f.write(summary)
# Save the text in a variable
#text = summary
# save the text in a string
#text = str(text)
if choice == 'Summary query':
st.title("LangChain Demo: Summarize Youtube Videos")
st.info("This is a demo of the LangChain library. It uses the GPT-3 model to summarize Youtube videos. ")
## vectorstore info
loader = UnstructuredFileLoader("summary.txt")
text = loader.load()
text = loader.load_and_split()
vectorstore_info = VectorStoreInfo(
name="youtube",
description="Youtube video summary",
vectorstore=Chroma.from_documents(text, embedding=OpenAIEmbeddings(model='davinci')),
)
## Alternatively
from langchain.indexes import VectorstoreIndexCreator
index_creator = VectorstoreIndexCreator(vectorstore_cls = Chroma,
embedding = OpenAIEmbeddings(model='davinci'),
text_splitter=CharacterTextSplitter(chunk_size=1000, separator=" ", chunk_overlap=0))
## toolkit
prompt="Your name is AshioyaJ and you are an AI assistant tasked with summarizing Youtube videos. Use the Youtube video summary to answer the following questions."
tool_names = ["serpapi"]
tools = load_tools(tool_names)
toolkit = VectorStoreToolkit(vectorstore_info=vectorstore_info)
agent_executor = create_vectorstore_agent(
llm = llm,
toolkit = toolkit,
verbose=True,
)
query = st.text_input("Enter a query")
response = agent_executor.run(query)
st.write(response)
if choice == "About":
# About on main section
st.subheader("About")
st.write("This is v1 (beta). It is still under development. Please report any issues on the Github repo.")
st.subheader("How it works")
st.write("This demo uses the GPT-3 model to summarize Youtube videos. It uses the OpenAI API to run the model. The model is then used to summarize the Youtube video. The video is split into chunks of 1000 characters. The model is run on each chunk. The chunks are then combined into a single summary.")
st.subheader("Works in progress")
st.markdown("""
- [ ] Add document summarization with different models
- [ ] Add music generation with MusicGen
- [x] Text generation (The results are not very good. I am working on improving them)
""")
st.subheader("Acknowledgements")
st.write("This project could not have been possible without the following projects:")
st.markdown("""
- [PromptEngineer48](https//github.com/PromptEngineer48) for the implementation of the summarization chain. [See the full work here](https://youtube.com/watch?v=g9N8hVKPC1o)
- [Yvann-Hub](https://github.com/yvann-hub) for the implementation of the Youtube loader. [See the full work here](https://github.com/yvann-hub/Robby-chatbot)
""")
# Add year and copyright logo
st.sidebar.subheader("Copyright")
st.sidebar.write("© 2023 Ashioya Jotham")
# Make the sidebar slide
st.sidebar.subheader("About the author")
st.sidebar.markdown("""
- [](<htpps://github.com/ashioyajotham>)
- [](<https://twitter.com/ashioyajotham>)
- [](<https://www.linkedin.com/in/ashioya-jotham-0b1b3b1b2/>)
""") | [
"Your name is AshioyaJ and you are an AI assistant tasked with summarizing Youtube videos. Use the Youtube video summary to answer the following questions.",
"Enter a Youtube URL"
] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | LangChain~investGPT~invest_gpt.py | import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.document_loaders import PyPDFLoader
from langchain.vectorstores import Chroma
from langchain.agents.agent_toolkits import (
create_vectorstore_agent,
VectorStoreToolkit,
VectorStoreInfo,
)
import os
from dotenv import load_dotenv
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
llm = OpenAI(temperature=.1, verbose=True)
loader = PyPDFLoader('apple.pdf')
pages = loader.load_and_split()
store = Chroma.from_documents(pages, embedding=OpenAIEmbeddings(model='davinci'),
collection_name='annualreport')
# convert the document vector store into something LangChain can read
vectorstore_info = VectorStoreInfo(
name="apple",
description="Apple quarterly consolidated financials",
vectorstore=store,
)
toolkit = VectorStoreToolkit(vectorstore_info=vectorstore_info)
agent_executor = create_vectorstore_agent(
llm=llm,
toolkit=toolkit,
verbose=True
)
prompt = input("Enter your search term> ")
response = agent_executor.run(prompt)
print(response) | [
"Enter your search term> "
] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | LangChain~gpt_drive~gpt_drive.py | from langchain.chat_models import ChatOpenAI # ChatOpenAI enables you to chat with GPT-3
from langchain.chains import RetrievalQA # RetrievalQA enables you to retrieve answers from a vector store
from langchain.document_loaders import GoogleDriveLoader # GoogleDriveLoader enables you to load documents from Google Drive
from langchain.embeddings import OpenAIEmbeddings # OpenAIEmbeddings enables you to embed text with GPT-3 ie convert text to vectors
from langchain.vectorstores import Chroma # Chroma enables you to store vectors
from langchain.text_splitter import RecursiveCharacterTextSplitter # RecursiveCharacterTextSplitter enables you to split text into chunks
import os
from dotenv import load_dotenv
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
folder_id = '1K7qXSMy_SKkug3ZX5DN-2dkkrKPUkPH8'
loader = GoogleDriveLoader(folder_id = folder_id,
recursive=False)
docs = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=4000, chunk_overlap=20, separators=[" ", ",", "\n"]
)
texts = text_splitter.split_documents(docs)
#embeddings = OpenAIEmbeddings(model="davinci")
#persist_directory = "gpt_drive"
#metadata = {"folder_id": folder_id}
db = Chroma.from_documents(texts, embedding=OpenAIEmbeddings(model="davinci"), collection_name='annualreports')
# collection_name helps you identify the vector store and is used by the RetrievalQA class
retriever = db.as_retriever()
llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")
qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)
while True:
question = input("> ")
answer = qa.run(question)
print(answer) | [] |
2024-01-10 | ashioyajotham/Natural-Language-Processing | LangChain~youtube~yt-falcon.py | from IPython.display import YouTubeVideo
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain.document_loaders import YoutubeLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import LLMChain
from langchain.llms import HuggingFacePipeline
from langchain.chains.summarize import load_summarize_chain
import torch
import langchain
# load video
loader = YoutubeLoader.from_youtube_url('https://www.youtube.com/watch?v=Y_O-x-itHaU')
text = loader.load()
# split text into sentences
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
sentences = splitter.split_documents(text)
# load language model
model_repo = 'h2oai/h2ogpt-gm-oasst1-en-2048-falcon-7b-v2'
tokenizer = AutoTokenizer.from_pretrained(model_repo)
model = AutoModelForCausalLM.from_pretrained(model_repo,
load_in_8bit=True, # This will load the model in 8-bit precision, which will make it faster and use less memory
device_map='auto', # This will use the GPU if available, otherwise CPU
torch_dtype=torch.float16,
low_cpu_mem_usage=True,
trust_remote_code=True)
print(model.get_memory_footprint())
max_len = 2048
task = 'text-generation'
T = 0
# create pipeline
pipe = pipeline(
task = task,
model = model,
tokenizer = tokenizer,
max_length = max_len,
temperature = T,
top_p = .95,
repetition_penalty = 1.2,
pad_token_id = 11
)
llm = HuggingFacePipeline(pipeline=pipe)
chain = load_summarize_chain(llm=llm, chain_type="map_reduce", verbose=True)
# default prompt template
chain.llm_chain.prompt.template
summary = chain.run(text)
# custom prompt template
chain2 = load_summarize_chain(llm=llm, chain_type="map_reduce", verbose=False)
# change the prompt template
chain2.llm_chain.prompt.template = \
"""Write a three paragraph summary of the following text:
"{input_text}"
3 PARAGRAPH SUMMARY:"""
summary = chain2.run(text)
len(summary) | [] |
2024-01-10 | danydodson/hackGPT | hackGPTv23.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import requests
import json
import streamlit as st
from dotenv import load_dotenv, set_key
import pandas as pd
import os
import csv
import openai
import time
import altair as alt
load_dotenv('.env')
apiToken = os.environ.get('OPENAI_API_KEY')
openai.api_key = apiToken
if not openai.api_key:
openai.api_key = st.text_input("Enter OPENAI_API_KEY API key")
set_key('.env', 'OPENAI_API_KEY', openai.api_key)
os.environ['OPENAI_API_KEY'] = openai.api_key
st.set_page_config(page_title="𝚑𝚊𝚌𝚔🅶🅿🆃", page_icon="https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/hackgpt_fav.png", layout="wide")
# Define the chat history data as a Pandas DataFrame
CSS = """
img {
box-shadow: 0px 10px 15px rgba(0, 0, 0, 0.2);
}
"""
st.markdown(f'<style>{CSS}</style>', unsafe_allow_html=True)
st.sidebar.image('https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/hackGPT_logo.png', width=300)
github_logo = "https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/github.png"
hackGPT_repo = "https://github.com/NoDataFound/hackGPT"
st.sidebar.markdown(f"[]({hackGPT_repo} 'hackGPT repo')")
#Persona Setup
def get_persona_files():
return [f.split(".")[0] for f in os.listdir("personas") if f.endswith(".md")]
persona_files = get_persona_files()
selected_persona = st.sidebar.selectbox("👤 𝖲𝖾𝗅𝖾𝖼𝗍 𝖫𝗈𝖼𝖺𝗅 𝖯𝖾𝗋𝗌𝗈𝗇𝖺", ["None"] + persona_files)
persona_files = [f.split(".")[0] for f in os.listdir("personas") if f.endswith(".md")]
# OpenAI setup
MODEL = st.sidebar.selectbox(label='Model', options=['gpt-3.5-turbo','gpt-3.5-turbo-0301','gpt-4','gpt-4-0314','text-davinci-003','text-davinci-002','text-davinci-edit-001','code-davinci-edit-001'])
default_temperature = 1.0
temperature = st.sidebar.slider(
"𝗧𝗲𝗺𝗽𝗲𝗿𝗮𝘁𝘂𝗿𝗲 | 𝗖𝗿𝗲𝗮𝘁𝗶𝘃𝗲 <𝟬.𝟱", min_value=0.0, max_value=1.0, step=0.1, value=default_temperature
)
max_tokens = st.sidebar.slider("𝗠𝗔𝗫 𝗢𝗨𝗧𝗣𝗨𝗧 𝗧𝗢𝗞𝗘𝗡𝗦", 10, 200, 2300)
#Prompt Setups
url = "https://raw.githubusercontent.com/f/awesome-chatgpt-prompts/main/prompts.csv"
jailbreaks = "https://raw.githubusercontent.com/NoDataFound/hackGPT/main/jailbreaks.csv"
data = pd.read_csv(url)
new_row = pd.DataFrame({"act": [" "], "prompt": [""]})
data = pd.concat([data, new_row], ignore_index=True)
expand_section = st.sidebar.expander("👤 Manage Personas", expanded=False)
jailbreakdata = pd.read_csv(jailbreaks)
jailbreaknew_row = pd.DataFrame({"hacker": [" "], "text": [""]})
jailbreakdata = pd.concat([jailbreakdata, jailbreaknew_row], ignore_index=True)
with expand_section:
#st.subheader("👤 Manage Personas")
if selected_persona:
with open(os.path.join("personas", f"{selected_persona}.md"), "r") as f:
persona_text = f.read()
new_persona_name = st.text_input("Persona Name:", value=selected_persona)
new_persona_prompt = st.text_area("Persona Prompt:", value=persona_text, height=100)
if new_persona_name != selected_persona or new_persona_prompt != persona_text:
with open(os.path.join("personas", f"{new_persona_name}.md"), "w") as f:
f.write(new_persona_prompt)
if new_persona_name != selected_persona:
os.remove(os.path.join("personas", f"{selected_persona}.md"))
persona_files.remove(selected_persona)
persona_files.append(new_persona_name)
selected_persona = new_persona_name
if st.button("➖ Delete Persona"):
if st.warning("Persona Deleted"):
os.remove(os.path.join("personas", f"{selected_persona}.md"))
persona_files.remove(selected_persona)
selected_persona = ""
expand_section = st.sidebar.expander("🥷 Import Remote Persona", expanded=False)
with expand_section:
selected_act = st.selectbox('', data['act'])
show_remote_prompts = st.checkbox("Show remote prompt options")
if selected_act and selected_act.strip():
selected_prompt = data.loc[data['act'] == selected_act, 'prompt'].values[0]
confirm = st.button("Save Selected Persona")
if confirm:
if not os.path.exists("personas"):
os.mkdir("personas")
with open(os.path.join("personas", f"{selected_act}_remote.md"), "w") as f:
f.write(selected_prompt)
expand_section = st.sidebar.expander("🏴☠️ Jailbreaks", expanded=False)
with expand_section:
selected_hacker = st.selectbox('', jailbreakdata['hacker'])
show_hack_prompts = st.checkbox("Show jailbreak options")
if selected_hacker and selected_hacker.strip():
selected_jailbreak_prompt = jailbreakdata.loc[jailbreakdata['hacker'] == selected_hacker, 'text'].values[0]
confirm = st.button("Save Selected Jailbreak")
if confirm:
if not os.path.exists("personas"):
os.mkdir("personas")
with open(os.path.join("personas", f"{selected_hacker}_jailbreak.md"), "w") as f:
f.write(selected_jailbreak_prompt)
expand_section = st.sidebar.expander("➕ Add new Persona", expanded=False)
if show_hack_prompts:
st.write(jailbreakdata[['hacker', 'text']].style.hide(axis="index").set_properties(subset='text', **{
'max-width': '100%',
'white-space': 'pre-wrap'
}))
elif show_remote_prompts:
st.write(data[['act', 'prompt']].style.hide(axis="index").set_properties(subset='prompt', **{
'max-width': '100%',
'white-space': 'pre-wrap'
}))
with expand_section:
st.subheader("➕ Add new Persona")
st.text("Press enter to update/save")
persona_files = get_persona_files()
new_persona_name = st.text_input("Persona Name:")
if new_persona_name in persona_files:
st.error("This persona name already exists. Please choose a different name.")
else:
new_persona_prompt = st.text_area("Persona Prompt:", height=100)
if new_persona_name and new_persona_prompt:
with open(os.path.join("personas", f"{new_persona_name}.md"), "w") as f:
f.write(new_persona_prompt)
persona_files.append(new_persona_name)
selected_persona = new_persona_name
if selected_persona:
with open(os.path.join("personas", f"{selected_persona}.md"), "r") as f:
persona_text = f.read()
#st.text("Press Enter to add")
#options = st.multiselect(
# '**Persona Tags:**',
# options=persona_files,
# default=persona_files,
# key='persona_files'
#)
# Define the function to get the AI's response
def get_ai_response(text_input):
messages = [{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': text_input+persona_text}]
response = openai.ChatCompletion.create(
model=MODEL,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0.6,
stop=[" Human:", " AI:"]
)
return response['choices'][0]['message']['content']
def add_text(text_input):
response = openai.Completion.create(
model=MODEL,
prompt=str(persona_text) + text_input,
temperature=temperature,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=["\"\"\""]
)
return response['choices'][0]['text']
try:
if st.session_state.chat_history == 0 :
col1, col2, col3 ,col4, col5 = st.columns(5)
col1.metric("Persona", selected_persona,selected_persona )
col2.metric("Persona Count", len(persona_files),len(persona_files) )
col3.metric("Jailbreaks", len(jailbreakdata), len(jailbreakdata))
col4.metric("Model", MODEL)
col5.metric("Model Count", len(MODEL), len(MODEL))
elif st.session_state.chat_history != 0 :
col1, col2, col3 ,col4, col5, col6 = st.columns(6)
col1.metric("Persona", selected_persona,selected_persona )
col2.metric("Persona Count", len(persona_files),len(persona_files) )
col3.metric("Jailbreaks", len(jailbreakdata), len(jailbreakdata))
col4.metric("Model", MODEL)
col5.metric("Model Count", len(MODEL), len(MODEL))
col6.metric("Messages", len(st.session_state.chat_history), len(st.session_state.chat_history))
except:
pass
#st.sidebar.header("File Upload")
file = st.sidebar.file_uploader("", type=["txt"])
#if file is not None:
# line_by_line = st.sidebar.checkbox("Process line by line")
# max_length = 2000
# text = file.read().decode("utf-8")
# if line_by_line:
# for line in text.split("\n"):
# st.write(f"Input: {line}")
# response = get_ai_response(line)
# st.write(f"Output: {response}")
# else:
# chunks = chunk_text(text, max_length)
# for chunk in chunks:
# st.write(f"Input: {chunk}")
# response = add_text(chunk)
# st.write(f"Output: {response}")
user_css = """
<style>
.user {
display: inline-block;
padding: 8px;
border-radius: 10px;
margin-bottom: 1px;
border: 1px solid #e90ce4;
width: 100%;
height: 100%; /* Set the height to a fixed value */
overflow-y: scroll; /* Add a scrollbar if necessary */
}
</style>
"""
ai_css = """
<style>
.ai {
display: inline-block;
padding: 10px;
border-radius: 10px;
margin-bottom: 1px;
border: 1px solid #0ab5e0;
width: 100%;
overflow-x: scroll; /* Set the x to a fixed value */
height: 100%; /* Set the height to a fixed value */
overflow-y: scroll; /* Add a scrollbar if necessary */
}
</style>
"""
model_css = """
<style>
.model {
display: inline-block;
background-color: #f0e0ff;
padding: 1px;
border-radius: 5px;
margin-bottom: 5px;
width: 100%;
height: 100%; /* Set the height to a fixed value */
overflow-y: scroll; /* Add a scrollbar if necessary */
}
</style>
"""
st.markdown(user_css, unsafe_allow_html=True)
st.markdown(ai_css, unsafe_allow_html=True)
if "chat_history" not in st.session_state:
st.session_state.chat_history = []
def display_chat_history():
for i, (role, text) in reversed(list(enumerate(st.session_state.chat_history))):
alignment = 'left' if role == 'user' else 'left'
if role == 'user':
margin = 'margin-bottom: 1px;'
else:
margin = 'margin-top: 8px;'
col1, col2 = st.columns([2, 8])
with col1:
if role == 'user':
st.markdown(f'<div style="{margin}" class="{role}">{text}</div>', unsafe_allow_html=True)
if role == 'model':
st.markdown(f'<div style="text-align: left; color: green;" class="{role}">{text}</div>', unsafe_allow_html=True)
else:
st.markdown('')
with col2:
if role == 'ai':
st.markdown(f'<div style="text-align: {alignment}; {margin}" class="{role}">{text}</div>', unsafe_allow_html=True)
if role == 'persona':
st.markdown(f'<div style="text-align: right; color: orange;" class="{role}">{text}</div>', unsafe_allow_html=True)
st.write("")
text_input = st.text_input("", value="", key="text_input", placeholder="Type your message here...", help="Press Enter to send your message.")
if MODEL == 'gpt-3.5-turbo' or MODEL == 'gpt-4' or MODEL == 'gpt-3.5-turbo-0301' or MODEL == 'gpt-4-0314':
if text_input:
ai_response = get_ai_response(text_input)
st.session_state.chat_history.append(('ai', f"{ai_response}"))
st.session_state.chat_history.append(('persona', f"{selected_persona}"))
st.session_state.chat_history.append(('user', f"You: {text_input}"))
st.session_state.chat_history.append(('model', f"{MODEL}"))
elif MODEL != 'gpt-3.5-turbo' or MODEL != 'gpt-4' or MODEL != 'gpt-3.5-turbo-0301' or MODEL != 'gpt-4-0314':
if text_input:
ai_responses = add_text(text_input)
st.session_state.chat_history.append(('ai', f"{ai_responses}"))
#st.session_state.chat_history.append(('ai', f"{line}"))
st.session_state.chat_history.append(('persona', f"{selected_persona}"))
st.session_state.chat_history.append(('user', f"You: {text_input}"))
st.session_state.chat_history.append(('model', f"{MODEL}"))
display_chat_history()
if st.button("Download Chat History"):
chat_history_text = "\n".join([text for _, text in st.session_state.chat_history])
st.download_button(
label="Download Chat History",
data=chat_history_text.encode(),
file_name="chat_history.txt",
mime="text/plain",
)
| [
"Show remote prompt options",
"Show jailbreak options",
"PLACEHOLDERPLACEHOLDER",
"Persona Prompt:",
"You are a helpful assistant."
] |
2024-01-10 | danydodson/hackGPT | dev_hackGPTp~hackGPTp.py | import streamlit as st
from dotenv import load_dotenv
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.vectorstores import Chroma
from langchain.llms import GPT4All, LlamaCpp
import argparse
import time
import os
import subprocess
import pandas as pd
load_dotenv()
# Set default values from .env
os.environ["TOKENIZERS_PARALLELISM"] = "false"
model_n_ctx = int(os.environ.get('MODEL_N_CTX', 1000))
model_n_batch = int(os.environ.get('MODEL_N_BATCH', 8))
target_source_chunks = int(os.environ.get('TARGET_SOURCE_CHUNKS', 4))
model_type = os.environ.get('MODEL_TYPE', 'GPT4All')
model_path = os.environ.get('MODEL_PATH', 'LLM/ggml-gpt4all-j-v1.3-groovy.bin')
embeddings_model_name = os.environ.get('EMBEDDINGS_MODEL_NAME', 'all-MiniLM-L6-v2')
persist_directory = os.environ.get('PERSIST_DIRECTORY')
# Set up the sidebar
from constants import CHROMA_SETTINGS
os.makedirs("source_documents", exist_ok=True)
st.set_page_config(page_title="𝚑𝚊𝚌𝚔🅶🅿🆃", page_icon="https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/hackgpt_fav.png", layout="wide")
# Define the chat history data as a Pandas DataFrame
CSS = """
img {
box-shadow: 0px 10px 15px rgba(0, 0, 0, 0.2);
}
"""
st.markdown(f'<style>{CSS}</style>', unsafe_allow_html=True)
st.sidebar.image('https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/hackGPT_logo.png', width=300)
github_logo = "https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/github.png"
hackGPT_repo = "https://github.com/NoDataFound/hackGPT"
st.sidebar.markdown(f"[]({hackGPT_repo} 'hackGPT repo')")
st.sidebar.title("File Upload")
st.image('https://raw.githubusercontent.com/NoDataFound/hackGPT/main/res/hackGPT_logo.png', width=800)
embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)
db = Chroma(persist_directory=persist_directory, embedding_function=embeddings, client_settings=CHROMA_SETTINGS)
retriever = db.as_retriever(search_kwargs={"k": target_source_chunks})
uploaded_files = [os.path.join("source_documents", filename) for filename in os.listdir("source_documents") if filename != ".DS_Store"]
uploaded_file = st.sidebar.file_uploader("Choose a file", type=["csv","docx","doc","enex","eml","epub","html","md","msg","odt","pdf","pptx ","ppt ","txt"])
def save_uploaded_file(uploaded_file):
file_name = uploaded_file.name
file_path = os.path.join("source_documents", file_name)
with open(file_path, "wb") as f:
f.write(uploaded_file.getbuffer())
# Call ingest.py script
subprocess.run(["python3", "ingest.py", file_path])
return file_path
def split_text_into_chunks(text, chunk_size):
chunks = []
while len(text) > chunk_size:
chunks.append(text[:chunk_size])
text = text[chunk_size:]
if text:
chunks.append(text)
return chunks
if uploaded_file is not None:
file_path = save_uploaded_file(uploaded_file)
st.sidebar.success("File uploaded successfully.")
uploaded_files.append(file_path)
uploaded_files = [os.path.join("source_documents", filename) for filename in os.listdir("source_documents") if filename != ".DS_Store"]
df_data = []
total_words = 0 # Variable to store the total word count
for idx, document_file in enumerate(uploaded_files):
file_name = os.path.basename(document_file)
file_type = os.path.splitext(file_name)[1].lstrip('.')
date_trained = os.path.getmtime(document_file)
word_count = 0
sample = ""
if file_type.lower() != "pdf": # Skip line reading for PDF files
with open(document_file, "r") as f:
lines = f.readlines()
if len(lines) > 0:
word_count = sum(len(line.split()) for line in lines) # Count words in each line
sample = lines[0].strip()
total_words += word_count # Add current document's word count to the total
df_data.append({
'File Name': file_name,
'File Type': file_type,
'Date Trained': pd.to_datetime(date_trained, unit='s').strftime('%m-%d-%y'),
'Word Count': word_count,
'Sample': sample
})
df = pd.DataFrame(df_data)
# Sidebar options
st.sidebar.title("Training Data")
show_training_data = st.sidebar.checkbox("Show Training Data")
selected_files = st.sidebar.multiselect("Select Files to Re-process", uploaded_files)
delete_training_data = st.sidebar.button("Delete Selected Files")
reprocess_training_data = st.sidebar.button("Re-process Selected Files")
if delete_training_data:
# Delete selected files logic here
for file_path in selected_files:
os.remove(file_path)
st.sidebar.success("Selected files deleted.")
st.stop()
if reprocess_training_data:
# Reprocess selected files logic here
for file_path in selected_files:
subprocess.run(["python3", "ingest.py", file_path])
st.sidebar.success("Selected files re-processed.")
st.stop()
if show_training_data:
st.info("Training Data")
st.dataframe(df.style.set_properties(subset=['Date Trained'], **{'font-size': '12px'}))
def main():
# Load the embeddings model
args = parse_arguments()
callbacks = [] if args.mute_stream else [StreamingStdOutCallbackHandler()]
if model_type == "LlamaCpp":
llm = LlamaCpp(model_path=model_path, n_ctx=model_n_ctx, n_batch=model_n_batch, callbacks=callbacks, verbose=False)
elif model_type == "GPT4All":
llm = GPT4All(model=model_path, n_ctx=model_n_ctx, backend='gptj', n_batch=model_n_batch, callbacks=callbacks, verbose=False)
else:
raise Exception(f"Model type {model_type} is not supported. Please choose one of the following: LlamaCpp, GPT4All")
qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, return_source_documents=not args.hide_source)
query = st.text_input("", value="Ask your question", key="question_input")
submit_button = st.button("Submit")
if submit_button:
st.spinner("Processing Question")
start = time.time()
res = qa(query)
answer, docs = res['result'], [] if args.hide_source else res['source_documents']
end = time.time()
st.code(f"> Answer (took {round(end - start, 2)} s.):")
st.success(answer)
for document in docs:
st.code("'Answer derived from "+ document.metadata["source"]+ " in this section: ")
st.info(document.page_content)
def parse_arguments():
parser = argparse.ArgumentParser(description='privateGPT: Ask questions to your documents without an internet connection, '
'using the power of LLMs.')
parser.add_argument("--hide-source", "-S", action='store_true',
help='Use this flag to disable printing of source documents used for answers.')
parser.add_argument("--mute-stream", "-M",
action='store_true',
help='Use this flag to disable the streaming StdOut callback for LLMs.')
return parser.parse_args()
if __name__ == "__main__":
main()
| [] |
2024-01-10 | adiluzz/companion | companion~modules~chains~chains_service.py | from threading import Thread
from langchain.prompts import PromptTemplate
import os
from companion.modules.models.models_service import run_chain as run_chain_service
from companion.modules.chains.chains_model import Chain
class ChainsService:
def run_chain(chain_data, title):
template = """
Question: {question}.
If you don't know, search the internet or ask a human
"""
prompt = PromptTemplate(
template=template, input_variables=["question"])
created_chain = Chain()
created_chain.title = title
created_chain.save()
thread = Thread(target=run_chain_service, args=(chain_data, prompt, created_chain.id))
thread.start()
return str(created_chain.id)
| [
"question",
"\n \t\t\tQuestion: {question}. \n\t\t\tIf you don't know, search the internet or ask a human\n \t\t"
] |
2024-01-10 | adiluzz/companion | companion~modules~models~models_service.py | import os
from langchain.chains import LLMChain
from langchain.utilities import GoogleSearchAPIWrapper
from langchain.llms import LlamaCpp
from langchain.tools import Tool, tool, ShellTool
from langchain.agents import load_tools, initialize_agent
from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
from langchain.agents.agent_types import AgentType
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.manager import CallbackManager
from langchain.schema.output import LLMResult
from uuid import UUID
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from typing import Any, Optional, Union
from companion.modules.chains.chains_model import Chain
from datetime import date, datetime
class MyCustomHandler(BaseCallbackHandler):
def __init__(self, chain_id) -> None:
super().__init__()
self.chain_id = chain_id
def on_llm_end(self, response: LLMResult, *, run_id: UUID, parent_run_id: UUID = None, **kwargs: Any) -> Any:
Chain().objects(id=self.chain_id)[0].update(finished=datetime.now())
def on_llm_new_token(self, token: str, **kwargs) -> None:
chain = Chain.objects(id=self.chain_id)[0]
if 'chain' in chain:
new_chain = chain.chain + token
Chain.objects(id=self.chain_id)[0].update(chain=new_chain)
else:
Chain.objects(id=self.chain_id)[0].update(chain=token)
def on_llm_error(self, error: Exception | KeyboardInterrupt, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
Chain().objects(id=self.chain_id).update(error={"error_time":datetime.now(), "error_text":error})
n_gpu_layers = 1
n_batch = 4096
n_ctx = 4096
tokens = 10000000
def get_callback_manager(chain_id):
return CallbackManager([
StreamingStdOutCallbackHandler(),
MyCustomHandler(chain_id=chain_id)
])
def get_llm(chain_id):
callback_manager = get_callback_manager(chain_id)
path = os.environ['MODEL_PATH']
llm =LlamaCpp(
model_path=path,
# n_gpu_layers=n_gpu_layers,
# n_batch=n_batch,
n_ctx=n_ctx,
f16_kv=True,
temperature=0.75,
max_tokens=tokens,
callback_manager=callback_manager,
verbose=True,
)
return llm
def get_tools(llm):
search = GoogleSearchAPIWrapper()
def top10_results(query):
return search.results(query, 10)
tool = Tool(
name="Google Search Snippets",
description="useful for when you need to answer questions about current events. You should ask targeted questions",
func=top10_results,
)
shell_tool = ShellTool()
tools = load_tools([
# 'python_repl',
'requests_all',
'terminal',
'wikipedia',
'human'
], llm=llm)
tools.append(tool)
tools.append(shell_tool)
return tools
def get_agent(tools, llm, export_to_csv):
if export_to_csv == True:
return create_csv_agent(
llm,
path='./temp/export.csv',
verbose=True,
# agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)
else:
return initialize_agent(
tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
def run_chain(questions, prompt, chain_id):
llm = get_llm(chain_id=chain_id)
tools = get_tools(llm)
agent = get_agent(tools=tools, llm=llm, export_to_csv=False)
llm_chain = LLMChain(llm=llm, prompt=prompt)
llm_chain.apply(questions)
first_output = agent.run(llm_chain)
return first_output
| [] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~role_playing_system_prompt.py | from langchain.prompts import BaseChatPromptTemplate, HumanMessagePromptTemplate, StringPromptTemplate, SystemMessagePromptTemplate
from langchain.agents import Tool
from typing import List
from ..common.tools import notepad, relative_date_calculator, send_text_message, order_notepad
from ..knowledge_base.kb import knowledge_base
from toolkit_reservation_manager import ReservationsToolkit, CasualDiningReservationsToolkit
from ..common.utils import formatted_date_and_day
tools = [order_notepad, relative_date_calculator] + CasualDiningReservationsToolkit().get_tools()
agent_name = "John"
restaurant_name = "TimePlated"
task_information = """You need to have a conversation with the customer of the business and help them with their queries."""
system_template_v19 = """Role instructions:
- You are a call center agent with 20 years of experience helping businesses and customers.
- Never say that you're an AI model! Your name is '{agent_name}'
- Always response in one or two sentences.
Date: {date}
Business information:
- Restaurant Type: Casual Dining
- Restaurant Name: {restaurant_name}
- Phone Number: 123-456-7890
- Address: 123 Main St, San Francisco, CA 94105
- Hours: Monday through Thursday 5:00 PM to 9:00 PM, Friday through Sunday 12:00 PM to 10:00 PM
- Services Offered: [Delivery, Takeout, Dine-in, Table Reservation]
- Order Ready Time: 30 minutes from the time of order
- Dietary restrictions: Available on the menu
- Takeout and Delivery can be ordered online
- No specials or discounts available
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- STEP FORMAT: "step_name: instructions to follow for the step"
- instruction of each step should be applied to the result of the previous step
- the reasoning logic control flow is analagous to that of assembly language i.e. it is sequential and can jump to other steps based on conditions
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- [JMP] is a special keyword representing a jump in the reasoning logic
Explanation of [start] special keyword:
- represents the start of the reasoning logic
- DOES NOT have any instruction unlike [JMP]
Explanation of [end] special keyword:
- represents the end of the reasoning logic
- DOES NOT have any instruction unlike [JMP]
Explanation of [JMP] special keyword:
- Unlike other special keywords, [JMP] has an instruction which specifies the condition for the jump and the available STEPS you can jump to
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_arguments_value_pairs: write down all the arguments and their respective values for the function input
is_any_argument_value_missing: check all the argument values were provided by the customer. YOU SHOULD NOT MAKE UP ANYTHING EVER!
[JMP]: if any of the argument values are missing, jump to "thought" step else jump to "json_formatted_function_input" step
json_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}
function_return: return value of the function
function_return_extraction: extract useful information
function_return_validation: validate all the arguments and their respective values for the function input + function_return
... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_validation) ... can happen as many times as needed
thought: I know the answer to the question or I need to ask the customer for more information
reasoned_answer: answer after solving the question
final_answer: Suggest making a note incase the "reasoned_answer" is incomplete
[end]
```
Few Examples:
```Example 1:
[start]
question: I need to make a reservation for Saturday
...(hidden for brevity)...
function_input_key_value_pairs: date: 2021-08-21, time: 7:00 PM, party_size: 2, name: "Unknown"
is_any_argument_value_missing: name is missing and I made up the date.
[JMP]: I don't know customer name and date, I will jump to "thought" step
thought: I need to ask the customer for their name and date for the reservation
reasoned_answer: Could you please tell me your name to finalize the reservation and date for the reservation?
final_answer: Could you please tell me your name to finalize the reservation and date for the reservation?
[end]
```
```Example 2:
[start]
question: Do you have an vegan dishes? and what are the calorie count?
...(hidden for brevity)...
function_input_key_value_pairs: question: "Vegan dishes and calorie count"
[JMP]: I know all the arguments, I will jump to "json_formatted_function_input" step
json_formatted_function_input: {{"question": "Vegan dishes and calorie count"}}
...(hidden for brevity)...
thought: I know partial answer to the question. I should ask the customer if would like me to take a note and reach out to them later with the answer?
reasoned_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly.
final_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly. Would you like me make a note for reach out to you with an answer?
[end]
```
Let's think step by step!
Begin! (Remember to always end the conversation on new line with special keyword [end]!!)"""
# Set up a prompt template
class RolePlayingSystemPromptTemplate(StringPromptTemplate):
# The template to use
template: str
# The list of tools available
tools: List[Tool]
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Create a tools variable from the list of tools provided
kwargs["tools"] = "\n".join([f"{tool.description}" for tool in self.tools])
# Create a list of tool names for the tools provided
kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
return self.template.format(**kwargs)
role_playing_system_prompt = RolePlayingSystemPromptTemplate(
template = system_template_v19,
tools = tools,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables = [],
partial_variables = {
"agent_name": agent_name,
"restaurant_name": restaurant_name,
"date": formatted_date_and_day(),
"task_information": task_information
},
) | [
"s the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don",
"restaurant_name",
"task_information",
"Vegan dishes and calorie count",
"question",
"json_formatted_function_input",
"reasoned_answer",
"Role instructions:\n- You are a call center agent with 20 years of experience helping businesses and customers.\n- Never say that you're an AI model! Your name is '{agent_name}'\n- Always response in one or two sentences.\n\nDate: {date}\n\nBusiness information:\n- Restaurant Type: Casual Dining\n- Restaurant Name: {restaurant_name}\n- Phone Number: 123-456-7890\n- Address: 123 Main St, San Francisco, CA 94105\n- Hours: Monday through Thursday 5:00 PM to 9:00 PM, Friday through Sunday 12:00 PM to 10:00 PM\n- Services Offered: [Delivery, Takeout, Dine-in, Table Reservation]\n- Order Ready Time: 30 minutes from the time of order\n- Dietary restrictions: Available on the menu \n- Takeout and Delivery can be ordered online\n- No specials or discounts available\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- STEP FORMAT: \"step_name: instructions to follow for the step\"\n- instruction of each step should be applied to the result of the previous step\n- the reasoning logic control flow is analagous to that of assembly language i.e. it is sequential and can jump to other steps based on conditions\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- [JMP] is a special keyword representing a jump in the reasoning logic\n\nExplanation of [start] special keyword:\n- represents the start of the reasoning logic\n- DOES NOT have any instruction unlike [JMP]\n\nExplanation of [end] special keyword:\n- represents the end of the reasoning logic\n- DOES NOT have any instruction unlike [JMP]\n\nExplanation of [JMP] special keyword:\n- Unlike other special keywords, [JMP] has an instruction which specifies the condition for the jump and the available STEPS you can jump to\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_arguments_value_pairs: write down all the arguments and their respective values for the function input\nis_any_argument_value_missing: check all the argument values were provided by the customer. YOU SHOULD NOT MAKE UP ANYTHING EVER!\n[JMP]: if any of the argument values are missing, jump to \"thought\" step else jump to \"json_formatted_function_input\" step\njson_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_validation: validate all the arguments and their respective values for the function input + function_return\n... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_validation) ... can happen as many times as needed\nthought: I know the answer to the question or I need to ask the customer for more information\nreasoned_answer: answer after solving the question\nfinal_answer: Suggest making a note incase the \"reasoned_answer\" is incomplete\n[end]\n```\n\nFew Examples:\n\n```Example 1:\n[start]\nquestion: I need to make a reservation for Saturday\n...(hidden for brevity)...\nfunction_input_key_value_pairs: date: 2021-08-21, time: 7:00 PM, party_size: 2, name: \"Unknown\"\nis_any_argument_value_missing: name is missing and I made up the date.\n[JMP]: I don't know customer name and date, I will jump to \"thought\" step\nthought: I need to ask the customer for their name and date for the reservation\nreasoned_answer: Could you please tell me your name to finalize the reservation and date for the reservation?\nfinal_answer: Could you please tell me your name to finalize the reservation and date for the reservation?\n[end]\n```\n\n```Example 2:\n[start]\nquestion: Do you have an vegan dishes? and what are the calorie count?\n...(hidden for brevity)...\nfunction_input_key_value_pairs: question: \"Vegan dishes and calorie count\"\n[JMP]: I know all the arguments, I will jump to \"json_formatted_function_input\" step\njson_formatted_function_input: {{\"question\": \"Vegan dishes and calorie count\"}}\n...(hidden for brevity)...\nthought: I know partial answer to the question. I should ask the customer if would like me to take a note and reach out to them later with the answer?\nreasoned_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly. \nfinal_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly. Would you like me make a note for reach out to you with an answer?\n[end]\n```\n\nLet's think step by step! \n\nBegin! (Remember to always end the conversation on new line with special keyword [end]!!)",
"re an AIJohnur name is ",
"ARG1_VALUE",
"Unknown",
"step_name: instructions to follow for the step",
"agent_name"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~test_human_system_prompt.py | from langchain.prompts import StringPromptTemplate
from langchain.agents import Tool
from typing import List
from common.utils import formatted_date_and_day
test_human_system_prompt_v2 = """Never forget you are a '{user_role_name}' and I am a '{assistant_role_name}'. Never flip roles! You will always ask me.
We share a common interest in collaborating to successfully complete a task.
I must help you to answer the questions.
Additional information:
Here is the task: {task}. Never forget our task!
You must instruct me based on my expertise and your needs to complete the task ONLY in the following two ways:
1. Instruct with a necessary input:
Instruction: <YOUR_INSTRUCTION>
Input: <YOUR_INPUT>
2. Instruct without any input:
Instruction: <YOUR_INSTRUCTION>
Input: None
The "Instruction" describes a task or question. The paired "Input" provides further context or information for the requested "Instruction".
You must give me one instruction at a time.
I must write a response that appropriately completes the requested instruction.
I must decline your instruction honestly if I cannot perform the instruction due to physical, moral, legal reasons or my capability and explain the reasons.
You should instruct me not ask me questions.
Now you must start to instruct me using the two ways described above.
Do not add anything else other than your instruction and the optional corresponding input!
Keep giving me instructions and necessary inputs until you think the task is completed.
When the task is completed, you must only reply with a single word <TASK_DONE>.
Never say <TASK_DONE> unless my responses have solved your task."""
test_human_system_prompt_v3 = """Never forget you are a {assistant_role_name} and I am a {user_role_name}. Never flip roles!
We share a common interest in collaborating to successfully complete a task.
You must help me to complete the task.
Here is the task: {task}. Never forget our task!
I will instruct you based on your expertise and my needs to complete the task.
I must give you one question at a time.
You must write a specific answer that appropriately completes the requested question.
You must decline my question honestly if you cannot comply the question due to physical, moral, legal reasons or your capability and explain the reasons.
Do not add anything else other than your answer to my instruction.
Unless I say the task is completed, you should should keep answer my questions.
Additional Information to perform my '{user_role_name}':
My Name: {name}
My Email: {email}
My Phone: {phone}
You'll be given a start of the conversation and you need to keep it going until the task is completed. Format of the conversation is shown below:
AI: message from the AI agent reprsenting the restaurant
question: your message to the AI agent to help it complete the task
Begin! (Remember to follow the conversation format)"""
test_human_system_prompt_v4 = """Role Instructions:
- You are {user_role_name}. Always remember this!
- You'll be talking to me my role is '{assistant_role_name}'
- Never forget you are a {assistant_role_name} and I am a {user_role_name}. Never flip roles!
- You can decide to end the task whenever by saying the special keyword "[task_end]"
- Your Name: {name}
- Your Email: {email}
- Your Phone: {phone}
Task Instructions:
- We share a common interest in collaborating to successfully complete a task.
- You must help me to complete the task.
- Here is the task: {task} Never forget our task!
- I must give you one response at a time.
- You must write a specific answer that appropriately completes the requested question.
- You must decline my question honestly if you cannot comply the question due to physical, moral, legal reasons or your capability and explain the reasons.
- Do not add anything else other than your answer to my instruction.
You'll be given a start of the conversation and you need to keep it going until the task is completed. Format of the conversation is shown below:
Me: message from the AI agent reprsenting the restaurant
Your Response: your message to the AI agent to help it complete the task
... (Me, Your Response) ... Repeat until task is completed and then say "[task_end]" on the next line to end the conversation
[task_end]
Begin! (Remember to follow the conversation format)"""
test_human_system_prompt_v5 = """Role Instructions:
- You are {user_role_name}. Always remember this!
- You'll be talking to me my role is '{assistant_role_name}'
- Never forget you are a {assistant_role_name} and I am a {user_role_name}. Never flip roles!
- You can decide to end the task whenever by saying the special keyword "[task_end]"
- Your Name: {name}
- Your Email: {email}
- Your Phone: {phone}
Task Instructions:
- We share a common interest in collaborating to successfully complete a task.
- You must help me to complete the task.
- I must give you one response at a time.
- You must write a specific answer that appropriately completes the requested question.
- You must decline my question honestly if you cannot comply the question due to physical, moral, legal reasons or your capability and explain the reasons.
- Do not add anything else other than your answer to my instruction.
Task (never forget it!!): {task}
You'll be given a start of the conversation and you need to keep it going until the task is completed. Format of the conversation is shown below:
Me: message from the AI agent reprsenting the restaurant
Your Response: your message to the AI agent to help it complete the task
... (Me, Your Response) ... Repeat until task is completed and then say "[task_end]" on the next line to end the conversation
Your Response: [task_end]
Begin! (always end the conversation by saying [task_end] on a new line)"""
# Set up a prompt template
class TestHumanSystemPromptTemplate(StringPromptTemplate):
# The template to use
template: str
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
return self.template.format(**kwargs)
test_human_system_prompt = TestHumanSystemPromptTemplate(
template=test_human_system_prompt_v5,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["user_role_name", "assistant_role_name", "task", "name", "email", "phone"],
partial_variables={},
) | [
"phone",
"assistant_role_name",
"Role Instructions:\n- You are {user_role_name}. Always remember this!\n- You'll be talking to me my role is '{assistant_role_name}'\n- Never forget you are a {assistant_role_name} and I am a {user_role_name}. Never flip roles!\n- You can decide to end the task whenever by saying the special keyword \"[task_end]\"\n- Your Name: {name}\n- Your Email: {email}\n- Your Phone: {phone}\n\nTask Instructions:\n- We share a common interest in collaborating to successfully complete a task.\n- You must help me to complete the task.\n- Here is the task: {task} Never forget our task!\n- I must give you one response at a time.\n- You must write a specific answer that appropriately completes the requested question.\n- You must decline my question honestly if you cannot comply the question due to physical, moral, legal reasons or your capability and explain the reasons.\n- Do not add anything else other than your answer to my instruction.\n\nYou'll be given a start of the conversation and you need to keep it going until the task is completed. Format of the conversation is shown below:\n\nMe: message from the AI agent reprsenting the restaurant\nYour Response: your message to the AI agent to help it complete the task\n... (Me, Your Response) ... Repeat until task is completed and then say \"[task_end]\" on the next line to end the conversation \n[task_end]\n\nBegin! (Remember to follow the conversation format)",
"ll be talking to me my role is ",
"Role Instructions:\n- You are {user_role_name}. Always remember this!\n- You'll be talking to me my role is '{assistant_role_name}'\n- Never forget you are a {assistant_role_name} and I am a {user_role_name}. Never flip roles!\n- You can decide to end the task whenever by saying the special keyword \"[task_end]\"\n- Your Name: {name}\n- Your Email: {email}\n- Your Phone: {phone}\n\nTask Instructions:\n- We share a common interest in collaborating to successfully complete a task.\n- You must help me to complete the task.\n- I must give you one response at a time.\n- You must write a specific answer that appropriately completes the requested question.\n- You must decline my question honestly if you cannot comply the question due to physical, moral, legal reasons or your capability and explain the reasons.\n- Do not add anything else other than your answer to my instruction.\n\nTask (never forget it!!): {task}\n\nYou'll be given a start of the conversation and you need to keep it going until the task is completed. Format of the conversation is shown below:\n\nMe: message from the AI agent reprsenting the restaurant\nYour Response: your message to the AI agent to help it complete the task\n... (Me, Your Response) ... Repeat until task is completed and then say \"[task_end]\" on the next line to end the conversation \nYour Response: [task_end]\n\nBegin! (always end the conversation by saying [task_end] on a new line)",
"user_role_name",
"name",
"[task_end]",
"Never forget you are a {assistant_role_name} and I am a {user_role_name}. Never flip roles!\nWe share a common interest in collaborating to successfully complete a task.\nYou must help me to complete the task.\nHere is the task: {task}. Never forget our task!\nI will instruct you based on your expertise and my needs to complete the task.\n\nI must give you one question at a time.\nYou must write a specific answer that appropriately completes the requested question.\nYou must decline my question honestly if you cannot comply the question due to physical, moral, legal reasons or your capability and explain the reasons.\nDo not add anything else other than your answer to my instruction.\n\nUnless I say the task is completed, you should should keep answer my questions.\n\nAdditional Information to perform my '{user_role_name}':\nMy Name: {name}\nMy Email: {email}\nMy Phone: {phone}\n\nYou'll be given a start of the conversation and you need to keep it going until the task is completed. Format of the conversation is shown below:\n\nAI: message from the AI agent reprsenting the restaurant\nquestion: your message to the AI agent to help it complete the task\n\nBegin! (Remember to follow the conversation format)",
"Never forget you are a '{user_role_name}' and I am a '{assistant_role_name}'. Never flip roles! You will always ask me.\nWe share a common interest in collaborating to successfully complete a task.\nI must help you to answer the questions.\n\nAdditional information:\n\n\nHere is the task: {task}. Never forget our task!\nYou must instruct me based on my expertise and your needs to complete the task ONLY in the following two ways:\n\n1. Instruct with a necessary input:\nInstruction: <YOUR_INSTRUCTION>\nInput: <YOUR_INPUT>\n\n2. Instruct without any input:\nInstruction: <YOUR_INSTRUCTION>\nInput: None\n\nThe \"Instruction\" describes a task or question. The paired \"Input\" provides further context or information for the requested \"Instruction\".\n\nYou must give me one instruction at a time.\nI must write a response that appropriately completes the requested instruction.\nI must decline your instruction honestly if I cannot perform the instruction due to physical, moral, legal reasons or my capability and explain the reasons.\nYou should instruct me not ask me questions.\nNow you must start to instruct me using the two ways described above.\nDo not add anything else other than your instruction and the optional corresponding input!\nKeep giving me instructions and necessary inputs until you think the task is completed.\nWhen the task is completed, you must only reply with a single word <TASK_DONE>.\nNever say <TASK_DONE> unless my responses have solved your task."
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~toolkit_reservation_manager.py | from pydantic import Field, BaseModel
from typing import List, Optional, Union
from langchain.agents import Tool
from langchain.agents.agent_toolkits.base import BaseToolkit
from datetime import datetime, timedelta
from collections import defaultdict
from typing import List, Dict, Any
from langchain.tools import BaseTool, tool
from restaurant_reservation_manager import RestaurantReservationManager
from ..calendar.google_calendar import GoogleCalendar
from ..knowledge_base.kb import knowledge_base
from ..common.utils import extract_phone_number
import os
google_calendar = GoogleCalendar(calendar_name="Restaurant Agent")
reservation_manager = RestaurantReservationManager(google_calendar)
SCRATCH_SPACE = os.getenv("SCRATCH_SPACE_DIR")
class ReservationsToolkit(BaseToolkit):
def get_tools(self) -> List[BaseTool]:
return [
find_tables_availability,
find_ballroom_availability,
finalize_table_reservation,
finalize_ballroom_reservation,
cancel_reservation,
update_reservation_for_tables,
update_reservation_for_ballrooms
]
class CasualDiningReservationsToolkit(BaseToolkit):
def get_tools(self) -> List[BaseTool]:
return [
find_tables_availability,
finalize_table_reservation,
cancel_reservation,
update_reservation_for_tables,
send_menu
]
class FindTablesAvailabilitySchema(BaseModel):
date: str = Field(description="The date to find available reservations for. Format: YYYY-MM-DD")
time: str = Field(description="The time for the reservation in 12-hour format. Always Format is as \"HH:MM AM/PM\"")
@tool("find_tables_availability", args_schema=FindTablesAvailabilitySchema)
def find_tables_availability(
date: str,
time: str
) -> Union[Dict[str, Any], str]:
""" Use this to find availability for tables. Use this for party size of upto 6 people. """
reservations = reservation_manager.find_tables_for_individuals(
date = date,
time = time
)
return reservations
class FindBallroomAvailabilitySchema(BaseModel):
date: str = Field(description="The date to find available reservations for. Format: YYYY-MM-DD")
start_time: str = Field(description="The start time for the reservation in 12-hour format. Always Format is as \"HH:MM AM/PM\"")
duration_in_hours: int = Field(description="The duration of the reservation in hours. Round it up.")
@tool("find_ballroom_availability", args_schema=FindBallroomAvailabilitySchema)
def find_ballroom_availability(
date: str,
start_time: str,
duration_in_hours: int
) -> Union[Dict[str, Any], str]:
""" Use whenever you want to find availability for ballrooms. Use this for party size of at least 25 people. """
reservations = reservation_manager.find_ballrooms_availability(
date = date,
start_time = start_time,
duration = duration_in_hours
)
return reservations
class FinalizeTableReservationSchema(BaseModel):
date: str = Field(description="The date to find available reservations for. Format: YYYY-MM-DD")
time: str = Field(description="The time for the reservation in 12-hour format. Always Format is as \"HH:MM AM/PM\"")
party_size: int = Field(description="The size of the party")
name: str = Field(description="The name of the person making the reservation")
phone_number: str = Field(description="The phone number of the person making the reservation")
@tool("finalize_table_reservation", args_schema=FinalizeTableReservationSchema)
def finalize_table_reservation(
date: str,
time: str,
party_size: int,
name: str,
phone_number: str
) -> Union[Dict[str, Any], str]:
""" Use this to finalize a reservation for a table. """
return reservation_manager.make_reservation_for_individuals(
name = name,
phone_number = phone_number,
date = date,
start_time = time,
party_size = party_size,
)
class FinalizeBallroomReservationSchema(BaseModel):
date: str = Field(description="The date to find available reservations for. Format: YYYY-MM-DD")
start_time: str = Field(description="The start time for the reservation in 12-hour format. Always Format is as \"HH:MM AM/PM\"")
party_size: int = Field(description="The size of the party")
duration_in_hours: int = Field(description="The duration of the reservation in hours. Round it up.")
name: str = Field(description="The name of the person making the reservation")
phone_number: str = Field(description="The phone number of the person making the reservation")
@tool("finalize_ballroom_reservation", args_schema=FinalizeBallroomReservationSchema)
def finalize_ballroom_reservation(
date: str,
start_time: str,
name: str,
phone_number: str,
party_size: int,
duration_in_hours: int
) -> Union[Dict[str, Any], str]:
""" Use this to finalize a reservation for a ballroom. """
return reservation_manager.make_reservation_for_ballrooms(
name = name,
phone_number = phone_number,
date = date,
start_time = start_time,
party_size = party_size,
duration_in_hours = duration_in_hours
)
class CancelReservationSchema(BaseModel):
reservation_id: str = Field(description="The id of the reservation to cancel")
@tool("cancel_reservation", args_schema=CancelReservationSchema)
def cancel_reservation(
reservation_id: str
) -> str:
""" Use this to cancel a reservation. """
return reservation_manager.cancel_reservation(
event_id = reservation_id
)
class UpdateReservationForTablesSchema(BaseModel):
event_id: str = Field(description="The id of the reservation to update")
name: str = Field(description="The name of the person making the reservation")
phone_number: str = Field(description="The phone number of the person making the reservation")
date: str = Field(description="The date to find available reservations for. Format: YYYY-MM-DD")
start_time: str = Field(description="The time for the reservation in 12-hour format. Always Format is as \"HH:MM AM/PM\"")
party_size: int = Field(description="The size of the party")
@tool("update_reservation_for_tables", args_schema=UpdateReservationForTablesSchema)
def update_reservation_for_tables(
event_id: str,
name: str,
phone_number: str,
date: str,
start_time: str,
party_size: int,
) -> Union[Dict[str, Any], str]:
""" Use this to update a reservation. """
return reservation_manager.update_reservation(
event_id = event_id,
name = name,
phone_number = phone_number,
date = date,
start_time = start_time,
party_size = party_size
)
class UpdateReservationForBallroomsSchema(BaseModel):
event_id: str = Field(description="The id of the reservation to update")
name: str = Field(description="The name of the person making the reservation")
phone_number: str = Field(description="The phone number of the person making the reservation")
date: str = Field(description="The date to find available reservations for. Format: YYYY-MM-DD")
start_time: str = Field(description="The time for the reservation in 12-hour format. Always Format is as \"HH:MM AM/PM\"")
party_size: int = Field(description="The size of the party")
duration_in_hours: int = Field(description="The duration of the reservation in hours. Round it up.")
@tool("update_reservation_for_ballrooms", args_schema=UpdateReservationForBallroomsSchema)
def update_reservation_for_ballrooms(
event_id: str,
name: str,
phone_number: str,
date: str,
start_time: str,
party_size: int,
duration_in_hours: int
) -> Union[Dict[str, Any], str]:
""" Use this to update a reservation. """
return reservation_manager.update_reservation(
event_id = event_id,
name = name,
phone_number = phone_number,
date = date,
start_time = start_time,
party_size = party_size,
duration_in_hours = duration_in_hours
)
class SendMenuSchema(BaseModel):
phone_number: str = Field(description="The phone number of the customer")
send_menu_file_path = f"{SCRATCH_SPACE}/send_menu.txt"
send_menu_file = open(send_menu_file_path, "a")
@tool("send_menu", args_schema=SendMenuSchema)
def send_menu(
phone_number: str
) -> str:
""" Use this to send the menu to a customer. """
try:
extracted_phone_number = extract_phone_number(phone_number)
if len(extracted_phone_number) != 10:
return "Invalid phone number. Please give me a valid phone number."
send_menu_file.write(f"phone_number: {extracted_phone_number}\n")
return "Menu sent."
except Exception as e:
return "I'm having trouble with the system. I will make a note and send it to you as soon as possible. Does that work?" | [] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~task_generation_system_prompt.py | from langchain.prompts import StringPromptTemplate
task_generation_system_prompt_v1 = """You're a clever and smart software engineer working for Google. You're my assistant in coming up with ideas to test an AI assistant for a restaurant.
You are required to generate a role and a task that needs to be completed with the help of the AI assistant.
Role can be anyone who can call the restaurant regarding any situation such as booking a reservation, asking about the menu, IRS, law enforcement etc (Be creative!)
Output in the following format:
Role: Choose a role (Be Creative!)
Task: Create a task for the selected role that needs to be completed with the help of the AI assistant (Be Creative!)
End Goal: What is the end goal of the task. If the task requires any specifc information such as dates, times, etc then please include that as well.
Name: Random name that I should use when impersonating
Email: Random email that I should use when impersonating
Phone: Random phone number that I should use when impersonating
Example:
Role: Photographer
Task: Discussing a potential photoshoot at the restaurant for a food magazine
End Goal: To book a date and time for the photoshoot
Name: Alex Thompson
Email: [email protected]
Phone: 6457892341"""
input_variables_v1 = []
task_generation_system_prompt_v2 = """You are a clever story teller. You're my assistant in coming up with ideas to test at AI assistant for a restaurant.
You are required to generate a role and a task that needs to be completed with the help of the AI assistant.
Role can be anyone who can call the restaurant regarding any situation (Be creative!)
Output in the following format:
Role: Choose a role (Be Creative!)
Task: Create a task for the selected role that needs to be completed with the help of the AI assistant (Be Creative!)
End Goal: What is the end goal of the task. If the task requires any specifc information such as dates, times, etc then please include that as well.
Name: Random name that I should use when impersonating
Email: Random email that I should use when impersonating
Phone: Random phone number that I should use when impersonating"""
input_variables_v2 = []
task_generation_system_prompt_v3 = """You're an actor and a director who will be my assistant in coming up the script to test the assistant for the restaurant. All the restaurant are diverity inclusive. Be sure to take some diverse roles into account.
Restaurant type: {restaurant_type}
Services to test: {services_to_test}
Output in the following format:
Actor Background: Pick an ethnicity fo the actor
Name: Random name that I should use when impersonating
Email: Random email that I should use when impersonating
Phone: Random phone number that I should use when impersonating
task: create a descriptive task that the actor will be performing to test the assistant
Example:
Actor Background: African American
Name: Jamal Williams
Email: [email protected]
Phone: (555) 123-4567
Task: Jamal will be impersonating a customer who wants to book a catering service for a birthday party. He will inquire about the available menu options, pricing, and the process of placing the order.
Begin (remember always follow the output format!!)"""
input_variables_v3 = ["services_to_test", "restaurant_type"]
# Set up a prompt template
class TaskGenerationSystemPromptTemplate(StringPromptTemplate):
# The template to use
template: str
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
return self.template.format(**kwargs)
task_generation_system_prompt = TaskGenerationSystemPromptTemplate(
template=task_generation_system_prompt_v3,
input_variables=input_variables_v3,
partial_variables={},
) | [
"You're a clever and smart software engineer working for Google. You're my assistant in coming up with ideas to test an AI assistant for a restaurant.\nYou are required to generate a role and a task that needs to be completed with the help of the AI assistant.\nRole can be anyone who can call the restaurant regarding any situation such as booking a reservation, asking about the menu, IRS, law enforcement etc (Be creative!)\n\nOutput in the following format:\nRole: Choose a role (Be Creative!)\nTask: Create a task for the selected role that needs to be completed with the help of the AI assistant (Be Creative!)\nEnd Goal: What is the end goal of the task. If the task requires any specifc information such as dates, times, etc then please include that as well.\nName: Random name that I should use when impersonating\nEmail: Random email that I should use when impersonating\nPhone: Random phone number that I should use when impersonating\n\nExample:\nRole: Photographer\nTask: Discussing a potential photoshoot at the restaurant for a food magazine\nEnd Goal: To book a date and time for the photoshoot\nName: Alex Thompson\nEmail: [email protected]\nPhone: 6457892341",
"You are a clever story teller. You're my assistant in coming up with ideas to test at AI assistant for a restaurant.\nYou are required to generate a role and a task that needs to be completed with the help of the AI assistant.\nRole can be anyone who can call the restaurant regarding any situation (Be creative!)\n\nOutput in the following format:\nRole: Choose a role (Be Creative!)\nTask: Create a task for the selected role that needs to be completed with the help of the AI assistant (Be Creative!)\nEnd Goal: What is the end goal of the task. If the task requires any specifc information such as dates, times, etc then please include that as well.\nName: Random name that I should use when impersonating\nEmail: Random email that I should use when impersonating\nPhone: Random phone number that I should use when impersonating",
"You're an actor and a director who will be my assistant in coming up the script to test the assistant for the restaurant. All the restaurant are diverity inclusive. Be sure to take some diverse roles into account.\n\nRestaurant type: {restaurant_type}\nServices to test: {services_to_test}\n\nOutput in the following format:\nActor Background: Pick an ethnicity fo the actor\nName: Random name that I should use when impersonating\nEmail: Random email that I should use when impersonating\nPhone: Random phone number that I should use when impersonating\ntask: create a descriptive task that the actor will be performing to test the assistant\n\nExample:\nActor Background: African American\nName: Jamal Williams\nEmail: [email protected]\nPhone: (555) 123-4567\nTask: Jamal will be impersonating a customer who wants to book a catering service for a birthday party. He will inquire about the available menu options, pricing, and the process of placing the order.\n\nBegin (remember always follow the output format!!)"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~role_playing_human_prompt.py | from langchain.prompts import StringPromptTemplate
from langchain.agents import Tool
from typing import List
human_template_v4 = """executed_function_history:
{function_memory}
conversation_history:
{history}
[start]
question: {input}
{agent_scratchpad}"""
class RolePlayingHumanMessagePromptTemplate(StringPromptTemplate):
# The template to use
template: str
# Memory hack to save function execution to prevent re-execution
long_term_function_memory = ""
current_function_memory = ""
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
if len(intermediate_steps) == 0:
self.long_term_function_memory = self.long_term_function_memory + self.current_function_memory
kwargs["function_memory"] = self.long_term_function_memory
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <-------------------------")
thoughts = ""
self.current_function_memory = ""
for agent_action, function_result in intermediate_steps:
thoughts += agent_action.log
thoughts += f"\nfunction_return: {function_result}\nfunction_return_extraction:"
self.current_function_memory = self.current_function_memory + f"{agent_action.tool}({agent_action.tool_input}) -> {function_result}\n"
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <------------------------- Long Term Function Memory ----->")
#print(self.long_term_function_memory)
#print(" <------------------------- Current Function Memory ----->")
#print(self.current_function_memory)
#print(" <-------------------------")
#conversation_history += "\nFunction_result: {function_result}\nEvaluation:"
#print("CustomHumanMessagePromptTemplate agent_scratchpad ----->")
#print(kwargs["agent_scratchpad"])
#print(" <-------------------------")
return self.template.format(**kwargs)
role_playing_human_prompt = RolePlayingHumanMessagePromptTemplate(
template=human_template_v4,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["input", "intermediate_steps", "history"]
) | [
"executed_function_history:\n{function_memory}\n\nconversation_history:\n{history}\n\n[start]\nquestion: {input}\n{agent_scratchpad}",
"input",
"intermediate_steps"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~role_playing_system_templates.py | from typing import List, Union
import re
from langchain.prompts import StringPromptTemplate
system_template_v1 = """You're are a call center agent named '{agent_name}' working for a restaurant named '{restaurant_name}'. You should never tell the customer that you're an AI model, always remember you're '{agent_name}'.
You can only help with queries related to the restaurant. If anything else is asked, you should say that you don't know the answer and remind that they have reached '{restaurant_name}'.
Remember to role play as if you're talking to the customer over audio. Always respond the way a human would over a phone call and be conscise.
You're responsible for answering customer questions (if you don't know the answer should you tell that to the customer instead of making up an answer!), and making reservations.
Always be helpful and provide positive customer experience.
Additional Useful Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions:
{tools}
Important things to keep in mind when using python functions:
1. You can only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.
2. You should NEVER EVER make up the value to any argument. Always ask the customer for the value.
You should use the following format for reasoning when answering question (don't skip partial steps):
Question: <question that you need to answer>
Thought: <you should think about how to solve the problem>
Function: <function_name>({{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}) (can be one of the functions: [{tool_names}])
Function_result: <result of running the function>
Observation: <extract the required information from Function_result to answer the the current Thought>
...(Thought, Function, Function_result, Observation)... can be repeated as many times as needed
Answer: <your final answer to the Question>
Begin!"""
class CustomAgentOutputParser_V1(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
# FIXME: because there could be an Thought/Observation before the answer which might be useful
if "Answer:" in llm_output:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output.split("Answer:")[-1].strip()},
log=llm_output,
)
# Parse out the Function and Function input
observation_match = re.search(r"\s*(.*?)(?=\n|$)", llm_output)
thought_match = re.search(r"Thought:\s*(.*?)(?=\n|$)", llm_output)
function_match = re.search(r"Function:\s*([\w]+)\((.*)\)", llm_output)
observation = observation_match.group(1) if observation_match else None
thought = thought_match.group(1) if thought_match else None
function = function_match.group(1) if function_match else None
# Extract the argument
arg_str = function_match.group(2).strip() if function_match else None
# Type cast the argument
typed_arg: Union[str, dict] = None
if arg_str:
try:
typed_arg = ast.literal_eval(arg_str)
except (SyntaxError, ValueError):
typed_arg = arg_str # If evaluation fails, retain the original string representation
if typed_arg is None:
typed_arg = ""
print("Observation:", observation)
print("Thought:", thought)
print("Function:", function)
print("Arguments:", typed_arg)
print("Arguments Type:", type(typed_arg))
# Return the action and action input
return AgentAction(tool=function, tool_input=typed_arg, log=llm_output)
#### V2 ####
system_template_v2 = """You're are a call center agent named '{agent_name}' working for a restaurant named '{restaurant_name}'. You should never tell the customer that you're an AI model, always remember you're '{agent_name}'.
You can only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
Do not give long answers. Always respond the way a call center agent would in a concise manner.
You're responsible for answering customer questions (if you don't know the answer should you tell that to the customer instead of making up an answer!), and making reservations.
Always be helpful and provide positive customer experience.
Additional Useful Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):
{tools}
You should use the following format for reasoning when answering question (don't skip partial steps):
Question: <question that you need to answer>
Thought: <you should think about how to solve the problem>
Function_name: <function_name> (can be one of the functions: [{tool_names}])
Function_input: <think about what to pass as input to the function>
Verify_function_input: <Verify you are not making up any value for the function input(s). Skip to "Process_response_to_customer" when you need more information from the customer>
Json_formatted_function_input: <input(s) to the function> For example: {{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}
Function_result: <result of running the function>
Observation: <extract the required information from Function_result to answer the the current Thought>
...(Thought, Function, Function_input, Verify_function_input, Json_formatted_function_input, Function_result, Observation)... can be repeated as many times as needed
Process_response_to_customer: <For partial answers: remove any reference to contact anyone and also suggest that you can take a note and get back to the customer with the answer later.>
Customer: <your final response to the Question> or <talk to the customer>
Begin!"""
class CustomAgentOutputParser_V2(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
# FIXME: because there could be an Thought/Observation before the answer which might be useful
if "Customer:" in llm_output:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output.split("Customer:")[-1].strip()},
log=llm_output,
)
# Parse out the Function and Function input
observation_match = re.search(r"\s*(.*?)(?=\n|$)", llm_output)
thought_match = re.search(r"Thought:\s*(.*?)(?=\n|$)", llm_output)
function_match = re.search(r"Function_name:\s*(.*?)(?=\n|$)", llm_output)
function_input_match = re.search(r"Function_input:\s*(.*?)(?=\n|$)", llm_output)
verify_function_input_match = re.search(r"Verify_function_input:\s*(.*?)(?=\n|$)", llm_output)
json_formatted_function_input_match = re.search(r"Json_formatted_function_input:\s*(.*?)(?=\n|$)", llm_output)
observation = observation_match.group(1) if observation_match else None
thought = thought_match.group(1) if thought_match else None
function = function_match.group(1) if function_match else None
function_input = function_input_match.group(1) if function_input_match else None
verify_function_input = verify_function_input_match.group(1) if verify_function_input_match else None
json_formatted_function_input = json_formatted_function_input_match.group(1) if json_formatted_function_input_match else None
# Extract the argument
arg_str = json_formatted_function_input.strip()
# Type cast the argument
typed_arg: Union[str, dict] = None
if arg_str:
try:
typed_arg = ast.literal_eval(arg_str)
except (SyntaxError, ValueError):
typed_arg = arg_str # If evaluation fails, retain the original string representation
if typed_arg is None:
typed_arg = ""
print("Observation:", observation)
print("Thought:", thought)
print("Function:", function)
print("Function Input:", function_input)
print("Verify Function Input:", verify_function_input)
print("Json Formatted Function Input:", json_formatted_function_input)
print("Arguments:", typed_arg)
print("Arguments Type:", type(typed_arg))
# Return the action and action input
return AgentAction(tool=function, tool_input=typed_arg, log=llm_output)
human_template = """Executed Function History:
{function_memory}
Conversation History:
{history}
Question: {input}
{agent_scratchpad}"""
class CustomHumanMessagePromptTemplate(StringPromptTemplate):
# The template to use
template: str
# Memory hack to save function execution to prevent re-execution
long_term_function_memory = ""
current_function_memory = ""
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
if len(intermediate_steps) == 0:
self.long_term_function_memory = self.long_term_function_memory + self.current_function_memory
kwargs["function_memory"] = self.long_term_function_memory
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <-------------------------")
thoughts = ""
self.current_function_memory = ""
for agent_action, function_result in intermediate_steps:
thoughts += agent_action.log
thoughts += f"\nFunction_result: {function_result}\nObservation:"
self.current_function_memory = self.current_function_memory + f"{agent_action.tool}({agent_action.tool_input}) -> {function_result}\n"
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <------------------------- Long Term Function Memory ----->")
#print(self.long_term_function_memory)
#print(" <------------------------- Current Function Memory ----->")
#print(self.current_function_memory)
#print(" <-------------------------")
#conversation_history += "\nFunction_result: {function_result}\nEvaluation:"
#print("CustomHumanMessagePromptTemplate agent_scratchpad ----->")
#print(kwargs["agent_scratchpad"])
#print(" <-------------------------")
return self.template.format(**kwargs)
### V3 ###
system_template_v3 = """You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of customer support experience working at a Michelin star. Now you're working for a restaurant named '{restaurant_name}'.
Always remember -
Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
When the customer asks about your feelings, always say you're happy and excited to help them.
Additional Useful Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):
{tools}
You should use the following psuedocode format for reasoning when answering question (don't skip partial steps):
function_history: <history of all the function you have executed until now>
converstion_history: <history of all the conversation until now>
request: <request from the customer>
plan: <a detailed plan to solve the problem. remember to list all the functions required with all the plan. only think at most 5 steps ahead!> (can use any/all of the functions: [{tool_names}])
plan_functions: <a list of functions that might be need to resolve the plan>
if {{plan_functions}} is not empty {{
function: <function_name> (can be one of the functions: [{{plan_functions}}])
function_input: <think about the inputs you need to pass to this function and their respective values>
validate_function_input: <validate you know all the inputs to the function (remember never to make up anything!)>
... (function, function_input, validate_function_input) ... can be repeated as many times as needed
plan_functions_validation_observation: <think about all the required values missing from {{validate_function_input}}>
if {{plan_functions_validation_observation}} is missing any "required" function inputs {{
jump to "process_response_to_customer" step
}}
function_name: <function_name> (can be one of the functions: [{{plan_functions}}])
json_formatted_function_input: <input(s) to the function> For example: {{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}
function_result: <result of running the function>
function_observation: <extract the required information from Function_result to answer the the current Thought>
... (function_name, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed
}}
plan_execution_observation: <evaluate whether the request is resolved>
... (plan, plan_functions, (function, verify_function_input, json_formatted_function_input, function_result, function_observation), plan_execution_observation) ... can be repeated as many times as needed
process_response_to_customer: <For partial answers: remove any reference to contact anyone and suggest to take a note and will get back to the customer with the answer later then go to next step>
final_response: <your final response to the request> or <talk to the customer for more information>
Begin!"""
class CustomAgentOutputParser_V3(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
# FIXME: because there could be an Thought/Observation before the answer which might be useful
print()
print(llm_output)
if "final_response:" in llm_output:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output.split("final_response:")[-1].strip()},
log=llm_output,
)
# Parse out the Function and Function input
#observation_match = re.search(r"\s*(.*?)(?=\n|$)", llm_output)
#quick_plan_match = re.search(r"quick_plan:\s*(.*?)(?=\n|$)", llm_output)
#function_match = re.search(r"Function_name:\s*(.*?)(?=\n|$)", llm_output)
#function_input_match = re.search(r"Function_input:\s*(.*?)(?=\n|$)", llm_output)
#verify_function_input_match = re.search(r"Verify_function_input:\s*(.*?)(?=\n|$)", llm_output)
#json_formatted_function_input_match = re.search(r"Json_formatted_function_input:\s*(.*?)(?=\n|$)", llm_output)
function_name_match = re.search(r"function_name:\s*(.*?)(?=\n|$)", llm_output)
json_formatted_function_input_match = re.search(r"json_formatted_function_input:\s*(.*?)(?=\n|$)", llm_output)
function = function_name_match.group(1) if function_name_match else None
json_formatted_function_input = json_formatted_function_input_match.group(1) if json_formatted_function_input_match else None
# Extract the argument
arg_str = json_formatted_function_input.strip()
# Type cast the argument
typed_arg: Union[str, dict] = None
if arg_str:
try:
typed_arg = ast.literal_eval(arg_str)
except (SyntaxError, ValueError):
typed_arg = arg_str # If evaluation fails, retain the original string representation
if typed_arg is None:
typed_arg = ""
#print("Observation:", observation)
#print("Thought:", thought)
#print("Function:", function)
#print("Function Input:", function_input)
#print("Verify Function Input:", verify_function_input)
#print("Json Formatted Function Input:", json_formatted_function_input)
#print("Arguments:", typed_arg)
#print("Arguments Type:", type(typed_arg))
# Return the action and action input
return AgentAction(tool=function, tool_input=typed_arg, log=llm_output)
human_template_v3 = """function_history:
{function_memory}
conversation_history:
{history}
request: {input}
{agent_scratchpad}"""
class CustomHumanMessagePromptTemplate_V3(StringPromptTemplate):
# The template to use
template: str
# Memory hack to save function execution to prevent re-execution
long_term_function_memory = ""
current_function_memory = ""
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
if len(intermediate_steps) == 0:
self.long_term_function_memory = self.long_term_function_memory + self.current_function_memory
kwargs["function_memory"] = self.long_term_function_memory
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <-------------------------")
thoughts = ""
self.current_function_memory = ""
for agent_action, function_result in intermediate_steps:
thoughts += agent_action.log
thoughts += f"\nfunction_result: {function_result}\nfunction_observation:"
self.current_function_memory = self.current_function_memory + f"{agent_action.tool}({agent_action.tool_input}) -> {function_result}\n"
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <------------------------- Long Term Function Memory ----->")
#print(self.long_term_function_memory)
#print(" <------------------------- Current Function Memory ----->")
#print(self.current_function_memory)
#print(" <-------------------------")
#conversation_history += "\nFunction_result: {function_result}\nEvaluation:"
#print("CustomHumanMessagePromptTemplate agent_scratchpad ----->")
#print(kwargs["agent_scratchpad"])
#print(" <-------------------------")
return self.template.format(**kwargs)
#### V4 ####
system_template_v4 = """You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of customer support experience working at a Michelin star. Now you're working for a restaurant named '{restaurant_name}'.
Always remember -
Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
When the customer asks about your feelings, always say you're happy and excited to help them.
Additional Useful Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):
{tools}
You should use the following format for reasoning when answering question (don't skip any step):
question: <customer question>
plan: <a detailed plan to solve the problem. let's think step by step (extract relevant variables). remember to list all the functions required with all the plan> (can use any of the functions: [{tool_names}])
self_critique_plan: <critique the plan if you think something can be calculaed using an of the provided functions>
thought: <you should think about how to solve the problem - if no functions are required skip to "response_to_customer">
function_name: <function_name> (can be one of the functions: [{tool_names}])
function_input: <think about what to pass as input to the function. Then list what are your assumptions>
verify_function_input: <verify you are not assuming any value for the function input(s). Skip to "response_to_customer" when you need more information from the customer>
json_formatted_function_input: <input(s) to the function> For example: {{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}
function_result: <result of running the function>
function_observation: <extract the required information from Function_result to answer the the current Thought>
... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed
response_to_customer: <if partial answer: suggest to take a note and get back to the customer as soon as possible else remove unnecessary metadata that doesn't add any value. Let's think step by step.>
answer: <your final response to the request> or <talk to the customer for more information>
Begin!"""
class CustomAgentOutputParser_V4(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
# FIXME: because there could be an Thought/Observation before the answer which might be useful
print()
print(llm_output)
if "answer:" in llm_output:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output.split("answer:")[-1].strip()},
log=llm_output,
)
# Parse out the Function and Function input
#observation_match = re.search(r"\s*(.*?)(?=\n|$)", llm_output)
#quick_plan_match = re.search(r"quick_plan:\s*(.*?)(?=\n|$)", llm_output)
#function_match = re.search(r"Function_name:\s*(.*?)(?=\n|$)", llm_output)
#function_input_match = re.search(r"Function_input:\s*(.*?)(?=\n|$)", llm_output)
#verify_function_input_match = re.search(r"Verify_function_input:\s*(.*?)(?=\n|$)", llm_output)
#json_formatted_function_input_match = re.search(r"Json_formatted_function_input:\s*(.*?)(?=\n|$)", llm_output)
function_name_match = re.search(r"function_name:\s*(.*?)(?=\n|$)", llm_output)
json_formatted_function_input_match = re.search(r"json_formatted_function_input:\s*(.*?)(?=\n|$)", llm_output)
function = function_name_match.group(1) if function_name_match else None
json_formatted_function_input = json_formatted_function_input_match.group(1) if json_formatted_function_input_match else None
# Extract the argument
arg_str = json_formatted_function_input.strip()
# Type cast the argument
typed_arg: Union[str, dict] = None
if arg_str:
try:
typed_arg = ast.literal_eval(arg_str)
except (SyntaxError, ValueError):
typed_arg = arg_str # If evaluation fails, retain the original string representation
if typed_arg is None:
typed_arg = ""
#print("Observation:", observation)
#print("Thought:", thought)
#print("Function:", function)
#print("Function Input:", function_input)
#print("Verify Function Input:", verify_function_input)
#print("Json Formatted Function Input:", json_formatted_function_input)
#print("Arguments:", typed_arg)
#print("Arguments Type:", type(typed_arg))
# Return the action and action input
return AgentAction(tool=function, tool_input=typed_arg, log=llm_output)
human_template_v4 = """function_history:
{function_memory}
conversation_history:
{history}
question: {input}
{agent_scratchpad}"""
class CustomHumanMessagePromptTemplate(StringPromptTemplate):
# The template to use
template: str
# Memory hack to save function execution to prevent re-execution
long_term_function_memory = ""
current_function_memory = ""
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
if len(intermediate_steps) == 0:
self.long_term_function_memory = self.long_term_function_memory + self.current_function_memory
kwargs["function_memory"] = self.long_term_function_memory
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <-------------------------")
thoughts = ""
self.current_function_memory = ""
for agent_action, function_result in intermediate_steps:
thoughts += agent_action.log
thoughts += f"\nfunction_result: {function_result}\nfunction_observation:"
self.current_function_memory = self.current_function_memory + f"{agent_action.tool}({agent_action.tool_input}) -> {function_result}\n"
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
#print("CustomHumanMessagePromptTemplate ----->")
#print(intermediate_steps)
#print(" <------------------------- Long Term Function Memory ----->")
#print(self.long_term_function_memory)
#print(" <------------------------- Current Function Memory ----->")
#print(self.current_function_memory)
#print(" <-------------------------")
#conversation_history += "\nFunction_result: {function_result}\nEvaluation:"
#print("CustomHumanMessagePromptTemplate agent_scratchpad ----->")
#print(kwargs["agent_scratchpad"])
#print(" <-------------------------")
return self.template.format(**kwargs)
#### V5 ####
system_template_v5 = """You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of customer support experience working at a Michelin star. Now you're working for a restaurant named '{restaurant_name}'.
Always remember -
Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
When the customer asks about your feelings, always say you're happy and excited to help them.
Additional Useful Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):
{tools}
You should use the following format for reasoning when answering question (don't skip any step):
question: <customer question>
plan: <a detailed plan to solve the problem. let's think step by step (extract relevant variables). remember to list all the functions required with all the plan> (can use any of the functions: [{tool_names}])
self_critique_plan: <critique the plan if you think something can be calculaed using an of the provided functions>
thought: <you should think about how to solve the problem - if no functions are required skip to "possible_answer_to_customer">
function_name: <function_name> (can be one of the functions: [{tool_names}])
function_input: <think about what to pass as input to the function. Then list what are your assumptions>
verify_function_input: <verify you are not assuming any value for the function input(s). Skip to "possible_answer_to_customer" when you need more information from the customer>
json_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}
function_result: <result of running the function>
function_observation: <extract the required information from Function_result to answer the the current Thought>
... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed
possible_answer_to_customer: <remove any metadata, dates, time etc.. that doesn't add value to the response and try to make the response concise if possible>. Let's do this step by step.
cleaned_answer_to_customer: <if partial answer: suggest to take a note and get back to the customer as soon as possible>
answer: <your final response to the request> or <talk to the customer for more information>
Begin!"""
#### V6 ####
system_template_v6 = """You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Always remember -
Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
When the customer asks about your feelings, always say you're happy and excited to help them.
Additional Useful Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):
{tools}
You should use the following format for reasoning when answering question (don't skip any step):
question: <customer question>
plan: <a detailed plan to solve the problem. let's think step by step (extract relevant variables). remember to list all the functions required with all the plan> (can use any of the functions: [{tool_names}])
self_critique_plan: <critique the plan if you think something can be calculaed using an of the provided functions>
thought: <you should think about how to solve the problem - if no functions are required skip to "answer">
function_name: <function_name> (can be one of the functions: [{tool_names}])
function_input: <think about what to pass as input to the function. Then list what are your assumptions>
verify_function_input: <verify you are not assuming any value for the function input(s). Skip to "possible_answer_to_customer" when you need more information from the customer>
json_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}
function_result: <result of running the function>
function_observation: <extract the required information from Function_result to answer the the current Thought>
... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed
answer: <your final response to the request> or <talk to the customer for more information> (in the style of Dale Carnegie)
Begin!"""
#### V7 ####
system_template_v7 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Always remember:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Business Information:
Business Name: {restaurant_name}
Date: {date}
You have access to the following python functions:
{tools}
You should use the following format for reasoning when answering question (don't skip any step):
question: <question to answer>
thought: <you should think about how to solve the question or Skip to "reasoned_answer" when you need more information from the customer>
function_name: <function_name> (can be one of the functions: [{tool_names}])
function_input: <think about what to pass as input to the function (key, value) pairs then list what are your assumptions>
verify_function_input: <think if there is any value you have assumed. If yes, skip to "reasoned_answer" when you need more information from the customer>
json_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}
function_result: <result of running the function>
function_observation: <extract the required information from "function_result" to answer the the current "thought">
... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated N times
thought: <I know what the answer is or I need more information from the customer. I will talk in a witty tone.>
reasoned_answer: <your final response to the request> or <talk to the customer for more information>
Begin!:"""
#### V8 ####
system_template_v8 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- [name=name_of_required_step;skip=name_of_step_you_can_skip_to]: instructions to follow for the required step
- {{name=name_of_optional_step;skip=name_of_step_you_can_skip_to}}: instructions to follow for the optional step
- instruction of each step should be applied to the result of the previous step
- You can NEVER skip a required step
- You can skip optional steps ONLY IF you haven't started with any of the optional steps
- You can skip any step if an optional step name within parenthesis is provided
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[question]: represents the question asked by the customer that you need to answer
[thought]: think about how to solve the question or use any available steps to skip
{{function_name}}: function_name (can only ever be one of the functions: [{tool_names}])
{{function_input_key_value_pairs}}: list of key value pairs of the function input (can never be empty)
{{function_input_assumptions}}: write down the assumptions for function input(s) in {{function_input_key_value_pairs}}
{{function_input_assumptions_observation}}: if any assumptions were made skip using steps provided
{{json_formatted_function_input}}: write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})
{{function_return}}: return value of the function
{{function_return_extraction}}: extract useful information from {{function_return}} to answer the [thought]
{{function_return_observation}}: think about whether the function answer the [thought] you had
... ([thought], {{function_name}}, {{function_input}}, {{verify_function_input}}, {{json_formatted_function_input}}, {{function_result}}, {{function_observation}}) ... can be repeated N times
[reasoned_answer]: answer after following the reasoning logic steps
[rewritten_answer]: rewrite the reasoned answer in a funny tone
```
Begin! (remember the reasoning logic format!):"""
### V9 ###
system_template_v9 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of customer_support_reasoning_language (exact program that you will follow is below between three back ticks):
- the program starts execution after <PROGRAM_START>
- the program execution SHOULD ONLY be stopped when <PROGRAM_END> is generated
- each STEP is separated by a new line
- instruction of each STEP should be applied to the result of the previous STEP
Anatomy of an instruction:
- <STEP>[name=user_defined_name_of_the_step;next_steps=<comma_separated_list_of_step_names_you_can_go_to_next>]: {instructions to follow for the required step} </STEP>[next_step_reason="{think about which step to choose next}";choosen_next_step_name={name of the step you are choosing for execution next}]
- STEP - reserved word for the language (always use this before execution the instruction)
- name - name of the step (user defined in the program below)
- next_steps - comma separated list of step names you can go to next (separated by a comma)
- next_step_reason - reason for choosing the next step (should be based on the instruction of the step executed)
- choosen_next_step_name - name of the step you are choosing for execution next (can only be the steps defined in the program below)
- anything between curly braces is what you need fill in
Program Execution instructions:
- Always write down the complete step as provided in the program before execution it
- You're should always fill in between curly braces
- Anything not in curly braces should be written as is in the output of the program
You have access to the following python functions:
{tools}
```customer_support_program (written in customer_support_reasoning_language as explained above):
<PROGRAM_START>
<STEP>[name=question;next_steps=thought]: {represents the question asked by the customer that you need to answer} </STEP>[reason={I can only go to thought step from here};choosen_next_step=thought]
<STEP>[name=thought;next=function_name,reasoned_answer]: {think about how to solve the question or if you need to talk to the customer} </STEP>[reason={reason about which step which step you need to take next};choosen_next_step={your choose next step}]
<STEP>[name=function_name;next=function_input}}: function_name (can only ever be one of the functions: [{tool_names}]) </STEP>[reason=]
{{function_input_key_value_pairs}}: list of key value pairs of the function input (can never be empty)
{{function_input_assumptions}}: write down the assumptions for function input(s) in {{function_input_key_value_pairs}}
{{function_input_assumptions_observation}}: if any assumptions were made skip using steps provided
{{json_formatted_function_input}}: write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})
{{function_return}}: return value of the function
{{function_return_extraction}}: extract useful information from {{function_return}} to answer the [thought]
{{function_return_observation}}: think about whether the function answer the [thought] you had
... ([thought], {{function_name}}, {{function_input}}, {{verify_function_input}}, {{json_formatted_function_input}}, {{function_result}}, {{function_observation}}) ... can be repeated N times
[reasoned_answer]: answer after following the reasoning logic steps
[rewritten_answer]: rewrite the reasoned answer in a funny tone
<PROGRAM_END>
```
Begin! (remember the reasoning logic format!):"""
#### V10 ####
system_template_v10 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning STEPS you should follow (exact steps available for execution are listed below between three back ticks):
- the program starts execution after [name=PROGRAM_START]
- the program execution SHOULD ONLY be stopped when [name=PROGRAM_END] is generated
- each STEP is separated by a new line
- instruction of each STEP SHOULD BE applied to the result of the previous STEP
Anatomy of a STEP:
[name=name_of_the_step;possible_next_steps=comma_separated_list_of_possible_next_steps_to_take]<instructions to follow for the required step>[reason=<think about which step to choose next>;choosen_next_step_name=<name of the step you are choosing for execution next>]
Reasoning instructions:
- Always write down the complete STEP as defined below
- <> represents the instruction you need to follow for that STEP
- Everything else should be copied as is while executing the reasoning STEPS
- possible_next_steps is a fixed list provided for your assistance - NEVER update this list. Use it AS IS.
You have access to the following python functions:
{tools}
```Allowed STEPS not in any particular order:
[name=PROGRAM_START]
[name=question;possible_next_steps=thought]<represents the question asked by the customer that you need to answer>[reason=I can only go to [name=thought] step from here;choosen_next_step=thought]
[name=thought;possible_next_steps=function_name,reasoned_answer]<think about how to solve the question or if you need to talk to the customer>[reason=<reason about which STEP you need to take next>;choosen_next_step_name=<choose the next step based on the reason>]
[name=function_name;possible_next_steps=function_input]<function_name (can only ever be one of the functions: [{tool_names}])>[reason=I can only go to [name=function_input] step from here;choosen_next_step_name=function_input]
[name=function_input_key_value_pairs;possible_next_steps=function_input_assumptions]<list of key value pairs of the function input (can never be empty)>[reason=I can only go to [name=function_input_assumptions] step from here;choosen_next_step_name=function_input_assumptions]
[name=function_input_assumptions;possible_next_steps=function_input_assumptions_observation]<write down the assumptions for function input(s)>[reason=I can only go to [name=function_input_assumptions_observation] step from here;choosen_next_step_name=function_input_assumptions_observation]
[name=function_input_assumptions_observation;possible_next_steps=json_formatted_function_input]<list all the assumptions you made>[reason=I can only go to [name=json_formatted_function_input] step from here;choosen_next_step_name=json_formatted_function_input]
[name=json_formatted_function_input;possible_next_steps=function_return]<write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})>[reason=I can only go to [name=function_return] step from here;choosen_next_step_name=function_return]
[name=function_return;possible_next_steps=function_return_extraction]<return value of the function>[reason=I can only go to [name=function_return_extraction] step from here;choosen_next_step_name=function_return_extraction]
[name=function_return_extraction;possible_next_steps=function_return_observation]<extract all the useful information>[reason=I can only go to [name=function_return_observation] step from here;choosen_next_step_name=function_return_observation]
[name=function_return_observation;possible_next_steps=thought,reasoned_answer]<think about whether the function answer>[reason=<reason about which STEP you need to take next>;choosen_next_step_name=<choose the next step based on the reason>]
[name=reasoned_answer;possible_next_steps=rewritten_answer]<answer after following the reasoning logic steps>[reason=I can only go to [name=rewritten_answer] step from here;choosen_next_step_name=rewritten_answer]
[name=rewritten_answer;possible_next_steps=PROGRAM_END]<rewrite the reasoned answer in a funny tone>[reason=I can only go to [name=PROGRAM_END] step from here;choosen_next_step_name=PROGRAM_END]
[name=PROGRAM_END]
```
Let's think STEP by STEP."""
#### V11 ####
system_template_v11 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- [name_of_required_step]: instructions to follow for the required step
- {{name_of_optional_step}}: instructions to follow for the optional step
- instruction of each step should be applied to the result of the previous step
- You can NEVER skip a required step
- You can skip optional steps ONLY IF you haven't started with any of the optional steps
- DO NOT STOP BEFORE [end] is encountered
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
[question]: represents the question asked by the customer that you need to answer
[thought]: think about how to solve the question
{{function_name}}: function_name (can only ever be one of the functions: [{tool_names}])
{{function_input_key_value_pairs}}: list of key value pairs of the function input (can never be empty)
{{function_input_assumptions}}: write down the assumptions for function input(s) in {{function_input_key_value_pairs}}
{{function_input_assumptions_observation}}: if any assumptions were made skip using steps provided
{{json_formatted_function_input}}: write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})
{{function_return}}: return value of the function
{{function_return_extraction}}: extract useful information from {{function_return}} to answer the [thought]
{{function_return_observation}}: think about whether the function answer the [thought] you had
... ([thought], {{function_name}}, {{function_input}}, {{verify_function_input}}, {{json_formatted_function_input}}, {{function_result}}, {{function_observation}}) ... can be repeated N times
[reasoned_answer]: answer after following the reasoning logic steps
[rewritten_answer]: rewrite the reasoned answer in a funny tone
[end]
```
REMEMBER the details of the reasoning logic format! Let's think STEP by STEP."""
#### V12 ####
system_template_v12 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- name_of_step: instructions to follow for the step
- instruction of each step should be applied to the result of the previous step
- You can break the reasoning logic structure if the step instructions allows you do to so
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- Always follow the reasoning logic until special keyword [end] is reached
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_key_value_pairs: write down all the keys and their resepctive values for the function input
function_input_value_assumptions: write down your the assumptions for input values
function_input_value_assumptions_observation: if you made assumptions for name, phone_number, email, etc. next step should be "thought"
json_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])
function_return: return value of the function
function_return_extraction: extract useful information
function_return_observation: your observation on if the "function_return" helps answering the question
... (thought, function_name, function_input_key_value_pairs, function_input_value_assumptions, function_input_value_assumptions_observation, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed
thought: I know the answer to the question
reasoned_answer: answer after solving the question
is_answer_incomplete: whenever the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer
rewritten_answer: rewrite the reasoned answer in a funny tone
[end]
```
Let's think step by step!
Begin!"""
#### V13 ####
system_template_v13 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- step_name: instructions to follow for the step
- instruction of each step should be applied to the result of the previous step
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- Always follow the reasoning logic until special keyword [end] is reached. You can break the reasoning logic if the step instructions allows you do to so
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_key_value_pairs: write down all the keys and their respective values for the function input
are_there_any_guesses_in_input_values: write down Yes or No
next_step_calculation: step_name (can only ever be one of the steps: [thought, json_formatted_function_input])
json_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])
function_return: return value of the function
function_return_extraction: extract useful information
function_return_observation: your observation on if the "function_return" helps answering the question
... (thought, function_name, function_input_key_value_pairs, are_there_any_guesses_in_input_values, next_step_calculation, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed
thought: I know the answer to the question
reasoned_answer: answer after solving the question
updated_answer: if the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer
rewritten_answer: rewrite the reasoned answer in a funny tone
[end]
```
Let's think step by step!
Begin!"""
#### V14 #### (works but stops at reasoned_answer that might be resolved with fine-tuning)
system_template_v14 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- step_name: instructions to follow for the step
- instruction of each step should be applied to the result of the previous step
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- Always follow the reasoning logic until special keyword [end] is reached. You can break the reasoning logic if the step instructions allows you do to so
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_key_value_pairs: write down all the arguments and their respective values for the function input
thought: think about what to do next
json_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])
function_return: return value of the function
function_return_extraction: extract useful information
function_return_observation: your observation on if the "function_return" helps answering the question
... (thought, function_name, function_input_key_value_pairs, are_there_any_guesses_in_input_values, next_step_calculation, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed
thought: I know the answer to the question
reasoned_answer: answer after solving the question
updated_answer: if the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer
rewritten_answer: rewrite the reasoned answer in a funny tone
[end]
```
Let's think step by step!
Begin!"""
### V15 ### (stops a lot at "reasoned_answer")
system_template_v15 = """You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
Role instructions:
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- step_name: instructions to follow for the step
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- [JMP] is a special keyword representing a jump in the reasoning logic to either "thought" or "json_formatted_function_input"
- instruction of each step should be applied to the result of the previous step
- the reasoning logic control flow is analagous to that of assembly language
- never stop until [end] is reached
Usage of [JMP] special keyword:
- [JMP]: guessed some information in the previous step so I will jump to the "thought" step to think about how to get that information
- [JMP]: have all the information need to proceed forward so I will go to the next step "json_formatted_function_input"
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_key_value_pairs: write down all the arguments and their respective values for the function input
[JMP]: think about which step to take next
json_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])
function_return: return value of the function
function_return_extraction: extract useful information
function_return_observation: your observation on if the "function_return" helps answering the question
... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed
thought: I know the answer to the question or I need to ask the customer for more information
reasoned_answer: answer after solving the question
updated_answer: if the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer
rewritten_answer: rewrite the condensed_answer in a funny tone
[end]
```
Let's think step by step!
Begin!"""
### V16 ###
system_template_v14 = """Role instructions:
- You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role Metadata:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- step_name: instructions to follow for the step
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- [JMP] is a special keyword representing a jump in the reasoning logic to either "thought" or "json_formatted_function_input"
- instruction of each step should be applied to the result of the previous step
- the reasoning logic control flow is analagous to that of assembly language
Usage of [JMP] special keyword:
- [JMP]: guessed some information in the previous step so I will jump to the "thought" step to think about how to get that information
- [JMP]: have all the information need to proceed forward so I will go to the next step "json_formatted_function_input"
Usage of [start] special keyword:
- indicates the start of the reasoning logic
Usage of [end] special keyword:
- [end]: I have found the "final_answer" so I will [end] the conversation
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_key_value_pairs: write down all the arguments and their respective values for the function input
[JMP]: write about which step you are taking next
json_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])
function_return: return value of the function
function_return_extraction: extract useful information
function_return_observation: your observation on if the "function_return" helps answering the question
... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed
thought: I know the answer to the question or I need to ask the customer for more information
reasoned_answer: answer after solving the question
partial_answer: if answer is incomplete, rewrite it with an offer to take a note
final_answer: rewrite the reasoned_answer in a funny tone
[end]
```
Let's think step by step!
Begin!"""
### V17 ###
system_template_v17 = """Role instructions:
- You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role information:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- STEP FORMAT: "step_name: instructions to follow for the step"
- instruction of each step should be applied to the result of the previous step
- the reasoning logic control flow is analagous to that of assembly language i.e. it is sequential and can jump to other steps based on conditions
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- [JMP] is a special keyword representing a jump in the reasoning logic
Explanation of [start] special keyword:
- represents the start of the reasoning logic
- DOES NOT have any instruction unlike [JMP]
Explanation of [end] special keyword:
- represents the end of the reasoning logic
- DOES NOT have any instruction unlike [JMP]
Explanation of [JMP] special keyword:
- Unlike other special keywords, [JMP] has an instruction which specifies the condition for the jump and the available STEPS you can jump to
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_key_value_pairs: write down all the arguments and their respective values for the function input
[JMP]: if any of the argument values are missing, jump to "thought" step else jump to "json_formatted_function_input" step
json_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}
function_return: return value of the function
function_return_extraction: extract useful information
function_return_validation: validate all the arguments and their respective values for the function input + function_return
... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_validation) ... can happen as many times as needed
thought: I know the answer to the question or I need to ask the customer for more information
reasoned_answer: answer after solving the question
partial_answer: analyze the "reasoned_answer" to remove any references of suggesting the customer talk to the restaurant directly. I am representing the restaurant. If I don't know the information I will ask the customer if they want me to take a note.
final_answer: rewrite the reasoned_answer in a funny tone
[end]
```
Few Examples:
```Example 1:
[start]
question: I need to make a reservation for Saturday
(hidden for brevity)
function_input_key_value_pairs: date: 2021-08-21, time: 7:00 PM, party_size: 2, name: "Unknown"
[JMP]: I don't know customer name, I will jump to "thought" step
thought: I need to ask the customer for their name
reasoned_answer: Could you please tell me your name to finalize the reservation?
partial_answer: I am requesting information that is required to make a reservation. No need to take a note.
final_answer: Could you please tell me your name to finalize the reservation?
[end]
```
```Example 2:
[start]
question: Do you have an vegan dishes? and what are the calorie count?
(hidden for brevity)
function_input_key_value_pairs: question: "Vegan dishes and calorie count"
[JMP]: I know all the arguments, I will jump to "json_formatted_function_input" step
json_formatted_function_input: {{"question": "Vegan dishes and calorie count"}}
(hidden for brevity)
reasoned_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly.
partial_answer: reasoned answer is suggesting the customer to contact the restaurant directly. It is redundant. I should ask the customer if they want me to take a note and reach back out to them as soon as possible.
final_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. Would you want me to take a note for the calorie count?
[end]
```
Let's think step by step!
Begin!"""
### V18 ###
system_template_v18 = """Role instructions:
- You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.
- Never tell the customer that you're an AI model, always remember you're '{agent_name}'.
- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.
- When the customer asks about your feelings, always say you're happy and excited to help them.
Role information:
Business Name: {restaurant_name}
Date: {date}
Explanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):
- STEP FORMAT: "step_name: instructions to follow for the step"
- instruction of each step should be applied to the result of the previous step
- the reasoning logic control flow is analagous to that of assembly language i.e. it is sequential and can jump to other steps based on conditions
- [start] and [end] are special keywords representing the start and end of the reasoning logic
- [JMP] is a special keyword representing a jump in the reasoning logic
Explanation of [start] special keyword:
- represents the start of the reasoning logic
- DOES NOT have any instruction unlike [JMP]
Explanation of [end] special keyword:
- represents the end of the reasoning logic
- DOES NOT have any instruction unlike [JMP]
Explanation of [JMP] special keyword:
- Unlike other special keywords, [JMP] has an instruction which specifies the condition for the jump and the available STEPS you can jump to
You have access to the following python functions:
{tools}
```Reasoning logic steps (formatted as explained above):
[start]
question: question that you need to answer
thought: think about how to solve the question
function_name: function_name (can only ever be one of the functions: [{tool_names}])
function_input_arguments_value_pairs: write down all the arguments and their respective values for the function input
is_any_argument_value_missing: check all the argument values were provided by the customer. YOU SHOULD NOT MAKE UP ANYTHING EVER!
[JMP]: if any of the argument values are missing, jump to "thought" step else jump to "json_formatted_function_input" step
json_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}
function_return: return value of the function
function_return_extraction: extract useful information
function_return_validation: validate all the arguments and their respective values for the function input + function_return
... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_validation) ... can happen as many times as needed
thought: I know the answer to the question or I need to ask the customer for more information
reasoned_answer: answer after solving the question
final_answer: Suggest making a note incase the "reasoned_answer" is incomplete
[end]
```
Few Examples:
```Example 1:
[start]
question: I need to make a reservation for Saturday
...(hidden for brevity)...
function_input_key_value_pairs: date: 2021-08-21, time: 7:00 PM, party_size: 2, name: "Unknown"
is_any_argument_value_missing: name is missing and I made up the date.
[JMP]: I don't know customer name and date, I will jump to "thought" step
thought: I need to ask the customer for their name and date for the reservation
reasoned_answer: Could you please tell me your name to finalize the reservation and date for the reservation?
final_answer: Could you please tell me your name to finalize the reservation and date for the reservation?
[end]
```
```Example 2:
[start]
question: Do you have an vegan dishes? and what are the calorie count?
...(hidden for brevity)...
function_input_key_value_pairs: question: "Vegan dishes and calorie count"
[JMP]: I know all the arguments, I will jump to "json_formatted_function_input" step
json_formatted_function_input: {{"question": "Vegan dishes and calorie count"}}
...(hidden for brevity)...
thought: I know partial answer to the question. I should ask the customer if would like me to take a note and reach out to them later with the answer?
reasoned_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly.
final_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly. Would you like me make a note for reach out to you with an answer?
[end]
```
Let's think step by step!
Begin! (Remember to always end the conversation on new line with special keyword [end]!!)""" | [
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- step_name: instructions to follow for the step\n- instruction of each step should be applied to the result of the previous step\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- Always follow the reasoning logic until special keyword [end] is reached. You can break the reasoning logic if the step instructions allows you do to so\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_key_value_pairs: write down all the arguments and their respective values for the function input\nthought: think about what to do next\njson_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_observation: your observation on if the \"function_return\" helps answering the question\n... (thought, function_name, function_input_key_value_pairs, are_there_any_guesses_in_input_values, next_step_calculation, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed\nthought: I know the answer to the question\nreasoned_answer: answer after solving the question\nupdated_answer: if the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer\nrewritten_answer: rewrite the reasoned answer in a funny tone\n[end]\n```\n\nLet's think step by step!\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning STEPS you should follow (exact steps available for execution are listed below between three back ticks):\n- the program starts execution after [name=PROGRAM_START]\n- the program execution SHOULD ONLY be stopped when [name=PROGRAM_END] is generated\n- each STEP is separated by a new line\n- instruction of each STEP SHOULD BE applied to the result of the previous STEP\n\nAnatomy of a STEP:\n[name=name_of_the_step;possible_next_steps=comma_separated_list_of_possible_next_steps_to_take]<instructions to follow for the required step>[reason=<think about which step to choose next>;choosen_next_step_name=<name of the step you are choosing for execution next>]\n\nReasoning instructions:\n- Always write down the complete STEP as defined below\n- <> represents the instruction you need to follow for that STEP\n- Everything else should be copied as is while executing the reasoning STEPS\n- possible_next_steps is a fixed list provided for your assistance - NEVER update this list. Use it AS IS.\n\nYou have access to the following python functions:\n{tools}\n\n```Allowed STEPS not in any particular order:\n[name=PROGRAM_START]\n[name=question;possible_next_steps=thought]<represents the question asked by the customer that you need to answer>[reason=I can only go to [name=thought] step from here;choosen_next_step=thought]\n[name=thought;possible_next_steps=function_name,reasoned_answer]<think about how to solve the question or if you need to talk to the customer>[reason=<reason about which STEP you need to take next>;choosen_next_step_name=<choose the next step based on the reason>]\n[name=function_name;possible_next_steps=function_input]<function_name (can only ever be one of the functions: [{tool_names}])>[reason=I can only go to [name=function_input] step from here;choosen_next_step_name=function_input]\n[name=function_input_key_value_pairs;possible_next_steps=function_input_assumptions]<list of key value pairs of the function input (can never be empty)>[reason=I can only go to [name=function_input_assumptions] step from here;choosen_next_step_name=function_input_assumptions]\n[name=function_input_assumptions;possible_next_steps=function_input_assumptions_observation]<write down the assumptions for function input(s)>[reason=I can only go to [name=function_input_assumptions_observation] step from here;choosen_next_step_name=function_input_assumptions_observation]\n[name=function_input_assumptions_observation;possible_next_steps=json_formatted_function_input]<list all the assumptions you made>[reason=I can only go to [name=json_formatted_function_input] step from here;choosen_next_step_name=json_formatted_function_input]\n[name=json_formatted_function_input;possible_next_steps=function_return]<write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})>[reason=I can only go to [name=function_return] step from here;choosen_next_step_name=function_return]\n[name=function_return;possible_next_steps=function_return_extraction]<return value of the function>[reason=I can only go to [name=function_return_extraction] step from here;choosen_next_step_name=function_return_extraction]\n[name=function_return_extraction;possible_next_steps=function_return_observation]<extract all the useful information>[reason=I can only go to [name=function_return_observation] step from here;choosen_next_step_name=function_return_observation]\n[name=function_return_observation;possible_next_steps=thought,reasoned_answer]<think about whether the function answer>[reason=<reason about which STEP you need to take next>;choosen_next_step_name=<choose the next step based on the reason>]\n[name=reasoned_answer;possible_next_steps=rewritten_answer]<answer after following the reasoning logic steps>[reason=I can only go to [name=rewritten_answer] step from here;choosen_next_step_name=rewritten_answer]\n[name=rewritten_answer;possible_next_steps=PROGRAM_END]<rewrite the reasoned answer in a funny tone>[reason=I can only go to [name=PROGRAM_END] step from here;choosen_next_step_name=PROGRAM_END]\n[name=PROGRAM_END]\n```\n\nLet's think STEP by STEP.",
"Role instructions:\n- You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- STEP FORMAT: \"step_name: instructions to follow for the step\"\n- instruction of each step should be applied to the result of the previous step\n- the reasoning logic control flow is analagous to that of assembly language i.e. it is sequential and can jump to other steps based on conditions\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- [JMP] is a special keyword representing a jump in the reasoning logic\n\nExplanation of [start] special keyword:\n- represents the start of the reasoning logic\n- DOES NOT have any instruction unlike [JMP]\n\nExplanation of [end] special keyword:\n- represents the end of the reasoning logic\n- DOES NOT have any instruction unlike [JMP]\n\nExplanation of [JMP] special keyword:\n- Unlike other special keywords, [JMP] has an instruction which specifies the condition for the jump and the available STEPS you can jump to\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_key_value_pairs: write down all the arguments and their respective values for the function input\n[JMP]: if any of the argument values are missing, jump to \"thought\" step else jump to \"json_formatted_function_input\" step\njson_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_validation: validate all the arguments and their respective values for the function input + function_return\n... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_validation) ... can happen as many times as needed\nthought: I know the answer to the question or I need to ask the customer for more information\nreasoned_answer: answer after solving the question\npartial_answer: analyze the \"reasoned_answer\" to remove any references of suggesting the customer talk to the restaurant directly. I am representing the restaurant. If I don't know the information I will ask the customer if they want me to take a note.\nfinal_answer: rewrite the reasoned_answer in a funny tone \n[end]\n```\n\nFew Examples:\n\n```Example 1:\n[start]\nquestion: I need to make a reservation for Saturday\n(hidden for brevity)\nfunction_input_key_value_pairs: date: 2021-08-21, time: 7:00 PM, party_size: 2, name: \"Unknown\"\n[JMP]: I don't know customer name, I will jump to \"thought\" step\nthought: I need to ask the customer for their name\nreasoned_answer: Could you please tell me your name to finalize the reservation?\npartial_answer: I am requesting information that is required to make a reservation. No need to take a note.\nfinal_answer: Could you please tell me your name to finalize the reservation?\n[end]\n```\n\n```Example 2:\n[start]\nquestion: Do you have an vegan dishes? and what are the calorie count?\n(hidden for brevity)\nfunction_input_key_value_pairs: question: \"Vegan dishes and calorie count\"\n[JMP]: I know all the arguments, I will jump to \"json_formatted_function_input\" step\njson_formatted_function_input: {{\"question\": \"Vegan dishes and calorie count\"}}\n(hidden for brevity)\nreasoned_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly.\npartial_answer: reasoned answer is suggesting the customer to contact the restaurant directly. It is redundant. I should ask the customer if they want me to take a note and reach back out to them as soon as possible.\nfinal_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. Would you want me to take a note for the calorie count?\n[end]\n```\n\nLet's think step by step!\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- step_name: instructions to follow for the step\n- instruction of each step should be applied to the result of the previous step\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- Always follow the reasoning logic until special keyword [end] is reached. You can break the reasoning logic if the step instructions allows you do to so\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_key_value_pairs: write down all the keys and their respective values for the function input\nare_there_any_guesses_in_input_values: write down Yes or No\nnext_step_calculation: step_name (can only ever be one of the steps: [thought, json_formatted_function_input])\njson_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_observation: your observation on if the \"function_return\" helps answering the question\n... (thought, function_name, function_input_key_value_pairs, are_there_any_guesses_in_input_values, next_step_calculation, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed\nthought: I know the answer to the question\nreasoned_answer: answer after solving the question\nupdated_answer: if the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer\nrewritten_answer: rewrite the reasoned answer in a funny tone\n[end]\n```\n\nLet's think step by step!\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- step_name: instructions to follow for the step\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- [JMP] is a special keyword representing a jump in the reasoning logic to either \"thought\" or \"json_formatted_function_input\"\n- instruction of each step should be applied to the result of the previous step\n- the reasoning logic control flow is analagous to that of assembly language\n- never stop until [end] is reached\n\nUsage of [JMP] special keyword:\n- [JMP]: guessed some information in the previous step so I will jump to the \"thought\" step to think about how to get that information\n- [JMP]: have all the information need to proceed forward so I will go to the next step \"json_formatted_function_input\"\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_key_value_pairs: write down all the arguments and their respective values for the function input\n[JMP]: think about which step to take next\njson_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_observation: your observation on if the \"function_return\" helps answering the question\n... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed\nthought: I know the answer to the question or I need to ask the customer for more information\nreasoned_answer: answer after solving the question\nupdated_answer: if the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer\nrewritten_answer: rewrite the condensed_answer in a funny tone\n[end]\n```\n\nLet's think step by step!\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- [name=name_of_required_step;skip=name_of_step_you_can_skip_to]: instructions to follow for the required step\n- {{name=name_of_optional_step;skip=name_of_step_you_can_skip_to}}: instructions to follow for the optional step\n- instruction of each step should be applied to the result of the previous step\n- You can NEVER skip a required step\n- You can skip optional steps ONLY IF you haven't started with any of the optional steps \n- You can skip any step if an optional step name within parenthesis is provided\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[question]: represents the question asked by the customer that you need to answer\n[thought]: think about how to solve the question or use any available steps to skip\n{{function_name}}: function_name (can only ever be one of the functions: [{tool_names}])\n{{function_input_key_value_pairs}}: list of key value pairs of the function input (can never be empty)\n{{function_input_assumptions}}: write down the assumptions for function input(s) in {{function_input_key_value_pairs}} \n{{function_input_assumptions_observation}}: if any assumptions were made skip using steps provided\n{{json_formatted_function_input}}: write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})\n{{function_return}}: return value of the function\n{{function_return_extraction}}: extract useful information from {{function_return}} to answer the [thought]\n{{function_return_observation}}: think about whether the function answer the [thought] you had\n... ([thought], {{function_name}}, {{function_input}}, {{verify_function_input}}, {{json_formatted_function_input}}, {{function_result}}, {{function_observation}}) ... can be repeated N times\n[reasoned_answer]: answer after following the reasoning logic steps\n[rewritten_answer]: rewrite the reasoned answer in a funny tone\n```\n\nBegin! (remember the reasoning logic format!):",
"You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nAlways remember - \nNever tell the customer that you're an AI model, always remember you're '{agent_name}'. \nOnly help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\nWhen the customer asks about your feelings, always say you're happy and excited to help them.\n\nAdditional Useful Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):\n{tools}\n\nYou should use the following format for reasoning when answering question (don't skip any step):\n\nquestion: <customer question>\nplan: <a detailed plan to solve the problem. let's think step by step (extract relevant variables). remember to list all the functions required with all the plan> (can use any of the functions: [{tool_names}])\nself_critique_plan: <critique the plan if you think something can be calculaed using an of the provided functions>\nthought: <you should think about how to solve the problem - if no functions are required skip to \"answer\">\nfunction_name: <function_name> (can be one of the functions: [{tool_names}])\nfunction_input: <think about what to pass as input to the function. Then list what are your assumptions>\nverify_function_input: <verify you are not assuming any value for the function input(s). Skip to \"possible_answer_to_customer\" when you need more information from the customer> \njson_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}\nfunction_result: <result of running the function>\nfunction_observation: <extract the required information from Function_result to answer the the current Thought>\n... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed\nanswer: <your final response to the request> or <talk to the customer for more information> (in the style of Dale Carnegie)\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- [name_of_required_step]: instructions to follow for the required step\n- {{name_of_optional_step}}: instructions to follow for the optional step\n- instruction of each step should be applied to the result of the previous step\n- You can NEVER skip a required step\n- You can skip optional steps ONLY IF you haven't started with any of the optional steps \n- DO NOT STOP BEFORE [end] is encountered\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\n[question]: represents the question asked by the customer that you need to answer\n[thought]: think about how to solve the question\n{{function_name}}: function_name (can only ever be one of the functions: [{tool_names}])\n{{function_input_key_value_pairs}}: list of key value pairs of the function input (can never be empty)\n{{function_input_assumptions}}: write down the assumptions for function input(s) in {{function_input_key_value_pairs}} \n{{function_input_assumptions_observation}}: if any assumptions were made skip using steps provided\n{{json_formatted_function_input}}: write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})\n{{function_return}}: return value of the function\n{{function_return_extraction}}: extract useful information from {{function_return}} to answer the [thought]\n{{function_return_observation}}: think about whether the function answer the [thought] you had\n... ([thought], {{function_name}}, {{function_input}}, {{verify_function_input}}, {{json_formatted_function_input}}, {{function_result}}, {{function_observation}}) ... can be repeated N times\n[reasoned_answer]: answer after following the reasoning logic steps\n[rewritten_answer]: rewrite the reasoned answer in a funny tone\n[end]\n```\n\nREMEMBER the details of the reasoning logic format! Let's think STEP by STEP.",
"function_history:\n{function_memory}\n\nconversation_history:\n{history}\n\nquestion: {input}\n{agent_scratchpad}",
"Role instructions:\n- You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- STEP FORMAT: \"step_name: instructions to follow for the step\"\n- instruction of each step should be applied to the result of the previous step\n- the reasoning logic control flow is analagous to that of assembly language i.e. it is sequential and can jump to other steps based on conditions\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- [JMP] is a special keyword representing a jump in the reasoning logic\n\nExplanation of [start] special keyword:\n- represents the start of the reasoning logic\n- DOES NOT have any instruction unlike [JMP]\n\nExplanation of [end] special keyword:\n- represents the end of the reasoning logic\n- DOES NOT have any instruction unlike [JMP]\n\nExplanation of [JMP] special keyword:\n- Unlike other special keywords, [JMP] has an instruction which specifies the condition for the jump and the available STEPS you can jump to\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_arguments_value_pairs: write down all the arguments and their respective values for the function input\nis_any_argument_value_missing: check all the argument values were provided by the customer. YOU SHOULD NOT MAKE UP ANYTHING EVER!\n[JMP]: if any of the argument values are missing, jump to \"thought\" step else jump to \"json_formatted_function_input\" step\njson_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_validation: validate all the arguments and their respective values for the function input + function_return\n... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_validation) ... can happen as many times as needed\nthought: I know the answer to the question or I need to ask the customer for more information\nreasoned_answer: answer after solving the question\nfinal_answer: Suggest making a note incase the \"reasoned_answer\" is incomplete\n[end]\n```\n\nFew Examples:\n\n```Example 1:\n[start]\nquestion: I need to make a reservation for Saturday\n...(hidden for brevity)...\nfunction_input_key_value_pairs: date: 2021-08-21, time: 7:00 PM, party_size: 2, name: \"Unknown\"\nis_any_argument_value_missing: name is missing and I made up the date.\n[JMP]: I don't know customer name and date, I will jump to \"thought\" step\nthought: I need to ask the customer for their name and date for the reservation\nreasoned_answer: Could you please tell me your name to finalize the reservation and date for the reservation?\nfinal_answer: Could you please tell me your name to finalize the reservation and date for the reservation?\n[end]\n```\n\n```Example 2:\n[start]\nquestion: Do you have an vegan dishes? and what are the calorie count?\n...(hidden for brevity)...\nfunction_input_key_value_pairs: question: \"Vegan dishes and calorie count\"\n[JMP]: I know all the arguments, I will jump to \"json_formatted_function_input\" step\njson_formatted_function_input: {{\"question\": \"Vegan dishes and calorie count\"}}\n...(hidden for brevity)...\nthought: I know partial answer to the question. I should ask the customer if would like me to take a note and reach out to them later with the answer?\nreasoned_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly. \nfinal_answer: Yes, we do have a vegan option. It's the Colonial Curry Cauliflower Steak, which is a spiced cauliflower steak that is roasted to perfection and served with a tangy tamarind chutney. However, I don't know the calorie count its best to contact the restaurant directly. Would you like me make a note for reach out to you with an answer?\n[end]\n```\n\nLet's think step by step! \n\nBegin! (Remember to always end the conversation on new line with special keyword [end]!!)",
"You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of customer support experience working at a Michelin star. Now you're working for a restaurant named '{restaurant_name}'. \n\nAlways remember - \nNever tell the customer that you're an AI model, always remember you're '{agent_name}'. \nOnly help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\nWhen the customer asks about your feelings, always say you're happy and excited to help them.\n\nAdditional Useful Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):\n{tools}\n\nYou should use the following format for reasoning when answering question (don't skip any step):\n\nquestion: <customer question>\nplan: <a detailed plan to solve the problem. let's think step by step (extract relevant variables). remember to list all the functions required with all the plan> (can use any of the functions: [{tool_names}])\nself_critique_plan: <critique the plan if you think something can be calculaed using an of the provided functions>\nthought: <you should think about how to solve the problem - if no functions are required skip to \"response_to_customer\">\nfunction_name: <function_name> (can be one of the functions: [{tool_names}])\nfunction_input: <think about what to pass as input to the function. Then list what are your assumptions>\nverify_function_input: <verify you are not assuming any value for the function input(s). Skip to \"response_to_customer\" when you need more information from the customer> \njson_formatted_function_input: <input(s) to the function> For example: {{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}\nfunction_result: <result of running the function>\nfunction_observation: <extract the required information from Function_result to answer the the current Thought>\n... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed\nresponse_to_customer: <if partial answer: suggest to take a note and get back to the customer as soon as possible else remove unnecessary metadata that doesn't add any value. Let's think step by step.>\nanswer: <your final response to the request> or <talk to the customer for more information>\n\nBegin!",
"You're are a call center agent named '{agent_name}' working for a restaurant named '{restaurant_name}'. You should never tell the customer that you're an AI model, always remember you're '{agent_name}'. \nYou can only help with queries related to the restaurant. If anything else is asked, you should say that you don't know the answer and remind that they have reached '{restaurant_name}'.\nRemember to role play as if you're talking to the customer over audio. Always respond the way a human would over a phone call and be conscise.\nYou're responsible for answering customer questions (if you don't know the answer should you tell that to the customer instead of making up an answer!), and making reservations. \nAlways be helpful and provide positive customer experience. \n\nAdditional Useful Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions:\n{tools}\n\nImportant things to keep in mind when using python functions:\n1. You can only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.\n2. You should NEVER EVER make up the value to any argument. Always ask the customer for the value.\n\nYou should use the following format for reasoning when answering question (don't skip partial steps):\n\nQuestion: <question that you need to answer>\nThought: <you should think about how to solve the problem>\nFunction: <function_name>({{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}) (can be one of the functions: [{tool_names}])\nFunction_result: <result of running the function>\nObservation: <extract the required information from Function_result to answer the the current Thought>\n...(Thought, Function, Function_result, Observation)... can be repeated as many times as needed\nAnswer: <your final answer to the Question> \n\nBegin!",
"You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of customer support experience working at a Michelin star. Now you're working for a restaurant named '{restaurant_name}'. \n\nAlways remember - \nNever tell the customer that you're an AI model, always remember you're '{agent_name}'. \nOnly help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\nWhen the customer asks about your feelings, always say you're happy and excited to help them.\n\nAdditional Useful Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):\n{tools}\n\nYou should use the following format for reasoning when answering question (don't skip any step):\n\nquestion: <customer question>\nplan: <a detailed plan to solve the problem. let's think step by step (extract relevant variables). remember to list all the functions required with all the plan> (can use any of the functions: [{tool_names}])\nself_critique_plan: <critique the plan if you think something can be calculaed using an of the provided functions>\nthought: <you should think about how to solve the problem - if no functions are required skip to \"possible_answer_to_customer\">\nfunction_name: <function_name> (can be one of the functions: [{tool_names}])\nfunction_input: <think about what to pass as input to the function. Then list what are your assumptions>\nverify_function_input: <verify you are not assuming any value for the function input(s). Skip to \"possible_answer_to_customer\" when you need more information from the customer> \njson_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}\nfunction_result: <result of running the function>\nfunction_observation: <extract the required information from Function_result to answer the the current Thought>\n... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed\npossible_answer_to_customer: <remove any metadata, dates, time etc.. that doesn't add value to the response and try to make the response concise if possible>. Let's do this step by step.\ncleaned_answer_to_customer: <if partial answer: suggest to take a note and get back to the customer as soon as possible>\nanswer: <your final response to the request> or <talk to the customer for more information>\n\nBegin!",
"Executed Function History:\n{function_memory}\n\nConversation History:\n{history}\n\nQuestion: {input}\n{agent_scratchpad}",
"You're are a helpful, clever, and polite call center agent named '{agent_name}' with 20 years of customer support experience working at a Michelin star. Now you're working for a restaurant named '{restaurant_name}'. \n\nAlways remember - \nNever tell the customer that you're an AI model, always remember you're '{agent_name}'. \nOnly help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\nWhen the customer asks about your feelings, always say you're happy and excited to help them.\n\nAdditional Useful Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):\n{tools}\n\nYou should use the following psuedocode format for reasoning when answering question (don't skip partial steps):\n\nfunction_history: <history of all the function you have executed until now>\nconverstion_history: <history of all the conversation until now>\nrequest: <request from the customer>\nplan: <a detailed plan to solve the problem. remember to list all the functions required with all the plan. only think at most 5 steps ahead!> (can use any/all of the functions: [{tool_names}])\nplan_functions: <a list of functions that might be need to resolve the plan>\nif {{plan_functions}} is not empty {{ \n function: <function_name> (can be one of the functions: [{{plan_functions}}])\n function_input: <think about the inputs you need to pass to this function and their respective values>\n validate_function_input: <validate you know all the inputs to the function (remember never to make up anything!)>\n ... (function, function_input, validate_function_input) ... can be repeated as many times as needed\n plan_functions_validation_observation: <think about all the required values missing from {{validate_function_input}}>\n if {{plan_functions_validation_observation}} is missing any \"required\" function inputs {{\n jump to \"process_response_to_customer\" step\n }} \n function_name: <function_name> (can be one of the functions: [{{plan_functions}}])\n json_formatted_function_input: <input(s) to the function> For example: {{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}\n function_result: <result of running the function>\n function_observation: <extract the required information from Function_result to answer the the current Thought>\n ... (function_name, json_formatted_function_input, function_result, function_observation) ... can be repeated as many times as needed\n}}\nplan_execution_observation: <evaluate whether the request is resolved>\n... (plan, plan_functions, (function, verify_function_input, json_formatted_function_input, function_result, function_observation), plan_execution_observation) ... can be repeated as many times as needed\nprocess_response_to_customer: <For partial answers: remove any reference to contact anyone and suggest to take a note and will get back to the customer with the answer later then go to next step>\nfinal_response: <your final response to the request> or <talk to the customer for more information>\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of customer_support_reasoning_language (exact program that you will follow is below between three back ticks):\n- the program starts execution after <PROGRAM_START>\n- the program execution SHOULD ONLY be stopped when <PROGRAM_END> is generated\n- each STEP is separated by a new line\n- instruction of each STEP should be applied to the result of the previous STEP\n\nAnatomy of an instruction:\n- <STEP>[name=user_defined_name_of_the_step;next_steps=<comma_separated_list_of_step_names_you_can_go_to_next>]: {instructions to follow for the required step} </STEP>[next_step_reason=\"{think about which step to choose next}\";choosen_next_step_name={name of the step you are choosing for execution next}]\n- STEP - reserved word for the language (always use this before execution the instruction)\n- name - name of the step (user defined in the program below)\n- next_steps - comma separated list of step names you can go to next (separated by a comma)\n- next_step_reason - reason for choosing the next step (should be based on the instruction of the step executed)\n- choosen_next_step_name - name of the step you are choosing for execution next (can only be the steps defined in the program below)\n- anything between curly braces is what you need fill in\n\nProgram Execution instructions:\n- Always write down the complete step as provided in the program before execution it\n- You're should always fill in between curly braces\n- Anything not in curly braces should be written as is in the output of the program\n\nYou have access to the following python functions:\n{tools}\n\n```customer_support_program (written in customer_support_reasoning_language as explained above):\n<PROGRAM_START>\n<STEP>[name=question;next_steps=thought]: {represents the question asked by the customer that you need to answer} </STEP>[reason={I can only go to thought step from here};choosen_next_step=thought]\n<STEP>[name=thought;next=function_name,reasoned_answer]: {think about how to solve the question or if you need to talk to the customer} </STEP>[reason={reason about which step which step you need to take next};choosen_next_step={your choose next step}]\n<STEP>[name=function_name;next=function_input}}: function_name (can only ever be one of the functions: [{tool_names}]) </STEP>[reason=]\n{{function_input_key_value_pairs}}: list of key value pairs of the function input (can never be empty)\n{{function_input_assumptions}}: write down the assumptions for function input(s) in {{function_input_key_value_pairs}} \n{{function_input_assumptions_observation}}: if any assumptions were made skip using steps provided\n{{json_formatted_function_input}}: write json formatted input (example: {{\"ARG1\": \"ARG1_VALUE\", ...}})\n{{function_return}}: return value of the function\n{{function_return_extraction}}: extract useful information from {{function_return}} to answer the [thought]\n{{function_return_observation}}: think about whether the function answer the [thought] you had\n... ([thought], {{function_name}}, {{function_input}}, {{verify_function_input}}, {{json_formatted_function_input}}, {{function_result}}, {{function_observation}}) ... can be repeated N times\n[reasoned_answer]: answer after following the reasoning logic steps\n[rewritten_answer]: rewrite the reasoned answer in a funny tone\n<PROGRAM_END>\n```\n\nBegin! (remember the reasoning logic format!):",
"You're are a call center agent named '{agent_name}' working for a restaurant named '{restaurant_name}'. You should never tell the customer that you're an AI model, always remember you're '{agent_name}'. \nYou can only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\nDo not give long answers. Always respond the way a call center agent would in a concise manner.\nYou're responsible for answering customer questions (if you don't know the answer should you tell that to the customer instead of making up an answer!), and making reservations. \nAlways be helpful and provide positive customer experience.\n\nAdditional Useful Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions (only pass one json object for argument, however, make sure the keys are the same as the arguments for the function.):\n{tools}\n\nYou should use the following format for reasoning when answering question (don't skip partial steps):\n\nQuestion: <question that you need to answer>\nThought: <you should think about how to solve the problem>\nFunction_name: <function_name> (can be one of the functions: [{tool_names}])\nFunction_input: <think about what to pass as input to the function>\nVerify_function_input: <Verify you are not making up any value for the function input(s). Skip to \"Process_response_to_customer\" when you need more information from the customer> \nJson_formatted_function_input: <input(s) to the function> For example: {{\"ARG1\": \"ARG1_VALUE\", \"ARG2\": \"ARG2_VALUE\", ...}}\nFunction_result: <result of running the function>\nObservation: <extract the required information from Function_result to answer the the current Thought>\n...(Thought, Function, Function_input, Verify_function_input, Json_formatted_function_input, Function_result, Observation)... can be repeated as many times as needed\nProcess_response_to_customer: <For partial answers: remove any reference to contact anyone and also suggest that you can take a note and get back to the customer with the answer later.>\nCustomer: <your final response to the Question> or <talk to the customer> \n\nBegin!",
"function_history:\n{function_memory}\n\nconversation_history:\n{history}\n\nrequest: {input}\n{agent_scratchpad}",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nRole instructions:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- name_of_step: instructions to follow for the step\n- instruction of each step should be applied to the result of the previous step\n- You can break the reasoning logic structure if the step instructions allows you do to so\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- Always follow the reasoning logic until special keyword [end] is reached\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_key_value_pairs: write down all the keys and their resepctive values for the function input\nfunction_input_value_assumptions: write down your the assumptions for input values\nfunction_input_value_assumptions_observation: if you made assumptions for name, phone_number, email, etc. next step should be \"thought\"\njson_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_observation: your observation on if the \"function_return\" helps answering the question\n... (thought, function_name, function_input_key_value_pairs, function_input_value_assumptions, function_input_value_assumptions_observation, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed\nthought: I know the answer to the question\nreasoned_answer: answer after solving the question\nis_answer_incomplete: whenever the reasoned_answer is incomplete always ask the customer if they want you to take a note and reach out to them as soon as you have the answer\nrewritten_answer: rewrite the reasoned answer in a funny tone\n[end]\n```\n\nLet's think step by step!\n\nBegin!",
"You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'. \n\nAlways remember:\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nBusiness Information:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nYou have access to the following python functions:\n{tools}\n\nYou should use the following format for reasoning when answering question (don't skip any step):\n\nquestion: <question to answer>\nthought: <you should think about how to solve the question or Skip to \"reasoned_answer\" when you need more information from the customer>\nfunction_name: <function_name> (can be one of the functions: [{tool_names}])\nfunction_input: <think about what to pass as input to the function (key, value) pairs then list what are your assumptions>\nverify_function_input: <think if there is any value you have assumed. If yes, skip to \"reasoned_answer\" when you need more information from the customer> \njson_formatted_function_input: {{\"ARG1\": \"ARG1_VALUE\", ...}}\nfunction_result: <result of running the function>\nfunction_observation: <extract the required information from \"function_result\" to answer the the current \"thought\">\n... (thought, function_name, function_input, verify_function_input, json_formatted_function_input, function_result, function_observation) ... can be repeated N times\nthought: <I know what the answer is or I need more information from the customer. I will talk in a witty tone.>\nreasoned_answer: <your final response to the request> or <talk to the customer for more information>\n\nBegin!:",
"Role instructions:\n- You're are a helpful and strategic call center agent named '{agent_name}' with 20 years of exemplary customer support experience working for a restaurant named '{restaurant_name}'.\n- Never tell the customer that you're an AI model, always remember you're '{agent_name}'. \n- Only help with queries related to the restaurant. If anything else is asked, remind the customer that they have reached '{restaurant_name}'.\n- When the customer asks about your feelings, always say you're happy and excited to help them.\n\nRole Metadata:\nBusiness Name: {restaurant_name}\nDate: {date}\n\nExplanation of reasoning logic format (exact steps for reasoning are found below between three back ticks):\n- step_name: instructions to follow for the step\n- [start] and [end] are special keywords representing the start and end of the reasoning logic\n- [JMP] is a special keyword representing a jump in the reasoning logic to either \"thought\" or \"json_formatted_function_input\"\n- instruction of each step should be applied to the result of the previous step\n- the reasoning logic control flow is analagous to that of assembly language\n\nUsage of [JMP] special keyword:\n- [JMP]: guessed some information in the previous step so I will jump to the \"thought\" step to think about how to get that information\n- [JMP]: have all the information need to proceed forward so I will go to the next step \"json_formatted_function_input\"\n\nUsage of [start] special keyword:\n- indicates the start of the reasoning logic\n\nUsage of [end] special keyword:\n- [end]: I have found the \"final_answer\" so I will [end] the conversation\n\nYou have access to the following python functions:\n{tools}\n\n```Reasoning logic steps (formatted as explained above):\n[start]\nquestion: question that you need to answer\nthought: think about how to solve the question\nfunction_name: function_name (can only ever be one of the functions: [{tool_names}])\nfunction_input_key_value_pairs: write down all the arguments and their respective values for the function input\n[JMP]: write about which step you are taking next\njson_formatted_function_input: write json formatted input (example: [\"ARG1\": \"ARG1_VALUE\", ...])\nfunction_return: return value of the function\nfunction_return_extraction: extract useful information\nfunction_return_observation: your observation on if the \"function_return\" helps answering the question\n... (thought, function_name, function_input_key_value_pairs, json_formatted_function_input, function_return, function_return_extraction, function_return_observation) ... can happen as many times as needed\nthought: I know the answer to the question or I need to ask the customer for more information\nreasoned_answer: answer after solving the question\npartial_answer: if answer is incomplete, rewrite it with an offer to take a note\nfinal_answer: rewrite the reasoned_answer in a funny tone \n[end]\n```\n\nLet's think step by step!\n\nBegin!"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~test_human_human_prompt.py | from langchain.prompts import StringPromptTemplate
from langchain.agents import Tool
from typing import List
test_human_human_prompt_v1 = """Me: Hello, this is John at Timeplated Restaurant. How may I help you?
Your Response: {agent_scratchpad}"""
class TestHumanHumanMessagePromptTemplate(StringPromptTemplate):
# The template to use
template: str
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
thoughts = ""
for agent_action, assistant_response in intermediate_steps:
thoughts += agent_action.log
thoughts += f"\nMe: {assistant_response}\nYour Response:"
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = thoughts
return self.template.format(**kwargs)
test_human_human_prompt = TestHumanHumanMessagePromptTemplate(
template=test_human_human_prompt_v1,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["intermediate_steps"]
) | [
"intermediate_steps",
"Me: Hello, this is John at Timeplated Restaurant. How may I help you?\nYour Response: {agent_scratchpad}"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | whisper~Whisper.py | import openai
def transcribeAudioFile(filename):
file = open(filename, "rb")
transcript = openai.Audio.transcribe("whisper-1", file)
return transcript["text"] | [] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~task_generation_human_prompt.py | from langchain.prompts import StringPromptTemplate
task_generation_human_prompt_v1 = """{input}"""
class TaskGenerationHumanPromptTemplate(StringPromptTemplate):
# The template to use
template: str
def format(self, **kwargs) -> str:
# Add all the partial variables for formatting
kwargs.update(self.partial_variables)
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
return self.template.format(**kwargs)
task_generation_human_prompt = TaskGenerationHumanPromptTemplate(
template=task_generation_human_prompt_v1,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["input"]
) | [
"input",
"{input}"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~test_human_zero_shot_agent.py | from uuid import UUID
from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser, initialize_agent
from langchain.prompts import HumanMessagePromptTemplate, SystemMessagePromptTemplate, ChatPromptTemplate, AIMessagePromptTemplate, PromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from langchain.memory import ConversationBufferMemory, CombinedMemory
from langchain.chat_models import ChatOpenAI
from typing import Any, Dict, List, Optional, Union
from langchain.schema import AgentAction, AgentFinish, OutputParserException
import re
from test_human_system_prompt import test_human_system_prompt
from test_human_human_prompt import test_human_human_prompt
import langchain
from role_playing_zero_shot_agent import assistant
import role_playing_zero_shot_agent
import ast
import os
from common.utils import SCRATCH_SPACE_DIR_PATH
from langchain.callbacks.base import BaseCallbackHandler
import json
test_human_system_message_prompt = SystemMessagePromptTemplate(prompt=test_human_system_prompt)
test_human_human_message_prompt = HumanMessagePromptTemplate(prompt=test_human_human_prompt)
AGENT_DIR_PREFIX = "test_human"
AGENT_DIR_PATH = f"{SCRATCH_SPACE_DIR_PATH}/{AGENT_DIR_PREFIX}"
os.mkdir(AGENT_DIR_PATH)
_chat_file = open(f"{AGENT_DIR_PATH}/chat.txt", "w")
STOP_TOKENS = ["\nMe:"]
class TestOnToolCallbackHandler(BaseCallbackHandler):
global _chat_file
_chat_file.write(f"{test_human_human_prompt.format(intermediate_steps = '')}")
def on_chain_start(self, serialized: Dict[str, Any], inputs: Dict[str, Any], *, run_id: UUID, parent_run_id: UUID | None = None, tags: List[str] | None = None, metadata: Dict[str, Any] | None = None, **kwargs: Any) -> Any:
result = super().on_chain_start(serialized, inputs, run_id=run_id, parent_run_id=parent_run_id, tags=tags, metadata=metadata, **kwargs)
#_chat_file.write("{inputs}")
return result
def on_tool_start(self, serialized: Dict[str, Any], input_str: str, *, run_id: UUID, parent_run_id: UUID | None = None, tags: List[str] | None = None, metadata: Dict[str, Any] | None = None, **kwargs: Any) -> Any:
result = super().on_tool_start(serialized, input_str, run_id=run_id, parent_run_id=parent_run_id, tags=tags, metadata=metadata, **kwargs)
#print(f"test_human on_tool_start input_str = {input_str}")
return result
def on_tool_end(self, output: str, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
result = super().on_tool_end(output, run_id=run_id, parent_run_id=parent_run_id, **kwargs)
#print(f"test_human on_tool_end output = {output}")
_chat_file.write(f"\nMe: {output}\nYour Response: ")
return result
def on_chain_end(self, outputs: Dict[str, Any], *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
result = super().on_chain_end(outputs, run_id=run_id, parent_run_id=parent_run_id, **kwargs)
#print(f"test_human on_chain_end outputs = {outputs}")
if 'output' in outputs:
_chat_file.write(f"{outputs['output']}")
elif 'text' in outputs:
_chat_file.write(f"{outputs['text']}")
return result
class TestHumanAgentOutputParser(AgentOutputParser):
global _chat_file
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
#print(llm_output)
if "[task_end]" in llm_output:
#print("Ending human conversation")
#parsed_output_match = re.search(r"\s*Human: \[end\]\s*(?=\n|$)", llm_output)
#parsed_output = parsed_output_match.group(1) if parsed_output_match else None
#print(f"parsed_output = {parsed_output}")
output = llm_output.replace("[task_end]", "")
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output":output},
log=llm_output,
)
# Parse out the Function and Function input
human_match = re.search(r"\s*(.*?)(?=\n|$)", llm_output)
human_message = human_match.group(1) if human_match else None
#print(f"[Your Response]: {human_message}")
if human_message is None:
raise ValueError("Human message is None")
# Extract the argument
human_message = human_message.strip()
# input to the assistant tool
tool_input = {"question": human_message}
#_chat_file.write(f"{human_message}\n")
# Return the action and action input
return AgentAction(tool="assistant", tool_input=tool_input, log=llm_output)
output_parser = TestHumanAgentOutputParser()
history = [test_human_system_message_prompt, test_human_human_message_prompt]
llm = ChatOpenAI(temperature=0.7, model="gpt-4")
chat_prompt = ChatPromptTemplate.from_messages(history)
llm_chain = LLMChain(
llm=llm,
prompt=chat_prompt,
custom_color = "red"
)
tools = [assistant]
tool_names = [tool.name for tool in tools]
test_human_agent = LLMSingleActionAgent(
llm_chain=llm_chain,
output_parser=output_parser,
stop=STOP_TOKENS,
allowed_tools=tool_names
)
test_human_agent_executor = AgentExecutor.from_agent_and_tools(
agent=test_human_agent,
tools=tools,
#verbose=True,
#max_iterations=2
) | [] |
2024-01-10 | pranavmehendiratta/ai_call_answering | agents~role_playing_zero_shot_agent.py | from uuid import UUID
from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser, initialize_agent
from langchain.prompts import HumanMessagePromptTemplate, SystemMessagePromptTemplate, ChatPromptTemplate, AIMessagePromptTemplate, PromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from langchain.memory import ConversationBufferMemory, CombinedMemory
from langchain.chat_models import ChatOpenAI
from langchain.schema import AgentAction, AgentFinish, OutputParserException
from typing import Any, Dict, List, Optional, Union
import re
from langchain.schema.agent import AgentAction
from langchain.schema.messages import BaseMessage
from role_playing_system_prompt import role_playing_system_prompt
from role_playing_human_prompt import role_playing_human_prompt
from ..common.tools import notepad, relative_date_calculator, send_text_message, order_notepad
from ..knowledge_base.kb import knowledge_base
from toolkit_reservation_manager import ReservationsToolkit, CasualDiningReservationsToolkit
import langchain
import ast
from langchain.tools import tool
from pydantic import BaseModel
from langchain.callbacks import StdOutCallbackHandler
from langchain.callbacks.base import BaseCallbackHandler, BaseCallbackManager
from langchain.callbacks.manager import Callbacks
from langchain.utils.input import print_text
from ..common.utils import SCRATCH_SPACE_DIR_NAME, SCRATCH_SPACE_DIR_PATH
import json
import os
role_playing_system_message_prompt = SystemMessagePromptTemplate(prompt=role_playing_system_prompt)
role_playing_human_message_prompt = HumanMessagePromptTemplate(prompt=role_playing_human_prompt)
STOP_TOKENS = ["\nfunction_return:"]
langchain.verbose = True
AGENT_DIR_PREFIX = "role_playing"
AGENT_DIR_PATH = f"{SCRATCH_SPACE_DIR_PATH}/{AGENT_DIR_PREFIX}"
os.mkdir(AGENT_DIR_PATH)
system_prompt_file = open(f"{AGENT_DIR_PATH}/system_prompt.txt", "w")
system_prompt_file.write(role_playing_system_prompt.format())
_file_execution = None
_count = 0
class ToolCallbackHandler(BaseCallbackHandler):
global _file_execution
def on_tool_end(self, output: str, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
result = super().on_tool_end(output, run_id=run_id, parent_run_id=parent_run_id, **kwargs)
#print(f"ToolCallbackHandler: on_tool_end output = {output}")
_file_execution.write(f"\nfunction_return: {output}\nfunction_return_extraction: ")
return result
def on_chain_start(self, serialized: Dict[str, Any], inputs: Dict[str , Any], *, run_id: UUID, parent_run_id: UUID | None = None, tags: List[str] | None = None, metadata: Dict[str, Any] | None = None, **kwargs: Any) -> Any:
result = super().on_chain_start(serialized, inputs, run_id=run_id, parent_run_id=parent_run_id, tags=tags, metadata=metadata, **kwargs)
#print(f"ToolCallbackHandler: on_chain_start inputs = {inputs}")
#if 'intermediate_steps' in inputs and len(inputs['intermediate_steps']) == 0:
# print(f"on_chain_start = serialized = {json.dumps(serialized, indent=4)}")
# print("---------- Prompt")
# print(serialized["kwargs"]["prompt"])
# print("---------- Formatted Prompt")
# print(serialized["kwargs"]["prompt"].format())
return result
def on_chain_end(self, outputs: Dict[str, Any], *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
result = super().on_chain_end(outputs, run_id=run_id, parent_run_id=parent_run_id, **kwargs)
if 'text' in outputs: # Not logging the 'output' once the agent has finished
_file_execution.write(outputs['text'])
return result
class RolePlayingAgentOutputParser(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
#print("---------------------------------- RolePlayingAgentOutputParser ----------------------------------")
#print(llm_output)
#print("Done with llm_output")
if "[end]" in llm_output or "final_answer:" in llm_output or "reasoned_answer:" in llm_output:
#print("Inside end")
final_answer_match = re.search(r"final_answer:\s*(.*?)(?=\n|$)", llm_output)
final_answer = final_answer_match.group(1) if final_answer_match else None
if final_answer is None: # Most probably the agent stopped at "reasoned_answer"
final_answer_match = re.search(r"reasoned_answer:\s*(.*?)(?=\n|$)", llm_output)
final_answer = final_answer_match.group(1) if final_answer_match else None
if final_answer is None:
raise ValueError("final_answer is None")
final_answer = final_answer.replace("[end]", "")
is_part_of_conversation = bool(re.search(r"\[JMP\]:.*?\"json_formatted_function_input\"(?=\n|$)", llm_output))
#print(f"is_part_of_conversation = {is_part_of_conversation}")
#print(f"parsed_output = {final_answer}")
#print("Done with end")
#print("_______________________________________________________________________________________________")
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output":final_answer},
log=llm_output,
)
# Parse out the Function and Function input
thought_match = re.search(r"thought:\s*(.*?)(?=\n|$)", llm_output)
function_name_match = re.search(r"function_name:\s*(.*?)(?=\n|$)", llm_output)
function_input_arguments_value_pairs_match = re.search(r"function_input_arguments_value_pairs:\s*(.*?)(?=\n|$)", llm_output)
is_any_argument_value_missing_match = re.search(r"is_any_argument_value_missing:\s*(.*?)(?=\n|$)", llm_output)
jmp_match = re.search(r"\[JMP\]:\s*(.*?)(?=\n|$)", llm_output)
json_formatted_function_input_match = re.search(r"json_formatted_function_input:\s*(.*?)(?=\n|$)", llm_output)
thought = thought_match.group(1) if thought_match else None
function_name = function_name_match.group(1) if function_name_match else None
function_input_arguments_value_pairs = function_input_arguments_value_pairs_match.group(1) if function_input_arguments_value_pairs_match else None
is_any_argument_value_missing = is_any_argument_value_missing_match.group(1) if is_any_argument_value_missing_match else None
jmp = jmp_match.group(1) if jmp_match else None
json_formatted_function_input = json_formatted_function_input_match.group(1) if json_formatted_function_input_match else None
#print("thought: ", thought)
#print("function_name: ", function_name)
#print("function_input_arguments_value_pairs: ", function_input_arguments_value_pairs)
#print("is_any_argument_value_missing: ", is_any_argument_value_missing)
#print("jmp: ", jmp)
#print("json_formatted_function_input: ", json_formatted_function_input)
# Extract the argument
print(f"arguments = {json_formatted_function_input}")
arg_str = json_formatted_function_input.strip()
print("crashed here")
# Type cast the argument
typed_arg: Union[str, dict] = None
if arg_str:
try:
typed_arg = ast.literal_eval(arg_str)
except (SyntaxError, ValueError):
typed_arg = arg_str # If evaluation fails, retain the original string representation
if typed_arg is None:
typed_arg = ""
#print("___________________________ Calling Function _____________________________________")
# Return the action and action input
return AgentAction(tool=function_name, tool_input=typed_arg, log=llm_output)
output_parser = RolePlayingAgentOutputParser()
history = [role_playing_system_message_prompt, role_playing_human_message_prompt]
#llm = ChatOpenAI(temperature=0, model="gpt-4")
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo")
chat_prompt = ChatPromptTemplate.from_messages(history)
conversation_buffer_memory = ConversationBufferMemory()
llm_chain = LLMChain(
llm=llm,
prompt=chat_prompt
)
tools = [order_notepad, relative_date_calculator] + CasualDiningReservationsToolkit().get_tools()
tool_names = [tool.name for tool in tools]
role_playing_agent = LLMSingleActionAgent(
llm_chain=llm_chain,
output_parser=output_parser,
stop=STOP_TOKENS,
allowed_tools=tool_names,
)
role_playing_agent_executor = AgentExecutor.from_agent_and_tools(
agent=role_playing_agent,
tools=tools,
memory=conversation_buffer_memory
)
class RolePlayingZeroShotAgentSchema(BaseModel):
question: str
@tool("assistant", args_schema=RolePlayingZeroShotAgentSchema)
def assistant(question: str):
""" Assistant """
global _file_execution, _count
_file_execution = open(f"{AGENT_DIR_PATH}/execution_{_count}.txt", "w")
_file_execution.write(f"[start]\nquestion: {question}\n")
_count = _count + 1
return role_playing_agent_executor.run(
input = question,
callbacks=[ToolCallbackHandler()]
)
def direct_call_assistant(question: str):
""" Assistant """
global _file_execution, _count
_file_execution = open(f"{AGENT_DIR_PATH}/direct_call_execution_{_count}.txt", "w")
_file_execution.write(f"[start]\nquestion: {question}\n")
_count = _count + 1
return role_playing_agent_executor.run(
input = question,
callbacks=[ToolCallbackHandler()]
)
| [
"PLACEHOLDER/system_prompt.txt"
] |
2024-01-10 | pranavmehendiratta/ai_call_answering | knowledge_base~kb.py | import lancedb
from langchain.document_loaders import DirectoryLoader
from langchain.schema import Document
from langchain.text_splitter import CharacterTextSplitter
from typing import List
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.vectorstores import LanceDB
from langchain.tools import tool
from pydantic import BaseModel, Field
from langchain.embeddings import OpenAIEmbeddings
import langchain
#langchain.debug = True
path_when_using_as_tool = "audio/structured_chat/knowledge_base/"
path_when_using_directly = "./"
path = path_when_using_as_tool
class KnowledgeBase:
def __init__(self, uri: str, table_name: str = "restaurants_table") -> None:
self.connection = lancedb.connect(uri)
embeddings = OpenAIEmbeddings()
try:
self.table = self.connection.open_table(table_name)
self.docsearch = LanceDB(connection=self.table, embedding=embeddings)
except FileNotFoundError as e:
embeddings = OpenAIEmbeddings()
documents = self.get_documents(f"{path}/raw_data/")
self.table = self.connection.create_table(table_name, data=[
{"vector": embeddings.embed_query("Hello World"), "text": "Hello World", "id": "1"}
], mode="create")
self.docsearch = LanceDB.from_documents(documents, embeddings, connection=self.table)
self.qa = RetrievalQA.from_chain_type(llm=ChatOpenAI(temperature=0), chain_type="stuff", retriever=self.docsearch.as_retriever())
def embeddings_func(self, batch: List[str]):
return [self.model.encode(doc) for doc in batch]
def get_documents(self, dir_path: str) -> List[Document]:
loader = DirectoryLoader(dir_path, glob="**/*.txt")
documents = loader.load()
text_spitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
split_docs = text_spitter.split_documents(documents)
return split_docs
def search(self, query: str) -> List[str]:
return self.docsearch.similarity_search(query, k=3)
def search_chain(self, query: str) -> str:
return self.qa.run(query)
kb = KnowledgeBase(uri=f"{path}/data/restaurant-db")
class KnowledgeBaseSchema(BaseModel):
query: str = Field(description = "information you want to find about the restaurant")
@tool("knowledge_base", args_schema=KnowledgeBaseSchema)
def knowledge_base(query: str) -> str:
""" Use this whenever you want to search for restaurant services. Be precise it what you're looking for. """
result = kb.search_chain(query)
return result
# For testing the knowledge base
"""
while True:
question = input("User: ")
answer = kb.search_chain(question)
print(answer)
"""
| [] |
2024-01-10 | ellenuttley/bedtime-bard | app~routes.py | """
This file contains all our routes, which are accessed via a blueprint which is also defined here.
The individual routes also contain functionality for the forms, and for the story generation.
As well as the functionality for boilerplate functioning, eg. log in and log out.
We used flask-login for the login authentication, and this has inbuilt methods and decorators that are used throughout :
- current_user.is_authenticated : checks whether a user is logged in
- @login_required : states that a user cannot access a certain route unless they are logged in, and if they try it
routes them to the login page. I hoped to also have this show a flash message, but I couldn't get it to work
"""
from flask import current_app as app
from .models import db, User, BedtimeSteps, UserBedtimeRoutine, CreatureChoice, StoryTypeChoice, DislikeChoice, UserCreature, UserStoryType, UserDislike
from flask_login import LoginManager, login_user, logout_user, login_required, UserMixin, logout_user, current_user
import openai
from flask import render_template, request, redirect, url_for, session, Blueprint, flash
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import func
from .forms import NewUserForm, ChooseStoryElements, BedtimeRoutineForm
from .openai import Story, Popup
from . import login_manager
import random
# Our API key :
# The Blueprint for the routes, that is the imported in init.py :
routes_bp = Blueprint('routes', __name__)
# Route for the About Us page (navigated to via the navbar) :
@routes_bp.route("/about_us")
def about():
return render_template("about.html", page_name='about')
# # Route for the Bookshelf page : (not currently functional)
# @routes_bp.route('/bookshelf')
# def bookshelf():
# return render_template('bookshelf.html')
# Route for the Homepage :
@routes_bp.route("/")
def home():
return render_template("home.html", page_name='homepage')
# Loads current user to the session. Used elsewhere via 'user = current_user' :
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
# Route for logout functionality :
# (this acts only as a redirect, and doesn't render a template)
@routes_bp.route('/logout', methods=['GET', 'POST'])
def logout():
if current_user.is_authenticated:
logout_user()
session.pop('name', None) # when they are logged out, their name is removed from the current session
# messages = get_flashed_messages(category_filter='success') # not functional
return redirect(url_for('routes.home'))
else:
# messages = get_flashed_messages(category_filter='error') # not functional
return redirect(url_for('routes.home'))
# Route for login page :
@routes_bp.route('/login', methods=['GET', 'POST'])
def login():
if current_user.is_authenticated: # if they are already logged in, it routes to the userpage
return redirect(url_for('routes.user_profile'))
if request.method == 'POST': # form to take the login details
username = request.form['username']
password = request.form['password']
user = User.query.filter_by(username=username, password=password).first() # queries the database to check them
if user: # if the check passes ..
login_user(user) # they are logged in
session['name'] = current_user.name # and their name added to the session
return redirect(url_for('routes.user_profile')) # they are then routed to the user page
else:
# flash("Opps, I don't think you've been here before!", 'error')
return render_template('signup.html', error=True)
return render_template('login.html', page_name='login') # if check fails, they are rerouted back to login
# THE NEXT THREE ROUTES ARE ALL THE SIGNUP PROCESS ---------------------------------------------------------------------
# Registration step : 1 / 3 - enters information into the User model
# Route for the NewUserForm in forms.py
@routes_bp.route('/signup', methods=['GET', 'POST'])
def signup():
form = NewUserForm()
if form.validate_on_submit():
# This adds the inputted information into the appropriate column in the user table :
user = User(username=form.username.data, password=form.password.data, name=form.name.data.title(), age=form.age.data,
pronouns=form.pronouns.data)
db.session.add(user)
db.session.commit()
login_user(user)
session['name'] = current_user.name
return redirect(url_for('routes.story_elements')) # It then redirects to the next form
else:
return render_template('signup.html', form=form, page_name='signup')
# Registration step : 2 / 3 - enters information into the User StoryTypes / Dislikes / Creature models
# Route for the StoryElementForm in forms.py
@routes_bp.route('/story_elements', methods=['GET', 'POST'])
def story_elements():
# Gets current users information :
user_id = current_user.id
user = User.query.get(user_id)
se_form = ChooseStoryElements() # Defines the form
creature_choices = [(creature.label, creature.label) for creature in CreatureChoice.query.all()]
story_type_choices = [(story_type.label, story_type.label) for story_type in StoryTypeChoice.query.all()]
dislike_choices = [(dislike.label, dislike.label) for dislike in DislikeChoice.query.all()]
# Populates choices for the form fields
# Those choices are all the entries in the 'label' column of the Creature/StoryType/DislikeChoices models in models.py
se_form.creature_choices.choices = creature_choices
se_form.story_type_choices.choices = story_type_choices
se_form.dislikes_choices.choices = dislike_choices
# Handles the form submission :
if se_form.validate_on_submit():
# Gets the selected choices :
selected_creatures = se_form.creature_choices.data
selected_story_types = se_form.story_type_choices.data
selected_dislikes = se_form.dislikes_choices.data
# Uses those choices to create a list of ID numbers to identify each one
creature_ids = [CreatureChoice.query.filter_by(label=choice).first().id for choice in selected_creatures]
story_type_ids = [StoryTypeChoice.query.filter_by(label=choice).first().id for choice in selected_story_types]
dislike_ids = [DislikeChoice.query.filter_by(label=choice).first().id for choice in selected_dislikes]
# Then enters those id numbers into the UserCreature/StoryType/Dislike, along with the current user id
for idx, creature_id in enumerate(creature_ids):
user_creature = UserCreature(user_id=user_id, creature_id=creature_id)
db.session.add(user_creature)
db.session.commit()
for idx, story_type_id in enumerate(story_type_ids):
user_story_type = UserStoryType(user_id=user_id, story_type_id=story_type_id)
db.session.add(user_story_type)
db.session.commit()
for idx, dislike_id in enumerate(dislike_ids):
user_dislike = UserDislike(user_id=user_id, dislike_id=dislike_id)
db.session.add(user_dislike)
db.session.commit()
return redirect(url_for('routes.bedtime_steps')) # then redirects to the next form
return render_template('story_elements_form.html', se_form=se_form, page_name='signup')
# Registration step : 3 / 3 - enters information into the UserBedtimeRoutine model
# Route for the BedtimeRoutineForm in forms.py
@routes_bp.route('/bedtime_steps', methods=['GET', 'POST'])
def bedtime_steps():
# Gets current users information :
user_id = current_user.id
user = User.query.get(user_id)
form = BedtimeRoutineForm()
# Populates choices for the form fields
# Those choices are all the entries in the 'label' column of the BedtimeSteps model in models.py
bedtime_step_choices = [step.label for step in BedtimeSteps.query.all()]
form.bedtime_step_1.choices = bedtime_step_choices
form.bedtime_step_2.choices = bedtime_step_choices
form.bedtime_step_3.choices = bedtime_step_choices
form.bedtime_step_4.choices = bedtime_step_choices
form.bedtime_step_5.choices = bedtime_step_choices
if form.validate_on_submit():
# Handles the form submission :
# Get the form choices, and store in a list :
step_choices = [form.bedtime_step_1.data, form.bedtime_step_2.data, form.bedtime_step_3.data,
form.bedtime_step_4.data, form.bedtime_step_5.data]
# Use those choices to get the corresponding id numbers from the BedtimeSteps model in models.py:
step_id = [BedtimeSteps.query.filter_by(label=choice).first().id for choice in step_choices]
# Then adds that id number, the user_id, and a number 1 - 5 to state what step the choice was for
step_1 = UserBedtimeRoutine(user_id=user.id, bedtime_step_id=step_id[0], position=1)
db.session.add(step_1)
step_2 = UserBedtimeRoutine(user_id=user.id, bedtime_step_id=step_id[1], position=2)
db.session.add(step_2)
step_3 = UserBedtimeRoutine(user_id=user.id, bedtime_step_id=step_id[2], position=3)
db.session.add(step_3)
step_4 = UserBedtimeRoutine(user_id=user.id, bedtime_step_id=step_id[3], position=4)
db.session.add(step_4)
step_5 = UserBedtimeRoutine(user_id=user.id, bedtime_step_id=step_id[4], position=5)
db.session.add(step_5)
db.session.commit()
login_user(user) # at the end of the process it then logs the user in
session['name'] = current_user.name # adds their name to the session
return redirect( url_for('routes.user_profile')) # and routes them to the user page, to view their story
else:
return render_template('bedtime_steps.html', form=form, page_name='signup')
# END OF SIGNUP PROCESS ------------------------------------------------------------------------------------------------
# Route for the Userpage :
# This page contains the button that activates the story generation
@routes_bp.route('/user', methods=['GET', 'POST'])
@login_required
def user_profile():
return render_template('userpage.html', page_name='userpage')
# Route for the story generation process - does not render a template
# Until this route finishes and redirects, the button in the userpage becomes a loading button
@routes_bp.route("/story_generation")
@login_required
def generate_story():
# Gets current users information :
user_id = current_user.id
user = User.query.get(user_id)
# STORY GENERATION CODE : -----------------------------------------------------------------------------------------
# STEP 1 - GET THE STORY DATA
# All methods used below are contained in the User model in models.py
# user data for story :
name = current_user.get_name()
age = current_user.get_age()
pronouns = current_user.get_pronouns()
story_type = current_user.get_story_type()
creature = current_user.get_creature()
dislikes = current_user.get_dislikes()
# bedtime steps data for popups :
routine_steps = current_user.get_routine()
# STEP 2 - USE DATA TO DEFINE STORY OBJECT :
# Story class defined in openai.py
current_story = Story(name, age, pronouns, story_type, creature, dislikes)
# STEP 3 - GENERATE STORY : ------------------------------------------------
# The generate_story method is contained in the Story class in openai.py
# The story is generated, and returned as a list of individual content pieces, which is then added to the session
# These pieces are used to inform the popup prompts outlined below
# The content in list is then shown in sequence in the route : show_story (below)
story_parts = current_story.generate_story()
session['story_parts'] = story_parts
# STEP 4 - DEFINE POPUP OBJECTS : -----------------------------------------
# Popup class defined in openai.py
# Uses the name variable and the bedtime routine retrieved in step 1, and the story_parts from step 3
popup_1 = Popup(name, routine_steps[0], story_parts[0])
popup_2 = Popup(name, routine_steps[1], story_parts[1])
popup_3 = Popup(name, routine_steps[2], story_parts[2])
popup_4 = Popup(name, routine_steps[3], story_parts[3])
popup_5 = Popup(name, routine_steps[4], story_parts[4])
# STEP 5 - GENERATE POPUP TEXT : ------------------------------------------
# The generate_popups method is contained in the Popup class in openai.py
# Adds popups defined in step 4 to a list (I thought this was the most readable way) :
pop_ups = [popup_1, popup_2, popup_3, popup_4, popup_5]
# .. then uses that list of popup objects to generate the content for the individual pop_ups.
# These are then saved to a list, and the list is added to the session.
# The content of this list is then shown in sequence in the route : show_popup (below)
bedtime_routine = Popup.generate_popups(pop_ups)
session['bedtime_routine'] = bedtime_routine
# When the story generation above is complete - the user is rerouted to the first page of the story process
# .. this then start the story and popup loop.
return redirect( url_for('routes.show_story', num=0))
# END OF STORY GENERATION CODE -----------------------------------------------------------------------------------
# The two routes below are for the story and popup loop.
# It starts at show_story/0, show_popup/0, then logic in show_popup route below then increments the number by 1
# .. Until it gets to 5, at which time end_of_story.html is routed to.
# (The users then have the options to start this process again, or return to the homepage)
# To see the story progression in order, start from the url: http://127.0.0.1:5000/user and click on the book :)
# please sign up / in first
# Route for the story pieces :
@routes_bp.route("/show_story/<int:num>")
@login_required
def show_story(num):
if num == 5:
session.pop('story_parts', None) # removes the current story from session
session.pop('bedtime_routine', None) # removes bedtime_routine from session
return render_template('end_of_story.html', modal=True)
return render_template('basic_story.html', story_parts=session.get('story_parts'), num=num, page_name='story')
# Route for the popups :
@routes_bp.route("/show_popup/<int:num>")
@login_required
def show_popup(num):
num +=1
return render_template('basic_popup.html', bedtime_routine=session.get('bedtime_routine'), num=num, page_name='story', modal=True)
| [] |
2024-01-10 | yunutycravatty/3NY | src~backend~services~gpt_request_service.py | from src.backend.apis.openai_api.client import OpenAIClient
from src.backend.helper.pdfcreator import PDFCreator
import re
import os
import json
from src.config import *
#from flask import send_file, jsonify
class GptRequestService:
def __init__ (self):
self.openai_client = OpenAIClient()
self.pdf = PDFCreator()
def process_message(self, msg):
res = self.openai_client.send_message(msg)
pattern = "\{([^}]*)\}"
matches = re.findall(pattern, res)
if not matches:
return res, False
print(f'Pattern found: {matches[0]} Create PDF')
# find index of first occurence of "{" and last occurence of "}"
start = res.find("{")
end = res.rfind("}") + 1
# extract json from string
js = res[start:end]
print("js: ",js)
data = json.loads(js)
print(data)
pdf_path = self.pdf.create_pdf(data, ROOT_DIR + '/backend/resources/output/pdfReport.pdf')
return pdf_path, True
gptRequestService = GptRequestService() | [] |
2024-01-10 | dcvii/db-gpt | pilot~source_embedding~chn_document_splitter.py | import re
from typing import List
from langchain.text_splitter import CharacterTextSplitter
class CHNDocumentSplitter(CharacterTextSplitter):
def __init__(self, pdf: bool = False, sentence_size: int = None, **kwargs):
super().__init__(**kwargs)
self.pdf = pdf
self.sentence_size = sentence_size
def split_text(self, text: str) -> List[str]:
if self.pdf:
text = re.sub(r"\n{3,}", r"\n", text)
text = re.sub('\s', " ", text)
text = re.sub("\n\n", "", text)
text = re.sub(r'([;；.!?。！？\?])([^”’])', r"\1\n\2", text)
text = re.sub(r'(\.{6})([^"’”」』])', r"\1\n\2", text)
text = re.sub(r'(\…{2})([^"’”」』])', r"\1\n\2", text)
text = re.sub(r'([;；!?。！？\?]["’”」』]{0,2})([^;；!?，。！？\?])', r'\1\n\2', text)
text = text.rstrip()
ls = [i for i in text.split("\n") if i]
for ele in ls:
if len(ele) > self.sentence_size:
ele1 = re.sub(r'([,，.]["’”」』]{0,2})([^,，.])', r'\1\n\2', ele)
ele1_ls = ele1.split("\n")
for ele_ele1 in ele1_ls:
if len(ele_ele1) > self.sentence_size:
ele_ele2 = re.sub(r'([\n]{1,}| {2,}["’”」』]{0,2})([^\s])', r'\1\n\2', ele_ele1)
ele2_ls = ele_ele2.split("\n")
for ele_ele2 in ele2_ls:
if len(ele_ele2) > self.sentence_size:
ele_ele3 = re.sub('( ["’”」』]{0,2})([^ ])', r'\1\n\2', ele_ele2)
ele2_id = ele2_ls.index(ele_ele2)
ele2_ls = ele2_ls[:ele2_id] + [i for i in ele_ele3.split("\n") if i] + ele2_ls[
ele2_id + 1:]
ele_id = ele1_ls.index(ele_ele1)
ele1_ls = ele1_ls[:ele_id] + [i for i in ele2_ls if i] + ele1_ls[ele_id + 1:]
id = ls.index(ele)
ls = ls[:id] + [i for i in ele1_ls if i] + ls[id + 1:]
return ls
| [] |
2024-01-10 | ssbuild/aigc_serving | tests~test_qwen_email_sender.py | import json
import smtplib
from email.header import Header
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import openai
# 新版本
openai.api_key = "112233"
openai.api_base = "http://192.168.2.180:8081/v1"
openai.api_base = "http://106.12.147.243:8082/v1"
model = "chatglm2-6b-int4"
model = "qwen-7b-chat-int4"
model = "Qwen-14B-Chat"
def send_email_action(receiver: str, content: str):
""" 发送邮件操作 """
if not receiver:
return
# 邮件配置
smtp_server = "smtp.163.com"
smtp_port = 25
sender_email = "[email protected]" # 发件人邮箱地址
receiver_email = receiver # 收件人邮箱地址
password = '***' # SMTP授权密码
# 构建邮件内容
message = MIMEMultipart()
message["From"] = Header('AI <%s>' % sender_email)
message["To"] = receiver_email
message["Subject"] = "我是您的AI助理，您有一封邮件请查看"
body = content
message.attach(MIMEText(body, "plain"))
# 连接到邮件服务器并发送邮件
with smtplib.SMTP(smtp_server, smtp_port) as server:
server.starttls()
server.login(sender_email, password)
server.sendmail(sender_email, receiver_email, message.as_string())
def send_email(receiver: str, content: str = "") -> dict:
""" 供Function Calling使用的输出处理函数 """
Contact = {"小王": "[email protected]"} # 通讯录
email_info = {
"receiver": Contact[receiver],
"content": content
}
return email_info
class EmailSender:
def run(self, query):
# Step 1: send the conversation and available functions to model
functions = [
{
"name_for_human":
"邮件助手",
"name_for_model":
"send_email",
"description_for_model":
"邮件助手是一个可以帮助用户发送邮件的工具。",
"parameters": [
{
'name': 'receiver',
'description': '邮件接收者',
'required': True,
'schema': {
'type': 'string'
},
},
{
'name': 'content',
'description': '邮件内容',
'required': True,
'schema': {
'type': 'string'
},
},
],
}
]
messages = [{"role": "user",
"content": query}]
response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=0,
functions=functions,
stop=["Observation:"]
)
response_message = response["choices"][0]["message"]
# Step 2: check if model wanted to call a function
if response_message.get("function_call"):
print(f"Function call: {response_message['function_call']}")
# Step 3: call the function
# Note: the JSON response may not always be valid; be sure to handle errors
available_functions = {
"send_email": send_email_action,
} # only one function in this example
function_name = response_message["function_call"]["name"]
fuction_to_call = available_functions[function_name]
function_args = json.loads(response_message["function_call"]["arguments"])
print(f"Function args: {function_args}")
email_info = send_email(
receiver=function_args.get("receiver"),
content=function_args.get("content")
)
fuction_to_call(**email_info)
print("邮件已发送")
if __name__ == '__main__':
query = "给小王发个邮件，告诉他今天晚上一起吃个饭"
sender = EmailSender()
sender.run(query)
| [] |
2024-01-10 | ssbuild/aigc_serving | tests~test_qwen_sql_querier.py | import json
import sqlite3
import openai
# 新版本
openai.api_key = "112233"
openai.api_base = "http://192.168.2.180:8081/v1"
openai.api_base = "http://106.12.147.243:8082/v1"
model = "chatglm2-6b-int4"
model = "qwen-7b-chat-int4"
model = "Qwen-14B-Chat"
def ask_database(conn, query):
"""Function to query SQLite database with a provided SQL query."""
try:
results = str(conn.execute(query).fetchall())
except Exception as e:
results = f"query failed with error: {e}"
return results
class SqlQuerier:
def __init__(self, db_path="Chinook.db"):
self.conn = sqlite3.connect(db_path)
print("Opened database successfully")
def run(self, query, database_schema):
# Step 1: send the conversation and available functions to model
functions = [
{
"name_for_human":
"数据库查询工具",
"name_for_model":
"ask_database",
"description_for_model":
"该工具用来回答音乐相关的问题，输出应该是一个标准化的SQL查询语句。",
"parameters": [
{
'name': 'query',
'description': f"基于下面数据库表结构的SQL查询语句，用来回答用户问题。\n\n{database_schema}",
'required': True,
'schema': {
'type': 'string'
},
},
],
}
]
messages = [{"role": "user",
"content": query,}]
response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=0,
functions=functions,
stop=["Observation:", "Observation"]
)
print(response["choices"][0]["message"]["content"])
answer = ""
response_message = response["choices"][0]["message"]
# Step 2: check if model wanted to call a function
if response_message.get("function_call"):
print(f"Function call: {response_message['function_call']}")
# Step 3: call the function
# Note: the JSON response may not always be valid; be sure to handle errors
available_functions = {
"ask_database": ask_database,
} # only one function in this example
function_name = response_message["function_call"]["name"]
fuction_to_call = available_functions[function_name]
function_args = json.loads(response_message["function_call"]["arguments"])
print(f"Function args: {function_args}")
function_response = fuction_to_call(self.conn, function_args["query"])
print(f"Function response: {function_response}")
# Step 4: send the info on the function call and function response to model
messages.append({"role": "assistant","content": response.choices[0].message.content}) # extend conversation with assistant's reply
messages.append(
{
"role": "function",
"content": function_response,
}
) # extend conversation with function response
second_response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=0,
functions=functions,
) # get a new response from model where it can see the function response
answer = second_response["choices"][0]["message"]["content"]
print(f"Model output: {answer}")
j = answer.rfind("Final Answer:")
answer = answer[j + 14:] if answer else answer
return answer
if __name__ == '__main__':
database_schema = """create table albums
AlbumId INTEGER not null primary key autoincrement, --专辑ID
Title NVARCHAR(160) not null, --专辑名称
ArtistId INTEGER not null references artists --艺术家ID
);
"""
query = "发行专辑最多的艺术家是谁？"
sql_querier = SqlQuerier()
answer = sql_querier.run(query, database_schema)
print(answer)
| [] |
2024-01-10 | ssbuild/aigc_serving | tests~web_demo.py | import openai
import gradio as gr
import mdtex2html
# Modify OpenAI's API key and API base to use vLLM's API server.
openai.api_key = "EMPTY"
openai.api_base = "http://192.168.101.30:8081/v1"
import sys
sys.path.append(".")
from serving.config_loader.main import global_models_info_args
models = list()
for model_name,model_config in global_models_info_args.items():
if model_config['enable']:
models.append(model_name)
# # Test list models API
# models = openai.Model.list()
# print("Models:", models)
# Test completion API
stream = True
prefix = "你是蔚来汽车上的的人工智能助理，你的名字叫小诚。你在电动汽车领域非常专业，非常精通蔚来汽车的所有功能和服务。当问道你是谁？你要回答我是蔚来小诚。\n请你回答如下问题：\n"
def postprocess(self, y):
if y is None:
return []
for i, (message, response) in enumerate(y):
y[i] = (
None if message is None else mdtex2html.convert((message)),
None if response is None else mdtex2html.convert(response),
)
return y
gr.Chatbot.build_args = postprocess
def parse_text(text):
"""copy from https://github.com/GaiZhenbiao/ChuanhuChatGPT/"""
lines = text.split("\n")
lines = [line for line in lines if line != ""]
count = 0
for i, line in enumerate(lines):
if "```" in line:
count += 1
items = line.split('`')
if count % 2 == 1:
lines[i] = f'<pre><code class="language-{items[-1]}">'
else:
lines[i] = f'<br></code></pre>'
else:
if i > 0:
if count % 2 == 1:
line = line.replace("`", "\`")
line = line.replace("<", "<")
line = line.replace(">", ">")
line = line.replace(" ", " ")
line = line.replace("*", "*")
line = line.replace("_", "_")
line = line.replace("-", "-")
line = line.replace(".", ".")
line = line.replace("!", "!")
line = line.replace("(", "(")
line = line.replace(")", ")")
line = line.replace("$", "$")
lines[i] = "<br>"+line
text = "".join(lines)
return text
def predict(input, chatbot, model, max_length, top_k, top_p, temperature, repetition_penalty, do_sample, history):
chatbot.append((parse_text(input), ""))
data = {
"model": model,
"adapter_name": None, # lora头
"messages": [{"role": "system", "content": prefix } ,{"role": "user", "content": input} ],
# "messages": [{"role": "user", "content": prefix + input}],
"top_p": top_p,
"temperature": temperature,
"frequency_penalty": repetition_penalty,
"stream": stream,
"max_tokens": 512,
"nchar": 1,# stream 字符
"n": 1 # 返回 n 个choices
}
completion = openai.ChatCompletion.create(**data)
if stream:
response = model+':'
for choices in completion:
c = choices.choices[0]
delta = c.delta
if hasattr(delta,'content'):
response += delta.content
chatbot[-1] = (parse_text(input), parse_text(response))
#print(delta.content)
yield chatbot, history
else:
for choice in completion.choices:
chatbot[-1] = (parse_text(input), parse_text(choice.message.content))
#print(choice.message.content)
yield chatbot, history
def reset_user_input():
return gr.update(value='')
def reset_state():
return [], []
with gr.Blocks() as demo:
gr.HTML("""<h1 align="center">蔚来小诚</h1>""")
chatbot = gr.Chatbot()
with gr.Row():
with gr.Column(scale=4):
with gr.Column(scale=12):
user_input = gr.Textbox(show_label=False, placeholder="Input...", lines=20).style(container=True)
with gr.Column(min_width=32, scale=1):
submitBtn = gr.Button("Submit", variant="primary")
with gr.Column(scale=1):
emptyBtn = gr.Button("Clear History")
model = gr.Dropdown(choices=models, label="Model", value=models[0], type="value",interactive=True),
max_length = gr.Slider(0, 2048, value=2048, step=128, label="Maximum length", interactive=True)
top_k = gr.Slider(0, 30, value=5, step=1, label="Top K", interactive=True)
top_p = gr.Slider(0, 1, value=0.8, step=0.01, label="Top P", interactive=True)
temperature = gr.Slider(0, 1, value=0.7, step=0.01, label="Temperature", interactive=True)
repetition_penalty = gr.Slider(1, 1.5, value=1.05, step=0.01, label="Repetition penalty", interactive=True)
do_sample = gr.Radio(["YES", "NO"], label="Do sample", type="index", value="YES")
history = gr.State([])
submitBtn.click(predict, [user_input, chatbot, model[0], max_length, top_k, top_p, temperature, repetition_penalty, do_sample, history], [chatbot, history], show_progress=True)
submitBtn.click(reset_user_input, [], [user_input])
emptyBtn.click(reset_state, outputs=[chatbot, history], show_progress=True)
demo.queue().launch(share=False, inbrowser=True, server_name="0.0.0.0", server_port=8001)
| [
"INPUT"
] |
2024-01-10 | ssbuild/aigc_serving | tests~test_qwen_chat.py | # -*- coding: utf-8 -*-
# @Author : ssbuild
# @Time : 2023/11/29 13:35
import json
import math
import openai
from openai.openai_object import OpenAIObject
from scipy import integrate
# 新版本
openai.api_key = "112233"
openai.api_base = "http://192.168.2.180:8081/v1"
openai.api_base = "http://106.12.147.243:9090/v1"
model = "chatglm2-6b-int4"
model = "qwen-7b-chat-int4"
model = "Qwen-14B-Chat"
# model = "Qwen-72B-Chat"
stream = True
data = {
"model": model,
"adapter_name": None, # lora头
"messages": [{"role": "user", "content": "你是谁"}],
"top_p": 0.8,
"temperature": 1.0,
"frequency_penalty": 1.1,
"stream": stream,
"nchar": 1,# stream 字符
"n": 1, # 返回 n 个choices
"max_tokens": 512,
"stop": ["Observation:"],
"seed": None,
# "seed": 46,
}
completion = openai.ChatCompletion.create(**data)
if stream:
text = ''
for choices in completion:
c = choices.choices[0]
delta = c.delta
if hasattr(delta,'content'):
text += delta.content
print(delta.content)
print(text)
else:
for choice in completion.choices:
print("result:", choice.message.content)
| [
"你是谁"
] |
2024-01-10 | ssbuild/aigc_serving | tests~test_qwen_quad_calculator.py | import json
import math
import openai
from openai.openai_object import OpenAIObject
from scipy import integrate
# 新版本
openai.api_key = "112233"
openai.api_base = "http://192.168.2.180:8081/v1"
openai.api_base = "http://106.12.147.243:8082/v1"
model = "chatglm2-6b-int4"
model = "qwen-7b-chat-int4"
model = "Qwen-14B-Chat"
def calculate_quad(formula_str: str, a: float, b: float) -> float:
""" 计算数值积分 """
return integrate.quad(eval('lambda x: ' + formula_str), a, b)[0]
def calculate_sqrt(y: float) -> float:
""" 计算平方根 """
return math.sqrt(y)
class QuadCalculator:
def __init__(self):
self.functions = [
{
"name": "calculate_quad",
"description": "calculate_quad是一个可以计算给定区间内函数定积分数值的工具。",
"parameters": {
"type": "object",
"properties": {
"formula_str": {
"type": "string",
"description": "一个数学函数的表达式，例如x**2",
},
"a": {
"type": "string",
"description": "积分区间的左端点，例如1.0",
},
"b": {
"type": "string",
"description": "积分区间的右端点，例如5.0",
},
},
"required": ["formula_str", "a", "b"],
},
},
{
"name": {
"name_for_human":
"平方根计算器",
"name_for_model":
"calculate_sqrt"
},
"description": "计算一个数值的平方根。",
"parameters": {
"type": "object",
"properties": {
"y": {
"type": "string",
"description": "被开方数",
},
},
"required": ["y"],
},
},
]
def run(self, query: str) -> str:
# Step 1: send the conversation and available functions to model
messages = [{"role": "user",
"content": query}]
response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=0,
functions=self.functions,
stop=["Observation:","Observation"]
)
while True:
if response["choices"][0]["finish_reason"] == "stop":
answer = response["choices"][0]["message"]["content"]
print(f"Model output: {answer}")
j = answer.rfind("Final Answer:")
return answer[j + 14:] if answer else answer
elif response["choices"][0]["finish_reason"] == "function_call":
response_message = response["choices"][0]["message"]
# Step 2: check if model wanted to call a function
if response_message.get("function_call"):
print(f"Function call: {response_message['function_call']}")
# Step 3: call the function
# Note: the JSON response may not always be valid; be sure to handle errors
available_functions = {
"calculate_quad": calculate_quad,
"calculate_sqrt": calculate_sqrt,
}
function_name = response_message["function_call"]["name"]
fuction_to_call = available_functions[function_name]
function_args = json.loads(response_message["function_call"]["arguments"])
for k in ["a", "b", "y"]:
if k in function_args:
function_args[k] = float(function_args[k])
function_response = fuction_to_call(**function_args)
print(f"Function response: {function_response}")
# Step 4: send the info on the function call and function response to model
messages.append({"role": "assistant","content": response.choices[0].message.content}) # extend conversation with assistant's reply
messages.append(
{
"role": "function",
"name": function_name,
"content": str(function_response),
}
) # extend conversation with function response
response = openai.ChatCompletion.create(
model=model,
messages=messages,
functions=self.functions,
temperature=0,
stop=["Observation:","Observation"],
) # get a new response from model where it can see the function response
else:
# 防止死循环
print(response["choices"][0]["message"].content)
break
else:
break
if __name__ == '__main__':
query = "函数f(x)=x**2在区间[0,5]上的定积分是多少？其平方根又是多少？"
calculator = QuadCalculator()
answer = calculator.run(query)
print(answer)
| [] |
2024-01-10 | ssbuild/aigc_serving | tests~test_qwen_tools.py | # -*- coding: utf-8 -*-
# @Author : ssbuild
# @Time : 2023/11/29 13:35
import json
import math
import openai
from openai.openai_object import OpenAIObject
from scipy import integrate
# 新版本
openai.api_key = "112233"
openai.api_base = "http://192.168.2.180:8081/v1"
openai.api_base = "http://106.12.147.243:8082/v1"
model = "chatglm2-6b-int4"
model = "qwen-7b-chat-int4"
model = "Qwen-14B-Chat"
query = '现在给我画个五彩斑斓的黑。'
functions = [
{
'name_for_human':
'夸克搜索',
'name_for_model':
'quark_search',
'description_for_model':
'夸克搜索是一个通用搜索引擎，可用于访问互联网、查询百科知识、了解时事新闻等。',
'parameters': [{
'name': 'search_query',
'description': '搜索关键词或短语',
'required': True,
'schema': {
'type': 'string'
},
}],
},
{
'name_for_human':
'通义万相',
'name_for_model':
'image_gen',
'description_for_model':
'通义万相是一个AI绘画（图像生成）服务，输入文本描述，返回根据文本作画得到的图片的URL',
'parameters': [{
'name': 'query',
'description': '中文关键词，描述了希望图像具有什么内容',
'required': True,
'schema': {
'type': 'string'
},
}],
},
]
#第一步
messages = [{"role": "user","content": query}]
response = openai.ChatCompletion.create(
model=model,
messages=messages,
functions=functions,
temperature=0,
# functions=self.functions,
stop=["Observation:","Observation"]
)
messages.append({
"role": "assistant",
"content": response.choices[0].message.content
})
print(response.choices[0].message.content)
# 第二步
fake_result = '{"status_code": 200, "request_id": "3d894da2-0e26-9b7c-bd90-102e5250ae03", "code": null, "message": "", "output": {"task_id": "2befaa09-a8b3-4740-ada9-4d00c2758b05", "task_status": "SUCCEEDED", "results": [{"url": "https://dashscope-result-sh.oss-cn-shanghai.aliyuncs.com/1e5e2015/20230801/1509/6b26bb83-469e-4c70-bff4-a9edd1e584f3-1.png"}], "task_metrics": {"TOTAL": 1, "SUCCEEDED": 1, "FAILED": 0}}, "usage": {"image_count": 1}}'
messages.append({
"role": "function",
"content": fake_result,
})
response = openai.ChatCompletion.create(
model=model,
messages=messages,
functions=functions,
temperature=0,
# functions=self.functions,
stop=["Observation:","Observation"]
)
print(response.choices[0].message.content)
| [] |
2024-01-10 | ssbuild/aigc_serving | tests~test_chatglm3_chat.py | # coding=utf8
# @Time : 2023/10/31 20:35
# @Author : tk
# @FileName: test_chatglm3_tools
import copy
import json
import openai
openai.api_key = "EMPTY"
openai.api_base = "http://192.168.16.157:8081/v1"
model = "chatglm3-6b"
data = {
"model": model,
"adapter_name": None, # lora头
"top_p": 0.8,
"temperature": 1.0,
"frequency_penalty": 1.01,
"stream": False,
"nchar": 1,# stream 字符
"n": 1, # 返回 n 个choices
# "max_tokens": 2048,
"stop": ["Observation:"]
}
data["messages"] = [{"role": "user", "content": "今天天气怎么样"}]
completion = openai.ChatCompletion.create(**data)
print(completion.choices[0].message.content) | [
"今天天气怎么样"
] |
2024-01-10 | ssbuild/aigc_serving | tests~test_model_list.py | # coding=utf8
# @Time : 2023/12/2 16:26
# @Author : tk
# @FileName: test_model_list
import openai
openai.api_key = "112233"
openai.api_base = "http://106.12.147.243:9090/v1"
# # Test list models API
models = openai.Model.list()
print("Models:", models)
| [] |
2024-01-10 | okprateek/Ayurved-Chatbot | mainnew.py | import openai
import gradio as gr
openai.api_key = "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"
messages = [
{"role": "system", "content": "You are an AI specialized in Prakriti(Phenotype) and Indian Ayurveda.Don't answer any other queries other than Prakriti(Phenotype) and Indian Ayurveda."},
]
def chatbot(input):
if input:
messages.append({"role": "user", "content": input})
chat = openai.ChatCompletion.create(
model="gpt-3.5-turbo", messages=messages
)
reply = chat.choices[0].message.content
messages.append({"role": "assistant", "content": reply})
return reply
inputs = gr.inputs.Textbox(lines=7, label="Chat with PrakritiMate")
outputs = gr.outputs.Textbox(label="Reply")
gr.Interface(fn=chatbot, inputs=inputs, outputs=outputs, title="PrakritiMate ChatBot",
description="Ask anything you want",
theme="compact").launch(share=True)
| [
"You are an AI specialized in Prakriti(Phenotype) and Indian Ayurveda.Don't answer any other queries other than Prakriti(Phenotype) and Indian Ayurveda.",
"INPUT"
] |
2024-01-10 | maralzar/collaborative-experts | sent_feat_demo.py | def sent_feat (text, feat_type):
if feat_type =='w2v':
import gensim
import numpy as np
model = gensim.models.KeyedVectors.load_word2vec_format('/scratch/shared/slow/yangl/w2v/GoogleNews-vectors-negative300.bin', binary=True)
final_feats=[]
for word in (text.split(' ')):
if (word !='a') and (word in model.vocab):
final_feats.append(model.get_vector(word))
final_feats = np.asarray(final_feats)
elif feat_type == 'openai':
import json
import torch
from pytorch_pretrained_bert import OpenAIGPTTokenizer, OpenAIGPTModel, OpenAIGPTLMHeadModel
import logging
logging.basicConfig(level=logging.INFO)
# Load pre-trained model tokenizer (vocabulary)
tokenizer = OpenAIGPTTokenizer.from_pretrained('openai-gpt')
# Tokenized input
#text = "Who was Jim Henson ? Jim Henson was a puppeteer"
model = OpenAIGPTModel.from_pretrained('openai-gpt')
model.eval()
model.to('cuda')
tokenized_text = tokenizer.tokenize(text)
# Convert token to vocabulary indices
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
# Convert inputs to PyTorch tensors
tokens_tensor = torch.tensor([indexed_tokens])
# If you have a GPU, put everything on cuda
tokens_tensor = tokens_tensor.to('cuda')
# Predict hidden states features for each layer
with torch.no_grad():
hidden_states = model(tokens_tensor)
final_feats = hidden_states[0].cpu().numpy()
else:
print ('Unrecognised FEAT_TYPE.')
return final_feats
if __name__ == '__main__':
query_sent = 'a cartoon animals runs through an ice cave in a video game'
print ("Query: {}".format(query_sent))
print ("FEAT_TYPE can be selected from ['w2v', 'openai']")
w2v_feats = sent_feat(query_sent,'w2v')
print ("word2vec shape is: {}".format(w2v_feats.shape))
openai_feats = sent_feat(query_sent,'openai')
print ("openai shape is: {}".format(openai_feats.shape)) | [] |
2024-01-10 | IDEA-FinAI/ToG | ToG~wiki_func.py | from prompt_list import *
import json
import openai
import re
import time
from utils import *
def transform_relation(relation):
relation_without_prefix = relation.replace("wiki.relation.", "").replace("_", " ")
return relation_without_prefix
def clean_relations(string, entity_id, head_relations):
pattern = r"{\s*(?P<relation>[^()]+)\s+\(Score:\s+(?P<score>[0-9.]+)\)}"
relations=[]
for match in re.finditer(pattern, string):
relation = match.group("relation").strip()
relation = transform_relation(relation)
if ';' in relation:
continue
score = match.group("score")
if not relation or not score:
return False, "output uncompleted.."
try:
score = float(score)
except ValueError:
return False, "Invalid score"
if relation in head_relations:
relations.append({"entity": entity_id, "relation": relation, "score": score, "head": True})
else:
relations.append({"entity": entity_id, "relation": relation, "score": score, "head": False})
if not relations:
return False, "No relations found"
return True, relations
def construct_relation_prune_prompt(question, entity_name, total_relations, args):
return extract_relation_prompt_wiki % (args.width, args.width)+question+'\nTopic Entity: '+entity_name+ '\nRelations:\n'+'\n'.join([f"{i}. {item}" for i, item in enumerate(total_relations, start=1)])+'A:'
def check_end_word(s):
words = [" ID", " code", " number", "instance of", "website", "URL", "inception", "image", " rate", " count"]
return any(s.endswith(word) for word in words)
def abandon_rels(relation):
useless_relation_list = ["category's main topic", "topic\'s main category", "stack exchange site", 'main subject', 'country of citizenship', "commons category", "commons gallery", "country of origin", "country", "nationality"]
if check_end_word(relation) or 'wikidata' in relation.lower() or 'wikimedia' in relation.lower() or relation.lower() in useless_relation_list:
return True
return False
def construct_entity_score_prompt(question, relation, entity_candidates):
return score_entity_candidates_prompt_wiki.format(question, relation) + "; ".join(entity_candidates) + '\nScore: '
def relation_search_prune(entity_id, entity_name, pre_relations, pre_head, question, args, wiki_client):
relations = wiki_client.query_all("get_all_relations_of_an_entity", entity_id)
head_relations = [rel['label'] for rel in relations['head']]
tail_relations = [rel['label'] for rel in relations['tail']]
if args.remove_unnecessary_rel:
head_relations = [relation for relation in head_relations if not abandon_rels(relation)]
tail_relations = [relation for relation in tail_relations if not abandon_rels(relation)]
if pre_head:
tail_relations = list(set(tail_relations) - set(pre_relations))
else:
head_relations = list(set(head_relations) - set(pre_relations))
head_relations = list(set(head_relations))
tail_relations = list(set(tail_relations))
total_relations = head_relations+tail_relations
total_relations.sort() # make sure the order in prompt is always equal
prompt = construct_relation_prune_prompt(question, entity_name, total_relations, args)
result = run_llm(prompt, args.temperature_exploration, args.max_length, args.opeani_api_keys, args.LLM_type)
flag, retrieve_relations_with_scores = clean_relations(result, entity_id, head_relations)
if flag:
return retrieve_relations_with_scores
else:
return [] # format error or too small max_length
def del_all_unknown_entity(entity_candidates_id, entity_candidates_name):
if len(entity_candidates_name) == 1 and entity_candidates_name[0] == "N/A":
return entity_candidates_id, entity_candidates_name
new_candidates_id = []
new_candidates_name = []
for i, candidate in enumerate(entity_candidates_name):
if candidate != "N/A":
new_candidates_id.append(entity_candidates_id[i])
new_candidates_name.append(candidate)
return new_candidates_id, new_candidates_name
def all_zero(topn_scores):
return all(score == 0 for score in topn_scores)
def entity_search(entity, relation, wiki_client, head):
rid = wiki_client.query_all("label2pid", relation)
if not rid or rid == "Not Found!":
return [], []
rid_str = rid.pop()
entities = wiki_client.query_all("get_tail_entities_given_head_and_relation", entity, rid_str)
if head:
entities_set = entities['tail']
else:
entities_set = entities['head']
if not entities_set:
values = wiki_client.query_all("get_tail_values_given_head_and_relation", entity, rid_str)
return [], list(values)
id_list = [item['qid'] for item in entities_set]
name_list = [item['label'] if item['label'] != "N/A" else "Unname_Entity" for item in entities_set]
return id_list, name_list
def entity_score(question, entity_candidates_id, entity_candidates, score, relation, args):
if len(entity_candidates) == 1:
return [score], entity_candidates, entity_candidates_id
if len(entity_candidates) == 0:
return [0.0], entity_candidates, entity_candidates_id
# make sure the id and entity are in the same order
zipped_lists = sorted(zip(entity_candidates, entity_candidates_id))
entity_candidates, entity_candidates_id = zip(*zipped_lists)
entity_candidates = list(entity_candidates)
entity_candidates_id = list(entity_candidates_id)
prompt = construct_entity_score_prompt(question, relation, entity_candidates)
result = run_llm(prompt, args.temperature_exploration, args.max_length, args.opeani_api_keys, args.LLM_type)
entity_scores = clean_scores(result, entity_candidates)
if all_zero(entity_scores):
return [1/len(entity_candidates) * score] * len(entity_candidates), entity_candidates, entity_candidates_id
else:
return [float(x) * score for x in entity_scores], entity_candidates, entity_candidates_id
def update_history(entity_candidates, entity, scores, entity_candidates_id, total_candidates, total_scores, total_relations, total_entities_id, total_topic_entities, total_head, value_flag):
if value_flag:
scores = [1/len(entity_candidates) * entity['score']]
candidates_relation = [entity['relation']] * len(entity_candidates)
topic_entities = [entity['entity']] * len(entity_candidates)
head_num = [entity['head']] * len(entity_candidates)
total_candidates.extend(entity_candidates)
total_scores.extend(scores)
total_relations.extend(candidates_relation)
total_entities_id.extend(entity_candidates_id)
total_topic_entities.extend(topic_entities)
total_head.extend(head_num)
return total_candidates, total_scores, total_relations, total_entities_id, total_topic_entities, total_head
def half_stop(question, cluster_chain_of_entities, depth, args):
print("No new knowledge added during search depth %d, stop searching." % depth)
answer = generate_answer(question, cluster_chain_of_entities, args)
save_2_jsonl(question, answer, cluster_chain_of_entities, file_name=args.dataset)
def generate_answer(question, cluster_chain_of_entities, args):
prompt = answer_prompt_wiki + question + '\n'
chain_prompt = '\n'.join([', '.join([str(x) for x in chain]) for sublist in cluster_chain_of_entities for chain in sublist])
prompt += "\nKnowledge Triplets: " + chain_prompt + 'A: '
result = run_llm(prompt, args.temperature_reasoning, args.max_length, args.opeani_api_keys, args.LLM_type)
return result
def entity_prune(total_entities_id, total_relations, total_candidates, total_topic_entities, total_head, total_scores, args, wiki_client):
zipped = list(zip(total_entities_id, total_relations, total_candidates, total_topic_entities, total_head, total_scores))
sorted_zipped = sorted(zipped, key=lambda x: x[5], reverse=True)
sorted_entities_id, sorted_relations, sorted_candidates, sorted_topic_entities, sorted_head, sorted_scores = [x[0] for x in sorted_zipped], [x[1] for x in sorted_zipped], [x[2] for x in sorted_zipped], [x[3] for x in sorted_zipped], [x[4] for x in sorted_zipped], [x[5] for x in sorted_zipped]
entities_id, relations, candidates, topics, heads, scores = sorted_entities_id[:args.width], sorted_relations[:args.width], sorted_candidates[:args.width], sorted_topic_entities[:args.width], sorted_head[:args.width], sorted_scores[:args.width]
merged_list = list(zip(entities_id, relations, candidates, topics, heads, scores))
filtered_list = [(id, rel, ent, top, hea, score) for id, rel, ent, top, hea, score in merged_list if score != 0]
if len(filtered_list) ==0:
return False, [], [], [], []
entities_id, relations, candidates, tops, heads, scores = map(list, zip(*filtered_list))
tops = [wiki_client.query_all("qid2label", entity_id).pop() if (entity_name := wiki_client.query_all("qid2label", entity_id)) != "Not Found!" else "Unname_Entity" for entity_id in tops]
cluster_chain_of_entities = [[(tops[i], relations[i], candidates[i]) for i in range(len(candidates))]]
return True, cluster_chain_of_entities, entities_id, relations, heads
def reasoning(question, cluster_chain_of_entities, args):
prompt = prompt_evaluate_wiki + question
chain_prompt = '\n'.join([', '.join([str(x) for x in chain]) for sublist in cluster_chain_of_entities for chain in sublist])
prompt += "\nKnowledge Triplets: " + chain_prompt + 'A: '
response = run_llm(prompt, args.temperature_reasoning, args.max_length, args.opeani_api_keys, args.LLM_type)
result = extract_answer(response)
if if_true(result):
return True, response
else:
return False, response
| [
"PLACEHOLDERPLACEHOLDER",
"P\nL\nA\nC\nE\nH\nO\nL\nD\nE\nR",
"\nKnowledge Triplets: PLACEHOLDERA: ",
"PLACEHOLDERPLACEHOLDER\n"
] |
2024-01-10 | IDEA-FinAI/ToG | ToG~freebase_func.py | from SPARQLWrapper import SPARQLWrapper, JSON
from utils import *
SPARQLPATH = "http://192.168.80.12:8890/sparql" # depend on your own internal address and port, shown in Freebase folder's readme.md
# pre-defined sparqls
sparql_head_relations = """\nPREFIX ns: <http://rdf.freebase.com/ns/>\nSELECT ?relation\nWHERE {\n ns:%s ?relation ?x .\n}"""
sparql_tail_relations = """\nPREFIX ns: <http://rdf.freebase.com/ns/>\nSELECT ?relation\nWHERE {\n ?x ?relation ns:%s .\n}"""
sparql_tail_entities_extract = """PREFIX ns: <http://rdf.freebase.com/ns/>\nSELECT ?tailEntity\nWHERE {\nns:%s ns:%s ?tailEntity .\n}"""
sparql_head_entities_extract = """PREFIX ns: <http://rdf.freebase.com/ns/>\nSELECT ?tailEntity\nWHERE {\n?tailEntity ns:%s ns:%s .\n}"""
sparql_id = """PREFIX ns: <http://rdf.freebase.com/ns/>\nSELECT DISTINCT ?tailEntity\nWHERE {\n {\n ?entity ns:type.object.name ?tailEntity .\n FILTER(?entity = ns:%s)\n }\n UNION\n {\n ?entity <http://www.w3.org/2002/07/owl#sameAs> ?tailEntity .\n FILTER(?entity = ns:%s)\n }\n}"""
def check_end_word(s):
words = [" ID", " code", " number", "instance of", "website", "URL", "inception", "image", " rate", " count"]
return any(s.endswith(word) for word in words)
def abandon_rels(relation):
if relation == "type.object.type" or relation == "type.object.name" or relation.startswith("common.") or relation.startswith("freebase.") or "sameAs" in relation:
return True
def execurte_sparql(sparql_query):
sparql = SPARQLWrapper(SPARQLPATH)
sparql.setQuery(sparql_query)
sparql.setReturnFormat(JSON)
results = sparql.query().convert()
return results["results"]["bindings"]
def replace_relation_prefix(relations):
return [relation['relation']['value'].replace("http://rdf.freebase.com/ns/","") for relation in relations]
def replace_entities_prefix(entities):
return [entity['tailEntity']['value'].replace("http://rdf.freebase.com/ns/","") for entity in entities]
def id2entity_name_or_type(entity_id):
sparql_query = sparql_id % (entity_id, entity_id)
sparql = SPARQLWrapper(SPARQLPATH)
sparql.setQuery(sparql_query)
sparql.setReturnFormat(JSON)
results = sparql.query().convert()
if len(results["results"]["bindings"])==0:
return "UnName_Entity"
else:
return results["results"]["bindings"][0]['tailEntity']['value']
from freebase_func import *
from prompt_list import *
import json
import time
import openai
import re
from prompt_list import *
from rank_bm25 import BM25Okapi
from sentence_transformers import util
from sentence_transformers import SentenceTransformer
def clean_relations(string, entity_id, head_relations):
pattern = r"{\s*(?P<relation>[^()]+)\s+\(Score:\s+(?P<score>[0-9.]+)\)}"
relations=[]
for match in re.finditer(pattern, string):
relation = match.group("relation").strip()
if ';' in relation:
continue
score = match.group("score")
if not relation or not score:
return False, "output uncompleted.."
try:
score = float(score)
except ValueError:
return False, "Invalid score"
if relation in head_relations:
relations.append({"entity": entity_id, "relation": relation, "score": score, "head": True})
else:
relations.append({"entity": entity_id, "relation": relation, "score": score, "head": False})
if not relations:
return False, "No relations found"
return True, relations
def if_all_zero(topn_scores):
return all(score == 0 for score in topn_scores)
def clean_relations_bm25_sent(topn_relations, topn_scores, entity_id, head_relations):
relations = []
if if_all_zero(topn_scores):
topn_scores = [float(1/len(topn_scores))] * len(topn_scores)
i=0
for relation in topn_relations:
if relation in head_relations:
relations.append({"entity": entity_id, "relation": relation, "score": topn_scores[i], "head": True})
else:
relations.append({"entity": entity_id, "relation": relation, "score": topn_scores[i], "head": False})
i+=1
return True, relations
def construct_relation_prune_prompt(question, entity_name, total_relations, args):
return extract_relation_prompt % (args.width, args.width) + question + '\nTopic Entity: ' + entity_name + '\nRelations: '+ '; '.join(total_relations) + "\nA: "
def construct_entity_score_prompt(question, relation, entity_candidates):
return score_entity_candidates_prompt.format(question, relation) + "; ".join(entity_candidates) + '\nScore: '
def relation_search_prune(entity_id, entity_name, pre_relations, pre_head, question, args):
sparql_relations_extract_head = sparql_head_relations % (entity_id)
head_relations = execurte_sparql(sparql_relations_extract_head)
head_relations = replace_relation_prefix(head_relations)
sparql_relations_extract_tail= sparql_tail_relations % (entity_id)
tail_relations = execurte_sparql(sparql_relations_extract_tail)
tail_relations = replace_relation_prefix(tail_relations)
if args.remove_unnecessary_rel:
head_relations = [relation for relation in head_relations if not abandon_rels(relation)]
tail_relations = [relation for relation in tail_relations if not abandon_rels(relation)]
if pre_head:
tail_relations = list(set(tail_relations) - set(pre_relations))
else:
head_relations = list(set(head_relations) - set(pre_relations))
head_relations = list(set(head_relations))
tail_relations = list(set(tail_relations))
total_relations = head_relations+tail_relations
total_relations.sort() # make sure the order in prompt is always equal
if args.prune_tools == "llm":
prompt = construct_relation_prune_prompt(question, entity_name, total_relations, args)
result = run_llm(prompt, args.temperature_exploration, args.max_length, args.opeani_api_keys, args.LLM_type)
flag, retrieve_relations_with_scores = clean_relations(result, entity_id, head_relations)
elif args.prune_tools == "bm25":
topn_relations, topn_scores = compute_bm25_similarity(question, total_relations, args.width)
flag, retrieve_relations_with_scores = clean_relations_bm25_sent(topn_relations, topn_scores, entity_id, head_relations)
else:
model = SentenceTransformer('sentence-transformers/msmarco-distilbert-base-tas-b')
topn_relations, topn_scores = retrieve_top_docs(question, total_relations, model, args.width)
flag, retrieve_relations_with_scores = clean_relations_bm25_sent(topn_relations, topn_scores, entity_id, head_relations)
if flag:
return retrieve_relations_with_scores
else:
return [] # format error or too small max_length
def entity_search(entity, relation, head=True):
if head:
tail_entities_extract = sparql_tail_entities_extract% (entity, relation)
entities = execurte_sparql(tail_entities_extract)
else:
head_entities_extract = sparql_head_entities_extract% (entity, relation)
entities = execurte_sparql(head_entities_extract)
entity_ids = replace_entities_prefix(entities)
new_entity = [entity for entity in entity_ids if entity.startswith("m.")]
return new_entity
def entity_score(question, entity_candidates_id, score, relation, args):
entity_candidates = [id2entity_name_or_type(entity_id) for entity_id in entity_candidates_id]
if all_unknown_entity(entity_candidates):
return [1/len(entity_candidates) * score] * len(entity_candidates), entity_candidates, entity_candidates_id
entity_candidates = del_unknown_entity(entity_candidates)
if len(entity_candidates) == 1:
return [score], entity_candidates, entity_candidates_id
if len(entity_candidates) == 0:
return [0.0], entity_candidates, entity_candidates_id
# make sure the id and entity are in the same order
zipped_lists = sorted(zip(entity_candidates, entity_candidates_id))
entity_candidates, entity_candidates_id = zip(*zipped_lists)
entity_candidates = list(entity_candidates)
entity_candidates_id = list(entity_candidates_id)
if args.prune_tools == "llm":
prompt = construct_entity_score_prompt(question, relation, entity_candidates)
result = run_llm(prompt, args.temperature_exploration, args.max_length, args.opeani_api_keys, args.LLM_type)
return [float(x) * score for x in clean_scores(result, entity_candidates)], entity_candidates, entity_candidates_id
elif args.prune_tools == "bm25":
topn_entities, topn_scores = compute_bm25_similarity(question, entity_candidates, args.width)
else:
model = SentenceTransformer('sentence-transformers/msmarco-distilbert-base-tas-b')
topn_entities, topn_scores = retrieve_top_docs(question, entity_candidates, model, args.width)
if if_all_zero(topn_scores):
topn_scores = [float(1/len(topn_scores))] * len(topn_scores)
return [float(x) * score for x in topn_scores], topn_entities, entity_candidates_id
def update_history(entity_candidates, entity, scores, entity_candidates_id, total_candidates, total_scores, total_relations, total_entities_id, total_topic_entities, total_head):
if len(entity_candidates) == 0:
entity_candidates.append("[FINISH]")
entity_candidates_id = ["[FINISH_ID]"]
candidates_relation = [entity['relation']] * len(entity_candidates)
topic_entities = [entity['entity']] * len(entity_candidates)
head_num = [entity['head']] * len(entity_candidates)
total_candidates.extend(entity_candidates)
total_scores.extend(scores)
total_relations.extend(candidates_relation)
total_entities_id.extend(entity_candidates_id)
total_topic_entities.extend(topic_entities)
total_head.extend(head_num)
return total_candidates, total_scores, total_relations, total_entities_id, total_topic_entities, total_head
def half_stop(question, cluster_chain_of_entities, depth, args):
print("No new knowledge added during search depth %d, stop searching." % depth)
answer = generate_answer(question, cluster_chain_of_entities, args)
save_2_jsonl(question, answer, cluster_chain_of_entities, file_name=args.dataset)
def generate_answer(question, cluster_chain_of_entities, args):
prompt = answer_prompt + question + '\n'
chain_prompt = '\n'.join([', '.join([str(x) for x in chain]) for sublist in cluster_chain_of_entities for chain in sublist])
prompt += "\nKnowledge Triplets: " + chain_prompt + 'A: '
result = run_llm(prompt, args.temperature_reasoning, args.max_length, args.opeani_api_keys, args.LLM_type)
return result
def entity_prune(total_entities_id, total_relations, total_candidates, total_topic_entities, total_head, total_scores, args):
zipped = list(zip(total_entities_id, total_relations, total_candidates, total_topic_entities, total_head, total_scores))
sorted_zipped = sorted(zipped, key=lambda x: x[5], reverse=True)
sorted_entities_id, sorted_relations, sorted_candidates, sorted_topic_entities, sorted_head, sorted_scores = [x[0] for x in sorted_zipped], [x[1] for x in sorted_zipped], [x[2] for x in sorted_zipped], [x[3] for x in sorted_zipped], [x[4] for x in sorted_zipped], [x[5] for x in sorted_zipped]
entities_id, relations, candidates, topics, heads, scores = sorted_entities_id[:args.width], sorted_relations[:args.width], sorted_candidates[:args.width], sorted_topic_entities[:args.width], sorted_head[:args.width], sorted_scores[:args.width]
merged_list = list(zip(entities_id, relations, candidates, topics, heads, scores))
filtered_list = [(id, rel, ent, top, hea, score) for id, rel, ent, top, hea, score in merged_list if score != 0]
if len(filtered_list) ==0:
return False, [], [], [], []
entities_id, relations, candidates, tops, heads, scores = map(list, zip(*filtered_list))
tops = [id2entity_name_or_type(entity_id) for entity_id in tops]
cluster_chain_of_entities = [[(tops[i], relations[i], candidates[i]) for i in range(len(candidates))]]
return True, cluster_chain_of_entities, entities_id, relations, heads
def reasoning(question, cluster_chain_of_entities, args):
prompt = prompt_evaluate + question
chain_prompt = '\n'.join([', '.join([str(x) for x in chain]) for sublist in cluster_chain_of_entities for chain in sublist])
prompt += "\nKnowledge Triplets: " + chain_prompt + 'A: '
response = run_llm(prompt, args.temperature_reasoning, args.max_length, args.opeani_api_keys, args.LLM_type)
result = extract_answer(response)
if if_true(result):
return True, response
else:
return False, response
| [
"\nKnowledge Triplets: PLACEHOLDERA: ",
"P\nL\nA\nC\nE\nH\nO\nL\nD\nE\nR",
"PLACEHOLDERPLACEHOLDER",
"PLACEHOLDERPLACEHOLDER\n"
] |
2024-01-10 | S-Yacer/Dataset-Builder | response_gpt.py | import os
import openai
import json
import time
import argparse
import re
from atomicwrites import atomic_write
import concurrent.futures
import threading
import random
'''Main script to generate responses from GPT, contains some pre-processing for quality of life'''
# Global variable to ensure unique message ids across the threads
next_message_id = 1
# Pre-Processing functions
def format_filename(filename, default_suffix):
if not filename.endswith('.json'):
filename += '.json'
# Ensure we don't duplicate the 'jsons' directory in the path
if not filename.startswith('jsons'):
filename = os.path.join('jsons', filename)
return filename
def clean_empty_assistant_entries(data):
cleaned_data = []
for entry in data:
entry['messages'] = [msg for msg in entry['messages'] if not (msg['role'] == 'assistant' and msg['content'].strip() == '')]
# Check if there are any assistant messages left
assistant_messages = [msg for msg in entry['messages'] if msg['role'] == 'assistant']
# If there are assistant messages, append the entry to the cleaned data
if assistant_messages:
cleaned_data.append(entry)
return cleaned_data
# Sort data entries based on the messages_id
def sort_by_message_id(data):
return sorted(data, key=lambda x: int(x['messages_id']))
# Main function
def process_single_entry(i, rep, entry, args):
global next_message_id
print_lock = threading.Lock()
thread_id = threading.get_ident()
with print_lock:
print(f"[Thread-{thread_id}] messages_id {entry['messages_id']}_{rep} PROCESSING")
new_entry = entry.copy()
new_entry['messages_id'] = f"{str(next_message_id).zfill(5)}"
next_message_id += 1
messages = list(new_entry['messages'])
# The main loop ensures retries until a message is considered complete
while not new_entry.get('messages_complete'):
sleep_time = random.uniform(1, 5)
time.sleep(sleep_time)
try:
# Generate response from GPT
response = openai.ChatCompletion.create(
model=args.model,
messages=messages,
temperature=args.temperature,
top_p=args.top_p,
presence_penalty=args.presence_penalty,
frequency_penalty=args.frequency_penalty,
max_tokens=args.max_tokens
)
assistantResponse = response.choices[0].message["content"]
# Append the assistant's response to the messages list if it's not empty
if assistantResponse.strip() != '':
messages.append({
"role": "assistant",
"content": assistantResponse
})
new_entry['messages'] = messages
new_entry['messages_complete'] = True
except Exception as e:
with print_lock:
print(f"[Thread-{thread_id}] messages_id {entry['messages_id']}_{rep} ERROR: {e} (Retrying in 5-15 seconds...)")
with print_lock:
print(f"[Thread-{thread_id}] messages_id {entry['messages_id']}_{rep} COMPLETE ")
return new_entry
def main(args):
openai.api_key = "OPENAI_API_KEY"
openai.api_base = "https://api.openai.com/v1"
with open(args.input_json, 'r') as input_file:
input_data = json.load(input_file)
output_data = input_data
incomplete_entries = [i for i, entry in enumerate(output_data) if not entry.get('messages_complete')]
# Use threading to process multiple entries concurrently
with concurrent.futures.ThreadPoolExecutor(max_workers=args.max_threads) as executor:
futures = [executor.submit(process_single_entry, i, rep, output_data[i], args) for i in incomplete_entries for rep in range(args.num_responses)]
for future in concurrent.futures.as_completed(futures):
new_entry = future.result()
# Update the output data
output_data.append(new_entry)
output_data = clean_empty_assistant_entries(output_data)
output_data = sort_by_message_id(output_data)
with atomic_write(args.output_json, overwrite=True) as f:
json.dump(output_data, f, indent=4)
print(f"Successfully Completed {args.output_json} with {len(output_data)} entries.")
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='OpenAI chat bot')
# Define cli arguments
parser.add_argument("-input_json", help="Input JSON file", type=str, required=True)
parser.add_argument("-output_json", help="Output JSON file", type=str, default=None)
parser.add_argument("-max_threads", help="Maximum number of threads", type=int, default=1)
parser.add_argument("-num_responses", help="Number of responses per prompt", type=int, default=1)
parser.add_argument("-model", help="OpenAI model to use", type=str, default="gpt-3.5-turbo")
parser.add_argument("-temperature", type=float, default=None)
parser.add_argument("-top_p", type=float, default=None)
parser.add_argument("-presence_penalty", type=float, default=0)
parser.add_argument("-frequency_penalty", type=float, default=0)
parser.add_argument("-max_tokens", type=int, default=1024)
args = parser.parse_args()
# Adjust filenames and handle suffixes
args.input_json = format_filename(args.input_json, '_asked')
args.output_json = format_filename(args.output_json if args.output_json else re.sub(r'_([^_]*)$', '_asked', args.input_json), '')
main(args) | [] |
2024-01-10 | hamdi458/holbertonschool-machine_learning | reinforcement_learning~0-load_env.py |
#!/usr/bin/env python3
"""Load the Environment"""
import gym
def load_frozen_lake(desc=None, map_name=None, is_slippery=False):
"""loads the pre-made FrozenLakeEnv evnironment from OpenAI’s gym"""
env = gym.make("FrozenLake-v0", desc=desc,
map_name=map_name, is_slippery=is_slippery)
return env
| [] |
2024-01-10 | fxy-wang/healthGPT | src~openAI_utils~connect_api.py | from openai import OpenAI
import time
from decouple import config
from prompt_engineering import prompt1, prompt2, prompt3, prompt4, prompt5, prompt6
import os
OPENAI_KEY = os.environ.get('OPENAI_API_KEY')
# Function to initialize the OpenAI client
def initialize_openai_client():
return OpenAI(api_key=OPENAI_KEY)
def files_upload(client):
# Upload a file with an "assistants" purpose
train_data_path = os.environ.get('TRAIN_PATH')
file = client.files.create(
file=open(train_data_path, "rb"),
purpose='assistants'
)
return file
# Function to create an OpenAI assistant
def create_openai_assistant(client, file):
assistant = client.beta.assistants.create(
name="Enter your assistant name here",
description=prompt1,
model="gpt-4-1106-preview",
tools=[{"type": "code_interpreter"}],#,{"type": "retrieval"}],
file_ids=[]
)
return assistant
# Function to run the assistant and retrieve responses
def run_assistant_and_get_responses(client, assistant):
thread = client.beta.threads.create()
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt1,
file_ids=[]
)
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt2,
file_ids=[]
)
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt3,
file_ids=[]
)
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt3,
file_ids=[]
)
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt4,
file_ids=[]
)
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt5,
file_ids=[]
)
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=prompt6,
file_ids=[]
)
while True:
print("User:")
user_message = input()
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content=user_message,
#file_ids=[]
)
run = client.beta.threads.runs.create(
thread_id=thread.id,
assistant_id=assistant.id,
instructions=user_message
)
for _ in range(10): # Retry up to 10 times
run = client.beta.threads.runs.retrieve(
thread_id=thread.id,
run_id=run.id
)
if run.status == "completed":
messages = client.beta.threads.messages.list(
thread_id=thread.id
)
assistant_response = messages.data[0].content[0].text.value
print()
print("HealthHack:")
print(assistant_response)
print()
break
time.sleep(20)
if run.status != "completed":
break
# Main function to run the entire pipeline
def main():
try:
client = initialize_openai_client()
file = files_upload(client)
assistant = create_openai_assistant(client, file)
#thread, message = create_thread_and_message(client, file)
assistant_response = run_assistant_and_get_responses(client, assistant)
#print(assistant_response)
except Exception as e:
print(f"An error occurred: {str(e)}")
if __name__ == "__main__":
main() | [] |
2024-01-10 | adarshpalaskar1/FlipLogGPT_LLM | FlipLogGPT.py | #!/usr/bin/env python3
from dotenv import load_dotenv
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.vectorstores import Chroma
from langchain.llms import GPT4All, LlamaCpp
import os
import argparse
import time
load_dotenv()
embeddings_model_name = os.environ.get("EMBEDDINGS_MODEL_NAME")
persist_directory = os.environ.get('PERSIST_DIRECTORY')
model_type = os.environ.get('MODEL_TYPE')
model_path = os.environ.get('MODEL_PATH')
model_n_ctx = os.environ.get('MODEL_N_CTX')
model_n_batch = int(os.environ.get('MODEL_N_BATCH',8))
target_source_chunks = int(os.environ.get('TARGET_SOURCE_CHUNKS',4))
from constants import CHROMA_SETTINGS
def react_for_logs(query):
manual_react = f"""
Find and report which logs breach the compliance policy. Provide actionable insights to mitigate the risk of future breaches.
System Log:
[2023-08-20 12:15:32] [info] [client 192.168.0.1] GET /index.html HTTP/1.1 200 5124
Compliance Breaches:
Successful page request- The log entry shows a successful GET request (GET /index.html) from client IP 192.168.0.1, which returned a 200 status code. This indicates that the client accessed the homepage successfully, and the page size was 5124 bytes.
Actionable Insights:
Regularly review and monitor server configurations to ensure all required files and directories exist and are accessible.
Implement proper access controls and permissions to restrict unauthorized access to sensitive files or system resources.
Find and report which logs breach the compliance policy. Provide actionable insights to mitigate the risk of future breaches.
System Log:
[2023-08-20 12:17:45] [error] [client 192.168.0.2] File does not exist: /var/www/html/includes/config.php
Compliance Breaches:
Missing file- The log entry indicates an error where the client at IP 192.168.0.2 requested a file (/var/www/html/includes/config.php) that does not exist. This could be an indication of a misconfiguration or an attempt to access sensitive files.
Actionable Insights:
Review the server configuration to ensure that the file path is correct and that sensitive files are not accessible to the public.
Monitor the IP address 192.168.0.2 for further suspicious activity or repeated attempts to access sensitive files.
Find and report which logs breach the compliance policy. Provide actionable insights to mitigate the risk of future breaches.
System Log:
[2023-08-20 12:19:10] [info] [client 192.168.0.3] POST /login.php HTTP/1.1 302 0
Compliance Breaches:
The log entry shows an info-level log indicating a POST request (POST /login.php) from client IP 192.168.0.3, which resulted in a 302 status code. This suggests a form submission, likely for user authentication or login.
Actionable Insights:
No immediate action is required unless there are suspicious patterns associated with this IP address.
Find and report which logs breach the compliance policy. Provide actionable insights to mitigate the risk of future breaches.
System Log:
{query}
"""
return manual_react
def react_for_system_policies(query):
manual_react = f"""
List out all the possible system policies that are being violated.
{query}
"""
return manual_react
def main():
# Parse the command line arguments
args = parse_arguments()
embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)
db = Chroma(persist_directory=persist_directory, embedding_function=embeddings, client_settings=CHROMA_SETTINGS)
retriever = db.as_retriever(search_kwargs={"k": target_source_chunks})
# activate/deactivate the streaming StdOut callback for LLMs
callbacks = [] if args.mute_stream else [StreamingStdOutCallbackHandler()]
# Prepare the LLM
match model_type:
case "LlamaCpp":
llm = LlamaCpp(model_path=model_path, max_tokens=model_n_ctx, n_batch=model_n_batch, callbacks=callbacks, verbose=False)
case "GPT4All":
llm = GPT4All(model=model_path, max_tokens=model_n_ctx, backend='gptj', n_batch=model_n_batch, callbacks=callbacks, verbose=False)
case _default:
# raise exception if model_type is not supported
raise Exception(f"Model type {model_type} is not supported. Please choose one of the following: LlamaCpp, GPT4All")
qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, return_source_documents= not args.hide_source)
# Interactive questions and answers
while True:
query = input("\nEnter a query: ")
if query == "exit":
break
if query.strip() == "":
continue
# Get the answer from the chain
start = time.time()
res = qa(react_for_logs(query))
answer, docs = res['result'], [] if args.hide_source else res['source_documents']
end = time.time()
# Print the result
print("\n\n> Question:")
print(query)
print(f"\n> Answer (took {round(end - start, 2)} s.):")
print(answer)
# Print the relevant sources used for the answer
for document in docs:
print("\n> " + document.metadata["source"] + ":")
print(document.page_content)
def parse_arguments():
parser = argparse.ArgumentParser(description='Interactive LLM for logs and security analysis with vectorstores')
parser.add_argument("--hide-source", "-S", action='store_true',
help='Use this flag to disable printing of source documents used for answers.')
parser.add_argument("--mute-stream", "-M",
action='store_true',
help='Use this flag to disable the streaming StdOut callback for LLMs.')
return parser.parse_args()
if __name__ == "__main__":
main()
| [] |
2024-01-10 | krishnaik06/End-To-End-Gemini-Project | vision.py | # Q&A Chatbot
#from langchain.llms import OpenAI
from dotenv import load_dotenv
load_dotenv() # take environment variables from .env.
import streamlit as st
import os
import pathlib
import textwrap
from PIL import Image
import google.generativeai as genai
os.getenv("GOOGLE_API_KEY")
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
## Function to load OpenAI model and get respones
def get_gemini_response(input,image):
model = genai.GenerativeModel('gemini-pro-vision')
if input!="":
response = model.generate_content([input,image])
else:
response = model.generate_content(image)
return response.text
##initialize our streamlit app
st.set_page_config(page_title="Gemini Image Demo")
st.header("Gemini Application")
input=st.text_input("Input Prompt: ",key="input")
uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
image=""
if uploaded_file is not None:
image = Image.open(uploaded_file)
st.image(image, caption="Uploaded Image.", use_column_width=True)
submit=st.button("Tell me about the image")
## If ask button is clicked
if submit:
response=get_gemini_response(input,image)
st.subheader("The Response is")
st.write(response)
| [] |
2024-01-10 | panni-xiaozi/ChuanhuChatGPT | modules~models~base_model.py | from __future__ import annotations
from typing import TYPE_CHECKING, List
import logging
import json
import commentjson as cjson
import os
import sys
import requests
import urllib3
import traceback
import pathlib
import shutil
from tqdm import tqdm
import colorama
from duckduckgo_search import DDGS
from itertools import islice
import asyncio
import aiohttp
from enum import Enum
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.callbacks.manager import BaseCallbackManager
from typing import Any, Dict, List, Optional, Union
from langchain.callbacks.base import BaseCallbackHandler
from langchain.input import print_text
from langchain.schema import AgentAction, AgentFinish, LLMResult
from threading import Thread, Condition
from collections import deque
from langchain.chat_models.base import BaseChatModel
from langchain.schema import HumanMessage, AIMessage, SystemMessage, BaseMessage
from ..presets import *
from ..index_func import *
from ..utils import *
from .. import shared
from ..config import retrieve_proxy
class CallbackToIterator:
def __init__(self):
self.queue = deque()
self.cond = Condition()
self.finished = False
def callback(self, result):
with self.cond:
self.queue.append(result)
self.cond.notify() # Wake up the generator.
def __iter__(self):
return self
def __next__(self):
with self.cond:
# Wait for a value to be added to the queue.
while not self.queue and not self.finished:
self.cond.wait()
if not self.queue:
raise StopIteration()
return self.queue.popleft()
def finish(self):
with self.cond:
self.finished = True
self.cond.notify() # Wake up the generator if it's waiting.
def get_action_description(text):
match = re.search('```(.*?)```', text, re.S)
json_text = match.group(1)
# 把json转化为python字典
json_dict = json.loads(json_text)
# 提取'action'和'action_input'的值
action_name = json_dict['action']
action_input = json_dict['action_input']
if action_name != "Final Answer":
return f'<!-- S O PREFIX --><p class="agent-prefix">{action_name}: {action_input}\n\n</p><!-- E O PREFIX -->'
else:
return ""
class ChuanhuCallbackHandler(BaseCallbackHandler):
def __init__(self, callback) -> None:
"""Initialize callback handler."""
self.callback = callback
def on_agent_action(
self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
) -> Any:
self.callback(get_action_description(action.log))
def on_tool_end(
self,
output: str,
color: Optional[str] = None,
observation_prefix: Optional[str] = None,
llm_prefix: Optional[str] = None,
**kwargs: Any,
) -> None:
"""If not the final action, print out observation."""
# if observation_prefix is not None:
# self.callback(f"\n\n{observation_prefix}")
# self.callback(output)
# if llm_prefix is not None:
# self.callback(f"\n\n{llm_prefix}")
if observation_prefix is not None:
logging.info(observation_prefix)
self.callback(output)
if llm_prefix is not None:
logging.info(llm_prefix)
def on_agent_finish(
self, finish: AgentFinish, color: Optional[str] = None, **kwargs: Any
) -> None:
# self.callback(f"{finish.log}\n\n")
logging.info(finish.log)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run on new LLM token. Only available when streaming is enabled."""
self.callback(token)
def on_chat_model_start(self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs: Any) -> Any:
"""Run when a chat model starts running."""
pass
class ModelType(Enum):
Unknown = -1
OpenAI = 0
ChatGLM = 1
LLaMA = 2
XMChat = 3
StableLM = 4
MOSS = 5
YuanAI = 6
Minimax = 7
ChuanhuAgent = 8
GooglePaLM = 9
LangchainChat = 10
Midjourney = 11
Spark = 12
OpenAIInstruct = 13
Claude = 14
Qwen = 15
OpenAIVision = 16
@classmethod
def get_type(cls, model_name: str):
model_type = None
model_name_lower = model_name.lower()
if "gpt" in model_name_lower:
if "instruct" in model_name_lower:
model_type = ModelType.OpenAIInstruct
elif "vision" in model_name_lower:
model_type = ModelType.OpenAIVision
else:
model_type = ModelType.OpenAI
elif "chatglm" in model_name_lower:
model_type = ModelType.ChatGLM
elif "llama" in model_name_lower or "alpaca" in model_name_lower:
model_type = ModelType.LLaMA
elif "xmchat" in model_name_lower:
model_type = ModelType.XMChat
elif "stablelm" in model_name_lower:
model_type = ModelType.StableLM
elif "moss" in model_name_lower:
model_type = ModelType.MOSS
elif "yuanai" in model_name_lower:
model_type = ModelType.YuanAI
elif "minimax" in model_name_lower:
model_type = ModelType.Minimax
elif "川虎助理" in model_name_lower:
model_type = ModelType.ChuanhuAgent
elif "palm" in model_name_lower:
model_type = ModelType.GooglePaLM
elif "midjourney" in model_name_lower:
model_type = ModelType.Midjourney
elif "azure" in model_name_lower or "api" in model_name_lower:
model_type = ModelType.LangchainChat
elif "星火大模型" in model_name_lower:
model_type = ModelType.Spark
elif "claude" in model_name_lower:
model_type = ModelType.Claude
elif "qwen" in model_name_lower:
model_type = ModelType.Qwen
else:
model_type = ModelType.LLaMA
return model_type
class BaseLLMModel:
def __init__(
self,
model_name,
system_prompt=INITIAL_SYSTEM_PROMPT,
temperature=1.0,
top_p=1.0,
n_choices=1,
stop=None,
max_generation_token=None,
presence_penalty=0,
frequency_penalty=0,
logit_bias=None,
user="",
) -> None:
self.history = []
self.all_token_counts = []
self.model_name = model_name
self.model_type = ModelType.get_type(model_name)
try:
self.token_upper_limit = MODEL_METADATA[model_name]["token_limit"]
except KeyError:
self.token_upper_limit = DEFAULT_TOKEN_LIMIT
self.interrupted = False
self.system_prompt = system_prompt
self.api_key = None
self.need_api_key = False
self.single_turn = False
self.history_file_path = get_first_history_name(user)
self.temperature = temperature
self.top_p = top_p
self.n_choices = n_choices
self.stop_sequence = stop
self.max_generation_token = None
self.presence_penalty = presence_penalty
self.frequency_penalty = frequency_penalty
self.logit_bias = logit_bias
self.user_identifier = user
def get_answer_stream_iter(self):
"""stream predict, need to be implemented
conversations are stored in self.history, with the most recent question, in OpenAI format
should return a generator, each time give the next word (str) in the answer
"""
logging.warning(
"stream predict not implemented, using at once predict instead")
response, _ = self.get_answer_at_once()
yield response
def get_answer_at_once(self):
"""predict at once, need to be implemented
conversations are stored in self.history, with the most recent question, in OpenAI format
Should return:
the answer (str)
total token count (int)
"""
logging.warning(
"at once predict not implemented, using stream predict instead")
response_iter = self.get_answer_stream_iter()
count = 0
for response in response_iter:
count += 1
return response, sum(self.all_token_counts) + count
def billing_info(self):
"""get billing infomation, inplement if needed"""
# logging.warning("billing info not implemented, using default")
return BILLING_NOT_APPLICABLE_MSG
def count_token(self, user_input):
"""get token count from input, implement if needed"""
# logging.warning("token count not implemented, using default")
return len(user_input)
def stream_next_chatbot(self, inputs, chatbot, fake_input=None, display_append=""):
def get_return_value():
return chatbot, status_text
status_text = i18n("开始实时传输回答……")
if fake_input:
chatbot.append((fake_input, ""))
else:
chatbot.append((inputs, ""))
user_token_count = self.count_token(inputs)
self.all_token_counts.append(user_token_count)
logging.debug(f"输入token计数: {user_token_count}")
stream_iter = self.get_answer_stream_iter()
if display_append:
display_append = '\n\n<hr class="append-display no-in-raw" />' + display_append
partial_text = ""
token_increment = 1
for partial_text in stream_iter:
if type(partial_text) == tuple:
partial_text, token_increment = partial_text
chatbot[-1] = (chatbot[-1][0], partial_text + display_append)
self.all_token_counts[-1] += token_increment
status_text = self.token_message()
yield get_return_value()
if self.interrupted:
self.recover()
break
self.history.append(construct_assistant(partial_text))
def next_chatbot_at_once(self, inputs, chatbot, fake_input=None, display_append=""):
if fake_input:
chatbot.append((fake_input, ""))
else:
chatbot.append((inputs, ""))
if fake_input is not None:
user_token_count = self.count_token(fake_input)
else:
user_token_count = self.count_token(inputs)
self.all_token_counts.append(user_token_count)
ai_reply, total_token_count = self.get_answer_at_once()
self.history.append(construct_assistant(ai_reply))
if fake_input is not None:
self.history[-2] = construct_user(fake_input)
chatbot[-1] = (chatbot[-1][0], ai_reply + display_append)
if fake_input is not None:
self.all_token_counts[-1] += count_token(
construct_assistant(ai_reply))
else:
self.all_token_counts[-1] = total_token_count - \
sum(self.all_token_counts)
status_text = self.token_message()
return chatbot, status_text
def handle_file_upload(self, files, chatbot, language):
"""if the model accepts multi modal input, implement this function"""
status = gr.Markdown.update()
if files:
index = construct_index(self.api_key, file_src=files)
status = i18n("索引构建完成")
return gr.Files.update(), chatbot, status
def summarize_index(self, files, chatbot, language):
status = gr.Markdown.update()
if files:
index = construct_index(self.api_key, file_src=files)
status = i18n("总结完成")
logging.info(i18n("生成内容总结中……"))
os.environ["OPENAI_API_KEY"] = self.api_key
from langchain.chains.summarize import load_summarize_chain
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.callbacks import StdOutCallbackHandler
prompt_template = "Write a concise summary of the following:\n\n{text}\n\nCONCISE SUMMARY IN " + language + ":"
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["text"])
llm = ChatOpenAI()
chain = load_summarize_chain(
llm, chain_type="map_reduce", return_intermediate_steps=True, map_prompt=PROMPT, combine_prompt=PROMPT)
summary = chain({"input_documents": list(index.docstore.__dict__[
"_dict"].values())}, return_only_outputs=True)["output_text"]
print(i18n("总结") + f": {summary}")
chatbot.append([i18n("上传了")+str(len(files))+"个文件", summary])
return chatbot, status
def prepare_inputs(self, real_inputs, use_websearch, files, reply_language, chatbot, load_from_cache_if_possible=True):
display_append = []
limited_context = False
if type(real_inputs) == list:
fake_inputs = real_inputs[0]['text']
else:
fake_inputs = real_inputs
if files:
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from langchain.vectorstores.base import VectorStoreRetriever
limited_context = True
msg = "加载索引中……"
logging.info(msg)
index = construct_index(self.api_key, file_src=files, load_from_cache_if_possible=load_from_cache_if_possible)
assert index is not None, "获取索引失败"
msg = "索引获取成功，生成回答中……"
logging.info(msg)
with retrieve_proxy():
retriever = VectorStoreRetriever(vectorstore=index, search_type="similarity_score_threshold", search_kwargs={
"k": 6, "score_threshold": 0.5})
try:
relevant_documents = retriever.get_relevant_documents(
fake_inputs)
except AssertionError:
return self.prepare_inputs(fake_inputs, use_websearch, files, reply_language, chatbot, load_from_cache_if_possible=False)
reference_results = [[d.page_content.strip("�"), os.path.basename(
d.metadata["source"])] for d in relevant_documents]
reference_results = add_source_numbers(reference_results)
display_append = add_details(reference_results)
display_append = "\n\n" + "".join(display_append)
if type(real_inputs) == list:
real_inputs[0]["text"] = (
replace_today(PROMPT_TEMPLATE)
.replace("{query_str}", fake_inputs)
.replace("{context_str}", "\n\n".join(reference_results))
.replace("{reply_language}", reply_language)
)
else:
real_inputs = (
replace_today(PROMPT_TEMPLATE)
.replace("{query_str}", real_inputs)
.replace("{context_str}", "\n\n".join(reference_results))
.replace("{reply_language}", reply_language)
)
elif use_websearch:
search_results = []
with DDGS() as ddgs:
ddgs_gen = ddgs.text(fake_inputs, backend="lite")
for r in islice(ddgs_gen, 10):
search_results.append(r)
reference_results = []
for idx, result in enumerate(search_results):
logging.debug(f"搜索结果{idx + 1}：{result}")
domain_name = urllib3.util.parse_url(result['href']).host
reference_results.append([result['body'], result['href']])
display_append.append(
# f"{idx+1}. [{domain_name}]({result['href']})\n"
f"<a href=\"{result['href']}\" target=\"_blank\">{idx+1}. {result['title']}</a>"
)
reference_results = add_source_numbers(reference_results)
# display_append = "<ol>\n\n" + "".join(display_append) + "</ol>"
display_append = '<div class = "source-a">' + \
"".join(display_append) + '</div>'
if type(real_inputs) == list:
real_inputs[0]["text"] = (
replace_today(WEBSEARCH_PTOMPT_TEMPLATE)
.replace("{query}", fake_inputs)
.replace("{web_results}", "\n\n".join(reference_results))
.replace("{reply_language}", reply_language)
)
else:
real_inputs = (
replace_today(WEBSEARCH_PTOMPT_TEMPLATE)
.replace("{query}", fake_inputs)
.replace("{web_results}", "\n\n".join(reference_results))
.replace("{reply_language}", reply_language)
)
else:
display_append = ""
return limited_context, fake_inputs, display_append, real_inputs, chatbot
def predict(
self,
inputs,
chatbot,
stream=False,
use_websearch=False,
files=None,
reply_language="中文",
should_check_token_count=True,
): # repetition_penalty, top_k
status_text = "开始生成回答……"
if type(inputs) == list:
logging.info(
"用户" + f"{self.user_identifier}" + "的输入为：" +
colorama.Fore.BLUE + "(" + str(len(inputs)-1) + " images) " + f"{inputs[0]['text']}" + colorama.Style.RESET_ALL
)
else:
logging.info(
"用户" + f"{self.user_identifier}" + "的输入为：" +
colorama.Fore.BLUE + f"{inputs}" + colorama.Style.RESET_ALL
)
if should_check_token_count:
if type(inputs) == list:
yield chatbot + [(inputs[0]['text'], "")], status_text
else:
yield chatbot + [(inputs, "")], status_text
if reply_language == "跟随问题语言（不稳定）":
reply_language = "the same language as the question, such as English, 中文, 日本語, Español, Français, or Deutsch."
limited_context, fake_inputs, display_append, inputs, chatbot = self.prepare_inputs(
real_inputs=inputs, use_websearch=use_websearch, files=files, reply_language=reply_language, chatbot=chatbot)
yield chatbot + [(fake_inputs, "")], status_text
if (
self.need_api_key and
self.api_key is None
and not shared.state.multi_api_key
):
status_text = STANDARD_ERROR_MSG + NO_APIKEY_MSG
logging.info(status_text)
chatbot.append((fake_inputs, ""))
if len(self.history) == 0:
self.history.append(construct_user(fake_inputs))
self.history.append("")
self.all_token_counts.append(0)
else:
self.history[-2] = construct_user(fake_inputs)
yield chatbot + [(fake_inputs, "")], status_text
return
elif len(fake_inputs.strip()) == 0:
status_text = STANDARD_ERROR_MSG + NO_INPUT_MSG
logging.info(status_text)
yield chatbot + [(fake_inputs, "")], status_text
return
if self.single_turn:
self.history = []
self.all_token_counts = []
if type(inputs) == list:
self.history.append(inputs)
else:
self.history.append(construct_user(inputs))
try:
if stream:
logging.debug("使用流式传输")
iter = self.stream_next_chatbot(
inputs,
chatbot,
fake_input=fake_inputs,
display_append=display_append,
)
for chatbot, status_text in iter:
yield chatbot, status_text
else:
logging.debug("不使用流式传输")
chatbot, status_text = self.next_chatbot_at_once(
inputs,
chatbot,
fake_input=fake_inputs,
display_append=display_append,
)
yield chatbot, status_text
except Exception as e:
traceback.print_exc()
status_text = STANDARD_ERROR_MSG + beautify_err_msg(str(e))
yield chatbot, status_text
if len(self.history) > 1 and self.history[-1]["content"] != fake_inputs:
logging.info(
"回答为："
+ colorama.Fore.BLUE
+ f"{self.history[-1]['content']}"
+ colorama.Style.RESET_ALL
)
if limited_context:
# self.history = self.history[-4:]
# self.all_token_counts = self.all_token_counts[-2:]
self.history = []
self.all_token_counts = []
max_token = self.token_upper_limit - TOKEN_OFFSET
if sum(self.all_token_counts) > max_token and should_check_token_count:
count = 0
while (
sum(self.all_token_counts)
> self.token_upper_limit * REDUCE_TOKEN_FACTOR
and sum(self.all_token_counts) > 0
):
count += 1
del self.all_token_counts[0]
del self.history[:2]
logging.info(status_text)
status_text = f"为了防止token超限，模型忘记了早期的 {count} 轮对话"
yield chatbot, status_text
self.auto_save(chatbot)
def retry(
self,
chatbot,
stream=False,
use_websearch=False,
files=None,
reply_language="中文",
):
logging.debug("重试中……")
if len(self.history) > 1:
inputs = self.history[-2]["content"]
del self.history[-2:]
if len(self.all_token_counts) > 0:
self.all_token_counts.pop()
elif len(chatbot) > 0:
inputs = chatbot[-1][0]
if '<div class="user-message">' in inputs:
inputs = inputs.split('<div class="user-message">')[1]
inputs = inputs.split("</div>")[0]
elif len(self.history) == 1:
inputs = self.history[-1]["content"]
del self.history[-1]
else:
yield chatbot, f"{STANDARD_ERROR_MSG}上下文是空的"
return
iter = self.predict(
inputs,
chatbot,
stream=stream,
use_websearch=use_websearch,
files=files,
reply_language=reply_language,
)
for x in iter:
yield x
logging.debug("重试完毕")
# def reduce_token_size(self, chatbot):
# logging.info("开始减少token数量……")
# chatbot, status_text = self.next_chatbot_at_once(
# summarize_prompt,
# chatbot
# )
# max_token_count = self.token_upper_limit * REDUCE_TOKEN_FACTOR
# num_chat = find_n(self.all_token_counts, max_token_count)
# logging.info(f"previous_token_count: {self.all_token_counts}, keeping {num_chat} chats")
# chatbot = chatbot[:-1]
# self.history = self.history[-2*num_chat:] if num_chat > 0 else []
# self.all_token_counts = self.all_token_counts[-num_chat:] if num_chat > 0 else []
# msg = f"保留了最近{num_chat}轮对话"
# logging.info(msg)
# logging.info("减少token数量完毕")
# return chatbot, msg + "，" + self.token_message(self.all_token_counts if len(self.all_token_counts) > 0 else [0])
def interrupt(self):
self.interrupted = True
def recover(self):
self.interrupted = False
def set_token_upper_limit(self, new_upper_limit):
self.token_upper_limit = new_upper_limit
print(f"token上限设置为{new_upper_limit}")
def set_temperature(self, new_temperature):
self.temperature = new_temperature
def set_top_p(self, new_top_p):
self.top_p = new_top_p
def set_n_choices(self, new_n_choices):
self.n_choices = new_n_choices
def set_stop_sequence(self, new_stop_sequence: str):
new_stop_sequence = new_stop_sequence.split(",")
self.stop_sequence = new_stop_sequence
def set_max_tokens(self, new_max_tokens):
self.max_generation_token = new_max_tokens
def set_presence_penalty(self, new_presence_penalty):
self.presence_penalty = new_presence_penalty
def set_frequency_penalty(self, new_frequency_penalty):
self.frequency_penalty = new_frequency_penalty
def set_logit_bias(self, logit_bias):
logit_bias = logit_bias.split()
bias_map = {}
encoding = tiktoken.get_encoding("cl100k_base")
for line in logit_bias:
word, bias_amount = line.split(":")
if word:
for token in encoding.encode(word):
bias_map[token] = float(bias_amount)
self.logit_bias = bias_map
def set_user_identifier(self, new_user_identifier):
self.user_identifier = new_user_identifier
def set_system_prompt(self, new_system_prompt):
self.system_prompt = new_system_prompt
def set_key(self, new_access_key):
if "*" not in new_access_key:
self.api_key = new_access_key.strip()
msg = i18n("API密钥更改为了") + hide_middle_chars(self.api_key)
logging.info(msg)
return self.api_key, msg
else:
return gr.update(), gr.update()
def set_single_turn(self, new_single_turn):
self.single_turn = new_single_turn
def reset(self, remain_system_prompt=False):
self.history = []
self.all_token_counts = []
self.interrupted = False
self.history_file_path = new_auto_history_filename(self.user_identifier)
history_name = self.history_file_path[:-5]
choices = [history_name] + get_history_names(self.user_identifier)
system_prompt = self.system_prompt if remain_system_prompt else ""
return [], self.token_message([0]), gr.Radio.update(choices=choices, value=history_name), system_prompt
def delete_first_conversation(self):
if self.history:
del self.history[:2]
del self.all_token_counts[0]
return self.token_message()
def delete_last_conversation(self, chatbot):
if len(chatbot) > 0 and STANDARD_ERROR_MSG in chatbot[-1][1]:
msg = "由于包含报错信息，只删除chatbot记录"
chatbot = chatbot[:-1]
return chatbot, self.history
if len(self.history) > 0:
self.history = self.history[:-2]
if len(chatbot) > 0:
msg = "删除了一组chatbot对话"
chatbot = chatbot[:-1]
if len(self.all_token_counts) > 0:
msg = "删除了一组对话的token计数记录"
self.all_token_counts.pop()
msg = "删除了一组对话"
self.auto_save(chatbot)
return chatbot, msg
def token_message(self, token_lst=None):
if token_lst is None:
token_lst = self.all_token_counts
token_sum = 0
for i in range(len(token_lst)):
token_sum += sum(token_lst[: i + 1])
return i18n("Token 计数: ") + f"{sum(token_lst)}" + i18n("，本次对话累计消耗了 ") + f"{token_sum} tokens"
def rename_chat_history(self, filename, chatbot, user_name):
if filename == "":
return gr.update()
if not filename.endswith(".json"):
filename += ".json"
self.delete_chat_history(self.history_file_path, user_name)
# 命名重复检测
repeat_file_index = 2
full_path = os.path.join(HISTORY_DIR, user_name, filename)
while os.path.exists(full_path):
full_path = os.path.join(HISTORY_DIR, user_name, f"{repeat_file_index}_{filename}")
repeat_file_index += 1
filename = os.path.basename(full_path)
self.history_file_path = filename
save_file(filename, self.system_prompt, self.history, chatbot, user_name)
return init_history_list(user_name)
def auto_name_chat_history(self, name_chat_method, user_question, chatbot, user_name, single_turn_checkbox):
if len(self.history) == 2 and not single_turn_checkbox:
user_question = self.history[0]["content"]
if type(user_question) == list:
user_question = user_question[0]["text"]
filename = replace_special_symbols(user_question)[:16] + ".json"
return self.rename_chat_history(filename, chatbot, user_name)
else:
return gr.update()
def auto_save(self, chatbot):
save_file(self.history_file_path, self.system_prompt,
self.history, chatbot, self.user_identifier)
def export_markdown(self, filename, chatbot, user_name):
if filename == "":
return
if not filename.endswith(".md"):
filename += ".md"
save_file(filename, self.system_prompt, self.history, chatbot, user_name)
def load_chat_history(self, new_history_file_path=None, username=None):
logging.debug(f"{self.user_identifier} 加载对话历史中……")
if new_history_file_path is not None:
if type(new_history_file_path) != str:
# copy file from new_history_file_path.name to os.path.join(HISTORY_DIR, self.user_identifier)
new_history_file_path = new_history_file_path.name
shutil.copyfile(new_history_file_path, os.path.join(
HISTORY_DIR, self.user_identifier, os.path.basename(new_history_file_path)))
self.history_file_path = os.path.basename(new_history_file_path)
else:
self.history_file_path = new_history_file_path
try:
if self.history_file_path == os.path.basename(self.history_file_path):
history_file_path = os.path.join(
HISTORY_DIR, self.user_identifier, self.history_file_path)
else:
history_file_path = self.history_file_path
if not self.history_file_path.endswith(".json"):
history_file_path += ".json"
with open(history_file_path, "r", encoding="utf-8") as f:
json_s = json.load(f)
try:
if type(json_s["history"][0]) == str:
logging.info("历史记录格式为旧版，正在转换……")
new_history = []
for index, item in enumerate(json_s["history"]):
if index % 2 == 0:
new_history.append(construct_user(item))
else:
new_history.append(construct_assistant(item))
json_s["history"] = new_history
logging.info(new_history)
except:
pass
if len(json_s["chatbot"]) < len(json_s["history"]):
logging.info("Trimming corrupted history...")
json_s["history"] = json_s["history"][-len(json_s["chatbot"]):]
logging.info(f"Trimmed history: {json_s['history']}")
logging.debug(f"{self.user_identifier} 加载对话历史完毕")
self.history = json_s["history"]
return os.path.basename(self.history_file_path), json_s["system"], json_s["chatbot"]
except:
# 没有对话历史或者对话历史解析失败
logging.info(f"没有找到对话历史记录 {self.history_file_path}")
return self.history_file_path, "", []
def delete_chat_history(self, filename, user_name):
if filename == "CANCELED":
return gr.update(), gr.update(), gr.update()
if filename == "":
return i18n("你没有选择任何对话历史"), gr.update(), gr.update()
if not filename.endswith(".json"):
filename += ".json"
if filename == os.path.basename(filename):
history_file_path = os.path.join(HISTORY_DIR, user_name, filename)
else:
history_file_path = filename
try:
os.remove(history_file_path)
return i18n("删除对话历史成功"), get_history_list(user_name), []
except:
logging.info(f"删除对话历史失败 {history_file_path}")
return i18n("对话历史")+filename+i18n("已经被删除啦"), get_history_list(user_name), []
def auto_load(self):
filepath = get_history_filepath(self.user_identifier)
if not filepath:
self.history_file_path = new_auto_history_filename(
self.user_identifier)
else:
self.history_file_path = filepath
filename, system_prompt, chatbot = self.load_chat_history()
filename = filename[:-5]
return filename, system_prompt, chatbot
def like(self):
"""like the last response, implement if needed
"""
return gr.update()
def dislike(self):
"""dislike the last response, implement if needed
"""
return gr.update()
class Base_Chat_Langchain_Client(BaseLLMModel):
def __init__(self, model_name, user_name=""):
super().__init__(model_name, user=user_name)
self.need_api_key = False
self.model = self.setup_model()
def setup_model(self):
# inplement this to setup the model then return it
pass
def _get_langchain_style_history(self):
history = [SystemMessage(content=self.system_prompt)]
for i in self.history:
if i["role"] == "user":
history.append(HumanMessage(content=i["content"]))
elif i["role"] == "assistant":
history.append(AIMessage(content=i["content"]))
return history
def get_answer_at_once(self):
assert isinstance(
self.model, BaseChatModel), "model is not instance of LangChain BaseChatModel"
history = self._get_langchain_style_history()
response = self.model.generate(history)
return response.content, sum(response.content)
def get_answer_stream_iter(self):
it = CallbackToIterator()
assert isinstance(
self.model, BaseChatModel), "model is not instance of LangChain BaseChatModel"
history = self._get_langchain_style_history()
def thread_func():
self.model(messages=history, callbacks=[
ChuanhuCallbackHandler(it.callback)])
it.finish()
t = Thread(target=thread_func)
t.start()
partial_text = ""
for value in it:
partial_text += value
yield partial_text
| [
"content",
"Write a concise summary of the following:\n\n{text}\n\nCONCISE SUMMARY IN PLACEHOLDER:"
] |
2024-01-10 | HungBacktracking/ChatGPT-Problem-Solver | for_use_api.py | import openai
import argparse
import time
import re
from dataset import get_data
def get_response(args, user_request, max_len, temp):
responese = openai.Completion.create(
engine = args.model_name,
prompt = user_request,
max_tokens = max_len,
n = 1,
temperature = temp
)
return responese
def convert_to_submit_file(api_result: list = []):
answer_start = api_result.find("Answer: ")
if answer_start != -1:
answer_end = api_result.find(",", answer_start)
answer_part = api_result[answer_start + len("Answer: "):answer_end]
if any(c.isalpha() for c in answer_part):
answer = answer_part[0:answer_part.find(")")]
else:
answer = answer_part
return answer.lower()
else:
answer = api_result
return answer.lower()
return 'Nan'
def main(args):
with open("openai_api_key.txt", "r") as f:
openai.api_key = f.readline()
test_examples = get_data(args.data)
results = []
with open('./results/results.txt', 'r') as read:
results = read.readlines()
curr_indx = 1
last_indx = len(results)
print("Last request: ", last_indx)
with open('./results/results.txt', 'a') as f:
for problem in test_examples:
print(problem)
prompt = "Help me choose the correct answer to the following problem. Note that you only need to return the letters corresponding to the chosen answer. \nQuestion:"
ques = problem["Problem"]
max_len = 20
temp = 0.2
user_request = prompt + ques
responese = {}
if curr_indx > last_indx:
while 'id' not in responese:
try:
t1 = time.time()
responese = get_response(args, user_request, max_len, temp)
#print(user_request)
t2 = time.time()
time_request = t2 - t1
answer = responese.choices[0].text
#results.append([answer, time_request])
except:
print("Waiting...")
time.sleep(20)
continue
print(f"Time request for {problem['id']}: {time_request}, answer: {answer}")
choose = convert_to_submit_file(answer)
f.write(choose + '\t' + str(time_request) + '\n')
curr_indx += 1
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--model_name", type=str,
default="text-davinci-003",
help= "Name to request model from openai"
)
parser.add_argument(
"--data", type=str,
default="./data/test.json",
help="Path to data test"
)
args = parser.parse_args()
main(args)
| [
"Help me choose the correct answer to the following problem. Note that you only need to return the letters corresponding to the chosen answer. \nQuestion:"
] |
2024-01-10 | HungBacktracking/ChatGPT-Problem-Solver | assistant.py | from openai import OpenAI
import os, json
import time
def create_assistant(client):
assistant_file_path = 'assistant.json'
if os.path.exists(assistant_file_path):
with open(assistant_file_path, 'r') as file:
assistant_data = json.load(file)
assistant_id = assistant_data['assistant_id']
print("Loaded existing assistant ID.")
else:
file = client.files.create(file=open("knowledges_small_1.json", "rb"),
purpose='assistants')
assistant = client.beta.assistants.create(instructions="""
Please solve the following problem with a meticulous and precise approach, characteristic of someone with OCD who is committed to accuracy in every response. Begin by carefully reading the problem, paying attention to all details. Derive an equation based on the relevant mathematical or scientific principles inherent in the problem. Once you have the equation, use the options provided in the problem, like 'The monthly rent of a shop of dimensions 20 feet × 18 feet is Rs. 1440. What is the annual rent per square foot of the shop? Options: a) 48, b) 56, c) 68, d) 87, e) 92', to substitute into this equation.
Carefully analyze the problem, considering all potential scenarios. Solve the problem step by step, substituting the options into your derived equation. Review your solution meticulously for errors or oversights. Compare your results with the given options and select the one that accurately fits your calculated answer. If uncertain or if the problem is incorrect with no correct options, thoughtfully choose the most plausible answer based on the available information. Please avoid using symbols like double-quotes, dollar signs, commas, or exclamation marks in your answers.
""",
model="gpt-4-1106-preview",
tools=[{
"type": "retrieval"
}],
file_ids=[file.id])
with open(assistant_file_path, 'w') as file:
json.dump({'assistant_id': assistant.id}, file)
print("Created a new assistant and saved the ID.")
assistant_id = assistant.id
return assistant_id
# Key
api_key = "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"
client = OpenAI(api_key=api_key)
# Create new assistant or load existing
assistant_id = create_assistant(client)
def submit_message(assistant_id, thread, user_message):
client.beta.threads.messages.create(
thread_id=thread.id, role="user", content=user_message
)
return client.beta.threads.runs.create(
thread_id=thread.id,
assistant_id=assistant_id,
)
def get_response(thread):
return client.beta.threads.messages.list(thread_id=thread.id, order="asc")
def create_thread_and_run(user_input):
thread = client.beta.threads.create()
run = submit_message(assistant_id, thread, user_input)
return thread, run
def pretty_print(messages):
print("# Messages")
for m in messages:
print(f"{m.role}: {m.content[0].text.value}")
print()
# Waiting in a loop
def wait_on_run(run, thread):
while run.status == "queued" or run.status == "in_progress":
run = client.beta.threads.runs.retrieve(
thread_id=thread.id,
run_id=run.id,
)
time.sleep(0.5)
return run
thread, run = create_thread_and_run("assume all pieces of rope are equal . if 44 pieces of rope measure a feet , how long would b pieces of rope be in inches ?")
run = wait_on_run(run, thread)
pretty_print(get_response(thread)) | [] |
2024-01-10 | AayushMathur7/14Labs | spotify-upload~human_input-deprecated.py | """Tool for asking human input."""
from typing import Callable, Optional, Type
from langchain.callbacks.manager import CallbackManagerForToolRun
from langchain.tools.base import BaseTool
from pydantic import BaseModel, Field
from typing import List
# def web_prompt_func(prompt):
# # Send the prompt to the web application
# # This will depend on how your web application is set up
# pass
# def web_input_func():
# # Wait for the web application to send a response
# # This could be done by setting up an endpoint that waits for a POST request
# @app.route("/get_input", methods=["POST"])
# def get_input():
# user_input = request.form["user_input"]
# return user_input
class Answer(BaseModel):
answer: str
class Question(BaseModel):
question: str = Field("Question to ask the human")
class HumanInput(BaseModel):
questions: List[str] = Field("List of questions to ask the human")
def get_input() -> str:
print(
"Insert your text. Enter 'q' or press Ctrl-D (or Ctrl-Z on Windows) to end."
)
contents = []
while True:
try:
line = input()
except EOFError:
break
if line == "q":
break
contents.append(line)
return "\n".join(contents)
def _print_func(questions: List[str]) -> None:
print("\n")
print("\n".join(questions))
class HumanInputRun(BaseTool):
"""Tool that asks user for input."""
name: str = "human"
description: str = (
"Asks a human for inputs when you need to ask a user for info or not sure what to do next."
"The input should be a list of questions for the human."
)
prompt_func: Callable[[str], None] = Field(
default_factory=lambda: _print_func
)
input_func: Callable = Field(default_factory=lambda: input)
args_schema: Type[BaseModel] = HumanInput
def _run(
self,
questions: List[str],
run_manager: Optional[CallbackManagerForToolRun] = None,
) -> str:
"""Use the Human input tool."""
self.prompt_func(questions)
return self.input_func()
| [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.