Computational geometry

We develop and analyze a method to reduce the size of a very large set of data points in a high dimensional Euclidean space R d to a small set of weighted points such that the result of a predetermined data analysis task on the reduced set is approximately the same as that for the original point set. For example, computing the first k principal components of the reduced set will return approximately the first k principal components of the original set or computing the centers of a k-means clustering on the reduced set will return an approximation for the original set. Such a reduced set is also known as a coreset. The main new feature of our construction is that the cardinality of the reduced set is independent of the dimension d of the input space and that the sets are mergable. The latter property means that the union of two reduced sets is a reduced set for the union of the two original sets (this property has recently also been called composability, see Indyk et. al., PODS 2014). It allows us to turn our methods into streaming or distributed algorithms using standard approaches. For problems such as k-means and subspace approximation the coreset sizes are also independent of the number of input points. Our method is based on projecting the points on a low dimensional subspace and reducing the cardinality of the points inside this subspace using known methods. The proposed approach works for a wide range of data analysis techniques including k-means clustering, principal component analysis and subspace clustering. The main conceptual contribution is a new coreset definition that allows to charge costs that appear for every solution to an additive constant.

Turning Big data into tiny data: Constant-size coresets for k-means, PCA and projective clustering

DBSCAN is an important spatial clustering technique
that is widely adopted in numerous applications. As
the size of datasets is extremely large nowadays, parallel
processing of complex data analysis such as DBSCAN becomes
indispensable. However, there are three major drawbacks
in the existing parallel DBSCAN algorithms. First,
they fail to properly balance the load among parallel tasks,
especially when data are heavily skewed. Second, the scalability
of these algorithms is limited because not all the critical
sub-procedures are parallelized. Third, most of them
are not primarily designed for shared-nothing environments,
which makes them less portable to emerging parallel processing
paradigms. In this paper, we present MR-DBSCAN, a
scalable DBSCAN algorithm using MapReduce. In our algorithm,
all the critical sub-procedures are fully parallelized.
As such, there is no performance bottleneck caused by sequential
processing. Most importantly, we propose a novel
data partitioning method based on computation cost estimation.
The objective is to achieve desirable load balancing even
in the context of heavily skewed data. Besides, We conduct
our evaluation using real large datasets with up to 1.2 billion
points. The experiment results well confirm the e ciency
and scalability of MR-DBSCAN.

MR-DBSCAN: a scalable MapReduce-based DBSCAN algorithm for heavily skewed data

Center-based clustering is a fundamental primitive for data analysis and becomes very challenging for large datasets. In this paper, we focus on the popular k-center variant which, given a set S of points from some metric space and a parameter k 0, the algorithms yield solutions whose approximation ratios are a mere additive term ϵ away from those achievable by the best known polynomial-time sequential algorithms, a result that substantially improves upon the state of the art. Our algorithms are rather simple and adapt to the intrinsic complexity of the dataset, captured by the doubling dimension D of the metric space. Specifically, our analysis shows that the algorithms become very space-efficient for the important case of small (constant) D. These theoretical results are complemented with a set of experiments on real-world and synthetic datasets of up to over a billion points, which show that our algorithms yield better quality solutions over the state of the art while featuring excellent scalability, and that they also lend themselves to sequential implementations much faster than existing ones.

/pdf/solving-k-center-clustering-with-outliers-in-mapreduce-and-3982kct0rn.pdf

Solving k-center clustering (with outliers) in MapReduce and streaming, almost as accurately as sequentially

Feature selection is a fundamental problem in machine learning and data mining. The majority of feature selection algorithms are designed for running on a single machine (centralized setting) and they are less applicable to very large datasets. Although there are some distributed methods to tackle this problem, most of them are distributing the data horizontally which are not suitable for datasets with a large number of features and few number of instances. Thus, in this paper, we introduce a novel vertically distributable feature selection method in order to speed up this process and be able to handle very large datasets in a scalable manner. In general, feature selection methods aim at selecting relevant and non-redundant features (Minimum Redundancy and Maximum Relevance). It is much harder to consider redundancy in a vertically distributed setting than a centralized setting since there is no global access to the whole data. To the best of our knowledge, this is the first attempt toward solving the feature selection problem with a vertically distributed filter method which handles the redundancy with consistently comparable results with centralized methods. In this paper, we formalize the feature selection problem as a diversity maximization problem by introducing a mutual-information-based metric distance on the features. We show the effectiveness of our method by performing an extensive empirical study. In particular, we show that our distributed method outperforms state-of-the-art centralized feature selection algorithms on a variety of datasets. From a theoretical point of view, we have proved that the used greedy algorithm in our method achieves an approximation factor of 1/4 for the diversity maximization problem in a distributed setting with high probability. Furthermore, we improve this to 8/25 expected approximation using multiplicity in our distribution.

Scalable Feature Selection via Distributed Diversity Maximization

