Introduzione a LMQL: il ponte tra SQL e i Large Language Models

Structured Query Language, o SQL (spesso pronunciato “sequel”), è un linguaggio di programmazione dichiarativo usato per archiviare, recuperare, gestire e manipolare dati all’interno di un sistema di gestione di database.

Fu sviluppato dai ricercatori IBM Raymond Boyce e Donald Chamberlain all’inizio degli anni ’70, ma divenne disponibile commercialmente solo nel 1979, quando Relational Software, Inc., oggi rinominata Oracle, ne introdusse un’implementazione.

Oggi SQL è ampiamente accettato come standard per i sistemi di gestione di database relazionali (RDBMS) grazie alla sua semplicità e alla capacità di gestire e analizzare in modo efficiente grandi set di dati, il che lo rende indispensabile in un mondo sempre più data-driven.

Ma il mondo data-driven sta evolvendo.

L’intelligenza artificiale sta guadagnando popolarità rapidamente e i large language model sono emersi come strumenti estremamente potenti per vari compiti. L’unico problema è che interagire con questi modelli linguistici a volte sembra parlare una lingua aliena. È qui che entra in gioco LMQL.

LMQL è stato sviluppato dallo SRI Lab del Politecnico di Zurigo (ETH Zürich) e funge da traduttore personale tra sviluppatori e i loro modelli linguistici. In pratica, LMQL porta la potenza di SQL nel mondo dei modelli linguistici, rendendo le interazioni più fluide, efficienti e anche più piacevoli.

Nel resto di questo tutorial parleremo di:

• Che cos’è LMQL?
• Perché LMQL?
• Come configurare LMQL
• Applicazioni pratiche di LMQL
• Limitazioni di LMQL
• Best practice

Che cos’è LMQL?

LMQL, acronimo di Language Models Query Language, è un linguaggio di programmazione innovativo per i Large Language Models (LLM). In particolare, combina elementi dichiarativi in stile SQL con una sintassi di scripting imperativa per offrire un modo più strutturato e intuitivo di estrarre informazioni o generare risposte dagli LLM.

Inoltre, LMQL è un superset di Python, cioè agisce come un’estensione che introduce nuove funzionalità e amplia le capacità di Python. Questo consente agli sviluppatori di creare prompt in linguaggio naturale che contengono testo e codice, aumentando la flessibilità e l’espressività delle query.

Secondo la documentazione, “LMQL offre un modo nuovo di intrecciare la programmazione tradizionale con la possibilità di chiamare LLM nel tuo codice. Va oltre i linguaggi di templating tradizionali integrando l’interazione con gli LLM in modo nativo a livello del codice del programma.”

Il linguaggio è stato presentato dai suoi creatori in un paper di ricerca intitolato Prompting is Programming: A Query Lnague for Large Language Models come soluzione per abilitare un fenomeno che hanno chiamato “LMP”, ovvero Language Model Prompting.

Per contesto, i large language model hanno mostrato prestazioni eccezionali in diversi compiti, come il question answering e la generazione di codice. In sostanza, gli LLM sono abili nel generare automaticamente sequenze logiche in base agli input forniti, utilizzando probabilità statistiche.

Sfruttando questa capacità, gli utenti possono istruire gli LLM con indicazioni in linguaggio naturale o esempi per avviare l’esecuzione di vari task a valle. Tecniche di prompting avanzate consentono persino interazioni tra utenti, modello linguistico e strumenti esterni come calcolatrici.

La sfida è ottenere prestazioni allo stato dell’arte o adattare gli LLM a compiti specifici, il che in genere richiede l’implementazione di programmi complessi e specifici per il task, che possono comunque dipendere da interazioni estemporanee.

Il prompting dei modelli linguistici è una disciplina emergente che sta guadagnando terreno per affrontare questi problemi. LMQL aderisce ai principi dell’LMP, tra cui fornire agli LLM una combinazione intuitiva di prompting testuale e scripting e permettere agli utenti di specificare vincoli sull’output del modello linguistico.

Perché LMQL?

Le generazioni più recenti di modelli linguistici possono essere facilmente indirizzate concettualmente con esempi o istruzioni. Tuttavia, sfruttarli al massimo e restare aggiornati con l’uscita di nuovi modelli richiede una comprensione approfondita del loro funzionamento interno e delle librerie e implementazioni specifiche dei vendor.

