AI & ML

The rapid progress of deep learning has led to growing computational requirements, raising concerns about the associated energy consumption. Consequently, energy efficiency becomes an increasingly important research topic. A prerequisite for improving energy efficiency in neural network training is understanding the factors that influence the energy consumption. We provide an overview of current research analyzing the energy consumption in neural network training and discuss key insights and lessons learned toward the development of more energy-efficient training methods.

Do you need compute time for AI projects? Is your workstation or university cluster too small? Are you considering a project even on the largest scale? The National High Performance Computing Alliance (NHR) and Gauss Centre for Supercomputing (GCS) can help. We provide computing resources well suited for AI in twelve High Performance Computing (HPC) Centres. The best: this is for free for scientists who belong to a German research institution. In our web seminar, we will give an overview over the HPC landscape in Germany, provide an introduction of supercomputer/HPC architecture, and where and how to apply for compute time. We provide a starting point for you to bootstrap your compute time application to a German Tier 1 or 2 HPC Centre.

To tackle the rising demand for (generative) AI inference, especially in higher education, utilising already existing computing infrastructure like High-Performance Computing (HPC) seems to be a straightforward solution. However, the classical operating model of HPC is usually not tailored to the requirements of synchronous, user-facing applications. To tackle this, we propose a solution that fully integrates the cloud-native Kubernetes with HPC-native Slurm to deploy vLLM, a Large Language Model (LLM) inference-engine for high-throughput scenarios. Our solution allows for automatically scaling the number of deployed models based on actual hardware load, while leveraging the job scheduling mechanisms provided by Slurm to efficiently maximise load on inference hardware, thus freeing unneeded hardware for scientific computing jobs. In addition, we provide initial performance benchmarks for two typical HPC compute-node hardware configurations and an outlook on aspects we want to improve in the near future. As our solution is already running in a production scenario for an ever-increasing number of higher education institutions across North Rhine-Westphalia, we are open to discuss our experiences with this operating model following the presentation.

Presentation

This presentation starts with an introduction to the Model Context Protocol (MCP). We then look at how you might use it to connect tools to LLMs in Zed and how you can create your own MCP servers. 
Presentation

Open-source large language models are increasingly used across diverse applications and deployed on HPC systems to leverage acceleration hardware. For both users and the HPC community, inference latency is a key performance factor affecting responsiveness and efficiency. However, comparing performance across different models, frameworks, and configurations remains challenging.
In this session, we present BALI [1] -- A Benchmark for accelerated Language Model Inference. It allows users to run LLMs with a fixed configuration on different Inference frameworks, comparing their text generation speed under user defined/application dependent settings. We aim for a discussion with the HPC and LLM Community to identify which perspectives, metrics or measurements on LLM inference are needed mostly and in the future to assess their efficiency.

[1] - L. Jurkschat, P. Gattogi, S. Vahdati and J. Lehmann, "BALI—A Benchmark for Accelerated Language Model Inference," in IEEE Access, vol. 13, pp. 98976-98989, 2025, doi: 10.1109/ACCESS.2025.3576898.

Migrating machine learning workloads from local compute resources (e.g., laptops or workstations) to large-scale high-performance computing (HPC) systems offers significant computational advantages, particularly through access to high-performance GPUs. However, these powerful resources can also expose hidden I/O-related bottlenecks that limit the expected speedup of the workflow. This talk examines common pitfalls and strategies to mitigate the impact of data transfer and augmentation operations in such environments. The focus lies on practical steps and best practices to optimize and scale machine learning workflows on powerful compute nodes.

Presentation

We discuss relevant aspects, information sources, and common issues of compute jobs on HPC clusters. The main focus is a practical guide/recipe for beginners that should help everyone to detect and avoid common pitfalls. While we focus on GPU usage on HPC systems, the guide applies also to HPC workloads without GPUs.

Presentation

MLPerf Training HPC is the high performance computing (HPC) track of the MLPerf benchmark suite. It measures how efficiently supercomputers can train state of the art deep learning models at scale. Beyond comparing the efficiency of different systems, the benchmark shows us how to:
• launch and coordinate thousands of GPUs for large scale training;
• identify bottlenecks through systematic profiling; and
• write code that runs efficiently on modern HPC architectures.

In this presentation, we’ll begin by demonstrating NCCL tests on two JSC supercomputers—JUWELS Booster and JEDI (one rack of JUPITER)—and then dive into the official repositories designed for MLPerf Training HPC.

Presentation

Concept drift occurs when data distributions change over time. Evaluating workflows that include drift detection requires balancing predictive performance with computational cost, making it a multi-objective problem (e.g., accuracy vs. runtime). In this talk, a benchmark of several concept drift detection methods is presented, assessing both runtime and accuracy. Bayesian hyperparameter optimization is used to derive Pareto fronts that make the trade-offs between these metrics explicit. The results and key takeaways from the study are discussed.
Elias Werner, TU Dresden

This project demonstrates a pipeline with ZenML that uses LoRA, quantization, and PeFT to reduce the memory and computational overhead when finetuning large language models.

Targeted design of materials and systems with certain desired properties is an important and general task across many scientific and engineering domains, but is incredibly difficult due to its ill-defined, functionally inverse nature. Traditionally, brute-force approaches have instead been employed together with niche expertise to generate and analyse massive datasets for candidate materials or systems of interest, often incurring great time and computational expenses. Recently, deep learning methods have found a way to avoid such expensive forward design approaches, by modelling the inverse design function. In this talk, we discuss the general problems/approaches to inverse design, and we present two recent applications which show the feasibility and power of inverse design with deep learning. We then discuss other potential applications of these new modelling approaches.

A tool for hyperparameter optimization when you work with neural networks and Big Data. 
• Omniopt is applicable to a broad class of problems (both classical simulations and neural networks). 
• Omniopt is robust. It checks and installs all dependencies automatically and fixes many problems in the background without the user even noticing that they have occurred. 
• While Omniopt optimizes, no further intervention is required. You can follow the ongoing stdout (standard output) live in the console. 
• Omniopt’s overhead is minimal and virtually imperceptible

Presentation

https://lightning.ai/, https://github.com/ashleve/lightning-hydra-template

The Virtual Environment Template is a simple, customizable template how to build Python Virtual Environments on top of Easybuild packages. At the Jülich Supercomputing Centre, the environment can be readily used to create Jupyter Kernels.