Déploiement de modèles locaux

Beaucoup de gens pensent que l'IA ne peut être utilisée que dans le cloud : lorsqu'on utilise ChatGPT, les données sont envoyées aux serveurs d'OpenAI, et lorsqu'on utilise Claude, les requêtes sont envoyées aux centres de données d'Anthropic.

En fait,les modèles d'IA peuvent fonctionner entièrement sur votre propre ordinateur。

Imaginez : vous pouvez utiliser l'IA sans réseau, les données sensibles ne quittent jamais votre ordinateur, pas besoin de payer à chaque appel, et vous pouvez la personnaliser comme vous le souhaitez.

C'est la valeur du déploiement local de modèles.

Ce module vous fera passer de zéro à l'exécution de votre premier modèle d'IA local sur votre propre ordinateur.


Pourquoi l'IA locale est nécessaire

L'IA cloud est pratique, mais l'IA locale présente des avantages irremplaçables.

Protection de la confidentialité des données

C'est la raison principale pour laquelle beaucoup de personnes choisissent le déploiement local.

Si vous traitez des contrats, des dossiers médicaux, des données financières ou des documents internes, l'envoi de ces données à des serveurs tiers est risqué.

Lors d'une exécution locale,toutes les données sont traitées sur votre propre ordinateur et ne quittent jamais votre appareil。

Utilisation en environnement hors ligne

Dans les avions, les trains ou les endroits où le réseau est instable, l'IA cloud est inutilisable.

Une fois téléchargés, les modèles locaux sont disponibles pour toujours et ne nécessitent pas de connexion réseau.

Contrôle des coûts

L’IA cloud facture en fonction du nombre d’appels ou de tokens, et une utilisation intensive peut représenter une dépense importante.

Les modèles locaux sont téléchargés une fois et peuvent ensuite être utilisés librement, sans coûts supplémentaires.

Possibilités de personnalisation

Vous ne pouvez pas modifier les modèles cloud ; vous pouvez uniquement utiliser les fonctionnalités fournies.

Avec les modèles locaux, vous pouvez affiner, quantifier, modifier les modèles de prompt et les personnaliser entièrement selon vos propres besoins.

Comparaison de ces avantages :

FonctionnalitéIA cloudIA locale
Confidentialité des donnéesLes données doivent être téléverséesLes données sont entièrement locales
Dépendance au réseauConnexion Internet requiseAucun réseau requis
Coût d'utilisationPaiement à l'usageUn téléchargement, utilisation illimitée
Capacité de personnalisationLimitéEntièrement contrôlable
Facilité d'utilisationPrêt à l'emploiNécessite une configuration
Vitesse de réponseDépend du réseauDépend du matériel

Non pas que l'IA cloud soit mauvaise, mais plutôtLes deux ont leurs propres scénarios d'applicationPour les discussions quotidiennes, utilisez le cloud ; pour les données sensibles, utilisez le local ; pour les tâches simples, utilisez le cloud ; pour une personnalisation spécifique, utilisez le local.


Évaluation des besoins matériels

Le fait qu'un modèle local puisse fonctionner et la vitesse à laquelle il fonctionne dépendent principalement de votre configuration matérielle.

Inférence CPU vs Inférence GPU

Il existe deux façons d'exécuter des modèles : l'inférence CPU et l'inférence GPU.

L'inférence CPU utilise le processeur principal de l'ordinateur pour exécuter des modèles. L'avantage est une bonne compatibilité ; presque tous les ordinateurs peuvent l'exécuter. L'inconvénient est la lenteur ; les grands modèles peuvent prendre beaucoup de temps.

L'inférence GPU utilise les cartes graphiques. L'avantage principal estune puissante capacité de calcul parallèle, ce qui rend l'exécution des modèles des dizaines de fois plus rapide。

Pour les cartes graphiques NVIDIA, vous devez installer le kit de développement CUDA ; pour les cartes graphiques AMD, vous pouvez utiliser ROCm ; pour les cartes graphiques Intel, vous pouvez utiliser OpenVINO.

Relation entre les besoins en VRAM et la taille du modèle

La VRAM détermine la taille du modèle que vous pouvez exécuter.

Plus un modèle a de paramètres, plus il nécessite de VRAM. Cependant, avec les techniques de quantification, vous pouvez exécuter des modèles plus grands avec moins de VRAM.

