Tutoriel DuckDB : créer des projets IA

Récemment, DuckDB est sorti de bêta et a publié une version stable. Adoptié à grande vitesse à mesure que divers frameworks de données l'intègrent à leurs écosystèmes, c'est le moment idéal pour apprendre DuckDB et garder une longueur d'avance dans le monde des données et de l'IA qui évolue sans cesse.

Dans ce tutoriel, nous allons découvrir DuckDB et ses points forts avec des exemples de code. Notre objectif principal sera de voir comment l'intégrer aux frameworks d'IA actuels. Pour cela, nous réaliserons deux projets : nous commencerons par créer une application de Retrieval-Augmented Generation (RAG) en utilisant DuckDB comme base vectorielle. Puis nous emploierons DuckDB comme moteur de requêtes IA pour analyser des données en langage naturel plutôt qu'en SQL.

Qu'est-ce que DuckDB ?

DuckDB est un SGBD analytique moderne, haute performance, en mémoire, conçu pour prendre en charge des requêtes analytiques complexes. C'est un SGBD relationnel (orienté tables) qui prend en charge le langage SQL.

DuckDB allie la simplicité et la facilité d'utilisation de SQLite aux performances nécessaires pour les charges analytiques, ce qui en fait un excellent choix pour les data scientists et les analystes.

Fonctionnalités clés

\n
1. Simplicité d'exploitation : DuckDB est serverless, sans dépendances externes, et s'exécute en mode embarqué dans un processus hôte. L'installation et le déploiement sont très simples : un compilateur C++11 suffit pour la construction.
\n
2. Riche en fonctionnalités : il prend en charge un large éventail de capacités SQL pour la gestion des données. DuckDB offre également une intégration poussée avec Python et R, idéale pour la data science et l'analyse interactive.
\n
3. Requêtes analytiques rapides : DuckDB utilise un moteur d'exécution de requêtes vectoriel en colonnes, optimisé pour l'analytique, permettant le traitement parallèle et la gestion efficace de jeux de données volumineux.
\n
4. Gratuit et open source : publié sous licence MIT permissive, il est gratuit et open source.
\n
5. Portabilité : sans dépendances externes, DuckDB est hautement portable et fonctionne sur plusieurs systèmes d'exploitation (Linux, macOS, Windows) et architectures CPU (x86, ARM). Il peut même s'exécuter dans les navigateurs via DuckDB-Wasm.
\n
6. Extensibilité : DuckDB prend en charge un mécanisme d'extensions flexible, permettant d'ajouter de nouveaux types de données, fonctions, formats de fichiers et syntaxes SQL.
\n
7. Tests approfondis : soumis à des tests intensifs en intégration continue, avec une batterie contenant des millions de requêtes, garantissant stabilité et fiabilité sur différentes plates-formes et compilateurs.
\n

Premiers pas avec DuckDB

Dans cette section, nous allons configurer DuckDB, charger des fichiers CSV, réaliser une analyse de données et découvrir les relations et fonctions de requête.

Commençons par installer le package Python DuckDB.

pip install duckdb --upgrade

Créer la base DuckDB

Pour créer une base persistante, il suffit d'utiliser la fonction connect et de lui fournir un nom de base de données.

import duckdb\ncon = duckdb.connect(\"datacamp.duckdb\")

Un fichier de base de données sera créé dans votre répertoire local.

Nous allons charger un fichier CSV et créer une table \"bank\". Le jeu de données utilisé est disponible dans DataLab et s'appelle Bank Marketing. Il regroupe des campagnes de marketing direct réalisées par une banque portugaise via des appels téléphoniques.

Pour charger le CSV, commencez par créer une table en SQL, puis utilisez la fonction read_csv() dans le script SQL pour charger le fichier. C'est aussi simple que ça.

Nous validerons ensuite la table en exécutant un script SQL listant toutes les tables de la base et en utilisant la fonction fetchdf pour afficher le résultat sous forme de DataFrame pandas.

Remarque : nous utilisons DataLab de DataCamp comme éditeur de code. DataLab est un Jupyter Notebook cloud, accessible gratuitement avec un compte DataCamp.

con.execute(\"\"\"\n    CREATE TABLE IF NOT EXISTS bank AS \n    SELECT * FROM read_csv('bank-marketing.csv')\n\"\"\")\ncon.execute(\"SHOW ALL TABLES\").fetchdf()

Maintenant que notre première table est créée, exécutons une requête débutant pour analyser les données et afficher le résultat sous forme de DataFrame.

con.execute(\"SELECT * FROM bank WHERE duration < 100 LIMIT 5\").fetchdf()

DuckDB est intégré nativement dans le nouveau DataLab de DataCamp. Pour en savoir plus, lisez l'article \u00ab DuckDB Makes SQL a First-Class Citizen on DataLab\u00a0\u00bb et testez la cellule SQL interactive pour analyser des données.

Relations DuckDB

Les relations DuckDB sont essentiellement des tables que l'on peut interroger via l'API relationnelle. Cette API permet d'enchaîner différentes opérations de requête sur des sources comme des DataFrames Pandas. Au lieu d'écrire du SQL, vous enchaînerez des fonctions Python pour analyser les données.

Par exemple, chargeons un CSV pour créer une relation DuckDB. Pour analyser la table, enchaînons les fonctions de filtre et de limitation.

bank_duck = duckdb.read_csv(\"bank-marketing.csv\",sep=\";\")\nbank_duck.filter(\"duration < 100\").limit(3).df()

Nous pouvons aussi créer des relations en chargeant la table depuis la base DuckDB.

rel = con.table(\"bank\")\nrel.columns

['age',\n 'job',\n 'marital',\n 'education',\n 'default',\n 'housing',\n 'loan',\n 'contact',\n 'month',\n 'day_of_week',\n 'duration',\n 'campaign',\n 'pdays',\n 'previous',\n 'poutcome',\n 'emp.var.rate',\n 'cons.price.idx',\n 'cons.conf.idx',\n 'euribor3m',\n 'nr.employed',\n 'y']

Écrivons une relation qui enchaîne plusieurs fonctions pour analyser les données.

rel.filter(\"duration < 100\").project(\"job,education,loan\").order(\"job\").limit(3).df()

Nous obtenons trois lignes et des colonnes triées par \"job\" et filtrées sur \"duration\".

Fonction de requête DuckDB

La fonction de requête DuckDB permet d'exécuter des requêtes SQL dans la base et de renvoyer des résultats convertibles en différents formats pour analyse.

Dans l'exemple, nous exécutons une requête SQL pour lister les métiers de clients de plus de 30 ans, compter le nombre de clients contactés par métier et calculer la durée moyenne de campagne.

Suivez le parcours SQL Fundamentals pour apprendre à gérer une base relationnelle et exécuter des requêtes pour une analyse simple.

res = duckdb.query(\"\"\"SELECT \n                            job,\n                            COUNT(*) AS total_clients_contacted,\n                            AVG(duration) AS avg_campaign_duration,\n                        FROM \n                            'bank-marketing.csv'\n                        WHERE \n                            age > 30\n                        GROUP BY \n                            job\n                        ORDER BY \n                            total_clients_contacted DESC;\"\"\")\nres.df()

Nous allons maintenant fermer la connexion à la base et libérer les ressources associées pour éviter toute fuite de mémoire ou de descripteurs de fichiers.

con.close()

Si vous rencontrez des difficultés pour exécuter le code ci-dessus, consultez l'espace de travail Getting Started with DuckDB.

Créer une application RAG avec DuckDB

Dans le premier projet, nous allons créer une application RAG avec LlamaIndex et utiliser DuckDB comme base vectorielle et comme retriever.

Configuration

Installez tous les packages Python nécessaires pour créer et interroger l'index.

%%capture\n%pip install duckdb\n%pip install llama-index\n%pip install llama-index-vector-stores-duckdb

Importez les packages Python et fonctions nécessaires.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader\nfrom llama_index.vector_stores.duckdb import DuckDBVectorStore\nfrom llama_index.core import StorageContext\n\nfrom IPython.display import Markdown, display

Configurer GPT-4o et le modèle d'embed

Comme modèle de langage, nous utiliserons le tout dernier modèle GPT4o via l'API OpenAI. Pour créer le client LLM, indiquez simplement le nom du modèle et votre clé API.

import os\nfrom llama_index.llms.openai import OpenAI\n\nllm = OpenAI(model=\"gpt-4o\",api_key=os.environ[\"OPENAI_API_KEY\"])

Ensuite, nous créerons le client d'embed avec le modèle OpenAI text-embedding-3-small.

Remarque : la clé API OpenAI est facultative si la variable d'environnement nommée « OPENAI_API_KEY » est déjà définie sur votre environnement de développement.

from llama_index.embeddings.openai import OpenAIEmbedding\nembed_model = OpenAIEmbedding(\n    model=\"text-embedding-3-small\",\n)

Nous allons rendre les modèles OpenAI LLM et Embedding globaux pour toutes les fonctions LlamaIndex. En bref, ils seront définis par défaut.

from llama_index.core import Settings\n\nSettings.llm = llm\nSettings.embed_model = embed_model

Utiliser DuckDB comme base vectorielle

Pour notre projet, nous chargerons les fichiers PDF du dossier data. Ces PDF sont des tutoriels DataCamp enregistrés en PDF via la fonction d'impression du navigateur.

Indiquez le répertoire au sein de la fonction SimpleDirectoryReader et chargez les données.

documents = SimpleDirectoryReader(\"Data\").load_data()

Créez ensuite le magasin vectoriel appelé \u00ab blog \u00bb en utilisant la base existante \u00ab datacamp.duckdb \u00bb. Puis convertissez le contenu des PDF en embeddings et stockez-les dans ce magasin.

vector_store = DuckDBVectorStore(database_name = \"datacamp.duckdb\",table_name = \"blog\",persist_dir=\"./\", embed_dim=1536)\nstorage_context = StorageContext.from_defaults(vector_store=vector_store)\n\nindex = VectorStoreIndex.from_documents(\n    documents, storage_context=storage_context\n)

Pour vérifier la création du magasin vectoriel, connectez-vous à la base via l'API Python de DuckDB et exécutez une requête SQL listant toutes les tables.

import duckdb\ncon = duckdb.connect(\"datacamp.duckdb\")\n\ncon.execute(\"SHOW ALL TABLES\").fetchdf()

Nous avons deux tables : une table promotionnelle \u00ab bank \u00bb et une table \u00ab blog \u00bb, qui est le magasin vectoriel. La table \u00ab blog \u00bb contient une colonne \u00ab embedding \u00bb où sont stockés tous les embeddings.

Créer une application RAG simple

Transformez l'index en moteur de requêtes : il recherchera d'abord automatiquement des documents similaires dans la base vectorielle, puis utilisera ce contexte pour générer la réponse.

Pour tester le moteur RAG, posons une question sur le tutoriel.

query_engine = index.as_query_engine()\nresponse = query_engine.query(\"Who wrote 'GitHub Actions and MakeFile: A Hands-on Introduction'?\")\ndisplay(Markdown(f\"<b>{response}</b>\"))

Et la réponse est correcte.

The author of \"GitHub Actions and MakeFile: A Hands-on Introduction\" is Abid Ali Awan.

Créer un chatbot RAG avec mémoire

Créons maintenant une application RAG avancée qui exploite l'historique de conversation pour générer la réponse. Pour cela, nous allons créer un tampon de mémoire de chat, puis un moteur de chat combinant mémoire, LLM et retriever du magasin vectoriel.

from llama_index.core.memory import ChatMemoryBuffer\nfrom llama_index.core.chat_engine import CondensePlusContextChatEngine\n\nmemory = ChatMemoryBuffer.from_defaults(token_limit=3900)\n\nchat_engine = CondensePlusContextChatEngine.from_defaults(\n    index.as_retriever(),\n    memory=memory,\n    llm=llm\n)\n\nresponse = chat_engine.chat(\n    \"What is the easiest way of finetuning the Llama 3 model? Please provide step-by-step instructions.\"\n)\n\ndisplay(Markdown(response.response))

Nous avons demandé comment affiner le modèle Llama 3, et le moteur a utilisé le magasin vectoriel pour fournir une réponse très précise.

Pour vérifier que la mémoire fonctionne, posons une question de relance.

response = chat_engine.chat(\n    \"Could you please provide more details about the Post Fine-Tuning Steps?\"\n)\ndisplay(Markdown(response.response))

Le moteur de chat s'est souvenu de l'échange précédent et a répondu en conséquence.

Si vous rencontrez des difficultés pour exécuter le code ci-dessus, consultez l'espace de travail Building a RAG application with DuckDB.

Construire un moteur de requêtes SQL DuckDB avec un LLM

Dans le deuxième projet, nous utiliserons DuckDB comme moteur de requêtes SQL. Il s'agit d'intégrer le moteur de base avec le modèle GPT-4o pour générer des réponses en langage naturel à des questions sur la base de données.

Installez duckdb-engine pour créer un moteur de base via SQLAlchemy.

%pip install duckdb-engine -q

Charger la base DuckDB

Nous allons charger la base DuckDB avec la fonction create_engine, puis écrire une requête SQL simple pour vérifier le bon chargement.

from sqlalchemy import create_engine\n\nengine = create_engine(\"duckdb:///datacamp.duckdb\")\nwith engine.connect() as connection:\n    cursor = connection.exec_driver_sql(\"SELECT * FROM bank LIMIT 3\")\n    print(cursor.fetchall())

Parfait. Notre moteur DuckDB est prêt à l'emploi.

[(56, 'housemaid', 'married', 'basic.4y', 'no', 'no', 'no', 'telephone', 'may', 'mon', 261, 1, 999, 0, 'nonexistent', 1.1, 93.994, -36.4, 4.857, 5191.0, 'no'), (57, 'services', 'married', 'high.school', 'unknown', 'no', 'no', 'telephone', 'may', 'mon', 149, 1, 999, 0, 'nonexistent', 1.1, 93.994, -36.4, 4.857, 5191.0, 'no'), (37, 'services', 'married', 'high.school', 'no', 'yes', 'no', 'telephone', 'may', 'mon', 226, 1, 999, 0, 'nonexistent', 1.1, 93.994, -36.4, 4.857, 5191.0, 'no')]

Créons désormais un outil base de données avec la fonction SQLDatabase. Fournissez-lui l'engine et le nom de table.

from llama_index.core import SQLDatabase\nsql_database = SQLDatabase(engine, include_tables=[\"bank\"])

Construire le moteur de requêtes SQL

Créez le moteur de requêtes SQL à l'aide de NLSQLTableQueryEngine en lui passant l'objet base SQL de LlamaIndex.

from llama_index.core.query_engine import NLSQLTableQueryEngine\n\nquery_engine = NLSQLTableQueryEngine(sql_database)

Posez une question en langage naturel au moteur sur la table \u00ab bank \u00bb.

response = query_engine.query(\"Which is the longest running campaign?\")\n\n\nprint(response.response)

En retour, vous obtenez la réponse à votre question en langage naturel. Plutôt pratique, n'est-ce pas ?

The longest running campaign in the database has a duration of 4918 days.

Posons une question plus complexe.

response = query_engine.query(\"Which type of job has the most housing loan?\")\nprint(response.response)

La réponse est précise, avec des informations complémentaires.

The job type with the most housing loans is 'admin.' with 5559 housing loans. This is followed by 'blue-collar' with 4710 housing loans and 'technician' with 3616 housing loans. Other job types with significant housing loans include 'services', 'management', 'retired', 'entrepreneur', and 'self-employed'.

Pour voir ce qui se passe en coulisses, affichons les métadonnées.

print(response.metadata)

Comme on le voit, GPT-4o génère d'abord la requête SQL, l'exécute pour obtenir le résultat, puis s'appuie dessus pour formuler la réponse. Ce chaînage se réalise en deux lignes de code.

{'d4ddf03c-337e-4ee6-957a-5fd2cfaa4b1c': {}, 'sql_query': \"SELECT job, COUNT(housing) AS housing_loan_count\\nFROM bank\\nWHERE housing = 'yes'\\nGROUP BY job\\nORDER BY housing_loan_count DESC;\", 'result': [('admin.', 5559), ('blue-collar', 4710), ('technician', 3616), ('services', 2050), ('management', 1490), ('retired', 892), ('entrepreneur', 779), ('self-employed', 740), ('unemployed', 557), ('housemaid', 540), ('student', 471), ('unknown', 172)], 'col_keys': ['job', 'housing_loan_count']}

Fermez le moteur une fois le projet terminé.

engine.close()

Si vous rencontrez des difficultés pour exécuter le code ci-dessus, consultez l'espace de travail DuckDB SQL Query Engine.

Conclusion

DuckDB est rapide, simple à utiliser et s'intègre parfaitement à de nombreux frameworks données et IA. En tant que data scientist, vous verrez qu'il ne faut que quelques minutes pour se familiariser avec son API et l'utiliser comme n'importe quel package Python. L'un de ses grands atouts : l'absence de dépendances, ce qui vous permet de l'utiliser pratiquement partout sans vous soucier de l'hébergement ni d'une configuration supplémentaire.

Dans ce tutoriel, nous avons découvert DuckDB et ses fonctionnalités clés. Nous avons également exploré l'API Python de DuckDB pour créer une table et mener une analyse simple. La seconde partie a présenté deux projets : une application de Retrieval-Augmented Generation (RAG) avec DuckDB comme base vectorielle, et l'utilisation de DuckDB comme moteur de requêtes SQL.

Avant de vous lancer dans un moteur de requêtes SQL ou dans l'intégration d'une base avec l'IA, vous avez besoin des fondamentaux en SQL et en analyse de données. Vous pouvez écrire la requête, mais comment savoir quelles questions poser ? C'est là qu'intervient une base en analyse de données et en SQL. Vous pouvez l'acquérir en suivant le parcours de carrière Associate Data Analyst in SQL.