{'fraction_non_alphanumeric': 0.03690892985194246, 'fraction_numerical': 0.009554140127388535, 'mean_word_length': 4.391131324616259, 'pattern_counts': {'":': 0, '<': 11, '<?xml version=': 0, '>': 10, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 7, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Effective Parallelisation for Machine Learning

We present a novel parallelisation scheme that simplifies the adaptation of learning algorithms to growing amounts of data as well as growing needs for accurate and confident predictions in critical applications. In contrast to other parallelisation techniques, it can be applied to a broad class of learning algorithms without further mathematical derivations and without writing dedicated code, while at the same time maintaining theoretical performance guarantees. Moreover, our parallelisation scheme is able to reduce the runtime of many learning algorithms to polylogarithmic time on quasi-polynomially many processing units. This is a significant step towards a general answer to an open question on the efficient parallelisation of machine learning algorithms in the sense of Nick's Class (NC). The cost of this parallelisation is in the form of a larger sample complexity. Our empirical study confirms the potential of our parallelisation scheme with fixed numbers of processors and instances in realistic application scenarios.


Introduction
This paper contributes a novel and provably effective parallelisation scheme for a broad class of learning algorithms. The significance of this result is to allow the confident application of machine learning algorithms with growing amounts of data. In critical application scenarios, i.e., when errors have almost prohibitively high cost, this confidence is essential [27,36]. To this end, we consider the parallelisation of an algorithm to be effective if it achieves the same confidence and error bounds as the sequential execution of that algorithm in much shorter time. Indeed, our parallelisation scheme can reduce the runtime of learning algorithms from polynomial to polylogarithmic. For that, it consumes more data and is executed on a quasi-polynomial number of processing units.
To formally describe and analyse our parallelisation scheme, we consider the regularised risk minimisation setting. For a fixed but unknown joint probability distribution D over an input space X and an output space Y, a dataset D ⊆ X × Y of size N ∈ N drawn iid from D, a convex hypothesis space F of functions f : X → Y, a loss function : F × X × Y → R that is convex in F, and a convex regularisation term Ω : F → R, regularised risk minimisation algorithms solve L(D) = argmin f ∈F (x,y)∈D (f, x, y) + Ω(f ) . (1) The aim of this approach is to obtain a hypothesis f ∈ F with small regret Regularised risk minimisation algorithms are typically designed to be consistent and efficient. They are consistent if there is a function N 0 : R + × R + → R + such that for all ε > 0, ∆ ∈ (0, 1], N ∈ N with N ≥ N 0 (ε, ∆), and training data D ∼ D N , the probability of generating an ε-bad hypothesis is no greater than ∆, i.e., P (Q (L(D)) > ε) ≤ ∆ .
They are efficient if the sample complexity N 0 (ε, ∆) is polynomial in 1 /ε, log 1 /∆ and the runtime complexity T L is polynomial in the sample complexity. This paper considers the parallelisation of such consistent and efficient learning algorithms, e.g., support vector machines, regularised least squares regression, and logistic regression. We additionally assume that data is abundant and that F can be parametrised in a fixed, finite dimensional Euclidean space R d such that the convexity of the regularised risk minimisation problem (Equation 1) is preserved. In other cases, (non-linear) low-dimensional embeddings [2,28] can preprocess the data to facilitate parallel learning with our scheme. With slight abuse of notation, we identify the hypothesis space with its parametrisation.
The main theoretical contribution of this paper is to show that algorithms satisfying the above conditions can be parallelised effectively. We consider a parallelisation to be effective if the (ε, ∆)guarantees (Equation 3) are achieved in time polylogarithmic in N 0 (ε, ∆). The cost for achieving this reduction in runtime comes in the form of an increased data size and in the number of processing units used. For the parallelisation scheme presented in this paper, we are able to bound this cost by a quasi-polynomial in 1 /ε and log 1 /∆. The main practical contribution of this paper is an effective parallelisation scheme that treats the underlying learning algorithm as a black-box, i.e., it can be parallelised without further mathematical derivations and without writing dedicated code.
Similar to averaging-based parallelisations [32,45,46], we apply the underlying learning algorithm in parallel to random subsets of the data. Each resulting hypothesis is assigned to a leaf of an aggregation tree which is then traversed bottom-up. Each inner node computes a new hypothesis that is a Radon point [30] of its children's hypotheses. In contrast to aggregation by averaging, the Radon point increases the confidence in the aggregate doubly-exponentially with the height of the aggregation tree. We describe our parallelisation scheme, the Radon machine, in detail in Section 2.
Comparing the Radon machine to the underlying learning algorithm which is applied to a dataset of the size necessary to achieve the same confidence, we are able to show a reduction in runtime from polynomial to polylogarithmic in Section 3.
The empirical evaluation of the Radon machine in Section 4 confirms its potential in practical settings. Given the same amount of data as the underlying learning algorithm, the Radon machine achieves a substantial reduction of computation time in realistic applications. Using 150 processors, the Radon machine is between 80 and around 700-times faster than the underlying learning algorithm on a single processing unit. Compared with parallel learning algorithms from Spark's MLlib, it achieves hypotheses of similar quality, while requiring only 15 − 85% of their runtime.
Parallel computing [18] and its limitations [13] have been studied for a long time in theoretical computer science [7]. Parallelising polynomial time algorithms ranges from being 'embarrassingly' [26] easy to being believed to be impossible. For the class of decision problems that are the hardest in P, i.e., for P-complete problems, it is believed that there is no efficient parallel algorithm in the sense of Nick's Class (NC [9]): efficient parallel algorithms in this sense are those that can be executed in polylogarithmic time on a polynomial number of processing units. Our paper thus contributes to

Algorithm 1 Radon Machine
Input: learning algorithm L, dataset D ⊆ X × Y, Radon number r ∈ N, and parameter h ∈ N Output: hypothesis f ∈ F 1: divide D into r h iid subsets D i of roughly equal size 2: run L in parallel to obtain partition S into iid subsets S 1 , . . . , S r i of size r each 6: calculate Radon points r(S 1 ), . . . , r(S r i ) in parallel # see Definition 1 and Appendix C.1

7:
S ← {r(S 1 ), . . . , r(S r i )} 8: end for 9: return r(S) understanding the extent to which efficient parallelisation of polynomial time learning algorithms is possible. This connection and other approaches to parallel learning are discussed in Section 5.

From Radon Points to Radon Machines
The Radon machine, described in Algorithm 1, first executes the underlying (base) learning algorithm on random subsets of the data to quickly achieve weak hypotheses and then iteratively aggregates them to stronger ones. Both the generation of weak hypotheses and the aggregation can be executed in parallel. To aggregate hypotheses, we follow along the lines of the iterated Radon point algorithm which was originally devised to approximate the centre point, i.e., a point of largest Tukey depth [38], of a finite set of points [8]. The Radon point [30] of a set of points is defined as follows: where · denotes the convex hull. The Radon number of a space F is the smallest r ∈ N such that for all S ⊂ F with |S| ≥ r there is a Radon partition; or ∞ if no S ⊂ F with Radon partition exists. A Radon point of a set S with Radon partition A, B is any r ∈ A ∩ B .
We now present the Radon machine (Algorithm 1), which is able to effectively parallelise consistent and efficient learning algorithms. Input to this parallelisation scheme is a learning algorithm L on a hypothesis space F, a dataset D ⊆ X × Y, the Radon number r ∈ N of the hypothesis space F, and a parameter h ∈ N. It divides the dataset into r h subsets D 1 , . . . , D r h (line 1) and runs the algorithm L on each subset in parallel (line 2). Then, the set of hypotheses (line 3) is iteratively aggregated to form better sets of hypotheses (line [4][5][6][7][8]. For that the set is partitioned into subsets of size r (line 5) and the Radon point of each subset is calculated in parallel (line 6). The final step of each iteration is to replace the set of hypotheses by the set of Radon points (line 7).
The scheme requires a hypothesis space with a valid notion of convexity and finite Radon number. While other notions of convexity are possible [16,33], in this paper we restrict our consideration to Euclidean spaces with the usual notion of convexity. Radon's theorem [30] states that the Euclidean space R d has Radon number r = d + 2. Radon points can then be obtained by solving a system of linear equations of size r × r (to be fully self-contained we state the system of linear equations explicitly in Appendix C.1). The next proposition gives a guarantee on the quality of Radon points: Proposition 2. Given a probability measure P over a hypothesis space F with finite Radon number r, let F denote a random variable with distribution P . Furthermore, let r be the random variable obtained by computing the Radon point of r random points drawn according to P r . Then it holds for the expected regret Q and all ε ∈ R that P (Q (r) > ε) ≤ (rP (Q (F ) > ε)) 2 .
The proof of Proposition 2 is provided in Section 7. Note that this proof also shows the robustness of the Radon point compared to the average: if only one of r points is ε-bad, the Radon point is still ε-good, while the average may or may not be; indeed, in a linear space with any set of ε-good hypotheses and any ε ≥ ε, we can always find a single ε -bad hypothesis such that the average of all these hypotheses is ε -bad.
A direct consequence of Proposition 2 is a bound on the probability that the output of the Radon machine with parameter h is bad: Theorem 3. Given a probability measure P over a hypothesis space F with finite Radon number r, let F denote a random variable with distribution P . Denote by r 1 the random variable obtained by computing the Radon point of r random points drawn iid according to P and by P 1 its distribution. For any h ∈ N, let r h denote the Radon point of r random points drawn iid from P h−1 and by P h its distribution. Then for any convex function Q : F → R and all ε ∈ R it holds that The proof of Theorem 3 is also provided in Section 7. For the Radon machine with parameter h, Theorem 3 shows that the probability of obtaining an ε-bad hypothesis is doubly exponentially reduced: with a bound δ on this probability for the base learning algorithm, the bound ∆ on this probability for the Radon machine is In the next section we compare the Radon machine to its base learning algorithm which is applied to a dataset of the size necessary to achieve the same ε and ∆.

Sample and Runtime Complexity
In this section we first derive the sample and runtime complexity of the Radon machine R from the sample and runtime complexity of the base learning algorithm L. We then relate the runtime complexity of the Radon machine to an application of the base learning algorithm which achieves the same (ε, ∆)-guarantee. For that, we consider consistent and efficient base learning algorithms with a sample complexity of the form N L 0 (ε, δ) = (α ε + β ε ld 1 /δ) k , for some 1 α ε , β ε ∈ R, and k ∈ N. From now on, we also assume that δ ≤ 1 /2r for the base learning algorithm.
The Radon machine creates r h base hypotheses and, with ∆ as in Equation 4, has sample complexity Theorem 3 then implies that the Radon machine with base learning algorithm L is consistent: with N ≥ N R 0 (ε, ∆) samples it achieves an (ε, ∆)-guarantee. To achieve the same guarantee as the Radon machine, the application of the base learning algorithm L itself (sequentially) would require M ≥ N L 0 (ε, ∆) samples, where For base learning algorithms L with runtime T L (n) polynomial in the data size n ∈ N, i.e., T L (n) ∈ O (n κ ) with κ ∈ N, we now determine the runtime T R,h (N ) of the Radon machine with h iterations and c = r h processing units on N ∈ N samples. In this case all base learning algorithms can be executed in parallel. In practical applications fewer physical processors can be used to simulate r h processing units-we discuss this case in Section 5.
The runtime of the Radon machine can be decomposed into the runtime of the base learning algorithm and the runtime for the aggregation. The base learning algorithm requires n ≥ N L 0 (ε, δ) samples and can be executed on r h processors in parallel in time T L (n). The Radon point in each of the h iterations can then be calculated in parallel in time r 3 (see Appendix C.1). Thus, the runtime of the Radon machine with N = r h n samples is T R,h (N ) = T L (n) + hr 3 . The theorem is proven in Appendix A.1 and relates to Nick's Class [1]: A decision problem can be solved efficiently in parallel in the sense of Nick's Class, if it can be decided by an algorithm in polylogarithmic time on polynomially many processors (assuming, e.g., PRAM model). For the class of decision problems that are the hardest in P , i.e., for P -complete problems, it is believed that there is no efficient parallel algorithm for solving them in this sense. Theorem 4 provides a step towards finding efficient parallelisations of regularised risk minimisers and towards answering the open question: is consistent regularised risk minimisation possible in polylogarithmic time on polynomially many processors. A similar question, for the case of learning half spaces, has been called a fundamental open problem by Long and Servedio [21] who gave an algorithms which runs on polynomially many processors in time that depends polylogarithmically on the sample size but is inversely proportional to a parameter of the learning problem. While Nick's Class as a notion of efficiency has been criticised [17], it is the only notion of efficiency that forms a proper complexity class in the sense of Blum [4]. To overcome the weakness of using only this notion, Kruskal et al. [17] suggested to consider also the inefficiency of simulating the parallel algorithm on a single processing unit. We discuss the inefficiency and the speed-up in Appendix A.2.

Empirical Evaluation
This empirical study compares the Radon machine to state-of-the-art parallel machine learning algorithms from the Spark machine learning library [25], as well as the natural baseline of averaging hypotheses instead of calculating their Radon point (averaging-at-the-end, Avg). We use base learning algorithms from WEKA [44] and scikit-learn [29]. We compare the Radon machine to the base learning algorithms on moderately sized datasets, due to scalability limitations of the base learners, and reserve larger datasets for the comparison with parallel learners. The experiments are executed on a Spark cluster (5 worker nodes, 25 processors per node) 2 . All results are obtained using 10-fold cross validation. We apply the Radon machine with parameter h = 1 and the maximal parameter h such that each instance of the base learning algorithm is executed on a subset of size at least 100 (denoted h = max). Averaging-at-the-end executes the base learning algorithm on the same number of subsets r h as the Radon machine with that parameter and is denoted in the Figures by stating the parameter h as for the Radon machine. All other parameters of the learning algorithms are optimised on an independent split of the datasets. See Appendix B for additional details.
What is the speed-up of our scheme in practice? In Figure 1(a), we compare the Radon machine to its base learners on moderately sized datasets (details on the datasets are provided in Appendix B). 2 The source code implementation in Spark can be found in the bitbucket repository https://bitbucket.org/Michael_Kamp/radonmachine.      There, the Radon machine is between 80 and around 700-times faster than the base learner using 150 processors. The speed-up is detailed in Figure 2. On the SUSY dataset (with 5 000 000 instances and 18 features), the Radon machine on 150 processors with h = 3 is 721 times faster than its base learning algorithms. At the same time, their predictive performances, measured by the area under the ROC curve (AUC) on an independent test dataset, are comparable.
How does the scheme compare to averagingat-the-end? In Figure 1(b) we compare the runtime and AUC of the parallelisation scheme against the averaging-at-the-end baseline (Avg).
In terms of the AUC, the Radon machine outperforms the averaging-at-the-end baseline on all datasets by at least 10%. The runtimes can hardly be distinguished in that figure. A small difference can however be noted in Figure 4 which is discussed in more details in the next paragraph. Since averaging is less computationally expensive than calculating the Radon point, the runtimes of the averaging-at-the-end baselines are slightly lower than the ones of the Radon machine. However, compared to the computational complexity of executing the base learner, this advantage becomes negligible.
How does our scheme compare to state-of-the-art Spark machine learning algorithms? We compare the Radon machine to various Spark machine learning algorithms on 5 large datasets. The results in Figure 1(c) indicate that the proposed parallelisation scheme with h = max has a substantially smaller runtime than the Spark algorithms on all datasets. On the SUSY and HIGGS dataset, the Radon machine is one order of magnitude faster than the Spark implementations-here the comparatively small number of features allows for a high level of parallelism. On the CASP9 dataset, the Radon machine is 15% faster than the fastest Spark algorithm. The performance in terms of AUC of the Radon machine is similar to the Spark algorithms. In particular, when using WekaLogReg with h = max, the Radon machine outperforms the Spark algorithms in terms of AUC and runtime on the datasets SUSY, wikidata, and CASP9. Details are given in the Appendix B. A summarizing comparison of the parallel approaches in terms of their trade-off between runtime and predictive performance is depicted in Figure 4. Here, results are shown for the Radon machine and averagingat-the-end with parameter h = max and for the two Spark algorithms most similar to the base learning algorithms. Note that it is unclear what caused the consistently weak performance of all algorithms on wikidata. Nonetheless, the results show that on all datasets the Radon machine has comparable predictive performance to the Spark algorithms and substantially higher predictive performance than averaging-at-the-end. At the same time, the Radon machine has a runtime comparable to averaging-at-the-end on all datasets and both are substantially faster than the Spark algorithms.
How does the runtime depend on the dataset size in a real-world system? The runtime of the Radon machine can be distinguished into its learning phase and its aggregation phase. While the learning phase fully benefits from parallelisation, this comes at the cost of additional runtime for the aggregation phase. The time for aggregating the hypotheses does not depend on the number of instances in the dataset but for a fixed parameter h it only depends on the dimension of the hypothesis space and that parameter. In Figure 3 we compare the runtimes of all base learning algorithms per dataset size to the Radon machines. Results indicate that, while the runtimes of the base learning algorithms depends on the dataset size with an average exponent of 1.57, the runtime of the Radon machine depends on the dataset size with an exponent of only 1.17.
How generally applicable is the scheme? As an indication of the general applicability in practice, we also consider regression and multi-class classification. For regression, we apply the scheme to the Scikit-learn implementation of regularised least squares regression [29]. On the dataset YearPre-dictionMSD, regularised least squares regression achieves an RMSE of 12.57, whereas the Radon machine achieved an RMSE of 13.64. At the same time, the Radon machine is 197-times faster. We also compare the Radon machine on a multi-class prediction problem using conditional maximum entropy models. For multi-class classification, we use the implementation described in Mcdonald et al. [23], who propose to use averaging-at-the-end for distributed training. We compare the Radon machine to averaging-at-the-end with conditional maximum entropy models on two large multiclass datasets (drift and spoken-arabic-digit). On average, our scheme performs better with only slightly longer runtime. The minimal difference in runtime can be explained-similar to the results in Figure 1

Discussion and Future Work
In the experiments we considered datasets where the number of dimensions is much smaller than the number of instances. What about high-dimensional models? The basic version of the parallelisation scheme presented in this paper cannot directly be applied to cases in which the size of the dataset is not at least a multiple of the Radon number of the hypothesis space. For various types of data such as text, this might cause concerns. However, random projections [15] or low-rank approximations [2,28] can alleviate this problem and are already frequently employed in machine learning. An alternative might be to combine our parallelisation scheme with block coordinate descent [37]. In this case, the scheme can be applied iteratively to subsets of the features.
In the experiments we considered only linear models. What about non-linear models? Learning non-linear models causes similar problems to learning high-dimensional ones. In non-parametric methods like kernel methods, for instance, the dimensionality of the optimisation problem is equal to the number of instances, thus prohibiting the application of our parallelisation scheme. However, similar low-rank approximation techniques as described above can be applied with non-linear kernels [11]. Furthermore, methods for speeding up the learning process for non-linear models explicitly approximate an embedding in which then a linear model can be learned [31]. Using explicitly constructed feature spaces, Radon machines can directly be applied to non-linear models.
We have theoretically analysed our parallelisation scheme for the case that there are enough processing units available to find each weak hypothesis on a separate processing units. What if there are not r h , but only c < r h processing units? The parallelisation scheme can quite naturally be "deparallelised" and partially executed in sequence. For the runtime this implies an additional factor of max{1, r h /c}. Thus, the Radon machine can be applied with any number of processing units.
The scheme improves ∆ doubly exponentially in its parameter h but for that it requires the weak hypotheses to already achieve δ ≤ 1 /2r. Is the scheme only applicable in high-confidence domains? Many application scenarios require high-confidence error bounds, e.g., in the medical domain [27] or in intrusion detection [36]. In practice our scheme achieves similar predictive quality much faster than its base learner.
Besides runtime, communication plays an essential role in parallel learning. What is the communication complexity of the scheme? As for all aggregation at the end strategies, the overall amount of communication is low compared to periodically communicating schemes. For the parallel aggregation of hypotheses, the scheme requires O(r h+1 ) messages (which can be sent in parallel) each containing a single hypothesis of size O(r). Our scheme is ideally suited for inherently distributed data and might even mitigate privacy concerns.
In a lot of applications data is available in the form of potentially infinite data streams. Can the scheme be applied to distributed data streams? For each data stream, a hypotheses could be maintained using an online learning algorithm and periodically aggregated using the Radon machine, similar to the federated learning approach proposed by McMahan et al. [24].
In this paper, we investigated the parallelisation of machine learning algorithms. Is the Radon machine more generally applicable? The parallelisation scheme could be applied to more general randomized convex optimization algorithms with unknown and random target functions. We will investigate its applicability for learning in non-Euclidean, abstract convexity spaces.

Conclusion and Related Work
In this paper we provided a step towards answering an open problem: Is parallel machine learning possible in polylogarithmic time using a polynomial number of processors only? This question has been posed for half-spaces by Long and Servedio [21] and called "a fundamental open problem about the abilities and limitations of efficient parallel learning algorithms". It relates machine learning to Nick's Class of parallelisable decision problems and its variants [13]. Early theoretical treatments of parallel learning with respect to NC considered probably approximately correct (PAC) [5,39] concept learning. Vitter and Lin [42] introduced the notion of NC-learnable for concept classes for which there is an algorithm that outputs a probably approximately correct hypothesis in polylogarithmic time using a polynomial number of processors. In this setting, they proved positive and negative learnability results for a number of concept classes that were previously known to be PAC-learnable in polynomial time. More recently, the special case of learning half spaces in parallel was considered by Long and Servedio [21] who gave an algorithm for this case that runs on polynomially many processors in time that depends polylogarithmically on the size of the instances but is inversely proportional to a parameter of the learning problem. Our paper complements these theoretical treatments of parallel machine learning and provides a provably effective parallelisation scheme for a broad class of regularised risk minimisation algorithms.
Some parallelisation schemes also train learning algorithms on small chunks of data and average the found hypotheses. While this approach has advantages [12,32], current error bounds do not allow a derivation of polylogarithmic runtime [20,35,45] and it has been doubted to have any benefit over learning on a single chunk [34]. Another popular class of parallel learning algorithms is based on stochastic gradient descent, targeting expected risk minimisation directly [34, and references therein]. The best so far known algorithm in this class [34] is the distributed mini-batch algorithm [10]. This algorithm still runs for a number of rounds inversely proportional to the desired optimisation error, hence not in polylogarithmic time. A more traditional approach is to minimise the empirical risk, i.e., an empirical sample-based approximation of the expected risk, using any, deterministic or randomised, optimisation algorithm. This approach relies on generalisation guarantees relating the expected and empirical risk minimisation as well as a guarantee on the optimisation error introduced by the optimisation algorithm. The approach is readily parallelisable by employing available parallel optimisation algorithms [e.g., 6]. It is worth noting that these algorithms solve a harder than necessary optimisation problem and often come with prohibitively high communication cost in distributed settings [34]. Recent results improve over these [22] but cannot achieve polylogarithmic time as the number of iterations depends linearly on the number of processors.
Apart from its theoretical advantages, the Radon machine also has several practical benefits. In particular, it is a black-box parallelisation scheme in the sense that it is applicable to a wide range of machine learning algorithms and it does not depend on the implementation of these algorithms. It speeds up learning while achieving a similar hypothesis quality as the base learner. Our empirical evaluation indicates that in practice the Radon machine achieves either a substantial speed-up or a higher predictive performance than other parallel machine learning algorithms.

Proof of Proposition 2 and Theorem 3
In order to prove Proposition 2 and consecutively Theorem 3, we first investigate some properties of Radon points and convex functions. We proof these properties for the more general case of quasiconvex functions. Since every convex function is also quasi-convex, the results hold for convex functions as well. A quasi-convex function is defined as follows. Definition 5. A function Q : F → R is called quasi-convex if all its sublevel sets are convex, i.e., ∀θ ∈ R : {f ∈ F | Q (f ) < θ} is convex.
First we give a different characterisation of quasi-convex functions. Proposition 6. A function Q : F → R is quasi-convex if and only if for all S ⊆ F and all s ∈ S there exists an s ∈ S with Q (s) ≥ Q (s ). Proof.
(⇒) Suppose this direction does not hold. Then there is a quasi-convex function Q, a set S ⊆ F, and an s ∈ S such that for all s ∈ S it holds that Q (s) < Q (s ) (therefore s / ∈ S). Let C = {c ∈ F | Q (c) < Q (s )}. As S ⊆ C = C we also have that S ⊆ C which contradicts S s / ∈ C.
(⇐) Suppose this direction does not hold. Then there exists an ε such that S = {s ∈ F | Q (s) < ε} is not convex and therefore there is an s ∈ S \ S. By assumption ∃s ∈ S : Q (s) ≥ Q (s ). Hence Q (s ) < ε and we have a contradiction since this would imply s ∈ S.
The next proposition concerns the value of any convex function at a Radon point. Proposition 7. For every set S with Radon point r and every quasi-convex function Q it holds that |{s ∈ S | Q (s) ≥ Q (r)}| ≥ 2.
Proof. We show a slightly stronger result: Take any family of pairwise disjoint sets A i with i A i = ∅ and r ∈ i A i . From proposition 6 follows directly the existence of an a i ∈ A i such that Q (a i ) ≥ Q (r). The desired result follows then from a i = a j ⇐ i = j.
We are now ready to proof Proposition 2 and Theorem 3 (which we re-state here for convenience). Theorem 3. Given a probability measure P over a hypothesis space F with finite Radon number r, let F denote a random variable with distribution P . Denote by r 1 the random variable obtained by computing the Radon point of r random points drawn iid according to P and by P 1 its distribution. For any h ∈ N, let r h denote the Radon point of r random points drawn iid from P h−1 and by P h its distribution. Then for any convex function Q : F → R and all ε ∈ R it holds that Proof of Proposition 2 and Theorem 3. By proposition 7, for any Radon point r of a set S there must be two points a, b ∈ S with Q (a) , Q (b) ≥ Q (r). Henceforth, the probability of Q (r) > ε is less than or equal to the probability of the pair a, b having Q (a) , Q (b) > ε. Proposition 2 follows by an application of the union bound on all pairs from S. Repeated application of the proposition proves Theorem 3.

A.1 Proof of Theorem 4
In the following, Theorem 4 is proven we which re-state here for convenience. Theorem 4. The Radon machine with a consistent and efficient regularised risk minimisation algorithm on a hypothesis space with finite Radon number has polylogarithmic runtime on quasipolynomially many processing units if the Radon number can be upper bounded by a function polylogarithmic in the sample complexity of the efficient regularised risk minimisation algorithm.y Proof. We assume the base learning algorithm L to be a consistent and efficient regularised risk minimisation algorithm on a hypothesis space with finite Radon number. Let r ∈ N be the Radon number of the hypothesis space and be its sample complexity with α ε , β ε ≥ 0. In the following, we want to compare the runtime of the Radon machine for achieving an (ε, ∆)-guarantee to the runtime of the application of the base learning algorithm for achieving the same (ε, ∆)-guarantee.
To achieve an (ε, ∆)-guarantee, the Radon machine with parameter h ∈ N requires N = nr h examples (i.e., with r h processing units), where n denotes the size of the data subset available to each parallel instance of the base learning algorithm. Since ∆ = (rδ) 2 h , each base learning algorithm needs to achieve an (ε, δ)-guarantee and thus requires at least examples. The application of the base learning algorithm requires at least (cf. Equation 6) Solving Equation 8 for β ε ld 1 /δ yields

By inserting this into Equation 9 we obtain
In the following, we show that for the choice of the runtime of the Radon machine is polylogarithmic in M , i.e., polylogarithmic in the number of examples the base learning algorithm requires to achieve the same (ε, ∆)-guarantee. For that, the Radon machine requires quasi-polynomially many processors in M . Note that the Radon machine processes N ≥ M many samples to achieve that (ε, ∆)-guarantee, which is more than the base learning algorithm requires by a factor in O ( r h /2 hk ).
Thus, we need to express the runtime of the Radon machine, that is, in terms of M instead of N . First, we express n in terms of M , by solving Equation 10 for n which yields Since L is efficient, T L (n) ∈ O(n κ ) and thus the runtime of the Radon machine in terms of M , denoted T M R , is Inserting h as in Equation 11 yields This shows that Thus, the runtime of the Radon machine to achieve an (ε, ∆)-guarantee in terms of M (i.e., the number of samples required by the base learning algorithm to achieve that guarantee) is in O ld κ M + ld kκ r + r 3 ld M and therefore polylogarithmic in M .
We now determine the number of processing units c = r h in terms of M . For that, observe that h as in Equation 11 can be expressed as With this the number of processing units is As mentioned in Section 3, for the Radon machine to achieve an (ε, ∆)-guarantee each instance of its base learning algorithm has to achieve δ ≤ 1 /2r. Thus, the sample size with respect to M has to be large enough so that each base learner achieves this minimum δ. Similar to the proof of Theorem 4, we can express this minimum sample size in terms of M : The base learning algorithm achieves δ ≤ 1 /2r for M ≥ 2 kβε(αε+1) . This can be shown by first observing that Equation 9 implies that for each instance of the base learning algorithm to achieve δ ≤ 1 /2r it is required that This holds for M ≥ 2 kβε(αε+1) ≥ 2 kβε , since After having proven that the Radon machine has polylogarithmic runtime on quasi-polynomially many processors, in the following section we analyse the speed-up over the base learning algorithm which achieves the same (ε, ∆)-guarantee.

A.2 Analysis of the Speed-Up of the Radon machine
In this section, we analyse the speed-up of the Radon machine over the execution of the base learning algorithm when both achieve the same (ε, ∆)-guarantee, as well as its inefficiency [17] and its data inefficiency, i.e., how much more data the Radon machine requires compared to the base learning algorithm which achieves the same (ε, ∆)-guarantee. For that, recall that the sample complexity of the base learning algorithm for a given ε > 0, 0 < ∆ < 1 is We assume that α ε ∈ Θ(ε −1 ) and β ε ∈ Θ(ε −1 ) (see for example Lemma 11 and Lemma 12).
Following the notion of Hanneke [14] the sample complexity can then be expressed as Similar to Kruskal et al. [17], we assume the base algorithm to have a runtime polynomial in N , i.e., The Radon machine runs L in parallel on c processors to obtain r h weak hypotheses with (ε, δ)guarantee. It then combines the obtained solutions h times-level-wise in parallel-calculating the Radon point (which takes time r 3 ). In this paper we assume the number of available processors to be abundant and thus set c = r h . With this, the runtime of the Radon machine is We now provide an analysis on the speed-up for c = r h and arbitrary h ∈ N. Proposition 8. Given a polynomial time consistent regularised risk minimisation algorithm L using a hypothesis space with finite Radon number r ∈ N and runtime as in Equation 15, the Radon machine run with parameter h ∈ N on r h processors. Then, the ratio of the runtime of the base learner over the runtime of the Radon machine, denoted the speed-up [17] T Proof. In order to achieve an (ε, ∆)-guarantee, the Radon machine runs r h parallel instances of the the base learning algorithm on n = N L 0 (ε, δ) examples with δ ≤ 1 /2r so that ∆ = (rδ) 2 h . To achieve the same (ε, ∆)-guarantee, the base learning algorithm requires many examples. The last step follows from the fact that, since δ ≤ 1 /2r, we have 1 /rδ ≥ 2r /r ≥ r and thus To achieve the (ε, ∆)-guarantee, the base learning algorithm has a runtime of Using T R from Equation 16, we get that The speed-up then is Note that the runtime of the Radon machine for the case that 1 ≤ c ≤ r h is given by In this case, the speed-up is lower by a factor of r h /c.
In the following, we analyse the inefficiency [17] of the Radon machine, i.e., the ratio between the total number of operations executed by all processors and the work of the base learning algorithm.
Thus, the inefficiency of the Radon machine is quasi-polynomially bounded or, for short, it has quasi-polynomial inefficiency.
In order to achieve the same (ε, ∆)-guarantee as the base learning algorithm, the Radon machine requires more data. In the following, we analyse the data inefficiency N R (ε, ∆) /N L (ε, ∆), i.e., the ratio of the data required by the Radon machine over the data required by the base learning algorithm.
Proposition 10. The Radon machine with a consistent and efficient regularised risk minimisation algorithm L with sample complexity N L (ε, ∆) on a hypothesis space with finite Radon number r ∈ N has a data inefficiency in Proof. We assume the sample complexity can be expressed as in Equation 14. For ∆ = (rδ) 2 h we have that Thus, the data inefficiency is in Choosing h = k −1 (ld M − ld ld M ) as in the proof of Theorem 4, this is in

B Experiments
This section provides additional details on the experiments conducted. All experiments are performed on a Spark cluster with a master node, 5 worker nodes, 25 processors and 64GB of RAM per node. The Radon machine is applied with parameter h = 1 and with the maximal h for a given dataset: Recall, that the number of iterations h is limited by the dataset size (i.e., number of instances) and the Radon number of the hypothesis space, since the dataset is partitioned into r h parts of size n. Thus, given a data set of size N , the maximal h is given by where n min denotes the minimum size of the local subset of data that each instance of the base learner is executed on. The experiments have been carried out with n min = 100. As discussed in Section 5, if r h is larger than the actual number of processing units, some instances of the base learner are executed sequentially.
As base learning algorithms we use the WEKA [44] implementation of Stochastic Gradient Descent (WekaSGD), and Logistic Regression (WekaLogReg), as well as a the Scikit-learn [29] implementation of the linear support vector machine (LinearSVM) with pyspark. The paralellisation of a base learner using the Radon machine is denoted PRM(h=?)[<base learner>].
We compare the Radon machine to the natural baseline of aggregating hypotheses by calculating their average, denoted averaging-at-the-end (Avg(h=?)[<base learner>]). Given a parameter h ∈ N, averaging-at-the-end executes the base learning algorithm on r h subsets of the data, i.e., on the same number of subsets as the Radon machine. Accordingly, the runtime for obtaining the set of hypotheses is similar, but the time for aggregating the models is shorter, since averaging is less computationally expensive than calculating the Radon point.
The properties of the datasets used in the empirical evaluation are presented in Table 1. Datasets have been acquired from OpenML [40], the UCI machine learning repository [19], and Big Data competition of the ECDBL'14 workshop 3 . Experiments on moderately sized datasets-on which we compare the Radon machine to the base learning algorithms executed on the entire dataset are conducted  on the datasets click prediction, poker, SUSY, Stagger1, SEA 50, and codrna. The comparison of Radon machine and Spark MLlib learners is executed on the datasets CASP9, HIGGS, wikidata, 20 newsgroups, and SUSY. The regression experiment is conducted using the YearPredictionMSD dataset, multiclass-prediction experiments using the drift, and spoken-arabic-digit datasets.
In the following, we provide more details on the experiments presented in Figures 1(a), 1(b), and 1(c) in Section 4. In particular, we analyse the trade-off between training time and AUC per dataset. Figure 5 shows the trade-off between training time and AUC for base learning algorithms and their parallelisation using the Radon machine. It confirms that the training time for the Radon machine is orders of magnitude smaller than the base learning algorithms on all datasets. Moreover, the training time is substantially smaller for the Radon machine with maximal height (h = max), compared to the parameter h = 1. In terms of AUC, the performance of the parallelisation is comparable to the base learner for WekaLogReg and LinearSVC on all datasets. For the base learner WekaSGD, the predictive performance of the parallelisation with the Radon machine is comparable on all datasets but codrna. There, the Radon machine with parameter h = 1 has substantially lower AUC, while the parallelisation with h = max has substantially higher AUC than the base learning algorithm executed on the entire dataset.
The comparison of the Radon machine to the averaging-at-the-end baseline in Figure 6 confirms the findings of Section 4, i.e., the Radon machine achieves a substantially higher AUC with only slightly higher runtime. Comparing the Radon machine to the Spark MLlib learning algorithms in Figure 7 indicates that the Radon machine is always favourable in terms of training time. However, in terms of AUC the results are mixed: For the base learner WekaLogReg, its parallelisation is always among the best in terms of AUC. The parallelisation of WekaSGD, however, has worse performance than the Spark learners on 2 out of 5 datasets. It also confirms that for the datasets SUSY and HIGGS, the runtime of the Radon machine with h = 1 is substantially larger than for h = max. Thus, for the best performance in terms of runtime and AUC, the height should be maximal.
In order to investigate the results depicted in Figure 7 more closely, we provide the training times and AUCs in detail in Table 2. As mentioned above, the Radon machine using WekaLogReg as base learner has better runtime than all Spark algorithms. At the same time, this version of the Radon machine outperforms the Spark algorithms in terms of AUC on all datasets but 20 newsgroupsthere it is 2.2% worse than the best Spark algorithm. In particular, on the largest dataset in the experiments-the CASP9 dataset with 32 million instances and 631 features-the Radon machine is 15% faster and 2.6% better in terms of AUC than the best Spark algorithm.
Note that for HIGGS and SUSY, the Radon machine with h = 1 is an order of magnitude slower than with h = max as well as the Spark algorithms. This follows from the low degree of parallelisation, since for h = 1 only 20 (for SUSY), respectively 30 (for HIGGS) hypotheses have to be generated. Thus, only 20, or 30 of the 150 available processors are used in parallel. At the same time, the amount of data each processor has to process is orders of magnitude larger than for h = max.
For the above experiments we assume that the data is already distributed over the nodes in the cluster so that it can directly be processed by the Radon machine. When loading data in Spark, this data is distributed over the worker nodes in subsetsbut not necessarily in r h subsets. In Spark, distributed  Table 2: Runtime and AUC of Spark machine learning library algorithms and the Radon machine using WekaSGD and WekaLogReg as base learning algorithms. The results, reported for each dataset, are the average over all folds in a 10-fold cross-validation. These results correspond to the ones presented in Figure 1(c) in Section 4.  Figure 6: AUC vs. training time for the parallelisation of base learning algorithms using the averaging-at-the-end baseline (Avg) and the Radon machine per dataset from the same experiment as in Figure 1 data is organised in partitions, where each partition corresponds to the subset of data available to one instance of the base learning algorithm. In order to apply the Radon machine to a dataset within the Spark framework, the data needs to re-distributed and partitioned into r h partitions which is achieved by a method called repartition. In the experiments in Section 4, we assume that the data is already partitioned to make a fair comparison to the Spark learning algorithms which do not require repartitioning. Figure 8(a) illustrates the time required for repartitioning a dataset in contrast to the runtime of the Radon machine. Repartitioning in Spark always includes a complete shuffling of the data, requiring communication to redistribute the dataset. This is rather inefficient in our context. Nonetheless, the time required for repartitioning is small compared to the overall runtimein the worst case it takes 14% of the runtime of the Radon machine. Still, taking into account the time for repartitioning the data shrinks the runtime advantage of the proposed scheme over the Spark algorithms. Figure 8(b) shows the runtimes of the Spark algorithms compared to the Radon machine-similar to Figure 1(c) in Section 4-but with the time required for repartitioning the data added to the runtime of the Radon machines. The Radon machine with h = max remains superior to the Spark algorithms in terms of runtime.
C Practical Aspects C. 1

Radon Point Construction
In the following, a simple construction is given for a system of linear equations with which a Radon point of a set can be determined. In his main theorem, Radon [30] gives the following construction of a Radon point for a set S = {s 1 , ..., s r } ⊆ R d . Find a non-zero solution λ ∈ R |S| for the Such a solution exists, since |S| > d + 1 implies that S is linearly dependent. Then, let I, J be index sets such that for all i ∈ I : λ i ≥ 0 and for all j ∈ J : λ j < 0. Then a Radon point is defined by where Λ = i∈I λ i = − j∈J λ j . Any solution to this linear system of equations is a Radon point.
The equation system can be solved in time r 3 . By setting the first element of λ to one, we obtain a unique solution of the system of linear equations. Using this solution λ, we define the Radon point of a set S as r(S) = r(λ) in order to resolve ambiguity.
Proof. For consistent empirical risk minimisers with a hypothesis class of finite Rademacher complexity ρ, a given ∆ and N the error bound is given by ε = 2ρ + log 2 1 /δ /2N [43]. Solving for N yields the above result.