Nutzen Sie das Open-Source-Llama 2 LLM, um einen benutzerdefinierten Chatbot mit Python zu erstellen.

Llama 2 ist ein von Meta entwickeltes Open-Source-Large-Language-Modell (LLM). Es handelt sich um ein kompetentes Open-Source-Modell für große Sprachen, das wohl besser ist als einige geschlossene Modelle wie GPT-3.5 und PaLM 2. Es besteht aus drei vorab trainierten und fein abgestimmten generativen Textmodellgrößen, einschließlich der Parametermodelle mit 7 Milliarden, 13 Milliarden und 70 Milliarden.

Sie erkunden die Konversationsfunktionen von Llama 2, indem Sie mit Streamlit und Llama 2 einen Chatbot erstellen.

Llama 2 verstehen: Funktionen und Vorteile

Wie unterschiedlich ist Llama 2 von seinem Vorgänger? großes Sprachmodell, Lama 1?

  • Größere Modellgröße: Das Modell ist mit bis zu 70 Milliarden Parametern größer. Dadurch ist es in der Lage, komplexere Assoziationen zwischen Wörtern und Sätzen zu lernen.
  • Verbesserte Konversationsfähigkeiten: Reinforcement Learning from Human Feedback (RLHF) verbessert die Fähigkeiten zur Konversationsanwendung. Dadurch kann das Modell auch bei komplizierten Interaktionen menschenähnliche Inhalte generieren.
    instagram viewer
  • Schnellere Schlussfolgerung: Es führt eine neuartige Methode namens Grouped-Query Attention ein, um die Inferenz zu beschleunigen. Dies führt dazu, dass das Unternehmen in der Lage ist, nützlichere Anwendungen wie Chatbots und virtuelle Assistenten zu entwickeln.
  • Effizienter: Es ist speicher- und rechenressourceneffizienter als sein Vorgänger.
  • Open-Source- und nichtkommerzielle Lizenz: Es ist Open Source. Forscher und Entwickler können Llama 2 ohne Einschränkungen nutzen und modifizieren.

Llama 2 übertrifft seinen Vorgänger in allen Belangen deutlich. Diese Eigenschaften machen es zu einem leistungsstarken Werkzeug für viele Anwendungen, wie etwa Chatbots, virtuelle Assistenten und das Verstehen natürlicher Sprache.

Einrichten einer Streamlit-Umgebung für die Chatbot-Entwicklung

Um mit der Erstellung Ihrer Anwendung zu beginnen, müssen Sie eine Entwicklungsumgebung einrichten. Dies dient dazu, Ihr Projekt von den vorhandenen Projekten auf Ihrem Computer zu isolieren.

Beginnen Sie zunächst mit Erstellen einer virtuellen Umgebung Verwendung der Pipenv Bibliothek wie folgt:

pipenv shell

Als nächstes installieren Sie die notwendigen Bibliotheken, um den Chatbot zu erstellen.

pipenv install streamlit replicate

Streamlit: Es handelt sich um ein Open-Source-Web-App-Framework, das Anwendungen für maschinelles Lernen und Datenwissenschaft schnell rendert.

Replizieren: Es handelt sich um eine Cloud-Plattform, die Zugriff auf große Open-Source-Modelle für maschinelles Lernen zur Bereitstellung bietet.

Holen Sie sich Ihr Llama 2 API-Token von Replicate

Um einen Replikat-Token-Schlüssel zu erhalten, müssen Sie zunächst ein Konto registrieren Replizieren mit Ihrem GitHub-Konto.

Replizieren erlaubt nur die Anmeldung über a GitHub-Konto.

Sobald Sie auf das Dashboard zugegriffen haben, navigieren Sie zu Erkunden Klicken Sie auf die Schaltfläche und suchen Sie nach „Llama 2 Chat“, um den zu sehen Lama-2–70b-Chat Modell.

Klick auf das Lama-2–70b-Chat Modell, um die Llama 2-API-Endpunkte anzuzeigen. Drücke den API Taste auf der Lama-2–70b-Chat Navigationsleiste des Modells. Klicken Sie auf der rechten Seite der Seite auf Python Taste. Dadurch erhalten Sie Zugriff auf das API-Token für Python-Anwendungen.

Kopiere das REPLICATE_API_TOKEN und bewahren Sie es für den späteren Gebrauch sicher auf.

Der vollständige Quellcode ist hier verfügbar GitHub-Repository.

Aufbau des Chatbots

Erstellen Sie zunächst eine Python-Datei mit dem Namen llama_chatbot.py und eine env-Datei (.env). Sie schreiben Ihren Code in llama_chatbot.py und speichern Ihre geheimen Schlüssel und API-Tokens in der .env-Datei.

Importieren Sie die Bibliotheken in der Datei llama_chatbot.py wie folgt.

import streamlit as st 
import os 
import replicate

Als nächstes legen Sie die globalen Variablen fest Lama-2–70b-Chat 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='')

Fügen Sie in der .env-Datei das Replikat-Token und die Modellendpunkte im folgenden Format hinzu:

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'

Fügen Sie Ihr Replikat-Token ein und speichern Sie die .env-Datei.

Entwerfen des Gesprächsflusses des Chatbots

