llama.cpp Télécharger - llama.cpp Télécharger le code source

llama.cpp

Autre code source

b3995

Télécharger

lama.cpp

Feuille de route / Statut du projet / Manifeste / ggml

Inférence du modèle LLaMA de Meta (et autres) en C/C++ pur

Modifications récentes de l'API

Journal des modifications pour l'API libllama
Journal des modifications pour l'API REST llama-server

Sujets d'actualité

Présentation de GGUF-my-LoRA #10123
Les points de terminaison d'inférence Hugging Face prennent désormais en charge GGUF dès le départ ! #9669
Hugging Face Editeur GGUF : discussion | outil

Description

L'objectif principal de llama.cpp est de permettre l'inférence LLM avec une configuration minimale et des performances de pointe sur une grande variété de matériels, localement et dans le cloud.

Implémentation simple en C/C++ sans aucune dépendance
Le silicium Apple est un citoyen de première classe - optimisé via les frameworks ARM NEON, Accelerate et Metal
Prise en charge AVX, AVX2, AVX512 et AMX pour les architectures x86
Quantification d'entiers 1,5 bits, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits et 8 bits pour une inférence plus rapide et une utilisation réduite de la mémoire
Noyaux CUDA personnalisés pour exécuter des LLM sur des GPU NVIDIA (prise en charge des GPU AMD via HIP et des GPU Moore Threads MTT via MUSA)
Prise en charge des back-ends Vulkan et SYCL
Inférence hybride CPU+GPU pour accélérer partiellement les modèles supérieurs à la capacité totale de la VRAM

Depuis sa création, le projet s'est considérablement amélioré grâce à de nombreuses contributions. C'est le principal terrain de jeu pour développer de nouvelles fonctionnalités pour la bibliothèque ggml.

Modèles pris en charge :

Généralement, les réglages fins des modèles de base ci-dessous sont également pris en charge.

(instructions pour prendre en charge plus de modèles : HOWTO-add-model.md)

Modèles multimodaux :

Reliures :

