# Implicit Directed Acyclic Graphs (DAGs) for Parallel Outlier/Anomaly Detection Ensembles

David Muhr, Michael Affenzeller, Josef Küng

► To cite this version:

David Muhr, Michael Affenzeller, Josef Küng. Implicit Directed Acyclic Graphs (DAGs) for Parallel Outlier/Anomaly Detection Ensembles. 19th IFIP International Conference on Artificial Intelligence Applications and Innovations (AIAI), Jun 2023, León, Spain. pp.3-15, 10.1007/978-3-031-34107-6_1 . hal-05498056

HAL Id: hal-05498056

https://inria.hal.science/hal-05498056v1

Submitted on 6 Feb 2026

**HAL** is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
<figure><img src="image_2.png" /></figure>

ifip

International Federation for Information Processing

This document is the original author manuscript of a paper submitted to an IFIP
conference proceedings or other IFIP publication by Springer Nature. As such, there
may be some differences in the official published version of the paper. Such
differences, if any, are usually due to reformatting during preparation for publication or
minor corrections made by the author(s) during final proofreading of the publication
manuscript.
# Implicit Directed Acyclic Graphs (DAGs) for Parallel Outlier/Anomaly Detection Ensembles

David Muhr<sup>1,2(✉)</sup> ID, Michael Affenzeller<sup>2,4 ID</sup>, and Josef Küng<sup>3 ID</sup>

¹ BMW Group, Steyr, Austria
david.muhr@bmw.com

² Institute for Formal Models and Verification, JKU Linz, Linz, Austria

³ Institute for Application-oriented Knowledge Processing, JKU Linz, Linz, Austria

⁴ Heuristic and Evolutionary Algorithms Laboratory, UAS Hagenberg,
Hagenberg, Austria

**Abstract.** We present a methodology to automatically parallelize out-lier detection ensemble models using directed acyclic graphs embedding the MapReduce paradigm. The DAGs are built implicitly such that naive sequential computations can be transformed into efficient parallel compu-tations without changing the underlying implementation. We show that the proposed parallelization approach is an effective strategy to com-bat the computational complexity inherent to ensemble learning models, leading to a near-optimal speedup in a theoretical setting, and a substantial speedup in a practical setting.

**Keywords:** outlier detection · anomaly detection · ensemble learning

## 1 Introduction

The key motivation behind ensemble learning is that a combination of individ-ual judgments improve upon a single judgment in terms of bias and/or variance. The effectiveness of ensemble models for outlier detection has repeatedly been shown in the literature [3, 4, 32, 40], yet little research addresses the paralleliza-tion problem of outlier ensembles. The computational complexity inherent to ensemble models limits the acceptance and usage of this kind of models and, as a result, the progress in this promising area of research. To tackle this challenge, we propose an abstraction of outlier ensembles in the form of implicitly gen-erated DAGs, drastically simplifying the definition of highly parallel ensembles without additional implementation effort.

Ensemble models for classification and regression have been extensively stud-ied for decades. Breiman [10] famously described a parallel ensemble known as bagging, which consists of multiple models trained on subsamples of the data using a plurality vote to classify the data. It has been shown that bagging reduces the variance of a predictor by equalizing the influence of individual training examples [13,23]. Other ensemble methods, collectively known as boosting [21], aim to reduce the bias of weak predictors by iteratively combining them to a
weighted ensemble. In contrast to classification and regression, ensemble learning for outlier detection has been neglected for a long time [39]. Outlier detection is the process of identifying observations that deviate from the remaining data, which is sometimes also referred to as anomaly detection or novelty detection. An outlier is (vaguely) described as “an observation (or subset of observations) which appears to be inconsistent with the remainder of that set of data” [7]. Outliers are infrequent by definition; thus, labels are often infeasible to obtain, and the ground truth is typically missing in outlier detection tasks. Outlier detection is mainly used in fields that process large amounts of unlabeled data, such as network intrusion detection, fraud detection, medical diagnostics, or industrial quality control, which further exacerbates the challenges regarding computational complexity in outlier ensembles. Aggarwal [2] differentiates between sequential and independent ensembles. Sequential ensembles are sequentially applied algorithms such that the previous applications impact the future application of the algorithms, as in boosting. Independent ensembles use different instantiations of algorithms or data, which are independent of the results obtained from mutual instantiations as, for example, in bagging. Sequential ensemble techniques are difficult to employ for outlier detection tasks because of the missing ground truth; therefore, outlier ensembles predominantly consist of independent, unsupervised approaches [4]. Consequently, we focus our work on independent ensembles and structure our work as follows. In Sect. 2, we categorize and differentiate ensemble learning approaches for outlier detection and review the current state of the art. In Sect. 3, we show how complex ensemble models can be modeled as implicitly generated DAGs. In Sect. 4, we show how the implicitly generated DAGs can efficiently be parallelized by embedding MapReduce. In Sect. 5, we show how our proposed method improves outlier detection ensembles in theoretical and practical settings. Finally, in Sect. 6, we summarize our contributions and propose research areas for future works.

