Download llama.cpp - download do código-fonte llama.cpp

llama.cpp

Outro código-fonte

b3995

Baixar

lhama.cpp

Roteiro / Status do projeto / Manifesto / ggml

Inferência do modelo LLaMA da Meta (e outros) em C/C++ puro

Mudanças recentes na API

Log de alterações da API libllama
Log de alterações para API REST llama-server

Tópicos importantes

Apresentando GGUF-my-LoRA #10123
Os endpoints de inferência facial Hugging agora suportam GGUF prontos para uso! #9669
Editor do Hugging Face GGUF: discussão | ferramenta

Descrição

O principal objetivo do llama.cpp é permitir a inferência LLM com configuração mínima e desempenho de última geração em uma ampla variedade de hardware - localmente e na nuvem.

Implementação simples de C/C++ sem quaisquer dependências
O silício da Apple é um cidadão de primeira classe - otimizado por meio de estruturas ARM NEON, Accelerate e Metal
Suporte AVX, AVX2, AVX512 e AMX para arquiteturas x86
Quantização inteira de 1,5 bits, 2 bits, 3 bits, 4 bits, 5 bits, 6 bits e 8 bits para inferência mais rápida e uso reduzido de memória
Kernels CUDA personalizados para execução de LLMs em GPUs NVIDIA (suporte para GPUs AMD via HIP e GPUs Moore Threads MTT via MUSA)
Suporte de back-end Vulkan e SYCL
Inferência híbrida CPU+GPU para acelerar parcialmente modelos maiores que a capacidade total de VRAM

Desde o seu início, o projeto melhorou significativamente graças a muitas contribuições. É o principal playground para o desenvolvimento de novos recursos para a biblioteca ggml.

Modelos suportados:

Normalmente, os ajustes finos dos modelos básicos abaixo também são suportados.

(instruções para suportar mais modelos: HOWTO-add-model.md)

Modelos multimodais:

Ligações:

Python: abetlen/llama-cpp-python
Acesse: go-skynet/go-llama.cpp
Node.js: withcatai/node-llama-cpp
JS/TS (cliente do servidor llama.cpp): lgrammel/modelfusion
JS/TS (CLI do mecanismo de prompt programável): offline-ai/cli
JavaScript/Wasm (funciona no navegador): tangledgroup/llama-cpp-wasm
Typescript/Wasm (API melhor, disponível em npm): ngxson/wllama
Rubi: yoshoku/llama_cpp.rb
Ferrugem (mais recursos): edgenai/llama_cpp-rs
Rust (API melhor): mdrokz/rust-llama.cpp
Rust (ligações mais diretas): utilityai/llama-cpp-rs
C#/.NET: SciSharp/LLamaSharp
C#/VB.NET (mais recursos - licença comunitária): LM-Kit.NET
Scala 3: donderom/llm4s
Clojure: phronmofóbico/llama.clj
React Native: mybigday/llama.rn
Java: kherud/java-llama.cpp
Zig: deins/llama.cpp.zig
Flutter/Dart: netdur/llama_cpp_dart
PHP (vinculações de API e recursos construídos sobre llama.cpp): distantemagic/resonance (mais informações)
Esquema de Guile: guile_llama_cpp
Swift srgtuszy/llama-cpp-swift
Swift ShenghaiWang/SwiftLlama

IU:

Salvo indicação em contrário, estes projetos são de código aberto com licenciamento permissivo:

MindWorkAI/AI-Studio (FSL-1.1-MIT)
iohub/collama
janhq/jan (AGPL)
nat/openplayground
Faraday (proprietário)
LMStudio (proprietário)
Layla (proprietária)
Ramalama (MIT)
IA local (MIT)
LostRuins/koboldcpp (AGPL)
Mozilla-Ocho/llamafile
nomic-ai/gpt4all
ollama / ollama
oobabooga/geração de texto-webui (AGPL)
psugihara/FreeChat
cztomsik/ava (MIT)
ptsochantaris/emeltal
pythops/tenere (AGPL)
RAGNA Desktop (proprietário)
RecurseChat (proprietário)
sempre/amica
comcatai/catai
Inteligência Artificial Móvel/empregada doméstica (MIT)
Msty (proprietário)
LLMFarm (MIT)
KanTV (Apachev2.0 ou posterior)
Ponto (GPL)
MindMac (proprietário)
KodiBot (GPL)
Eva (MIT)
Plug-in AI Sublime Text (MIT)
AI Kit (MIT)
LARS - A solução LLM e referência avançada (AGPL)
LLMUnidade (MIT)
Assistente de lhama (GPL)
PocketPal AI – um aplicativo para iOS e Android (MIT)

(para ter um projeto listado aqui, deve indicar claramente que depende de llama.cpp )

Ferramentas:

akx/ggify – baixe modelos PyTorch do HuggingFace Hub e converta-os para GGML
akx/ollama-dl – baixe modelos da biblioteca Ollama para serem usados diretamente com llama.cpp
crashr/gppm – inicie instâncias llama.cpp utilizando GPUs NVIDIA Tesla P40 ou P100 com consumo de energia ocioso reduzido
gpustack/gguf-parser - revise/verifique o arquivo GGUF e estime o uso de memória
Styled Lines (wrapper assíncrono licenciado proprietário de parte de inferência para desenvolvimento de jogos em Unity3d com wrappers de plataforma móvel e Web pré-construídos e um exemplo de modelo)

