{'fraction_non_alphanumeric': 0.029628148740503797, 'fraction_numerical': 0.0041583366653338664, 'mean_word_length': 4.949333967649857, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
KDD-SC: Subspace Clustering Extensions for Knowledge Discovery Frameworks

Analyzing high dimensional data is a challenging task. For these data it is known that traditional clustering algorithms fail to detect meaningful patterns. As a solution, subspace clustering techniques have been introduced. They analyze arbitrary subspace projections of the data to detect clustering structures. In this paper, we present our subspace clustering extension for KDD frameworks, termed KDD-SC. In contrast to existing subspace clustering toolkits, our solution neither is a standalone product nor is it tightly coupled to a specific KDD framework. Our extension is realized by a common codebase and easy-to-use plugins for three of the most popular KDD frameworks, namely KNIME, RapidMiner, and WEKA. KDD-SC extends these frameworks such that they offer a wide range of different subspace clustering functionalities. It provides a multitude of algorithms, data generators, evaluation measures, and visualization techniques specifically designed for subspace clustering. These functionalities integrate seamlessly with the frameworks' existing features such that they can be flexibly combined. KDD-SC is publicly available on our website.


INTRODUCTION
Clustering is one of the core data mining tasks. The goal of clustering is to automatically group similar objects while separating dissimilar ones. Traditional clustering methods consider all dimensions of the dataspace to measure the similarity between objects. For today's high dimensional data, however, these full-space clustering approaches fail to detect meaningful patterns since irrelevant dimensions obfuscate the clustering structure [7,16]. Using global dimensionality reduction techniques such as principle components analysis is not sufficient to solve this problem: by definition, all objects are projected to the same lower dimensional subspace. However, as Figure 1 illustrates, each cluster might have locally relevant dimensions and objects can be part of multiple clusters in different subspaces. These effects cannot be captured by global dimensionality reduction approaches.
To tackle this challenge, subspace clustering techniques have been introduced, aiming at detecting locally relevant dimensions per cluster [16,21]. They analyze arbitrary subspace projections of the data to detect the hidden clusters. Typical applications for subspace clustering include gene expression analysis, customer profiling, and sensor network analysis. In each of these scenarios, subsets of the objects (e.g., genes) are similar regarding subsets of the dimensions (e.g., different experimental conditions). Existing systems: Today, general data mining functionality is provided to the end-user in a convenient and intuitive way by established knowledge discovery frameworks as KN-IME (Konstanz Information Miner, [6]), RapidMiner [18], and WEKA (Waikato Environment for Knowledge Analysis, [14]). These systems are succesfully and frequently used in research and practice. The applicability of subspace clustering, in contrast, is still limited.
So far, there are two systems that support the user in the task of subspace clustering, namely OpenSubspace [20] and ELKI [1]. Both systems are milestones in the process of providing subspace clustering functionality to the end-user, but have severe limitations concerning their integration into established data mining workflows. While ELKI, as a standalone java framework, does not offer any integration into existing data mining toolkits, OpenSubspace is highly coupled and its current form only applicable within the WEKA framework. Due to this strong coupling, it is difficult to integrate new algorithms and to (re)use already implemented subspace clustering functionality in other KDD frameworks. Accordingly, for end-users running their established KDD workflows in other frameworks than WEKA or ELKI, the integration of subspace clustering into these workflows is a hard and time-consuming challenge.
Our contribution: In this paper, we propose a new system for subspace clustering, which is seamlessly integrated into KNIME, RapidMiner, and WEKA. By covering this broad spectrum of knowledge discovery frameworks, many researchers and practitioners can benefit from our system. It is based on a common code basis across all KDD frameworks. Thus, it is possible to quickly deploy new subspace clustering methods in multiple frameworks at the same time. By integrating our system into these established knowledge discovery frameworks, the user can easily use subspace clustering functionality within the whole KDD process. Our methods can be combined with the existing algorithms, data transformations techniques, and visualization tools of these frameworks. Overall, our system offers • a seamless integration of subspace clustering functionality into KNIME, RapidMiner, and WEKA. Accordingly, many researchers and practitioners can use their established KDD workflows without any loss in productivity.
• a common code basis for subspace clustering algorithms, evaluation measures, and synthetic data generators. It is independent of the chosen data mining framework and realizes easy extensibility and reusability of all components.
• visualization and interaction principles for subspace clustering exploiting the capabilities of the different data mining toolkits, which support the user in the interpretation of the obtained results.

GENERAL ARCHITECTURE
In this section we describe the general architecture and functionality of our subspace clustering extension. The usage of our extension within the different knowledge discovery frameworks is described in the Sections 3-5.
For reusability and easy portability of the developed methods, our KDD-SC framework is separated into a core package (CoreSC) and packages realizing the integration into the different KDD frameworks (KnimeSC, RapidSC, WekaSC). Figure 2 shows an overview of this design.

KnimeSC
RapidSC WekaSC CoreSC -subspace clustering algorithms -data generators -evaluation measures -visualization In the core package, the actual functionality of our system is implemented. This functionality is independent of a specific system. The core package is divided into four major components: subspace clustering algorithms, data generators, evaluation measures, and visualization tools. A detailed description of these components is provided in the following sections.
The WekaSC user interface as well as parts of the core package (algorithms & evaluation measures) have been extracted from the OpenSubspace project [20]. In contrast to the original OpenSubspace, which was tightly bundled with a specific WEKA version, our redesigned WekaSC implements the WEKA plugin interface and enables easy extension by our component-based design.
In the three packages KnimeSC, RapidSC, and WekaSC we included the implementations which are necessary to realize an interaction of the knowledge discovery frameworks with the core package. Thus, these packages act as adapters between the core package and the actual system. In the KnimeSC package, for example, we implemented the nodebased representation of the algorithms as required for the KNIME framework (cf. Section 3).
By using a common codebase, i.e. the CoreSC package, it is easy to integrate new subspace clustering techniques for each of the knowledge discovery frameworks. The actual subspace clustering algorithm has only to be implemented in the core package. Additionally, one can easily support other (e.g., R) or even new data mining frameworks by simply providing a new adapter package.
Each algorithm implements the interface SubspaceAlgorithm, which defines the input and output of the algorithms. The input corresponds to a database of objects described by numerical features, i.e. each algorithm needs to be provided with a list of objects o1, . . . , on where oi ∈ R d . The output of each algorithm is a list of subspace clusters C1, . . . , C k . Each subspace cluster Ci represents the objects and relevant dimensions belonging to this clusters. Note that in subspace clustering each cluster has its individual set of relevant dimensions (cf. Figure 1). Thus, each subspace cluster corresponds to a tuple Ci = (Oi, Si) where Oi represents the clustered objects by their objects ids, i.e. Oi ⊆ {1, . . . , n}, and Si represents the relevant dimensions of the cluster, i.e. Si ⊆ {1, . . . , d}.
It is worth mentioning that subspace clustering in general is not restricted to disjoint clusters; thus, the result set might contain clusters Ci and Cj (with i = j) where Oi ∩ Oj = ∅ or Si ∩ Sj = ∅. Additionally, dependent on the chosen algorithm, not necessarily each object or dimension needs to be part of some cluster, i.e. it might hold

Data Generators
The second component of the core package contains a flexible data generator first introduced in [13], which generates synthetic data with hidden subspace clusters. These datasets can be used to evaluate the correctness of subspace clustering algorithms and to assess the methods' scalability. The data generator implements the interface SubspaceData-Generator which defines the two outputs of the generator.
The first output corresponds to the generated data, i.e. as above it corresponds to a list of objects o1, . . . , on with oi ∈ R d . The second output of each data generator is the ground truth clustering. This ground truth specifies which clusters are hidden in the data and which clusters should be found by the subspace clustering algorithms. Accordingly, the second output is a list of subspace clusters C1, . . . , C k .

Evaluation Measures
The third component provides implementations of evaluation measures for subspace clustering. Evaluation measures summarize the clustering result by a numerical value where, e.g., a high value indicates better quality of the clustering. Evaluation measures can be categorized into internal measures and external measures. While internal measures as- sess the quality of a clustering based on properties as, e.g., the compactness or density, external measures compute the quality w.r.t. a ground truth clustering [8,11]. Please note that the ground truth clustering can be any clustering: either generated by a data generator, provided manually by the user, or determined by an algorithm. Thus, besides comparing the result of a single algorithm against the ground truth, external measures can also be used to compare the results of two different algorithms on the same data. We provide several evaluation measure specifically designed for subspace clustering in our framework. These measure include CE, RNIA, Entropy, F1P, F1R, and E4SC. We kindly refer to [11] for a description of these measures.
In our extension, all evaluation measures implement the interface SCEvaluationMeasure. The interface specifies the input of these measure which corresponds to the database on which the clustering is performed, and two subspace clustering results C1, . . . , C k and C 1 , . . . , C l . The output of each measure is a numerical value summarizing the quality of the clustering. Since some measures provide more fine grained evaluation results for each cluster individually, we additionally implemented the interface SCExtendedEvalua-tionMeasure. This interface allows to retrieve a evaluation result for each cluster of the result individually.

Visualization
The last component of the core package provides subspace clustering specific visualization and interaction principles. In our extension we integrated the CoDA [10], MCExplorer [12], and Visa [4] toolkits. While these techniques are independent of the used KDD framework, we additionally integrated further techniques exploiting the individual visualization capabilities of each framework. These methods are integrated in the framework-specific packages of KDD-SC.

KNIME EXTENSION
This section describes the usage of our extension within KNIME, termed KnimeSC. We demonstrated a first version of KnimeSC at [13]. KNIME is an opensource data mining framework offering several benefits and is widely been used in industry as well as in academia. It has a modern, user-friendly interface which allows to model data mining workflows in an intuitive manner. In KNIME, a workflow is defined by a set of nodes, which can represent data sources and sinks, mining algorithms, transformations, visualizations, and further concepts. Each node has specific input and output ports depending on the node's functionality. The user establishes a new workflow by selecting a set of nodes from the node repository and then connects the corresponding input and output ports to steer the data flow between these nodes. Data mining workflows can be stored for later re-use, modification, or extension.
A major benefit of KNIME is the easy-to-use plugin concept. It allows KNIME to be extended by new features, represented as new nodes in the node repository. These new nodes can freely interact with the existing KNIME components, achieving a deep integration of our extension. Thus, all techniques already integrated in KNIME can be combined with our extension for mutual benefit. Figure 3 shows a screenshot of KNIME and our extension. On the left, the newly developed nodes are illustrated in the node repository. Each node corresponds to one functionality provided by the CoreSC package. On the right, descriptions of each node and its corresponding input/output ports are given. In the center, the actual workflow is illustrated. In the following we provide details of our extension and the different types of nodes based on three different workflows. Figure 3 shows a simple workflow where a data reader node ('Node 1'; here: reading data from an ARFF file) is connected with a subspace clustering algorithm node ('Node 2'; here: PROCLUS [2]). Accordingly, by specifying this workflow, the user applies PROCLUS on a given database.

Subspace Clustering Algorithms
As described in Section 2.1, each algorithm gets as an input the database to be clustered. This is shown by the single input port of the node 'Node 2'. Considering the output of the node, we have to take care of the special format used in KNIME. The standard format to exchange information between nodes in KNIME is by using flat tables/relations. Since the output of each algorithm is a list of subspace clusters, which itself are tuples describing sets of objects and sets of dimensions, each node needs to have two output ports. At the first output port, a table is provided which describes the relevant dimensions Si of each cluster Ci = (Oi, Si) via binary encoding. In Figure 3 this table is illustrated at the bottom ('Cluster Dimensions') and shows three subspace clusters found in the Iris dataset [9]. The cluster with ID 2, for example, is located in the dimensions 'sepallength', 'sepalwidth', and 'petalwidth'. The second output port provides information which objects belong to the detected clusters (table 'Cluster Objects'). In the example, the object 149 belongs to cluster 0, while object 17 belongs to cluster 1. Please note again that in subspace clustering each object might belong to multiple clusters, i.e. clusters might over- lap due to different subspace projections. Thus, the output table corresponds to an n:m relation. These two outputs can be forwarded to any other node included in the KNIME framework as we will show next.

Data Generators & Evaluation Measures
A second workflow is illustrated in Figure 4. It models the task frequently performed in scientific literature: a) generate synthetic data with a given clustering ground truth, b) apply an algorithm on the data, and c) measure whether the detected result matches the ground truth.
To solve this task with our framework, the user has to select a data generator node ('Node 1'). The node constructs synthetic data where the subspace clustering structure is known, i.e. the ground truth for clustering is given. Again, we have to take care that in KNIME the information is exchanged via flat tables. Thus, each data generator node has three output ports: First, the generated data. Second, the relevant dimensions of each cluster. Third, the cluster memberships of each object. The last two outputs are of the same format as the outputs of the subspace clustering algorithm nodes as described above. Connecting the first port of the data generator with an algorithm node ('Node 2') allows to cluster the synthetic data.
Finally, to measure the quality of the detected results, the user can use an evaluation measure node ('Node 3'; here: CE measure [22]). Such a node has five input ports: four ports are required to specify the two clustering results that should be compared (two ports for each clustering result), and one port for the database. Thus, in the figure, all three output ports of the data generator are connected to the measure as well as the two output ports of the MineClus node.

