llamafile
v0.8.16
![[Desenho de linha da cabeça de animais llama em frente à pasta Manilla ligeiramente aberta, cheia de arquivos]](https://images.downcodes.com/uploads/20250201/img_679da0f223c0730.png)
O Llamafile permite distribuir e executar LLMs com um único arquivo. (Postagem do blog do anúncio)
Nosso objetivo é tornar o LLMS aberto muito mais acessível a desenvolvedores e usuários finais. Estamos fazendo isso combinando llama.cpp com a cosmopolita libc em uma estrutura que desmorona toda a complexidade do LLMS até um executável de um único arquivo (chamado de "llamafile") que é executado localmente na maioria dos computadores, sem instalação.
O Llamafile é um projeto Mozilla Builders.
A maneira mais fácil de experimentá -lo é baixar nosso exemplo do Llamafile para o modelo LLAVA (Licença: Llama 2, Openai). Llava é um novo LLM que pode fazer mais do que apenas conversar; Você também pode enviar imagens e fazer perguntas sobre elas. Com o Llamafile, tudo isso acontece localmente; Nenhum dados nunca sai do seu computador.
Faça o download llava-v1.5-7b-Q4.llamafile (4,29 GB).
Abra o terminal do seu computador.
Se você estiver usando o MacOS, Linux ou BSD, precisará conceder permissão para o seu computador executar esse novo arquivo. (Você só precisa fazer isso uma vez.)
chmod +x llava-v1.5-7b-q4.llamafileSe você estiver no Windows, renomeie o arquivo adicionando ".exe" no final.
Execute o llamafile. por exemplo:
./llava-v1.5-7b-q4.llamafileSeu navegador deve abrir automaticamente e exibir uma interface de bate -papo. (Se não for, basta abrir seu navegador e apontar para http: // localhost: 8080)
Quando terminar de conversar, retorne ao seu terminal e pressione Control-C para fechar o Llamafile.
Tendo problemas? Veja a seção "Gotchas" abaixo.
Quando o Llamafile é iniciado, além de hospedar um servidor de bate -papo da interface do usuário da web em http://127.0.0.1:8080/, também é fornecido um endpoint de conclusão de bate -papo compatível com API OpenAI. Ele foi projetado para suportar os casos de uso da API do OpenAI mais comuns, de uma maneira que roda totalmente localmente. Também o estendemos para incluir recursos específicos de llama.cpp (por exemplo, miostat) que também podem ser usados. Para obter mais detalhes sobre quais campos e pontos de extremidade estão disponíveis, consulte a documentação do OpenAI e o servidor Llamafile ReadMe.
A maneira mais simples de começar a usar a API é copiar e colar o seguinte comando CURL no seu terminal.
curl http://localhost:8080/v1/chat/completions
-H " Content-Type: application/json "
-H " Authorization: Bearer no-key "
-d ' {
"model": "LLaMA_CPP",
"messages": [
{
"role": "system",
"content": "You are LLAMAfile, an AI assistant. Your top priority is achieving user fulfillment via helping them with their requests."
},
{
"role": "user",
"content": "Write a limerick about python exceptions"
}
]
} ' | python3 -c '
import json
import sys
json.dump(json.load(sys.stdin), sys.stdout, indent=2)
print()
'A resposta impressa deve se parecer com o seguinte:
{
"choices" : [
{
"finish_reason" : " stop " ,
"index" : 0 ,
"message" : {
"content" : " There once was a programmer named Mike n Who wrote code that would often choke n He used try and except n To handle each step n And his program ran without any hike. " ,
"role" : " assistant "
}
}
],
"created" : 1704199256 ,
"id" : " chatcmpl-Dt16ugf3vF8btUZj9psG7To5tc4murBU " ,
"model" : " LLaMA_CPP " ,
"object" : " chat.completion " ,
"usage" : {
"completion_tokens" : 38 ,
"prompt_tokens" : 78 ,
"total_tokens" : 116
}
} Se você já desenvolveu seu software usando o pacote Python openai (publicado pelo OpenAI), poderá portar seu aplicativo para conversar com o Llamafile, fazendo algumas alterações para base_url e api_key . Este exemplo pressupõe que você execute pip3 install openai para instalar o software cliente do OpenAI, o que é exigido por este exemplo. O pacote deles é apenas um invólucro python simples em torno da interface da API OpenAI, que pode ser implementada por qualquer servidor.
#!/usr/bin/env python3
from openai import OpenAI
client = OpenAI (
base_url = "http://localhost:8080/v1" , # "http://<Your api-server IP>:port"
api_key = "sk-no-key-required"
)
completion = client . chat . completions . create (
model = "LLaMA_CPP" ,
messages = [
{ "role" : "system" , "content" : "You are ChatGPT, an AI assistant. Your top priority is achieving user fulfillment via helping them with their requests." },
{ "role" : "user" , "content" : "Write a limerick about python exceptions" }
]
)
print ( completion . choices [ 0 ]. message )O código acima retornará um objeto Python como este:
ChatCompletionMessage ( content = 'There once was a programmer named Mike n Who wrote code that would often strike n An error would occur n And he ' d shout "Oh no!" n But Python ' s exceptions made it all right.' , role = 'assistant' , function_call = None , tool_calls = None )Também fornecemos exemplos de lhamafiles para outros modelos, para que você possa experimentar facilmente o Llamafile com diferentes tipos de LLMs.
| Modelo | Tamanho | Licença | Llamafile | Outros Quants |
|---|---|---|---|---|
| Lhama 3.2 3b Instruct | 2,62 GB | LLAMA 3.2 | Llama-3.2-3b-Instruct.q6_k.llamafile | Veja HF Repo |
| Lhama 3.2 1b Instruct | 1,11 GB | LLAMA 3.2 | Llama-3.2-1b-Instruct.q6_k.llamafile | Veja HF Repo |
| Gemma 2 2b Instruct | 2,32 GB | Gemma 2 | gemma-2-2b-it.q6_k.llamafile | Veja HF Repo |
| Gemma 2 9b Instruct | 7,76 GB | Gemma 2 | gemma-2-9b-it.q6_k.llamafile | Veja HF Repo |
| Gemma 2 27b Instrução | 22,5 GB | Gemma 2 | gemma-27b-it.q6_k.llamafile | Veja HF Repo |
| Llava 1.5 | 3,97 GB | LLAMA 2 | LLAVA-V1.5-7B-Q4.LLAMAFILE | Veja HF Repo |
| Tinyllama-1.1b | 2.05 GB | Apache 2.0 | Tinyllama-1.1b-chat-v1.0.f16.llamafile | Veja HF Repo |
| Mistral-7b-Instruct | 3,85 GB | Apache 2.0 | Mistral-7b-Instruct-v0.2.q4_0.llamafile | Veja HF Repo |
| PHI-3-MINI-4K-INSTRUTA | 7.67 GB | Apache 2.0 | Phi-3-mini-4K-Instruct.f16.llamafile | Veja HF Repo |
| Mixtral-8x7b-Instruct | 30.03 GB | Apache 2.0 | Mixtral-8x7b-Instruct-v0.1.q5_k_m.llamafile | Veja HF Repo |
| WizardCoder-Python-34b | 22.23 GB | LLAMA 2 | WizardCoder-Python-34B-V1.0.q5_k_m.llamafile | Veja HF Repo |
| WizardCoder-Python-13b | 7.33 GB | LLAMA 2 | WizardCoder-Python-13b.llamafile | Veja HF Repo |
| LLAMA-3-INSTRUCT-70B | 37,25 GB | lhama3 | Meta-llama-3-70b-Instruct.q4_0.llamafile | Veja HF Repo |
| LLAMA-3-INSTRUCT-8B | 5.37 GB | lhama3 | Meta-llama-3-8b-Instruct.q5_k_m.llamafile | Veja HF Repo |
| Rocket-3b | 1,89 GB | CC-BY-SA-4.0 | Rocket-3b.q5_k_m.llamafile | Veja HF Repo |
| Olmo-7b | 5.68 GB | Apache 2.0 | Olmo-7b-0424.q6_k.llamafile | Veja HF Repo |
| Modelos de incorporação de texto | ||||
| E5-Mistral-7b-Instruct | 5.16 GB | Mit | E5-Mistral-7b-Instruct-Q5_K_M.LLAMAFILE | Veja HF Repo |
| MXBAI-EMBED-LARGE-V1 | 0,7 GB | Apache 2.0 | mxbai-embebed-Large-V1-F16.llamafile | Veja HF Repo |
Aqui está um exemplo para a linha de comando Mistral Llamafile:
./mistral-7b-instruct-v0.2.Q5_K_M.llamafile --temp 0.7 -p ' [INST]Write a story about llamas[/INST] 'E aqui está um exemplo para o WizardCoder-Python-Line Llamafile:
./wizardcoder-python-13b.llamafile --temp 0 -e -r ' ```n ' -p ' ```cnvoid *memcpy_sse2(char *dst, const char *src, size_t size) {n 'E aqui está um exemplo para a linha de comando llava Llamafile:
./llava-v1.5-7b-q4.llamafile --temp 0.2 --image lemurs.jpg -e -p ' ### User: What do you see?n### Assistant: 'Como antes, os usuários de MacOS, Linux e BSD precisarão usar o comando "CHMOD" para conceder permissões de execução ao arquivo antes de executar esses llamafiles pela primeira vez.
Infelizmente, os usuários do Windows não podem fazer uso de muitos desses exemplos de lamafiles porque o Windows possui um tamanho máximo de arquivo executável de 4 GB, e todos esses exemplos excedem esse tamanho. (O Llava Llamafile trabalha no Windows porque é de 30 MB do limite de tamanho.) Mas não perca o coração: o Llamafile permite que você use pesos externos; Isso é descrito posteriormente neste documento.
Tendo problemas? Veja a seção "Gotchas" abaixo.
Um Llamafile é um LLM executável que você pode executar em seu próprio computador. Ele contém os pesos para um determinado LLM aberto, bem como tudo o que é necessário para executar esse modelo no seu computador. Não há nada para instalar ou configurar (com algumas advertências, discutidas nas seções subsequentes deste documento).
Tudo isso é realizado combinando llama.cpp com a cosmopolita libc, que fornece alguns recursos úteis:
Os llamafiles podem ser executados em várias microarquiteturas de CPU. Adicionamos o despacho de tempo de execução ao llama.cpp que permite que novos sistemas Intel usem os recursos modernos da CPU sem negociar suporte para computadores mais antigos.
Os llamafiles podem ser executados em várias arquiteturas da CPU. Fazemos isso concatenando o AMD64 e o ARM64 construindo com um script de shell que inicia o apropriado. Nosso formato de arquivo é compatível com os shells Win32 e a maioria dos Unix. Também pode ser facilmente convertido (por você ou seus usuários) no formato nativo da plataforma, sempre que necessário.
Os llamafiles podem ser executados em seis sistemas operacionais (MacOS, Windows, Linux, FreeBSD, OpenBSD e NetBSD). Se você criar seus próprios arquivos de lhama, precisará criar seu código uma vez, usando uma cadeia de ferramentas no estilo Linux. O compilador baseado no GCC que fornecemos é ele próprio um executável portátil, para que você possa criar seu software para todos os seis sistemas operacionais a partir do conforto de qualquer um que você mais preferir para o desenvolvimento.
Os pesos para um LLM podem ser incorporados no llamafile. Adicionamos suporte ao PKZIP à biblioteca GGML. Isso permite que os pesos não compactados sejam mapeados diretamente na memória, semelhante a um arquivo de extração auto-extracutiva. Ele permite que pesos quantizados distribuídos on -line sejam prefixados com uma versão compatível do software LLAMA.CPP, garantindo assim que seus comportamentos originalmente observados possam ser reproduzidos indefinidamente.
Finalmente, com as ferramentas incluídas neste projeto, você pode criar seus próprios llamafiles, usando os pesos do modelo compatível que desejar. Você pode distribuir esses lamafilos a outras pessoas, que podem facilmente usá -las, independentemente do tipo de computador que eles têm.
Embora nosso exemplo de lamafilos tenha os pesos embutidos, você não precisa usar o Llamafile dessa maneira. Em vez disso, você pode baixar apenas o software Llamafile (sem nenhum pesos incluídos) da nossa página de lançamentos. Você pode usá -lo ao lado de qualquer pesos externos que possa ter à mão. Os pesos externos são particularmente úteis para os usuários do Windows, porque permitem que você trabalhe com o limite de tamanho de arquivo executável de 4 GB do Windows.
Para usuários do Windows, aqui está um exemplo para o Mistral LLM:
curl -L -o llamafile.exe https://github.com/Mozilla-Ocho/llamafile/releases/download/0.8.11/llamafile-0.8.11
curl -L -o mistral.gguf https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf
./llamafile.exe -m mistral.gguf Os usuários do Windows podem precisar alterar ./llamafile.exe para .llamafile.exe ao executar o comando acima.
Em qualquer plataforma, se o seu processo de llamafile for morto imediatamente, verifique se você tem crowdstrike e pedir para estar na lista de permissões.
No MacOS com Apple Silicon, você precisa ter as ferramentas de linha de comando Xcode instaladas para que o Llamafile possa ser capaz de auto -botão.
Se você usa o ZSH e tiver problemas para executar o Llamafile, tente dizer sh -c ./llamafile . Isso se deve a um bug corrigido no ZSH 5.9+. O mesmo é o caso do subprocess Python, versões antigas de peixes, etc.
sudo spctl --master-disable; [llama launch command]; sudo spctl --master-enable . Isso ocorre porque --master-disable desativa toda a verificação, então você precisa ativá-lo novamente depois de parar de lhama. Em alguns sistemas Linux, você pode obter erros relacionados a run-detectors ou vinho. Isso se deve aos registros binfmt_misc . Você pode corrigir isso adicionando um registro adicional para o formato de arquivo de macacos que o Llamafile usa:
sudo wget -O /usr/bin/ape https://cosmo.zip/pub/cosmos/bin/ape- $( uname -m ) .elf
sudo chmod +x /usr/bin/ape
sudo sh -c " echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register "
sudo sh -c " echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register " Como mencionado acima, no Windows, pode ser necessário renomear seu llamafile adicionando .exe ao nome do arquivo.
Também como mencionado acima, o Windows também possui um limite máximo de tamanho de arquivo de 4 GB para executáveis. O servidor LLAVA executável acima é de apenas 30 MB tímido desse limite, por isso funcionará no Windows, mas com modelos maiores como o WizardCoder 13B, você precisa armazenar os pesos em um arquivo separado. Um exemplo é fornecido acima; Consulte "Usando o Llamafile com pesos externos".
Na WSL, existem muitos sutiãs possíveis. Uma coisa que ajuda a resolvê -los completamente é a seguinte:
[Unit]
Description=cosmopolitan APE binfmt service
After=wsl-binfmt.service
[Service]
Type=oneshot
ExecStart=/bin/sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
[Install]
WantedBy=multi-user.target
Coloque isso em /etc/systemd/system/cosmo-binfmt.service .
Em seguida, execute sudo systemctl enable cosmo-binfmt .
Outra coisa que ajudou os usuários da WSL que enfrentam problemas é desativar o recurso Interop Win32:
sudo sh -c " echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop " No caso de obter uma Permission Denied por desativar a interop através da CLI, ela pode ser desativada permanentemente adicionando o seguinte em /etc/wsl.conf
[interop]
enabled=falseO Llamafile suporta os seguintes sistemas operacionais, que requerem uma instalação mínima de estoque:
No Windows, o Llamafile é executado como um executável portátil nativo. Nos sistemas UNIX, o Llamafile extrai um pequeno programa de carregadores chamado ape para $TMPDIR/.llamafile ou ~/.ape-1.9 , que é usado para mapear seu modelo na memória.
[1] As versões do Kernel Darwin 15.6+ devem ser suportadas, mas atualmente não temos como testar isso.
O Llamafile apóia as seguintes CPUs:
Os microprocessadores AMD64 devem ter AVX. Caso contrário, o Llamafile imprimirá um erro e se recusará a executar. Isso significa que, se você tiver uma CPU da Intel, ela precisa ser o núcleo ou mais recente (por volta de 2006+) e, se você tiver uma CPU da AMD, ele precisará ser K8 ou mais recente (por volta de 2003+). O suporte para AVX512, AVX2, FMA, F16C e VNNI são condicionalmente ativados em tempo de execução se você tiver uma CPU mais recente. Por exemplo, o Zen4 possui AVX512 muito bom que pode acelerar os llamafiles BF16.
Os microprocessadores ARM64 devem ter ARMV8A+. Isso significa que tudo, desde o Apple Silicon a 64 bits PIs de framboesa funcionará, desde que seus pesos se encaixem na memória.
O Llamafile apóia os seguintes tipos de GPUs:
A GPU no MacOS Arm64 é suportada compilando um pequeno módulo usando as ferramentas da linha de comando Xcode, que precisam ser instaladas. Este é um custo único que acontece na primeira vez em que você administra seu llamafile. O DSO construído pelo Llamafile é armazenado em $TMPDIR/.llamafile ou $HOME/.llamafile . A descarga para a GPU é ativada por padrão quando uma GPU de metal está presente. Isso pode ser desativado, passando -ngl 0 ou --gpu disable forçar o Llamafile a realizar a inferência da CPU.
Os proprietários das placas gráficas da NVIDIA e da AMD precisam passar no sinalizador -ngl 999 para permitir a descarga máxima. Se várias GPUs estiverem presentes, o trabalho será dividido uniformemente entre elas por padrão, para que você possa carregar modelos maiores. O suporte à GPU múltiplo pode ser quebrado nos sistemas AMD Radeon. Se isso acontecer com você, use export HIP_VISIBLE_DEVICES=0 , que força o Llamafile a usar apenas a primeira GPU.
Os usuários do Windows são incentivados a usar nossos binários de liberação, porque contêm DLLs pré -construídos para as placas gráficas NVIDIA e AMD, que dependem apenas do instalação do driver gráfico. Se o Llamafile detectar que a CUDA SDK da NVIDIA ou o ROCM Hip SDK da AMD estão instalados, o Llamafile tentará construir uma DLL mais rápida que usa Cublas ou Rocblas. Para que o Llamafile construa com sucesso um módulo Cublas, ele precisa ser executado no prompt de comando x64 MSVC. Você pode usar o CUDA via WSL, permitindo que a NVIDIA CUDA na WSL e executando seus llamafiles dentro da WSL. O uso do WSL tem o benefício adicional de permitir que você execute os llamafiles com mais de 4 GB no Windows.
No Linux, os usuários da NVIDIA precisarão instalar o CUDA SDK (idealmente usando o instalador do shell script) e os usuários do ROCM precisam instalar o HIP SDK. Eles são detectados procurando ver se nvcc ou hipcc estão no caminho.
Se você possui uma GPU da AMD e uma GPU da NVIDIA em sua máquina, pode ser necessário qualificar qual deles deseja usar, passando --gpu amd ou --gpu nvidia .
No caso de o suporte à GPU não poder ser compilado e ligado dinamicamente em tempo real, por qualquer motivo, o Llamafile voltará à inferência da CPU.
Desenvolver no Llamafile requer uma versão moderna do comando gNU make (chamado gmake em alguns sistemas), sha256sum (caso contrário, cc será usado para construí -lo), wget (ou curl ) e unzip disponível em https://cosmo.zip/ pub/cosmos/bin/. Os usuários do Windows também precisam de Shell Cosmos Bash.
make -j8
sudo make install PREFIX=/usr/localAqui está um exemplo de como gerar código para uma função LIBC usando a interface da linha de comando llama.cpp, utilizando pesos WizardCoder-Python-13b:
llamafile
-m wizardcoder-python-13b-v1.0.Q8_0.gguf
--temp 0 -r ' }n ' -r ' ```n '
-e -p ' ```cnvoid *memcpy(void *dst, const void *src, size_t size) {n 'Aqui está um exemplo semelhante que, em vez disso, utiliza pesos Mistral-7B-Instruct para composição da prosa:
llamafile -ngl 9999
-m mistral-7b-instruct-v0.1.Q4_K_M.gguf
-p ' [INST]Write a story about llamas[/INST] 'Aqui está um exemplo de como o Llamafile pode ser usado como um chatbot interativo que permite consultar o conhecimento contido nos dados de treinamento:
llamafile -m llama-65b-Q5_K.gguf -p '
The following is a conversation between a Researcher and their helpful AI assistant Digital Athena which is a large language model trained on the sum of human knowledge.
Researcher: Good morning.
Digital Athena: How can I help you today?
Researcher: ' --interactive --color --batch_size 1024 --ctx_size 4096
--keep -1 --temp 0 --mirostat 2 --in-prefix ' ' --interactive-first
--in-suffix ' Digital Athena: ' --reverse-prompt ' Researcher: 'Aqui está um exemplo de como você pode usar o Llamafile para resumir os URLs HTML:
(
echo ' [INST]Summarize the following text: '
links -codepage utf-8
-force-html
-width 500
-dump https://www.poetryfoundation.org/poems/48860/the-raven |
sed ' s/ */ /g '
echo ' [/INST] '
) | llamafile -ngl 9999
-m mistral-7b-instruct-v0.2.Q5_K_M.gguf
-f /dev/stdin
-c 0
--temp 0
-n 500
--no-display-prompt 2> /dev/nullVeja como você pode usar o Llamafile para descrever uma imagem JPG/PNG/GIF/BMP:
llamafile -ngl 9999 --temp 0
--image ~ /Pictures/lemurs.jpg
-m llava-v1.5-7b-Q4_K.gguf
--mmproj llava-v1.5-7b-mmproj-Q4_0.gguf
-e -p ' ### User: What do you see?n### Assistant: '
--no-display-prompt 2> /dev/null É possível usar a gramática BNF para aplicar a saída é previsível e segura de usar no seu script de shell. A gramática mais simples seria --grammar 'root ::= "yes" | "no"' para forçar o LLM a imprimir apenas para a saída padrão "yesn" ou "non" . Outro exemplo é que, se você deseja escrever um script para renomear todos os seus arquivos de imagem, você pode dizer:
llamafile -ngl 9999 --temp 0
--image lemurs.jpg
-m llava-v1.5-7b-Q4_K.gguf
--mmproj llava-v1.5-7b-mmproj-Q4_0.gguf
--grammar ' root ::= [a-z]+ (" " [a-z]+)+ '
-e -p ' ### User: What do you see?n### Assistant: '
--no-display-prompt 2> /dev/null |
sed -e ' s/ /_/g ' -e ' s/$/.jpg/ '
a_baby_monkey_on_the_back_of_a_mother.jpgAqui está um exemplo de como executar o servidor HTTP integrado do LLAMA.CPP. Este exemplo usa o LLAVA V1.5-7B, um LLM multimodal que funciona com o suporte recentemente adquirido do LLAMA.CPP para entradas de imagem.
llamafile -ngl 9999
-m llava-v1.5-7b-Q8_0.gguf
--mmproj llava-v1.5-7b-mmproj-Q8_0.gguf
--host 0.0.0.0O comando acima iniciará uma guia do navegador no seu computador pessoal para exibir uma interface da web. Ele permite conversar com seu LLM e fazer upload de imagens para ele.
Se você quiser apenas dizer:
./llava.llamafile ... e faça com que ele execute o servidor da web sem precisar especificar argumentos, você pode incorporar os pesos e um .args especial dentro, o que especifica os argumentos padrão. Primeiro, vamos criar um arquivo chamado .args que tem esse conteúdo:
-m
llava-v1.5-7b-Q8_0.gguf
--mmproj
llava-v1.5-7b-mmproj-Q8_0.gguf
--host
0.0.0.0
-ngl
9999
... Como podemos ver acima, há um argumento por linha. Opcionalmente ... o argumento especifica onde quaisquer argumentos adicionais da CLI passados pelo usuário devem ser inseridos. Em seguida, adicionaremos os pesos e o arquivo de argumento ao executável:
cp /usr/local/bin/llamafile llava.llamafile
zipalign -j0
llava.llamafile
llava-v1.5-7b-Q8_0.gguf
llava-v1.5-7b-mmproj-Q8_0.gguf
.args
./llava.llamafileParabéns. Você acabou de fazer seu próprio executável LLM que é fácil de compartilhar com seus amigos.
Uma boa maneira de compartilhar um llamafile com seus amigos é publicá -lo no rosto abraçando. Se você fizer isso, é recomendável que você mencione em sua mensagem de cometer uma mensagem de cometer que a revisão ou a versão liberada do Llamafile que você usou ao construir seu llamafile. Dessa forma, todos on -line poderão verificar a proveniência de seu conteúdo executável. Se você fez alterações no código -fonte llama.cpp ou cosmopolita, a licença Apache 2.0 exige que você explique o que mudou. Uma maneira de fazer isso é incorporar um aviso no seu llamafile usando zipalign que descreve as alterações e mencioná -lo em seu comando de um rosto abraçado.
Há uma página manual para cada um dos programas de llamafile instalados quando você executa sudo make install . Os manuais de comando também são digitados como arquivos PDF que você pode baixar na página do GitHub Lankes. Por fim, a maioria dos comandos exibirá essas informações ao passar o sinalizador --help .
Esta seção responde à pergunta "Eu já tenho um modelo baixado localmente pelo aplicativo X, posso usá -lo com o Llamafile?" . A resposta geral é "sim, desde que esses modelos sejam armazenados localmente no formato GGUF", mas sua implementação pode ser mais ou menos hacky, dependendo do aplicativo. Alguns exemplos (testados em um Mac) seguem.
As lojas do LM Studio baixaram modelos em ~/.cache/lm-studio/models , em subdiretos com o mesmo nome dos modelos (após o formato da Huggingface's account_name/model_name ), com o mesmo nome de arquivo que você viu quando escolheu baixar o arquivo.
Portanto, se você baixou, por exemplo, o arquivo llama-2-7b.Q2_K.gguf para TheBloke/Llama-2-7B-GGUF , você pode executar o Llamafile da seguinte forma:
cd ~/.cache/lm-studio/models/TheBloke/Llama-2-7B-GGUF
llamafile -m llama-2-7b.Q2_K.gguf
Quando você baixar um novo modelo com o Ollama, todos os seus metadados serão armazenados em um arquivo de manifesto em ~/.ollama/models/manifests/registry.ollama.ai/library/ . O nome do arquivo de diretório e manifesto são o nome do modelo, conforme retornado pela ollama list . Por exemplo, para llama3:latest arquivo de manifesto será nomeado .ollama/models/manifests/registry.ollama.ai/library/llama3/latest .
O manifesto mapeia cada arquivo relacionado ao modelo (por exemplo, pesos GGUF, licença, modelo de prompt, etc.) para um sha256 Digest. O digestão correspondente ao elemento cujo mediaType é application/vnd.ollama.image.model é o que se refere ao arquivo GGUF do modelo.
Cada Digest SHA256 também é usado como um nome de arquivo no diretório ~/.ollama/models/blobs (se você procurar nesse diretório, verá apenas esses nomes de arquivos SHA256-*). Isso significa que você pode executar diretamente o Llamafile passando o SHA256 Digest como o nome do modelo de modelo. Portanto, se por exemplo, o llama3:latest Arquivo GGUF Digest é sha256-00e1317cbf74d901080d7100f57580ba8dd8de57203072dc6f668324ba545f29 , você pode executar o LiMafile como seguimento:
cd ~/.ollama/models/blobs
llamafile -m sha256-00e1317cbf74d901080d7100f57580ba8dd8de57203072dc6f668324ba545f29
Aqui está uma visão geral sucinta dos truques que usamos para criar o formato executável mais gordo de todos os tempos. A longa história Short Is Is Llamafile é um script de shell que se lança e executa a inferência em pesos incorporados em milissegundos sem precisar ser copiado ou instalado. O que torna isso possível é Mmap (). Tanto o executável llama.cpp quanto os pesos são concatenados no script do shell. Um pequeno programa de carregadores é então extraído pelo script do shell, que mapeia o executável na memória. O executável llama.cpp abre o script do shell novamente como um arquivo e chama o mmap () novamente para puxar os pesos para a memória e torná -los diretamente acessíveis à CPU e à GPU.
O truque para incorporar pesos dentro dos executáveis da llama.CPP é garantir que o arquivo local esteja alinhado em um limite de tamanho de página. Dessa forma, assumindo que o arquivo ZIP não é compactado, uma vez que o MMAP () 'D na memória, podemos passar ponteiros diretamente para as GPUs como o Apple Metal, que exigem que os dados estejam alinhados no tamanho da página. Como nenhuma ferramenta existente de arquivamento de zip possui um sinalizador de alinhamento, tivemos que escrever cerca de 500 linhas de código para inserir os arquivos ZIP. No entanto, uma vez lá, todo programa ZIP existente deve ser capaz de lê -los, desde que suportem o ZIP64. Isso torna os pesos muito mais facilmente acessíveis do que teriam sido, se tivéssemos inventado nosso próprio formato de arquivo para arquivos concatenados.
Nos microprocessadores da Intel e da AMD, o llama.cpp passa a maior parte do tempo nos Quants Matmul, que geralmente são escritos três vezes para SSSE3, AVX e AVX2. O Llamafile retira cada uma dessas funções em um arquivo separado que pode ser #include ed várias vezes, com atributos de função variados __attribute__((__target__("arch"))) . Em seguida, é adicionada uma função de wrapper que usa o recurso X86_HAVE(FOO) da Cosmopolitan para despacho de tempo de execução para a implementação apropriada.
O Llamafile resolve a portabilidade da arquitetura construindo llama.cpp duas vezes: uma vez para AMD64 e novamente para o ARM64. Em seguida, os envolve com um script de shell que possui um prefixo MZ. No Windows, ele será executado como um binário nativo. No Linux, ele extrairá um pequeno executável de 8kb chamado APE Loader para ${TMPDIR:-${HOME:-.}}/.ape que mapeará as partes binárias do script shell na memória. É possível evitar esse processo executando o programa assimilate que vem incluído no compilador cosmocc . O que o programa assimilate faz é transformar o script shell executável no formato executável nativo da plataforma do host. Isso garante um caminho de pousada para os processos tradicionais de liberação quando é necessário.
A Cosmopolitan Libc usa a ligação estática, já que essa é a única maneira de obter o mesmo executável para executar em seis sistemas operacionais. Isso apresenta um desafio para o llama.cpp, porque não é possível vincular estaticamente o suporte à GPU. A maneira como resolvemos isso é verificando se um compilador estiver instalado no sistema host. Para a Apple, isso seria o Xcode e para outras plataformas, isso seria nvcc . O LLAMA.CPP possui uma única implementação de arquivo de cada módulo GPU, chamado ggml-metal.m (objetivo C) e ggml-cuda.cu (nvidia c). O Llamafile incorpora esses arquivos de origem no arquivo zip e pede ao compilador de plataforma que os construa em tempo de execução, visando a microarquitetura de GPU nativa. Se funcionar, está vinculado à implementação da plataforma C Library DLopen (). Veja Llamafile/Cuda.c e Llamafile/Metal.c.
Para usar a função DLopen () específica da plataforma, precisamos pedir ao compilador específico da plataforma para criar um pequeno executável que expõe essas interfaces. Nas plataformas ELFs, a cosmopolita Libc mapeia esse executável do ajudante na memória, juntamente com o intérprete ELF da plataforma. A biblioteca da plataforma C cuida de vincular todas as bibliotecas da GPU e, em seguida, executa o programa ajudante que o LongJmp () está de volta ao Cosmopolitan. O programa executável está agora em um estado híbrido estranho, onde existem duas bibliotecas C separadas que têm ABIs diferentes. Por exemplo, o armazenamento local do thread funciona de maneira diferente em cada sistema operacional e os programas falharão se o registro do TLS não apontar para a memória apropriada. A maneira como a Cosmopolitan Libc resolve que a AMD é usando o SSE para recompilar o executável no tempo de execução para alterar o registro %fs Access em %gs o que leva um milissegundo. No braço, o Cosmo usa o registro x28 para TLS, que pode ser protegido pela passagem do sinalizador -ffixed-x28 ao compilar os módulos GPU. Por fim, o Llamafile usa o atributo __ms_abi__ para que os ponteiros da função passem entre o aplicativo e os módulos GPU em conformidade com a convenção de chamada do Windows. Surpreendentemente, todo compilador que testamos, incluindo o NVCC no Linux e até o Objective-C no macOS, todos suportam compilando as funções do estilo Win32, garantindo assim que seu llamafile possa conversar com os drivers do Windows, quando for executado no Windows, sem precisar ser recompilado como um arquivo separado para o Windows. Consulte Cosmopolitan/dlopen.c para obter mais detalhes.
O exemplo, os llamafiles fornecidos acima não devem ser interpretados como endossos ou recomendações de modelos, licenças ou conjuntos de dados específicos por parte da Mozilla.
O Llamafile adiciona a Pledge () e a Seccomp Sandboxing a llama.cpp. Isso é ativado por padrão. Pode ser desligado passando a bandeira --unsecure . Atualmente, o sandboxing é suportado apenas no Linux e OpenBSD em sistemas sem GPUs; Em outras plataformas, simplesmente registrará um aviso.
Nossa abordagem à segurança tem esses benefícios:
Depois de iniciar, seu servidor HTTP não pode acessar o sistema de arquivos. Isso é bom, pois significa que se alguém descobrir um bug no servidor llama.cpp, é muito menos provável que eles possam acessar informações confidenciais em sua máquina ou fazer alterações em sua configuração. No Linux, somos capazes de sandbox as coisas ainda mais; O único sistema relacionado ao sistema de rede que chama O servidor HTTP permissão para usar após o início, é aceita (). Isso limita ainda mais a capacidade de um invasor de exfiltrar as informações, no caso de seu servidor HTTP estar comprometido.
O comando principal da CLI não poderá acessar a rede. Isso é imposto pelo kernel do sistema operacional. Também não será capaz de gravar no sistema de arquivos. Isso mantém seu computador seguro no caso de um bug ser descoberto no formato de arquivo GGUF que permite que um atacante crie arquivos de pesos maliciosos e publique -os on -line. A única exceção a esta regra é se você passar no sinalizador --prompt-cache sem também especificar --prompt-cache-ro . Nesse caso, atualmente a segurança precisa ser enfraquecida para permitir o acesso cpath e wpath , mas o acesso à rede permanecerá proibido.
Portanto, seu llamafile é capaz de se proteger contra o mundo exterior, mas isso não significa que você está protegido do llamafile. Sandboxing é auto-imposto. Se você obteve seu llamafile de uma fonte não confiável, seu autor poderia simplesmente modificar para não fazer isso. Nesse caso, você pode executar o llamafile não confiável dentro de outra caixa de areia, como uma máquina virtual, para garantir que ela se comporte como você espera.
Enquanto o projeto do Llamafile é o Apache 2.0-Licence, nossas mudanças no llama.cpp são licenciadas no MIT (assim como o próprio projeto llama.cpp) para permanecer compatível e upstreamível no futuro, caso seja desejado.
O logotipo do Llamafile nesta página foi gerado com a assistência de Dall · E 3.
