Merge pull request #28 from marimo-team/aka/optimization-dcp

optimization/06_convex_optimization.py

@@ -0,0 +1,90 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "cvxpy==1.6.0",
+#     "marimo",
+#     "numpy==2.2.2",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.11.2"
+app = marimo.App()
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        # Convex optimization
+
+        In the previous tutorials, we learned about least squares, linear programming,
+        and quadratic programming, and saw applications of each. We also learned that these problem
+        classes can be solved efficiently and reliably using CVXPY. That's because these problem classes are a special
+        case of a more general class of tractable problems, called **convex optimization problems.**
+
+        A convex optimization problem is an optimization problem that minimizes a convex
+        function, subject to affine equality constraints and convex inequality
+        constraints ($f_i(x)\leq 0$, where $f_i$ is a convex function).
+
+        **CVXPY.** CVXPY lets you specify and solve any convex optimization problem,
+        abstracting away the more specific problem classes. You start with CVXPY's **atomic functions**, like `cp.exp`, `cp.log`, and `cp.square`, and compose them to build more complex convex functions. As long as the functions are composed in the right way — as long as they are "DCP-compliant" —  your resulting problem will be convex and solvable by CVXPY.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        **🛑 Stop!** Before proceeding, read the CVXPY docs to learn about atomic functions and the DCP ruleset:
+
+        https://www.cvxpy.org/tutorial/index.html
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""**Is my problem DCP-compliant?** Below is a sample CVXPY problem. It is DCP-compliant. Try typing in other problems and seeing if they are DCP-compliant. If you know your problem is convex, there exists a way to express it in a DCP-compliant way.""")
+    return
+
+
+@app.cell
+def _(mo):
+    import cvxpy as cp
+    import numpy as np
+
+    x = cp.Variable(3)
+    P_sqrt = np.random.randn(3, 3)
+
+    objective = cp.log(np.random.randn(3) @ x) - cp.sum_squares(P_sqrt @ x)
+    constraints = [x >= 0, cp.sum(x) == 1]
+    problem = cp.Problem(cp.Maximize(objective), constraints)
+    mo.md(f"Is my problem DCP? `{problem.is_dcp()}`")
+    return P_sqrt, constraints, cp, np, objective, problem, x
+
+
+@app.cell
+def _(problem):
+    problem.solve()
+    return
+
+
+@app.cell
+def _(x):
+    x.value
+    return
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+if __name__ == "__main__":
+    app.run()

optimization/07_sdp.py

@@ -0,0 +1,128 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "cvxpy==1.6.0",
+#     "marimo",
+#     "numpy==2.2.2",
+#     "wigglystuff==0.1.9",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.11.2"
+app = marimo.App()
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""# Semidefinite program""")
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        _This notebook introduces an advanced topic._ A semidefinite program (SDP) is an optimization problem of the form
+
+        \[
+            \begin{array}{ll}
+            \text{minimize}   & \mathbf{tr}(CX) \\
+            \text{subject to} & \mathbf{tr}(A_iX) = b_i, \quad i=1,\ldots,p \\
+                              & X \succeq 0,
+            \end{array}
+        \]
+
+        where $\mathbf{tr}$ is the trace function, $X \in \mathcal{S}^{n}$ is the optimization variable and $C, A_1, \ldots, A_p \in \mathcal{S}^{n}$, and $b_1, \ldots, b_p \in \mathcal{R}$ are problem data, and $X \succeq 0$ is a matrix inequality. Here $\mathcal{S}^{n}$ denotes the set of $n$-by-$n$ symmetric matrices.
+
+        **Example.** An example of an SDP is to complete a covariance matrix $\tilde \Sigma \in \mathcal{S}^{n}_+$ with missing entries $M \subset \{1,\ldots,n\} \times \{1,\ldots,n\}$:
+
+        \[
+            \begin{array}{ll}
+            \text{minimize}   & 0 \\
+            \text{subject to} & \Sigma_{ij} = \tilde \Sigma_{ij}, \quad (i,j) \notin M \\
+                              & \Sigma \succeq 0,
+            \end{array}
+        \]
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## Example
+
+        In the following code, we show how to specify and solve an SDP with CVXPY.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    import cvxpy as cp
+    import numpy as np
+    return cp, np
+
+
+@app.cell
+def _(np):
+    # Generate a random SDP.
+    n = 3
+    p = 3
+    np.random.seed(1)
+    C = np.random.randn(n, n)
+    A = []
+    b = []
+    for i in range(p):
+        A.append(np.random.randn(n, n))
+        b.append(np.random.randn())
+    return A, C, b, i, n, p
+
+
+@app.cell
+def _(A, C, b, cp, n, p):
+    # Create a symmetric matrix variable.
+    X = cp.Variable((n, n), symmetric=True)
+
+    # The operator >> denotes matrix inequality, with X >> 0 constraining X
+    # to be positive semidefinite
+    constraints = [X >> 0]
+    constraints += [cp.trace(A[i] @ X) == b[i] for i in range(p)]
+    prob = cp.Problem(cp.Minimize(cp.trace(C @ X)), constraints)
+    _ = prob.solve()
+    return X, constraints, prob
+
+
+@app.cell
+def _(X, mo, prob, wigglystuff):
+    mo.md(
+        f"""
+        The optimal value is {prob.value:0.4f}.
+
+        A solution for $X$ is (rounded to the nearest decimal) is: 
+        
+        {mo.ui.anywidget(wigglystuff.Matrix(X.value)).center()}
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    import wigglystuff
+    return (wigglystuff,)
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+if __name__ == "__main__":
+    app.run()

optimization/README.md

@@ -1,15 +1,13 @@
 # Learn optimization
 
-🚧 _This collection is a work in progress. Check back later for new notebooks!_
-
-This collection of marimo notebooks teaches you the basics of mathematical
+This collection of marimo notebooks teaches you the basics of convex
 optimization.
 
 After working through these notebooks, you'll understand how to create
 and solve optimization problems using the Python library
 [CVXPY](https://github.com/cvxpy/cvxpy), as well as how to apply what you've
 learned to real-world problems such as portfolio allocation in finance,
-resource allocation, and more.
+control of vehicles, and more.
 
 ![SpaceX](https://www.debugmind.com/wp-content/uploads/2020/01/spacex-1.jpg)