Parallelisation of a Common Changepoint Detection Method

In recent years, various means of efficiently detecting changepoints in the univariate setting have been proposed, with one popular approach involving minimising a penalised cost function using dynamic programming. In some situations, these algorithms can have an expected computational cost that is linear in the number of data points; however, the worst case cost remains quadratic. We introduce two means of improving the computational performance of these methods, both based on parallelising the dynamic programming approach. We establish that parallelisation can give substantial computational improvements: in some situations the computational cost decreases roughly quadratically in the number of cores used. These parallel implementations are no longer guaranteed to find the true minimum of the penalised cost; however, we show that they retain the same asymptotic guarantees in terms of their accuracy in estimating the number and location of the changes.


Introduction
The challenge of changepoint detection has received considerable interest in recent years (see, for example, Rigaill et al. (2012), Chen and Nkurunziza (2017) and Truong et al. (2018) and references therein).In particular, there has been a significant focus on the important issue of developing computationally efficient methods to detect multiple changes.This article makes a new contribution to this area by focusing on the problem of parallelising a penalised cost approach to provide a significant computational advantage without compromising on statistical efficiency.
The common changepoint problem setting considers the analysis of a data sequence, y 1 , ..., y n , which is ordered by some index, such as time or position along a chromosome.We use the notation y s:t = (y s , . . ., y t ) for t ≥ s.Our interest is in segmenting the data into consecutive regions; such a segmentation can be defined by the changepoints, 0 = τ 0 < τ 1 < . . .< τ m < τ m+1 = n, where throughout we take m as fixed, but unknown.Thus the set of changepoints splits the data into m + 1 segments, with the j th segment containing data-points y τ j−1 +1:τ j .
Several approaches can be used to identify the locations of these changes.Within this article, we focus on a class of methods which involve finding the set of changepoints that minimise a given cost.The cost associated with a specific segmentation consists of two important specifications.The first of these is C(.), the cost incurred from a segment of the data.Common choices for C(.) include quadratic error loss, Huber loss and the negative log-likelihood (for an appropriate within-segment model for the data); see Yao and Au (1989), Fearnhead and Rigaill (2017) and Chen and Gupta (2000) for further discussion.For example, using quadratic error loss gives: (1) Note that in the case of a piecewise constant signal observed with additive Gaussian noise, (1) is equivalent to twice the negative log-likelihood.The second specification is β, the penalty incurred when introducing a changepoint into the model.Common choices for β include the Akaike Information Criterion, Schwarz Information Criterion and modified Bayesian Information Criterion; see Rigaill et al. (2013), Haynes et al. (2017) and Truong et al. (2017) and references therein for further discussion.Finally, it is assumed that the cost function is additive over segments.The objective is then to find the segmentation which minimises the cost.In other words, we wish to find: arg min Dynamic programming methods exist which are guaranteed to find the global minimum of (2).
Optimal Partitioning, due to Jackson et al. (2005), uses dynamic programming to solve (2) exactly in a computation time of O(n 2 ).Killick et al. (2012) introduce the PELT algorithm, which also solves (2) exactly, and can have a substantially reduced computational cost.In situations where the number of changepoints increases linearly with n, Killick et al. (2012) show that PELT's expected computational cost can be linear in n.However, the worst case cost is still O(n 2 ), suggesting that significant computational savings are still desirable in practice.
Parallel computing techniques are an increasingly popular means of doing precisely this.The application of parallelisation is vast, with use in such areas as meta-heuristics, cloud computing and biomolecular simulation, as discussed in Alba (2005), Mezmaz et al. (2011), Schmid et al. (2012) and Wang and Dunson (2014) among many others.Some methods are more easily parallelisable in that it is plain how to split a search space or other task between different nodes.These problems are often described as 'Embarrassingly Parallel'.For the changepoint detection problem, some existing methods may be described as such.These include Binary Segmentation, due to Scott and Knott (1974), and its related approaches, notably the Wild Binary Segmentation (WBS) method of Fryzlewicz (2014).However, it is not so straightforward to parallelise dynamic programming methods such as PELT.This shall be the focus of this paper.
One of our approaches to parallelising algorithms such as PELT will use the fact that (2) can still be solved exactly when we restrict the changepoints to an ordered subset B = {b 1 , . . ., b k } ⊂ {1, . . ., (n − 1)}.Let F (u) denote the minimum of (2) when we restrict changepoints to B and consider data only up to time u; in addition let (τ 1 , . . ., τ m ) be an ordered set of (estimated) changepoints, so that, for t < s: Using the initial condition F (0) = 0, this gives a means of recursively calculating F (b k ).
The general format of this paper is as follows: Section 2 introduces two means of parallelising dynamic programming methods for solving (2), which we refer to as Chunk and Deal.In each case, we provide a description of the proposed algorithm with practical suggestions for implementation, followed by a short discussion of the theoretical justifications behind these choices.We devote Section 3 to examining this latter aspect in detail.In particular, we establish the asymptotic consistency of Chunk and Deal in a specific case with recourse to the asymptotic consistency of the penalised cost function method.Section 4 compares the use of parallelisation to other common approaches in a number of scenarios involving changes in mean.We conclude with a short discussion in Section 5.The proofs of all results may be found in the appendices and supplementary materials.

