llamafile
v0.8.16
![[Dessin de ligne de la tête animale lama devant un dossier Manille légèrement ouvert rempli de fichiers]](https://images.downcodes.com/uploads/20250201/img_679da0f223c0730.png)
Llafile vous permet de distribuer et d'exécuter des LLM avec un seul fichier. (article de blog d'annonce)
Notre objectif est de rendre les LLM ouvertes beaucoup plus accessibles aux développeurs et aux utilisateurs finaux. Nous le faisons en combinant llama.cpp avec Cosmopolitan LIBC dans un cadre qui effondre toute la complexité des LLMS jusqu'à un exécutable unique (appelé un "llafile") qui s'exécute localement sur la plupart des ordinateurs, sans installation.
Llafile est un projet Mozilla Builders.
La façon la plus simple de l'essayer par vous-même est de télécharger notre exemple de Llafile pour le modèle Llava (Licence: Llama 2, Openai). Llava est un nouveau LLM qui peut faire plus que simplement discuter; Vous pouvez également télécharger des images et lui poser des questions à leur sujet. Avec Llafile, tout se passe localement; Aucune donnée ne quitte jamais votre ordinateur.
Télécharger llava-v1.5-7b-q4.llamafile (4,29 Go).
Ouvrez le terminal de votre ordinateur.
Si vous utilisez MacOS, Linux ou BSD, vous devrez accorder l'autorisation à votre ordinateur pour exécuter ce nouveau fichier. (Vous n'avez besoin de le faire qu'une seule fois.)
chmod +x llava-v1.5-7b-q4.llamafileSi vous êtes sous Windows, renommez le fichier en ajoutant ".exe" à la fin.
Diriger le llafile. Par exemple:
./llava-v1.5-7b-q4.llamafileVotre navigateur doit s'ouvrir automatiquement et afficher une interface de chat. (Si ce n'est pas le cas, ouvrez simplement votre navigateur et pointez-le sur http: // localhost: 8080)
Lorsque vous avez terminé de discuter, retournez à votre terminal et appuyez sur Control-C pour arrêter Llafile.
Vous avez des problèmes? Voir la section "Gotchas" ci-dessous.
Lorsque Llamafile est démarré, en plus d'héberger un serveur de chat interne Web sur http://127.0.0.1:8080/, un point de terminaison compatible de chat compatible API OpenAI est également fourni. Il est conçu pour prendre en charge les cas d'utilisation des API OpenAI les plus courants, d'une manière qui fonctionne entièrement localement. Nous l'avons également étendu pour inclure des fonctionnalités spécifiques de lama.cpp (par exemple Mirostat) qui peuvent également être utilisées. Pour plus de détails sur les champs et les points de terminaison disponibles, reportez-vous à la fois à la documentation OpenAI et à la lecture du serveur Llafile.
Le moyen le plus simple de commencer à utiliser l'API est de copier et de coller la commande Curl suivante dans votre 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()
'La réponse imprimée devrait ressembler à ce qui suit:
{
"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
}
} Si vous avez déjà développé votre logiciel à l'aide du package openai Python (publié par OpenAI), vous devriez être en mesure de porter votre application pour parler à Llafile à la place, en apportant quelques modifications à base_url et api_key . Cet exemple suppose que vous avez exécuté pip3 install openai pour installer le logiciel client d'Openai, qui est requis par cet exemple. Leur package est juste un simple wrapper python autour de l'interface API OpenAI, qui peut être implémentée par n'importe quel serveur.
#!/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 )Le code ci-dessus renverra un objet Python comme ceci:
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 )Nous fournissons également des exemples de llafiles pour d'autres modèles, vous pouvez donc facilement essayer Llafile avec différents types de LLM.
| Modèle | Taille | Licence | llafile | Autres quants |
|---|---|---|---|---|
| LLAMA 3.2 3B Instruct | 2,62 Go | Lama 3.2 | LLAMA-3.2-3B-INSTRUCT.Q6_K.LLAMAFILE | Voir HF Repo |
| LLAMA 3.2 1B Instruct | 1,11 Go | Lama 3.2 | LLAMA-3.2-1B-INSTRUCT.Q6_K.LLAMAFILE | Voir HF Repo |
| GEMMA 2 2B | 2,32 Go | Gemma 2 | gemma-2-2b-it.q6_k.llamafile | Voir HF Repo |
| GEMMA 2 9B | 7,76 Go | Gemma 2 | gemma-2-9b-it.q6_k.llamafile | Voir HF Repo |
| GEMMA 2 27B | 22,5 Go | Gemma 2 | gemma-2-27b-it.q6_k.llamafile | Voir HF Repo |
| Llava 1.5 | 3,97 Go | Lama 2 | llava-v1.5-7b-q4.llamafile | Voir HF Repo |
| Tinyllama-1.1b | 2,05 Go | Apache 2.0 | Tinyllama-1.1b-chat-v1.0.f16.llamafile | Voir HF Repo |
| Mistral-7B-Istruct | 3,85 Go | Apache 2.0 | Mistral-7B-Instruct-V0.2.Q4_0.LlamaFil | Voir HF Repo |
| PHI-3-MINI-4K-INSTRUCT | 7,67 Go | Apache 2.0 | PHI-3-MINI-4K-INSTRUCT.F16.LAMAFILE | Voir HF Repo |
| Mixtral-8x7b-instruct | 30,03 Go | Apache 2.0 | mixtral-8x7b-instruct-v0.1.q5_k_m.llamafile | Voir HF Repo |
| Wizardcoder-python-34b | 22,23 Go | Lama 2 | wizardcoder-python-34b-v1.0.q5_k_m.llamafile | Voir HF Repo |
| Wizardcoder-python-13b | 7,33 Go | Lama 2 | wizardcoder-python-13b.llamafile | Voir HF Repo |
| LLAMA-3-INSTRUCT-70B | 37,25 Go | lama3 | Meta-llama-3-70b-instruct.q4_0.llamafile | Voir HF Repo |
| LLAMA-3-INSTRUCT-8B | 5,37 Go | lama3 | Meta-llama-3-8b-instruct.q5_k_m.llamafile | Voir HF Repo |
| Fusée-3b | 1,89 Go | cc-by-sa-4.0 | ROCKET-3B.Q5_K_M.LLAMAFILE | Voir HF Repo |
| Olmo-7b | 5,68 Go | Apache 2.0 | Olmo-7b-0424.q6_k.llamafile | Voir HF Repo |
| Modèles d'intégration de texte | ||||
| E5-Mistral-7B-Istruct | 5,16 Go | Mit | E5-Mistral-7B-Instruct-Q5_K_M.LlamaFil | Voir HF Repo |
| MXBAI-EMBED-LANG-V1 | 0,7 Go | Apache 2.0 | MXBAI-EMBED-LANG-V1-F16.LAMAFILE | Voir HF Repo |
Voici un exemple pour la ligne de commande Mistral Llafile:
./mistral-7b-instruct-v0.2.Q5_K_M.llamafile --temp 0.7 -p ' [INST]Write a story about llamas[/INST] 'Et voici un exemple pour WizardCoder-Python Command Line Llafile:
./wizardcoder-python-13b.llamafile --temp 0 -e -r ' ```n ' -p ' ```cnvoid *memcpy_sse2(char *dst, const char *src, size_t size) {n 'Et voici un exemple pour la ligne de commande Llava Llafile:
./llava-v1.5-7b-q4.llamafile --temp 0.2 --image lemurs.jpg -e -p ' ### User: What do you see?n### Assistant: 'Comme précédemment, les utilisateurs de MacOS, Linux et BSD devront utiliser la commande "ChMOD" pour accorder des autorisations d'exécution au fichier avant d'exécuter ces llafiles pour la première fois.
Malheureusement, les utilisateurs de Windows ne peuvent pas utiliser bon nombre de ces exemples de llafiles car Windows a une taille de fichier exécutable maximale de 4 Go, et tous ces exemples dépassent cette taille. (Le Llava Llafile travaille sur les fenêtres car il est à 30 Mo de la limite de taille.) Mais ne perdez pas cœur: Llafile vous permet d'utiliser des poids externes; Ceci est décrit plus loin dans ce document.
Vous avez des problèmes? Voir la section "Gotchas" ci-dessous.
Un llafile est un LLM exécutable que vous pouvez exécuter sur votre propre ordinateur. Il contient les poids pour une LLM ouverte donnée, ainsi que tout ce qui est nécessaire pour exécuter ce modèle sur votre ordinateur. Il n'y a rien à installer ou à configurer (avec quelques mises en garde, discutées dans les sections suivantes de ce document).
Tout cela est accompli en combinant Llama.cpp avec Cosmopolitan LIBC, qui offre des capacités utiles:
Les llafiles peuvent fonctionner sur plusieurs microarchitectures CPU. Nous avons ajouté l'exécution de l'exécution à llama.cpp qui permet à de nouveaux systèmes Intel utiliser les fonctionnalités CPU modernes sans échanger la prise en charge des ordinateurs plus anciens.
Les llafiles peuvent fonctionner sur plusieurs architectures de processeur. Nous le faisons en concaténant AMD64 et ARM64 construit avec un script de shell qui lance celui approprié. Notre format de fichier est compatible avec Win32 et la plupart des coquilles UNIX. Il peut également être facilement converti (par vous ou vos utilisateurs) au format de plate-forme natif, chaque fois que nécessaire.
Les llafiles peuvent fonctionner sur six OS (macOS, Windows, Linux, FreeBSD, OpenBSD et NetBSD). Si vous créez vos propres fichiers lama, vous n'aurez besoin de créer votre code qu'une seule fois, à l'aide d'une chaîne d'outils de style Linux. Le compilateur basé sur le GCC que nous fournissons est lui-même un exécutable réellement portable, vous pouvez donc créer votre logiciel pour les six OSE dans le confort de celui que vous préférez le plus pour le développement.
Les poids pour un LLM peuvent être intégrés dans le llafile. Nous avons ajouté la prise en charge de PKZIP à la bibliothèque GGML. Cela permet aux poids non compressés d'être mappés directement dans la mémoire, similaires à une archive auto-extraite. Il permet de préfixer des poids quantifiés distribués en ligne avec une version compatible du logiciel lama.cpp, garantissant ainsi que ses comportements observés à l'origine peuvent être reproduits indéfiniment.
Enfin, avec les outils inclus dans ce projet, vous pouvez créer vos propres llafiles, en utilisant tous les poids de modèle compatibles que vous souhaitez. Vous pouvez ensuite distribuer ces llafiles à d'autres personnes, qui peuvent facilement les utiliser quel que soit le type d'ordinateur dont ils disposent.
Même si notre exemple de llafiles a les poids intégrés, vous n'avez pas à utiliser Llafile de cette façon. Au lieu de cela, vous pouvez télécharger uniquement le logiciel Llafile (sans aucun poids inclus) à partir de notre page de versions. Vous pouvez ensuite l'utiliser à côté de tous les poids externes que vous pourriez avoir à portée de main. Les poids externes sont particulièrement utiles pour les utilisateurs de Windows car ils vous permettent de travailler autour de la limite de taille de fichier exécutable de 4 Go de Windows.
Pour les utilisateurs de Windows, voici un exemple pour le 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 Les utilisateurs de Windows peuvent avoir besoin de modifier ./llamafile.exe vers .llamafile.exe lors de l'exécution de la commande ci-dessus.
Sur n'importe quelle plate-forme, si votre processus de llafile est immédiatement tué, vérifiez si vous avez une Crowdstrike, puis demandez à être liste blanche.
Sur MacOS avec Apple Silicon, vous devez faire installer des outils de ligne de commande Xcode pour que Llafile puisse se démarquer.
Si vous utilisez ZSH et que vous avez du mal à diriger Llafile, essayez de dire sh -c ./llamafile . Cela est dû à un bug qui a été corrigé dans Zsh 5.9+. Il en va de même pour subprocess Python, les anciennes versions de poisson, etc.
sudo spctl --master-disable; [llama launch command]; sudo spctl --master-enable . En effet, --master-disable désactive toute la vérification, vous devez donc le rallumer après avoir quitté Llama. Sur certains systèmes Linux, vous pouvez obtenir des erreurs relatives aux run-detectors ou à du vin. Cela est dû aux enregistrements binfmt_misc . Vous pouvez résoudre ce problème en ajoutant une inscription supplémentaire pour le format de fichier APE que Llafile utilise:
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 " Comme mentionné ci-dessus, sur Windows, vous devrez peut-être renommer votre llafile en ajoutant .exe au nom de fichier.
Également mentionné ci-dessus, Windows a également une limite de taille de fichier maximale de 4 Go pour les exécutables. L'exécutable de serveur LLAVA ci-dessus ne représente que 30 Mo de plus de cette limite, donc il fonctionnera sur Windows, mais avec des modèles plus grands comme WizardCoder 13B, vous devez stocker les poids dans un fichier séparé. Un exemple est fourni ci-dessus; Voir «Utilisation de Llafile avec des poids externes».
Sur WSL, il y a beaucoup de gatchas possibles. Une chose qui aide à les résoudre complètement est la suivante:
[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
Mettez cela dans /etc/systemd/system/cosmo-binfmt.service .
Exécutez ensuite sudo systemctl enable cosmo-binfmt .
Une autre chose qui a aidé les utilisateurs de WSL qui éprouvent des problèmes, est de désactiver la fonctionnalité d'interopérative Win32:
sudo sh -c " echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop " Dans le cas de l'obtention d'une Permission Denied sur la désactivation d' /etc/wsl.conf
[interop]
enabled=falseLlafile prend en charge les systèmes d'exploitation suivants, qui nécessitent une installation minimale de stock:
Sur Windows, Llafile s'exécute comme un exécutable portable natif. Sur les systèmes UNIX, Llafile extrait un petit programme de chargeur nommé ape à $TMPDIR/.llamafile ou ~/.ape-1.9 qui est utilisé pour cartographier votre modèle en mémoire.
[1] Les versions du noyau Darwin 15.6+ devraient être prises en charge, mais nous n'avons actuellement aucun moyen de tester cela.
Llafile soutient les processeurs suivants:
Les microprocesseurs AMD64 doivent avoir AVX. Sinon, Llafile imprimera une erreur et refusera de courir. Cela signifie que si vous avez un processeur Intel, il doit être Intel Core ou plus récent (vers 2006+), et si vous avez un CPU AMD, il doit être K8 ou plus récent (vers 2003+). La prise en charge de AVX512, AVX2, FMA, F16C et VNNI est activée conditionnellement au moment de l'exécution si vous avez un CPU plus récent. Par exemple, Zen4 a un très bon AVX512 qui peut accélérer les llafiles BF16.
Les microprocesseurs ARM64 doivent avoir ARMV8A +. Cela signifie que tout, du silicium Apple à la framboise 64 bits, les IP fonctionneront, à condition que vos poids s'intègrent dans la mémoire.
Llafile soutient les types de GPU suivants:
GPU sur MacOS ARM64 est pris en charge en compilant un petit module à l'aide des outils de ligne de commande Xcode, qui doivent être installés. C'est un coût unique qui se produit la première fois que vous dirigez votre llafile. Le DSO construit par Llafile est stocké dans $TMPDIR/.llamafile ou $HOME/.llamafile . Le déchargement vers GPU est activé par défaut lorsqu'un GPU métallique est présent. Cela peut être désactivé en passant -ngl 0 ou --gpu disable pour forcer Llafile à effectuer l'inférence du processeur.
Les propriétaires de cartes graphiques NVIDIA et AMD doivent passer le drapeau -ngl 999 pour permettre le déchargement maximal. Si plusieurs GPU sont présents, les travaux seront divisés uniformément entre eux par défaut, vous pouvez donc charger des modèles plus grands. Le support multiple GPU peut être rompu sur les systèmes AMD Radeon. Si cela vous arrive, utilisez export HIP_VISIBLE_DEVICES=0 qui oblige Llamafile à utiliser uniquement le premier GPU.
Les utilisateurs de Windows sont encouragés à utiliser nos binaires de libération, car ils contiennent des DLL prédéfinies pour les cartes graphiques NVIDIA et AMD, qui ne dépendent que du pilote graphique installé. Si Llafile détecte que le SDK CUDA de Nvidia ou le SDK Rocm Hip d'AMD est installé, alors Llafile essaiera de construire une DLL plus rapide qui utilise des Cublil ou des Rocblas. Pour que Llamafile puisse construire avec succès un module CUBLAS, il doit être exécuté sur l'invite de commande X64 MSVC. Vous pouvez utiliser CUDA via WSL en activant Nvidia Cuda sur WSL et en exécutant vos llafiles à l'intérieur de WSL. L'utilisation de WSL a l'avantage supplémentaire de vous permettre d'exécuter des llafiles supérieurs à 4 Go sur Windows.
Sur Linux, les utilisateurs de Nvidia devront installer le SDK CUDA (idéalement à l'aide du programme d'installation de script shell) et les utilisateurs ROCM doivent installer le SDK branché. Ils sont détectés en cherchant à voir si nvcc ou hipcc sont sur le chemin.
Si vous avez à la fois un GPU AMD et un GPU NVIDIA dans votre machine, vous devrez peut-être qualifier celui que vous souhaitez utiliser, en passant soit --gpu amd ou --gpu nvidia .
Dans le cas où le support GPU ne pouvait pas être compilé et lié dynamiquement à la volée pour quelque raison que ce soit, Llafile se repliera à l'inférence du processeur.
Développer sur Llafile nécessite une version moderne de la commande GNU make (appelée gmake sur certains systèmes), sha256sum (sinon cc sera utilisée pour la construire), wget (ou curl ) et unzip disponible sur https://cosmo.zip/ pub / cosmos / bin /. Les utilisateurs de Windows ont également besoin de Cosmos Bash Shell.
make -j8
sudo make install PREFIX=/usr/localVoici un exemple de la façon de générer du code pour une fonction LIBC à l'aide de l'interface de ligne de commande LLAMA.CPP, en utilisant WizardCoder-Python-13B Poids:
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 'Voici un exemple similaire qui utilise plutôt les poids Mistral-7B-Istruct pour la composition en prose:
llamafile -ngl 9999
-m mistral-7b-instruct-v0.1.Q4_K_M.gguf
-p ' [INST]Write a story about llamas[/INST] 'Voici un exemple de la façon dont Llafile peut être utilisé comme chatbot interactif qui vous permet de demander des connaissances contenues dans les données de formation:
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: 'Voici un exemple de la façon dont vous pouvez utiliser Llamafile pour résumer les URL 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/nullVoici comment vous pouvez utiliser Llafile pour décrire une image 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 Il est possible d'utiliser la grammaire BNF pour appliquer que la sortie est prévisible et sûre à utiliser dans votre script de shell. La grammaire la plus simple serait --grammar 'root ::= "yes" | "no"' pour forcer le LLM à imprimer uniquement en sortie standard "yesn" ou "non" . Un autre exemple est que si vous vouliez écrire un script pour renommer tous vos fichiers d'image, vous pourriez dire:
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.jpgVoici un exemple de la façon d'exécuter le serveur HTTP intégré de Llama.cpp. Cet exemple utilise LLAVA V1.5-7B, un LLM multimodal qui fonctionne avec la prise en charge récemment ajoutée de Llama.cpp pour les entrées d'image.
llamafile -ngl 9999
-m llava-v1.5-7b-Q8_0.gguf
--mmproj llava-v1.5-7b-mmproj-Q8_0.gguf
--host 0.0.0.0La commande ci-dessus lancera un onglet de navigateur sur votre ordinateur personnel pour afficher une interface Web. Il vous permet de discuter avec votre LLM et de télécharger des images.
Si vous voulez pouvoir dire:
./llava.llamafile ... et faites-le exécuter le serveur Web sans avoir à spécifier des arguments, puis vous pouvez intégrer les poids et les .args spéciaux à l'intérieur, ce qui spécifie les arguments par défaut. Tout d'abord, créons un fichier nommé .args qui a ce contenu:
-m
llava-v1.5-7b-Q8_0.gguf
--mmproj
llava-v1.5-7b-mmproj-Q8_0.gguf
--host
0.0.0.0
-ngl
9999
... Comme nous pouvons le voir ci-dessus, il y a un argument par ligne. L'argument ... spécifie éventuellement où les arguments CLI supplémentaires transmis par l'utilisateur doivent être insérés. Ensuite, nous ajouterons à la fois les poids et le fichier d'argument à l'exécutable:
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.llamafileFélicitations. Vous venez de faire votre propre exécutable LLM facile à partager avec vos amis.
Une bonne façon de partager un llafile avec vos amis est de le publier sur un visage étreint. Si vous faites cela, il est recommandé que vous mentionniez dans votre message étreint comme un message Git Revision ou publié la version de Llafile que vous avez utilisée lors de la construction de votre llafile. De cette façon, tout le monde en ligne pourra vérifier la provenance de son contenu exécutable. Si vous avez apporté des modifications au code source llama.cpp ou cosmopolite, alors la licence Apache 2.0 vous oblige à expliquer ce qui a changé. Une façon dont vous pouvez le faire est en intégrant un avis dans votre llafile à l'aide zipalign qui décrit les modifications et le mentionner dans votre engagement étreint.
Il y a une page manuelle pour chacun des programmes de Llafile installés lorsque vous exécutez sudo make install . Les manuels de commande sont également composés de fichiers PDF que vous pouvez télécharger à partir de notre page GitHub Releases. Enfin, la plupart des commandes afficheront ces informations lors du passage de l'indicateur --help .
Cette section répond à la question "J'ai déjà un modèle téléchargé localement par l'application X, puis-je l'utiliser avec Llafile?" . La réponse générale est "oui, tant que ces modèles sont stockés localement au format GGUF", mais que son implémentation peut être plus ou moins hacky selon l'application. Quelques exemples (testés sur un Mac) suivent.
LM Studio Stores a téléchargé des modèles dans ~/.cache/lm-studio/models , dans des sous-répertoires avec le même nom des modèles (suivant le format account_name/model_name de HuggingFace), avec le même nom de fichier que vous avez vu lorsque vous avez choisi de télécharger le fichier.
Donc, si vous avez téléchargé par exemple le fichier llama-2-7b.Q2_K.gguf pour TheBloke/Llama-2-7B-GGUF , vous pouvez exécuter Llafile comme suit:
cd ~/.cache/lm-studio/models/TheBloke/Llama-2-7B-GGUF
llamafile -m llama-2-7b.Q2_K.gguf
Lorsque vous téléchargez un nouveau modèle avec Olllama, toutes ses métadonnées seront stockées dans un fichier manifeste sous ~/.ollama/models/manifests/registry.ollama.ai/library/ . Le répertoire et le nom de fichier manifeste sont le nom du modèle comme renvoyé par ollama list . Par exemple, pour llama3:latest fichier manifeste sera nommé .ollama/models/manifests/registry.ollama.ai/library/llama3/latest .
Le manifeste mappe chaque fichier lié au modèle (par exemple, poids GGUF, licence, modèle d'invite, etc.) à un digest SHA256. Le digest correspondant à l'élément dont mediaType est application/vnd.ollama.image.model est celui qui fait référence au fichier GGUF du modèle.
Chaque digest SHA256 est également utilisé comme nom de fichier dans le répertoire ~/.ollama/models/blobs (si vous examinez ce répertoire, vous ne verrez que ces noms de fichiers SHA256- *). Cela signifie que vous pouvez dire directement Llafile en passant le digest Sha256 comme nom de fichier modèle. Donc, si par exemple le llama3:latest digest de fichier GGUF est sha256-00e1317cbf74d901080d7100f57580ba8dd8de57203072dc6f668324ba545f29 , vous pouvez exécuter Llafile comme suit:
cd ~/.ollama/models/blobs
llamafile -m sha256-00e1317cbf74d901080d7100f57580ba8dd8de57203072dc6f668324ba545f29
Voici un aperçu succinct des astuces que nous avons utilisées pour créer le format exécutable le plus gras de tous les temps. Le long métrage est que Llafile est un script de shell qui se lance et exécute l'inférence sur les poids intégrés en millisecondes sans avoir besoin d'être copiés ou installés. Ce qui rend cela possible, c'est mmap (). L'exécutable LLAMA.CPP et les poids sont concaténés sur le script shell. Un petit programme de chargeur est ensuite extrait par le script shell, qui mappe l'exécutable en mémoire. L'exécutable llama.cpp ouvre à nouveau le script shell en tant que fichier, et appelle à nouveau mmap () pour tirer les poids en mémoire et les rendre directement accessibles au CPU et au GPU.
L'astuce pour intégrer des poids à l'intérieur des exécutables llama.cpp est de s'assurer que le fichier local est aligné sur une limite de taille de page. De cette façon, en supposant que le fichier zip n'est pas compressé, une fois qu'il est mmap () 'd dans la mémoire, nous pouvons transmettre des pointeurs directement sur des GPU comme Apple Metal, qui nécessitent que les données soient alignées sur la taille de la page. Étant donné qu'aucun outil d'archivage zip existant n'a un drapeau d'alignement, nous avons dû écrire environ 500 lignes de code pour insérer les fichiers zip nous-mêmes. Cependant, une fois sur place, chaque programme ZIP existant devrait être en mesure de les lire, à condition qu'ils prennent en charge ZIP64. Cela rend les poids beaucoup plus facilement accessibles qu'ils ne l'auraient été autrement, si nous avions inventé notre propre format de fichiers pour les fichiers concaténés.
Sur les microprocesseurs Intel et AMD, Llama.cpp passe la plupart de son temps dans le Matmul Quants, qui sont généralement écrits trois fois pour SSSE3, AVX et AVX2. Llafile retire chacune de ces fonctions dans un fichier séparé qui peut être #include ed plusieurs fois, avec des attributs de fonction __attribute__((__target__("arch"))) . Ensuite, une fonction de wrapper est ajoutée qui utilise la fonctionnalité X86_HAVE(FOO) de Cosmopolitan pour l'exécution de l'exécution de l'implémentation appropriée.
Llafile résout la portabilité de l'architecture par Building Llama.cpp deux fois: une fois pour AMD64 et encore pour ARM64. Il les enveloppe ensuite avec un script shell qui a un préfixe MZ. Sur Windows, il fonctionnera en tant que binaire natif. Sur Linux, il extrait un petit exécutable de 8KB appelé APE Loader à ${TMPDIR:-${HOME:-.}}/.ape qui mappera les parties binaires du script shell en mémoire. Il est possible d'éviter ce processus en exécutant le programme assimilate qui vient inclus avec le compilateur cosmocc . Ce que fait le programme assimilate , c'est transformer l'exécutable de script shell en format exécutable natif de la plate-forme hôte. Cela garantit qu'un chemin de secours existe pour les processus de libération traditionnels lorsqu'il est nécessaire.
Cosmopolitan LIBC utilise des liens statiques, car c'est le seul moyen d'obtenir le même exécutable pour fonctionner sur six OS. Cela présente un défi pour llama.cpp, car il n'est pas possible de lier statiquement le support GPU. La façon dont nous résolvons cela consiste en vérifiant si un compilateur est installé sur le système hôte. Pour Apple, ce serait Xcode, et pour d'autres plates-formes, ce serait nvcc . llama.cpp a une implémentation de fichiers unique de chaque module GPU, nommé ggml-metal.m (objectif c) et ggml-cuda.cu (nvidia c). Llafile intégre ces fichiers source dans les archives ZIP et demande au compilateur de plate-forme de les construire à l'exécution, ciblant la microarchitecture GPU native. Si cela fonctionne, il est lié à l'implémentation de la bibliothèque de la plate-forme C DLOpen (). Voir Llafile / Cuda.c et Llafile / Metal.C.
Afin d'utiliser la fonction DLOpen () spécifique à la plate-forme, nous devons demander au compilateur spécifique à la plate-forme pour créer un petit exécutable qui expose ces interfaces. Sur les plates-formes ELF, Cosmopolitan LIBC cartose cet exécutable d'assistance en mémoire avec l'interprète ELF de la plate-forme. La bibliothèque de la plate-forme C s'occupe ensuite de relier toutes les bibliothèques GPU, puis exécute le programme d'aide à laquelle LongJMP () est de retour dans Cosmopolitan. Le programme exécutable est désormais dans un état hybride étrange où deux bibliothèques C distinctes existent qui ont des ABI différents. Par exemple, le stockage local de thread fonctionne différemment sur chaque système d'exploitation, et les programmes se bloqueront si le registre TLS ne pointe pas vers la mémoire appropriée. La façon dont Cosmopolitan LIBC résout que sur AMD consiste à utiliser SSE pour recompiler l'exécutable au moment de l'exécution pour modifier les accès de registre %fs en %gs ce qui prend une milliseconde. Sur ARM, COSMO utilise le registre x28 pour TLS qui peut être mis en sécurité en passant le drapeau -ffixed-x28 lors de la compilation des modules GPU. Enfin, Llafile utilise l'attribut __ms_abi__ afin que les pointeurs de fonction passaient entre les modules d'application et GPU se conforment à la convention d'appel Windows. Étonnamment, chaque compilateur que nous avons testé, y compris NVCC sur Linux et même Objective-C sur macOS, tous les fonctions de style Win32 de compilation de support, garantissant ainsi que votre llafile pourra parler aux pilotes de Windows, lorsqu'il est exécuté sur Windows, sans avoir besoin d'être Recompilé en tant que fichier séparé pour Windows. Voir cosmopolitan / dlopen.c pour plus de détails.
L'exemple que Llafiles fourni ci-dessus ne doit pas être interprété comme des avenants ou des recommandations de modèles, de licences ou d'ensembles de données spécifiques de la partie de Mozilla.
Llafile ajoute Gled () et SecComp Boxing à Llama.cpp. Ceci est activé par défaut. Il peut être désactivé en passant le drapeau --unsecure . Le sandboxing est actuellement pris en charge uniquement sur Linux et OpenBSD sur des systèmes sans GPU; Sur d'autres plateformes, il enregistrera simplement un avertissement.
Notre approche de la sécurité présente ces avantages:
Après son démarrage, votre serveur HTTP ne peut pas du tout accéder au système de fichiers. C'est bien, car cela signifie que si quelqu'un découvre un bogue sur le serveur lama.cpp, il est beaucoup moins probable qu'ils pourront accéder à des informations sensibles sur votre machine ou apporter des modifications à sa configuration. Sur Linux, nous sommes en mesure de sandbox les choses encore plus loin; Le seul système lié au réseautage appelle le serveur HTTP autorisé à utiliser après le démarrage, est accepter (). Cela limite davantage la capacité d'un attaquant à exfiltrer des informations, dans le cas où votre serveur HTTP est compromis.
La commande CLI principale ne pourra pas du tout accéder au réseau. Ceci est appliqué par le noyau du système d'exploitation. Il ne pourra pas non plus écrire dans le système de fichiers. Cela protège votre ordinateur dans le cas où un bogue est jamais découvert dans le format de fichier GGUF qui permet à un attaquant de créer des fichiers de poids malveillants et de les publier en ligne. La seule exception à cette règle est si vous passez l'indicateur --prompt-cache sans spécifier --prompt-cache-ro . Dans ce cas, la sécurité doit actuellement être affaiblie pour permettre l'accès cpath et wpath , mais l'accès au réseau restera interdit.
Par conséquent, votre llafile est capable de se protéger contre le monde extérieur, mais cela ne signifie pas que vous êtes protégé contre Llafile. Le sable est auto-imposé. Si vous avez obtenu votre llafile à partir d'une source non fiable, son auteur aurait simplement pu le modifier pour ne pas le faire. Dans ce cas, vous pouvez exécuter le llafile non fiable dans un autre bac à sable, comme une machine virtuelle, pour vous assurer qu'elle se comporte comme vous vous attendez.
Bien que le projet Llafile soit autorisé par Apache 2.0, nos modifications à Llama.cpp sont concédées sous licence MIT (tout comme le projet LLAMA.CPP lui-même) de manière à rester compatibles et amorpables à l'avenir, si celle-ci est souhaitée.
Le logo de Llafile sur cette page a été généré avec l'aide de Dall · E 3.
