Tutorial de Llama.cpp: Guía completa para la inferencia e implementación eficientes de LLM

Los grandes modelos lingüísticos (LLM) están revolucionando diversos sectores. Desde los chatbots de atención al cliente hasta las sofisticadas herramientas de análisis de datos, las capacidades de esta potente tecnología están remodelando el panorama de la interacción digital y la automatización.

Sin embargo, las aplicaciones prácticas de los LLM pueden verse limitadas por la necesidad de una computación de alta potencia o de tiempos de respuesta rápidos. Estos modelos suelen requerir hardware sofisticado y amplias dependencias, lo que puede dificultar su adopción en entornos más restringidos.

Aquí es donde LLaMa.cpp (o LLaMa C++) viene al rescate, proporcionando una alternativa más ligera y portable a los frameworks pesados.

Llama.cpp logo(fuente)

¿Qué es Llama.cpp?

LLaMa.cpp fue desarrollado por Georgi Gerganov. Implementa la arquitectura LLaMa de Meta en C/C++ eficiente, y es una de las comunidades de código abierto más dinámicas en torno a la inferencia LLM, con más de 390 colaboradores, 43000+ estrellas en el repositorio oficial de GitHub, y 930+ versiones.

Algunas ventajas clave de utilizar LLama.cpp para la inferencia LLM

• Compatibilidad universal: El diseño de Llama.cpp como biblioteca C++ orientada a la CPU se traduce en una menor complejidad y una integración perfecta en otros entornos de programación. Esta amplia compatibilidad aceleró su adopción en diversas plataformas.

• Integración completa de funciones: Llama.cpp, que actúa como repositorio de funciones críticas de bajo nivel, refleja el enfoque de LangChain para las funciones de alto nivel, lo que agiliza el proceso de desarrollo, aunque con posibles problemas de escalabilidad en el futuro.

• Optimización focalizada: Llama.cpp se centra en una arquitectura de modelo único, lo que permite mejoras precisas y eficaces. Su apuesta por los modelos Llama a través de formatos como el GGML y el GGUF ha permitido mejorar sustancialmente la eficiencia.

Con este conocimiento de Llama.cpp, las siguientes secciones de este tutorial recorren el proceso de implementación de un caso de uso de generación de texto. Empezaremos explorando los fundamentos de LLama.cpp, comprendiendo el flujo de trabajo global de principio a fin del proyecto en cuestión y analizando algunas de sus aplicaciones en diferentes industrias.

Llama.cpp Arquitectura

La columna vertebral de Llama.cpp son los modelos originales de Llama, que también se basa en la arquitectura de transformadores. Los autores de Llama aprovecharon varias mejoras que se propusieron posteriormente y utilizaron diferentes modelos como PaLM.

Diferencia entre Transformers y arquitectura Llama (Arquitectura Llama por Umar Jamil)

La principal diferencia entre la arquitectura LLaMa y la de los transformadores:

• Prenormalización (GPT3): se utiliza para mejorar la estabilidad del entrenamiento normalizando la entrada de cada subcapa transformadora utilizando el enfoque RMSNorm, en lugar de normalizar la salida.
• Función de activación SwigGLU (PaLM): la función de activación no lineal original ReLU se sustituye por la función de activación SwiGLU, lo que permite mejorar el rendimiento.
• Incrustaciones rotativas (GPTNeao): las incrustaciones posicionales rotativas (RoPE) se añadieron en cada capa de la red tras eliminar las incrustaciones posicionales absolutas.

Configuración del entorno

Los prerrequisitos para empezar a trabajar con LLama.cpp incluyen:

• Pythonpara poder ejecutar pip, que es el gestor de paquetes de Python
• Llama-cpp-pythonel enlace Python para llama.cpp

Crear el entorno virtual

Se recomienda crear un entorno virtual para evitar cualquier problema relacionado con el proceso de instalación, y conda puede ser un buen candidato para la creación del entorno.

Todos los comandos de esta sección se ejecutan desde un terminal. Utilizando la sentencia conda create, creamos un entorno virtual llamado llama-cpp-env.

conda create --name llama-cpp-env

Después de crear con éxito el entorno virtual, activamos el entorno virtual anterior utilizando la sentencia conda activate, como se indica a continuación de:

conda activate llama-cpp-env

La declaración anterior debería mostrar el nombre de la variable de entorno entre paréntesis al principio del terminal, como se indica a continuación:

Nombre del entorno virtual tras la activación

