Spaces:
Sleeping
Sleeping
File size: 7,568 Bytes
844cee8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 |
import os
import openai
import numpy as np
import time
import time
import pandas as pd
MODEL_AUGMENT = "gpt-3.5-turbo-16k"
MODEL_ANSWER = "gpt-3.5-turbo-16k"
def cosine_similarity(a, b):
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
def get_embedding(text, model="text-embedding-ada-002"):
try:
text = text.replace("\n", " ")
except:
None
try:
return openai.Embedding.create(input = [text], model=model)['data'][0]['embedding']
except:
time.sleep(2)
def augment_query(query):
SYS_PROMPT = """
On [current date: 19 July], you'll receive a finance-related question from a sales manager, without direct interaction. Generate a JSON response with the following structure, considering the temporal aspect:
{
"timestamps": # Relevant timestamps to study corresponding tweets for a temporal dynamic aspect (e.g., topic drift). USE THE MINIMAL NUMBER OF TIMESTAMP POSSIBLE ALWAYS ALWAYS!,
"query": # Repeat the user's query,
"similarity_boilerplate": # Boilerplate of relevant documents for cosine similarity search after embedding (it could look like example of tweets that might help answer the query),
}
Allowed historical timestamps:
['2018-07-18', '2018-07-19', '2018-07-08', '2018-07-09', '2018-07-10', '2018-07-11', '2018-07-12', '2018-07-13', '2018-07-14', '2018-07-15', '2018-07-16', '2018-07-17']
Ensure the output is always in JSON format and never provide any other response.
"""
response = openai.chat.completions.create(
model=MODEL_AUGMENT,
messages=
[
{
"role": "system",
"content": SYS_PROMPT
},
{
"role": "user",
"content": query
}
],
temperature=1,
max_tokens=1000,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
).choices[0].message.content
return response
def semantic_search(df_loc, query,timestamp, nb_elements_to_consider=15):
timestamp = str(timestamp).strip()
embedding = get_embedding(query, model='text-embedding-ada-002')
filtered_df = df_loc[df_loc["timestamp"]==timestamp].drop(columns=["url"])
def wrap_cos(x,y):
try:
res = cosine_similarity(x,y)
except:
res = 0
return res
filtered_df['similarity'] = filtered_df.embedding.apply(lambda x: wrap_cos(x, embedding))
results = filtered_df.sort_values('similarity', ascending=False).head(nb_elements_to_consider)
return results
def condition_check(tweet, query):
response = openai.chat.completions.create(model=MODEL_AUGMENT,messages=[ {
"role": "system",
"content": "Only answer with True or False no matter what"
},
{
"role": "user",
"content": f"Consider this tweet:\n\n{tweet}\n\nIs it relevant to the following query:\n\n\{query}"
}
],
temperature=1,
max_tokens=1000,
top_p=1,
frequency_penalty=0,
presence_penalty=0
).choices[0].message.content
return bool(response)
def get_number_relevant_tweets(df,timestamp, query):
sorted_df = semantic_search(df, str(str(query["query"]) + "\n"+ str(query["similarity_boilerplate"])),timestamp, nb_elements_to_consider=len(df))
left, right = 0, len(sorted_df) - 1
while left <= right:
mid = (left + right) // 2
print(f"Currently searching with max range at {mid}")
if condition_check(sorted_df['text'].iloc[mid], query):
left = mid + 1
else:
right = mid - 1
print(f"Dichotomy done, found relevant tweets: {left}")
return left
def get_relevant_documents(df, query,nb_elements_to_consider = 10):
query = eval(query)
all_retrieved = []
for timestamp in query["timestamps"]:
number_of_relevant_tweets = get_number_relevant_tweets(df,timestamp, query)
all_retrieved.append({
"timestamp" : timestamp,
"number_of_relevant_tweets": str(number_of_relevant_tweets),
"tweets" : semantic_search(df, str(str(query["query"]) + "\n"+ str(query["similarity_boilerplate"])),timestamp, nb_elements_to_consider=min(nb_elements_to_consider,number_of_relevant_tweets))
})
return all_retrieved
def get_final_answer(relevant_documents, query):
context = ""
for document in relevant_documents:
print("TIMESTAMP: ", document["timestamp"] )
tweet_entry = document["tweets"]
context += "\nTimestamp: " + document["timestamp"] + " - Number of relevant tweets in database (EXACT VOLUME OF TWEETS): +"+ document["number_of_relevant_tweets"] + "\nList of tweets:\n" + str((tweet_entry["text"] + " --- Tweeted by: @" +tweet_entry["source"] + " \n").to_list()) + "\n---"
SYS_PROMPT = f"""
You will be fed a list of tweets each at a specific timestamp and the number of relevant tweets. You need to take into account (if needed) the number of tweets relevant to the query and how this number evolved. Your task is to use those tweets to answer to the best of your knowledge the following question:
QUESTION: {query}
SPECIFIC INSTRUCTIONS AND SYSTEM WARNINGS: You redact a properly structured markdown string containing a professional report.
You ALWAYS specify your sources by citing them (no urls though). Those tweets are samples from the data and are the closest to the query, you should also take into account the volume of tweets obtained.
Otherwise, it will be considered highly misleading and harmful content.
You should however always try your best to answer and you need to study in depth the historical relationship between the timestamps and how it answers the QUESTION.
You never refer to yourself.
Make it as if a real human provided a well constructed and structured report/answer extracting the best of the knowledge contained in the context."
"""
response = openai.chat.completions.create(
model=MODEL_ANSWER,
messages=[
{
"role": "system",
"content": SYS_PROMPT
},
{
"role": "user",
"content": str(context)
}
],
temperature=1,
max_tokens=3000,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
).choices[0].message.content
return response
def get_answer(query, df,api_key,nb_elements_to_consider=10):
openai.api_key = api_key
augmented_query = augment_query(query)
relevant_documents = get_relevant_documents(df, augmented_query,nb_elements_to_consider=nb_elements_to_consider)
response = get_final_answer(relevant_documents, augmented_query)
print(response)
return response
|