Taille de la VRAMModèles exécutables (FP16)Modèles exécutables (après quantification)Scénarios recommandés
8 GBLes modèles 7B sont quelque peu difficiles7B (Q4), 13B (Q4) fonctionnent à peineChat simple, tâches légères
16 GBModèles 7B, 13B7B、13B(Q4/Q8)、33B(Q4)Usage quotidien, meilleur rapport qualité-prix
24 GBModèles 7B, 13B, 33B7B、13B、33B(Q4/Q8)、70B(Q4)Usage professionnel, expérience fluide
48 GB+Modèles 33B, 70BTous les modèles courantsRecherche, environnements de production

Avantages de la série M des Mac

Apple Silicon (puces des séries M1, M2, M3) présente des avantages uniques en IA locale.

Le framework Metal d'Apple et l'architecture de mémoire unifiée rendent les Mac très efficaces pour exécuter des modèles locaux.

La mémoire unifiée signifieque le CPU et le GPU partagent la mémoireet peuvent emprunter automatiquement de la mémoire lorsque la VRAM est insuffisante.

Un MacBook Pro avec 16GB de mémoire unifiée peut exécuter en douceur des modèles quantifiés 7B et 13B.

Plans de configuration recommandés

En fonction des différents budgets et besoins, voici plusieurs options de configuration :

ForfaitConfigurationConvient pourExpérience attendue
Formule d'entrée de gammeTout ordinateur (8GB+ RAM)Débutants qui souhaitent découvrir l'IA localePeut exécuter de petits modèles, relativement lent
Meilleur rapport qualité-prix16GB RAM + 6GB+ VRAMUsage personnel quotidienExécution fluide des modèles 7B/13B
Formule professionnelle32GB RAM + 12GB+ VRAMDéveloppeurs, chercheursExécution fluide des modèles 33B
Formule MacM1/M2/M3 + 16GB de mémoire unifiéePremier choix pour les utilisateurs MacExécution fluide des modèles 7B/13B

Ne soyez pas intimidé par le terme « grand modèle ». La technologie de quantification d'aujourd'hui permet déjà aux modèles 7B de fonctionner de manière fluide sur des ordinateurs ordinaires, et les capacités des modèles 7B suffisent à la plupart des tâches quotidiennes.


Ollama : l'outil d'IA local le plus simple

Ollama est actuellement l'outil de modèles locaux le plus populaire. Pour résumer en une phrase :Installez des modèles comme vous installez des applications, utilisez l'IA comme vous utiliseriez la ligne de commande。

Installation et configuration

Ollama prend en charge macOS, Linux et Windows, et le processus d'installation est très simple.

Lien de téléchargement de l'installateur :https://ollama.com/download

Installez avec une seule commande :

curl -fsSL https://ollama.com/install.sh | sh

Les utilisateurs de macOS peuvent télécharger directement l'installateur, ou l'installer avec Homebrew :

# macOS 使用 Homebrew 安装
brew install ollama

# 或者下载安装包:https://ollama.com/download

Les utilisateurs de Windows peuvent simplement télécharger l'installateur depuis le site officiel et l'exécuter.

Après l'installation, démarrez le service Ollama :

ollama serve

Une fois que vous voyez que le service a démarré avec succès, vous pouvez commencer à l'utiliser.

Téléchargement des modèles

La bibliothèque de modèles d'Ollama est très riche, incluant des modèles courants tels que Llama, Qwen, Gemma et Mistral.

Le téléchargement d'un modèle ne prend qu'une seule commande :

Exemple

# Télécharger Llama 3 (8B paramètres)
ollama pull llama3

# Télécharger Qwen (Tongyi Qianwen, adapté au chinois)
ollama pull qwen

# Télécharger Gemma (de Google)
ollama pull gemma

# Télécharger Mistral
ollama pull mistral

Vous pouvez également utiliserollama run + model namecommande, qui téléchargera automatiquement le modèle spécifié s'il n'est pas déjà présent :

ollama run qwen

Exécutez le modèle qwen, en le téléchargeant s'il n'est pas disponible.

Chaque modèle a différentes versions, telles que 8B, 70B, ou différentes versions quantifiées.

Vous pouvez utiliserollama listpour afficher les modèles déjà téléchargés :

ollama list

Sortie similaire à :

NAME              ID              SIZE      MODIFIED
qwen3.5:latest    6488c96fa5fa    6.6 GB    3 months ago

Utilisation de la ligne de commande

Une fois le modèle téléchargé, vous pouvez l'exécuter directement pour démarrer une conversation :

