Introduction à LMQL : le pont entre SQL et les grands modèles de langage

Le Structured Query Language, ou SQL (souvent prononcé « si-quel ») est un langage de programmation déclaratif utilisé pour stocker, interroger, gérer et manipuler des données au sein d’un système de gestion de base de données.

Il a été mis au point au début des années 1970 par les chercheurs d’IBM Raymond Boyce et Donald Chamberlain, mais n’a été commercialisé qu’en 1979 lorsque Relational Software, Inc., aujourd’hui Oracle, en a proposé une implémentation.

Aujourd’hui, SQL s’est imposé comme la norme des systèmes de gestion de bases de données relationnelles (SGBDR). Sa simplicité et sa capacité à gérer et analyser efficacement de grands volumes de données en font un outil indispensable dans un monde de plus en plus guidé par les données.

Mais ce monde évolue.

L’intelligence artificielle gagne rapidement du terrain, et les grands modèles de langage sont devenus des outils extrêmement puissants pour de nombreuses tâches. Le seul problème, c’est que l’interaction avec ces modèles peut parfois donner l’impression de parler une langue étrangère. C’est là qu’intervient LMQL.

Développé par le SRI Lab de l’ETH Zurich, LMQL fait office de traducteur personnel entre les développeurs et leurs modèles de langage. En bref, LMQL apporte la puissance de SQL dans l’univers des modèles de langage, rendant les interactions plus fluides, plus efficaces et, osons le dire, plus agréables.

Dans la suite de ce tutoriel, nous verrons :

• Qu’est-ce que LMQL ?
• Pourquoi LMQL ?
• Comment configurer LMQL
• Des cas d’usage concrets de LMQL
• Les limites de LMQL
• Les bonnes pratiques

Qu’est-ce que LMQL ?

LMQL, acronyme de Language Models Query Language, est un langage de programmation innovant pour les grands modèles de langage (LLM). Il combine des éléments déclaratifs proches de SQL avec une syntaxe de script impérative afin d’offrir un moyen plus structuré et intuitif d’extraire des informations ou de générer des réponses à partir de LLM.

Par ailleurs, LMQL est un surensemble de Python, ce qui signifie qu’il agit comme une extension apportant de nouvelles fonctionnalités et élargissant les capacités de Python. Les développeurs peuvent ainsi créer des invites en langage naturel mêlant texte et code, ce qui renforce la flexibilité et l’expressivité des requêtes.

D’après la documentation, « LMQL offre une nouvelle façon d’entrelacer la programmation traditionnelle avec la possibilité d’appeler des LLM dans votre code. Il va au‑delà des langages de templating classiques en intégrant nativement l’interaction avec les LLM au niveau même de votre code. »

Le langage a été présenté par ses concepteurs dans un article de recherche intitulé Prompting is Programming: A Query Lnague for Large Language Models comme une solution pour permettre un phénomène qu’ils nomment « LMP », pour Language Model Prompting.

Pour situer le contexte, les grands modèles de langage affichent des performances remarquables sur plusieurs tâches, comme les questions‑réponses et la génération de code. Fondamentalement, les LLM excellent à produire automatiquement des enchaînements logiques à partir d’entrées données, sur la base de probabilités statistiques.

En exploitant cette capacité, on peut solliciter les LLM avec des consignes en langage naturel ou des exemples afin de déclencher l’exécution de diverses tâches en aval. Des techniques d’invite avancées permettent même des interactions entre l’utilisateur, le modèle et des outils externes comme des calculateurs.

Le défi consiste à atteindre l’état de l’art ou à adapter des LLM à des tâches spécifiques, ce qui nécessite généralement de mettre en œuvre des programmes complexes et dédiés, tout en restant tributaires d’interactions improvisées.

Le prompting des modèles de langage est une discipline émergente qui gagne du terrain pour répondre à ces enjeux. LMQL s’aligne sur les principes du LMP : il combine de manière intuitive texte d’invite et scripting, et permet aux utilisateurs de définir des contraintes sur la sortie des modèles.

Pourquoi LMQL ?

La génération récente de modèles de langage se prête assez bien à des invites conceptuelles via des exemples ou des consignes. Toutefois, pour en tirer tout le potentiel et rester à jour au rythme des nouveaux modèles, il faut comprendre finement leur fonctionnement interne ainsi que les bibliothèques et implémentations propres à chaque fournisseur.

Par exemple, limiter le décodage à une liste de mots ou d’expressions autorisés peut s’avérer difficile, car les modèles manipulent des tokens. Que vous utilisiez des LLM en local ou via une API, ils coûtent cher à exécuter, car ce sont des réseaux de très grande taille.

LMQL peut réduire le nombre d’appels au modèle de langage (LM) en tirant parti de comportements prédéfinis et de la recherche contrainte introduite par les contraintes.

