Plongez en profondeur dans JITR : l’outil d’IA générative d’ingestion et d’interrogation de PDF
Motivation
L’accès, la compréhension et la récupération d’informations à partir de documents sont au cœur d’innombrables processus dans divers secteurs. Que vous travailliez dans la finance, dans le secteur de la santé, dans un magasin de tapis familial ou en tant qu’étudiant dans une université, il existe des situations où vous voyez un gros document que vous devez lire pour répondre aux questions. Entrez dans JITR, un outil révolutionnaire qui ingère des fichiers PDF et exploite les LLM (Language Language Models) pour répondre aux requêtes des utilisateurs sur le contenu. Explorons la magie derrière JITR.
Qu’est-ce que le JITR ?
JITR, qui signifie Just In Time Retrieval, est l’un des outils les plus récents de la suite GenAI Accelerator de Simseo, conçu pour traiter les documents PDF, extraire leur contenu et fournir des réponses précises aux questions et requêtes des utilisateurs. Imaginez avoir un assistant personnel capable de lire et de comprendre n’importe quel document PDF, puis de répondre instantanément à vos questions. C’est JITR pour vous.
Comment fonctionne le JITR ?
Ingestion de PDF : La première étape consiste à ingérer un PDF dans le système JITR. Ici, l’outil convertit le contenu statique du PDF en un format numérique ingérable par le modèle d’intégration. Le modèle d’intégration convertit chaque phrase du fichier PDF en vecteur. Ce processus crée une base de données vectorielle du fichier PDF d’entrée.
Appliquer votre LLM : Une fois le contenu ingéré, l’outil appelle le LLM. Les LLM sont des modèles d’IA de pointe entraînés sur de grandes quantités de données textuelles. Ils excellent dans la compréhension du contexte, dans la détermination du sens et dans la génération de textes de type humain. JITR utilise ces modèles pour comprendre et indexer le contenu du PDF.
Requête interactive : Les utilisateurs peuvent ensuite poser des questions sur le contenu du PDF. Le LLM récupère les informations pertinentes et présente les réponses de manière concise et cohérente.
Avantages de l’utilisation de JITR
Chaque organisation produit une variété de documents générés dans un service et consommés par un autre. Souvent, la récupération d’informations pour les employés et les équipes peut prendre du temps. L’utilisation de JITR améliore l’efficacité des employés en réduisant le temps de révision de longs PDF et en fournissant des réponses instantanées et précises à leurs questions. De plus, JITR peut gérer tout type de contenu PDF, ce qui permet aux organisations de l’intégrer et de l’utiliser dans différents flux de travail sans se soucier du document d’entrée.
De nombreuses organisations peuvent ne pas disposer des ressources et de l’expertise en développement de logiciels nécessaires pour développer des outils utilisant les LLM dans leur flux de travail. JITR permet aux équipes et aux départements qui ne maîtrisent pas Python de convertir un fichier PDF en base de données vectorielle comme contexte pour un LLM. En disposant simplement d’un point de terminaison vers lequel envoyer des fichiers PDF, JITR peut être intégré à n’importe quelle application Web telle que Slack (ou d’autres outils de messagerie) ou à des portails externes pour les clients. Aucune connaissance des LLM, du traitement du langage naturel (NLP) ou des bases de données vectorielles n’est requise.
Applications du monde réel
Compte tenu de sa polyvalence, JITR peut être intégré à presque tous les flux de travail. Vous trouverez ci-dessous quelques-unes des applications.
Rapport d’activité : Les professionnels peuvent rapidement obtenir des informations à partir de longs rapports, contrats et livres blancs. De même, cet outil peut être intégré aux processus internes, permettant aux collaborateurs et aux équipes d’interagir avec les documents internes.
Service client: De la compréhension des manuels techniques à la plongée approfondie dans les didacticiels, JITR peut permettre aux clients d’interagir avec les manuels et les documents liés aux produits et aux outils. Cela peut augmenter la satisfaction des clients et réduire le nombre de tickets d’assistance et d’escalades.
Recherche et développement: Les équipes de R&D peuvent extraire rapidement des informations pertinentes et compréhensibles à partir de documents de recherche complexes pour mettre en œuvre la technologie de pointe dans le produit ou les processus internes.
Alignement avec les lignes directrices : De nombreuses organisations ont des lignes directrices qui doivent être suivies par les employés et les équipes. JITR permet aux employés de récupérer efficacement les informations pertinentes des directives.
Légal: JITR peut ingérer des documents juridiques et des contrats et répondre aux questions en fonction des informations fournies dans les documents d’entrée.
Comment créer le bot JITR avec Simseo
Le workflow de création d’un bot JITR est similaire au workflow de déploiement de n’importe quel pipeline LLM à l’aide de Simseo. Les deux principales différences sont :
- Votre base de données vectorielles est définie au moment de l’exécution
- Vous avez besoin de logique pour gérer un PDF encodé
Pour ce dernier, nous pouvons définir une fonction simple qui prend un encodage et le réécrit dans un fichier PDF temporaire au sein de notre déploiement.
```python
def base_64_to_file(b64_string, filename: str="temp.PDF", directory_path: str = "./storage/data") -> str:
"""Decode a base64 string into a PDF file"""
import os
if not os.path.exists(directory_path):
os.makedirs(directory_path)
file_path = os.path.join(directory_path, filename)
with open(file_path, "wb") as f:
f.write(codecs.decode(b64_string, "base64"))
return file_path
```
Avec cette fonction d’assistance définie, nous pouvons parcourir et créer nos crochets. Les hooks ne sont qu’une expression sophistiquée pour les fonctions portant un nom spécifique. Dans notre cas, il nous suffit de définir un hook appelé `load_model` et un autre hook appelé `score_unstructured`. Dans `load_model`, nous définirons le modèle d’intégration que nous souhaitons utiliser pour trouver les morceaux de texte les plus pertinents ainsi que le LLM que nous enverrons avec notre invite contextuelle.
```python
def load_model(input_dir):
"""Custom model hook for loading our knowledge base."""
import os
import datarobot_drum as drum
from langchain.chat_models import AzureChatOpenAI
from langchain.embeddings.sentence_transformer import SentenceTransformerEmbeddings
try:
# Pull credentials from deployment
key = drum.RuntimeParameters.get("OPENAI_API_KEY")("apiToken")
except ValueError:
# Pull credentials from environment (when running locally)
key = os.environ.get('OPENAI_API_KEY', '')
embedding_function = SentenceTransformerEmbeddings(
model_name="all-MiniLM-L6-v2",
cache_folder=os.path.join(input_dir, 'storage/deploy/sentencetransformers')
)
llm = AzureChatOpenAI(
deployment_name=OPENAI_DEPLOYMENT_NAME,
openai_api_type=OPENAI_API_TYPE,
openai_api_base=OPENAI_API_BASE,
openai_api_version=OPENAI_API_VERSION,
openai_api_key=OPENAI_API_KEY,
openai_organization=OPENAI_ORGANIZATION,
model_name=OPENAI_DEPLOYMENT_NAME,
temperature=0,
verbose=True
)
return llm, embedding_function
```Ok, nous avons donc notre fonction d’intégration et notre LLM. Nous avons également un moyen de prendre un encodage et de revenir à un PDF. Passons maintenant au cœur du robot JITR, où nous allons construire notre magasin de vecteurs au moment de l’exécution et l’utiliser pour interroger le LLM.
```python
def score_unstructured(model, data, query, **kwargs) -> str:
"""Custom model hook for making completions with our knowledge base.
When requesting predictions from the deployment, pass a dictionary
with the following keys:
- 'question' the question to be passed to the retrieval chain
- 'document' a base64 encoded document to be loaded into the vector database
datarobot-user-models (DRUM) handles loading the model and calling
this function with the appropriate parameters.
Returns:
--------
rv : str
Json dictionary with keys:
- 'question' user's original question
- 'answer' the generated answer to the question
"""
import json
from langchain.chains import ConversationalRetrievalChain
from langchain.document_loaders import PyPDFLoader
from langchain.vectorstores.base import VectorStoreRetriever
from langchain.vectorstores.faiss import FAISS
llm, embedding_function = model
DIRECTORY = "./storage/data"
temp_file_name = "temp.PDF"
data_dict = json.loads(data)
# Write encoding to file
base_64_to_file(data_dict('document').encode(), filename=temp_file_name, directory_path=DIRECTORY)
# Load up the file
loader = PyPDFLoader(os.path.join(DIRECTORY, temp_file_name))
docs = loader.load_and_split()
# Remove file when done
os.remove(os.path.join(DIRECTORY, temp_file_name))
# Create our vector database
texts = (doc.page_content for doc in docs)
metadatas = (doc.metadata for doc in docs)
db = FAISS.from_texts(texts, embedding_function, metadatas=metadatas)
# Define our chain
retriever = VectorStoreRetriever(vectorstore=db)
chain = ConversationalRetrievalChain.from_llm(
llm,
retriever=retriever
)
# Run it
response = chain(inputs={'question': data_dict('question'), 'chat_history': ()})
return json.dumps({"result": response})
```Une fois nos hooks définis, il ne nous reste plus qu’à déployer notre pipeline afin que nous disposions d’un point de terminaison avec lequel les gens peuvent interagir. Pour certains, le processus de création d’un point de terminaison sécurisé, surveillé et interrogeable à partir de code Python arbitraire peut sembler intimidant ou du moins long à mettre en place. En utilisant le package drx, nous pouvons déployer notre Bot JITR en un seul appel de fonction.
```python
import datarobotx as drx
deployment = drx.deploy(
"./storage/deploy/", # Path with embedding model
name=f"JITR Bot {now}",
hooks={
"score_unstructured": score_unstructured,
"load_model": load_model
},
extra_requirements=("pyPDF"), # Add a package for parsing PDF files
environment_id="64c964448dd3f0c07f47d040", # GenAI Dropin Python environment
)
```Comment utiliser JITR
Ok, le dur labeur est terminé. Nous pouvons maintenant profiter d’interagir avec notre nouveau déploiement. Grâce à Python, nous pouvons à nouveau profiter du package drx pour répondre à nos questions les plus urgentes.
```python
# Find a PDF
url = "https://s3.amazonaws.com/datarobot_public_datasets/drx/Instantnoodles.PDF"
resp = requests.get(url).content
encoding = base64.b64encode(io.BytesIO(resp).read()) # encode it
# Interact
response = deployment.predict_unstructured(
{
"question": "What does this say about noodle rehydration?",
"document": encoding.decode(),
}
)('result')
— – – –
{'question': 'What does this say about noodle rehydration?',
'chat_history': (),
'answer': 'The article mentions that during the frying process, many tiny holes are created due to mass transfer, and they serve as channels for water penetration upon rehydration in hot water. The porous structure created during frying facilitates rehydration.'}
```Mais plus important encore, nous pouvons effectuer notre déploiement dans n’importe quelle langue de notre choix puisqu’il ne s’agit que d’un point de terminaison. Ci-dessous, je montre une capture d’écran de moi interagissant avec le déploiement directement via Postman. Cela signifie que nous pouvons intégrer notre Bot JITR dans pratiquement n’importe quelle application de notre choix en demandant simplement à l’application d’effectuer un appel API.
Une fois intégré dans une application, utiliser JITR est très simple. Par exemple, dans l’application Slackbot utilisée en interne chez Simseo, les utilisateurs téléchargent simplement un PDF avec une question pour démarrer une conversation liée au document.
JITR permet à tous les membres d’une organisation de commencer à générer de la valeur réelle grâce à l’IA générative, à travers d’innombrables points de contact dans les flux de travail quotidiens des employés. Regardez cette vidéo pour en savoir plus sur JITR.
Choses que vous pouvez faire pour rendre le bot JITR plus puissant
Dans le code que j’ai montré, nous avons parcouru une implémentation simple du JITRBot qui prend un PDF encodé et crée un magasin vectoriel au moment de l’exécution afin de répondre aux questions. Comme ils n’étaient pas pertinents par rapport au concept de base, j’ai choisi de laisser de côté un certain nombre de cloches et de sifflets que nous avons implémentés en interne avec le JITRBot, tels que :
- Renvoi d’invites contextuelles et de jetons d’achèvement
- Répondre à des questions basées sur plusieurs documents
- Répondre à plusieurs questions à la fois
- Permettre aux utilisateurs de fournir un historique des conversations
- Utiliser d’autres chaînes pour différents types de questions
- Rapporter des métriques personnalisées au déploiement
Il n’y a également aucune raison pour que JITRBot fonctionne uniquement avec des fichiers PDF ! Tant qu’un document peut être encodé et reconverti en une chaîne de texte, nous pourrions intégrer plus de logique dans notre `score_unstructured` hook pour gérer tout type de fichier fourni par un utilisateur.
Commencez à tirer parti du JITR dans votre flux de travail
JITR facilite l’interaction avec des PDF arbitraires. Si vous souhaitez l’essayer, vous pouvez suivre le cahier ici.
