{'fraction_non_alphanumeric': 0.044934059859432995, 'fraction_numerical': 0.008410329305851694, 'mean_word_length': 4.131077795786061, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 4, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 14, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A core-set approach for distributed quadratic programming in big-data classification

A new challenge for learning algorithms in cyber-physical network systems is the distributed solution of big-data classification problems, i.e., problems in which both the number of training samples and their dimension is high. Motivated by several problem set-ups in Machine Learning, in this paper we consider a special class of quadratic optimization problems involving a"large"number of input data, whose dimension is"big". To solve these quadratic optimization problems over peer-to-peer networks, we propose an asynchronous, distributed algorithm that scales with both the number and the dimension of the input data (training samples in the classification problem). The proposed distributed optimization algorithm relies on the notion of"core-set"which is used in geometric optimization to approximate the value function associated to a given set of points with a smaller subset of points. By computing local core-sets on a smaller version of the global problem and exchanging them with neighbors, the nodes reach consensus on a set of active constraints representing an approximate solution for the global quadratic program.


I. INTRODUCTION
Several learning problems in modern cyber-physical network systems involve a large number of very-highdimensional input data. The related research areas go under the names of big-data analytics or big-data classification. From an optimization point of view, the problems arising in this area involve a large number of constraints and/or local cost functions typically distributed among computing nodes communicating asynchronously and unreliably. An additional challenge arising in big-data classification problems is that not only the number of constraints and local cost functions is large, but also the dimension of the decision variable is big and may depend on the number of nodes in the network.
We organize the literature in two parts. First, we point out some recent works focusing the attention on big-data optimization problems, i.e., problems in which all the data of the optimization problem are big and cannot be handled using standard approaches from sequential or even parallel optimization. The survey paper [1] reviews recent advances in convex optimization algorithms for big-data, which aim to reduce the computational, storage, and communications bottlenecks. The role of parallel and distributed computation Giuseppe  frameworks is highlighted. In [2] big-data, possibly nonconvex, optimization problems are approached by means of a decomposition framework based on successive approximations of the cost function. In [3] dictionary learning tasks motivate the development of non-convex and nonsmooth optimization algorithms in a big-data context. The paper develops an online learning framework by jointly leveraging the stochastic approximation paradigm with firstorder acceleration schemes.
Second, we review distributed optimization algorithms applied to learning problems and highlight their limitations when dealing with big-data problems. An early reference on peer-to-peer training of Support Vector Machines is [4]. A distributed training mechanism is proposed in which multiple servers compute the optimal solution by exchanging support vectors over a fixed directed graph. The work is a first successful attempt to solve SVM problems over networks. However, the local memory and computation at each node does not scale with the problem and data sizes and the graph is time-invariant. In [5] a distributed Alternating Direction Method of Multipliers (ADMM) is proposed to solve a linear SVM training problem, while in [6] the same problem is solved by means of a random projected gradient algorithm. Both the algorithms are proven to solve the centralized problem (i.e., all the nodes reach a consensus on the global solution), but again show some limitations: the graph topology must be (fixed, [5], and) undirected, and the algorithms do not scale with the dimension of the training vector space. In [7] a survey on ADMM algorithms applied to statistical learning problems is given. In [8] the problem of exchanging only those measurements that are most informative in a network SVM problem is investigated. For separable problems an algorithm is provided to determine if an element in the training set can become a support vector. The distributed optimization algorithm proposed in [9] solves part of these problems: local memory is scalable and communication can be directed and asynchronous. However, the dimension of the training vectors is still an issue.
The core-set idea used in this paper was introduced in [10] as a building block for clustering, and refined in [11]. In [12] the approach was shown to be relevant for several learning problems and the algorithm re-stated for such scenarios. A multi-processor implementation of the core-set approach was proposed in [13]. However, differently from our approach, that algorithm: (i) is not completely distributed since it involves a coordinator, and (ii) does not compute a global core-set, but a larger set approximating it.
The main contribution of this paper is twofold. First, we identify a distributed big-data optimization framework appearing in modern classification problems arising in cyberphysical network systems. In this framework the problem is characterized by a large number of input data distributed among computing processors. The key challenge is that the dimension of each input vector is very-high, so that standard local updates in distributed optimization cannot be used. For this big-data scenario, we identify a class of quadratic programs that model several interesting classification problems as, e.g., training of support vector machines. Second, for this class of big-data quadratic optimization problems, we propose a distributed algorithm that solves the problem up to an arbitrary ǫ tolerance and scales both with the number and the dimension of the input vectors. The algorithm is based on the notion of core-set used in geometric optimization to approximate the value function of a given set of points with a smaller subset of points. From an optimization point of view, a subset of active constraints is identified, whose number depends only on the tolerance ǫ. The resulting approximate solution is such that an ǫ-relaxation of the constraints guarantees no constraint violation. The paper is organized as follows. In Section II we introduce the distributed optimization problem addressed in the paper and describe the network model. Section III motivates the problem set-up by showing a class of learning problems that can be cast in this set-up. In Section IV the core-set consensus algorithm is introduced and analyzed. Finally, in Section V a numerical example is given to show the algorithm correctness.

FRAMEWORK
In this section we introduce the problem set-up considered in the paper. We recall that we will deal with optimization problems in which both the number of constraints and decision variables are "big".
We consider a set of processors {1, . . . , N }, each equipped with communication and computation capabilities. Each processor i has knowledge of a vector s i ∈ R d and needs to cooperatively solve the quadratic program min z∈R d ,r∈R The above quadratic program is known in geometric optimization as minimum enclosing ball problem, since it computes the center of the ball with minimum radius enclosing the set of points s 1 , . . . , s N . By applying standard duality arguments, it can be shown that solving (1) is equivalent to solving its dual with x i ∈ R, i ∈ {1, . . . , N }. The problem can be written in a more compact form as We will show in the next sections that this class of quadratic programs arises in many important big-data classification problems.
Each node has computation capabilities meaning that it can run a routine to solve a local optimization problem. Since the dimension d can be big, the distributed optimization algorithm to solve problem (1) needs to be designed so that the local routine at each node scales "nicely" with d.
The communication among the processors is modeled by where t ∈ Z ≥0 represents a slotted universal time, the node set V c = {1, . . . , N } is the set of processor identifiers, and the edge set E c (t) ⊂ {1, . . . , N } 2 characterizes the communication among the processors. Specifically, at time t there is an edge from node i to node j if and only if processor i transmits information to processor j at time t. The timevarying set of outgoing (incoming) neighbors of node i at time t, i.e., the set of nodes to (from) which there are edges . A static digraph is said to be strongly connected if for every pair of nodes (i, j) there exists a path of directed edges that goes from i to j. For the time-varying communication graph we rely on the concept of a jointly strongly connected graph.
It is worth noting that joint strong connectivity of the directed communication graph is a fairly weak assumption (it just requires persistent spreading of information) for solving a distributed optimization problem, and naturally embeds an asynchronous scenario.
We want to stress once more that in our paper all the nodes are peers, i.e., they run the same local instance of the distributed algorithm, and no node can take any special role. Consistently, we allow nodes to be asynchronous, i.e., nodes can perform the same computation at different speed, and communication can be unreliable and happen without a common clock (the time t is a universal time that does not need to be known by the nodes).

III. DISTRIBUTED BIG-DATA CLASSIFICATION
In this section we present a distributed set up for some fundamental classification problems and show, following [12], how they can be cast into the distributed quadratic programming framework introduced in the previous section.
We consider classification problems to be solved in a distributed way by a network of processors following the model in Section II. Each node in the network is assigned a subset of input vectors and the goal for the processors is to cooperatively agree on the optimal classifier without the help of any central coordinator.

A. Training of Support Vector Machines (SVMs)
Informally, the SVM training problem can be summarized as follows. Given a set of positively and negatively labeled points in a k-dimensional space, find a hyperplane separating "positive" and "negative" points with the maximal separation from all the data points. The labeled points are commonly called examples or training vectors.
Linear separability of the training vectors is usually a strong assumption. In many important concrete scenarios the training data cannot be separated by simply using a linear function (a hyperplane). To handle the nonlinear separability, nonlinear kernel functions are used to map the training samples into a feature space in which the resulting features can be linearly separated. That is, given a set of points The key aspect in SVM is that ϕ does not need to be known, but all the computations can be done through a so called Kernel Remark 3.1: It is worth noting that the dimension of the feature space can be much higher than the one of the input space, even infinite (e.g., Gaussian kernels).
Following [14] and [12] we will adopt the following common assumption in SVM. For any p i in the input space with c independent of i. This condition is satisfied by the most common kernel functions used in SVM as, e.g., the isotropic kernel (e.g., Gaussian kernel), the dot-product kernel with normalized inputs or any normalized kernel. For fixed d ∈ N, let ϕ(p i ) ∈ R d , i ∈ {1, . . . , N }, be a set of N ∈ N feature-points with associated label ℓ i ∈ {−1, +1}. The training vectors are said to be linearly separable if there exist w ∈ R d and b ∈ R such that ℓ i (w T ϕ(p i ) + b) ≥ 1 for all i ∈ {1, . . . , N }. The hard-margin SVM training problem consists of finding the optimal hyperplane w T o x + b o = 0, x ∈ R d , (w o is a vector orthogonal to the hyperplane and b o is a bias) that linearly separates the training vectors with maximal margin, that is, such that the distance In most concrete applications the training data cannot be separated without outliers (or training errors). A convex program that approximates the above problem was introduced in [15]. The idea is to introduce positive slack variables in order to relax the constraints and add an additional penalty in the cost function to weight them. The resulting classification problems are known as soft marging problems and the solution is called soft margin hyperplane.
Next, we will concentrate on a widely used soft-margin problem, the 2-norm problem, which adopts a quadratic penalty function. Following [12], we will show that its dual version is a quadratic program with the structure of (2). The 2-norm optimization problem turns out to be min w,b,ρ,ξ1,...,ξN Solving problem (6) is equivalent to solving the dual problem where δ ij =1 if i=j and δ ij = 0 otherwise.

Remark 3.2 (Support vectors):
The vector w o defining the optimal hyperplane can be written as linear combination of training vectors, These vectors are called support vectors. Support vectors are basically active constraints of the quadratic program. Now, we can notice that definingK(p i , p j ) = ℓ i ℓ j ϕ(p i ) T ϕ(p j ) + ℓ i ℓ j + δij C , it holds can be added to the cost function. Thus, posing with e i the ith canonical vector (e.g., e 1 = [1 0 . . . 0] T ), problem (7) can be equivalently rewritten as which has exactly the same structure as problem (2). It is worth noting that even if the dimension d of the training samples in the feature space (ϕ(p i ) ∈ R d ) is small compared to the number of samples N (so that in problem (5) the dimension of the decision variable is much smaller than the number of constraints), in the "augmented" softmargin problem (2) we have ϕ(p i ) ∈ R d+1+N . Thus, in the primal problem (1) the dimension of the decision variable is of the same order as the number of constraints.

B. Unsupervised classification and clustering
Next, we recall from [12] that also some unsupervised soft margin classification problems can be cast into the same problem set-up of the paper.
First, from [12] and references therein, it can be shown that problem (1) is equivalent to the hard-margin Support Vector Data Description (SVDD) problem. Indeed, given a kernel function K and feature map ϕ, the hard-margin SVDD primal problem is In other words, problem (8) is simply problem (1) in the feature space.
Another unsupervised learning problem that can be cast into the problem set-up (2) is the so called one-class L2 SVM, [12]. Given a set of unlabeled input vectors the goal is to separate outliers from normal data. From an optimization point of view, the problem can be written as problem (6), but with b = 0 and ℓ i = 1 for all i ∈ {1, . . . , N }. Thus, using the same arguments as in the previous subsection, the problem can be rewritten in the form (2).
To conclude this motivating section, we recall from [10] that algorithms solving problem (1) are important building blocks for clustering problems.

IV. CORE-SET CONSENSUS ALGORITHM
In this section we introduce the core-set consensus algorithm to solve problem (1) (or equivalently its dual (2)) in a distributed way. We start by introducing the notion of core-set borrowed from geometric optimization and a routine from [11] that is proven to compute an efficient core-set for (1), which in geometric optimization is known as minimum enclosing ball problem.

A. Core sets: definition and preliminaries
In the following we will a little abuse notation by denoting with G ∈ R d×m both the d × m matrix and the set of m vectors (or points) of dimension d. Let S ∈ R d×N be a matrix of "points" s i ∈ R d , i ∈ {1, . . . , N }, (i.e., a matrix in which each column represents a vector in R d ) with c(S) and r(S) respectively the center and radius of the minimum enclosing ball containing the points of S. We say that C ⊂ S is an ǫ-core-set for the Minimum Enclosing Ball (MEB) problem, (1), if all the points of S are at distance at most (1 + ǫ)r(S) from the center c(C) of the minimum enclosing ball containing C. Note that r(S) 2 = r 2 * , with r * being the optimal value of (1).
Next, we introduce the algorithm in [11] that is proven to compute a core-set of dimension 1 ǫ for the minimum enclosing ball problem (1).
Given a set of points P , the algorithm can be initialized by choosing any subset C ⊂ P of 1 ǫ points. Then the algorithm evolves as follows: • select a point a of P farthest from the center of the minimum enclosing ball of C; • let C a = C ∪ {a}; • remove a point b ∈ C a so that the minimum enclosing ball of the set C a \ {b} is the one with largest radius; • if the new radius is equal to the radius of minimum enclosing ball of C, then return C. Otherwise set C = C a \ {b} and repeat the procedure.
More formally, the routing is described in the following table. As before, we let c(P ) and r(P ) be respectively the center and radius of the minimum enclosing ball containing all the points in a set of points P .
function coreset(P, C) C = C a \ {b} and go to step 1 6: else 7: It is worth pointing out once more that if P = S, with S the one in (3), then the coreset algorithm finds an ǫ-coreset for (3) (or equivalently (1)).
The coreset algorithm will be the local routine implemented in the distributed optimization algorithm we propose in this paper. That is, each node will use the algorithm to solve a (smaller) local version of the main problem.
Next we provide a lemma that states the results in [11] by formally itemizing the properties of the algorithm that we will need in our distributed optimization algorithm.
Lemma 4.1 ( [11]): Let P ⊂ R d be any point set in R d . Then (i) P has an ǫ-core-set of size at most 1 ǫ ; (ii) the coreset algorithm computes an ǫ-core-set for P in a finite number of iterations; (iii) for any G ⊂ P the radius of coreset(G, C) is larger than or equal to the radius of C. Proof: Statements (i) and (ii) are proven in [11,Theorem 3.5], while (iii) follows immediately by step 4 of the algorithm.

B. Core-set consensus algorithm description
Let S be the matrix characterizing problem (3) or consistently the set of vectors s i ∈ R d , i ∈ {1, . . . , N }. As stated in Section II, each node is assigned one input vector. This assumption is just for clarity of presentation and can be easily removed. In fact, the algorithm can be run even if each node is assigned more than one vector. For this reason we denote S i the set of initial vectors, so that under the above assumption we have S i = {s i }.
An informal description of the core-set consensus distributed algorithm is the following. Each node stores a candidate core-set C i , i.e., a set of 1 ǫ vectors that represent node-i's current estimate for the core-set of S. At each communication round each node receives the candidate core sets (sets of 1 ǫ vectors) from its in-neighbors and initializes its local routine to the core-set with highest value. Let S tmp = S i ∪ C i ∪ ∪ j∈N I i (t) C j be the set of vectors from all neighboring core-sets plus the initial vectors assigned to node i. The local routine at each node finds a core set (of 1 ǫ vectors) of S tmp , and updates the candidate core set with the returned value.
A pseudo-code of the algorithm is given in the following table. We assume each node can run two routines, namely C out = coreset(G, C in ) and r 2 out = r 2 (C in ) returning respectively the core-set of a given set of vectors G (the routine is initialized with C in ) and the value of a given core set, i.e., the optimal value of problem (3) with matrix S = G (squared radius of the minimum enclosing ball).

Algorithm 1 Core-set consensus
Processor state: . . , s i } Message to out-neighbors: C i Local routine:

Remark 4.2:
The algorithm works also if a larger set of vectors is assigned to each node. Only the initialization needs to be changed. If a node is assigned more than 1 ǫ vectors, it will initialize C i with a random set of 1 ǫ vectors. Remark 4.3: It is worth noting that the nodes need to know the common tolerance ǫ (and thus the core-set dimension 1 ǫ ) to run the algorithm. To analyze the algorithm, we associate a universal, discrete time t ∈ Z ≥0 to each step of the distributed algorithm evolution, i.e., to each computation and communication round. This time t is the one defining the time varying nature of the communication graph and, thus, the same used in Assumption 2.1.

C. Algorithm analysis
We are now ready to analyze the convergence properties of the algorithm.  (3), for any C 1 , C 2 ⊂ S with C 1 , C 2 ∈ R d×⌈ 1 ǫ ⌉ , then r(C 1 ) = r(C 2 ).
The above assumption can be removed by using a total ordering for the choice of C i0 in Algorithm 1. For example, if two candidate sets C 1 i0 and C 2 i0 have r(C 1 i0 ) = r(C 2 i0 ), then one of the two could be uniquely chosen by using a lexicographic ordering on the vectors. Theorem 4.5: Consider a network of processors with set of identifiers V c = {1, . . . , N } and communication graph G c (t) = (V c , E c (t)), t ∈ N, satisfying Assumption 2.1. Suppose problem (1) satisfies Assumption 4.4 and has a minimum value r 2 * . Then the core-set consensus algorithm (Algorithm 1) computes an ǫ-core-set for problem (1) in a finite-number of communication rounds. That is, there exists T > 0 such that (i) C i (t) =C for all i ∈ {1, . . . , N } and for all t ≥ T ; . . , N }. Proof: We prove the statement in three steps. First, we prove that each core set converges in a finite-number of communication rounds to a stationary set of vectors. Second, we prove that (due to Assumption 4.4) all the stationary core sets are equal. Third and finally, we prove that the common steady-state set is a core set for problem (1).
To prove the first part, notice that by the choice of C i0 in Algorithm 1 and by Lemma 4.1, r 2 (C i (t)) is a monotone nondecreasing function for all i ∈ {1, . . . , N } along the algorithm evolution. Thus, due to the finite possible values that C i can assume (it is a set of 1 ǫ vectors out of N vectors), r 2 (C i (t)) converges to a stationary value in finite time.
To prove the second part, suppose that at some time T > 0 all the r 2 (C i (t))s have converged to a stationary value and that there exist at least two nodes i and j such that r 2 (C i (t)) > r 2 (C j (t)). Without loss of generality, from Assumption 2.1, we can choose the two nodes so that (i, j) ∈ E c (t), i.e., (i, j) is an edge in G c (t) for some time instantt > T . But from Algorithm 1 at timet node j would choose C i to initialize its coreset routine, thus leading to a contradiction. From Assumption 4.4, it follows C i =C for all i ∈ {1, . . . , N }.
Finally, we just need to prove thatC is a core-set for S. But from the properties of the coreset algorithm, for each node i ∈ {1, . . . , N }, C i =C is a core-set for the a set of points including s i , so thatC is a core set for S = [s 1 . . . s N ], thus concluding the proof.
Remark 4.6 (Core-sets and active constraints): A coreset C is a set of "active constraints" in problem (1) with a cost r 2 (C) (i.e., r = r(C)). Clearly, some of the constraints will be violated for this value of r, but no one will be violated for r = r * (1 + ǫ), with r * being the optimal value of r. An equivalent characterization for the core-set is that no constraint is violated if r(C) is relaxed to r(C)(1 − ǫ). This test is easier to run, since it does not involve the computation of the optimal value and will be used in the simulations.

