Skip to main content

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 :

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​