Exemples de code pour exécuter des LLM sur HPC
Find a file
2025-12-07 10:20:12 -05:00
images update ollama image + references slides 2025-10-07 14:08:47 -04:00
.gitignore Première version 2025-08-24 20:00:05 -04:00
annonce-promo.md restructurer les fichiers 2025-12-07 10:20:12 -05:00
hpc-configuration-francais.md restructurer les fichiers 2025-12-07 10:20:12 -05:00
hpc-setup-english.md restructurer les fichiers 2025-12-07 10:20:12 -05:00
LICENSE Initial commit 2025-08-24 18:28:56 +00:00
llm-hpc.pdf Première version 2025-08-24 20:00:05 -04:00
llm-hpc.py Première version 2025-08-24 20:00:05 -04:00
README.md restructurer les fichiers 2025-12-07 10:20:12 -05:00
setup_llm_hpc.sh Première version 2025-08-24 20:00:05 -04:00

Utilisation de grands modèles de langage localement en recherche

Utilisation de Ollama et Open Web UI sur son ordinateur local ou de l'infrastructure cloud

Pourquoi l'IA locale ?

  • Protection de la vie privée
  • Protection de la propriété intellectuelle
  • Impact environnemental moindre

Les principaux outils

Pour débuter:

  • Ollama
  • Open Web UI

Avancés:

  • vLLM
  • Flowise
  • LangChain/LangGraph

Ollama

  • Moteur d'inférence de modèles de langage et de plongements (Embeddings)
  • Permet de faire fonctionner des LLM localement

Les LLM sont des gros fichiers binaires qui contiennent les poids et la description de la structure d'un réseau de neurones profond.

ollama-internals

Installation

Télécharge le paquet Ollama pour macOS depuis le site web officiel.

  • Windows et MacOS: comme n'importe quel autre logiciel packagé
  • Linux: curl -fsSL https://ollama.com/install.sh | sh

Choisir un modèle de langage

  • Présence ou non d'un GPU (AMD, NVIDIA, Apple Silicon)
  • RAM et VRAM disponible
  • Fenêtre de contexte
  • Quantization (précision en bits des poids du modèle)

Règle du pouce

Un modèle dans Ollama quantisé en 4 bits utilise environ 70% du nombre de paramètres en octets de mémoire, plus un overhead.

  • Modèle 2b = 2 Go de RAM
  • Modèle 7b = 5 Go de RAM
  • Modèle 32b = 23 Go de RAM

Il faut ajouter à ça le contexte:

  • le nombre de jetons n'est pas suffisant pour calculer la taille
  • ça varie selon l'architecture du modèle
  • ça reste linéaire dans la plupart des cas

Outil super utile:

Types de modèles

  • Dense
  • Mixture of Experts
  • Réflectif
  • Vision / Multimodal

PC (CPU+GPU)

cpu-gpu-pci-express.jpeg

Apple Silicon

m1x-graphic

Attention au déversement sur CPU

Si le modèle n'est pas tout dans la VRAM

  • en partie sur la RAM
  • exécutées sur CPU
  • résultats envoyés au GPU

CPU, GPU et Bus PCI Express

  • CPU: 30x-50x moins rapide qu'un GPU pour ces calculs
  • bus PCI Express: partie entre carte mère et le GPU est particulièrement lente si aller-retour.

Soit:

  • tout sur GPU
  • tout sur CPU (lent, mais ça marche)

Utilisation de Ollama

# Télécharger un modèle
ollama pull monmodele:mataille
# Lancer un modèle dans le terminal
ollama run monmodele:mataille
# Lister les modèles actifs en mémoire
ollama ps 
# Listes les modèles téléchargés
ollama list

Pour changer la taille du contexte, une fois ollama run lancé:

/set parameter num_ctx 16384
/save modele_16k

Si je fais ollama ps, je vois la taille du contexte changé et la taille totale (modèle + contexte)

ollama ps

Open Web UI

Interface graphique complète pour utiliser des LLM localement

Installation avec Docker (testé Windows, MacOS et Linux)

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

Voici un exemple d'analyse de document dans Open Web UI avec le modèle précédent qwen3:8b et un contexte de 16384 tokens (environ 20 pages de PDF ou 10000 mots)

Analyse de document dans Open Web UI

Utilisation de Python et Transformers sur une infrastructure HPC

Prérequis

  • Accès à un cluster HPC (comme VALERIA, Calcul Québec, Alliance de recherche numérique du Canada)
  • Connaissances de base en Python
  • Accès à une session Jupyter (ou un environnement Python) sur l'instance de calcul

Configuration matérielle requise

  • RAM : Minimum 32 Go (pour les modèles 7B sans quantization)
  • CPU : 2 coeurs suffisent (le GPU sera le principal accélérateur)
  • GPU : Sélectionnez un GPU disponible sur le cluster

Étape 1 : Configuration de l'environnement sur le noeud frontal

Charger les modules nécessaires :

module load python/3.12 cuda/12.6 scipy-stack/2025a

Créer un environnement virtuel isolé :

virtualenv --no-download ~/venvs/$NAME
source ~/venvs/$NAME/bin/activate

Installer les bibliothèques deep learning :

pip install --no-index --upgrade pip
pip install --no-index transformers torch accelerate

Pourquoi --no-index ? Cette option force pip à utiliser uniquement les packages déjà disponibles dans l'environnement module, ce qui est plus rapide et plus fiable sur les clusters HPC.

Enregistrer l'environnement pour JupyterLab :

python -m ipykernel install --name ${NAME} --user

Étape 2 : Téléchargement du modèle depuis le noeud frontal

Ouvrir une session Python pour télécharger les fichiers du modèle :

python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Spécifier le modèle souhaité
model_name = "Qwen/Qwen2.5-7B-Instruct"

# Télécharger le tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Télécharger le modèle
model = AutoModelForCausalLM.from_pretrained(model_name)

Étape 3 : Configuration sur l'instance de calcul

Sélectionner et charger la collection de modules appropriés pour l'instance de calcul.

Charger le kernel virtuel créé précédemment dans JupyterLab.

Étape 4 : Code d'exécution sur l'instance de calcul

import json
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from tqdm import tqdm

# Configuration
model_name = "Qwen/Qwen2.5-7B-Instruct"
number_of_menus = 5

# Charger le modèle et le tokenizer
device = "cuda"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name).to(device)

Exemple détaillé

Bonnes pratiques

  • Gestion de la mémoire : Utilisez la quantization pour réduire l'empreinte mémoire
  • Optimisation des performances : Profitez du parallélisme des GPU dans les serveurs. Les processeurs NVIDIA reliés avec NVLink fonctionnent comme si c'était un seul gros processeur.
  • Reproductibilité : Sauvegardez les versions des bibliothèques utilisées
  • Sécurité : Ne stockez jamais de données sensibles dans les notebooks Jupyter. Il faut vider la sortie avant de sauvegarder et versionner dans Git.

Me suivre et me contacter