Given a set S of points in a metric space, and a diversity measure div( ) dened over subsets of S, the goal of the diversity maximization problem is to nd a subset T S of size k that maximizes div(T ). Motivated by applications in massive data processing, we consider the composable coreset framework in which a coreset for a diversity measure is called -composable, if for any collection of sets and their corresponding coresets, the maximum diversity of the union of the coresets approximates the maximum diversity of the union of the sets. We present composable coresets with near-optimal approximation factors for several notions of diversity, including remote-clique, remote-cycle, and remote-tree. We also prove a general lower bound on the approximation factor of composable coresets for a large class of diversity maximization problems.

/pdf/diversity-maximization-via-composable-coresets-35tg098flg.pdf

Diversity Maximization via Composable Coresets

Given a set of n segments and a query shape Q, the windowing length query asks for finding the sum of the lengths of the parts of the segments that lie inside Q. The popular places problem of a set of curves asks for the subset of the plane where each query shape centered at a point of that region intersects with at least f distinct curves. For square queries, an optimal $$O(n^2)$$
 time algorithm and a matching lower bound exist. We solve the length query problem for convex polygons and disks as query shapes, with $$O(\log n+k)$$
 query time and polynomial preprocessing time that depends on the complexity of the query shape. We define a new version of the problem of finding popular places in a set of trajectories where the center of a query is a popular place if the length of the curves inside that query is at least f and use our data structure to solve the original problem as well as this new version. Other than length queries, we solve reporting queries that return the set of intersected segments. For disk queries, we design a point-location data structure for congruent disks with $$O(\log n)$$
 query time and $$O(n^3\log n)$$
 preprocessing. We also give algorithms for computing the length query for c-packed curves, which are a class of curves for which the length of the curve inside a disk of radius r is upper-bounded by cr, where c is a constant. Also, we use length queries for polygons to approximate the minimum value c for which a curve is c-packed, if such a c exists. Our results extend to MRC and MPC models for MapReduce, where we address these problems on a set of x-monotone curves. The round complexities of our MapReduce algorithms are constant. In addition, we also implemented our popular places algorithms on trajectories on inputs as big as 15K points to evaluate the efficiency of our algorithms in practice.

Windowing queries using Minkowski sum and their extension to MapReduce

A set of points $P$ in a metric space and a constant integer $k$ are given. The $k$-center problem finds $k$ points as centers among $P$, such that the maximum distance of any point of $P$ to their closest centers $(r)$ is minimized. 
Doubling metrics are metric spaces in which for any $r$, a ball of radius $r$ can be covered using a constant number of balls of radius $r/2$. Fixed dimensional Euclidean spaces are doubling metrics. The lower bound on the approximation factor of $k$-center is $1.822$ in Euclidean spaces, however, $(1+\epsilon)$-approximation algorithms with exponential dependency on $\frac{1}{\epsilon}$ and $k$ exist. 
For a given set of sets $P_1,\ldots,P_L$, a composable coreset independently computes subsets $C_1\subset P_1, \ldots, C_L\subset P_L$, such that $\cup_{i=1}^L C_i$ contains an approximation of a measure of the set $\cup_{i=1}^L P_i$. 
We introduce a $(1+\epsilon)$-approximation composable coreset for $k$-center, which in doubling metrics has size sublinear in $|P|$. This results in a $(2+\epsilon)$-approximation algorithm for $k$-center in MapReduce with a constant number of rounds in doubling metrics for any $\epsilon>0$ and sublinear communications, which is based on parametric pruning. 
We prove the exponential nature of the trade-off between the number of centers $(k)$ and the radius $(r)$, and give a composable coreset for a related problem called dual clustering. Also, we give a new version of the parametric pruning algorithm with $O(\frac{nk}{\epsilon})$ running time, $O(n)$ space and $2+\epsilon$ approximation factor for metric $k$-center.

A Composable Coreset for k-Center in Doubling Metrics

A geometric spanner on a point set is a sparse graph that approximates the Euclidean distances between all pairs of points in the point set. Here, we intend to construct a geometric spanner for a massive point set, using a distributed algorithm on parallel machines. In particular, we use the MapReduce model of computation to construct spanners in several rounds with inter-communications in between. An algorithm in this model is called efficient if it uses a sublinear number of machines and runs in a polylogarithmic number of rounds. In this paper, we propose an efficient MapReduce algorithm for constructing a geometric spanner in a constant number of rounds, using linear amount of communication. The stretch factors of our spanner is $1+\epsilon $, for any $\epsilon >0$.

Geometric Spanners in the MapReduce Model

/pdf/a-composable-coreset-for-k-center-in-doubling-metrics-166c7ycyot.pdf

Sepideh Aghamolaei

Papers

Diversity Maximization via Composable Coresets

Windowing queries using Minkowski sum and their extension to MapReduce

A Composable Coreset for k-Center in Doubling Metrics

Geometric Spanners in the MapReduce Model

A Composable Coreset for k-Center in Doubling Metrics