EPFL OptML_course: A Practical Course on Optimization for Machine Learning

CS-439 course scope and intended audience

epfml/OptML_course is the repository for EPFL's Optimization for Machine Learning course, identified in the README as CS-439. Its stated audience is students following the course, particularly those studying modern mathematical optimization methods for machine learning and data science. The repository is therefore organized around instruction and assessment. It is not presented as a reusable solver package with a stable public API, supported deployment model, or installation command. That distinction matters for engineers looking for code they can add to an application. The repository contains course materials and links to resources, while the actual implementation work is distributed through weekly exercises and a mini-project. The course covers convexity, gradient methods, projected gradient descent, proximal algorithms, subgradient methods, stochastic and online variants, coordinate descent, Frank-Wolfe, accelerated methods, primal-dual methods, duality, second-order and quasi-Newton methods, derivative-free optimization, distributed optimization, federated learning, computational trade-offs, lower bounds, non-convex optimization, alternating minimization, and neural network training. This is a broad curriculum, but the breadth comes from separate lecture topics and labs rather than one integrated library. The README lists lectures on Fridays from 13:15 to 15:00 in CO2 and exercises from 15:15 to 17:00 in BC01, which confirms the repository's primary setting as an EPFL course.

Repository structure and learning path

Based on the repository layout, the course is divided into `slides/`, `lecture_notes/`, `labs/`, and `exams/`. The README provides a week-by-week program. Early sessions move from convexity and gradient descent to projected and proximal methods, followed by stochastic gradient descent and non-convex optimization. Later sessions cover Newton's method, quasi-Newton methods, Frank-Wolfe, Muon, coordinate descent, accelerated gradient descent, gradient-free and adaptive methods, and optimization for real-world AI model training. The `labs/` tree contains weekly exercise directories such as `ex01` through `ex10`, and the README says these exercises combine theoretical and practical Python work. The files are primarily Jupyter Notebooks, matching the repository's primary language. The learning sequence matters because later algorithms depend on ideas introduced earlier. For example, stochastic and non-convex optimization appear before second-order methods, while coordinate descent and accelerated methods follow earlier treatment of gradient techniques. The repository also provides a consolidated lecture-notes PDF, individual lecture slides, previous exams, solutions, and a detailed mini-project description. The exam archive covers 2018 through 2025, while the README states that the 2026 exam is scheduled for 18 June 2026. The EPFL discussion forum linked in the README is marked as an internal course resource, so external readers should not assume access to the same support channel.

How the optimization material is meant to be used

The repository does not describe a single optimizer execution path such as loading a model, constructing an objective function, and calling one solver. Instead, the material is organized around derivations and experimental comparisons. The README says that scalability for large datasets is discussed in theory and implementation. In the practical portions, students can study how an optimization algorithm behaves on a machine-learning task, then use observations to support a mini-project. The project is mandatory, completed in groups of three students, and worth 30% of the final grade. Its detailed description asks students to investigate the real-world performance of one studied optimization algorithm or variant and provide empirical evidence about its behavior. That is a different objective from shipping a maintained optimizer. The course also discusses trade-offs among time, data, and accuracy, as well as lower bounds. The recorded program gives a concrete sequence for using the repository: read the relevant lecture notes or slides, work through the corresponding exercise directory, consult the available solutions, and then apply a selected method in the mini-project. This structure is useful for learning because it connects formal properties with implementation choices. It also leaves implementation details distributed across notebooks and PDFs. The README does not provide a package manifest, a public command-line interface, or a documented API for calling the course code from another project.

Installing the course materials and starting a first exercise

