Comment exécuter un LLM local : Un guide pour RAG en utilisant le OnLogic Karbon 804
L'IA générative, une branche du Machine Learning qui utilise de grands modèles de langage (LLM), devient rapidement l'une des catégories d'outils d'IA les plus influentes et a le potentiel d'apporter une valeur considérable aux organisations de toutes tailles et dans tous les secteurs. Des exemples populaires comme ChatGPT, basés sur les modèles GPT d'OpenAI, ont démontré la puissance de ces modèles pour diverses tâches, mais les solutions LLM basées sur le cloud peuvent poser des défis en matière de sécurité des données, de latence et d'implémentations hors ligne.
Cet article montre comment surmonter ces limitations en mettant en œuvre un LLM local sur l'appareil en utilisant la génération augmentée par récupération (RAG). Cette approche apporte la puissance de l'IA directement à vos déploiements en périphérie grâce à des modèles locaux, permettant des cas d'utilisation pratiques dans des domaines tels que la fabrication, le service sur le terrain et la surveillance à distance. En exploitant un modèle Llama 3.1 et une base de données contextuelle locale, cette solution permet un accès sécurisé aux données propriétaires et fournit des réponses rapides et précises, même sans connexion Internet. Découvrez comment apporter des capacités puissantes d'IA à vos déploiements en périphérie en utilisant du matériel sur site.
Déverrouiller l'intelligence sur l'appareil : Pourquoi les LLM locaux sont importants
La plupart des interactions avec les LLM sont traitées dans le cloud, calculées dans des centres de données éloignés de la source des données, et simplement récupérées sur un appareil local. Cette stratégie peut être utile pour le contenu généré par l'IA nécessitant des connaissances généralisées ou un accès centralisé, et peut être exploitée par la plupart des appareils disposant d'une connexion internet. Mais pour les organisations intéressées à exploiter la puissance de l'IA en utilisant leurs propres données propriétaires, ces solutions basées sur le cloud sont insuffisantes en matière de sécurité des données et peuvent rapidement rendre les coûts de calcul sur le cloud intenables.
Pour minimiser la latence et surmonter les limitations de partage de données telles que la géographie ou la sensibilité des données, déplacer le calcul vers la périphérie peut être une solution optimale pour exécuter des LLM. Par exemple, lorsqu'un LLM nécessite un accès à des données sensibles et propriétaires, telles que des dossiers de santé ou des informations juridiques, déployer le modèle sur un périphérique de périphérie offre une sécurité des données améliorée par rapport à leur transmission sur Internet. Les déploiements en périphérie ouvrent une variété de cas d'utilisation où les LLMs basés sur le cloud sont insuffisants, surtout lorsque la fiabilité, la latence ou la confidentialité des données sont essentielles. De plus, les LLM peuvent nécessiter un déploiement dans des zones sans connectivité adéquate, comme la surveillance à distance ou les sites de fabrication qui n'ont pas de connexions fiables aux fournisseurs de cloud. Pour plus d'informations sur la valeur et l'importance de l'IA à la périphérie, veuillez consulter notre article : Architecture IA Edge : L'Edge est l'endroit idéal pour l'IA.
Dans cet article, nous décrivons le processus pour mettre en œuvre un chatbot IA sur appareil afin de répondre aux questions concernant ses données fournies, dans ce cas, des informations à propos d'OnLogic. Étant donné que ce scénario nécessite que l'IA ait des connaissances spécifiques et spécialisées, nous utiliserons un concept appelé RAG pour garantir que le modèle ait accès à des informations contextuelles précises afin d'aider à répondre à chaque question.
selection-de-modele
Exécuter des LLMs localement peut sembler intimidant au début, mais il existe une variété d'outils gratuits et open-source disponibles pour simplifier le processus de développement. Bien que des modèles propriétaires puissants existent, tels que ceux proposés par OpenAI ou Azure IA de Microsoft, notre objectif ici est de démontrer une solution robuste, hébergée localement, en utilisant des outils open-source pour un meilleur contrôle et une confidentialité des données renforcée. La première étape pour qu'un Développeur crée une solution IA sur mesure est de comprendre vos objectifs de performance. Pour les besoins de notre chatbot d'information sur les produits, notre modèle d'IA doit répondre aux critères énumérés ci-dessous.
Le LLM doit :
Exécuter localement
Soyez un LLM largement disponible avec une licence ouverte ou permissive, comme Llama 3.1, Mistral, Gemma, Mixtral ou DeepSeek.
Répondez aux questions rapidement et avec précision, y compris :
Commencez à fournir des réponses en moins d'une seconde.
Produisez du texte plus rapidement que la moyenne des mots lus par minute.
Ne pas fournir d'informations en dehors des sources de données approuvées, dans ce cas les manuels de produits.
En fonction de ces objectifs, nous avons choisi d'utiliser la version à 8 milliards de paramètres de Llama 3.1, un modèle de langage de pointe et open-source développé par Meta. Llama 3.1 est la dernière évolution des grands modèles de langage de Meta, offrant des améliorations significatives en matière de raisonnement et d'utilisation d'outils par rapport aux versions précédentes comme Llama 2. Des modèles comme Llama 3.1 peuvent être exécutés efficacement sur du matériel local en utilisant des bibliothèques d'inférence légères telles que llama.cpp, qui est spécifiquement optimisée pour les performances CPU et les environnements à faible mémoire. Bien que des modèles propriétaires puissants existent, tels que ceux proposés par le GPT-4 d'OpenAI, notre objectif ici est de démontrer une solution robuste, hébergée localement, en utilisant des outils open-source pour un meilleur contrôle et une confidentialité des données renforcée. Comme de nombreux modèles open-source deHugging Face Hub renom, Llama 3 est facilement disponible. Vous pouvez télécharger n'importe quel LLM avec l'extension .gguf et l'exécuter dans le terminal, ce qui le rend facilement accessible pour un déploiement local. Llama 3.1surpasse les modèles open-source de taille similaire dans une variété de benchmarks LLM, spécifiquement dans les catégories de raisonnement et d'utilisation des outils.
Nous sommes confiants d'utiliser un modèle plus petit car notre scénario RAG implique un LLM effectuant une tâche spécialisée axée sur nos propres données d'entrée. Ainsi, notre modèle n'a pas besoin d'être aussi grand puisque nous n'avons pas besoin d'une vaste connaissance généralisée. Pour les organisations possédant des connaissances très spécifiques dans un domaine ou des schémas d'interaction uniques, affiner Llama 3 sur des ensembles de données propriétaires pourrait améliorer encore ses performances et sa pertinence.
Configuration matérielle
Avec le LLM sélectionné, nous pouvons passer à la configuration d'un ordinateur de périphérie capable d'exécuter le modèle efficacement. Lorsqu'il s'agit de modèles de langage de grande taille (le mot clé étant "grand"), la capacité mémoire peut rapidement devenir un goulot d'étranglement pour l'exécution - nous devons donc nous assurer que notre configuration peut gérer le modèle avec une certaine marge pour la surcharge mémoire. Pour ce faire, nous utiliserons cette équation de mémoire GPU de Sam Stoelinga.
M = (P * 4B)/(32 / Q)*1,2
Voici une explication de chacun des éléments de l'équation.
Symbole | Description |
|---|---|
M | Mémoire GPU exprimée en gigaoctets |
P | Le nombre de paramètres dans le modèle |
4B | 4 octets, exprimant les octets utilisés pour chaque paramètre |
32 | Le nombre de bits dans 4 octets |
Q | Le nombre de bits à utiliser pour charger le modèle (par exemple, 16 bits, 8 bits ou 4 bits) |
1.2 | Représente une surcharge de 20 % pour le chargement d'éléments supplémentaires dans la mémoire GPU. |
Notre modèle Llama utilise la quantification Q4_K_M (4 bits) et possède 8 milliards de paramètres, offrant :
M = (8 * 4B)/(32 / 4) * 1,2 = 4,8 Go
Avec ce calcul effectué, nous savons que nous aurons suffisamment de marge de mémoire sur la plupart des GPU Dédiés, même en tenant compte de l'espace supplémentaire requis pour la base de données de contexte et le modèle Embarqué. Nous utiliserons le OnLogic Karbon 804 avec un GPU Nvidia A4000 et un CPU haute performance pour exécuter le modèle, ce qui nous donne une grande puissance de traitement pour gérer notre LLM. Il offrira également la fiabilité nécessaire pour exécuter notre modèle où que ce soit.
Le Karbon 804 de OnLogic était le choix idéal pour faire fonctionner notre LLM local.
Le OnLogic K804 est un périphérique de périphérie robuste de premier plan pour les applications d'IA. Il peut fonctionner à des températures allant de -40°C à 70°C, et est équipé pour faire face à diverses autres conditions difficiles, comme l'humidité, les chocs et les vibrations. Le plus important pour nous, c'est qu'il dispose de configurations qui fournissent la puissance de traitement pour le calcul LLM et l'espace pour accueillir jusqu'à deux GPU à un seul emplacement.
generation-augmentee-par-recuperation
Le prochain élément de notre solution IA est de s'assurer que le chatbot fournit uniquement des données provenant de ses sources fournies. Comme nous l'avons mentionné dans l'introduction, nous utiliserons un concept d'IA extrêmement utile pour l'edge computing appelé Generation Augmentée par Récupération (RAG).
RAG est important car les LLM ont la fâcheuse habitude d'écrire des textes qui "semblent" corrects, mais qui ne sont pas fondés sur la vérité. Si le modèle n'a pas de formation spécifique sur les informations que l'utilisateur souhaite obtenir, il y a un risque élevé que l'utilisateur reçoive une réponse inventée. La technique RAG garantit que le modèle informe sa réponse à l'utilisateur avec une base de données de sources de contexte acceptées, qui, dans notre cas, seront les manuels de produits OnLogic.
Notre système utilise deux modèles clés. Tout d'abord, un modèle de texte Embarqué analyse l'invite d'entrée, en la comparant sémantiquement à nos sources contextuelles. Cela nous permet d'identifier et de récupérer les sources les plus pertinentes, qui sont ensuite fournies, avec l'invite originale, au principal modèle de langage large (LLM) — dans notre cas, Llama. À partir de là, le modèle LLM (dans ce cas, Llama 3.1) génère ensuite le texte final.
Le flux de données pour un LLM utilisant RAG. La requête de l'utilisateur est utilisée pour trouver un contexte pertinent dans une base de données, et la requête ainsi que le contexte sont tous deux fournis au modèle.
Exemple de solution
Les principaux outils qui alimentent notre exemple de mise en œuvre RAG serontOllama et LangChain. Avant de plonger dans le code, il est important de configurer les dépendances requises.
Ollama est une application open-source facile à utiliser pour charger et exécuter des modèles localement sur Linux, macOS et Windows. Pour les utilisateurs qui préfèrent une interface graphique, des outils comme LM Studio offrent une expérience sur ordinateur pour exécuter des LLM locaux, y compris des modèles comme Llama 3, Mistral et DeepSeek, sans avoir besoin d'utiliser la ligne de commande. Ollama prend également en charge le déploiement basé sur Docker, vous permettant de containeriser votre runtime LLM local pour une distribution facile à travers différents environnements. Bien que l'exemple montre l'utilisation de la ligne de commande, les concepts fondamentaux et l'API qu'il expose sont applicables sur différents systèmes d'exploitation, y compris Windows, bien que les étapes spécifiques d'installation et d'utilisation puissent varier. Depuis Ollama, vous pouvez télécharger les deux modèles nécessaires par leur nom de modèle depuis la ligne de commande avec :
ollama-pull-llama31-8b
ollama-pull-nomic-embed-text
LangChain est un cadre puissant pour créer des pipelines LLM. Il propose des packages Python qui simplifient l'intégration avec les API pour divers modèles, y compris Ollama, facilitant ainsi l'exécution et la gestion de vos flux de travail LLM locaux.
Le code complet de la solution peut être trouvé sur GitHub.
La première étape de notre solution consistera à analyser nos PDF pour créer notre base de données contextuelle afin de les mettre dans un format compréhensible par un LLM. Nous utilisons la bibliothèque `langchain_unstructured` pour analyser les PDF, ce qui nous permet de collecter le texte de chaque document tout en conservant une partie de la structure intacte. Lorsque Ollama exécute un modèle, il le sert via une API locale accessible via localhost, généralement à l'adresse http://localhost:11434. Cela permet à des outils comme LangChain de se connecter au modèle pour l'exécution de requêtes et l'enchaînement.
Notre commande pour charger les PDF ressemble à ceci :
Pythonfor file in pdf_filepaths: loader = UnstructuredLoader( file_path=file, strategy="fast", chunking_strategy="by_title" ) for doc in loader.lazy_load(): docs.append(doc)
Nous utilisons la stratégie "rapide" au lieu de "haute résolution" pour charger rapidement les PDF, et la stratégie de découpage "par_titre" pour s'assurer que nos PDF ne se divisent pas en trop de sections, ce qui alourdirait la base de données contextuelle. Créer un chargeur pour chacun de nos PDF nous donne une collection finale de 207 documents, qui contiennent le texte brut de chaque section du PDF, ainsi que des métadonnées utiles comme la catégorie d'élément et la source du document.
Ensuite, avec notre collection de documents, nous pouvons créer une base de données embarquée en utilisant Langchain Chroma. Notre modèle d'Embarqué de texte, nomic-embed-text, prendra le texte de chaque document et calculera un Embarqué, un vecteur de haute dimension qui tente de catégoriser le texte en fonction de son contenu. Ensuite, lorsque nous interrogeons le modèle, nomic-embed-text créera un autre vecteur embarqué pour la requête, qu'il comparera ensuite aux vecteurs stockés dans la base de données. La base de données renverra les vecteurs les plus similaires et fournira le texte pour chaque vecteur en tant que contexte au LLM principal. Le code pour ce traitement est incroyablement simple lorsqu'on utilise Chroma et Ollama ensemble.
Pythonlocal_embeddings = OllamaEmbeddings(model=”nomic-embed-text”) vectorstore = Chroma.from_documents(docs, local_embeddings)
C'est tout ! Nous pouvons tester notre base de données contextuelle avec une requête d'exemple et voir quel est le document le plus similaire :
Pythonquery = “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"
La base de données a pu trouver la section correcte sur les DisplayPorts dans le manuel K800 ! Ensuite, nous devons tout assembler, ce qui est à nouveau très facile grâce à la bibliothèque python de LangChain. Nous allons charger le modèle Llama, puis créer une chaîne qui décrit l'ensemble de notre pipeline IA.
Pythonmodel = 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 )
Désormais, interroger l'ensemble du modèle est aussi simple que d'appeler une fonction.
Pythonquestion = "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.
Notre réponse inclut également des métadonnées utiles pour évaluer sa rapidité. Nous avons calculé que le temps jusqu'au premier jeton était de 0,27 seconde, et le nombre de jetons par seconde était de 68,9, ce qui équivaut à environ 3 100 mots par minute. Ainsi, notre implémentation dépasse largement nos exigences de vitesse, tout en étant capable de fournir une réponse précise directement à partir du manuel du produit.
Travail futur
Il existe de nombreuses façons d'améliorer potentiellement notre solution LLM au-delà de notre petit Jupyter Notebook, et nous n'avons pas besoin de dépasser les outils open-source pour y parvenirOpen Web UI. Cela pourrait offrir une interface utilisateur beaucoup plus attrayante pour les requêtes. Ces interfaces communiquent généralement avec l'API exposée par le runtime LLM local, comme Ollama, pour envoyer des invites et recevoir des réponses. Nous pourrions également continuer à améliorer la qualité et la rapidité de nos résultats grâce à une sélection ou une optimisation plus poussée des modèles (quantification, élagage, etc.), en explorant des techniques comme le réglage fin du modèle Llama 3 sur notre documentation produit spécifique, et en améliorant notre pipeline LangChain pour inclure le modèleautocorrection ou recherche sur le web.
Il y a également la possibilité d'ajuster notre sélection de matériel une fois que la solution logicielle est finalisée. Ollama a utilisé environ 7,5 Go de mémoire GPU au total pour exécuter notre exemple, soit environ la moitié de la VRAM Dédiée de l'A4000. À condition que nous considérions la sortie du LLM comme satisfaisante, réduire la taille du GPU pourrait mieux adapter le matériel à la charge de travail.
Pensées finales
Ce projet d'exemple montre à quel point il est facile de configurer un modèle de langage de grande taille exécuté localement avec une génération augmentée par récupération pour garantir des réponses de chatbot IA de haute qualité et soutenues par le contexte. Tous les outils utilisés sont open source et bien documentés, ce qui nous permet d'adapter notre solution à nos objectifs et aux ressources disponibles. Combiné avec le matériel d'Ordinateur de périphérie d'OnLogic, qui peut être déployé partout où le modèle doit être exécuté, même dans des environnements qui feraient échouer un matériel informatique plus standard (comme les CPU de bureau typiques ou les GPU de qualité grand public), les cas d'utilisation de ce cadre d'edge IA sont vastes. Imaginez une mine éloignée sans connectivité sans fil qui doit résoudre des problèmes de machines en panne, ou un technicien de service sur place chez un client qui doit identifier la cause des pannes d'équipement, l'accès à ce type de modèle de langage serait inestimable.
Si vous êtes intéressé par l'exploration des avantages que l'IA sur site pourrait apporter à votre organisation, contactez notre équipe de conseil enIA.