Infraestrutura:

Paddler - Balanceador de carga stateful personalizado para llama.cpp
GPUStack – Gerencie clusters de GPU para execução de LLMs
llama_cpp_canister - llama.cpp como um contrato inteligente no computador da Internet, usando WebAssembly

Jogos:

Lucy's Labyrinth - Um jogo de labirinto simples onde agentes controlados por um modelo de IA tentarão enganá-lo.

Demonstração

Execução típica usando LLaMA v2 13B em 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

Demonstração de execução de LLaMA-7B e Whisper.cpp em um único MacBook M1 Pro

E aqui está outra demonstração de execução do LLaMA-7B e do Whisper.cpp em um único MacBook M1 Pro:

sussurro-lhama-lq.mp4

Uso

Aqui estão as etapas completas de construção binária e conversão de modelo para a maioria dos modelos suportados.

Uso básico

Em primeiro lugar, você precisa obter o binário. Existem diferentes métodos que você pode seguir:

Método 1: Clone este repositório e construa localmente, veja como construir
Método 2: Se estiver usando MacOS ou Linux, você pode instalar llama.cpp via brew, flox ou nix
Método 3: use uma imagem Docker, consulte a documentação do Docker
Método 4: Baixe o binário pré-construído dos lançamentos

Você pode executar uma conclusão básica usando este comando:

 llama-cli -m your_model.gguf -p "Eu acredito que o sentido da vida é" -n 128# Resultado:# Acredito que o sentido da vida é encontrar sua própria verdade e viver de acordo com ela. Para mim, isso significa ser fiel a mim mesmo e seguir minhas paixões, mesmo que elas não estejam alinhadas com as expectativas da sociedade. Acho que é isso que adoro no yoga – não é apenas uma prática física, mas também espiritual. Trata-se de conectar-se consigo mesmo, ouvir sua voz interior e honrar sua jornada única.

Consulte esta página para obter uma lista completa de parâmetros.

Modo de conversa

Se quiser uma experiência mais parecida com ChatGPT, você pode executar em modo conversação passando -cnv como parâmetro:

 llama-cli -m your_model.gguf -p "Você é um assistente útil" -cnv# Saída:# > oi, quem é você?# Olá! Eu sou seu assistente útil! Sou um chatbot com tecnologia de IA projetado para ajudar e fornecer informações a usuários como você. Estou aqui para ajudar a responder suas perguntas, fornecer orientação e oferecer suporte em uma ampla variedade de tópicos. Sou uma IA amigável e experiente e estou sempre feliz em ajudar com qualquer coisa que você precisar. O que você está pensando e como posso ajudá-lo hoje?## > o que é 1+1?# Fácil! A resposta para 1+1 é... 2!

Por padrão, o modelo de chat será retirado do modelo de entrada. Se você quiser usar outro modelo de chat, passe --chat-template NAME como parâmetro. Veja a lista de modelos suportados

 ./llama-cli -m your_model.gguf -p "Você é um assistente útil" -cnv --chat-template chatml

Você também pode usar seu próprio modelo por meio de parâmetros in-prefix, in-suffix e prompt reverso:

 ./llama-cli -m your_model.gguf -p "Você é um assistente útil" -cnv --in-prefix 'Usuário:' --reverse-prompt 'Usuário:'

Servidor web

O servidor web llama.cpp é um servidor HTTP leve compatível com a API OpenAI que pode ser usado para servir modelos locais e conectá-los facilmente a clientes existentes.

Exemplo de uso:

 ./llama-server -m your_model.gguf --port 8080# UI básica da web pode ser acessada via navegador: http://localhost:8080# Endpoint de conclusão do bate-papo: http://localhost:8080/v1/chat/completions

Modo interativo

Observação

Se você preferir o uso básico, considere usar o modo de conversação em vez do modo interativo

Neste modo, você sempre pode interromper a geração pressionando Ctrl+C e inserindo uma ou mais linhas de texto, que serão convertidas em tokens e anexadas ao contexto atual. Você também pode especificar um prompt reverso com o parâmetro -r "reverse prompt string" . Isso resultará na solicitação da entrada do usuário sempre que os tokens exatos da sequência de prompt reverso forem encontrados na geração. Um uso típico é usar um prompt que faz com que o LLaMA emule um bate-papo entre vários usuários, digamos Alice e Bob, e passe -r "Alice:" .

Aqui está um exemplo de interação de algumas cenas, invocada com o comando

 # argumentos padrão usando um modelo 7B./examples/chat.sh# bate-papo avançado com um modelo 13B./examples/chat-13B.sh# argumentos personalizados usando um modelo 13B./llama-cli -m ./models/13B/ ggml-model-q4_0.gguf -n 256 --repeat_penalty 1.0 --color -i -r "Usuário:" -f prompts/chat-with-bob.txt