Parallelisation of Dynamic Programming Methods
In this section, we introduce Chunk and Deal, two methods for parallelising dynamic programming procedures for changepoint detection.For convenience, we shall herein refer to this exclusively as the parallelisation of PELT.
We introduce the notation P ELT (y A , B) when referring to applying PELT to a dataset y A but only allowing candidate changepoints to be fitted from within the set B. Note that we trivially require B ⊆ A. The general setup for the parallelisation procedure then takes the following form: • (Split Phase) We divide the space {1, . . ., (n − 1)} into (not necessarily disjoint) subsets B 1 , . . ., B L(n) , where L(n) is the number of computer cores available; • Each of the cores i = 1, . . ., L(n) then performs P ELT (y A i , B i ), returning a candidate set, τi , of changes, which are returned to the parent core; • (Merge Phase) The parent core then performs P ELT (y 1:n , ∪ L(n) i=1 τi ), and the method returns τ , the set of estimated changes found at this stage.
Note that in the above we require ∪

Chunk
The Chunk procedure consists of dividing the data into continuous segments and then handing each core a separate segment on which to search for changes.This splitting mechanism is shown in Figure 1.One problem with this division arises from changes which can be arbitrarily close to, or coincide with, the 'boundary points' of adjacent cores.This necessitates the use of an overlap -a set of points which are considered by both adjacent cores for potential changes, also shown in Figure 1.For a time series of length n, we choose an overlap of size V (n) either side of the boundary for each core.The full procedure for Chunk is detailed in Algorithm 1. with 5 cores (l).An overlap is specified between the segments such that points within are considered by both adjacent cores (r).
Step 1: Split the dataset into the subsets B 1 , . . ., B L(n) such that i=1 τi into ascending order; Step 3: Calculate and return (τ 1 , . . ., τ m) = P ELT y 1:n , ∪ Algorithm 1: Chunk for the PELT procedure Given that Algorithm 1 executes PELT multiple times, it is not immediate that Chunk represents a computational gain.We therefore briefly examine the speed of the procedure from an intuitive perspective.Taking the worst case computational cost of PELT to be O(|B| 2 ), where B is the candidate set of changepoints, then the worst case cost of the split phase will be The cost of the merge phase is dependent on the total number of estimated changes generated in the split phase.If we can estimate changepoint locations to sufficient accuracy, then as each change appears in at most two of the 'chunks', the number of returned changes ought to be at most 2m.
Thus the merge phase has a cost that is O(m 2 ).This intuition is confirmed later, in Corollary 3.3.1.
In order to guarantee that the method does not overestimate the number of changes, some knowledge of the location error inherent in the PELT procedure is needed.This motivates the results of Section 3, which in turn imply various practical choices for the length of the overlap region, V (n).
In particular, using V (n) = (log n) 2 will give an effective guarantee of the accuracy of the method.
Other sensible choices for V (n) can be made based on the trade-off between accuracy and speed (see Section 3 for details).