# 运行 Llama 3,没有会下载
ollama run llama3

# 运行 Qwen,没有会下载
ollama run qwen3.5

qwen3.5 est plus que suffisant pour les tâches ordinaires :

Ensuite, vous pouvez parler directement au modèle :

>>> 你好,请介绍一下你自己
你好!我是 Llama 3,由 Meta 开发的 AI 助手。我可以帮你回答问题、
写作、编程、分析数据等。有什么我可以帮你的吗?

>>> 用 Python 写一个 Hello World 程序
好的,这是一个简单的 Python Hello World 程序:

print("Hello, World!")

>>> /bye  # 输入 /bye 退出

Commandes courantes :

CommandeFonctionExemple
ollama pull <model>Télécharger le modèleollama pull llama3
ollama run <model>Exécuter le modèleollama run llama3
ollama listLister les modèles installésollama list
ollama rm <model>Supprimer le modèleollama rm llama3
ollama show <model>Afficher les informations du modèleollama show llama3

Appels à l'interface API

Ollama est livré avec une API HTTP, vous pouvez donc l'appeler avec du code, pas seulement depuis la ligne de commande.

Par défaut, Ollama est àhttp://localhost:11434pour fournir le service API.

Appeler l'API Ollama avec Python :

Exemple

# Chemin du fichier : /Users/example/ollama_test.py
# Appel de l'API Ollama avec Python

import requests
import json

# Adresse de l'API Ollama
OLLAMA_URL = "http://localhost:11434/api/generate"


def ask_ollama(prompt: str, model: str = "llama3") -> str:
    """
Envoyer une requête à Ollama pour obtenir la réponse du modèle

    Arguments :
prompt : l'invite saisie par l'utilisateur
model : le nom du modèle à utiliser, par défaut, llama3

    Retourne :
Le texte de réponse du modèle
    """

    # Construire les données de la requête
    payload = {
        "model": model,      # Modèle à utiliser
        "prompt": prompt,    # Entrée utilisateur
        "stream": False      # Ne pas utiliser la sortie en streaming, tout renvoyer d'un coup
    }

    try:
        # Envoyer la requête POST
        response = requests.post(OLLAMA_URL, json=payload)
        response.raise_for_status()  # Vérifier si la requête a réussi

        # Analyser le JSON renvoyé
        result = response.json()
        return result.get("response", "")

    except requests.exceptions.ConnectionError:
        return "Erreur : Impossible de se connecter au service Ollama, veuillez confirmer qu'Ollama est démarré"
    except requests.exceptions.RequestException as e:
        return f"Erreur de requête : {str(e)}"


# Le tester
if __name__ == "__main__":
    # Tester la question 1
    question1 = "Veuillez présenter le tutoriel EXAMPLE en une phrase"
    answer1 = ask_ollama(question1)
    print(f"Question : {question1}")
    print(f"Réponse : {answer1}")
    print("-" * 50)

    # Question de test 2
    question2 = "Écrire une fonction Python pour calculer la suite de Fibonacci"
    answer2 = ask_ollama(question2)
    print(f"Question : {question2}")
    print(f"Réponse : {answer2}")

Exécutez ce script :

Exemple

# Installez d'abord la bibliothèque requests (si elle n'est pas déjà installée)
pip install requests

# Exécutez le script
python ollama_test.py

Si vous souhaitez un wrapper de plus haut niveau, vous pouvez utiliser la bibliothèque Python officielle d'Ollama :

Exemple

# Chemin du fichier : /Users/example/ollama_advanced.py
# Utilisation de la bibliothèque Python Ollama

# Première installation : pip install ollama

import ollama


def chat_with_example():
    """
Utilisez la bibliothèque Python Ollama pour les conversations à plusieurs tours
    """

    # Historique des messages
    messages = [
        {
            "role": "system",
            "content": "Vous êtes un assistant de programmation amical nommé ExampleBot. Vos réponses doivent être concises et pratiques, avec davantage d'exemples de code."
        }
    ]

    print("ExampleBot est démarré ! Saisissez 'quit' pour quitter.")
    print("-" * 50)

    while True:
        # Obtenir la saisie de l'utilisateur
        user_input = input(Vous :)

        if user_input.lower() in ["quit", "exit", Quitter]:
            print(Au revoir !)
            break

        # Ajouter le message de l'utilisateur à l'historique
        messages.append({
            "role": "user",
            "content": user_input
        })

        # Appeler le modèle
        response = ollama.chat(
            model="llama3",
            messages=messages
        )

        # Obtenir la réponse
        assistant_message = response["message"]["content"]
        print(f"ExampleBot:{assistant_message}")
        print("-" * 50)

        # Ajouter la réponse de l'assistant à l'historique
        messages.append({
            "role": "assistant",
            "content": assistant_message
        })


