Uso de Llamafiles para simplificar la ejecución de LLM

Introducción

Ejecutar modelos de lenguaje grandes siempre ha sido un proceso tedioso. Hay que descargar un conjunto de software de terceros para cargar estos LLM o descargar Python y crear un entorno descargando muchas bibliotecas Pytorch y HuggingFace. Si se utiliza el enfoque Pythonic, hay que pasar por el proceso de escribir código para descargar y ejecutar el modelo. Esta guía analizará un enfoque más sencillo para ejecutar estos LLM.

OBJETIVOS DE APRENDIZAJE

• Comprender los desafíos de la ejecución tradicional de un LLM
• Capta el concepto innovador de Llamafiles
• Aprenda a descargar y ejecutar sus propios ejecutables de Llamafile con facilidad
• Aprender a crear Llamfiles a partir de LLM cuantificados
• Identificar las limitaciones de este enfoque.

Este artículo fue publicado como parte del Blogatón de ciencia de datos.

Problemas con modelos de lenguaje grandes

Los Large Language Models (LLM) han revolucionado la forma en que interactuamos con las computadoras, generando texto, traduciendo idiomas, escribiendo diferentes tipos de contenido creativo e incluso respondiendo sus preguntas de manera informativa. Sin embargo, ejecutar estos potentes modelos en su computadora a menudo ha sido un desafío.

Para ejecutar los LLM, tenemos que descargar Python y muchas dependencias de IA y, además, incluso tenemos que escribir código para descargarlos y ejecutarlos. Incluso cuando se instalan las IU listas para usar para modelos de lenguajes grandes, se requieren muchas configuraciones, que pueden salir mal fácilmente. Instalarlos y ejecutarlos como un ejecutable no ha sido un proceso sencillo.

¿Qué son los Llamafiles?

Los Llamafiles se crean para funcionar fácilmente con modelos populares de lenguajes grandes de código abierto. Estos son ejecutables de un solo archivo. Es como descargar un LLM y ejecutarlo como un ejecutable. No es necesaria una instalación inicial de bibliotecas. Todo esto fue posible gracias a llama.cpp y cosmopolitan libc, que hace que los LLM se ejecuten en diferentes sistemas operativos.

Llama.cpp fue desarrollado por Georgi Gerganov para ejecutar modelos de lenguaje grandes en formato cuantificado para que puedan ejecutarse en una CPU. llama.cpp es una biblioteca C que nos permite ejecutar LLM cuantificados en hardware de consumo. Por otro lado, la cosmopolita libc es otra biblioteca C que crea un binario que puede ejecutarse en cualquier sistema operativo (Windows, Mac, Ubuntu) sin necesidad de un intérprete. Entonces, Llamafile se construye sobre estas bibliotecas, lo que le permite crear LLM ejecutables de un solo archivo.

Los modelos disponibles están en formato cuantificado GGUF. GGUF es un formato de archivo para modelos de lenguaje grandes desarrollado por Georgi Gerganov, el creador de llama.cpp. GGUF es un formato para almacenar, compartir y cargar modelos de lenguaje grandes de manera efectiva y eficiente en CPU y GPU. El GGUF utiliza una técnica de cuantificación para comprimir los modelos desde su punto flotante original de 16 bits a un formato entero de 4 u 8 bits. Los pesos de este modelo cuantificado se pueden almacenar en este formato GGUF.

Esto simplifica la ejecución de modelos de 7 mil millones de parámetros en una computadora con 16 GB de VRAM. Podemos ejecutar los modelos de lenguajes grandes sin necesidad de una GPU (aunque Llamafile incluso nos permite ejecutar los LLM en una GPU). En este momento, los archivos llama de modelos populares de lenguajes grandes de código abierto como LlaVa, Mistral y WizardCoder están disponibles para descargar y ejecutar.

Ejecutables de un solo disparo

En esta sección, descargaremos e intentaremos ejecutar un archivo LlaVa Llama multimodal. Aquí, no trabajaremos con GPU y ejecutaremos el modelo en la CPU. Vaya al repositorio oficial de Llamafile GitHub haciendo clic esta página y descargando el Modelo LlaVa 1.5.

Descarga el Modelo

La imagen de arriba muestra todos los modelos disponibles con sus nombres, tamaños y enlaces de descarga. El LlaVa 1.5 tiene alrededor de 4 GB y es un potente multimodelo que puede comprender imágenes. El modelo descargado es un modelo de 7 mil millones de parámetros cuantificado en 4 bits. Después de descargar el modelo, vaya a la carpeta donde lo descargó.

