Python et Conda

Cette page explique comment utiliser Python sur eXplor-v2 et comment isoler les dépendances d'un projet avec venv, pip ou Conda. Un environnement isolé évite les conflits entre projets et permet de reproduire plus facilement un calcul.

Choisir une méthode

Utilisez venv et pip pour les projets Python courants. Utilisez Conda lorsqu'un projet nécessite des paquets complexes, des dépendances non-Python ou un environnement déjà décrit par un fichier environment.yml.

Avant de commencer

Vérifiez les versions de Python disponibles par modules :

module spider python
module avail 2>&1 | grep -i python

Chargez une version de Python fournie par le centre :

module purge
module load nom_module_python

which python
python --version

Utilisez les noms exacts affichés par les commandes de recherche.

Évitez l'installation globale

N'installez pas de paquets avec pip install --user dans un environnement global sans en comprendre les conséquences. Préférez un environnement isolé par projet.

Choisir l'emplacement de l'environnement

Placez l'environnement dans un espace persistant adapté, généralement votre espace personnel ou l'espace projet :

$HOME/venvs/mon-projet
$HOME/mon-projet/.venv
$PROJECT/mon-projet/.venv

Évitez de créer un environnement dans $SCRATCH si vous devez le conserver : cet espace est destiné aux données temporaires.

L'environnement et les données de calcul n'ont pas le même rôle :

• conservez l'environnement et les fichiers de configuration dans $HOME ou l'espace projet ;
• placez les fichiers temporaires et les données intermédiaires dans $SCRATCH si cela est approprié.

Consultez Espaces de stockage.

Utiliser venv et pip

Créer un environnement virtuel

Depuis le répertoire du projet :

module purge
module load nom_module_python

python -m venv .venv

Activez l'environnement :

source .venv/bin/activate

Après activation, le chemin de l'interpréteur doit pointer vers .venv :

which python
python --version

Mettez à jour pip :

python -m pip install --upgrade pip

Installer des dépendances

Installez un paquet :

python -m pip install nom_paquet

Installez les dépendances décrites dans un fichier :

python -m pip install -r requirements.txt

Vérifiez les paquets installés :

python -m pip list
python -m pip show nom_paquet

Enregistrer les dépendances

Pour figer les versions utilisées :

python -m pip freeze > requirements.txt

Avant de publier ou d'utiliser ce fichier pour une installation sur un autre environnement, relisez-le : certaines dépendances peuvent avoir été installées localement ou ne pas être nécessaires au projet.

Désactiver l'environnement

Lorsque vous avez terminé :

deactivate

Utiliser Conda et Miniforge

Conda permet de créer des environnements contenant Python, des paquets Python et des dépendances système compatibles avec le canal de paquets utilisé.

Pourquoi privilégier Miniforge et conda-forge ?

Pour les environnements Conda sur eXplor-v2, privilégiez la distribution Miniforge et le canal communautaire conda-forge.

Cette approche offre notamment :

• un écosystème ouvert et largement utilisé dans le calcul scientifique ;
• une cohérence accrue entre les paquets installés depuis le même canal ;
• un accès à de nombreux paquets scientifiques, compilés et maintenus pour plusieurs plateformes ;
• une alternative évitant les conditions commerciales associées à l'utilisation des canaux et paquets Anaconda dans certains contextes professionnels ou institutionnels.

Évitez les canaux Anaconda par défaut

Les paquets distribués via les canaux Anaconda peuvent être soumis à des conditions d'utilisation commerciales dans certains contextes, notamment au sein de grandes organisations. Pour éviter toute ambiguïté de licence ou de conformité, utilisez de préférence Miniforge et conda-forge, conformément aux recommandations du centre.

Module recommandé

Pour créer ou installer des environnements Conda, chargez en priorité le module suivant :

module load miniforge/25.12

Ce module fournit Miniforge et les outils Conda associés. Utilisez-le de préférence aux installations personnelles de Conda ou de Mamba lorsque cela est possible.

Vérifiez que le module est chargé :

module list

Vous devez voir une sortie similaire :

Currently Loaded Modules:
  1) miniforge/25.12

Initialiser Conda dans le shell

Après le chargement du module, initialisez les fonctions Conda dans votre shell en chargeant le fichier miniforge.rc :

source "$HOME_MINIFORGE/miniforge.rc"

Après cette commande, l'invite de commande affiche généralement le préfixe (base) :

(base) utilisateur@hote:~$

Vous pouvez alors vérifier les commandes disponibles :

