Curso
Conceptos de la IA generativa
2 h
117.2K
Structured Query Language, o SQL (a menudo pronunciado “sequel”), es un lenguaje de programación declarativo utilizado para almacenar, recuperar, gestionar y manipular datos dentro de un sistema de gestión de bases de datos.
Fue desarrollado por los investigadores de IBM Raymond Boyce y Donald Chamberlain a principios de los años 70, pero no estuvo disponible comercialmente hasta 1979, cuando Relational Software, Inc., hoy conocida como Oracle, lanzó su implementación.
Hoy en día, SQL está ampliamente aceptado como el estándar de los sistemas de gestión de bases de datos relacionales (RDBMS) por su sencillez y su capacidad para gestionar y analizar eficientemente grandes volúmenes de datos, lo que lo hace indispensable en un mundo cada vez más basado en datos.
Pero el mundo data‑driven está evolucionando.
La inteligencia artificial está ganando popularidad a gran velocidad, y los grandes modelos de lenguaje han emergido como herramientas tremendamente potentes para multitud de tareas. El único problema es que interactuar con estos modelos a veces se siente como hablar un idioma alienígena. Aquí es donde entra en juego LMQL.
LMQL fue desarrollado por el SRI Lab de ETH Zúrich y actúa como un traductor personal entre los desarrolladores y sus modelos de lenguaje. En esencia, LMQL lleva el poder de SQL al terreno de los modelos de lenguaje, haciendo que la interacción con ellos sea más fluida, eficiente y, por qué no, más divertida.
En el resto de este tutorial veremos:
- ¿Qué es LMQL?
- ¿Por qué LMQL?
- Cómo configurar LMQL
- Aplicaciones prácticas de LMQL
- Limitaciones de LMQL
- Mejores prácticas
¿Qué es LMQL?
LMQL, siglas de Language Models Query Language, es un innovador lenguaje de programación para grandes modelos de lenguaje (LLMs). Combina elementos declarativos al estilo SQL con una sintaxis imperativa de scripting para ofrecer una forma más estructurada e intuitiva de extraer información o generar respuestas a partir de LLMs.
Además, LMQL es un superconjunto de Python, es decir, actúa como una extensión que introduce nuevas funciones y amplía las capacidades de Python. Esto permite a los desarrolladores crear prompts en lenguaje natural que combinan texto y código, aumentando la flexibilidad y expresividad de las consultas.
Según la documentación, “LMQL ofrece una forma novedosa de entrelazar la programación tradicional con la capacidad de invocar LLMs dentro de tu código. Va más allá de los lenguajes de plantillas convencionales al integrar la interacción con LLMs de forma nativa a nivel del código de tu programa”.
El lenguaje fue presentado por sus creadores en el artículo de investigación titulado Prompting is Programming: A Query Lnague for Large Language Models como una solución para habilitar un fenómeno que llamaron “LMP” (Language Model Prompting).
Para contextualizar, los grandes modelos de lenguaje han demostrado un rendimiento excepcional en múltiples tareas, como respuesta a preguntas y generación de código. En esencia, los LLMs son muy competentes generando secuencias lógicas de forma automática a partir de entradas dadas, utilizando probabilidades estadísticas.
Aprovechando esta capacidad, los usuarios pueden “promptear” a los LLMs con instrucciones en lenguaje natural o ejemplos para ejecutar diversas tareas posteriores. Las técnicas avanzadas de prompting incluso permiten interacciones entre los usuarios, el modelo de lenguaje y herramientas externas como calculadoras.
El reto está en alcanzar un rendimiento de vanguardia o adaptar los LLMs a tareas específicas, lo que suele requerir la implementación de programas complejos y ad hoc que aun así pueden depender de interacciones improvisadas.
El prompting de modelos de lenguaje es una disciplina emergente que está ganando tracción para abordar estos problemas. LMQL se adhiere a los principios del LMP, como ofrecer a los LLMs una combinación intuitiva de prompting textual y scripting, y permitir que los usuarios especifiquen restricciones sobre la salida del modelo.
¿Por qué LMQL?
La generación más reciente de modelos de lenguaje se puede promptear fácilmente con ejemplos o instrucciones a nivel conceptual. Sin embargo, exprimir todo su potencial y mantenerse al día a medida que aparecen nuevos modelos exige comprender bien su funcionamiento interno y las bibliotecas e implementaciones específicas de cada proveedor.
Por ejemplo, limitar el proceso de decodificación a una lista de palabras o frases válidas puede ser complicado porque los modelos trabajan con tokens. Tanto si utilizas LLMs localmente como vía API, su coste es elevado porque son redes de gran tamaño.
LMQL puede reducir el número de invocaciones al modelo de lenguaje aprovechando el comportamiento predefinido y la búsqueda restringida que introducen las constraints.
Otra razón a favor de LMQL es que muchas técnicas de prompting requieren comunicación de ida y vuelta entre el modelo y el usuario (como vemos con chatbots tipo ChatGPT) o interfaces muy especializadas, como las usadas para realizar cálculos aritméticos con lógica de control externa.
Implementar estos prompts requiere mucho trabajo manual e interactuar con los procedimientos de decodificación del modelo, lo que limita la generalidad de las implementaciones resultantes. Por último, como un LM solo puede generar un token (subpalabra) a la vez, completar una salida puede requerir múltiples llamadas.
Los LMs existentes no proporcionan de serie la funcionalidad para restringir la salida, algo vital cuando se usan en producción. Por ejemplo, imagina que estás construyendo una aplicación de análisis de sentimiento para marcar reseñas negativas. El programa esperaría que el LLM respondiera con algo como “positivo”, “negativo” o “neutral”.
Sin embargo, con bastante frecuencia el LLM podría responder algo como “El sentimiento de la reseña proporcionada es positivo”, lo cual es difícil de procesar para tu API. Por eso, las restricciones son muy útiles.
Con LMQL puedes controlar la salida con términos comprensibles para humanos en lugar de los tokens que usan los LMs.
Configuración de LMQL
LMQL puede instalarse en local o utilizarse online a través del Playground IDE en la web. Ten en cuenta que, si quieres usar modelos autoalojados mediante Transformers o llama.cpp, debes instalar LMQL localmente. Así es como se hace:
Instalación y preparación del entorno
Instalar LMQL en local es bastante sencillo.
Solo tienes que ejecutar el siguiente comando en un entorno con Python >= 3.10:
pip install lmqlSi quieres ejecutar modelos en una GPU local, debes instalar LMQL en un entorno con una instalación de PyTorch >= 1.11 con soporte para GPU.
Este es el comando para instalar LMQL con dependencias de GPU vía pip:
pip install lmql[hf]Nota: es buena práctica instalar las dependencias en un entorno virtual.
Tras la instalación, tienes tres opciones para ejecutar programas LMQL:
1. Playground
Puedes lanzar una instancia local del Playground IDE
lmql playgroundEste comando abrirá un Playground IDE en el navegador; si no se abre automáticamente, ve a http://localhost:3000.
Ten en cuenta que este método requiere una instalación de Node.js.
2. Interfaz de línea de comandos
Como alternativa al Playground, puedes usar la herramienta de línea de comandos para ejecutar archivos .lmql locales. Para usarla, ejecuta:
lmql run3. Integración con Python
Al ser un superconjunto, LMQL puede ejecutarse directamente desde un programa en Python. Solo tienes que importar el paquete lmql. Todo el código de consulta debe ejecutarse mediante lmql.run o con el decorador @lmql.query.
Cuando uses modelos Transformer locales en el Playground IDE o en la herramienta de línea de comandos, primero debes lanzar una instancia de la LMQL Inference API para el modelo correspondiente ejecutando el comando lmql serve-model.
Entendiendo la sintaxis de LMQL
Un programa LMQL consta de cinco partes fundamentales, cada una con un papel clave en el comportamiento de una consulta. Estos componentes son:
- Query
- Decoder
- Model
- Constraints
- Distribution
Veámoslos con más detalle.
Query
El bloque de consulta (query) es el medio principal de comunicación entre el modelo de lenguaje y el usuario.
Aquí tienes una consulta LMQL básica:
# Source: https://lmql.ai/docs/
"Say 'this is a test':[RESPONSE]" where len(TOKENS(RESPONSE)) < 25
—-- Model Output—--
"""
Say 'this is a test': RESPONSE This is a test
"""El bloque de consulta trata cada cadena de texto de nivel superior como una consulta directa al modelo de lenguaje. De forma similar a las f-strings de Python, estas cadenas admiten dos subcampos especiales con escape.
Fíjate en que la frase que generará el modelo de lenguaje se representa con [varname]. Esto también se conoce como “agujero” (hole). Veremos la cláusula where en un momento.
También puedes recuperar el valor de una variable del ámbito actual usando {varname}.
Por ejemplo:
# Source: https://lmql.ai/docs/language/overview.html
# review a analizar
review = """We had a great stay. Hiking in the mountains was fabulous and the food is really good."""
# usa sentencias de prompt para pasar información al modelo
"Review: {review}"Decoder
LMQL admite varios algoritmos de decodificación utilizados para generar texto a partir de la distribución de tokens de un modelo de lenguaje. Esto permite especificar el algoritmo de decodificación al inicio de una consulta.
Hay dos formas de indicar qué algoritmo de decodificación usar:
1. Como parte de la consulta - aquí especificas el algoritmo y sus parámetros dentro de la propia consulta. Según la documentación de LMQL, “Esto puede ser especialmente útil si tu elección de decodificador es relevante para el programa concreto que estás escribiendo”. Así se ve en código:
# Source: https://lmql.ai/docs/language/decoding.html
# usa beam search con ancho de haz 2
# para todo el programa
beam(n=2)
# usa beam search para generar RESPONSE
"This is a query with a specified decoder: [RESPONSE]"2. Externamente - el algoritmo de decodificación y sus parámetros se especifican fuera del programa, es decir, por separado. Ten en cuenta que esto solo es posible cuando LMQL se usa desde un contexto de Python
# Source: https://lmql.ai/docs/language/decoding.htmlimport lmql
@lmql.query(model="openai/text-davinci-003", decoder="sample", temperature=1.8)
def tell_a_joke():
'''lmql
"""A list good dad joke. A indicates the punchline:
Q:[JOKE]
A:[PUNCHLINE]""" where STOPS_AT(JOKE, "?") and STOPS_AT(PUNCHLINE, "\n")
'''
tell_a_joke() # uses the decoder specified in @lmql.query(...)
tell_a_joke(decoder="beam", n=2) # uses a beam search decoder with n=2Model
Los desarrolladores definen LMQL como un “lenguaje de alto nivel y front‑end para generación de texto”. Esto significa que no está ligado a un único modelo de generación de texto. En su lugar, en el backend se admiten varios modelos, como OpenAI model, llama.cpp y HuggingFace Transformers.
Cargar modelos es muy sencillo. Puedes usar la función lmql.model(...), que produce un objeto lmql.LMM.
Así es como se usa:
# Source: https://lmql.ai/docs/models/
lmql.model("openai/gpt-3.5-turbo-instruct") # modelo de la API de OpenAI
lmql.model("random", seed=123) # modelo de muestreo aleatorio
lmql.model("llama.cpp:<YOUR_WEIGHTS>.gguf") # modelo de llama.cpp
lmql.model("local:gpt2") # cargar un modelo `transformers` en el propio proceso
lmql.model("local:gpt2", cuda=True, load_in_4bit=True) # cargar un modelo `transformers` en proceso con argumentos adicionales
lmql.model("gpt2") # acceder a un modelo `transformers` servido vía `lmql serve-model`Una vez creado el objeto lmql.LLM, puedes pasar el modelo al programa de consulta de dos formas:
1. Especificando el modelo externamente
# Source: https://lmql.ai/docs/models/
import lmql
# usa 'chatgpt' por defecto
@lmql.query(model="chatgpt")
def tell_a_joke():
'''lmql
"""A great good dad joke. A indicates the punchline
Q:[JOKE]
A:[PUNCHLINE]""" where STOPS_AT(JOKE, "?") and \
STOPS_AT(PUNCHLINE, "\n")
'''
tell_a_joke() # usa chatgpt
tell_a_joke(model=lmql.model("openai/text-davinci-003")) # usa text-davinci-0032. Usando una consulta con la cláusula from
# Source: https://lmql.ai/docs/models/
argmax
"This is a query with a specified 'from'-clause: [RESPONSE]"
from
"openai/text-ada-001"Constraints
Uno de los grandes atractivos de LMQL es el componente de restricciones (constraints). LMQL permite especificar restricciones sobre la salida del modelo de lenguaje. Esto ayuda en el prompting “scriptado” al garantizar que la salida del modelo termine en el punto previsto y, además, da control al usuario durante la decodificación.
Las restricciones admitidas incluyen:
- Frases de parada (Stopping Phrases)
- Restricciones de tipo numérico
- Elección desde un conjunto
- Longitud en caracteres
- Longitud en tokens
- Vista previa de restricciones Regex
- Combinación de restricciones
- Personalizadas
Consulta la página de Constraints en la documentación de LMQL para saber más.
Distribution
La instrucción de distribución es una pieza clave en LMQL. Ofrece control sobre el formato y la estructura de la salida definiendo cómo se distribuyen y presentan los resultados generados.
Aquí tienes un ejemplo en acción:
# Source: https://lmql.ai/docs/language/overview.html
argmax
# review a analizar
review = """We had a great stay. Hiking in the mountains was fabulous and the food is really good."""
# usa sentencias de prompt para pasar información al modelo
"Review: {review}"
"Q: What is the underlying sentiment of this review and why?"
# variables de plantilla como [ANALYSIS] se usan para generar texto
"A:[ANALYSIS]" where not "\n" in ANALYSIS
# usa una variable restringida para producir una clasificación
"Based on this, the overall sentiment of the message can be considered to be[CLS]"
distribution
CLS in [" positive", " neutral", " negative"]
----- Model Output ------
Review: We had a great stay. Hiking in the mountains was fabulous and the food is really good.
Q: What is the underlying sentiment of this review and why?
A: ANALYSIS The underlying sentiment of this review is positive because the reviewer had a great stay, enjoyed the hiking and found the food to be good.
Based on this, the overall sentiment of the message can be considered to be CLSLimitaciones de LMQL y apoyo de la comunidad
Como con cualquier tecnología, LMQL tiene algunas limitaciones. Por ejemplo:
- La biblioteca LMQL no lleva mucho tiempo y no es muy popular. En consecuencia, la comunidad es reducida y hay pocos recursos externos disponibles para ayudarte cuando te atasques.
- La documentación de la biblioteca no es tan detallada como podría ser.
- Las limitaciones de la API de OpenAI implican que no es posible aprovechar al máximo LMQL con ChatGPT, ya que los modelos más populares y con mejor rendimiento no son accesibles.
Aunque estos puntos pueden ser bloqueadores para quien esté valorando usar LMQL, conviene recordar que la biblioteca es bastante nueva y sigue en desarrollo: es posible que estas limitaciones se solucionen en versiones posteriores.
Conclusión
LMQL es un lenguaje de programación con sabor a SQL y, además, un superconjunto de Python. Simplifica la extracción de información y la generación de respuestas a partir de LLMs al combinar elementos declarativos con una sintaxis imperativa de scripting. Los desarrolladores pueden apoyarse en LMQL para controlar eficazmente la generación de texto, lo que lo convierte en una herramienta de gran valor para múltiples aplicaciones en el sector tecnológico.
Para seguir aprendiendo, echa un vistazo a:
