Hur man bygger en chatbot med Streamlit och Llama 2

Llama 2 är en stor språkmodell med öppen källkod (LLM) utvecklad av Meta. Det är en kompetent storspråksmodell med öppen källkod, utan tvekan bättre än vissa slutna modeller som GPT-3.5 och PaLM 2. Den består av tre förtränade och finjusterade generativa textmodellstorlekar, inklusive 7 miljarder, 13 miljarder och 70 miljarder parametermodeller.

Du kommer att utforska Llama 2:s konversationsmöjligheter genom att bygga en chatbot med Streamlit och Llama 2.

Förstå Llama 2: Funktioner och fördelar

Hur annorlunda är Llama 2 från sin föregångare stor språkmodell, Lama 1?

• Större modellstorlek: Modellen är större, med upp till 70 miljarder parametrar. Detta gör det möjligt för den att lära sig mer intrikata associationer mellan ord och meningar.
• Förbättrade samtalsförmåga: Förstärkning Att lära av mänsklig feedback (RLHF) förbättrar förmågan att använda konversation. Detta gör att modellen kan generera mänskligt innehåll även i komplicerade interaktioner.
instagram viewer
• Snabbare slutledning: Den introducerar en ny metod som kallas grouped-query uppmärksamhet för att påskynda slutledning. Detta resulterar i dess förmåga att bygga mer användbara applikationer som chatbots och virtuella assistenter.
• Mer effektiv: Den är mer minnes- och beräkningseffektiv än sin föregångare.
• Öppen källkod och icke-kommersiell licens: Det är öppen källkod. Forskare och utvecklare kan använda och modifiera Llama 2 utan begränsningar.

Llama 2 överträffar sin föregångare betydligt i alla avseenden. Dessa egenskaper gör det till ett kraftfullt verktyg för många applikationer, såsom chatbots, virtuella assistenter och naturlig språkförståelse.

Konfigurera en strömbelyst miljö för chatbotutveckling

För att börja bygga din applikation måste du skapa en utvecklingsmiljö. Detta för att isolera ditt projekt från de befintliga projekten på din maskin.

Börja först med skapa en virtuell miljö använda Pipenv bibliotek enligt följande:

pipenv shell

Installera sedan de nödvändiga biblioteken för att bygga chatboten.

pipenv install streamlit replicate

Strömbelyst: Det är ett ramverk för webbappar med öppen källkod som gör maskininlärning och datavetenskap snabbt.

Återskapa: Det är en molnplattform som ger tillgång till stora maskininlärningsmodeller med öppen källkod för implementering.

Få din Llama 2 API-token från replikera

För att få en Replicate token-nyckel måste du först registrera ett konto på Återskapa med ditt GitHub-konto.

Replikera tillåter endast inloggning via a GitHub-konto.

När du har öppnat instrumentpanelen, navigera till Utforska knappen och sök efter Llama 2 chatt för att se lama-2–70b-chatt modell.

Klicka på lama-2–70b-chatt modell för att se Llama 2 API-slutpunkter. Klicka på API knappen på lama-2–70b-chatt modellens navigeringsfält. Till höger på sidan klickar du på Pytonorm knapp. Detta ger dig tillgång till API-token för Python-applikationer.

Kopiera REPLICATE_API_TOKEN och förvara den säkert för framtida bruk.

Den fullständiga källkoden finns tillgänglig i denna GitHub-förråd.

Bygger Chatbot

Skapa först en Python-fil som heter llama_chatbot.py och en env-fil (.env). Du kommer att skriva din kod i llama_chatbot.py och lagra dina hemliga nycklar och API-tokens i .env-filen.

I filen llama_chatbot.py importerar du biblioteken enligt följande.

import streamlit as st 
import os 
import replicate

Ställ sedan in de globala variablerna för lama-2–70b-chatt modell.

# Global variables
REPLICATE_API_TOKEN = os.environ.get('REPLICATE_API_TOKEN', default='') 
# Define model endpoints as independent variables
LLaMA2_7B_ENDPOINT = os.environ.get('MODEL_ENDPOINT7B', default='')
LLaMA2_13B_ENDPOINT = os.environ.get('MODEL_ENDPOINT13B', default='')
LLaMA2_70B_ENDPOINT = os.environ.get('MODEL_ENDPOINT70B', default='')

I .env-filen lägger du till replikeratoken och modellslutpunkter i följande format:

REPLICATE_API_TOKEN='Paste_Your_Replicate_Token'
MODEL_ENDPOINT7B='a16z-infra/llama7b-v2-chat: 4f0a4744c7295c024a1de15e1a63c880d3da035fa1f49bfd344fe076074c8eea'
MODEL_ENDPOINT13B='a16z-infra/llama13b-v2-chat: df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5'
MODEL_ENDPOINT70B='replicate/llama70b-v2-chat: e951f18578850b652510200860fc4ea62b3b16fac280f83ff32282f87bbd2e48'

Klistra in din replikeringstoken och spara .env-filen.

Utforma chatbotens konversationsflöde

Skapa en förfrågan om att starta Llama 2-modellen beroende på vilken uppgift du vill att den ska göra. I det här fallet vill du att modellen ska fungera som assistent.

# Set Pre-propmt 
PRE_PROMPT = "You are a helpful assistant. You do not respond as " \
"'User' or pretend to be 'User'." \
" You only respond once as Assistant."

Ställ in sidkonfigurationen för din chatbot enligt följande:

# Set initial page configuration
st.set_page_config(
 page_title="LLaMA2Chat",
 page_icon=":volleyball:",
 layout="wide"
)

Skriv en funktion som initierar och ställer in sessionstillståndsvariabler.

# Constants
LLaMA2_MODELS = {
'LLaMA2-7B': LLaMA2_7B_ENDPOINT,
'LLaMA2-13B': LLaMA2_13B_ENDPOINT,
'LLaMA2-70B': LLaMA2_70B_ENDPOINT,
}
# Session State Variables
DEFAULT_TEMPERATURE = 0.1
DEFAULT_TOP_P = 0.9
DEFAULT_MAX_SEQ_LEN = 512
DEFAULT_PRE_PROMPT = PRE_PROMPT
defsetup_session_state():
 st.session_state.setdefault('chat_dialogue', [])
 selected_model = st.sidebar.selectbox(
'Choose a LLaMA2 model:', list(LLaMA2_MODELS.keys()), key='model')
 st.session_state.setdefault(
'llm', LLaMA2_MODELS.get(selected_model, LLaMA2_70B_ENDPOINT))
 st.session_state.setdefault('temperature', DEFAULT_TEMPERATURE)
 st.session_state.setdefault('top_p', DEFAULT_TOP_P)
 st.session_state.setdefault('max_seq_len', DEFAULT_MAX_SEQ_LEN)
 st.session_state.setdefault('pre_prompt', DEFAULT_PRE_PROMPT)

Funktionen ställer in de väsentliga variablerna som chat_dialog, pre_prompt, llm, top_p, max_seq_len, och temperatur i sessionstillståndet. Den hanterar också valet av Llama 2-modellen baserat på användarens val.

Skriv en funktion för att återge sidofältets innehåll i Streamlit-appen.

defrender_sidebar():
 st.sidebar.header("LLaMA2 Chatbot")
 st.session_state['temperature'] = st.sidebar.slider('Temperature:',
 min_value=0.01, max_value=5.0, value=DEFAULT_TEMPERATURE, step=0.01)
 st.session_state['top_p'] = st.sidebar.slider('Top P:', min_value=0.01,
 max_value=1.0, value=DEFAULT_TOP_P, step=0.01)
 st.session_state['max_seq_len'] = st.sidebar.slider('Max Sequence Length:',
 min_value=64, max_value=4096, value=DEFAULT_MAX_SEQ_LEN, step=8)
 new_prompt = st.sidebar.text_area(
'Prompt before the chat starts. Edit here if desired:', 
 DEFAULT_PRE_PROMPT, height=60)
if new_prompt != DEFAULT_PRE_PROMPT and new_prompt != ""and
new_prompt isnotNone:
 st.session_state['pre_prompt'] = new_prompt + "\n"
else:
 st.session_state['pre_prompt'] = DEFAULT_PRE_PROMPT

Funktionen visar rubriken och inställningsvariablerna för Llama 2 chatbot för justeringar.

Skriv funktionen som återger chatthistoriken i huvudinnehållsområdet i Streamlit-appen.

defrender_chat_history():
 response_container = st.container()
for message in st.session_state.chat_dialogue:
with st.chat_message(message["role"]):
 st.markdown(message["content"])

Funktionen itererar genom chat_dialogen som sparats i sessionstillståndet och visar varje meddelande med motsvarande roll (användare eller assistent).

Hantera användarens input med funktionen nedan.

defhandle_user_input():
 user_input = st.chat_input(
"Type your question here to talk to LLaMA2"
)
if user_input:
 st.session_state.chat_dialogue.append(
{"role": "user", "content": user_input}
)
with st.chat_message("user"):
 st.markdown(user_input)