if __name__ == "__main__":
    chat_with_example()

Intégration avec Open WebUI

La ligne de commande est pratique, mais une interface graphique est plus conviviale.

Open WebUI est une très belle interface web qui peut se connecter à Ollama, vous permettant d'utiliser des modèles locaux comme ChatGPT.

Installer Open WebUI :

Exemple

# Installer Open WebUI avec Docker
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

# Si vous n'utilisez pas Docker, vous pouvez également l'installer avec pip
pip install open-webui
open-webui serve

Après l'installation, ouvrez-le dans le navigateurhttp://localhost:3000, et vous verrez une interface qui ressemble beaucoup à ChatGPT.

Ollama + Open WebUI est actuellement la combinaison d'IA locale la plus recommandée — simple à installer, interface conviviale et puissante, adaptée à la grande majorité des utilisateurs.


LM Studio : opérations via interface graphique

Si vous n'aimez pas la ligne de commande, LM Studio est un excellent choix —Interface purement graphique, le téléchargement et l'exécution des modèles se font entièrement dans la fenêtre.。

Installation de LM Studio

LM Studio prend en charge Windows, macOS et Linux.

Depuis le site officielhttps://lmstudio.aiTéléchargez le paquet d'installation et installez-le directement.

Téléchargement et gestion des modèles

Ouvrez LM Studio, la bibliothèque de modèles se trouve à gauche.

Vous pouvez rechercher par nom de modèle, par exemple rechercher "llama", "qwen", "mistral", trouver le modèle souhaité, puis cliquer sur télécharger.

LM Studio listera automatiquement les différentes versions du même modèle :

VersionDescriptionScénario recommandé
Q4_K_MQuantification 4 bits, peu de perte de qualitéLe choix de la plupart des gens
Q5_K_MQuantification 5 bits, meilleure qualité, taille légèrement plus grandeChoisissez ceci lorsque vous avez suffisamment de VRAM
Q8_0Quantification 8 bits, proche de la qualité nativePour ceux qui recherchent la qualité et ont suffisamment de VRAM
FP16Précision complète, taille la plus grandeÀ des fins de recherche

Les modèles téléchargés apparaîtront dans la liste "My Models".

Service API local

LM Studio peut également fournir un service API, compatible avec le format d'API d'OpenAI.

Cela signifie que pour le code OpenAI que vous écrivez, vous n'avez qu'à changer l'adresse API et la clé pour utiliser un modèle local.

Exemple

# Chemin du fichier : /Users/example/lmstudio_openai.py
# LM Studio est compatible avec le format API OpenAI

from openai import OpenAI

# Se connecter au serveur local LM Studio
# Remarque : vous devez d'abord démarrer le serveur dans LM Studio
client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="lm-studio"  # LM Studio peut simplement utiliser cet espace réservé
)


def ask_local_model(prompt: str, system_prompt: str = "Vous êtes un assistant serviable.") -> str:
    """
Appel du modèle local LM Studio via une interface compatible avec OpenAI
    """

    response = client.chat.completions.create(
        model="local-model",  # Ce champ sera ignoré par LM Studio
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
    )
    return response.choices[0].message.content


# Test
if __name__ == "__main__":
    question = "Présentez les fonctionnalités du tutoriel Python"
    answer = ask_local_model(
        prompt=question,
        system_prompt="Vous êtes le service client dédié d'Example, répondant professionnellement aux questions sur l'apprentissage de la programmation."
    )
    print(f"Q: {question}")
    print(f"A: {answer}")

Cette fonctionnalité est très utile—vous pouvez utiliser le même code pour basculer entre les modèles cloud et les modèles locaux selon vos besoins.

Pour les utilisateurs novices en IA locale, je recommande : commencez d'abord par LM Studio pour comprendre les concepts et opérations de base ; une fois familiarisé, utilisez Ollama pour l'automatisation et l'intégration.


Premiers pas avec la quantification des modèles

La quantification est une technologie clé qui permet aux grands modèles de fonctionner sur des ordinateurs ordinaires—Exécutez des modèles plus grands avec moins de VRAM tout en conservant la plupart des capacités。

