{"id":23421,"date":"2023-09-07T09:25:57","date_gmt":"2023-09-07T07:25:57","guid":{"rendered":"https:\/\/info.gwdg.de\/news\/?p=23421"},"modified":"2023-10-13T08:02:02","modified_gmt":"2023-10-13T06:02:02","slug":"using-apptainer-containers-to-manage-your-python-environments","status":"publish","type":"post","link":"https:\/\/info.gwdg.de\/news\/using-apptainer-containers-to-manage-your-python-environments\/","title":{"rendered":"Using apptainer containers to manage your Python environments"},"content":{"rendered":"

When it comes to our High-Performance Computing (HPC) systems, efficiency is the name of the game. But are you managing your Python environments efficiently?<\/p>\n

Our HPC systems use network file systems that are optimized to access a small number of large files. This is particularly true for the parallel file systems that are used for the \/scratch directories (which uses the Lustre file system). Using a typical Python environment with many thousands of small files creates overhead for the file system and can slow down the loading time of your program significantly, as well as slowing down the file system for all other users of the cluster.<\/p>\n

In this article we learn how to put the Python environment inside a single container file instead, which greatly reduces the overhead on the file system. The used container definition files can also easily be tracked with version management to satisfy the requirements of scientific data management, similar to the source code you write.<\/p>\n

A more permanent version to this article with updates and fixes can be found at https:\/\/gitlab-ce.gwdg.de\/hpc-team-public\/science-domains-blog\/-\/blob\/main\/20230907_python-apptainer.md<\/a><\/p>\n

Sign up for NHR@G\u00f6ttingen<\/h2>\n

If you don’t have access yet you can create an NHR account at https:\/\/zulassung.hlrn.de\/<\/a>. This is free for all researchers associated with german universities. Is this your first time on any cluster? Check out our bonus material on cluster concepts<\/a>.<\/p>\n

<\/a>Apptainer on the Emmy & Grete systems<\/h3>\n

You can load the apptainer<\/code> module on the login servers glogin[0-9]<\/code><\/p>\n

\n
module load apptainer\r\n<\/span><\/code><\/pre>\n
 <\/p>\n<\/div>\n
You can run apptainer build<\/code> commands on the login nodes to create your container files, and submit a slurm job that uses apptainer run<\/code> to run them on the compute nodes. It is currently not possible to run them directly on the login nodes. Note that for testing the test queues as well as interactive sessions can be used to prevent waiting for your job to start only to figure out later that you forgot a semicolon in your code.<\/p>\n
To use the container you have to submit a slurm job to run them on one of the compute nodes.<\/p>\n
<\/a>I want to test it on my own system<\/h3>\n
You can also install apptainer on your local linux computer or virtual machine (VM). You can find the latest releases on https:\/\/github.com\/apptainer\/apptainer\/releases\/<\/a> If you don’t use Linux on your computer, you can also create a Virtual Machine (VM) with a Linux installation to test on (for example by using VirtualBox, VMWare Fusion or Parallels Desktop).<\/p>\n
On Ubuntu 22.04 LTS Desktop the following should be sufficient to install version 1.2.2 (which might be outdated by the time you are reading this):<\/p>\n
\n
sudo nala install fuse-overlayfs<\/span>\r\nwget https:\/\/github.com\/apptainer\/apptainer\/releases\/download\/v1.2.2\/apptainer_1.2.2_amd64.deb<\/span>\r\ndpkg -i apptainer_1.2.2_amd64.deb<\/span><\/code><\/pre>\n
 <\/p>\n<\/div>\n
Note:<\/strong> nala<\/code> is a more powerful and intuitive replacement for apt. If you don’t use nala<\/code> yet you can install it with sudo apt install nala<\/code> or use the old apt install<\/code> instead of nala install<\/code>. Check out nala history<\/code> in particular!<\/p>\n
<\/a>Can I run it on the GWDG Scientific Compute Cluster (SCC)?<\/h3>\n
We currently do not support building your own containers on SCC. If you bring your own container image container.sif<\/code> though (for example created on your own system, see previous section), you can run it:<\/p>\n
\n
module load singularity<\/span>\r\nsingularity run container.sif<\/span><\/code><\/pre>\n<\/div>\n
<\/a>General workflow<\/h2>\n
When working with apptainer, there are usually three steps involved:<\/p>\n
    \n
  1. Writing a container definition file (.def<\/em>) (or recipe<\/em>)<\/li>\n
  2. Using apptainer build<\/code> to create a container image file (.sif<\/em>) ( or baking<\/em> the recipe)<\/li>\n
  3. Using apptainer run<\/code> to run the container (if we continue with the metaphor, getting scientific results is like eating a cake)<\/li>\n<\/ol>\n
     <\/p>\n
    It is not necessary to do all of the steps on the same computer or even by the same person: you can exchange recipes with your colleagues, and also make container image files you created available for download.<\/p>\n
    In this tutorial we will exemplify the process by providing you recipes that you can build & run on our Emmy & Grete clusters.<\/p>\n
    <\/a>Editing text files on the cluster<\/h2>\n
    Please keep in mind that you don’t have to use terminal text editors like vim<\/code> and emacs<\/code> but can use the graphical text editor you might already be familiar with if you use an SFTP\/SCP client like FileZilla<\/em>, CyberDuck<\/em> or Transmit<\/em> or a text-editor with a built-in client. You need to provide the same hostname, username and SSH key as when logging in via the terminal. The details depend on your operating system and SFTP\/SCP client and might be more difficult for Windows users.<\/p>\n
    \"\"<\/a>
    Python apptainer<\/figcaption><\/figure>\n
     <\/p>\n
    On Linux your file browser probably already supports SFTP\/SCP without having to install anything. (If you use Gnome and you have setup the $HOME\/.ssh\/config<\/code> on your computer so that e.g. you only have to type ssh glogin-gpu<\/code> to connect to Grete, just enter ssh:\/\/glogin-gpu<\/code> in Files > + Other Locations > Connect To Server.)<\/p>\n
    <\/a>Miniconda container: Physics Example<\/h2>\n
    Don’t worry, you will not need any physics knowledge to run this example.<\/p>\n
    We want to install Quspin (https:\/\/quspin.github.io\/QuSpin\/<\/a>) in a container to simulate a many-body quantum system. Create the following Apptainer Definition File:<\/p>\n
    <\/a>quspin.def<\/code><\/h3>\n
    \n
    Bootstrap: docker<\/span>\r\nFrom: continuumio\/miniconda3<\/span>\r\n%post<\/span>\r\n    conda update -y conda<\/span>\r\n    conda install -y python=3.10<\/span>\r\n    conda install -y -c weinbe58 omp quspin <\/span><\/code><\/pre>\n
      <\/span><\/code><\/pre>\n<\/div>\n
    If we build this file, the official miniconda3 container will be fetched from https:\/\/hub.docker.com\/r\/continuumio\/miniconda3<\/a> and the commands in the %post<\/code> section will be run to install the quspin module before creating a single Singularity Image Format file (SIF). If you read this article in the far future, you might have to re-adjust the Python version from 3.10 to one that is currently supported by quspin.<\/p>\n
    \n
    $ apptainer build quspin.sif quspin.def<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    The creation of the SIF file can take a few minutes.
    \nWe can now fetch an example from the QuSpin project and try out our new container (we use srun here to start a slurm job on the Emmy cluster):<\/p>\n
    \n
    $ wget https:\/\/quspin.github.io\/QuSpin\/downloads\/be9497383fff21e4d03309a4d1a24ce1\/example5.py<\/span>\r\n$ srun -p medium40:test .\/quspin.sif python example5.py<\/span>\r\nsrun: job 4813650 queued and waiting for resources<\/span>\r\nsrun: job 4813650 has been allocated resources<\/span>\r\nHermiticity check passed!<\/span>\r\nSymmetry checks passed!<\/span>\r\nParticle conservation check passed!<\/span>\r\n$ <\/span><\/code><\/pre>\n<\/div>\n

    \nNote:<\/strong> If you are reading this in the future and the examples have changed, feel free to substitute a different example script from the QuSpin website.<\/p>\n
    Congratulations! You might have just simulated your first many-body quantum system! Feel free to explore the other quspin examples and simulate your favourite many-body quantum system.<\/p>\n
    Instead of explicitly executing the .sif file as an executable, you can also use the apptainer run command:<\/p>\n
    \n
    srun -p medium40:test apptainer run quspin.sif python example5.py <\/span><\/code><\/pre>\n<\/div>\n
    \n
    NOTE:<\/strong> By default your home directory on the cluster $HOME is mounted inside the container at the same location. If you need other directories — in particular $WORK and $TMPDIR — to be available inside the container, add e.g. --bind $WORK,$TMPDIR<\/code> to your apptainer run<\/code> command:<\/p>\n
    \n
    apptainer run --bind $WORK,$TMPDIR quspin.sif python example5.py <\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    Otherwise the files in your $WORK and $TMPDIR directories on Emmy\/Grete will not be visible inside the container, since they are not subdirectories of $HOME.<\/p>\n
    NOTE:<\/strong> If you have installed Python modules directly into your $HOME with pip, this might cause all sorts of problems (not just with apptainer but also conda and venv environments) and you might consider running the apptainer with –no-home and –bind only the directories you need explicitly.<\/p>\n
    You can check if you have those modules contaminating your container\/environment by running python -m pip list --user<\/code> inside the container\/environment and if you are sure you don’t need them<\/strong>, remove them with python -m pip uninstall <pkgname><\/code>.<\/p>\n
    <\/a>Running the quspin example on your own machine<\/h3>\n
    You will not be using the slurm resource manager if you are following the examples on your own machine. In that case you can execute the container directly:<\/p>\n
    \n
    .\/quspin.sif python example5.py<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    The other commands used were running directly on the login node and should also work on your computer.<\/p>\n
    <\/a>Python container with pip: Deep Learning Example<\/h2>\n
    In this example we will move the Python environment that is used for the A Beginner\u2019s Guide to Deep Learning with GPUs on Grete<\/strong> at https:\/\/info.gwdg.de\/news\/a-beginners-guide-to-deep-learning-with-gpus-on-grete\/<\/a> into a container. Since pip<\/code> is used to install the modules, we can use the official Python container and do not have to mix pip with conda (which can break your environments if you are not careful). Also it is always good to be less reliant on commercial software like Anaconda. We just need the Apptainer Definition File (.def) and a file with the modules we want pip to install which we will call requirements.txt<\/code>.<\/p>\n
    In this case we take the requirements.txt<\/code> from the Course gitlab repository: https:\/\/gitlab-ce.gwdg.de\/dmuelle3\/deep-learning-with-gpu-cores\/-\/blob\/main\/code\/requirements.txt<\/a>. Note that we use Python version 3.8 to match what is used in the course. You can check out what other versions are currently available at https:\/\/hub.docker.com\/_\/python<\/a>.<\/p>\n
    <\/a>deep-learning.def<\/code><\/h2>\n
    \n
    Bootstrap: docker<\/span>\r\nFrom: python:3.8<\/span>\r\n<\/span>\r\n%files<\/span>\r\n    $PWD\/requirements.txt requirements.txt<\/span>\r\n<\/span>\r\n%post<\/span>\r\n    pip install --root-user-action=ignore -r requirements.txt<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    We run the following commands:<\/p>\n
    \n
    wget https:\/\/gitlab-ce.gwdg.de\/dmuelle3\/deep-learning-with-gpu-cores\/-\/raw\/main\/code\/requirements.txt<\/span>\r\napptainer build --nv deep-learing.sif deep-learning.def<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    We can now test our container on the Grete cluster. We will use a simple test script:<\/p>\n
    <\/a>test-python-environment.py<\/code><\/h2>\n
    \n
    import torch<\/span>\r\nimport torch.nn as nn<\/span>\r\nimport torch.optim as optim<\/span>\r\ntorch.utils.collect_env<\/span>\r\nimport sklearn<\/span>\r\n<\/span>\r\nprint(sklearn.show_versions())<\/span>\r\n<\/span>\r\nprint(torch.__config__.show())<\/span>\r\n<\/span>\r\nprint(torch.utils.collect_env.get_pretty_env_info())<\/span>\r\n<\/span>\r\nif torch.cuda.is_available() and torch.cuda.device_count() > 0:<\/span>\r\n\tprint(\"Active CUDA device:\", <\/span>\r\n          torch.cuda.get_device_name(torch.cuda.current_device()))<\/span>\r\nelse:<\/span>\r\n        print(\"No active CUDA devices.\")<\/span>\r\n<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    We start an interactive job on a grete compute node:<\/p>\n
    \n
    $ salloc -t 01:00:00 -p grete:interactive -N1 -G V100:1<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    And then run the test script:<\/p>\n
    \n
    $ module load apptainer<\/span>\r\n$ apptainer run --bind $WORK,$TMPDIR --nv deep-learning.sif python test-python-environment.py <\/span>\r\n$ exit<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    NOTE:<\/strong> To get NVIDIA CUDA<\/em> support the --nv<\/code> option to the apptainer run<\/code> is required. On AMD ROCm<\/em> platforms this would instead be replaced by --rocm<\/code>.<\/p>\n
    Example output on Grete (shortened)<\/strong><\/p>\n
    \n
    login9:~\/deep-learning-test $ salloc -t 01:00:00 -p grete:interactive -N1 -G V100:1<\/span>\r\n[... snip ...]<\/span>\r\nsalloc: Nodes ggpu02 are ready for job<\/span>\r\nggpu02:~\/deep-learning-test $ module load apptainer<\/span>\r\nggpu02:~\/deep-learning-test $ apptainer run --bind $WORK,$TMPDIR --nv deep-learning.sif python test-python-environment.py <\/span>\r\n[... snip ...]<\/span>\r\nVersions of relevant libraries:<\/span>\r\n[pip3] numpy==1.24.2<\/span>\r\n[pip3] torch==2.0.0<\/span>\r\n[pip3] torchvision==0.15.1<\/span>\r\n[conda] Could not collect<\/span>\r\nActive CUDA device: Tesla V100S-PCIE-32GB<\/span>\r\nggpu02:~\/deep-learning-test $ exit<\/span>\r\nexit<\/span>\r\nsalloc: Relinquishing job allocation 4812554<\/span>\r\nsalloc: Job allocation 4812554 has been revoked.<\/span>\r\nglogin9:~\/deep-learning-test $ <\/span><\/code><\/pre>\n<\/div>\n
    \n
    Similarly the submit scripts from the course can be changed to use apptainer instead of anaconda3. For example, if we put the container file at $WORK\/deep-learning.sif, the code in submit_train.sh<\/code> could look like this:<\/p>\n
    \n
    # SBATCH ...<\/span>\r\nmodule load apptainer<\/span>\r\napptainer run --nv --bind \/scratch $WORK\/deep-learning.sif python train.py<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    Here we have bound the entire \/scratch<\/code> directory so we have access to $WORK, $TMPDIR and also the data folder in \/scratch\/projects\/workshops\/gpu-workshop<\/code> from inside the container.<\/p>\n
    To get the debug output that was previously provided by python -m torch.utils.collect_env<\/code> in the submit script, you can for example add the following line to the if __name__ == \"__main__\":<\/code> block in train.py<\/code><\/p>\n
    \n
    print(torch.utils.collect_env.get_pretty_env_info())<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    A more advanced usage would be to create a shell script that is executed inside the container (apptainer run ... run_train.sh<\/code>) that allows you to run e.g. multiple Python commands and emit extra debugging information about the container.<\/p>\n
    <\/a>Running the deep learning example on your own machine<\/h3>\n
    You will not be using the slurm resource manager if you are following the examples on your own machine. In that case you can execute the container directly:<\/p>\n
    \n
    apptainer run --nv deep-learning.sif python test-python-environment.py<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    If you don’t have a CUDA Stack you can also leave out the –nv flag. You should still see some output from PyTorch, even though the „Active CUDA device: …“ will be missing.<\/p>\n
    The other commands used were running directly on the login node and should also work on your computer.<\/p>\n
    <\/a>Using a sandbox<\/h2>\n
    While you are testing how to best build your container, you can skip the creation of the .sif<\/code> file and instead create a directory that contains all the individual files inside the container. If we change the earlier QuSpin example:<\/p>\n
    \n
    apptainer build --sandbox quspin quspin.def<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    You can now run commands inside the container (for a sandbox this will also work on the login nodes of NHR@G\u00f6ttingen!)<\/p>\n
    \n
    apptainer shell quspin<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    You can even make changes (for example to install software with apt, yum or pip) to the container if you use the following command:<\/p>\n
    \n
    apptainer shell --writable quspin<\/span><\/code><\/pre>\n
     <\/p>\n<\/div>\n
    If you are satisfied with the container you should add all the necessary commands to the .def<\/code> file and build a .sif<\/code> file for use on the cluster as shown in the previous sections, since the sandbox has all the same disadvantages for the file system that Python environments have.<\/p>\n
    <\/a>Other containers<\/h2>\n
    A few other interesting containers to start from are miniforge3 from conda-forge<\/a> with access to the large community driven package repository and NVIDIA CUDA<\/a> with the latest version of the NVIDIA CUDA Deep Neural Network library. Please be careful about only using containers from reputable sources!<\/p>\n
    I wish you a fun and educational time with apptainer!<\/p>\n
    Author<\/h2>\n
    Niklas B\u00f6lter
    \nhttps:\/\/gitlab-ce.gwdg.de\/hpc-team-public\/science-domains-blog\/-\/blob\/main\/20230907_python-apptainer.md<\/p>\n
    CUDA is a registered trademark of NVIDIA Corporation ROCm is a registered trademark of Advanced Micro Devices, Inc<\/p>\n
    \nAppendix: Example output on Grete (full, Click to expand)<\/summary>\n
    login9:~\/deep-learning-test $ salloc -t 01:00:00 -p grete:interactive -N1 -G V100:1
    \nsalloc: Pending job allocation 4812554
    \nsalloc: job 4812554 queued and waiting for resources
    \nsalloc: job 4812554 has been allocated resources
    \nsalloc: Granted job allocation 4812554
    \nsalloc: Waiting for resource configuration
    \nsalloc: Nodes ggpu02 are ready for job
    \nggpu02:~\/deep-learning-test $ module load apptainer
    \nggpu02:~\/deep-learning-test $ apptainer run –bind $WORK,$TMPDIR –nv deep-learning.sif python test-python-environment.py
    \nINFO: fuse: warning: library too old, some operations may not work
    \nINFO: underlay of \/usr\/bin\/nvidia-smi required more than 50 (517) bind mounts<\/p>\n
    System:
    \npython: 3.8.17 (default, Jul 28 2023, 06:03:56) [GCC 12.2.0]
    \nexecutable: \/usr\/local\/bin\/python
    \nmachine: Linux-4.18.0-425.19.2.el8_7.x86_64-x86_64-with-glibc2.34<\/p>\n
    Python dependencies:
    \nsklearn: 1.2.2
    \npip: 23.0.1
    \nsetuptools: 65.6.3
    \nnumpy: 1.24.2
    \nscipy: 1.10.1
    \nCython: None
    \npandas: 1.5.3
    \nmatplotlib: 3.7.1
    \njoblib: 1.2.0
    \nthreadpoolctl: 3.1.0<\/p>\n
    Built with OpenMP: True<\/p>\n
    threadpoolctl info:
    \nuser_api: openmp
    \ninternal_api: openmp
    \nprefix: libgomp
    \nfilepath: \/usr\/local\/lib\/python3.8\/site-packages\/torch\/lib\/libgomp-a34b3233.so.1
    \nversion: None
    \nnum_threads: 1<\/p>\n
    user_api: blas
    \ninternal_api: openblas
    \nprefix: libopenblas
    \nfilepath: \/usr\/local\/lib\/python3.8\/site-packages\/numpy.libs\/libopenblas64_p-r0-15028c96.3.21.so
    \nversion: 0.3.21
    \nthreading_layer: pthreads
    \narchitecture: SkylakeX
    \nnum_threads: 1<\/p>\n
    user_api: openmp
    \ninternal_api: openmp
    \nprefix: libgomp
    \nfilepath: \/usr\/local\/lib\/python3.8\/site-packages\/scikit_learn.libs\/libgomp-a34b3233.so.1.0.0
    \nversion: None
    \nnum_threads: 1<\/p>\n
    user_api: blas
    \ninternal_api: openblas
    \nprefix: libopenblas
    \nfilepath: \/usr\/local\/lib\/python3.8\/site-packages\/scipy.libs\/libopenblasp-r0-41284840.3.18.so
    \nversion: 0.3.18
    \nthreading_layer: pthreads
    \narchitecture: SkylakeX
    \nnum_threads: 1
    \nNone
    \nPyTorch built with:
    \n– GCC 9.3
    \n– C++ Version: 201703
    \n– Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications
    \n– Intel(R) MKL-DNN v2.7.3 (Git Hash 6dbeffbae1f23cbbeae17adb7b5b13f1f37c080e)
    \n– OpenMP 201511 (a.k.a. OpenMP 4.5)
    \n– LAPACK is enabled (usually provided by MKL)
    \n– NNPACK is enabled
    \n– CPU capability usage: AVX2
    \n– CUDA Runtime 11.7
    \n– NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86
    \n– CuDNN 8.5
    \n– Magma 2.6.1
    \n– Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.7, CUDNN_VERSION=8.5.0, CXX_COMPILER=\/opt\/rh\/devtoolset-9\/root\/usr\/bin\/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wunused-local-typedefs -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.0.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF,<\/p>\n
    PyTorch version: 2.0.0+cu117
    \nIs debug build: False
    \nCUDA used to build PyTorch: 11.7
    \nROCM used to build PyTorch: N\/A<\/p>\n
    OS: Debian GNU\/Linux 12 (bookworm) (x86_64)
    \nGCC version: (Debian 12.2.0-14) 12.2.0
    \nClang version: Could not collect
    \nCMake version: version 3.26.1
    \nLibc version: glibc-2.36<\/p>\n
    Python version: 3.8.17 (default, Jul 28 2023, 06:03:56) [GCC 12.2.0] (64-bit runtime)
    \nPython platform: Linux-4.18.0-425.19.2.el8_7.x86_64-x86_64-with-glibc2.34
    \nIs CUDA available: True
    \nCUDA runtime version: Could not collect
    \nCUDA_MODULE_LOADING set to: LAZY
    \nGPU models and configuration: GPU 0: Tesla V100S-PCIE-32GB
    \nNvidia driver version: 530.30.02
    \ncuDNN version: Could not collect
    \nHIP runtime version: N\/A
    \nMIOpen runtime version: N\/A
    \nIs XNNPACK available: True<\/p>\n
    CPU:
    \nArchitecture: x86_64
    \nCPU op-mode(s): 32-bit, 64-bit
    \nAddress sizes: 46 bits physical, 48 bits virtual
    \nByte Order: Little Endian
    \nCPU(s): 80
    \nOn-line CPU(s) list: 0-79
    \nVendor ID: GenuineIntel
    \nModel name: Intel(R) Xeon(R) Gold 6248 CPU @ 2.50GHz
    \nCPU family: 6
    \nModel: 85
    \nThread(s) per core: 2
    \nCore(s) per socket: 20
    \nSocket(s): 2
    \nStepping: 7
    \nCPU(s) scaling MHz: 38%
    \nCPU max MHz: 3900.0000
    \nCPU min MHz: 1000.0000
    \nBogoMIPS: 5000.00
    \nFlags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc art arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc cpuid aperfmperf pni pclmulqdq dtes64 monitor ds_cpl smx est tm2 ssse3 sdbg fma cx16 xtpr pdcm pcid dca sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm abm 3dnowprefetch cpuid_fault epb cat_l3 cdp_l3 invpcid_single intel_ppin ssbd mba ibrs ibpb stibp ibrs_enhanced fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid cqm mpx rdt_a avx512f avx512dq rdseed adx smap clflushopt clwb intel_pt avx512cd avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves cqm_llc cqm_occup_llc cqm_mbm_total cqm_mbm_local dtherm ida arat pln pts pku ospke avx512_vnni md_clear flush_l1d arch_capabilities
    \nL1d cache: 1.3 MiB (40 instances)
    \nL1i cache: 1.3 MiB (40 instances)
    \nL2 cache: 40 MiB (40 instances)
    \nL3 cache: 55 MiB (2 instances)
    \nNUMA node(s): 2
    \nNUMA node0 CPU(s): 0-19,40-59
    \nNUMA node1 CPU(s): 20-39,60-79
    \nVulnerability Itlb multihit: KVM: Mitigation: VMX unsupported
    \nVulnerability L1tf: Not affected
    \nVulnerability Mds: Not affected
    \nVulnerability Meltdown: Not affected
    \nVulnerability Mmio stale data: Mitigation; Clear CPU buffers; SMT vulnerable
    \nVulnerability Retbleed: Mitigation; Enhanced IBRS
    \nVulnerability Spec store bypass: Mitigation; Speculative Store Bypass disabled via prctl
    \nVulnerability Spectre v1: Mitigation; usercopy\/swapgs barriers and __user pointer sanitization
    \nVulnerability Spectre v2: Mitigation; Enhanced IBRS, IBPB conditional, RSB filling, PBRSB-eIBRS SW sequence
    \nVulnerability Srbds: Not affected
    \nVulnerability Tsx async abort: Mitigation; TSX disabled<\/p>\n
    Versions of relevant libraries:
    \n[pip3] numpy==1.24.2
    \n[pip3] torch==2.0.0
    \n[pip3] torchvision==0.15.1
    \n[conda] Could not collect
    \nActive CUDA device: Tesla V100S-PCIE-32GB
    \nggpu02:~\/deep-learning-test $ exit
    \nexit
    \nsalloc: Relinquishing job allocation 4812554
    \nsalloc: Job allocation 4812554 has been revoked.
    \nglogin9:~\/deep-learning-test $<\/p>\n<\/details>\n","protected":false},"excerpt":{"rendered":"
    When it comes to our High-Performance Computing (HPC) systems, efficiency is the name of the game. But are you managing your Python environments efficiently? Our HPC systems use network file systems that are optimized to access a small number of large files. This is particularly true for the parallel file systems that are used for … Weiterlesen<\/a><\/p>\n","protected":false},"author":166,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1,129],"tags":[],"class_list":["post-23421","post","type-post","status-publish","format-standard","hentry","category-alle","category-wissenschaftliche-domaenen"],"_links":{"self":[{"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts\/23421","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/users\/166"}],"replies":[{"embeddable":true,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/comments?post=23421"}],"version-history":[{"count":17,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts\/23421\/revisions"}],"predecessor-version":[{"id":23446,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts\/23421\/revisions\/23446"}],"wp:attachment":[{"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/media?parent=23421"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/categories?post=23421"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/tags?post=23421"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}