llama.cpp
b3995
Hoja de ruta / Estado del proyecto / Manifiesto / ggml
Inferencia del modelo LLaMA de Meta (y otros) en C/C++ puro
Registro de cambios para la API libllama
Registro de cambios para la API REST llama-server
Presentamos GGUF-my-LoRA #10123
¡Los puntos finales de Hugging Face Inference ahora son compatibles con GGUF desde el primer momento! #9669
Editor de Hugging Face GGUF: discusión | herramienta
El objetivo principal de llama.cpp es permitir la inferencia LLM con una configuración mínima y un rendimiento de última generación en una amplia variedad de hardware, localmente y en la nube.
Implementación simple de C/C++ sin dependencias
El silicio de Apple es un ciudadano de primera clase: optimizado a través de los marcos ARM NEON, Accelerate y Metal.
Soporte AVX, AVX2, AVX512 y AMX para arquitecturas x86
Cuantización de enteros de 1,5 bits, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits y 8 bits para una inferencia más rápida y un uso reducido de memoria
Kernels CUDA personalizados para ejecutar LLM en GPU NVIDIA (soporte para GPU AMD a través de HIP y GPU Moore Threads MTT a través de MUSA)
Soporte de backend de Vulkan y SYCL
Inferencia híbrida CPU+GPU para acelerar parcialmente modelos mayores que la capacidad total de VRAM
Desde sus inicios, el proyecto ha mejorado significativamente gracias a muchas contribuciones. Es el campo de juego principal para desarrollar nuevas funciones para la biblioteca ggml.
Modelos compatibles:
Por lo general, también se admiten ajustes finos de los modelos básicos siguientes.
¿LLAMA?
LLAMA 2 ??
LLAMA 3???
Mistral 7B
Ministerio de Educación Mixtral
DBRX
Halcón
LLaMA chino/Alpaca y LLaMA-2 chino/Alpaca-2
Vigoña (francés)
BERT
Coala
Baichuan 1 y 2 + derivaciones
Áquila 1 y 2
Modelos de codificadores estelares
Refacturar
MPT
Floración
modelos yi
Modelos LM estables
modelos de búsqueda profunda
Modelos qwen
PLAMo-13B
Modelos phi
GPT-2
Orión 14B
PasanteLM2
CódigoShell
Gema
Tipo de serpiente venenosa
Grok-1
Xverso
Modelos Command-R
LEÓN MARINO
GranoLM-7B + GranoLM-8x7B
OLMo
OLMoE
Modelos de granito
GPT-NeoX + Pitia
MoE Copo de Nieve-Ártico
Smaug
Poro 34B
Modelos Bitnet b1.58
Flan T5
Modelos abiertos de olmo
ChatGLM3-6b + ChatGLM4-9b
SmolLM
EXAONE-3.0-7.8B-Instrucción
Modelos de FalconMamba
jais
Bielik-11B-v2.3
RWKV-6
(instrucciones para admitir más modelos: HOWTO-add-model.md)
Modelos multimodales:
Modelos LLaVA 1.5, modelos LLaVA 1.6
BakLLaVA
Obsidiana
CompartirGPT4V
Modelos MobileVLM 1.7B/3B
Yi-VL
CPM mínimo
sueño lunar
Conejito
Fijaciones:
Python: abetlen/llama-cpp-python
Ir: go-skynet/go-llama.cpp
Node.js: concatai/node-llama-cpp
JS/TS (cliente del servidor llama.cpp): lgrammel/modelfusion
JS/TS (CLI del motor de aviso programable): fuera de línea-ai/cli
JavaScript/Wasm (funciona en el navegador): tangledgroup/llama-cpp-wasm
Typecript/Wasm (API mejor, disponible en npm): ngxson/wllama
Rubí: yoshoku/llama_cpp.rb
Rust (más funciones): edgenai/llama_cpp-rs
Rust (API mejor): mdrokz/rust-llama.cpp
Rust (enlaces más directos): utilitario/llama-cpp-rs
C#/.NET: SciSharp/LLamaSharp
C#/VB.NET (más funciones - licencia comunitaria): LM-Kit.NET
Escala 3: donderom/llm4s
Clojure: phronmophobic/llama.clj
Reaccionar nativo: mybigday/llama.rn
Java: kherud/java-llama.cpp
Zig: deins/llama.cpp.zig
Aleteo/Dardo: netdur/llama_cpp_dart
PHP (enlaces de API y características creadas sobre llama.cpp): distantmagic/resonance (más información)
Esquema de astucia: guile_llama_cpp
Swift srgtuszy/llama-cpp-swift
Swift ShenghaiWang/SwiftLlama
Interfaz de usuario:
A menos que se indique lo contrario, estos proyectos son de código abierto con licencias permisivas:
MindWorkAI/AI-Studio (FSL-1.1-MIT)
iohub/collama
janhq/enero (AGPL)
parque nacional/abierto
Faraday (propietario)
LMStudio (propietario)
Layla (propietaria)
Ramalama (MIT)
IA local (MIT)
Ruinas Perdidas/koboldcpp (AGPL)
Mozilla-Ocho/llamafile
nomic-ai/gpt4all
ollama/ollama
oobabooga/generación de texto-webui (AGPL)
psugihara/Chat libre
cztomsik/ava (MIT)
ptochantaris/emeltal
pythops/tenere (AGPL)
Escritorio RAGNA (propietario)
RecurseChat (propietario)
semperai/amica
concatai/catai
Inteligencia-artificial-móvil/criada (MIT)
Msty (propietario)
LLMFarm (MIT)
KanTV (Apachev2.0 o posterior)
Punto (GPL)
MindMac (propietario)
KodiBot (GPL)
Eva (MIT)
Complemento AI Sublime Text (MIT)
AIKit (MIT)
LARS: la solución de referenciación avanzada y LLM (AGPL)
LLMUnity (MIT)
Asistente de llamas (GPL)
PocketPal AI: una aplicación para iOS y Android (MIT)
(para tener un proyecto listado aquí, debe indicar claramente que depende de llama.cpp )
Herramientas:
akx/ggify: descargue modelos de PyTorch desde HuggingFace Hub y conviértalos a GGML
akx/ollama-dl: descargue modelos de la biblioteca de Ollama para usarlos directamente con llama.cpp
crashr/gppm: lanza instancias de llama.cpp utilizando GPU NVIDIA Tesla P40 o P100 con un consumo de energía inactivo reducido
gpustack/gguf-parser: revisa/comprueba el archivo GGUF y estima el uso de memoria
Styled Lines (envoltorio asíncrono de parte de inferencia con licencia patentada para el desarrollo de juegos en Unity3d con envoltorios de plataforma web y móvil precompilados y un ejemplo de modelo)
Infraestructura:
Paddler: equilibrador de carga con estado personalizado para llama.cpp
GPUStack: administre clústeres de GPU para ejecutar LLM
llama_cpp_canister - llama.cpp como contrato inteligente en Internet Computadora, usando WebAssembly
Juegos:
Lucy's Labyrinth: un sencillo juego de laberinto en el que agentes controlados por un modelo de IA intentarán engañarte.
$ 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
Y aquí hay otra demostración de cómo ejecutar LLaMA-7B y Whisper.cpp en una sola MacBook Pro M1:
Estos son los pasos de conversión de modelos y compilación binaria de un extremo a otro para la mayoría de los modelos compatibles.
En primer lugar, necesitas obtener el binario. Hay diferentes métodos que puedes seguir:
Método 1: clonar este repositorio y compilarlo localmente; vea cómo compilarlo
Método 2: si está utilizando MacOS o Linux, puede instalar llama.cpp mediante brew, flox o nix
Método 3: utilice una imagen de Docker; consulte la documentación de Docker
Método 4: descargar archivos binarios prediseñados desde las versiones
Puede ejecutar una finalización básica usando este comando:
llama-cli -m your_model.gguf -p "Creo que el significado de la vida es" -n 128# Salida:# Creo que el significado de la vida es encontrar tu propia verdad y vivir de acuerdo con ella. Para mí, esto significa ser fiel a mí mismo y seguir mis pasiones, incluso si no se alinean con las expectativas de la sociedad. Creo que eso es lo que me encanta del yoga: no es sólo una práctica física, sino también espiritual. Se trata de conectarte contigo mismo, escuchar tu voz interior y honrar tu propio viaje único.
Consulte esta página para obtener una lista completa de parámetros.
Si desea una experiencia más parecida a ChatGPT, puede ejecutar en modo conversación pasando -cnv como parámetro:
llama-cli -m your_model.gguf -p "Eres un asistente útil" -cnv# Salida:# > hola, ¿quién eres?# ¡Hola! ¡Soy tu útil asistente! Soy un chatbot con tecnología de inteligencia artificial diseñado para ayudar y brindar información a usuarios como usted. Estoy aquí para ayudar a responder sus preguntas, brindar orientación y ofrecer apoyo en una amplia gama de temas. Soy una IA amigable y conocedora, y siempre estaré feliz de ayudarte con cualquier cosa que necesites. ¿Qué tienes en mente y cómo puedo ayudarte hoy?## > ¿Qué es 1+1?# ¡Fácil! La respuesta a 1+1 es... ¡2!
De forma predeterminada, la plantilla de chat se tomará del modelo de entrada. Si desea utilizar otra plantilla de chat, pase --chat-template NAME como parámetro. Ver la lista de plantillas compatibles
./llama-cli -m your_model.gguf -p "Eres un asistente útil" -cnv --chat-template chatml
También puede utilizar su propia plantilla mediante parámetros de prefijo, sufijo y solicitud inversa:
./llama-cli -m your_model.gguf -p "Eres un asistente útil" -cnv --in-prefix 'Usuario: ' --reverse-prompt 'Usuario:'
El servidor web llama.cpp es un servidor HTTP ligero compatible con API OpenAI que se puede utilizar para servir modelos locales y conectarlos fácilmente a clientes existentes.
Uso de ejemplo:
./llama-server -m your_model.gguf --port 8080# Se puede acceder a la interfaz de usuario web básica a través del navegador: http://localhost:8080# Punto final de finalización del chat: http://localhost:8080/v1/chat/completions
Nota
Si prefiere el uso básico, considere usar el modo conversación en lugar del modo interactivo.
En este modo, siempre puede interrumpir la generación presionando Ctrl+C e ingresando una o más líneas de texto, que se convertirán en tokens y se agregarán al contexto actual. También puede especificar un mensaje inverso con el parámetro -r "reverse prompt string" . Esto dará como resultado que se solicite la entrada del usuario cada vez que se encuentren en la generación los tokens exactos de la cadena de solicitud inversa. Un uso típico es utilizar un mensaje que hace que LLaMA emule un chat entre varios usuarios, digamos Alice y Bob, y pase -r "Alice:" .
A continuación se muestra un ejemplo de una interacción de unos pocos disparos, invocada con el comando
# argumentos predeterminados usando un modelo 7B./examples/chat.sh# chat avanzado con un modelo 13B./examples/chat-13B.sh# argumentos personalizados usando un modelo 13B./llama-cli -m ./models/13B/ ggml-model-q4_0.gguf -n 256 --repeat_penalty 1.0 --color -i -r "Usuario:" -f indicaciones/chatear-con-bob.txt
Tenga en cuenta el uso de --color para distinguir entre la entrada del usuario y el texto generado. Otros parámetros se explican con más detalle en el archivo README del programa de ejemplo llama-cli .
Las indicaciones, las entradas del usuario y las generaciones de modelos se pueden guardar y reanudar en llamadas a ./llama-cli aprovechando --prompt-cache y --prompt-cache-all . El script ./examples/chat-persistent.sh demuestra esto con soporte para sesiones de chat reanudables y de larga duración. Para usar este ejemplo, debe proporcionar un archivo para almacenar en caché el mensaje de chat inicial y un directorio para guardar la sesión de chat y, opcionalmente, puede proporcionar las mismas variables que chat-13B.sh . El mismo caché de avisos se puede reutilizar para nuevas sesiones de chat. Tenga en cuenta que tanto la caché de mensajes como el directorio de chat están vinculados al mensaje inicial ( PROMPT_TEMPLATE ) y al archivo del modelo.
# Iniciar un nuevo chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh# Reanudar ese chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat- persistente.sh# Iniciar un chat diferente con el mismo Prompt/modelPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/another ./examples/chat-persistent.sh# Caché de mensajes diferentes para diferentes mensajes/modelPROMPT_TEMPLATE=./prompts/chat-with-bob.txt PROMPT_CACHE_FILE=bob. símbolo.bin
CHAT_SAVE_DIR=./chat/bob ./examples/chat-persistent.sh llama.cpp admite gramáticas para restringir la salida del modelo. Por ejemplo, puede forzar que el modelo genere solo JSON:
./llama-cli -m ./models/13B/ggml-model-q4_0.gguf -n 256 --grammar-file grammars/json.gbnf -p 'Solicitud: programar una llamada a las 8 p. m.; Dominio:'
La carpeta grammars/ contiene algunos ejemplos de gramáticas. Para escribir el suyo propio, consulte la Guía GBNF.
Para crear gramáticas JSON más complejas, también puede consultar https://grammar.intrinsiclabs.ai/, una aplicación de navegador que le permite escribir interfaces TypeScript que compila en gramáticas GBNF que puede guardar para uso local. Tenga en cuenta que la aplicación es creada y mantenida por miembros de la comunidad; presente cualquier problema o FR en su repositorio y no en este.
Consulte Construir llama.cpp localmente.
| backend | Dispositivos de destino |
|---|---|
| Metal | Silicio de manzana |
| BLAS | Todo |
| BLIS | Todo |
| SYCL | GPU Intel y Nvidia |
| musa | GPU Moore Threads MTT |
| CUDA | GPU Nvidia |
| caderaBLAS | GPU AMD |
| vulcano | GPU |
| GOLPE LIGERO | Ascender NPU |
Nota
También puede utilizar el espacio GGUF-my-repo en Hugging Face para cuantificar los pesos de su modelo sin ninguna configuración. Se sincroniza desde llama.cpp main cada 6 horas.
Para obtener los pesos oficiales de LLaMA 2 consulte la sección Obtención y uso del modelo LLaMA 2 de Facebook. También hay una gran selección de modelos gguf precuantizados disponibles en Hugging Face.
Nota: convert.py se ha movido a examples/convert_legacy_llama.py y no debe usarse para nada más que los modelos Llama/Llama2/Mistral y sus derivados. No es compatible con LLaMA 3, puede usar convert_hf_to_gguf.py con LLaMA 3 descargado de Hugging Face.
Para obtener más información sobre el modelo de cuantificación, lea esta documentación.
Puede utilizar el ejemplo perplexity para medir la perplejidad ante un mensaje determinado (cuanto menor sea la perplejidad, mejor). Para obtener más información, consulte https://huggingface.co/docs/transformers/perplexity.
Para obtener más información sobre cómo medir la perplejidad usando llama.cpp, lea esta documentación.
Los contribuyentes pueden abrir relaciones públicas
Los colaboradores pueden enviar a las ramas en el repositorio llama.cpp y fusionar los PR en la rama master .
Se invitará a colaboradores en base a las contribuciones.
¡Cualquier ayuda con la gestión de problemas, relaciones públicas y proyectos es muy apreciada!
Vea buenos primeros números para tareas adecuadas para primeras contribuciones
Lea CONTRIBUTING.md para obtener más información.
Asegúrate de leer esto: Inferencia en el borde
Un poco de historia de fondo para aquellos que estén interesados: podcast de Changelog
principal (cli)
servidor
peligro
Gramáticas GBNF
Documentaciones de desarrollo
como construir
Ejecutando en Docker
Construir en Android
Solución de problemas de rendimiento
Consejos y trucos de GGML
Artículos fundamentales y antecedentes sobre los modelos.
Si su problema es con la calidad de la generación de modelos, al menos escanee los siguientes enlaces y documentos para comprender las limitaciones de los modelos LLaMA. Esto es especialmente importante al elegir un tamaño de modelo apropiado y apreciar las diferencias significativas y sutiles entre los modelos LLaMA y ChatGPT:
Llama:
Presentamos LLaMA: un modelo de lenguaje grande fundamental con 65 mil millones de parámetros
LLaMA: modelos de lenguaje básico abiertos y eficientes
GPT-3
Los modelos de lenguaje son aprendices de pocas oportunidades
GPT-3.5 / InstructGPT / ChatGPT:
Alinear modelos de lenguaje para seguir instrucciones
Entrenar modelos de lenguaje para seguir instrucciones con retroalimentación humana.