Visualization
The two outputs of each algorithm node already allow to analyze the detected clustering structure on a basic level. That is, by inspecting the corresponding tables (cf. Fig. 3) the user might get an impression about the relevant dimensions of the clusters and the supporting objects. Though, analyzing these tables might be difficult to gain further knowledge; accordingly, for easy interpretations of the clustering results we include different visualizations.
One possible visualization is realized with the workflow depicted in Figure 5. The subspace visualization node generates results as shown in the table on the right. The table represents the original database where each row corresponds to one object. The objects belonging to the same cluster are highlighted with the same color. In the example, three clusters are shown. Additionally, also the relevant dimensions of the clusters are depicted. A dimension is relevant, if and only if there is a colored bar on the right hand side of the number. In the example, the green cluster is located in the subspace of dimension 2 and 4, while the blue cluster is located in all four dimensions. Using this visualization, the user can easily compare the different subspaces of the clusters as well as the attribute values of the clustered objects. Considering for example the green cluster, we see that the attribute values in the first (and irrelevant) dimension are distributed in the broad range of 5.0-6.3, while the second (and relevant) dimension shows a deviation of only 2.0-2.4.
To obtain this visualization, the subspace visualization node requires three inputs: First, the database to be analyzed. Next, the relevant dimensions of each cluster with their corresponding coloring. This coloring is realized by using the Color Manager node provided by the KNIME framework. That is, the first output of the subspace clustering algorithm ('Node 2') is firstly forwarded to the Color Manager ('Node 3') before used as an input of the subspace visualization node ('Node 4'). In the Color Manager node, the user can choose the color of each cluster. The last input required for the visualization is the cluster membership information which can be directly transferred from 'Node 2'.