Luego abra el CMD, navegue hasta la carpeta donde se descarga este modelo, escriba el nombre del archivo que descargamos y presione Entrar.

llava-v1.5-7b-q4.llamafile

Para usuarios de Mac y Linux

Para Mac y Linux, de forma predeterminada, el permiso de ejecución para este archivo está desactivado. Por lo tanto, debemos proporcionar permiso de ejecución para el archivo llama, lo cual podemos hacer ejecutando el siguiente comando.

chmod +x llava-v1.5-7b-q4.llamafile

Esto es para activar el permiso de ejecución para el archivo llama-v1.5-7b-q4.llama. Además, agregue “./” antes del nombre del archivo para ejecutar el archivo en Mac y Linux. Después de presionar la palabra clave Enter, el modelo se enviará a la RAM del sistema y mostrará el siguiente resultado.

Luego aparecerá el navegador y el modelo se ejecutará en la URL http://127.0.0.1:8080/

La imagen de arriba muestra el mensaje predeterminado, el nombre de usuario, el nombre de LLM, la plantilla de mensaje y la plantilla de historial de chat. Estos se pueden configurar, pero por ahora usaremos los valores predeterminados.

A continuación, incluso podemos verificar los hiperparámetros LLM configurables como Top P, Top K, Temperatura y otros. Incluso estos, los dejaremos predeterminados por ahora. Ahora escribamos algo y hagamos clic en enviar.

En la imagen de arriba, podemos ver que escribimos un mensaje e incluso recibimos una respuesta. Debajo de eso, podemos verificar que estamos obteniendo alrededor de 6 tokens por segundo, lo cual es un buen token/segundo considerando que lo estamos ejecutando completamente en la CPU. Esta vez, intentémoslo con una imagen.

Aunque no es 100% correcto, el modelo casi podría obtener la mayoría de las cosas correctamente desde la imagen. Ahora tengamos una conversación de varios turnos con el LlaVa para probar si recuerda el historial de chat.

En la imagen de arriba, podemos ver que LlaVa LLM pudo mantener bien la conversación. Podría tomar la conversación histórica y luego generar las respuestas. Aunque la última respuesta generada no es del todo cierta, reunió la conversación anterior para generarla. De esta manera, podemos descargar un archivo llama y simplemente ejecutarlo como software y trabajar con esos modelos descargados.

Creando archivos Llama

Hemos visto una demostración de Llamafile que ya estaba presente en el GitHub oficial. Muchas veces no queremos trabajar con estos modelos. En su lugar, deseamos crear ejecutables de un solo archivo de nuestros modelos de lenguajes grandes. En esta sección, analizaremos el proceso de creación de ejecutables de un solo archivo, es decir, archivos llama a partir de LLM cuantificados.

Seleccione un LLM

Primero comenzaremos seleccionando un modelo de lenguaje grande. Para esta demostración, seleccionaremos una versión cuantificada de TinyLlama. Aquí descargaremos el modelo GGUF cuantificado de 8 bits de TinyLlama (puede hacer clic en esta página para ir a HuggingFace y descargar el modelo)

Descargue el último archivo Llama

Se puede descargar el último zip de llamafile desde el enlace oficial de GitHub. Además, descargue el zip y extraiga el archivo zip. La versión actual de este artículo es llama file-0.6. Después de la extracción de la llama, la carpeta bin con la carpeta de archivos contendrá los archivos como se muestra en la imagen a continuación.

Ahora mueva el modelo cuantificado de 8 bits de TinyLlama descargado a esta carpeta bin. Para crear los ejecutables de un solo archivo, necesitamos crear un archivo .args en la carpeta bin de llamafile. A este archivo, debemos agregar el siguiente contenido:

-m
tinyllama-1.1b-chat-v0.3.Q8_0.gguf
--host
0.0.0.0
...

• La primera línea indica el indicador -m. Esto le dice al llamafile que estamos cargando los pesos de un modelo.
• En la segunda línea, especificamos el nombre del modelo que hemos descargado, que está presente en el mismo directorio en el que está el archivo .args, es decir, la carpeta bin del llamafile.
• En la tercera línea, agregamos el indicador de host, lo que indica que ejecutamos el archivo ejecutable y queremos alojarlo en un servidor web.
• Finalmente, en la última línea, mencionamos la dirección donde queremos alojar, que se asigna a localhost. Seguidos de esto están los tres puntos, que especifican que podemos pasar argumentos a nuestro llamafile una vez creado.
• Agregue estas líneas al archivo .args y guárdelo.