Autre raison en faveur de LMQL : de nombreuses techniques de prompting exigent des échanges aller‑retour entre le modèle et l’utilisateur (comme avec des chatbots tels que ChatGPT) ou des interfaces très spécialisées, par exemple pour effectuer des calculs arithmétiques avec une logique de contrôle externe.

Mettre en place ces invites réclame beaucoup de travail manuel et une interaction avec les procédures de décodage du modèle, ce qui limite la généricité des implémentations obtenues. Enfin, comme un LM ne génère qu’un seul token (sous‑mot) à la fois, l’achèvement peut nécessiter de multiples appels.

Les LMs actuels ne permettent pas nativement de contraindre la sortie, fonctionnalité pourtant essentielle en production. Par exemple, imaginez une application d’analyse de sentiment pour étiqueter les avis négatifs. Le programme attend du LLM une réponse du type « positif », « négatif » ou « neutre ».

Or, bien souvent, le LLM peut répondre : « Le sentiment de l’avis fourni est positif », ce qui complique le traitement côté API. D’où l’intérêt crucial des contraintes.

Avec LMQL, vous pouvez contrôler la sortie avec des termes compréhensibles par des humains plutôt qu’avec les tokens utilisés par les LMs.

Configuration de LMQL

LMQL peut être installé en local ou utilisé en ligne via l’IDE Playground accessible sur le web. Notez que si vous souhaitez utiliser des modèles auto‑hébergés via Transformers ou llama.cpp, vous devez installer LMQL en local. Voici comment procéder :

Installation et préparation de l’environnement

Installer LMQL en local est assez simple.

Il suffit d’exécuter la commande suivante dans un environnement Python >= 3.10 :

pip install lmql

Si vous envisagez d’exécuter des modèles sur un GPU local, vous devez installer LMQL dans un environnement où PyTorch >= 1.11 est installé avec la prise en charge du GPU.

Voici la commande à exécuter si vous souhaitez installer LMQL avec les dépendances GPU via pip :

pip install lmql[hf]

Remarque : installer les dépendances dans un environnement virtuel est une bonne pratique.

Après l’installation, vous avez trois options pour exécuter des programmes LMQL :

1. Playground
Vous pouvez lancer une instance locale de l’IDE Playground

lmql playground

Cette commande ouvre un Playground dans le navigateur. S’il ne se lance pas automatiquement, rendez‑vous sur http://localhost:3000.

Notez que cette méthode nécessite une installation de Node.js.

2. Interface en ligne de commande
Alternative au Playground, l’outil en ligne de commande permet d’exécuter des fichiers .lmql locaux. Pour l’utiliser, exécutez simplement :

lmql run

3. Intégration Python
Étant un surensemble, LMQL peut s’exécuter directement dans un programme Python. Il suffit d’importer le paquet lmql. Tout code de requête doit être exécuté via lmql.run ou avec le décorateur @lmql.query.

Lorsque vous utilisez des modèles Transformer locaux dans l’IDE Playground ou l’outil en ligne de commande, vous devez d’abord lancer une instance de l’API d’inférence LMQL pour le modèle concerné en exécutant la commande lmql serve-model.

Comprendre la syntaxe de LMQL

Un programme LMQL comporte cinq éléments fondamentaux, chacun jouant un rôle clé dans le comportement d’une requête. Ces composants sont :

• Query
• Decoder
• Model
• Constraints
• Distribution

Voyons chacun plus en détail.

Query

Le bloc de requête est le principal canal de communication entre le modèle de langage et l’utilisateur.

Voici une requête LMQL de base :