RAPIDMINER EXTENSION
In this section we present the usage of our extension within the RapidMiner framework. Similar to KNIME, RapidMiner models data mining workflows via a node-based interface, i.e. each node performs a certain task and has specific input and output ports. Information between different nodes is exchanged by connecting their corresponding ports. Figure 6 shows a screenshot of RapidMiner and our extension. On the left of the screen, the newly developed nodes are shown. On the right, the parametrization of the currently selected node is illustrated (here: the parameters of the MineClus algorithm) and a description of the node is provided. In the center, one sees the actual workflow.
While the general interaction with RapidMiner is similar to KNIME, we briefly discuss some differences. The exchange of information between KNIME nodes is based on flat tables. Thus, we represented a subspace clustering results via two flat tables, describing the object groupings and the relevant dimensions of the clusters. In RapidMiner, information between nodes is exchanged based on Java objects. Thus, instead of using flat tables, we directly exchange the list of subspace clusters via the Java class SubspaceCluster-Model. Accordingly, in RapidMiner each node representing a subspace clustering algorithm has only a single output port (cf. the MineClus node in Figure 6) and each data generator node has only two outputs (one port for the ground truth clustering and the other port for the generated database). These output ports are typed, i.e. they can only be connected to other input ports which also accept subspace clustering results.
In Figure 6, we see how the ground truth clustering of the data generator and the result of MineClus are forwarded to the evaluation measure E4SC. Additionally, the generated database is provided as an input for the measure. The fourth input port shows a further feature integrated in RapidMiner: the chaining of nodes. Here, the measures E4SC and CE are chained, i.e. all output ports of E4SC act as input ports for CE. While the first three output ports simply forward the three input ports of the measure, the last output port represents the result of the evaluation measure and of all measures which are before this node in the chain. That is, in the workflow of Figure 6, the result of the CE measure is a list representing the result of the E4SC and the CE measure. By chaining the nodes the workflows are more compact and, thus, easier understandable.

