{"id":24051,"date":"2024-09-18T15:07:53","date_gmt":"2024-09-18T13:07:53","guid":{"rendered":"https:\/\/info.gwdg.de\/news\/?p=24051"},"modified":"2024-09-19T07:53:20","modified_gmt":"2024-09-19T05:53:20","slug":"deep-learning-containers-in-hpc","status":"publish","type":"post","link":"https:\/\/info.gwdg.de\/news\/deep-learning-containers-in-hpc\/","title":{"rendered":"Deep Learning Containers in HPC"},"content":{"rendered":"

Reliable software environments are often a problem for data scientists. This becomes an issue especially when the analysis needs to be run on different machines \u2013 colleagues laptop, cloud VM or HPC cluster. Here we introduce the idea of containerised software environments in the use case of a deep learning workflow. A more general view on this has already been described in our blog post Declutter your Python environments<\/a>.<\/p>\n

A more permanent version of this article with updates and fixes can be found in our GitLab Repository<\/a>.<\/p>\n

\"\"<\/a>
Overview of a deep learning container. This example deep learning container may be a bit overloaded, but it shows the flexibility and versatility you can get when using containers to wrap your software environment.<\/figcaption><\/figure>\n

Why? Lets ask Chat AI<\/a><\/h3>\n

What are the five most important benefits of using containers in my machine learning workflow?<\/p>\n

    \n
  1. Consistency and Reproducibility<\/strong>: Containers ensure that your ML environment is consistent across different machines and environments, making it easier to reproduce results and collaborate with others.<\/li>\n
  2. Dependency Management<\/strong>: Containers simplify dependency management by packaging all required libraries and dependencies within the container, eliminating version conflicts and ensuring that your ML code runs smoothly.<\/li>\n
  3. Isolation and Security<\/strong>: Containers provide a sandboxed environment for your ML code, isolating it from the host system and preventing potential security risks, such as data breaches or malware infections.<\/li>\n
  4. Portability and Flexibility<\/strong>: Containers are highly portable, allowing you to move your ML workloads between different environments, such as development, testing, and production, without worrying about compatibility issues.<\/li>\n
  5. Efficient Resource Utilization<\/strong>: Containers can run multiple ML workloads on a single machine, maximizing resource utilization and reducing the need for additional hardware.<\/li>\n<\/ol>\n

     <\/p>\n

    Credits: Here the self-hosted model LLaMA 3 70B Instruct was used to generate this answer. Only an excerpt of the original answer is shown here.<\/p>\n

    Building the container \ud83d\udee0\ufe0f<\/h2>\n
    me@local-machine~ % ssh grete\r\n[me@glogin9 ~]$ cd \/path\/to\/deep-learning-with-gpu-cores\/code\/container\r\n[me@glogin9 ~]$ bash build_dlc-dlwgpu.sh\r\n<\/pre>\n
     <\/p>\n
    The container can be built on our various HPC clusters using the build_dlc-*.sh<\/code> scripts. Details on how to use Apptainer and the process of building containers are described in our documentation<\/a> and our blog article Decluttering your Python environments<\/a>. Running build_dlc-dlwgpu.sh<\/code> will build an image with the software used for our workshop example, as defined in dlc-dlwgpu.def<\/code>. Contrary to the traditional way of using conda to install all packages defined in a requirements.txt<\/code> file, pip is used here to reduce the number of software packages used. However, there are good reasons to use conda, so build_dlc-conda-example.sh<\/code> shows a minimal example of installing Python packages in a container using conda (see dlc-conda-example.def<\/code>).<\/p>\n
    If you encounter errors while building the container, have a look at build_dlc-dlwgpu.log<\/code> or build_dlc-conda-example.log<\/code>. You can also use cat<\/code> (in a different terminal) to see the progress of the image building process.<\/p>\n
    The image can now be used on our JupyterHub service or via the command line on our HPC systems. We recommend using JupyterHub for the initial phase of a project to set up the workflow and for data exploration. Compute-intensive workloads, such as model training, should be run on the HPC cluster using SLURM. This allows users to execute computational jobs in a very flexible and customisable way, making the best use of the available computing resources.<\/p>\n
    Using the container on HPC JupyterHub<\/h3>\n
    Below are two examples of how to use HPC JupyterHub. The first example shows the use of a JupyterNotebook for data exploration. The second example is about testing the software environment to ensure that everything is set up correctly, e.g. CUDA for GPU acceleration.<\/p>\n
    \"\"<\/a>
    Screenshot of the HPC JupyterHub with examples<\/figcaption><\/figure>\n
    <\/div>\n
    \n
    1. visit https:\/\/jupyter.hpc.gwdg.de<\/div>\n
    2. click on the „Sign in with AcademicCloud“ button<\/div>\n
    3. start your server with the following options (everything else is default)<\/div>\n
    – Select a job profile: `GWDG HPC with own Container`<\/div>\n
    – Set your own Apptainer container location: `$WORK\/dlc-dlwgpu.sif`<\/div>\n
    – Jupyter Notebook’s Home directory: `\/path\/to\/deep-learning-with-gpu-cores\/`<\/div>\n
    4. run the code<\/div>\n
    – Notebook: Open `\/path\/to\/deep-learning-with-gpu-cores\/code\/notebooks\/00.1-inital-data-exploration.ipynb`<\/div>\n
    – Python file:<\/div>\n
    – Open `\/path\/to\/deep-learning-with-gpu-cores\/test_env.py`.<\/div>\n
    – [Create Console for Editor](https:\/\/jupyterlab.readthedocs.io\/en\/stable\/user\/documents_kernels.html) and run the code in the console.<\/div>\n
    5. Stop the JupyterHub server<\/div>\n
    – File -> Hub Control Panel -> Stop My Server<\/div>\n<\/div>\n
    <\/a>Using the container via CLI on the HPC<\/h3>\n
    The full potential of an HPC cluster can only be utilised using the command line interface (CLI). Workflows can be optimized for the available hardware, such as different accelerators (e.g. GPUs, NPU, …) and highly parallel workflows. Here a simple workflow using our workshops example is shown, based on the same container, that was used in JupyterHub. For more details please have a look at our documentation<\/a>, e.g. on Slurm\/GPU Usage<\/a> and GPU Partitions<\/a>.<\/p>\n
    <\/a>Interactive HPC usage<\/h4>\n
    Using an HPC cluster interactively gives you direct access to the cluster’s compute resources. This can be particularly useful for optimising your workflow on the HPC. For the interactive usage first the compute ressources are requested (salloc<\/code>). On the requested compute node, a shell is started within the container, allowing code to be executed with the pre-built software environment. In this example, the software environment is tested to make sure that everything works as intended, such as the correct use of CUDA for GPU acceleration (test_env.py<\/code>).<\/p>\n
    cd <\/span>path\/to\/deep-learning-with-gpu-cores\/code\/\r\n\r\n# get available GPUs with (see docs.hpc.gwdg.de\/usage_guide\/slurm\/gpu_usage\/)<\/span>\r\n# sinfo -o \"%25N  %5c  %10m  %32f  %10G %18P \" | grep gpu<\/span>\r\n\r\nsalloc -t<\/span> 01:00:00 -p<\/span> grete:interactive -N1<\/span> -G<\/span> 3g.20gb\r\n\r\nmodule load apptainer\r\n\r\napptainer exec<\/span> --nv<\/span> --bind<\/span> \/scratch dlc.sif bash\r\n\r\npython ..\/test_env.py\r\n<\/pre>\n
     <\/p>\n
    Author<\/h3>\n
    Hauke Kirchner<\/a><\/p>\n
    This article was first published in scope of the workshop Deep learning with GPU cores<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Reliable software environments are often a problem for data scientists. This becomes an issue especially when the analysis needs to be run on different machines \u2013 colleagues laptop, cloud VM or HPC cluster. Here we introduce the idea of containerised software environments in the use case of a deep learning workflow. A more general view … 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":[132,133,129],"tags":[],"class_list":["post-24051","post","type-post","status-publish","format-standard","hentry","category-forstwirtschaften","category-kuenstliche-intelligenz","category-wissenschaftliche-domaenen"],"_links":{"self":[{"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts\/24051","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=24051"}],"version-history":[{"count":21,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts\/24051\/revisions"}],"predecessor-version":[{"id":24090,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/posts\/24051\/revisions\/24090"}],"wp:attachment":[{"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/media?parent=24051"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/categories?post=24051"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/info.gwdg.de\/news\/wp-json\/wp\/v2\/tags?post=24051"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
    HPC usage via batch scripts<\/h3>\n
    Finally, the defined workflow can be submitted as a job to the workload manager SLURM<\/a>. To do this, a job script needs to be defined and submitted via sbatch<\/code>. As you already have a lot of experience with the containerised software environment, starting on your local machine and JupyterHub, a major point of failure when scaling up your analysis and moving to HPC systems has become unlikely.<\/p>\n
    sbatch path\/to\/deep-learning-with-gpu-cores\/code\/submit_train_dlc.sh
    \n<\/code><\/p>\n