Ahora, podemos instalar el paquete Llama-cpp-python de la siguiente manera:

pip install llama-cpp-python
or
pip install llama-cpp-python==0.1.48

La ejecución correcta de llama_cpp_script.py significa que la biblioteca está correctamente instalada.

Para asegurarnos de que la instalación se realiza correctamente, vamos a crear y añadir la sentencia import y, a continuación, ejecutar el script.

• En primer lugar, añada la dirección from llama_cpp import Llama al archivo llama_cpp_script.py y, a continuación
• Ejecute el archivo python llama_cpp_script.py. Se produce un error si la biblioteca no se importa; por lo tanto, necesita un diagnóstico adicional para el proceso de instalación.

Comprender los conceptos básicos de Llama.cpp

Llegados a este punto, el proceso de instalación debería haber finalizado con éxito, y vamos a sumergirnos en la comprensión de los fundamentos de LLama.cpp.

La clase Llama importada arriba es el constructor principal aprovechado cuando se usa Llama.cpp, y toma varios parámetros y no se limita a los de abajo. La lista completa de parámetros figura en la documentación oficial:

• model_path: La ruta al archivo del modelo Llama que se está utilizando
• rápido: El mensaje de entrada al modelo. Este texto se tokeniza y se pasa al modelo.
• dispositivo: El dispositivo que se utilizará para ejecutar el modelo Llama; dicho dispositivo puede ser una CPU o una GPU.
• max_tokens: Número máximo de fichas que se generarán en la respuesta del modelo.
• Para: Una lista de cadenas que harán que el proceso de generación del modelo se detenga
• temperatura: Este valor oscila entre 0 y 1. Cuanto menor sea el valor, más determinista será el resultado final. Por otra parte, un valor más alto conduce a una mayor aleatoriedad y, por tanto, a una producción más diversa y creativa.
• top_p: Se utiliza para controlar la diversidad de las predicciones, lo que significa que selecciona los tokens más probables cuya probabilidad acumulada supere un umbral determinado. Partiendo de cero, un valor más alto aumenta la probabilidad de encontrar un resultado mejor, pero requiere cálculos adicionales.
• echo: Un booleano utilizado para determinar si el modelo incluye el aviso original al principio (True) o no lo incluye (False).

Por ejemplo, consideremos que queremos utilizar un modelo de lenguaje grande llamado <MY_AWESOME_MODEL> almacenado en el directorio de trabajo actual, el proceso de instanciación será como sigue:

# Instanciate the model
my_aweseome_llama_model = Llama(model_path="./MY_AWESOME_MODEL")


prompt = "This is a prompt"
max_tokens = 100
temperature = 0.3
top_p = 0.1
echo = True
stop = ["Q", "\n"]


# Define the parameters
model_output = my_aweseome_llama_model(
       prompt,
       max_tokens=max_tokens,
       temperature=temperature,
       top_p=top_p,
       echo=echo,
       stop=stop,
   )
final_result = model_output["choices"][0]["text"].strip()

El código se explica por sí mismo y puede entenderse fácilmente a partir de las viñetas iniciales que indican el significado de cada parámetro.

El resultado del modelo es un diccionario que contiene la respuesta generada junto con algunos metadatos adicionales. El formato de la salida se explora en las siguientes secciones del artículo.

Tu primer proyecto Llama.cpp

Ahora, es el momento de empezar con la implementación del proyecto de generación de texto. Empezar un nuevo proyecto Llama.cpp no tiene más que seguir la plantilla de código python anterior que explica todos los pasos desde la carga del gran modelo de lenguaje de interés hasta la generación de la respuesta final.

El proyecto aprovecha la versión GGUF del Zephyr-7B-Beta de Hugging Face. Se trata de una versión perfeccionada de mistralai/Mistral-7B-v0.1 que se entrenó en una mezcla de conjuntos de datos sintéticos disponibles públicamente utilizando la Optimización de Preferencia Directa (OPD).

Nuestra Introducción al uso de Transformers y Cara de abrazo ofrece una mejor comprensión de los Transformers y de cómo aprovechar su poder para resolver problemas de la vida real. También tenemos un tutorial de Mistral 7B.

Modelo Zephyr de Hugging Face(fuente)

Una vez descargado el modelo localmente, podemos moverlo a la ubicación del proyecto en la carpeta model. Antes de sumergirnos en la implementación, entendamos la estructura del proyecto:

La estructura del proyecto

