Erweiterte Indexierungstechniken mit LlamaIndex und Ollama: Teil 2

Erweiterte Indexierungstechniken mit LlamaIndex und Ollama: Teil 2

Code finden Sie hier: GitHub – jamesbmour/blog_tutorials:

Willkommen zurück zu unserem tiefen Einblick in LlamaIndex und Ollama! In Teil 1 haben wir die Grundlagen der Einrichtung und Verwendung dieser leistungsstarken Tools für den effizienten Informationsabruf behandelt. Jetzt ist es an der Zeit, erweiterte Indizierungstechniken zu erkunden, die Ihre Dokumentverarbeitungs- und Abfragefunktionen auf die nächste Stufe heben.

1. Einführung

Bevor wir fortfahren, lassen Sie uns kurz die wichtigsten Erkenntnisse aus Teil 1 zusammenfassen:

• LlamaIndex und Ollama einrichten
• Einen Basisindex erstellen
• Durchführen einfacher Abfragen

In diesem Teil befassen wir uns mit verschiedenen Indextypen, erfahren, wie Sie Indexeinstellungen anpassen, mehrere Dokumente verwalten und erweiterte Abfragetechniken erkunden. Am Ende verfügen Sie über ein solides Verständnis dafür, wie Sie LlamaIndex und Ollama für komplexe Informationsabrufaufgaben nutzen können.

Wenn Sie Ihre Umgebung noch nicht eingerichtet haben, schauen Sie unbedingt noch einmal in Teil 1 nach, um detaillierte Anweisungen zur Installation und Konfiguration von LlamaIndex und Ollama zu erhalten.

2. Erkundung verschiedener Indextypen

LlamaIndex bietet verschiedene Indextypen, die jeweils auf unterschiedliche Anwendungsfälle zugeschnitten sind. Lassen Sie uns die vier Haupttypen untersuchen:

2.1 Listenindex

Der Listenindex ist die einfachste Form der Indizierung in LlamaIndex. Es handelt sich um eine geordnete Liste von Textblöcken, ideal für einfache Anwendungsfälle.

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)

Vorteile:

• Einfach und schnell zu erstellen
• Am besten geeignet für kleine Dokumentensätze

Nachteile:

• Weniger effizient bei großen Datensätzen
• Eingeschränktes semantisches Verständnis

2.2 Vector Store-Index

Der Vector Store Index nutzt Einbettungen, um eine semantische Darstellung Ihrer Dokumente zu erstellen und so anspruchsvollere Suchvorgänge zu ermöglichen.

# 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)

Dieser Indextyp zeichnet sich durch semantische Suche und Skalierbarkeit aus und ist daher ideal für große Datenmengen.

2.3 Baumindex

Der Baumindex organisiert Informationen hierarchisch, was für strukturierte Daten von Vorteil ist.

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)

Baumindizes sind besonders effektiv für Daten mit natürlichen Hierarchien, wie z. B. Organisationsstrukturen oder Taxonomien.

2.4 Stichworttabellenindex

Der Schlüsselworttabellenindex ist für eine effiziente schlüsselwortbasierte Suche optimiert.

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)

Dieser Indextyp ist ideal für Szenarien, die eine schnelle Suche basierend auf bestimmten Schlüsselwörtern erfordern.

3. Anpassen der Indexeinstellungen

3.1 Chunking-Strategien

Effektives Text-Chunking ist entscheidend für die Indexleistung. LlamaIndex bietet verschiedene Chunking-Methoden:

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])

Experimentieren Sie mit verschiedenen Chunking-Strategien, um das optimale Gleichgewicht zwischen Kontexterhaltung und Abfrageleistung zu finden.

3.2 Modelle einbetten

LlamaIndex unterstützt verschiedene Einbettungsmodelle. So können Sie Ollama für Einbettungen verwenden:

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)

Experimentieren Sie mit verschiedenen Ollama-Modellen und passen Sie Parameter an, um die Einbettungsqualität für Ihren spezifischen Anwendungsfall zu optimieren.

4. Umgang mit mehreren Dokumenten

4.1 Erstellen eines Multi-Dokument-Index

LlamaIndex vereinfacht die Erstellung von Indizes aus mehreren Dokumenten unterschiedlicher Art:

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 Dokumentübergreifende Abfrage

Um mehrere Dokumente effektiv abzufragen, können Sie Relevanzbewertung implementieren und Kontextgrenzen verwalten:

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. Fazit und nächste Schritte

In diesem zweiten Teil unserer LlamaIndex- und Ollama-Reihe haben wir fortgeschrittene Indexierungstechniken untersucht, darunter:

• Verschiedene Indextypen und ihre Anwendungsfälle
• Indexeinstellungen für optimale Leistung anpassen
• Verwaltung mehrerer Dokumente und dokumentenübergreifende Abfragen

Wenn Sie mich unterstützen oder mir ein Bier kaufen möchten, können Sie sich gerne meinem Patreon jamesbmour anschließen

Das obige ist der detaillierte Inhalt vonErweiterte Indexierungstechniken mit LlamaIndex und Ollama: Teil 2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!