Spaces:

microsoft-cognitive-service
/

mm-react

Running

JJteam

changing title to reflect GPT4

30bfa95 10 months ago

No virus

23 kB

	import re
	import io
	import os
	from typing import Optional, Tuple
	import datetime
	import sys
	import gradio as gr
	import requests
	import json
	from threading import Lock
	from langchain import ConversationChain, LLMChain
	from langchain.agents import load_tools, initialize_agent, Tool
	from langchain.tools.bing_search.tool import BingSearchRun, BingSearchAPIWrapper
	from langchain.chains.conversation.memory import ConversationBufferMemory
	from langchain.llms import OpenAI
	from langchain.chains import PALChain
	from langchain.llms import AzureOpenAI
	from langchain.utilities import ImunAPIWrapper, ImunMultiAPIWrapper
	from langchain.utils import get_url_path
	from openai.error import AuthenticationError, InvalidRequestError, RateLimitError
	import argparse
	import logging
	from opencensus.ext.azure.log_exporter import AzureLogHandler
	import uuid

	logger = None


	OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
	BUG_FOUND_MSG = "Some Functionalities not supported yet. Please refresh and hit 'Click to wake up MM-REACT'"
	AUTH_ERR_MSG = "OpenAI key needed"
	REFRESH_MSG = "Please refresh and hit 'Click to wake up MM-REACT'"
	MAX_TOKENS = 512


	def get_logger():
	global logger
	if logger is None:
	logger = logging.getLogger(__name__)
	logger.addHandler(AzureLogHandler())
	return logger


	# load chain
	def load_chain(history, log_state):
	global ARGS

	if ARGS.openAIModel == 'openAIGPT35':
	# openAI GPT 3.5
	llm = OpenAI(temperature=0, max_tokens=MAX_TOKENS)
	elif ARGS.openAIModel == 'azureChatGPT':
	# for Azure OpenAI ChatGPT
	llm = AzureOpenAI(deployment_name="text-chat-davinci-002", model_name="text-chat-davinci-002", temperature=0, max_tokens=MAX_TOKENS)
	elif ARGS.openAIModel == 'azureGPT35turbo':
	# for Azure OpenAI gpt3.5 turbo
	llm = AzureOpenAI(deployment_name="gpt-35-turbo-version-0301", model_name="gpt-35-turbo (version 0301)", temperature=0, max_tokens=MAX_TOKENS)
	elif ARGS.openAIModel == 'azureTextDavinci003':
	# for Azure OpenAI text davinci
	llm = AzureOpenAI(deployment_name="text-davinci-003", model_name="text-davinci-003", temperature=0, max_tokens=MAX_TOKENS)
	elif ARGS.openAIModel == 'azureGPT4':
	# for Azure GPT4 private preview
	llm = AzureOpenAI(deployment_name="gpt-4-32k-0613", temperature=0, chat_completion=True, max_tokens=MAX_TOKENS, openai_api_version="2023-03-15-preview")

	memory = ConversationBufferMemory(memory_key="chat_history")


	#############################
	# loading all tools

	imun_dense = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_URL2"),
	params=os.environ.get("IMUN_PARAMS2"),
	imun_subscription_key=os.environ.get("IMUN_SUBSCRIPTION_KEY2"))

	imun = ImunAPIWrapper()
	imun = ImunMultiAPIWrapper(imuns=[imun, imun_dense])

	imun_celeb = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_CELEB_URL"),
	params="")

	imun_read = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_OCR_READ_URL"),
	params=os.environ.get("IMUN_OCR_PARAMS"),
	imun_subscription_key=os.environ.get("IMUN_OCR_SUBSCRIPTION_KEY"))

	imun_receipt = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_OCR_RECEIPT_URL"),
	params=os.environ.get("IMUN_OCR_PARAMS"),
	imun_subscription_key=os.environ.get("IMUN_OCR_SUBSCRIPTION_KEY"))

	imun_businesscard = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_OCR_BC_URL"),
	params=os.environ.get("IMUN_OCR_PARAMS"),
	imun_subscription_key=os.environ.get("IMUN_OCR_SUBSCRIPTION_KEY"))

	imun_layout = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_OCR_LAYOUT_URL"),
	params=os.environ.get("IMUN_OCR_PARAMS"),
	imun_subscription_key=os.environ.get("IMUN_OCR_SUBSCRIPTION_KEY"))

	imun_invoice = ImunAPIWrapper(
	imun_url=os.environ.get("IMUN_OCR_INVOICE_URL"),
	params=os.environ.get("IMUN_OCR_PARAMS"),
	imun_subscription_key=os.environ.get("IMUN_OCR_SUBSCRIPTION_KEY"))

	bing = BingSearchAPIWrapper(k=2)

	def edit_photo(query: str) -> str:
	endpoint = os.environ.get("PHOTO_EDIT_ENDPOINT_URL")
	query = query.strip()
	url_idx, img_url = get_url_path(query)
	if not img_url.startswith(("http://", "https://")):
	return "Invalid image URL"
	img_url = img_url.replace("0.0.0.0", os.environ.get("PHOTO_EDIT_ENDPOINT_URL_SHORT"))
	instruction = query[:url_idx]
	# This should be some internal IP to wherever the server runs
	job = {"image_path": img_url, "instruction": instruction}
	response = requests.post(endpoint, json=job)
	if response.status_code != 200:
	return "Could not finish the task try again later!"
	return "Here is the edited image " + endpoint + response.json()["edited_image"]

	# these tools should not step on each other's toes
	tools = [
	Tool(
	name="PAL-MATH",
	func=PALChain.from_math_prompt(llm).run,
	description=(
	"A wrapper around calculator. "
	"A language model that is really good at solving complex word math problems."
	"Input should be a fully worded hard word math problem."
	)
	),
	Tool(
	name = "Image Understanding",
	func=imun.run,
	description=(
	"A wrapper around Image Understanding. "
	"Useful for when you need to understand what is inside an image (objects, texts, people)."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	Tool(
	name = "OCR Understanding",
	func=imun_read.run,
	description=(
	"A wrapper around OCR Understanding (Optical Character Recognition). "
	"Useful after Image Understanding tool has found text or handwriting is present in the image tags."
	"This tool can find the actual text, written name, or product name in the image."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	Tool(
	name = "Receipt Understanding",
	func=imun_receipt.run,
	description=(
	"A wrapper receipt understanding. "
	"Useful after Image Understanding tool has recognized a receipt in the image tags."
	"This tool can find the actual receipt text, prices and detailed items."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	Tool(
	name = "Business Card Understanding",
	func=imun_businesscard.run,
	description=(
	"A wrapper around business card understanding. "
	"Useful after Image Understanding tool has recognized businesscard in the image tags."
	"This tool can find the actual business card text, name, address, email, website on the card."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	Tool(
	name = "Layout Understanding",
	func=imun_layout.run,
	description=(
	"A wrapper around layout and table understanding. "
	"Useful after Image Understanding tool has recognized businesscard in the image tags."
	"This tool can find the actual business card text, name, address, email, website on the card."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	Tool(
	name = "Invoice Understanding",
	func=imun_invoice.run,
	description=(
	"A wrapper around invoice understanding. "
	"Useful after Image Understanding tool has recognized businesscard in the image tags."
	"This tool can find the actual business card text, name, address, email, website on the card."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	Tool(
	name = "Celebrity Understanding",
	func=imun_celeb.run,
	description=(
	"A wrapper around celebrity understanding. "
	"Useful after Image Understanding tool has recognized people in the image tags that could be celebrities."
	"This tool can find the name of celebrities in the image."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	BingSearchRun(api_wrapper=bing),
	Tool(
	name = "Photo Editing",
	func=edit_photo,
	description=(
	"A wrapper around photo editing. "
	"Useful to edit an image with a given instruction."
	"Input should be an image url, or path to an image file (e.g. .jpg, .png)."
	)
	),
	]

	chain = initialize_agent(tools, llm, agent="conversational-assistant", verbose=True, memory=memory, return_intermediate_steps=True, max_iterations=4)
	log_state = log_state or ""
	print ("log_state {}".format(log_state))
	log_state = str(uuid.uuid1())
	print("langchain reloaded")
	# eproperties = {'custom_dimensions': {'key_1': 'value_1', 'key_2': 'value_2'}}
	properties = {'custom_dimensions': {'session': log_state}}
	get_logger().warning("langchain reloaded", extra=properties)
	history = []
	history.append(("Show me what you got!", "Hi Human, Please upload an image to get started!"))

	return history, history, chain, log_state, \
	gr.Textbox.update(visible=True), \
	gr.Button.update(visible=True), \
	gr.UploadButton.update(visible=True), \
	gr.Row.update(visible=True), \
	gr.HTML.update(visible=True), \
	gr.Button.update(variant="secondary")


	# executes input typed by human
	def run_chain(chain, inp):
	# global chain

	output = ""
	try:
	output = chain.conversation(input=inp, keep_short=ARGS.noIntermediateConv)
	# output = chain.run(input=inp)
	except AuthenticationError as ae:
	output = AUTH_ERR_MSG + str(datetime.datetime.now()) + ". " + str(ae)
	print("output", output)
	except RateLimitError as rle:
	output = "\n\nRateLimitError: " + str(rle)
	except ValueError as ve:
	output = "\n\nValueError: " + str(ve)
	except InvalidRequestError as ire:
	output = "\n\nInvalidRequestError: " + str(ire)
	except Exception as e:
	output = "\n\n" + BUG_FOUND_MSG + ":\n\n" + str(e)

	return output

	# simple chat function wrapper
	class ChatWrapper:

	def __init__(self):
	self.lock = Lock()

	def __call__(
	self, inp: str, history: Optional[Tuple[str, str]], chain: Optional[ConversationChain], log_state
	):

	"""Execute the chat functionality."""
	self.lock.acquire()
	try:
	print("\n==== date/time: " + str(datetime.datetime.now()) + " ====")
	print("inp: " + inp)

	properties = {'custom_dimensions': {'session': log_state}}
	get_logger().warning("inp: " + inp, extra=properties)


	history = history or []
	# If chain is None, that is because no API key was provided.
	output = "Please paste your OpenAI key from openai.com to use this app. " + str(datetime.datetime.now())

	########################
	# multi line
	outputs = run_chain(chain, inp)

	outputs = process_chain_output(outputs)

	print (" len(outputs) {}".format(len(outputs)))
	for i, output in enumerate(outputs):
	if i==0:
	history.append((inp, output))
	else:
	history.append((None, output))


	except Exception as e:
	raise e
	finally:
	self.lock.release()

	print (history)
	properties = {'custom_dimensions': {'session': log_state}}
	if outputs is None:
	outputs = ""
	get_logger().warning(str(json.dumps(outputs)), extra=properties)

	return history, history, ""

	def add_image_with_path(state, chain, imagepath, log_state):
	global ARGS
	state = state or []

	url_input_for_chain = "http://0.0.0.0:{}/file={}".format(ARGS.port, imagepath)

	outputs = run_chain(chain, url_input_for_chain)

	########################
	# multi line response handling
	outputs = process_chain_output(outputs)

	for i, output in enumerate(outputs):
	if i==0:
	# state.append((f"![](/file={imagepath})", output))
	state.append(((imagepath,), output))
	else:
	state.append((None, output))


	print (state)
	properties = {'custom_dimensions': {'session': log_state}}
	get_logger().warning("url_input_for_chain: " + url_input_for_chain, extra=properties)
	if outputs is None:
	outputs = ""
	get_logger().warning(str(json.dumps(outputs)), extra=properties)
	return state, state


	# upload image
	def add_image(state, chain, image, log_state):
	global ARGS
	state = state or []

	# handling spaces in image path
	imagepath = image.name.replace(" ", "%20")

	url_input_for_chain = "http://0.0.0.0:{}/file={}".format(ARGS.port, imagepath)

	outputs = run_chain(chain, url_input_for_chain)

	########################
	# multi line response handling
	outputs = process_chain_output(outputs)

	for i, output in enumerate(outputs):
	if i==0:
	state.append(((imagepath,), output))
	else:
	state.append((None, output))


	print (state)
	properties = {'custom_dimensions': {'session': log_state}}
	get_logger().warning("url_input_for_chain: " + url_input_for_chain, extra=properties)
	if outputs is None:
	outputs = ""
	get_logger().warning(str(json.dumps(outputs)), extra=properties)
	return state, state

	# extract image url from response and process differently
	def replace_with_image_markup(text):
	img_url = None
	text= text.strip()
	url_idx = text.rfind(" ")
	img_url = text[url_idx + 1:].strip()
	if img_url.endswith((".", "?")):
	img_url = img_url[:-1]

	# if img_url is not None:
	# img_url = f"![](/file={img_url})"
	return img_url

	# multi line response handling
	def process_chain_output(outputs):
	global ARGS
	EMPTY_AI_REPLY = "AI:"
	# print("outputs {}".format(outputs))
	if isinstance(outputs, str): # single line output
	if outputs.strip() == EMPTY_AI_REPLY:
	outputs = REFRESH_MSG
	outputs = [outputs]
	elif isinstance(outputs, list): # multi line output
	if ARGS.noIntermediateConv: # remove the items with assistant in it.
	cleanOutputs = []
	for output in outputs:
	if output.strip() == EMPTY_AI_REPLY:
	output = REFRESH_MSG
	# found an edited image url to embed
	img_url = None
	# print ("type list: {}".format(output))
	if "assistant: here is the edited image " in output.lower():
	img_url = replace_with_image_markup(output)
	cleanOutputs.append("Assistant: Here is the edited image")
	if img_url is not None:
	cleanOutputs.append((img_url,))
	else:
	cleanOutputs.append(output)
	# cleanOutputs = cleanOutputs + output+ "."
	outputs = cleanOutputs

	return outputs


	def init_and_kick_off():
	global ARGS
	# initalize chatWrapper
	chat = ChatWrapper()

	exampleTitle = """<h3>Examples to start conversation..</h3>"""
	comingSoon = """<center><b>MM-REACT: July 21th version with GPT4 and image understanding capabilities.</b> <i>(data will be collected for research purpose)</i></center>"""
	detailLinks = """
	<center>
	<a href="https://multimodal-react.github.io/"> MM-ReAct Website</a>
	·
	<a href="https://arxiv.org/abs/2303.11381">MM-ReAct Paper</a>
	·
	<a href="https://github.com/microsoft/MM-REACT">MM-ReAct Code</a>
	</center>
	"""

	with gr.Blocks(css="#tryButton {width: 120px;}") as block:
	llm_state = gr.State()
	history_state = gr.State()
	chain_state = gr.State()
	log_state = gr.State()

	reset_btn = gr.Button(value="!!!CLICK to wake up MM-REACT!!!", variant="primary", elem_id="resetbtn").style(full_width=True)
	gr.HTML(detailLinks)
	gr.HTML(comingSoon)

	example_image_size = 90
	col_min_width = 80
	button_variant = "primary"
	with gr.Row():
	with gr.Column(scale=1.0, min_width=100):
	chatbot = gr.Chatbot(elem_id="chatbot", label="MM-REACT Bot").style(height=620)
	with gr.Column(scale=0.20, min_width=200, visible=False) as exampleCol:
	with gr.Row():
	grExampleTitle = gr.HTML(exampleTitle, visible=False)
	with gr.Row():
	with gr.Column(scale=0.50, min_width=col_min_width):
	example3Image = gr.Image("images/receipt.png", interactive=False).style(height=example_image_size, width=example_image_size)
	with gr.Column(scale=0.50, min_width=col_min_width):
	example3ImageButton = gr.Button(elem_id="tryButton", value="Try it!", variant=button_variant).style(full_width=True)
	# dummy text field to hold the path
	example3ImagePath = gr.Text("images/receipt.png", interactive=False, visible=False)
	with gr.Row():
	with gr.Column(scale=0.50, min_width=col_min_width):
	example1Image = gr.Image("images/money.png", interactive=False).style(height=example_image_size, width=example_image_size)
	with gr.Column(scale=0.50, min_width=col_min_width):
	example1ImageButton = gr.Button(elem_id="tryButton", value="Try it!", variant=button_variant).style(full_width=True)
	# dummy text field to hold the path
	example1ImagePath = gr.Text("images/money.png", interactive=False, visible=False)
	with gr.Row():
	with gr.Column(scale=0.50, min_width=col_min_width):
	example2Image = gr.Image("images/cartoon.png", interactive=False).style(height=example_image_size, width=example_image_size)
	with gr.Column(scale=0.50, min_width=col_min_width):
	example2ImageButton = gr.Button(elem_id="tryButton", value="Try it!", variant=button_variant).style(full_width=True)
	# dummy text field to hold the path
	example2ImagePath = gr.Text("images/cartoon.png", interactive=False, visible=False)
	with gr.Row():
	with gr.Column(scale=0.50, min_width=col_min_width):
	example4Image = gr.Image("images/product.png", interactive=False).style(height=example_image_size, width=example_image_size)
	with gr.Column(scale=0.50, min_width=col_min_width):
	example4ImageButton = gr.Button(elem_id="tryButton", value="Try it!", variant=button_variant).style(full_width=True)
	# dummy text field to hold the path
	example4ImagePath = gr.Text("images/product.png", interactive=False, visible=False)
	with gr.Row():
	with gr.Column(scale=0.50, min_width=col_min_width):
	example5Image = gr.Image("images/celebrity.png", interactive=False).style(height=example_image_size, width=example_image_size)
	with gr.Column(scale=0.50, min_width=col_min_width):
	example5ImageButton = gr.Button(elem_id="tryButton", value="Try it!", variant=button_variant).style(full_width=True)
	# dummy text field to hold the path
	example5ImagePath = gr.Text("images/celebrity.png", interactive=False, visible=False)



	with gr.Row():
	with gr.Column(scale=0.75):
	message = gr.Textbox(label="Upload a pic and ask!",
	placeholder="Type your question about the uploaded image",
	lines=1, visible=False)
	with gr.Column(scale=0.15):
	submit = gr.Button(value="Send", variant="secondary", visible=False).style(full_width=True)
	with gr.Column(scale=0.10, min_width=0):
	btn = gr.UploadButton("🖼️", file_types=["image"], visible=False).style(full_width=True)


	message.submit(chat, inputs=[message, history_state, chain_state, log_state], outputs=[chatbot, history_state, message])

	submit.click(chat, inputs=[message, history_state, chain_state, log_state], outputs=[chatbot, history_state, message])

	btn.upload(add_image, inputs=[history_state, chain_state, btn, log_state], outputs=[history_state, chatbot])

	# load the chain
	reset_btn.click(load_chain, inputs=[history_state, log_state], outputs=[chatbot, history_state, chain_state, log_state, message, submit, btn, exampleCol, grExampleTitle, reset_btn])

	# setup listener click for the examples
	example1ImageButton.click(add_image_with_path, inputs=[history_state, chain_state, example1ImagePath, log_state], outputs=[history_state, chatbot])
	example2ImageButton.click(add_image_with_path, inputs=[history_state, chain_state, example2ImagePath, log_state], outputs=[history_state, chatbot])
	example3ImageButton.click(add_image_with_path, inputs=[history_state, chain_state, example3ImagePath, log_state], outputs=[history_state, chatbot])
	example4ImageButton.click(add_image_with_path, inputs=[history_state, chain_state, example4ImagePath, log_state], outputs=[history_state, chatbot])
	example5ImageButton.click(add_image_with_path, inputs=[history_state, chain_state, example5ImagePath, log_state], outputs=[history_state, chatbot])


	# launch the app
	block.launch(server_name="0.0.0.0", server_port = ARGS.port)

	if __name__ == '__main__':
	parser = argparse.ArgumentParser()

	parser.add_argument('--port', type=int, required=False, default=7860)
	parser.add_argument('--openAIModel', type=str, required=False, default='azureGPT4')
	parser.add_argument('--noIntermediateConv', default=True, action='store_true', help='if this flag is turned on no intermediate conversation should be shown')

	global ARGS
	ARGS = parser.parse_args()

	init_and_kick_off()