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 cloud | IA locale |
|---|---|---|
| Confidentialité des données | Les données doivent être téléversées | Les données sont entièrement locales |
| Dépendance au réseau | Connexion Internet requise | Aucun réseau requis |
| Coût d'utilisation | Paiement à l'usage | Un téléchargement, utilisation illimitée |
| Capacité de personnalisation | Limité | Entièrement contrôlable |
| Facilité d'utilisation | Prêt à l'emploi | Nécessite une configuration |
| Vitesse de réponse | Dépend du réseau | Dé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 VRAM | Modèles exécutables (FP16) | Modèles exécutables (après quantification) | Scénarios recommandés |
|---|---|---|---|
| 8 GB | Les modèles 7B sont quelque peu difficiles | 7B (Q4), 13B (Q4) fonctionnent à peine | Chat simple, tâches légères |
| 16 GB | Modèles 7B, 13B | 7B、13B(Q4/Q8)、33B(Q4) | Usage quotidien, meilleur rapport qualité-prix |
| 24 GB | Modèles 7B, 13B, 33B | 7B、13B、33B(Q4/Q8)、70B(Q4) | Usage professionnel, expérience fluide |
| 48 GB+ | Modèles 33B, 70B | Tous les modèles courants | Recherche, 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 :
| Forfait | Configuration | Convient pour | Expérience attendue |
|---|---|---|---|
| Formule d'entrée de gamme | Tout ordinateur (8GB+ RAM) | Débutants qui souhaitent découvrir l'IA locale | Peut exécuter de petits modèles, relativement lent |
| Meilleur rapport qualité-prix | 16GB RAM + 6GB+ VRAM | Usage personnel quotidien | Exécution fluide des modèles 7B/13B |
| Formule professionnelle | 32GB RAM + 12GB+ VRAM | Développeurs, chercheurs | Exécution fluide des modèles 33B |
| Formule Mac | M1/M2/M3 + 16GB de mémoire unifiée | Premier choix pour les utilisateurs Mac | Exé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
- Site officiel d'Ollama :https://ollama.com/
- Liste des modèles pris en charge par Ollama :https://ollama.com/search
- Tutoriel Ollama :https://www.example.com/ollama/ollama-tutorial.html
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
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 :
| Commande | Fonction | Exemple |
|---|---|---|
| ollama pull <model> | Télécharger le modèle | ollama pull llama3 |
| ollama run <model> | Exécuter le modèle | ollama run llama3 |
| ollama list | Lister les modèles installés | ollama list |
| ollama rm <model> | Supprimer le modèle | ollama rm llama3 |
| ollama show <model> | Afficher les informations du modèle | ollama 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
# 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
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
# 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
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 :
| Version | Description | Scénario recommandé |
|---|---|---|
| Q4_K_M | Quantification 4 bits, peu de perte de qualité | Le choix de la plupart des gens |
| Q5_K_M | Quantification 5 bits, meilleure qualité, taille légèrement plus grande | Choisissez ceci lorsque vous avez suffisamment de VRAM |
| Q8_0 | Quantification 8 bits, proche de la qualité native | Pour ceux qui recherchent la qualité et ont suffisamment de VRAM |
| FP16 | Pré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
# 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 :
| Precision | Taille du modèle 7B | Taille du modèle 13B | Besoin en VRAM | Perte de qualité |
|---|---|---|---|---|
| FP16 | 13 GB | 26 GB | Élevée | Aucune |
| Q8_0 | 7 GB | 13 GB | Moyenne | Très minime |
| Q5_K_M | 5 GB | 9 GB | Faible | Acceptable |
| Q4_K_M | 4 GB | 7 GB | Très faible | Léger |
| Q3_K_M | 3 GB | 5 GB | Extrê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énario | Niveau 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 simples | Q4_K_M | Meilleur rapport qualité-prix |
| Rédaction, programmation, analyse | Q5_K_M ou Q6_K | Équilibre entre qualité et vitesse |
| Recherche de la meilleure qualité | Q8_0 | Proche 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 quantification | Matériel applicable | Vitesse | Qualité | Outils recommandés |
|---|---|---|---|---|
| GGUF | CPU + différents GPU | Rapide | OK | Ollama、LM Studio |
| AWQ | NVIDIA GPU | Très rapide | Très bon | vLLM、Text Generation WebUI |
| GPTQ | NVIDIA GPU | Très rapide | Très bon | AutoGPTQ、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écification | Mémoire VRAM requise (Q4) | Vitesse d'inférence | Niveau de capacité | Scénarios applicables |
|---|---|---|---|---|
| 7B | 4-6 GB | Très rapide | Adéquat | Conversation quotidienne, tâches simples |
| 13B | 7-10 GB | Rapide | Bon | Rédaction, programmation, analyse |
| 33B | 15-20 GB | Moyenne | Excellent | Raisonnement complexe, domaines professionnels |
| 70B | 30-40 GB | Plus lent | Proche de GPT-3.5 | Recherche, 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èle | Développeur | Fonctionnalités | Commande Ollama |
|---|---|---|---|
| Qwen (Tongyi Qianwen) | Alibaba | Forte capacité en chinois, performances équilibrées | ollama pull qwen |
| Yi (01.AI) | 01.AI | Bonne compréhension du chinois, raisonnement solide | ollama pull yi |
| DeepSeek | DeepSeek | Codage solide, chinois correct | ollama pull deepseek-coder |
| Llama 3 | Meta | Globalement solide, mais le chinois nécessite un affinage | ollama pull llama3 |
| Gemma | Base solide, bonne capacité de codage | ollama 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âche | Modèle recommandé | Raison |
|---|---|---|
| Conversation quotidienne, questions-réponses | Llama 3、Qwen、Mistral | Capacité globale équilibrée |
| Écriture, rédaction publicitaire | Yi, Llama 3, Claude (cloud) | Bon style d'écriture, expression fluide |
| Programmation, code | DeepSeek-Coder、CodeLlama、StarCoder | Forte compréhension et génération de code |
| Mathématiques, raisonnement | Llama 3、Qwen、WizardMath | Bon raisonnement logique |
| Domaines professionnels (médical, juridique) | Modèles affinés pour le domaine | Entraî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
# 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
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 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
# 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ètre | Description | Suggestions d'optimisation |
|---|---|---|
| temperature | Contrôler l'aléatoire | Une valeur modérée convient, cela n'affecte pas la vitesse |
| top_k | Limiter le nombre de mots candidats | Définissez-le plus petit (20-40) pour accélérer |
| top_p | Seuil de probabilité cumulée | La valeur par défaut 0.9 convient |
| num_predict | Nombre maximal de tokens générés | Limiter selon les besoins |
| num_ctx | Taille de la fenêtre de contexte | Juste 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.
Autres extensionsL'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.