Techniques d'indexation avancées avec LlamaIndex et Ollama : Partie 2

Techniques d'indexation avancées avec LlamaIndex et Ollama : Partie 2

Le code peut être trouvé ici : GitHub - jamesbmour/blog_tutorials :

Bienvenue dans notre plongée profonde dans LlamaIndex et Ollama ! Dans la première partie, nous avons couvert les éléments essentiels de la configuration et de l'utilisation de ces outils puissants pour une récupération efficace des informations. Il est maintenant temps d'explorer des techniques d'indexation avancées qui élèveront vos capacités de traitement et d'interrogation de documents au niveau supérieur.

1. Introduction

Avant de continuer, récapitulons rapidement les principaux points à retenir de la première partie :

• Configuration de LlamaIndex et Ollama
• Création d'un index de base
• Effectuer des requêtes simples

Dans cette partie, nous allons plonger dans différents types d'index, apprendre à personnaliser les paramètres d'index, gérer plusieurs documents et explorer les techniques d'interrogation avancées. À la fin, vous aurez une solide compréhension de la façon d'exploiter LlamaIndex et Ollama pour des tâches complexes de recherche d'informations.

Si vous n'avez pas encore configuré votre environnement, assurez-vous de vous référer à la partie 1 pour des instructions détaillées sur l'installation et la configuration de LlamaIndex et Ollama.

2. Explorer différents types d'index

LlamaIndex propose différents types d'index, chacun adapté à différents cas d'utilisation. Explorons les quatre types principaux :

2.1 Index de la liste

L'index de liste est la forme d'indexation la plus simple dans LlamaIndex. Il s'agit d'une liste ordonnée de morceaux de texte, idéale pour les cas d'utilisation simples.

from llama_index.core import ListIndex, SimpleDirectoryReader, VectorStoreIndex
from dotenv import load_dotenv
from llama_index.llms.ollama import  Ollama
from llama_index.core import Settings
from IPython.display import Markdown, display
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core import StorageContext
from llama_index.embeddings.ollama import OllamaEmbedding
import chromadb
from IPython.display import HTML
# make markdown display text color green for all cells
# Apply green color to all Markdown output
def display_green_markdown(text):
    green_style = """
    <style>
    .green-output {
        color: green;
    }
    </style>
    """
    green_markdown = f'<div class="green-output">{text}</div>'
    display(HTML(green_style + green_markdown))


# set the llm to ollama
Settings.llm = Ollama(model='phi3', base_url='http://localhost:11434',temperature=0.1)

load_dotenv()

documents = SimpleDirectoryReader('data').load_data()
index = ListIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("What is llama index used for?")

display_green_markdown(response)

Avantages :

• Simple et rapide à créer
• Idéal pour les petits ensembles de documents

Inconvénients :

• Moins efficace avec de grands ensembles de données
• Compréhension sémantique limitée

2.2 Indice du magasin de vecteurs

L'index Vector Store exploite les intégrations pour créer une représentation sémantique de vos documents, permettant des recherches plus sophistiquées.

# Create Chroma client
chroma_client = chromadb.EphemeralClient()

# Define collection name
collection_name = "quickstart"

# Check if the collection already exists
existing_collections = chroma_client.list_collections()

if collection_name in [collection.name for collection in existing_collections]:
    chroma_collection = chroma_client.get_collection(collection_name)
    print(f"Using existing collection '{collection_name}'.")
else:
    chroma_collection = chroma_client.create_collection(collection_name)
    print(f"Created new collection '{collection_name}'.")

# Set up embedding model
embed_model = OllamaEmbedding(
    model_name="snowflake-arctic-embed",
    base_url="http://localhost:11434",
    ollama_additional_kwargs={"prostatic": 0},
)

# Load documents
documents = SimpleDirectoryReader("./data/paul_graham/").load_data()

# Set up ChromaVectorStore and load in data
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context, embed_model=embed_model
)

# Create query engine and perform query
query_engine = index.as_query_engine()
response = query_engine.query("What is llama index best suited for?")
display_green_markdown(response)

