anything-question-answering

Sleeping

LOUIS SANNA

feat(chat): avoid crash

8d2c035 4 months ago

No virus

20.6 kB

	import gradio as gr

	from utils import create_user_id

	# Langchain
	from langchain.embeddings import HuggingFaceEmbeddings
	from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

	# ClimateQ&A imports
	from anyqa.config import get_domains
	from anyqa.chains import load_qa_chain_with_text, load_reformulation_chain
	from anyqa.embeddings import EMBEDDING_MODEL_NAME
	from anyqa.llm import get_llm
	from anyqa.prompts import audience_prompts
	from anyqa.qa_logging import log
	from anyqa.retriever import QARetriever
	from anyqa.source_table import generate_source_table
	from anyqa.vectorstore import get_vectorstore

	# Load environment variables in local mode
	try:
	from dotenv import load_dotenv

	load_dotenv()
	except Exception as e:
	pass

	# Set up Gradio Theme
	theme = gr.themes.Base(
	primary_hue="blue",
	secondary_hue="red",
	font=[gr.themes.GoogleFont("Poppins"), "ui-sans-serif", "system-ui", "sans-serif"],
	)


	init_prompt = ""

	system_template = {
	"role": "system",
	"content": init_prompt,
	}

	user_id = create_user_id()

	# ---------------------------------------------------------------------------
	# ClimateQ&A core functions
	# ---------------------------------------------------------------------------

	from langchain.callbacks.base import BaseCallbackHandler
	from queue import Empty
	from threading import Thread
	from langchain.schema import LLMResult
	from typing import Any, Union, Dict, List
	from queue import SimpleQueue

	# # Create a Queue
	# Q = Queue()

	import re


	def parse_output_llm_with_sources(output):
	# Split the content into a list of text and "[Doc X]" references
	content_parts = re.split(r"\[(Doc\s?\d+(?:,\s?Doc\s?\d+)*)\]", output)
	parts = []
	for part in content_parts:
	if part.startswith("Doc"):
	subparts = part.split(",")
	subparts = [
	subpart.lower().replace("doc", "").strip() for subpart in subparts
	]
	subparts = [
	f"<span class='doc-ref'><sup>{subpart}</sup></span>"
	for subpart in subparts
	]
	parts.append("".join(subparts))
	else:
	parts.append(part)
	content_parts = "".join(parts)
	return content_parts


	job_done = object() # signals the processing is done


	class StreamingGradioCallbackHandler(BaseCallbackHandler):
	def __init__(self, q: SimpleQueue):
	self.q = q

	def on_llm_start(
	self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
	) -> None:
	"""Run when LLM starts running. Clean the queue."""
	while not self.q.empty():
	try:
	self.q.get(block=False)
	except Empty:
	continue

	def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
	"""Run on new LLM token. Only available when streaming is enabled."""
	self.q.put(token)

	def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
	"""Run when LLM ends running."""
	self.q.put(job_done)

	def on_llm_error(
	self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
	) -> None:
	"""Run when LLM errors."""
	self.q.put(job_done)


	# Create embeddings function and LLM
	embeddings_function = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL_NAME)

	# Create vectorstore and retriever
	vectorstore = get_vectorstore(embeddings_function)

	# ---------------------------------------------------------------------------
	# ClimateQ&A Streaming
	# From https://github.com/gradio-app/gradio/issues/5345
	# And https://stackoverflow.com/questions/76057076/how-to-stream-agents-response-in-langchain
	# ---------------------------------------------------------------------------

	from threading import Thread


	def answer_user(query, query_example, history):
	return query, history + [[query, ". . ."]]


	def answer_user_example(query, query_example, history):
	return query_example, history + [[query_example, ". . ."]]


	def fetch_sources(query, domains):
	llm_reformulation = get_llm(
	max_tokens=512, temperature=0.0, verbose=True, streaming=False
	)
	print("domains", domains)
	retriever = QARetriever(
	vectorstore=vectorstore, domains=domains, k_summary=0, k_total=10
	)
	reformulation_chain = load_reformulation_chain(llm_reformulation)

	# Calculate language
	output_reformulation = reformulation_chain({"query": query})
	question = output_reformulation["question"]
	language = output_reformulation["language"]

	# Retrieve docs
	docs = retriever.get_relevant_documents(question)

	if len(docs) > 0:
	# Already display the sources
	sources_text = []
	for i, d in enumerate(docs, 1):
	sources_text.append(make_html_source(d, i))
	citations_text = "".join(sources_text)
	docs_text = "\n\n".join([d.page_content for d in docs])
	return "", citations_text, docs_text, question, language
	else:
	sources_text = (
	"⚠️ No relevant passages found in the scientific reports (IPCC and IPBES)"
	)
	citations_text = "⚠️ No relevant passages found in the sources, you may want to ask a more specific question."
	docs_text = ""
	return "", citations_text, docs_text, question, language


	def answer_bot(query, history, docs, question, language, audience):
	if audience == "Children":
	audience_prompt = audience_prompts["children"]
	elif audience == "General public":
	audience_prompt = audience_prompts["general"]
	elif audience == "Experts":
	audience_prompt = audience_prompts["experts"]
	else:
	audience_prompt = audience_prompts["experts"]

	# Prepare Queue for streaming LLMs
	Q = SimpleQueue()

	llm_streaming = get_llm(
	max_tokens=1000,
	temperature=0.0,
	verbose=True,
	streaming=True,
	callbacks=[StreamingGradioCallbackHandler(Q), StreamingStdOutCallbackHandler()],
	)

	qa_chain = load_qa_chain_with_text(llm_streaming)

	def threaded_chain(question, audience, language, docs):
	try:
	response = qa_chain(
	{
	"question": question,
	"audience": audience,
	"language": language,
	"summaries": docs,
	}
	)
	Q.put(response)
	Q.put(job_done)
	except Exception as e:
	print(e)

	history[-1][1] = ""

	textbox = gr.Textbox(
	placeholder=". . .", show_label=False, scale=1, lines=1, interactive=False
	)

	if len(docs) > 0:
	# Start thread for streaming
	thread = Thread(
	target=threaded_chain,
	kwargs={
	"question": question,
	"audience": audience_prompt,
	"language": language,
	"docs": docs,
	},
	)
	thread.start()

	while True:
	next_item = Q.get(block=True) # Blocks until an input is available

	if next_item is job_done:
	break
	elif isinstance(next_item, str):
	new_paragraph = history[-1][1] + next_item
	new_paragraph = parse_output_llm_with_sources(new_paragraph)
	history[-1][1] = new_paragraph
	yield textbox, history
	else:
	pass
	thread.join()

	log(question=question, history=history, docs=docs, user_id=user_id)

	else:
	complete_response = "⚠️ No relevant passages found in the sources, you may want to ask a more specific question."
	history[-1][1] += complete_response
	yield "", history


	# ---------------------------------------------------------------------------
	# ClimateQ&A core functions
	# ---------------------------------------------------------------------------


	def make_html_source(source, i):
	meta = source.metadata
	content = source.page_content.split(":", 1)[1].strip()
	link = (
	f'<a href="{meta["url"]}#page={int(meta["page_number"])}" target="_blank" class="pdf-link"><span role="img" aria-label="Open PDF">🔗</span></a>'
	if "url" in meta
	else ""
	)
	return f"""
	<div class="card">
	<div class="card-content">
	<h2>Doc {i} - {meta['short_name']} - Page {int(meta['page_number'])}</h2>
	<p>{content}</p>
	</div>
	<div class="card-footer">
	<span>{meta['name']}</span>
	{link}
	</div>
	</div>
	"""


	def reset_textbox():
	return gr.update(value="")


	# --------------------------------------------------------------------
	# Gradio
	# --------------------------------------------------------------------


	init_prompt = """
	Hello, I'm a conversational assistant. I will answer your questions by sifting through trusted data sources.

	💡 How to use
	- Language: You can ask me your questions in any language.
	- Audience: You can specify your audience (children, general public, experts) to get a more adapted answer.
	- Sources: You can choose to search in which sources you want me to look for answers. By default, I will search in all sources.

	⚠️ Limitations
	Please note that the AI is not perfect and may sometimes give irrelevant answers. If you are not satisfied with the answer, please ask a more specific question or report your feedback to help us improve the system.

	❓ What do you want to learn ?
	"""


	def vote(data: gr.LikeData):
	if data.liked:
	print(data.value)
	else:
	print(data)


	def change_tab():
	return gr.Tabs.update(selected=1)


	with gr.Blocks(title="❓ Q&A", css="style.css", theme=theme) as demo:
	# user_id_state = gr.State([user_id])

	with gr.Tab("❓ Q&A"):
	with gr.Row(elem_id="chatbot-row"):
	with gr.Column(scale=2):
	# state = gr.State([system_template])
	bot = gr.Chatbot(
	value=[[None, init_prompt]],
	show_copy_button=True,
	show_label=False,
	elem_id="chatbot",
	layout="panel",
	avatar_images=("assets/bot_avatar.png", None),
	)

	# bot.like(vote,None,None)

	with gr.Row(elem_id="input-message"):
	textbox = gr.Textbox(
	placeholder="Ask me anything here!",
	show_label=False,
	scale=1,
	lines=1,
	interactive=True,
	max_lines=2
	)
	# submit_button = gr.Button(">",scale = 1,elem_id = "submit-button")

	with gr.Column(scale=1, variant="panel", elem_id="right-panel"):
	with gr.Tabs() as tabs:
	with gr.TabItem("📝 Examples", elem_id="tab-examples", id=0):
	examples_hidden = gr.Textbox(elem_id="hidden-message")
	questions = [
	"How does Daoism view our dependence on modern technology?",
	"From a Confucian perspective, what is the role of tradition in modern society?",
	"How might Daoism influence sustainable economic practices?",
	"Does Confucianism advocate for a particular economic model?",
	"How does Daoism interpret the dynamics of modern relationships?",
	"From a Confucian viewpoint, what are the responsibilities of individuals in a family?",
	"How might Daoism guide our approach to mental and physical health?",
	"Does Confucianism offer insights into educational methods?",
	"How does Daoism view the purpose and methods of modern education?",
	"From a Confucian perspective, what is the importance of social harmony?",
	]

	examples_questions = gr.Examples(
	questions,
	[examples_hidden],
	examples_per_page=10,
	run_on_click=False,
	# cache_examples=True,
	)

	with gr.Tab("📚 Citations", elem_id="tab-citations", id=1):
	sources_textbox = gr.HTML(
	show_label=False, elem_id="sources-textbox"
	)
	docs_textbox = gr.State("")

	with gr.Tab("⚙️ Configuration", elem_id="tab-config", id=2):
	gr.Markdown(
	"Reminder: You can talk in any language, this tool is multi-lingual!"
	)
	domains = get_domains()
	dropdown_domains = gr.CheckboxGroup(
	domains,
	label="Select source types",
	value=[],
	interactive=True,
	)

	dropdown_audience = gr.Dropdown(
	["Children", "General public", "Experts"],
	label="Select audience",
	value="Experts",
	interactive=True,
	)

	output_query = gr.Textbox(
	label="Query used for retrieval",
	show_label=True,
	elem_id="reformulated-query",
	lines=2,
	interactive=False,
	)
	output_language = gr.Textbox(
	label="Language",
	show_label=True,
	elem_id="language",
	lines=1,
	interactive=False,
	)

	(
	textbox.submit(
	answer_user,
	[textbox, examples_hidden, bot],
	[textbox, bot],
	queue=False,
	)
	.success(change_tab, None, tabs)
	.success(
	fetch_sources,
	[textbox, dropdown_domains],
	[
	textbox,
	sources_textbox,
	docs_textbox,
	output_query,
	output_language,
	],
	)
	.success(
	answer_bot,
	[
	textbox,
	bot,
	docs_textbox,
	output_query,
	output_language,
	dropdown_audience,
	],
	[textbox, bot],
	queue=True,
	)
	.success(lambda x: textbox, [textbox], [textbox])
	)

	(
	examples_hidden.change(
	answer_user_example,
	[textbox, examples_hidden, bot],
	[textbox, bot],
	queue=False,
	)
	.success(change_tab, None, tabs)
	.success(
	fetch_sources,
	[textbox, dropdown_domains],
	[
	textbox,
	sources_textbox,
	docs_textbox,
	output_query,
	output_language,
	],
	)
	.success(
	answer_bot,
	[
	textbox,
	bot,
	docs_textbox,
	output_query,
	output_language,
	dropdown_audience,
	],
	[textbox, bot],
	queue=True,
	)
	.success(lambda x: textbox, [textbox], [textbox])
	)

	# ---------------------------------------------------------------------------------------
	# OTHER TABS
	# ---------------------------------------------------------------------------------------

	with gr.Tab("ℹ️ About", elem_classes="max-height"):
	gr.Markdown(
	"""
	<div class="tip-box">
	<div class="tip-box-title">
	<span class="light-bulb" role="img" aria-label="Light Bulb">💡</span>
	How does this tool work?
	</div>
	This tool harnesses modern OCR techniques to parse and preprocess documents. By leveraging state-of-the-art question-answering algorithms, <i>our tool is able to sift through the extensive collection of trusted sources and identify relevant passages in response to user inquiries</i>. Furthermore, the integration of the ChatGPT API allows Q&A to present complex data in a user-friendly manner, summarizing key points and facilitating communication to a wider audience.
	</div>
	"""
	)

	gr.Markdown("## How to use")
	gr.Markdown(
	"""
	### 💪 Getting started
	- In the chatbot section, simply type your question, and the app will provide an answer with references to relevant sources.
	- the app retrieves specific passages to help answer your question accurately.
	- Source information, including page numbers and passages, is displayed on the right side of the screen for easy verification.
	- Feel free to ask follow-up questions within the chatbot for a more in-depth understanding.
	- You can ask question in any language, the tool is multi-lingual !
	"""
	)

	gr.Markdown(
	"""
	### ⚠️ Limitations
	<div class="warning-box">
	<ul>
	<li>Please note that, like any AI, the model may occasionally generate an inaccurate or imprecise answer. Always refer to the provided sources to verify the validity of the information given. If you find any issues with the response, kindly provide feedback to help improve the system.</li>
	</div>
	"""
	)

	with gr.Tab("👩‍💻 Community"):
	gr.Markdown(
	"""
	We welcomes community contributions.

	To participate, head over to the Community Tab and create a "New Discussion" to ask questions and share your insights.

	This tool is a fork from the work done by the R&D lab at Ekimetrics* for Climate Q&A: https://climateqa.com/.*
	"""
	)

	with gr.Tab("📚 Sources", elem_classes="max-height"):
	gr.Markdown(generate_source_table())

	with gr.Tab("🛢️ Carbon Footprint"):
	gr.Markdown(
	"""

	Carbon emissions were measured during the development and inference process using CodeCarbon [https://github.com/mlco2/codecarbon](https://github.com/mlco2/codecarbon)

	\| Phase \| Description \| Emissions \| Source \|
	\| --- \| --- \| --- \| --- \|
	\| Development \| OCR and parsing all pdf documents with AI \| 28gCO2e \| CodeCarbon \|
	\| Development \| Question Answering development \| 114gCO2e \| CodeCarbon \|
	\| Inference \| Question Answering \| ~0.102gCO2e / call \| CodeCarbon \|
	\| Inference \| API call to turbo-GPT \| ~0.38gCO2e / call \| https://medium.com/@chrispointon/the-carbon-footprint-of-chatgpt-e1bc14e4cc2a \|

	Carbon Emissions are relatively low but not negligible compared to other usages: one question asked is around 0.482gCO2e - equivalent to 2.2m by car (https://datagir.ademe.fr/apps/impact-co2/)
	Or around 2 to 4 times more than a typical Google search.
	"""
	)

	with gr.Tab("🪄 Changelog"):
	gr.Markdown(
	"""

	##### v1.0.0 - 2023-10-25

	- Forked ClimateQ&A
	- Added Chroma as vector store
	- Added support for OpenAI api
	- Added support for other topics
	"""
	)

	demo.queue(concurrency_count=16)

	demo.launch()