From 3fa3dc21542535f614f7db283ecfdc8c2a40a388 Mon Sep 17 00:00:00 2001 From: AdrienTaylor <10559960+AdrienTaylor@users.noreply.github.com> Date: Mon, 1 Dec 2025 06:34:35 +0100 Subject: [PATCH 1/5] main modifs to pep.py --- PEPit/pep.py | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/PEPit/pep.py b/PEPit/pep.py index ea932618..916d5bab 100644 --- a/PEPit/pep.py +++ b/PEPit/pep.py @@ -45,6 +45,14 @@ class PEP(object): G_value (ndarray): the value of the Gram matrix G that the solver found. F_value (ndarray): the value of the vector of :class:`Expression`s F that the solver found. + + trim_dimension (bool): trims the apperent useless dimensions of the found worst-case function + (best used with dimension_reduction_heuristic) + + toggled_dimensions (int): number of dimensions output when using eval() on :class:`Point` objects + (after solving the PEP) + + estimated_dimension (int): estimated dimension of computed worst-case instance. residual (ndarray): the dual value found by the solver to the lmi constraints G >> 0. @@ -101,6 +109,10 @@ def __init__(self): # The constraint G >= 0 is the only constraint that is not defined from the class Constraint. # Its dual value, called residual, is then stored in the following attribute. self.residual = None + + self.trim_dim = False + self.toggled_dimensions = None + self.estimated_dimension = None @staticmethod def _reset_classes(): @@ -575,6 +587,7 @@ def _solve_with_wrapper(self, wrapper, verbose=1, return_primal_or_dual="dual", # leading to different dual values. The ones we store here provide the proof of the obtained guarantee. self.residual = wrapper.assign_dual_values() G_value, F_value = wrapper.get_primal_variables() + nb_eigenvalues = G_value.shape[0] # Perform a dimension reduction if required if dimension_reduction_heuristic: @@ -637,6 +650,7 @@ def _solve_with_wrapper(self, wrapper, verbose=1, return_primal_or_dual="dual", self.F_value = F_value self._eval_points_and_function_values(F_value, G_value, verbose=verbose) dual_objective = self.check_feasibility(wc_value, verbose=verbose) + self.estimated_dimension = nb_eigenvalues # Return the value of the minimal performance metric if return_primal_or_dual == "dual": @@ -646,6 +660,23 @@ def _solve_with_wrapper(self, wrapper, verbose=1, return_primal_or_dual="dual", else: raise ValueError("The argument \'return_primal_or_dual\' must be \'dual\' or \`primal\`." "Got {}".format(return_primal_or_dual)) + + def trim_dimension(self, trim_dim=False, toggled_dimensions=None): + """ + Activate the dimension trimmer (convenient for plotting worst-case trajectories). + `toggled_dimensions` dimensions are output when using `Point.eval`. + + Args: + trim_dim (bool): activates/deactivates the dimension trimmer. + toggled_dimensions (int, optional): number of dimensions that are kept when evaluating. + default to the estimated number of nonzero eigenvalues. + + """ + + self.trim_dim = trim_dim + self.toggled_dimensions = toggled_dimensions + + self._eval_points_and_function_values(self.F_value, self.G_value, verbose=0) def check_feasibility(self, wc_value, verbose=1): """ @@ -857,6 +888,7 @@ def get_nb_eigenvalues_and_corrected_matrix(M): def _eval_points_and_function_values(self, F_value, G_value, verbose=1): """ Store values of :class:`Point` and :class:`Expression objects at optimum after the PEP has been solved. + It adapts to the option `trim_dimension` and `toggle_dimensions` to trim worst-case dimensions. Args: F_value (nd.array): value of the cvxpy variable F @@ -885,6 +917,16 @@ def _eval_points_and_function_values(self, F_value, G_value, verbose=1): # Extracts points values points_values = np.linalg.qr((np.sqrt(eig_val) * eig_vec).T, mode='r') + nb_points = points_values.shape[1] + + # Adapts to the trim_dimensions and toggled_dimensions + if not self.trim_dim: + toggled_dimensions = nb_points + else: + if self.toggled_dimensions is not None: + toggled_dimensions = np.min(self.toggled_dimensions, nb_points) + else: + toggled_dimensions = np.min(self.estimated_dimension, nb_points) # Iterate over point and function value # Set the attribute value of all leaf variables to the right value From 7c79869f5e2d71c3f8b6fb74f42a813d2ce6fbb6 Mon Sep 17 00:00:00 2001 From: AdrienTaylor <10559960+AdrienTaylor@users.noreply.github.com> Date: Mon, 1 Dec 2025 07:45:48 +0100 Subject: [PATCH 2/5] simple lower dim evaluation --- PEPit/pep.py | 32 ++++++++++++++++---------------- PEPit/point.py | 22 +++++++++++++++++++++- 2 files changed, 37 insertions(+), 17 deletions(-) diff --git a/PEPit/pep.py b/PEPit/pep.py index 916d5bab..23597812 100644 --- a/PEPit/pep.py +++ b/PEPit/pep.py @@ -46,8 +46,8 @@ class PEP(object): G_value (ndarray): the value of the Gram matrix G that the solver found. F_value (ndarray): the value of the vector of :class:`Expression`s F that the solver found. - trim_dimension (bool): trims the apperent useless dimensions of the found worst-case function - (best used with dimension_reduction_heuristic) + trim_dim (bool): trims the apperent useless dimensions of the found worst-case function + (best used with dimension_reduction_heuristic) toggled_dimensions (int): number of dimensions output when using eval() on :class:`Point` objects (after solving the PEP) @@ -674,9 +674,11 @@ def trim_dimension(self, trim_dim=False, toggled_dimensions=None): """ self.trim_dim = trim_dim - self.toggled_dimensions = toggled_dimensions - - self._eval_points_and_function_values(self.F_value, self.G_value, verbose=0) + if toggled_dimensions is not None: + self.toggled_dimensions = min(toggled_dimensions, Point.counter) + elif self.estimated_dimension is not None: + self.toggled_dimensions = min(self.estimated_dimension, Point.counter) + Point._toggled_dimensions = self.toggled_dimensions def check_feasibility(self, wc_value, verbose=1): """ @@ -888,7 +890,6 @@ def get_nb_eigenvalues_and_corrected_matrix(M): def _eval_points_and_function_values(self, F_value, G_value, verbose=1): """ Store values of :class:`Point` and :class:`Expression objects at optimum after the PEP has been solved. - It adapts to the option `trim_dimension` and `toggle_dimensions` to trim worst-case dimensions. Args: F_value (nd.array): value of the cvxpy variable F @@ -917,16 +918,6 @@ def _eval_points_and_function_values(self, F_value, G_value, verbose=1): # Extracts points values points_values = np.linalg.qr((np.sqrt(eig_val) * eig_vec).T, mode='r') - nb_points = points_values.shape[1] - - # Adapts to the trim_dimensions and toggled_dimensions - if not self.trim_dim: - toggled_dimensions = nb_points - else: - if self.toggled_dimensions is not None: - toggled_dimensions = np.min(self.toggled_dimensions, nb_points) - else: - toggled_dimensions = np.min(self.estimated_dimension, nb_points) # Iterate over point and function value # Set the attribute value of all leaf variables to the right value @@ -962,3 +953,12 @@ def _eval_points_and_function_values(self, F_value, G_value, verbose=1): raise TypeError( "Expressions are made of function values, inner products and constants only!" "Got {}".format(type(sub_expression))) + + # Adapts to the trim_dimensions and toggled_dimensions + if not self.trim_dim: + toggled_dimensions = Point.counter + else: + if self.toggled_dimensions is not None: + Point._toggled_dimensions = min(self.toggled_dimensions, nb_points) + else: + Point._toggled_dimensions = min(self.estimated_dimension, nb_points) diff --git a/PEPit/point.py b/PEPit/point.py index 503f2b17..8f7637c7 100644 --- a/PEPit/point.py +++ b/PEPit/point.py @@ -20,6 +20,7 @@ class Point(object): Keys are :class:`Point` objects. And values are their associated coefficients. counter (int): counts the number of leaf :class:`Point` objects. + _toggled_dimensions (int): shows only the first `toggled_dimensions` dimensions when using `eval`. :class:`Point` objects can be added or subtracted together. They can also be multiplied and divided by a scalar value. @@ -52,6 +53,9 @@ class Point(object): # namely the number of points needed to linearly generate the others. counter = 0 list_of_leaf_points = list() + # Number of dimensions to be output when evaluating (None corresponds to + # all dimensions being output + _toggled_dimensions = None def __init__(self, is_leaf=True, @@ -282,7 +286,6 @@ def eval(self): ValueError("The PEP must be solved to evaluate Points!") if the PEP has not been solved yet. """ - # If the attribute value is not None, then simply return it. # Otherwise, compute it and return it. if self._value is None: @@ -298,6 +301,23 @@ def eval(self): return self._value + def eval_ld(self): + """ + Evaluation in lower dimension. + + Returns: + value (np.array): The trimmed value of this :class:`Point` after the corresponding PEP was solved numerically. + + Raises: + ValueError("The PEP must be solved to evaluate Points!") if the PEP has not been solved yet. + + """ + if Point._toggled_dimensions is not None: + toggled_dimensions = Point._toggled_dimensions + else: + toggled_dimensions = Point.counter + + return self.eval()[:toggled_dimensions] # Define a null Point initialized to 0. null_point = Point(is_leaf=False, decomposition_dict=dict()) From 574c767ff0eb7513d8618ab031f4091885864191 Mon Sep 17 00:00:00 2001 From: AdrienTaylor <10559960+AdrienTaylor@users.noreply.github.com> Date: Tue, 2 Dec 2025 00:45:43 +0100 Subject: [PATCH 3/5] visualization demo --- PEPit/tools/interpolator.py | 59 + ...PEPit_demo_visual_worstcase_function.ipynb | 1608 +++++++++++++++++ 2 files changed, 1667 insertions(+) create mode 100644 PEPit/tools/interpolator.py create mode 100644 ressources/demo/PEPit_demo_visual_worstcase_function.ipynb diff --git a/PEPit/tools/interpolator.py b/PEPit/tools/interpolator.py new file mode 100644 index 00000000..00e4ba27 --- /dev/null +++ b/PEPit/tools/interpolator.py @@ -0,0 +1,59 @@ +import cvxpy as cp +import numpy as np + +class Interpolator(object): + """ + The class :class:`Interpolator` is designed to help identifying worst-case examples. + + Attributes: + list_of_triplets (list): list of triplets + + L (float): curvature of the quadratic upper bound on the function (possibly np.inf) + m (float): curvature of the quadratic lower bound on the function (possibly np.inf) + d (int): dimension + + """ + def __init__(self, list_of_triplets, mu, L, d, options='lowest'): + self.x_list, self.g_list, self.f_list = list_of_triplets + self.nb_eval = len(self.x_list) + self.L = L + self.mu = mu + self.d = d + self.options = options + + def __set_constraint__(self, + xi, gi, fi, + xj, gj, fj, + ): + if self.L is not np.inf: + constraint = (0 >= fj - fi + gj @ (xi - xj) + + 1 / 2 / (self.L-self.mu) * cp.norm(gi - gj,2) ** 2 + + self.mu * self.L / 2 / (self.L-self.mu) * cp.norm(xi - xj,2) ** 2 + - self.mu / (self.L - self.mu) * (gi-gj)@(xi-xj) ) + else: + constraint = (0 >= fj - fi + gj @ (xi - xj) + + self.mu / 2 * cp.norm(xi - xj,2) ** 2 ) + + return constraint + + + def evaluate(self, x): + fx = cp.Variable(1) + gx = cp.Variable((self.d,)) + cons = [] + for i in range(self.nb_eval): + fi = self.f_list[i] + gi = self.g_list[i] + xi = self.x_list[i] + cons.append(self.__set_constraint__(xi,gi,fi,x,gx,fx)) + cons.append(self.__set_constraint__(x,gx,fx,xi,gi,fi)) + + if self.options == 'highest': + prob = cp.Problem(cp.Maximize(fx), cons) + if self.options == 'lowest': + prob = cp.Problem(cp.Minimize(fx), cons) + prob.solve(verbose=False) + return fx.value + + + diff --git a/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb b/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb new file mode 100644 index 00000000..75b740a2 --- /dev/null +++ b/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb @@ -0,0 +1,1608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7f662ada", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/bgoujaud/PEPit/blob/master/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb)" + ] + }, + { + "cell_type": "markdown", + "id": "95ff2f88", + "metadata": {}, + "source": [ + "# PEPit : numerical identification of worst-case examples" + ] + }, + { + "cell_type": "markdown", + "id": "21316fe3", + "metadata": {}, + "source": [ + "This notebook provides:\n", + "- A simple example illustrating how to obtain a worst-case instance for **gradient descent** (when minimizing a smooth convex function) using the PEPit package.\n", + "- Four other examples illustrating how to obtain worst-case instances in other situations: with proximal operators, momentum, possibly non-convex functions, and primal-dual methods.\n", + "\n", + "For a first demo of PEPit, that include detailed installation, imports, and base introductory steps, we refer to the introductory [demo](https://colab.research.google.com/github/bgoujaud/PEPit/blob/master/ressources/demo/PEPit_demo.ipynb) file.\n", + "\n", + "\n", + "Four algorithms are being considered below:\n", + "* [Example 1](#example1) : **gradient descent** for smooth convex minimization.\n", + "* [Example 2](#example2) : the **fast iterative shrinkage-thresholding algorithm** (FISTA) for composite convex minimization.\n", + "* [Example 3](#example3) : an **alternating projection algorithm** for finding a point in intersection of two convex sets\n", + "* [Example 4](#example4) : **gradient descent** for smooth possibly non-convex minimization.\n", + "* [Example 5](#example5) : a primal-dual **proximal-point algorithm** for convex (possibly non-smooth) minimization." + ] + }, + { + "cell_type": "markdown", + "id": "e10f9c2b", + "metadata": {}, + "source": [ + "**Import a few necessary common Python packages (numpy, matplotlib)**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "672abc5f", + "metadata": { + "pycharm": { + "is_executing": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from math import sqrt" + ] + }, + { + "cell_type": "markdown", + "id": "302e5a76-1dbd-4f4d-ac7b-55ed79cbf45a", + "metadata": {}, + "source": [ + "We re-implement the base examples below. This is necessary as we will save the worst-case trajectories." + ] + }, + { + "cell_type": "markdown", + "id": "4a39cccf", + "metadata": {}, + "source": [ + "## Example 1 : gradient descent for smooth convex minimization \n", + "\n", + "We consider the following convex minimization problem:\n", + "\\begin{equation}\n", + "f_\\star \\triangleq \\min_x f(x),\n", + "\\end{equation}\n", + "where $f$ is $L$-smooth and convex.\n", + "\n", + "For this example, we consider the problem of computing the smallest possible $\\tau(n, L, \\gamma)$ such that the following guarantee holds (for all initialization of the algorithm, and all $L$-smooth convex function)\n", + "\\begin{equation}\n", + "f(x_n)-f_\\star \\leqslant \\tau(n, L, \\gamma) \\| x_0 - x_\\star \\|^2,\n", + "\\end{equation}\n", + "where $x_n$ is the output of the gradient descent with fixed step size $\\gamma$, started from $x_0$, and where $x_\\star$ is a solution.\n", + "\n", + "#### Algorithm\n", + "\n", + "Gradient descent with fixed step size $\\gamma$ may be described as follows, for $t \\in \\{0,1, \\ldots, n-1\\}$\n", + "\\begin{equation}\n", + "x_{t+1} = x_t - \\gamma \\nabla f(x_t).\n", + "\\end{equation}\n" + ] + }, + { + "cell_type": "markdown", + "id": "71704e34-fa09-4467-b426-428a54aaceb4", + "metadata": {}, + "source": [ + "#### Low-dimensional worst-case examples?\n", + "\n", + "The solution to the PEP provides a discrete version of a worst-case example. In general worst-case examples are non-unique in different ways. First, there are generally multiple discretizations that correspond to worst-case examples, and second, there are generally multiple ways to interpolate a discrete version of a worst-case instance. Using a solution to the PEP, one can identify the dimension of a matching worst-case instance by inspection of the rank of the Gram matrix. More precisely, the rank of the Gram matrix corresponds to the dimension of the matching worst-case example (see, e.g., [here, Section 3.2](https://arxiv.org/pdf/1502.05666)).\n", + "\n", + "PEPit contains a few heuristics to try to identify such low-dimensional worst-case instances, by searching for low-rank Gram matrices. There are two of them: the trace heuristic ($\\ell_1$ on the eigenvalues) and the logdet heuristic (reweighted $\\ell_1$ on the eigenvalues). For both of them, we need to potentially leave some slack in the objective, which we fix here to `tol_dimension_reduction=1e-6`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b6ba7178", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(PEPit) Setting up the problem: size of the Gram matrix: 7x7\n", + "(PEPit) Setting up the problem: performance measure is the minimum of 1 element(s)\n", + "(PEPit) Setting up the problem: Adding initial conditions and general constraints ...\n", + "(PEPit) Setting up the problem: initial conditions and general constraints (1 constraint(s) added)\n", + "(PEPit) Setting up the problem: interpolation conditions for 1 function(s)\n", + "\t\t\tFunction 1 : Adding 30 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 30 scalar constraint(s) added\n", + "(PEPit) Setting up the problem: additional constraints for 0 function(s)\n", + "(PEPit) Compiling SDP\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.05555555533812068\n", + "(PEPit) Postprocessing: 2 eigenvalue(s) > 4.671406847528681e-08 before dimension reduction\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.055554555299594764\n", + "(PEPit) Postprocessing: 1 eigenvalue(s) > 1.7461167801076963e-09 after dimension reduction\n", + "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -4.18e-11 < 0).\n", + " Small deviation from 0 may simply be due to numerical error. Big ones should be deeply investigated.\n", + " In any case, from now the provided values of parameters are based on the projection of the Gram matrix onto the cone of symmetric semi-definite matrix.\u001b[0m\n", + "(PEPit) Primal feasibility check:\n", + "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 4.1766070694651726e-11\n", + "\t\tAll the primal scalar constraints are verified up to an error of 7.828505291934684e-11\n", + "(PEPit) Dual feasibility check:\n", + "\t\tThe solver found a residual matrix that is positive semi-definite\n", + "\t\tAll the dual scalar values associated with inequality constraints are nonnegative up to an error of 2.8401484695904976e-09\n", + "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 4.100138731311098e-08\n", + "(PEPit) Final upper bound (dual): 0.055555558389116265 and lower bound (primal example): 0.055554555299594764 \n", + "(PEPit) Duality gap: absolute: 1.003089521500744e-06 and relative: 1.805593647705899e-05\n" + ] + } + ], + "source": [ + "from PEPit import PEP\n", + "from PEPit.functions import SmoothConvexFunction\n", + "\n", + "L = 1\n", + "gamma = 1/L\n", + "n = 4\n", + "verbose = 1\n", + "\n", + "\n", + "# Instantiate PEP\n", + "problem = PEP()\n", + "\n", + "# Declare a smooth strongly convex function\n", + "f = problem.declare_function(SmoothConvexFunction, L=L)\n", + "\n", + "# Then define the starting point x0 of the algorithm as well as corresponding gradient and function value g0 and f0\n", + "x0 = problem.set_initial_point()\n", + "g0, f0 = f.oracle(x0)\n", + "\n", + "xs = f.stationary_point()\n", + "gs, fs = f.oracle(xs)\n", + "\n", + "# Prepare empty lists for saving all datapoints\n", + "x_list = list()\n", + "g_list = list()\n", + "f_list = list()\n", + "\n", + "# Run n steps of GD method with step-size gamma\n", + "gx, fx = g0, f0\n", + "\n", + "x_list.append(x0)\n", + "g_list.append(g0)\n", + "f_list.append(f0)\n", + "\n", + "for i in range(n):\n", + " x_list.append(x_list[-1] - gamma * gx)\n", + " gx, fx = f.oracle(x_list[-1])\n", + " g_list.append(gx)\n", + " f_list.append(fx)\n", + " \n", + "# Set initial condition and performance metric\n", + "problem.set_initial_condition((x0-xs)**2 <= 1)\n", + "problem.set_performance_metric(f_list[-1] - fs)\n", + "\n", + "# Solve the PEP\n", + "pepit_verbose = max(verbose, 0)\n", + "pepit_tau = problem.solve(verbose=pepit_verbose, dimension_reduction_heuristic=\"trace\", tol_dimension_reduction=1e-6)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "9c95eeb5-8e23-4b49-add4-496044395283", + "metadata": {}, + "source": [ + "As we can see from the output, PEPit identified a low-rank matrix.\n", + "\n", + "In order to evaluate and plot a worst-case trajectory, we use the `eval_ld` function that allows trimming apparent useless dimensions from the vectors output by PEPit, as follows. For using this, we need to trim the useless dimensions first.\n", + "\n", + "In the evaluation, we center the coordinates so that $x_\\star=0$ and $f_\\star=0$ for simplicity." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "628a39d9-24a8-40c7-ac2a-31e9ef9f9d5f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "problem.trim_dimension(True) # Remove the useless dimensions\n", + "xs_evaluated = xs.eval_ld() # x*\n", + "gs_evaluated = gs.eval_ld() # g(x*)=0\n", + "fs_evaluated = fs.eval() # f(x*)\n", + "\n", + "x_list_evaluated = [x.eval_ld()-xs_evaluated for x in x_list] # centered iterates\n", + "g_list_evaluated = [g.eval_ld() for g in g_list] # gradient values\n", + "f_list_evaluated = [f.eval()-fs_evaluated for f in f_list] # centered function values\n", + "xs_evaluated = xs_evaluated - xs_evaluated # should be zero \n", + "fs_evaluated = fs_evaluated - fs_evaluated # should be zero " + ] + }, + { + "cell_type": "markdown", + "id": "5b2cea08-90b2-4988-97b9-028a1740d665", + "metadata": {}, + "source": [ + "Now, using the list of iterate, we can simply plot the trajectory as follows: " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "522606de", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_list_evaluated, f_list_evaluated, '.--', color='blue')\n", + "plt.plot(x_list_evaluated, f_list_evaluated, marker='.', color='red', linestyle='none', markersize=8, label='$(x_t,f(x_t))$')\n", + "plt.plot(xs_evaluated, fs_evaluated, marker='*', color='gold', linestyle='none', markersize=8, label='$(x_\\star,f(x_\\star))$')\n", + "\n", + "\n", + "plt.legend()\n", + "plt.xlabel('x')\n", + "plt.ylabel('f(x)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "69e8d142-5604-4512-9223-468d857a53c5", + "metadata": {}, + "source": [ + "The last plot is giving a partial picture of what a worst-case function might look like. For this reason, we provide a few tools that allows extrapolating within certain classes of functions. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a2c79293-1ecb-47bd-b329-0b7e6abf31ff", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from PEPit.tools.interpolator import Interpolator\n", + "\n", + "# Add the x* to the list of points to be interpolated\n", + "x_list_evaluated.append(xs_evaluated)\n", + "f_list_evaluated.append(fs_evaluated)\n", + "g_list_evaluated.append(gs_evaluated)\n", + "\n", + "# Create an interpolator for the class of L-smooth convex functions\n", + "triplets = (x_list_evaluated,g_list_evaluated,f_list_evaluated)\n", + "fx = Interpolator(triplets,0,L,1,'highest')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "83400afc-9c72-43d3-9b8a-756b71b016ac", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50 done on 200\n", + "100 done on 200\n", + "150 done on 200\n", + "200 done on 200\n" + ] + } + ], + "source": [ + "x_test = np.linspace(np.min(x_list_evaluated),np.max(x_list_evaluated),200)\n", + "fx_test = np.zeros(x_test.shape)\n", + "for i in range(len(x_test)):\n", + " fx_test[i] = fx.evaluate(x_test[i])\n", + " if (i+1) % 50 == 0:\n", + " print('{} done on {}'.format((i+1),len(x_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bb411cc0-3fb4-40ab-8f8b-cad64aae00ac", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPnklEQVR4nO3dd3hUVf7H8fekDi0RCSQ0aa70UBJaBNHfakJRpCmWjWUVjY0mSpfiAnYRpYkR11WBVQIihrorxSVSQkKRILokgkiWagISQkju748rgZBCEjJzJ5nP63nmSebMmXs/c1Hmy73nnmMzDMNARERExI14WB1ARERExNlUAImIiIjbUQEkIiIibkcFkIiIiLgdFUAiIiLidlQAiYiIiNtRASQiIiJux8vqAK4oJyeHX3/9lWrVqmGz2ayOIyIiIsVgGAanT5+mTp06eHgUfY5HBVABfv31V+rXr291DBERESmFQ4cOUa9evSL7qAAqQLVq1QDzAPr5+VmcRkRERIojPT2d+vXr536PF0UFUAEuXvby8/NTASQiIlLOFGf4igZBi4iIiNtRASQiIiJuRwWQiIiIuB2NARIRkQotOzubrKwsq2NIGfHx8bnqLe7FoQJIREQqJMMwSE1N5bfffrM6ipQhDw8PGjVqhI+PzzVtRwWQiIhUSBeLn1q1alG5cmVNbFsBXJyo+MiRI9xwww3X9GeqAkhERCqc7Ozs3OKnRo0aVseRMlSzZk1+/fVXLly4gLe3d6m3o0HQIiJS4Vwc81O5cmWLk0hZu3jpKzs7+5q2owJIREQqLF32qnjK6s9UBZCIiIi4HRVAIiIi4nZUADlTTAy0aQOVKpk/Y2KsTiQiIuKWVAA5S0wMDBgAu3fDuXPmzwEDVASJiIhYQAWQs0yeDDYbGIb53DDM51OmWJtLRERc0okTJ6hVqxYpKSllts1Zs2bRsGFDvLy8eOGFF0q1j4EDB/LWW29dtc3V2Qzj4jeyXJSeno6/vz9paWn4+fmVzUYrVTLP/FzJboeMjLLZh4iIAHDu3DmSk5Np1KgRdrvd6jilMnLkSE6dOkV0dHSZbG/Pnj20a9eOZcuW0b59e/z9/XnppZdKvI9du3Zx2223kZycnPsdWVCboxT1Z1uS72+dAXKWm24yz/hcJhsbR/ybkpNjUSYREXFJGRkZREdH8/jjj5fZNpcvX05ISAi9e/emdu3a2Gy2Uu0jODiYhg0b8umnnxbZ5upUADnLxImXLnsBOdjwxODp/03krrvg1CmL84mIuInffy/8ceWJ+qL6XnnyvrB+pbFy5Uq8vLzo0qVLbtvChQux2+0cPnw4t+3xxx8nODiYtLS0IrfXpEkTxo0bx5YtW7DZbERGRha4j+Lup0+fPixcuDDP+wpqc2UqgJylf39YsgSCg8Fux6NNMBuGxrC6Uj9iYyE0FPbutTqkiEjFV7Vq4Y8BA/L2rVWr8L49e+bt27Bhwf1KY+PGjYSGhuZpu++++2jatCnTp08HYPLkyaxevZqVK1fi7+9f5Pbi4uJo3Lgxr7/+OkeOHGH27NkF7qO4++nYsSNbt24lMzMz930FtbkyrQXmTP37m48/dAc2PwL9+sHp01CtmmXJRETEhaSkpFCnTp08bTabjalTpzJw4EDq1KnDO++8w6ZNm6hbt+5Vt1e1alVSUlLo2rUrQUFBhe6juPupW7cumZmZpKam0qBBg0LbXJkKIIu1bQvx8XDgANSvf6n9sqtlIiJShs6cKfw1T8+8z48eLbyvxxXXUMrwZi0yMjIKHLx955130qJFCyZPnsyaNWto2bJlsba3a9cuAFq3bn3VfRRnP5UqVQLg7NmzRba5MhVALuD6683HRcuWwYwZsGgR/FGoi4hIGalSxfq+VxMQEMCpAgaHrl69mn379pGdnU1gYGCxt5eYmMiNN95IlctCFraP4uzn5MmTgLkye1FtrkxjgFxMZiY89xxs2AAhIRAXZ3UiERFxtnbt2rH3ioGhO3bs4J577mHevHlEREQwYcKEYm8vMTGRNm3aXHUfxd3Pnj17qFevHgEBAUW2uTIVQC7G1xfWrYPmzeHXX6F7d5gz59L8iSIiUvFFRETw/fff556hSUlJoXfv3owePZrIyEimTJnCkiVLiI+PL9b2EhMTadu2bZH7KMl+Nm3aRHh4+FXbXJkKIBfUtCls2WLejZCVBU8/DX/9q+ZLFBFxF61btyY0NJR//vOfnDx5kp49e9KnTx/Gjh0LQEhICHfddRfjxo3Lfc9HH32ErYDBozk5OezevTvfGaDL9wEUez/nzp1j6dKlDB48uMg2V6eZoAvgkJmgS8Ew4PXXYcwYyMmB9u1h0yaoXNmySCIi5UJFmAk6NjaWkSNHsmfPHjyuHHFdgEmTJrF+/XrWr1/vsH2AuZzGl19+yZo1a4psc5QKMxP07Nmzcz9ESEgImzZtKrTvkSNHeOCBB2jatCkeHh4MGzaswH5LliyhRYsW+Pr60qJFC5YuXeqg9I5ls8GLL8Lq1VCjBtx8s4ofERF30atXL5588sk8ExIWZfXq1bz22msO3QeAt7c377777lXbXJ2lZ4AWL15MZGQks2fP5uabb2bevHl88MEH7N27lxtuuCFf/5SUFN5++21CQkJ4++236d69OzNmzMjTJy4ujm7duvHyyy/Tr18/li5dyksvvcS3335Lp06dipXLVc4AXe6XX8wJuXx8zOdnzph3HOhWeRGR/CrCGSApWFmdAbK0AOrUqRPt27dnzpw5uW3Nmzenb9++uTNQFubWW2+lbdu2+QqgQYMGkZ6ezsqVK3PbevToQfXq1QudojszMzPPzJXp6enUr1/fpQqgy2VlwR13QEAALFigCRRFRK6kAqjiKveXwM6fP098fHy+EePh4eFs3ry51NuNi4vLt82IiIgitzl9+nT8/f1zH/Uvn5HQBW3bBps3mytrdOoEP/xgdSIREZHyxbIC6Pjx4wVOsBQYGEhqamqpt5uamlribY4ZM4a0tLTcx6FDh0q9f2cIC4ONG6FOHUhKgg4dzMkTRUREpHgsHwR95S17hmEUeBufI7fp6+uLn59fnoer69wZduyAW24x1xHr1w/GjYPsbKuTiYiIuD7LCqCAgAA8PT3znZk5evRoiab3vlJQUFCZb9NVBQaakyYOH24+nzYNnn3W2kwiIiLlgWUFkI+PDyEhIaxduzZP+9q1awkLCyv1drt06ZJvm2vWrLmmbboyb2946y347DOzIHruOasTiYiIuD5LF0MdMWIEkZGRhIaG0qVLF95//30OHjxIVFQUYI7NOXz4MB9//HHuexITEwE4c+YMx44dIzExER8fH1q0aAHA0KFDueWWW3j11Ve5++67+fLLL1m3bh3ffvut0z+fM91/P9x9d955gn74wZxVWkRERPKytAAaNGgQJ06cYMqUKRw5coRWrVoRGxtLgwYNAHPiw4MHD+Z5T7t27XJ/j4+P57PPPqNBgwakpKQAEBYWxqJFixg/fjwTJkygSZMmLF68uNhzAJVnlxc/GzfC//0fREWZZ4guzh8kIiIiWgqjQK44EWJJvf02jBhh/h4WBp9/bt41JiLiDjQPUMVV7ucBEscaPhy++gr8/c05g0JCoIJfBRQRqVBOnDhBrVq1cq9wOMKsWbNo2LAhXl5evPDCC2Wyz4EDB/LWW28Vu90qOgNUgIpwBuiiH3+E/v1hzx7w8jIvhz37rJbQEJGKrSKcARo5ciSnTp0iOjraIdvfs2cP7dq1Y9myZbRv3x5/f39eeumla97nrl27uO2220hOTs7zHVpYe0npDJAUy5/+BHFxMGgQXLgAQ4bAZauEiIiIC8rIyCA6OprHH3/cYftYvnw5ISEh9O7dm9q1a2Oz2cpkn8HBwTRs2JBPP/20WO1WUQHkBqpWhYUL4c034S9/gZ49rU4kIlKOxMRAmzZQqZL5MybG4btcuXIlXl5edOnSJbdt4cKF2O32PCu3P/744wQHB5OWllai7Tdp0oRx48axZcsWbDYbkZGRBe6ztPvt06dPgetvFtZuBRVAbsJmMwdFf/zxpctf6enwzTfW5hIRcWkxMTBgAOzeDefOmT8HDHB4EbRx40ZCQ0PztN133300bdo0d7HwyZMns3r1alauXIm/v3+Jth8XF0fjxo15/fXXOXLkCLNnzy5wn6Xdb8eOHdm6dWuehcaLareCCiA3c7H4MQx45BH485/NGaRzciyNJSLimiZPNv/ivDhc1jDM51OmOHS3KSkp1Lni1l2bzcbUqVP54IMPmDZtGu+88w6rVq2ibt26ABw4cICvvvqqWNuvWrUqKSkpdO3alaCgIKpVq1bgPku737p165KZmZlvZYbC2q2gAshNXbgANWua/y+PG2f+gyY93epUIiIuZv/+S8XPRYZhzjTrQBkZGQUO3r7zzjtp0aIFkydPZunSpbRs2TL3tZUrV7Jv375ibX/Xrl0AtG7d+qr7LM1+K1WqBMDZs2eL1W4FFUBuytsb5s2D+fPNSRKXLTNXld+71+pkIiIu5Kab8t82a7M5fJr9gIAATp06la999erV7Nu3j+zs7DxrXG7YsIHx48czf/582rVrR0ZGRpHbT0xM5MYbb6RKlSpX3Wdp9nvy5EkAatasmWc7hbVbQQWQm3v8cXN+oHr1zH/odOoES5ZYnUpExEVMnHjpshdcuhw2caJDd9uuXTv2XvEv0h07dnDPPfcwb948IiIimDBhQu5r3bt3p1WrVvzrX/8iISEh90xLYRITE2nTps1V91na/e7Zs4d69eoREBCQZ1uFtVtBBZDQoQPEx8Ntt8GZMzB0KPz+u9WpRERcQP/+5r8Kg4PBbjd/xsRAv34O3W1ERATff/997hmZlJQUevfuzejRo4mMjGTKlCksWbKE+Pj43Pf88ssv1K9fv1jbT0xMpG3btkXu81r2u2nTJsLDw/Ptt7B2SxiST1pamgEYaWlpVkdxqqwswxg1yjA2b7Y6iYjItcnIyDD27t1rZGRkWB2l1Dp37mzMnTvXOHHihNGsWTPjiSeeyPN6nz59jIiICMMwDOPQoUPGzTffnOf1BQsWGAV9zWdnZxuVK1c2VqxYUeg+DcMo9X4zMjIMPz8/Iy4urljtJVXUn21Jvr8tXQxVXIuXF7zySt62pUuhfn0o4M5IERFxoAkTJjBy5EgGDx5MUlJSvte//PLL3N+Tk5Pz3cGVkpJC9+7d873Pw8OD3ws5zX/5Pq+//vpS7Tc6OppOnTrRuXPnYrVbRZfApFC7d8ODD0LXrvDhh1anERFxL7169eLJJ5/MMwFhYVq1asWPP/5I69atc+/IWr16Na+99prD9lnYfr29vXn33Xfz9S2s3SpaC6wAFWktsGuRlgYPPQTLl5vPn3wS3nkHfH2tzSUicjUVYS0wKZjWAhOH8/c3L4G9/LJ548O8edC9Oxyf7/xp4UVERMqSCiApkocHjB8PX38N110HdbbEEPDEAAwnTwsvIiJSllQASbH07Anbt8N0+2RysGFz8rTwIiIiZUl3gUmxNWkChrEfG86fFl5ERKQs6QyQlIitaf5p4XOwkdnQsdPCi4iIlCUVQFIyV0wLn4MNDwweOziRr7+2OJuIiEgxqQCSkrliWvjsFsGMvimGT8/24847YfJkyMmxOqSIiEjRVABJyfXvD4mJkJGB9/eJTNndj6efNl+aNAnuvht++83CfCIiIlehAkiumY8PzJoFCxaYkySuWGEunVHAosIiIiIuQQWQlJlHHoHNm6FBAzhxQjNGi4iI61IBJGWqfXtzvqCvvzZvm79IC66ISLmWuQd+6Wv+dJITJ05Qq1YtUlJSnLZPgFmzZtGwYUO8vLx44YUXHJZj4MCBvPXWW1dtcxQVQFLmAgIgLOzS89Wr4fbb4ehR6zKJiFyTMyvgzJdwxnm3u06fPp277rqLhg0bOm2fe/bsYdiwYcyaNYtDhw4xefJkh+V46aWXmDp1Kunp6UW2OYoKIHGorCxzEdV//xtCQmDLFqsTiYiUwu//zvvTwTIyMoiOjubxxx93yv4uWr58OSEhIfTu3ZvatWtjs9kcliM4OJiGDRvy6aefFtnmKCqAxKG8vWHlSmjaFH75BW65BebPtzqViMhVZP0C53b88YiHjE1me8ZG8/nF17IOO2T3K1euxMvLiy5duuS2LVy4ELvdzuHDl/b5+OOPExwcTFpa2jXvs0mTJowbN44tW7Zgs9mIjIwsMEdZZunTpw8LFy68apsjqAASh2veHLZuhX794Px5eOIJGDzYXEtVRMQl/dIbUkL+eISCkWm2G5nm84uv/dLLIbvfuHEjoaGhedruu+8+mjZtyvTp0wGYPHkyq1evZuXKlfj7+1/zPuPi4mjcuDGvv/46R44cYfbs2QXmKMssHTt2ZOvWrWRmZhbZ5ggqgMQp/PzM+ROnTTMnkf7gA/Ns0JkzVicTESlAtYFXNBhX/LzY7x6H7D4lJYU6derkabPZbEydOpUPPviAadOm8c4777Bq1Srq1q17KeUfd5xMmjQpz/PiqFq1KikpKXTt2pWgoCCqVatWYI6yzFK3bl0yMzNJTU0tss0RtBiqOI3NBmPGmGOB7r/fnEy6ShWrU4mIFCBggvnz+EtF9HkZAsY7ZPcZGRnY7fZ87XfeeSctWrRg8uTJrFmzhpYtW+Z5fc6cOXh5efH7778zevRoevbsSffu3Yu1z127dgHQunXrq+YoqyyVKlUC4OzZs0W2OYLOAInThYfDjh3w3nuX1lU9e1a3youIiwmYANVHFPza9c87rPgBCAgI4NSpU/naV69ezb59+8jOziYwMDDf608//TRpaWnMnDmTu+66q9jFD0BiYiI33ngjVS77l2lhOcoqy8mTJwGoWbNmkW2OoAJILNGgAVz8R0V2trm6xqBBuiQmIq7mAmD748Gl340LDt1ru3bt2HvFdPo7duzgnnvuYd68eURERDBhwoR875s7dy7+/v4MGTKEFStWsGnTpmLvMzExkTZt2lw1R1lm2bNnD/Xq1SMgIKDINocwJJ+0tDQDMNLS0qyO4ha++84wvLwMAwyjRQvD+OEHqxOJSHmXkZFh7N2718jIyCj9RnKyDWN/LcNIwjB+uM4wjr5k/kzCbM/JLrvAV9i1a5fh5eVlnDx50jAMw0hOTjaCgoKMqVOnGoZhGNu3bzdsNpuxffv2vJFzcgzDMIyJEyfmeV4cnTp1yt1+YTnKOsvDDz9s/PWvf71q2+WK+rMtyfe3CqACqAByvv/8xzBq1zaLID8/w/jyS6sTiUh5ViYFUPYZwzgQYhiH+hlG1v/Mtqz/mc+TQ83XHahz587G3LlzjRMnThjNmjUznnjiiTyv9+nTx4iIiCjRNhcsWGAUdO4jOzvbqFy5srFixYpCcxiGUaZZMjIyDD8/PyMuLq7ItoLeVxYFkM0wNPLiSunp6fj7+5OWloafn5/VcdxGairccw98+635fPx4c3V5T09LY4lIOXTu3DmSk5Np1KhRoYN4i8XIBlsBfwkV1l6GYmNjGTlyJHv27MHDo2xGrEyaNIn169ezfv16S3OAueTGl19+yZo1a4psu1JRf7Yl+f7WGCBxGUFB5ozRQ4aYz//2N3j6aWsziYibK6zIcXDxA9CrVy+efPLJPJMNXqvVq1fz2muvWZ4DwNvbm3ffffeqbY6iM0AF0Bkg633yCQwdCuvWQbt2VqcRkfKmzM4AicvRGSCp0P7yF0hJyVv8HDhgWRwREalgVACJy6pW7dLvW7eaS2oMG2YusCoiInItVABJufCf/5jriL3zDvz5z+aAaRERkdJSASTlwvDhsGyZeVZo0yZzOY24OKtTiYir0zDXiqes/kxVAEm5cffdsG0btGgBv/4K3bvDnDlaQkNE8vP29gYcv56UON/58+cB8LzGOVK0GKqUK02bwnffwV//Cl98Yd4mX7cu9OljdTIRcSWenp5cd911HD16FIDKlStju7j4oJRbOTk5HDt2jMqVK+PldW0ljAogKXeqVYN//hPeeMMshu680+pEIuKKgoKCAHKLIKkYPDw8uOGGG665oNU8QAXQPEDlh2HkXVF++3a45RZrM4mIa8nOziZLt49WGD4+PoXOSF2S72+dAZJy7WLxYxgweDAsWgRTp8KoUZdeExH35unpec3jRaTi0SBoqRCys8Fuh5wcGDMGBg6E9HSrU4mIiKtSASQVgpcXfPABzJsH3t4QEwOdOsG+fVYnExERV6QCSCoMmw2eeAI2bjTvDNu3Dzp2hKVLrU4mIiKuRgWQVDidO0N8vDkY+vRpiIoyf4qIiFykQdBSIQUGmivJjx4Nd92Vd10xERERFUBSYXl7w5tv5m1budIsjtq3tyaTiIi4Bssvgc2ePZtGjRpht9sJCQlh06ZNRfbfsGEDISEh2O12GjduzNy5c/P1mTFjBk2bNqVSpUrUr1+f4cOHc+7cOUd9BCknfvgBBg2Cm2+Gv//d6jQiImIlSwugxYsXM2zYMMaNG0dCQgLdunWjZ8+eHDx4sMD+ycnJ9OrVi27dupGQkMDYsWMZMmQIS5Ysye3z6aefMnr0aCZOnEhSUhLR0dEsXryYMWPGOOtjiYuqVQu6dYNz5+CRR2B+zxhygttApUrQpo1565iIiLgFS2eC7tSpE+3bt2fOnDm5bc2bN6dv375Mnz49X/9Ro0axfPlykpKSctuioqLYuXMncX8sDf7ss8+SlJTEv/71r9w+zz//PFu3br3q2aWLNBN0xZWTA1OmwK7JMcQwgBxsePDHdNKGAUuWQP/+VscUEZFSKMn3t2VngM6fP098fDzh4eF52sPDw9m8eXOB74mLi8vXPyIigu3bt+dOc961a1fi4+PZunUrAAcOHCA2NpbevXsXmiUzM5P09PQ8D6mYPDxg0iT4qOHkS8UPXFpTY8oUS/OJiIhzWDYI+vjx42RnZxMYGJinPTAwkNTU1ALfk5qaWmD/CxcucPz4cWrXrs19993HsWPH6Nq1K4ZhcOHCBZ566ilGjx5daJbp06czefLka/9QUm74pe4Hrjj5aRjmQCEREanwLB8EfeVqroZhFLnCa0H9L29fv349U6dOZfbs2ezYsYOYmBhWrFjByy+/XOg2x4wZQ1paWu7j0KFDpf04Ul7cdFP+xcJsNmja1Jo8IiLiVJadAQoICMDT0zPf2Z6jR4/mO8tzUVBQUIH9vby8qFGjBgATJkwgMjKSxx9/HIDWrVvz+++/88QTTzBu3LgCV5D19fXF19e3LD6WlBcTJ8KAAZfG/vzx88K4iTz3FLzwAjRubHVIERFxFMvOAPn4+BASEsLatWvztK9du5awsLAC39OlS5d8/desWUNoaCje3t4AnD17Nl+R4+npiWEYWDjeW1xN//7mgOfgYHMV1eBgiIlh0s5+zJ0LoaGwapXVIUVExGEMCy1atMjw9vY2oqOjjb179xrDhg0zqlSpYqSkpBiGYRijR482IiMjc/sfOHDAqFy5sjF8+HBj7969RnR0tOHt7W188cUXuX0mTpxoVKtWzVi4cKFx4MABY82aNUaTJk2Me++9t9i50tLSDMBIS0sruw8r5cKhQ4bRqZNhgGHYbIbx8suGkZ1tdSoRESmOknx/WzoT9KBBgzhx4gRTpkzhyJEjtGrVitjYWBo0aADAkSNH8swJ1KhRI2JjYxk+fDizZs2iTp06zJw5kwEDBuT2GT9+PDabjfHjx3P48GFq1qzJXXfdxdSpU53++aT8qVcPNmyAoUPNleUnTIBt2+Djj8Hf3+p0IiJSViydB8hVaR4gAYiOhqefhvPn4U9/gmXLoEULq1OJiEhhysU8QCKu7rHH4NtvoX59OHIk/01jIiJSfmkxVJEidOgA8fHw/ffQvPml9os3jomISPmkM0AiV1GzJtx666XnGzZAz55w7JhlkURE5BqpABIpgQsX4K9/hdWrISQEtm+3OpGIiJSGCiCREvDyguXLzYmkDx2Crl3hww+tTiUiIiWlAkikhFq2hK1boU8fyMw0B0tHRZm/i4hI+aACSKQU/P1h6VL429/MwdDz5kH37pCebnUyEREpDhVAIqXk4QHjxkFsLFSvbq4dVq2a1alERKQ4dBu8yDXq0cO8Vb5WrUu3xp87B76+ulVeRMRV6QyQSBlo1AiqVDF/z8mB+++HBx6A33+3NpeIiBRMZ4BEytiOHbBihXnL/J495lihG2+0OpWIiFxOZ4BEylhoKPz73xAYaBZAoaHw9ddWpxIRkcupABJxgG7dzDNBXbpAWhrceSdMnmxeHhMREeupABJxkDp1YP16c0V5gEmT4MknrUwkIiIXqQAScSAfH5g1CxYsAD8/c9JEERGxngogESd45BH4+Wfo3PlS26FDlsUREXF7KoBEnOS66y79npgITZvC88+bd4uJiIhzqQASscA330BGBrz1FtxxBxw9anUiERH3ogJIxALDh8OSJVC1qjlQun172LLF6lQiIu5DBZCIRfr3h23boFkzOHwYbrkF5s+3OpWIiHtQASRioWbNYOtWsxg6fx6eeAJiYqxOJSJS8WkpDBGLVasGX3wBr70GGzbA3XdbnUhEpOLTGSARF2CzwahR5hpinp5mW2YmxMVZm0tEpKJSASTiQjwu+z/yueega1d44w0wDOsyiYhURCqARFxQdrY5JignB154AQYNgjNnrE4lIlJxqAAScUGenubyGbNng7c3fP45dOoE+/dbnUxEpGJQASTiomw2eOopc56g2rVh717o0AGWL7c6mYhI+acCSMTFhYXBjh3meKD0dHj0UUhLszqViEj5ptvgRcqBoCD4979h5Ejo0QP8/a1OJCJSvukMkEg54e0N77wDPXteats9OYaMm9pApUrQpo1mURQRKSYVQCLlVOqcGFpPGoDvj7vh3DnYvRsGDFARJCJSDCqARMqpgFmTycGGB39MEmQYGDYbTJlibTARkXJAY4BEyimv/+4H8s6QaDMMjH0/YLMmkohIuaEzQCLl1U03mffKXyYbG3uzm2oJDRGRq1ABJFJeTZxorpHxRxFk2Gx4YjD+wkT+/neLs4mIuDgVQCLlVf/+sGQJBAeD3Y4tOJiMT2NoNb4fM2ZYHU5ExLXZDEPLLF4pPT0df39/0tLS8PPzszqOSKllZ5triQ0ZAg0bWp1GRMSxSvL9rTNAIhXY9Onw9tsQEgJr11qdRkTEdagAEqnAHnoIQkPh5ElzBulXXjGHDYmIuDsVQCIV2A03wKZN8NhjkJMDY8bAwIHmmmIiIu5MBZBIBWe3wwcfwLx55nIaMTHQqRPs22d1MhER66gAEnETTzxhng2qWxd+/hkyM61OJCJiHc0ELeJGOnWC+HhITDTXThURcVc6AyTiZgIDISLi0vPvvoM774Tjx63LJCLibCqARNxYdjY88gh8/bV5t9iOHVYnEhFxDhVAIm7M0xM+/xxuvNEcFxQWhpbREBG3oAJIxM21bg3btpmXwTIzzTNCTz8N589bnUxExHFUAIkI110HX34Jkyeba6vOmQO33gppaVYnExFxDBVAIgKAhwe89BJ89RX4+5uDpatVszqViIhj6DZ4Ecmjd2/zVvmaNc2iCMzLYd7e5tkhEZGKQAWQiOTTpMml3w0DHn3ULH7efx8qV7Yul4hIWVEBJCJFSkyExYvNW+b37DGX0mjc2OpUIiLXRmOARKRI7drBunVQqxbs3GnOF7RypdWpRESujeUF0OzZs2nUqBF2u52QkBA2bdpUZP8NGzYQEhKC3W6ncePGzJ07N1+f3377jWeeeYbatWtjt9tp3rw5sbGxjvoIIhXerbea44I6dYJTp8xxQn/7m7nCvIhIeWRpAbR48WKGDRvGuHHjSEhIoFu3bvTs2ZODBw8W2D85OZlevXrRrVs3EhISGDt2LEOGDGHJkiW5fc6fP88dd9xBSkoKX3zxBT/88APz58+nbt26zvpYIhVSvXqwYQM8+aQ5LmjCBHOBVRGR8shmGIZh1c47depE+/btmTNnTm5b8+bN6du3L9OnT8/Xf9SoUSxfvpykpKTctqioKHbu3ElcXBwAc+fO5fXXX2ffvn14e3uXKld6ejr+/v6kpaXh5+dXqm2IVGTR0TB0qLmERvfuVqcRETGV5PvbsjNA58+fJz4+nvDw8Dzt4eHhbN68ucD3xMXF5esfERHB9u3bycrKAmD58uV06dKFZ555hsDAQFq1asW0adPIzs4uNEtmZibp6el5HiJSuMceg5SUvMXPkSOWxRERKTHLCqDjx4+TnZ1NYGBgnvbAwEBSU1MLfE9qamqB/S9cuMDxP5ayPnDgAF988QXZ2dnExsYyfvx43nzzTaZOnVpolunTp+Pv75/7qF+//jV+OpGKLyDg0u9JSdC0KbzwAly4YF0mEZHisnwQtO2KmdUMw8jXdrX+l7fn5ORQq1Yt3n//fUJCQrjvvvsYN25cnstsVxozZgxpaWm5j0OHDpX244i4pdWr4fRpeOMNCA+HY8esTiQiUjTL5gEKCAjA09Mz39meo0eP5jvLc1FQUFCB/b28vKhRowYAtWvXxtvbG09Pz9w+zZs3JzU1lfPnz+Pj45Nvu76+vvj6+l7rRxJxW8OGQd265oSJ33wDISGwZAl06GB1MhGRgll2BsjHx4eQkBDWrl2bp33t2rWEhYUV+J4uXbrk679mzRpCQ0NzBzzffPPN/PTTT+Rcdn/u/v37qV27doHFj4iUjXvuga1b4aab4NAh6NrVHCwtIuKKLL0ENmLECD744AM+/PBDkpKSGD58OAcPHiQqKgowL0099NBDuf2joqL4+eefGTFiBElJSXz44YdER0czcuTI3D5PPfUUJ06cYOjQoezfv5+vv/6aadOm8cwzzzj984m4mxYtzCLo7rvN9cMefxz++U+rU4mI5GfpUhiDBg3ixIkTTJkyhSNHjtCqVStiY2Np0KABAEeOHMkzJ1CjRo2IjY1l+PDhzJo1izp16jBz5kwGDBiQ26d+/fqsWbOG4cOHExwcTN26dRk6dCijRo1y+ucTcUf+/uZyGdOnmzNI9+tndSIRkfwsnQfIVWkeIJGykZ0NF4fjZWWZ64ppXJCIOEq5mAdIRCq+y+5F4IUXoEsXePttcyZpERErqQASEYfLzoYTJ8yfI0bAAw/A779bnUpE3JkKIBFxOE9P+PhjmDkTvLxg0SLo3Bl++snqZCLirlQAiYhT2Gzw3HPmPEFBQbBnD4SGmuuJiYg4mwogEXGqrl0hPh7CwiAtzbwcdubjGGjTBipVMn/GxFgdU0QqOBVAIuJ0deqYZ4KeeQZWPxlD1YcHwO7dcO6c+XPAABVBIuJQug2+ALoNXsSJ2rQxi57L/yqy2SA42LxvXkSkmHQbvIiUH/v3578v3jDghx+sySMibkEFkIhY66abzDM+l8nGxuFqTcnKsiiTiFR4KoBExFoTJ5pnfP4ognKw4YnBs8cmcvvt8L//WZxPRCqkEhdAP/zwA5MmTeLPf/4zTZo0oXbt2gQHB/Pwww/z2WefkZmZ6YicIlJR9e8PS5aYY37sdjzaBPPdizH8q1o/Nm6E9u3hu++sDikiFU2xB0EnJCTw4osvsmnTJsLCwujYsSN169alUqVKnDx5kj179rBp0ybS09N58cUXGTZsGL6+vo7O7xAaBC1ivX37zIVU9+2Dhx+Gjz6yOpGIuLqSfH8XuwBq0KABL7zwAg888ADXX399of3i4uJ4++23adu2LWPHji1ZchehAkjENZw+DS+/DJMmQeXKVqcREVfnkALo/Pnz+Pj4FDtESfu7EhVAIq4pJwfGj4eoKLjhBqvTiIirccht8MUtZs6ePVui/iIixfXWWzB9OoSEwL/+ZXUaESnPSnUX2K233sovv/ySr33Lli20bdv2WjOJiBRo4EBzUPTx4xAeDq+/nn8KIRGR4ihVAeTn50dwcDCLFi0CICcnh0mTJnHLLbfQp0+fMg0oInJRw4bw7bfmoOicHHjxRbj3XnOskIhISZR6KYy5c+cycuRI+vTpQ0pKCgcPHuSjjz7i9ttvL+uMTqcxQCKuzTBg7lwYOhSysqBFC1i61JxTUUTcV0m+v71Ku5OoqCh+/vlnXn31Vby8vFi/fj1hYWGl3ZyISLHZbPDUU+YyYgMHwk8/walTVqcSkfKkVJfATp06xYABA5gzZw7z5s3j3nvvJTw8nNmzZ5d1PhGRQoWFwY4d8Pnn0KmT1WlEpDwpVQHUqlUr/ve//5GQkMDgwYP55JNPiI6OZsKECfTu3busM4qIFCooCC4fepiYaE6gePKkZZFEpBwoVQEUFRXFxo0badSoUW7boEGD2LlzJ+fPny+zcCIiJZGTA3/5CyxbBqGhZjEkIlKQUg+Crsg0CFqk/Nq501xe7MABsNth/nyzKBKRis8hEyEePHiwRCEOHz5cov4iImWhTRvYvh169oRz5yAyEoYMMe8WExG5qNgFUIcOHRg8eDBbt24ttE9aWhrz58+nVatWxMTElElAEZGSql4dvvoKJkwwn7/7Lvzf/8Fvv1kaS0RcSLFvg09KSmLatGn06NEDb29vQkNDqVOnDna7nVOnTrF3716+//57QkNDef311+nZs6cjc4uIFMnTE6ZMgQ4dzEtgVapAtWpWpxIRV1HsMUC7du2iZcuWZGVlsXLlSjZu3EhKSgoZGRkEBATQrl07IiIiaNWqlaMzO5zGAIlULPv3Q0AAXH+9+fzCBbNAstmszSUiZcshq8F7enqSmppKzZo1ady4Mdu2baNGjRplEtjVqAASqdgGDzbHBM2ZA5UqWZ1GRMqKQwZBX3fddRw4cACAlJQUcnJyri2liIgFdu+GBQvg73+Hm2+GlBSrE4mIFYo9BmjAgAF0796d2rVrY7PZCA0NxdPTs8C+FwslERFX07o1rF0LgwZBQgKEhMCiRXDHHVYnExFnKnYB9P7779O/f39++uknhgwZwuDBg6mmEYUiUg7ddhvEx8OAAbBtG/ToAVOnwqhRGhck4i5KNRHio48+ysyZMytsAaQxQCLu4dw5c46g+fPN53/9K0RHW5tJRErPIWOALrdgwYIKW/yIiPuw2+H9982H3Q733GN1IhFxllIVQCIiFcngweZg6B49LrUdO2ZZHBFxAhVAIiJAYOCl3//7X2jaFMaMgexs6zKJiOOoABIRucLXX8OpU/DKK+ZZoePHrU4kImVNBZCIyBWGDDFvja9cGdatM2+Vj4+3OpWIlCUVQCIiBRg0CLZsgRtvhIMHzUkTP/rI6lQiUlZUAImIFKJVK3OeoDvvhMxMePRRWLjQ6lQiUhZUAImIFOG66+DLL2HyZOjcGfr3tzqRiJQFFUAiIlfh4QEvvQQbN4Kvr9mWnQ2JiZbGEpFroAJIRKSYvL0v/T5hAnToADNnQsnn0xcRq6kAEhEpoZwcc2D0hQswdChERsLZs1anEpGSUAEkIlJCHh7wj3/AjBng6QmffgphYXDggNXJRKS4VACJiJSCzWae/fnXv6BWLdi505wvaOVKq5OJSHGoABIRuQbdu8OOHeYdYr/9Zi6oqpmjRVyfl9UBRETKu7p1Yf16GDYMunWDgACrE4nI1agAEhEpA76+MGdO3rZt26BSJXNCRRFxLboEJiLiAP/7H/Tta14a++c/rU4jIldSASQi4gCentC8Ofz+u7mu2AsvmLfNi4hrUAEkIuIAAQGwahW8+KL5/I03IDwcjh2zNpeImFQAiYg4iJcXvPoqfP45VKkC33xj3iq/bZvVyUREBZCIiIMNHAhbt8JNN8GhQ/Dmm1YnEhEVQCIiTtCihVkEDRkC779vdRoRsbwAmj17No0aNcJutxMSEsKmTZuK7L9hwwZCQkKw2+00btyYuXPnFtp30aJF2Gw2+vbtW8apRURKzt8f3nkH/PzM54YBL78Mv/xibS4Rd2RpAbR48WKGDRvGuHHjSEhIoFu3bvTs2ZODBw8W2D85OZlevXrRrVs3EhISGDt2LEOGDGHJkiX5+v7888+MHDmSbt26OfpjiIiUyqxZ8NJL0L69OZGiiDiPzTAMw6qdd+rUifbt2zPnstnDmjdvTt++fZk+fXq+/qNGjWL58uUkJSXltkVFRbFz507i4uJy27Kzs+nevTuPPvoomzZt4rfffmPZsmWF5sjMzCQzMzP3eXp6OvXr1yctLQ2/i/9UExEpY8nJ0L8/JCaat82/9hoMH26uMyYiJZeeno6/v3+xvr8tOwN0/vx54uPjCQ8Pz9MeHh7O5s2bC3xPXFxcvv4RERFs376drKys3LYpU6ZQs2ZNHnvssWJlmT59Ov7+/rmP+vXrl/DTiIiUXKNG8J//QGQkZGfD88/D/febcweJiGNZVgAdP36c7OxsAgMD87QHBgaSmppa4HtSU1ML7H/hwgWO/7H64H/+8x+io6OZP39+sbOMGTOGtLS03MehQ4dK+GlEREqncmX4+9/h3XfN2+YXLzZnj/7xR6uTiVRslg+Ctl1xrtcwjHxtV+t/sf306dP85S9/Yf78+QSUYDVCX19f/Pz88jxERJzFZoNnnzXHAQUFQVIS/Pqr1alEKjbLFkMNCAjA09Mz39meo0eP5jvLc1FQUFCB/b28vKhRowbff/89KSkp3HXXXbmv5+TkAODl5cUPP/xAkyZNyviTiIiUjZtvhh074NtvoXt3q9OIVGyWnQHy8fEhJCSEtWvX5mlfu3YtYWFhBb6nS5cu+fqvWbOG0NBQvL29adasGbt37yYxMTH30adPH2677TYSExM1tkdEXF7t2nDPPZee791rriV26pR1mUQqIsvOAAGMGDGCyMhIQkND6dKlC++//z4HDx4kKioKMMfmHD58mI8//hgw7/h67733GDFiBIMHDyYuLo7o6GgWLlwIgN1up1WrVnn2cd111wHkaxcRcXU5OfDgg+ZdYtu3w9KlEBxsdSqRisHSAmjQoEGcOHGCKVOmcOTIEVq1akVsbCwNGjQA4MiRI3nmBGrUqBGxsbEMHz6cWbNmUadOHWbOnMmAAQOs+ggiIg7j4QEffmjeKn/ggDk4+oMP4IEHrE4mUv5ZOg+QqyrJPAIiIo524oRZ9KxZYz4fNsycM8jb29JYIi6nXMwDJCIixVOjBsTGwtix5vMZM+D22zUuSORaqAASESkHPD1h6lSIiYFq1cxb56tWtTqVSPll6RggEREpmX79oHlzqF790iWw7GxzvJCW0BApPhVAIiLlTLNmeZ8PHw5nzsDs2WC3W5NJpLxRASQiUo4lJZmryufkwK5dsGQJ/HEjrYgUQWOARETKsebNYfVqc6B0fDyEhMC6dVanEnF9KoBERMq522+/VPycOAEREfDqq6BJTkQKpwJIRKQCaNDAXEPs0UfNy2GjR8Njj1mdSsR1qQASEakg7HaIjoY5c8DHB/r0sTqRiOtSASQiUoHYbBAVZS6d0bfvpXZNmiiSlwogEZEKqG7dS78fOmTeOj9unDlnkIioABIRqfCWLYOjR2HaNOjd2xwoLeLuVACJiFRwzz0Hn3wClSqZt8yHhkJCgtWpRKylAkhExA08+CDExUHjxpCSAmFh8I9/WJ1KxDoqgERE3ESbNrB9O/TsCefOwUMPmWeGRNyRCiARETdSvTqsWAEvvQRt20L//lYnErGGCiARETfj4QGTJ8N330HlymZbTg7s2WNtLhFnUgEkIuKmfH0v/T5tGrRrZy6sqiU0xB2oABIRcXOGAXv3woUL8Oyz8MgjkJFhdSoRx1IBJCLi5mw2+PRTePNN8PSEjz827xJLTrY6mYjjqAASERFsNhgxAtauhZo1ITHRnC9ozRqrk4k4hgogERHJddttEB8PHTrAyZPmemJHj1qdSqTseVkdQEREXEv9+rBxIwwZAh07Qq1aVicSKXsqgEREJB+7Hd5/P2/bzp3g4wPNm1uTSaQs6RKYiIhc1YkT5uWwjh1hyRKr04hcOxVAIiJyVTk50LAhnDkDAwfC6NGQnW11KpHSUwEkIiJXVbOmeYfY88+bz199FXr0gOPHrc0lUloqgEREpFi8vOCNN2DRInMJjXXrICTEvGtMpLxRASQiIiUyaBBs2QI33ggHD8Lf/mZ1IpGSUwEkIiIl1qoVbNsGUVEQHW11GpGSUwEkIiKlct11MGcOXH+9+dww4LXX4PBhS2OJFIsKIBERKRPR0TBqFLRvb06kKOLKVACJiEiZuO02CA42l874v/+Dd94xzwqJuCIVQCIiUiaaNIHNm+GBB8w5goYNg7/8BX7/3epkIvmpABIRkTJTpQp88gnMmAGenvDZZxAWBv/9r9XJRPJSASQiImXKZoOhQ+Hf/zYXUt29WwWQuB4thioiIg5xyy2wY4dZCIWHW51GJC+dARIREYepWxciIy89/+kn83lamnWZREAFkIiIOIlhmAOkP/kEOnSAPXusTiTuTAWQiIg4hc0Gs2fDDTfAjz9C587wz39anUrclQogERFxmtBQ2L4d/vxn8/b4QYNg5Ei4cMHqZOJuVACJiIhT1awJq1bBiy+az9980xwkffKktbnEvagAEhERp/Pygldfhc8/N+cOOnvW/CniLLoNXkRELDNwILRoAX5+4OtrtuXkgIf+eS4OpgJIREQs1aJF3ufjxsHx4/Dee5eKIpGypgJIRERcxo8/wmuvmWeBdu6EJUugfn2rU0lFpJOMIiLiMv70J4iNherVYds2CAmBb76xOpVURCqARETEpUREQHw8tG0Lx47BHXeYd4oZhtXJpCJRASQiIi6nUSP4z3/MZTOys825gh57zOpUUpGoABIREZdUuTL8/e/mYGhvb/NMkEhZ0SBoERFxWTYbPPMM9O4NDRteak9PN2+dFyktnQESERGXd3nxk5pq3jo/caJ5t5hIaagAEhGRcmXJEjh8GKZMgbvuglOnrE4k5ZHlBdDs2bNp1KgRdrudkJAQNm3aVGT/DRs2EBISgt1up3HjxsydOzfP6/Pnz6dbt25Ur16d6tWrc/vtt7N161ZHfgQREXGiZ56Bjz8Gu928ZT40FHbtsjqVlDeWFkCLFy9m2LBhjBs3joSEBLp160bPnj05ePBggf2Tk5Pp1asX3bp1IyEhgbFjxzJkyBCWLFmS22f9+vXcf//9fPPNN8TFxXHDDTcQHh7O4cOHnfWxRETEwSIjYfNm89LYgQPQuTN89pnVqaQ8sRmGdTMrdOrUifbt2zNnzpzctubNm9O3b1+mT5+er/+oUaNYvnw5SUlJuW1RUVHs3LmTuLi4AveRnZ1N9erVee+993jooYeKlSs9PR1/f3/S0tLw0yg7ERGXdfIkPPAArF5tPv/oI3j4YUsjiYVK8v1t2Rmg8+fPEx8fT3h4eJ728PBwNm/eXOB74uLi8vWPiIhg+/btZGVlFfies2fPkpWVxfXXX19olszMTNLT0/M8RETE9V1/PXz9tbl+WIsW0L+/1YmkvLCsADp+/DjZ2dkEBgbmaQ8MDCQ1NbXA96SmphbY/8KFCxw/frzA94wePZq6dety++23F5pl+vTp+Pv75z7qa+EZEZFyw9MT/vY32L4dqlUz2wwD9u2zNpe4NssHQdtstjzPDcPI13a1/gW1A7z22mssXLiQmJgY7HZ7odscM2YMaWlpuY9Dhw6V5COIiIgLqFTp0u9vvw3BwTB3rpbQkIJZNhFiQEAAnp6e+c72HD16NN9ZnouCgoIK7O/l5UWNGjXytL/xxhtMmzaNdevWERwcXGQWX19ffH19S/EpRETE1RgGbN0KWVnw1FPm77Nm5S2QRCw7A+Tj40NISAhr167N07527VrCwsIKfE+XLl3y9V+zZg2hoaF4e3vntr3++uu8/PLLrFq1itDQ0LIPLyIiLstmg4UL4dVXwcMDFiyArl3h55+tTiauxNJLYCNGjOCDDz7gww8/JCkpieHDh3Pw4EGioqIA89LU5XduRUVF8fPPPzNixAiSkpL48MMPiY6OZuTIkbl9XnvtNcaPH8+HH35Iw4YNSU1NJTU1lTNnzjj984mIiDVsNnjxRfPusBo1YMcOCAmBdeusTiYuw7DYrFmzjAYNGhg+Pj5G+/btjQ0bNuS+9vDDDxvdu3fP03/9+vVGu3btDB8fH6Nhw4bGnDlz8rzeoEEDA8j3mDhxYrEzpaWlGYCRlpZ2LR9NRERcQEqKYYSEGAYYhq+vYRw+bHUicZSSfH9bOg+Qq9I8QCIiFcu5c/D009C2LQwZYnUacZSSfH9rNXgREanw7HaIjs7blpRkjhFq2tSaTGIty2+DFxERcQabzXwApKVB377QoQMsW2ZlKrGKCiAREXE7589DUBCcPg39+pkzSWdnW51KnEkFkIiIuJ2aNc07woYPN59Pmwa9esGJE9bmEudRASQiIm7J2xveestcRb5SJVizBkJDISHB6mTiDCqARETErd1/P3z3HTRpAikp5uUwqfhUAImIiNsLDoZt2+Cvf4WPPrI6jTiDCiARERGgenXzVvlatS61vfsu/PqrdZnEcVQAiYiIFODTT81JE0NC4NtvrU4jZU0FkIiISAE6doSWLSE1FW67Dd57z1xpXioGFUAiIiIF+NOfzMHRgwbBhQvw3HPw8MNw9qzVyaQsqAASEREpRNWqsHAhvPkmeHrCP/4BN98MyclWJ5NrpQJIRESkCDYbjBgBa9eaEygmJsLu3VankmulxVBFRESK4bbbID4eVq2CPn2sTiPXSmeAREREiql+fRg8+NLzgwfNuYPS063LJKWjAkhERKQUDAMefBAWLDDvGNu71+pEUhIqgERERErBZjPXEqtXD374ATp1giVLrE4lxaUCSEREpJQ6dDDHBd12G5w5AwMHwujR5m3z4tpUAImIiFyDWrXMleRHjjSfv/oq9OwJJ09am0uKpgJIRETkGnl5weuvw+LFUKUKHD8OdrvVqaQoug1eRESkjNx7r7l8RuXK5gPMwdI2m7W5JD8VQCIiImWoZcu8z19+GY4cgRkzwNfXkkhSABVAIiIiDnLgAEyZAtnZ5gzSX3wBdetanUpAY4BEREQcpnFj+OoruO46c2HV9u1h40arUwmoABIREXGonj1h+3YIDoajR+H//s+8HGYYVidzbyqAREREHKxJE4iLgwceMC+HDR8Ojz1mdSr3pgJIRETECSpXhk8+gXfeMW+bv/lmqxO5Nw2CFhERcRKbDYYMMS+L/elPl9p//92cP0icR2eAREREnOzy4ufECWjdGiZPhpwc6zK5GxVAIiIiFvrnPyE5GSZNgrvvht9+szqRe1ABJCIiYqGnnoIFC8xJElesMBdY3b3b6lQVnwogERERiz3yCGzeDA0awE8/QefOsGiR1akqNhVAIiIiLqB9e3O+oNtvh7Nn4f77zTND4hgqgERERFxEQACsWgWjR5tzB/Xta3WiiksFkIiIiAvx9ITp0821w6pXN9sMw1xXTMqOCiAREREXVLXqpd/nzYPmzWH+fOvyVDQqgERERFyYYcD69XD+PDzxBAweDJmZVqcq/1QAiYiIuDCbDT77DKZNM3//4AO45RY4dMjqZOWbCiAREREX5+EBY8aYA6Svvx62bjXvGvv6a6uTlV8qgERERMqJ8HCIj4d27eD4cfMusZQUq1OVT1oMVUREpBxp2BDi4swzQtWrm8+l5FQAiYiIlDO+vvDWW+YA6Yv27jUvkQ0dat5KL0XTJTAREZFyymYzf2ZmmjNHP/88dOmitcSKQwWQiIhIOefjA88+C35+sG2bOUB6wgTdLl8UFUAiIiLlnM1mzg+UlGQOjL5wAf72N2jbFtassTqda1IBJCIiUkHUqQMxMfD55xAYCPv2QUQErF1rdTLXowJIRESkArHZYOBA82zQsGEQFgZ//vOl17OzLYvmUlQAiYiIVEDVq8Pbb8OGDeZEigBnzkCzZjB5Mvz2m6XxLKcCSEREpALzumzCm08/hZ9+gkmTzPmDJk+GtDSrkllLBZCIiIibGDwYFi+GFi3MwmfSJGjQAEaOhORkq9M5lwogERERN+HhAffea84TdHkh9Oab0LQpHDtmdULnUQEkIiLiZi4vhFasMNcYu+suqFnzUp/oaPjvfx0UIHMP/NLX/GkRLYUhIiLipjw8oHdv85GVdak9ORkef9z8vXNnePBBs0Bq0KCMdnxmBZz5Eip1Ad9WZbTRkrH8DNDs2bNp1KgRdrudkJAQNm3aVGT/DRs2EBISgt1up3HjxsydOzdfnyVLltCiRQt8fX1p0aIFS5cudVR8ERGRCsHb+9Lvp0+bZ4U8POC77+C558xB0y1bmuOFvv/+Gnf2+7/z/rSApQXQ4sWLGTZsGOPGjSMhIYFu3brRs2dPDh48WGD/5ORkevXqRbdu3UhISGDs2LEMGTKEJUuW5PaJi4tj0KBBREZGsnPnTiIjI7n33nvZsmWLsz6WiIhIuRYcDKtXw+HD5q30N99sFkN795rjhfbtu9T3++/Nu8t+/NGcgbpAWb/AuR3mI/Z1+G2d2f7bWvP5xdeyDjv8s11kM4zL15J1rk6dOtG+fXvmzJmT29a8eXP69u3L9OnT8/UfNWoUy5cvJykpKbctKiqKnTt3EhcXB8CgQYNIT09n5cqVuX169OhB9erVWbhwYbFypaen4+/vT1paGn5+fqX9eCIiIhXGqVPmjNKxsfDOO+Dvb7ZPnAhTppi/e3tDo0bwpz/BjTdC/frwyCNQI70NZO7K3ZaRAzYPIIe8p2J8g6HRzlJnLMn3t2VngM6fP098fDzh4eF52sPDw9m8eXOB74mLi8vXPyIigu3bt5P1x8XLwvoUtk2AzMxM0tPT8zxERETkkurVzYHTH310qfgBqFvXHCdkt5vjiPbvh6+/NoukkSPNy2lUG5hnW7aL1ceVVUi1exz4CfKybBD08ePHyc7OJjAwME97YGAgqampBb4nNTW1wP4XLlzg+PHj1K5du9A+hW0TYPr06UyePLmUn0RERMR9PfGE+cjJgV9+MS+F/fST+TM1FQICgKoTzM7HXyp8QwEvQ8B4p2QGF7gLzGaz5XluGEa+tqv1v7K9pNscM2YMI0aMyH2enp5O/fr1rx5eREREAHOM0A03mI/L1x7LFTABPpoJdx7P/9qKmjDSecUPWFgABQQE4Onpme/MzNGjR/OdwbkoKCiowP5eXl7UqFGjyD6FbRPA19cXX1/f0nwMERERKa4uHSEn1vz94hgggLCOTo9i2RggHx8fQkJCWLt2bZ72tWvXEhYWVuB7unTpkq//mjVrCA0NxfuP+/cK61PYNkVERMQJjByotd2sPM56wjxP86cHUHOb+boTWXoJbMSIEURGRhIaGkqXLl14//33OXjwIFFRUYB5aerw4cN8/PHHgHnH13vvvceIESMYPHgwcXFxREdH57m7a+jQodxyyy28+uqr3H333Xz55ZesW7eOb7/91pLPKCIiIoCRAV71odLNcONcCK0FF45CahRcOGS+bqvitDiWFkCDBg3ixIkTTJkyhSNHjtCqVStiY2Np8MdUk0eOHMkzJ1CjRo2IjY1l+PDhzJo1izp16jBz5kwGDBiQ2ycsLIxFixYxfvx4JkyYQJMmTVi8eDGdOnVy+ucTERGRP3hUgYZbwOZ5qc2rFtSLASM7b7sTWDoPkKvSPEAiIiLlT7mYB0hERETEKiqARERExO2oABIRERG3owJIRERE3I4KIBEREXE7KoBERETE7agAEhEREbejAkhERETcjgogERERcTuWLoXhqi5Ojp2enm5xEhERESmui9/bxVnkQgVQAU6fPg1A/fr1LU4iIiIiJXX69Gn8/f2L7KO1wAqQk5PDr7/+SrVq1bDZbGW67fT0dOrXr8+hQ4e0zpgD6Tg7h46zc+g4O4+OtXM46jgbhsHp06epU6cOHh5Fj/LRGaACeHh4UK9ePYfuw8/PT/9zOYGOs3PoODuHjrPz6Fg7hyOO89XO/FykQdAiIiLidlQAiYiIiNtRAeRkvr6+TJw4EV9fX6ujVGg6zs6h4+wcOs7Oo2PtHK5wnDUIWkRERNyOzgCJiIiI21EBJCIiIm5HBZCIiIi4HRVAIiIi4nZUADnY1KlTCQsLo3Llylx33XXFeo9hGEyaNIk6depQqVIlbr31Vr7//nvHBq0ATp06RWRkJP7+/vj7+xMZGclvv/1W5HvOnDnDs88+S7169ahUqRLNmzdnzpw5zglcTpXmOAMkJSXRp08f/P39qVatGp07d+bgwYOOD1xOlfY4X/Tkk09is9mYMWOGwzJWBCU9zllZWYwaNYrWrVtTpUoV6tSpw0MPPcSvv/7qvNDlxOzZs2nUqBF2u52QkBA2bdpUZP8NGzYQEhKC3W6ncePGzJ0716H5VAA52Pnz57nnnnt46qmniv2e1157jbfeeov33nuPbdu2ERQUxB133JG7RpkU7IEHHiAxMZFVq1axatUqEhMTiYyMLPI9w4cPZ9WqVXzyySckJSUxfPhwnnvuOb788ksnpS5/SnOc//vf/9K1a1eaNWvG+vXr2blzJxMmTMButzspdflTmuN80bJly9iyZQt16tRxcMryr6TH+ezZs+zYsYMJEyawY8cOYmJi2L9/P3369HFiate3ePFihg0bxrhx40hISKBbt2707Nmz0H/0JCcn06tXL7p160ZCQgJjx45lyJAhLFmyxHEhDXGKBQsWGP7+/lftl5OTYwQFBRmvvPJKbtu5c+cMf39/Y+7cuQ5MWL7t3bvXAIzvvvsuty0uLs4AjH379hX6vpYtWxpTpkzJ09a+fXtj/PjxDstanpX2OA8aNMj4y1/+4oyIFUJpj7NhGMYvv/xi1K1b19izZ4/RoEED4+2333Zw2vLrWo7z5bZu3WoAxs8//+yImOVSx44djaioqDxtzZo1M0aPHl1g/xdffNFo1qxZnrYnn3zS6Ny5s8My6gyQi0lOTiY1NZXw8PDcNl9fX7p3787mzZstTOba4uLi8Pf3p1OnTrltnTt3xt/fv8jj1rVrV5YvX87hw4cxDINvvvmG/fv3ExER4YzY5U5pjnNOTg5ff/01N910ExEREdSqVYtOnTqxbNkyJ6Uuf0r733NOTg6RkZG88MILtGzZ0hlRy7XSHucrpaWlYbPZij3MoaI7f/488fHxeb7HAMLDwws9rnFxcfn6R0REsH37drKyshySUwWQi0lNTQUgMDAwT3tgYGDua5JfamoqtWrVytdeq1atIo/bzJkzadGiBfXq1cPHx4cePXowe/Zsunbt6si45VZpjvPRo0c5c+YMr7zyCj169GDNmjX069eP/v37s2HDBkdHLpdK+9/zq6++ipeXF0OGDHFkvAqjtMf5cufOnWP06NE88MADWjz1D8ePHyc7O7tE32OpqakF9r9w4QLHjx93SE4VQKUwadIkbDZbkY/t27df0z5sNlue54Zh5GtzByU51gUdn6sdt5kzZ/Ldd9+xfPly4uPjefPNN3n66adZt26dwz6TK3Lkcc7JyQHg7rvvZvjw4bRt25bRo0dz5513OnyQo6tx5HGOj4/nnXfe4aOPPnLLvysu5+i/Ny7KysrivvvuIycnh9mzZ5f55yjvSvo9VlD/gtrLipdDtlrBPfvss9x3331F9mnYsGGpth0UFASY1XDt2rVz248ePZqvOnYHxT3Wu3bt4n//+1++144dO1boccvIyGDs2LEsXbqU3r17AxAcHExiYiJvvPEGt99++7V/gHLCkcc5ICAALy8vWrRokae9efPmfPvtt6UPXQ458jhv2rSJo0ePcsMNN+S2ZWdn8/zzzzNjxgxSUlKuKXt54sjjfFFWVhb33nsvycnJ/Pvf/9bZn8sEBATg6emZ72xPUd9jQUFBBfb38vKiRo0aDsmpAqgUAgICCAgIcMi2GzVqRFBQEGvXrqVdu3aAeT11w4YNvPrqqw7Zpysr7rHu0qULaWlpbN26lY4dOwKwZcsW0tLSCAsLK/A9WVlZZGVl4eGR90Sop6dn7lkLd+HI4+zj40OHDh344Ycf8rTv37+fBg0aXHv4csSRxzkyMjJf0R4REUFkZCSPPvrotYcvRxx5nOFS8fPjjz/yzTffOOwLurzy8fEhJCSEtWvX0q9fv9z2tWvXcvfddxf4ni5duvDVV1/laVuzZg2hoaF4e3s7JqjDhleLYRiG8fPPPxsJCQnG5MmTjapVqxoJCQlGQkKCcfr06dw+TZs2NWJiYnKfv/LKK4a/v78RExNj7N6927j//vuN2rVrG+np6VZ8hHKjR48eRnBwsBEXF2fExcUZrVu3Nu688848fa481t27dzdatmxpfPPNN8aBAweMBQsWGHa73Zg9e7az45cbpTnOMTExhre3t/H+++8bP/74o/Huu+8anp6exqZNm5wdv9wozXG+ku4Cu7qSHuesrCyjT58+Rr169YzExETjyJEjuY/MzEwrPoJLWrRokeHt7W1ER0cbe/fuNYYNG2ZUqVLFSElJMQzDMEaPHm1ERkbm9j9w4IBRuXJlY/jw4cbevXuN6Ohow9vb2/jiiy8cllEFkIM9/PDDBpDv8c033+T2AYwFCxbkPs/JyTEmTpxoBAUFGb6+vsYtt9xi7N692/nhy5kTJ04YDz74oFGtWjWjWrVqxoMPPmicOnUqT58rj/WRI0eMRx55xKhTp45ht9uNpk2bGm+++aaRk5Pj3PDlSGmOs2EYRnR0tHHjjTcadrvdaNOmjbFs2TLnhS6HSnucL6cC6OpKepyTk5ML/Dv9yr/XxTBmzZplNGjQwPDx8THat29vbNiwIfe1hx9+2OjevXue/uvXrzfatWtn+Pj4GA0bNjTmzJnj0Hw2w/hjlJGIiIiIm9BdYCIiIuJ2VACJiIiI21EBJCIiIm5HBZCIiIi4HRVAIiIi4nZUAImIiIjbUQEkIiIibkcFkIiIiLgdFUAiIiLidlQAiYiIiNtRASQiIiJuRwWQiLiFY8eOERQUxLRp03LbtmzZgo+PD2vWrLEwmYhYQYuhiojbiI2NpW/fvmzevJlmzZrRrl07evfuzYwZM6yOJiJOpgJIRNzKM888w7p16+jQoQM7d+5k27Zt2O12q2OJiJOpABIRt5KRkUGrVq04dOgQ27dvJzg42OpIImIBjQESEbdy4MABfv31V3Jycvj555+tjiMiFtEZIBFxG+fPn6djx460bduWZs2a8dZbb7F7924CAwOtjiYiTqYCSETcxgsvvMAXX3zBzp07qVq1KrfddhvVqlVjxYoVVkcTESfTJTARcQvr169nxowZ/OMf/8DPzw8PDw/+8Y9/8O233zJnzhyr44mIk+kMkIiIiLgdnQESERERt6MCSERERNyOCiARERFxOyqARERExO2oABIRERG3owJIRERE3I4KIBEREXE7KoBERETE7agAEhEREbejAkhERETcjgogERERcTv/D6lShBY1LnFSAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_test, fx_test, '--', color='blue', label='$(x,f(x))$')\n", + "plt.plot(x_list_evaluated, f_list_evaluated, marker='.', color='red', linestyle='none', markersize=8, label='$(x_t,f(x_t))$')\n", + "plt.plot(xs_evaluated, fs_evaluated, marker='*', color='gold', linestyle='none', markersize=8, label='$(x_*,f(x_*))$')\n", + "\n", + "\n", + "plt.legend()\n", + "plt.xlabel('x')\n", + "plt.ylabel('f(x)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1c9d0ffe-808e-41df-aa4f-4f67bc7ffc77", + "metadata": {}, + "source": [ + "We observe a nice Huber-type function, as predicted by Corollary 3.1 from [this paper](https://arxiv.org/pdf/1206.3209)." + ] + }, + { + "cell_type": "markdown", + "id": "11561b38-b5b9-4744-b9b1-1be5c36acba4", + "metadata": { + "tags": [] + }, + "source": [ + "## Example 2 : FISTA for composite convex minimization \n", + "\n", + "We consider the following convex minimization problem:\n", + "\\begin{equation}\n", + "F_\\star \\triangleq \\min_x f(x)+h(x),\n", + "\\end{equation}\n", + "where $f$ is $L$-smooth and convex, and where $h$ is convex (closed, proper) with a proximal operator readily available.\n", + "\n", + "For this example, we consider the problem of computing the smallest possible $\\tau(n, L)$ such that the following guarantee holds (for all initialization of the algorithm, and all $L$-smooth convex function)\n", + "\\begin{equation}\n", + "F(x_n)-F_\\star \\leqslant \\tau(n, L, \\gamma) \\| x_0 - x_\\star \\|^2,\n", + "\\end{equation}\n", + "where $x_n$ is the output of the FISTA initiated at $x_0$, and where $x_\\star$ is a solution.\n", + "\n", + "#### Algorithm\n", + "\n", + "The iterates of FISTA are described as (for $t \\in \\{0,1, \\ldots, n-1\\}$)\n", + "\\begin{eqnarray}\n", + " \\lambda_{t+1} & = &\\frac{1 + \\sqrt{4\\lambda_t^2 + 1}}{2}\\\\\n", + " x_t & = &\\mathrm{argmin}_x \\left\\{h(x)+\\frac{L}{2}\\left\\|x-\\left(y_t - \\frac{1}{L} \\nabla f(y_t)\\right)\\right\\|^2 \\right\\}\\\\\n", + " y_{t+1} & = & x_t + \\frac{\\lambda_t-1}{\\lambda_{t+1}} (x_t-x_{t-1}).\n", + "\\end{eqnarray}\n", + "\n", + "Let us first start by importing all necessary packages for the implementation in PEPit" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dcaaadeb-c9bc-4173-875d-efa8aa098113", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from math import sqrt\n", + "from PEPit import PEP\n", + "from PEPit.functions import SmoothConvexFunction\n", + "from PEPit.functions import ConvexFunction\n", + "from PEPit.primitive_steps import proximal_step" + ] + }, + { + "cell_type": "markdown", + "id": "9fd7a956-ad1f-4646-807f-224308970365", + "metadata": {}, + "source": [ + "The following lines adapt the previous code to the study of FISTA:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4061ac10-38dc-422e-ac99-500929d3d08f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(PEPit) Setting up the problem: size of the Gram matrix: 10x10\n", + "(PEPit) Setting up the problem: performance measure is the minimum of 1 element(s)\n", + "(PEPit) Setting up the problem: Adding initial conditions and general constraints ...\n", + "(PEPit) Setting up the problem: initial conditions and general constraints (1 constraint(s) added)\n", + "(PEPit) Setting up the problem: interpolation conditions for 2 function(s)\n", + "\t\t\tFunction 1 : Adding 20 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 20 scalar constraint(s) added\n", + "\t\t\tFunction 2 : Adding 12 scalar constraint(s) ...\n", + "\t\t\tFunction 2 : 12 scalar constraint(s) added\n", + "(PEPit) Setting up the problem: additional constraints for 0 function(s)\n", + "(PEPit) Compiling SDP\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.07617878654557693\n", + "(PEPit) Postprocessing: 3 eigenvalue(s) > 7.475738589339979e-08 before dimension reduction\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.07617778646352988\n", + "(PEPit) Postprocessing: 1 eigenvalue(s) > 3.6854606250823318e-09 after dimension reduction\n", + "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -9.39e-11 < 0).\n", + " Small deviation from 0 may simply be due to numerical error. Big ones should be deeply investigated.\n", + " In any case, from now the provided values of parameters are based on the projection of the Gram matrix onto the cone of symmetric semi-definite matrix.\u001b[0m\n", + "(PEPit) Primal feasibility check:\n", + "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 9.390868888605197e-11\n", + "\t\tAll the primal scalar constraints are verified up to an error of 1.9873790634006294e-10\n", + "(PEPit) Dual feasibility check:\n", + "\t\tThe solver found a residual matrix that is positive semi-definite\n", + "\t\tAll the dual scalar values associated with inequality constraints are nonnegative\n", + "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 5.799398345118396e-08\n", + "(PEPit) Final upper bound (dual): 0.07617879083709189 and lower bound (primal example): 0.07617778646352988 \n", + "(PEPit) Duality gap: absolute: 1.0043735620135497e-06 and relative: 1.3184598931532273e-05\n" + ] + } + ], + "source": [ + "# Parameters / options for the study:\n", + "verbose = 1 # verbose\n", + "n = 3 # number of iterations\n", + "L = 1 # Lipschitz constant\n", + "\n", + "# Performance estimation problem (PEP) formulation:\n", + "\n", + "# Instantiate PEP\n", + "problem = PEP()\n", + "\n", + "# Declare a strongly convex smooth function and a convex function\n", + "f = problem.declare_function(SmoothConvexFunction, L=L)\n", + "h = problem.declare_function(ConvexFunction)\n", + "F = f + h\n", + "\n", + "# Start by defining an optimal point xs = x_* and its function value Fs = F(x_*)\n", + "xs = F.stationary_point()\n", + "Fs = F(xs)\n", + "gs, fs = f.oracle(xs) # this is g(xs)=f'(x_*)\n", + "ss, hs = -gs, Fs - fs # this is s(xs) \\in \\partial h(x_*) and hs = Fs - fs\n", + "\n", + "# Create empty lists for saving a worst-case trajectory\n", + "y_list = list() # this is the list of points where we will evaluate f() and its gradient\n", + "g_list = list() # this is the list of evaluated gradients of f() at y's\n", + "f_list = list() # this is the list of evaluated f() at y's\n", + "x_list = list() # this is the list of outputs of the proximal operator\n", + "s_list = list() # this is the list of evaluated subgradients of h() at x's (outputs of prox)\n", + "h_list = list() # this is the list of evaluated h() at x's (outputs of prox)\n", + "\n", + "# Then define a starting point x0\n", + "x0 = problem.set_initial_point()\n", + "# Set the initial constraint that is the distance between x0 and x^*\n", + "problem.set_initial_condition((x0 - xs) ** 2 <= 1)\n", + "\n", + "# Compute n steps of FISTA starting from x0 \t\n", + "x_new = x0\n", + "y = x0\n", + "lam = 1\n", + "for i in range(n):\n", + " # update momentum parameters\n", + " lam_old = lam\n", + " lam = (1 + sqrt(4 * lam_old ** 2 + 1)) / 2\n", + " \n", + " # save old point for momentum\n", + " x_old = x_new\n", + " \n", + " # evaluate gradient at y + save corresponding values\n", + " gy, fy = f.oracle(y)\n", + " y_list.append(y)\n", + " g_list.append(gy)\n", + " f_list.append(fy)\n", + " \n", + " # perform a proximal-gradient step\n", + " x_new, sx_new, hx_new = proximal_step(y - 1 / L * gy, h, 1 / L)\n", + " \n", + " # save outputs/subgradient of h() at x (output of prox)\n", + " x_list.append(x_new)\n", + " s_list.append(sx_new)\n", + " h_list.append(hx_new)\n", + " \n", + " y = x_new + (lam_old - 1) / lam * (x_new - x_old)\n", + "\n", + "# Since we evaluate the performance of the algorithm at x_n, we add it to the y_list (list of points at which f() is evaluated)\n", + "gx, fx = f.oracle(x_new)\n", + "y_list.append(x_new)\n", + "g_list.append(gx)\n", + "f_list.append(fx) \n", + "\n", + "# Set the performance metric to the function value accuracy\n", + "problem.set_performance_metric((fx + hx_new) - Fs)\n", + "\n", + "# Solve the PEP\n", + "pepit_verbose = max(verbose, 0)\n", + "pepit_tau = problem.solve(verbose=pepit_verbose, dimension_reduction_heuristic=\"trace\", tol_dimension_reduction=1e-6)" + ] + }, + { + "cell_type": "markdown", + "id": "6e3cb1e3-c112-40f4-9ef8-d3f31d46652e", + "metadata": {}, + "source": [ + "Let us clean and evaluate the different lists, in order to plot the corresponding functions" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9102b19b-4b59-40a2-8a27-700cb469e930", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "problem.trim_dimension(True) # Remove the useless dimensions\n", + "\n", + "# Evaluation at the optimal point:\n", + "xs_evaluated = xs.eval_ld() # x*\n", + "gs_evaluated = gs.eval_ld() # g(x*)=0\n", + "fs_evaluated = fs.eval() # f(x*)\n", + "ss_evaluated = -gs_evaluated # s(x*) \\in\\partial h(x*)\n", + "hs_evaluated = Fs.eval() - fs_evaluated\n", + "\n", + "# Evaluation of the trajectories (recentered around x* = 0)\n", + "y_list_evaluated = [y.eval_ld()-xs_evaluated for y in y_list] # centered iterates (evaluations of f() )\n", + "x_list_evaluated = [x.eval_ld()-xs_evaluated for x in x_list] # centered iterates (evaluations of h() )\n", + "\n", + "g_list_evaluated = [g.eval_ld() for g in g_list] # gradient values for f\n", + "s_list_evaluated = [s.eval_ld() for s in s_list] # gradient values for h\n", + "\n", + "f_list_evaluated = [f.eval()-fs_evaluated for f in f_list] # centered function values\n", + "h_list_evaluated = [h.eval()-hs_evaluated for h in h_list] # centered function values\n", + "\n", + "xs_evaluated = xs_evaluated - xs_evaluated # should be zero \n", + "fs_evaluated = fs_evaluated - fs_evaluated # should be zero \n", + "hs_evaluated = hs_evaluated - hs_evaluated # should be zero " + ] + }, + { + "cell_type": "markdown", + "id": "da497570-cbc7-4e87-b9f9-711f00e5e2d6", + "metadata": {}, + "source": [ + "Let us now plot the iterates (in 1D) on the two functions, side to side:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "12e4a91e-55b4-4a44-b4f1-ad4281bcfdca", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + "# --------------------------\n", + "# LEFT: trajectory evaluated on f()\n", + "# --------------------------\n", + "ax1.plot(y_list_evaluated, f_list_evaluated, '.--', color='blue')\n", + "ax1.plot(y_list_evaluated, f_list_evaluated, marker='.', color='red',\n", + " linestyle='none', markersize=8,\n", + " label='$\\\\{(y_t,f(y_t))\\\\}_{t=0,\\\\ldots,n} \\\\cup \\\\{(x_n,f(x_n))\\\\}$')\n", + "ax1.plot(xs_evaluated, fs_evaluated, marker='*', color='gold',\n", + " linestyle='none', markersize=8,\n", + " label='$(x_\\\\star,f(x_\\\\star))$')\n", + "\n", + "ax1.set_xlabel('x')\n", + "ax1.set_ylabel('f(x)')\n", + "ax1.legend()\n", + "ax1.set_title('Trajectory on $f$')\n", + "\n", + "\n", + "# --------------------------\n", + "# RIGHT: trajectory evaluated on h()\n", + "# --------------------------\n", + "ax2.plot(x_list_evaluated, h_list_evaluated, '.--', color='blue')\n", + "ax2.plot(x_list_evaluated, h_list_evaluated, marker='.', color='red',\n", + " linestyle='none', markersize=8,\n", + " label='$\\\\{(x_t,h(x_t))\\\\}_{t=1,\\\\ldots,n}$')\n", + "ax2.plot(xs_evaluated, hs_evaluated, marker='*', color='gold',\n", + " linestyle='none', markersize=8,\n", + " label='$(x_\\\\star,h(x_\\\\star))$')\n", + "\n", + "ax2.set_xlabel('x')\n", + "ax2.set_ylabel('h(x)')\n", + "ax2.legend()\n", + "ax2.set_title('Trajectory on $h$')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3ae9e031-67fb-44d2-82b8-7f9cb0ca2c5b", + "metadata": {}, + "source": [ + "This is already quite informative, but arguably not enough. Can we easily recover a pair of functions interpolating through those points? Let interpolate an example of a worst-case function $F()$ by computing the two components individually, using again the `interpolator` tool." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a5df55df-41f8-4d65-add2-8c265df2bf2f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from PEPit.tools.interpolator import Interpolator\n", + "\n", + "# Add the x* to the lists of points to be interpolated\n", + "y_list_evaluated.append(xs_evaluated)\n", + "f_list_evaluated.append(fs_evaluated)\n", + "g_list_evaluated.append(gs_evaluated)\n", + "\n", + "x_list_evaluated.append(xs_evaluated)\n", + "h_list_evaluated.append(hs_evaluated)\n", + "s_list_evaluated.append(ss_evaluated)\n", + "\n", + "# Create an interpolator for f (within the class of L-smooth convex functions)\n", + "triplets = (y_list_evaluated,g_list_evaluated,f_list_evaluated)\n", + "fy = Interpolator(triplets,0,L,d=1)\n", + "\n", + "# Create an interpolator for h (within the class of closed convex proper functions)\n", + "triplets = (x_list_evaluated,s_list_evaluated,h_list_evaluated)\n", + "hx = Interpolator(triplets,0,np.inf,d=1)\n" + ] + }, + { + "cell_type": "markdown", + "id": "54316826-cc1b-4536-8db6-2a1f959075fb", + "metadata": { + "tags": [] + }, + "source": [ + "Query the interpolator at a set of point in the relevant interval" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "95b82bc9-97c4-4e5b-9b60-ca0be861f147", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50 done on 50\n", + "50 done on 50\n" + ] + } + ], + "source": [ + "y_test = np.linspace(-np.max(np.abs(y_list_evaluated)),np.max(np.abs(y_list_evaluated)),50)\n", + "\n", + "fy_test = np.zeros(y_test.shape)\n", + "for i in range(len(y_test)):\n", + " fy_test[i] = fy.evaluate(y_test[i])\n", + " if (i+1) % 50 == 0:\n", + " print('{} done on {}'.format((i+1),len(y_test)))\n", + " \n", + "x_test = np.linspace(-np.max(np.abs(x_list_evaluated)),np.max(np.abs(x_list_evaluated)),50)\n", + "\n", + "hx_test = np.zeros(x_test.shape)\n", + "for i in range(len(x_test)):\n", + " hx_test[i] = hx.evaluate(x_test[i])\n", + " if (i+1) % 50 == 0:\n", + " print('{} done on {}'.format((i+1),len(x_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "77d9783a-ecb1-4eb8-a015-57927ec221aa", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + "# --------------------------\n", + "# LEFT: trajectory evaluated on f()\n", + "# --------------------------\n", + "ax1.plot(y_test, fy_test, '--', color='blue')\n", + "ax1.plot(y_list_evaluated, f_list_evaluated, marker='.', color='red',\n", + " linestyle='none', markersize=8,\n", + " label='$\\\\{(y_t,f(y_t))\\\\}_{t=0,\\\\ldots,n} \\\\cup \\\\{(x_n,f(x_n))\\\\}$')\n", + "ax1.plot(xs_evaluated, fs_evaluated, marker='*', color='gold',\n", + " linestyle='none', markersize=8,\n", + " label='$(x_\\\\star,f(x_\\\\star))$')\n", + "\n", + "ax1.set_xlabel('x')\n", + "ax1.set_ylabel('f(x)')\n", + "ax1.legend()\n", + "ax1.set_title('Trajectory on $f$')\n", + "\n", + "\n", + "# --------------------------\n", + "# RIGHT: trajectory evaluated on h()\n", + "# --------------------------\n", + "ax2.plot(x_test, hx_test, '--', color='blue')\n", + "ax2.plot(x_list_evaluated, h_list_evaluated, marker='.', color='red',\n", + " linestyle='none', markersize=8,\n", + " label='$\\\\{(x_t,h(x_t))\\\\}_{t=1,\\\\ldots,n}$')\n", + "ax2.plot(xs_evaluated, hs_evaluated, marker='*', color='gold',\n", + " linestyle='none', markersize=8,\n", + " label='$(x_\\\\star,h(x_\\\\star))$')\n", + "\n", + "ax2.set_xlabel('x')\n", + "ax2.set_ylabel('h(x)')\n", + "ax2.legend()\n", + "ax2.set_title('Trajectory on $h$')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ab1f847b-3aa1-4a8d-b319-e5e0775f0343", + "metadata": {}, + "source": [ + "So we observe that the worst-case is achieved already when $f$ is linear and when $h$ is a $\\ell_1$-shaped (in fact, $h$ can also be taken as a simple indicator, see, e.g., [this paper (Section 4.2)](https://arxiv.org/pdf/1512.07516) or [Yoel Drori's thesis, Section 2.8](https://www.researchgate.net/profile/Yoel-Drori/publication/303895929_Contributions_to_the_Complexity_Analysis_of_Optimization_Algorithms/links/575b19f008ae9a9c95519686/Contributions-to-the-Complexity-Analysis-of-Optimization-Algorithms.pdf) for the related projected gradient method)." + ] + }, + { + "cell_type": "markdown", + "id": "c3c2ebf1-f683-4e85-987e-a3d8b29722dd", + "metadata": {}, + "source": [ + "## Example 3 : alternate projections for finding a point in intersection of two convex sets \n", + "\n", + "In this example, we investigate low-dimensional examples achieving a worst-case ratio for the criterion \n", + "\\begin{equation}\n", + "\\frac{\\|\\mathrm{Proj}_{Q_1}(x_t)-\\mathrm{Proj}_{Q_2}(x_t)\\|^2}{\\|x_0-x_\\star\\|^2}\n", + "\\end{equation}\n", + "\n", + "where $Q_1$ and $Q_2$ are two closed convex sets, and where $x_t$ ($t\\in\\{0,\\ldots,n\\}$) are generated by the alternate projection method\n", + "\n", + "\\begin{equation}\n", + "x_{t+1} = \\mathrm{Proj}_{Q_2}\\left(\\mathrm{Proj}_{Q_1}\\left(x_t\\right)\\right).\n", + "\\end{equation}\n", + "\n", + "Below, we model the problem as: \n", + "\\begin{equation}\n", + "\\text{Find } x\\in\\mathbb{R}^d: x\\in Q_1\\cap Q_2 \\quad \\Leftrightarrow \\quad \\min_{x\\in\\mathbb{R}^d} f_1(x)+f_2(x),\n", + "\\end{equation}\n", + "with $f_1,f_2$ respectively the indicator functions for $Q_1$ and $Q_2$.\n", + "\n", + "We start with a few imports." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9676680d-7c0d-4317-9f44-dab19835122c", + "metadata": {}, + "outputs": [], + "source": [ + "from PEPit import PEP\n", + "from PEPit.functions import ConvexIndicatorFunction\n", + "from PEPit.primitive_steps import proximal_step" + ] + }, + { + "cell_type": "markdown", + "id": "d9c0dd6d-3af7-468c-916f-41059e456fd9", + "metadata": {}, + "source": [ + "Then, let us code the alternate projection example in PEPit." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "60bb3c0b-246a-4568-8586-17ce84fb6301", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(PEPit) Setting up the problem: size of the Gram matrix: 7x7\n", + "(PEPit) Setting up the problem: performance measure is the minimum of 1 element(s)\n", + "(PEPit) Setting up the problem: Adding initial conditions and general constraints ...\n", + "(PEPit) Setting up the problem: initial conditions and general constraints (1 constraint(s) added)\n", + "(PEPit) Setting up the problem: interpolation conditions for 2 function(s)\n", + "\t\t\tFunction 1 : Adding 9 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 9 scalar constraint(s) added\n", + "\t\t\tFunction 2 : Adding 9 scalar constraint(s) ...\n", + "\t\t\tFunction 2 : 9 scalar constraint(s) added\n", + "(PEPit) Setting up the problem: additional constraints for 0 function(s)\n", + "(PEPit) Compiling SDP\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.1481481525665704\n", + "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -3.1e-09 < 0).\n", + " Small deviation from 0 may simply be due to numerical error. Big ones should be deeply investigated.\n", + " In any case, from now the provided values of parameters are based on the projection of the Gram matrix onto the cone of symmetric semi-definite matrix.\u001b[0m\n", + "(PEPit) Primal feasibility check:\n", + "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 3.0955627696216428e-09\n", + "\t\tAll the primal scalar constraints are verified up to an error of 4.619276183781551e-09\n", + "(PEPit) Dual feasibility check:\n", + "\t\tThe solver found a residual matrix that is positive semi-definite\n", + "\t\tAll the dual scalar values associated with inequality constraints are nonnegative\n", + "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 2.701335510997387e-08\n", + "(PEPit) Final upper bound (dual): 0.14814815427049585 and lower bound (primal example): 0.1481481525665704 \n", + "(PEPit) Duality gap: absolute: 1.7039254451844954e-09 and relative: 1.1501496411970686e-08\n" + ] + } + ], + "source": [ + "# Parameters / options for the study:\n", + "verbose = 1 # verbose\n", + "n = 2 # number of iterations\n", + "\n", + "\n", + "# Instantiate PEP\n", + "problem = PEP()\n", + "\n", + "f1 = problem.declare_function(ConvexIndicatorFunction) # indicator for Q1\n", + "f2 = problem.declare_function(ConvexIndicatorFunction) # indicator for Q2\n", + "func = f1 + f2 # indicator for the intersection\n", + "\n", + "# x* is a point in the intersection\n", + "xs = func.stationary_point()\n", + "\n", + "# Then define the starting point x0 of the algorithm\n", + "x0 = problem.set_initial_point()\n", + "\n", + "# Run the alternate projection method\n", + "z_list = list() # list of points after projections\n", + "x = x0\n", + "for i in range(n):\n", + " y, _, _ = proximal_step(x, f1, 1)\n", + " z_list.append(y)\n", + " x, _, _ = proximal_step(y, f2, 1)\n", + " z_list.append(x)\n", + "\n", + "# Set the performance metric to the distance between x and xs\n", + "problem.set_performance_metric((y-x)**2)\n", + "problem.set_initial_condition((x0-xs)**2==1)\n", + "\n", + "\n", + "# Solve the PEP\n", + "pepit_tau = problem.solve(verbose=verbose)\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cbc3099-161f-4f0c-83bc-898d49460fff", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "[pepit_tau, 1/(2*n-1) * (1-1/2/n)**(2*n)]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "5f6f6900-ec29-468c-806f-b29d7ee97316", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "problem.trim_dimension(True) # Remove the useless dimensions\n", + "\n", + "# Evaluation at the optimal point:\n", + "xs_evaluated = xs.eval_ld() # x*\n", + "\n", + "# Evaluation of the trajectories (recentered around x* = 0)\n", + "z_list_evaluated = [z.eval_ld()-xs_evaluated for z in z_list] # centered iterates\n", + "\n", + "xs_evaluated = xs_evaluated - xs_evaluated # should be zero " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "d0e965de-eb37-4a19-8de3-8642d1d8bee2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert the list of 2D vectors into two arrays x1, x2\n", + "z_array = np.array(z_list_evaluated) # shape (N, 2)\n", + "z1 = z_array[:, 0]\n", + "z2 = z_array[:, 1]\n", + "\n", + "# Worst-case point (xs_evaluated is a 2D vector)\n", + "xs = np.array(xs_evaluated)\n", + "xs1, xs2 = xs[0], xs[1]\n", + "\n", + "# Blue line (theoretical bound)\n", + "plt.plot(z1, z2, '--', color='blue')\n", + "\n", + "# Red points (x_t's)\n", + "plt.scatter(z1[::2], z2[::2], marker='.', color='red', s=30, label='$x_t$')\n", + "\n", + "# Orange points (y_t's)\n", + "plt.scatter(z1[1::2], z2[1::2], marker='.', color='orange', s=30, label='$y_t$')\n", + "\n", + "# Green point (starting point)\n", + "plt.scatter(z1[0], z2[0], marker='s', color='green', s=100, label='$x_0$')\n", + "\n", + "# Gold star (optimal point)\n", + "plt.scatter(xs1, xs2, marker='*', color='gold', s=100, label='$x_\\star$')\n", + "\n", + "plt.xlabel('$z_1$')\n", + "plt.ylabel('$z_2$')\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c5f7cfcf-ac69-47c8-84c0-77bdd97bbca4", + "metadata": {}, + "source": [ + "... and we observe a nice alternate projection between two hyperplanes! (and tuning the angle between the hyperplanes suffices to obtain the worst-case estimate)" + ] + }, + { + "cell_type": "markdown", + "id": "eddba311-abbf-49eb-bb91-eee85880dc35", + "metadata": {}, + "source": [ + "## Example 4 : gradient descent for potentially non-convex minimization \n", + "\n", + "We consider the following convex minimization problem:\n", + "\\begin{equation}\n", + "f_\\star \\triangleq \\min_x f(x),\n", + "\\end{equation}\n", + "where $f$ is $L$-smooth (and potentially non-convex).\n", + "\n", + "For this example, we consider the problem of computing the smallest possible $\\tau(n, L, \\mu, \\gamma)$ such that the following guarantee holds (for all initialization of the algorithm, and all $L$-smooth function)\n", + "\\begin{equation}\n", + "\\min_{0\\leq t\\leq n} \\|\\nabla f(x_t)\\|^2 \\leqslant \\tau(n, L, \\gamma) (f(x_0)-f(x_\\star)),\n", + "\\end{equation}\n", + "where $x_t$ are the iterates gradient descent with step size $\\gamma$, started from $x_0$:\n", + "\\begin{equation}\n", + "x_{t+1} = x_t - \\gamma \\nabla f(x_t),\n", + "\\end{equation}\n", + "and where $x_\\star$ is a stationnary point such that $f(x_\\star)\\leq f(x_t)$ for all $t=0,1,\\ldots,n$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "a695f961-77ea-4911-a4aa-6bce1cb96f17", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(PEPit) Setting up the problem: size of the Gram matrix: 6x6\n", + "(PEPit) Setting up the problem: performance measure is the minimum of 4 element(s)\n", + "(PEPit) Setting up the problem: Adding initial conditions and general constraints ...\n", + "(PEPit) Setting up the problem: initial conditions and general constraints (1 constraint(s) added)\n", + "(PEPit) Setting up the problem: interpolation conditions for 1 function(s)\n", + "\t\t\tFunction 1 : Adding 20 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 20 scalar constraint(s) added\n", + "(PEPit) Setting up the problem: additional constraints for 1 function(s)\n", + "\t\t\tFunction 1 : Adding 4 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 4 scalar constraint(s) added\n", + "(PEPit) Compiling SDP\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.37409398278086586\n", + "(PEPit) Postprocessing: 3 eigenvalue(s) > 2.4421029256841564e-07 before dimension reduction\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.37409298285666776\n", + "(PEPit) Postprocessing: 1 eigenvalue(s) > 1.93387735488241e-09 after 1 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.3740929829138106\n", + "(PEPit) Postprocessing: 1 eigenvalue(s) > 0 after 2 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.3740929835418104\n", + "(PEPit) Postprocessing: 1 eigenvalue(s) > 0 after 3 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.3740929835418104\n", + "(PEPit) Postprocessing: 1 eigenvalue(s) > 0 after dimension reduction\n", + "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -2.41e-11 < 0).\n", + " Small deviation from 0 may simply be due to numerical error. Big ones should be deeply investigated.\n", + " In any case, from now the provided values of parameters are based on the projection of the Gram matrix onto the cone of symmetric semi-definite matrix.\u001b[0m\n", + "(PEPit) Primal feasibility check:\n", + "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 2.4086626117829453e-11\n", + "\t\tAll the primal scalar constraints are verified\n", + "(PEPit) Dual feasibility check:\n", + "\t\tThe solver found a residual matrix that is positive semi-definite\n", + "\t\tAll the dual scalar values associated with inequality constraints are nonnegative up to an error of 1.7054939349078082e-09\n", + "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 1.0227156045544847e-08\n", + "(PEPit) Final upper bound (dual): 0.374093983448596 and lower bound (primal example): 0.3740929835418104 \n", + "(PEPit) Duality gap: absolute: 9.999067855925858e-07 and relative: 2.672883025299595e-06\n" + ] + } + ], + "source": [ + "from PEPit import PEP\n", + "from PEPit.functions import SmoothFunction\n", + "\n", + "L = 1\n", + "n = 3\n", + "gamma = .95/L\n", + "verbose = 1\n", + "\n", + "\n", + "# Instantiate PEP\n", + "problem = PEP()\n", + "\n", + "# Declare a smooth strongly convex function\n", + "f = problem.declare_function(SmoothFunction, L=L)\n", + "\n", + "# Then define the starting point x0 of the algorithm as well as corresponding gradient and function value g0 and f0\n", + "x0 = problem.set_initial_point()\n", + "g0, f0 = f.oracle(x0)\n", + "\n", + "xs = f.stationary_point()\n", + "gs, fs = f.oracle(xs)\n", + "\n", + "# Run n steps of GD method with step-size gamma\n", + "x_list = list()\n", + "g_list = list()\n", + "f_list = list()\n", + "gx, fx = g0, f0\n", + "\n", + "x_list.append(x0)\n", + "f_list.append(f0)\n", + "g_list.append(g0)\n", + "\n", + "for i in range(n):\n", + " # Set the performance metric to the minimum of the gradient norm over the iterations\n", + " problem.set_performance_metric(gx**2)\n", + " f.add_constraint(fs <= fx - 1/2/L * gx**2)\n", + " x_list.append(x_list[-1] - gamma * gx)\n", + " gx, fx = f.oracle(x_list[-1])\n", + " f_list.append(fx)\n", + " g_list.append(gx)\n", + "problem.set_performance_metric(gx**2)\n", + "f.add_constraint(fs <= fx - 1/2/L * gx**2)\n", + "\n", + "# Set initial condition\n", + "problem.set_initial_condition( f0 - fs == 1)\n", + "\n", + "# Solve the PEP\n", + "pepit_verbose = max(verbose, 0)\n", + "pepit_tau = problem.solve(verbose=pepit_verbose, dimension_reduction_heuristic=\"logdet3\", tol_dimension_reduction=1e-6)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "8ca53bd9-8762-42c7-be2e-4f1a28f0c1f7", + "metadata": {}, + "source": [ + "In the evaluation, we center the coordinates so that $x_\\star=0$ and $f_\\star=0$ for simplicity." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "a6312d61-2981-4a53-b079-f7cf6517e0af", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "problem.trim_dimension(True) # Remove the useless dimensions\n", + "xs_evaluated = xs.eval_ld() # x*\n", + "fs_evaluated = fs.eval() # f(x*)\n", + "gs_evaluated = gs.eval_ld() # g(x*)\n", + "\n", + "x_list_evaluated = [x.eval_ld()-xs_evaluated for x in x_list] # centered iterates\n", + "f_list_evaluated = [f.eval()-fs_evaluated for f in f_list] # centered function values\n", + "g_list_evaluated = [g.eval_ld() for g in g_list] # centered function values\n", + "xs_evaluated = xs_evaluated - xs_evaluated # should be zero \n", + "fs_evaluated = fs_evaluated - fs_evaluated # should be zero" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "dd94d501-125c-4c2b-b667-14e342f22f0e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot theoretical and PEPit (numerical) worst-case performance bounds as functions of the iteration count\n", + "\n", + "plt.plot(x_list_evaluated, f_list_evaluated, '.--', color='blue')\n", + "plt.plot(x_list_evaluated, f_list_evaluated, marker='.', color='red', linestyle='none', markersize=8, label='$(x_t,f(x_t))$')\n", + "plt.plot(xs_evaluated, fs_evaluated, marker='*', color='gold', linestyle='none', markersize=8, label='$(x_\\star,f(x_\\star))$')\n", + "\n", + "\n", + "plt.legend()\n", + "plt.xlabel('x')\n", + "plt.ylabel('f(x)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "1d1e81b3-1ffc-416a-98d6-00b0a3ecfa32", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "x_list_evaluated.append(xs_evaluated)\n", + "f_list_evaluated.append(fs_evaluated)\n", + "g_list_evaluated.append(gs_evaluated)\n", + "\n", + "from PEPit.tools.interpolator import Interpolator\n", + "\n", + "triplets = (x_list_evaluated,g_list_evaluated,f_list_evaluated)\n", + "fx = Interpolator(triplets,-L,L,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "5320adfd-6ba7-4715-aa96-aa71bf6c1be1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50 done on 200\n", + "100 done on 200\n", + "150 done on 200\n", + "200 done on 200\n" + ] + } + ], + "source": [ + "x_test = np.linspace(np.min(x_list_evaluated),np.max(x_list_evaluated),200)\n", + "fx_test = x_test.copy()\n", + "for i in range(len(x_test)):\n", + " fx_test[i] = fx.evaluate(x_test[i])\n", + " if (i+1) % 50 == 0:\n", + " print('{} done on {}'.format(i+1,len(x_test)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "cd4452fe-715d-4938-9857-540e72fec551", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_test, fx_test, '--', color='blue')\n", + "plt.plot(x_list_evaluated, f_list_evaluated, marker='.', color='red', linestyle='none', markersize=8, label='$(x_t,f(x_t))$')\n", + "plt.plot(xs_evaluated, fs_evaluated, marker='*', color='gold', linestyle='none', markersize=8, label='$(x_\\star,f(x_\\star))$')\n", + "\n", + "\n", + "plt.legend()\n", + "plt.xlabel('x')\n", + "plt.ylabel('f(x)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ea304152-1174-4ccf-a953-b431bbadd757", + "metadata": { + "tags": [] + }, + "source": [ + "## Example 5 : primal-dual proximal point for convex minimization \n", + "\n", + "For this last example, we consider again the problem of minimizing a sum:\n", + "\\begin{equation}\n", + "\\min_{x\\in\\mathbb{R}^d} f(x)+h(x)\n", + "\\end{equation}\n", + "where both $f$ and $h$ are closed convex and proper, and we assume $\\exists x_\\star,y_\\star$ (KKT point): $-y_\\star\\in\\partial f(x_\\star),\\, x_\\star\\in\\partial h^*(y_\\star)$.\n", + " \n", + "We study PD proximal-point for solving such problems: \n", + "\\begin{align}\n", + "(y_{k+1},x_{k+1})=\\underset{y\\in\\mathbb{R}^d}{\\mathrm{argmax}}\\,\\,\\underset{x\\in\\mathbb{R}^d}{\\mathrm{argmin}} \\Bigl\\{f(x)-h^*(y)+\\langle y,\\, x\\rangle +\\tfrac1{2\\alpha} \\|x-x_k\\|^2-\\tfrac1{2\\alpha} \\|y-y_k\\|^2 \\Bigl\\}\n", + "\\end{align}\n", + "and we inspect guarantees of the form (for some elements of $\\partial f$ and $\\partial h^*$)\n", + "\\begin{equation}\n", + "\\frac{\\|g_N+y_N\\|^2 + \\|x_N-s_N\\|^2}{\\|x_0 - x_\\star\\|^2+\\|y_0-y_\\star\\|^2}\\leq \\tau(N,\\alpha)\n", + "\\end{equation}\n", + "with $g_N\\in\\partial f(x_N)$ and $s_N\\in\\partial h^*(y_N)$.\n", + "\n", + "For studying this algorithm, we start by the appropriate imports, followed by an implementation of the primal-dual proximal step in PEPit:" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "f509615f-9993-4406-b645-dc4ca6e24b03", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from PEPit import PEP\n", + "from PEPit.point import Point\n", + "from PEPit.expression import Expression\n", + "from PEPit.functions import ConvexFunction\n", + "import numpy as np\n", + "\n", + "def PD_proximal_step(x0,lambda0, f, g, alpha):\n", + " x1 = Point()\n", + " lambda1 = Point()\n", + " \n", + " # subgradients\n", + " pf_x1 = (x0-x1)/alpha-lambda1\n", + " pg_lambda1 = (lambda0-lambda1)/alpha+x1\n", + " \n", + " fx1 = Expression()\n", + " glambda1 = Expression()\n", + " \n", + " f.add_point((x1, pf_x1, fx1))\n", + " g.add_point((pg_lambda1, lambda1, glambda1))\n", + "\n", + " return x1, lambda1, pf_x1, pg_lambda1\n", + "\n", + "# helper function: evaluation of conjugate\n", + "def evaluate_conjugate(lam,f):\n", + " x = Point()\n", + " fx = Expression()\n", + " f.add_point((x, lam, fx))\n", + " fconj = lam*x - fx\n", + " return fconj" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "6b08f66d-a636-4e75-b613-95e180dbecbb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(PEPit) Setting up the problem: size of the Gram matrix: 44x44\n", + "(PEPit) Setting up the problem: performance measure is the minimum of 1 element(s)\n", + "(PEPit) Setting up the problem: Adding initial conditions and general constraints ...\n", + "(PEPit) Setting up the problem: initial conditions and general constraints (1 constraint(s) added)\n", + "(PEPit) Setting up the problem: interpolation conditions for 2 function(s)\n", + "\t\t\tFunction 1 : Adding 420 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 420 scalar constraint(s) added\n", + "\t\t\tFunction 2 : Adding 420 scalar constraint(s) ...\n", + "\t\t\tFunction 2 : 420 scalar constraint(s) added\n", + "(PEPit) Setting up the problem: additional constraints for 0 function(s)\n", + "(PEPit) Compiling SDP\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.018867672518097733\n", + "(PEPit) Postprocessing: 6 eigenvalue(s) > 9.258683788194795e-08 before dimension reduction\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.01876767179093053\n", + "(PEPit) Postprocessing: 4 eigenvalue(s) > 6.520392661202409e-10 after 1 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.01876767209985053\n", + "(PEPit) Postprocessing: 2 eigenvalue(s) > 3.132699666995685e-08 after 2 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.01876767209985053\n", + "(PEPit) Postprocessing: 2 eigenvalue(s) > 3.132699666995685e-08 after dimension reduction\n", + "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -5.57e-10 < 0).\n", + " Small deviation from 0 may simply be due to numerical error. Big ones should be deeply investigated.\n", + " In any case, from now the provided values of parameters are based on the projection of the Gram matrix onto the cone of symmetric semi-definite matrix.\u001b[0m\n", + "(PEPit) Primal feasibility check:\n", + "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 5.574719418694589e-10\n", + "\t\tAll the primal scalar constraints are verified up to an error of 1.1580023606683199e-09\n", + "(PEPit) Dual feasibility check:\n", + "\t\tThe solver found a residual matrix that is positive semi-definite\n", + "\t\tAll the dual scalar values associated with inequality constraints are nonnegative\n", + "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 3.191019723965561e-08\n", + "(PEPit) Final upper bound (dual): 0.01886767311507418 and lower bound (primal example): 0.01876767209985053 \n", + "(PEPit) Duality gap: absolute: 0.00010000101522365107 and relative: 0.005328365430278777\n" + ] + } + ], + "source": [ + "n = 20 # number of iterations\n", + "alpha = n * [1] # step sizes\n", + "verbose = 1 # verbose mode\n", + "\n", + "\n", + "# PEP:\n", + "problem = PEP()\n", + "\n", + "# Problem setup\n", + "f = problem.declare_function(ConvexFunction, reuse_gradient=True)\n", + "g = problem.declare_function(ConvexFunction, reuse_gradient=True)\n", + "F = f+g\n", + "\n", + "# Optimal primal and dual solutions\n", + "xs = F.stationary_point()\n", + "ys = -f.gradient(xs)\n", + "\n", + "# Starting point of the algorithm\n", + "x0 = problem.set_initial_point()\n", + "y0 = problem.set_initial_point()\n", + "\n", + "\n", + "# Compute n steps of the proximal method starting from x0\n", + "x_list = list()\n", + "y_list = list()\n", + "x_list.append(x0)\n", + "y_list.append(y0)\n", + "\n", + "x = x0\n", + "y = y0\n", + "for i in range(n):\n", + " x, y, df_xk, dg_lambdak = PD_proximal_step(x, y, f, g, alpha[i])\n", + " x_list.append(x)\n", + " y_list.append(y)\n", + "\n", + "# Set initial condition (distance to a solution)\n", + "problem.set_initial_condition((x0 - xs) ** 2 + (y0 - ys) ** 2 <= 1)\n", + "\n", + "# Set performance metric: KKT residual\n", + "problem.set_performance_metric((df_xk+y) ** 2 + (x - dg_lambdak) ** 2)\n", + "\n", + "# Solve the PEP\n", + "pepit_tau = problem.solve(verbose=verbose, dimension_reduction_heuristic=\"logdet2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "8cb5d1cf-1817-4354-9f8f-71cc883c4b94", + "metadata": {}, + "outputs": [], + "source": [ + "problem.trim_dimension(True) # Remove the useless dimensions\n", + "xs_evaluated = xs.eval_ld() # x*\n", + "ys_evaluated = ys.eval_ld() # y*\n", + "\n", + "x_list_evaluated = [x.eval_ld()-xs_evaluated for x in x_list] # centered iterates\n", + "xs_evaluated = xs_evaluated - xs_evaluated # should be zero \n", + "y_list_evaluated = [y.eval_ld()-ys_evaluated for y in y_list] # centered iterates\n", + "ys_evaluated = ys_evaluated - ys_evaluated # should be zero \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "1e1f544f-d024-4652-83dc-630c086d27e0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d4e7d4c088c4ff6bdc36336946c58c2", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib widget\n", + "plt.ion() # <-- this enables rotation\n", + "\n", + "\n", + "import numpy as np\n", + "\n", + "# Convert the list of 2D vectors into two arrays x1, x2\n", + "x_array = np.array(x_list_evaluated) \n", + "x1 = x_array[:, 0]\n", + "x2 = x_array[:, 1]\n", + "# Convert the list of 2D vectors into two arrays y1, y2\n", + "y_array = np.array(y_list_evaluated)\n", + "y1 = y_array[:, 0]\n", + "y2 = y_array[:, 1]\n", + "\n", + "# Worst-case point (xs_evaluated is a 2D vector)\n", + "xs = np.array(xs_evaluated)\n", + "xs1, xs2 = xs[0], xs[1]\n", + "# Worst-case point (ys_evaluated is a 2D vector)\n", + "ys = np.array(ys_evaluated)\n", + "ys1, ys2 = ys[0], ys[1]\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "# Blue line (trajectory)\n", + "ax.plot(x1, y1, y2, '--', color='blue')\n", + "ax.scatter(x1, y1, y2, marker='.', color='red',\n", + " s=30, label='$(x_t,y_t^{(1)},y_t^{(2)})$')\n", + "\n", + "# Gold star (optimal point)\n", + "ax.scatter(xs1, ys1, ys2, marker='*', color='gold',\n", + " s=100, label='$(x_\\star,y_\\star^{(1)},y_\\star^{(2)})$')\n", + "\n", + "# Green point (starting point)\n", + "ax.scatter(x1[0], y1[0], y2[0], marker='s', color='green',\n", + " s=100, label='$(x_0,y_0^{(1)},y_0^{(2)})$')\n", + "\n", + "ax.set_xlabel('$x^{(1)}$')\n", + "ax.set_ylabel('$y^{(1)}$')\n", + "ax.set_zlabel('$y^{(2)}$')\n", + "\n", + "ax.legend()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2e56502-1df1-4657-8894-58bf02fe6bc1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": { + "height": "341px", + "width": "386px" + }, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": { + "height": "379px", + "left": "1067.99px", + "top": "518px", + "width": "574px" + }, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 684e1b7559f02386232d44fef98c1effed91d531 Mon Sep 17 00:00:00 2001 From: AdrienTaylor <10559960+AdrienTaylor@users.noreply.github.com> Date: Tue, 2 Dec 2025 00:53:28 +0100 Subject: [PATCH 4/5] notebook update --- ...PEPit_demo_visual_worstcase_function.ipynb | 105 ++++++++---------- 1 file changed, 46 insertions(+), 59 deletions(-) diff --git a/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb b/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb index 75b740a2..41156905 100644 --- a/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb +++ b/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb @@ -430,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "4061ac10-38dc-422e-ac99-500929d3d08f", "metadata": { "tags": [] @@ -559,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "9102b19b-4b59-40a2-8a27-700cb469e930", "metadata": { "tags": [] @@ -600,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "12e4a91e-55b4-4a44-b4f1-ad4281bcfdca", "metadata": { "tags": [] @@ -669,7 +669,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "id": "a5df55df-41f8-4d65-add2-8c265df2bf2f", "metadata": { "tags": [] @@ -708,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "id": "95b82bc9-97c4-4e5b-9b60-ca0be861f147", "metadata": { "tags": [] @@ -743,7 +743,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "id": "77d9783a-ecb1-4eb8-a015-57927ec221aa", "metadata": { "tags": [] @@ -751,7 +751,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -839,7 +839,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "id": "9676680d-7c0d-4317-9f44-dab19835122c", "metadata": {}, "outputs": [], @@ -859,7 +859,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 16, "id": "60bb3c0b-246a-4568-8586-17ce84fb6301", "metadata": {}, "outputs": [ @@ -867,38 +867,46 @@ "name": "stdout", "output_type": "stream", "text": [ - "(PEPit) Setting up the problem: size of the Gram matrix: 7x7\n", + "(PEPit) Setting up the problem: size of the Gram matrix: 13x13\n", "(PEPit) Setting up the problem: performance measure is the minimum of 1 element(s)\n", "(PEPit) Setting up the problem: Adding initial conditions and general constraints ...\n", "(PEPit) Setting up the problem: initial conditions and general constraints (1 constraint(s) added)\n", "(PEPit) Setting up the problem: interpolation conditions for 2 function(s)\n", - "\t\t\tFunction 1 : Adding 9 scalar constraint(s) ...\n", - "\t\t\tFunction 1 : 9 scalar constraint(s) added\n", - "\t\t\tFunction 2 : Adding 9 scalar constraint(s) ...\n", - "\t\t\tFunction 2 : 9 scalar constraint(s) added\n", + "\t\t\tFunction 1 : Adding 36 scalar constraint(s) ...\n", + "\t\t\tFunction 1 : 36 scalar constraint(s) added\n", + "\t\t\tFunction 2 : Adding 36 scalar constraint(s) ...\n", + "\t\t\tFunction 2 : 36 scalar constraint(s) added\n", "(PEPit) Setting up the problem: additional constraints for 0 function(s)\n", "(PEPit) Compiling SDP\n", "(PEPit) Calling SDP solver\n", - "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.1481481525665704\n", - "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -3.1e-09 < 0).\n", + "(PEPit) Solver status: optimal (wrapper:cvxpy, solver: MOSEK); optimal value: 0.043304934753411475\n", + "(PEPit) Postprocessing: 4 eigenvalue(s) > 1.310465911575286e-07 before dimension reduction\n", + "(PEPit) Calling SDP solver\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.04320493512398807\n", + "(PEPit) Postprocessing: 2 eigenvalue(s) > 2.7659735915464028e-09 after 1 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.04320493494810006\n", + "(PEPit) Postprocessing: 2 eigenvalue(s) > 0 after 2 dimension reduction step(s)\n", + "(PEPit) Solver status: optimal (solver: MOSEK); objective value: 0.04320493494810006\n", + "(PEPit) Postprocessing: 2 eigenvalue(s) > 0 after dimension reduction\n", + "\u001b[96m(PEPit) Postprocessing: solver's output is not entirely feasible (smallest eigenvalue of the Gram matrix is: -5.08e-11 < 0).\n", " Small deviation from 0 may simply be due to numerical error. Big ones should be deeply investigated.\n", " In any case, from now the provided values of parameters are based on the projection of the Gram matrix onto the cone of symmetric semi-definite matrix.\u001b[0m\n", "(PEPit) Primal feasibility check:\n", - "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 3.0955627696216428e-09\n", - "\t\tAll the primal scalar constraints are verified up to an error of 4.619276183781551e-09\n", + "\t\tThe solver found a Gram matrix that is positive semi-definite up to an error of 5.07861805602762e-11\n", + "\t\tAll the primal scalar constraints are verified up to an error of 4.896416605504328e-11\n", "(PEPit) Dual feasibility check:\n", "\t\tThe solver found a residual matrix that is positive semi-definite\n", "\t\tAll the dual scalar values associated with inequality constraints are nonnegative\n", - "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 2.701335510997387e-08\n", - "(PEPit) Final upper bound (dual): 0.14814815427049585 and lower bound (primal example): 0.1481481525665704 \n", - "(PEPit) Duality gap: absolute: 1.7039254451844954e-09 and relative: 1.1501496411970686e-08\n" + "(PEPit) The worst-case guarantee proof is perfectly reconstituted up to an error of 6.498339803964986e-08\n", + "(PEPit) Final upper bound (dual): 0.04330493817034633 and lower bound (primal example): 0.04320493494810006 \n", + "(PEPit) Duality gap: absolute: 0.00010000322224627128 and relative: 0.002314624992871768\n" ] } ], "source": [ "# Parameters / options for the study:\n", "verbose = 1 # verbose\n", - "n = 2 # number of iterations\n", + "n = 5 # number of iterations\n", "\n", "\n", "# Instantiate PEP\n", @@ -929,25 +937,12 @@ "\n", "\n", "# Solve the PEP\n", - "pepit_tau = problem.solve(verbose=verbose)\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9cbc3099-161f-4f0c-83bc-898d49460fff", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "[pepit_tau, 1/(2*n-1) * (1-1/2/n)**(2*n)]" + "pepit_tau = problem.solve(verbose=verbose, dimension_reduction_heuristic='logdet2')" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 17, "id": "5f6f6900-ec29-468c-806f-b29d7ee97316", "metadata": { "tags": [] @@ -967,7 +962,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 18, "id": "d0e965de-eb37-4a19-8de3-8642d1d8bee2", "metadata": { "tags": [] @@ -975,7 +970,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1051,7 +1046,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 19, "id": "a695f961-77ea-4911-a4aa-6bce1cb96f17", "metadata": { "tags": [] @@ -1162,7 +1157,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 20, "id": "a6312d61-2981-4a53-b079-f7cf6517e0af", "metadata": { "tags": [] @@ -1183,7 +1178,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 21, "id": "dd94d501-125c-4c2b-b667-14e342f22f0e", "metadata": { "tags": [] @@ -1217,7 +1212,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 22, "id": "1d1e81b3-1ffc-416a-98d6-00b0a3ecfa32", "metadata": { "tags": [] @@ -1236,7 +1231,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 23, "id": "5320adfd-6ba7-4715-aa96-aa71bf6c1be1", "metadata": { "tags": [] @@ -1264,7 +1259,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 24, "id": "cd4452fe-715d-4938-9857-540e72fec551", "metadata": { "tags": [] @@ -1272,7 +1267,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1324,7 +1319,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 25, "id": "f509615f-9993-4406-b645-dc4ca6e24b03", "metadata": { "tags": [] @@ -1364,7 +1359,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 26, "id": "6b08f66d-a636-4e75-b613-95e180dbecbb", "metadata": {}, "outputs": [ @@ -1456,7 +1451,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 27, "id": "8cb5d1cf-1817-4354-9f8f-71cc883c4b94", "metadata": {}, "outputs": [], @@ -1474,14 +1469,14 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 28, "id": "1e1f544f-d024-4652-83dc-630c086d27e0", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5d4e7d4c088c4ff6bdc36336946c58c2", + "model_id": "cff82afbf93044fd8f6d90540e934c5a", "version_major": 2, "version_minor": 0 }, @@ -1553,14 +1548,6 @@ "\n", "plt.show()\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d2e56502-1df1-4657-8894-58bf02fe6bc1", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 0546b526197c6ea43d7197f4a02e4a02b4349cab Mon Sep 17 00:00:00 2001 From: AdrienTaylor <10559960+AdrienTaylor@users.noreply.github.com> Date: Tue, 2 Dec 2025 11:25:16 +0100 Subject: [PATCH 5/5] demo file --- ...PEPit_demo_visual_worstcase_function.ipynb | 70 ++++++++++++++----- 1 file changed, 53 insertions(+), 17 deletions(-) diff --git a/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb b/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb index 41156905..d88202f2 100644 --- a/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb +++ b/ressources/demo/PEPit_demo_visual_worstcase_function.ipynb @@ -239,7 +239,7 @@ "id": "5b2cea08-90b2-4988-97b9-028a1740d665", "metadata": {}, "source": [ - "Now, using the list of iterate, we can simply plot the trajectory as follows: " + "Now, using the list of iterate, we can simply plot the trajectory (in terms of $(x,f(x))$ as follows: " ] }, { @@ -279,7 +279,7 @@ "id": "69e8d142-5604-4512-9223-468d857a53c5", "metadata": {}, "source": [ - "The last plot is giving a partial picture of what a worst-case function might look like. For this reason, we provide a few tools that allows extrapolating within certain classes of functions. " + "The last plot is giving a partial picture of what a worst-case function might look like. For this reason, we provide a few tools that allows extrapolating within certain classes of functions. This is done via the \"Interpolator\" class (that internally formulates the interpolation problem as a convex quadratic program)." ] }, { @@ -300,7 +300,15 @@ "\n", "# Create an interpolator for the class of L-smooth convex functions\n", "triplets = (x_list_evaluated,g_list_evaluated,f_list_evaluated)\n", - "fx = Interpolator(triplets,0,L,1,'highest')" + "fx = Interpolator(triplets,0,L,1)" + ] + }, + { + "cell_type": "markdown", + "id": "7c43bf11-71b8-44b8-b88a-fe6bfcf47a98", + "metadata": {}, + "source": [ + "Now, we can evaluate an interpolating function on a grid of points around the iterates and the solution." ] }, { @@ -331,6 +339,14 @@ " print('{} done on {}'.format((i+1),len(x_test)))" ] }, + { + "cell_type": "markdown", + "id": "e6721674-76fc-4a06-ac93-d879e1ce9c3d", + "metadata": {}, + "source": [ + "... and plot it!" + ] + }, { "cell_type": "code", "execution_count": 7, @@ -388,7 +404,7 @@ "\n", "For this example, we consider the problem of computing the smallest possible $\\tau(n, L)$ such that the following guarantee holds (for all initialization of the algorithm, and all $L$-smooth convex function)\n", "\\begin{equation}\n", - "F(x_n)-F_\\star \\leqslant \\tau(n, L, \\gamma) \\| x_0 - x_\\star \\|^2,\n", + "F(x_n)-F_\\star \\leqslant \\tau(n, L) \\| x_0 - x_\\star \\|^2,\n", "\\end{equation}\n", "where $x_n$ is the output of the FISTA initiated at $x_0$, and where $x_\\star$ is a solution.\n", "\n", @@ -401,7 +417,7 @@ " y_{t+1} & = & x_t + \\frac{\\lambda_t-1}{\\lambda_{t+1}} (x_t-x_{t-1}).\n", "\\end{eqnarray}\n", "\n", - "Let us first start by importing all necessary packages for the implementation in PEPit" + "Let us first start by importing all necessary packages for the implementation in PEPit (this is done [there](https://pepit.readthedocs.io/en/0.4.0/examples/b.html#accelerated-proximal-gradient-a-k-a-fista), which we use below)." ] }, { @@ -554,7 +570,10 @@ "id": "6e3cb1e3-c112-40f4-9ef8-d3f31d46652e", "metadata": {}, "source": [ - "Let us clean and evaluate the different lists, in order to plot the corresponding functions" + "\n", + "\n", + "Let us clean and evaluate the different lists, in order to plot the corresponding functions:\n", + "\n" ] }, { @@ -595,7 +614,7 @@ "id": "da497570-cbc7-4e87-b9f9-711f00e5e2d6", "metadata": {}, "source": [ - "Let us now plot the iterates (in 1D) on the two functions, side to side:" + "Let us now plot the iterates on the two functions (in terms of $(y,f(y))$ and $(x,f(x))$, side to side:" ] }, { @@ -664,7 +683,7 @@ "id": "3ae9e031-67fb-44d2-82b8-7f9cb0ca2c5b", "metadata": {}, "source": [ - "This is already quite informative, but arguably not enough. Can we easily recover a pair of functions interpolating through those points? Let interpolate an example of a worst-case function $F()$ by computing the two components individually, using again the `interpolator` tool." + "This is already quite informative, but arguably not enough. Can we easily recover a pair of functions interpolating through those points? Let interpolate an example of a worst-case function $F()$ by computing the two components individually, using again the `interpolator` tool, which we instantiate below." ] }, { @@ -703,7 +722,7 @@ "tags": [] }, "source": [ - "Query the interpolator at a set of point in the relevant interval" + "... and evaluate them on a range of points around the iterates." ] }, { @@ -741,6 +760,14 @@ " print('{} done on {}'.format((i+1),len(x_test)))" ] }, + { + "cell_type": "markdown", + "id": "64586656-a0f8-4df8-9b57-2d86cf8bac92", + "metadata": {}, + "source": [ + "The computed worst-case examples are thus as below:" + ] + }, { "cell_type": "code", "execution_count": 14, @@ -817,22 +844,23 @@ "source": [ "## Example 3 : alternate projections for finding a point in intersection of two convex sets \n", "\n", - "In this example, we investigate low-dimensional examples achieving a worst-case ratio for the criterion \n", + "In this example, we model the problem of finding a point in the intersection of two convex sets:\n", + "\\begin{equation}\n", + "\\text{Find } x\\in\\mathbb{R}^d: x\\in Q_1\\cap Q_2 \\quad \\Leftrightarrow \\quad \\min_{x\\in\\mathbb{R}^d} f_1(x)+f_2(x),\n", + "\\end{equation}\n", + "with $f_1,f_2$ respectively the indicator functions for $Q_1$ and $Q_2$, which are closed convex sets.\n", + "\n", + "More precisely, we investigate low-dimensional examples achieving a worst-case ratio for the criterion:\n", "\\begin{equation}\n", "\\frac{\\|\\mathrm{Proj}_{Q_1}(x_t)-\\mathrm{Proj}_{Q_2}(x_t)\\|^2}{\\|x_0-x_\\star\\|^2}\n", "\\end{equation}\n", "\n", - "where $Q_1$ and $Q_2$ are two closed convex sets, and where $x_t$ ($t\\in\\{0,\\ldots,n\\}$) are generated by the alternate projection method\n", + "where $x_t$ ($t\\in\\{0,\\ldots,n\\}$) are generated by the alternate projection method\n", "\n", "\\begin{equation}\n", "x_{t+1} = \\mathrm{Proj}_{Q_2}\\left(\\mathrm{Proj}_{Q_1}\\left(x_t\\right)\\right).\n", "\\end{equation}\n", "\n", - "Below, we model the problem as: \n", - "\\begin{equation}\n", - "\\text{Find } x\\in\\mathbb{R}^d: x\\in Q_1\\cap Q_2 \\quad \\Leftrightarrow \\quad \\min_{x\\in\\mathbb{R}^d} f_1(x)+f_2(x),\n", - "\\end{equation}\n", - "with $f_1,f_2$ respectively the indicator functions for $Q_1$ and $Q_2$.\n", "\n", "We start with a few imports." ] @@ -1476,7 +1504,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cff82afbf93044fd8f6d90540e934c5a", + "model_id": "c641cf9378074f98949652a43d6bf512", "version_major": 2, "version_minor": 0 }, @@ -1548,6 +1576,14 @@ "\n", "plt.show()\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6eda4fc7-f4fe-425e-a0c3-a911090a2429", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {