Améliorer le chatbot avec la génération de code : créer un chatbot contextuel pour les publications

Introduction

Depuis que ChatGPT a captivé l’imagination du public au début de 2023, il y a eu une explosion d’intérêt pour la commercialisation de grandes applications basées sur des modèles de langage. L'une des applications les plus intéressantes a été la création de systèmes de chat experts capables de répondre à des requêtes en langage naturel à partir d'une base de données de connaissances exclusive.

L'une des techniques les plus populaires dans cet espace est la [génération augmentée par récupération](https://retrieval augmentéd Generation aws), ou RAG, qui utilise l'incorporation de documents pour rechercher des éléments pertinents pour la requête de l'utilisateur avant d'utiliser un grand modèle de langage pour générer une réponse.

La technique est extrêmement puissante car elle permet des recherches extrêmement rapides et peu coûteuses, offre une flexibilité extrême pour que la base de connaissances change et évolue au fil du temps, et des réponses hautement informées et précises qui réduisent considérablement les hallucinations et les erreurs.

Pour une analyse plus approfondie des systèmes RAG et comment en mettre en œuvre un, vous pouvez lire mon article précédent ici .

Aussi puissants que puissent être les systèmes RAG, leur architecture présente de graves limitations. Nous avons exploré certaines des limitations dans mon article précédent et proposé des moyens d'améliorer l'architecture.

Aujourd'hui, nous allons explorer une autre limitation de l'architecture basée sur l'intégration et proposer un moyen de contourner les limites de l'architecture.

Énoncé du problème

Limites du RAG basé sur les intégrations

Supposons que nous soyons une publication qui souhaite créer une interface de discussion permettant aux lecteurs et aux clients de poser des questions.

Bien entendu, nous pourrons répondre à des questions telles que « Quelle est votre opinion sur X ? » ou "Qu'avez-vous dit à propos de Y ?" avec une simple implémentation RAG, mais une architecture RAG commence vraiment à avoir des difficultés lorsque vous êtes confronté à des questions telles que « Qu'avez-vous dit à propos de X en 2021 ? ou « Comment votre couverture de Y a-t-elle évolué entre 2021 et 2023 ? »

L'un des défis d'un RAG basé sur les intégrations est que les modèles d'intégration sont généralement incapables d'encoder les métadonnées de manière systématique. Par conséquent, toute recherche nécessitant la connaissance d'éléments tels que la date de publication ou le nom de l'auteur posera pas mal de problèmes à votre système RAG. .

Nous pouvons résoudre ce problème en exploitant l’une des fonctionnalités les plus intéressantes des grands modèles de langage : la génération de code. Nous examinerons une publication réelle, concevrons un algorithme basé sur LLM qui améliore l'architecture RAG et construirons un chatbot basé sur l'algorithme.

Problème commercial

Aujourd'hui, nous examinerons la CB Insights Newsletter, une newsletter quotidienne populaire couvrant les startups et la technologie. En tant qu'ancien développeur full-stack chez CB Insights, j'attendais souvent avec impatience l'esprit et la perspicacité uniques du fondateur à la fin de la journée de travail.

Aujourd'hui, nous utiliserons les archives de la newsletter CB Insights comme données de base pour créer un chatbot capable de répondre aux requêtes en langage naturel basées sur des métadonnées d'une manière supérieure à une implémentation RAG basée sur Vanilla Embeddings.

Plus précisément, nous souhaitons que le chatbot soit capable de répondre à des questions telles que :

• Qu'avez-vous dit d'Uber en 2020 ?

• Comment la fortune d’Airbnb a-t-elle changé entre 2016 et 2019 ?

• Quelles sont les startups licornes notables de l’Inde dans les années 2020 ?

Allons-y !

Technologies utilisées

Pour accomplir cette tâche, nous utiliserons les technologies suivantes :

Python

Si vous avez suivi mes autres articles , il n'est pas surprenant que j'utilise Python pour la plupart du code de cet article. Python dispose d'excellents web scraping, traitement de données et intégration OpenAI, que nous exploiterons tous pour notre projet aujourd'hui.

SQL

SQL est le langage de requête qui permet aux utilisateurs d'interagir avec plusieurs bases de données relationnelles majeures, notamment SQLite, MySQL, PostgreSQL et SQL Server. Le langage est un ensemble d'instructions destinées à la base de données sur la manière de récupérer, combiner et manipuler les données avant de les renvoyer à l'utilisateur.

Génération de code LLM

La génération de code LLM est une technique qui a suscité une grande attention au cours des derniers mois, car plusieurs modèles de base, dont GPT 3.5, GPT 4 et LLaMa 2, ont démontré la capacité à générer du code d'une complexité surprenante en réponse à des requêtes en langage naturel.

Des systèmes spécialement formés et réglés, tels que Copilot de GitHub, sont capables d'écrire du code remarquablement intelligent en utilisant des modèles spécialement conçus pour la génération de code, mais un modèle GPT à usage général correctement invité possède déjà des capacités exceptionnelles en matière d'écriture de code.

Incorporation sémantique

L'intégration sémantique est l'épine dorsale de la plupart des implémentations RAG. En utilisant une série de techniques de langage naturel, nous pouvons transformer un texte en langage naturel en un vecteur de nombres qui représentent le contenu du texte dans un espace vectoriel sémantique.

Nous pouvons ensuite utiliser l’algèbre vectorielle pour manipuler ces plongements, ce qui nous permet de déterminer la relation entre deux corpus de textes à l’aide de méthodes mathématiques.

GPT-3.5 et GPT-4

Avec 1,7 billion de paramètres, GPT-4 est tout simplement le modèle de langage étendu basé sur un transformateur le plus puissant disponible sur le marché aujourd'hui. GPT-4 est capable de comprendre de grands corps de texte, des raisonnements complexes et de générer des réponses convaincantes et de longue durée en réponse à des invites difficiles.

GPT-3.5, le cousin beaucoup plus petit de GPT-4, est le modèle qui a propulsé ChatGPT lorsqu'il a pris d'assaut le monde. Il est capable de traiter des invites incroyablement complexes, et ce qui lui manque en termes de capacité de raisonnement pur, il le compense en termes de rapidité et d'économies de coûts.

Pour les tâches plus simples, GPT3.5 établit l’équilibre entre performances et précision.

Configuration du backend du chatbot

Configuration de la base de données

Avant de construire notre IA, nous devons obtenir les données. Pour ce faire, nous pouvons utiliser la page d'archives des newsletters de CB Insights [ https://www.cbinsights.com/newsletter/ ] qui contient une collection de newsletters passées.

Pour obtenir tous les liens, nous pouvons utiliser les requêtes de Python et la magnifique bibliothèque de soupes comme ceci :

 import requests from bs4 import BeautifulSoup res = requests.get('https://www.cbinsights.com/newsletter/') soup = BeautifulSoup(res.text) article_links = [[i.text, i['href']] for i in soup.find_all('a') if 'campaign-archive' in i['href'] ]

Une fois que nous avons les liens, nous pouvons accéder à chacun des liens et télécharger l'article HTML. Avec la compréhension de liste de Python, nous pouvons le faire en une seule ligne :

 article_soups = [BeautifulSoup(requests.get(link[1]).text) for link in article_links]

Cela prendra un certain temps, mais à terme, tous les liens devraient être supprimés.

Maintenant, nous pouvons utiliser BeautifulSoup pour extraire les sections pertinentes :

 import re # SEO optimizations cause some articles to appear twice so we dedupe them. # We also remove some multiple newlines and unicode characters. def get_deduped_article_tables(article_table): new_article_tables = [] for i in article_table: text_content = re.sub(r'\n{2,}', '\n', i.replace('\xa0', '').strip()) if text_content not in new_article_tables or text_content == '': new_article_tables.append(text_content) return new_article_tables result_json = {} for soup_meta, soup_art in zip(article_links, article_soups): article_tables = [] cur_article = [] for table in soup_art.find_all('table'): if table.attrs.get('mc:variant') == 'Section_Divider': article_tables.append(get_deduped_article_tables(cur_article)) cur_article = [] else: cur_article.append(table.text) article_tables.append(get_deduped_article_tables(cur_article)) result_json[soup_meta[0]] = article_tables

Faisons un peu plus de traitement et transformons-le en DataFrame :

 import pandas as pd result_rows = [] for article_name, article_json in result_json.items(): article_date = article_json[0][1] for idx, tbl in enumerate(article_json[1:]): txt = '\n'.join(tbl).strip() if txt != '': result_rows.append({ 'article_name': article_name, 'article_date': article_date, 'idx': idx, 'text': txt, }) df = apd.DataFrame(result_rows)

Si vous inspectez le dataframe, vous devriez voir quelque chose comme ci-dessous :

Pendant que nous disposons des données, générons également les intégrations pour les articles. Avec le modèle d'intégration ada d'OpenAI, c'est assez simple.

 import openai EMBEDDING_MODEL = "text-embedding-ada-002" openai.api_key = [YOUR KEY] df['embedding'] = df['text'].map(lambda txt: openai.Embedding.create(model=EMBEDDING_MODEL, input=[txt])['data'][0]['embedding'])

Maintenant que nous disposons des données que nous utilisons pour cet exercice, chargeons-les dans une base de données. Pour cet exercice, nous utiliserons SQLite, un système de base de données léger et autonome fourni avec Python.

Veuillez noter que dans un environnement de production, vous souhaiterez probablement utiliser une instance de base de données appropriée telle que MySQL ou PostgreSQL avec des modifications mineures du SQL que nous utilisons ici, mais la technique générale restera la même.

Pour instancier et charger la base de données, exécutez simplement ce qui suit en Python. Notez qu'en plus du texte de l'article et des intégrations, nous sauvegardons également certaines métadonnées, à savoir la date de publication.

Notez également que SQLite3, contrairement à la plupart des autres bases de données SQL, utilise un système de typage dynamique, nous n'avons donc pas besoin de spécifier les types de données dans la requête de création.

 import sqlite3 import json con = sqlite3.connect("./cbi_article.db") cur = con.cursor() cur.execute("CREATE TABLE article(name, date, idx, content, embedding_json)") con.commit() rows = [] for _, row in df.iterrows(): rows.append([row['article_name'], row['article_date'], row['idx'], row['text'], json.dumps(row['embedding'])]) cur.executemany("INSERT INTO article VALUES (?, ?, ?, ?, ?)", rows) con.commit()

Et essayons d'interroger les données.

 res = cur.execute(""" SELECT name, date, idx FROM article WHERE date >= DATE('now', '-2 years'); """) res.fetchall()

Cela devrait donner quelque chose comme :

Ça a l'air plutôt bien !

Création d'un générateur de code pour la recherche de métadonnées

Maintenant que les données sont chargées dans la base de données SQLite, nous pouvons passer à l'étape suivante. N'oubliez pas que l'un des défis liés à la mise en œuvre de RAG avec intégration uniquement est le manque de fonctionnalités flexibles de recherche de métadonnées.

Cependant, maintenant que les métadonnées sont chargées dans une base de données SQL, nous pouvons utiliser les capacités de génération de code de GPT pour effectuer des recherches de métadonnées flexibles.