Visualization
In Figure 7 we illustrate another RapidMiner workflow modeling the analysis of subspace clustering results via the CoDA [10] and MCExplorer [12] toolkits. After reading data from an external source, the database is forwarded to the PROCLUS node. The clustering result of PROCLUS and the database are then transferred to the visualization node shown on the right. Please note that in RapidMiner we have to use a so called 'Multiply' node when a single output port needs to be connected to multiple input ports. In the example, the loaded database is used as an input for PROCLUS as well as for the visualization. When activating the node on the right, a new window containing the CoDA and McExplorer toolkits will open in which the user can interact with the clustering result. A detailed description of the toolkits' functionalities is given in the original papers.

WEKA EXTENSION
Finally, our extension is integrated into WEKA as shown in Figure 8. The functionality and user interface of WekaSC correspond to OpenSubspace [20]. As already mentioned, the advantage introduced by our redesign is its implementation of the WEKA plugin interface and its easy extensibility by the component-based design.
The classical workflow to analyze data in WEKA differs from the previous two knowledge discovery frameworks. It represents primarily a sequential process where a single dataset is loaded, preprocessed, and finally analyzed by an algorithm. The loading and preprocessing functionality of WEKA is integrated into the 'Preprocess' tab as shown in  The 'Subspace Clustering' tab provides the major functionality of our extension. Here, the preprocessed data is analyzed using subspace clustering methods. The user can select among the multitude of implemented subspace clustering algorithms. In the example, the PROCLUS method is chosen. Additionally, the user can select different evaluation measures which will be applied when the result of the algorithm has been generated. As shown in the lower left part of the screenshot, different measures can be selected and the ground truth clustering to which the result is compared can be loaded. After starting the algorithm, the clustering result will appear in the right part of the window. It represents the list of detected subspace clusters with their relevant dimensions in binary encoding as well as the number of objects per cluster and the corresponding object ids. This textual output corresponds to the two tables as used in KNIME. The two remaining tabs 'CoDA' and 'MCExplorer' can be used to analyze the clustering results based on the corresponding toolkits as described before.

CONCLUSION
Subspace clustering is an important mining task and it is widely studied in the scientific community. In this paper, we presented our subspace clustering extension KDD-SC, which is integrated in the KDD frameworks KNIME, Rapid-Miner, and WEKA. Our extension provides subspace clustering functionality for these frameworks based on a common code basis, and it can flexibly be combined with the toolkits' existing features. Our KDD-SC extension is publicly available on the following website: http://dme.rwth-aachen.de/KDD-SC Overall, our extension sets the stage for the wide applicability of subspace clustering in practical applications.