El primer paso es cargar el modelo utilizando el constructor Llama. Dado que se trata de un modelo de gran tamaño, es importante especificar el tamaño máximo del contexto del modelo que se va a cargar. En este proyecto concreto, utilizamos 512 fichas.

from llama_cpp import Llama


# GLOBAL VARIABLES
my_model_path = "./model/zephyr-7b-beta.Q4_0.gguf"
CONTEXT_SIZE = 512


# LOAD THE MODEL
zephyr_model = Llama(model_path=my_model_path,
                    n_ctx=CONTEXT_SIZE)

Una vez cargado el modelo, el siguiente paso es la fase de generación de texto, utilizando el modelo de código original, pero en su lugar utilizamos una función de ayuda llamada generate_text_from_prompt.

def generate_text_from_prompt(user_prompt,
                             max_tokens = 100,
                             temperature = 0.3,
                             top_p = 0.1,
                             echo = True,
                             stop = ["Q", "\n"]):




   # Define the parameters
   model_output = zephyr_model(
       user_prompt,
       max_tokens=max_tokens,
       temperature=temperature,
       top_p=top_p,
       echo=echo,
       stop=stop,
   )


   return model_output

Dentro de la cláusula __main__, la función puede ejecutarse utilizando un indicador dado.

if __name__ == "__main__":


   my_prompt = "What do you think about the inclusion policies in Tech companies?"


   zephyr_model_response = generate_text_from_prompt(my_prompt)


   print(zephyr_model_response)

A continuación se ofrece la respuesta del modelo:

La respuesta del modelo

La respuesta generada por el modelo es y la respuesta exacta del modelo se resalta en el recuadro naranja.

• El aviso original tiene 12 fichas
• Las fichas de respuesta o finalización tienen 10 fichas y,
• El total de fichas es la suma de las dos fichas anteriores, que es 22

Aunque esta salida completa puede ser útil para usos posteriores, es posible que sólo nos interese la respuesta textual del modelo. Podemos formatear la respuesta para obtener dicho resultado seleccionando el campo “text” del elemento "choices” de la siguiente manera:

final_result = model_output["choices"][0]["text"].strip()

La función strip() se utiliza para eliminar los espacios en blanco iniciales y finales de una cadena y el resultado es:

Tech companies want diverse workforces to build better products.

Aplicaciones reales de Llama.CPP

Esta sección recorre una aplicación real de LLama.cpp y proporciona el problema subyacente, la posible solución y los beneficios de usar Llama.cpp.

Problema

Imagina ETP4Africa, una empresa tecnológica que necesita un modelo lingüístico que pueda funcionar eficazmente en varios dispositivos para su aplicación educativa sin causar retrasos.

Solución con Llama.cpp

Implementan Llama.cpp, aprovechando su rendimiento optimizado para CPU y la capacidad de interactuar con su backend basado en Go.

Beneficios

• Portabilidad y rapidez: El diseño ligero de Llama.cpp garantiza respuestas rápidas y compatibilidad con muchos dispositivos.
• Personalización: Las funciones de bajo nivel adaptadas permiten a la aplicación proporcionar asistencia de codificación en tiempo real de forma eficaz.

La integración de Llama.cpp permite a la aplicación ETP4Africa ofrecer una guía de programación inmediata e interactiva, mejorando la experiencia y el compromiso del usuario.

La Ingeniería de Datos es un componente clave para cualquier proyecto de Ciencia de Datos e IA, y nuestro tutorial Introducción a LangChain para Ingeniería de Datos y Aplicaciones de Datos proporciona una guía completa para incluir IA de grandes modelos de lenguaje dentro de pipelines de datos y aplicaciones.

Conclusión

En resumen, este artículo ha proporcionado una visión general sobre la configuración y utilización de grandes modelos lingüísticos con LLama.cpp.

Se proporcionaron instrucciones detalladas para comprender los fundamentos de Llama.cpp, configurar el entorno de trabajo, instalar la biblioteca necesaria e implementar un caso de uso de generación de texto (respuesta a preguntas).

Por último, se proporcionaron ideas prácticas para una aplicación del mundo real y cómo se puede utilizar Llama.cpp para abordar eficientemente el problema subyacente.

¿Está listo para sumergirse en el mundo de los grandes modelos lingüísticos? Mejore sus habilidades con los potentes marcos de aprendizaje profundo LangChain y Pytorch utilizados por los profesionales de la IA con nuestro tutorial Cómo crear aplicaciones LLM con LangChain y Cómo entrenar un LLM con PyTorch.