Pour générer du code SQL, nous pouvons utiliser une simple ingénierie d'invite.

 response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a SQL query writer that can construct queries based on incoming questions. Answer with only the SQL query."}, {"role": "user", "content": """ Suppose we have the SQLite database table called "article" with the following columns, which contains newsletter articles from a publication: name, date, idx, content, embedding_json Write a question that would retrieve the rows necessary to answer the following user question. Only filter on date. Do not filter on any other column. Make sure the query returns every row in the table by name. Reply only with the SQL query. User question: What did you say about the future of the fintech industry in summer of 2022? """}, ] )

Notez l'ingénierie d'invite suivante 1) nous donnons le schéma de la base de données mais restons simple. 2) Nous précisons les colonnes de retour. 3) Nous spécifions les colonnes disponibles pour le filtrage. 4) Nous spécifions la saveur SQL. Cette invite devrait générer du code SQL comme celui ci-dessous :

 SELECT * FROM article WHERE date BETWEEN '2022-06-01' AND '2022-08-31'

Maintenant, comme la valeur de retour n'est pas déterministe, vous vous retrouverez parfois avec des particularités dans votre code généré. Pour gérer ces conditions, nous pouvons simplement avoir une boucle try-catch pour essayer de régénérer les données. Nous ne voulons pas faire cela indéfiniment, bien sûr, donc si nous ne pouvons pas générer un code SQL approprié en trois essais, nous allons simplement quitter et revenir à Vanilla RAG.

Nous pouvons implémenter le filtre comme ceci :

 res = [] for i in range(3): response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a SQL query writer that can construct queries based on incoming questions. Answer with only the SQL query."}, {"role": "user", "content": """ Suppose we have the SQLite database table called "article" with the following columns, which contains newsletter articles from a publication: name, date, idx, content, embedding_json Write a question that would retrieve the rows necessary to answer the following user question. Only filter on date. Do not filter on any other column. Make sure the query returns every row in the table by name. Reply only with the SQL query. User question: What did you say about the future of the fintech industry in summer of 2022? """}, ] ) generated_query = response.choices[0].message['content'] is_query_safe = True for no_use_word in {'DELETE', 'UPDATE', 'DROP'}: if no_use_word in generated_query.upper(): is_query_safe = False if not is_query_safe: break # the user input is likely malicious. Try to answer the question with vanilla RAG res = cur.execute(generated_query).fetchall() if len(res) > 0: break if len(res) == 0: # vanilla RAG in memory. Use a vector DB in production please. res = cur.execute('''SELECT * FROM articles''').fetchall()

Il s'agit d'un filtre relativement rudimentaire, donc dans les cas d'utilisation en production, vous souhaiterez probablement effectuer davantage de vérifications de pertinence et d'exactitude SQL, mais cela est suffisant pour notre exemple.

Une note rapide sur la sécurité de l'IA : nous devons être prudents lors de l'exécution du code renvoyé par une IA, en particulier si l'entrée de l'utilisateur a été utilisée dans le cadre de l'invite.

Si nous ne nettoyons pas la sortie, nous nous laissons vulnérables aux attaques d'ingénierie rapide où l'utilisateur tente de manipuler l'IA pour générer des instructions de mise à jour ou de suppression.

Par conséquent, nous devons toujours vérifier que le résultat est conforme à nos attentes avant d’exécuter le code sur notre ordinateur.

Exécutez le code suivant pour voir le résultat récupéré :

 df = pd.DataFrame([{c[0]: v for c, v in zip(cur.description, row)} for row in res])

Et maintenant, vous devriez voir le résultat suivant :

Exécution de RAG standard avec le résultat

Maintenant que nous avons le résultat de la recherche de métadonnées, le reste est simple. Nous calculons la similarité cosinus pour tous les résultats récupérés comme suit :

 from openai.embeddings_utils import cosine_similarity q_embed = openai.Embedding.create(model=EMBEDDING_MODEL, input=[user_question])['data'][0]['embedding'] df['cosine_similarity'] = df['embedding_json'].map(lambda js: cosine_similarity(json.loads(js), q_embed))

Et maintenant, nous pouvons prendre les 10 meilleures newsletters et utiliser l’ingénierie rapide pour répondre à la question. Nous en avons choisi 10 ici car chaque extrait de newsletter est relativement court.

Si vous travaillez avec des articles plus longs, vous souhaiterez potentiellement utiliser moins d'articles ou utiliser la technique décrite dans la section bonus.

 answer_prompt = ''' Consider the following newsletter excerpts from the following dates: ''' for _, row in df.sort_values('cosine_similarity', ascending=False).iloc[:10].iterrows(): answer_prompt += """ ======= Date: %s ==== %s ===================== """ % (row['date'], row['content']) answer_prompt += """ Answer the following question: %s """ % user_question response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a tech analyst that can summarize the content of newsletters"}, {"role": "user", "content": answer_prompt}, ] )

Cela devrait vous donner un résultat similaire à celui-ci :

L'avenir de la Fintech a été abordé dans diverses newsletters au cours de l'été 2022. Il y a eu un ralentissement notable dans la Fintech alors que le financement du deuxième trimestre 2022 a chuté vers les niveaux de 2020, après un sommet en 2021. Le rapport du deuxième trimestre 2022 a souligné la baisse des investissements mondiaux dans la fintech. .

Cependant, l'avenir de la fintech semble prometteur, car une évolution significative vers les startups en phase de démarrage a été constatée, en particulier dans le domaine des paiements. Les investissements mondiaux dans le secteur des paiements ont chuté de 43 % par rapport au premier trimestre 2022, pour atteindre 5,1 milliards de dollars au deuxième trimestre 2022, en raison du retour à la normale du financement après les sommets de 2021.

Les nouveaux entrants dans ce domaine ont attiré une part plus élevée de transactions (63 %) jusqu’à présent en 2022, ce qui témoigne de l’intérêt des investisseurs pour les start-ups. Il a également été signalé que la concurrence croissante que la Fintech faisait peser sur les banques de détail, les obligeant à donner la priorité à la numérisation des services de base.

Le secteur bancaire a réagi en se concentrant sur l'amélioration de l'expérience client, en particulier les services bancaires mobiles, en utilisant des technologies telles que les chatbots et les plateformes d'analyse client. Tout cela laisse présager une industrie FinTech dynamique et compétitive à venir.

Ce qui est plutôt bien ! Si vous vérifiez la réponse en consultant l'invite de réponse, vous remarquerez que les statistiques proviennent toutes du matériel source. Vous remarquerez également qu'il existe un formatage idiosyncrasique dans le matériel source que GPT4 a pu ignorer. Cela montre la flexibilité des LLM dans les systèmes de synthèse de données.

Bonus : middleware de synthèse

L’un des problèmes que vous pouvez rencontrer au cours de ce processus est que, lorsque le corpus est extrêmement volumineux, l’invite finale peut être très volumineuse. Cela peut être coûteux si vous utilisez GPT-4, mais une invite très longue risque également de confondre le modèle.

Pour résoudre ce problème, nous pouvons prétraiter les articles individuels avec GPT-3.5, en compressant l'invite finale que nous envoyons à GPT-4 à l'étape finale.

 summarization_prompt = ''' Summarize the following passage and extract only portions that are relevant to answering the user question. Passage: ======= %s ======= User Questions: %s ''' (row['content'], user_question) response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "You are a summarizer of tech industry reports"}, {"role": "user", "content": summarization_prompt}, ] )

Nous pouvons ensuite insérer les résumés dans l'invite finale, ce qui représente des économies significatives par rapport à l'insertion de l'article pur dans l'invite finale.

Construire une interface simple

Maintenant que nous avons écrit le code Python, intégrons-le sous la forme d'une simple application Web.

API back-end

Il est relativement simple de conditionner le code en tant qu'API backend avec Flask. Créez simplement une fonction et liez-la à Flask comme ceci :

 import requests from bs4 import BeautifulSoup import re import pandas as pd import sqlite3 import json import openai from openai.embeddings_utils import cosine_similarity from flask import Flask, request, jsonify from flask_cors import CORS app = Flask(__name__) CORS(app) EMBEDDING_MODEL = "text-embedding-ada-002" openai.api_key = [Your OpenAI Key] db_location = [Location of your SQLite DB] def process_user_query(user_question): con = sqlite3.connect(db_location) cur = con.cursor() user_question = 'What did you say about the future of the fintech industry in summer of 2022?' res = [] for i in range(3): response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a SQL query writer that can construct queries based on incoming questions. Answer with only the SQL query."}, {"role": "user", "content": """ Suppose we have the SQLite database table called "article" with the following columns, which contains newsletter articles from a publication: name, date, idx, content, embedding_json Write a question that would retrieve the rows necessary to answer the following user question. Only filter on date. Do not filter on any other column. Make sure the query returns every row in the table by name. Reply only with the SQL query. User question: What did you say about the future of the fintech industry in summer of 2022? """}, ] ) generated_query = response.choices[0].message['content'] is_query_safe = True for no_use_word in {'DELETE', 'UPDATE', 'DROP'}: if no_use_word in generated_query.upper(): is_query_safe = False if not is_query_safe: break # the user input is likely malicious. Try to answer the question with vanilla RAG res = cur.execute(generated_query).fetchall() if len(res) > 0: break if len(res) == 0: # vanilla RAG in memory. Use a vector DB in production please. res = cur.execute('''SELECT * FROM articles''').fetchall() df = pd.DataFrame([{c[0]: v for c, v in zip(cur.description, row)} for row in res]) q_embed = openai.Embedding.create(model=EMBEDDING_MODEL, input=[user_question])['data'][0]['embedding'] df['cosine_similarity'] = df['embedding_json'].map(lambda js: cosine_similarity(json.loads(js), q_embed)) answer_prompt = ''' Consider the following newsletter excerpts from the following dates: ''' for _, row in df.sort_values('cosine_similarity', ascending=False).iloc[:10].iterrows(): answer_prompt += """ ======= Date: %s ==== %s ===================== """ % (row['date'], row['content']) answer_prompt += """ Answer the following question: %s """ % user_question response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a tech analyst that can summarize the content of newsletters"}, {"role": "user", "content": answer_prompt}, ] ) return response.choices[0].message['content'] @app.route('/process_user_question', methods=["POST"]) def process_user_question(): return jsonify({ 'status': 'success', 'result': process_user_query(request.json['user_question']) }) app.run()

Et c’est en fait tout ce que nous devons faire pour le backend !

Code frontal

Étant donné que nous n'avons qu'un seul point de terminaison et que nous n'avons pas besoin de beaucoup d'états dans notre application, le code frontal devrait être assez simple. Rappelez-vous dans un article précédent, nous avons mis en place une application React avec un routage qui nous permet de restituer des composants sur des itinéraires spécifiques.

Suivez simplement les instructions de cet article pour configurer un projet React.JS et ajoutez le composant suivant sur un itinéraire de votre choix :

 import React, {useState, useEffect} from 'react'; import axios from 'axios'; const HNArticle = () => { const [result, setResult] = useState(''); const [message, setMessage] = useState(''); const [question, setQuestion] = useState(''); const askQuestion = () => { axios.post("http://127.0.0.1:5000/process_user_question", {user_question: question}) .then(r => r.data) .then(d => { console.log(d); setResult(d.result); }); } return <div className="row" style={{marginTop: '15px'}}> <div className="col-md-12" style={{marginBottom: '15px'}}> <center> <h5>Hackernoon CB Insights Demo</h5> </center> </div> <div className="col-md-10 offset-md-1 col-sm-12 col-lg-8 offset-lg-2" style={{marginBottom: '15px'}}> <ul className="list-group"> <li className="list-group-item"> <h6>Your Question</h6> <p><input className="form-control" placeholder="Question" value={question} onChange={e => setQuestion(e.target.value)} /></p> <p>{message}</p> <p> <button className="btn btn-primary" onClick={askQuestion}>Ask</button> </p> </li> {result? <li className="list-group-item"> <h6>Response</h6> {result.split("\n").map((p, i) => <p key={i}>{p}</p>)} </li>: ''} </ul> </div> </div>; } export default HNArticle;

Exécutez le code et vous devriez voir une interface comme celle-ci :

Posez une question, et après un petit moment, vous devriez voir le résultat :

Et voilà ! Nous avons réussi à créer un chatbot avec des capacités de requête avancées au-delà d'un système RAG vanille !

Conclusion

Dans l'article d'aujourd'hui, nous avons créé un chatbot doté de puissantes capacités de génération de code. Il s’agit d’un exemple d’une nouvelle classe d’applications LLM actuellement créées par de nombreux pionniers de l’IA, qui peuvent exploiter les données, les langages de programmation et la compréhension du langage naturel pour créer des systèmes d’IA génératifs dotés d’un savoir-faire spécialisé.

Ces systèmes spécialisés sont la clé pour débloquer la viabilité commerciale des applications LLM cherchant à offrir une valeur au-delà de ce qui est directement disponible auprès des fournisseurs de plateformes comme OpenAI et Anthropic.

La génération de code n'est que l'une des techniques rendues possibles par la génération récente de grands modèles de langage disponibles dans le commerce.

Si vous avez des idées sur la façon dont les LLM peuvent être commercialisés ou si vous souhaitez avoir une conversation sur l'IA, n'hésitez pas à nous contacter sur LinkedIn ou GitHub . J’ai eu de nombreuses conversations enrichissantes avec des lecteurs au cours de l’année dernière et j’attends avec impatience bien d’autres !