Update

Author: Shuvomoy

examples/composite_convex_minimization/three_operator_splitting.jl

@@ -1,60 +1,60 @@
-using PEPit, OrderedCollections
-
-
-function wc_three_operator_splitting(mu1, L1, L3, alpha, theta, n; verbose=true)
-
-    problem = PEP()
-
-    f1 = declare_function!(problem, SmoothStronglyConvexFunction, OrderedDict("mu" => mu1, "L" => L1); reuse_gradient=true)
-    f2 = declare_function!(problem, ConvexFunction, OrderedDict(); reuse_gradient=false)
-    f3 = declare_function!(problem, SmoothConvexFunction, OrderedDict("L" => L3); reuse_gradient=true)
-
-    w0 = set_initial_point!(problem)
-    w0p = set_initial_point!(problem)
-
-    set_initial_condition!(problem, (w0 - w0p)^2 <= 1)
-
-    w = w0
-    for _ in 1:n
-        x, _, _ = proximal_step!(w, f2, alpha)
-
-        gx, _ = oracle!(f3, x)
-
-        y, _, _ = proximal_step!(2 * x - w - alpha * gx, f1, alpha)
-
-        w = w + theta * (y - x)
-    end
-
-    wp = w0p
-    for _ in 1:n
-        xp, _, _ = proximal_step!(wp, f2, alpha)
-
-        gxp, _ = oracle!(f3, xp)
-
-        yp, _, _ = proximal_step!(2 * xp - wp - alpha * gxp, f1, alpha)
-
-        wp = wp + theta * (yp - xp)
-    end
-
-    set_performance_metric!(problem, (w - wp)^2)
-
-    pepit_tau = solve!(problem; verbose=verbose)
-
-    theoretical_tau = nothing
-
-    if verbose
-        println("*** Example file: worst-case performance of the Three Operator Splitting in distance ***")
-        println("\tPEPit guarantee:\t ||w^1_n - w^0_n||^2 <= $(round(pepit_tau, digits=6)) ||w^1_0 - w^0_0||^2")
-    end
-
-    return pepit_tau, theoretical_tau
-end
-
-
-L3 = 1.0
-
-alpha = 1 / L3
-
-pepit_tau, theoretical_tau = wc_three_operator_splitting(0.1, 10.0, L3, alpha, 1.0, 4; verbose=true)
-
-
+using PEPit, OrderedCollections
+
+
+function wc_three_operator_splitting(mu1, L1, L3, alpha, theta, n; verbose=true)
+
+    problem = PEP()
+
+    f1 = declare_function!(problem, SmoothStronglyConvexFunction, OrderedDict("mu" => mu1, "L" => L1); reuse_gradient=true)
+    f2 = declare_function!(problem, ConvexFunction, OrderedDict(); reuse_gradient=false)
+    f3 = declare_function!(problem, SmoothConvexFunction, OrderedDict("L" => L3); reuse_gradient=true)
+
+    w0 = set_initial_point!(problem)
+    w0p = set_initial_point!(problem)
+
+    set_initial_condition!(problem, (w0 - w0p)^2 <= 1)
+
+    w = w0
+    for _ in 1:n
+        x, _, _ = proximal_step!(w, f2, alpha)
+
+        gx, _ = oracle!(f3, x)
+
+        y, _, _ = proximal_step!(2 * x - w - alpha * gx, f1, alpha)
+
+        w = w + theta * (y - x)
+    end
+
+    wp = w0p
+    for _ in 1:n
+        xp, _, _ = proximal_step!(wp, f2, alpha)
+
+        gxp, _ = oracle!(f3, xp)
+
+        yp, _, _ = proximal_step!(2 * xp - wp - alpha * gxp, f1, alpha)
+
+        wp = wp + theta * (yp - xp)
+    end
+
+    set_performance_metric!(problem, (w - wp)^2)
+
+    pepit_tau = solve!(problem; verbose=verbose)
+
+    theoretical_tau = nothing
+
+    if verbose
+        println("*** Example file: worst-case performance of the Three Operator Splitting in distance ***")
+        println("\tPEPit guarantee:\t ||w^1_n - w^0_n||^2 <= $(round(pepit_tau, digits=6)) ||w^1_0 - w^0_0||^2")
+    end
+
+    return pepit_tau, theoretical_tau
+end
+
+
+L3 = 1.0
+
+alpha = 1 / L3
+
+pepit_tau, theoretical_tau = wc_three_operator_splitting(0.1, 10.0, L3, alpha, 1.0, 4; verbose=true)
+
+

