Creazione di query SQL complesse con l’assistenza dell’intelligenza artificiale generativa | Intelligenza-Artificiale

introduzione

Il lancio di ChatGPT ha segnato un momento senza precedenti nella storia dell’intelligenza artificiale. Con le loro incredibili capacità, ChatGPT e molti altri strumenti di intelligenza artificiale generativa hanno il potenziale per cambiare radicalmente il modo in cui lavoriamo. Scrivere SQL è un compito che sta già cambiando nella scienza dei dati in seguito alla rivoluzione dell’intelligenza artificiale. Forniremo un esempio illustrativo dell’utilizzo del linguaggio naturale per connettersi e interagire con un database SQL. Utilizzerai il pacchetto open source di Python Vanna. Il collegamento al Notebook è Qui. Padroneggia l’arte della creazione complessa query SQL con l’intelligenza artificiale generativa. Scopri come semplificare le interazioni del database utilizzando istruzioni in linguaggio naturale in questa guida approfondita.

obiettivi formativi

In questo articolo imparerai:

• Perché scrivere SQL è una sfida comune nei progetti basati sui dati?
• Il potenziale dell’intelligenza artificiale generativa per rendere SQL più semplice e accessibile
• Come è possibile implementare LLM per scrivere SQL utilizzando i prompt in linguaggio naturale?
• Come connettersi e interagire con un database SQL con il pacchetto Vanna di Python?
• I limiti di Vanna e, più in generale, dei LLM nella scrittura di SQL.

Questo articolo è stato pubblicato come parte del Blogathon sulla scienza dei dati.

SQL: una sfida comune nei progetti basati sui dati

SQL è uno dei linguaggi di programmazione più popolari e ampiamente utilizzati. La maggior parte delle aziende moderne ha adottato l’architettura SQL per archiviare e analizzare i dati aziendali. Tuttavia, non tutti in azienda sono in grado di sfruttare tali dati. Potrebbero non avere le competenze tecniche o non avere familiarità con la struttura e lo schema del database.

Qualunque sia la ragione, questo rappresenta spesso un collo di bottiglia nei progetti basati sui dati, perché per rispondere alle domande aziendali, tutti dipendono dalla disponibilità delle pochissime persone che sanno come utilizzare il database SQL. Non sarebbe fantastico se tutti in azienda, indipendentemente dalla loro esperienza SQL, potessero sfruttare tali dati sempre, ovunque e contemporaneamente?

Ciò potrebbe essere presto possibile con l’aiuto di IA generativa. Sviluppatori e ricercatori stanno già testando diversi approcci per addestrare Large Language Models (LLM), la tecnologia di base della maggior parte degli strumenti di intelligenza artificiale generativa, per scopi SQL. Per esempio, LangChainil popolare framework per lo sviluppo di applicazioni basate su LLM, ora può connettersi e interagire con database SQL in base a istruzioni in linguaggio naturale.

Tuttavia, questi strumenti sono ancora in una fase nascente. Spesso restituiscono risultati imprecisi o sperimentano i cosiddetti Allucinazioni LLMsoprattutto quando si lavora con database grandi e complessi. Inoltre, potrebbero non essere abbastanza intuitivi per gli utenti non tecnici. Quindi c’è ancora un ampio margine di miglioramento.

Vanna in poche parole

Vanna è un agente AI progettato per democratizzare l’uso di SQL. Partendo da un modello preaddestrato basato su una combinazione di LLM di terze parti di OpenAI e Google, puoi mettere a punto un modello personalizzato specifico per il tuo database.

Una volta che il modello è pronto, devi porre domande aziendali in linguaggio naturale e il modello le tradurrà in query SQL. Dovrai anche eseguire le query sul database di destinazione. Basta chiedere al modello e restituirà la query e un DataFrame panda con i risultati, un grafico grafico e un elenco di domande di follow-up.

Per creare il modello personalizzato, Vanna deve essere addestrata con informazioni contestualmente rilevanti, inclusi esempi SQL, documentazione di database e schemi di database, ad esempio DDL (Data Definition Language). La precisione del modello dipenderà in ultima analisi dalla qualità e dalla quantità dei dati di addestramento. La buona notizia è che il modello è progettato per continuare ad apprendere mentre lo utilizzi. Poiché le query SQL generate verranno aggiunte automaticamente ai dati di addestramento, il modello imparerà dagli errori precedenti e migliorerà gradualmente.

L’intero processo è illustrato nella seguente immagine:

Dai un’occhiata a questo articolo per saperne di più sugli aspetti tecnici degli LLM e di altri tipi di reti neurali.

Ora che conosci la teoria, passiamo alla pratica.

Iniziare

Come con qualsiasi pacchetto Python, devi prima installare Vanna. Il pacchetto è disponibile in PyPI e dovrebbe essere installato in pochi secondi.

Una volta che hai Vanna sul tuo computer, importalo nel tuo ambiente di lavoro utilizzando l’alias vn :

# Install vanna, if necessary
%pip install vanna

# import packages
import pandas as pd
import vanna as vn

Per utilizzare Vanna, devi creare un login e ottenere una chiave API. Questo è un processo semplice. Esegui la funzione vn.get_api_key() con la tua email e un codice verrà inviato alla tua casella di posta. Basta inserire il codice ed eseguire vn.set_api_key() e sei pronto per usare Vanna.

# Create login and get API key
api_key = vn.get_api_key('(email protected)') 
vn.set_api_key(api_key)

Come funzionano le modelle a Vanna?

Con Vanna puoi creare tutti i modelli personalizzati che desideri. Supponiamo che tu sia un membro del dipartimento marketing della tua azienda. Il tuo team normalmente lavora con il data warehouse Snowflake dell’azienda e un database PostgreSQL specifico del dipartimento. Si potrebbero quindi creare due modelli diversi, ciascuno addestrato sulle caratteristiche specifiche dei database e con permessi di accesso diversi.

Per creare un modello, utilizzare la funzione vn.create_model(modello, db_type)fornendo un nome e il tipo di database. Vanna può essere utilizzato con qualsiasi database che supporti la connessione tramite Python, inclusi SQLite, PostgreSQL, Snowflake, BigQuery e Amazon Athena.

Due database

Immagina di voler creare due modelli per i due database con cui lavora il tuo team:

# Create models
vn.create_model(model="data_warehose", db_type="Snowflake")
vn.create_model(model="marketing_db", db_type="Postgres")

Una volta creati, puoi accedervi utilizzando il file vn.get_model() funzione. La funzione restituirà un elenco dei modelli disponibili.

('data_warehose',
 'marketing_db',
 'my-dataset2',
 'demo-tpc-h',
 'tpc',
 'chinook')

Potresti aver notato che ci sono più modelli di quelli che hai appena creato. Questo perché Vanna viene fornito con una serie di modelli preaddestrati che possono essere utilizzati a scopo di test.

Giocheremo con il modello “chinook” per il resto del tutorial. È addestrato su Chinookun database SQLite immaginario contenente informazioni su un negozio di musica. Per maggiore chiarezza, di seguito sono riportate le tabelle e le relazioni che compongono il database:

Seleziona il Modello

Per selezionare quel modello, esegui:

# Set model
vn.set_model('chinook')

Questa funzione imposterà il modello da utilizzare per l’API Vanna. Consentirà all’agente di inviare le tue richieste al LLM sottostante, sfruttando le sue capacità con i dati di addestramento per tradurre le tue domande in linguaggio naturale in query SQL.

Tuttavia, se desideri che l’agente esegua le query SQL generate sul database, dovrai connetterti ad esso. A seconda del tipo di database, avrai bisogno di una funzione di connessione diversa. Poiché stiamo utilizzando un database SQLite, utilizzeremo il file vn.connect_to_sqlite(url) funzione con l’URL in cui è ospitato il database:

# Connect to database
url= """https://github.com/lerocha/chinook-database/raw/master
/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite"""
vn.connect_to_sqlite(url=url)

Modello Chinook

Come accennato, il modello Chinook è già pre-addestrato con informazioni contestualmente rilevanti. Una delle cose più belle di Vanna è che hai sempre il pieno controllo sul processo di formazione. In qualsiasi momento puoi verificare quali dati sono presenti nel modello. Questo viene fatto con il vn.get_training_data() funzione, che restituirà un DataFrame panda con i dati di addestramento:

# Check training data
training_data = vn.get_training_data()
training_data

Il modello è stato addestrato con un mix di domande con la corrispondente query SQL, DDL e documentazione del database. Se desideri aggiungere più dati di addestramento, puoi farlo manualmente con la funzione vn.train(). A seconda dei parametri utilizzati, la funzione può raccogliere diversi tipi di dati di allenamento:

• vn.train(domanda, sql): Aggiunge nuove coppie di query domande-SQL.
• vn.train(ddl): Aggiunge un’istruzione DDL al modello.
• vn.train(documentazione): Aggiunge la documentazione del database.

Ad esempio, includiamo la domanda “Quali sono i cinque negozi principali per vendite?” e la query SQL associata:

# Add question-query pair
vn.train(question="Which are the five top stores by sales?", 
         sql="""SELECT BILLINGCITY, SUM(TOTAL) 
         FROM INVOICE 
         GROUP BY 1 
         ORDER BY 2 DESC 
         LIMIT 5;""" )

L’addestramento manuale del modello può essere scoraggiante e richiedere molto tempo. Esiste anche la possibilità di addestrare automaticamente il modello dicendo all’agente Vanna di eseguire la scansione del database per recuperare i metadati. Sfortunatamente questa funzionalità è ancora in fase sperimentale ed è disponibile solo per i database Snowflake, quindi non ho avuto la possibilità di provarla.

