{"id":1281,"date":"2026-08-21T14:31:28","date_gmt":"2026-08-21T14:31:28","guid":{"rendered":"https:\/\/matforge.org\/?p=1281","raw":"https:\/\/matforge.org\/?p=1281"},"modified":"2026-08-21T14:31:28","modified_gmt":"2026-08-21T14:31:28","slug":"hpc-python-workflows-from-laptop-to-supercomputer","status":"publish","type":"post","link":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/","title":{"rendered":"Flux de travail HPC Python : de l&rsquo;ordinateur portable au superordinateur","raw":"Flux de travail HPC Python : de l'ordinateur portable au superordinateur"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 10<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><h2>Points \u00e0 retenir cl\u00e9s<\/h2>\n<ul>\n<li>Le code Python peut s&rsquo;ex\u00e9cuter sur un ordinateur portable et un syst\u00e8me HPC volumineux avec la m\u00eame logique de base lorsque le flux de travail utilise correctement MPI4Py ou Dask.<\/li>\n<li>La reproductibilit\u00e9 de l&rsquo;environnement est souvent la partie la plus difficile du travail de HPC. Les environnements Conda, les fichiers de verrouillage et les scripts de travaux aident \u00e0 le r\u00e9soudre.<\/li>\n<li>Le flux de travail comporte trois \u00e9tapes&nbsp;: prototyper localement, parall\u00e9liser avec MPI4PY ou DASK et soumettre des travaux via SLURM, PBS ou un autre planificateur.<\/li>\n<li>Ne r\u00e9\u00e9crivez pas toute la base de code pour le cluster. Gardez la logique de simulation stable et enveloppez-la avec un environnement reproductible et des couches d&rsquo;ex\u00e9cution parall\u00e8les.<\/li>\n<\/ul>\n<p>Vous \u00e9crivez un script de simulation sur votre ordinateur portable. Vous le testez avec de petits jeux de donn\u00e9es. Il fonctionne en quelques minutes. Ensuite, vous avez besoin de milliers de c\u0153urs et de centaines de gigaoctets de RAM pour l&rsquo;ex\u00e9cuter \u00e0 grande \u00e9chelle.<\/p>\n<p>R\u00e9\u00e9crivez-vous toute la base de code&nbsp;?<\/p>\n<p>Non. Le m\u00eame code Python qui s&rsquo;ex\u00e9cute sur votre ordinateur portable peut s&rsquo;ex\u00e9cuter sur un superordinateur avec des modifications minimales. La cl\u00e9 n&rsquo;est pas de r\u00e9\u00e9crire. C&rsquo;est enveloppant.<\/p>\n<p>Vous avez besoin de trois \u00e9l\u00e9ments&nbsp;: un environnement reproductible, un mod\u00e8le d&rsquo;ex\u00e9cution parall\u00e8le et un script de soumission de travaux pour le planificateur de cluster.<\/p>\n<p>Ce guide parcourt le flux de travail complet du prototype local au d\u00e9ploiement HPC de production sans modifier votre logique de simulation de base.<\/p>\n<h2>Le flux de travail HPC Python en trois \u00e9tapes<\/h2>\n<p>La plupart des projets HPC Python suivent le m\u00eame mod\u00e8le en trois \u00e9tapes, quel que soit le domaine scientifique.<\/p>\n<pre><code>Stage 1 \u2014 Local Prototyping:\n  Laptop \u2192 Jupyter or IDE \u2192 NumPy \/ Pandas \u2192 serial execution\n\nStage 2 \u2014 Parallelization:\n  Same code \u2192 mpi4py or Dask \u2192 parallel execution\n\nStage 3 \u2014 Cluster Deployment:\n  Python script \u2192 Slurm \/ PBS job submission \u2192 distributed compute nodes\n<\/code><\/pre>\n<p>L&rsquo;objectif est de parcourir ces \u00e9tapes progressivement. Commencez avec une version locale fonctionnelle. Ajoutez une ex\u00e9cution parall\u00e8le uniquement une fois que la logique est correcte. Soumettre au cluster uniquement apr\u00e8s des petits tests parall\u00e8les.<\/p>\n<h2>\u00c9tape 1 : Mise en place d&rsquo;un environnement reproductible<\/h2>\n<p>Avant d&rsquo;\u00e9crire du code parall\u00e8le, vous avez besoin d&rsquo;un environnement de d\u00e9veloppement fiable. C&rsquo;est l\u00e0 que de nombreux flux de travail scientifiques \u00e9chouent en premier.<\/p>\n<h3>Pourquoi la reproductibilit\u00e9 est difficile pour les clusters HPC<\/h3>\n<p>Les clusters HPC sont des syst\u00e8mes partag\u00e9s. De nombreux groupes de recherche utilisent la m\u00eame infrastructure et les packages de syst\u00e8mes peuvent changer au fil du temps. Une simulation qui fonctionne aujourd&rsquo;hui peut interrompre six mois plus tard apr\u00e8s les mises \u00e0 jour du module, les modifications du compilateur ou les modifications de la version du package.<\/p>\n<p>La solution est la gestion de l&rsquo;environnement. Conda est couramment utilis\u00e9 car il isole les packages du syst\u00e8me Python et peut g\u00e9rer les d\u00e9pendances compil\u00e9es ainsi que les packages Python.<\/p>\n<pre><code class=\"language-bash\"># Create a reproducible environment\nconda create -n my-sim python=3.11 numpy mpi4py dask\n\n# Lock dependencies for reproducibility\nconda env export --no-builds --name my-sim &gt; environment.yml\n\n# Recreate the environment on another machine\nconda env create -n my-sim -f environment.yml\n<\/code><\/pre>\n<p>Un seul fichier d&rsquo;environnement donne aux collaborateurs et aux futurs utilisateurs un moyen clair de recr\u00e9er la pile logicielle. Pour une reproductibilit\u00e9 plus stricte, utilisez des fichiers de verrouillage qui \u00e9pinglent chaque version de package et d\u00e9pendance de g\u00e9n\u00e9ration.<\/p>\n<h3>Conda vs Venv : pourquoi Conda gagne souvent sur HPC<\/h3>\n<p>Python int\u00e9gr\u00e9 <code>venv<\/code> fonctionne bien pour les packages Python Pure. Les flux de travail HPC d\u00e9pendent souvent de biblioth\u00e8ques scientifiques compil\u00e9es, d&rsquo;ex\u00e9cutions MPI, de HDF5, de BLA, de CUDA et d&rsquo;autres composants au niveau du syst\u00e8me.<\/p>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Fonctionnalit\u00e9<\/th>\n<th>veuve<\/th>\n<th>peste<\/th>\n<\/tr>\n<tr>\n<td>Forfaits Pure Python<\/td>\n<td>Oui<\/td>\n<td>Oui<\/td>\n<\/tr>\n<tr>\n<td>D\u00e9pendances au niveau du syst\u00e8me telles que MPI et HDF5<\/td>\n<td>Non<\/td>\n<td>Oui<\/td>\n<\/tr>\n<tr>\n<td>Coh\u00e9rence multiplateforme<\/td>\n<td>Limit\u00e9<\/td>\n<td>Fort<\/td>\n<\/tr>\n<tr>\n<td>Forfaits d&rsquo;acc\u00e9l\u00e9ration GPU tels que Cupy ou PyTorch CUDA<\/td>\n<td>Configuration manuelle<\/td>\n<td>Configuration plus automatis\u00e9e<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Conda donne une reproductibilit\u00e9 dans une plus grande partie de la pile scientifique. Cela compte lorsqu&rsquo;il travaille avec MPI4Py car l&rsquo;environnement d&rsquo;ex\u00e9cution MPI et Python doit \u00eatre compatible \u00e0 la fois sur la machine locale et sur le cluster.<\/p>\n<h2>\u00c9tape&nbsp;2&nbsp;: Parall\u00e8lement \u00e0 votre code Python<\/h2>\n<p>Une fois que la version locale fonctionne, la prochaine \u00e9tape est la parall\u00e9lisation. Dans les flux de travail HPC Python, deux outils sont particuli\u00e8rement courants :<\/p>\n<ol>\n<li>MPI4py pour un contr\u00f4le distribu\u00e9 \u00e0 grain fin sur de nombreux n\u0153uds.<\/li>\n<li>DASK pour un parall\u00e9lisme de niveau sup\u00e9rieur avec moins de changements de code.<\/li>\n<\/ol>\n<h3>Pourquoi vous avez besoin de MPI4PY<\/h3>\n<p>Le verrou d&rsquo;interpr\u00e9teur global de Python limite la v\u00e9ritable ex\u00e9cution de Python multithread dans un processus. Le module <code>multiprocessing<\/code> peut parall\u00e9liser sur une seule machine, mais il ne s&rsquo;adapte pas naturellement \u00e0 plusieurs n\u0153uds de calcul.<\/p>\n<p>MPI4PY fournit des liaisons Python pour MPI, l&rsquo;interface de transmission de messages. MPI est une API standard pour le calcul parall\u00e8le distribu\u00e9 et est largement utilis\u00e9 sur les syst\u00e8mes HPC.<\/p>\n<p>Avec MPI4Py, chaque processus ex\u00e9cute le m\u00eame script mais re\u00e7oit un rang unique. Ce classement contr\u00f4le la partie de la charge de travail que chaque processus g\u00e8re.<\/p>\n<h3>Mod\u00e8le MPI4PY de base&nbsp;: bonjour le monde<\/h3>\n<pre><code class=\"language-python\">from mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\nprint(f\"Hello from process {rank} out of {size} processes\")\n<\/code><\/pre>\n<p>Lancez le script avec MPI&nbsp;:<\/p>\n<pre><code class=\"language-bash\">mpiexec -n 16 python my_script.py\n<\/code><\/pre>\n<p>Cela d\u00e9marre 16 processus Python ind\u00e9pendants. Chaque processus ex\u00e9cute le m\u00eame script, mais chacun a un <code>rank<\/code> diff\u00e9rent.<\/p>\n<h3>Le mod\u00e8le de donn\u00e9es : processus ind\u00e9pendants<\/h3>\n<p>Les processus MPI ne partagent pas de m\u00e9moire par d\u00e9faut. Chaque processus a son propre espace m\u00e9moire. Pour \u00e9changer des informations, les processus doivent explicitement envoyer, recevoir, diffuser, collecter ou r\u00e9duire les donn\u00e9es.<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\n\n# Rank 0 creates the initial data.\nif rank == 0:\n    data = np.arange(10, dtype=\"i\")\nelse:\n    data = np.empty(10, dtype=\"i\")\n\n# Broadcast data from rank 0 to all ranks.\ncomm.Bcast(data, root=0)\n\nprint(f\"Rank {rank} received data: {data}\")\n<\/code><\/pre>\n<p>Ce mod\u00e8le de communication explicite est l&rsquo;une des raisons pour lesquelles le MPI \u00e9volue bien. Chaque classement poss\u00e8de sa m\u00e9moire locale et la communication ne se produit que lorsque vous en faites la demande.<\/p>\n<h3>Distribution de la charge de travail&nbsp;: le mod\u00e8le de base<\/h3>\n<p>La plupart des flux de travail MPI scientifiques suivent le m\u00eame sch\u00e9ma&nbsp;: divisez le probl\u00e8me, calculez localement et r\u00e9duisez les r\u00e9sultats.<\/p>\n<pre><code class=\"language-python\">from mpi4py import MPI\nimport numpy as np\n\ncomm = MPI.COMM_WORLD\n\nsize = comm.Get_size()\nrank = comm.Get_rank()\n\n# Total problem size\nN = 10_000_000\n\n# Calculate workload per rank\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\n# Each rank works on its own slice\nmy_data = np.random.rand(my_end - my_start)\n\n# Local computation\nlocal_result = np.sum(np.sin(my_data))\n\n# Sum results across all ranks\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Total computed across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<p>Ce mod\u00e8le s&rsquo;applique \u00e0 de nombreuses t\u00e2ches de simulation :<\/p>\n<ul>\n<li>Simulations de Monte Carlo, o\u00f9 chaque classement traite des \u00e9chantillons ind\u00e9pendants.<\/li>\n<li>Balayages de param\u00e8tres, chaque classement testant diff\u00e9rents jeux de param\u00e8tres.<\/li>\n<li>D\u00e9composition du domaine, o\u00f9 chaque classement poss\u00e8de une partie de la grille de simulation.<\/li>\n<li>Dynamique mol\u00e9culaire, o\u00f9 les rangs calculent les forces pour diff\u00e9rents sous-ensembles de particules.<\/li>\n<\/ul>\n<h3>La bo\u00eete \u00e0 outils de communication collective<\/h3>\n<p>MPI4PY fournit des op\u00e9rations collectives qui sont g\u00e9n\u00e9ralement plus faciles et plus efficaces que la messagerie point \u00e0 point personnalis\u00e9e.<\/p>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Op\u00e9ration<\/th>\n<th>ce qu&rsquo;il fait<\/th>\n<th>Quand utiliser<\/th>\n<\/tr>\n<tr>\n<td><code>Bcast<\/code><\/td>\n<td>Un processus envoie les m\u00eames donn\u00e9es \u00e0 tous les rangs<\/td>\n<td>Partage des conditions initiales, des constantes ou des valeurs de configuration<\/td>\n<\/tr>\n<tr>\n<td><code>Scatter<\/code><\/td>\n<td>Distribue des morceaux d&rsquo;un tableau \u00e0 travers les rangs<\/td>\n<td>D\u00e9composition du domaine ou partitionnement de la charge de travail<\/td>\n<\/tr>\n<tr>\n<td><code>Gather<\/code><\/td>\n<td>Collecte des donn\u00e9es de tous les rangs<\/td>\n<td>Collecte des sorties partielles<\/td>\n<\/tr>\n<tr>\n<td><code>Reduce<\/code><\/td>\n<td>Agr\u00e9ge des valeurs telles que somme, max ou min<\/td>\n<td>Sommer des \u00e9nergies ou collecter des m\u00e9triques globales<\/td>\n<\/tr>\n<tr>\n<td><code>Allreduce<\/code><\/td>\n<td>Agr\u00e9ge les valeurs et donne le r\u00e9sultat \u00e0 chaque rang<\/td>\n<td>Synchroniser l&rsquo;\u00e9tat global dans tous les processus<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Utilisez la communication collective lorsque cela est possible. Il est g\u00e9n\u00e9ralement plus simple et plus efficace que de coordonner manuellement de nombreux envois et r\u00e9ceptions.<\/p>\n<h3>Quand utiliser DASK \u00e0 la place<\/h3>\n<p>Dask se situe entre Python en s\u00e9rie et MPI. Il est utile lorsque la charge de travail est parall\u00e8lement embarrassante, comme l&rsquo;ex\u00e9cution de la m\u00eame simulation avec de nombreux jeux de param\u00e8tres ou conditions initiales.<\/p>\n<pre><code class=\"language-python\">from dask.distributed import Client\nfrom dask import delayed\n\nclient = Client(n_workers=16, threads_per_worker=4)\n\ndef my_simulation(params):\n    # Your simulation logic here\n    return params[\"a\"] * params[\"b\"]\n\nparameter_list = [\n    {\"a\": i, \"b\": 2.0}\n    for i in range(100)\n]\n\ntasks = [\n    delayed(my_simulation)(params)\n    for params in parameter_list\n]\n\nfinal_results = client.compute(tasks, sync=True)\n\nprint(final_results[:5])\n<\/code><\/pre>\n<p>L&rsquo;avantage de Dask est qu&rsquo;il vous permet de parall\u00e9liser de nombreux flux de travail sans red\u00e9finir la simulation autour des rangs et des communicateurs.<\/p>\n<h3>MPI4py vs DASK&nbsp;: lequel choisir&nbsp;?<\/h3>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Crit\u00e8re<\/th>\n<th>Mpi4py<\/th>\n<th>t\u00e9n\u00e8bres<\/th>\n<\/tr>\n<tr>\n<td>Courbe d&rsquo;apprentissage<\/td>\n<td>Plus raide parce que vous devez comprendre les rangs et les communicateurs<\/td>\n<td>Plus doux car il utilise des mod\u00e8les de t\u00e2ches Python familiers<\/td>\n<\/tr>\n<tr>\n<td>Contr\u00f4le \u00e0 grain fin<\/td>\n<td>Excellent car chaque communication est explicite<\/td>\n<td>Limit\u00e9 par l&rsquo;abstraction du graphe de t\u00e2ches<\/td>\n<\/tr>\n<tr>\n<td>Efficacit\u00e9 m\u00e9moire<\/td>\n<td>\u00c9lev\u00e9 car chaque classement stocke sa propre tranche<\/td>\n<td>Mod\u00e9r\u00e9 parce que les travailleurs ajoutent des frais g\u00e9n\u00e9raux<\/td>\n<\/tr>\n<tr>\n<td>Convient \u00e0<\/td>\n<td>Solveurs PDE \u00e0 grande \u00e9chelle et simulations d\u00e9compos\u00e9es par le domaine<\/td>\n<td>Monte Carlo, balayages de param\u00e8tres et analyse des donn\u00e9es<\/td>\n<\/tr>\n<tr>\n<td>Meilleure \u00e9chelle<\/td>\n<td>Parall\u00e9lisme dense sur de nombreux n\u0153uds<\/td>\n<td>\u00c9chelle faible sur le nombre de travailleurs mod\u00e9r\u00e9s<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Commencez par Dask pour le prototypage et des charges de travail parall\u00e8les embarrassantes. Passez \u00e0 MPI4PY lorsque vous avez besoin d&rsquo;un contr\u00f4le \u00e9troit de la communication, de la m\u00e9moire et de la mise \u00e0 l&rsquo;\u00e9chelle sur de nombreux n\u0153uds.<\/p>\n<h2>\u00c9tape 3 : Soumission au cluster<\/h2>\n<p>Apr\u00e8s les tests et la parall\u00e9lisation locaux, la prochaine \u00e9tape est le d\u00e9ploiement de cluster. La plupart des clusters utilisent un planificateur de travaux. Le slurm est l&rsquo;un des plus courants.<\/p>\n<h3>Le script de travail Slurm<\/h3>\n<p>Un script de t\u00e2che Slurm indique au planificateur quelles ressources vous avez besoin et comment ex\u00e9cuter le code.<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=my-sim\n#SBATCH --nodes=32\n#SBATCH --tasks-per-node=4\n#SBATCH --cpus-per-task=1\n#SBATCH --mem=8GB\n#SBATCH --time=04:00:00\n#SBATCH --output=sim_output.%j\n\n# Load required modules\nmodule load Python\/3.11\n\n# Activate conda environment\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\n# Run the MPI job\nsrun python my_simulation.py\n<\/code><\/pre>\n<p>Les param\u00e8tres importants comprennent :<\/p>\n<ul>\n<li><code>--nodes<\/code>&nbsp;: nombre de n\u0153uds de calcul.<\/li>\n<li><code>--tasks-per-node<\/code>&nbsp;: nombre de t\u00e2ches MPI par n\u0153ud.<\/li>\n<li><code>--cpus-per-task<\/code>&nbsp;: c\u0153urs de CPU affect\u00e9s \u00e0 chaque t\u00e2che.<\/li>\n<li><code>--time<\/code>&nbsp;: limite d&rsquo;horloge murale. Les emplois sont g\u00e9n\u00e9ralement arr\u00eat\u00e9s s&rsquo;ils le d\u00e9passent.<\/li>\n<li><code>--output<\/code>&nbsp;: mod\u00e8le de fichier de sortie. <code>%j<\/code> Ins\u00e8re l&rsquo;ID du travail.<\/li>\n<\/ul>\n<h3>Ex\u00e9cution sur des clusters sans Slurm<\/h3>\n<p>Tous les clusters n&rsquo;utilisent pas Slurm. Les alternatives courantes comprennent :<\/p>\n<ul>\n<li>PBS ou couple, g\u00e9n\u00e9ralement en utilisant <code>qsub<\/code>.<\/li>\n<li>LSF, en utilisant g\u00e9n\u00e9ralement <code>bsub<\/code>.<\/li>\n<li>Cobalt ou autres planificateurs sp\u00e9cifiques au site.<\/li>\n<\/ul>\n<p>La syntaxe de la soumission des travaux change, mais le code Python ne change g\u00e9n\u00e9ralement pas. MPI4PY et DASK sont pour la plupart agnostiques de planification une fois lanc\u00e9s correctement.<\/p>\n<h3>Mode interactif vs batch<\/h3>\n<p>Pour le d\u00e9bogage, les ex\u00e9cutions interactives sont utiles :<\/p>\n<pre><code class=\"language-bash\">srun --ntasks=4 --pty --time=02:00:00 python my_simulation.py\n<\/code><\/pre>\n<p>Pour la production, utilisez la soumission par lot&nbsp;:<\/p>\n<pre><code class=\"language-bash\">sbatch my_job_script.sh\n<\/code><\/pre>\n<p>Les sessions interactives sont bonnes pour les tests courts. Les travaux par lots sont meilleurs pour les longues p\u00e9riodes, les charges de travail du jour au lendemain et les simulations de production.<\/p>\n<h2>Le flux de travail complet : de l&rsquo;ordinateur portable \u00e0 la production<\/h2>\n<p>La transition du prototype local au d\u00e9ploiement du cluster peut \u00eatre progressive. La logique de simulation de base doit rester stable pendant que l&rsquo;enveloppe d&rsquo;ex\u00e9cution change.<\/p>\n<h3>\u00c9tape&nbsp;1&nbsp;: D\u00e9velopper et tester localement<\/h3>\n<pre><code class=\"language-python\"># my_simulation.py\nimport numpy as np\n\ndef simulate(initial_condition, params):\n    # Core simulation logic\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\n# Local test\ndata = np.random.rand(1000)\nresult = simulate(data, {\"factor\": 1.5})\n\nprint(f\"Local result: {result}\")\n<\/code><\/pre>\n<h3>\u00c9tape&nbsp;2&nbsp;: Ajout de la parall\u00e9lisation<\/h3>\n<pre><code class=\"language-python\"># my_simulation_mpi.py\nimport numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\ndef simulate(initial_condition, params):\n    # Core simulation logic stays the same\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\nN = 10_000_000\n\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\nmy_data = np.random.rand(my_end - my_start)\n\nlocal_result = simulate(my_data, {\"factor\": 1.5})\n\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Parallel result across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<h3>\u00c9tape&nbsp;3&nbsp;: Soumettre au cluster<\/h3>\n<p>Enregistrez un script de travail tel que <code>job_script.sh<\/code>&nbsp;:<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=parallel-sim\n#SBATCH --nodes=64\n#SBATCH --tasks-per-node=8\n#SBATCH --time=12:00:00\n\nmodule load Python\/3.11\n\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\nsrun python my_simulation_mpi.py\n<\/code><\/pre>\n<p>Soumettez-le&nbsp;:<\/p>\n<pre><code class=\"language-bash\">sbatch job_script.sh\n<\/code><\/pre>\n<p>La logique de simulation reste la m\u00eame. Le wrapper modifie la fa\u00e7on dont la charge de travail est divis\u00e9e et lanc\u00e9e.<\/p>\n<h2>Des pi\u00e8ges courants et comment les \u00e9viter<\/h2>\n<h3>Pitfall&nbsp;1&nbsp;: Diffuser trop de donn\u00e9es<\/h3>\n<p>La diffusion de grands tableaux de rang 0 \u00e0 chaque rang peut devenir un goulot d&rsquo;\u00e9tranglement de communication. Pour les simulations volumineuses, \u00e9vitez d&rsquo;envoyer plus de donn\u00e9es que ce dont chaque rang a besoin.<\/p>\n<p>Les meilleures options incluent :<\/p>\n<ul>\n<li>Utilisez <code>Scatter<\/code> au lieu de <code>Bcast<\/code> lorsque chaque rang n&rsquo;a besoin que d&rsquo;une tranche.<\/li>\n<li>Utilisez la d\u00e9composition du domaine afin que chaque rang poss\u00e8de une r\u00e9gion de la simulation.<\/li>\n<li>Pour Monte Carlo, laissez chaque rang g\u00e9n\u00e9rer ses propres \u00e9chantillons al\u00e9atoires au lieu de les diffuser.<\/li>\n<\/ul>\n<h3>Pitfall 2 : surallocation des ressources du cluster<\/h3>\n<p>Demander plus de n\u0153uds que votre code peut utiliser des pertes de temps d&rsquo;allocation et peut augmenter le d\u00e9lai de file d&rsquo;attente.<\/p>\n<p>Commencez par un petit travail de test, tel que 4 \u00e0 8 n\u0153uds. Mesurez l&rsquo;acc\u00e9l\u00e9ration. \u00c9chelle uniquement apr\u00e8s que le code montre une efficacit\u00e9 parall\u00e8le utile.<\/p>\n<h3>Pitfall 3 : Oublier le Gil en code mixte<\/h3>\n<p>Les biblioth\u00e8ques NumPy, Scipy et Compiled C ou Fortran lib\u00e8rent souvent le verrou d&rsquo;interpr\u00e9teur global Python lors d&rsquo;op\u00e9rations num\u00e9riques lourdes. Les threads Pure Python ne procurent g\u00e9n\u00e9ralement pas le m\u00eame avantage.<\/p>\n<p>Si votre flux de travail m\u00e9lange les threads Python avec les biblioth\u00e8ques num\u00e9riques, testez la mise \u00e0 l&rsquo;\u00e9chelle au lieu de supposer que plus de threads vous aideront.<\/p>\n<h3>Pitfall 4 : inad\u00e9quation de l&rsquo;environnement sur le cluster<\/h3>\n<p>Votre ordinateur portable peut utiliser Python 3.11 tandis que le module de cluster fournit Python 3.9. Les biblioth\u00e8ques MPI4Py, MPI et les d\u00e9pendances compil\u00e9es peuvent se casser lorsque les versions ne correspondent pas.<\/p>\n<p>Utilisez un environnement Conda et documentez la configuration exacte. Recr\u00e9ez et testez l&rsquo;environnement sur le cluster avant d&rsquo;ex\u00e9cuter des travaux volumineux.<\/p>\n<h2>Guide de d\u00e9cision&nbsp;: quelle strat\u00e9gie de parall\u00e9lisation&nbsp;?<\/h2>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Situation<\/th>\n<th>Approche recommand\u00e9e<\/th>\n<\/tr>\n<tr>\n<td>Petit ensemble de donn\u00e9es et tests de logique locale<\/td>\n<td>Python s\u00e9rie avec NumPy<\/td>\n<\/tr>\n<tr>\n<td>Machine unique avec plusieurs c\u0153urs<\/td>\n<td>Python <code>multiprocessing<\/code> ou DASK <code>LocalCluster<\/code><\/td>\n<\/tr>\n<tr>\n<td>8 \u00e0 64&nbsp;travailleurs et t\u00e2ches parall\u00e8les embarrassantes<\/td>\n<td>DASK avec un lanceur de cluster<\/td>\n<\/tr>\n<tr>\n<td>64 \u00e0 1&nbsp;000&nbsp;n\u0153uds et PDE d\u00e9compos\u00e9s dans le domaine<\/td>\n<td>MPI4Py avec une distribution de charge de travail explicite<\/td>\n<\/tr>\n<tr>\n<td>Simulation de production sur plus de 1&nbsp;000&nbsp;noeuds<\/td>\n<td>MPI4Py, scripts de travaux de planificateur et environnement Conda verrouill\u00e9<\/td>\n<\/tr>\n<tr>\n<td>Code de recherche sans reproductibilit\u00e9 garantie<\/td>\n<td>DASK, fichier d&rsquo;environnement Conda et script de travail comme point de d\u00e9part<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Votre outil de parall\u00e9lisation doit correspondre \u00e0 l&rsquo;\u00e9chelle et \u00e0 la structure du probl\u00e8me. Commencez plus petit que ce dont vous pensez avoir besoin, puis augmentez apr\u00e8s la mesure des performances.<\/p>\n<h2>Guides connexes<\/h2>\n<p>Pour les sujets connexes dans les flux de travail de simulation scientifique&nbsp;:<\/p>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-acceleration-for-fipy-simulations-cupy-and-numba-integration-guide\/\">Acc\u00e9l\u00e9ration GPU pour les simulations FIPY&nbsp;: CUPY et NUMBA Integration Guide<\/a> \u2014 Lorsque le processeur parall\u00e8le ne suffit pas.<\/li>\n<li><a href=\"https:\/\/matforge.org\/performance-profiling-optimization-python-pde-solvers\/\">Profilage et optimisation des performances pour les solveurs PDE de Python&nbsp;: un guide pratique<\/a> \u2014 Trouver des goulots d&rsquo;\u00e9tranglement avant parall\u00e9lisation.<\/li>\n<li><a href=\"https:\/\/matforge.org\/python-debugging-scientific-code-print-statements-profiling\/\">d\u00e9bogage de Python pour le code scientifique&nbsp;: des instructions d&rsquo;impression au profilage<\/a> &#8211; d\u00e9bogage des simulations parall\u00e8les.<\/li>\n<\/ul>\n<h2>R\u00e9sum\u00e9 et \u00e9tapes suivantes<\/h2>\n<p>Les flux de travail HPC Python concernent l&#8217;emballage, et non la r\u00e9\u00e9criture. La m\u00eame logique de simulation qui s&rsquo;ex\u00e9cute sur un ordinateur portable peut s&rsquo;ex\u00e9cuter sur de nombreux c\u0153urs lorsque vous cr\u00e9ez la bonne structure d&rsquo;ex\u00e9cution.<\/p>\n<p>Le workflow est :<\/p>\n<ol>\n<li>Verrouillez l&rsquo;environnement avec Conda afin que le code s&rsquo;ex\u00e9cute de mani\u00e8re coh\u00e9rente entre les syst\u00e8mes.<\/li>\n<li>Ajoutez du parall\u00e9lisme avec MPI4PY pour un contr\u00f4le distribu\u00e9 \u00e0 grain fin ou un DASK pour un parall\u00e9lisme de t\u00e2ches de haut niveau.<\/li>\n<li>Soumettez des travaux via Slurm, PBS, LSF ou le planificateur utilis\u00e9 par votre cluster.<\/li>\n<\/ol>\n<p>La partie la plus difficile est souvent l&rsquo;environnement, pas le code. Investissez rapidement dans une configuration reproductible et les simulations parall\u00e8les deviennent plus faciles \u00e0 mettre \u00e0 l&rsquo;\u00e9chelle de l&rsquo;ordinateur portable au superordinateur.<\/p>\n<h3>Prochaines \u00e9tapes<\/h3>\n<ol>\n<li>V\u00e9rifier la simulation actuelle. S&rsquo;il ne fonctionne que sur un ordinateur portable, commencez par cr\u00e9er un environnement Conda et tester une petite ex\u00e9cution multic\u0153ur.<\/li>\n<li>Mesurez avant de mettre \u00e0 l&rsquo;\u00e9chelle. Ex\u00e9cutez un petit travail de cluster, mesurez l&rsquo;acc\u00e9l\u00e9ration, puis passez \u00e0 la taille de la production.<\/li>\n<li>Documentez la configuration. Enregistrez le fichier d&rsquo;environnement, le script de travail, la commande de lancement et la sortie attendue.<\/li>\n<\/ol>\n<p>L&rsquo;\u00e9tablissement d&rsquo;un flux de travail HPC Python n\u00e9cessite de comprendre les packages scientifiques Python, la programmation parall\u00e8le et l&rsquo;infrastructure de cluster. Si vous avez besoin d&rsquo;aide pour la parall\u00e9lisation MPI, la planification des t\u00e2ches ou la reproductibilit\u00e9 de l&rsquo;environnement, notre \u00e9quipe peut prendre en charge des flux de travail scientifiques \u00e9volutifs de Python, notamment des simulations bas\u00e9es sur Fipy et des moteurs de Monte Carlo personnalis\u00e9s.<\/p>\n","protected":false,"raw":"<h2>Points \u00e0 retenir cl\u00e9s<\/h2>\n<ul>\n<li>Le code Python peut s'ex\u00e9cuter sur un ordinateur portable et un syst\u00e8me HPC volumineux avec la m\u00eame logique de base lorsque le flux de travail utilise correctement MPI4Py ou Dask.<\/li>\n<li>La reproductibilit\u00e9 de l'environnement est souvent la partie la plus difficile du travail de HPC. Les environnements Conda, les fichiers de verrouillage et les scripts de travaux aident \u00e0 le r\u00e9soudre.<\/li>\n<li>Le flux de travail comporte trois \u00e9tapes&nbsp;: prototyper localement, parall\u00e9liser avec MPI4PY ou DASK et soumettre des travaux via SLURM, PBS ou un autre planificateur.<\/li>\n<li>Ne r\u00e9\u00e9crivez pas toute la base de code pour le cluster. Gardez la logique de simulation stable et enveloppez-la avec un environnement reproductible et des couches d'ex\u00e9cution parall\u00e8les.<\/li>\n<\/ul>\n<p>Vous \u00e9crivez un script de simulation sur votre ordinateur portable. Vous le testez avec de petits jeux de donn\u00e9es. Il fonctionne en quelques minutes. Ensuite, vous avez besoin de milliers de c\u0153urs et de centaines de gigaoctets de RAM pour l'ex\u00e9cuter \u00e0 grande \u00e9chelle.<\/p>\n<p>R\u00e9\u00e9crivez-vous toute la base de code&nbsp;?<\/p>\n<p>Non. Le m\u00eame code Python qui s'ex\u00e9cute sur votre ordinateur portable peut s'ex\u00e9cuter sur un superordinateur avec des modifications minimales. La cl\u00e9 n'est pas de r\u00e9\u00e9crire. C'est enveloppant.<\/p>\n<p>Vous avez besoin de trois \u00e9l\u00e9ments&nbsp;: un environnement reproductible, un mod\u00e8le d'ex\u00e9cution parall\u00e8le et un script de soumission de travaux pour le planificateur de cluster.<\/p>\n<p>Ce guide parcourt le flux de travail complet du prototype local au d\u00e9ploiement HPC de production sans modifier votre logique de simulation de base.<\/p>\n<h2>Le flux de travail HPC Python en trois \u00e9tapes<\/h2>\n<p>La plupart des projets HPC Python suivent le m\u00eame mod\u00e8le en trois \u00e9tapes, quel que soit le domaine scientifique.<\/p>\n<pre><code>Stage 1 \u2014 Local Prototyping:\n  Laptop \u2192 Jupyter or IDE \u2192 NumPy \/ Pandas \u2192 serial execution\n\nStage 2 \u2014 Parallelization:\n  Same code \u2192 mpi4py or Dask \u2192 parallel execution\n\nStage 3 \u2014 Cluster Deployment:\n  Python script \u2192 Slurm \/ PBS job submission \u2192 distributed compute nodes\n<\/code><\/pre>\n<p>L'objectif est de parcourir ces \u00e9tapes progressivement. Commencez avec une version locale fonctionnelle. Ajoutez une ex\u00e9cution parall\u00e8le uniquement une fois que la logique est correcte. Soumettre au cluster uniquement apr\u00e8s des petits tests parall\u00e8les.<\/p>\n<h2>\u00c9tape 1 : Mise en place d'un environnement reproductible<\/h2>\n<p>Avant d'\u00e9crire du code parall\u00e8le, vous avez besoin d'un environnement de d\u00e9veloppement fiable. C'est l\u00e0 que de nombreux flux de travail scientifiques \u00e9chouent en premier.<\/p>\n<h3>Pourquoi la reproductibilit\u00e9 est difficile pour les clusters HPC<\/h3>\n<p>Les clusters HPC sont des syst\u00e8mes partag\u00e9s. De nombreux groupes de recherche utilisent la m\u00eame infrastructure et les packages de syst\u00e8mes peuvent changer au fil du temps. Une simulation qui fonctionne aujourd'hui peut interrompre six mois plus tard apr\u00e8s les mises \u00e0 jour du module, les modifications du compilateur ou les modifications de la version du package.<\/p>\n<p>La solution est la gestion de l'environnement. Conda est couramment utilis\u00e9 car il isole les packages du syst\u00e8me Python et peut g\u00e9rer les d\u00e9pendances compil\u00e9es ainsi que les packages Python.<\/p>\n<pre><code class=\"language-bash\"># Create a reproducible environment\nconda create -n my-sim python=3.11 numpy mpi4py dask\n\n# Lock dependencies for reproducibility\nconda env export --no-builds --name my-sim &gt; environment.yml\n\n# Recreate the environment on another machine\nconda env create -n my-sim -f environment.yml\n<\/code><\/pre>\n<p>Un seul fichier d'environnement donne aux collaborateurs et aux futurs utilisateurs un moyen clair de recr\u00e9er la pile logicielle. Pour une reproductibilit\u00e9 plus stricte, utilisez des fichiers de verrouillage qui \u00e9pinglent chaque version de package et d\u00e9pendance de g\u00e9n\u00e9ration.<\/p>\n<h3>Conda vs Venv : pourquoi Conda gagne souvent sur HPC<\/h3>\n<p>Python int\u00e9gr\u00e9 <code>venv<\/code> fonctionne bien pour les packages Python Pure. Les flux de travail HPC d\u00e9pendent souvent de biblioth\u00e8ques scientifiques compil\u00e9es, d'ex\u00e9cutions MPI, de HDF5, de BLA, de CUDA et d'autres composants au niveau du syst\u00e8me.<\/p>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Fonctionnalit\u00e9<\/th>\n<th>veuve<\/th>\n<th>peste<\/th>\n<\/tr>\n<tr>\n<td>Forfaits Pure Python<\/td>\n<td>Oui<\/td>\n<td>Oui<\/td>\n<\/tr>\n<tr>\n<td>D\u00e9pendances au niveau du syst\u00e8me telles que MPI et HDF5<\/td>\n<td>Non<\/td>\n<td>Oui<\/td>\n<\/tr>\n<tr>\n<td>Coh\u00e9rence multiplateforme<\/td>\n<td>Limit\u00e9<\/td>\n<td>Fort<\/td>\n<\/tr>\n<tr>\n<td>Forfaits d'acc\u00e9l\u00e9ration GPU tels que Cupy ou PyTorch CUDA<\/td>\n<td>Configuration manuelle<\/td>\n<td>Configuration plus automatis\u00e9e<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Conda donne une reproductibilit\u00e9 dans une plus grande partie de la pile scientifique. Cela compte lorsqu'il travaille avec MPI4Py car l'environnement d'ex\u00e9cution MPI et Python doit \u00eatre compatible \u00e0 la fois sur la machine locale et sur le cluster.<\/p>\n<h2>\u00c9tape&nbsp;2&nbsp;: Parall\u00e8lement \u00e0 votre code Python<\/h2>\n<p>Une fois que la version locale fonctionne, la prochaine \u00e9tape est la parall\u00e9lisation. Dans les flux de travail HPC Python, deux outils sont particuli\u00e8rement courants :<\/p>\n<ol>\n<li>MPI4py pour un contr\u00f4le distribu\u00e9 \u00e0 grain fin sur de nombreux n\u0153uds.<\/li>\n<li>DASK pour un parall\u00e9lisme de niveau sup\u00e9rieur avec moins de changements de code.<\/li>\n<\/ol>\n<h3>Pourquoi vous avez besoin de MPI4PY<\/h3>\n<p>Le verrou d'interpr\u00e9teur global de Python limite la v\u00e9ritable ex\u00e9cution de Python multithread dans un processus. Le module <code>multiprocessing<\/code> peut parall\u00e9liser sur une seule machine, mais il ne s'adapte pas naturellement \u00e0 plusieurs n\u0153uds de calcul.<\/p>\n<p>MPI4PY fournit des liaisons Python pour MPI, l'interface de transmission de messages. MPI est une API standard pour le calcul parall\u00e8le distribu\u00e9 et est largement utilis\u00e9 sur les syst\u00e8mes HPC.<\/p>\n<p>Avec MPI4Py, chaque processus ex\u00e9cute le m\u00eame script mais re\u00e7oit un rang unique. Ce classement contr\u00f4le la partie de la charge de travail que chaque processus g\u00e8re.<\/p>\n<h3>Mod\u00e8le MPI4PY de base&nbsp;: bonjour le monde<\/h3>\n<pre><code class=\"language-python\">from mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\nprint(f\"Hello from process {rank} out of {size} processes\")\n<\/code><\/pre>\n<p>Lancez le script avec MPI&nbsp;:<\/p>\n<pre><code class=\"language-bash\">mpiexec -n 16 python my_script.py\n<\/code><\/pre>\n<p>Cela d\u00e9marre 16 processus Python ind\u00e9pendants. Chaque processus ex\u00e9cute le m\u00eame script, mais chacun a un <code>rank<\/code> diff\u00e9rent.<\/p>\n<h3>Le mod\u00e8le de donn\u00e9es : processus ind\u00e9pendants<\/h3>\n<p>Les processus MPI ne partagent pas de m\u00e9moire par d\u00e9faut. Chaque processus a son propre espace m\u00e9moire. Pour \u00e9changer des informations, les processus doivent explicitement envoyer, recevoir, diffuser, collecter ou r\u00e9duire les donn\u00e9es.<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\n\n# Rank 0 creates the initial data.\nif rank == 0:\n    data = np.arange(10, dtype=\"i\")\nelse:\n    data = np.empty(10, dtype=\"i\")\n\n# Broadcast data from rank 0 to all ranks.\ncomm.Bcast(data, root=0)\n\nprint(f\"Rank {rank} received data: {data}\")\n<\/code><\/pre>\n<p>Ce mod\u00e8le de communication explicite est l'une des raisons pour lesquelles le MPI \u00e9volue bien. Chaque classement poss\u00e8de sa m\u00e9moire locale et la communication ne se produit que lorsque vous en faites la demande.<\/p>\n<h3>Distribution de la charge de travail&nbsp;: le mod\u00e8le de base<\/h3>\n<p>La plupart des flux de travail MPI scientifiques suivent le m\u00eame sch\u00e9ma&nbsp;: divisez le probl\u00e8me, calculez localement et r\u00e9duisez les r\u00e9sultats.<\/p>\n<pre><code class=\"language-python\">from mpi4py import MPI\nimport numpy as np\n\ncomm = MPI.COMM_WORLD\n\nsize = comm.Get_size()\nrank = comm.Get_rank()\n\n# Total problem size\nN = 10_000_000\n\n# Calculate workload per rank\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\n# Each rank works on its own slice\nmy_data = np.random.rand(my_end - my_start)\n\n# Local computation\nlocal_result = np.sum(np.sin(my_data))\n\n# Sum results across all ranks\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Total computed across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<p>Ce mod\u00e8le s'applique \u00e0 de nombreuses t\u00e2ches de simulation :<\/p>\n<ul>\n<li>Simulations de Monte Carlo, o\u00f9 chaque classement traite des \u00e9chantillons ind\u00e9pendants.<\/li>\n<li>Balayages de param\u00e8tres, chaque classement testant diff\u00e9rents jeux de param\u00e8tres.<\/li>\n<li>D\u00e9composition du domaine, o\u00f9 chaque classement poss\u00e8de une partie de la grille de simulation.<\/li>\n<li>Dynamique mol\u00e9culaire, o\u00f9 les rangs calculent les forces pour diff\u00e9rents sous-ensembles de particules.<\/li>\n<\/ul>\n<h3>La bo\u00eete \u00e0 outils de communication collective<\/h3>\n<p>MPI4PY fournit des op\u00e9rations collectives qui sont g\u00e9n\u00e9ralement plus faciles et plus efficaces que la messagerie point \u00e0 point personnalis\u00e9e.<\/p>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Op\u00e9ration<\/th>\n<th>ce qu'il fait<\/th>\n<th>Quand utiliser<\/th>\n<\/tr>\n<tr>\n<td><code>Bcast<\/code><\/td>\n<td>Un processus envoie les m\u00eames donn\u00e9es \u00e0 tous les rangs<\/td>\n<td>Partage des conditions initiales, des constantes ou des valeurs de configuration<\/td>\n<\/tr>\n<tr>\n<td><code>Scatter<\/code><\/td>\n<td>Distribue des morceaux d'un tableau \u00e0 travers les rangs<\/td>\n<td>D\u00e9composition du domaine ou partitionnement de la charge de travail<\/td>\n<\/tr>\n<tr>\n<td><code>Gather<\/code><\/td>\n<td>Collecte des donn\u00e9es de tous les rangs<\/td>\n<td>Collecte des sorties partielles<\/td>\n<\/tr>\n<tr>\n<td><code>Reduce<\/code><\/td>\n<td>Agr\u00e9ge des valeurs telles que somme, max ou min<\/td>\n<td>Sommer des \u00e9nergies ou collecter des m\u00e9triques globales<\/td>\n<\/tr>\n<tr>\n<td><code>Allreduce<\/code><\/td>\n<td>Agr\u00e9ge les valeurs et donne le r\u00e9sultat \u00e0 chaque rang<\/td>\n<td>Synchroniser l'\u00e9tat global dans tous les processus<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Utilisez la communication collective lorsque cela est possible. Il est g\u00e9n\u00e9ralement plus simple et plus efficace que de coordonner manuellement de nombreux envois et r\u00e9ceptions.<\/p>\n<h3>Quand utiliser DASK \u00e0 la place<\/h3>\n<p>Dask se situe entre Python en s\u00e9rie et MPI. Il est utile lorsque la charge de travail est parall\u00e8lement embarrassante, comme l'ex\u00e9cution de la m\u00eame simulation avec de nombreux jeux de param\u00e8tres ou conditions initiales.<\/p>\n<pre><code class=\"language-python\">from dask.distributed import Client\nfrom dask import delayed\n\nclient = Client(n_workers=16, threads_per_worker=4)\n\ndef my_simulation(params):\n    # Your simulation logic here\n    return params[\"a\"] * params[\"b\"]\n\nparameter_list = [\n    {\"a\": i, \"b\": 2.0}\n    for i in range(100)\n]\n\ntasks = [\n    delayed(my_simulation)(params)\n    for params in parameter_list\n]\n\nfinal_results = client.compute(tasks, sync=True)\n\nprint(final_results[:5])\n<\/code><\/pre>\n<p>L'avantage de Dask est qu'il vous permet de parall\u00e9liser de nombreux flux de travail sans red\u00e9finir la simulation autour des rangs et des communicateurs.<\/p>\n<h3>MPI4py vs DASK&nbsp;: lequel choisir&nbsp;?<\/h3>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Crit\u00e8re<\/th>\n<th>Mpi4py<\/th>\n<th>t\u00e9n\u00e8bres<\/th>\n<\/tr>\n<tr>\n<td>Courbe d'apprentissage<\/td>\n<td>Plus raide parce que vous devez comprendre les rangs et les communicateurs<\/td>\n<td>Plus doux car il utilise des mod\u00e8les de t\u00e2ches Python familiers<\/td>\n<\/tr>\n<tr>\n<td>Contr\u00f4le \u00e0 grain fin<\/td>\n<td>Excellent car chaque communication est explicite<\/td>\n<td>Limit\u00e9 par l'abstraction du graphe de t\u00e2ches<\/td>\n<\/tr>\n<tr>\n<td>Efficacit\u00e9 m\u00e9moire<\/td>\n<td>\u00c9lev\u00e9 car chaque classement stocke sa propre tranche<\/td>\n<td>Mod\u00e9r\u00e9 parce que les travailleurs ajoutent des frais g\u00e9n\u00e9raux<\/td>\n<\/tr>\n<tr>\n<td>Convient \u00e0<\/td>\n<td>Solveurs PDE \u00e0 grande \u00e9chelle et simulations d\u00e9compos\u00e9es par le domaine<\/td>\n<td>Monte Carlo, balayages de param\u00e8tres et analyse des donn\u00e9es<\/td>\n<\/tr>\n<tr>\n<td>Meilleure \u00e9chelle<\/td>\n<td>Parall\u00e9lisme dense sur de nombreux n\u0153uds<\/td>\n<td>\u00c9chelle faible sur le nombre de travailleurs mod\u00e9r\u00e9s<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Commencez par Dask pour le prototypage et des charges de travail parall\u00e8les embarrassantes. Passez \u00e0 MPI4PY lorsque vous avez besoin d'un contr\u00f4le \u00e9troit de la communication, de la m\u00e9moire et de la mise \u00e0 l'\u00e9chelle sur de nombreux n\u0153uds.<\/p>\n<h2>\u00c9tape 3 : Soumission au cluster<\/h2>\n<p>Apr\u00e8s les tests et la parall\u00e9lisation locaux, la prochaine \u00e9tape est le d\u00e9ploiement de cluster. La plupart des clusters utilisent un planificateur de travaux. Le slurm est l'un des plus courants.<\/p>\n<h3>Le script de travail Slurm<\/h3>\n<p>Un script de t\u00e2che Slurm indique au planificateur quelles ressources vous avez besoin et comment ex\u00e9cuter le code.<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=my-sim\n#SBATCH --nodes=32\n#SBATCH --tasks-per-node=4\n#SBATCH --cpus-per-task=1\n#SBATCH --mem=8GB\n#SBATCH --time=04:00:00\n#SBATCH --output=sim_output.%j\n\n# Load required modules\nmodule load Python\/3.11\n\n# Activate conda environment\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\n# Run the MPI job\nsrun python my_simulation.py\n<\/code><\/pre>\n<p>Les param\u00e8tres importants comprennent :<\/p>\n<ul>\n<li><code>--nodes<\/code>&nbsp;: nombre de n\u0153uds de calcul.<\/li>\n<li><code>--tasks-per-node<\/code>&nbsp;: nombre de t\u00e2ches MPI par n\u0153ud.<\/li>\n<li><code>--cpus-per-task<\/code>&nbsp;: c\u0153urs de CPU affect\u00e9s \u00e0 chaque t\u00e2che.<\/li>\n<li><code>--time<\/code>&nbsp;: limite d'horloge murale. Les emplois sont g\u00e9n\u00e9ralement arr\u00eat\u00e9s s'ils le d\u00e9passent.<\/li>\n<li><code>--output<\/code>&nbsp;: mod\u00e8le de fichier de sortie. <code>%j<\/code> Ins\u00e8re l'ID du travail.<\/li>\n<\/ul>\n<h3>Ex\u00e9cution sur des clusters sans Slurm<\/h3>\n<p>Tous les clusters n'utilisent pas Slurm. Les alternatives courantes comprennent :<\/p>\n<ul>\n<li>PBS ou couple, g\u00e9n\u00e9ralement en utilisant <code>qsub<\/code>.<\/li>\n<li>LSF, en utilisant g\u00e9n\u00e9ralement <code>bsub<\/code>.<\/li>\n<li>Cobalt ou autres planificateurs sp\u00e9cifiques au site.<\/li>\n<\/ul>\n<p>La syntaxe de la soumission des travaux change, mais le code Python ne change g\u00e9n\u00e9ralement pas. MPI4PY et DASK sont pour la plupart agnostiques de planification une fois lanc\u00e9s correctement.<\/p>\n<h3>Mode interactif vs batch<\/h3>\n<p>Pour le d\u00e9bogage, les ex\u00e9cutions interactives sont utiles :<\/p>\n<pre><code class=\"language-bash\">srun --ntasks=4 --pty --time=02:00:00 python my_simulation.py\n<\/code><\/pre>\n<p>Pour la production, utilisez la soumission par lot&nbsp;:<\/p>\n<pre><code class=\"language-bash\">sbatch my_job_script.sh\n<\/code><\/pre>\n<p>Les sessions interactives sont bonnes pour les tests courts. Les travaux par lots sont meilleurs pour les longues p\u00e9riodes, les charges de travail du jour au lendemain et les simulations de production.<\/p>\n<h2>Le flux de travail complet : de l'ordinateur portable \u00e0 la production<\/h2>\n<p>La transition du prototype local au d\u00e9ploiement du cluster peut \u00eatre progressive. La logique de simulation de base doit rester stable pendant que l'enveloppe d'ex\u00e9cution change.<\/p>\n<h3>\u00c9tape&nbsp;1&nbsp;: D\u00e9velopper et tester localement<\/h3>\n<pre><code class=\"language-python\"># my_simulation.py\nimport numpy as np\n\ndef simulate(initial_condition, params):\n    # Core simulation logic\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\n# Local test\ndata = np.random.rand(1000)\nresult = simulate(data, {\"factor\": 1.5})\n\nprint(f\"Local result: {result}\")\n<\/code><\/pre>\n<h3>\u00c9tape&nbsp;2&nbsp;: Ajout de la parall\u00e9lisation<\/h3>\n<pre><code class=\"language-python\"># my_simulation_mpi.py\nimport numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\ndef simulate(initial_condition, params):\n    # Core simulation logic stays the same\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\nN = 10_000_000\n\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\nmy_data = np.random.rand(my_end - my_start)\n\nlocal_result = simulate(my_data, {\"factor\": 1.5})\n\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Parallel result across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<h3>\u00c9tape&nbsp;3&nbsp;: Soumettre au cluster<\/h3>\n<p>Enregistrez un script de travail tel que <code>job_script.sh<\/code>&nbsp;:<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=parallel-sim\n#SBATCH --nodes=64\n#SBATCH --tasks-per-node=8\n#SBATCH --time=12:00:00\n\nmodule load Python\/3.11\n\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\nsrun python my_simulation_mpi.py\n<\/code><\/pre>\n<p>Soumettez-le&nbsp;:<\/p>\n<pre><code class=\"language-bash\">sbatch job_script.sh\n<\/code><\/pre>\n<p>La logique de simulation reste la m\u00eame. Le wrapper modifie la fa\u00e7on dont la charge de travail est divis\u00e9e et lanc\u00e9e.<\/p>\n<h2>Des pi\u00e8ges courants et comment les \u00e9viter<\/h2>\n<h3>Pitfall&nbsp;1&nbsp;: Diffuser trop de donn\u00e9es<\/h3>\n<p>La diffusion de grands tableaux de rang 0 \u00e0 chaque rang peut devenir un goulot d'\u00e9tranglement de communication. Pour les simulations volumineuses, \u00e9vitez d'envoyer plus de donn\u00e9es que ce dont chaque rang a besoin.<\/p>\n<p>Les meilleures options incluent :<\/p>\n<ul>\n<li>Utilisez <code>Scatter<\/code> au lieu de <code>Bcast<\/code> lorsque chaque rang n'a besoin que d'une tranche.<\/li>\n<li>Utilisez la d\u00e9composition du domaine afin que chaque rang poss\u00e8de une r\u00e9gion de la simulation.<\/li>\n<li>Pour Monte Carlo, laissez chaque rang g\u00e9n\u00e9rer ses propres \u00e9chantillons al\u00e9atoires au lieu de les diffuser.<\/li>\n<\/ul>\n<h3>Pitfall 2 : surallocation des ressources du cluster<\/h3>\n<p>Demander plus de n\u0153uds que votre code peut utiliser des pertes de temps d'allocation et peut augmenter le d\u00e9lai de file d'attente.<\/p>\n<p>Commencez par un petit travail de test, tel que 4 \u00e0 8 n\u0153uds. Mesurez l'acc\u00e9l\u00e9ration. \u00c9chelle uniquement apr\u00e8s que le code montre une efficacit\u00e9 parall\u00e8le utile.<\/p>\n<h3>Pitfall 3 : Oublier le Gil en code mixte<\/h3>\n<p>Les biblioth\u00e8ques NumPy, Scipy et Compiled C ou Fortran lib\u00e8rent souvent le verrou d'interpr\u00e9teur global Python lors d'op\u00e9rations num\u00e9riques lourdes. Les threads Pure Python ne procurent g\u00e9n\u00e9ralement pas le m\u00eame avantage.<\/p>\n<p>Si votre flux de travail m\u00e9lange les threads Python avec les biblioth\u00e8ques num\u00e9riques, testez la mise \u00e0 l'\u00e9chelle au lieu de supposer que plus de threads vous aideront.<\/p>\n<h3>Pitfall 4 : inad\u00e9quation de l'environnement sur le cluster<\/h3>\n<p>Votre ordinateur portable peut utiliser Python 3.11 tandis que le module de cluster fournit Python 3.9. Les biblioth\u00e8ques MPI4Py, MPI et les d\u00e9pendances compil\u00e9es peuvent se casser lorsque les versions ne correspondent pas.<\/p>\n<p>Utilisez un environnement Conda et documentez la configuration exacte. Recr\u00e9ez et testez l'environnement sur le cluster avant d'ex\u00e9cuter des travaux volumineux.<\/p>\n<h2>Guide de d\u00e9cision&nbsp;: quelle strat\u00e9gie de parall\u00e9lisation&nbsp;?<\/h2>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Situation<\/th>\n<th>Approche recommand\u00e9e<\/th>\n<\/tr>\n<tr>\n<td>Petit ensemble de donn\u00e9es et tests de logique locale<\/td>\n<td>Python s\u00e9rie avec NumPy<\/td>\n<\/tr>\n<tr>\n<td>Machine unique avec plusieurs c\u0153urs<\/td>\n<td>Python <code>multiprocessing<\/code> ou DASK <code>LocalCluster<\/code><\/td>\n<\/tr>\n<tr>\n<td>8 \u00e0 64&nbsp;travailleurs et t\u00e2ches parall\u00e8les embarrassantes<\/td>\n<td>DASK avec un lanceur de cluster<\/td>\n<\/tr>\n<tr>\n<td>64 \u00e0 1&nbsp;000&nbsp;n\u0153uds et PDE d\u00e9compos\u00e9s dans le domaine<\/td>\n<td>MPI4Py avec une distribution de charge de travail explicite<\/td>\n<\/tr>\n<tr>\n<td>Simulation de production sur plus de 1&nbsp;000&nbsp;noeuds<\/td>\n<td>MPI4Py, scripts de travaux de planificateur et environnement Conda verrouill\u00e9<\/td>\n<\/tr>\n<tr>\n<td>Code de recherche sans reproductibilit\u00e9 garantie<\/td>\n<td>DASK, fichier d'environnement Conda et script de travail comme point de d\u00e9part<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Votre outil de parall\u00e9lisation doit correspondre \u00e0 l'\u00e9chelle et \u00e0 la structure du probl\u00e8me. Commencez plus petit que ce dont vous pensez avoir besoin, puis augmentez apr\u00e8s la mesure des performances.<\/p>\n<h2>Guides connexes<\/h2>\n<p>Pour les sujets connexes dans les flux de travail de simulation scientifique&nbsp;:<\/p>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-acceleration-for-fipy-simulations-cupy-and-numba-integration-guide\/\">Acc\u00e9l\u00e9ration GPU pour les simulations FIPY&nbsp;: CUPY et NUMBA Integration Guide<\/a> \u2014 Lorsque le processeur parall\u00e8le ne suffit pas.<\/li>\n<li><a href=\"https:\/\/matforge.org\/performance-profiling-optimization-python-pde-solvers\/\">Profilage et optimisation des performances pour les solveurs PDE de Python&nbsp;: un guide pratique<\/a> \u2014 Trouver des goulots d'\u00e9tranglement avant parall\u00e9lisation.<\/li>\n<li><a href=\"https:\/\/matforge.org\/python-debugging-scientific-code-print-statements-profiling\/\">d\u00e9bogage de Python pour le code scientifique&nbsp;: des instructions d'impression au profilage<\/a> - d\u00e9bogage des simulations parall\u00e8les.<\/li>\n<\/ul>\n<h2>R\u00e9sum\u00e9 et \u00e9tapes suivantes<\/h2>\n<p>Les flux de travail HPC Python concernent l'emballage, et non la r\u00e9\u00e9criture. La m\u00eame logique de simulation qui s'ex\u00e9cute sur un ordinateur portable peut s'ex\u00e9cuter sur de nombreux c\u0153urs lorsque vous cr\u00e9ez la bonne structure d'ex\u00e9cution.<\/p>\n<p>Le workflow est :<\/p>\n<ol>\n<li>Verrouillez l'environnement avec Conda afin que le code s'ex\u00e9cute de mani\u00e8re coh\u00e9rente entre les syst\u00e8mes.<\/li>\n<li>Ajoutez du parall\u00e9lisme avec MPI4PY pour un contr\u00f4le distribu\u00e9 \u00e0 grain fin ou un DASK pour un parall\u00e9lisme de t\u00e2ches de haut niveau.<\/li>\n<li>Soumettez des travaux via Slurm, PBS, LSF ou le planificateur utilis\u00e9 par votre cluster.<\/li>\n<\/ol>\n<p>La partie la plus difficile est souvent l'environnement, pas le code. Investissez rapidement dans une configuration reproductible et les simulations parall\u00e8les deviennent plus faciles \u00e0 mettre \u00e0 l'\u00e9chelle de l'ordinateur portable au superordinateur.<\/p>\n<h3>Prochaines \u00e9tapes<\/h3>\n<ol>\n<li>V\u00e9rifier la simulation actuelle. S'il ne fonctionne que sur un ordinateur portable, commencez par cr\u00e9er un environnement Conda et tester une petite ex\u00e9cution multic\u0153ur.<\/li>\n<li>Mesurez avant de mettre \u00e0 l'\u00e9chelle. Ex\u00e9cutez un petit travail de cluster, mesurez l'acc\u00e9l\u00e9ration, puis passez \u00e0 la taille de la production.<\/li>\n<li>Documentez la configuration. Enregistrez le fichier d'environnement, le script de travail, la commande de lancement et la sortie attendue.<\/li>\n<\/ol>\n<p>L'\u00e9tablissement d'un flux de travail HPC Python n\u00e9cessite de comprendre les packages scientifiques Python, la programmation parall\u00e8le et l'infrastructure de cluster. Si vous avez besoin d'aide pour la parall\u00e9lisation MPI, la planification des t\u00e2ches ou la reproductibilit\u00e9 de l'environnement, notre \u00e9quipe peut prendre en charge des flux de travail scientifiques \u00e9volutifs de Python, notamment des simulations bas\u00e9es sur Fipy et des moteurs de Monte Carlo personnalis\u00e9s.<\/p>\n"},"excerpt":{"rendered":"<p><span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 10<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span>Points \u00e0 retenir cl\u00e9s Le code Python peut s&rsquo;ex\u00e9cuter sur un ordinateur portable et un syst\u00e8me HPC volumineux avec la m\u00eame logique de base lorsque le flux de travail utilise correctement MPI4Py ou Dask. La reproductibilit\u00e9 de l&rsquo;environnement est souvent la partie la plus difficile du travail de HPC. Les environnements Conda, les fichiers de [&hellip;]<\/p>\n","protected":false,"raw":""},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"fr_FR","_original_post":"https:\/\/matforge.org\/?p=341","iawp_total_views":1,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1281","post","type-post","status-publish","format-standard","hentry","category-simulation-modeling-projects","fr-FR"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.3 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Guide des flux de travail HPC Python<\/title>\n<meta name=\"description\" content=\"D\u00e9couvrez comment d\u00e9placer des simulations Python d&#039;un ordinateur portable vers des clusters HPC \u00e0 l&#039;aide de scripts de travaux Conda, MPI4Py, Dask, Slurm et Reproductible.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Guide des flux de travail HPC Python\" \/>\n<meta property=\"og:description\" content=\"D\u00e9couvrez comment d\u00e9placer des simulations Python d&#039;un ordinateur portable vers des clusters HPC \u00e0 l&#039;aide de scripts de travaux Conda, MPI4Py, Dask, Slurm et Reproductible.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/\" \/>\n<meta property=\"og:site_name\" content=\"matforge.org\" \/>\n<meta property=\"article:published_time\" content=\"2026-08-21T14:31:28+00:00\" \/>\n<meta name=\"author\" content=\"Elena Markovska\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Elena Markovska\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"16 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"},\"author\":{\"name\":\"Elena Markovska\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\"},\"headline\":\"Flux de travail HPC Python : de l&rsquo;ordinateur portable au superordinateur\",\"datePublished\":\"2026-08-21T14:31:28+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"},\"wordCount\":2705,\"commentCount\":0,\"articleSection\":[\"Simulation &amp; Projets de mod\u00e9lisation\"],\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\",\"name\":\"Guide des flux de travail HPC Python\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"datePublished\":\"2026-08-21T14:31:28+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\"},\"description\":\"D\u00e9couvrez comment d\u00e9placer des simulations Python d'un ordinateur portable vers des clusters HPC \u00e0 l'aide de scripts de travaux Conda, MPI4Py, Dask, Slurm et Reproductible.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Flux de travail HPC Python : de l&#8217;ordinateur portable au superordinateur\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\",\"url\":\"https:\\\/\\\/matforge.org\\\/\",\"name\":\"matforge.org\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/matforge.org\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\",\"name\":\"Elena Markovska\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"caption\":\"Elena Markovska\"},\"sameAs\":[\"http:\\\/\\\/matforge.org\"],\"url\":\"https:\\\/\\\/matforge.org\\\/author\\\/elena-markovska\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Guide des flux de travail HPC Python","description":"D\u00e9couvrez comment d\u00e9placer des simulations Python d'un ordinateur portable vers des clusters HPC \u00e0 l'aide de scripts de travaux Conda, MPI4Py, Dask, Slurm et Reproductible.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/","og_locale":"fr_FR","og_type":"article","og_title":"Guide des flux de travail HPC Python","og_description":"D\u00e9couvrez comment d\u00e9placer des simulations Python d'un ordinateur portable vers des clusters HPC \u00e0 l'aide de scripts de travaux Conda, MPI4Py, Dask, Slurm et Reproductible.","og_url":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/","og_site_name":"matforge.org","article_published_time":"2026-08-21T14:31:28+00:00","author":"Elena Markovska","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Elena Markovska","Dur\u00e9e de lecture estim\u00e9e":"16 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/"},"author":{"name":"Elena Markovska","@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da"},"headline":"Flux de travail HPC Python : de l&rsquo;ordinateur portable au superordinateur","datePublished":"2026-08-21T14:31:28+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/"},"wordCount":2705,"commentCount":0,"articleSection":["Simulation &amp; Projets de mod\u00e9lisation"],"inLanguage":"fr-FR","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/","url":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/","name":"Guide des flux de travail HPC Python","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"datePublished":"2026-08-21T14:31:28+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da"},"description":"D\u00e9couvrez comment d\u00e9placer des simulations Python d'un ordinateur portable vers des clusters HPC \u00e0 l'aide de scripts de travaux Conda, MPI4Py, Dask, Slurm et Reproductible.","breadcrumb":{"@id":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/fr\/hpc-python-workflows-from-laptop-to-supercomputer\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/"},{"@type":"ListItem","position":2,"name":"Flux de travail HPC Python : de l&#8217;ordinateur portable au superordinateur"}]},{"@type":"WebSite","@id":"https:\/\/matforge.org\/#website","url":"https:\/\/matforge.org\/","name":"matforge.org","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/matforge.org\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Person","@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da","name":"Elena Markovska","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","caption":"Elena Markovska"},"sameAs":["http:\/\/matforge.org"],"url":"https:\/\/matforge.org\/author\/elena-markovska\/"}]}},"_links":{"self":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1281","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/comments?post=1281"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1281\/revisions"}],"predecessor-version":[{"id":1409,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1281\/revisions\/1409"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=1281"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=1281"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=1281"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}