Python : abetlen/llama-cpp-python
Allez : go-skynet/go-llama.cpp
Node.js : withcatai/node-llama-cpp
JS/TS (client serveur lama.cpp) : lgrammel/modelfusion
JS/TS (CLI du moteur d'invite programmable) : hors ligne-ai/cli
JavaScript/Wasm (fonctionne dans le navigateur) : tangledgroup/llama-cpp-wasm
Typescript/Wasm (API plus agréable, disponible sur npm) : ngxson/wllama
Rubis : yoshoku/llama_cpp.rb
Rust (plus de fonctionnalités) : edgenai/llama_cpp-rs
Rust (API plus agréable) : mdrokz/rust-llama.cpp
Rust (liaisons plus directes) : utilityai/llama-cpp-rs
C#/.NET : SciSharp/LLamaSharp
C#/VB.NET (plus de fonctionnalités - licence communautaire) : LM-Kit.NET
Scala 3 : donderom/llm4s
Clojure : phronmophobic/llama.clj
React Native : mybigday/llama.rn
Java : kherud/java-llama.cpp
Zig : deins/llama.cpp.zig
Flutter/Fléchette : netdur/llama_cpp_dart
PHP (liaisons API et fonctionnalités construites sur llama.cpp) : lointainmagic/resonance (plus d'infos)
Schéma de ruse : guile_llama_cpp
Swift srgtuszy/llama-cpp-swift
Swift ShenghaiWang/SwiftLlama

Interface utilisateur :

Sauf indication contraire, ces projets sont open source avec licence permissive :

MindWorkAI/AI-Studio (FSL-1.1-MIT)
iohub/collama
janhq/jan (AGPL)
nat/openplayground
Faraday (propriétaire)
LMStudio (propriétaire)
Layla (propriétaire)
ramalama (MIT)
IA locale (MIT)
Ruines perdues/koboldcpp (AGPL)
Mozilla-Ocho/llamafile
nomic-ai/gpt4all
ollama/ollama
oobabooga/text-génération-webui (AGPL)
psugihara/FreeChat
cztomsik/ava (MIT)
ptsochantaris/émeltal
pythops/ténéré (AGPL)
Bureau RAGNA (propriétaire)
RecurseChat (propriétaire)
semperai/amica
aveccatai/catai
Intelligence artificielle mobile/femme de ménage (MIT)
Msty (propriétaire)
LLMFarm (MIT)
KanTV (Apachev2.0 ou version ultérieure)
Point (GPL)
MindMac (propriétaire)
KodiBot (GPL)
Eva (MIT)
Plugin AI Sublime Text (MIT)
AIKit (MIT)
LARS - La solution LLM et référencement avancé (AGPL)
LLMUnity (MIT)
Assistant Lama (GPL)
PocketPal AI - Une application iOS et Android (MIT)

(pour qu'un projet soit répertorié ici, il doit clairement indiquer qu'il dépend de llama.cpp )

Outils:

akx/ggify – téléchargez les modèles PyTorch depuis HuggingFace Hub et convertissez-les en GGML
akx/ollama-dl – téléchargez des modèles depuis la bibliothèque Ollama pour les utiliser directement avec llama.cpp
crashr/gppm – lancez des instances llama.cpp en utilisant les GPU NVIDIA Tesla P40 ou P100 avec une consommation d'énergie réduite au ralenti
gpustack/gguf-parser - examine/vérifie le fichier GGUF et estime l'utilisation de la mémoire
Styled Lines (wrapper asynchrone sous licence propriétaire de la partie d'inférence pour le développement de jeux dans Unity3d avec des wrappers de plate-forme mobile et Web pré-construits et un exemple de modèle)

Infrastructure:

Paddler - Équilibreur de charge avec état personnalisé pour llama.cpp
GPUStack - Gérer les clusters GPU pour exécuter des LLM
llama_cpp_canister - llama.cpp en tant que contrat intelligent sur l'ordinateur Internet, en utilisant WebAssembly

Jeux :

Lucy's Labyrinth - Un jeu de labyrinthe simple dans lequel des agents contrôlés par un modèle d'IA tenteront de vous tromper.

Démo

Exécution typique avec LLaMA v2 13B sur M2 Ultra

$ make -j && ./llama-cli -m models/llama-13b-v2/ggml-model-q4_0.gguf -p "Building a website can be done in 10 simple steps:nStep 1:" -n 400 -e
I llama.cpp build info:
I UNAME_S:  Darwin
I UNAME_P:  arm
I UNAME_M:  arm64
I CFLAGS:   -I.            -O3 -std=c11   -fPIC -DNDEBUG -Wall -Wextra -Wpedantic -Wcast-qual -Wdouble-promotion -Wshadow -Wstrict-prototypes -Wpointer-arith -Wmissing-prototypes -pthread -DGGML_USE_K_QUANTS -DGGML_USE_ACCELERATE
I CXXFLAGS: -I. -I./common -O3 -std=c++11 -fPIC -DNDEBUG -Wall -Wextra -Wpedantic -Wcast-qual -Wno-unused-function -Wno-multichar -pthread -DGGML_USE_K_QUANTS
I LDFLAGS:   -framework Accelerate
I CC:       Apple clang version 14.0.3 (clang-1403.0.22.14.1)
I CXX:      Apple clang version 14.0.3 (clang-1403.0.22.14.1)

make: Nothing to be done for `default'.
main: build = 1041 (cf658ad)
main: seed  = 1692823051
llama_model_loader: loaded meta data with 16 key-value pairs and 363 tensors from models/llama-13b-v2/ggml-model-q4_0.gguf (version GGUF V1 (latest))
llama_model_loader: - type  f32:   81 tensors
llama_model_loader: - type q4_0:  281 tensors
llama_model_loader: - type q6_K:    1 tensors
llm_load_print_meta: format         = GGUF V1 (latest)
llm_load_print_meta: arch           = llama
llm_load_print_meta: vocab type     = SPM
llm_load_print_meta: n_vocab        = 32000
llm_load_print_meta: n_merges       = 0
llm_load_print_meta: n_ctx_train    = 4096
llm_load_print_meta: n_ctx          = 512
llm_load_print_meta: n_embd         = 5120
llm_load_print_meta: n_head         = 40
llm_load_print_meta: n_head_kv      = 40
llm_load_print_meta: n_layer        = 40
llm_load_print_meta: n_rot          = 128
llm_load_print_meta: n_gqa          = 1
llm_load_print_meta: f_norm_eps     = 1.0e-05
llm_load_print_meta: f_norm_rms_eps = 1.0e-05
llm_load_print_meta: n_ff           = 13824
llm_load_print_meta: freq_base      = 10000.0
llm_load_print_meta: freq_scale     = 1
llm_load_print_meta: model type     = 13B
llm_load_print_meta: model ftype    = mostly Q4_0
llm_load_print_meta: model size     = 13.02 B
llm_load_print_meta: general.name   = LLaMA v2
llm_load_print_meta: BOS token = 1 '<s>'
llm_load_print_meta: EOS token = 2 '</s>'
llm_load_print_meta: UNK token = 0 '<unk>'
llm_load_print_meta: LF token  = 13 '<0x0A>'
llm_load_tensors: ggml ctx size =    0.11 MB
llm_load_tensors: mem required  = 7024.01 MB (+  400.00 MB per state)
...................................................................................................
llama_new_context_with_model: kv self size  =  400.00 MB
llama_new_context_with_model: compute buffer total size =   75.41 MB

system_info: n_threads = 16 / 24 | AVX = 0 | AVX2 = 0 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 0 | NEON = 1 | ARM_FMA = 1 | F16C = 0 | FP16_VA = 1 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 0 | VSX = 0 |
sampling: repeat_last_n = 64, repeat_penalty = 1.100000, presence_penalty = 0.000000, frequency_penalty = 0.000000, top_k = 40, tfs_z = 1.000000, top_p = 0.950000, typical_p = 1.000000, temp = 0.800000, mirostat = 0, mirostat_lr = 0.100000, mirostat_ent = 5.000000
generate: n_ctx = 512, n_batch = 512, n_predict = 400, n_keep = 0


 Building a website can be done in 10 simple steps:
Step 1: Find the right website platform.
Step 2: Choose your domain name and hosting plan.
Step 3: Design your website layout.
Step 4: Write your website content and add images.
Step 5: Install security features to protect your site from hackers or spammers
Step 6: Test your website on multiple browsers, mobile devices, operating systems etc…
Step 7: Test it again with people who are not related to you personally – friends or family members will work just fine!
Step 8: Start marketing and promoting the website via social media channels or paid ads
Step 9: Analyze how many visitors have come to your site so far, what type of people visit more often than others (e.g., men vs women) etc…
Step 10: Continue to improve upon all aspects mentioned above by following trends in web design and staying up-to-date on new technologies that can enhance user experience even further!
How does a Website Work?
A website works by having pages, which are made of HTML code. This code tells your computer how to display the content on each page you visit – whether it’s an image or text file (like PDFs). In order for someone else’s browser not only be able but also want those same results when accessing any given URL; some additional steps need taken by way of programming scripts that will add functionality such as making links clickable!
The most common type is called static HTML pages because they remain unchanged over time unless modified manually (either through editing files directly or using an interface such as WordPress). They are usually served up via HTTP protocols – this means anyone can access them without having any special privileges like being part of a group who is allowed into restricted areas online; however, there may still exist some limitations depending upon where one lives geographically speaking.
How to
llama_print_timings:        load time =   576.45 ms
llama_print_timings:      sample time =   283.10 ms /   400 runs   (    0.71 ms per token,  1412.91 tokens per second)
llama_print_timings: prompt eval time =   599.83 ms /    19 tokens (   31.57 ms per token,    31.68 tokens per second)
llama_print_timings:        eval time = 24513.59 ms /   399 runs   (   61.44 ms per token,    16.28 tokens per second)
llama_print_timings:       total time = 25431.49 ms

Démo de l'exécution de LLaMA-7B et Whisper.cpp sur un seul MacBook M1 Pro

Et voici une autre démonstration de l'exécution de LLaMA-7B et de Whisper.cpp sur un seul MacBook M1 Pro :

murmure-llama-lq.mp4

Usage

Voici les étapes de construction binaire et de conversion de modèle de bout en bout pour la plupart des modèles pris en charge.

Utilisation de base

Tout d'abord, vous devez obtenir le binaire. Il existe différentes méthodes que vous pouvez suivre :

Méthode 1 : clonez ce référentiel et construisez localement, voyez comment construire
Méthode 2 : Si vous utilisez MacOS ou Linux, vous pouvez installer llama.cpp via Brew, Flox ou nix
Méthode 3 : utiliser une image Docker, voir la documentation de Docker
Méthode 4 : Télécharger les binaires prédéfinis à partir des versions

Vous pouvez exécuter une complétion de base à l'aide de cette commande :

 llama-cli -m your_model.gguf -p "Je crois que le sens de la vie est" -n 128# Résultat :# Je crois que le sens de la vie est de trouver sa propre vérité et de vivre conformément à elle. Pour moi, cela signifie être fidèle à moi-même et suivre mes passions, même si elles ne correspondent pas aux attentes de la société. Je pense que c'est ce que j'aime dans le yoga : ce n'est pas seulement une pratique physique, mais aussi spirituelle. Il s'agit de se connecter avec soi-même, d'écouter sa voix intérieure et d'honorer son propre voyage.

Voir cette page pour une liste complète des paramètres.

Mode conversation

Si vous souhaitez une expérience plus proche de ChatGPT, vous pouvez exécuter en mode conversation en passant -cnv comme paramètre :

 llama-cli -m your_model.gguf -p "Vous êtes un assistant utile" -cnv# Sortie :# > salut, qui êtes-vous ?# Salut à tous ! Je suis votre assistant utile ! Je suis un chatbot basé sur l'IA conçu pour aider et fournir des informations aux utilisateurs comme vous. Je suis là pour vous aider à répondre à vos questions, vous fournir des conseils et vous offrir une assistance sur un large éventail de sujets. Je suis une IA sympathique et compétente, et je suis toujours heureux de vous aider pour tout ce dont vous avez besoin. Qu'est-ce qui vous préoccupe et comment puis-je vous aider aujourd'hui ?## > qu'est-ce que 1+1 ?# C'est simple ! La réponse à 1+1 est... 2 !

Par défaut, le modèle de discussion sera extrait du modèle d'entrée. Si vous souhaitez utiliser un autre modèle de discussion, transmettez --chat-template NAME comme paramètre. Voir la liste des modèles pris en charge

 ./llama-cli -m your_model.gguf -p "Vous êtes un assistant utile" -cnv --chat-template chatml

Vous pouvez également utiliser votre propre modèle via les paramètres in-prefix, in-suffix et reverse-prompt :

 ./llama-cli -m your_model.gguf -p "Vous êtes un assistant utile" -cnv --in-prefix 'Utilisateur : ' --reverse-prompt 'Utilisateur :'

Serveur Web

Le serveur Web llama.cpp est un serveur HTTP léger compatible avec l'API OpenAI qui peut être utilisé pour servir des modèles locaux et les connecter facilement aux clients existants.

Exemple d'utilisation :

 ./llama-server -m your_model.gguf --port 8080# L'interface utilisateur Web de base est accessible via un navigateur : http://localhost:8080# Point de terminaison de fin de discussion : http://localhost:8080/v1/chat/completions

Mode interactif

Note

Si vous préférez une utilisation basique, pensez à utiliser le mode conversation au lieu du mode interactif.

Dans ce mode, vous pouvez toujours interrompre la génération en appuyant sur Ctrl+C et en saisissant une ou plusieurs lignes de texte, qui seront converties en jetons et ajoutées au contexte actuel. Vous pouvez également spécifier une invite inversée avec le paramètre -r "reverse prompt string" . Cela entraînera une saisie par l'utilisateur chaque fois que les jetons exacts de la chaîne d'invite inverse seront rencontrés lors de la génération. Une utilisation typique consiste à utiliser une invite qui permet à LLaMA d'émuler une discussion entre plusieurs utilisateurs, par exemple Alice et Bob, et de transmettre -r "Alice:" .

Voici un exemple d'interaction en quelques instants, invoquée avec la commande

 # arguments par défaut utilisant un modèle 7B./examples/chat.sh# chat avancé avec un modèle 13B./examples/chat-13B.sh# arguments personnalisés utilisant un modèle 13B./llama-cli -m ./models/13B/ ggml-model-q4_0.gguf -n 256 --repeat_penalty 1.0 --color -i -r "Utilisateur :" -f invites/chat-avec-bob.txt

Notez l'utilisation de --color pour faire la distinction entre la saisie utilisateur et le texte généré. D'autres paramètres sont expliqués plus en détail dans le README de l'exemple de programme llama-cli .

Interaction persistante

L'invite, les entrées utilisateur et les générations de modèles peuvent être enregistrées et reprises lors des appels à ./llama-cli en exploitant --prompt-cache et --prompt-cache-all . Le script ./examples/chat-persistent.sh le démontre avec la prise en charge des sessions de discussion de longue durée et pouvant être reprises. Pour utiliser cet exemple, vous devez fournir un fichier pour mettre en cache l'invite de discussion initiale et un répertoire pour enregistrer la session de discussion, et pouvez éventuellement fournir les mêmes variables que chat-13B.sh . Le même cache d'invites peut être réutilisé pour de nouvelles sessions de discussion. Notez que le cache d'invite et le répertoire de discussion sont liés à l'invite initiale ( PROMPT_TEMPLATE ) et au fichier modèle.

 # Démarrer un nouveau chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh# Reprendre ce chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat- persistent.sh# Démarrez une discussion différente avec le même prompt/modelPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/another ./examples/chat-persistent.sh# Cache d'invite différent pour différentes invites/modelPROMPT_TEMPLATE=./prompts/chat-with-bob.txt PROMPT_CACHE_FILE=bob. invite.bin 
    CHAT_SAVE_DIR=./chat/bob ./examples/chat-persistent.sh

Sortie contrainte avec des grammaires

llama.cpp prend en charge les grammaires pour contraindre la sortie du modèle. Par exemple, vous pouvez forcer le modèle à générer uniquement du JSON :

 ./llama-cli -m ./models/13B/ggml-model-q4_0.gguf -n 256 --grammar-file grammars/json.gbnf -p 'Demande : planifier un appel à 20h ; Commande:'

Le dossier grammars/ contient une poignée d’exemples de grammaires. Pour rédiger le vôtre, consultez le Guide GBNF.

Pour créer des grammaires JSON plus complexes, vous pouvez également consulter https://grammar.intrinsiclabs.ai/, une application de navigateur qui vous permet d'écrire des interfaces TypeScript qu'elle compile en grammaires GBNF que vous pouvez enregistrer pour une utilisation locale. Notez que l'application est créée et maintenue par des membres de la communauté, veuillez déposer tout problème ou FR sur son dépôt et non sur celui-ci.

Construire

Veuillez vous référer à Build llama.cpp localement

Backends pris en charge

Back-end	Appareils cibles
Métal	Pomme Silicium
BLAS	Tous
BLIS	Tous
SYCL	GPU Intel et Nvidia
MUSA	GPU Moore Threads MTT
CUDA	GPU Nvidia
hancheBLAS	GPU AMD
Vulcan	GPU
CAN	Monter le NPU

Outils

Préparer et quantifier

Note

Vous pouvez également utiliser l'espace GGUF-my-repo sur Hugging Face pour quantifier les poids de votre modèle sans aucune configuration. Il est synchronisé depuis llama.cpp principal toutes les 6 heures.

Pour obtenir les poids officiels LLaMA 2, veuillez consulter la section Obtention et utilisation du modèle Facebook LLaMA 2. Il existe également une large sélection de modèles gguf pré-quantifiés disponibles sur Hugging Face.

Remarque : convert.py a été déplacé vers examples/convert_legacy_llama.py et ne doit pas être utilisé pour autre chose que les modèles Llama/Llama2/Mistral et leurs dérivés. Il ne prend pas en charge LLaMA 3, vous pouvez utiliser convert_hf_to_gguf.py avec LLaMA 3 téléchargé depuis Hugging Face.

Pour en savoir plus sur le modèle de quantification, lisez cette documentation

Perplexité (mesurer la qualité du modèle)

Vous pouvez utiliser l'exemple perplexity pour mesurer la perplexité sur une invite donnée (une perplexité plus faible est préférable). Pour plus d'informations, consultez https://huggingface.co/docs/transformers/perplexity.

Pour en savoir plus sur la façon de mesurer la perplexité à l'aide de llama.cpp, lisez cette documentation

Contribuer

Les contributeurs peuvent ouvrir des PR
Les collaborateurs peuvent pousser vers les branches du dépôt llama.cpp et fusionner les PR dans la branche master
Les collaborateurs seront invités en fonction des contributions
Toute aide pour la gestion des problèmes, des relations publiques et des projets est très appréciée !
Voir les bons premiers numéros pour les tâches adaptées aux premières contributions
Lisez le CONTRIBUTING.md pour plus d'informations
Assurez-vous de lire ceci : Inférence à la limite
Un peu d'histoire pour ceux que ça intéresse : podcast Changelog

Autres documentations

principal (cli)
serveur
péril
Grammaires GBNF

Documentations de développement

Comment construire
Exécuté sur Docker
Construire sur Android
Dépannage des performances
Trucs et astuces GGML

Articles fondateurs et contexte sur les modèles

Si votre problème concerne la qualité de la génération de modèles, veuillez au moins parcourir les liens et documents suivants pour comprendre les limites des modèles LLaMA. Ceci est particulièrement important lors du choix d'une taille de modèle appropriée et de l'appréciation des différences significatives et subtiles entre les modèles LLaMA et ChatGPT :