examples/inexact_proximal_methods/accelerated_inexact_forward_backward.jl

@@ -1,65 +1,65 @@
-using PEPit, OrderedCollections
-
-function wc_accelerated_inexact_forward_backward(L, zeta, n; verbose=true)
-
-    problem = PEP()
-
-    f = declare_function!(problem, SmoothConvexFunction, OrderedDict("L" => L); reuse_gradient=true)
-    h = declare_function!(problem, ConvexFunction, OrderedDict(); reuse_gradient=false)
-
-    F = f + h
-
-    xs = stationary_point!(F)
-
-    Fs = value!(F, xs)
-
-    x0 = set_initial_point!(problem)
-
-    set_initial_condition!(problem, (x0 - xs)^2 <= 1)
-
-    gamma = 1 / L
-
-    eta = (1 - zeta^2) * gamma
-
-    A = 0.0
-
-    x = x0
-    z = x0
-
-    hx = nothing
-
-    for _ in 1:n
-        A_next = A + (eta + sqrt(eta^2 + 4 * eta * A)) / 2
-
-        y = x + (1 - A / A_next) * (z - x)
-
-        gy = gradient!(f, y)
-
-        x, _, hx, _, vx, _, eps_var = inexact_proximal_step!(y - gamma * gy, h, gamma; opt="PD_gapI")
-
-        add_constraint!(h, eps_var <= (zeta * gamma)^2 / 2 * (vx + gy)^2)
-
-        z = z - (A_next - A) * (vx + gy)
-
-        A = A_next
-    end
-
-    set_performance_metric!(problem, value!(f, x) + hx - Fs)
-
-    pepit_tau = solve!(problem; verbose=verbose)
-
-    theoretical_tau = 2 * L / (1 - zeta^2) / n^2
-
-    if verbose
-        println("*** Example file: worst-case performance of an inexact accelerated forward backward method ***")
-        println("\tPEPit guarantee:\t F(x_n)-F_* <= $(round(pepit_tau, digits=7)) ||x_0 - x_*||^2")
-        println("\tTheoretical guarantee:\t F(x_n)-F_* <= $(round(theoretical_tau, digits=7)) ||x_0 - x_*||^2")
-    end
-
-    return pepit_tau, theoretical_tau
-end
-
-
-pepit_tau, theoretical_tau = wc_accelerated_inexact_forward_backward(1.3, 0.45, 11; verbose=true)
-
-
+using PEPit, OrderedCollections
+
+function wc_accelerated_inexact_forward_backward(L, zeta, n; verbose=true)
+
+    problem = PEP()
+
+    f = declare_function!(problem, SmoothConvexFunction, OrderedDict("L" => L); reuse_gradient=true)
+    h = declare_function!(problem, ConvexFunction, OrderedDict(); reuse_gradient=false)
+
+    F = f + h
+
+    xs = stationary_point!(F)
+
+    Fs = value!(F, xs)
+
+    x0 = set_initial_point!(problem)
+
+    set_initial_condition!(problem, (x0 - xs)^2 <= 1)
+
+    gamma = 1 / L
+
+    eta = (1 - zeta^2) * gamma
+
+    A = 0.0
+
+    x = x0
+    z = x0
+
+    hx = nothing
+
+    for _ in 1:n
+        A_next = A + (eta + sqrt(eta^2 + 4 * eta * A)) / 2
+
+        y = x + (1 - A / A_next) * (z - x)
+
+        gy = gradient!(f, y)
+
+        x, _, hx, _, vx, _, eps_var = inexact_proximal_step!(y - gamma * gy, h, gamma; opt="PD_gapI")
+
+        add_constraint!(h, eps_var <= (zeta * gamma)^2 / 2 * (vx + gy)^2)
+
+        z = z - (A_next - A) * (vx + gy)
+
+        A = A_next
+    end
+
+    set_performance_metric!(problem, value!(f, x) + hx - Fs)
+
+    pepit_tau = solve!(problem; verbose=verbose)
+
+    theoretical_tau = 2 * L / (1 - zeta^2) / n^2
+
+    if verbose
+        println("*** Example file: worst-case performance of an inexact accelerated forward backward method ***")
+        println("\tPEPit guarantee:\t F(x_n)-F_* <= $(round(pepit_tau, digits=7)) ||x_0 - x_*||^2")
+        println("\tTheoretical guarantee:\t F(x_n)-F_* <= $(round(theoretical_tau, digits=7)) ||x_0 - x_*||^2")
+    end
+
+    return pepit_tau, theoretical_tau
+end
+
+
+pepit_tau, theoretical_tau = wc_accelerated_inexact_forward_backward(1.3, 0.45, 11; verbose=true)
+
+

examples/online_learning/online_gradient_descent.jl

@@ -1,50 +1,50 @@
-using PEPit, OrderedCollections
-
-function wc_online_gradient_descent(M::Real, D::Real, n::Int; verbose = true)
-
-    problem = PEP()
-
-    gamma = D / (M * sqrt(n))
-
-    fis = [declare_function!(problem, ConvexLipschitzFunction, OrderedDict("M" => M)) for _ in 1:n]
-
-    h = declare_function!(problem, ConvexIndicatorFunction, OrderedDict("D" => D))
-
-    F = sum(fis)
-
-    x_ref = set_initial_point!(problem)
-    x_ref, _, _ = proximal_step!(x_ref, h, 1)
-    _, F_ref = oracle!(F, x_ref)
-
-    x = set_initial_point!(problem)
-    x, _, _ = proximal_step!(x, h, 1)
-
-    f_saved = Vector{Expression}(undef, n)
-    for i in 1:n
-        g_i, f_i = oracle!(fis[i], x)
-        f_saved[i] = f_i
-        x, _, _ = proximal_step!(x - gamma * g_i, h, gamma)
-    end
-
-    set_performance_metric!(problem, sum(f_saved) - F_ref)
-
-    pepit_tau = solve!(problem; verbose=verbose)
-
-    theoretical_tau = M * D * sqrt(n)
-
-    if verbose != -1
-        println("*** Example file: worst-case regret of online gradient descent for fixed step-sizes ***")
-        println("\tPEPit guarantee:\t R_n <= $(round(pepit_tau, digits=6))")
-        println("\tTheoretical guarantee:\t R_n <= $(round(theoretical_tau, digits=6))")
-    end
-
-    return pepit_tau, theoretical_tau
-end
-
-
-
-M, D, n = 1.0, 0.5, 2
-
-pepit_tau, theoretical_tau = wc_online_gradient_descent(M, D, n; verbose=true)
-
-
+using PEPit, OrderedCollections
+
+function wc_online_gradient_descent(M::Real, D::Real, n::Int; verbose = true)
+
+    problem = PEP()
+
+    gamma = D / (M * sqrt(n))
+
+    fis = [declare_function!(problem, ConvexLipschitzFunction, OrderedDict("M" => M)) for _ in 1:n]
+
+    h = declare_function!(problem, ConvexIndicatorFunction, OrderedDict("D" => D))
+
+    F = sum(fis)
+
+    x_ref = set_initial_point!(problem)
+    x_ref, _, _ = proximal_step!(x_ref, h, 1)
+    _, F_ref = oracle!(F, x_ref)
+
+    x = set_initial_point!(problem)
+    x, _, _ = proximal_step!(x, h, 1)
+
+    f_saved = Vector{Expression}(undef, n)
+    for i in 1:n
+        g_i, f_i = oracle!(fis[i], x)
+        f_saved[i] = f_i
+        x, _, _ = proximal_step!(x - gamma * g_i, h, gamma)
+    end
+
+    set_performance_metric!(problem, sum(f_saved) - F_ref)
+
+    pepit_tau = solve!(problem; verbose=verbose)
+
+    theoretical_tau = M * D * sqrt(n)
+
+    if verbose != -1
+        println("*** Example file: worst-case regret of online gradient descent for fixed step-sizes ***")
+        println("\tPEPit guarantee:\t R_n <= $(round(pepit_tau, digits=6))")
+        println("\tTheoretical guarantee:\t R_n <= $(round(theoretical_tau, digits=6))")
+    end
+
+    return pepit_tau, theoretical_tau
+end
+
+
+
+M, D, n = 1.0, 0.5, 2
+
+pepit_tau, theoretical_tau = wc_online_gradient_descent(M, D, n; verbose=true)
+
+