## 2 Types of Outlier Ensembles

In a similar vein to the ensemble learning categorization efforts of Aggarwal [2] or Sagi and Rokach [34], we differentiate between the following strategies to induce diversity in the ensemble learning process.

**Transformation and embedding.** Each model in the ensemble is learned using a transformed version of the input data such that a variety of inputs are used for the different models. A transformation of the input data can be achieved by using different data augmentations such as CutPaste [28] or using different feature embeddings as in PatchCore ensembles [5].

**Subspacing and subsampling.** In this category of methods, different samples of the data are utilized to build an ensemble. This general idea has been explored from various angles, such as learning models from subsamples of the data, as in bagging [10], learning models from different subspaces, as in feature bagging [27], or learning models from a partitioning of the data, as in divide and conquer detection [32].
**Model adaptation.** Ensembles using model adaptation combine entirely different outlier detection models, randomized versions of the same model, or the same model over different choices of parameters. Isolation methods, for example, build an ensemble of tree-based [29] or hypersphere-based [6] detectors to determine the outlierness of an instance.

The unifying aspect of the categories above is that all of them yield multiple outlier detection models as a result of the training process. An outlier detection model is typically formalized as a scoring function $q: \mathcal{M} \to \mathbb{R}$ on a metric space $\mathcal{M}$, which assigns a real-valued *outlier score* or simply *score* to each sample. A question arising in the context of outlier detection ensemble learning is: How can the scores from the models in the ensemble be combined? To answer that question, there are two major issues that need to be solved, namely, score normalization and score combination [2]. Normalization addresses the problem that different models may output scores that are not directly comparable. For example, a distance-based method might output some form of distance as an outlier score while a probabilistic method might use a negative log-likelihood estimate as a measure of outlierness. The simplest way of bringing outlier scores to a common scale is to apply a linear transformation such that the minimum score is mapped to 0 and the maximum score is mapped to 1. [22] propose an expectation maximization approach to learn the parameters of a sigmoid calibration function or mixture model to convert the outlier scores to probability estimates. [26] point out that the expectation maximization models often converge to a “no outliers” or “all outlier” model and propose instead to use a Gaussian or Gamma distribution instead to transform the scores. [35] note that “a key for building good ensembles is to use ensemble members that make uncorrelated errors”, proposing that the *selection* of ensemble members can be an important additional step. Ensemble model selection, however, is often missing in ensemble research and would greatly benefit from reduced processing time and parallelization.

The normalized scores of the models in the ensemble finally have to be combined to a single outlier score for the ensemble. The commonly used strategies to combine normalized scores is to average the scores or take the maximum of scores for a specific sample [3]. Aggarwal and Sathe [3] further propose to combine the average and maximum to counter their individual drawbacks, which appears to be useful for very large ensembles. Other authors [27] propose to discard the scores entirely and use the maximum ranks instead.

In summary, an (independent) outlier ensemble can be formulated as a process of diversification, normalization and combination as shown in Fig. 1.

## 3 Ensembles as DAGs

We formalize outlier detection ensemble models as directed acyclic graphs and show that this specification brings several advantages for such models. The composition of machine learning models as graphs has already been described in machine learning toolboxes [8], outlier detection frameworks [31], automated machine learning [24] or federated machine learning [30]. Following [8], we define a node in the
<figure><img src="image_3.png" /><figcaption>**Fig. 1.** Generic outlier detection ensemble model, where the abstract input is diversified into a set of individual outlier detection models $M_1, \dots, M_n$, that are processed using normalization functions $N_1, \dots, N_n$ to a final model $M_{final}$.</figcaption></figure>

