Corrected Interpolation conditions

Author: mansirankawat

PEPit/examples/minmax_optimization/minmax_prox_blockcoordinate.py

@@ -2,7 +2,7 @@
 from PEPit.functions import BlockConvexConcaveFunction
 from PEPit.point import Point
 from PEPit.expression import Expression
-
+import numpy as np
 
 def wc_proximal_point(gamma, n, wrapper="cvxpy", solver=None, verbose=1):
     """
@@ -100,7 +100,6 @@ def wc_proximal_point(gamma, n, wrapper="cvxpy", solver=None, verbose=1):
     func = problem.declare_function(function_class=BlockConvexConcaveFunction, partition=block_partition)
     # Start by defining its unique optimal point xs = x_* and corresponding function value fs = f_*
     zs = func.stationary_point()
-    fs = func(zs)
 
     # Then define the starting point x0 of the algorithm
     z0 = problem.set_initial_point()
@@ -110,42 +109,42 @@ def wc_proximal_point(gamma, n, wrapper="cvxpy", solver=None, verbose=1):
 
     # Run n steps of the proximal point method
     z = z0
-    z_avg = z
-    count = 1
+    z_prev = z
+
     for _ in range(n):
 
 
          # Compute x from the docstring equation.
          gz = Point()
          fz = Expression()
+         z_prev = z
          z = z - gamma * block_partition.get_block(gz, 0)
          z = z + gamma * block_partition.get_block(gz, 1)
-         z_avg += z
-         count+=1
+
          # Add point to Function f.
          func.add_point((z, gz, fz))
 
-    z_avg /= count
-    #func.add_point((z_avg, func.gradient(z_avg), func(z_avg)))
+
     # Set the performance metric to the final distance to optimum in function values
-    problem.set_performance_metric(func(z_avg)-fs)
+    problem.set_performance_metric((z-z_prev)**2)
 
     # Solve the PEP
     pepit_verbose = max(verbose, 0)
     pepit_tau = problem.solve(wrapper=wrapper, solver=solver, verbose=pepit_verbose)
 
     # Compute theoretical guarantee (for comparison)
-    theoretical_tau = 1 / (gamma * n)
+    #theoretical_tau = 1 / (gamma * n)
+    theoretical_tau = np.power((1.0 - (1.0/n)), n-1)/n
 
     # Print conclusion if required
     if verbose != -1:
         print('*** Example file: worst-case performance of proximal point method ***')
-        print('\tPEPit guarantee:\t f(z_avg)-f_* <= {:.6} ||z_0 - z_*||^2'.format(pepit_tau))
-        print('\tTheoretical guarantee:\t f(z_avg)-f_* <= {:.6} ||z_0 - z_*||^2'.format(theoretical_tau))
+        print('\tPEPit guarantee:\t ||z_n - z_n-1||^2 <= {:.6} ||z_0 - z_*||^2'.format(pepit_tau))
+        print('\tTheoretical guarantee:\t||z_n - z_n-1||^2<= {:.6} ||z_0 - z_*||^2'.format(theoretical_tau))
 
     # Return the worst-case guarantee of the evaluated method (and the reference theoretical value)
     return pepit_tau, theoretical_tau
 
 
 if __name__ == "__main__":
-    pepit_tau, theoretical_tau = wc_proximal_point(gamma=0.2, n=10, wrapper="cvxpy", solver=None, verbose=1)
+    pepit_tau, theoretical_tau = wc_proximal_point(gamma=2, n=5, wrapper="cvxpy", solver=None, verbose=1)

PEPit/functions/block_convex_concave_function.py

@@ -80,45 +80,37 @@ def add_class_constraints(self):
             function_id = "Function_{}".format(self.counter)
 
         # Set tables_of_constraints attributes
-        self.tables_of_constraints["convexity_block_{}".format(0)] = [[]]*len(self.list_of_points)
-        self.tables_of_constraints["concavity_block_{}".format(1)] = [[]]*len(self.list_of_points)
+        self.tables_of_constraints["convexity_concavity_block_{}".format(0)] = [[]]*len(self.list_of_points)
 
         # Browse list of points and create interpolation constraints
         for i, point_i in enumerate(self.list_of_points):
 
-            xi, gi, fi = point_i
-            xi_id = xi.get_name()
-            if xi_id is None:
-                xi_id = "Point_{}".format(i)
+            zi, gi, fi = point_i
+            zi_id = zi.get_name()
+            if zi_id is None:
+                zi_id = "Point_{}".format(i)
 
             for j, point_j in enumerate(self.list_of_points):
 
-                xj, gj, fj = point_j
-                xj_id = xj.get_name()
-                if xj_id is None:
-                    xj_id = "Point_{}".format(j)
+                zj, gj, fj = point_j
+                zj_id = zj.get_name()
+                if zj_id is None:
+                    zj_id = "Point_{}".format(j)
 
                 if point_i == point_j:
-                    self.tables_of_constraints["convexity_block_{}".format(0)][i].append(0)
-                    self.tables_of_constraints["concavity_block_{}".format(1)][i].append(0)
+                    self.tables_of_constraints["convexity_concavity_block_{}".format(0)][i].append(0)
 
                 else:
-                    gj_cvx = self.partition.get_block(gj, 0)
-                    xi_cvx = self.partition.get_block(xi, 0)
-                    xj_cvx = self.partition.get_block(xj, 0)
-                    constraint = fi - fj >= gj_cvx * (xi_cvx - xj_cvx)
-                    constraint.set_name("IC_{}_convexity_block_{}({}, {})".format(function_id, 0,
-                                                                                  xi_id, xj_id))
-                    self.tables_of_constraints["convexity_block_{}".format(0)][i].append(constraint)
+                    gj_x = self.partition.get_block(gj, 0)
+                    xi = self.partition.get_block(zi, 0)
+                    xj = self.partition.get_block(zj, 0)
+
+                    gi_y = self.partition.get_block(gi, 1)
+                    yi = self.partition.get_block(zi, 1)
+                    yj = self.partition.get_block(zj, 1)
+                    constraint = fi >= fj + gj_x * (xi - xj) + gi_y * (yi - yj)
+                    constraint.set_name("IC_{}_convexity_concavity_block_{}({}, {})".format(function_id, 0,
+                                                                                  zi_id, zj_id))
+                    self.tables_of_constraints["convexity_concavity_block_{}".format(0)][i].append(constraint)
                     self.list_of_class_constraints.append(constraint)
-
-                    gj_ccv = self.partition.get_block(gj, 1)
-                    xi_ccv = self.partition.get_block(xi, 1)
-                    xj_ccv = self.partition.get_block(xj, 1)
-                    constraint = fi - fj <= gj_ccv * (xi_ccv - xj_ccv)
-                    constraint.set_name("IC_{}_concavity_block_{}({}, {})".format(function_id, 1,
-                                                                                  xi_id, xj_id))
-                    self.tables_of_constraints["concavity_block_{}".format(1)][i].append(constraint)
-                    self.list_of_class_constraints.append(constraint)
-