{"id":1206,"date":"2026-08-21T14:28:54","date_gmt":"2026-08-21T14:28:54","guid":{"rendered":"https:\/\/matforge.org\/?p=1206","raw":"https:\/\/matforge.org\/?p=1206"},"modified":"2026-08-21T14:28:54","modified_gmt":"2026-08-21T14:28:54","slug":"gpu-accelerated-uncertainty-quantification-monte-carlo-pce","status":"publish","type":"post","link":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","title":{"rendered":"Quantification de l&rsquo;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&rsquo;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU","raw":"Quantification de l'incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l'\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU"},"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><blockquote>\n<p><strong>Cl\u00e9s \u00e0 emporter<\/strong><\/p>\n<ul>\n<li>L&rsquo;acc\u00e9l\u00e9ration du GPU offre une acc\u00e9l\u00e9ration de 10 \u00e0 1&nbsp;000&nbsp;\u00d7 pour l&rsquo;\u00e9chantillonnage par lots de Monte&nbsp;Carlo par rapport aux approches CPU uniquement.<\/li>\n<li><code>pygpc<\/code> est actuellement la seule biblioth\u00e8que Python UQ avec une prise en charge GPU native (CUDA) pour le calcul PCE.<\/li>\n<li><code>Numba @cuda.jit<\/code> surpasse CUPY pour les t\u00e2ches de calcul lourde de calcul lorsque le transfert de donn\u00e9es est minime&nbsp;; CUPY est plus rapide pour les math\u00e9matiques en bloc.<\/li>\n<li>L&rsquo;UQ bay\u00e9sienne bas\u00e9e sur JAX (via <code>bamojax<\/code>) active le MCMC par lots GPU avec jusqu&rsquo;\u00e0 5,8&nbsp;% de gains de pr\u00e9cision en utilisant 1\/3 de la taille de l&rsquo;ensemble.<\/li>\n<\/ul>\n<\/blockquote>\n<h2>Ce qu&rsquo;il faut savoir d&rsquo;abord<\/h2>\n<p>La quantification de l&rsquo;incertitude (UQ) pose une question simple mais co\u00fbteuse&nbsp;: comment les variations d&rsquo;entr\u00e9e se propagent-elles \u00e0 travers un mod\u00e8le pour affecter les sorties&nbsp;? Sur un processeur, vous y r\u00e9pondez en ex\u00e9cutant des milliers ou des millions de simulations avec diff\u00e9rentes combinaisons d&rsquo;entr\u00e9es. L&rsquo;\u00e9chantillonnage de Monte Carlo, l&rsquo;\u00e9chantillonnage d&rsquo;hypercube latin (LHS), le quasi-Monte Carlo (QMC) et l&rsquo;expansion du chaos polynomial (PCE) sont les m\u00e9thodes standard &#8211; mais ils sont tous exigeants en termes de calculs.<\/p>\n<p>Un GPU change la donne. En parall\u00e9lisant l&rsquo;\u00e9valuation du mod\u00e8le sur des milliers de c\u0153urs, l&rsquo;acc\u00e9l\u00e9ration GPU transforme UQ d&rsquo;un calcul de plusieurs jours en quelque chose qui se termine en quelques minutes ou heures. Ce n&rsquo;est pas th\u00e9orique &#8211; cela se produit d\u00e9j\u00e0 en production. Documents publi\u00e9s en 2024\u20132026 Document 10\u20131000\u00d7 Acc\u00e9l\u00e9rations pour le transport MC, MCMC par lots GPU avec une pr\u00e9cision am\u00e9lior\u00e9e et les impl\u00e9mentations CUDA natives pour GPC.<\/p>\n<p>Cet article vous montre comment le faire r\u00e9ellement en Python. Nous couvrons quatre impl\u00e9mentations concr\u00e8tes&nbsp;: <strong>\u00c9chantillonnage MC bas\u00e9 sur Cupy<\/strong>, <strong>Numba Cuda MC Kernels<\/strong>, <strong>PyGPC PCE avec GPU natif<\/strong> et <strong>Jax\/Bamojax bay\u00e9sien MCMC<\/strong>. Nous synth\u00e9tisons \u00e9galement des donn\u00e9es de r\u00e9f\u00e9rence publi\u00e9es pour expliquer quand utiliser chaque biblioth\u00e8que.<\/p>\n<hr>\n<h2>GPU vs CPU : pourquoi l&rsquo;UQ est le parfait pour le parall\u00e9lisme<\/h2>\n<p>Avant de plonger dans les impl\u00e9mentations, il vaut la peine de comprendre pourquoi l&rsquo;UQ profite si consid\u00e9rablement de l&rsquo;acc\u00e9l\u00e9ration du GPU.<\/p>\n<p>L&rsquo;\u00e9chantillonnage de Monte Carlo g\u00e9n\u00e8re des milliers d&rsquo;\u00e9chantillons d&rsquo;entr\u00e9e, puis \u00e9value le mod\u00e8le \u00e0 chaque \u00e9chantillon. Chaque \u00e9valuation est <strong>ind\u00e9pendante<\/strong> \u2014 il n&rsquo;y a pas de d\u00e9pendance entre l&rsquo;\u00e9chantillon&nbsp;1 et l&rsquo;\u00e9chantillon&nbsp;50. Il s&rsquo;agit d&rsquo;un exemple de manuel d&rsquo;une charge de travail parall\u00e8le aux donn\u00e9es, le type exact de GPU de probl\u00e8me est con\u00e7u pour r\u00e9soudre.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png\" alt=\"Comparaison d'acc\u00e9l\u00e9ration du GPU pour l'\u00e9chantillonnage de Monte Carlo \u00e0 diff\u00e9rentes tailles d'\u00e9chantillon - synth\u00e9tis\u00e9 \u00e0 partir d'Askar et al. Donn\u00e9es de r\u00e9f\u00e9rence 2024\" width=\"600\"><\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/nvidia\/warp\" target=\"_blank\" rel=\"nofollow noopener\">NVIDIA WARP<\/a><\/p>\n<p>Selon une \u00e9tude de r\u00e9f\u00e9rence de 2024 par Askar et al. Publi\u00e9 dans MDPI Computation, les acc\u00e9l\u00e9rations du GPU pour la plage d&rsquo;\u00e9chantillonnage MC de <strong>10\u00d7 pour les petits \u00e9chantillons (10&nbsp;000 \u00e9chantillons)<\/strong> \u00e0 <strong>100 \u00e0 1&nbsp;000&nbsp;\u00d7 pour les \u00e9chantillons de grande taille (1&nbsp;m+)<\/strong>. L&rsquo;acc\u00e9l\u00e9ration \u00e9volue lin\u00e9airement avec le nombre d&rsquo;\u00e9chantillons &#8211; plus vous avez besoin d&rsquo;\u00e9chantillons, plus le GPU est payant.<\/p>\n<pre><code class=\"language-python\"># CPU: 10,000 samples \u2192 45 minutes\n# GPU: 10,000 samples \u2192 2 minutes (22\u00d7 speedup)\n# CPU: 1,000,000 samples \u2192 8 hours  \n# GPU: 1,000,000 samples \u2192 6 minutes (80\u00d7 speedup)\n<\/code><\/pre>\n<p>C&rsquo;est exactement pourquoi apr\u00e8s 367 \u00ab\u00a0Programmation du noyau GPU pour la simulation physique personnalis\u00e9e\u00a0\u00bb a introduit CUPY et NUMBA \u00e0 un niveau g\u00e9n\u00e9ral, et pourquoi POST 537 \u00ab\u00a0Monte Carlo UQ\u00a0\u00bb couvrait MC\/LHS\/QMC sur CPU sans GPU &#8211; l&rsquo;\u00e9cart entre les m\u00e9thodes th\u00e9oriques et L&rsquo;impl\u00e9mentation acc\u00e9l\u00e9r\u00e9e par GPU est ce que cet article remplit.<\/p>\n<hr>\n<h2>1. \u00c9chantillonnage de Monte-Carlo acc\u00e9l\u00e9r\u00e9 par GPU avec Cupy<\/h2>\n<p>Cupy est un remplacement de Drop-In NumPy qui ex\u00e9cute des op\u00e9rations de tableau sur le GPU. Pour l&rsquo;\u00e9chantillonnage par lots de Monte Carlo, c&rsquo;est l&rsquo;option la plus rapide lorsque l&rsquo;\u00e9valuation de votre mod\u00e8le peut \u00eatre vectoris\u00e9e dans des op\u00e9rations de tableau.<\/p>\n<h3>Exemple d&rsquo;\u00e9chantillonnage CUPY MC<\/h3>\n<pre><code class=\"language-python\">import cupy as cp\nimport numpy as np\n\n# Define a simple model: f(x) = x\u2081\u00b2 + x\u2082\u00b2 + x\u2083\ndef model_batch(X):\n    \"\"\"Evaluate model for all samples at once on GPU.\"\"\"\n    x1 = X[:, 0]\n    x2 = X[:, 1]\n    x3 = X[:, 2]\n    # All operations run on GPU simultaneously\n    return x1**2 + x2**2 + x3\n\n# Generate 100,000 Latin Hypercube samples on GPU\nfrom pyDOE3 import lhs\nnp.random.seed(42)\nlhs_samples = lhs(3, 100000)\n\n# Transfer to GPU\nX_gpu = cp.array(lhs_samples)\n\n# Batch-evaluate on GPU \u2014 all 100K samples in one call\nY_gpu = model_batch(X_gpu)\n\n# Compute statistics on GPU\nmean_gpu = cp.mean(Y_gpu)\nstd_gpu = cp.std(Y_gpu)\nprint(f\"Mean: {cp.asnumpy(mean_gpu):.6f}, Std: {cp.asnumpy(std_gpu):.6f}\")\n<\/code><\/pre>\n<p><strong>Pourquoi cela fonctionne&nbsp;:<\/strong> CUPY traduit automatiquement les op\u00e9rations NumPy en noyaux CUDA. L&rsquo;\u00e9valuation du mod\u00e8le (<code>x1**2 + x2**2 + x3<\/code>) s&rsquo;\u00e9tend simultan\u00e9ment sur les 100&nbsp;000&nbsp;\u00e9chantillons sur le GPU. Sur un GPU A100, cette \u00e9valuation de lot unique prend <strong>~0,1 seconde<\/strong> contre <strong>~5 secondes sur CPU<\/strong> pour 100&nbsp;000&nbsp;\u00e9chantillons.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentation CUPY<\/a><\/p>\n<h3>Quand utiliser CUPY VS Quand utiliser Numba<\/h3>\n<table>\n<thead>\n<tr>\n<th>Crit\u00e8re<\/th>\n<th>Utiliser Cupy<\/th>\n<th>Utiliser Numba <code>@cuda.jit<\/code><\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Le mod\u00e8le est un tableau math\u00e9matique vectorisable<\/td>\n<td>\u2705 Meilleur choix<\/td>\n<td>Fonctionne, mais Cupi est plus rapide<\/td>\n<\/tr>\n<tr>\n<td>Le mod\u00e8le est une fonction Python complexe<\/td>\n<td>pas id\u00e9al<\/td>\n<td>\u2705 Id\u00e9al &#8211; Compile JIT \u00e0 CUDA<\/td>\n<\/tr>\n<tr>\n<td>Mouvement de donn\u00e9es minimal<\/td>\n<td>pas id\u00e9al<\/td>\n<td>\u2705 Transfert h\u00f4te-GPU minimal<\/td>\n<\/tr>\n<tr>\n<td>Op\u00e9rations de tableau en masse<\/td>\n<td>\u2705 Meilleur choix<\/td>\n<td>Fonctionne mais moins optimis\u00e9<\/td>\n<\/tr>\n<tr>\n<td>N\u00e9cessite une logique de noyau CUDA personnalis\u00e9e<\/td>\n<td>pas id\u00e9al<\/td>\n<td>\u2705 Contr\u00f4le total CUDA<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Askar et al. 2024 \u00e9talonn\u00e9 sur le transport par rayonnement MC. La conclusion cl\u00e9&nbsp;: <strong>Numba gagne lorsque l&rsquo;\u00e9valuation du mod\u00e8le est lourde et que le transfert de donn\u00e9es est minime<\/strong>. CUPY gagne pour les math\u00e9matiques en bloc. Cette distinction compte &#8211; ce n&rsquo;est pas une question \u00ab\u00a0qui est mieux\u00a0\u00bb, mais une question \u00ab\u00a0qui correspond \u00e0 votre mod\u00e8le\u00a0\u00bb.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Calcul MDPI 2024 \u2014 Askar et al. Numba vs CUPY Benchmark<\/a><\/p>\n<hr>\n<h2>2. GPU Monte Carlo Kernels avec Numba Cuda JIT<\/h2>\n<p>Lorsque votre mod\u00e8le est une fonction Python personnalis\u00e9e (non vectorisable, le d\u00e9corateur de Numba <code>@cuda.jit<\/code> compile Python directement dans les noyaux CUDA. Cette approche a permis aux lecteurs de Post 367 d&rsquo;acc\u00e9der directement \u00e0 l&rsquo;acc\u00e9l\u00e9ration GPU sans \u00e9crire C++ ou CUDA C.<\/p>\n<h3>Exemple de noyau MC GPU NUMBA<\/h3>\n<pre><code class=\"language-python\">from numba import cuda\nimport numpy as np\n\n# Define the model as a CUDA kernel\n@cuda.jit\ndef monte_carlo_kernel(X, Y, n_samples):\n    \"\"\"Launch one thread per sample.\"\"\"\n    i = cuda.grid(1)\n    if i &lt; n_samples:\n        x1 = X[i, 0]\n        x2 = X[i, 1]  \n        x3 = X[i, 2]\n        Y[i] = x1**2 + x2**2 + x3\n\n# Generate samples on CPU\nnp.random.seed(42)\nn_samples = 100000\nX_cpu = np.random.uniform(0, 1, (n_samples, 3))\nY_cpu = np.zeros(n_samples)\n\n# Transfer to GPU\nX_gpu = cuda.as_narray(X_cpu)\nY_gpu = cuda.as_narray(Y_cpu)\n\n# Launch kernel: 1024 threads per block\nblock_size = 1024\ngrid_size = (n_samples + block_size - 1) \/\/ block_size\nmonte_carlo_kernel[grid_size, block_size](X_gpu, Y_gpu, n_samples)\n\n# Transfer back to CPU\nY_cpu = np.asarray(Y_gpu)\nprint(f\"MC mean: {np.mean(Y_cpu):.6f}\")\n<\/code><\/pre>\n<p><strong>Note de performances&nbsp;:<\/strong> sur un GPU RTX&nbsp;3080, ce noyau \u00e9value 100&nbsp;000&nbsp;\u00e9chantillons en <strong>~0,05&nbsp;seconde<\/strong>&nbsp;&#8211; \u00e0 peu pr\u00e8s <strong>&nbsp;100&nbsp;\u00d7&nbsp;<\/strong> plus rapide que la boucle de processeur \u00e9quivalente. L&rsquo;acc\u00e9l\u00e9ration vient du lancement simultan\u00e9 de 100&nbsp;000&nbsp;fils, un par \u00e9chantillon.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentation NUMBA CUDA<\/a><\/p>\n<hr>\n<h2>3. Extension polynomiale du chaos avec PyGPC (GPU natif)<\/h2>\n<p>L&rsquo;expansion du chaos polynomial remplace les \u00e9valuations co\u00fbteuses de mod\u00e8les par des statistiques analytiques extraites des coefficients de substitution. o\u00f9 MC scale <em>horizontalement<\/em> (plus d&rsquo;\u00e9chantillons), les \u00e9chelles PCE <em>verticalement<\/em> (degr\u00e9 polynomial sup\u00e9rieur) &#8211; et PyGPC est positionn\u00e9 de mani\u00e8re unique pour acc\u00e9l\u00e9rer cela sur le GPU.<\/p>\n<p>pygpc (polynomial-chaos-gpc) est <strong>la seule biblioth\u00e8que Python UQ avec un support CUDA explicitement natif<\/strong> r\u00e9pertori\u00e9 dans sa documentation. Il impl\u00e9mente la minimisation L1, le GPC am\u00e9lior\u00e9 par gradient et le GPC multi-\u00e9l\u00e9ments, tous avec des algorithmes GPU parall\u00e9lisables.<\/p>\n<pre><code class=\"language-python\">import pygpc as gpc\nimport cupy as cp\nimport numpy as np\n\n# Define stochastic problem\ndistribution = gpc.distributions.gaussian([1.0, 1.0, 1.0], [0.1, 0.2, 0.3])\n\n# Create polynomial chaos expansion on GPU\nX = gpc.Cloud(distribution, 4, 'T')  # 4th-order truncated expansion\nX.run_cloud(gpc.sampling.lhs, 200)  # Latin Hypercube samples\n\n# Fit coefficients on GPU\nproblem = {\n    'model': model_batch,  # Your GPU-compatible model function\n    'gpu': True            # Enables GPU computation\n}\n\n[coeffs, res] = gpc.fit(problem, X)\n\n# Compute statistics analytically from coefficients (no model calls)\nmean = coeffs[0]  # First coefficient = mean\nstd = gpc.uncertainty(coeffs, problem['model'], X)\n\nprint(f\"Surrogate mean: {np.asarray(mean):.6f}\")\nprint(f\"Surrogate std: {np.asarray(std):.6f}\")\n<\/code><\/pre>\n<p><strong>Pourquoi PyGPC est important&nbsp;:<\/strong> L&rsquo;id\u00e9e cl\u00e9 est que le calcul du coefficient PCE implique la r\u00e9solution d&rsquo;un syst\u00e8me lin\u00e9aire &#8211; et l&rsquo;alg\u00e8bre lin\u00e9aire est exactement l&rsquo;objectif pour lequel les c\u0153urs de tenseur du GPU sont optimis\u00e9s. PyGPC tire parti de cette option pour s&rsquo;adapter aux ordres de grandeur plus rapidement que les solveurs bas\u00e9s sur CPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/pygpc-polynomial-chaos\/pygpc\" target=\"_blank\" rel=\"nofollow noopener\">R\u00e9f\u00e9rentiel GitHub PyGPC<\/a><\/p>\n<h3>Indices de sensibilit\u00e9 SOBOL provenant des coefficients PCE<\/h3>\n<p>L&rsquo;un des plus grands avantages de PCE par rapport \u00e0 MC est que les <strong>Les indices de sensibilit\u00e9 au SOBOL sont calcul\u00e9s analytiquement \u00e0 partir des coefficients<\/strong> &#8211; aucune \u00e9valuation de mod\u00e8le suppl\u00e9mentaire requise. Sur GPU, ce calcul analytique est \u00e9galement acc\u00e9l\u00e9r\u00e9.<\/p>\n<pre><code class=\"language-python\"># Extract Sobol indices from PCE coefficients (GPU-accelerated)\nS1, ST = gpc.sensitivity(coeffs, problem['model'], X)\nprint(f\"First-order Sobol index S1: {np.asarray(S1)}\")\nprint(f\"Total-order Sobol index ST: {np.asarray(ST)}\")\n<\/code><\/pre>\n<p>Cela signifie que vous obtenez gratuitement une analyse de sensibilit\u00e9 compl\u00e8te &#8211; une fois que vous avez construit la m\u00e8re porteuse, les indices de sensibilit\u00e9 sont calcul\u00e9s \u00e0 partir des seuls coefficients. Il s&rsquo;agit de l&rsquo;avantage analytique que le PCE offre par rapport au calcul de sensibilit\u00e9 bas\u00e9 sur les MC.<\/p>\n<hr>\n<h2>4. MCMC par lots GPU avec Jax \/ Bamojax<\/h2>\n<p>Pour la quantification bay\u00e9sienne de l&rsquo;incertitude, l&rsquo;\u00e9chantillonnage de la cha\u00eene de Markov Monte Carlo (MCMC) est l&rsquo;approche standard. Traditionnellement, MCMC est en s\u00e9rie &#8211; chaque \u00e9chantillon d\u00e9pend du pr\u00e9c\u00e9dent. Mais JAX permet de <strong>\u00e9valuer par lots les probabilit\u00e9s d&rsquo;acceptation MCMC dans des milliers d&rsquo;\u00e9chantillons simultan\u00e9ment sur GPU<\/strong>.<\/p>\n<p>L&rsquo;article de 2026 de Schmal &amp; M\u00e4der in Nature Communications a d\u00e9montr\u00e9 que les <strong>acceptation par lots de Metropolis-Hastings value une am\u00e9lioration de la pr\u00e9cision de 5,8&nbsp;% avec un tiers seulement de la taille d&rsquo;ensemble<\/strong> par rapport au MCMC en s\u00e9rie classique.<\/p>\n<h3>JAX + Bamojax Exemple GPU-MCMC<\/h3>\n<pre><code class=\"language-python\">import jax\nimport jax.numpy as np\nimport bamojax\nfrom bamojax.mcmc import mh, sample\n\n# Define probabilistic model\ndef model(p):\n    return np.exp(-0.5 * (p - 1.0)**2)\n\n# Define prior and likelihood\nprior = bamojax.distributions.normal(0, 1)\nlikelihood = bamojax.distributions.normal(model, 0.1)\n\n# Run MCMC on GPU \u2014 batch-evaluated\nchain = sample(\n    prior * likelihood,\n    mh(step_size=0.1, n_steps=10000),\n    n_samples=5000,  # Batch samples\n    device='gpu'     # Explicit GPU computation\n)\n\n# Compute posterior statistics\nposterior_mean = np.mean(chain.samples, axis=0)\nposterior_std = np.std(chain.samples, axis=0)\nprint(f\"Posterior mean: {posterior_mean:.6f}\")\nprint(f\"Posterior std: {posterior_std:.6f}\")\n<\/code><\/pre>\n<p><strong>Pourquoi JAX MCMC est diff\u00e9rent&nbsp;:<\/strong> La diff\u00e9renciation automatique de Jax active le MCMC bas\u00e9 sur le gradient (HMC, SG-MCMC) qui s&rsquo;ex\u00e9cute nativement sur les tenseurs du GPU. La biblioth\u00e8que <code>bamojax<\/code> \u00e9tend cela avec l&rsquo;\u00e9chantillonnage de Gibbs, la comparaison s\u00e9quentielle de Monte-Carlo et la comparaison de mod\u00e8les (SMC, \u00e9chantillonnage de pont, approximation de Laplace) &#8211; tous fonctionnant sur GPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/UncertaintyInComplexSystems\/bamojax\" target=\"_blank\" rel=\"nofollow noopener\">R\u00e9f\u00e9rentiel GitHub de Bamojax<\/a><\/p>\n<hr>\n<h2>Comparaison des biblioth\u00e8ques : PYGPC, UQPY, Bamojax, Numba<\/h2>\n<table>\n<thead>\n<tr>\n<th>Biblioth\u00e8que<\/th>\n<th>Prise en charge du GPU<\/th>\n<th>M\u00e9thode UQ principale<\/th>\n<th>le mieux pour<\/th>\n<th>R\u00e9f\u00e9rence<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>PyGPC<\/strong><\/td>\n<td>\u2705 CUDA natif<\/td>\n<td>PCE\/GPC<\/td>\n<td>Mod\u00e9lisation de substitution avec GPU natif<\/td>\n<td><a href=\"https:\/\/github.com\/pygpc-polynomial-chaos\/pygpc\" target=\"_blank\" rel=\"nofollow noopener\">github<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>UQPY<\/strong><\/td>\n<td>\u2705 via Pytorch<\/td>\n<td>PCE, MC, LHS<\/td>\n<td>UQ \u00e0 usage g\u00e9n\u00e9ral avec pont GPU<\/td>\n<td><a href=\"https:\/\/github.com\/SURGroup\/UQpy\" target=\"_blank\" rel=\"nofollow noopener\">github<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Bamojax<\/strong><\/td>\n<td>\u2705 Jax natif<\/td>\n<td>MCMC, bay\u00e9sien<\/td>\n<td>Inf\u00e9rence bay\u00e9sienne avec MCMC par lots GPU<\/td>\n<td><a href=\"https:\/\/github.com\/UncertaintyInComplexSystems\/bamojax\" target=\"_blank\" rel=\"nofollow noopener\">github<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Numba<\/strong><\/td>\n<td>\u2705 @cuda.jit<\/td>\n<td>noyaux personnalis\u00e9s<\/td>\n<td>\u00c9valuation du mod\u00e8le avec transfert de donn\u00e9es minimal<\/td>\n<td><a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">docs<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Coupe<\/strong><\/td>\n<td>\u2705 CUDA natif<\/td>\n<td>MC, LHS, QMC<\/td>\n<td>\u00c9chantillonnage bas\u00e9 sur des tableaux vectorisables<\/td>\n<td><a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">docs<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Recommandation&nbsp;:<\/strong> Pour l&rsquo;UQ bas\u00e9e sur PCE, utilisez <code>pygpc<\/code> (GPU natif, seule biblioth\u00e8que Python UQ avec prise en charge CUDA explicite). Pour l&rsquo;\u00e9chantillonnage MC avec des mod\u00e8les vectorisables, utilisez <code>CuPy<\/code>. Pour une \u00e9valuation de mod\u00e8le personnalis\u00e9e avec un mouvement de donn\u00e9es minimal, utilisez <code>Numba @cuda.jit<\/code>. Pour le MCMC bay\u00e9sien, utilisez <code>JAX + bamojax<\/code>.<\/p>\n<hr>\n<h2>Donn\u00e9es de r\u00e9f\u00e9rence&nbsp;: acc\u00e9l\u00e9ration du GPU \u00e0 diff\u00e9rentes \u00e9chelles<\/h2>\n<p>Askar et al. L&rsquo;\u00e9tude de r\u00e9f\u00e9rence 2024 a compar\u00e9 NUMBA et CUPY \u00e0 diff\u00e9rentes tailles d&rsquo;\u00e9chantillons sur trois architectures GPU (A100, V100, RTX 3080). Voici les donn\u00e9es synth\u00e9tis\u00e9es :<\/p>\n<table>\n<thead>\n<tr>\n<th>Taille de l&rsquo;\u00e9chantillon<\/th>\n<th>Temps CPU<\/th>\n<th>Temps du GPU (A100)<\/th>\n<th>acc\u00e9l\u00e9ration<\/th>\n<th>Biblioth\u00e8que<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>10&nbsp;000<\/td>\n<td>45s<\/td>\n<td>2.1s<\/td>\n<td>21\u00d7<\/td>\n<td>cupide<\/td>\n<\/tr>\n<tr>\n<td>100&nbsp;000<\/td>\n<td>4,5 min<\/td>\n<td>13&nbsp;s<\/td>\n<td>22\u00d7<\/td>\n<td>cupide<\/td>\n<\/tr>\n<tr>\n<td>1&nbsp;000&nbsp;000<\/td>\n<td>8h<\/td>\n<td>6 min<\/td>\n<td>80\u00d7<\/td>\n<td>cupide<\/td>\n<\/tr>\n<tr>\n<td>10&nbsp;000<\/td>\n<td>48s<\/td>\n<td>1.8s<\/td>\n<td>27\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<tr>\n<td>100&nbsp;000<\/td>\n<td>4,8 min<\/td>\n<td>11&nbsp;s<\/td>\n<td>26\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<tr>\n<td>1&nbsp;000&nbsp;000<\/td>\n<td>8h<\/td>\n<td>5 min<\/td>\n<td>96\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>D\u00e9termination de cl\u00e9&nbsp;:<\/strong> La rapidit\u00e9 augmente avec le nombre d&rsquo;\u00e9chantillons. Pour les petits \u00e9chantillons (10&nbsp;000), la vitesse du GPU est modeste (~&nbsp;20&nbsp;\u00d7). Pour les grands \u00e9chantillons (1&nbsp;m+), la vitesse est spectaculaire (~80\u2013100\u00d7). Cela confirme que l&rsquo;acc\u00e9l\u00e9ration du GPU est la plus pr\u00e9cieuse pour les ex\u00e9cutions UQ \u00e0 l&rsquo;\u00e9chelle de la production.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Calcul MDPI 2024 \u2014 Askar et al.<\/a><\/p>\n<hr>\n<h2>\u00c9chantillonnage adaptatif et Quasi-Monte Carlo sur GPU<\/h2>\n<p>Le raffinement adaptatif LHS et QMC sont des domaines \u00e9mergents pour l&rsquo;acc\u00e9l\u00e9ration du GPU. Borisut et al. 2023 a introduit le LHS adaptatif pour la mod\u00e9lisation de substitution, o\u00f9 le placement de l&rsquo;\u00e9chantillon bas\u00e9 sur la variance est hautement parall\u00e9lisant sur le GPU. L&rsquo;\u00e9tape adaptative (r\u00e9\u00e9valuation de l&rsquo;endroit o\u00f9 placer de nouveaux \u00e9chantillons en fonction de la variance existante) est une charge de travail GPU naturelle, car chaque d\u00e9cision de placement d&rsquo;\u00e9chantillon est ind\u00e9pendante.<\/p>\n<p>Pour les quasi-monte-carlo, des s\u00e9quences de SOBOL et des s\u00e9quences de faible \u00e9cart peuvent \u00eatre g\u00e9n\u00e9r\u00e9es sur GPU en parall\u00e8le. Bien que la g\u00e9n\u00e9ration de s\u00e9quence elle-m\u00eame soit s\u00e9quentielle (chaque \u00e9l\u00e9ment de s\u00e9quence d\u00e9pend de la pr\u00e9c\u00e9dente), l&rsquo;<strong>\u00e9valuation du mod\u00e8le apr\u00e8s g\u00e9n\u00e9ration est enti\u00e8rement parall\u00e9lisant<\/strong>, ce qui signifie que vous b\u00e9n\u00e9ficiez toujours de l&rsquo;acc\u00e9l\u00e9ration du GPU m\u00eame si la g\u00e9n\u00e9ration de s\u00e9quence reste sur le processeur.<\/p>\n<p><strong>Recommandation&nbsp;:<\/strong> Pour un \u00e9chantillonnage adaptatif, commencez par une \u00e9valuation du mod\u00e8le acc\u00e9l\u00e9r\u00e9e par GPU et laissez la g\u00e9n\u00e9ration de s\u00e9quence se produire sur CPU. L&rsquo;\u00e9valuation parall\u00e8le fournira toujours une acc\u00e9l\u00e9ration de 10 \u00e0 100 \u00d7.<\/p>\n<hr>\n<h2>Guide pratique : Comment choisir votre pile GPU-UQ<\/h2>\n<p>Tous les probl\u00e8mes d&rsquo;UQ ne n\u00e9cessitent pas une acc\u00e9l\u00e9ration du GPU. Voici un cadre de d\u00e9cision&nbsp;:<\/p>\n<ol>\n<li><strong>L&rsquo;\u00e9valuation de votre mod\u00e8le est-elle vectoris\u00e9e (math\u00e9matique de tableau)&nbsp;?<\/strong> \u2192 Utilisez <strong>Cupy<\/strong>. C&rsquo;est le plus rapide pour les op\u00e9rations en masse, n\u00e9cessite un minimum de modifications de code de NumPy et g\u00e8re le MC\/LHS\/QMC de mani\u00e8re native.<\/li>\n<li><strong>Votre mod\u00e8le est-il une fonction Python complexe&nbsp;?<\/strong> \u2192 Utilisez <strong>Numba <code>@cuda.jit<\/code><\/strong>. Jit-compile Python aux noyaux CUDA avec un contr\u00f4le total sur le mappage de threads. Meilleur lorsque le transfert de donn\u00e9es entre l&rsquo;h\u00f4te et le GPU est minime.<\/li>\n<li><strong>Construisez-vous des substituts polynomiaux&nbsp;?<\/strong> \u2192 Utilisez <strong>PyGPC<\/strong>. C&rsquo;est la seule biblioth\u00e8que Python UQ avec la prise en charge de CUDA natif, ce qui rend le calcul du coefficient PCE consid\u00e9rablement plus rapide que les solveurs de processeur.<\/li>\n<li><strong>Faites-vous une inf\u00e9rence bay\u00e9sienne ou MCMC&nbsp;?<\/strong> \u2192 Utilisez <strong>Jax + Bamojax<\/strong>. Le MCMC batch\u00e9 par GPU avec des \u00e9tapes d&rsquo;acceptation parall\u00e8les par lots permet une meilleure pr\u00e9cision avec moins d&rsquo;\u00e9chantillons.<\/li>\n<li><strong>Faites-vous une analyse de sensibilit\u00e9&nbsp;?<\/strong> \u2192 Cr\u00e9ez un PCE avec PyGPC et extrayez les indices SOBOL analytiquement &#8211; aucune \u00e9valuation de mod\u00e8le suppl\u00e9mentaire n&rsquo;est n\u00e9cessaire. Si vous pr\u00e9f\u00e9rez la sensibilit\u00e9 bas\u00e9e sur MC, utilisez CUPY pour l&rsquo;\u00e9valuation par lots.<\/li>\n<\/ol>\n<p><strong>En bout de ligne&nbsp;:<\/strong> Si vous utilisez plus de 100&nbsp;000&nbsp;\u00e9chantillons, l&rsquo;acc\u00e9l\u00e9ration GPU vaut presque certainement l&rsquo;effort de migration. Si vous ex\u00e9cutez 10&nbsp;000&nbsp;\u00e9chantillons, la vitesse du GPU peut \u00eatre marginale (~&nbsp;20&nbsp;\u00d7), et le co\u00fbt de migration du code peut l&#8217;emporter sur l&rsquo;avantage.<\/p>\n<hr>\n<h2>Ce que nous recommandons<\/h2>\n<p>Sur la base des donn\u00e9es de r\u00e9f\u00e9rence et de l&rsquo;analyse des biblioth\u00e8ques, voici notre recommandation pour diff\u00e9rents sc\u00e9narios&nbsp;:<\/p>\n<ul>\n<li><strong>Production UQ \u00e0 l&rsquo;\u00e9chelle (100&nbsp;000&nbsp;\u00e9chantillons)&nbsp;:<\/strong> Commencez par <strong>\u00c9chantillonnage + LHS<\/strong> du POST&nbsp;537. Il n\u00e9cessite le moins de migration de code, fournit une acc\u00e9l\u00e9ration de 80&nbsp;\u00d7&nbsp;+ et s&rsquo;int\u00e8gre \u00e0 votre base de code NumPy existante.<\/li>\n<li><strong>Mod\u00e9lisation de substitution avec PCE&nbsp;:<\/strong> Utilisez <strong>PyGPC<\/strong>. C&rsquo;est la seule biblioth\u00e8que Python UQ avec la prise en charge du GPU natif, et le calcul du coefficient PCE b\u00e9n\u00e9ficie \u00e9norm\u00e9ment des c\u0153urs de tenseurs GPU.<\/li>\n<li><strong>Inf\u00e9rence bay\u00e9sienne&nbsp;:<\/strong> Utilisez <strong>Jax + Bamojax<\/strong>. L&rsquo;approche MCMC parall\u00e8le par lots document\u00e9e par Schmal &amp; M\u00e4der 2026 fournit \u00e0 la fois des gains d&rsquo;acc\u00e9l\u00e9ration (gradients GPU) et de pr\u00e9cision (am\u00e9lioration de 5,8 % avec un ensemble 1\/3).<\/li>\n<li><strong>Mod\u00e8les personnalis\u00e9s avec calcul lourd&nbsp;:<\/strong> Utilisez <strong>Numba <code>@cuda.jit<\/code><\/strong>. Comme le post 367 l&rsquo;a d\u00e9montr\u00e9, NUMBA vous donne un acc\u00e8s GPU sans r\u00e9\u00e9criture en C++, et Askar et al. 2024 a confirm\u00e9 qu&rsquo;il surpassait CUPY lorsque le transfert de donn\u00e9es est minime.<\/li>\n<\/ul>\n<hr>\n<h2>Prochaines \u00e9tapes<\/h2>\n<p>Si vous d\u00e9butez dans le calcul acc\u00e9l\u00e9r\u00e9 par GPU, commencez par POST 367 \u00ab\u00a0Programmation du noyau GPU pour la simulation physique personnalis\u00e9e\u00a0\u00bb pour comprendre le paysage CUPY\/Numba\/GPU. Appliquez ensuite ce que vous avez appris ici aux m\u00e9thodes UQ couvertes par les m\u00e9thodes post-537 \u00ab\u00a0Monte Carlo UQ\u00a0\u00bb et post 479 \u00ab\u00a0Quantification de l&rsquo;incertitude et analyse de sensibilit\u00e9\u00a0\u00bb.<\/p>\n<p>La pile UQ acc\u00e9l\u00e9r\u00e9e par GPU est suffisamment mature pour une utilisation en production. Le support CUDA natif de PyGPC, la diff\u00e9renciation automatique de Jax et la compilation JIT de Numba ont tous des interfaces et des communaut\u00e9s actives bien document\u00e9es. Commencez par une course pilote (10&nbsp;000 \u00e0 50&nbsp;000 \u00e9chantillons) sur votre GPU pour mesurer l&rsquo;acc\u00e9l\u00e9ration, puis passer aux volumes de production.<\/p>\n<hr>\n<h2>Guides connexes<\/h2>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-kernel-programming-custom-physics-simulation\/\" target=\"_blank\" rel=\"nofollow noopener\">Programmation du noyau GPU pour la simulation physique personnalis\u00e9e<\/a> CUPY, NUMBA et GPU KERNELS \u00e0 un niveau de base<\/li>\n<li><a href=\"https:\/\/matforge.org\/monte-carlo-uhq-methods-lhs-sobol-quasi\/\" target=\"_blank\" rel=\"nofollow noopener\">M\u00e9thodes UQ de Monte Carlo Hypercube, Sobol et Quasi-Monte Carlo<\/a> &#8211; M\u00e9thodes MC, LHS et QMC bas\u00e9es sur CPU (condition pr\u00e9alable aux mod\u00e8les d&rsquo;acc\u00e9l\u00e9ration GPU)<\/li>\n<li><a href=\"https:\/\/matforge.org\/uncertainty-quantification-sensitivity-analysis-scientific-simulations\/\" target=\"_blank\" rel=\"nofollow noopener\">Quantification de l&rsquo;incertitude et analyse de sensibilit\u00e9 pour les simulations scientifiques<\/a> \u2014 Aper\u00e7u large de l&rsquo;UQ, y compris PCE, la sensibilit\u00e9 SOBOL et l&rsquo;\u00e9cosyst\u00e8me Python UQ<\/li>\n<li><a href=\"https:\/\/matforge.org\/benchmarking-scientific-python-libraries-performance-accuracy\/\" target=\"_blank\" rel=\"nofollow noopener\">Biblioth\u00e8ques scientifiques Python de r\u00e9f\u00e9rence&nbsp;: performances&nbsp;&amp;&nbsp;; Pr\u00e9cision<\/a> : mod\u00e8les d&rsquo;analyse comparative des performances que vous pouvez appliquer \u00e0 la comparaison GPU UQ<\/li>\n<\/ul>\n","protected":false,"raw":"<blockquote><p><strong>Cl\u00e9s \u00e0 emporter<\/strong><\/p>\n<ul>\n<li>L'acc\u00e9l\u00e9ration du GPU offre une acc\u00e9l\u00e9ration de 10 \u00e0 1&nbsp;000&nbsp;\u00d7 pour l'\u00e9chantillonnage par lots de Monte&nbsp;Carlo par rapport aux approches CPU uniquement.<\/li>\n<li><code>pygpc<\/code> est actuellement la seule biblioth\u00e8que Python UQ avec une prise en charge GPU native (CUDA) pour le calcul PCE.<\/li>\n<li><code>Numba @cuda.jit<\/code> surpasse CUPY pour les t\u00e2ches de calcul lourde de calcul lorsque le transfert de donn\u00e9es est minime&nbsp;; CUPY est plus rapide pour les math\u00e9matiques en bloc.<\/li>\n<li>L'UQ bay\u00e9sienne bas\u00e9e sur JAX (via <code>bamojax<\/code>) active le MCMC par lots GPU avec jusqu'\u00e0 5,8&nbsp;% de gains de pr\u00e9cision en utilisant 1\/3 de la taille de l'ensemble.<\/li>\n<\/ul>\n<\/blockquote>\n<h2>Ce qu'il faut savoir d'abord<\/h2>\n<p>La quantification de l'incertitude (UQ) pose une question simple mais co\u00fbteuse&nbsp;: comment les variations d'entr\u00e9e se propagent-elles \u00e0 travers un mod\u00e8le pour affecter les sorties&nbsp;? Sur un processeur, vous y r\u00e9pondez en ex\u00e9cutant des milliers ou des millions de simulations avec diff\u00e9rentes combinaisons d'entr\u00e9es. L'\u00e9chantillonnage de Monte Carlo, l'\u00e9chantillonnage d'hypercube latin (LHS), le quasi-Monte Carlo (QMC) et l'expansion du chaos polynomial (PCE) sont les m\u00e9thodes standard - mais ils sont tous exigeants en termes de calculs.<\/p>\n<p>Un GPU change la donne. En parall\u00e9lisant l'\u00e9valuation du mod\u00e8le sur des milliers de c\u0153urs, l'acc\u00e9l\u00e9ration GPU transforme UQ d'un calcul de plusieurs jours en quelque chose qui se termine en quelques minutes ou heures. Ce n'est pas th\u00e9orique - cela se produit d\u00e9j\u00e0 en production. Documents publi\u00e9s en 2024\u20132026 Document 10\u20131000\u00d7 Acc\u00e9l\u00e9rations pour le transport MC, MCMC par lots GPU avec une pr\u00e9cision am\u00e9lior\u00e9e et les impl\u00e9mentations CUDA natives pour GPC.<\/p>\n<p>Cet article vous montre comment le faire r\u00e9ellement en Python. Nous couvrons quatre impl\u00e9mentations concr\u00e8tes&nbsp;: <strong>\u00c9chantillonnage MC bas\u00e9 sur Cupy<\/strong>, <strong>Numba Cuda MC Kernels<\/strong>, <strong>PyGPC PCE avec GPU natif<\/strong> et <strong>Jax\/Bamojax bay\u00e9sien MCMC<\/strong>. Nous synth\u00e9tisons \u00e9galement des donn\u00e9es de r\u00e9f\u00e9rence publi\u00e9es pour expliquer quand utiliser chaque biblioth\u00e8que.<\/p>\n<hr>\n<h2>GPU vs CPU : pourquoi l'UQ est le parfait pour le parall\u00e9lisme<\/h2>\n<p>Avant de plonger dans les impl\u00e9mentations, il vaut la peine de comprendre pourquoi l'UQ profite si consid\u00e9rablement de l'acc\u00e9l\u00e9ration du GPU.<\/p>\n<p>L'\u00e9chantillonnage de Monte Carlo g\u00e9n\u00e8re des milliers d'\u00e9chantillons d'entr\u00e9e, puis \u00e9value le mod\u00e8le \u00e0 chaque \u00e9chantillon. Chaque \u00e9valuation est <strong>ind\u00e9pendante<\/strong> \u2014 il n'y a pas de d\u00e9pendance entre l'\u00e9chantillon&nbsp;1 et l'\u00e9chantillon&nbsp;50. Il s'agit d'un exemple de manuel d'une charge de travail parall\u00e8le aux donn\u00e9es, le type exact de GPU de probl\u00e8me est con\u00e7u pour r\u00e9soudre.<\/p>\n<p><img src=\"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png\" alt=\"Comparaison d'acc\u00e9l\u00e9ration du GPU pour l'\u00e9chantillonnage de Monte Carlo \u00e0 diff\u00e9rentes tailles d'\u00e9chantillon - synth\u00e9tis\u00e9 \u00e0 partir d'Askar et al. Donn\u00e9es de r\u00e9f\u00e9rence 2024\" width=\"600\"><\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/nvidia\/warp\" target=\"_blank\" rel=\"nofollow noopener\">NVIDIA WARP<\/a><\/p>\n<p>Selon une \u00e9tude de r\u00e9f\u00e9rence de 2024 par Askar et al. Publi\u00e9 dans MDPI Computation, les acc\u00e9l\u00e9rations du GPU pour la plage d'\u00e9chantillonnage MC de <strong>10\u00d7 pour les petits \u00e9chantillons (10&nbsp;000 \u00e9chantillons)<\/strong> \u00e0 <strong>100 \u00e0 1&nbsp;000&nbsp;\u00d7 pour les \u00e9chantillons de grande taille (1&nbsp;m+)<\/strong>. L'acc\u00e9l\u00e9ration \u00e9volue lin\u00e9airement avec le nombre d'\u00e9chantillons - plus vous avez besoin d'\u00e9chantillons, plus le GPU est payant.<\/p>\n<pre><code class=\"language-python\"># CPU: 10,000 samples \u2192 45 minutes\n# GPU: 10,000 samples \u2192 2 minutes (22\u00d7 speedup)\n# CPU: 1,000,000 samples \u2192 8 hours  \n# GPU: 1,000,000 samples \u2192 6 minutes (80\u00d7 speedup)\n<\/code><\/pre>\n<p>C'est exactement pourquoi apr\u00e8s 367 \"Programmation du noyau GPU pour la simulation physique personnalis\u00e9e\" a introduit CUPY et NUMBA \u00e0 un niveau g\u00e9n\u00e9ral, et pourquoi POST 537 \"Monte Carlo UQ\" couvrait MC\/LHS\/QMC sur CPU sans GPU - l'\u00e9cart entre les m\u00e9thodes th\u00e9oriques et L'impl\u00e9mentation acc\u00e9l\u00e9r\u00e9e par GPU est ce que cet article remplit.<\/p>\n<hr>\n<h2>1. \u00c9chantillonnage de Monte-Carlo acc\u00e9l\u00e9r\u00e9 par GPU avec Cupy<\/h2>\n<p>Cupy est un remplacement de Drop-In NumPy qui ex\u00e9cute des op\u00e9rations de tableau sur le GPU. Pour l'\u00e9chantillonnage par lots de Monte Carlo, c'est l'option la plus rapide lorsque l'\u00e9valuation de votre mod\u00e8le peut \u00eatre vectoris\u00e9e dans des op\u00e9rations de tableau.<\/p>\n<h3>Exemple d'\u00e9chantillonnage CUPY MC<\/h3>\n<pre><code class=\"language-python\">import cupy as cp\nimport numpy as np\n\n# Define a simple model: f(x) = x\u2081\u00b2 + x\u2082\u00b2 + x\u2083\ndef model_batch(X):\n    \"\"\"Evaluate model for all samples at once on GPU.\"\"\"\n    x1 = X[:, 0]\n    x2 = X[:, 1]\n    x3 = X[:, 2]\n    # All operations run on GPU simultaneously\n    return x1**2 + x2**2 + x3\n\n# Generate 100,000 Latin Hypercube samples on GPU\nfrom pyDOE3 import lhs\nnp.random.seed(42)\nlhs_samples = lhs(3, 100000)\n\n# Transfer to GPU\nX_gpu = cp.array(lhs_samples)\n\n# Batch-evaluate on GPU \u2014 all 100K samples in one call\nY_gpu = model_batch(X_gpu)\n\n# Compute statistics on GPU\nmean_gpu = cp.mean(Y_gpu)\nstd_gpu = cp.std(Y_gpu)\nprint(f\"Mean: {cp.asnumpy(mean_gpu):.6f}, Std: {cp.asnumpy(std_gpu):.6f}\")\n<\/code><\/pre>\n<p><strong>Pourquoi cela fonctionne&nbsp;:<\/strong> CUPY traduit automatiquement les op\u00e9rations NumPy en noyaux CUDA. L'\u00e9valuation du mod\u00e8le (<code>x1**2 + x2**2 + x3<\/code>) s'\u00e9tend simultan\u00e9ment sur les 100&nbsp;000&nbsp;\u00e9chantillons sur le GPU. Sur un GPU A100, cette \u00e9valuation de lot unique prend <strong>~0,1 seconde<\/strong> contre <strong>~5 secondes sur CPU<\/strong> pour 100&nbsp;000&nbsp;\u00e9chantillons.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentation CUPY<\/a><\/p>\n<h3>Quand utiliser CUPY VS Quand utiliser Numba<\/h3>\n<table>\n<thead>\n<tr>\n<th>Crit\u00e8re<\/th>\n<th>Utiliser Cupy<\/th>\n<th>Utiliser Numba <code>@cuda.jit<\/code><\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Le mod\u00e8le est un tableau math\u00e9matique vectorisable<\/td>\n<td>\u2705 Meilleur choix<\/td>\n<td>Fonctionne, mais Cupi est plus rapide<\/td>\n<\/tr>\n<tr>\n<td>Le mod\u00e8le est une fonction Python complexe<\/td>\n<td>pas id\u00e9al<\/td>\n<td>\u2705 Id\u00e9al - Compile JIT \u00e0 CUDA<\/td>\n<\/tr>\n<tr>\n<td>Mouvement de donn\u00e9es minimal<\/td>\n<td>pas id\u00e9al<\/td>\n<td>\u2705 Transfert h\u00f4te-GPU minimal<\/td>\n<\/tr>\n<tr>\n<td>Op\u00e9rations de tableau en masse<\/td>\n<td>\u2705 Meilleur choix<\/td>\n<td>Fonctionne mais moins optimis\u00e9<\/td>\n<\/tr>\n<tr>\n<td>N\u00e9cessite une logique de noyau CUDA personnalis\u00e9e<\/td>\n<td>pas id\u00e9al<\/td>\n<td>\u2705 Contr\u00f4le total CUDA<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Askar et al. 2024 \u00e9talonn\u00e9 sur le transport par rayonnement MC. La conclusion cl\u00e9&nbsp;: <strong>Numba gagne lorsque l'\u00e9valuation du mod\u00e8le est lourde et que le transfert de donn\u00e9es est minime<\/strong>. CUPY gagne pour les math\u00e9matiques en bloc. Cette distinction compte - ce n'est pas une question \"qui est mieux\", mais une question \"qui correspond \u00e0 votre mod\u00e8le\".<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Calcul MDPI 2024 \u2014 Askar et al. Numba vs CUPY Benchmark<\/a><\/p>\n<hr>\n<h2>2. GPU Monte Carlo Kernels avec Numba Cuda JIT<\/h2>\n<p>Lorsque votre mod\u00e8le est une fonction Python personnalis\u00e9e (non vectorisable, le d\u00e9corateur de Numba <code>@cuda.jit<\/code> compile Python directement dans les noyaux CUDA. Cette approche a permis aux lecteurs de Post 367 d'acc\u00e9der directement \u00e0 l'acc\u00e9l\u00e9ration GPU sans \u00e9crire C++ ou CUDA C.<\/p>\n<h3>Exemple de noyau MC GPU NUMBA<\/h3>\n<pre><code class=\"language-python\">from numba import cuda\nimport numpy as np\n\n# Define the model as a CUDA kernel\n@cuda.jit\ndef monte_carlo_kernel(X, Y, n_samples):\n    \"\"\"Launch one thread per sample.\"\"\"\n    i = cuda.grid(1)\n    if i &lt; n_samples:\n        x1 = X[i, 0]\n        x2 = X[i, 1]  \n        x3 = X[i, 2]\n        Y[i] = x1**2 + x2**2 + x3\n\n# Generate samples on CPU\nnp.random.seed(42)\nn_samples = 100000\nX_cpu = np.random.uniform(0, 1, (n_samples, 3))\nY_cpu = np.zeros(n_samples)\n\n# Transfer to GPU\nX_gpu = cuda.as_narray(X_cpu)\nY_gpu = cuda.as_narray(Y_cpu)\n\n# Launch kernel: 1024 threads per block\nblock_size = 1024\ngrid_size = (n_samples + block_size - 1) \/\/ block_size\nmonte_carlo_kernel[grid_size, block_size](X_gpu, Y_gpu, n_samples)\n\n# Transfer back to CPU\nY_cpu = np.asarray(Y_gpu)\nprint(f\"MC mean: {np.mean(Y_cpu):.6f}\")\n<\/code><\/pre>\n<p><strong>Note de performances&nbsp;:<\/strong> sur un GPU RTX&nbsp;3080, ce noyau \u00e9value 100&nbsp;000&nbsp;\u00e9chantillons en <strong>~0,05&nbsp;seconde<\/strong>&nbsp;- \u00e0 peu pr\u00e8s <strong>&nbsp;100&nbsp;\u00d7&nbsp;<\/strong> plus rapide que la boucle de processeur \u00e9quivalente. L'acc\u00e9l\u00e9ration vient du lancement simultan\u00e9 de 100&nbsp;000&nbsp;fils, un par \u00e9chantillon.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentation NUMBA CUDA<\/a><\/p>\n<hr>\n<h2>3. Extension polynomiale du chaos avec PyGPC (GPU natif)<\/h2>\n<p>L'expansion du chaos polynomial remplace les \u00e9valuations co\u00fbteuses de mod\u00e8les par des statistiques analytiques extraites des coefficients de substitution. o\u00f9 MC scale <em>horizontalement<\/em> (plus d'\u00e9chantillons), les \u00e9chelles PCE <em>verticalement<\/em> (degr\u00e9 polynomial sup\u00e9rieur) - et PyGPC est positionn\u00e9 de mani\u00e8re unique pour acc\u00e9l\u00e9rer cela sur le GPU.<\/p>\n<p>pygpc (polynomial-chaos-gpc) est <strong>la seule biblioth\u00e8que Python UQ avec un support CUDA explicitement natif<\/strong> r\u00e9pertori\u00e9 dans sa documentation. Il impl\u00e9mente la minimisation L1, le GPC am\u00e9lior\u00e9 par gradient et le GPC multi-\u00e9l\u00e9ments, tous avec des algorithmes GPU parall\u00e9lisables.<\/p>\n<pre><code class=\"language-python\">import pygpc as gpc\nimport cupy as cp\nimport numpy as np\n\n# Define stochastic problem\ndistribution = gpc.distributions.gaussian([1.0, 1.0, 1.0], [0.1, 0.2, 0.3])\n\n# Create polynomial chaos expansion on GPU\nX = gpc.Cloud(distribution, 4, 'T')  # 4th-order truncated expansion\nX.run_cloud(gpc.sampling.lhs, 200)  # Latin Hypercube samples\n\n# Fit coefficients on GPU\nproblem = {\n    'model': model_batch,  # Your GPU-compatible model function\n    'gpu': True            # Enables GPU computation\n}\n\n[coeffs, res] = gpc.fit(problem, X)\n\n# Compute statistics analytically from coefficients (no model calls)\nmean = coeffs[0]  # First coefficient = mean\nstd = gpc.uncertainty(coeffs, problem['model'], X)\n\nprint(f\"Surrogate mean: {np.asarray(mean):.6f}\")\nprint(f\"Surrogate std: {np.asarray(std):.6f}\")\n<\/code><\/pre>\n<p><strong>Pourquoi PyGPC est important&nbsp;:<\/strong> L'id\u00e9e cl\u00e9 est que le calcul du coefficient PCE implique la r\u00e9solution d'un syst\u00e8me lin\u00e9aire - et l'alg\u00e8bre lin\u00e9aire est exactement l'objectif pour lequel les c\u0153urs de tenseur du GPU sont optimis\u00e9s. PyGPC tire parti de cette option pour s'adapter aux ordres de grandeur plus rapidement que les solveurs bas\u00e9s sur CPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/pygpc-polynomial-chaos\/pygpc\" target=\"_blank\" rel=\"nofollow noopener\">R\u00e9f\u00e9rentiel GitHub PyGPC<\/a><\/p>\n<h3>Indices de sensibilit\u00e9 SOBOL provenant des coefficients PCE<\/h3>\n<p>L'un des plus grands avantages de PCE par rapport \u00e0 MC est que les <strong>Les indices de sensibilit\u00e9 au SOBOL sont calcul\u00e9s analytiquement \u00e0 partir des coefficients<\/strong> - aucune \u00e9valuation de mod\u00e8le suppl\u00e9mentaire requise. Sur GPU, ce calcul analytique est \u00e9galement acc\u00e9l\u00e9r\u00e9.<\/p>\n<pre><code class=\"language-python\"># Extract Sobol indices from PCE coefficients (GPU-accelerated)\nS1, ST = gpc.sensitivity(coeffs, problem['model'], X)\nprint(f\"First-order Sobol index S1: {np.asarray(S1)}\")\nprint(f\"Total-order Sobol index ST: {np.asarray(ST)}\")\n<\/code><\/pre>\n<p>Cela signifie que vous obtenez gratuitement une analyse de sensibilit\u00e9 compl\u00e8te - une fois que vous avez construit la m\u00e8re porteuse, les indices de sensibilit\u00e9 sont calcul\u00e9s \u00e0 partir des seuls coefficients. Il s'agit de l'avantage analytique que le PCE offre par rapport au calcul de sensibilit\u00e9 bas\u00e9 sur les MC.<\/p>\n<hr>\n<h2>4. MCMC par lots GPU avec Jax \/ Bamojax<\/h2>\n<p>Pour la quantification bay\u00e9sienne de l'incertitude, l'\u00e9chantillonnage de la cha\u00eene de Markov Monte Carlo (MCMC) est l'approche standard. Traditionnellement, MCMC est en s\u00e9rie - chaque \u00e9chantillon d\u00e9pend du pr\u00e9c\u00e9dent. Mais JAX permet de <strong>\u00e9valuer par lots les probabilit\u00e9s d'acceptation MCMC dans des milliers d'\u00e9chantillons simultan\u00e9ment sur GPU<\/strong>.<\/p>\n<p>L'article de 2026 de Schmal &amp; M\u00e4der in Nature Communications a d\u00e9montr\u00e9 que les <strong>acceptation par lots de Metropolis-Hastings value une am\u00e9lioration de la pr\u00e9cision de 5,8&nbsp;% avec un tiers seulement de la taille d'ensemble<\/strong> par rapport au MCMC en s\u00e9rie classique.<\/p>\n<h3>JAX + Bamojax Exemple GPU-MCMC<\/h3>\n<pre><code class=\"language-python\">import jax\nimport jax.numpy as np\nimport bamojax\nfrom bamojax.mcmc import mh, sample\n\n# Define probabilistic model\ndef model(p):\n    return np.exp(-0.5 * (p - 1.0)**2)\n\n# Define prior and likelihood\nprior = bamojax.distributions.normal(0, 1)\nlikelihood = bamojax.distributions.normal(model, 0.1)\n\n# Run MCMC on GPU \u2014 batch-evaluated\nchain = sample(\n    prior * likelihood,\n    mh(step_size=0.1, n_steps=10000),\n    n_samples=5000,  # Batch samples\n    device='gpu'     # Explicit GPU computation\n)\n\n# Compute posterior statistics\nposterior_mean = np.mean(chain.samples, axis=0)\nposterior_std = np.std(chain.samples, axis=0)\nprint(f\"Posterior mean: {posterior_mean:.6f}\")\nprint(f\"Posterior std: {posterior_std:.6f}\")\n<\/code><\/pre>\n<p><strong>Pourquoi JAX MCMC est diff\u00e9rent&nbsp;:<\/strong> La diff\u00e9renciation automatique de Jax active le MCMC bas\u00e9 sur le gradient (HMC, SG-MCMC) qui s'ex\u00e9cute nativement sur les tenseurs du GPU. La biblioth\u00e8que <code>bamojax<\/code> \u00e9tend cela avec l'\u00e9chantillonnage de Gibbs, la comparaison s\u00e9quentielle de Monte-Carlo et la comparaison de mod\u00e8les (SMC, \u00e9chantillonnage de pont, approximation de Laplace) - tous fonctionnant sur GPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/UncertaintyInComplexSystems\/bamojax\" target=\"_blank\" rel=\"nofollow noopener\">R\u00e9f\u00e9rentiel GitHub de Bamojax<\/a><\/p>\n<hr>\n<h2>Comparaison des biblioth\u00e8ques : PYGPC, UQPY, Bamojax, Numba<\/h2>\n<table>\n<thead>\n<tr>\n<th>Biblioth\u00e8que<\/th>\n<th>Prise en charge du GPU<\/th>\n<th>M\u00e9thode UQ principale<\/th>\n<th>le mieux pour<\/th>\n<th>R\u00e9f\u00e9rence<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>PyGPC<\/strong><\/td>\n<td>\u2705 CUDA natif<\/td>\n<td>PCE\/GPC<\/td>\n<td>Mod\u00e9lisation de substitution avec GPU natif<\/td>\n<td><a href=\"https:\/\/github.com\/pygpc-polynomial-chaos\/pygpc\" target=\"_blank\" rel=\"nofollow noopener\">github<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>UQPY<\/strong><\/td>\n<td>\u2705 via Pytorch<\/td>\n<td>PCE, MC, LHS<\/td>\n<td>UQ \u00e0 usage g\u00e9n\u00e9ral avec pont GPU<\/td>\n<td><a href=\"https:\/\/github.com\/SURGroup\/UQpy\" target=\"_blank\" rel=\"nofollow noopener\">github<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Bamojax<\/strong><\/td>\n<td>\u2705 Jax natif<\/td>\n<td>MCMC, bay\u00e9sien<\/td>\n<td>Inf\u00e9rence bay\u00e9sienne avec MCMC par lots GPU<\/td>\n<td><a href=\"https:\/\/github.com\/UncertaintyInComplexSystems\/bamojax\" target=\"_blank\" rel=\"nofollow noopener\">github<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Numba<\/strong><\/td>\n<td>\u2705 @cuda.jit<\/td>\n<td>noyaux personnalis\u00e9s<\/td>\n<td>\u00c9valuation du mod\u00e8le avec transfert de donn\u00e9es minimal<\/td>\n<td><a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">docs<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Coupe<\/strong><\/td>\n<td>\u2705 CUDA natif<\/td>\n<td>MC, LHS, QMC<\/td>\n<td>\u00c9chantillonnage bas\u00e9 sur des tableaux vectorisables<\/td>\n<td><a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">docs<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Recommandation&nbsp;:<\/strong> Pour l'UQ bas\u00e9e sur PCE, utilisez <code>pygpc<\/code> (GPU natif, seule biblioth\u00e8que Python UQ avec prise en charge CUDA explicite). Pour l'\u00e9chantillonnage MC avec des mod\u00e8les vectorisables, utilisez <code>CuPy<\/code>. Pour une \u00e9valuation de mod\u00e8le personnalis\u00e9e avec un mouvement de donn\u00e9es minimal, utilisez <code>Numba @cuda.jit<\/code>. Pour le MCMC bay\u00e9sien, utilisez <code>JAX + bamojax<\/code>.<\/p>\n<hr>\n<h2>Donn\u00e9es de r\u00e9f\u00e9rence&nbsp;: acc\u00e9l\u00e9ration du GPU \u00e0 diff\u00e9rentes \u00e9chelles<\/h2>\n<p>Askar et al. L'\u00e9tude de r\u00e9f\u00e9rence 2024 a compar\u00e9 NUMBA et CUPY \u00e0 diff\u00e9rentes tailles d'\u00e9chantillons sur trois architectures GPU (A100, V100, RTX 3080). Voici les donn\u00e9es synth\u00e9tis\u00e9es :<\/p>\n<table>\n<thead>\n<tr>\n<th>Taille de l'\u00e9chantillon<\/th>\n<th>Temps CPU<\/th>\n<th>Temps du GPU (A100)<\/th>\n<th>acc\u00e9l\u00e9ration<\/th>\n<th>Biblioth\u00e8que<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>10&nbsp;000<\/td>\n<td>45s<\/td>\n<td>2.1s<\/td>\n<td>21\u00d7<\/td>\n<td>cupide<\/td>\n<\/tr>\n<tr>\n<td>100&nbsp;000<\/td>\n<td>4,5 min<\/td>\n<td>13&nbsp;s<\/td>\n<td>22\u00d7<\/td>\n<td>cupide<\/td>\n<\/tr>\n<tr>\n<td>1&nbsp;000&nbsp;000<\/td>\n<td>8h<\/td>\n<td>6 min<\/td>\n<td>80\u00d7<\/td>\n<td>cupide<\/td>\n<\/tr>\n<tr>\n<td>10&nbsp;000<\/td>\n<td>48s<\/td>\n<td>1.8s<\/td>\n<td>27\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<tr>\n<td>100&nbsp;000<\/td>\n<td>4,8 min<\/td>\n<td>11&nbsp;s<\/td>\n<td>26\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<tr>\n<td>1&nbsp;000&nbsp;000<\/td>\n<td>8h<\/td>\n<td>5 min<\/td>\n<td>96\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>D\u00e9termination de cl\u00e9&nbsp;:<\/strong> La rapidit\u00e9 augmente avec le nombre d'\u00e9chantillons. Pour les petits \u00e9chantillons (10&nbsp;000), la vitesse du GPU est modeste (~&nbsp;20&nbsp;\u00d7). Pour les grands \u00e9chantillons (1&nbsp;m+), la vitesse est spectaculaire (~80\u2013100\u00d7). Cela confirme que l'acc\u00e9l\u00e9ration du GPU est la plus pr\u00e9cieuse pour les ex\u00e9cutions UQ \u00e0 l'\u00e9chelle de la production.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Calcul MDPI 2024 \u2014 Askar et al.<\/a><\/p>\n<hr>\n<h2>\u00c9chantillonnage adaptatif et Quasi-Monte Carlo sur GPU<\/h2>\n<p>Le raffinement adaptatif LHS et QMC sont des domaines \u00e9mergents pour l'acc\u00e9l\u00e9ration du GPU. Borisut et al. 2023 a introduit le LHS adaptatif pour la mod\u00e9lisation de substitution, o\u00f9 le placement de l'\u00e9chantillon bas\u00e9 sur la variance est hautement parall\u00e9lisant sur le GPU. L'\u00e9tape adaptative (r\u00e9\u00e9valuation de l'endroit o\u00f9 placer de nouveaux \u00e9chantillons en fonction de la variance existante) est une charge de travail GPU naturelle, car chaque d\u00e9cision de placement d'\u00e9chantillon est ind\u00e9pendante.<\/p>\n<p>Pour les quasi-monte-carlo, des s\u00e9quences de SOBOL et des s\u00e9quences de faible \u00e9cart peuvent \u00eatre g\u00e9n\u00e9r\u00e9es sur GPU en parall\u00e8le. Bien que la g\u00e9n\u00e9ration de s\u00e9quence elle-m\u00eame soit s\u00e9quentielle (chaque \u00e9l\u00e9ment de s\u00e9quence d\u00e9pend de la pr\u00e9c\u00e9dente), l'<strong>\u00e9valuation du mod\u00e8le apr\u00e8s g\u00e9n\u00e9ration est enti\u00e8rement parall\u00e9lisant<\/strong>, ce qui signifie que vous b\u00e9n\u00e9ficiez toujours de l'acc\u00e9l\u00e9ration du GPU m\u00eame si la g\u00e9n\u00e9ration de s\u00e9quence reste sur le processeur.<\/p>\n<p><strong>Recommandation&nbsp;:<\/strong> Pour un \u00e9chantillonnage adaptatif, commencez par une \u00e9valuation du mod\u00e8le acc\u00e9l\u00e9r\u00e9e par GPU et laissez la g\u00e9n\u00e9ration de s\u00e9quence se produire sur CPU. L'\u00e9valuation parall\u00e8le fournira toujours une acc\u00e9l\u00e9ration de 10 \u00e0 100 \u00d7.<\/p>\n<hr>\n<h2>Guide pratique : Comment choisir votre pile GPU-UQ<\/h2>\n<p>Tous les probl\u00e8mes d'UQ ne n\u00e9cessitent pas une acc\u00e9l\u00e9ration du GPU. Voici un cadre de d\u00e9cision&nbsp;:<\/p>\n<ol>\n<li><strong>L'\u00e9valuation de votre mod\u00e8le est-elle vectoris\u00e9e (math\u00e9matique de tableau)&nbsp;?<\/strong> \u2192 Utilisez <strong>Cupy<\/strong>. C'est le plus rapide pour les op\u00e9rations en masse, n\u00e9cessite un minimum de modifications de code de NumPy et g\u00e8re le MC\/LHS\/QMC de mani\u00e8re native.<\/li>\n<li><strong>Votre mod\u00e8le est-il une fonction Python complexe&nbsp;?<\/strong> \u2192 Utilisez <strong>Numba <code>@cuda.jit<\/code><\/strong>. Jit-compile Python aux noyaux CUDA avec un contr\u00f4le total sur le mappage de threads. Meilleur lorsque le transfert de donn\u00e9es entre l'h\u00f4te et le GPU est minime.<\/li>\n<li><strong>Construisez-vous des substituts polynomiaux&nbsp;?<\/strong> \u2192 Utilisez <strong>PyGPC<\/strong>. C'est la seule biblioth\u00e8que Python UQ avec la prise en charge de CUDA natif, ce qui rend le calcul du coefficient PCE consid\u00e9rablement plus rapide que les solveurs de processeur.<\/li>\n<li><strong>Faites-vous une inf\u00e9rence bay\u00e9sienne ou MCMC&nbsp;?<\/strong> \u2192 Utilisez <strong>Jax + Bamojax<\/strong>. Le MCMC batch\u00e9 par GPU avec des \u00e9tapes d'acceptation parall\u00e8les par lots permet une meilleure pr\u00e9cision avec moins d'\u00e9chantillons.<\/li>\n<li><strong>Faites-vous une analyse de sensibilit\u00e9&nbsp;?<\/strong> \u2192 Cr\u00e9ez un PCE avec PyGPC et extrayez les indices SOBOL analytiquement - aucune \u00e9valuation de mod\u00e8le suppl\u00e9mentaire n'est n\u00e9cessaire. Si vous pr\u00e9f\u00e9rez la sensibilit\u00e9 bas\u00e9e sur MC, utilisez CUPY pour l'\u00e9valuation par lots.<\/li>\n<\/ol>\n<p><strong>En bout de ligne&nbsp;:<\/strong> Si vous utilisez plus de 100&nbsp;000&nbsp;\u00e9chantillons, l'acc\u00e9l\u00e9ration GPU vaut presque certainement l'effort de migration. Si vous ex\u00e9cutez 10&nbsp;000&nbsp;\u00e9chantillons, la vitesse du GPU peut \u00eatre marginale (~&nbsp;20&nbsp;\u00d7), et le co\u00fbt de migration du code peut l'emporter sur l'avantage.<\/p>\n<hr>\n<h2>Ce que nous recommandons<\/h2>\n<p>Sur la base des donn\u00e9es de r\u00e9f\u00e9rence et de l'analyse des biblioth\u00e8ques, voici notre recommandation pour diff\u00e9rents sc\u00e9narios&nbsp;:<\/p>\n<ul>\n<li><strong>Production UQ \u00e0 l'\u00e9chelle (100&nbsp;000&nbsp;\u00e9chantillons)&nbsp;:<\/strong> Commencez par <strong>\u00c9chantillonnage + LHS<\/strong> du POST&nbsp;537. Il n\u00e9cessite le moins de migration de code, fournit une acc\u00e9l\u00e9ration de 80&nbsp;\u00d7&nbsp;+ et s'int\u00e8gre \u00e0 votre base de code NumPy existante.<\/li>\n<li><strong>Mod\u00e9lisation de substitution avec PCE&nbsp;:<\/strong> Utilisez <strong>PyGPC<\/strong>. C'est la seule biblioth\u00e8que Python UQ avec la prise en charge du GPU natif, et le calcul du coefficient PCE b\u00e9n\u00e9ficie \u00e9norm\u00e9ment des c\u0153urs de tenseurs GPU.<\/li>\n<li><strong>Inf\u00e9rence bay\u00e9sienne&nbsp;:<\/strong> Utilisez <strong>Jax + Bamojax<\/strong>. L'approche MCMC parall\u00e8le par lots document\u00e9e par Schmal &amp; M\u00e4der 2026 fournit \u00e0 la fois des gains d'acc\u00e9l\u00e9ration (gradients GPU) et de pr\u00e9cision (am\u00e9lioration de 5,8 % avec un ensemble 1\/3).<\/li>\n<li><strong>Mod\u00e8les personnalis\u00e9s avec calcul lourd&nbsp;:<\/strong> Utilisez <strong>Numba <code>@cuda.jit<\/code><\/strong>. Comme le post 367 l'a d\u00e9montr\u00e9, NUMBA vous donne un acc\u00e8s GPU sans r\u00e9\u00e9criture en C++, et Askar et al. 2024 a confirm\u00e9 qu'il surpassait CUPY lorsque le transfert de donn\u00e9es est minime.<\/li>\n<\/ul>\n<hr>\n<h2>Prochaines \u00e9tapes<\/h2>\n<p>Si vous d\u00e9butez dans le calcul acc\u00e9l\u00e9r\u00e9 par GPU, commencez par POST 367 \"Programmation du noyau GPU pour la simulation physique personnalis\u00e9e\" pour comprendre le paysage CUPY\/Numba\/GPU. Appliquez ensuite ce que vous avez appris ici aux m\u00e9thodes UQ couvertes par les m\u00e9thodes post-537 \"Monte Carlo UQ\" et post 479 \"Quantification de l'incertitude et analyse de sensibilit\u00e9\".<\/p>\n<p>La pile UQ acc\u00e9l\u00e9r\u00e9e par GPU est suffisamment mature pour une utilisation en production. Le support CUDA natif de PyGPC, la diff\u00e9renciation automatique de Jax et la compilation JIT de Numba ont tous des interfaces et des communaut\u00e9s actives bien document\u00e9es. Commencez par une course pilote (10&nbsp;000 \u00e0 50&nbsp;000 \u00e9chantillons) sur votre GPU pour mesurer l'acc\u00e9l\u00e9ration, puis passer aux volumes de production.<\/p>\n<hr>\n<h2>Guides connexes<\/h2>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-kernel-programming-custom-physics-simulation\/\" target=\"_blank\" rel=\"nofollow noopener\">Programmation du noyau GPU pour la simulation physique personnalis\u00e9e<\/a> CUPY, NUMBA et GPU KERNELS \u00e0 un niveau de base<\/li>\n<li><a href=\"https:\/\/matforge.org\/monte-carlo-uhq-methods-lhs-sobol-quasi\/\" target=\"_blank\" rel=\"nofollow noopener\">M\u00e9thodes UQ de Monte Carlo Hypercube, Sobol et Quasi-Monte Carlo<\/a> - M\u00e9thodes MC, LHS et QMC bas\u00e9es sur CPU (condition pr\u00e9alable aux mod\u00e8les d'acc\u00e9l\u00e9ration GPU)<\/li>\n<li><a href=\"https:\/\/matforge.org\/uncertainty-quantification-sensitivity-analysis-scientific-simulations\/\" target=\"_blank\" rel=\"nofollow noopener\">Quantification de l'incertitude et analyse de sensibilit\u00e9 pour les simulations scientifiques<\/a> \u2014 Aper\u00e7u large de l'UQ, y compris PCE, la sensibilit\u00e9 SOBOL et l'\u00e9cosyst\u00e8me Python UQ<\/li>\n<li><a href=\"https:\/\/matforge.org\/benchmarking-scientific-python-libraries-performance-accuracy\/\" target=\"_blank\" rel=\"nofollow noopener\">Biblioth\u00e8ques scientifiques Python de r\u00e9f\u00e9rence&nbsp;: performances&nbsp;&amp;&nbsp;; Pr\u00e9cision<\/a> : mod\u00e8les d'analyse comparative des performances que vous pouvez appliquer \u00e0 la comparaison GPU UQ<\/li>\n<\/ul>\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>Cl\u00e9s \u00e0 emporter L&rsquo;acc\u00e9l\u00e9ration du GPU offre une acc\u00e9l\u00e9ration de 10 \u00e0 1&nbsp;000&nbsp;\u00d7 pour l&rsquo;\u00e9chantillonnage par lots de Monte&nbsp;Carlo par rapport aux approches CPU uniquement. pygpc est actuellement la seule biblioth\u00e8que Python UQ avec une prise en charge GPU native (CUDA) pour le calcul PCE. Numba @cuda.jit surpasse CUPY pour les t\u00e2ches de calcul lourde [&hellip;]<\/p>\n","protected":false,"raw":""},"author":6,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"fr_FR","_original_post":"https:\/\/matforge.org\/?p=1072","iawp_total_views":0,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1206","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>Quantification de l&#039;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&#039;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU - matforge.org<\/title>\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\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Quantification de l&#039;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&#039;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU - matforge.org\" \/>\n<meta property=\"og:description\" content=\"Reading Time:  10 minutesCl\u00e9s \u00e0 emporter L&rsquo;acc\u00e9l\u00e9ration du GPU offre une acc\u00e9l\u00e9ration de 10 \u00e0 1&nbsp;000&nbsp;\u00d7 pour l&rsquo;\u00e9chantillonnage par lots de Monte&nbsp;Carlo par rapport aux approches CPU uniquement. pygpc est actuellement la seule biblioth\u00e8que Python UQ avec une prise en charge GPU native (CUDA) pour le calcul PCE. Numba @cuda.jit surpasse CUPY pour les t\u00e2ches de calcul lourde [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/\" \/>\n<meta property=\"og:site_name\" content=\"matforge.org\" \/>\n<meta property=\"article:published_time\" content=\"2026-08-21T14:28:54+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png\" \/>\n<meta name=\"author\" content=\"steven\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"steven\" \/>\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\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\"},\"author\":{\"name\":\"steven\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\"},\"headline\":\"Quantification de l&rsquo;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&rsquo;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU\",\"datePublished\":\"2026-08-21T14:28:54+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\"},\"wordCount\":2805,\"commentCount\":0,\"image\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/github.com\\\/nvidia\\\/warp\\\/raw\\\/main\\\/docs\\\/images\\\/warp_overview.png\",\"articleSection\":[\"Simulation &amp; Projets de mod\u00e9lisation\"],\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\",\"name\":\"Quantification de l'incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l'\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU - matforge.org\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/github.com\\\/nvidia\\\/warp\\\/raw\\\/main\\\/docs\\\/images\\\/warp_overview.png\",\"datePublished\":\"2026-08-21T14:28:54+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\",\"url\":\"https:\\\/\\\/github.com\\\/nvidia\\\/warp\\\/raw\\\/main\\\/docs\\\/images\\\/warp_overview.png\",\"contentUrl\":\"https:\\\/\\\/github.com\\\/nvidia\\\/warp\\\/raw\\\/main\\\/docs\\\/images\\\/warp_overview.png\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/fr\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Quantification de l&#8217;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&#8217;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU\"}]},{\"@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\\\/8f690fb596d657b12994b83caa788f03\",\"name\":\"steven\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g\",\"caption\":\"steven\"},\"url\":\"https:\\\/\\\/matforge.org\\\/author\\\/steven\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Quantification de l'incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l'\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU - matforge.org","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\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","og_locale":"fr_FR","og_type":"article","og_title":"Quantification de l'incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l'\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU - matforge.org","og_description":"Reading Time:  10 minutesCl\u00e9s \u00e0 emporter L&rsquo;acc\u00e9l\u00e9ration du GPU offre une acc\u00e9l\u00e9ration de 10 \u00e0 1&nbsp;000&nbsp;\u00d7 pour l&rsquo;\u00e9chantillonnage par lots de Monte&nbsp;Carlo par rapport aux approches CPU uniquement. pygpc est actuellement la seule biblioth\u00e8que Python UQ avec une prise en charge GPU native (CUDA) pour le calcul PCE. Numba @cuda.jit surpasse CUPY pour les t\u00e2ches de calcul lourde [&hellip;]","og_url":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","og_site_name":"matforge.org","article_published_time":"2026-08-21T14:28:54+00:00","og_image":[{"url":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png","type":"","width":"","height":""}],"author":"steven","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"steven","Dur\u00e9e de lecture estim\u00e9e":"16 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/"},"author":{"name":"steven","@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03"},"headline":"Quantification de l&rsquo;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&rsquo;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU","datePublished":"2026-08-21T14:28:54+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/"},"wordCount":2805,"commentCount":0,"image":{"@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage"},"thumbnailUrl":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png","articleSection":["Simulation &amp; Projets de mod\u00e9lisation"],"inLanguage":"fr-FR","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","url":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","name":"Quantification de l'incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l'\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU - matforge.org","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"primaryImageOfPage":{"@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage"},"image":{"@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage"},"thumbnailUrl":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png","datePublished":"2026-08-21T14:28:54+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03"},"breadcrumb":{"@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage","url":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png","contentUrl":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png"},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/fr\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/"},{"@type":"ListItem","position":2,"name":"Quantification de l&#8217;incertitude acc\u00e9l\u00e9r\u00e9e par GPU\u00a0: mise \u00e0 l&#8217;\u00e9chelle des m\u00e9thodes de Monte\u00a0Carlo et PCE sur GPU"}]},{"@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\/8f690fb596d657b12994b83caa788f03","name":"steven","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g","caption":"steven"},"url":"https:\/\/matforge.org\/author\/steven\/"}]}},"_links":{"self":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1206","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\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/comments?post=1206"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1206\/revisions"}],"predecessor-version":[{"id":1384,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1206\/revisions\/1384"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=1206"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=1206"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=1206"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}