Per esempio, limitare il processo di decodifica a un elenco di parole o frasi consentite può essere difficile perché i modelli linguistici lavorano con token. Che tu utilizzi gli LLM in locale o via API, sono piuttosto costosi perché sono reti di grandi dimensioni.

LMQL può ridurre il numero di chiamate di invocazione al modello linguistico (LM) sfruttando comportamenti predefiniti e la ricerca vincolata introdotta dai constraints.

Un altro motivo per usare LMQL è che molte tecniche di prompting possono richiedere una comunicazione avanti e indietro tra il modello linguistico e l’utente (come vediamo con chatbot tipo ChatGPT) o interfacce altamente specializzate, come quelle usate per eseguire calcoli aritmetici con logica di controllo esterna.

Implementare questi prompt richiede molto lavoro manuale e interazione con le procedure di decodifica del modello, il che limita la generalità delle implementazioni risultanti. Infine, poiché un LM può generare solo un singolo token (sub-word) alla volta, il completamento può richiedere più chiamate.

Gli LLM esistenti non offrono la funzionalità per vincolare l’output, cosa fondamentale se gli LLM sono impiegati in produzione. Ad esempio, immagina di costruire un’applicazione di analisi del sentiment per contrassegnare le recensioni negative. Il programma si aspetterebbe che l’LLM risponda con qualcosa come “positivo”, “negativo” o “neutro”.

Tuttavia, spesso l’LLM può dire qualcosa come “Il sentiment per la recensione fornita è positivo”, il che è difficile da elaborare per la tua API. Per questo, i vincoli sono estremamente utili.

Con LMQL puoi controllare l’output con termini comprensibili agli esseri umani, invece che con i token usati dagli LLM.

Configurare LMQL

LMQL può essere installato in locale oppure utilizzato online tramite la Playground IDE basata sul web. Nota che se vuoi usare modelli self-hosted tramite Transformers o llama.cpp, devi installare LMQL in locale. Ecco come fare:

Installazione e configurazione dell’ambiente

Installare LMQL in locale è piuttosto semplice.

Ti basta eseguire il seguente comando in un ambiente Python >= 3.10:

pip install lmql

Se intendi eseguire modelli su una GPU locale, allora devi installare LMQL in un ambiente con un’installazione di PyTorch con supporto GPU >= 1.11.

Ecco il comando da eseguire se vuoi installare LMQL con le dipendenze GPU tramite pip:

pip install lmql[hf]

Nota: installare le dipendenze in un ambiente virtuale è una buona pratica.

Dopo l’installazione, hai tre opzioni per eseguire programmi LMQL:

1. Playground
Puoi avviare un’istanza locale della Playground IDE

lmql playground

Questo comando avvierà una Playground IDE nel browser; se non si apre automaticamente, vai su http://localhost:3000.

Nota che questo metodo richiede un’installazione di Node.js.

2. Interfaccia a riga di comando
Un’alternativa al playground è lo strumento da riga di comando. Può essere usato per eseguire file .lmql locali. Per usarlo, esegui semplicemente il comando seguente:

lmql run

3. Integrazione con Python
Essendo un superset, LMQL può essere eseguito direttamente all’interno di un programma Python. Devi solo importare il pacchetto lmql. Tutto il codice delle query deve essere eseguito tramite lmql.run o con il decorator @lmql.query.

Quando utilizzi i modelli Transformer locali nella Playground IDE o nello strumento da riga di comando, devi prima avviare un’istanza della LMQL Inference API per il modello corrispondente eseguendo il comando lmql serve-model.

Comprendere la sintassi di LMQL

Un programma LMQL è composto da cinque parti fondamentali, ognuna con un ruolo vitale nel determinare il comportamento di una query. Queste componenti includono:

• Query
• Decoder
• Model
• Constraints
• Distribution

Vediamole più da vicino.

Query

Il principale mezzo di comunicazione tra il modello linguistico e l’utente è il blocco di query.

