GPU and accelerators
Rescale offers a set of GPU coretypes for AI training, inference, physics-informed neural networks, and solvers that target NVIDIA hardware directly. This page covers the GPU coretypes available on the platform, how to pick one for your workload, how to run NVIDIA NGC Catalog containers and NVIDIA Modulus on those coretypes, and how to monitor the GPU while a job is running.
Choosing a GPU coretype
GPU coretypes on Rescale pair an NVIDIA GPU with a CPU host. Some coretypes use Intel Xeon hosts; others use AMD EPYC. Both the GPU model and the host matter: the GPU sets the ceiling for training throughput, and the host determines how fast data can be staged in and out.
The GPU models currently present in the coretype portfolio include NVIDIA A100 (with 40 GB and 80 GB memory variants), NVIDIA H100, and NVIDIA V100. Rescale also exposes coretypes with NVIDIA P100 for legacy workloads.
Representative GPU coretypes
Use Coretype Explorer to filter GPU coretypes by GPU model, GPUs per node, host memory per core, and price. See Coretype Explorer.
Recommended GPU coretypes for NVIDIA Modulus
For NVIDIA Modulus, the published recommendations are:
- NVIDIA A100. Ankerite, Celestine.
- NVIDIA V100. Dolomite, Aquamarine V3.
- NVIDIA P100. Aquamarine V2.
When GPU acceleration helps
GPU coretypes are the right choice when:
- You are training or fine-tuning a deep learning model.
- You are running a GPU-accelerated solver (for example, ANSYS Fluent GPU solver, LAMMPS with the GPU package, MATLAB GPU arrays).
- You are building physics-informed neural networks with NVIDIA Modulus or a similar framework.
- You need the interactive GPU visualization capabilities of a Rescale Workstation.
If your solver does not support GPUs, a GPU coretype does not help. CPU-bound MPI workloads should stay on a High-Speed Interconnect CPU coretype from the general Coretypes catalog.
Running NVIDIA NGC Catalog containers on Rescale
NVIDIA GPU Cloud (NGC) Catalog is a curated set of GPU-optimized containers for AI, HPC, and visualization, along with pre-trained models, Helm charts, and industry SDKs. Rescale exposes NGC Catalog as a software tile so that you can pull and run containers inside a batch job or a Workstation without standing up your own container infrastructure.
Batch job
To run an NGC container as a batch job, create a Basic Job, upload scripts or inputs as input files, and pick the NVIDIA NGC Catalog tile on the Software step. In the Command box, paste the prepopulated login command and then pull and run your container. For a TensorFlow training example:
docker pull nvcr.io/nvidia/tensorflow:22.06-tf1-py3
docker run --gpus all -v ${PWD}/test:/test nvcr.io/nvidia/tensorflow:22.06-tf1-py3 \
bash -c 'cd /test; python test.py'
Under License Options, check Use Existing License and enter your NGC API key and Org code (generate the key from your NGC account). On the Hardware step, pick a GPU coretype and the number of GPUs you want; the --gpus all flag passes every GPU in the slot to the container. Submit the job and watch process_output.log for training output.
Workstation
For interactive development, create a new Workstation, upload inputs, pick the NGC Catalog Interactive Workflow tile on the Software step, and enter your NGC API key and Org code under License Options. When the Workstation is ready, connect via the Rescale browser session or the local NICE DCV client, then log in to NGC and pull containers from a terminal:
echo -e "\n \n $(echo $NGC_ORG_ID) \n \n \n" | ngc config set
docker login -u '$oauthtoken' --password-stdin nvcr.io <<< $(echo $NGC_CLI_API_KEY)
docker pull nvcr.io/nvidia/tensorflow:22.06-tf1-py3
docker run --gpus all -it --rm -v ${PWD}/test:/test \
nvcr.io/nvidia/tensorflow:22.06-tf1-py3 bash
For visualization, pull the ParaView container and open the DCV web browser at https://localhost:8080/.
Running NVIDIA Modulus on Rescale
NVIDIA Modulus is a neural network framework that combines governing PDEs with data to build parameterized surrogate models. You can run it on Rescale as either a batch job or interactively on a workstation.
For a batch job on a GPU coretype, use a Singularity (Apptainer) image and scale with MPI:
mpirun -np $[$RESCALE_GPUS_PER_NODE*$RESCALE_NODES_PER_SLOT] \
-N $RESCALE_GPUS_PER_NODE \
singularity exec --nv /usr/bin/Modulus_v21.06.sif python your-code.py
Add --xla=True at the end of the command to enable Accelerated Linear Algebra for training.
For multi-node jobs, create the checkpoint directory before the first run so that the container picks it up:
mkdir network_checkpoint_ldc_2d
mpirun -np $[$RESCALE_GPUS_PER_NODE*$RESCALE_NODES_PER_SLOT] \
-N $RESCALE_GPUS_PER_NODE \
singularity exec --nv /usr/bin/Modulus_v21.06.sif python ldc_2d.py
Results land in ~/work/shared. For interactive development, launch a GPU workstation, open a terminal, and start Jupyter Notebook, TensorBoard, or ParaView from inside the Singularity container. A full GUI on multiple GPUs.
Monitoring GPU utilization
While a GPU job is running, open a terminal from the job's Status page (click Open in new window) and run:
nvidia-smi
This shows per-GPU utilization, memory usage, power draw, and active processes. On Workstations, you can also use NVDashboard inside JupyterLab or Jupyter Notebook for a graphical view. See the KB articles linked in Citations for step-by-step guides.