Erstellen Sie eine Vorabaufforderung zum Starten des Llama 2-Modells, je nachdem, welche Aufgabe es ausführen soll. In diesem Fall möchten Sie, dass das Modell als Assistent fungiert.

# 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."

Richten Sie die Seitenkonfiguration für Ihren Chatbot wie folgt ein:

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

Schreiben Sie eine Funktion, die Sitzungsstatusvariablen initialisiert und einrichtet.

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

Die Funktion setzt die wesentlichen Variablen wie chat_dialog, pre_prompt, llm, top_p, max_seq_len, Und Temperatur im Sitzungsstatus. Es übernimmt auch die Auswahl des Llama 2-Modells basierend auf der Wahl des Benutzers.

Schreiben Sie eine Funktion zum Rendern des Seitenleisteninhalts der Streamlit-App.

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

Die Funktion zeigt den Header und die Einstellungsvariablen des Llama 2 Chatbots für Anpassungen an.

Schreiben Sie die Funktion, die den Chat-Verlauf im Hauptinhaltsbereich der Streamlit-App rendert.

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"])

Die Funktion durchläuft den im Sitzungsstatus gespeicherten chat_dialogue und zeigt jede Nachricht mit der entsprechenden Rolle (Benutzer oder Assistent) an.

Behandeln Sie die Eingaben des Benutzers mit der folgenden Funktion.

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)

Diese Funktion präsentiert die Benutzer mit einem Eingabefeld, in das sie ihre Nachrichten und Fragen eingeben können. Die Nachricht wird dem hinzugefügt chat_dialog im Sitzungszustand mit dem Benutzer Rolle, sobald der Benutzer die Nachricht übermittelt.

Schreiben Sie eine Funktion, die Antworten aus dem Llama 2-Modell generiert und diese im Chatbereich anzeigt.

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})

Die Funktion erstellt eine Konversationsverlaufszeichenfolge, die sowohl Benutzer- als auch Assistentennachrichten enthält, bevor sie aufgerufen wird debounce_replicate_run Funktion, um die Antwort des Assistenten zu erhalten. Es ändert kontinuierlich die Antwort in der Benutzeroberfläche, um ein Chat-Erlebnis in Echtzeit zu ermöglichen.

Schreiben Sie die Hauptfunktion, die für das Rendern der gesamten Streamlit-App verantwortlich ist.

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

Es ruft alle definierten Funktionen auf, um den Sitzungsstatus einzurichten, die Seitenleiste und den Chat-Verlauf darzustellen, Benutzereingaben zu verarbeiten und Assistentenantworten in einer logischen Reihenfolge zu generieren.

Schreiben Sie eine Funktion zum Aufrufen render_app Funktion und starten Sie die Anwendung, wenn das Skript ausgeführt wird.

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

Jetzt sollte Ihre Bewerbung zur Ausführung bereit sein.

Bearbeitung von API-Anfragen

Ein... kreieren utils.py Datei in Ihrem Projektverzeichnis und fügen Sie die folgende Funktion hinzu:

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

Die Funktion führt einen Entprellungsmechanismus durch, um häufige und übermäßige API-Abfragen aus der Eingabe eines Benutzers zu verhindern.

Als nächstes importieren Sie die Entprellungsantwortfunktion in Ihr llama_chatbot.py Datei wie folgt:

from utils import debounce_replicate_run

Führen Sie nun die Anwendung aus:

streamlit run llama_chatbot.py

Erwartete Ausgabe:

Die Ausgabe zeigt ein Gespräch zwischen dem Modell und einem Menschen.

Reale Anwendungen von Streamlit- und Llama 2-Chatbots

Einige Beispiele aus der Praxis für Llama 2-Anwendungen sind:

  • Chatbots: Seine Verwendung gilt für das Erstellen Chatbots mit menschlicher Reaktion das Echtzeitgespräche zu verschiedenen Themen führen kann.
  • Virtuelle Assistenten: Seine Verwendung bezieht sich auf die Erstellung virtueller Assistenten, die menschliche Sprachanfragen verstehen und darauf reagieren.
  • Sprachübersetzung: Seine Verwendung gilt für Sprachübersetzungsaufgaben.
  • Textzusammenfassung: Seine Verwendung eignet sich zum Zusammenfassen großer Texte in kurze Texte, um das Verständnis zu erleichtern.
  • Forschung: Sie können Llama 2 zu Forschungszwecken anwenden, indem Sie Fragen zu einer Reihe von Themen beantworten.

Die Zukunft der KI

Bei geschlossenen Modellen wie GPT-3.5 und GPT-4 ist es für kleine Spieler ziemlich schwierig, mit LLMs etwas Substanzielles zu bauen, da der Zugriff auf die GPT-Modell-API recht teuer sein kann.

Die Öffnung fortschrittlicher großer Sprachmodelle wie Llama 2 für die Entwicklergemeinschaft ist nur der Beginn einer neuen Ära der KI. Dies wird zu einer kreativeren und innovativeren Umsetzung der Modelle in realen Anwendungen führen, was zu einem beschleunigten Wettlauf um die Erreichung der künstlichen Superintelligenz (ASI) führen wird.