Ce type d'index excelle dans la recherche sémantique et l'évolutivité, ce qui le rend idéal pour les grands ensembles de données.

2.3 Index des arbres

L'index arborescent organise les informations de manière hiérarchique, ce qui est bénéfique pour les données structurées.

from llama_index.core import TreeIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader('data').load_data()
tree_index = TreeIndex.from_documents(documents)
query_engine = tree_index.as_query_engine()
response = query_engine.query("Explain the tree index structure.")
display_green_markdown(response)

Les indices arborescents sont particulièrement efficaces pour les données avec des hiérarchies naturelles, telles que les structures organisationnelles ou les taxonomies.

2.4 Index du tableau des mots-clés

L'index du tableau de mots-clés est optimisé pour une récupération efficace basée sur des mots-clés.

from llama_index.core import KeywordTableIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader('data/paul_graham').load_data()
keyword_index = KeywordTableIndex.from_documents(documents)
query_engine = keyword_index.as_query_engine()
response = query_engine.query("What is the keyword table index in llama index?")
display_green_markdown(response)

Ce type d'index est idéal pour les scénarios qui nécessitent des recherches rapides basées sur des mots-clés spécifiques.

3. Personnalisation des paramètres d'index

3.1 Stratégies de regroupement

Une segmentation efficace du texte est cruciale pour les performances de l'index. LlamaIndex propose diverses méthodes de segmentation :

from llama_index.core.node_parser import SimpleNodeParser

parser = SimpleNodeParser.from_defaults(chunk_size=1024)

documents = SimpleDirectoryReader('data').load_data()
nodes = parser.get_nodes_from_documents(documents)
print(nodes[0])

Expérimentez différentes stratégies de segmentation pour trouver l'équilibre optimal entre la préservation du contexte et les performances des requêtes.

3.2 Modèles d'intégration

LlamaIndex prend en charge différents modèles d'intégration. Voici comment utiliser Ollama pour les intégrations :

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.embeddings.ollama import OllamaEmbedding

embed_model = OllamaEmbedding(
    model_name="snowflake-arctic-embed",
    base_url="http://localhost:11434",
    ollama_additional_kwargs={"mirostat": 0},
)
index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)
query_engine = index.as_query_engine()
response = query_engine.query("What is an embedding model used for in LlamaIndex?")
display_green_markdown(response)

Expérimentez avec différents modèles Ollama et ajustez les paramètres pour optimiser la qualité d'intégration pour votre cas d'utilisation spécifique.

4. Gestion de plusieurs documents

4.1 Création d'un index multi-documents

LlamaIndex simplifie le processus de création d'index à partir de plusieurs documents de différents types :

txt_docs = SimpleDirectoryReader('data/paul_graham').load_data()
web_docs = SimpleDirectoryReader('web_pages').load_data()
data = txt_docs  + web_docs
all_docs = txt_docs  + web_docs
index = VectorStoreIndex.from_documents(all_docs)

query_engine = index.as_query_engine()
response = query_engine.query("How do you create a multi-document index in LlamaIndex?")
display_green_markdown(response)

4.2 Requête inter-documents

Pour interroger efficacement plusieurs documents, vous pouvez mettre en œuvre un score de pertinence et gérer les limites du contexte :

from llama_index.core import QueryBundle
from llama_index.core.query_engine import RetrieverQueryEngine

retriever = index.as_retriever(similarity_top_k=5)
query_engine = RetrieverQueryEngine.from_args(retriever, response_mode="compact")
query = QueryBundle("How do you query across multiple documents?")
response = query_engine.query(query)
display_green_markdown(response)

5. Conclusion et prochaines étapes

Dans cette deuxième partie de notre série LlamaIndex et Ollama, nous avons exploré des techniques d'indexation avancées, notamment :

• Différents types d'index et leurs cas d'utilisation
• Personnalisation des paramètres d'index pour des performances optimales
• Gestion de plusieurs documents et requêtes inter-documents

Si vous souhaitez me soutenir ou m'acheter une bière n'hésitez pas à rejoindre mon Patreon jamesbmour

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!