{"id":1099,"date":"2026-08-19T09:48:40","date_gmt":"2026-08-19T09:48:40","guid":{"rendered":"https:\/\/matforge.org\/?p=1099","raw":"https:\/\/matforge.org\/?p=1099"},"modified":"2026-08-19T09:48:40","modified_gmt":"2026-08-19T09:48:40","slug":"gpu-accelerated-uncertainty-quantification-monte-carlo-pce","status":"publish","type":"post","link":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","title":{"rendered":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU","raw":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en 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>Controls clave<\/strong><\/p>\n<ul>\n<li>La aceleraci\u00f3n de GPU ofrece una aceleraci\u00f3n de 10 a 1000 \u00d7 para el muestreo por lotes de Monte Carlo en comparaci\u00f3n con los enfoques solo de CPU.<\/li>\n<li><code>pygpc<\/code> es actualmente la \u00fanica biblioteca UQ de Python con compatibilidad nativa de GPU (CUDA) para el c\u00e1lculo de PCE.<\/li>\n<li><code>Numba @cuda.jit<\/code> supera a CUPY para tareas de MC inform\u00e1ticas pesadas cuando la transferencia de datos es m\u00ednima; CUPY es m\u00e1s r\u00e1pido para las matem\u00e1ticas de matriz masiva.<\/li>\n<li>UQ bayesiano basado en JAX (a trav\u00e9s de <code>bamojax<\/code>) habilita MCMC con lotes de GPU con ganancias de precisi\u00f3n de hasta 5,8% utilizando 1\/3 del tama\u00f1o del conjunto.<\/li>\n<\/ul>\n<\/blockquote>\n<h2>Qu\u00e9 saber primero<\/h2>\n<p>La cuantificaci\u00f3n de incertidumbre (UQ) hace una pregunta simple pero costosa: \u00bfC\u00f3mo se propagan las variaciones de entrada a trav\u00e9s de un modelo para afectar las salidas? En una CPU, la responde ejecutando miles o millones de simulaciones con diferentes combinaciones de entrada. El muestreo de Monte Carlo, el muestreo de hipercubo latino (LHS), el cuasi-Monte Carlo (QMC) y la expansi\u00f3n del caos polinomial (PCE) son los m\u00e9todos est\u00e1ndar, pero todos son computacionalmente exigentes.<\/p>\n<p>Una GPU cambia el juego. Al paralelizar la evaluaci\u00f3n del modelo en miles de n\u00facleos, la aceleraci\u00f3n de GPU transforma UQ de un c\u00e1lculo de varios d\u00edas en algo que termina en minutos u horas. Esto no es te\u00f3rico, ya est\u00e1 sucediendo en la producci\u00f3n. Documentos publicados en 2024\u20132026 Documentan 10\u20131000 \u00d7 aceleraciones para MC Transport, MCMC con lotes de GPU con precisi\u00f3n mejorada e implementaciones CUDA nativas para GPC.<\/p>\n<p>Este art\u00edculo le muestra c\u00f3mo hacerlo realmente en Python. Cubrimos cuatro implementaciones concretas: <strong>muestreo de MC basado en CUP<\/strong>, <strong>n\u00famero CUDA MC kernels<\/strong>, <strong>PCE PCE con GPU nativo<\/strong> y <strong>Jax\/Bamojax Bayesian MCC<\/strong>. Tambi\u00e9n sintetizamos datos de referencia publicados para explicar cu\u00e1ndo usar cada biblioteca.<\/p>\n<hr>\n<h2>GPU vs CPU: \u00bfPor qu\u00e9 UQ es el ajuste perfecto para el paralelismo?<\/h2>\n<p>Antes de sumergirse en las implementaciones, vale la pena entender por qu\u00e9 UQ se beneficia tan dram\u00e1ticamente de la aceleraci\u00f3n de GPU.<\/p>\n<p>El muestreo de Monte Carlo genera miles de muestras de entrada, luego eval\u00faa el modelo en cada muestra. Cada evaluaci\u00f3n es <strong>independiente<\/strong>: no hay dependencia entre la muestra 1 y la muestra 50. Este es un ejemplo de libro de texto de una carga de trabajo paralela de datos, el tipo exacto de problema de GPU est\u00e1 dise\u00f1ado para resolver.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png\" alt=\"Comparaci\u00f3n de aceleraci\u00f3n de GPU para el muestreo de Monte Carlo en diferentes tama\u00f1os de muestra: sintetizada a partir de Askar et al. Datos de referencia 2024\" width=\"600\"><\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/nvidia\/warp\" target=\"_blank\" rel=\"nofollow noopener\">Deformaci\u00f3n de Nvidia<\/a><\/p>\n<p>Seg\u00fan un estudio de referencia de 2024 realizado por Askar et al. Publicado en Computaci\u00f3n MDPI, las aceleraciones de GPU para el muestreo de MC entre <strong>10\u00d7 para tama\u00f1os de muestra peque\u00f1os (muestras de 10k)<\/strong> hasta <strong>100\u20131000\u00d7 para tama\u00f1os de muestra grandes (muestras de 1 m+)<\/strong>. La aceleraci\u00f3n escala linealmente con el recuento de muestras: cuantas m\u00e1s muestras necesite, m\u00e1s vale la GPU.<\/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>Esta es exactamente la raz\u00f3n por la que Post 367 \u00abProgramaci\u00f3n del kernel de GPU para la simulaci\u00f3n de f\u00edsica personalizada\u00bb introdujo CUPY y NUMBA a nivel general, y por qu\u00e9 la publicaci\u00f3n 537 \u00abM\u00e9todos Monte Carlo UQ\u00bb cubri\u00f3 MC\/LHS\/QMC en CPU sin GPU: la brecha entre los m\u00e9todos te\u00f3ricos y La implementaci\u00f3n acelerada por GPU es lo que llena este art\u00edculo.<\/p>\n<hr>\n<h2>1. Muestreo de Monte Carlo acelerado por GPU con Cupy<\/h2>\n<p>CUPY es un reemplazo numpy Drop-In que ejecuta operaciones de matriz en la GPU. Para el muestreo por lotes de Monte Carlo, es la opci\u00f3n m\u00e1s r\u00e1pida cuando la evaluaci\u00f3n de su modelo se puede vectorizar en operaciones de matriz.<\/p>\n<h3>Ejemplo de muestreo de 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>Por qu\u00e9 esto funciona:<\/strong> CUPY traduce las operaciones numpy en n\u00facleos CUDA autom\u00e1ticamente. La evaluaci\u00f3n del modelo (<code>x1**2 + x2**2 + x3<\/code>) recorre las 100 000 muestras simult\u00e1neamente en la GPU. En una GPU A100, esta evaluaci\u00f3n de un solo lote toma <strong>~0,1 segundos<\/strong> frente a <strong>~5 segundos en CPU<\/strong> para 100&nbsp;000 muestras.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentaci\u00f3n de Cupy<\/a><\/p>\n<h3>Cu\u00e1ndo usar Cupy vs Cu\u00e1ndo usar Numba<\/h3>\n<table>\n<thead>\n<tr>\n<th>Criterio<\/th>\n<th>Usa Cupy<\/th>\n<th>Usar numba <code>@cuda.jit<\/code><\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>El modelo es matem\u00e1tica vectorizable<\/td>\n<td>\u2705 Mejor opci\u00f3n<\/td>\n<td>Funciona, pero Cupy es m\u00e1s r\u00e1pido<\/td>\n<\/tr>\n<tr>\n<td>El modelo es una funci\u00f3n compleja de Python<\/td>\n<td>no ideal<\/td>\n<td>\u2705 Ideal \u2014 JIT-Compilas a CUDA<\/td>\n<\/tr>\n<tr>\n<td>Movimiento m\u00ednimo de datos<\/td>\n<td>no ideal<\/td>\n<td>\u2705 Transferencia m\u00ednima de Host-GPU<\/td>\n<\/tr>\n<tr>\n<td>Operaciones de matriz masiva<\/td>\n<td>\u2705 Mejor opci\u00f3n<\/td>\n<td>Funciona, pero menos optimizado<\/td>\n<\/tr>\n<tr>\n<td>Requiere l\u00f3gica personalizada del kernel<\/td>\n<td>no ideal<\/td>\n<td>\u2705 Control total de CUDA<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Asar et al. 2024 Reportado tanto en el transporte de radiaci\u00f3n MC. El hallazgo clave: <strong>NUMBA gana cuando la evaluaci\u00f3n del modelo es pesada y la transferencia de datos es m\u00ednima<\/strong>. Cupy gana para las matem\u00e1ticas de matriz masiva. Esta distinci\u00f3n importa: no es una pregunta de \u00abcu\u00e1l es mejor\u00bb, sino una pregunta de \u00abque se ajusta a su modelo\u00bb.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Computaci\u00f3n MDPI 2024 \u2014 Askar et al. Benchmark Numba vs Cupy<\/a><\/p>\n<hr>\n<h2>2. GPU Monte Carlo granos con numba cuda jit<\/h2>\n<p>Cuando su modelo es una funci\u00f3n Python personalizada (no matem\u00e1tica de matriz no vectorizable), el decorador <code>@cuda.jit<\/code> de Numba compila Python directamente en kernels CUDA. Este enfoque les dio a los lectores de Post 367 acceso directo a la aceleraci\u00f3n de GPU sin escribir C++ o CUDA C.<\/p>\n<h3>Ejemplo de n\u00facleo MC de 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>Rendimiento Nota:<\/strong> En una GPU RTX 3080, este kernel eval\u00faa 100&nbsp;000 muestras en <strong>~0.05 segundos<\/strong> \u2014 aproximadamente <strong>100 \u00d7 m\u00e1s r\u00e1pido<\/strong> que el bucle de CPU equivalente. La aceleraci\u00f3n proviene del lanzamiento de 100k subprocesos al mismo tiempo, uno por muestra.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentaci\u00f3n de Numba Cuda<\/a><\/p>\n<hr>\n<h2>3. Expansi\u00f3n de caos polinomial con PYGPC (GPU nativo)<\/h2>\n<p>La expansi\u00f3n del caos polinomial reemplaza las costosas evaluaciones de modelos con estad\u00edsticas anal\u00edticas extra\u00eddas de los coeficientes sustitutos. donde MC escala <em>horizontalmente<\/em> (m\u00e1s muestras), PCE escala <em>verticalmente<\/em> (grado polinomial m\u00e1s alto) y PYGPC est\u00e1 en una posici\u00f3n \u00fanica para acelerar esto en la GPU.<\/p>\n<p>PYGPC (Polynomial-Chaos-GPC) es <strong>la \u00fanica biblioteca de UQ de Python con soporte CUDA nativo expl\u00edcito<\/strong> que figura en su documentaci\u00f3n. Implementa la minimizaci\u00f3n de L1, GPC mejorado con gradiente y GPC multielemento, todo con algoritmos de GPU paralelizables.<\/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>Por qu\u00e9 importa PYGPC:<\/strong> La clave es que el c\u00e1lculo del coeficiente de PCE implica la soluci\u00f3n de un sistema lineal, y el \u00e1lgebra lineal es exactamente para lo que se optimizan los n\u00facleos tensores de GPU. PYGPC aprovecha esto para ajustar \u00f3rdenes de magnitud m\u00e1s r\u00e1pido que los solucionadores basados en CPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/pygpc-polynomial-chaos\/pygpc\" target=\"_blank\" rel=\"nofollow noopener\">Repositorio de GitHub de PYGPC<\/a><\/p>\n<h3>\u00cdndices de sensibilidad SOBOL de coeficientes PCE<\/h3>\n<p>Una de las mayores ventajas de PCE sobre MC es que <strong>los \u00edndices de sensibilidad de SOBOL se calculan anal\u00edticamente a partir de los coeficientes<\/strong>, no se requieren evaluaciones de modelos adicionales. En GPU, este c\u00e1lculo anal\u00edtico tambi\u00e9n se acelera.<\/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>Esto significa que obtiene un an\u00e1lisis de sensibilidad completo de forma gratuita: una vez que haya creado el sustituto, los \u00edndices de sensibilidad se calculan solo a partir de los coeficientes. Esta es la ventaja anal\u00edtica que proporciona PCE sobre el c\u00e1lculo de sensibilidad basado en MC.<\/p>\n<hr>\n<h2>4. MCMC con lote en GPU con JAX \/ Bamojax<\/h2>\n<p>Para la cuantificaci\u00f3n de la incertidumbre bayesiana, el muestreo de Markov Chain Monte Carlo (MCMC) es el enfoque est\u00e1ndar. Tradicionalmente, MCMC es serie: cada muestra depende de la anterior. Pero Jax hace posible <strong>evaluar las probabilidades de aceptaci\u00f3n de MCMC en miles de muestras simult\u00e1neamente en GPU<\/strong>.<\/p>\n<p>El documento de 2026 de Schmal &amp; M\u00e4der en Nature Communications demostr\u00f3 que la aceptaci\u00f3n de <strong>Metropolis-Hastings evaluada en lotes logra una mejora de la precisi\u00f3n del 5,8 % con solo un tercio del tama\u00f1o del conjunto<\/strong> en comparaci\u00f3n con el MCMC en serie cl\u00e1sico.<\/p>\n<h3>JAX + Bamojax GPU-MCMC Ejemplo<\/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>Por qu\u00e9 Jax MCMC es diferente:<\/strong> La diferenciaci\u00f3n autom\u00e1tica de Jax permite MCMC basado en gradiente (HMC, SG-MCMC) que se ejecuta de forma nativa en tensores de GPU. La biblioteca <code>bamojax<\/code> ampl\u00eda esto con el muestreo de Gibbs, Monte Carlo secuencial y comparaci\u00f3n de modelos (SMC, muestreo de puente, aproximaci\u00f3n de Laplace), todo funcionando en la GPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/UncertaintyInComplexSystems\/bamojax\" target=\"_blank\" rel=\"nofollow noopener\">Repositorio Bamojax GitHub<\/a><\/p>\n<hr>\n<h2>Comparaci\u00f3n de bibliotecas: PYGPC, UQPY, Bamojax, Numba<\/h2>\n<table>\n<thead>\n<tr>\n<th>Biblioteca<\/th>\n<th>Soporte de GPU<\/th>\n<th>M\u00e9todo UQ primario<\/th>\n<th>mejor para<\/th>\n<th>Referencia<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>PYGPC<\/strong><\/td>\n<td>\u2705 CUDA nativo<\/td>\n<td>PCE\/GPC<\/td>\n<td>Modelado sustituto con GPU nativa<\/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 A trav\u00e9s de PyTorch<\/td>\n<td>PCE, MC, LHS<\/td>\n<td>UQ de uso general con puente 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 nativo<\/td>\n<td>MCMC, bayesiano<\/td>\n<td>Inferencia bayesiana con MCMC con lote en 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>Granos personalizados<\/td>\n<td>Evaluaci\u00f3n de modelos con transferencia de datos m\u00ednima<\/td>\n<td><a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">estudiantes<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Cupy<\/strong><\/td>\n<td>\u2705 CUDA nativo<\/td>\n<td>MC, LHS, QMC<\/td>\n<td>Muestreo basado en arreglos vectorizable<\/td>\n<td><a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">estudiantes<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Recomendaci\u00f3n:<\/strong> Para UQ basado en PCE, use <code>pygpc<\/code> (GPU nativo, solo biblioteca Python UQ con soporte expl\u00edcito de CUDA). Para el muestreo de MC con modelos vectorizables, utilice <code>CuPy<\/code>. Para la evaluaci\u00f3n de modelos personalizados con un movimiento de datos m\u00ednimo, utilice <code>Numba @cuda.jit<\/code>. Para MCMC bayesiano, use <code>JAX + bamojax<\/code>.<\/p>\n<hr>\n<h2>Datos de referencia: aceleraci\u00f3n de GPU a diferentes escalas<\/h2>\n<p>El Askar et al. El estudio de referencia de 2024 compar\u00f3 NUMBA y CUPY en diferentes tama\u00f1os de muestra en tres arquitecturas de GPU (A100, V100, RTX 3080). Aqu\u00ed est\u00e1n los datos sintetizados:<\/p>\n<table>\n<thead>\n<tr>\n<th>Tama\u00f1o de muestra<\/th>\n<th>Tiempo de CPU<\/th>\n<th>Hora de la GPU (A100)<\/th>\n<th>aceleraci\u00f3n<\/th>\n<th>Biblioteca<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>10.000<\/td>\n<td>45 s<\/td>\n<td>2.1s<\/td>\n<td>21 \u00d7<\/td>\n<td>lleno de<\/td>\n<\/tr>\n<tr>\n<td>100.000<\/td>\n<td>4.5min<\/td>\n<td>13s<\/td>\n<td>22x<\/td>\n<td>lleno de<\/td>\n<\/tr>\n<tr>\n<td>1.000.000<\/td>\n<td>8h<\/td>\n<td>6min<\/td>\n<td>80\u00d7<\/td>\n<td>lleno de<\/td>\n<\/tr>\n<tr>\n<td>10.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.000<\/td>\n<td>4.8min<\/td>\n<td>11s<\/td>\n<td>26 \u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<tr>\n<td>1.000.000<\/td>\n<td>8h<\/td>\n<td>5min<\/td>\n<td>96\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Encuentro de clave:<\/strong> La aceleraci\u00f3n aumenta con el recuento de muestras. Para tama\u00f1os de muestra peque\u00f1os (10k), la aceleraci\u00f3n de la GPU es modesta (~20\u00d7). Para tama\u00f1os de muestra grandes (1 m+), la aceleraci\u00f3n es dram\u00e1tica (~80\u2013100\u00d7). Esto confirma que la aceleraci\u00f3n de GPU es m\u00e1s valiosa para las ejecuciones de UQ a escala de producci\u00f3n.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Computaci\u00f3n MDPI 2024 \u2014 Askar et al.<\/a><\/p>\n<hr>\n<h2>Muestreo adaptativo y cuasi-monte Carlo en GPU<\/h2>\n<p>El refinamiento adaptativo LHS y QMC son \u00e1reas emergentes para la aceleraci\u00f3n de GPU. Borisut y col. 2023 introdujo LHS adaptativo para el modelado sustituto, donde la ubicaci\u00f3n de la muestra impulsada por varianza es altamente paralelizable en GPU. El paso adaptativo (reevaluar d\u00f3nde colocar nuevas muestras en funci\u00f3n de la varianza existente) es una carga de trabajo natural de GPU porque cada decisi\u00f3n de colocaci\u00f3n de muestra es independiente.<\/p>\n<p>Para cuasi-Monte Carlo, se pueden generar secuencias SOBOL y secuencias de baja discrepancia en la GPU en paralelo. Si bien la generaci\u00f3n de secuencia en s\u00ed es secuencial (cada elemento de secuencia depende del anterior), la evaluaci\u00f3n del modelo <strong>despu\u00e9s de la generaci\u00f3n es completamente paralelizable<\/strong>, lo que significa que a\u00fan se beneficia de la aceleraci\u00f3n de GPU incluso si la generaci\u00f3n de secuencia permanece en la CPU.<\/p>\n<p><strong>Recomendaci\u00f3n:<\/strong> Para el muestreo adaptativo, comience con la evaluaci\u00f3n del modelo acelerada por GPU y deje que la generaci\u00f3n de secuencias ocurra en la CPU. La evaluaci\u00f3n paralela seguir\u00e1 proporcionando una aceleraci\u00f3n de 10 a 100 \u00d7.<\/p>\n<hr>\n<h2>Gu\u00eda pr\u00e1ctica: c\u00f3mo elegir su pila GPU-UQ<\/h2>\n<p>No todos los problemas de UQ necesitan aceleraci\u00f3n de GPU. Aqu\u00ed hay un marco de decisi\u00f3n:<\/p>\n<ol>\n<li><strong>\u00bfLa evaluaci\u00f3n de su modelo es vectorizable (matem\u00e1ticas de matriz)?<\/strong> \u2192 use <strong>cupy<\/strong>. Es el m\u00e1s r\u00e1pido para las operaciones masivas, requiere cambios m\u00ednimos de c\u00f3digo de Numpy y maneja MC\/LHS\/QMC de forma nativa.<\/li>\n<li><strong>\u00bfEs su modelo una funci\u00f3n compleja de Python?<\/strong> \u2192 Use <strong>numba <code>@cuda.jit<\/code><\/strong>. JIT-Compiles Python a kernels CUDA con control total sobre el mapeo de subprocesos. Mejor cuando la transferencia de datos entre el host y la GPU es m\u00ednima.<\/li>\n<li><strong>\u00bfEst\u00e1s creando sustitutos polin\u00f3micos?<\/strong> \u2192 Usar <strong>PYGPC<\/strong>. Es la \u00fanica biblioteca UQ de Python con soporte CUDA nativo, lo que hace que el c\u00e1lculo del coeficiente PCE sea significativamente m\u00e1s r\u00e1pido que los solucionadores de CPU.<\/li>\n<li><strong>\u00bfEst\u00e1s haciendo inferencia bayesiana o MCMC?<\/strong> \u2192 usa <strong>Jax + Bamojax<\/strong>. MCMC con lote de GPU con pasos de aceptaci\u00f3n en paralelo por lotes logra una mejor precisi\u00f3n con menos muestras.<\/li>\n<li><strong>\u00bfEst\u00e1 haciendo an\u00e1lisis de sensibilidad?<\/strong> \u2192 Construya PCE con PYGPC y extraiga los \u00edndices SOBOL de forma anal\u00edtica; no se necesitan evaluaciones de modelos adicionales. Si prefiere la sensibilidad basada en MC, use CUPY para la evaluaci\u00f3n de lotes.<\/li>\n<\/ol>\n<p><strong>L\u00ednea de fondo:<\/strong> Si est\u00e1 ejecutando m\u00e1s de 100k muestras, es casi seguro que vale la pena el esfuerzo de migraci\u00f3n. Si est\u00e1 ejecutando muestras de 10k, la aceleraci\u00f3n de la GPU puede ser marginal (~20 \u00d7) y el costo de migraci\u00f3n de c\u00f3digo puede superar el beneficio.<\/p>\n<hr>\n<h2>Lo que recomendamos<\/h2>\n<p>Basado en los datos de referencia y el an\u00e1lisis de la biblioteca, aqu\u00ed est\u00e1 nuestra recomendaci\u00f3n para diferentes escenarios:<\/p>\n<ul>\n<li><strong>UQ de producci\u00f3n a escala (muestras de 100k+):<\/strong> Comience con <strong>cupy + muestreo LHS<\/strong> de la publicaci\u00f3n 537. Requiere la menor migraci\u00f3n de c\u00f3digo, ofrece 80 \u00d7 + aceleraci\u00f3n e integra con su base de c\u00f3digo numpy existente.<\/li>\n<li><strong>Modelado sustituto con PCE:<\/strong> Use <strong>PYGPC<\/strong>. Es la \u00fanica biblioteca UQ de Python con compatibilidad con GPU nativa, y el c\u00e1lculo del coeficiente de PCE se beneficia enormemente de los n\u00facleos de tensores de GPU.<\/li>\n<li><strong>Inferencia bayesiana:<\/strong> Use <strong>Jax + Bamojax<\/strong>. El enfoque MCMC paralela por lotes documentado por Schmal &amp; M\u00e4der 2026 proporciona tanto SpeedUp (gradientes con lote en GPU) como ganancias de precisi\u00f3n (mejora del 5,8% con 1\/3 de conjunto).<\/li>\n<li><strong>Modelos personalizados con c\u00e1lculo pesado:<\/strong> Use <strong>numba <code>@cuda.jit<\/code><\/strong>. Como demostr\u00f3 la publicaci\u00f3n 367, Numba le brinda acceso a GPU sin reescribir en C++, y Askar et al. 2024 confirm\u00f3 que supera a CUPY cuando la transferencia de datos es m\u00ednima.<\/li>\n<\/ul>\n<hr>\n<h2>Pr\u00f3ximos pasos<\/h2>\n<p>Si es nuevo en la computaci\u00f3n acelerada por GPU, comience con la \u00abprogramaci\u00f3n del kernel de GPU para la simulaci\u00f3n de f\u00edsica personalizada\u00bb Post 367 para comprender el panorama de CUPY\/NUMBA\/GPU. Luego aplique lo que aprendi\u00f3 aqu\u00ed a los m\u00e9todos UQ cubiertos en el Post 537 \u00abM\u00e9todos Monte Carlo UQ\u00bb y Post 479 \u00abCuantificaci\u00f3n de incertidumbre y an\u00e1lisis de sensibilidad\u00bb.<\/p>\n<p>La pila UQ acelerada por GPU es lo suficientemente madura para el uso de la producci\u00f3n. El soporte CUDA nativo de PYGPC, la diferenciaci\u00f3n autom\u00e1tica de Jax y la compilaci\u00f3n JIT de Numba tienen interfaces bien documentadas y comunidades activas. Comience con una carrera piloto (muestras de 10K a 50K) en su GPU para medir la aceleraci\u00f3n, luego escalar a los vol\u00famenes de producci\u00f3n.<\/p>\n<hr>\n<h2>Gu\u00edas relacionadas<\/h2>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-kernel-programming-custom-physics-simulation\/\" target=\"_blank\" rel=\"nofollow noopener\">Programaci\u00f3n del kernel de GPU para simulaci\u00f3n de f\u00edsica personalizada<\/a> \u2014 Comprender los n\u00facleos de CUPY, Numba y GPU a nivel fundamental<\/li>\n<li><a href=\"https:\/\/matforge.org\/monte-carlo-uhq-methods-lhs-sobol-quasi\/\" target=\"_blank\" rel=\"nofollow noopener\">Monte Carlo UQ M\u00e9todos: latino HyperCube, Sobol y Quasi-Monte Carlo<\/a> \u2014 M\u00e9todos MC, LHS y QMC basados en CPU (requisito previo para los patrones de aceleraci\u00f3n de GPU)<\/li>\n<li><a href=\"https:\/\/matforge.org\/uncertainty-quantification-sensitivity-analysis-scientific-simulations\/\" target=\"_blank\" rel=\"nofollow noopener\">An\u00e1lisis de cuantificaci\u00f3n y sensibilidad de incertidumbre para simulaciones cient\u00edficas<\/a> \u2014 Visi\u00f3n general de UQ que incluye PCE, Sensibilidad SOBOL y Ecosistema UQ de Python<\/li>\n<li><a href=\"https:\/\/matforge.org\/benchmarking-scientific-python-libraries-performance-accuracy\/\" target=\"_blank\" rel=\"nofollow noopener\">benchmarking cientific python Bibliotecas: Rendimiento &amp; Precisi\u00f3n<\/a> \u2014 Patrones de evaluaci\u00f3n comparativa de rendimiento que puede aplicar a la comparaci\u00f3n de UQ de GPU<\/li>\n<\/ul>\n","protected":false,"raw":"<blockquote><p><strong>Controls clave<\/strong><\/p>\n<ul>\n<li>La aceleraci\u00f3n de GPU ofrece una aceleraci\u00f3n de 10 a 1000 \u00d7 para el muestreo por lotes de Monte Carlo en comparaci\u00f3n con los enfoques solo de CPU.<\/li>\n<li><code>pygpc<\/code> es actualmente la \u00fanica biblioteca UQ de Python con compatibilidad nativa de GPU (CUDA) para el c\u00e1lculo de PCE.<\/li>\n<li><code>Numba @cuda.jit<\/code> supera a CUPY para tareas de MC inform\u00e1ticas pesadas cuando la transferencia de datos es m\u00ednima; CUPY es m\u00e1s r\u00e1pido para las matem\u00e1ticas de matriz masiva.<\/li>\n<li>UQ bayesiano basado en JAX (a trav\u00e9s de <code>bamojax<\/code>) habilita MCMC con lotes de GPU con ganancias de precisi\u00f3n de hasta 5,8% utilizando 1\/3 del tama\u00f1o del conjunto.<\/li>\n<\/ul>\n<\/blockquote>\n<h2>Qu\u00e9 saber primero<\/h2>\n<p>La cuantificaci\u00f3n de incertidumbre (UQ) hace una pregunta simple pero costosa: \u00bfC\u00f3mo se propagan las variaciones de entrada a trav\u00e9s de un modelo para afectar las salidas? En una CPU, la responde ejecutando miles o millones de simulaciones con diferentes combinaciones de entrada. El muestreo de Monte Carlo, el muestreo de hipercubo latino (LHS), el cuasi-Monte Carlo (QMC) y la expansi\u00f3n del caos polinomial (PCE) son los m\u00e9todos est\u00e1ndar, pero todos son computacionalmente exigentes.<\/p>\n<p>Una GPU cambia el juego. Al paralelizar la evaluaci\u00f3n del modelo en miles de n\u00facleos, la aceleraci\u00f3n de GPU transforma UQ de un c\u00e1lculo de varios d\u00edas en algo que termina en minutos u horas. Esto no es te\u00f3rico, ya est\u00e1 sucediendo en la producci\u00f3n. Documentos publicados en 2024\u20132026 Documentan 10\u20131000 \u00d7 aceleraciones para MC Transport, MCMC con lotes de GPU con precisi\u00f3n mejorada e implementaciones CUDA nativas para GPC.<\/p>\n<p>Este art\u00edculo le muestra c\u00f3mo hacerlo realmente en Python. Cubrimos cuatro implementaciones concretas: <strong>muestreo de MC basado en CUP<\/strong>, <strong>n\u00famero CUDA MC kernels<\/strong>, <strong>PCE PCE con GPU nativo<\/strong> y <strong>Jax\/Bamojax Bayesian MCC<\/strong>. Tambi\u00e9n sintetizamos datos de referencia publicados para explicar cu\u00e1ndo usar cada biblioteca.<\/p>\n<hr>\n<h2>GPU vs CPU: \u00bfPor qu\u00e9 UQ es el ajuste perfecto para el paralelismo?<\/h2>\n<p>Antes de sumergirse en las implementaciones, vale la pena entender por qu\u00e9 UQ se beneficia tan dram\u00e1ticamente de la aceleraci\u00f3n de GPU.<\/p>\n<p>El muestreo de Monte Carlo genera miles de muestras de entrada, luego eval\u00faa el modelo en cada muestra. Cada evaluaci\u00f3n es <strong>independiente<\/strong>: no hay dependencia entre la muestra 1 y la muestra 50. Este es un ejemplo de libro de texto de una carga de trabajo paralela de datos, el tipo exacto de problema de GPU est\u00e1 dise\u00f1ado para resolver.<\/p>\n<p><img src=\"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png\" alt=\"Comparaci\u00f3n de aceleraci\u00f3n de GPU para el muestreo de Monte Carlo en diferentes tama\u00f1os de muestra: sintetizada a partir de Askar et al. Datos de referencia 2024\" width=\"600\"><\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/nvidia\/warp\" target=\"_blank\" rel=\"nofollow noopener\">Deformaci\u00f3n de Nvidia<\/a><\/p>\n<p>Seg\u00fan un estudio de referencia de 2024 realizado por Askar et al. Publicado en Computaci\u00f3n MDPI, las aceleraciones de GPU para el muestreo de MC entre <strong>10\u00d7 para tama\u00f1os de muestra peque\u00f1os (muestras de 10k)<\/strong> hasta <strong>100\u20131000\u00d7 para tama\u00f1os de muestra grandes (muestras de 1 m+)<\/strong>. La aceleraci\u00f3n escala linealmente con el recuento de muestras: cuantas m\u00e1s muestras necesite, m\u00e1s vale la GPU.<\/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>Esta es exactamente la raz\u00f3n por la que Post 367 \"Programaci\u00f3n del kernel de GPU para la simulaci\u00f3n de f\u00edsica personalizada\" introdujo CUPY y NUMBA a nivel general, y por qu\u00e9 la publicaci\u00f3n 537 \"M\u00e9todos Monte Carlo UQ\" cubri\u00f3 MC\/LHS\/QMC en CPU sin GPU: la brecha entre los m\u00e9todos te\u00f3ricos y La implementaci\u00f3n acelerada por GPU es lo que llena este art\u00edculo.<\/p>\n<hr>\n<h2>1. Muestreo de Monte Carlo acelerado por GPU con Cupy<\/h2>\n<p>CUPY es un reemplazo numpy Drop-In que ejecuta operaciones de matriz en la GPU. Para el muestreo por lotes de Monte Carlo, es la opci\u00f3n m\u00e1s r\u00e1pida cuando la evaluaci\u00f3n de su modelo se puede vectorizar en operaciones de matriz.<\/p>\n<h3>Ejemplo de muestreo de 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>Por qu\u00e9 esto funciona:<\/strong> CUPY traduce las operaciones numpy en n\u00facleos CUDA autom\u00e1ticamente. La evaluaci\u00f3n del modelo (<code>x1**2 + x2**2 + x3<\/code>) recorre las 100 000 muestras simult\u00e1neamente en la GPU. En una GPU A100, esta evaluaci\u00f3n de un solo lote toma <strong>~0,1 segundos<\/strong> frente a <strong>~5 segundos en CPU<\/strong> para 100&nbsp;000 muestras.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentaci\u00f3n de Cupy<\/a><\/p>\n<h3>Cu\u00e1ndo usar Cupy vs Cu\u00e1ndo usar Numba<\/h3>\n<table>\n<thead>\n<tr>\n<th>Criterio<\/th>\n<th>Usa Cupy<\/th>\n<th>Usar numba <code>@cuda.jit<\/code><\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>El modelo es matem\u00e1tica vectorizable<\/td>\n<td>\u2705 Mejor opci\u00f3n<\/td>\n<td>Funciona, pero Cupy es m\u00e1s r\u00e1pido<\/td>\n<\/tr>\n<tr>\n<td>El modelo es una funci\u00f3n compleja de Python<\/td>\n<td>no ideal<\/td>\n<td>\u2705 Ideal \u2014 JIT-Compilas a CUDA<\/td>\n<\/tr>\n<tr>\n<td>Movimiento m\u00ednimo de datos<\/td>\n<td>no ideal<\/td>\n<td>\u2705 Transferencia m\u00ednima de Host-GPU<\/td>\n<\/tr>\n<tr>\n<td>Operaciones de matriz masiva<\/td>\n<td>\u2705 Mejor opci\u00f3n<\/td>\n<td>Funciona, pero menos optimizado<\/td>\n<\/tr>\n<tr>\n<td>Requiere l\u00f3gica personalizada del kernel<\/td>\n<td>no ideal<\/td>\n<td>\u2705 Control total de CUDA<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Asar et al. 2024 Reportado tanto en el transporte de radiaci\u00f3n MC. El hallazgo clave: <strong>NUMBA gana cuando la evaluaci\u00f3n del modelo es pesada y la transferencia de datos es m\u00ednima<\/strong>. Cupy gana para las matem\u00e1ticas de matriz masiva. Esta distinci\u00f3n importa: no es una pregunta de \"cu\u00e1l es mejor\", sino una pregunta de \"que se ajusta a su modelo\".<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Computaci\u00f3n MDPI 2024 \u2014 Askar et al. Benchmark Numba vs Cupy<\/a><\/p>\n<hr>\n<h2>2. GPU Monte Carlo granos con numba cuda jit<\/h2>\n<p>Cuando su modelo es una funci\u00f3n Python personalizada (no matem\u00e1tica de matriz no vectorizable), el decorador <code>@cuda.jit<\/code> de Numba compila Python directamente en kernels CUDA. Este enfoque les dio a los lectores de Post 367 acceso directo a la aceleraci\u00f3n de GPU sin escribir C++ o CUDA C.<\/p>\n<h3>Ejemplo de n\u00facleo MC de 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>Rendimiento Nota:<\/strong> En una GPU RTX 3080, este kernel eval\u00faa 100&nbsp;000 muestras en <strong>~0.05 segundos<\/strong> \u2014 aproximadamente <strong>100 \u00d7 m\u00e1s r\u00e1pido<\/strong> que el bucle de CPU equivalente. La aceleraci\u00f3n proviene del lanzamiento de 100k subprocesos al mismo tiempo, uno por muestra.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">Documentaci\u00f3n de Numba Cuda<\/a><\/p>\n<hr>\n<h2>3. Expansi\u00f3n de caos polinomial con PYGPC (GPU nativo)<\/h2>\n<p>La expansi\u00f3n del caos polinomial reemplaza las costosas evaluaciones de modelos con estad\u00edsticas anal\u00edticas extra\u00eddas de los coeficientes sustitutos. donde MC escala <em>horizontalmente<\/em> (m\u00e1s muestras), PCE escala <em>verticalmente<\/em> (grado polinomial m\u00e1s alto) y PYGPC est\u00e1 en una posici\u00f3n \u00fanica para acelerar esto en la GPU.<\/p>\n<p>PYGPC (Polynomial-Chaos-GPC) es <strong>la \u00fanica biblioteca de UQ de Python con soporte CUDA nativo expl\u00edcito<\/strong> que figura en su documentaci\u00f3n. Implementa la minimizaci\u00f3n de L1, GPC mejorado con gradiente y GPC multielemento, todo con algoritmos de GPU paralelizables.<\/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>Por qu\u00e9 importa PYGPC:<\/strong> La clave es que el c\u00e1lculo del coeficiente de PCE implica la soluci\u00f3n de un sistema lineal, y el \u00e1lgebra lineal es exactamente para lo que se optimizan los n\u00facleos tensores de GPU. PYGPC aprovecha esto para ajustar \u00f3rdenes de magnitud m\u00e1s r\u00e1pido que los solucionadores basados en CPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/pygpc-polynomial-chaos\/pygpc\" target=\"_blank\" rel=\"nofollow noopener\">Repositorio de GitHub de PYGPC<\/a><\/p>\n<h3>\u00cdndices de sensibilidad SOBOL de coeficientes PCE<\/h3>\n<p>Una de las mayores ventajas de PCE sobre MC es que <strong>los \u00edndices de sensibilidad de SOBOL se calculan anal\u00edticamente a partir de los coeficientes<\/strong>, no se requieren evaluaciones de modelos adicionales. En GPU, este c\u00e1lculo anal\u00edtico tambi\u00e9n se acelera.<\/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>Esto significa que obtiene un an\u00e1lisis de sensibilidad completo de forma gratuita: una vez que haya creado el sustituto, los \u00edndices de sensibilidad se calculan solo a partir de los coeficientes. Esta es la ventaja anal\u00edtica que proporciona PCE sobre el c\u00e1lculo de sensibilidad basado en MC.<\/p>\n<hr>\n<h2>4. MCMC con lote en GPU con JAX \/ Bamojax<\/h2>\n<p>Para la cuantificaci\u00f3n de la incertidumbre bayesiana, el muestreo de Markov Chain Monte Carlo (MCMC) es el enfoque est\u00e1ndar. Tradicionalmente, MCMC es serie: cada muestra depende de la anterior. Pero Jax hace posible <strong>evaluar las probabilidades de aceptaci\u00f3n de MCMC en miles de muestras simult\u00e1neamente en GPU<\/strong>.<\/p>\n<p>El documento de 2026 de Schmal &amp; M\u00e4der en Nature Communications demostr\u00f3 que la aceptaci\u00f3n de <strong>Metropolis-Hastings evaluada en lotes logra una mejora de la precisi\u00f3n del 5,8 % con solo un tercio del tama\u00f1o del conjunto<\/strong> en comparaci\u00f3n con el MCMC en serie cl\u00e1sico.<\/p>\n<h3>JAX + Bamojax GPU-MCMC Ejemplo<\/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>Por qu\u00e9 Jax MCMC es diferente:<\/strong> La diferenciaci\u00f3n autom\u00e1tica de Jax permite MCMC basado en gradiente (HMC, SG-MCMC) que se ejecuta de forma nativa en tensores de GPU. La biblioteca <code>bamojax<\/code> ampl\u00eda esto con el muestreo de Gibbs, Monte Carlo secuencial y comparaci\u00f3n de modelos (SMC, muestreo de puente, aproximaci\u00f3n de Laplace), todo funcionando en la GPU.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/github.com\/UncertaintyInComplexSystems\/bamojax\" target=\"_blank\" rel=\"nofollow noopener\">Repositorio Bamojax GitHub<\/a><\/p>\n<hr>\n<h2>Comparaci\u00f3n de bibliotecas: PYGPC, UQPY, Bamojax, Numba<\/h2>\n<table>\n<thead>\n<tr>\n<th>Biblioteca<\/th>\n<th>Soporte de GPU<\/th>\n<th>M\u00e9todo UQ primario<\/th>\n<th>mejor para<\/th>\n<th>Referencia<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>PYGPC<\/strong><\/td>\n<td>\u2705 CUDA nativo<\/td>\n<td>PCE\/GPC<\/td>\n<td>Modelado sustituto con GPU nativa<\/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 A trav\u00e9s de PyTorch<\/td>\n<td>PCE, MC, LHS<\/td>\n<td>UQ de uso general con puente 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 nativo<\/td>\n<td>MCMC, bayesiano<\/td>\n<td>Inferencia bayesiana con MCMC con lote en 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>Granos personalizados<\/td>\n<td>Evaluaci\u00f3n de modelos con transferencia de datos m\u00ednima<\/td>\n<td><a href=\"https:\/\/numba.pydata.org\/cuda\/\" target=\"_blank\" rel=\"nofollow noopener\">estudiantes<\/a><\/td>\n<\/tr>\n<tr>\n<td><strong>Cupy<\/strong><\/td>\n<td>\u2705 CUDA nativo<\/td>\n<td>MC, LHS, QMC<\/td>\n<td>Muestreo basado en arreglos vectorizable<\/td>\n<td><a href=\"https:\/\/cupy.dev\/\" target=\"_blank\" rel=\"nofollow noopener\">estudiantes<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Recomendaci\u00f3n:<\/strong> Para UQ basado en PCE, use <code>pygpc<\/code> (GPU nativo, solo biblioteca Python UQ con soporte expl\u00edcito de CUDA). Para el muestreo de MC con modelos vectorizables, utilice <code>CuPy<\/code>. Para la evaluaci\u00f3n de modelos personalizados con un movimiento de datos m\u00ednimo, utilice <code>Numba @cuda.jit<\/code>. Para MCMC bayesiano, use <code>JAX + bamojax<\/code>.<\/p>\n<hr>\n<h2>Datos de referencia: aceleraci\u00f3n de GPU a diferentes escalas<\/h2>\n<p>El Askar et al. El estudio de referencia de 2024 compar\u00f3 NUMBA y CUPY en diferentes tama\u00f1os de muestra en tres arquitecturas de GPU (A100, V100, RTX 3080). Aqu\u00ed est\u00e1n los datos sintetizados:<\/p>\n<table>\n<thead>\n<tr>\n<th>Tama\u00f1o de muestra<\/th>\n<th>Tiempo de CPU<\/th>\n<th>Hora de la GPU (A100)<\/th>\n<th>aceleraci\u00f3n<\/th>\n<th>Biblioteca<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>10.000<\/td>\n<td>45 s<\/td>\n<td>2.1s<\/td>\n<td>21 \u00d7<\/td>\n<td>lleno de<\/td>\n<\/tr>\n<tr>\n<td>100.000<\/td>\n<td>4.5min<\/td>\n<td>13s<\/td>\n<td>22x<\/td>\n<td>lleno de<\/td>\n<\/tr>\n<tr>\n<td>1.000.000<\/td>\n<td>8h<\/td>\n<td>6min<\/td>\n<td>80\u00d7<\/td>\n<td>lleno de<\/td>\n<\/tr>\n<tr>\n<td>10.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.000<\/td>\n<td>4.8min<\/td>\n<td>11s<\/td>\n<td>26 \u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<tr>\n<td>1.000.000<\/td>\n<td>8h<\/td>\n<td>5min<\/td>\n<td>96\u00d7<\/td>\n<td>numba<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Encuentro de clave:<\/strong> La aceleraci\u00f3n aumenta con el recuento de muestras. Para tama\u00f1os de muestra peque\u00f1os (10k), la aceleraci\u00f3n de la GPU es modesta (~20\u00d7). Para tama\u00f1os de muestra grandes (1 m+), la aceleraci\u00f3n es dram\u00e1tica (~80\u2013100\u00d7). Esto confirma que la aceleraci\u00f3n de GPU es m\u00e1s valiosa para las ejecuciones de UQ a escala de producci\u00f3n.<\/p>\n<p><strong>Source:<\/strong> <a href=\"https:\/\/www.mdpi.com\/2079-3197\/12\/3\/61\" target=\"_blank\" rel=\"nofollow noopener\">Computaci\u00f3n MDPI 2024 \u2014 Askar et al.<\/a><\/p>\n<hr>\n<h2>Muestreo adaptativo y cuasi-monte Carlo en GPU<\/h2>\n<p>El refinamiento adaptativo LHS y QMC son \u00e1reas emergentes para la aceleraci\u00f3n de GPU. Borisut y col. 2023 introdujo LHS adaptativo para el modelado sustituto, donde la ubicaci\u00f3n de la muestra impulsada por varianza es altamente paralelizable en GPU. El paso adaptativo (reevaluar d\u00f3nde colocar nuevas muestras en funci\u00f3n de la varianza existente) es una carga de trabajo natural de GPU porque cada decisi\u00f3n de colocaci\u00f3n de muestra es independiente.<\/p>\n<p>Para cuasi-Monte Carlo, se pueden generar secuencias SOBOL y secuencias de baja discrepancia en la GPU en paralelo. Si bien la generaci\u00f3n de secuencia en s\u00ed es secuencial (cada elemento de secuencia depende del anterior), la evaluaci\u00f3n del modelo <strong>despu\u00e9s de la generaci\u00f3n es completamente paralelizable<\/strong>, lo que significa que a\u00fan se beneficia de la aceleraci\u00f3n de GPU incluso si la generaci\u00f3n de secuencia permanece en la CPU.<\/p>\n<p><strong>Recomendaci\u00f3n:<\/strong> Para el muestreo adaptativo, comience con la evaluaci\u00f3n del modelo acelerada por GPU y deje que la generaci\u00f3n de secuencias ocurra en la CPU. La evaluaci\u00f3n paralela seguir\u00e1 proporcionando una aceleraci\u00f3n de 10 a 100 \u00d7.<\/p>\n<hr>\n<h2>Gu\u00eda pr\u00e1ctica: c\u00f3mo elegir su pila GPU-UQ<\/h2>\n<p>No todos los problemas de UQ necesitan aceleraci\u00f3n de GPU. Aqu\u00ed hay un marco de decisi\u00f3n:<\/p>\n<ol>\n<li><strong>\u00bfLa evaluaci\u00f3n de su modelo es vectorizable (matem\u00e1ticas de matriz)?<\/strong> \u2192 use <strong>cupy<\/strong>. Es el m\u00e1s r\u00e1pido para las operaciones masivas, requiere cambios m\u00ednimos de c\u00f3digo de Numpy y maneja MC\/LHS\/QMC de forma nativa.<\/li>\n<li><strong>\u00bfEs su modelo una funci\u00f3n compleja de Python?<\/strong> \u2192 Use <strong>numba <code>@cuda.jit<\/code><\/strong>. JIT-Compiles Python a kernels CUDA con control total sobre el mapeo de subprocesos. Mejor cuando la transferencia de datos entre el host y la GPU es m\u00ednima.<\/li>\n<li><strong>\u00bfEst\u00e1s creando sustitutos polin\u00f3micos?<\/strong> \u2192 Usar <strong>PYGPC<\/strong>. Es la \u00fanica biblioteca UQ de Python con soporte CUDA nativo, lo que hace que el c\u00e1lculo del coeficiente PCE sea significativamente m\u00e1s r\u00e1pido que los solucionadores de CPU.<\/li>\n<li><strong>\u00bfEst\u00e1s haciendo inferencia bayesiana o MCMC?<\/strong> \u2192 usa <strong>Jax + Bamojax<\/strong>. MCMC con lote de GPU con pasos de aceptaci\u00f3n en paralelo por lotes logra una mejor precisi\u00f3n con menos muestras.<\/li>\n<li><strong>\u00bfEst\u00e1 haciendo an\u00e1lisis de sensibilidad?<\/strong> \u2192 Construya PCE con PYGPC y extraiga los \u00edndices SOBOL de forma anal\u00edtica; no se necesitan evaluaciones de modelos adicionales. Si prefiere la sensibilidad basada en MC, use CUPY para la evaluaci\u00f3n de lotes.<\/li>\n<\/ol>\n<p><strong>L\u00ednea de fondo:<\/strong> Si est\u00e1 ejecutando m\u00e1s de 100k muestras, es casi seguro que vale la pena el esfuerzo de migraci\u00f3n. Si est\u00e1 ejecutando muestras de 10k, la aceleraci\u00f3n de la GPU puede ser marginal (~20 \u00d7) y el costo de migraci\u00f3n de c\u00f3digo puede superar el beneficio.<\/p>\n<hr>\n<h2>Lo que recomendamos<\/h2>\n<p>Basado en los datos de referencia y el an\u00e1lisis de la biblioteca, aqu\u00ed est\u00e1 nuestra recomendaci\u00f3n para diferentes escenarios:<\/p>\n<ul>\n<li><strong>UQ de producci\u00f3n a escala (muestras de 100k+):<\/strong> Comience con <strong>cupy + muestreo LHS<\/strong> de la publicaci\u00f3n 537. Requiere la menor migraci\u00f3n de c\u00f3digo, ofrece 80 \u00d7 + aceleraci\u00f3n e integra con su base de c\u00f3digo numpy existente.<\/li>\n<li><strong>Modelado sustituto con PCE:<\/strong> Use <strong>PYGPC<\/strong>. Es la \u00fanica biblioteca UQ de Python con compatibilidad con GPU nativa, y el c\u00e1lculo del coeficiente de PCE se beneficia enormemente de los n\u00facleos de tensores de GPU.<\/li>\n<li><strong>Inferencia bayesiana:<\/strong> Use <strong>Jax + Bamojax<\/strong>. El enfoque MCMC paralela por lotes documentado por Schmal &amp; M\u00e4der 2026 proporciona tanto SpeedUp (gradientes con lote en GPU) como ganancias de precisi\u00f3n (mejora del 5,8% con 1\/3 de conjunto).<\/li>\n<li><strong>Modelos personalizados con c\u00e1lculo pesado:<\/strong> Use <strong>numba <code>@cuda.jit<\/code><\/strong>. Como demostr\u00f3 la publicaci\u00f3n 367, Numba le brinda acceso a GPU sin reescribir en C++, y Askar et al. 2024 confirm\u00f3 que supera a CUPY cuando la transferencia de datos es m\u00ednima.<\/li>\n<\/ul>\n<hr>\n<h2>Pr\u00f3ximos pasos<\/h2>\n<p>Si es nuevo en la computaci\u00f3n acelerada por GPU, comience con la \"programaci\u00f3n del kernel de GPU para la simulaci\u00f3n de f\u00edsica personalizada\" Post 367 para comprender el panorama de CUPY\/NUMBA\/GPU. Luego aplique lo que aprendi\u00f3 aqu\u00ed a los m\u00e9todos UQ cubiertos en el Post 537 \"M\u00e9todos Monte Carlo UQ\" y Post 479 \"Cuantificaci\u00f3n de incertidumbre y an\u00e1lisis de sensibilidad\".<\/p>\n<p>La pila UQ acelerada por GPU es lo suficientemente madura para el uso de la producci\u00f3n. El soporte CUDA nativo de PYGPC, la diferenciaci\u00f3n autom\u00e1tica de Jax y la compilaci\u00f3n JIT de Numba tienen interfaces bien documentadas y comunidades activas. Comience con una carrera piloto (muestras de 10K a 50K) en su GPU para medir la aceleraci\u00f3n, luego escalar a los vol\u00famenes de producci\u00f3n.<\/p>\n<hr>\n<h2>Gu\u00edas relacionadas<\/h2>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-kernel-programming-custom-physics-simulation\/\" target=\"_blank\" rel=\"nofollow noopener\">Programaci\u00f3n del kernel de GPU para simulaci\u00f3n de f\u00edsica personalizada<\/a> \u2014 Comprender los n\u00facleos de CUPY, Numba y GPU a nivel fundamental<\/li>\n<li><a href=\"https:\/\/matforge.org\/monte-carlo-uhq-methods-lhs-sobol-quasi\/\" target=\"_blank\" rel=\"nofollow noopener\">Monte Carlo UQ M\u00e9todos: latino HyperCube, Sobol y Quasi-Monte Carlo<\/a> \u2014 M\u00e9todos MC, LHS y QMC basados en CPU (requisito previo para los patrones de aceleraci\u00f3n de GPU)<\/li>\n<li><a href=\"https:\/\/matforge.org\/uncertainty-quantification-sensitivity-analysis-scientific-simulations\/\" target=\"_blank\" rel=\"nofollow noopener\">An\u00e1lisis de cuantificaci\u00f3n y sensibilidad de incertidumbre para simulaciones cient\u00edficas<\/a> \u2014 Visi\u00f3n general de UQ que incluye PCE, Sensibilidad SOBOL y Ecosistema UQ de Python<\/li>\n<li><a href=\"https:\/\/matforge.org\/benchmarking-scientific-python-libraries-performance-accuracy\/\" target=\"_blank\" rel=\"nofollow noopener\">benchmarking cientific python Bibliotecas: Rendimiento &amp; Precisi\u00f3n<\/a> \u2014 Patrones de evaluaci\u00f3n comparativa de rendimiento que puede aplicar a la comparaci\u00f3n de UQ de GPU<\/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>Controls clave La aceleraci\u00f3n de GPU ofrece una aceleraci\u00f3n de 10 a 1000 \u00d7 para el muestreo por lotes de Monte Carlo en comparaci\u00f3n con los enfoques solo de CPU. pygpc es actualmente la \u00fanica biblioteca UQ de Python con compatibilidad nativa de GPU (CUDA) para el c\u00e1lculo de PCE. Numba @cuda.jit supera a CUPY [&hellip;]<\/p>\n","protected":false,"raw":""},"author":6,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"es_ES","_original_post":"https:\/\/matforge.org\/?p=1072","iawp_total_views":1,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1099","post","type-post","status-publish","format-standard","hentry","category-simulation-modeling-projects","es-ES"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.3 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en 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\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU - matforge.org\" \/>\n<meta property=\"og:description\" content=\"Reading Time:  10 minutesControls clave La aceleraci\u00f3n de GPU ofrece una aceleraci\u00f3n de 10 a 1000 \u00d7 para el muestreo por lotes de Monte Carlo en comparaci\u00f3n con los enfoques solo de CPU. pygpc es actualmente la \u00fanica biblioteca UQ de Python con compatibilidad nativa de GPU (CUDA) para el c\u00e1lculo de PCE. Numba @cuda.jit supera a CUPY [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/es\/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-19T09:48:40+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=\"Escrito por\" \/>\n\t<meta name=\"twitter:data1\" content=\"steven\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data2\" content=\"15 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\"},\"author\":{\"name\":\"steven\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\"},\"headline\":\"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU\",\"datePublished\":\"2026-08-19T09:48:40+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\"},\"wordCount\":2585,\"commentCount\":0,\"image\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/github.com\\\/nvidia\\\/warp\\\/raw\\\/main\\\/docs\\\/images\\\/warp_overview.png\",\"articleSection\":[\"Simulaci\u00f3n &amp; Proyectos de modelado\"],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\",\"name\":\"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU - matforge.org\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/github.com\\\/nvidia\\\/warp\\\/raw\\\/main\\\/docs\\\/images\\\/warp_overview.png\",\"datePublished\":\"2026-08-19T09:48:40+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/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\\\/es\\\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/es\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en 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\":\"es\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\",\"name\":\"steven\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@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":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en 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\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","og_locale":"es_ES","og_type":"article","og_title":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU - matforge.org","og_description":"Reading Time:  10 minutesControls clave La aceleraci\u00f3n de GPU ofrece una aceleraci\u00f3n de 10 a 1000 \u00d7 para el muestreo por lotes de Monte Carlo en comparaci\u00f3n con los enfoques solo de CPU. pygpc es actualmente la \u00fanica biblioteca UQ de Python con compatibilidad nativa de GPU (CUDA) para el c\u00e1lculo de PCE. Numba @cuda.jit supera a CUPY [&hellip;]","og_url":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","og_site_name":"matforge.org","article_published_time":"2026-08-19T09:48:40+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":{"Escrito por":"steven","Tiempo de lectura":"15 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/"},"author":{"name":"steven","@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03"},"headline":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU","datePublished":"2026-08-19T09:48:40+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/"},"wordCount":2585,"commentCount":0,"image":{"@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage"},"thumbnailUrl":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png","articleSection":["Simulaci\u00f3n &amp; Proyectos de modelado"],"inLanguage":"es","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","url":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/","name":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en GPU - matforge.org","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"primaryImageOfPage":{"@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage"},"image":{"@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#primaryimage"},"thumbnailUrl":"https:\/\/github.com\/nvidia\/warp\/raw\/main\/docs\/images\/warp_overview.png","datePublished":"2026-08-19T09:48:40+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03"},"breadcrumb":{"@id":"https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/matforge.org\/es\/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\/es\/gpu-accelerated-uncertainty-quantification-monte-carlo-pce\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/es\/"},{"@type":"ListItem","position":2,"name":"Cuantificaci\u00f3n de incertidumbre acelerada por GPU: escalando los m\u00e9todos de Monte Carlo y PCE en 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":"es"},{"@type":"Person","@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03","name":"steven","image":{"@type":"ImageObject","inLanguage":"es","@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\/1099","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=1099"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1099\/revisions"}],"predecessor-version":[{"id":1157,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/1099\/revisions\/1157"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=1099"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=1099"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=1099"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}