{"id":552,"date":"2026-07-22T08:17:36","date_gmt":"2026-07-22T08:17:36","guid":{"rendered":"https:\/\/matforge.org\/?p=552","raw":"https:\/\/matforge.org\/?p=552"},"modified":"2026-07-22T08:17:36","modified_gmt":"2026-07-22T08:17:36","slug":"hpc-python-workflows-from-laptop-to-supercomputer","status":"publish","type":"post","link":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/","title":{"rendered":"Flujos de trabajo de HPC Python: de una computadora port\u00e1til a una supercomputadora","raw":"Flujos de trabajo de HPC Python: de una computadora port\u00e1til a una supercomputadora"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 10<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><h2>Comida clave<\/h2>\n<ul>\n<li>El c\u00f3digo Python puede ejecutarse en una computadora port\u00e1til y en un sistema HPC grande con la misma l\u00f3gica central cuando el flujo de trabajo usa MPi4PY o DASK correctamente.<\/li>\n<li>La reproducibilidad del medio ambiente es a menudo la parte m\u00e1s dif\u00edcil del trabajo de HPC. Los entornos de Conda, los archivos de bloqueo y los scripts de trabajo ayudan a resolverlo.<\/li>\n<li>El flujo de trabajo tiene tres etapas: prototipo local, paralelizar con MPPI4PY o DASK y enviar trabajos a trav\u00e9s de SLURM, PBS u otro programador.<\/li>\n<li>No vuelva a escribir toda la base de c\u00f3digo para el cl\u00faster. Mantenga estable la l\u00f3gica de simulaci\u00f3n y envu\u00e9lvala con un entorno reproducible y capas de ejecuci\u00f3n en paralelo.<\/li>\n<\/ul>\n<p>Escribes un script de simulaci\u00f3n en tu computadora port\u00e1til. Lo prueba con peque\u00f1os conjuntos de datos. Funciona en minutos. Entonces necesitas miles de n\u00facleos y cientos de gigabytes de RAM para ejecutarlo a escala.<\/p>\n<p>\u00bfReescribes toda la base de c\u00f3digo?<\/p>\n<p>No. El mismo c\u00f3digo de Python que se ejecuta en su computadora port\u00e1til puede ejecutarse en una supercomputadora con cambios m\u00ednimos. La clave no es reescribir. es envolver.<\/p>\n<p>Necesita tres cosas: un entorno reproducible, un modelo de ejecuci\u00f3n en paralelo y un script de env\u00edo de trabajos para el programador de cl\u00fasteres.<\/p>\n<p>Esta gu\u00eda recorre el flujo de trabajo completo desde el prototipo local hasta la implementaci\u00f3n de HPC de producci\u00f3n sin cambiar su l\u00f3gica de simulaci\u00f3n principal.<\/p>\n<h2>El flujo de trabajo de Python de HPC de tres etapas<\/h2>\n<p>La mayor\u00eda de los proyectos de HPC Python siguen el mismo patr\u00f3n de tres etapas, independientemente del dominio cient\u00edfico.<\/p>\n<pre><code>Stage 1 \u2014 Local Prototyping:\n  Laptop \u2192 Jupyter or IDE \u2192 NumPy \/ Pandas \u2192 serial execution\n\nStage 2 \u2014 Parallelization:\n  Same code \u2192 mpi4py or Dask \u2192 parallel execution\n\nStage 3 \u2014 Cluster Deployment:\n  Python script \u2192 Slurm \/ PBS job submission \u2192 distributed compute nodes\n<\/code><\/pre>\n<p>El objetivo es avanzar gradualmente a trav\u00e9s de estas etapas. Comience con una versi\u00f3n local en funcionamiento. Agregue la ejecuci\u00f3n en paralelo solo despu\u00e9s de que la l\u00f3gica sea correcta. Env\u00ede al cl\u00faster solo despu\u00e9s de que funcionen peque\u00f1as pruebas paralelas.<\/p>\n<h2>Etapa 1: Establecer un entorno reproducible<\/h2>\n<p>Antes de escribir c\u00f3digo paralelo, necesita un entorno de desarrollo confiable. Aqu\u00ed es donde muchos flujos de trabajo cient\u00edficos fallan primero.<\/p>\n<h3>Por qu\u00e9 la reproducibilidad es dif\u00edcil para los cl\u00fasteres de HPC<\/h3>\n<p>Los cl\u00fasteres de HPC son sistemas compartidos. Muchos grupos de investigaci\u00f3n utilizan la misma infraestructura y los paquetes de sistemas pueden cambiar con el tiempo. Una simulaci\u00f3n que funciona hoy puede romperse seis meses despu\u00e9s de las actualizaciones del m\u00f3dulo, los cambios del compilador o los cambios en la versi\u00f3n del paquete.<\/p>\n<p>La soluci\u00f3n es la gesti\u00f3n del medio ambiente. Conda se usa com\u00fanmente porque a\u00edsla paquetes del sistema Python y puede administrar dependencias compiladas, as\u00ed como paquetes de Python.<\/p>\n<pre><code class=\"language-bash\"># Create a reproducible environment\nconda create -n my-sim python=3.11 numpy mpi4py dask\n\n# Lock dependencies for reproducibility\nconda env export --no-builds --name my-sim &gt; environment.yml\n\n# Recreate the environment on another machine\nconda env create -n my-sim -f environment.yml\n<\/code><\/pre>\n<p>Un solo archivo de entorno brinda a los colaboradores y futuros usuarios una forma clara de recrear la pila de software. Para una reproducibilidad m\u00e1s estricta, use archivos de bloqueo que anclan cada versi\u00f3n de paquete y de dependencia de compilaci\u00f3n.<\/p>\n<h3>Conda vs Venv: Por qu\u00e9 Conda a menudo gana en HPC<\/h3>\n<p>El <code>venv<\/code> incorporado de Python funciona bien para paquetes de Python puro. Los flujos de trabajo de HPC a menudo dependen de bibliotecas cient\u00edficas compiladas, tiempos de ejecuci\u00f3n de MPI, HDF5, BLAS, CUDA y otros componentes a nivel de sistema.<\/p>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Caracter\u00edstica<\/th>\n<th>ven<\/th>\n<th>condaci\u00f3n<\/th>\n<\/tr>\n<tr>\n<td>Paquetes de Python puro<\/td>\n<td>S\u00ed<\/td>\n<td>S\u00ed<\/td>\n<\/tr>\n<tr>\n<td>Dependencias a nivel de sistema como MPI y HDF5<\/td>\n<td>No<\/td>\n<td>S\u00ed<\/td>\n<\/tr>\n<tr>\n<td>Consistencia multiplataforma<\/td>\n<td>Limitado<\/td>\n<td>Fuerte<\/td>\n<\/tr>\n<tr>\n<td>Paquetes de aceleraci\u00f3n de GPU como CUPY o PyTorch CUDA<\/td>\n<td>Configuraci\u00f3n manual<\/td>\n<td>Configuraci\u00f3n m\u00e1s automatizada<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Conda da reproducibilidad a trav\u00e9s de m\u00e1s de la pila cient\u00edfica. Eso importa cuando se trabaja con MPI4PY porque el entorno de ejecuci\u00f3n de MPI y Python deben ser compatibles tanto en la m\u00e1quina local como en el cl\u00faster.<\/p>\n<h2>Etapa 2: Paralelizaci\u00f3n de su c\u00f3digo Python<\/h2>\n<p>Una vez que la versi\u00f3n local funciona, el siguiente paso es la paralelizaci\u00f3n. En los flujos de trabajo de Python HPC, dos herramientas son especialmente comunes:<\/p>\n<ol>\n<li>MPI4PY para un control distribuido de grano fino en muchos nodos.<\/li>\n<li>Dask para paralelismo de nivel superior con menos cambios de c\u00f3digo.<\/li>\n<\/ol>\n<h3>Por qu\u00e9 necesitas MPPI4PY<\/h3>\n<p>El bloqueo global del int\u00e9rprete de Python limita la verdadera ejecuci\u00f3n de Python de subprocesos m\u00faltiples dentro de un proceso. El m\u00f3dulo <code>multiprocessing<\/code> puede paralelizar en una m\u00e1quina, pero no se escala naturalmente a trav\u00e9s de varios nodos de c\u00f3mputo.<\/p>\n<p>MPI4PY proporciona enlaces de Python para MPI, la interfaz de paso de mensajes. MPI es una API est\u00e1ndar para computaci\u00f3n en paralelo distribuida y se usa ampliamente en sistemas HPC.<\/p>\n<p>Con MPI4PY, cada proceso ejecuta el mismo script pero recibe un rango \u00fanico. Ese rango controla qu\u00e9 parte de la carga de trabajo maneja cada proceso.<\/p>\n<h3>Patr\u00f3n b\u00e1sico de MPi4PY: Hola mundo<\/h3>\n<pre><code class=\"language-python\">from mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\nprint(f\"Hello from process {rank} out of {size} processes\")\n<\/code><\/pre>\n<p>Inicie el script con MPI:<\/p>\n<pre><code class=\"language-bash\">mpiexec -n 16 python my_script.py\n<\/code><\/pre>\n<p>Esto inicia 16 procesos independientes de Python. Cada proceso ejecuta el mismo script, pero cada uno tiene un <code>rank<\/code>.<\/p>\n<h3>El modelo de datos: procesos independientes<\/h3>\n<p>Los procesos MPI no comparten memoria de forma predeterminada. Cada proceso tiene su propio espacio de memoria. Para intercambiar informaci\u00f3n, los procesos deben enviar, recibir, difundir, recopilar o reducir expl\u00edcitamente datos.<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\n\n# Rank 0 creates the initial data.\nif rank == 0:\n    data = np.arange(10, dtype=\"i\")\nelse:\n    data = np.empty(10, dtype=\"i\")\n\n# Broadcast data from rank 0 to all ranks.\ncomm.Bcast(data, root=0)\n\nprint(f\"Rank {rank} received data: {data}\")\n<\/code><\/pre>\n<p>Este modelo de comunicaci\u00f3n expl\u00edcito es una de las razones por las que MPI escala bien. Cada rango posee su memoria local, y la comunicaci\u00f3n solo ocurre cuando la solicita.<\/p>\n<h3>Distribuci\u00f3n de la carga de trabajo: el patr\u00f3n central<\/h3>\n<p>La mayor\u00eda de los flujos de trabajo cient\u00edficos de MPI siguen el mismo patr\u00f3n: divide el problema, calcula localmente y reduce los resultados.<\/p>\n<pre><code class=\"language-python\">from mpi4py import MPI\nimport numpy as np\n\ncomm = MPI.COMM_WORLD\n\nsize = comm.Get_size()\nrank = comm.Get_rank()\n\n# Total problem size\nN = 10_000_000\n\n# Calculate workload per rank\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\n# Each rank works on its own slice\nmy_data = np.random.rand(my_end - my_start)\n\n# Local computation\nlocal_result = np.sum(np.sin(my_data))\n\n# Sum results across all ranks\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Total computed across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<p>Este patr\u00f3n se aplica a muchas tareas de simulaci\u00f3n:<\/p>\n<ul>\n<li>Simulaciones de Monte Carlo, donde cada rango procesa muestras independientes.<\/li>\n<li>barridos de par\u00e1metros, donde cada rango prueba diferentes conjuntos de par\u00e1metros.<\/li>\n<li>Descomposici\u00f3n de dominio, donde cada rango posee parte de la cuadr\u00edcula de simulaci\u00f3n.<\/li>\n<li>Din\u00e1mica molecular, donde clasifica las fuerzas de c\u00f3mputo para diferentes subconjuntos de part\u00edculas.<\/li>\n<\/ul>\n<h3>La caja de herramientas de comunicaci\u00f3n colectiva<\/h3>\n<p>MPI4PY proporciona operaciones colectivas que suelen ser m\u00e1s f\u00e1ciles y eficientes que los mensajes de punto a punto personalizados.<\/p>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Operaci\u00f3n<\/th>\n<th>\u00bfQue hace?<\/th>\n<th>Cu\u00e1ndo usar<\/th>\n<\/tr>\n<tr>\n<td><code>Bcast<\/code><\/td>\n<td>Un proceso env\u00eda los mismos datos a todos los rangos<\/td>\n<td>Compartir condiciones iniciales, constantes o valores de configuraci\u00f3n<\/td>\n<\/tr>\n<tr>\n<td><code>Scatter<\/code><\/td>\n<td>Distribuye piezas de una matriz entre rangos<\/td>\n<td>Descomposici\u00f3n de dominio o partici\u00f3n de carga de trabajo<\/td>\n<\/tr>\n<tr>\n<td><code>Gather<\/code><\/td>\n<td>Recopila datos de todos los rangos<\/td>\n<td>Recopilaci\u00f3n de salidas parciales<\/td>\n<\/tr>\n<tr>\n<td><code>Reduce<\/code><\/td>\n<td>Agrega valores como Sum, Max o Min<\/td>\n<td>Sumar energ\u00edas o recopilar m\u00e9tricas globales<\/td>\n<\/tr>\n<tr>\n<td><code>Allreduce<\/code><\/td>\n<td>agrega valores y da el resultado a cada rango<\/td>\n<td>Sincronizaci\u00f3n del estado global en todos los procesos<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Utilice la comunicaci\u00f3n colectiva cuando sea posible. Por lo general, es m\u00e1s simple y eficiente que coordinar manualmente muchos env\u00edos y recepci\u00f3n.<\/p>\n<h3>Cu\u00e1ndo usar Dask en su lugar<\/h3>\n<p>Dask se encuentra entre Python en serie y MPI. Es \u00fatil cuando la carga de trabajo es vergonzosamente paralela, como ejecutar la misma simulaci\u00f3n con muchos conjuntos de par\u00e1metros o condiciones iniciales.<\/p>\n<pre><code class=\"language-python\">from dask.distributed import Client\nfrom dask import delayed\n\nclient = Client(n_workers=16, threads_per_worker=4)\n\ndef my_simulation(params):\n    # Your simulation logic here\n    return params[\"a\"] * params[\"b\"]\n\nparameter_list = [\n    {\"a\": i, \"b\": 2.0}\n    for i in range(100)\n]\n\ntasks = [\n    delayed(my_simulation)(params)\n    for params in parameter_list\n]\n\nfinal_results = client.compute(tasks, sync=True)\n\nprint(final_results[:5])\n<\/code><\/pre>\n<p>La ventaja de Dask es que le permite paralelizar muchos flujos de trabajo sin redise\u00f1ar la simulaci\u00f3n en torno a rangos y comunicadores.<\/p>\n<h3>MPI4PY vs Dask: \u00bfCu\u00e1l elegir?<\/h3>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Criterio<\/th>\n<th>MPI4PY<\/th>\n<th>seguro<\/th>\n<\/tr>\n<tr>\n<td>curva de aprendizaje<\/td>\n<td>m\u00e1s empinado porque debes entender las filas y los comunicadores<\/td>\n<td>M\u00e1s suave porque utiliza patrones familiares de tareas de Python<\/td>\n<\/tr>\n<tr>\n<td>control de grano fino<\/td>\n<td>excelente porque toda comunicaci\u00f3n es expl\u00edcita<\/td>\n<td>Limitado por la abstracci\u00f3n del gr\u00e1fico de tareas<\/td>\n<\/tr>\n<tr>\n<td>Eficiencia de memoria<\/td>\n<td>Alto porque cada rango almacena su propia porci\u00f3n<\/td>\n<td>moderado porque los trabajadores agregan gastos generales<\/td>\n<\/tr>\n<tr>\n<td>Adecuado para<\/td>\n<td>Soludores de PDE a gran escala y simulaciones descompuestas de dominio<\/td>\n<td>Monte Carlo, barridos de par\u00e1metros y an\u00e1lisis de datos<\/td>\n<\/tr>\n<tr>\n<td>Mejor escala<\/td>\n<td>Paralelismo denso en muchos nodos<\/td>\n<td>Escala d\u00e9bil en los recuentos de trabajadores moderados<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Comience con Dask para crear prototipos y cargas de trabajo vergonzosamente paralelas. Mu\u00e9vase a MPI4PY cuando necesite un control estricto sobre la comunicaci\u00f3n, la memoria y la escala en muchos nodos.<\/p>\n<h2>Etapa 3: Presentaci\u00f3n al cl\u00faster<\/h2>\n<p>Despu\u00e9s de las pruebas locales y la paralelizaci\u00f3n, el siguiente paso es la implementaci\u00f3n de cl\u00fasteres. La mayor\u00eda de los cl\u00fasteres usan un programador de trabajos. Slurm es uno de los m\u00e1s comunes.<\/p>\n<h3>El gui\u00f3n de trabajo de Slurm<\/h3>\n<p>Un script de trabajo SLURM le dice al programador qu\u00e9 recursos necesita y c\u00f3mo ejecutar el c\u00f3digo.<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=my-sim\n#SBATCH --nodes=32\n#SBATCH --tasks-per-node=4\n#SBATCH --cpus-per-task=1\n#SBATCH --mem=8GB\n#SBATCH --time=04:00:00\n#SBATCH --output=sim_output.%j\n\n# Load required modules\nmodule load Python\/3.11\n\n# Activate conda environment\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\n# Run the MPI job\nsrun python my_simulation.py\n<\/code><\/pre>\n<p>Los par\u00e1metros importantes incluyen:<\/p>\n<ul>\n<li><code>--nodes<\/code>: N\u00famero de nodos de c\u00e1lculo.<\/li>\n<li><code>--tasks-per-node<\/code>: N\u00famero de tareas MPI por nodo.<\/li>\n<li><code>--cpus-per-task<\/code>: n\u00facleos de CPU asignados a cada tarea.<\/li>\n<li><code>--time<\/code>: L\u00edmite de reloj de pared. Los trabajos generalmente se detienen si lo superan.<\/li>\n<li><code>--output<\/code>: patr\u00f3n de archivo de salida. <code>%j<\/code> Inserta el ID de trabajo.<\/li>\n<\/ul>\n<h3>Ejecuci\u00f3n en grupos sin slurm<\/h3>\n<p>No todos los grupos usan Slurm. Las alternativas comunes incluyen:<\/p>\n<ul>\n<li>PBS o par, generalmente usando <code>qsub<\/code>.<\/li>\n<li>LSF, generalmente usando <code>bsub<\/code>.<\/li>\n<li>Cobalto u otros programadores espec\u00edficos del sitio.<\/li>\n<\/ul>\n<p>La sintaxis de env\u00edo de trabajos cambia, pero el c\u00f3digo de Python generalmente no. MPI4PY y Dask son en su mayor\u00eda agn\u00f3sticos del programador una vez que se lanzaron correctamente.<\/p>\n<h3>Modo interactivo frente a lote<\/h3>\n<p>Para la depuraci\u00f3n, las ejecuciones interactivas son \u00fatiles:<\/p>\n<pre><code class=\"language-bash\">srun --ntasks=4 --pty --time=02:00:00 python my_simulation.py\n<\/code><\/pre>\n<p>Para la producci\u00f3n, utilice el env\u00edo por lotes:<\/p>\n<pre><code class=\"language-bash\">sbatch my_job_script.sh\n<\/code><\/pre>\n<p>Las sesiones interactivas son buenas para pruebas cortas. Los trabajos por lotes son mejores para tiradas largas, cargas de trabajo durante la noche y simulaciones de producci\u00f3n.<\/p>\n<h2>El flujo de trabajo completo: de la computadora port\u00e1til a la producci\u00f3n<\/h2>\n<p>La transici\u00f3n del prototipo local al despliegue de cl\u00faster puede ser gradual. La l\u00f3gica de simulaci\u00f3n central debe permanecer estable mientras cambia el contenedor de ejecuci\u00f3n.<\/p>\n<h3>Paso 1: Desarrollar y probar localmente<\/h3>\n<pre><code class=\"language-python\"># my_simulation.py\nimport numpy as np\n\ndef simulate(initial_condition, params):\n    # Core simulation logic\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\n# Local test\ndata = np.random.rand(1000)\nresult = simulate(data, {\"factor\": 1.5})\n\nprint(f\"Local result: {result}\")\n<\/code><\/pre>\n<h3>Paso 2: agregar paralelizaci\u00f3n<\/h3>\n<pre><code class=\"language-python\"># my_simulation_mpi.py\nimport numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\ndef simulate(initial_condition, params):\n    # Core simulation logic stays the same\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\nN = 10_000_000\n\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\nmy_data = np.random.rand(my_end - my_start)\n\nlocal_result = simulate(my_data, {\"factor\": 1.5})\n\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Parallel result across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<h3>Paso 3: Enviar al cl\u00faster<\/h3>\n<p>Guarde un script de trabajo como <code>job_script.sh<\/code>:<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=parallel-sim\n#SBATCH --nodes=64\n#SBATCH --tasks-per-node=8\n#SBATCH --time=12:00:00\n\nmodule load Python\/3.11\n\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\nsrun python my_simulation_mpi.py\n<\/code><\/pre>\n<p>Env\u00edelo:<\/p>\n<pre><code class=\"language-bash\">sbatch job_script.sh\n<\/code><\/pre>\n<p>La l\u00f3gica de simulaci\u00f3n sigue siendo la misma. El contenedor cambia la forma en que se divide y se lanza la carga de trabajo.<\/p>\n<h2>Trampas comunes y c\u00f3mo evitarlas<\/h2>\n<h3>Escolar 1: Difundir demasiados datos<\/h3>\n<p>Difundir grandes matrices desde el rango 0 hasta cada rango puede convertirse en un cuello de botella de comunicaci\u00f3n. Para simulaciones grandes, evite enviar m\u00e1s datos de los que necesita cada rango.<\/p>\n<p>Las mejores opciones incluyen:<\/p>\n<ul>\n<li>Use <code>Scatter<\/code> en lugar de <code>Bcast<\/code> cuando cada rango solo necesite un segmento.<\/li>\n<li>Utilice la descomposici\u00f3n del dominio para que cada rango tenga una regi\u00f3n de la simulaci\u00f3n.<\/li>\n<li>Para Monte Carlo, que cada rango genere sus propias muestras aleatorias en lugar de transmitirlas.<\/li>\n<\/ul>\n<h3>Pitfall 2: Sobreasignaci\u00f3n de recursos de cl\u00faster<\/h3>\n<p>Solicitar m\u00e1s nodos que su c\u00f3digo puede usar el tiempo de asignaci\u00f3n de p\u00e9rdidas y puede aumentar el retraso en la cola.<\/p>\n<p>Comience con un peque\u00f1o trabajo de prueba, como de 4 a 8 nodos. Mide la velocidad. Escala solo despu\u00e9s de que el c\u00f3digo muestre una eficiencia paralela \u00fatil.<\/p>\n<h3>Escolar 3: Olvidar el gil en c\u00f3digo mixto<\/h3>\n<p>Numpy, Scipy y Bibliotecas Compiladas C o Fortran a menudo liberan el bloqueo de int\u00e9rprete global de Python durante operaciones num\u00e9ricas pesadas. Los hilos de Python puro generalmente no proporcionan el mismo beneficio.<\/p>\n<p>Si su flujo de trabajo mezcla subprocesos de Python con bibliotecas num\u00e9ricas, la escala de prueba con cuidado en lugar de asumir m\u00e1s subprocesos le ayudar\u00e1.<\/p>\n<h3>Escolar 4: Desajuste del medio ambiente en el cl\u00faster<\/h3>\n<p>Su computadora port\u00e1til puede usar Python 3.11 mientras que el m\u00f3dulo de cl\u00faster proporciona Python 3.9. MPI4PY, bibliotecas MPI y dependencias compiladas pueden romperse cuando las versiones no coinciden.<\/p>\n<p>Utilice un entorno de Conda y documente la configuraci\u00f3n exacta. Vuelva a crear y probar el entorno en el cl\u00faster antes de ejecutar trabajos grandes.<\/p>\n<h2>Gu\u00eda de decisi\u00f3n: \u00bfQu\u00e9 estrategia de paralelizaci\u00f3n?<\/h2>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Situaci\u00f3n<\/th>\n<th>Enfoque recomendado<\/th>\n<\/tr>\n<tr>\n<td>Peque\u00f1o conjunto de datos y pruebas l\u00f3gicas locales<\/td>\n<td>Python en serie con numpy<\/td>\n<\/tr>\n<tr>\n<td>M\u00e1quina \u00fanica con m\u00faltiples n\u00facleos<\/td>\n<td>Python <code>multiprocessing<\/code> o Dask <code>LocalCluster<\/code><\/td>\n<\/tr>\n<tr>\n<td>8-64 trabajadores y tareas vergonzosamente paralelas<\/td>\n<td>Dask con un lanzador de cl\u00fasteres<\/td>\n<\/tr>\n<tr>\n<td>64-1000 nodos y PDE descompuestos por el dominio<\/td>\n<td>MPI4PY con distribuci\u00f3n expl\u00edcita de carga de trabajo<\/td>\n<\/tr>\n<tr>\n<td>Simulaci\u00f3n de producci\u00f3n en m\u00e1s de 1000 nodos<\/td>\n<td>MPI4PY, secuencias de comandos de trabajos de programador y entorno de Conda bloqueado<\/td>\n<\/tr>\n<tr>\n<td>C\u00f3digo de investigaci\u00f3n sin reproducibilidad garantizada<\/td>\n<td>Dask, archivo de entorno de Conda y script de trabajo como punto de partida<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Su herramienta de paralelizaci\u00f3n debe coincidir con la escala y la estructura del problema. Comience m\u00e1s peque\u00f1o de lo que cree que necesita, luego escalar despu\u00e9s de medir el rendimiento.<\/p>\n<h2>Gu\u00edas relacionadas<\/h2>\n<p>Para temas relacionados en flujos de trabajo de simulaci\u00f3n cient\u00edfica:<\/p>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-acceleration-for-fipy-simulations-cupy-and-numba-integration-guide\/\">Aceleraci\u00f3n de GPU para simulaciones FIPY: integraci\u00f3n de CUPY y NUMBA Gu\u00eda<\/a> \u2014 Cuando la CPU en paralelo no es suficiente.<\/li>\n<li><a href=\"https:\/\/matforge.org\/performance-profiling-optimization-python-pde-solvers\/\">performance de perfiles y optimizaci\u00f3n para solucionadores de PDE de Python: una gu\u00eda pr\u00e1ctica<\/a> \u2014 Encontrar cuellos de botella antes Paralelizaci\u00f3n.<\/li>\n<li><a href=\"https:\/\/matforge.org\/python-debugging-scientific-code-print-statements-profiling\/\">Depuraci\u00f3n de Python para c\u00f3digo cient\u00edfico: desde declaraciones impresas hasta perfiles<\/a> \u2014 Depuraci\u00f3n de simulaciones paralelas.<\/li>\n<\/ul>\n<h2>Resumen y pr\u00f3ximos pasos<\/h2>\n<p>Los flujos de trabajo de HPC Python se tratan de envolver, no de reescribir. La misma l\u00f3gica de simulaci\u00f3n que se ejecuta en una computadora port\u00e1til puede ejecutarse en muchos n\u00facleos cuando construye la estructura de ejecuci\u00f3n correcta.<\/p>\n<p>El flujo de trabajo es:<\/p>\n<ol>\n<li>Bloquee el entorno con Conda para que el c\u00f3digo se ejecute constantemente en todos los sistemas.<\/li>\n<li>Agregue paralelismo con MPI4PY para un control distribuido de grano fino o DASK para el paralelismo de tareas de alto nivel.<\/li>\n<li>Env\u00ede trabajos a trav\u00e9s de SLURM, PBS, LSF o el planificador utilizado por su cl\u00faster.<\/li>\n<\/ol>\n<p>La parte m\u00e1s dif\u00edcil es a menudo el entorno, no el c\u00f3digo. Invierta en una configuraci\u00f3n reproducible antes de tiempo, y las simulaciones paralelas se vuelven m\u00e1s f\u00e1ciles de escalar desde una computadora port\u00e1til a una supercomputadora.<\/p>\n<h3>Pr\u00f3ximos pasos<\/h3>\n<ol>\n<li>Auditar la simulaci\u00f3n actual. Si solo se ejecuta en una computadora port\u00e1til, comience creando un entorno de conda y pruebe una peque\u00f1a ejecuci\u00f3n de m\u00faltiples n\u00facleos.<\/li>\n<li>Medir antes de escalar. Ejecute un peque\u00f1o trabajo de cl\u00faster, mida la aceleraci\u00f3n y solo luego escala al tama\u00f1o de producci\u00f3n.<\/li>\n<li>Documente la configuraci\u00f3n. Guarde el archivo de entorno, el script de trabajo, el comando de inicio y la salida esperada.<\/li>\n<\/ol>\n<p>Establecer un flujo de trabajo de Python de HPC requiere comprender los paquetes cient\u00edficos de Python, la programaci\u00f3n en paralelo y la infraestructura de cl\u00fasteres. Si necesita ayuda con la paralelizaci\u00f3n de MPI, la programaci\u00f3n de trabajos o la reproducibilidad del entorno, nuestro equipo puede admitir flujos de trabajo cient\u00edficos escalables de Python, incluidas las simulaciones basadas en Fipy y los motores Monte Carlo personalizados.<\/p>\n","protected":false,"raw":"<h2>Comida clave<\/h2>\n<ul>\n<li>El c\u00f3digo Python puede ejecutarse en una computadora port\u00e1til y en un sistema HPC grande con la misma l\u00f3gica central cuando el flujo de trabajo usa MPi4PY o DASK correctamente.<\/li>\n<li>La reproducibilidad del medio ambiente es a menudo la parte m\u00e1s dif\u00edcil del trabajo de HPC. Los entornos de Conda, los archivos de bloqueo y los scripts de trabajo ayudan a resolverlo.<\/li>\n<li>El flujo de trabajo tiene tres etapas: prototipo local, paralelizar con MPPI4PY o DASK y enviar trabajos a trav\u00e9s de SLURM, PBS u otro programador.<\/li>\n<li>No vuelva a escribir toda la base de c\u00f3digo para el cl\u00faster. Mantenga estable la l\u00f3gica de simulaci\u00f3n y envu\u00e9lvala con un entorno reproducible y capas de ejecuci\u00f3n en paralelo.<\/li>\n<\/ul>\n<p>Escribes un script de simulaci\u00f3n en tu computadora port\u00e1til. Lo prueba con peque\u00f1os conjuntos de datos. Funciona en minutos. Entonces necesitas miles de n\u00facleos y cientos de gigabytes de RAM para ejecutarlo a escala.<\/p>\n<p>\u00bfReescribes toda la base de c\u00f3digo?<\/p>\n<p>No. El mismo c\u00f3digo de Python que se ejecuta en su computadora port\u00e1til puede ejecutarse en una supercomputadora con cambios m\u00ednimos. La clave no es reescribir. es envolver.<\/p>\n<p>Necesita tres cosas: un entorno reproducible, un modelo de ejecuci\u00f3n en paralelo y un script de env\u00edo de trabajos para el programador de cl\u00fasteres.<\/p>\n<p>Esta gu\u00eda recorre el flujo de trabajo completo desde el prototipo local hasta la implementaci\u00f3n de HPC de producci\u00f3n sin cambiar su l\u00f3gica de simulaci\u00f3n principal.<\/p>\n<h2>El flujo de trabajo de Python de HPC de tres etapas<\/h2>\n<p>La mayor\u00eda de los proyectos de HPC Python siguen el mismo patr\u00f3n de tres etapas, independientemente del dominio cient\u00edfico.<\/p>\n<pre><code>Stage 1 \u2014 Local Prototyping:\n  Laptop \u2192 Jupyter or IDE \u2192 NumPy \/ Pandas \u2192 serial execution\n\nStage 2 \u2014 Parallelization:\n  Same code \u2192 mpi4py or Dask \u2192 parallel execution\n\nStage 3 \u2014 Cluster Deployment:\n  Python script \u2192 Slurm \/ PBS job submission \u2192 distributed compute nodes\n<\/code><\/pre>\n<p>El objetivo es avanzar gradualmente a trav\u00e9s de estas etapas. Comience con una versi\u00f3n local en funcionamiento. Agregue la ejecuci\u00f3n en paralelo solo despu\u00e9s de que la l\u00f3gica sea correcta. Env\u00ede al cl\u00faster solo despu\u00e9s de que funcionen peque\u00f1as pruebas paralelas.<\/p>\n<h2>Etapa 1: Establecer un entorno reproducible<\/h2>\n<p>Antes de escribir c\u00f3digo paralelo, necesita un entorno de desarrollo confiable. Aqu\u00ed es donde muchos flujos de trabajo cient\u00edficos fallan primero.<\/p>\n<h3>Por qu\u00e9 la reproducibilidad es dif\u00edcil para los cl\u00fasteres de HPC<\/h3>\n<p>Los cl\u00fasteres de HPC son sistemas compartidos. Muchos grupos de investigaci\u00f3n utilizan la misma infraestructura y los paquetes de sistemas pueden cambiar con el tiempo. Una simulaci\u00f3n que funciona hoy puede romperse seis meses despu\u00e9s de las actualizaciones del m\u00f3dulo, los cambios del compilador o los cambios en la versi\u00f3n del paquete.<\/p>\n<p>La soluci\u00f3n es la gesti\u00f3n del medio ambiente. Conda se usa com\u00fanmente porque a\u00edsla paquetes del sistema Python y puede administrar dependencias compiladas, as\u00ed como paquetes de Python.<\/p>\n<pre><code class=\"language-bash\"># Create a reproducible environment\nconda create -n my-sim python=3.11 numpy mpi4py dask\n\n# Lock dependencies for reproducibility\nconda env export --no-builds --name my-sim &gt; environment.yml\n\n# Recreate the environment on another machine\nconda env create -n my-sim -f environment.yml\n<\/code><\/pre>\n<p>Un solo archivo de entorno brinda a los colaboradores y futuros usuarios una forma clara de recrear la pila de software. Para una reproducibilidad m\u00e1s estricta, use archivos de bloqueo que anclan cada versi\u00f3n de paquete y de dependencia de compilaci\u00f3n.<\/p>\n<h3>Conda vs Venv: Por qu\u00e9 Conda a menudo gana en HPC<\/h3>\n<p>El <code>venv<\/code> incorporado de Python funciona bien para paquetes de Python puro. Los flujos de trabajo de HPC a menudo dependen de bibliotecas cient\u00edficas compiladas, tiempos de ejecuci\u00f3n de MPI, HDF5, BLAS, CUDA y otros componentes a nivel de sistema.<\/p>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Caracter\u00edstica<\/th>\n<th>ven<\/th>\n<th>condaci\u00f3n<\/th>\n<\/tr>\n<tr>\n<td>Paquetes de Python puro<\/td>\n<td>S\u00ed<\/td>\n<td>S\u00ed<\/td>\n<\/tr>\n<tr>\n<td>Dependencias a nivel de sistema como MPI y HDF5<\/td>\n<td>No<\/td>\n<td>S\u00ed<\/td>\n<\/tr>\n<tr>\n<td>Consistencia multiplataforma<\/td>\n<td>Limitado<\/td>\n<td>Fuerte<\/td>\n<\/tr>\n<tr>\n<td>Paquetes de aceleraci\u00f3n de GPU como CUPY o PyTorch CUDA<\/td>\n<td>Configuraci\u00f3n manual<\/td>\n<td>Configuraci\u00f3n m\u00e1s automatizada<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Conda da reproducibilidad a trav\u00e9s de m\u00e1s de la pila cient\u00edfica. Eso importa cuando se trabaja con MPI4PY porque el entorno de ejecuci\u00f3n de MPI y Python deben ser compatibles tanto en la m\u00e1quina local como en el cl\u00faster.<\/p>\n<h2>Etapa 2: Paralelizaci\u00f3n de su c\u00f3digo Python<\/h2>\n<p>Una vez que la versi\u00f3n local funciona, el siguiente paso es la paralelizaci\u00f3n. En los flujos de trabajo de Python HPC, dos herramientas son especialmente comunes:<\/p>\n<ol>\n<li>MPI4PY para un control distribuido de grano fino en muchos nodos.<\/li>\n<li>Dask para paralelismo de nivel superior con menos cambios de c\u00f3digo.<\/li>\n<\/ol>\n<h3>Por qu\u00e9 necesitas MPPI4PY<\/h3>\n<p>El bloqueo global del int\u00e9rprete de Python limita la verdadera ejecuci\u00f3n de Python de subprocesos m\u00faltiples dentro de un proceso. El m\u00f3dulo <code>multiprocessing<\/code> puede paralelizar en una m\u00e1quina, pero no se escala naturalmente a trav\u00e9s de varios nodos de c\u00f3mputo.<\/p>\n<p>MPI4PY proporciona enlaces de Python para MPI, la interfaz de paso de mensajes. MPI es una API est\u00e1ndar para computaci\u00f3n en paralelo distribuida y se usa ampliamente en sistemas HPC.<\/p>\n<p>Con MPI4PY, cada proceso ejecuta el mismo script pero recibe un rango \u00fanico. Ese rango controla qu\u00e9 parte de la carga de trabajo maneja cada proceso.<\/p>\n<h3>Patr\u00f3n b\u00e1sico de MPi4PY: Hola mundo<\/h3>\n<pre><code class=\"language-python\">from mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\nprint(f\"Hello from process {rank} out of {size} processes\")\n<\/code><\/pre>\n<p>Inicie el script con MPI:<\/p>\n<pre><code class=\"language-bash\">mpiexec -n 16 python my_script.py\n<\/code><\/pre>\n<p>Esto inicia 16 procesos independientes de Python. Cada proceso ejecuta el mismo script, pero cada uno tiene un <code>rank<\/code>.<\/p>\n<h3>El modelo de datos: procesos independientes<\/h3>\n<p>Los procesos MPI no comparten memoria de forma predeterminada. Cada proceso tiene su propio espacio de memoria. Para intercambiar informaci\u00f3n, los procesos deben enviar, recibir, difundir, recopilar o reducir expl\u00edcitamente datos.<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\n\n# Rank 0 creates the initial data.\nif rank == 0:\n    data = np.arange(10, dtype=\"i\")\nelse:\n    data = np.empty(10, dtype=\"i\")\n\n# Broadcast data from rank 0 to all ranks.\ncomm.Bcast(data, root=0)\n\nprint(f\"Rank {rank} received data: {data}\")\n<\/code><\/pre>\n<p>Este modelo de comunicaci\u00f3n expl\u00edcito es una de las razones por las que MPI escala bien. Cada rango posee su memoria local, y la comunicaci\u00f3n solo ocurre cuando la solicita.<\/p>\n<h3>Distribuci\u00f3n de la carga de trabajo: el patr\u00f3n central<\/h3>\n<p>La mayor\u00eda de los flujos de trabajo cient\u00edficos de MPI siguen el mismo patr\u00f3n: divide el problema, calcula localmente y reduce los resultados.<\/p>\n<pre><code class=\"language-python\">from mpi4py import MPI\nimport numpy as np\n\ncomm = MPI.COMM_WORLD\n\nsize = comm.Get_size()\nrank = comm.Get_rank()\n\n# Total problem size\nN = 10_000_000\n\n# Calculate workload per rank\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\n# Each rank works on its own slice\nmy_data = np.random.rand(my_end - my_start)\n\n# Local computation\nlocal_result = np.sum(np.sin(my_data))\n\n# Sum results across all ranks\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Total computed across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<p>Este patr\u00f3n se aplica a muchas tareas de simulaci\u00f3n:<\/p>\n<ul>\n<li>Simulaciones de Monte Carlo, donde cada rango procesa muestras independientes.<\/li>\n<li>barridos de par\u00e1metros, donde cada rango prueba diferentes conjuntos de par\u00e1metros.<\/li>\n<li>Descomposici\u00f3n de dominio, donde cada rango posee parte de la cuadr\u00edcula de simulaci\u00f3n.<\/li>\n<li>Din\u00e1mica molecular, donde clasifica las fuerzas de c\u00f3mputo para diferentes subconjuntos de part\u00edculas.<\/li>\n<\/ul>\n<h3>La caja de herramientas de comunicaci\u00f3n colectiva<\/h3>\n<p>MPI4PY proporciona operaciones colectivas que suelen ser m\u00e1s f\u00e1ciles y eficientes que los mensajes de punto a punto personalizados.<\/p>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Operaci\u00f3n<\/th>\n<th>\u00bfQue hace?<\/th>\n<th>Cu\u00e1ndo usar<\/th>\n<\/tr>\n<tr>\n<td><code>Bcast<\/code><\/td>\n<td>Un proceso env\u00eda los mismos datos a todos los rangos<\/td>\n<td>Compartir condiciones iniciales, constantes o valores de configuraci\u00f3n<\/td>\n<\/tr>\n<tr>\n<td><code>Scatter<\/code><\/td>\n<td>Distribuye piezas de una matriz entre rangos<\/td>\n<td>Descomposici\u00f3n de dominio o partici\u00f3n de carga de trabajo<\/td>\n<\/tr>\n<tr>\n<td><code>Gather<\/code><\/td>\n<td>Recopila datos de todos los rangos<\/td>\n<td>Recopilaci\u00f3n de salidas parciales<\/td>\n<\/tr>\n<tr>\n<td><code>Reduce<\/code><\/td>\n<td>Agrega valores como Sum, Max o Min<\/td>\n<td>Sumar energ\u00edas o recopilar m\u00e9tricas globales<\/td>\n<\/tr>\n<tr>\n<td><code>Allreduce<\/code><\/td>\n<td>agrega valores y da el resultado a cada rango<\/td>\n<td>Sincronizaci\u00f3n del estado global en todos los procesos<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Utilice la comunicaci\u00f3n colectiva cuando sea posible. Por lo general, es m\u00e1s simple y eficiente que coordinar manualmente muchos env\u00edos y recepci\u00f3n.<\/p>\n<h3>Cu\u00e1ndo usar Dask en su lugar<\/h3>\n<p>Dask se encuentra entre Python en serie y MPI. Es \u00fatil cuando la carga de trabajo es vergonzosamente paralela, como ejecutar la misma simulaci\u00f3n con muchos conjuntos de par\u00e1metros o condiciones iniciales.<\/p>\n<pre><code class=\"language-python\">from dask.distributed import Client\nfrom dask import delayed\n\nclient = Client(n_workers=16, threads_per_worker=4)\n\ndef my_simulation(params):\n    # Your simulation logic here\n    return params[\"a\"] * params[\"b\"]\n\nparameter_list = [\n    {\"a\": i, \"b\": 2.0}\n    for i in range(100)\n]\n\ntasks = [\n    delayed(my_simulation)(params)\n    for params in parameter_list\n]\n\nfinal_results = client.compute(tasks, sync=True)\n\nprint(final_results[:5])\n<\/code><\/pre>\n<p>La ventaja de Dask es que le permite paralelizar muchos flujos de trabajo sin redise\u00f1ar la simulaci\u00f3n en torno a rangos y comunicadores.<\/p>\n<h3>MPI4PY vs Dask: \u00bfCu\u00e1l elegir?<\/h3>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Criterio<\/th>\n<th>MPI4PY<\/th>\n<th>seguro<\/th>\n<\/tr>\n<tr>\n<td>curva de aprendizaje<\/td>\n<td>m\u00e1s empinado porque debes entender las filas y los comunicadores<\/td>\n<td>M\u00e1s suave porque utiliza patrones familiares de tareas de Python<\/td>\n<\/tr>\n<tr>\n<td>control de grano fino<\/td>\n<td>excelente porque toda comunicaci\u00f3n es expl\u00edcita<\/td>\n<td>Limitado por la abstracci\u00f3n del gr\u00e1fico de tareas<\/td>\n<\/tr>\n<tr>\n<td>Eficiencia de memoria<\/td>\n<td>Alto porque cada rango almacena su propia porci\u00f3n<\/td>\n<td>moderado porque los trabajadores agregan gastos generales<\/td>\n<\/tr>\n<tr>\n<td>Adecuado para<\/td>\n<td>Soludores de PDE a gran escala y simulaciones descompuestas de dominio<\/td>\n<td>Monte Carlo, barridos de par\u00e1metros y an\u00e1lisis de datos<\/td>\n<\/tr>\n<tr>\n<td>Mejor escala<\/td>\n<td>Paralelismo denso en muchos nodos<\/td>\n<td>Escala d\u00e9bil en los recuentos de trabajadores moderados<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Comience con Dask para crear prototipos y cargas de trabajo vergonzosamente paralelas. Mu\u00e9vase a MPI4PY cuando necesite un control estricto sobre la comunicaci\u00f3n, la memoria y la escala en muchos nodos.<\/p>\n<h2>Etapa 3: Presentaci\u00f3n al cl\u00faster<\/h2>\n<p>Despu\u00e9s de las pruebas locales y la paralelizaci\u00f3n, el siguiente paso es la implementaci\u00f3n de cl\u00fasteres. La mayor\u00eda de los cl\u00fasteres usan un programador de trabajos. Slurm es uno de los m\u00e1s comunes.<\/p>\n<h3>El gui\u00f3n de trabajo de Slurm<\/h3>\n<p>Un script de trabajo SLURM le dice al programador qu\u00e9 recursos necesita y c\u00f3mo ejecutar el c\u00f3digo.<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=my-sim\n#SBATCH --nodes=32\n#SBATCH --tasks-per-node=4\n#SBATCH --cpus-per-task=1\n#SBATCH --mem=8GB\n#SBATCH --time=04:00:00\n#SBATCH --output=sim_output.%j\n\n# Load required modules\nmodule load Python\/3.11\n\n# Activate conda environment\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\n# Run the MPI job\nsrun python my_simulation.py\n<\/code><\/pre>\n<p>Los par\u00e1metros importantes incluyen:<\/p>\n<ul>\n<li><code>--nodes<\/code>: N\u00famero de nodos de c\u00e1lculo.<\/li>\n<li><code>--tasks-per-node<\/code>: N\u00famero de tareas MPI por nodo.<\/li>\n<li><code>--cpus-per-task<\/code>: n\u00facleos de CPU asignados a cada tarea.<\/li>\n<li><code>--time<\/code>: L\u00edmite de reloj de pared. Los trabajos generalmente se detienen si lo superan.<\/li>\n<li><code>--output<\/code>: patr\u00f3n de archivo de salida. <code>%j<\/code> Inserta el ID de trabajo.<\/li>\n<\/ul>\n<h3>Ejecuci\u00f3n en grupos sin slurm<\/h3>\n<p>No todos los grupos usan Slurm. Las alternativas comunes incluyen:<\/p>\n<ul>\n<li>PBS o par, generalmente usando <code>qsub<\/code>.<\/li>\n<li>LSF, generalmente usando <code>bsub<\/code>.<\/li>\n<li>Cobalto u otros programadores espec\u00edficos del sitio.<\/li>\n<\/ul>\n<p>La sintaxis de env\u00edo de trabajos cambia, pero el c\u00f3digo de Python generalmente no. MPI4PY y Dask son en su mayor\u00eda agn\u00f3sticos del programador una vez que se lanzaron correctamente.<\/p>\n<h3>Modo interactivo frente a lote<\/h3>\n<p>Para la depuraci\u00f3n, las ejecuciones interactivas son \u00fatiles:<\/p>\n<pre><code class=\"language-bash\">srun --ntasks=4 --pty --time=02:00:00 python my_simulation.py\n<\/code><\/pre>\n<p>Para la producci\u00f3n, utilice el env\u00edo por lotes:<\/p>\n<pre><code class=\"language-bash\">sbatch my_job_script.sh\n<\/code><\/pre>\n<p>Las sesiones interactivas son buenas para pruebas cortas. Los trabajos por lotes son mejores para tiradas largas, cargas de trabajo durante la noche y simulaciones de producci\u00f3n.<\/p>\n<h2>El flujo de trabajo completo: de la computadora port\u00e1til a la producci\u00f3n<\/h2>\n<p>La transici\u00f3n del prototipo local al despliegue de cl\u00faster puede ser gradual. La l\u00f3gica de simulaci\u00f3n central debe permanecer estable mientras cambia el contenedor de ejecuci\u00f3n.<\/p>\n<h3>Paso 1: Desarrollar y probar localmente<\/h3>\n<pre><code class=\"language-python\"># my_simulation.py\nimport numpy as np\n\ndef simulate(initial_condition, params):\n    # Core simulation logic\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\n# Local test\ndata = np.random.rand(1000)\nresult = simulate(data, {\"factor\": 1.5})\n\nprint(f\"Local result: {result}\")\n<\/code><\/pre>\n<h3>Paso 2: agregar paralelizaci\u00f3n<\/h3>\n<pre><code class=\"language-python\"># my_simulation_mpi.py\nimport numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\ndef simulate(initial_condition, params):\n    # Core simulation logic stays the same\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\nN = 10_000_000\n\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\nmy_data = np.random.rand(my_end - my_start)\n\nlocal_result = simulate(my_data, {\"factor\": 1.5})\n\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Parallel result across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<h3>Paso 3: Enviar al cl\u00faster<\/h3>\n<p>Guarde un script de trabajo como <code>job_script.sh<\/code>:<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=parallel-sim\n#SBATCH --nodes=64\n#SBATCH --tasks-per-node=8\n#SBATCH --time=12:00:00\n\nmodule load Python\/3.11\n\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\nsrun python my_simulation_mpi.py\n<\/code><\/pre>\n<p>Env\u00edelo:<\/p>\n<pre><code class=\"language-bash\">sbatch job_script.sh\n<\/code><\/pre>\n<p>La l\u00f3gica de simulaci\u00f3n sigue siendo la misma. El contenedor cambia la forma en que se divide y se lanza la carga de trabajo.<\/p>\n<h2>Trampas comunes y c\u00f3mo evitarlas<\/h2>\n<h3>Escolar 1: Difundir demasiados datos<\/h3>\n<p>Difundir grandes matrices desde el rango 0 hasta cada rango puede convertirse en un cuello de botella de comunicaci\u00f3n. Para simulaciones grandes, evite enviar m\u00e1s datos de los que necesita cada rango.<\/p>\n<p>Las mejores opciones incluyen:<\/p>\n<ul>\n<li>Use <code>Scatter<\/code> en lugar de <code>Bcast<\/code> cuando cada rango solo necesite un segmento.<\/li>\n<li>Utilice la descomposici\u00f3n del dominio para que cada rango tenga una regi\u00f3n de la simulaci\u00f3n.<\/li>\n<li>Para Monte Carlo, que cada rango genere sus propias muestras aleatorias en lugar de transmitirlas.<\/li>\n<\/ul>\n<h3>Pitfall 2: Sobreasignaci\u00f3n de recursos de cl\u00faster<\/h3>\n<p>Solicitar m\u00e1s nodos que su c\u00f3digo puede usar el tiempo de asignaci\u00f3n de p\u00e9rdidas y puede aumentar el retraso en la cola.<\/p>\n<p>Comience con un peque\u00f1o trabajo de prueba, como de 4 a 8 nodos. Mide la velocidad. Escala solo despu\u00e9s de que el c\u00f3digo muestre una eficiencia paralela \u00fatil.<\/p>\n<h3>Escolar 3: Olvidar el gil en c\u00f3digo mixto<\/h3>\n<p>Numpy, Scipy y Bibliotecas Compiladas C o Fortran a menudo liberan el bloqueo de int\u00e9rprete global de Python durante operaciones num\u00e9ricas pesadas. Los hilos de Python puro generalmente no proporcionan el mismo beneficio.<\/p>\n<p>Si su flujo de trabajo mezcla subprocesos de Python con bibliotecas num\u00e9ricas, la escala de prueba con cuidado en lugar de asumir m\u00e1s subprocesos le ayudar\u00e1.<\/p>\n<h3>Escolar 4: Desajuste del medio ambiente en el cl\u00faster<\/h3>\n<p>Su computadora port\u00e1til puede usar Python 3.11 mientras que el m\u00f3dulo de cl\u00faster proporciona Python 3.9. MPI4PY, bibliotecas MPI y dependencias compiladas pueden romperse cuando las versiones no coinciden.<\/p>\n<p>Utilice un entorno de Conda y documente la configuraci\u00f3n exacta. Vuelva a crear y probar el entorno en el cl\u00faster antes de ejecutar trabajos grandes.<\/p>\n<h2>Gu\u00eda de decisi\u00f3n: \u00bfQu\u00e9 estrategia de paralelizaci\u00f3n?<\/h2>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Situaci\u00f3n<\/th>\n<th>Enfoque recomendado<\/th>\n<\/tr>\n<tr>\n<td>Peque\u00f1o conjunto de datos y pruebas l\u00f3gicas locales<\/td>\n<td>Python en serie con numpy<\/td>\n<\/tr>\n<tr>\n<td>M\u00e1quina \u00fanica con m\u00faltiples n\u00facleos<\/td>\n<td>Python <code>multiprocessing<\/code> o Dask <code>LocalCluster<\/code><\/td>\n<\/tr>\n<tr>\n<td>8-64 trabajadores y tareas vergonzosamente paralelas<\/td>\n<td>Dask con un lanzador de cl\u00fasteres<\/td>\n<\/tr>\n<tr>\n<td>64-1000 nodos y PDE descompuestos por el dominio<\/td>\n<td>MPI4PY con distribuci\u00f3n expl\u00edcita de carga de trabajo<\/td>\n<\/tr>\n<tr>\n<td>Simulaci\u00f3n de producci\u00f3n en m\u00e1s de 1000 nodos<\/td>\n<td>MPI4PY, secuencias de comandos de trabajos de programador y entorno de Conda bloqueado<\/td>\n<\/tr>\n<tr>\n<td>C\u00f3digo de investigaci\u00f3n sin reproducibilidad garantizada<\/td>\n<td>Dask, archivo de entorno de Conda y script de trabajo como punto de partida<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Su herramienta de paralelizaci\u00f3n debe coincidir con la escala y la estructura del problema. Comience m\u00e1s peque\u00f1o de lo que cree que necesita, luego escalar despu\u00e9s de medir el rendimiento.<\/p>\n<h2>Gu\u00edas relacionadas<\/h2>\n<p>Para temas relacionados en flujos de trabajo de simulaci\u00f3n cient\u00edfica:<\/p>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-acceleration-for-fipy-simulations-cupy-and-numba-integration-guide\/\">Aceleraci\u00f3n de GPU para simulaciones FIPY: integraci\u00f3n de CUPY y NUMBA Gu\u00eda<\/a> \u2014 Cuando la CPU en paralelo no es suficiente.<\/li>\n<li><a href=\"https:\/\/matforge.org\/performance-profiling-optimization-python-pde-solvers\/\">performance de perfiles y optimizaci\u00f3n para solucionadores de PDE de Python: una gu\u00eda pr\u00e1ctica<\/a> \u2014 Encontrar cuellos de botella antes Paralelizaci\u00f3n.<\/li>\n<li><a href=\"https:\/\/matforge.org\/python-debugging-scientific-code-print-statements-profiling\/\">Depuraci\u00f3n de Python para c\u00f3digo cient\u00edfico: desde declaraciones impresas hasta perfiles<\/a> \u2014 Depuraci\u00f3n de simulaciones paralelas.<\/li>\n<\/ul>\n<h2>Resumen y pr\u00f3ximos pasos<\/h2>\n<p>Los flujos de trabajo de HPC Python se tratan de envolver, no de reescribir. La misma l\u00f3gica de simulaci\u00f3n que se ejecuta en una computadora port\u00e1til puede ejecutarse en muchos n\u00facleos cuando construye la estructura de ejecuci\u00f3n correcta.<\/p>\n<p>El flujo de trabajo es:<\/p>\n<ol>\n<li>Bloquee el entorno con Conda para que el c\u00f3digo se ejecute constantemente en todos los sistemas.<\/li>\n<li>Agregue paralelismo con MPI4PY para un control distribuido de grano fino o DASK para el paralelismo de tareas de alto nivel.<\/li>\n<li>Env\u00ede trabajos a trav\u00e9s de SLURM, PBS, LSF o el planificador utilizado por su cl\u00faster.<\/li>\n<\/ol>\n<p>La parte m\u00e1s dif\u00edcil es a menudo el entorno, no el c\u00f3digo. Invierta en una configuraci\u00f3n reproducible antes de tiempo, y las simulaciones paralelas se vuelven m\u00e1s f\u00e1ciles de escalar desde una computadora port\u00e1til a una supercomputadora.<\/p>\n<h3>Pr\u00f3ximos pasos<\/h3>\n<ol>\n<li>Auditar la simulaci\u00f3n actual. Si solo se ejecuta en una computadora port\u00e1til, comience creando un entorno de conda y pruebe una peque\u00f1a ejecuci\u00f3n de m\u00faltiples n\u00facleos.<\/li>\n<li>Medir antes de escalar. Ejecute un peque\u00f1o trabajo de cl\u00faster, mida la aceleraci\u00f3n y solo luego escala al tama\u00f1o de producci\u00f3n.<\/li>\n<li>Documente la configuraci\u00f3n. Guarde el archivo de entorno, el script de trabajo, el comando de inicio y la salida esperada.<\/li>\n<\/ol>\n<p>Establecer un flujo de trabajo de Python de HPC requiere comprender los paquetes cient\u00edficos de Python, la programaci\u00f3n en paralelo y la infraestructura de cl\u00fasteres. Si necesita ayuda con la paralelizaci\u00f3n de MPI, la programaci\u00f3n de trabajos o la reproducibilidad del entorno, nuestro equipo puede admitir flujos de trabajo cient\u00edficos escalables de Python, incluidas las simulaciones basadas en Fipy y los motores Monte Carlo personalizados.<\/p>\n"},"excerpt":{"rendered":"<p><span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 10<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span>Comida clave El c\u00f3digo Python puede ejecutarse en una computadora port\u00e1til y en un sistema HPC grande con la misma l\u00f3gica central cuando el flujo de trabajo usa MPi4PY o DASK correctamente. La reproducibilidad del medio ambiente es a menudo la parte m\u00e1s dif\u00edcil del trabajo de HPC. Los entornos de Conda, los archivos de [&hellip;]<\/p>\n","protected":false,"raw":""},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"es_ES","_original_post":"https:\/\/matforge.org\/?p=341","iawp_total_views":0,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-552","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.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Gu\u00eda de flujos de trabajo de HPC Python<\/title>\n<meta name=\"description\" content=\"Obtenga informaci\u00f3n sobre c\u00f3mo mover simulaciones de Python de la computadora port\u00e1til a los cl\u00fasteres de HPC utilizando scripts de trabajo Conda, MPI4PY, DASK, SLURM y reproducibles.\" \/>\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\/hpc-python-workflows-from-laptop-to-supercomputer\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Gu\u00eda de flujos de trabajo de HPC Python\" \/>\n<meta property=\"og:description\" content=\"Obtenga informaci\u00f3n sobre c\u00f3mo mover simulaciones de Python de la computadora port\u00e1til a los cl\u00fasteres de HPC utilizando scripts de trabajo Conda, MPI4PY, DASK, SLURM y reproducibles.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/\" \/>\n<meta property=\"og:site_name\" content=\"matforge.org\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-22T08:17:36+00:00\" \/>\n<meta name=\"author\" content=\"Elena Markovska\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Escrito por\" \/>\n\t<meta name=\"twitter:data1\" content=\"Elena Markovska\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data2\" content=\"16 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"},\"author\":{\"name\":\"Elena Markovska\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\"},\"headline\":\"Flujos de trabajo de HPC Python: de una computadora port\u00e1til a una supercomputadora\",\"datePublished\":\"2026-07-22T08:17:36+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"},\"wordCount\":2589,\"commentCount\":0,\"articleSection\":[\"Simulaci\u00f3n &amp; Proyectos de modelado\"],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\",\"name\":\"Gu\u00eda de flujos de trabajo de HPC Python\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"datePublished\":\"2026-07-22T08:17:36+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\"},\"description\":\"Obtenga informaci\u00f3n sobre c\u00f3mo mover simulaciones de Python de la computadora port\u00e1til a los cl\u00fasteres de HPC utilizando scripts de trabajo Conda, MPI4PY, DASK, SLURM y reproducibles.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/es\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/es\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Flujos de trabajo de HPC Python: de una computadora port\u00e1til a una supercomputadora\"}]},{\"@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\\\/980162bb5de46742daece973661d93da\",\"name\":\"Elena Markovska\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"caption\":\"Elena Markovska\"},\"sameAs\":[\"http:\\\/\\\/matforge.org\"],\"url\":\"https:\\\/\\\/matforge.org\\\/author\\\/elena-markovska\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Gu\u00eda de flujos de trabajo de HPC Python","description":"Obtenga informaci\u00f3n sobre c\u00f3mo mover simulaciones de Python de la computadora port\u00e1til a los cl\u00fasteres de HPC utilizando scripts de trabajo Conda, MPI4PY, DASK, SLURM y reproducibles.","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\/hpc-python-workflows-from-laptop-to-supercomputer\/","og_locale":"es_ES","og_type":"article","og_title":"Gu\u00eda de flujos de trabajo de HPC Python","og_description":"Obtenga informaci\u00f3n sobre c\u00f3mo mover simulaciones de Python de la computadora port\u00e1til a los cl\u00fasteres de HPC utilizando scripts de trabajo Conda, MPI4PY, DASK, SLURM y reproducibles.","og_url":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/","og_site_name":"matforge.org","article_published_time":"2026-07-22T08:17:36+00:00","author":"Elena Markovska","twitter_card":"summary_large_image","twitter_misc":{"Escrito por":"Elena Markovska","Tiempo de lectura":"16 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/"},"author":{"name":"Elena Markovska","@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da"},"headline":"Flujos de trabajo de HPC Python: de una computadora port\u00e1til a una supercomputadora","datePublished":"2026-07-22T08:17:36+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/"},"wordCount":2589,"commentCount":0,"articleSection":["Simulaci\u00f3n &amp; Proyectos de modelado"],"inLanguage":"es","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/","url":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/","name":"Gu\u00eda de flujos de trabajo de HPC Python","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"datePublished":"2026-07-22T08:17:36+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da"},"description":"Obtenga informaci\u00f3n sobre c\u00f3mo mover simulaciones de Python de la computadora port\u00e1til a los cl\u00fasteres de HPC utilizando scripts de trabajo Conda, MPI4PY, DASK, SLURM y reproducibles.","breadcrumb":{"@id":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/es\/hpc-python-workflows-from-laptop-to-supercomputer\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/es\/"},{"@type":"ListItem","position":2,"name":"Flujos de trabajo de HPC Python: de una computadora port\u00e1til a una supercomputadora"}]},{"@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\/980162bb5de46742daece973661d93da","name":"Elena Markovska","image":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","caption":"Elena Markovska"},"sameAs":["http:\/\/matforge.org"],"url":"https:\/\/matforge.org\/author\/elena-markovska\/"}]}},"_links":{"self":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/552","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/comments?post=552"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/552\/revisions"}],"predecessor-version":[{"id":737,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/552\/revisions\/737"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=552"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=552"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=552"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}