llama cpp python
v0.3.2
llama.cpp 
Einfache Python-Bindungen für die Bibliothek llama.cpp von @ggerganov . Dieses Paket bietet:
ctypes Schnittstelle.Die Dokumentation ist unter https://llama-cpp-python.readthedocs.io/en/latest verfügbar.
Anforderungen:
Um das Paket zu installieren, führen Sie Folgendes aus:
pip install llama-cpp-python Dadurch wird auch llama.cpp aus dem Quellcode erstellt und zusammen mit diesem Python-Paket installiert.
Wenn dies fehlschlägt, fügen Sie --verbose zur pip install hinzu und sehen Sie sich das vollständige cmake-Build-Protokoll an.
Vorgefertigtes Rad (Neu)
Es ist auch möglich, ein vorgefertigtes Rad mit grundlegender CPU-Unterstützung zu installieren.
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu llama.cpp unterstützt eine Reihe von Hardwarebeschleunigungs-Backends, um die Inferenz zu beschleunigen, sowie Backend-spezifische Optionen. Eine vollständige Liste finden Sie in der README-Datei zu llama.cpp.
Alle Cmake-Build-Optionen llama.cpp können über die Umgebungsvariable CMAKE_ARGS oder über das CLI-Flag --config-settings / -C während der Installation festgelegt werden.
# Linux and Mac
CMAKE_ARGS= " -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS "
pip install llama-cpp-python # Windows
$ env: CMAKE_ARGS = " -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS "
pip install llama - cpp - python Sie können auch über den Befehl pip install -C / --config-settings festgelegt und in einer Datei requirements.txt gespeichert werden:
pip install --upgrade pip # ensure pip is up to date
pip install llama-cpp-python
-C cmake.args= " -DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS " # requirements.txt
llama-cpp-python -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS"Nachfolgend finden Sie einige gängige Backends, ihre Build-Befehle und alle zusätzlich erforderlichen Umgebungsvariablen.
Um mit OpenBLAS zu installieren, legen Sie vor der Installation die Umgebungsvariablen GGML_BLAS und GGML_BLAS_VENDOR fest:
CMAKE_ARGS= " -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS " pip install llama-cpp-python Um mit CUDA-Unterstützung zu installieren, legen Sie vor der Installation die Umgebungsvariable GGML_CUDA=on fest:
CMAKE_ARGS= " -DGGML_CUDA=on " pip install llama-cpp-pythonVorgefertigtes Rad (Neu)
Es ist auch möglich, ein vorgefertigtes Rad mit CUDA-Unterstützung zu installieren. Solange Ihr System einige Anforderungen erfüllt:
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/ < cuda-version > Dabei ist <cuda-version> einer der folgenden:
cu121 : CUDA 12.1cu122 : CUDA 12.2cu123 : CUDA 12.3cu124 : CUDA 12.4cu125 : CUDA 12.5So installieren Sie beispielsweise das CUDA 12.1-Rad:
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu121 Um mit Metal (MPS) zu installieren, legen Sie vor der Installation die Umgebungsvariable GGML_METAL=on fest:
CMAKE_ARGS= " -DGGML_METAL=on " pip install llama-cpp-pythonVorgefertigtes Rad (Neu)
Es ist auch möglich, ein vorgefertigtes Rad mit Metallhalterung zu installieren. Solange Ihr System einige Anforderungen erfüllt:
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/metal Um mit hipBLAS/ROCm-Unterstützung für AMD-Karten zu installieren, legen Sie vor der Installation die Umgebungsvariable GGML_HIPBLAS=on fest:
CMAKE_ARGS= " -DGGML_HIPBLAS=on " pip install llama-cpp-python Um mit Vulkan-Unterstützung zu installieren, legen Sie vor der Installation die Umgebungsvariable GGML_VULKAN=on fest:
CMAKE_ARGS= " -DGGML_VULKAN=on " pip install llama-cpp-python Um mit SYCL-Unterstützung zu installieren, legen Sie vor der Installation die Umgebungsvariable GGML_SYCL=on fest:
source /opt/intel/oneapi/setvars.sh
CMAKE_ARGS= " -DGGML_SYCL=on -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx " pip install llama-cpp-python Um mit RPC-Unterstützung zu installieren, legen Sie vor der Installation die Umgebungsvariable GGML_RPC=on fest:
source /opt/intel/oneapi/setvars.sh
CMAKE_ARGS= " -DGGML_RPC=on " pip install llama-cpp-python Wenn Sie auf Probleme stoßen, bei denen es sich beschwert, dass 'nmake' '?' nicht gefunden werden kann. oder CMAKE_C_COMPILER, Sie können w64devkit wie im llama.cpp-Repo erwähnt extrahieren und diese manuell zu CMAKE_ARGS hinzufügen, bevor Sie pip install ausführen:
$env:CMAKE_GENERATOR = "MinGW Makefiles"
$env:CMAKE_ARGS = "-DGGML_OPENBLAS=on -DCMAKE_C_COMPILER=C: /w64devkit/bin/gcc.exe -DCMAKE_CXX_COMPILER=C: /w64devkit/bin/g++.exe" Sehen Sie sich die obigen Anweisungen an und legen Sie CMAKE_ARGS auf das BLAS-Backend fest, das Sie verwenden möchten.
Eine ausführliche Installationsdokumentation für die MacOS Metal GPU finden Sie unter docs/install/macos.md
Hinweis: Wenn Sie Apple Silicon (M1) Mac verwenden, stellen Sie sicher, dass Sie eine Python-Version installiert haben, die die arm64-Architektur unterstützt. Zum Beispiel:
wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
bash Miniforge3-MacOSX-arm64.shAndernfalls wird bei der Installation die x86-Version von llama.cpp erstellt, die auf dem Apple Silicon (M1) Mac zehnmal langsamer ist.
Versuchen Sie die Installation mit
CMAKE_ARGS= " -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_APPLE_SILICON_PROCESSOR=arm64 -DGGML_METAL=on " pip install --upgrade --verbose --force-reinstall --no-cache-dir llama-cpp-python Um llama-cpp-python zu aktualisieren und neu zu erstellen, fügen Sie die Flags --upgrade --force-reinstall --no-cache-dir zum Befehl pip install hinzu, um sicherzustellen, dass das Paket aus der Quelle neu erstellt wird.
API-Referenz
Die High-Level-API stellt über die Llama Klasse eine einfache verwaltete Schnittstelle bereit.
Nachfolgend finden Sie ein kurzes Beispiel, das zeigt, wie die High-Level-API zur grundlegenden Textvervollständigung verwendet wird:
from llama_cpp import Llama
llm = Llama (
model_path = "./models/7B/llama-model.gguf" ,
# n_gpu_layers=-1, # Uncomment to use GPU acceleration
# seed=1337, # Uncomment to set a specific seed
# n_ctx=2048, # Uncomment to increase the context window
)
output = llm (
"Q: Name the planets in the solar system? A: " , # Prompt
max_tokens = 32 , # Generate up to 32 tokens, set to None to generate up to the end of the context window
stop = [ "Q:" , " n " ], # Stop generating just before the model would generate a new question
echo = True # Echo the prompt back in the output
) # Generate a completion, can also call create_completion
print ( output ) Standardmäßig generiert llama-cpp-python Vervollständigungen in einem OpenAI-kompatiblen Format:
{
"id" : "cmpl-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" ,
"object" : "text_completion" ,
"created" : 1679561337 ,
"model" : "./models/7B/llama-model.gguf" ,
"choices" : [
{
"text" : "Q: Name the planets in the solar system? A: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune and Pluto." ,
"index" : 0 ,
"logprobs" : None ,
"finish_reason" : "stop"
}
],
"usage" : {
"prompt_tokens" : 14 ,
"completion_tokens" : 28 ,
"total_tokens" : 42
}
} Die Textvervollständigung ist über die Methoden __call__ und create_completion der Llama -Klasse verfügbar.
Sie können Llama -Modelle im gguf Format direkt von Hugging Face herunterladen, indem Sie die Methode from_pretrained verwenden. Sie müssen das Paket huggingface-hub installieren, um diese Funktion nutzen zu können ( pip install huggingface-hub ).
llm = Llama . from_pretrained (
repo_id = "Qwen/Qwen2-0.5B-Instruct-GGUF" ,
filename = "*q8_0.gguf" ,
verbose = False
) Standardmäßig lädt from_pretrained das Modell in das Huggingface-Cache-Verzeichnis herunter. Anschließend können Sie installierte Modelldateien mit dem huggingface-cli -Tool verwalten.
Die High-Level-API bietet auch eine einfache Schnittstelle für den Chat-Abschluss.
Für die Vervollständigung des Chats muss das Modell wissen, wie die Nachrichten in einer einzigen Eingabeaufforderung formatiert werden. Die Llama -Klasse erledigt dies mithilfe vorregistrierter Chat-Formate (z. B. chatml , llama-2 , gemma usw.) oder durch die Bereitstellung eines benutzerdefinierten Chat-Handler-Objekts.
Das Modell formatiert die Nachrichten in einer einzigen Eingabeaufforderung unter Verwendung der folgenden Rangfolge:
chat_handler , falls bereitgestelltchat_format , falls bereitgestellttokenizer.chat_template aus den Metadaten des gguf Modells (sollte für die meisten neuen Modelle funktionieren, ältere Modelle verfügen möglicherweise nicht darüber).llama-2 Chatformat zurück Legen Sie verbose=True fest, um das ausgewählte Chat-Format anzuzeigen.
from llama_cpp import Llama
llm = Llama (
model_path = "path/to/llama-2/llama-model.gguf" ,
chat_format = "llama-2"
)
llm . create_chat_completion (
messages = [
{ "role" : "system" , "content" : "You are an assistant who perfectly describes images." },
{
"role" : "user" ,
"content" : "Describe this image in detail please."
}
]
) Der Chat-Abschluss ist über die Methode create_chat_completion der Klasse Llama verfügbar.
Für die Kompatibilität mit OpenAI API v1 verwenden Sie die Methode create_chat_completion_openai_v1 , die pydantische Modelle anstelle von Diktaten zurückgibt.
Um Chat-Antworten nur auf gültiges JSON oder ein bestimmtes JSON-Schema zu beschränken, verwenden Sie das Argument response_format in create_chat_completion .
Das folgende Beispiel beschränkt die Antwort nur auf gültige JSON-Zeichenfolgen.
from llama_cpp import Llama
llm = Llama ( model_path = "path/to/model.gguf" , chat_format = "chatml" )
llm . create_chat_completion (
messages = [
{
"role" : "system" ,
"content" : "You are a helpful assistant that outputs in JSON." ,
},
{ "role" : "user" , "content" : "Who won the world series in 2020" },
],
response_format = {
"type" : "json_object" ,
},
temperature = 0.7 ,
) Um die Antwort weiter auf ein bestimmtes JSON-Schema einzuschränken, fügen Sie das Schema zur schema Eigenschaft des Arguments response_format hinzu.
from llama_cpp import Llama
llm = Llama ( model_path = "path/to/model.gguf" , chat_format = "chatml" )
llm . create_chat_completion (
messages = [
{
"role" : "system" ,
"content" : "You are a helpful assistant that outputs in JSON." ,
},
{ "role" : "user" , "content" : "Who won the world series in 2020" },
],
response_format = {
"type" : "json_object" ,
"schema" : {
"type" : "object" ,
"properties" : { "team_name" : { "type" : "string" }},
"required" : [ "team_name" ],
},
},
temperature = 0.7 ,
) Die High-Level-API unterstützt OpenAI-kompatible Funktions- und Toolaufrufe. Dies ist über das Chat-Format functionary Pre-Trained Models“ oder über das generische Chat-Format chatml-function-calling möglich.
from llama_cpp import Llama
llm = Llama ( model_path = "path/to/chatml/llama-model.gguf" , chat_format = "chatml-function-calling" )
llm . create_chat_completion (
messages = [
{
"role" : "system" ,
"content" : "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. The assistant calls functions with appropriate input when necessary"
},
{
"role" : "user" ,
"content" : "Extract Jason is 25 years old"
}
],
tools = [{
"type" : "function" ,
"function" : {
"name" : "UserDetail" ,
"parameters" : {
"type" : "object" ,
"title" : "UserDetail" ,
"properties" : {
"name" : {
"title" : "Name" ,
"type" : "string"
},
"age" : {
"title" : "Age" ,
"type" : "integer"
}
},
"required" : [ "name" , "age" ]
}
}
}],
tool_choice = {
"type" : "function" ,
"function" : {
"name" : "UserDetail"
}
}
) Die verschiedenen gguf-konvertierten Dateien für diesen Modellsatz finden Sie hier. Functionary ist in der Lage, Funktionen intelligent aufzurufen und auch alle bereitgestellten Funktionsausgaben zu analysieren, um kohärente Antworten zu generieren. Alle Funktionärsmodelle der Version 2 unterstützen den parallelen Funktionsaufruf . Sie können beim Initialisieren der Llama-Klasse entweder functionary-v1 oder functionary-v2 für das chat_format angeben.
Aufgrund von Diskrepanzen zwischen llama.cpp und den Tokenizern von HuggingFace ist es erforderlich, HF-Tokenizer für Funktionäre bereitzustellen. Die LlamaHFTokenizer -Klasse kann initialisiert und an die Llama-Klasse übergeben werden. Dadurch wird der standardmäßige llama.cpp-Tokenizer überschrieben, der in der Llama-Klasse verwendet wird. Die Tokenizer-Dateien sind bereits in den jeweiligen HF-Repositorys enthalten, die die gguf-Dateien hosten.
from llama_cpp import Llama
from llama_cpp . llama_tokenizer import LlamaHFTokenizer
llm = Llama . from_pretrained (
repo_id = "meetkai/functionary-small-v2.2-GGUF" ,
filename = "functionary-small-v2.2.q4_0.gguf" ,
chat_format = "functionary-v2" ,
tokenizer = LlamaHFTokenizer . from_pretrained ( "meetkai/functionary-small-v2.2-GGUF" )
)HINWEIS : Es ist nicht erforderlich, die in Functionary verwendeten Standardsystemnachrichten bereitzustellen, da diese automatisch im Functionary-Chat-Handler hinzugefügt werden. Daher sollten die Nachrichten nur die Chat-Nachrichten und/oder Systemnachrichten enthalten, die zusätzlichen Kontext für das Modell bereitstellen (z. B. Datum, Uhrzeit usw.).
llama-cpp-python unterstützt beispielsweise llava1.5, die es dem Sprachmodell ermöglichen, Informationen sowohl aus Text als auch aus Bildern zu lesen.
Nachfolgend sind die unterstützten multimodalen Modelle und ihre jeweiligen Chat-Handler (Python-API) und Chat-Formate (Server-API) aufgeführt.
| Modell | LlamaChatHandler | chat_format |
|---|---|---|
| llava-v1.5-7b | Llava15ChatHandler | llava-1-5 |
| llava-v1.5-13b | Llava15ChatHandler | llava-1-5 |
| llava-v1.6-34b | Llava16ChatHandler | llava-1-6 |
| Mondtraum2 | MoondreamChatHandler | moondream2 |
| Nanollava | NanollavaChatHandler | nanollava |
| Lama-3-Vision-Alpha | Llama3VisionAlphaChatHandler | llama-3-vision-alpha |
| minicpm-v-2.6 | MiniCPMv26ChatHandler | minicpm-v-2.6 |
Anschließend müssen Sie einen benutzerdefinierten Chat-Handler verwenden, um das Clip-Modell zu laden und die Chat-Nachrichten und Bilder zu verarbeiten.
from llama_cpp import Llama
from llama_cpp . llama_chat_format import Llava15ChatHandler
chat_handler = Llava15ChatHandler ( clip_model_path = "path/to/llava/mmproj.bin" )
llm = Llama (
model_path = "./path/to/llava/llama-model.gguf" ,
chat_handler = chat_handler ,
n_ctx = 2048 , # n_ctx should be increased to accommodate the image embedding
)
llm . create_chat_completion (
messages = [
{ "role" : "system" , "content" : "You are an assistant who perfectly describes images." },
{
"role" : "user" ,
"content" : [
{ "type" : "text" , "text" : "What's in this image?" },
{ "type" : "image_url" , "image_url" : { "url" : "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" } }
]
}
]
) Sie können das Modell auch mithilfe der from_pretrained -Methode aus dem Hugging Face Hub ziehen.
from llama_cpp import Llama
from llama_cpp . llama_chat_format import MoondreamChatHandler
chat_handler = MoondreamChatHandler . from_pretrained (
repo_id = "vikhyatk/moondream2" ,
filename = "*mmproj*" ,
)
llm = Llama . from_pretrained (
repo_id = "vikhyatk/moondream2" ,
filename = "*text-model*" ,
chat_handler = chat_handler ,
n_ctx = 2048 , # n_ctx should be increased to accommodate the image embedding
)
response = llm . create_chat_completion (
messages = [
{
"role" : "user" ,
"content" : [
{ "type" : "text" , "text" : "What's in this image?" },
{ "type" : "image_url" , "image_url" : { "url" : "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" } }
]
}
]
)
print ( response [ "choices" ][ 0 ][ "text" ])Hinweis : Multimodale Modelle unterstützen auch Toolaufrufe und den JSON-Modus.
Bilder können als Base64-codierte Daten-URIs übergeben werden. Das folgende Beispiel zeigt, wie das geht.
import base64
def image_to_base64_data_uri ( file_path ):
with open ( file_path , "rb" ) as img_file :
base64_data = base64 . b64encode ( img_file . read ()). decode ( 'utf-8' )
return f"data:image/png;base64, { base64_data } "
# Replace 'file_path.png' with the actual path to your PNG file
file_path = 'file_path.png'
data_uri = image_to_base64_data_uri ( file_path )
messages = [
{ "role" : "system" , "content" : "You are an assistant who perfectly describes images." },
{
"role" : "user" ,
"content" : [
{ "type" : "image_url" , "image_url" : { "url" : data_uri }},
{ "type" : "text" , "text" : "Describe this image in detail please." }
]
}
] llama-cpp-python unterstützt spekulative Dekodierung, die es dem Modell ermöglicht, Vervollständigungen basierend auf einem Entwurfsmodell zu generieren.
Der schnellste Weg, spekulative Dekodierung zu verwenden, ist die Klasse LlamaPromptLookupDecoding .
Übergeben Sie dies einfach während der Initialisierung als Entwurfsmodell an die Llama -Klasse.
from llama_cpp import Llama
from llama_cpp . llama_speculative import LlamaPromptLookupDecoding
llama = Llama (
model_path = "path/to/model.gguf" ,
draft_model = LlamaPromptLookupDecoding ( num_pred_tokens = 10 ) # num_pred_tokens is the number of tokens to predict 10 is the default and generally good for gpu, 2 performs better for cpu-only machines.
) Um Texteinbettungen zu generieren, verwenden Sie create_embedding oder embed . Beachten Sie, dass Sie bei der Modellerstellung embedding=True an den Konstruktor übergeben müssen, damit diese ordnungsgemäß funktionieren.
import llama_cpp
llm = llama_cpp . Llama ( model_path = "path/to/model.gguf" , embedding = True )
embeddings = llm . create_embedding ( "Hello, world!" )
# or create multiple embeddings at once
embeddings = llm . create_embedding ([ "Hello, world!" , "Goodbye, world!" ])Es gibt zwei Hauptbegriffe für Einbettungen in einem Modell im Transformer-Stil: Token-Ebene und Sequenzebene . Einbettungen auf Sequenzebene werden durch „Zusammenfassen“ von Einbettungen auf Tokenebene erzeugt, normalerweise durch Mittelung oder Verwendung des ersten Tokens.
Modelle, die explizit auf Einbettungen ausgerichtet sind, geben normalerweise standardmäßig Einbettungen auf Sequenzebene zurück, eine für jede Eingabezeichenfolge. Nicht einbettende Modelle, wie sie beispielsweise für die Textgenerierung entwickelt wurden, geben normalerweise nur Einbettungen auf Token-Ebene zurück, eine für jedes Token in jeder Sequenz. Daher ist die Dimensionalität des Rückgabetyps für Einbettungen auf Token-Ebene um eins höher.
In einigen Fällen ist es möglich, das Pooling-Verhalten mithilfe des Flags pooling_type bei der Modellerstellung zu steuern. Mit LLAMA_POOLING_TYPE_NONE können Sie Einbettungen auf Token-Ebene aus jedem Modell sicherstellen. Umgekehrt ist es derzeit nicht möglich, ein generierungsorientiertes Modell zu erhalten, um Einbettungen auf Sequenzebene zu erzielen. Sie können das Pooling jedoch jederzeit manuell durchführen.
Das Kontextfenster der Llama-Modelle bestimmt die maximale Anzahl an Token, die gleichzeitig verarbeitet werden können. Standardmäßig ist dieser auf 512 Token eingestellt, kann aber je nach Ihren Anforderungen angepasst werden.
Wenn Sie beispielsweise mit größeren Kontexten arbeiten möchten, können Sie das Kontextfenster erweitern, indem Sie beim Initialisieren des Llama-Objekts den Parameter n_ctx festlegen:
llm = Llama ( model_path = "./models/7B/llama-model.gguf" , n_ctx = 2048 ) llama-cpp-python bietet einen Webserver, der als Ersatz für die OpenAI-API dienen soll. Dadurch können Sie llama.cpp-kompatible Modelle mit jedem OpenAI-kompatiblen Client (Sprachbibliotheken, Dienste usw.) verwenden.
So installieren Sie das Serverpaket und legen los:
pip install ' llama-cpp-python[server] '
python3 -m llama_cpp.server --model models/7B/llama-model.ggufÄhnlich wie im Abschnitt „Hardwarebeschleunigung“ oben können Sie auch mit GPU-Unterstützung (cuBLAS) wie folgt installieren:
CMAKE_ARGS= " -DGGML_CUDA=on " FORCE_CMAKE=1 pip install ' llama-cpp-python[server] '
python3 -m llama_cpp.server --model models/7B/llama-model.gguf --n_gpu_layers 35Navigieren Sie zu http://localhost:8000/docs, um die OpenAPI-Dokumentation anzuzeigen.
Um eine Bindung an 0.0.0.0 herzustellen und Remoteverbindungen zu ermöglichen, verwenden Sie python3 -m llama_cpp.server --host 0.0.0.0 . Um den Port zu ändern (Standard ist 8000), verwenden Sie ebenfalls --port .
Wahrscheinlich möchten Sie auch das Eingabeaufforderungsformat festlegen. Verwenden Sie für Chatml
python3 -m llama_cpp.server --model models/7B/llama-model.gguf --chat_format chatmlDadurch wird die Eingabeaufforderung entsprechend den Erwartungen des Modells formatiert. Das Eingabeaufforderungsformat finden Sie in der Modellkarte. Mögliche Optionen finden Sie unter llama_cpp/llama_chat_format.py und suchen Sie nach Zeilen, die mit „@register_chat_format“ beginnen.
Wenn Sie huggingface-hub installiert haben, können Sie auch das Flag --hf_model_repo_id verwenden, um ein Modell vom Hugging Face Hub zu laden.
python3 -m llama_cpp.server --hf_model_repo_id Qwen/Qwen2-0.5B-Instruct-GGUF --model ' *q8_0.gguf 'Ein Docker-Image ist auf GHCR verfügbar. So führen Sie den Server aus:
docker run --rm -it -p 8000:8000 -v /path/to/models:/models -e MODEL=/models/llama-model.gguf ghcr.io/abetlen/llama-cpp-python:latestDocker auf Termux (erfordert Root) ist derzeit die einzige bekannte Möglichkeit, dies auf Telefonen auszuführen, siehe Termux-Supportproblem
API-Referenz
Die Low-Level-API ist eine direkte ctypes Bindung an die von llama.cpp bereitgestellte C-API. Die gesamte Low-Level-API ist in llama_cpp/llama_cpp.py zu finden und spiegelt direkt die C-API in llama.h wider.
Unten finden Sie ein kurzes Beispiel, das zeigt, wie Sie die Low-Level-API zum Tokenisieren einer Eingabeaufforderung verwenden:
import llama_cpp
import ctypes
llama_cpp . llama_backend_init ( False ) # Must be called once at the start of each program
params = llama_cpp . llama_context_default_params ()
# use bytes for char * params
model = llama_cpp . llama_load_model_from_file ( b"./models/7b/llama-model.gguf" , params )
ctx = llama_cpp . llama_new_context_with_model ( model , params )
max_tokens = params . n_ctx
# use ctypes arrays for array params
tokens = ( llama_cpp . llama_token * int ( max_tokens ))()
n_tokens = llama_cpp . llama_tokenize ( ctx , b"Q: Name the planets in the solar system? A: " , tokens , max_tokens , llama_cpp . c_bool ( True ))
llama_cpp . llama_free ( ctx )Weitere Beispiele für die Verwendung der Low-Level-API finden Sie im Beispielordner.
Die Dokumentation ist über https://llama-cpp-python.readthedocs.io/ verfügbar. Wenn Sie Probleme mit der Dokumentation feststellen, öffnen Sie bitte ein Problem oder reichen Sie eine PR ein.
Dieses Paket befindet sich in der aktiven Entwicklung und ich freue mich über jeden Beitrag.
Klonen Sie zunächst das Repository und installieren Sie das Paket im bearbeitbaren/Entwicklungsmodus:
git clone --recurse-submodules https://github.com/abetlen/llama-cpp-python.git
cd llama-cpp-python
# Upgrade pip (required for editable mode)
pip install --upgrade pip
# Install with pip
pip install -e .
# if you want to use the fastapi / openapi server
pip install -e .[server]
# to install all optional dependencies
pip install -e .[all]
# to clear the local build cache
make clean Sie können auch bestimmte Commits von llama.cpp testen, indem Sie den gewünschten Commit im Submodul vendor/llama.cpp auschecken und dann make clean und pip install -e . wieder. Alle Änderungen an der llama.h -API erfordern Änderungen an der Datei llama_cpp/llama_cpp.py damit sie mit der neuen API übereinstimmen (zusätzliche Änderungen können an anderer Stelle erforderlich sein).