Qu'est-ce que la quantification

En termes simples, la quantification consiste à réduire la précision des paramètres du modèle.

Les modèles natifs stockent généralement chaque paramètre en utilisant des nombres à virgule flottante de 16 bits (FP16) ou de 32 bits (FP32).

Après quantification, nous utilisons des entiers de 8 bits (INT8) ou même des entiers de 4 bits (INT4) pour le stockage.

La précision diminue, mais la taille et les besoins en VRAM sont considérablement réduits.

Par exemple :

PrecisionTaille du modèle 7BTaille du modèle 13BBesoin en VRAMPerte de qualité
FP1613 GB26 GBÉlevéeAucune
Q8_07 GB13 GBMoyenneTrès minime
Q5_K_M5 GB9 GBFaibleAcceptable
Q4_K_M4 GB7 GBTrès faibleLéger
Q3_K_M3 GB5 GBExtrêmement faibleÉvident

La règle empirique : la quantification Q8 a une perte de qualité presque imperceptible, et la quantification Q4 est suffisante pour la plupart des tâches.

Le format GGUF expliqué

GGUF est actuellement le format de modèle quantifié le plus populaire.

Le prédécesseur de GGUF est GGML, développé par le projet llama.cpp.

Avantages de ce format :

  • Premièrement,Bonne compatibilité multiplateforme—Fonctionne sous Windows, macOS et Linux ; s'exécute à la fois sur CPU et GPU.

  • Deuxièmement,Prend en charge plusieurs niveaux de quantification—De FP16 à Q3, choisissez selon vos besoins.

  • Troisièmement,Vitesse d'inférence rapide—Fortement optimisée pour CPU et GPU.

La plupart des outils de modèles locaux (Ollama, LM Studio, llama.cpp) prennent désormais en charge le format GGUF.

Différences entre la quantification Q4/Q8

Q4 et Q8 sont les deux niveaux de quantification les plus couramment utilisés.

  • La quantification Q8 est sur 8 bits ; chaque paramètre est stocké sous forme d’entier 8 bits. L’avantage de Q8 estune perte de qualité minimale, presque identique au modèle original; l’inconvénient est que la taille n’est toujours pas suffisamment petite.

  • La quantification Q4 est sur 4 bits ; chaque paramètre est stocké sous forme d’entier 4 bits. L’avantage de Q4 estune taille réduite et une vitesse élevée; l’inconvénient est que la qualité chute nettement sur les tâches complexes.

Comment choisir :

ScénarioNiveau de quantification recommandéRaison
VRAM très limitée (moins de 8GB)Q4_K_MÊtre utilisable est la priorité absolue
Conversation quotidienne, tâches simplesQ4_K_MMeilleur rapport qualité-prix
Rédaction, programmation, analyseQ5_K_M ou Q6_KÉquilibre entre qualité et vitesse
Recherche de la meilleure qualitéQ8_0Proche de la qualité native

Schémas de quantification AWQ/GPTQ

En plus de la quantification GGUF, il existe deux autres schémas de quantification courants : AWQ et GPTQ.

AWQ (Activation-aware Weight Quantization) se caractérise parla conservation des poids qui ont un fort impact sur les résultats, ce qui entraîne une perte de qualité plus faible après quantification.

GPTQ (Gradient-based Post-Training Quantization) se caractérise parl'utilisation des informations de gradient pour optimiser la quantification, adapté aux scénarios avec GPU.

Ces deux schémas sont principalement utilisés sur les GPU NVIDIA prenant en charge CUDA.

Comparaison simple :

Schéma de quantificationMatériel applicableVitesseQualitéOutils recommandés
GGUFCPU + différents GPURapideOKOllama、LM Studio
AWQNVIDIA GPUTrès rapideTrès bonvLLM、Text Generation WebUI
GPTQNVIDIA GPUTrès rapideTrès bonAutoGPTQ、ExLlama

Pour les débutants, ne vous préoccupez pas de ces détails techniques—utilisez simplement la version Q4_K_M recommandée dans Ollama ou LM Studio. C'est le meilleur compromis, vérifié par de nombreux tests.


Guide de sélection des modèles

Il existe désormais des centaines de modèles open source ; il est important d'en choisir un qui corresponde à vos besoins.

Comparaison des modèles 7B/13B/70B

Le nombre de paramètres est une mesure importante—7B, 13B et 70B sont les spécifications les plus courantes.

