Heim > Artikel > Backend-Entwicklung > 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.
Bevor wir fortfahren, lassen Sie uns kurz die wichtigsten Erkenntnisse aus Teil 1 zusammenfassen:
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.
LlamaIndex bietet verschiedene Indextypen, die jeweils auf unterschiedliche Anwendungsfälle zugeschnitten sind. Lassen Sie uns die vier Haupttypen untersuchen:
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:
Nachteile:
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.
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.
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.
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.
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.
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)
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)
In diesem zweiten Teil unserer LlamaIndex- und Ollama-Reihe haben wir fortgeschrittene Indexierungstechniken untersucht, darunter:
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!