graph as a lazily evaluated expression $f$ with optional input arguments. Each node in the graph is assigned a unique name. We denote a hypothetical node $a$ in the graph as $f_a()$ or short $f_a$, where $()$ indicates that the node $a$ does not have any input arguments. An edge in a graph describes a directed dependency, such that the evaluation of an unnamed node $f(f_1, \dots, f_n)$ with arguments $f_1, \dots, f_n$ defines the directed dependencies from $f$ to $f_1, \dots, f_n$ and requires an evaluation of the dependencies before $f$ can be evaluated. Using this formalization, we can infer the underlying computational graph $G$ with no explicit definition of the graph structure. The described specification, by definition, leads to a directed graph, but, because a node depends on the evaluation of its dependencies, there must not be any circular dependencies. For example, if a node $a$ depends on $b$, then the node $b$ cannot depend on $a$ because those dependencies could not be resolved. We define a dependency chain as a walk on the graph such that the walk $(a \to b \to c)$ describes a dependency chain, whereby $c$ depends on $b$, and $b$ depends on $a$. To ensure that no circular dependencies exist in the specified graph, we require that there exists no walk that begins and ends with the same node. For instance, the graph implicitly determined by a set of nodes $G(\{f_a(f_c), f_b(f_a), f_c(f_b)\})$ would not be valid, because the inferred walk $(a \to b \to c \to a)$ begins with $a$ and ends with $a$ and, therefore, is not acyclic. Using the introduced formalization, we can provide a concrete example of a feature bagging ensemble. For a detailed definition of the individual steps of the feature bagging approach, we refer to [27]. Also note that the decision as to what defines a node in the graph is given by a specified set of interrelated functions, which implicitly determine the granularity at which to exploit the concurrency. The granularity refers to the amount of work associated with a node in the graph and leads to a trade-off between many nodes with high overhead or fewer nodes with decreased load balance [16].

$$G(\{f_{\text{data}}, f_{\text{subspace}}(f_{\text{data}}), f_{\text{model}}(f_{\text{subspace}}), f_{\text{combine}}(f_{\text{model}})\}) \quad (1)$$
In this case, the implicit graph is a simple walk of (data → subspace → model → combine) and the graph contains no branches, which is sometimes referred to as a pipeline [33]. Note that it is only possible to determine a *static* graph implicitly. In the feature bagging example of definition 1, we do not necessarily know how many subspaces are generated from the data, because the determination of the number of subspaces could depend on the dimensionality of the data, which is only known after $f_{data}$ is evaluated and, hence, leads to a *dynamic* graph. Alternatively, we can define a fully static feature bagging ensemble with a fixed number of three rounds as follows.

$$G(\{f_{\text{data}}, f_{\text{subspace}_1}(f_{\text{data}}), f_{\text{subspace}_2}(f_{\text{data}}), f_{\text{subspace}_3}(f_{\text{data}}), f_{\text{model}_1}(f_{\text{subspace}_1}), f_{\text{model}_2}(f_{\text{subspace}_2}), f_{\text{model}_3}(f_{\text{subspace}_3}), f_{\text{combine}}(f_{\text{model}_1}, f_{\text{model}_2}, f_{\text{model}_3})\}) \quad (2)$$

Because the graph is directed and acyclic, it is possible to generate a topological ordering of the graph, which, in this example, is unique, but this does not have to be the case. The underlying ordered graph is depicted in Fig. 2.

<figure><img src="image_4.png" /><figcaption>**Fig. 2.** Topologically ordered feature bagging graph where the data is denoted by d, the subspaces by $s_1, s_2, s_3$, the models by $m_1, m_2, m_3$ combined by c.</figcaption></figure>

Formally, for a DAG with nodes $v_1, v_2, \dots, v_n$, a topological ordering describes linear ordering of its nodes such that, for every edge $(v_i, v_j)$, it holds that $i < j$. It can be proven that, if a graph has a topological ordering, then the graph is a DAG and vice versa [25]. In the following section, we will discuss how such a topological ordering can be used to parallelize DAGs.

# 4 Parallelization of DAGs

