Back to home

High-Performance Machine Learning at Columbia University

COMS E6998, taught by Dr. Kaoutar El Maghraoui

High-Performance Machine Learning (HPML) covers the systems and hardware techniques used to train and serve machine-learning models efficiently. Students work across the model, framework, compiler, runtime, and accelerator stack, and they learn to measure performance, find what is slow, and judge the trade-offs an optimization makes. The course uses PyTorch and CUDA, and the work is done on real GPUs.

Who the course is for

HPML is a graduate course on the systems and hardware side of machine learning. It is for students who want to understand how machine-learning systems actually run, from GPU execution and memory to distributed training, model compression, and large language model serving.

The course is built on understanding and measurement. Students profile real workloads, apply a technique they can defend against that profile, and report before-and-after results on GPU hardware. The work is project-based, and projects can connect to current research problems.

The HPML stack from models to systems: five stacked layers labeled Model (architectures, attention, transformers), Framework (PyTorch tensors, autograd, operators), Compiler (torch.compile, graph capture and fusion), Runtime (dispatcher, kernel launches, data loading), and Accelerator (GPU memory hierarchy, CUDA, bandwidth).
HPML works across five layers, from the model to the accelerator. Most of the speedups come from how these layers interact.

In the classroom

Dr. Kaoutar El Maghraoui teaching the Fall 2026 HPML lecture on PyTorch performance and torch.compile at Columbia University.
Lecture on PyTorch performance and torch.compile, Fall 2026.
Dr. Kaoutar El Maghraoui teaching the Fall 2026 HPML lecture on fused attention kernels and scaled dot-product attention backends at Columbia University.
Lecture on fused attention kernels, Fall 2026.

What students learn

The course covers the full stack. The current syllabus is the authoritative source for the schedule and the exact topics in a given offering. The areas below describe the scope.

Performance methodology and PyTorch

  • Profiling with the PyTorch Profiler and NVIDIA Nsight
  • JIT compilation and the HPC and AI landscape
  • Data-loading and input-pipeline optimization

GPU and parallel computing

  • The CUDA programming model
  • Memory hierarchy and shared memory
  • Distributed training, All-Reduce, and NCCL

Model compression and efficiency

  • Pruning and sparsity
  • Quantization (post-training and quantization-aware)
  • Knowledge distillation

Efficient LLM inference and serving

  • FlashAttention and KV-cache management
  • vLLM and PagedAttention
  • Speculative decoding and LoRA / QLoRA fine-tuning

Neural architecture search and projects

  • Neural Architecture Search and hardware-aware NAS
  • A measured final project, presented to the class

Prerequisites and how the course works

The course assumes proficiency in Python, a working knowledge of machine-learning fundamentals, and comfort with programming and the command line. Prior exposure to computer-systems concepts is helpful. The current syllabus is the authoritative source for prerequisites and enrollment details.

HPML is organized around measurement. The habit the course builds is to measure first, change one thing, and measure again. Students open a project by profiling a training or inference workload, so they can see where the time actually goes across data loading, host-to-device transfer, and compute, and only then apply a technique they can defend against that profile. Each project reports before-and-after numbers on GPU hardware.

The term combines lectures, discussion of research papers, hands-on programming assignments, and a final project that students present to the class. The current syllabus is the authoritative source for the schedule, assignments, and assessment in any given semester.

The measurement-first loop taught in HPML: profile with the PyTorch Profiler and NVIDIA Nsight, find the bottleneck in data loading, host-to-device transfer, or compute, apply one change such as quantization, batching, caching, or distribution, then measure again by logging before-and-after results on GPU hardware in Weights and Biases, and repeat.
The habit the course builds: profile, change one thing you can defend, measure again, and log the result.

From class projects to research

HPML projects connect systems concepts to measurable implementation and open research questions. In the Spring 2026 offering, several teams worked on open problems brought in from IBM Research, mentored by Dr. Dhaval Patel and Shuxin Lin. Five of those projects became arXiv preprints, and one, PHMForge, was accepted at NeurIPS 2026. The examples below describe the students' contributions and link to the original work. For the full account, see From class projects to research innovation.

A benchmark that tests whether an LLM agent can act reliably on prognostics and health-management tasks by calling real algorithms through MCP rather than reasoning over text, with 99 expert-authored scenarios across eight asset classes.

Yusheng Li, Tianjun Feng, Yunfeng Chen, Chun-Yi Tsai, Yihan Sun, with Ayan Das (Georgia Tech); advised by Kaoutar El Maghraoui, Shuxin Lin, and Dhaval Patel

A position paper arguing that a single aggregate benchmark score does not transfer reliably when the data distribution changes, and proposing predictive validity as the measure to rank by instead.

Dhaval Patel, Kaoutar El Maghraoui, Shuxin Lin, et al.

A temporal semantic cache that reuses a stored agent result only when it is still valid for the new query, cutting latency without returning stale answers.

Alimurtaza Merchant, Krish Veera, Sajal Kumar Goyla, Shambhawi Bhure, Dhaval Patel, Kaoutar El Maghraoui

A three-stage generator with a validate-and-repair loop that expands an agent benchmark beyond hand-authored scenarios while preserving scenario quality.

Sagar Chethan Kumar, Rohith Kanathur, Dhaval Patel, Kaoutar El Maghraoui

Moving a fixed tool catalog out of the prompt and into a small model's weights with QLoRA, cutting input length while preserving planning quality.

Yuval Shemla, Ayal Yakobe, Tanmay Agarwal, Dhaval Patel, Kaoutar El Maghraoui

Tally as of October 2026: five arXiv preprints from the Spring 2026 class, one of them (PHMForge) accepted at NeurIPS 2026. The other four are preprints under extension for submission.

Earlier offerings

HPML projects have produced published work in earlier years as well. One example:

A neural-architecture-search and knowledge-distillation approach that accelerates medical image segmentation for resource-constrained deployment.

Arnold Caleb Asiimwe, William Das, Hadjer Benmeziane, Kaoutar El Maghraoui

Syllabus and course resources

The public syllabus is the authoritative source for the current topics, prerequisites, and policies. The student-research article describes a recent set of course projects in technical detail.

What students say

A great semester in Scaling LLMs, and again in HPML — lucky to be taking these courses. Hoping to learn more and more in these fields over time.
Graduate student
Scaling LLMs & High-Performance Machine Learning
Columbia CTL Thank-a-Prof, 2026

Students have also discussed the course in independent threads on Reddit, which are unaffiliated with Columbia University and are not verified representations of overall student experience: May 2024 discussion and a January 2025 discussion.

More on teaching at Columbia

HPML is one of two graduate courses I teach at Columbia University. The teaching section on the homepage covers both, including the Scaling LLMs research seminar and my teaching philosophy.