Observe o uso de --color para distinguir entre a entrada do usuário e o texto gerado. Outros parâmetros são explicados com mais detalhes no README do programa de exemplo llama-cli .

imagem

Interação Persistente

O prompt, as entradas do usuário e as gerações de modelo podem ser salvos e retomados nas chamadas para ./llama-cli aproveitando --prompt-cache e --prompt-cache-all . O script ./examples/chat-persistent.sh demonstra isso com suporte para sessões de bate-papo retomáveis e de longa duração. Para usar este exemplo, você deve fornecer um arquivo para armazenar em cache o prompt inicial do chat e um diretório para salvar a sessão de chat e, opcionalmente, pode fornecer as mesmas variáveis que chat-13B.sh . O mesmo cache de prompt pode ser reutilizado para novas sessões de chat. Observe que tanto o cache de prompt quanto o diretório de chat estão vinculados ao prompt inicial ( PROMPT_TEMPLATE ) e ao arquivo de modelo.

 # Iniciar um novo chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh# Retomar esse chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat- persistente.sh# Inicie um chat diferente com o mesmo prompt/modelPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/another ./examples/chat-persistent.sh# Cache de prompt diferente para prompt diferente/modelPROMPT_TEMPLATE=./prompts/chat-with-bob.txt PROMPT_CACHE_FILE=bob. prompt.bin 
    CHAT_SAVE_DIR=./chat/bob ./examples/chat-persistent.sh

Saída restrita com gramáticas

llama.cpp oferece suporte a gramáticas para restringir a saída do modelo. Por exemplo, você pode forçar o modelo a gerar apenas JSON:

 ./llama-cli -m ./models/13B/ggml-model-q4_0.gguf -n 256 --grammar-file gramáticas/json.gbnf -p 'Solicitação: agende uma chamada às 20h; Comando:'

A pasta grammars/ contém alguns exemplos de gramáticas. Para escrever o seu próprio, consulte o Guia GBNF.

Para criar gramáticas JSON mais complexas, você também pode conferir https://grammar.intrinsiclabs.ai/, um aplicativo de navegador que permite escrever interfaces TypeScript que compila para gramáticas GBNF que você pode salvar para uso local. Observe que o aplicativo é desenvolvido e mantido por membros da comunidade. Por favor, registre quaisquer problemas ou FRs em seu repositório e não neste.

Construir

Consulte Construir llama.cpp localmente

Back-ends suportados

Back-end	Dispositivos alvo
Metal	Silício da Apple
BLAS	Todos
BLIS	Todos
SYCL	GPU Intel e Nvidia
MUSA	GPU Moore Threads MTT
CUDA	GPU Nvidia
hipBLAS	GPU AMD
Vulcano	GPU
PODE	Ascender NPU

Ferramentas

Preparar e Quantizar

Observação

Você pode usar o espaço GGUF-my-repo no Hugging Face para quantizar os pesos do seu modelo sem qualquer configuração também. Ele é sincronizado com llama.cpp main a cada 6 horas.

Para obter os pesos oficiais do LLaMA 2, consulte a seção Obtenção e uso do modelo LLaMA 2 do Facebook. Há também uma grande seleção de modelos gguf pré-quantizados disponíveis no Hugging Face.

Nota: convert.py foi movido para examples/convert_legacy_llama.py e não deve ser usado para nada além dos modelos Llama/Llama2/Mistral e seus derivados. Ele não suporta LLaMA 3, você pode usar convert_hf_to_gguf.py com LLaMA 3 baixado de Hugging Face.

Para saber mais sobre o modelo de quantização, leia esta documentação

Perplexidade (medindo a qualidade do modelo)

Você pode usar o exemplo perplexity para medir a perplexidade em um determinado prompt (menor perplexidade é melhor). Para obter mais informações, consulte https://huggingface.co/docs/transformers/perplexity.

Para saber mais como medir a perplexidade usando llama.cpp, leia esta documentação

Contribuindo

Colaboradores podem abrir PRs
Os colaboradores podem enviar push para ramificações no repositório llama.cpp e mesclar PRs na ramificação master
Os colaboradores serão convidados com base nas contribuições
Qualquer ajuda com o gerenciamento de problemas, relações públicas e projetos será muito apreciada!
Veja boas primeiras edições para tarefas adequadas para primeiras contribuições
Leia CONTRIBUTING.md para obter mais informações
Certifique-se de ler isto: Inferência na borda
Um pouco da história para quem estiver interessado: podcast Changelog

Outras documentações

principal (cli)
servidor
perigo
Gramáticas GBNF

Documentações de desenvolvimento

Como construir
Executando no Docker
Construir no Android
Solução de problemas de desempenho
Dicas e truques do GGML

Artigos seminais e antecedentes dos modelos

Se o seu problema for com a qualidade da geração do modelo, leia pelo menos os links e documentos a seguir para entender as limitações dos modelos LLaMA. Isto é especialmente importante ao escolher um tamanho de modelo apropriado e apreciar as diferenças significativas e sutis entre os modelos LLaMA e ChatGPT: