{'fraction_non_alphanumeric': 0.040536122915985615, 'fraction_numerical': 0.012291598561621445, 'mean_word_length': 4.412597310686483, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Faster Rates for the Frank-Wolfe Algorithm Using Jacobi Polynomials

The Frank Wolfe algorithm (FW) is a popular projection-free alternative for solving large-scale constrained optimization problems. However, the FW algorithm suffers from a sublinear convergence rate when minimizing a smooth convex function over a compact convex set. Thus, exploring techniques that yield a faster convergence rate becomes crucial. A classic approach to obtain faster rates is to combine previous iterates to obtain the next iterate. In this work, we extend this approach to the FW setting and show that the optimal way to combine the past iterates is using a set of orthogonal Jacobi polynomials. We also a polynomial-based acceleration technique, referred to as Jacobi polynomial accelerated FW, which combines the current iterate with the past iterate using combing weights related to the Jacobi recursion. By carefully choosing parameters of the Jacobi polynomials, we obtain a faster sublinear convergence rate. We provide numerical experiments on real datasets to demonstrate the efficacy of the proposed algorithm.


INTRODUCTION
Consider constrained optimization problems of the form where f : dom(f ) → R is a smooth convex function and the constraint set C ⊆ dom(f ) is compact and compact. Projected gradient descent [1] is a popular technique to solve constrained optimization problems, wherein gradient descent iterates are projected onto the constraint set. The constraint set in many large-scale problems that are commonly encountered in machine learning and signal processing, such as lasso, matrix completion, regularized logistic or robust regression, has a nice structure, but the projection operation onto the constraint set can be computationally expensive. The Frank-Wolfe (FW) algorithm (also popularly known as the conditional gradient method) [2] is a projection-free alternative to the projected gradient descent algorithm for solving constrained optimization problems. The FW algorithm avoids the projection step and instead has a direction-finding step that minimizes a local linear approximation of the objective function over the constraint set. The update is then computed by taking a convex combination of the previous iterate with the solution from the linear minimization step. The linear minimization step in FW is often easy to compute for pnorm ball or polytope constraint sets that frequently appear in machine learning and signal processing problems, thereby making FW an attractive choice. This work is supported in part by the CISCO CNI and Pratiskha Trust Fellowships.
In [3], convergences results are provided for the FW algorithm. The FW algorithm has iteration complexity bounds that are independent of the problem size but limited by a sublinear convergence rate of O(1/k). With a carefully selected step size, for minimizing a strongly convex function over a strongly convex constraint set, the FW algorithm can achieve convergence rates of O(1/k 2 ) and linear convergence rate when the solution lies in the interior of the convex constraint set [4]. The FW algorithm can even achieve linear rates under weaker conditions than strongly convex functions over polytopes by removing carefully chosen directions (referred to as away steps) that hinder the convergence rate [5]. By finding an optimal step size at each iteration, faster convergence of the FW algorithm may be obtained [4,6].
For unconstrained optimization problems, Nesterov's acceleration technique [7] and Polyak's heavy-ball momentum technqiue [8] provide faster rates of O(1/k 2 ). Central to Polyak's heavy-ball method [8] is the so-called multistep method, which keeps track of all the previous iterates and computes successive updates by taking a weighted combination of the past iterates. Doing so yields a smoother trajectory and helps attain faster convergence rates. In a similar vein, several variants of the multistep method have been proposed for FW. In [9], a momentum-guided accelerated FW (AFW) algorithm that can achieve a convergence rate of O(1/k 2 ) for smooth convex minimization problems over p-norm balls, but an order of O(1/k) in the general setting has been proposed. The FW iterates zig-zag as we approach the optimal solution and might affect the convergence rate. In [6], the zig-zag trajectory is alleviated by using the concept of parallel tangents for FW, wherein a significant improvement in convergence has been reported but without any theoretical guarantees. In [10], the zig-zag phenomenon is controlled by keeping track of the past gradients and taking its weighted average with different heuristic choices for the weights. When using multistep-based methods, finding the optimal updates and combining weights that can achieve faster convergence without much computational overhead is important.
The main aim of this work is, therefore, to determine an optimal technique independent of the problem size, to combine the previous iterates as in the multistep method, and obtain faster convergence rates. To this end, we draw inspiration from polynomial-based iteration methods for unconstrained problems [11] and extend that to the FW setting. The main contributions of the paper are as follows.
• We express the linear combination of the past FW iterates as a polynomial and show that the optimal polynomial that yields the maximum error reduction is given by a set of orthogonal Jacobi polynomials. • We then modify the FW algorithm to incorporate a Jacobi recursion, wherein the weights from the recurrence relation of the Jacobi polynomials are used to combine the past iterate with the current iterate. • We show that for carefully selected parameters of the Jacobi polynomials, we obtain a faster convergence rate of O(1/k 2 ) when minimizing a smooth convex function over a compact convex constraint set.
Through numerical experiments on real datasets, we demonstrate the efficacy of the proposed algorithm.

PRELIMINARIES
We use boldface lowercase (uppercase) letters to represent vectors (respectively, matrices). We use x, y to denote the inner product between vectors x and y. We denote an arbitrary norm using · , 2-norm using ||·||2, and nuclear norm using · . We say that a function f :

The FW method
The FW algorithm [2] finds an update direction based on the local linear approximation of f around the current iterate x k by solving the linear minimization problem: Then the update is computed by forming a convex combination of s k and x k as This ensures x k+1 ∈ C. Typically, a diminishing step size γ k is used [3], but line search techniques to compute the optimal step size may also be used [2]. The FW method is summarized as Algorithm 1.
The FW algorithm with a diminishing step size of γ k = 2 k+2 yields a sublinear convergence of O(1/k) for minimizing L-smooth convex functions over a compact convex constraint set. Specifically, the suboptimality gap at the kth iterate of FW satisfies [3] f where D = sup x,y∈C x − y 2 is the diameter of the constraint set and x is a minimizer of f .

THE OPTIMAL POLYNOMIAL
A classic technique to accelerate iterative methods is the so-called multistep method, which uses past iterates to construct the successive iterate [8]. In this section, we apply this technique to FW and find an optimal procedure to use the past iterates.
Suppose we take a linear combination of all the past iterates from Step 4 of Algorithm 1 with a fixed step size γ, we get where we constrain the combining coefficients such that k i=0 θi = 1 with θi ∈ [0, 1] for i = 0, 1, . . . , k. This constraint ensures that the weighted average is a feasible point, i.e., z k+1 ∈ C.
Now an important question to ask is, can we find optimal coefficients that can possibly accelerate the FW algorithm? To answer this question, we express (5) as a polynomial and then select the best polynomial that speeds up the convergence rate. To do so, let us first unroll (5) and express it in terms of x0 as Let us define the polynomial p k (1 − γ) of degree k as with p0(1 − γ) = 1. Then we can express z k+1 as and thus z k+1 ∈ conv{x0, s0, · · · , s k−1 }. The best polynomial is the one that minimizes the distance of the k + 1st iterate to x , i.e., for each k, and is bounded from above as due to the triangle inequality. Thus minimizing this upper bound would provide updates that are as close as possible to the optimal path. Next, we find the best polynomial that minimizes the above bound in the following theorem.

Theorem 1. A kth degree orthogonal Jacobi polynomial is a minimizer of the upper bound in (6).
Proof. Recall that the Jacobi polynomials are orthogonal in the interval [−1, 1]. With the change of variable γ = x+1 2 the Jacobi polynomials are orthogonal in the interval [0, 1] w.r.t. the weight w(γ) = (2 − 2γ) α (2γ) β dγ. The polynomial p k that minimizes its norm w.r.t a weight function w(γ), i.e., are given by the set of orthogonal polynomials [12]. Since a kth degree Jacobi polynomial can be expressed as a linear combination of lower degree Jacobi polynomials [13], we further have p k (1 − γ) = k−1 i=0 cipi(1 − γ) for some combining weights {ci}. Thus, for Jacobi polynomials, we have Therefore, selecting a kth degree Jacobi polynomial ensures that the norm of the lower degree polynomials are also minimized. Thereby minimizing the upper bound in (7) and the error z k+1 − x at the k + 1st iteration. 2 The above theorem suggests that combining all the past iterates using orthogonal Jacobi polynomials yields the best successive update. Based on this insight, we modify the vanilla Frank-Wolfe method in the next section.

JACOBI ACCELERATION FOR FRANK-WOLFE
In this section, we present the proposed Jacobi accelerated Frank-Wolfe method (JFW), which is a polynomial-based technique for using the past iterates. For a convex and L-smooth function f , we show that to reach error of at most ε, for carefully chosen Jacobi polynomial parameters (α, β), JFW only needs O(1/ √ ε) instead of O(1/ε) as needed by FW.

The JFW algorithm
We have seen in Section 2.2 that orthogonal Jacobi polynomials follow a second-order recursion in (3) with three sequences of coefficients {a k , b k , c k } computed as in (4). This means that, we do not have to store all the past iterates to compute (5), but only store the previous iterate. Specifically, the proposed JFW algorithm computes an intermediate update where s k is the FW direction computed as in Step 3 of Algorithm 1 with γ k = 2/(k+2). Then we combine the intermediate update with the past iterate using the second-order Jacobi recursion [cf. (3)]: with γ ∈ [0, 1]. Since a k (1 − γ) + b k − c k = 1 − γa k for the Jacobi polynomials, z k+1 / ∈ C. Therefore, we make a final correction step so that x k+1 ∈ C is a feasible point. The proposed JFW is summarized as Algorithm 2.

Convergence analysis
To demonstrate the convergence of the Jacobi FW, we consider a Lsmooth convex function over a compact convex constraint set. The next theorem states the improvement in convergence of the proposed algorithm.
Theorem 2. Let f : dom(f ) → R be a L-smooth and convex function, C ⊆ dom(f ) be compact and convex, and x be a minimizer of f over C. For appropriately chosen parameters (α, β, γ) with α ≥ β > −1, JFW in Algorithm 2 satisfies where D = sup x,y∈C x − y 2 is the diameter of the constraint set.
The complete proof is available online 1 and is omitted due to space constraints. Here, we give a brief sketch of the proof, which is based on mathematical induction. For the base case k = 0, the bound directly follows from definitions of the diameter of the set and L-smoothness of the objective function. Then by the induction hypothesis, we assume that the bound holds for k iterations and show that the bound is also valid for approximately chosen tuning parameters (α, β) at the k +1st iterate. To do so, we show that JFW satisfies the descent property with ω k = a k (1 − γ) + b k ∈ [0, 1] and L ≥ 0. Theorem 2 affirms that we can achieve a faster sublinear convergence rate of O(1/k 2 ) using a Jacobi polynomial-based acceleration technique as compared to the O(1/k) rate of FW. However, in order to achieve this faster rate, careful tuning of the parameters of the Jacobi polynomials, (α, β, γ), is needed. Further, the bound on iteration complexity of JFW matches the bounds proposed in [9], but for more general convex and compact constraint sets.

NUMERICAL EXPERIMENTS
We validate the JFW algorithm on real datasets for three tasks, namely, logistic and robust regression with an 2-norm constraint and robust matrix completion. We compare JFW with the vanilla FW in Algorithm 1 and the momentum-guided AFW [9] algorithms 2 .

Logistic regression
Consider the logistic regression problem with an 2-norm constraint for binary classification: where ai ∈ R d is the feature vector and bi is the binary class label. We apply FW, AFW and JFW on a breast cancer [14] dataset with m = 698 and d = 9. We use α = β = 1.2, t = 50, and γ = 2/3. The suboptimality gap is shown in Fig. 1(a), where to compute the suboptimality gap we obtain the optimal value using cvxpy [15]. We can see from Fig. 1(a) that JFW has a faster rate.

Robust regression
Next, we consider robust ridge regression using a smooth Huber loss function with an 2-norm constraint [16]: where ai ∈ R d and yi ∈ R. The Huber loss function is given by We apply robust ridge regression on Pima Indian diabetes [17] dataset with m = 767 and d = 8, and the optimal function value is computed using scikit-learn [18]. We use t = 35, δ = 0.5, α = β = 1450, and γ = 0.65. Fig. 1(b) shows the suboptimality gap, where we see that JFW has a faster convergence than FW and AFW as before.

Robust matrix completion
Finally, we consider the robust matrix completion problem to predict unobserved missing entries from observations corrupted with outliers. We use the Huber loss function as before along with a low-rank promoting nuclear norm constraint for the robust matrix completion task, i.e., we solve minimize X (i,j)∈Ω where A ∈ R m×n is the partially observed matrix with the entries Aij available for (i, j) ∈ Ω. The sampling mask Ω is know.
We apply robust matrix completion on the Movielens 100K [19] dataset with m = 1682 movies rated by n = 943 users with 6.30% percent ratings observed. Further, we introduce outliers by setting 4% of the total ratings (i.e., mn ratings) to its maximum value. We use 50% of the available ratings for training and the remaining observations for testing. We use R = 5, α = β = 4.5, γ = 2/3 and δ = 4. Fig. 1(c) shows normalized error, which is defined as with Ωtest being the index set of the observations in the test set. We again observe that JFW performs slightly better than FW.

CONCLUSIONS
The FW algorithm is a viable alternative for solving constrained optimization problems for which projection onto the constraint set is a computationally expensive operation. Motivated by polynomialbased acceleration techniques for unconstrained problems, we show that a set of orthogonal Jacobi polynomials with carefully chosen parameters can yield faster convergence rates. We have proposed Jacobi accelerated FW algorithm that provably has a faster sublinear convergence rate for minimizing a smooth convex function over a compact convex constraint set.