Let’s code a chatbot in Python!
Are you curious about constructing a chatbot that makes use of the newest AI fashions? With only a few traces of code utilizing Panel, we will simply construct a chatbot that features each ChatGPT and DALL·E 2. ChatGPT and DALL·E 2 are developed by OpenAI to generate textual content and pictures from scratch based mostly on textual content prompts. On this weblog submit, we are going to discover the OpenAI API and see how we will use the inventive energy of ChatGPT and DALL·E 2 in a single Python Panel software. Think about a chatbot that may not solely reply questions and craft tales, but additionally allow you to envision your story by visible artwork. Wouldn’t that be cool?
To make use of the OpenAI API, we first have to create an account on openai.com and create an API key. Keep in mind to repeat the important thing and reserve it someplace for later use.
We are able to then set up the Python bindings of the OpenAI API through pip: pip set up openai.
Then we will begin coding in Python! You possibly can both code in Jupyter Pocket book or VSCode or one other of your favourite editors.
After importing the wanted packages and defining API keys, we will run openai.Mannequin.checklist() to checklist all of the out there fashions on OpenAI. There are 66 of them! You possibly can learn the descriptions of the principle fashions on beta.openai.com/docs/fashions.
These OpenAI fashions fall into 5 classes: textual content completion, code completion, picture technology, fine-tuning, and embeddings. For our functions of exploring ChatGPT and DALL·E 2, we shall be utilizing textual content completion and picture technology APIs with openai.Completion and openai.Picture.
I wrapped these two API request strategies into two capabilities the place we give it a immediate and obtain a textual content and picture URL. There are plenty of parameters you may play with in these two capabilities. For instance, openai.Completion enables you to select from a set of GPT-3 fashions and right here I selected text-davinci-003, probably the most succesful GPT-3 mannequin OpenAI launched. It additionally enables you to outline the utmost variety of tokens to generate within the completion and the temperature, which is the dangers the mannequin will take with 0 indicating well-defined solutions and 1 indicating extra inventive solutions. Equally, openai.Picture enables you to outline the variety of photographs returned and the picture dimension, you may select from ‘256×256’, ‘512×512’, and ‘1024×1024’.
def openai_completion(immediate):
response = openai.Completion.create(
mannequin="text-davinci-003",
immediate=immediate,
max_tokens=150,
temperature=0.5
)
return response['choices'][0]['text']def openai_image(immediate):
response = openai.Picture.create(
immediate=immediate,
n=1,
dimension="512x512"
)
image_url = response['data'][0]['url']
return image_url
Let’s attempt to give them prompts and see what occurs. The openai_completion perform is ready to accurately inform me the present temperature of Austin and the openai_image perform returns a picture of “Unicorn climbing on the cloud”. Success!
Now we’ve got discovered the OpenAI textual content completion API and the picture technology API, can we tie them collectively in a Python Panel Dashboard?
What’s Panel? Panel is the dashboarding library within the open-source HoloViz ecosystem that gives high-level instruments to simplify visualization in Python and was developed by Philipp Rudiger, Jim Bednar, and a neighborhood of contributors. Take a look at panel.holoviz.org to study extra.
To construct a Panel dashboard, let’s first import panel and related modules:
import panel as pn
pn.extension(loading_spinner='dots', loading_color='#00aa41')
Let’s then make three widgets. inp is the place we kind our textual content immediate to speak with the chatbot, button_conversation is the “Chat!” button that may ship the immediate to the OpenAI textual content completion API, and button_image is the “Picture!” button that may ship the immediate to the OpenAI picture technology API.
inp = pn.widgets.TextInput(worth="", placeholder='Enter textual content right here…')
button_conversation = pn.widgets.Button(title="Chat!")
button_image = pn.widgets.Button(title="Picture!")
The get_conversations perform returns all of the conversations we’ve got with the chatbot in a Panel object. There are a number of issues to notice right here:
convos_textshops all conversations in a listing. Once we give the OpenAI textual content completion a immediate, we embody all chats from historical past.- Panel helps Markdown. I added all of the prompts and the OpenAI’s responses to the Markdown format.
- Each time there’s a new chat, a brand new Panel object will get created to replicate this new chat and append to the
convoschecklist.
The get_image perform is so much less complicated, we merely present the picture from the picture URL in a Panel object. Every little thing proven in a Panel dashboard must be a Panel object.
convos_text = [] # retailer all texts in a listing
convos = [] # retailer all panel objects in a listingdef get_conversations(_):
immediate = inp.worth
inp.worth = ''
if immediate != "":
convos_text.append(immediate)
openai_answer = openai_completion('n'.be part of(convos_text)) # immediate consists of all historical past
convos_text.append(openai_answer)
convos.append(
pn.Row('U0001F60A', pn.pane.Markdown(immediate, width=600))
)
convos.append(
pn.Row('U0001F916', pn.pane.Markdown(openai_answer, width=600, fashion={'background-color': '#F6F6F6'}))
)
if len(convos_text) == 0:
convos.append(pn.Row('U0001F916', pn.pane.Markdown("Give me one thing!", width=600, fashion={'background-color': '#F6F6F6'})))
return pn.Column(*convos)
def get_image(_):
if len(convos_text)>0:
image_prompt = convos_text[-1]
image_url = openai_image(image_prompt)
return pn.pane.PNG(image_url, width=600)
Then the ultimate step is to bind the get_conversations perform with the button_conversation button and bind the get_image perform with the button_image button, which means that solely once we click on the button, the perform will execute. Then we arrange all of the Panel widgets and interactive parts in a single dashboard.
interactive_conversation = pn.bind(get_conversations, button_conversation)
interactive_image = pn.bind(get_image, button_image)dashboard = pn.Column(
inp,
pn.Row(button_conversation,button_image),
pn.panel(interactive_conversation, loading_indicator=True, top=500),
pn.panel(interactive_image, loading_indicator=True, top=500),
)
dashboard.servable()
You will discover the entire code in my GitHub repo:
https://github.com/sophiamyang/panel_openai/
Be happy to provide it a attempt. Run panel serve panel_openai.py or panel serve panel_openai.ipynb to see the interactive dashboard as proven originally of the article!
Once more, on this app, you may kind in a immediate, click on “Chat!” to start out chatting with the chatbot, and click on “Picture!” to generate photographs based mostly on the newest dialog.
On this article, we demonstrated how you can construct a easy chatbot in Panel. Utilizing two OpenAI APIs and mixing each ChatGPT and DALL·E 2 in a single software, our chatbot is empowered with textual content technology and picture technology functionalities. Give it a attempt when you haven’t already!
Thanks Jim Bednar, Simon Hansen, Maxime Liquet, and Philipp Rudiger on your steerage and suggestions!
. . .
By Sophia Yang on December 22, 2022.
Sophia Yang is a Senior Information Scientist at Anaconda. Join with me on LinkedIn, Twitter, and YouTube, and be part of the DS/ML E book Membership ❤️