# 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
"""

Le bloc de requête traite toute chaîne au premier niveau comme une requête directe au modèle de langage. À l’instar des f-strings de Python, ces chaînes de requête prennent en charge deux sous‑champs échappés spéciaux.

Notez que la portion que le modèle doit générer est représentée par [varname]. On parle aussi de « trou » (hole) – nous aborderons la clause where dans un instant.

On peut également récupérer la valeur d’une variable de la portée courante en utilisant {varname}.

Par exemple :

# Source: https://lmql.ai/docs/language/overview.html
# review to be analyzed
review = """We had a great stay. Hiking in the mountains was fabulous and the food is really good."""

# use prompt statements to pass information to the model
"Review: {review}"

Decoder

LMQL prend en charge divers algorithmes de décodage pour générer du texte à partir de la distribution de tokens d’un modèle de langage. Cela permet de préciser l’algorithme au début d’une requête.

Deux façons de spécifier l’algorithme de décodage :

1. Dans la requête – vous indiquez l’algorithme et ses paramètres directement dans la requête. Selon la documentation de LMQL, « Ceci est particulièrement utile si le choix du décodeur est pertinent pour le programme que vous écrivez. » Voici à quoi cela ressemble en code :

# Source: https://lmql.ai/docs/language/decoding.html
# use beam search with beam width 2 for
# the entire program
beam(n=2)

# uses beam search to generate RESPONSE 
"This is a query with a specified decoder: [RESPONSE]"

2. En externe – vous définissez l’algorithme et ses paramètres séparément du programme. Notez que ceci n’est possible que lorsque LMQL est utilisé depuis un contexte 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=2

Model

LMQL est défini par ses concepteurs comme un « langage frontal de haut niveau pour la génération de texte ». Il n’est donc pas lié à un modèle de génération spécifique. Différents moteurs de génération sont pris en charge en backend, tels que les OpenAI model, llama.cpp et HuggingFace Transformers.

Le chargement des modèles est très simple. Vous pouvez utiliser la fonction lmql.model(...), qui retourne un objet lmql.LMM.

Exemple :

# Source: https://lmql.ai/docs/models/
lmql.model("openai/gpt-3.5-turbo-instruct") # OpenAI API model
lmql.model("random", seed=123) # randomly sampling model
lmql.model("llama.cpp:<YOUR_WEIGHTS>.gguf") # llama.cpp model

lmql.model("local:gpt2") # load a `transformers` model in-process
lmql.model("local:gpt2", cuda=True, load_in_4bit=True) # load a `transformers` model in process with additional arguments
lmql.model("gpt2") # access a `transformers` model hosted via `lmql serve-model`

Une fois l’objet lmql.LLM créé, vous pouvez transmettre le modèle au programme de requête de deux façons :

1. En le spécifiant en externe

# Source: https://lmql.ai/docs/models/
import lmql

# uses 'chatgpt' by default
@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() # uses chatgpt
tell_a_joke(model=lmql.model("openai/text-davinci-003")) # uses text-davinci-003

2. En utilisant une requête avec la clause from

# Source: https://lmql.ai/docs/models/
argmax
    "This is a query with a specified 'from'-clause: [RESPONSE]"
from
    "openai/text-ada-001"

Constraints

L’un des principaux atouts de LMQL réside dans les contraintes. LMQL permet en effet de définir des contraintes sur la sortie du modèle. Cela facilite le prompting scripté en garantissant que la sortie s’arrête au point souhaité et offre un contrôle sur le modèle pendant le décodage.

Parmi les contraintes prises en charge :

• Phrases d’arrêt
• Contraintes de type numérique
• Choix dans un ensemble
• Longueur en caractères
• Longueur en tokens
• Préversion des contraintes Regex
• Combinaison de contraintes
• Personnalisées

Consultez la page Constraints dans la documentation de LMQL pour en savoir plus.

Distribution

L’instruction distribution est un composant clé de LMQL. Elle permet de contrôler le format et la structure de la sortie en définissant la façon dont les résultats générés sont répartis et présentés.

Voici un exemple :

# Source: https://lmql.ai/docs/language/overview.html
argmax
    # review to be analyzed
    review = """We had a great stay. Hiking in the mountains was fabulous and the food is really good."""

    # use prompt statements to pass information to the model
    "Review: {review}"
    "Q: What is the underlying sentiment of this review and why?"
    # template variables like [ANALYSIS] are used to generate text
    "A:[ANALYSIS]" where not "\n" in ANALYSIS

    # use constrained variable to produce a classification
    "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 CLS

Limites de LMQL et soutien de la communauté

Comme toute technologie, LMQL présente certaines limites. Par exemple :

• La bibliothèque LMQL est récente et encore peu répandue. La communauté est donc restreinte et il existe peu de ressources externes pour vous aider en cas de blocage.
• La documentation de la bibliothèque n’est pas aussi détaillée qu’elle pourrait l’être.
• Les limitations de l’API OpenAI font qu’il n’est pas possible d’exploiter pleinement LMQL avec ChatGPT, car les modèles les plus populaires et performants ne sont pas accessibles.

Même si ces points peuvent freiner certains utilisateurs, gardez à l’esprit que la bibliothèque est encore jeune et en cours d’évolution : ces limites pourraient être levées dans de prochaines versions.

Conclusion

LMQL est un langage de type SQL qui est également un surensemble de Python. Il simplifie l’extraction d’informations ou la génération de réponses à partir de LLM en combinant éléments déclaratifs et syntaxe de script impérative. Les développeurs peuvent s’appuyer sur LMQL pour contrôler finement la génération de texte, ce qui en fait un outil extrêmement précieux pour de nombreux cas d’usage dans la tech.

Pour aller plus loin, découvrez :

• LlamaIndex : ajouter des données personnelles aux LLM
• Les 10 meilleures alternatives à ChatGPT à essayer dès aujourd’hui
• Introduction à ChatGPT
• Comment entraîner un LLM avec PyTorch
• Introduction à LangChain pour la data engineering et les applications data
• Utiliser des LLM avec l’API Cohere