Para usuarios de Windows

Ahora, el siguiente paso es para los usuarios de Windows. Si trabajábamos en Windows, necesitábamos tener instalado Linux a través de WSL. Si no, haga clic esta página para seguir los pasos de instalación de Linux a través de WSL. En Mac y Linux, no se requieren pasos adicionales. Ahora abra la carpeta bin de la carpeta llamafile en la terminal (si trabaja en Windows, abra este directorio en WSL) y escriba los siguientes comandos.

cp llamafile tinyllama-1.1b-chat-v0.3.Q8_0.llamafile

Aquí, estamos creando un nuevo archivo llamado tinyllama-1.1b-chat-v0.3.Q3_0.llamafile; es decir, estamos creando un archivo con la extensión .llamafile y moviendo el archivo llamafile a este nuevo archivo. Ahora, después de esto, escribiremos el siguiente comando.

./zipalign -j0 tinyllama-1.1b-chat-v0.3.Q8_0.llamafile tinyllama-1.1b-chat-v0.3.Q8_0.gguf .args

Aquí trabajamos con el archivo zipalign que vino cuando descargamos el zip llamafile de GitHub. Trabajamos con este comando para crear el archivo llama para nuestro TinyLlama cuantificado. A este comando zipalign, le pasamos el archivo tinyllama-1.1b-chat-v0.3.Q8_0.llama que hemos creado en el paso anterior, luego le pasamos el archivo tinyllama-1.1b-chat-v0.3.Q8_0.llama. modelo que tenemos en la carpeta bin y finalmente pasar el archivo .args que hemos creado anteriormente.

Esto finalmente producirá nuestro archivo ejecutable de un solo archivo tinyllama-1.1b-chat-v0.3.Q8_0.llamafile. Para asegurarnos de que estamos en la misma página, la carpeta bin ahora contiene los siguientes archivos.

Ahora podemos ejecutar el archivo tinyllama-1.1b-chat-v0.3.Q8_0.llama de la misma manera que lo hicimos antes. En Windows, incluso puedes cambiar el nombre del archivo .llama a .exe y ejecutarlo haciendo doble clic en él.

Servidor compatible con OpenAI

Esta sección analizará cómo servir LLM a través de Llamfile. Hemos notado que cuando ejecutamos el archivo llama, el navegador se abre y podemos interactuar con LLM a través de la WebUI. Esto es básicamente lo que llamamos alojamiento del modelo de lenguaje grande.

Una vez que ejecutamos Llamafile, podemos interactuar con el LLM respectivo como punto final porque el modelo se sirve en el host local en el PUERTO 8080. El servidor sigue el protocolo API OpenAI, es decir, similar al punto final OpenAI GPT, lo que hace que Es fácil cambiar entre el modelo OpenAI GPT y el LLM que se ejecuta con Llamafile.

Aquí, ejecutaremos el archivo llama TinyLlama creado previamente. Ahora, esto debe ejecutarse en localhost 8080. Ahora lo probaremos a través de la API OpenAI en Python.