As apparent from the feature bagging example with a fixed number of rounds, a topological ordering can result in a number of nodes that do not depend on
each other and may be parallelized, such as the nodes $s_1, s_2, s_3$ and $m_1, m_2, m_3$ in Fig. 2. We say that a topological ordering results in a number of topological generations, sometimes called levels, such that each descendant of a node is guaranteed to be in a following generation. Each node in a generation can be executed in parallel, because it is guaranteed that all dependencies have already been resolved in the previous generation. Schedulers may not parallelize entire generations, but schedule individual nodes that are ready, meaning that all dependencies are resolved for the specific node, for example, based on a first-in first-out queue. Scheduling computational DAGs has been extensively explored in multiprocessor scheduling [17, 19] and cloud workflow scheduling [1, 15, 38]. The scheduler can follow different goals depending on the application, see [1] for an extensive overview of scheduling objectives. In our theoretical and practical analysis in Sect. 5, we focus on the makespan objective, which reflects the total execution time of the DAG. Parallelization of DAGs leads to multiple challenges: (1) a scheduler may not have knowledge of the entire DAG beforehand, thus, it has to learn about the structure of the DAG online and use dynamic scheduling [9], (2) the individual nodes in the DAG vary in their computational and resource requirements leading to resource scheduling challenges [38], and (3) the graph structure can result in deeply nested parallel workloads, leading to bad timing behavior [37]. Due to stated scheduling challenges and the highly complex and heterogeneous workloads in ensemble learning, we propose to embed a MapReduce [18] workflow in the DAG to enable more fine-grained resource and workflow scheduling. The success of MapReduce has shown that a simple processing model can be beneficial even for complex tasks. Conceptually, the map and reduce functions have associated types as follows

