Udnyt open source Llama 2 LLM til at bygge en tilpasset chatbot med Python.

Llama 2 er en open source stor sprogmodel (LLM) udviklet af Meta. Det er en kompetent open source-storsprogmodel, uden tvivl bedre end nogle lukkede modeller som GPT-3.5 og PaLM 2. Den består af tre forudtrænede og finjusterede generative tekstmodelstørrelser, herunder 7 milliarder, 13 milliarder og 70 milliarder parametermodeller.

Du vil udforske Llama 2s samtaleevner ved at bygge en chatbot ved hjælp af Streamlit og Llama 2.

Forstå Llama 2: Funktioner og fordele

Hvor anderledes er Llama 2 fra sin forgænger stor sprogmodel, Lama 1?

  • Større modelstørrelse: Modellen er større med op til 70 milliarder parametre. Dette gør det muligt for den at lære mere indviklede associationer mellem ord og sætninger.
  • Forbedrede samtaleevner: Forstærkning Learning from Human Feedback (RLHF) forbedrer samtaleapplikationsevner. Dette gør det muligt for modellen at generere menneskelignende indhold selv i indviklede interaktioner.
  • Hurtigere slutning
    instagram viewer
    : Den introducerer en ny metode kaldet grouped-query opmærksomhed for at fremskynde inferens. Dette resulterer i dens evne til at bygge mere nyttige applikationer som chatbots og virtuelle assistenter.
  • Mere effektivt: Den er mere hukommelses- og beregningsressourceeffektiv end sin forgænger.
  • Open source og ikke-kommerciel licens: Det er open source. Forskere og udviklere kan bruge og ændre Llama 2 uden begrænsninger.

Llama 2 overgår markant sin forgænger på alle punkter. Disse egenskaber gør det til et potent værktøj til mange applikationer, såsom chatbots, virtuelle assistenter og naturlig sprogforståelse.

Opsætning af et strømbelyst miljø til Chatbot-udvikling

For at begynde at bygge din applikation skal du opsætte et udviklingsmiljø. Dette er for at isolere dit projekt fra de eksisterende projekter på din maskine.

Først, start med skabe et virtuelt miljø bruger Pipenv bibliotek som følger:

pipenv shell

Derefter skal du installere de nødvendige biblioteker for at bygge chatbotten.

pipenv install streamlit replicate

Strømbelyst: Det er en open source-webappramme, der gør maskinlæring og datavidenskabsapplikationer hurtigt.

Repliker: Det er en cloud-platform, der giver adgang til store open source-maskinelæringsmodeller til implementering.

Få dit Llama 2 API-token fra replikat

For at få en Replicate token-nøgle skal du først registrere en konto på Repliker ved hjælp af din GitHub-konto.

Repliker tillader kun login via en GitHub-konto.

Når du har åbnet dashboardet, skal du navigere til Udforske knappen og søg efter Llama 2 chat for at se lama-2-70b-chat model.

Klik på lama-2-70b-chat model for at se Llama 2 API-endepunkterne. Klik på API knappen på lama-2-70b-chat modellens navigationslinje. I højre side af siden skal du klikke på Python knap. Dette giver dig adgang til API-tokenet til Python-applikationer.

Kopier REPLICATE_API_TOKEN og opbevar det sikkert til fremtidig brug.

Den fulde kildekode er tilgængelig i denne GitHub-depot.

Opbygning af chatbot

Først skal du oprette en Python-fil kaldet llama_chatbot.py og en env-fil (.env). Du skriver din kode i llama_chatbot.py og gemmer dine hemmelige nøgler og API-tokens i .env-filen.

I filen llama_chatbot.py importerer du bibliotekerne som følger.

import streamlit as st 
import os 
import replicate

Indstil derefter de globale variabler for lama-2-70b-chat model.

# 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='')

Tilføj repliker-tokenet og modelslutpunkter i .env-filen i følgende 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'

Indsæt dit repliker-token, og gem .env-filen.