SpécificationMémoire VRAM requise (Q4)Vitesse d'inférenceNiveau de capacitéScénarios applicables
7B4-6 GBTrès rapideAdéquatConversation quotidienne, tâches simples
13B7-10 GBRapideBonRédaction, programmation, analyse
33B15-20 GBMoyenneExcellentRaisonnement complexe, domaines professionnels
70B30-40 GBPlus lentProche de GPT-3.5Recherche, environnements de production

Pour la plupart des gens, le meilleur compromis est la version quantifiée 13B Q4 — bonne capacité avec une vitesse acceptable.

Modèles recommandés avec un bon support du chinois

De nombreux modèles étrangers ont des capacités moyennes en chinois. Voici quelques modèles adaptés au chinois :

Nom du modèleDéveloppeurFonctionnalitésCommande Ollama
Qwen (Tongyi Qianwen)AlibabaForte capacité en chinois, performances équilibréesollama pull qwen
Yi (01.AI)01.AIBonne compréhension du chinois, raisonnement solideollama pull yi
DeepSeekDeepSeekCodage solide, chinois correctollama pull deepseek-coder
Llama 3MetaGlobalement solide, mais le chinois nécessite un affinageollama pull llama3
GemmaGoogleBase solide, bonne capacité de codageollama pull gemma

Pour les tâches en chinois, Qwen est le premier choix ; sa compréhension et sa génération du chinois sont de tout premier ordre parmi les modèles open source.

Sélection de modèle spécifique à la tâche

Différents modèles ont des forces différentes ; choisissez en fonction de votre tâche :

Type de tâcheModèle recommandéRaison
Conversation quotidienne, questions-réponsesLlama 3、Qwen、MistralCapacité globale équilibrée
Écriture, rédaction publicitaireYi, Llama 3, Claude (cloud)Bon style d'écriture, expression fluide
Programmation, codeDeepSeek-Coder、CodeLlama、StarCoderForte compréhension et génération de code
Mathématiques, raisonnementLlama 3、Qwen、WizardMathBon raisonnement logique
Domaines professionnels (médical, juridique)Modèles affinés pour le domaineEntraînés sur des données professionnelles

Un modèle plus grand n'est pas toujours meilleur, ni un plus récent —celui qui correspond à votre matériel et à votre tâcheest le meilleur. Commencez par essayer quelques modèles 7B pour vous faire une idée, puis passez à un modèle supérieur.


Mise en pratique : construire une base de connaissances locale entièrement hors ligne

L'un des cas d'usage les plus pratiques des modèles locaux consiste à construire votre propre base de connaissances privée —fournissez des documents locaux au modèle et faites-lui répondre à des questions en se basant sur ceux-ci.。

L'ensemble du système fonctionne entièrement hors ligne ; les données ne quittent jamais votre ordinateur.

Approche technique

Nous utilisons la technologie RAG (Retrieval-Augmented Generation) :

1. Découper les documents en segments

2. Utiliser un modèle d'embedding pour convertir chaque segment en vecteur

3. Stocker les vecteurs dans une base de données vectorielle

4. Lors d'une question, convertir également la question en vecteur

5. Trouver les segments de document les plus pertinents dans la base de données vectorielle

6. Envoyer ensemble les documents pertinents et la question au LLM local

7. Le LLM répond en fonction du contenu du document

Cela semble complexe, mais c'est simple avec les outils existants.

Implémentation avec Ollama + LangChain

Nous allons utiliser Python pour implémenter une version simple :

Exemple

# Chemin du fichier : /Users/example/local_knowledge_base.py
# Système RAG de base de connaissances locale entièrement hors ligne

# Installez d'abord les dépendances :
# pip install langchain langchain-ollama chromadb pypdf

from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
import os