V. SIMULATIONS
In this section we provide a numerical example showing the effectiveness of the proposed strategy.
We consider a network with N = 100 nodes communicating according to a directed, time-varying graph obtained by extracting at each time-instant an Erdős-Rényi graph with parameter 0.01. We choose a small value, so that at a given instant the graph is disconnected with high probability, but the graph turns out to be jointly connected. We solve a quadratic program, (1), with d = 50 and choose a tolerance ǫ = 0.1 so that the number of vectors in the core-set is 1 ǫ = 10. In Figure 1 and Figure 2 the evolution of the squaredradius and center-norm of the core-sets at each node are depicted. As expected from the theoretical analysis, the convergence of the radius to the consensus value is monotone non-decreasing.

VI. CONCLUSIONS
In this paper we have proposed a distributed algorithm to solve a special class of quadratic programs that models several classification problems. The proposed algorithm handles problems in which not only the number of input data is large, but furthermore their dimension is big. The resulting learning area is known as big-data classification. We have proposed a distributed optimization algorithm that computes an approximate solution of the global problem. Specifically, for any chosen tolerance ǫ, each local node needs to store only 1 ǫ active constraints, which represent a solution for the global quadratic program up to a relative tolerance ǫ. Future research developments include the extension of the algorithmic idea, based on core-sets, to other big-data optimization problems.