Fare domande

Ora che il tuo modello è pronto, passiamo alla parte più divertente: fare domande.

Per fare una domanda, è necessario utilizzare il file vn.ask(domanda) funzione. Cominciamo con uno semplice:

vn.ask(question='What are the top 5 jazz artists by sales?')

Vanna proverà per impostazione predefinita a restituire i quattro elementi già menzionati: la query SQL, un Pandas DataFrame con i risultati, un grafico tracciato e un elenco con domande di follow-up. Quando eseguiamo questa riga, i risultati sembrano accurati:

SELECT a.name, sum(il.quantity) as total_sales
FROM artist a 
INNER JOIN album al 
  ON a.artistid = al.artistid 
INNER JOIN track t 
  ON al.albumid = t.albumid 
INNER JOIN invoiceline il 
  ON t.trackid = il.trackid 
INNER JOIN genre g 
  ON t.genreid = g.genreid
WHERE g.name="Jazz"
GROUP BY a.nameORDER 
BY total_sales DESC
LIMIT 5;

Salva i risultati

Supponiamo che tu voglia salvare i risultati invece di stamparli. In tal caso, puoi impostare i parametri print_results su False e decomprimere i risultati in diverse variabili che potrai successivamente scaricare nel formato desiderato utilizzando tecniche regolari, come i panda .to_csv() metodo per DataFrame e plotly .write_immagine() metodo per la visualizzazione:

sql, df, fig, followup_questions = vn.ask(question='What are the top 5 jazz artists by sales?', 
                                          print_results=False)

#Save dataframe and image
df.to_csv('top_jazz_artists.csv', index=False)
fig.write_image('top_jazz_artists.png')

La funzione ha un altro parametro chiamato auto_train impostato su True per impostazione predefinita. Ciò significa che la domanda verrà aggiunta automaticamente al set di dati di addestramento. Possiamo confermarlo utilizzando la seguente sintassi:

training_data = vn.get_training_data()
training_data('question').str.contains('What are the top 5 jazz artists by sales?').any()

Nonostante le impressionanti capacità del vn.ask(domanda) funzione, mi chiedo come funzionerà nel mondo reale, probabilmente database più grandi e complessi. Inoltre, non importa quanto potente sia il LLM sottostante, il processo di formazione sembra essere la chiave per un’elevata precisione. Di quanti dati di allenamento abbiamo bisogno? Che rappresentanza deve avere? Puoi accelerare il processo di formazione per sviluppare un modello pratico e operativo?

D’altronde Vanna è un progetto completamente nuovo e molte cose potrebbero essere migliorate. Ad esempio, le visualizzazioni della trama non sembrano molto convincenti e non sembrano esserci strumenti per personalizzarle. Inoltre, la documentazione potrebbe essere chiarita e arricchita con esempi illustrativi.

Inoltre, ho notato alcuni problemi tecnici che non dovrebbero essere difficili da risolvere. Ad esempio, quando si desidera conoscere solo un punto dati, la funzione si interrompe quando si tenta di costruire il grafico, il che ha senso perché, in questi scenari, una visualizzazione è inutile. Ma il problema è che non vedi le domande successive e, cosa ancora più importante, non puoi decomprimere la tupla.

Ad esempio, guarda cosa succede quando vuoi conoscere il dipendente più anziano.

vn.ask(question='Who is the oldest employee')

Conclusione

Vanna è uno dei tanti strumenti che stanno cercando di sfruttare la potenza degli LLM per rendere SQL accessibile a tutti, indipendentemente dalla loro conoscenza tecnica. I risultati sono promettenti, ma c’è ancora molta strada da fare per sviluppare agenti AI in grado di rispondere a ogni azienda con query SQL precise. Come abbiamo visto in questo tutorial, sebbene i potenti LLM svolgano un ruolo essenziale nell’equazione, il segreto risiede ancora nei dati di addestramento. Data l’ubiquità di SQL nelle aziende di tutto il mondo, l’automazione delle attività di scrittura delle query può rappresentare un punto di svolta. Pertanto, vale la pena osservare come si evolveranno in futuro gli strumenti SQL basati sull’intelligenza artificiale come Vanna.

Punti chiave

• L’intelligenza artificiale generativa e i LLM stanno rapidamente cambiando la scienza dei dati tradizionale.
• Scrivere SQL è un compito impegnativo e dispendioso in termini di tempo che spesso provoca colli di bottiglia nei progetti basati sui dati.
• SQL potrebbe diventare più semplice e accessibile grazie agli strumenti di intelligenza artificiale di prossima generazione.
• Vanna è uno dei tanti strumenti che cercano di affrontare questo problema con la potenza dei LLM

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell’autore.

Imparentato