$$ \mathbf{map} (k, v) \rightarrow \text{list}(k', v') \\ \mathbf{reduce} (k', \text{list}(v')) \rightarrow \text{list}(v'), \qquad (3) $$

where the input keys $k$ and values $v$ are drawn from a different domain than the output keys $k'$ and values $v'$ [18]. Embedding MapReduce in a DAG allows the DAG to be statically defined and the dynamic portions of the DAG can be efficiently handled by MapReduce. The high-level query languages for MapReduce extend the original processing model [36], however, Fegaras [20] shows that a simple algebra underlies those so-called data-intensive computing environments [12]. Using the previously declared feature bagging ensemble, Fig. 3 shows the static DAG with embedded MapReduce edges. To embed MapReduce in a statically determined DAG, we annotate dynamic edges of the graph as map or reduce edges. We can then define the total amount of work of a DAG $T$ as the sum of work of the static nodes $w^{(\text{static})}$ plus the sum of work of the dynamic nodes $w^{(\text{dynamic})}$ times the extent of their dynamic edges $s$.

$$ T = \sum_{i=1}^{n} w_{i}^{(\text{static})} + \sum_{k=1}^{m} s_{k} \cdot w_{k}^{(\text{dynamic})}, \qquad (4) $$

where $n$ is the number of static nodes and $m$ is the number of dynamic nodes. The work required to compute a node is also referred to as a node's
<figure><img src="image_5.png" /><figcaption>**Fig. 3.** The feature bagging graph where the data is denoted by *d*, the variable number of subspaces by *s*, the corresponding number of models by *m* which are combined by *c*. The map edge denotes a mapping step, such that each subspace *s* yields a model *m*. The reduce edge, in this case, consists of a single reducer.</figcaption></figure>

*weight*. In terms of parallelization, we further differentiate between static and dynamic parallelization as visible in Fig. 4. The optimal level of parallelism can be defined as $T/L$, where *L* is the total work of the nodes in the critical path. For the example in Fig. 4, if we assume that each node’s weight is equal to one, the critical path’s total work is *L* = 5, the total work is *T* = 11, and the optimal level of parallelism for this DAG is $T/L$ = 2.2, which is also referred to as the optimal speedup or average parallelism under infinite resources [16].

<figure><img src="image_6.png" /><figcaption>**Fig. 4.** Static and dynamic parallelization of MapReduce DAGs.</figcaption></figure>

We do not prescribe a specific computational backend for the generated MapReduce DAGs; instead, we allow any computational backend representable by the algebra defined in [20]. The algebra is based on the concept of a *monoid* in abstract algebra, and the authors show that a small number of operations based on collection monoids are a good basis for various computational back-ends. For a collection monoid $⊕$ and a collection monoid $⊗$, the partial order $⊗ \preceq ⊕$ indicates that $⊕$ obeys all the laws of $⊗$. For example, using the Boom Hierarchy [14], it can be seen that list-concat $\preceq$ set-concat since set-concat is commutative, while list-concat is not. The MapReduce paradigm in definition 3 can be implemented using two of the operations of the collection monoid algebra described in [20], namely *concat-map* and *group-by*. The concat-map function
embodies the concept of data parallelism, in which multiple processing nodes execute identical code on distinct sets of data. Given two collection monoids $⊕$ and $⊗$ with $⊗ \preceq ⊕$, concat-map maps a collection $\mathcal{X}$ with parametric data type $T_⊕(α)$ to a collection of type $T_⊗(β)$, by applying a mapping function of type $α \to T_⊗(β)$. In contrast, the group-by function redistributes data among nodes based on the grouping key, such that data sharing the same key are directed to a single node. Given a type $κ$ that supports value equality, a type $α$ and a collection $\mathcal{X}$ of type $T_⊕(κ \times α)$, the group-by operation groups elements by their key, returning a collection of type $κ \times T_⊕(α)$. Using concat-map and group-by, we can define MapReduce in the monoid algebra as

$$ \text{mapReduce}(m, r, X) = \text{concatMap}(r, \text{groupBy}(\text{concatMap}(m, X))), \quad (5) $$

where $m$ is a mapping function and $r$ is a reduce function. Note that, if a node specifies a dependency as a map or reduce edge, it has to be defined in terms of a mapping function $m$ or reduce function $r$, and it is possible to transform the node into concat-map and group-by, which allows for a translation to computational backends that can be represented in the collection monoid algebra.

# 5 Implementation and Results

To test the potential of our approach, we first examine a theoretical example, using a resource-independent computational workload and a low-overhead computational backend. Second, we test our approach using a realistic outlier detection ensemble with different computational backends. For the theoretical example, we want to test the static and dynamic parallelization and a combination thereof. We generate a graph with a variable number of static and dynamic nodes and assume that each node in the graph waits for 100 ms before its execution finishes. We define the sequential lower bound as $T \cdot 100$ ms, which would only be achievable without any computational overhead. The parallel lower bound is defined as $L \cdot 100$ ms corresponding to the minimal time required for the critical path with no overhead. We conduct three experiments as shown in Fig. 5 where we increase the static and dynamic depth using $n$ workers. Using a lightweight threading backend, we observe that an almost optimal level of parallelism can be achieved when the number of threads $n$ equals the static or dynamic depth as visible when compared to the parallel lower bound.

For the realistic case study, we hypothetically devise a novel outlier detection ensemble model combining bagging with feature bagging, therefore training multiple models on simultaneous subspaces and subsamples of the data. We are interested in the overall speedup of the makespan objective compared to the sequential execution of the nodes in the graph, representing a naive, unoptimized implementation. Note that the exact same function definitions are used to implement the sequential and parallel approach. We use decorators to annotate each function and implicitly generate the underlying DAG and MapReduce edges from the annotations, which allows us to parallelize the DAG without
<figure><img src="image_7.png" /><figcaption>**Fig. 5.** Parallelization behavior with different depths, where (a) shows the parallelization using *n* threads under a fixed dynamic depth, but variable static depth, (b) shows a fixed static and variable dynamic depth and (c) shows the parallelization behavior with increasing static and dynamic depth.</figcaption></figure>

changing any underlying function definitions.<fnref n="1" /> As a computational backend for parallelization, we use a mixture of thread-based parallelism and process-based parallelism. Because the same function definitions are used for the sequential and parallel implementation, both sequential and parallel execution lead to the same results; therefore, we are not interested in a comparison of the resulting scores and use randomized synthetic data for all experiments. We generate standard-normal data with a fixed dataset size of 1024 samples and 128 features. We draw 50% of the samples for each bootstrap and 50% of the features. To determine the outlier scores for each bootstrap, we use the Local Outlier Factor [11] model implemented in scikit-learn [33].

<figure><img src="image_8.png" /><figcaption>**Fig. 6.** Makespan objective of an implicitly parallelized outlier detection ensemble with varying number of workers consisting of threads and processes.</figcaption></figure>

<footnote n="1">¹ It should be noted that the DAG could equivalently be inferred by other means.</footnote>
As visible in Fig. 6, a sequential implementation of the proposed ensemble model requires 1.71 ± 0.01 s to compute the entire graph, which consists of the computation of the outlier scores for ten subspaces and subsamples. With increasing numbers of workers, the performance saturates the underlying computational resources at about ten workers with 0.23 ± 0.16 s to complete the DAG. Note that 25 executions are performed to determine the mean execution time and corresponding standard deviation. The high standard deviation is mainly an implementation detail due to process pool initialization. Using ten workers, we achieve a speedup of ~ 7.4 without changing the underlying naive implementation and implicitly generating a MapReduce DAG from annotations.<fnref n="2" />

# 6 Conclusion

We show an effective approach to automatically parallelize outlier detection ensembles by implicitly generating and parallelizing the underlying DAG. The effectiveness is achieved by embedding MapReduce in the DAG, such that MapReduce handles the dynamic parts of the DAG which drastically simplifies scheduling of the entire graph. Previous works in outlier detection ensemble learning often resulted in models with high computational complexity, limiting their usefulness and adoption. We show that these outlier detection ensembles, implemented in a naive, sequential manner can be automatically parallelized without additional implementation effort. A limitation of our work is that it focuses only on independent outlier detection ensembles, which include a majority of the existing methods, but non-independent models would also benefit from parallelization. A future extension to our approach could include support for sequential ensemble methods that are not independent of their previous executions. More generally, the described implicit parallelization approach could also be applied to a wide range of other computational tasks in the future. We use a simple algebra to represent the statically and dynamically parallelized parts based on collection monoids. Future researchers could extend the algebra and MapReduce paradigm as proposed in [20], for example by fusing mapping operations for improved parallelization or including improved support for join-type operations. Extending the algebra could also simplify mapping the DAGs to various computational backends. Using our proposed method, future researchers working in outlier detection ensemble learning have an opportunity to drastically reduce the computational complexity of their methods using parallelization. An important future research endeavor would be an empirical evaluation of the possible speedup of common outlier detection ensembles using different computational backends. In general, parallelization aspects should be discussed more thoroughly in future outlier detection ensemble learning research.

<footnote n="2">² We publish the code to reproduce our experiments including all dependencies at: https://github.com/davnn/implicit-dag.</footnote>
## References

1. Adhikari, M., Amgoth, T., Srirama, S.N.: A survey on scheduling strategies for workflows in cloud environment and emerging trends. ACM Comput. Surv. 52(4), 1–36 (2020). https://doi.org/10.1145/3325097. ISSN 0360-0300, 1557-7341

2. Aggarwal, C.C.: Outlier ensembles: position paper. ACM SIGKDD Explor. Newslett. 14(2), 49–58 (2013). https://doi.org/10.1145/2481244.2481252. ISSN 1931-0145, 1931-0153

3. Aggarwal, C.C., Sathe, S.: Theoretical foundations and algorithms for outlier ensembles. ACM SIGKDD Explor. Newslett. 17(1), 24–47 (2015). https://doi.org/10.1145/2830544.2830549. ISSN 1931-145

4. Aggarwal, C.C., Sathe, S.: Outlier Ensembles. Springer, Cham (2017). https://doi.org/10.1007/978-3-319-54765-7. ISBN 978-3-319-54764-0 978-3-319-54765-7

5. Bae, J., Lee, J.H., Kim, S.: Image Anomaly Detection and Localization with Position and Neighborhood Information (2022)

6. Bandaragoda, T.R., Ting, K.M., Albrecht, D., Liu, F.T., Zhu, Y., Wells, J.R.: Isolation-based anomaly detection using nearest-neighbor ensembles. Comput. Intell. 34(4), 968–998 (2018). https://doi.org/10.1111/coin.12156. ISSN 1467-8640

7. Barnett, V., Lewis, T.: Outliers in Statistical Data. Wiley, Hoboken (1978). ISBN 978-0-471-99599-9

8. Blaom, A.D., Vollmer, S.J.: Flexible model composition in machine learning and its implementation in MLJ. arXiv:2012.15505 (2020)

9. Blelloch, G.E., Gibbons, P.B., Matias, Y.: Provably efficient scheduling for languages with fine-grained parallelism. J. ACM 46(2), 281–321 (1999). https://doi.org/10.1145/301970.301974. ISSN 0004-5411

10. Breiman, L.: Bagging predictors. Mach. Learn. 24(2), 123–140 (1996). https://doi.org/10.1007/BF00058655. ISSN 1573-0565

11. Breunig, M.M., Kriegel, H.P., Ng, R.T., Sander, J.: LOF: identifying density-based local outliers. In: Dunham, M., Naughton, J.F., Chen, W., Koudas, N. (eds.) Proceedings of the 2000 ACM SIGMOD International Conference on Management of Data: 2000, Dallas, Texas, United States, 15–18 May 2000, pp. 93–104. Association for Computing Machinery, New York (2000). https://doi.org/10.1145/342009.335388. ISBN 1-58113-217-4

12. Bryant, R.E.: Data-intensive scalable computing for scientific applications. Comput. Sci. Eng. 13(6), 25–33 (2011). https://doi.org/10.1109/MCSE.2011.73. ISSN 1558-366X

13. Bühlmann, P., Yu, B.: Analyzing bagging. Ann. Stat. 30(4) (2002). https://doi.org/10.1214/aos/1031689014. ISSN 0090-5364

14. Bunkenburg, A.: The boom hierarchy. In: O'Donnell, J.T., Hammond, K. (eds.) Functional Programming, pp. 1–8. Springer, London (1994). https://doi.org/10.1007/978-1-4471-3236-3_1 ISBN 978-1-4471-3236-3

15. Convolbo, M.W., Chou, J.: Cost-aware DAG scheduling algorithms for minimizing execution cost on cloud resources. J. Supercomput. 72(3), 985–1012 (2016). https://doi.org/10.1007/s11227-016-1637-7

16. Culler, D., Singh, J.P., Ph.D, A.G.: Parallel Computer Architecture: A Hardware/Software Approach, 1st edn. Morgan Kaufmann, San Francisco (1998). ISBN 978-1-55860-343-1

17. da Silva, E.C., Gabriel, P.H.R.: A comprehensive review of evolutionary algorithms for multiprocessor DAG scheduling. Computation 8(2), 26 (2020). https://doi.org/10.3390/computation8020026. ISSN 2079-3197
18. Dean, J., Ghemawat, S.: MapReduce: simplified data processing on large clusters. Commun. ACM **51**(1), 107–113 (2008). https://doi.org/10.1145/1327452.1327492. ISSN 0001-0782

19. Drozdowski, M.: Scheduling multiprocessor tasks — an overview. Eur. J. Oper. Res. **94**(2), 215–230 (1996). https://doi.org/10.1016/0377-2217(96)00123-3. ISSN 0377-2217

20. Fegaras, L.: An algebra for distributed big data analytics. J. Funct. Program. **27**, e27 (2017). https://doi.org/10.1017/S0956796817000193. ISSN 0956-7968, 1469-7653

21. Freund, Y., Schapire, R.E.: A decision-theoretic generalization of on-line learning and an application to boosting. J. Comput. Syst. Sci. **55**(1), 119–139 (1997). https://doi.org/10.1006/jcss.1997.1504. ISSN 0022-0000

22. Gao, J., Tan, P.N.: Converting output scores from outlier detection algorithms into probability estimates. In: Sixth International Conference on Data Mining (ICDM 2006), pp. 212–221 (2006). https://doi.org/10.1109/ICDM.2006.43. ISSN 2374-8486

23. Grandvalet, Y.: Bagging equalizes influence. Mach. Learn. **55**(3), 251–270 (2004). https://doi.org/10.1023/B:MACH.0000027783.34431.42. ISSN 0885-6125

24. He, X., Zhao, K., Chu, X.: AutoML: a survey of the state-of-the-art. Knowl.-Based Syst. **212**, 106622 (2021). https://doi.org/10.1016/j.knosys.2020.106622. ISSN 0950-7051

25. Kleinberg, J., Tardos, E.: Algorithm Design, 1st edn. Addison-Wesley Educational Publishers Inc, Boston (2005). ISBN 978-0-321-29535-4

26. Kriegel, H.P., Kroger, P., Schubert, E., Zimek, A.: Interpreting and unifying outlier scores. In: Liu, B., Liu, H., Clifton, C., Washio, T., Kamath, C. (eds.) Proceedings of the 2011 SIAM International Conference on Data Mining, pp. 13–24. Society for Industrial and Applied Mathematics, Philadelphia (2011). https://doi.org/10.1137/1.9781611972818.2. ISBN 978-0-89871-992-5

27. Lazarevic, A., Kumar, V.: Feature bagging for outlier detection. In: Proceedings of the Eleventh ACM SIGKDD International Conference on Knowledge Discovery in Data Mining, KDD 2005, pp. 157–166. Association for Computing Machinery, New York (2005). https://doi.org/10.1145/1081870.1081891. ISBN 978-1-59593-135-1

28. Li, C.L., Sohn, K., Yoon, J., Pfister, T.: CutPaste: self-supervised learning for anomaly detection and localization. In: 2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), Nashville, TN, USA, pp. 9659–9669. IEEE (2021). https://doi.org/10.1109/CVPR46437.2021.00954. ISBN 978-1-66544-509-2