Deal
The Deal procedure relies on distributing points to the computing cores in the same manner as a playing card dealer.Define Q a (b, c) as the largest integer such that Q a (b, c) × b + (a mod b) < c.
The split phase then partitions {1, . . ., (n − 1)} as follows: This splitting mechanism is shown in Figure 2. On the k th core, the objective function to be minimised then becomes: as discussed in Section 1.The full procedure for Deal is detailed in Algorithm 2. Data: A univariate dataset, y 1:n .
Step 1: Split the dataset into subsets B 1 , . . ., B L(n) such that i=1 τi into ascending order; Step 3: Calculate and return (τ 1 , . . ., Algorithm 2: Deal for the PELT procedure As for the Chunk procedure, the implementation of Deal leads to computational gains.By the previous section, the worst case computational time of the split phase of Deal will be The speed of the merge phase is again dependent on the number of changes detected at the split phase.We demonstrate in the proof of Corollary 3.3.1 that the number of changes detected by each core is at most 2m, meaning that the worst case performance of the merge phase is O L(n) 2 .
For both procedures, using the standard SIC penalty gives a maximum location error of O(log n) in the asymptotic setting, see Theorems 3.2 and 3.3 for details.With the Deal procedure, however, an additional lower bound constraint is enforced on the number of cores required for this location error (see Theorem 3.3); we therefore recommend setting L(n) to be as large as the number of cores available in most practical settings.
We remark that while the Chunk and Deal procedures do not inherit the exactness of PELT in finding the optimal solution to (2), they nevertheless track the true optimum very closely, as seen by the empirical results in Section 4.

Consistency of Parallelised Approaches
As exactness with respect to minimising (2) cannot be assumed for the two methods, we must verify that they retain the desirable properties of PELT.To this end, we now turn to consider the consistency of the parallel procedures for a change in mean setting.
We now stipulate that a time series y 1 , ..., y n has changepoints corresponding to proportions θ 1 , ..., θ m , for some fixed m, such that, for a given n, the changepoints τ 1 , ..., τ m are defined as τ i = θ i n ∀i.
For the asymptotic setting we consider, take θ 1:m to be fixed.
With this framework in place, we note that the consistency results for Chunk and Deal we develop in Section 3.1 require one particular result not provided by Killick et al. (2012), namely consistency of PELT for the change in mean setting.
This result also extends naturally to the multivariate setting, with a penalty of (d + 1) (1 + ) log n (see Section B of the Supplementary Materials for details).For the univariate case, the proof of Proposition 3.1 follows a similar pattern to that of Yao (1988), though we relax Yao's condition that an upper bound on the estimated number of changes is specified a priori.

Consistency and Computational Cost of Chunk and Deal
We now extend the consistency result in the unparallelised setting to obtain equivalent results for Chunk and Deal.These results not only give a bound on the maximum location error of an estimated changepoint, but also provide some insight into the best setting of, for instance, L(n) and V (n), which we can use in turn to provide a theoretical result on the computational power of the new methods.
Theorem 3.2.For the change in mean setting specified in (3), assume that for a data series of length n we have L(n) cores across which to parallelise a changepoint detection procedure.Defining E α n as for the previous results for any α > 0, then additionally assuming that L(n) = o(n) with L(n) → ∞ gives that, under the Chunk procedure for parallelising a procedure which minimises least squared error under a penalty of β = (2 + ) log n, P(E α n ) → 1 as n → ∞.
Proof : See Appendix.
Note that the definition of the event E α n is as for Proposition 3.1, meaning that the maximum asymptotic location error under the Chunk procedure is O(log n).This error suggests that we can choose V (n) to be small compared to n L(n) , the number of data points on a core.For instance, setting V (n) = (log n) 2 ensures accuracy in probability for large n with negligible computational impact relative to V (n) = (log n) .
In addition, we remark that the conditions on L(n) for Chunk are relatively weak, and are in place to avoid segments of fixed size for n → ∞.For most practical values of n, we advise setting L(n) such that the length of the segments is at least 2V (n) to avoid intersecting overlaps.
Theorem 3.3.The same result as for Theorem 3.2 holds with the Deal parallelisation procedure, assuming in addition that L(n) ≥ (log n) 1+α .
Proof : See Appendix.
Note that the conditions on L(n) are stronger for Deal than for Chunk, with a lower bound corresponding with the maximum location error inherent in the event E α n .We believe the constraint on L(n) is an artefact of the proof technique.Intuitively we would expect the statistical accuracy of Deal to be larger for smaller L(n); as, for example, L(n) = 1 corresponds to optimally minimising the cost.Practically, setting L(n) = (log n) is unlikely to be problematic for typical values of n, a notion which we confirm empirically in Section 4.
Finally, given these results, we are now in a position to give a formal statement on the worst case computational cost for both Chunk and Deal, when the computational cost of setting up a parallel environment is assumed to be negligible.
Corollary 3.3.1.Under the change in mean setting outlined in Proposition 3.1, with probability tending to 1 as n → ∞, the computational cost for Chunk when parallelising the PELT procedure , while for Deal the cost is , compared to a cost of O(n 2 ) for unparallelised PELT.
Proof : See Appendix.
We remark that setting L(n) ∼ n 1 2 in Corollary 3.3.1 guarantees a worst case computational cost of O(n) for both Chunk and Deal, no matter the performance of PELT.In addition, we note that we achieve a computational gain which is quadratic with L(n) in the best case.We emphasise again that this result ignores the cost of setting up a parallel environment, which can lead to PELT performing better computationally for small n.Therefore, we now conduct a simulation study in order to understand the likely practical circumstances in which parallelisation is a more efficient option.

Simulations
We now turn to consider the performance of these parallelised approximate methods on simulated data.
While these suggested parallelisation techniques do speed up the implementation of the dynamic programming procedure underlying, say, PELT, the exactness of PELT in resolving (2) is no longer guaranteed.We therefore compare parallelised PELT with Wild Binary Segmentation (WBS), proposed by Fryzlewicz (2014), a non-exact changepoint method which has impressive computational speed.
Simulated time series with piecewise normal segments were generated.Five scenarios, with changes at particular proportions of the time series, were examined in detail in the study.For a time series length of 100000, these scenarios are shown in Figure 3.
Different lengths of series for each of the five scenarios, keeping the proportionate change sets the same, were used to examine the statistical power of PELT, Chunk, Deal and WBS under a number of replications for the error terms (n = 200 in all cases).In addition, four change magnitudes (0.25, 0.5, 1 and 2) were used to examine the behaviour of the algorithms in each of the scenarios as ∆µ was increased.
The number of false positives (which were counted as the number of estimated changes more than log n points from the closest true change) and missed changes (the number of true changes with no estimated change within log n points), as well as the maximum observed location error and average location error across all repetitions were measured.Finally, the average cost of the segmentations (using mean squared error) generated by the methods relative to the optimal given by PELT were recorded.
As can be seen from Tables 1 -3, Chunk and Deal closely mirror PELT in statistical performance in finding approximately the same number of changes in broadly similar locations.The performance of WBS was generally worse across these measures, although WBS did mirror PELT moderately closely and did occasionally perform better, particularly in certain scenarios for average location error.However, as the number of changes was increased, WBS was generally outperformed by both Chunk and Deal.
From Table 4, we note that, in practice, Deal often outperforms Chunk in terms of computational speed for a given number of cores.This is due to the fact that the Deal procedure will rarely perform at the worst case computational speed during the split phase (which typically dominates the computation time), as one of the candidates around a true change is very likely to be chosen as a candidate changepoint (see the proof of Theorem 3.3).This means that more candidates for the most recent changepoint are pruned than for Chunk.PELT was observed to be the fastest method for the smallest value of n across all scenarios.It was at the larger values of n where the quadratic gains in speed of Chunk and Deal became apparent, as can also be seen in Figure 4, which shows the relative computational gain for Scenario C when ∆µ = 1 and n = 100000 across multiple different values of L(n).

Discussion
We have proposed two new methods for changepoint detection, Chunk and Deal, each based on parallelising an existing method, PELT.These methods represent a substantial computational gain in many cases, particularly for large n.In addition, by establishing the asymptotic consistency of PELT, we have been able in turn to show the asymptotic consistency of the Chunk and Deal methods, such that the error inherent to all three is O (log n) in terms of the maximum location error of an estimated change relative to the corresponding true change.
We have demonstrated empirically that an implication of this is that Chunk and Deal, while not inheriting the exactness of PELT, do perform well in finding changes in practice.

Acknowledgments
Tickle is grateful for the support of the EPSRC (grant number EP/L015692/1).The authors also acknowledge British Telecommunications plc (BT) for financial support, and are grateful to Kjeld Jensen and Dave Yearling in BT Research & Innovation for helpful discussions.

Appendix
The following results will be stated with respect to a general α > 0. Theoretically, this means that any α > 0 can be used in Algorithm 1 or Algorithm 2, however in the simulation study detailed in Section 4, (log n) 2 was used as the overlap length (for Chunk), while the cutoff value for closeness Table 5: The average cost, calculated using the log likelihood of the segments, resulting from executing each procedure.This is adjusted according to the equivalent cost computed by PELT (which is optimal).detailed in the merge phase (Step 3) of both procedures was taken as (log n) .
Proof of Theorem 3.2: It is necessary to establish that: (I): Each change is detected by the core in which it is present.
(II): At the merge phase, only one estimated change per core is kept.
Proof of (I): Thus, the Chunk procedure will inherit the asymptotic consistency of the base procedure providing no change consistently falls arbitrarily close to the boundary between two cores.In which case, for V (n) = (log n) 1+α , the segment length would be reduced from O(n) to O (log n) 1+α (although the smallest possible segment length is (log n) 1+α ).As such a segment length violates the condition on fixed values for θ i = τ i n outlined in Section 3, it is therefore necessary to establish that a true change positioned at a point within (log n) 1+α of either the beginning or the end of the series will be detected with probability 1 as n → ∞.It is sufficient to extend Corollary A.2.1 (see Section A of the Supplementary Materials) to the case where the first true change is at location (log n) 1+α .However, as the minimum segment length is at least O(n), then by the argument of the proof of Corollary A.2.1 each changepoint is detected by at least one core to which it is given in probability for increasing n.Formally, one can consider the difference: Diff : = RSS(y 1:n ; τ1: m) − RSS y 1:n ; τ 1 + (log n) 1+α , τ 2:m , τ1: m , and it can be shown that Diff = O((log n) 1+α ).In particular, Diff > 2m log n, so the Chunk procedure will detect a change at the boundary with a segment length of (log n) 1+α .

Proof of (II):
We examine all segmentations, τ1:m , such that |τ i − τ i | ≤ K log log n, for fixed With recourse once more to the result of Laurent and Massart (2000) (see equation ( 6) in Section A of the Supplementary Materials for the general result), if U ∼ χ 2 m+1 then: for any δ > 0, providing that log log n > m+1 2d .As there are (2K log log n) m possibilities for the segmentation τ1:m , then uniformly across all segmentations, taking d = 2m for example, gives that the difference in the residual sum of squares is uniformly o p (log n).Now from the proof of Proposition 3.1 (see Section B of the Supplementary Materials) we know that in probability any segmentation with more than m changes will have a greater cost than the true segmentation if a penalty of 2 (1 + /2) log n is used.Therefore, across all segmentations under consideration here, the cost is at least /2 log n greater than the cost of the true segmentation if a penalty of 2 (1 + ) log n is used.
Proof of Theorem 3.3: Recall that L(n) ≥ (log n) 1+α and L(n) = o(n).The idea will be to show that the core which is 'dealt' a particular true change, τ i , will always return this true change as a candidate changepoint for the merge phase.By Yao (1988), letting τ1:m be a set of estimated changes which miss the true change τ i by at least (log n) 1+α , then again by the proof of Corollary A.2.1 the cost of this segmentation is strictly worse than the cost of also fitting changes at the points τ i − L(n) and τ i + L(n).By then considering the difference: in a similar fashion to the proof of Corollary A.2.1, it can be shown that in probability: where again ∆µ i−1 is the absolute change in mean at the changepoint τ i .
Proof of Corollary 3.3.1:It is sufficient to prove the following Claim regarding the number of candidate changes each core returns.
Note that this argument does not consider segmentations which do not contain S 2 as a proper subset.In order to extend this argument, we define the following three sets of segmentations (with respect to a given core): Note that S 2 ∈ GS 2 and that the argument showing that any segmentation S 3 containing S 2 is rejected uniformly in favour of S 2 may be extended to any element of GS 2 to show that any segmentation with more than 2m estimated changes in total and which has at least two estimated changes between each true change is uniformly dominated by a corresponding element of GS 2 .
In the same way, let us now consider extensions from a general element, T 1 ∈ GS 1 , where here an extension is defined as a superset of T 1 which also contains additional estimated changes from regions between two estimated changes within T 1 not containing a true change.Letting, for example: 1 , ..., s i−1 , s i , s for some k ∈ {1, 2} and i ∈ {1, ..., m}.Then any extensions of T 1 consists of placing any further estimated changes in any of the regions between the changes above with the exception of either (if . Let T 1 be an arbitrary such extension, and again let A be any region between two consecutive points of T 1 which contains a point found only in T 1 .As before, uniformly across such regions, and supposing again that k > 0 such estimated changes are found within A, letting: Diff := RSS(y A ; T 1 ) − RSS(y A ; T 1 ), then again Diff is distributed as χ 2 k+1 .With recourse to the same argument as before (noting again that any such region A will have at most ñ = n L(n) candidate points for the extension -no matter which base element of GS 1 we pick), and extending to other elements of GS 1 , we conclude that any segmentation with more than 2m estimated changes which places just one estimated change between two true changes in at least one case will be rejected uniformly (and for all cores) in favour of an element of GS 1 .
Finally, we consider all segmentations with more than 2m changes which place no estimated changes between two true changes in at least one case.We again compare with T 0 ∈ GS 0 .Letting, for example: 2 , . . ., s i−1 , s (1) i+1 , . . ., s (2) m , for some i ∈ {1, . . ., m}.Then any extensions of T 0 consists of placing any further estimated changes in any of the regions between the changes above with the exception of the region s (2) i−1 , s i+1 .Let T 0 be an arbitrary such extension, and again let A be any region between two consecutive points of T 0 which contains a point found only in T 0 .Then again letting: Diff := RSS(y A ; T 0 ) − RSS(y A ; T 0 ), then for k > 0 changes in the region A, Diff is distributed as χ 2 k+1 .We can again extend this argument to extensions of other elements of GS 0 to conclude that segmentations with more than 2m changes which have no estimated changepoints between two consecutive true changes in at least one case will be uniformly rejected in favour of an element of GS 0 .Therefore, as any segmentation with more than 2m changes for any core is an extension of an element of GS 0 , GS 1 or GS 2 (as such a segmentation must contain a region between two consecutive true changes with at least three estimated changes), then across all cores, a segmentation must be picked from within one of the classes GS 0 , GS 1 or GS 2 in probability.Thus, the maximum number of estimated changepoints that a core can return in the Deal procedure is 2m.
The number of candidates returned for the merge phase of the Deal procedure is therefore bounded in probability by 2mL(n), so that the maximum computation time of the merge phase is O (L(n)) 2 in the worst case, giving the total worst case computation time for the whole procedure.This establishes the required results for both regions of type B i and L i (R i ) by substituting ñ = λn, λ ≤ 1 and ñ = (log n) 1+α (for α < 1 to obtain the constant 4 in the two initial statements) respectively.
Proof of (b): Now have that m < m.For n sufficiently large, it is guaranteed that there is at least one true change (which shall be labelled τ ) such that the closest estimated change is at least (log n) 1+α time points away.Thus, by the proof of Corollary A.2.1, given that a change has been missed by this error, adding in estimated changes to the model at the points τ − (log n) 1+α , τ , τ + (log n) 1+α gives that the reduction in the RSS is greater than the incurred penalty for adding 3 changes.Thus, the original segmentation was not optimal.

Figure 1 :
Figure 1: The time series is split into continuous segments by the Chunk procedure, in this case

Figure 2 :
Figure 2: Points coloured differently are processed by different cores.In the above case 5 cores are used.A core may fit changes only in locations of a given colour.

Figure 3 :
Figure 3: Five scenarios under examination in the simulation study.Clockwise from top left are scenarios A, B, C, E and D with 2, 3, 6, 14 and 9 changes respectively.

Finally
, from Table 5, both Chunk and Deal are seen to track PELT very closely in terms of the final cost of the model.In particular, Deal seems to perform well for smaller values of ∆µ, while Chunk in general appears to find solutions of a very similar global cost to the PELT algorithm for larger ∆µ.Caution should be exercised, however, as only the value of L(n) = 4 was tested.

Figure 4 :
Figure 4: Relative computational gain for Chunk and Deal across a differing number of cores under Scenario C with ∆µ = 1 and n = 100000.The line y = x is shown for comparison, demonstrating the super-linear computational gain.

Table 1 :
The average number of false alarms recorded across all 200 repetitions for each of the 5

Table 3 :
The average location error between those true changes which were detected by the algorithms and the corresponding estimated change across all 200 repetitions for each of the 5 scenarios.

Table 4 :
The average relative computational speed of the Chunk and Deal procedures compared to PELT using 4 cores.