class LocalKnowledgeBase:
    """Classe de base de connaissances locale implémentant une fonctionnalité RAG entièrement hors ligne"""

    def __init__(self, model_name: str = "llama3", persist_dir: str = "./chroma_db"):
        """
Initialiser la base de connaissances

        Arguments :
model_name: nom du modèle Ollama à utiliser
persist_dir: répertoire de persistance de la base de données vectorielle
        """

        self.model_name = model_name
        self.persist_dir = persist_dir

        # 1. Initialiser le LLM (modèle local)
        self.llm = OllamaLLM(model=model_name)

        # 2. Initialiser le modèle d'embedding (embeddings locaux)
        # Utiliser nomic-embed-text ; ce modèle fonctionne bien à la fois pour le chinois et l'anglais
        self.embeddings = OllamaEmbeddings(model="nomic-embed-text")

        # 3. Espace réservé pour la base de données vectorielle
        self.vector_store = None
        self.qa_chain = None

    def load_documents(self, document_paths: list):
        """
Charger les documents et construire la base de données vectorielle

        Arguments :
document_paths: Liste des chemins de documents
        """

        documents = []

        for path in document_paths:
            if not os.path.exists(path):
                print(f"Avertissement : le fichier {path} n'existe pas, ignoré")
                continue

            # Sélectionner le chargeur en fonction de l'extension du fichier
            if path.lower().endswith(".pdf"):
                loader = PyPDFLoader(path)
            elif path.lower().endswith(".txt"):
                loader = TextLoader(path, encoding="utf-8")
            else:
                print(f"Avertissement : type de fichier non pris en charge {path}, ignoré")
                continue

            documents.extend(loader.load())
            print(f"Chargé : {path}")

        if not documents:
            print("Aucun document n'a été chargé avec succès")
            return

        print(f"Total de {len(documents)} fragments de document chargés")

        # 4. Diviser les documents
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=500,      # Chaque fragment : 500 caractères
            chunk_overlap=100    # Chevauchement entre les fragments : 100 caractères
        )
        split_docs = text_splitter.split_documents(documents)
        print(f"Divisé en {len(split_docs)} segments")

        # 5. Construire la base de données vectorielle
        print("Construction de la base de données vectorielle...")
        self.vector_store = Chroma.from_documents(
            documents=split_docs,
            embedding=self.embeddings,
            persist_directory=self.persist_dir
        )
        print("Base de données vectorielle construite avec succès !")

        # 6. Construire la chaîne de questions-réponses
        self._build_qa_chain()

    def _build_qa_chain(self):
        """Construire la chaîne de questions-réponses RAG"""
        if not self.vector_store:
            print("Veuillez d'abord charger un document !")
            return

        # Construire le retriever
        retriever = self.vector_store.as_retriever(
            search_type="similarity",
            search_kwargs={"k": 3}  # Retourner les 3 segments les plus pertinents
        )

        # Construire la chaîne RAG
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",
            retriever=retriever,
            return_source_documents=True
        )

    def load_existing_db(self):
        """Charger la base de données vectorielle existante"""
        if os.path.exists(self.persist_dir):
            self.vector_store = Chroma(
                persist_directory=self.persist_dir,
                embedding_function=self.embeddings
            )
            self._build_qa_chain()
            print("Base de données vectorielle existante chargée")
            return True
        else:
            print("Aucune base de données vectorielle existante trouvée")
            return False

    def ask(self, question: str) -> dict:
        """
Poser une question à la base de connaissances

        Arguments :
question: question

        Retourne :
Un dictionnaire contenant la réponse et les sources de référence
        """

        if not self.qa_chain:
            return {"error": "Veuillez d'abord charger un document ou une base de données existante !"}

        # Construire un modèle de prompt pour encourager les réponses en chinois
        result = self.qa_chain.invoke({
            "query": f"""Veuillez répondre à la question suivante en chinois. Si la réponse se trouve dans le contexte, indiquez-le explicitement.
Si la réponse ne se trouve pas dans le contexte, dites honnêtement "Impossible de répondre sur la base des informations fournies."

Question : {question}
"""

        })

        return {
            "question": question,
            "answer": result["result"],
            "sources": [doc.page_content for doc in result["source_documents"]]
        }


# ============================================
# Exemple d'utilisation
# ============================================