which conda
conda --version
conda info

Charger le fichier, pas le répertoire

$HOME_MINIFORGE désigne le répertoire d'installation de Miniforge. La commande suivante est incorrecte, car source attend un fichier shell et non un répertoire :

source "$HOME_MINIFORGE/"

Chargez précisément le fichier d'initialisation :

source "$HOME_MINIFORGE/miniforge.rc"

À répéter dans chaque nouveau shell

Le chargement du module et la commande source "$HOME_MINIFORGE/miniforge.rc" doivent être exécutés dans chaque nouveau terminal, session interactive ou script Slurm qui utilise Conda, sauf si une configuration officielle du centre les exécute déjà.

Créer un environnement Conda

Après avoir chargé le module et initialisé Conda, créez un environnement avec le canal conda-forge :

module load miniforge/25.12
source "$HOME_MINIFORGE/miniforge.rc"

conda create -n mon-projet -c conda-forge python=3.12
conda activate mon-projet

L'option -c conda-forge indique explicitement le canal de paquets à utiliser. Vérifiez l'environnement actif :

which python
python --version

Si Mamba est disponible dans le module ou l'environnement chargé, la syntaxe équivalente est :

mamba create -n mon-projet -c conda-forge python=3.12
mamba activate mon-projet

Toutefois, sur eXplor-v2, privilégiez miniforge/25.12 et conda-forge plutôt qu'une installation personnelle de Conda ou de Mamba.

Installer des paquets

Installez un paquet depuis conda-forge :

conda install -n mon-projet -c conda-forge nom_paquet

Après activation de l'environnement, vous pouvez aussi utiliser :

conda install -c conda-forge nom_paquet

Vous pouvez utiliser pip dans un environnement Conda, mais installez d'abord les dépendances disponibles avec Conda. Utilisez ensuite pip uniquement pour les paquets indisponibles sur conda-forge.

Exporter un environnement

Pour enregistrer les dépendances :

conda env export --from-history > environment.yml

Cette forme conserve principalement les dépendances demandées explicitement et produit un fichier plus facile à réutiliser qu'un export complet.

Pour recréer l'environnement :

conda env create -f environment.yml

Nom de l'environnement

Le nom indiqué dans environment.yml peut être modifié avant de créer l'environnement. Vérifiez qu'il ne remplace pas un environnement existant.

Modules et environnements Python

Un environnement Python repose souvent sur une version de Python fournie par un module. Chargez le même module lors de la création et de l'utilisation de l'environnement.

Exemple avec venv dans un script Slurm :

module purge
module load nom_module_python
source "$HOME/mon-projet/.venv/bin/activate"

which python
python --version
python -m pip list

Pour Miniforge, chargez le module puis initialisez Conda avant d'activer l'environnement :

module purge
module load miniforge/25.12
source "$HOME_MINIFORGE/miniforge.rc"
conda activate mon-projet

which python
python --version

Python dans un job Slurm

Utilisez un script batch pour les calculs longs ou reproductibles.

Exemple avec venv

#!/bin/bash
#SBATCH --job-name=python-analyse
#SBATCH --partition=std
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --time=01:00:00
#SBATCH --output=logs/%x-%j.out
#SBATCH --error=logs/%x-%j.err

set -euo pipefail

mkdir -p logs

module purge
module load nom_module_python
source "$HOME/mon-projet/.venv/bin/activate"

which python
python --version
python script.py

Exemple avec Miniforge et Conda

#!/bin/bash
#SBATCH --job-name=python-conda
#SBATCH --partition=std
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --time=01:00:00
#SBATCH --output=logs/%x-%j.out
#SBATCH --error=logs/%x-%j.err

set -euo pipefail

mkdir -p logs

module purge
module load miniforge/25.12
source "$HOME_MINIFORGE/miniforge.rc"
conda activate mon-projet

which python
python --version
python script.py

Pour un programme multithreadé utilisant des bibliothèques numériques, adaptez le nombre de threads aux CPU demandés :

export OMP_NUM_THREADS="$SLURM_CPUS_PER_TASK"
export MKL_NUM_THREADS="$SLURM_CPUS_PER_TASK"
export OPENBLAS_NUM_THREADS="$SLURM_CPUS_PER_TASK"

python script.py

Vérifiez la documentation des bibliothèques utilisées : certaines gèrent elles-mêmes les threads et peuvent nécessiter des réglages différents.

Python et GPU

