Aangepaste embeddingmodellen integreren
Leer aangepaste of gefinetunede embeddingmodellen te integreren om representaties te genereren die zijn geoptimaliseerd voor uw specifieke domein.
Aangepaste embeddingmodellen integreren is een gratis LangChain / RAG / vectordatabases-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject LangChain / RAG / vectordatabases. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus LangChain / RAG / vectordatabases bevat in totaal 4 lessen.
Waarom aangepaste insluitingen gebruiken?
Standaardmodellen voor insluitingen zijn ontzettend veelzijdig, maar soms zijn je gegevens bijzonder. Wanneer je met zeer specifieke of gespecialiseerde informatie werkt, begrijpen algemene modellen de subtiele betekenissen mogelijk niet volledig.
Aangepaste insluitingsmodellen zijn verfijnd voor specifieke domeinen. Daardoor begrijpen ze je unieke jargon en concepten beter, wat leidt tot nauwkeurigere en relevantere resultaten.
Wanneer aangepaste modellen uitblinken
Gespecialiseerde insluitingen zijn vooral nuttig in situaties waarin nauwkeurigheid en domeinspecifiek begrip cruciaal zijn:
- Medisch onderzoek: Complexe biologische termen of patiëntendossiers begrijpen.
- Juridische documenten: Subtiele juridische nuances en precedenten in rechtszaken onderscheiden.
- Eigendomelijke gegevens: Wanneer gevoelige informatie je lokale omgeving of specifieke cloudinstantie niet mag verlaten.
Ze leiden tot aanzienlijk relevantere resultaten bij het ophalen in RAG-systemen.
LangChain en Hugging Face-modellen
LangChain maakt het eenvoudig om aangepaste of opensource-insluitingsmodellen te integreren, vooral modellen die beschikbaar zijn op Hugging Face. De klasse HuggingFaceEmbeddings is hiervoor je belangrijkste hulpmiddel.
Je geeft eenvoudig de modelnaam op, bijvoorbeeld een model van sentence-transformers, waarna LangChain het laden afhandelt en het model vaak naar je lokale computer downloadt voor offlinegebruik.
Je omgeving instellen
Voordat je Hugging Face-modellen binnen LangChain kunt gebruiken, moet je enkele essentiële Python-bibliotheken installeren:
langchain-community: Biedt de klasseHuggingFaceEmbeddings.sentence-transformers: De kernbibliotheek voor het uitvoeren van deze modellen.torchoftensorflow: Een deep-learningframework waarvan de modellen afhankelijk zijn.
Je kunt ze installeren met pip: pip install langchain-community sentence-transformers torch
Insluitingen genereren met een lokaal model
Laten we een insluiting genereren voor een eenvoudige zin met een populair, klein model van sentence-transformers. Hiermee zie je hoe je een aangepast model initialiseert en gebruikt.
from langchain_community.embeddings import HuggingFaceEmbeddings
def main():
# Load a local sentence-transformer model.
# This model will be downloaded to your machine if not present.
model_name = "all-MiniLM-L6-v2"
embeddings = HuggingFaceEmbeddings(model_name=model_name)
text = "This is a custom embedding example using a local model."
query_result = embeddings.embed_query(text)
print(f"Embedding dimensions: {len(query_result)}")
print(f"First 5 dimensions: {query_result[:5]}")
if __name__ == "__main__":
main()De code voor insluitingen ontrafelen
In het vorige voorbeeld hebben we deze belangrijke stappen uitgevoerd:
- We hebben
HuggingFaceEmbeddingsgeïmporteerd uitlangchain_community. - We hebben het geïnitialiseerd met
"all-MiniLM-L6-v2", een populair en efficiënt model. - De methode
embed_query()nam onze tekst en zette deze om in een numerieke vector (de embedding), die de semantische betekenis ervan vastlegt.
Het model zelf wordt lokaal gedownload en uitgevoerd, wat privacy en mogelijk snellere inferentie biedt.
Aangepaste embeddings in RAG
Aangepaste embeddings zijn het effectiefst wanneer je ze in je RAG-pijplijn integreert. Ze vervangen generieke embeddings op het moment dat je je vectoropslag opbouwt.
Wanneer je documenten laadt, ze in fragmenten opsplitst en vervolgens embeddings voor opslag genereert, gebruik je je aangepaste model. Zo zorg je ervoor dat het zoekproces zeer relevant is voor je specifieke domein of dataset.
Voorbeeld van integratie met een vectoropslag
Zo gebruik je je instantie van HuggingFaceEmbeddings bij het maken en gebruiken van een vectordatabase zoals Chroma DB. Zo zorg je ervoor dat alle opgeslagen en opgevraagde documenten je gespecialiseerde model gebruiken.
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.docstore.document import Document
import os
import shutil
def main():
# Define a temporary directory for Chroma DB
persist_directory = "./chroma_db_custom_embed"
if os.path.exists(persist_directory):
shutil.rmtree(persist_directory)
os.makedirs(persist_directory)
# Load custom embedding model
model_name = "all-MiniLM-L6-v2"
embeddings = HuggingFaceEmbeddings(model_name=model_name)
# Create some sample documents
documents = [
Document(page_content="The patient exhibited symptoms of acute respiratory distress."),
Document(page_content="Legal precedents often guide future court decisions."),
Document(page_content="This is a general statement about technology."),
]
# Create a Chroma vector store with custom embeddings
vectordb = Chroma.from_documents(
documents=documents,
embedding=embeddings,
persist_directory=persist_directory
)
vectordb.persist() # Save the database to disk
# Perform a similarity search using the same custom embeddings
query = "What medical conditions were observed?"
docs = vectordb.similarity_search(query)
print(f"Query: '{query}'")
print("\nRetrieved documents:")
for i, doc in enumerate(docs):
print(f"{i+1}. {doc.page_content}")
# Clean up the temporary directory
shutil.rmtree(persist_directory)
if __name__ == "__main__":
main()Waarom kiezen voor aangepaste embeddings?
Bekijk nog eens de overtuigende redenen om te kiezen voor aangepaste of fijn afgestemde embeddingmodellen:
- Relevantie voor het domein: Krijg een dieper en nauwkeuriger begrip van gespecialiseerde taal en concepten.
- Verbeterde nauwkeurigheid: Dit leidt tot het nauwkeuriger ophalen van documenten, waardoor de kwaliteit van RAG-uitvoer verbetert.
- Kostenefficiëntie: Dit kan voordeliger zijn dan voortdurend commerciële modellen via een API aanroepen bij gebruik op grote schaal.
- Gegevensprivacy: Verwerk embeddings lokaal, zodat gevoelige gegevens onder jouw controle blijven.
- Flexibiliteit: Gebruik opensourcemodellen of stem je eigen model fijn af voor maximale aanpasbaarheid.
Test je kennis
Aangepaste embeddingmodellen bieden verschillende voordelen, vooral voor specifieke gebruikssituaties in een RAG-systeem.
Aangepaste embeddings: de belangrijkste punten
Je hebt geleerd hoe aangepaste embeddingmodellen een krachtige manier bieden om het begrip van je RAG-systeem af te stemmen op specifieke domeinen.
Met hulpmiddelen zoals HuggingFaceEmbeddings van LangChain kun je gespecialiseerde modellen in je toepassingen integreren voor betere nauwkeurigheid, privacy en kostenefficiëntie.
Vervolgens bekijken we hoe je ophaalketens kunt uitbreiden met aangepaste logica om het gedrag van je RAG-toepassingen verder te verfijnen.
Leer LangChain / RAG / vectordatabases met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Aangepaste embeddingmodellen integreren” gratis?
Ja — de volledige tekst van “Aangepaste embeddingmodellen integreren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus LangChain / RAG / vectordatabases wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus LangChain / RAG / vectordatabases bevat in totaal 4 lessen.
Wat leer ik in “Aangepaste embeddingmodellen integreren”?
Leer aangepaste of gefinetunede embeddingmodellen te integreren om representaties te genereren die zijn geoptimaliseerd voor uw specifieke domein. Je oefent met LangChain / RAG / vectordatabases door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met LangChain / RAG / vectordatabases te beginnen?
Ervaring vooraf is niet nodig. LangChain / RAG / vectordatabases op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Aangepaste embeddingmodellen integreren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over LangChain / RAG / vectordatabases?
Ja. Elke les over LangChain / RAG / vectordatabases bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Aangepaste documentloaders ontwikkelen
- Aangepaste embeddingmodellen integreren
- Retrieval-ketens uitbreiden met aangepaste logica
- Aangepaste outputparsers bouwen