29. Liu, F.T., Ting, K.M., Zhou, Z.H.: Isolation forest. In: 2008 Eighth IEEE International Conference on Data Mining, Pisa, Italy, pp. 413–422. IEEE (2008). https://doi.org/10.1109/ICDM.2008.17. ISBN 978-0-7695-3502-9

30. Liu, J., Huang, J., Zhou, Y., Li, X., Ji, S., Xiong, H., Dou, D.: From distributed machine learning to federated learning: a survey. Knowl. Inf. Syst. **64**(4), 885–917 (2022). https://doi.org/10.1007/s10115-022-01664-x

31. Muhr, D., Affenzeller, M., Blaom, A.D.: OutlierDetection.jl: a modular outlier detection ecosystem for the Julia programming language (2022)

32. Muhr, D., Tripathi, S., Jodlbauer, H.: Divide and conquer anomaly detection: a case study predicting defective engines. Procedia Manuf. **42**, 57–61 (2020). https://doi.org/10.1016/j.promfg.2020.02.090. ISSN 23519789

33. Pedregosa, F., et al.: Scikit-learn: machine learning in python. J. Mach. Learn. Res. **12**, 2825–2830 (2011)
34. Sagi, O., Rokach, L.: Ensemble learning: a survey. WIREs Data Mining Knowl. Discov. 8(4), e1249 (2018). https://doi.org/10.1002/widm.1249. ISSN 1942-4795