The README does not give installation steps for a Python package, Jupyter environment, dependency set, or operating system. It gives no `pip`, `conda`, `requirements.txt`, or container command that can be reproduced from the repository. For that reason, an installation tutorial cannot be completed without inventing details. A first real use begins by obtaining the repository files and opening the exercise corresponding to the current lecture. The README links weekly exercises under `labs/` and states that solutions are available in the lab folder. A reader can also start with `lecture_notes/lecture-notes.pdf`, which the README identifies as the course's lecture notes. The repository includes Jupyter Notebook content, so a notebook viewer is implied by the file format, but the README does not document the exact environment or commands required to execute it. The first practical session in the program is `ex00`, associated with the introduction and convexity material, and the later directories are `ex01` through `ex10`. The repository does not state that a learner can run all notebooks independently, nor does it define expected outputs, random seeds, hardware, or runtime. This absence is a meaningful adoption constraint. Engineers adopting the code should first inspect the notebook imports and environment instructions in the files themselves. Without a documented dependency baseline, successful execution on one machine would not establish compatibility with another.

Concrete limitations for production use

The clearest limitation is the absence of a documented production interface. The repository description calls it a course, and the README describes lectures, exercises, exams, videos, and a mini-project. It does not advertise stable function signatures, release versions, compatibility guarantees, or an installation package. There are also no GitHub releases, so the README's course schedule and repository layout are more informative than release history. The unknown license status creates a separate adoption issue. The repository does not identify a license, so the absence of a license prevents assuming that code or course materials may be copied, modified, or redistributed under stated terms. The project is not archived, and the last push was on 2026-07-14, which indicates recent repository activity but does not by itself establish that every notebook or course resource is actively maintained. A second limitation concerns evaluation. The mini-project asks students to produce empirical evidence for a real machine-learning task, but the README does not define a universal benchmark, compare notebooks against a fixed baseline, or promise reproducible hardware. Different datasets, initialization choices, stopping rules, and measurement procedures can produce different conclusions. The repository is therefore well suited to guided study and experimentation, but the documentation is not enough to treat it as a dependable solver for an external service.

Alternatives to the CS-439 materials

The README itself points to two related course collections: CMU 10-725 at Carnegie Mellon University and Berkeley EE-227C. Their difference is organizational rather than a claim about code quality. The README lists CMU 10-725 and Berkeley EE-227C as related courses and materials without explaining their contents. These alternatives may be useful when a learner wants another syllabus or a different collection of lectures and assignments. They should not be treated as drop-in replacements for OptML_course because the README does not document matching assignments, dependency environments, or implementation interfaces. A practical difference within OptML_course itself is that it combines mathematical lecture material with Python exercises and a graded project focused on real-world optimization behavior. A learner seeking only production solver code may find that combination less direct than a library. A learner seeking course structure, theory, exercises, and assessment records will find those resources explicitly listed here. The repository also includes links to recommended books, although the README excerpt does not provide their full bibliographic details. The selection should therefore be based on whether the desired artifact is a course sequence or reusable software.

Maintenance, upgrades, and reuse boundaries

The repository is not archived, and its last push was on 2026-07-14. It also has no GitHub releases, so there is no documented release cadence or packaged upgrade path in the README. For course participants, maintenance may mean updated slides, notebooks, schedules, or project descriptions rather than semantic versioning of an API. The README identifies 2026 assessment dates and links earlier exams from 2018 through 2025, but it does not describe backward compatibility requirements for notebooks. That is relevant because machine-learning environments can change dependency behavior even when the mathematical exercise remains the same. No dependency lockfile or installation manifest is identified in the top-level repository entries, which are `.gitignore`, `README.md`, `exams/`, `labs/`, `lecture_notes/`, and `slides/`. The unknown license is the most concrete reuse boundary. Without a license identifier, engineers cannot infer permission to redistribute modified notebooks, incorporate code into a proprietary codebase, or publish derived course material. The repository is best approached as EPFL course content. Before reuse outside the course, inspect the current `labs/` files for imports and assumptions, check the repository's license metadata, and decide whether the use is for study, internal experimentation, or distribution. Those are separate decisions with different documentation and permission requirements.

Editorial conclusion

EPFL students working toward CS-439 should use this repository as a structured course archive, while independent developers should first verify whether the notebooks contain reusable implementations rather than treating the repository as a production optimization package. The first checks should be the selected exercise notebook, its Python environment requirements, the solution files, and the unknown license status before redistribution or integration.

Frequently asked questions

Official sources

1. epfml/OptML_course on GitHub
2. Issues
3. README