Teachings | HAMZEH'S WEBPAGE

EECS 4224

Tue, 01 Sep 2026 00:00:00 +0000

This course analyzes the systems engineering principles required to build, deploy, and maintain machine learning systems at scale. It examines the architecture of data pipelines, distributed training strategies, and low-latency model serving frameworks. Students evaluate trade-offs between computational efficiency, scalability, and reliability while gaining hands-on experience with hardware accelerators and cloud-based ML infrastructure. Prerequisites: LE/EECS 3221 3.00 and (LE/EECS 3404 3.00 or LE/EECS 3405 3.00 or LE/CSSD 3131 3.00).

This course focuses on the design and implementation of machine learning systems in production settings, with an emphasis on scalability, performance, and reliability. It covers the end-to-end ML lifecycle, including data ingestion, feature engineering, distributed training, model evaluation, and deployment. Students explore system-level challenges such as resource management, fault tolerance, and hardware acceleration (e.g., GPUs), as well as trade-offs between latency, throughput, and cost in cloud environments.

The course adopts a systems-oriented perspective, drawing on concepts from distributed systems and software engineering. Students engage with modern ML infrastructure and frameworks, and complete programming assignments and a substantial project that involves building and optimizing components of real-world ML systems. Case studies from industry and recent research are used to illustrate practical design patterns and emerging trends in ML systems.

Tentative topics:

Introduction to ML systems: overview of the ML system lifecycle; model-centric vs. system-centric perspectives; case studies of production ML systems.
Data pipelines and feature engineering systems: data ingestion, preprocessing, feature stores, data validation, and pipeline orchestration.
Storage systems for ML: distributed storage, data formats, batch vs. streaming systems, data locality.
Distributed training: parallelism strategies (data, model, pipeline parallelism), distributed ML frameworks, parameter servers, all-reduce, communication efficiency, and fault tolerance.
Hardware acceleration: GPUs, TPUs and accelerators, memory hierarchies, performance optimization techniques.
Model serving systems: batch vs. online inference, serving architectures, serverless vs. serverful, latency, throughput, and scaling challenges.
Caching, optimization, and resource management: caching strategies, scheduling, autoscaling, quantization, pruning, distillation, and cost-performance trade-offs in cloud environments.
ML system reliability and monitoring: logging, monitoring, debugging, and system failures.
Edge computing and mobile ML: edge computing architecture, model compression, on-device inference frameworks, federated learning.
MLOps and continuous deployment: CI/CD for ML, model lifecycle management, governance, and ethical considerations.
Emerging topics: foundation models, distributed inference, serverless ML, and student project presentations.

By the end of this course, students will be able to:

Design and implement end-to-end machine learning systems architecture.
Engineer scalable data pipelines for ML workloads.
Deploy and monitor ML models in production environments.
Implement testing and quality assurance practices for ML systems.
Optimize ML systems for performance and cost-effectiveness.
Apply MLOps practices to ensure reproducibility and maintainability of ML systems.

This new course will be offered starting Fall 2027.

EECS 3221

Mon, 01 Jan 2018 00:00:00 +0000

This course is intended to teach students the fundamental concepts that underlie operating systems, including multiprogramming, concurrent processes, CPU scheduling, deadlocks, memory management, file systems, protection and security. Many examples from real systems are given to illustrate the application of particular concepts. At the end of this course, a student will be able to understand the principles and techniques required for understanding and designing operating systems.

I have been teaching this course every year since 2019.

EECS 4222

Mon, 01 Jan 2018 00:00:00 +0000

This is an introductory course in Distributed Computing Systems. This course is the study of how to design and implement a computer system where the state of the system is divided over multiple computing nodes. More specifically, this course teaches design and implementation techniques that enable the building of functional, usable, fast, fault-tolerant and scalable distributed systems. To make the issues more concrete, the class includes two projects requiring significant design and implementation which enable students to gain practical experience in designing, implementing, and debugging real distributed systems.

In this course we use the Go programming language, which was designed for implementing distributed systems. For the most part, students learn this language on their own, with the TAs covering the fundamentals of Go and then practicing the language through the course projects during the biweekly labs.

Topics include distributed communication models (e.g., sockets, remote procedure calls, distributed shared memory), distributed synchronization (clock synchronization, logical clocks, distributed mutex), distributed file systems, replication, consistency models, fault tolerance, QoS and performance, scheduling, concurrency, agreement and commitment, Paxos-based consensus, MapReduce and NoSQL datastores, decentralized systems, cloud infrastructures, microservices, and serverless computing.

By the end of this course, students will be able to:

Apply communication protocols such as remote procedure calls, taking into account control semantics and language limitations; implement serialization and de-serialization; apply the end-to-end argument in real systems.
Analyze data caching and one-copy semantics, cache consistency protocols and implementation tradeoffs, and temporal and spatial locality.
Trace failures in distributed systems using empirical studies such as fail-fast and Byzantine failures, and identify fundamental limits of failure resilience.
Explain how to achieve consensus using unanimity (two-phase commit) and majority (leader election, Paxos).
Design and implement highly available systems using the basic concepts of replication with the latest paradigms and design patterns in distributed cloud systems.

I have been teaching this course every year since 2019.

EECS 6446

Mon, 01 Jan 2018 00:00:00 +0000

In distributed systems, one can choose from a variety of load balancing policies, a wide range of migration policies, capacity provisioning schemes, power management policies, etc. Ideally, one would like to have answers to these questions before investing the time and money to build a system. This course introduces students to stochastic and queuing modeling to answer the above questions.

I have been teaching this course every year since 2019.