llamafile
v0.8.16
![[Dibujo de línea de Llama Animal Head frente a la carpeta Manilla ligeramente abierta llena de archivos]](https://images.downcodes.com/uploads/20250201/img_679da0f223c0730.png)
LlamaFile le permite distribuir y ejecutar LLM con un solo archivo. (Publicación de blog de anuncios)
Nuestro objetivo es hacer que Open LLM sea mucho más accesible tanto para los desarrolladores como para los usuarios finales. Estamos haciendo eso combinando Llama.cpp con Cosmopolitan LBC en un marco que colapsa toda la complejidad de los LLM a un ejecutable de una sola archivo (llamado "llamaFile") que se ejecuta localmente en la mayoría de las computadoras, sin instalación.
LlamaFile es un proyecto de constructores de Mozilla.
La forma más fácil de probarlo por ti mismo es descargar nuestro ejemplo de LlamaFile para el modelo LLAVA (Licencia: Llama 2, OpenAI). Llava es un nuevo LLM que puede hacer más que chatear; También puede cargar imágenes y hacerle preguntas sobre ellas. Con LlamaFile, todo esto sucede localmente; Ningún datos deja su computadora.
Descargar Llava-V1.5-7b-Q4.LlamaFile (4.29 GB).
Abra la terminal de su computadora.
Si está utilizando MacOS, Linux o BSD, deberá otorgar permiso para que su computadora ejecute este nuevo archivo. (Solo necesitas hacer esto una vez).
chmod +x llava-v1.5-7b-q4.llamafileSi está en Windows, cambie el nombre del archivo agregando ".exe" al final.
Dirige el LlamaFile. p.ej:
./llava-v1.5-7b-q4.llamafileSu navegador debe abrirse automáticamente y mostrar una interfaz de chat. (Si no es así, solo abra su navegador y apírtelo en http: // localhost: 8080)
Cuando haya terminado de chatear, regrese a su terminal y presione Control-C para apagar llamaFile.
¿Tiene problemas? Vea la sección "Gotchas" a continuación.
Cuando se inicia LlamaFile, además de alojar un servidor de chat de interfaz de usuario web en http://127.0.0.1:8080/, también se proporciona un punto final de finalización de chat compatible con API OpenAI. Está diseñado para admitir los casos de uso de API de Operai más comunes, de una manera que se ejecuta completamente localmente. También lo hemos extendido para incluir características específicas de Llama.CPP (por ejemplo, Mirostat) que también se pueden usar. Para obtener más detalles sobre qué campos y puntos finales están disponibles, consulte tanto la documentación de OpenAI como el readMe del servidor LLAMAFILE.
La forma más simple de comenzar a usar la API es copiar y pegar el siguiente comando Curl en su 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 respuesta que está impresa debería parecer la siguiente:
{
"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 ya ha desarrollado su software utilizando el paquete openai Python (que es publicado por OpenAI), entonces debería poder transferir su aplicación para hablar con llamaFile, realizando algunos cambios en base_url y api_key . Este ejemplo supone que ha ejecutado pip3 install openai para instalar el software cliente de OpenAI, que es requerido por este ejemplo. Su paquete es solo un simple envoltorio de Python alrededor de la interfaz API de OpenAI, que cualquier servidor puede implementar.
#!/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 )El código anterior devolverá un 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 )También proporcionamos Ejemplo LlamaFiles para otros modelos, por lo que puede probar fácilmente LlamaFile con diferentes tipos de LLM.
| Modelo | Tamaño | Licencia | llama | Otros Quants |
|---|---|---|---|---|
| Llama 3.2 3B instruir | 2.62 GB | Llama 3.2 | Llama-3.2-3b-instruct.q6_k.llamaFile | Ver repositorio de HF |
| Llama 3.2 1b instruir | 1.11 GB | Llama 3.2 | Llama-3.2-1b-instruct.q6_k.llamaFile | Ver repositorio de HF |
| Gemma 2 2b instrucciones | 2.32 GB | Gemma 2 | gemma-2-2b-it.q6_k.llamafile | Ver repositorio de HF |
| Gemma 2 9B instructa | 7.76 GB | Gemma 2 | gemma-2-9b-it.q6_k.llamafile | Ver repositorio de HF |
| Gemma 2 27b instructa | 22.5 GB | Gemma 2 | gemma-2-27b-it.q6_k.llamafile | Ver repositorio de HF |
| Llava 1.5 | 3.97 GB | Llama 2 | llava-v1.5-7b-q4.llamaFile | Ver repositorio de HF |
| Tinyllama-1.1b | 2.05 GB | Apache 2.0 | Tinyllama-1.1b-chat-v1.0.f16.llamafile | Ver repositorio de HF |
| Mistral-7B-Instructo | 3.85 GB | Apache 2.0 | Mistral-7B-InNSTRUCT-V0.2.Q4_0.LLAMAFILE | Ver repositorio de HF |
| Phi-3-mini-4K-Instructo | 7.67 GB | Apache 2.0 | Phi-3-mini-4k-instruct.f16.llamaFile | Ver repositorio de HF |
| Mixtral-8x7b-inscucts | 30.03 GB | Apache 2.0 | mixtral-8x7b-instruct-v0.1.q5_k_m.llamafile | Ver repositorio de HF |
| WizardCoder-Python-34b | 22.23 GB | Llama 2 | wizardcoder-python-34b-v1.0.q5_k_m.llamafile | Ver repositorio de HF |
| WizardCoder-Python-13b | 7.33 GB | Llama 2 | wizardcoder-python-13b.llamaFile | Ver repositorio de HF |
| LLAMA-3-INSTRUCT-70B | 37.25 GB | Llama3 | Meta-llama-3-70b-insucta.Q4_0.llamaFile | Ver repositorio de HF |
| LLAMA-3-INSTRUST-8B | 5.37 GB | Llama3 | Meta-llama-3-8b-instruct.q5_k_m.llamafile | Ver repositorio de HF |
| Cohete-3b | 1.89 GB | CC-BY-SA-4.0 | Rocket-3B.Q5_K_M.LlAMAFILE | Ver repositorio de HF |
| Olmo-7b | 5.68 GB | Apache 2.0 | Olmo-7b-0424.q6_k.llamafile | Ver repositorio de HF |
| Modelos de incrustación de texto | ||||
| E5-Mistral-7B-Instructo | 5.16 GB | MIT | E5-MISTRAL-7B-INSTRUCT-Q5_K_M.LLAMAFILE | Ver repositorio de HF |
| mxbai-embbed-large-v1 | 0.7 GB | Apache 2.0 | mxbai-embbed-large-v1-f16.llamaFile | Ver repositorio de HF |
Aquí hay un ejemplo para la línea de comandos Mistral LlamaFile:
./mistral-7b-instruct-v0.2.Q5_K_M.llamafile --temp 0.7 -p ' [INST]Write a story about llamas[/INST] 'Y aquí hay un ejemplo para WizardCoder-Python Command-Line LlamaFile:
./wizardcoder-python-13b.llamafile --temp 0 -e -r ' ```n ' -p ' ```cnvoid *memcpy_sse2(char *dst, const char *src, size_t size) {n 'Y aquí hay un ejemplo para la línea de comandos de 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, los usuarios de MacOS, Linux y BSD deberán usar el comando "CHMOD" para otorgar permisos de ejecución al archivo antes de ejecutar estos LLAMAFILES por primera vez.
Desafortunadamente, los usuarios de Windows no pueden utilizar muchos de estos ejemplos de LlamaFiles porque Windows tiene un tamaño de archivo ejecutable máximo de 4GB, y todos estos ejemplos exceden ese tamaño. (El Llava LlamaFile funciona en Windows porque está a 30 MB del límite del tamaño). Pero no se pierda el corazón: LlamaFile le permite usar pesas externas; Esto se describe más adelante en este documento.
¿Tiene problemas? Vea la sección "Gotchas" a continuación.
A LlamaFile es un LLM ejecutable que puede ejecutar en su propia computadora. Contiene los pesos para un LLM abierto dado, así como todo lo necesario para ejecutar ese modelo en su computadora. No hay nada que instalar o configurar (con algunas advertencias, discutidas en secciones posteriores de este documento).
Todo esto se logra combinando llama.cpp con cosmopolita libc, que proporciona algunas capacidades útiles:
LlamaFiles puede ejecutarse en múltiples microarquitecturas de CPU. Agregamos el envío de tiempo de ejecución a Llama.cpp que permite que los nuevos sistemas Intel usemos características modernas de CPU sin intercambiar soporte para computadoras más antiguas.
LlamaFiles puede ejecutarse en múltiples arquitecturas de CPU. Lo hacemos concatenando las compilaciones AMD64 y ARM64 con un script de shell que lanza el apropiado. Nuestro formato de archivo es compatible con Win32 y la mayoría de los shells Unix. También puede convertirse fácilmente (ya sea por usted o sus usuarios) al formato de plataforma-nativa, siempre que sea necesario.
LlamaFiles puede ejecutarse en seis sistemas operativos (macOS, Windows, Linux, FreeBSD, OpenBSD y NetBSD). Si realiza sus propios archivos de LLAMA, solo necesitará construir su código una vez, utilizando una cadena de herramientas de estilo Linux. El compilador basado en GCC que proporcionamos es en sí mismo un ejecutable realmente portátil, por lo que puede construir su software para las seis OSE a partir de la comodidad de cualquiera que más prefiera para el desarrollo.
Los pesos para un LLM se pueden incrustar dentro del LlamaFile. Agregamos soporte para PKZIP a la biblioteca GGML. Esto permite que los pesos sin comprimir se mapearan directamente en la memoria, similar a un archivo de autoextraces. Permite que los pesos cuantificados distribuidos en línea se prefijaran con una versión compatible del software LLAMA.CPP, asegurando así que sus comportamientos observados originalmente puedan reproducirse indefinidamente.
Finalmente, con las herramientas incluidas en este proyecto, puede crear sus propios LLAMAFILES, utilizando cualquier peso de modelo compatible que desee. Luego puede distribuir estos LlamaFiles a otras personas, que pueden usarlos fácilmente, independientemente del tipo de computadora que tengan.
A pesar de que nuestro ejemplo de LlamaFiles tiene los pesos incorporados, no tiene que usar LlamaFile de esa manera. En su lugar, puede descargar solo el software LLAMAFILE (sin ningún peso incluido) de nuestra página de versiones. Luego puede usarlo junto con cualquier peso externo que pueda tener a mano. Los pesos externos son particularmente útiles para los usuarios de Windows porque le permiten trabajar alrededor del límite del tamaño del archivo ejecutable de 4GB de Windows.
Para los usuarios de Windows, aquí hay un ejemplo para el 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 Los usuarios de Windows pueden necesitar cambiar ./llamafile.exe a .llamafile.exe al ejecutar el comando anterior.
En cualquier plataforma, si su proceso de LlamaFile se mata inmediatamente, verifique si tiene crowdstrike y luego solicite que se conozca.
En MacOS con Apple Silicon, debe tener herramientas de línea de comandos Xcode instaladas para LLamaFile para poder arrancar.
Si usa ZSH y tiene problemas para ejecutar llamaFile, intente decir sh -c ./llamafile . Esto se debe a un error que se solucionó en ZSH 5.9+. Lo mismo es el caso del subprocess de Python, versiones antiguas de peces, etc.
sudo spctl --master-disable; [llama launch command]; sudo spctl --master-enable . Esto se debe a que --master-disable desactiva la comprobación, por lo que debe volver a encenderlo después de dejar de fumar. En algunos sistemas de Linux, puede obtener errores relacionados con run-detectors o vino. Esto se debe a los registros binfmt_misc . Puede solucionarlo agregando un registro adicional para los usos de formato de archivo APE llamaFile:
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 se mencionó anteriormente, en Windows es posible que deba cambiar el nombre de su LlamaFile agregando .exe al nombre de archivo.
Además, como se mencionó anteriormente, Windows también tiene un límite máximo de tamaño de archivo de 4GB para ejecutables. El ejecutable del servidor LLAVA anterior está a solo 30 MB de ese límite, por lo que funcionará en Windows, pero con modelos más grandes como WizardCoder 13B, debe almacenar los pesos en un archivo separado. Se proporciona un ejemplo arriba; Consulte "Usar LlamaFile con pesos externos".
En WSL, hay muchos posibles Gotchas. Una cosa que ayuda a resolverlos por completo es esto:
[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
Pon eso en /etc/systemd/system/cosmo-binfmt.service .
Luego ejecute sudo systemctl enable cosmo-binfmt .
Otra cosa que ayudó a los usuarios de WSL que experimentan problemas es deshabilitar la función Win32 Interop:
sudo sh -c " echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop " En el caso de obtener un Permission Denied para deshabilitar la interoperación a través de la CLI, se puede deshabilitar permanentemente agregando lo siguiente en /etc/wsl.conf
[interop]
enabled=falseLlamaFile admite los siguientes sistemas operativos, que requieren una instalación mínima de stock:
En Windows, LlamaFile se ejecuta como un ejecutable portátil nativo. En Unix Systems, LlamaFile extrae un pequeño programa de cargadores llamado ape a $TMPDIR/.llamafile o ~/.ape-1.9 que se utiliza para asignar su modelo a la memoria.
[1] Las versiones de Darwin Kernel 15.6+ deberían ser compatibles, pero actualmente no tenemos forma de probar eso.
LlamaFile apoya las siguientes CPU:
Los microprocesadores AMD64 deben tener AVX. De lo contrario, LLamaFile imprimirá un error y se negará a ejecutarse. Esto significa que si tiene una CPU Intel, debe ser Intel Core o más nuevo (alrededor de 2006+), y si tiene una CPU AMD, entonces debe ser K8 o más nuevo (alrededor de 2003+). El soporte para AVX512, AVX2, FMA, F16C y VNNI se habilitan condicionalmente en tiempo de ejecución si tiene una CPU más nueva. Por ejemplo, Zen4 tiene muy buena AVX512 que puede acelerar BF16 LlamaFiles.
Los microprocesadores ARM64 deben tener ARMV8A+. Esto significa que todo, desde Apple Silicon hasta Raspberry Pis de 64 bits funcionará, siempre que sus pesos se ajusten a la memoria.
LlamaFile apoya los siguientes tipos de GPU:
GPU en MacOS ARM64 se admite compilando un pequeño módulo utilizando las herramientas de línea de comandos XCode, que deben instalarse. Este es un costo único que ocurre la primera vez que ejecuta su LlamaFile. El DSO construido por LlamaFile se almacena en $TMPDIR/.llamafile o $HOME/.llamafile . La descarga de GPU está habilitada de forma predeterminada cuando está presente una GPU de metal. Esto se puede deshabilitar pasando -ngl 0 o --gpu disable para obligar a LlamaFile a realizar inferencias de CPU.
Los propietarios de tarjetas gráficas NVIDIA y AMD deben pasar el indicador -ngl 999 para habilitar la máxima descarga. Si están presentes múltiples GPU, el trabajo se dividirá uniformemente entre ellos de forma predeterminada, por lo que puede cargar modelos más grandes. Se pueden romper múltiples soporte de GPU en los sistemas AMD Radeon. Si eso le sucede a usted, use export HIP_VISIBLE_DEVICES=0 que obliga a LlamaFile a usar solo la primera GPU.
Se alienta a los usuarios de Windows a usar nuestros binarios de lanzamiento, ya que contienen DLL prebuiladas para tarjetas gráficas NVIDIA y AMD, que solo dependen del controlador de gráficos que se está instalando. Si LlamaFile detecta que se instalan CUDA SDK de NVIDIA o Rocm HIP SDK de AMD, entonces LlamaFile intentará construir una DLL más rápida que use CUBLAS o ROCBLAS. Para que LlamaFile construya con éxito un módulo CUBLAS, debe ejecutarse en el símbolo del sistema X64 MSVC. Puede usar CUDA a través de WSL habilitando a Nvidia Cuda en WSL y ejecutando sus LlamaFiles dentro de WSL. El uso de WSL tiene el beneficio adicional de permitirle ejecutar llamaFiles mayores de 4 GB en Windows.
En Linux, los usuarios de NVIDIA deberán instalar el SDK CUDA (idealmente usando el instalador de script de Shell) y los usuarios de ROCM deben instalar el SDK de la cadera. Se detectan buscando para ver si nvcc o hipcc están en el camino.
Si tiene una GPU AMD y una GPU NVIDIA en su máquina, entonces es posible que deba calificar cuál desea utilizar, al pasar --gpu amd o --gpu nvidia .
En el caso de que el soporte de GPU no pueda compilarse y vincularse dinámicamente sobre la marcha por cualquier motivo, LlamaFile volverá a la inferencia de la CPU.
Desarrollar en LlamaFile requiere una versión moderna del comando GNU make (llamado gmake en algunos sistemas), sha256sum (de lo contrario, cc se usará para construirlo), wget (o curl ) y unzip disponible en https://cosmo.zip/ pub/cosmos/bin/. Los usuarios de Windows también necesitan shell bash de cosmos.
make -j8
sudo make install PREFIX=/usr/localAquí hay un ejemplo de cómo generar código para una función libc utilizando la interfaz de línea de comandos 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 'Aquí hay un ejemplo similar que en su lugar utiliza pesos de instrucciones Mistral-7B para la composición de la prosa:
llamafile -ngl 9999
-m mistral-7b-instruct-v0.1.Q4_K_M.gguf
-p ' [INST]Write a story about llamas[/INST] 'Aquí hay un ejemplo de cómo LlamaFile puede usarse como un chatbot interactivo que le permite consultar el conocimiento contenido en los datos de capacitación:
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: 'Aquí hay un ejemplo de cómo puede usar llamaFile para resumir las 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/nullAsí es como puede usar LlamaFile para describir una imagen 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 Es posible usar la gramática BNF para hacer cumplir la salida es predecible y seguro de usar en su script de shell. La gramática más simple sería --grammar 'root ::= "yes" | "no"' forzar a la LLM a imprimir solo en la salida estándar, ya sea "yesn" o "non" . Otro ejemplo es si desea escribir un script para cambiar el nombre de todos sus archivos de imagen, podría decir:
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.jpgAquí hay un ejemplo de cómo ejecutar el servidor HTTP incorporado de Llama.CPP. Este ejemplo utiliza Llava V1.5-7b, un LLM multimodal que funciona con el soporte recientemente agregado para entradas de imágenes.
llamafile -ngl 9999
-m llava-v1.5-7b-Q8_0.gguf
--mmproj llava-v1.5-7b-mmproj-Q8_0.gguf
--host 0.0.0.0El comando anterior iniciará una pestaña de navegador en su computadora personal para mostrar una interfaz web. Te permite chatear con tu LLM y cargarte imágenes.
Si quieres poder decir:
./llava.llamafile ... y haga que ejecute el servidor web sin tener que especificar argumentos, luego puede incrustar tanto los pesos como un especial .args en el interior, lo que especifica los argumentos predeterminados. Primero, creemos un archivo llamado .args que tiene este contenido:
-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 anteriormente, hay un argumento por línea. El argumento ... opcionalmente especifica dónde se insertarán cualquier argumento de CLI adicional aprobado por el usuario. A continuación, agregaremos los pesos y el archivo de argumentos al ejecutable:
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.llamafileFelicidades. Acaba de hacer su propio ejecutable LLM que es fácil de compartir con sus amigos.
Una buena manera de compartir un LlamaFile con tus amigos es publicarlo en la cara abrazada. Si hace eso, se recomienda que mencione en su mensaje de abrazo de abrazo de abrazo, qué revisión Git o versión lanzada de LlamaFile que usó al construir su LlamaFile. De esa manera, todos en línea podrán verificar la procedencia de su contenido ejecutable. Si ha realizado cambios en Llama.cpp o Cosmopolitan Source Code, entonces la licencia Apache 2.0 requiere que explique qué cambió. Una forma en que puede hacerlo es incrustando un aviso en su LlamaFile usando zipalign que describe los cambios y lo mencione en su abrazo de abrazo.
Hay una página manual para cada uno de los programas de LlamaFile instalados cuando ejecuta sudo make install . Los manuales de comandos también están compuestos como archivos PDF que puede descargar desde nuestra página de lanzamientos de GitHub. Por último, la mayoría de los comandos mostrarán esa información al pasar el indicador --help .
Esta sección responde a la pregunta "Ya tengo un modelo descargado localmente por aplicación x, ¿puedo usarlo con llamaFile?" . La respuesta general es "Sí, siempre y cuando esos modelos se almacenen localmente en formato GGUF", pero su implementación puede ser más o menos hacky dependiendo de la aplicación. Siguen algunos ejemplos (probados en una Mac).
LM Studio almacena modelos descargados en ~/.cache/lm-studio/models , en subdirectorios con el mismo nombre de los modelos (siguiendo el formato de account_name/model_name ), con el mismo nombre de archivo que vio cuando eligió descargar el archivo.
Entonces, si ha descargado, por ejemplo, el archivo llama-2-7b.Q2_K.gguf para TheBloke/Llama-2-7B-GGUF , puede ejecutar llamaFile de la siguiente manera:
cd ~/.cache/lm-studio/models/TheBloke/Llama-2-7B-GGUF
llamafile -m llama-2-7b.Q2_K.gguf
Cuando descargue un nuevo modelo con Ollama, todos sus metadatos se almacenarán en un archivo manifiesto en ~/.ollama/models/manifests/registry.ollama.ai/library/ . El nombre de directorio y el nombre de archivo manifiesto son el nombre del modelo devuelto por ollama list . Por ejemplo, para llama3:latest archivo manifiesto se nombrará .ollama/models/manifests/registry.ollama.ai/library/llama3/latest .
El manifiesto asigna cada archivo relacionado con el modelo (por ejemplo, pesos GGGUF, licencia, plantilla de inmediato, etc.) a un resumen SHA256. El resumen correspondiente al elemento cuyo mediaType es application/vnd.ollama.image.model es el que se refiere al archivo GGUF del modelo.
Cada resumen de SHA256 también se usa como nombre de archivo en el directorio ~/.ollama/models/blobs (si observa ese directorio, solo verá esos nombres de archivo SHA256-*). Esto significa que puede ejecutar directamente llamaFile pasando el digest de SHA256 como nombre de archivo modelo. Entonces, si EG el llama3:latest digest de archivos GGUF es sha256-00e1317cbf74d901080d7100f57580ba8dd8de57203072dc6f668324ba545f29 , puede ejecutar LlamaFile como sigue:
cd ~/.ollama/models/blobs
llamafile -m sha256-00e1317cbf74d901080d7100f57580ba8dd8de57203072dc6f668324ba545f29
Aquí hay una descripción general de los trucos que usamos para crear el formato ejecutable más gordo de la historia. The Long Story Short es LlamaFile es un script de shell que se lanza y ejecuta inferencia sobre pesas incrustadas en milisegundos sin necesidad de ser copiados o instalados. Lo que hace que eso sea posible es mmap (). Tanto el ejecutable LLAMA.CPP como los pesos se concatenan en el script de shell. Luego, el script de shell extrae un pequeño programa de cargadores, que mapea el ejecutable en la memoria. El ejecutable Llama.cpp abre el script de shell nuevamente como un archivo, y llama a MMAP () nuevamente para atraer los pesos a la memoria y hacerlos directamente accesibles para la CPU y la GPU.
El truco para incorporar pesas dentro de Llama.cpp Ejecutables es asegurarse de que el archivo local esté alineado en un límite de tamaño de página. De esa manera, suponiendo que el archivo zip no esté comprimido, una vez que está mmap () 'd en la memoria, podemos pasar punteros directamente a GPU como Apple Metal, lo que requiere que los datos estén alineados. Dado que ninguna herramienta de archivo ZIP existente tiene un indicador de alineación, tuvimos que escribir alrededor de 500 líneas de código para insertar los archivos ZIP nosotros mismos. Sin embargo, una vez allí, cada programa ZIP existente debería poder leerlos, siempre que admitan ZIP64. Esto hace que los pesos sean mucho más fáciles de lo que hubieran sido, si hubiéramos inventado nuestro propio formato de archivo para archivos concatenados.
En los microprocesadores Intel y AMD, Llama.cpp pasa la mayor parte de su tiempo en los Matmul Quants, que generalmente se escriben tres veces para SSSE3, AVX y AVX2. LlamaFile saca cada una de estas funciones en un archivo separado que puede ser #include varias veces, con variables atributos de la función __attribute__((__target__("arch"))) . Luego, se agrega una función de envoltorio que utiliza la función X86_HAVE(FOO) de Cosmopolitan para el envío de tiempo de ejecución a la implementación adecuada.
LlamaFile resuelve la portabilidad de la arquitectura mediante la construcción de Llama.cpp dos veces: una vez para AMD64 y otra para ARM64. Luego los envuelve con un script de shell que tiene un prefijo MZ. En Windows, se ejecutará como un binario nativo. En Linux, extraerá un pequeño ejecutable de 8 kb llamado APE Loader a ${TMPDIR:-${HOME:-.}}/.ape que asignará las porciones binarias del script de shell en la memoria. Es posible evitar este proceso ejecutando el programa assimilate que viene incluido con el compilador cosmocc . Lo que hace el programa assimilate es convertir el ejecutable de script Shell en el formato ejecutable nativo de la plataforma host. Esto garantiza que exista un camino de respuesta para los procesos de lanzamiento tradicionales cuando es necesario.
Cosmopolitan LBC utiliza la vinculación estática, ya que esa es la única forma de obtener el mismo ejecutable para ejecutarse con seis OSE. Esto presenta un desafío para llama.cpp, porque no es posible vincular estáticamente el soporte de GPU. La forma en que resolvemos eso es verificar si se instala un compilador en el sistema de host. Para Apple, eso sería Xcode, y para otras plataformas, eso sería nvcc . Llama.cpp tiene una implementación de un solo archivo de cada módulo GPU, llamado ggml-metal.m (Objetivo C) y ggml-cuda.cu (NVIDIA C). LlamaFile incorpora esos archivos fuente dentro del archivo ZIP y le pide al compilador de la plataforma que los cree en tiempo de ejecución, apuntando a la microarquitectura de GPU nativa. Si funciona, entonces está vinculado con la implementación de la biblioteca de la plataforma C dlopen (). Ver LLAMAFILE/CUDA.C Y LLAMAFILE/METAL.C.
Para usar la función Dlopen () específica de la plataforma, debemos pedirle al compilador específico de la plataforma que cree un pequeño ejecutable que exponga estas interfaces. En las plataformas ELF, Cosmopolitan LBC mapea este ejecutable auxiliar en la memoria junto con el intérprete ELF de la plataforma. La biblioteca de la plataforma C se encarga de vincular todas las bibliotecas de la GPU, y luego ejecuta el programa Helper que LongJMP () está de vuelta en Cosmopolitan. El programa ejecutable ahora se encuentra en un extraño estado híbrido donde existen dos bibliotecas C separadas que tienen ABI diferentes. Por ejemplo, el almacenamiento local de Thread funciona de manera diferente en cada sistema operativo, y los programas se bloquearán si el registro TLS no apunta a la memoria apropiada. La forma en que Cosmopolitan LABC resuelve que en AMD es mediante el uso de SSE para recompilar el ejecutable en tiempo de ejecución para cambiar %fs de los accesos de registro en %gs lo que lleva un milisegundo. En el brazo, Cosmo usa el registro x28 para TLS que se puede hacer seguro al pasar la bandera -ffixed-x28 al compilar módulos GPU. Por último, LlamaFile utiliza el atributo __ms_abi__ para que los punteros de la función pasen entre la aplicación y los módulos de GPU se ajusten a la convención de llamadas de Windows. Sorprendentemente, cada compilador que probamos, incluido NVCC en Linux e incluso Objective-C en MacOS, todos admiten compilar funciones de estilo Win32, asegurando así que su LlamaFile pueda hablar con los controladores de Windows, cuando se ejecuta en Windows, sin necesidad de ser Recompilado como un archivo separado para Windows. Ver Cosmopolitan/Dlopen.c para más detalles.
El ejemplo de LlamaFiles proporcionados anteriormente no debe interpretarse como endosos o recomendaciones de modelos, licencias o conjuntos de datos específicos por parte de Mozilla.
LlamaFile agrega compromiso () y seccomp sandboxing a llama.cpp. Esto está habilitado de forma predeterminada. Se puede apagar pasando la bandera --unsecure . Sandboxing actualmente solo es compatible con Linux y OpenBSD en sistemas sin GPU; En otras plataformas, simplemente registrará una advertencia.
Nuestro enfoque de seguridad tiene estos beneficios:
Después de que se inicia, su servidor HTTP no puede acceder al sistema de archivos. Esto es bueno, ya que significa que si alguien descubre un error en el servidor Llama.cpp, entonces es mucho menos probable que puedan acceder a información confidencial en su máquina o hacer cambios en su configuración. En Linux, podemos sandbox cosas aún más; El único sistema relacionado con la red llame al servidor HTTP permitirá usar después de iniciar, es aceptar (). Eso limita aún más la capacidad de un atacante para exfiltrar la información, en el caso de que su servidor HTTP se vea comprometido.
El comando CLI principal no podrá acceder a la red en absoluto. Esto se aplica por el núcleo del sistema operativo. Tampoco podrá escribir en el sistema de archivos. Esto mantiene su computadora segura en caso de que se descubra un error en el formato de archivo GGUF que permite a un atacante crear archivos de pesas maliciosas y publicarlos en línea. La única excepción a esta regla es si pasa el indicador --prompt-cache sin especificar también --prompt-cache-ro . En ese caso, la seguridad actualmente debe debilitarse para permitir el acceso cpath y wpath , pero el acceso a la red seguirá siendo prohibido.
Por lo tanto, su LlamaFile puede protegerse contra el mundo exterior, pero eso no significa que esté protegido de LlamaFile. El sandboxing es autoimpuesto. Si obtuvo su LlamaFile de una fuente no confiable, entonces su autor podría haberlo modificado para no hacer eso. En ese caso, puede ejecutar el LlamaFile no confiable dentro de otro sandbox, como una máquina virtual, para asegurarse de que se comporte cómo espere.
Si bien el proyecto LlamaFile tiene una licencia de Apache 2.0, nuestros cambios en Llama.cpp tienen licencia bajo MIT (al igual que el proyecto LLAMA.CPP en sí) para permanecer compatibles y aguas arriba en el futuro, si eso se desee.
El logotipo de LlamaFile en esta página se generó con la ayuda de Dall · E 3.