from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8080/v1", 
    api_key = "sk-no-key-required"
)
completion = client.chat.completions.create(
    model="TinyLlama",
    messages=[
        {"role": "system", "content": "You are a usefull AI 
        Assistant who helps answering user questions"},
        {"role": "user", "content": "Distance between earth to moon?"}
    ]
)
print(completion.choices[0].message.content)

• Aquí trabajamos con la biblioteca OpenAI. Pero en lugar de especificar el punto final de OpenAI, especificamos la URL donde está alojado nuestro TinyLlama y le damos el “sk-no–se requiere token” para la clave_api
• Luego, el cliente se conectará a nuestro punto final TinyLlama.
• Ahora, de manera similar a como trabajamos con OpenAI, podemos usar el código para chatear con nuestro TinyLlama.
• Para ello trabajamos con el terminaciones clase de OpenAI. Creamos nuevos terminaciones con el .crear() objetar y pasar los detalles como el nombre del modelo y los mensajes.
• Los mensajes tienen forma de lista de diccionarios, donde tenemos el rol, que puede ser sistema, usuario o asistente, y tenemos el contenido.
• Finalmente, podemos recuperar la información generada a través de la declaración impresa anterior.

El resultado de lo anterior se puede ver a continuación.

De esta manera, podemos aprovechar los llamafiles y reemplazar la API OpenAI fácilmente con el llamafile que elegimos ejecutar.

Limitaciones de Llamafiles

Si bien son revolucionarios, los llamafiles aún están en desarrollo. Algunas limitaciones incluyen:

• Selección de modelo limitada: Actualmente, no todos los LLM están disponibles en forma de archivos llama. La selección actual de Llamafiles prediseñados sigue creciendo. Actualmente, Llamafiles están disponibles para Llama 2, LlaVa, Mistral y Wizard Coder.
• Requerimientos de Hardware: Ejecutar LLM, incluso a través de Llamafiles, todavía requiere muchos recursos computacionales. Si bien son más fáciles de ejecutar que los métodos tradicionales, es posible que las computadoras más antiguas o menos potentes necesiten ayuda para ejecutarlos sin problemas.
• Preocupaciones de seguridad: Descargar y ejecutar ejecutables de fuentes no confiables conlleva riesgos inherentes. Entonces debe haber una plataforma confiable donde podamos descargar estos archivos llama.

Llamafiles contra el resto

Antes de Llamafiles, había diferentes formas de ejecutar modelos de lenguaje grandes. Uno fue a través del llama_cpp_python. Esta es la versión Python de llama.cpp que nos permite ejecutar modelos de lenguaje grande cuantificados en hardware de consumo como computadoras portátiles y de escritorio. Pero para ejecutarlo, debemos descargar e instalar Python e incluso bibliotecas de aprendizaje profundo como torch, huggingface, transformadores y muchas más. Y después de eso, implicó escribir muchas líneas de código para ejecutar el modelo.

Incluso entonces, a veces podemos enfrentar problemas debido a problemas de dependencia (es decir, algunas bibliotecas tienen versiones inferiores o superiores a las necesarias). Y también está el Transformadores C Biblioteca que nos permite ejecutar LLM cuantificados. Incluso esto requiere el mismo proceso que hemos comentado para llama_cpp_python.

Y luego, hay Ollama. Ollama ha tenido un gran éxito en la comunidad de IA por su facilidad de uso para cargar y ejecutar modelos de lenguaje grandes, especialmente los cuantificados. Ollama es una especie de TUI (Interfaz de usuario terminal) para LLM. La única diferencia entre Ollama y Llamafile es la capacidad de compartir. Es decir, si quiero, puedo compartir mi archivo model.llama con cualquier persona y ellos pueden ejecutarlo sin descargar ningún software adicional. Pero en el caso de Ollama, necesito compartir el archivo model.gguf, que la otra persona puede ejecutar sólo cuando instala el software de Ollama o mediante las bibliotecas de Python anteriores.

En cuanto a los recursos, todos requieren la misma cantidad de recursos porque todos estos métodos utilizan llama.cpp debajo para ejecutar los modelos cuantificados. Sólo se trata de la facilidad de uso cuando existen diferencias entre estos.

Conclusión

Llamafiles marca un paso crucial hacia adelante para hacer que los LLM sean fácilmente ejecutables. Su facilidad de uso y portabilidad abre un mundo de posibilidades para desarrolladores, investigadores y usuarios ocasionales. Si bien existen limitaciones, el potencial de los llamafiles para democratizar el acceso a los LLM es evidente. Ya sea que sea un desarrollador experto o un novato curioso, Llamafiles abre posibilidades interesantes para explorar el mundo de los LLM. En esta guía, hemos visto cómo descargar Llamafiles e incluso cómo crear nuestros propios Llamafiles con nuestros modelos cuantificados. . Incluso hemos echado un vistazo al servidor compatible con OpenAI que se crea al ejecutar Llamafiles.

Puntos clave

• Los llamafiles son ejecutables de un solo archivo que hacen que la ejecución de modelos de lenguaje grandes (LLM) sea más fácil y esté más disponible.
• Eliminan la necesidad de instalaciones y configuraciones complejas, lo que permite a los usuarios descargar y ejecutar LLM directamente sin requisitos de Python o GPU.
• Los Llamafiles están disponibles en este momento para una selección limitada de LLM de código abierto, incluidos LlaVa, Mistral y WizardCoder.
• Si bien es conveniente, Llamafiles aún tiene limitaciones, como los requisitos de hardware y los problemas de seguridad asociados con la descarga de ejecutables de fuentes no confiables.
• A pesar de estas limitaciones, Llamafiles representa un paso importante hacia la democratización del acceso a LLM para desarrolladores, investigadores e incluso usuarios ocasionales.

Preguntas frecuentes

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

Relacionado:

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://www.analyticsvidhya.com/blog/2024/01/using-llamafiles-to-simplify-llm-execution/