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 skiljer sig Llama 2 från sin föregångare stora språkmodell, Llama 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ågor: Förstärkning Att lära sig 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.
  • Snabbare slutledning: Den introducerar en ny metod som kallas uppmärksamhet för grupperad fråga 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 effektivt: Det är mer minnes- och beräkningsresurseffektivt än sin föregångare.
  • Öppen källkod och icke-kommersiell licens: Den ä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 att skapa en virtuell miljö med Pipenv-biblioteket enligt följande:

 pipenv shell 

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

 pipenv install streamlit replicate 

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

Replikera: 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.

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

Klicka på llama-2–70b-chattmodellen för att se Llama 2 API-slutpunkter. Klicka på API-knappen i llama-2–70b-chattmodellens navigeringsfält. Klicka på Python-knappen till höger på sidan. Detta ger dig tillgång till API-token för Python-applikationer.

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

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 llama-2–70b-chattmodellen.

 
REPLICATE_API_TOKEN = os.environ.get('REPLICATE_API_TOKEN', default="")


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.

Designa 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.

 
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:

 
st.set_page_config(
   page_title="LLaMA2Chat",
   page_icon=":volleyball:",
   layout="wide"
)

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

 
LLaMA2_MODELS = {
   'LLaMA2-7B': LLaMA2_7B_ENDPOINT,
   'LLaMA2-13B': LLaMA2_13B_ENDPOINT,
   'LLaMA2-70B': LLaMA2_70B_ENDPOINT,
}


DEFAULT_TEMPERATURE = 0.1
DEFAULT_TOP_P = 0.9
DEFAULT_MAX_SEQ_LEN = 512
DEFAULT_PRE_PROMPT = PRE_PROMPT

def setup_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_dialogue, 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.

 def render_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 is not None:
       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.

 def render_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_dialogue sparad i sessionstillståndet och visar varje meddelande med motsvarande roll (användare eller assistent).

Hantera användarens input med funktionen nedan.

 def handle_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 ger användaren ett inmatningsfält där de kan skriva in sina meddelanden och frågor. Meddelandet läggs till i chat_dialogue i sessionstillståndet med användarrollen när användaren skickar meddelandet.

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

 def generate_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 funktionen debounce_replicate_run anropas 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.

 def render_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-funktionen och starta applikationen när skriptet körs.

 def main():
   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


last_call_time = 0
debounce_interval = 2

def debounce_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 funktionen för avstudssvar 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 respons chatbots som kan hålla realtidskonversationer 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 kan användas 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 olika ä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).