35. Schubert, E., Wojdanowski, R., Zimek, A., Kriegel, H.P.: On evaluation of outlier rankings and outlier scores. In: Ghosh, J., Liu, H., Davidson, I., Domeniconi, C., Kamath, C. (eds.) Proceedings of the 2012 SIAM International Conference on Data Mining, pp. 1047–1058. Society for Industrial and Applied Mathematics, Philadelphia (2012). https://doi.org/10.1137/1.9781611972825.90. ISBN 978-1-61197-232-0

36. Stewart, R.J., Trinder, P.W., Loidl, H.-W.: Comparing high level mapreduce query languages. In: Temam, O., Yew, P.-C., Zang, B. (eds.) APPT 2011. LNCS, vol. 6965, pp. 58–72. Springer, Heidelberg (2011). https://doi.org/10.1007/978-3-642-24151-2_5

37. Sun, J., Guan, N., Li, F., Gao, H., Shi, C., Yi, W.: Real-time scheduling and analysis of OpenMP DAG tasks supporting nested parallelism. IEEE Trans. Comput. 69(9), 1335–1348 (2020). https://doi.org/10.1109/TC.2020.2972385. ISSN 1557-9956

38. Zhan, Z.H., Liu, X.F., Gong, Y.J., Zhang, J., Chung, H.S.H., Li, Y.: Cloud computing resource scheduling and a survey of its evolutionary approaches. ACM Comput. Surv. 47(4), 1–33 (2015). https://doi.org/10.1145/2788397. ISSN 0360-0300, 1557-7341

39. Zimek, A., Campello, R.J., Sander, J.: Ensembles for unsupervised outlier detection: challenges and research questions. ACM SIGKDD Explor. Newslett. 15(1), 11–22 (2014). https://doi.org/10.1145/2594473.2594476. ISSN 1931-0145

40. Zimek, A., Gaudet, M., Campello, R.J., Sander, J.: Subsampling for efficient and effective unsupervised outlier detection ensembles. In: Proceedings of the 19th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD 2013, pp. 428–436. Association for Computing Machinery, New York (2013). https://doi.org/10.1145/2487575.2487676. ISBN 978-1-4503-2174-7