Denna funktion presenterar användare med ett inmatningsfält där de kan skriva in sina meddelanden och frågor. Meddelandet läggs till i chat_dialog i sessionstillståndet med användare roll när användaren skickar meddelandet.

Skriv en funktion som genererar svar från Llama 2-modellen och visar dem i chattområdet.

defgenerate_assistant_response():
 message_placeholder = st.empty()
 full_response = ""
 string_dialogue = st.session_state['pre_prompt']

for dict_message in st.session_state.chat_dialogue:
 speaker = "User"if dict_message["role"] == "user"else"Assistant"
 string_dialogue += f"{speaker}: {dict_message['content']}\n"

 output = debounce_replicate_run(
 st.session_state['llm'],
 string_dialogue + "Assistant: ",
 st.session_state['max_seq_len'],
 st.session_state['temperature'],
 st.session_state['top_p'],
 REPLICATE_API_TOKEN
 )

for item in output:
 full_response += item
 message_placeholder.markdown(full_response + "▌")

 message_placeholder.markdown(full_response)
 st.session_state.chat_dialogue.append({"role": "assistant",
"content": full_response})

Funktionen skapar en konversationshistoriksträng som inkluderar både användar- och assistentmeddelanden innan du ringer upp debounce_replicate_run funktion för att få assistentens svar. Den modifierar kontinuerligt svaret i användargränssnittet för att ge en chattupplevelse i realtid.

Skriv huvudfunktionen som ansvarar för att rendera hela Streamlit-appen.

defrender_app():
 setup_session_state()
 render_sidebar()
 render_chat_history()
 handle_user_input()
 generate_assistant_response()

Den anropar alla definierade funktioner för att ställa in sessionstillståndet, rendera sidofältet, chatthistorik, hantera användarinmatning och generera assistentsvar i en logisk ordning.

Skriv en funktion för att anropa render_app funktion och starta programmet när skriptet körs.

defmain():
 render_app()
if __name__ == "__main__":
 main()

Nu bör din ansökan vara klar för exekvering.

Hantera API-förfrågningar

Skapa en utils.py fil i din projektkatalog och lägg till funktionen nedan:

import replicate
import time
# Initialize debounce variables
last_call_time = 0
debounce_interval = 2# Set the debounce interval (in seconds)
defdebounce_replicate_run(llm, prompt, max_len, temperature, top_p,
 API_TOKEN):
global last_call_time
 print("last call time: ", last_call_time)
 current_time = time.time()
 elapsed_time = current_time - last_call_time
if elapsed_time < debounce_interval:
 print("Debouncing")
return"Hello! Your requests are too fast. Please wait a few" \
" seconds before sending another request."
 last_call_time = time.time()
 output = replicate.run(llm, input={"prompt": prompt + "Assistant: ",
"max_length": max_len, "temperature": 
 temperature, "top_p": top_p,
"repetition_penalty": 1}, api_token=API_TOKEN)
return output

Funktionen utför en avstudsmekanism för att förhindra frekventa och överdrivna API-frågor från en användares indata.

Importera sedan avstudsningssvarsfunktionen till din llama_chatbot.py fil enligt följande:

from utils import debounce_replicate_run

Kör nu applikationen:

streamlit run llama_chatbot.py

Förväntad utgång:

Resultatet visar ett samtal mellan modellen och en människa.

Verkliga tillämpningar av Streamlit och Llama 2 Chatbots

Några verkliga exempel på Llama 2-applikationer inkluderar:

• Chatbots: Dess användning gäller för att skapa mänskliga svar chatbots som kan hålla konversationer i realtid om flera ämnen.
• Virtuella assistenter: Dess användning gäller för att skapa virtuella assistenter som förstår och svarar på mänskliga språkfrågor.
• Språköversättning: Användningen gäller språköversättningsuppgifter.
• Textsammanfattning: Dess användning är tillämpbar för att sammanfatta stora texter till korta texter för enkel förståelse.
• Forskning: Du kan använda Llama 2 för forskningsändamål genom att svara på frågor inom en rad ämnen.

AI: s framtid

Med slutna modeller som GPT-3.5 och GPT-4 är det ganska svårt för små spelare att bygga någonting av substans med hjälp av LLM eftersom det kan vara ganska dyrt att komma åt GPT-modellens API.

Att öppna upp avancerade stora språkmodeller som Llama 2 för utvecklargemenskapen är bara början på en ny era av AI. Det kommer att leda till mer kreativ och innovativ implementering av modellerna i verkliga applikationer, vilket leder till en accelererad kapplöpning mot att uppnå artificiell superintelligens (ASI).