Design af Chatbots samtaleflow

Opret en pre-prompt for at starte Llama 2-modellen afhængigt af, hvilken opgave du vil have den til at udføre. I dette tilfælde ønsker du, at modellen skal fungere 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."

Opsæt sidekonfigurationen for din chatbot som følger:

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

Skriv en funktion, der initialiserer og opsætter sessionstilstandsvariabler.

# 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 indstiller de væsentlige variabler som f.eks chat_dialog, pre_prompt, llm, top_s, max_seq_len, og temperatur i sessionstilstanden. Den håndterer også valget af Llama 2-modellen baseret på brugerens valg.

Skriv en funktion til at gengive sidebjælkeindholdet 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 viser headeren og indstillingsvariablerne for Llama 2 chatbot til justeringer.

Skriv den funktion, der gengiver chathistorikken, i hovedindholdsområ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 itererer gennem chat_dialogen, der er gemt i sessionstilstanden, og viser hver besked med den tilsvarende rolle (bruger eller assistent).

Håndter brugerens input ved hjælp af funktionen nedenfor.

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)

Denne funktion præsenterer bruger med et indtastningsfelt, hvor de kan indtaste deres beskeder og spørgsmål. Beskeden føjes til chat_dialog i sessionstilstanden med bruger rolle, når brugeren indsender beskeden.

Skriv en funktion, der genererer svar fra Llama 2-modellen og viser dem i chatområ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 opretter en samtalehistorikstreng, der inkluderer både bruger- og assistentbeskeder, før du ringer til debounce_replicate_run funktion for at få assistentens svar. Det ændrer løbende svaret i brugergrænsefladen for at give en chatoplevelse i realtid.

Skriv hovedfunktionen, der er ansvarlig for at gengive hele Streamlit-appen.

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

Det kalder alle de definerede funktioner til at konfigurere sessionstilstanden, gengive sidebjælken, chathistorik, håndtere brugerinput og generere assistentsvar i en logisk rækkefølge.

Skriv en funktion til at starte render_app funktion og start applikationen, når scriptet er udført.

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

Nu skulle din ansøgning være klar til eksekvering.

Håndtering af API-anmodninger

Lave en utils.py fil i din projektmappe og tilføj funktionen nedenfor:

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 udfører en debounce-mekanisme for at forhindre hyppige og overdrevne API-forespørgsler fra en brugers input.

Importer derefter debounce response-funktionen til din llama_chatbot.py fil som følger:

from utils import debounce_replicate_run

Kør nu applikationen:

streamlit run llama_chatbot.py

Forventet output:

Outputtet viser en samtale mellem modellen og et menneske.

Virkelige applikationer af Streamlit og Llama 2 Chatbots

Nogle eksempler fra den virkelige verden på Llama 2-applikationer inkluderer:

  • Chatbots: Dens brug gælder for at skabe menneskelige svar chatbots der kan holde samtaler i realtid om flere emner.
  • Virtuelle assistenter: Dets brug gælder for at skabe virtuelle assistenter, der forstår og reagerer på menneskelige sprogforespørgsler.
  • Sprogoversættelse: Dets brug gælder for sprogoversættelsesopgaver.
  • Tekstopsummering: Dens brug er anvendelig til at opsummere store tekster til korte tekster for nem forståelse.
  • Forskning: Du kan anvende Llama 2 til forskningsformål ved at besvare spørgsmål på tværs af en række emner.

Fremtiden for AI

Med lukkede modeller som GPT-3.5 og GPT-4 er det ret svært for små spillere at bygge noget af substans ved hjælp af LLM'er, da adgang til GPT-modellens API kan være ret dyrt.

At åbne avancerede store sprogmodeller som Llama 2 for udviklerfællesskabet er kun begyndelsen på en ny æra af kunstig intelligens. Det vil føre til mere kreativ og innovativ implementering af modellerne i applikationer fra den virkelige verden, hvilket vil føre til et accelereret kapløb mod at opnå kunstig superintelligens (ASI).