Laden...
Laden...
Laden...
AI5 mei 20258 Min leestijd

Een local LLM uitvoeren: een gids voor RAG met de OnLogic Karbon 804

Een afbeelding van documenten en data aan de ene kant en een hoofd aan de andere kant als voorstelling van local LLM's met behulp van Retrieval-Augmented Generation.

Generatieve AI die gebruik maakt van grote taalmodellen (LLM's) heeft het potentieel om enorme waarde toe te voegen aan organisaties van elke grootte en in elke industrie. Populaire voorbeelden zoals ChatGPT hebben de kracht van deze modellen voor verschillende taken aangetoond. Cloudgebaseerde LLM-oplossingen kunnen echter uitdagingen betekenen voor gegevensbeveiliging, latency en offline implementaties.

In dit artikel lees je hoe je deze beperkingen kunt overwinnen door een local LLM op het apparaat te implementeren met behulp van Retrieval-Augmented Generation (RAG). Deze aanpak brengt de kracht van AI via lokale modellen rechtstreeks naar je implementaties aan de edge. Door gebruik te maken van een Llama 3.1-model en een lokale contextdatabase, biedt deze oplossing veilige toegang tot bedrijfseigen gegevens en snelle, nauwkeurige reacties, zelfs zonder internetverbinding. Ontdek hoe je krachtige AI-mogelijkheden in je edge-implementaties kunt implementeren met behulp van lokale hardware.

Intelligentie op apparaat ontgrendelen: waarom local LLM's belangrijk zijn

De meeste LLM-interacties worden verwerkt in de cloud en berekend in datacenters, ver van de gegevensbron. Ze kunnen eenvoudig worden opgehaald op een lokaal apparaat. Deze strategie kan nuttig zijn voor door AI gegenereerde content waarvoor algemene kennis of gecentraliseerde toegang nodig is en kan worden gebruikt door de meeste apparaten met een internetverbinding. Maar voor organisaties die de kracht van AI willen benutten met hun eigen data, schieten deze cloudgebaseerde oplossingen tekort op het gebied van gegevensbeveiliging. Daarnaast kunnen de kosten van cloud computing al snel onhoudbaar worden.

Om latency te minimaliseren en data-sharing beperkingen, zoals geografie of datagevoeligheid, te overwinnen, zou het verplaatsen van de computer naar de edge een optimale oplossing zijn voor de uitvoering van LLM's. Als een LLM bijvoorbeeld toegang nodig heeft tot gevoelige, bedrijfseigen data, zoals medische dossiers of juridische informatie, biedt de implementatie van het model op een edge device betere gegevensbeveiliging dan wanneer ze via internet worden verzonden. Bovendien moeten LLM's mogelijk worden geïmplementeerd in gebieden zonder adequate connectiviteit, zoals monitoring op afstand of productielocaties die geen betrouwbare verbindingen met cloudproviders hebben. Meer informatie over de waarde en het belang van AI aan de edge vind je in ons artikel: Edge AI-architectuur: De edge is de plek waar je moet zijn voor AI.

In dit artikel beschrijven we hoe je een on-device AI-chatbot implementeert voor het beantwoorden van vragen over de geleverde data, in dit geval informatie over OnLogic-producten. Aangezien de AI voor dit scenario specifieke, gespecialiseerde kennis nodig heeft, gebruiken we een concept dat RAG wordt genoemd. RAG zorgt ervoor dat het model toegang heeft tot nauwkeurige contextuele informatie om elke vraag zo goed mogelijk te kunnen beantwoorden.

Modelselectie

Het lokaal uitvoeren van LLM's lijkt in het begin misschien intimiderend, maar er zijn verschillende gratis en open-source tools beschikbaar om het ontwikkelingsproces te stroomlijnen. De eerste stap in het ontwikkelen van een aangepaste AI-oplossing is het begrijpen van je prestatiedoelstellingen. Voor onze productinformatie-chatbot moet ons AI-model voldoen aan de onderstaande criteria.

De LLM moet:

  1. lokaal worden uitgevoerd.

  2. een op grote schaal beschikbare open-source LLM zijn.

  3. snel en nauwkeurig reageren op vragen, dat wil zeggen:

    1. binnen één seconde beginnen met het geven van antwoorden;

    2. tekst sneller uitvoeren dan het gemiddelde aantal woorden per minuut.

  4. geen informatie verstrekken buiten goedgekeurde databronnen, in dit geval producthandleidingen.  

Op basis van deze doelen hebben we gekozen voor de 8-miljard parameterversie van Llama 3.1, een state-of-the-art en open-source taalmodel ontwikkeld door Meta. Hoewel er krachtige bedrijfseigen modellen bestaan, zoals die van OpenAI, richten we ons hier op het demonstreren van een robuuste, lokaal gehoste oplossing met open-source tools voor verbeterde controle en gegevensprivacy. Net als veel andere prominente open-source modellen is Llama 3 direct beschikbaar op de Hugging Face Hub, waardoor deze gemakkelijk lokaal kan worden geïmplementeerd. Llama 3.1 presteert in een verscheidenheid aan LLM-benchmarks beter dan open source-modellen van vergelijkbare omvang, met name in de categorieën redenering en gebruikmaking van tools. 

We hebben gekozen voor een kleiner model, omdat ons RAG-scenario een LLM omvat dat een gespecialiseerde taak uitvoert die is gericht op onze eigen inputdata. Ons model hoeft dus niet zo groot te zijn omdat we geen uitgebreide, algemene kennis nodig hebben. Voor organisaties met zeer specifieke domeinkennis of unieke interactiepatronen kan het fijnafstemmen van Llama 3 op bedrijfseigen datasets de prestaties en relevantie ervan verder verbeteren.

Hardwareconfiguratie

Zodra de LLM is geselecteerd, kunnen we een edge computer gaan configureren die het model effectief kan uitvoeren. Als het gaat om Large Language Models (met de nadruk op ‘groot’), kan de geheugencapaciteit snel een knelpunt voor de uitvoering worden. We moeten er dus voor zorgen dat onze configuratie het model aankan met wat ruimte voor geheugenoverhead. Hiervoor gebruiken we deze GPU-geheugenvergelijking van Sam Stoelinga.

M = (P * 4B)(32 / Q)*1.2

Hier is een uitsplitsing van elk van de elementen in de vergelijking.

Symbool

Beschrijving

M

GPU-geheugen uitgedrukt in gigabytes

P

Het aantal parameters in het model

4B

4 bytes, de bytes die voor elke parameter worden gebruikt

32

Het aantal bits in 4 bytes

Q

Het aantal bits dat moet worden gebruikt voor het laden van het model (bijv. 16 bits, 8 bits of 4 bits)

1.2

Staat voor een overhead van 20% voor het laden van extra items in het GPU-geheugen

Ons Llama-model maakt gebruik van Q4_K_M-kwantificatie (4-bits) en heeft 8 miljard parameters. Dit levert het volgende op:

M = (8 * 4B)(32 / 4) * 1.2 = 4.8 GB

Als we deze berekeningen hebben uitgevoerd, weten we dat we op de meeste dedicated GPU's genoeg geheugenoverhead hebben, zelfs als we rekening houden met de extra ruimte die nodig is voor de contextdatabase en embedding model. We gebruiken de OnLogic Karbon 804 met een Nvidia A4000-GPU waarop we het model gaan uitvoeren. Deze heeft voldoende power voor de LLM. Deze biedt ook de betrouwbaarheid om ons model te gebruiken waar het nodig is. 

K804 rugged computer met uitbreidingsruimte voor GPU

De OnLogic Karbon 804 was de ideale keuze voor onze local LLM. 

De OnLogic K804 is een eersteklas rugged edge device voor AI-toepassingen. Hij werkt bij temperaturen variërend van -40°C tot 70°C en is bestand tegen een verscheidenheid aan andere zware omstandigheden, zoals vochtigheid, schokken en trillingen. Het belangrijkste voor ons is dat het configuraties heeft die de verwerkingskracht voor LLM-berekeningen bieden en ruimte bieden voor maximaal twee single-slot GPU's. 

Retrieval-augmented generation

Nu moeten we ervoor zorgen dat de chatbot alleen data uit de geleverde bronnen levert. Zoals eerder gezegd, gebruiken we een AI-concept dat ongelooflijk nuttig is voor edge computing, namelijk Retrieval-Augmented Generation (RAG).

RAG is belangrijk omdat LLM’s de ongelukkige gewoonte hebben om tekst te schrijven die ‘goed klinkt’ maar niet altijd op waarheid is gebaseerd. Als het model niet specifiek wordt getraind over de informatie die de gebruiker moet ophalen, bestaat er een groot risico dat de gebruiker een AI-hallucinatie als antwoord krijgt. De RAG-techniek zorgt ervoor dat het model zijn reactie aan de gebruiker informeert met een database van geaccepteerde contextbronnen. In ons geval zijn dit producthandleidingen van OnLogic.

Ons systeem maakt gebruik van twee belangrijke modellen. Ten eerste analyseert een text-embedding model de invoerprompt. Deze wordt semantisch vergeleken met onze contextbronnen. Zo kunnen we de meest relevante bronnen identificeren en ophalen. Deze worden vervolgens samen met de oorspronkelijke prompt geleverd aan het belangrijkste Large Language Model (LLM) — in ons geval, Llama. Daarna genereert het Llama-model de uiteindelijke tekstuitvoer.

A diagram showing the flow of data for an LLM using RAG.

De datastroom voor een LLM met RAG. De query van de gebruiker wordt gebruikt om relevante context te vinden in een database en de query en context worden beide aan het model geleverd.

Voorbeeldoplossing

De belangrijkste tools voor onze voorbeeld-RAG-implementatie zijn Ollama en LangChain.

  • Ollama is een gebruiksvriendelijke, open-source toepassing voor het lokaal laden en uitvoeren van modellen. Hoewel het voorbeeld het gebruik van de opdrachtregel laat zien, zijn de basisconcepten en de API die het weergeeft van toepassing op verschillende besturingssystemen, waaronder Windows. Het is mogelijk dat specifieke installatie- en gebruiksstappen verschillen. Van Ollama downloaden we vanaf de opdrachtregel de twee noodzakelijke modellen:

    • ollama pull llama3.1:8b

    • ollama pull nomic-embed-text

  • LangChain is een krachtig framework voor de bouw van LLM-pipelines. Het biedt Python-pakketten die de integratie met API's voor verschillende modellen vereenvoudigen, waaronder Ollama. Daardoor is het eenvoudiger om local LLM-workflows uit te voeren en te beheren.

De volledige code voor de oplossing vind je op GitHub.

De eerste stap van onze oplossing is het doorzoeken van onze PDF's om een contextdatabase te maken, zodat een LLM ze kan begrijpen. We gebruiken de bibliotheek 'langchain_unstructured' om de PDF's te analyseren. We kunnen de teksten van elk document dan verzamelen terwijl een deel van de structuur intact blijft. De opdracht om de PDF's te laden ziet er als volgt uit:

Python
for file in pdf_filepaths: loader = UnstructuredLoader( file_path=file, strategy="fast", chunking_strategy="by_title" ) for doc in loader.lazy_load(): docs.append(doc)

We gebruiken de strategie 'fast’ in plaats van de strategie 'high resolution' om snel in de PDF's te laden. We gebruiken de chunking-strategie 'by_title' om ervoor te zorgen dat onze PDF's niet in te veel secties worden opgesplitst, waardoor de contextdatabase te groot zou worden. Door voor elk van onze PDF's een loader te maken, krijgen we een definitieve verzameling van 207 documenten. Deze bevatten de onbewerkte tekstinhoud van elk deel van de PDF plus nuttige metadata zoals elementcategorie en documentbron. 

Vervolgens kunnen we met onze verzameling documenten een 'embedding database' maken met behulp van Langchain Chroma. Ons 'text-embedding model', nomic-embed-text, neemt de tekst van elk document en berekent een 'embedding'. Een 'embedding' is een vector met veel dimensies, die probeert de tekst te categoriseren op basis van de inhoud. Wanneer we vervolgens een vraag stellen aan het model, maakt nomic-embed-text een andere 'embedding vector' voor die vraag. Deze vector wordt vergeleken met de vectoren die in de database zijn opgeslagen. De database geeft dan de meest vergelijkbare vectoren terug, en levert de tekst van elke vector als context aan het hoofd-LLM. De code voor dit proces is erg eenvoudig wanneer je Chroma en Ollama samen gebruikt.

Python
local_embeddings = OllamaEmbeddings(model=”nomic-embed-text”) vectorstore = Chroma.from_documents(docs, local_embeddings) 

Dat is het! We kunnen onze contextdatabase testen met een voorbeeldquery en zien wat het meest vergelijkbare document is:

Python
query = “What are the DisplayPort details for the k800 series?” docs = vectorstore.similarity_search(query) docs[0].page_content >>> "2.9 - DisplayPort\n\nTher are two full-size DisplayPorts on the Karbon 800 series. Both ports support DP 1.4 at 4k 50Hz\n\nand support MST (Multi Stream Topology). An MST hub can be used to support up to four\n\nindependent displays. Please refer to Intel documentation for additional Alder Lake-S display output\n\nspecifications: https://ark.intel.com\n\n22"

De database kon het juiste gedeelte over DisplayPorts vinden in de K800-handleiding! Vervolgens moeten we het allemaal bij elkaar brengen, wat je weer heel gemakkelijk kunt doen met behulp van de pythonbibliotheek van LangChain. We laden het Llama-model en maken dan een keten, die onze hele AI-pipeline beschrijft. 

Python
model = ChatOllama(model="llama3.1:8b") RAG_TEMPLATE = """ You are an assistant for tech support question answering tasks. Use the following product manual sections to answer the question. If you don’t know the answer, say that you don’t know. Use under three sentences and keep the answer concise.  <context> {context} </context> Answer the following question:  {question} """ rag_prompt = ChatPromptTemplate.from_template(RAG_TEMPLATE) retriever = vectorstore.as_retriever() chain = ( {"context": retriever | format_docs, "question": RunnablePassthrough()} | rag_prompt | model )

Je hoeft nu nog maar één functie aan te roepen om het hele model op te vragen. 

Python
question = "For the K800 series of computers, what are the details of their CE compliance?" response = chian.invoke(question) print(response.content) >>> The K800 series was evaluated for medical, IT equipment, automotive, maritime, and railway EMC standards as a class A device. It complies with the relevant IT equipment directives for the CE mark. Testing includes EN55032, EN55035, and other specified standards. 

Ons antwoord bevat ook enkele nuttige metadata om de snelheid ervan te evalueren. We hebben berekend dat de tijd tot het eerste token 0.27 seconden was en de output tokens per seconde 68,9, wat neerkomt op ongeveer 3.100 WPM. Met onze implementatie voldoet dus ruimschoots aan onze eisen op het gebied van snelheid, terwijl deze direct vanuit de producthandleiding een nauwkeurig antwoord geeft.  

Toekomstig werk

Er zijn veel manieren om onze LLM-oplossing verder te verbeteren dan onze kleine Jupyter-notebook, en daarvoor hoeven we de open-source tools echt niet links te laten liggen. Open Web UI zou een veel visueel betere gebruikersinterface voor de uitvoering van query's kunnen zijn. Deze interfaces communiceren meestal met de API die in runtime door de local LLM wordt weergegeven, zoals Ollama, om prompts te verzenden en reacties te ontvangen. We kunnen ook de kwaliteit en snelheid van onze resultaten verder verbeteren door verdere modelselectie of -optimalisatie (kwantificeren, beperking, enz.), door technieken te verkennen zoals het verfijnen van het Llama 3-model op onze specifieke productdocumentatie en door onze LangChain-pipeline te verbeteren om model self-correctie of web search op te nemen.

Er is ook ruimte om toegang te krijgen tot onze hardwareselectie zodra de softwareoplossing is afgerond. Ollama gebruikte slechts in totaal ongeveer 7,5 GB GPU-geheugen om ons voorbeeld uit te voeren, ongeveer de helft van de dedicated VRAM van de A4000. Op voorwaarde dat we de LLM-uitvoer bevredigend vinden, kan downsizing van de GPU de hardware het beste afstemmen op de workload. 

Conclusie

Dit voorbeeldproject laat zien hoe eenvoudig het kan zijn om een lokaal uitgevoerd Large Language Model op te zetten met Retrieval-Augmented Generation om hoge kwaliteit, context ondersteunde reacties van een AI-chatbot te garanderen. Alle gebruikte tools zijn open-source en goed gedocumenteerd, zodat we onze oplossing kunnen afstemmen op onze doelen en beschikbare resources. De toepassingen van dit edge AI framework zijn enorm in combinatie met de edge computing hardware van OnLogic. Deze kan overal worden geïmplementeerd waar het model moet worden uitgevoerd, zelfs in omgevingen waarin standaard computerhardware het laat afweten. Denk maar aan een afgelegen mijn zonder draadloze connectiviteit die problemen met machines moet oplossen, of een servicetechnicus op locatie bij een klant die storingen in apparatuur moet opsporen. Toegang tot dit type LLM zou van onschatbare waarde zijn.

Als je geïnteresseerd bent in het verkennen van hoe on-site AI van nut kan zijn voor je organisatie, neem dan contact op met ons AI Consulting-team.

Henry Kraessig
Henry Kraessig
Henry Kraessig is Applications Engineer bij OnLogic. Hij is afgestudeerd aan de Universiteit van Vermont in data science en wiskunde en zet zijn expertise in om oplossingen te bouwen die de kracht van moderne edge AI laten zien. Hij is gepassioneerd door technologie en vult zijn vrije tijd graag met koffie drinken, boeken en honkbal.

Blijf op de hoogte.

Ontvang als eerste toegang tot de nieuwste producten en Industry 4.0-innovatie, OnLogic Live!-evenementen en meer.