if __name__ == "__main__":
    # 1. Créer une instance de base de connaissances
    kb = LocalKnowledgeBase(model_name="qwen")  # Utiliser Qwen, mieux adapté au chinois

    # 2. Essayer de charger une base de données existante ; sinon, charger les documents
    if not kb.load_existing_db():
        # Préparez quelques documents, par ex., enregistrez quelques tutoriels d'exemple au format txt
        sample_docs = [
            "/Users/example/documents/example_python_tutorial.txt",
            "/Users/example/documents/company_handbook.pdf",
        ]
        kb.load_documents(sample_docs)

    # 3. Questions-réponses interactives
    print("=" * 50)
    print("La base de connaissances locale d'exemple a démarré !")
    print("Entrez votre question, ou tapez 'quit' pour quitter")
    print("=" * 50)

    while True:
        user_input = input("\n"Votre question : ")

        if user_input.lower() in ["quit", "exit", "Exit"]:
            print("Au revoir !")
            break

        if not user_input.strip():
            continue

        # Poser une question
        result = kb.ask(user_input)

        if "error" in result:
            print(f"Erreur : {result['error']}")
            continue

        print(f"\n"Réponse : {result['answer']}")
        print("\n"Sources de référence : ")
        for i, source in enumerate(result["sources"], 1):
            print(f"\n[{i}] {source[:200]}...")

Avant d'utiliser ce système, vous devez télécharger le modèle d'embedding :

Exemple

# Télécharger le modèle d'embedding
ollama pull nomic-embed-text

# Télécharger le modèle principal (s'il n'est pas déjà téléchargé)
ollama pull qwen

Ainsi, vous disposez d'un système de base de connaissances privé qui fonctionne entièrement en local.

Vous pouvez ajouter vos propres notes, documents et livres électroniques, et laisser l'IA vous aider à effectuer des recherches et à répondre aux questions.

Toutes les données de ce système restent sur votre machine locale—les documents sur votre disque dur, la base de données vectorielle dans votre répertoire, les modèles sur votre ordinateur—vous n'avez donc pas du tout à vous soucier des fuites de données.


Conseils d'optimisation des performances

Le modèle local est en cours d'exécution, mais comment pouvez-vous le rendre plus rapide ? Voici quelques conseils pratiques.

Choisir le bon niveau de quantification

C'est l'optimisation la plus simple et la plus efficace—plus le niveau de quantification est bas, plus la vitesse est élevée.

Si Q4 fonctionne, n'utilisez pas Q8 ; si Q8 fonctionne, n'utilisez pas FP16.

Ajuster la taille de la fenêtre de contexte

Plus la fenêtre de contexte est grande, plus le calcul nécessaire est important.

Si vous n'avez pas besoin d'un long contexte, vous pouvez le définir dans le Modelfile d'Ollama :

Exemple

# Créer un modèle personnalisé avec une fenêtre de contexte limitée
# Créer un nouveau fichier Modelfile

echo "FROM llama3
PARAMETER num_ctx 2048"
> Modelfile

# Créer le modèle personnalisé
ollama create llama3-fast -f Modelfile

# Exécuter
ollama run llama3-fast

Réduire le contexte de la valeur par défaut 8192 à 2048 le rendra nettement plus rapide.

Utilisation de l'accélération GPU

Si vous avez un GPU NVIDIA ou un Mac Apple Silicon, assurez-vous qu'Ollama utilise le GPU plutôt que le CPU.

Ollama détectera et utilisera automatiquement le GPU, mais il faut parfois le vérifier.

Dans les journaux de démarrage d'Ollama, vous devriez voir des messages comme "Metal GPU activated" ou "CUDA activated".

Utilisation de paramètres d'échantillonnage plus rapides

Certains paramètres d'échantillonnage peuvent affecter la vitesse :

Exemple

# Créer un Modelfile optimisé pour la vitesse
# Fichier : Modelfile.fast

echo "FROM llama3
PARAMETER temperature 0.7
PARAMETER top_k 20
PARAMETER top_p 0.9
PARAMETER num_predict 256"
> Modelfile.fast

# Créer et exécuter
ollama create llama3-optimized -f Modelfile.fast
ollama run llama3-optimized

Description des paramètres :

ParamètreDescriptionSuggestions d'optimisation
temperatureContrôler l'aléatoireUne valeur modérée convient, cela n'affecte pas la vitesse
top_kLimiter le nombre de mots candidatsDéfinissez-le plus petit (20-40) pour accélérer
top_pSeuil de probabilité cumuléeLa valeur par défaut 0.9 convient
num_predictNombre maximal de tokens générésLimiter selon les besoins
num_ctxTaille de la fenêtre de contexteJuste ce qu'il faut convient ; plus c'est petit, plus c'est rapide

Désactivation des fonctionnalités inutiles

Si vous utilisez des appels API et que vous n'avez pas besoin de sortie en streaming, vous pouvez définir stream sur false.

Bien que cela n'accélère pas l'inférence, cela peut réduire la surcharge de transmission réseau.

L'optimisation des performances est un art de l'équilibre—la vitesse, la qualité et la mémoire ne peuvent pas être toutes atteintes en même temps. Trouvez le point d'équilibre qui correspond à vos besoins.

Autres extensions