Avant une campagne GPU, validez l'environnement dans une allocation interactive GPU. Vérifiez le matériel et la détection de l'accélérateur par votre bibliothèque Python.

Exemple de test :

nvidia-smi
python -c "import sys; print(sys.version)"

Avec PyTorch, si le paquet est installé dans l'environnement :

python -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'GPU indisponible')"

Avec JAX, si le paquet est installé :

python -c "import jax; print(jax.devices())"

Avec CuPy, si le paquet est installé :

python -c "import cupy; print(cupy.cuda.runtime.getDeviceCount())"

Compatibilité CUDA

La version de CUDA requise par PyTorch, JAX, CuPy ou une autre bibliothèque doit être compatible avec le pilote NVIDIA du nœud attribué. Consultez CUDA et GPU avant d'installer un paquet GPU.

JupyterLab et VS Code

Pour utiliser le même environnement Python dans JupyterLab ou VS Code via Open OnDemand, chargez le module Python nécessaire puis activez l'environnement depuis le terminal de la session.

Pour rendre un environnement venv disponible comme noyau Jupyter, installez ipykernel dans cet environnement :

source .venv/bin/activate
python -m pip install ipykernel
python -m ipykernel install --user \
  --name mon-projet \
  --display-name "Python (mon-projet)"

Le noyau doit être installé dans un espace persistant et le nom choisi doit être explicite.

Dans VS Code, sélectionnez l'interpréteur correspondant au fichier .venv/bin/python ou à l'environnement Conda du projet.

Consultez :

• JupyterLab ;
• VS Code ;
• Open OnDemand.

Diagnostiquer un environnement Python

Vérifiez l'interpréteur, les chemins et les paquets :

which python
python --version
python -m pip --version
python -m pip list
python -c "import sys; print(sys.executable); print('\n'.join(sys.path))"

Vérifiez si un environnement virtuel est actif :

echo "${VIRTUAL_ENV:-aucun environnement virtuel actif}"

Pour Conda :

conda info --envs
conda list

Erreurs fréquentes

ModuleNotFoundError

Le paquet n'est pas installé dans l'environnement Python actif ou le mauvais interpréteur est utilisé.

which python
python -m pip show nom_paquet

Activez le bon environnement, puis installez le paquet avec :

python -m pip install nom_paquet

pip installe les paquets au mauvais endroit

Utilisez toujours :

python -m pip install nom_paquet

plutôt que :

pip install nom_paquet

La première forme garantit que pip est associé au même interpréteur Python que celui qui exécutera le programme.

L'environnement Conda ne s'active pas dans un job Slurm

Chargez le module miniforge/25.12, puis chargez le fichier d'initialisation :

source "$HOME_MINIFORGE/miniforge.rc"

Activez ensuite l'environnement Conda et vérifiez l'interpréteur :

conda activate mon-projet
which python
python --version

Le GPU n'est pas détecté par Python

Vérifiez successivement :

• que vous êtes dans une allocation GPU ;
• que nvidia-smi fonctionne ;
• que la version de la bibliothèque Python est compatible avec le pilote ;
• que l'environnement Python actif contient une version GPU du paquet ;
• que les modules CUDA requis sont chargés selon les recommandations de la bibliothèque.

Bonnes pratiques

• Utilisez un environnement isolé par projet.
• Chargez explicitement le même module Python lors de la création et de l'exécution de l'environnement.
• Utilisez python -m pip plutôt que pip seul.
• Pour Conda, chargez miniforge/25.12, puis exécutez source "$HOME_MINIFORGE/miniforge.rc".
• Privilégiez le canal conda-forge.
• Évitez les canaux Anaconda par défaut afin de limiter les questions de conditions d'utilisation commerciales.
• Conservez requirements.txt ou environment.yml dans le dépôt du projet.
• Testez l'environnement sur un petit cas avant une campagne batch.
• Testez la détection GPU dans une allocation interactive avant une production GPU.
• Ne conservez pas les environnements importants uniquement dans $SCRATCH.
• Évitez d'installer des paquets dans l'environnement système ou partagé.
• Conservez dans les logs la version de Python, les paquets et les modules chargés.
• Ne stockez pas de jetons, mots de passe ou secrets dans environment.yml, requirements.txt ou le code source.

Pages associées

• Logiciels et environnements
• Modules
• Environnements logiciels
• Compilateurs et MPI
• CUDA et GPU
• Apptainer
• Reproductibilité
• JupyterLab
• VS Code
• Jobs interactifs
• Jobs batch
• Espaces de stockage