Ecco una query LMQL di 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
"""

Il blocco di query tratta ogni stringa di primo livello come una query diretta al modello linguistico. In modo simile alle f-string di Python, queste stringhe di query supportano due sotto-campi speciali con escape.

Nota che la frase che il modello linguistico genererà è rappresentata da [varname]. Questo è anche noto come “hole” (buco) — arriveremo alla clausola where tra un momento.

È anche possibile recuperare il valore di una variabile dallo scope corrente usando {varname}.

Per esempio:

# 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 supporta vari algoritmi di decodifica utilizzati per generare testo dalla distribuzione di token di un modello linguistico. Questo consente di specificare l’algoritmo di decodifica all’inizio di una query.

Ci sono due modi per specificare l’algoritmo di decodifica da usare:

1. Come parte della query - qui specifichi l’algoritmo e i suoi parametri come parte della query. Secondo la documentazione di LMQL, “Questo può essere particolarmente utile se la scelta del decoder è rilevante per il programma concreto che stai scrivendo.” Ecco come appare nel codice:

# 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. Esternamente - in questo caso l’algoritmo di decodifica e i parametri sono specificati esternamente, cioè separatamente dal programma vero e proprio. Nota che questo è possibile solo quando LMQL è utilizzato in un contesto 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 è definito dagli sviluppatori come un “linguaggio front-end di alto livello per la generazione di testo”. Questo significa che non è specifico per un modello di generazione di testo. Al contrario, sul backend sono supportati vari modelli di generazione di testo, come OpenAI model, llama.cpp e HuggingFace Transformers.

Caricare i modelli è piuttosto semplice. Puoi usare la funzione lmql.model(...), che produce un oggetto lmql.LMM.

Ecco come appare:

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

Una volta creato l’oggetto lmql.LLM, puoi passare il modello al programma di query con uno di due metodi:

1. Specificando il modello esternamente

# 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. Usando una query con la clausola 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 dei principali punti di forza di LMQL è il componente dei vincoli (constraints). In particolare, LMQL consente agli utenti di specificare vincoli sull’output del modello linguistico. Questo aiuta con il prompting scriptato garantendo che l’output del modello termini nel punto previsto e offre anche agli utenti controllo sul modello durante la decodifica.

I vincoli supportati includono:

• Frasi di stop
• Vincoli sul tipo numerico
• Scelta da un insieme
• Lunghezza in caratteri
• Lunghezza in token
• Anteprima dei vincoli regex
• Combinazione di vincoli
• Personalizzati

Consulta la pagina Constraints nella documentazione di LMQL per saperne di più.

Distribution

L’istruzione di distribuzione è un componente chiave in LMQL. Fornisce controllo sul formato e sulla struttura dell’output definendo come i risultati generati vengono distribuiti e presentati.

Ecco un esempio in azione:

# 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

Limitazioni di LMQL e supporto della community

Come per tutte le tecnologie, ci sono alcune limitazioni con LMQL. Per esempio:

• La libreria LMQL non è in circolazione da molto e non è super popolare. Di conseguenza, la community è piuttosto piccola e sono disponibili solo poche risorse esterne per aiutarti quando ti blocchi.
• La documentazione della libreria non è dettagliata quanto potrebbe.
• Le limitazioni dell’API OpenAI significano che non è possibile sfruttare appieno LMQL con ChatGPT, poiché i modelli più popolari e performanti non sono accessibili.

Sebbene questi possano essere ostacoli per chi sta valutando l’uso di LMQL, è importante notare che la libreria è ancora piuttosto nuova ed è un lavoro in corso: queste limitazioni potrebbero essere risolte nelle versioni successive.

Conclusione

LMQL è un linguaggio di programmazione simile a SQL ed è anche un superset di Python. Semplifica il processo di estrazione di informazioni o generazione di risposte dagli LLM combinando elementi dichiarativi con una sintassi di scripting imperativa. Gli sviluppatori possono sfruttare LMQL per controllare efficacemente la generazione di testo, rendendolo uno strumento estremamente prezioso per varie applicazioni nel settore tech.

Per continuare a imparare, dai un’occhiata a:

• LlamaIndex: aggiungere dati personali agli LLM
• Le 10 migliori alternative a ChatGPT da provare oggi
• Introduzione a ChatGPT
• Come addestrare un LLM con PyTorch
• Introduzione a LangChain per Data Engineering e applicazioni dati
• Usare gli LLM con la Cohere API