Scalable Distributed Subtrajectory Clustering

TL;DR

This paper presents a scalable distributed approach for subtrajectory clustering that dynamically discovers significant patterns in large mobility datasets using MapReduce, improving over existing methods.

Contribution

It introduces a novel distributed framework for subtrajectory clustering that handles dynamic pattern discovery and demonstrates superior scalability and effectiveness.

Findings

Efficiently clusters large-scale mobility data in distributed environments.

Outperforms state-of-the-art subtrajectory clustering algorithms.

Validated on synthetic and real maritime and urban datasets.

Abstract

Trajectory clustering is an important operation of knowledge discovery from mobility data. Especially nowadays, the need for performing advanced analytic operations over massively produced data, such as mobility traces, in efficient and scalable ways is imperative. However, discovering clusters of complete trajectories can overlook significant patterns that exist only for a small portion of their lifespan. In this paper, we address the problem of Distributed Subtrajectory Clustering in an efficient and highly scalable way. The problem is challenging because the subtrajectories to be clustered are not known in advance, but they need to be discovered dynamically based on adjacent subtrajectories in space and time. Towards this objective, we split the original problem to three sub-problems, namely Subtrajectory Join, Trajectory Segmentation and Clustering and Outlier Detection, and deal with each one in a distributed fashion by utilizing the MapReduce programming model. The efficiency and the effectiveness of our solution is demonstrated experimentally over a synthetic and two large real datasets from the maritime and urban domains and through comparison with two state of the art subtrajectory clustering algorithms.

Figures

Tables

Table 1. Table 1: Parameters and default values (in bold)

Parameter	Values
	(i)	(ii)	(iii)	(iv)	(v)
${ϵ}_{sp}$ (%)	10%	15%	20%	25%	30%
${ϵ}_t$ (%)	0%	25%	50%	75%	100%
$\delta t$ (%)	0%	25%	50%	75%	100%
$w$	10	15	20	25	30
$\tau$	0.2	0.4	0.6	0.8	1
$\alpha$ (in $\sigma$)	-2	-1	0	1	2
$k$ (in $\sigma$)	-2	-1	0	1	2

Equations

$$Sim(r,s)=\frac{LCS{S}_{{ϵ}_t,{ϵ}_{sp}}(r,s)}{min(|r|,|s|)}$$

$$Sim(r,s)=\frac{\sum _{k=1}^{min(|r|,|s|)}(1-\frac{d_s(r_k,s_k)}{{ϵ}_{sp}})}{min(|r|,|s|)}$$

$$SSCR=\sum _{\forall R_i\in R}\sum _{\forall r_j^{\prime }\in C_i}Sim(R_i,r_j^{\prime })$$

$$V(r_i)=\sum _{\forall s\in D}\frac{d_s(r_i,s_k)}{{ϵ}_{sp}}$$

$$\overline{V}(r)[]=\{\frac{V(r_1)}{{\max }_{i=1}^{N}V(r_i)},\dots ,\frac{V(r_N)}{{\max }_{i=1}^{N}V(r_i)}\}$$

$$V(r)=\frac{1}{N}\sum _{i=1}^{N}V(r_i)$$

$$\overline{d_s(r^{\prime },s^{\prime })}\le {ϵ}_{sp}\cdot (1-\alpha )$$

$$Sim(r^{\prime },s^{\prime })=\frac{\sum _{k=1}^{min(|r^{\prime }|,|s^{\prime }|)}(1-\frac{d_s(r_k^{\prime },s_k^{\prime })}{{ϵ}_{sp}})}{min(|r^{\prime }|,|s^{\prime }|)}$$

$$Sim(r^{\prime },s^{\prime })=\frac{min(|r^{\prime }|,|s^{\prime }|)-\sum _{k=1}^{min(|r^{\prime }|,|s^{\prime }|)}\frac{d_s(r_k^{\prime },s_k^{\prime })}{{ϵ}_{sp}}}{min(|r^{\prime }|,|s^{\prime }|)}$$

$$But,\sum _{k=1}^{min(|r^{\prime }|,|s^{\prime }|)}{d}_s(r_k^{\prime },s_k^{\prime })=min(|r^{\prime }|,|s^{\prime }|)\cdot \overline{d_s(r^{\prime },s^{\prime })}$$

$$So,Sim(r^{\prime },s^{\prime })=\frac{min(|r^{\prime }|,|s^{\prime }|)-\frac{min(|r^{\prime }|,|s^{\prime }|)\cdot \overline{d_s(r^{\prime },s^{\prime })}}{{ϵ}_{sp}}}{min(|r^{\prime }|,|s^{\prime }|)}$$

$$Sim(r^{\prime },s^{\prime })=\frac{min(|r^{\prime }|,|s^{\prime }|)\cdot (1-\frac{\overline{d_s(r^{\prime },s^{\prime })}}{{ϵ}_{sp}})}{min(|r^{\prime }|,|s^{\prime }|)}$$

$$Sim(r^{\prime },s^{\prime })=1-\frac{\overline{d(r^{\prime },s^{\prime })}}{{ϵ}_{sp}}$$

$$But,Sim(r^{\prime },s^{\prime })\ge \alpha$$

$$So,\overline{d_s(r^{\prime },s^{\prime })}\le {ϵ}_{sp}\cdot (1-\alpha )$$

Full text

K****eywords Mobility data, trajectories, subtrajectory clustering, big mobility data mining, distributed clustering, mapreduce

1 Introduction

Nowadays, the unprecedented rate of trajectory data generation, due to the proliferation of GPS-enabled devices, poses new challenges in terms of storing, querying, analyzing and extracting knowledge from big mobility data. One of these challenges is cluster analysis, which aims at identifying clusters of moving objects (thus, unveil hidden patterns of collective behavior), as well as detecting moving objects that demonstrate abnormal behaviour and can be considered as outliers.

The research so far has focused mainly in methods that aim to identify specific collective behavior patterns among moving objects, such as [8, 7, 6, 15, 11, 10, 24, 27, 5]. However, this kind of approaches operate at specific predefined temporal “snapshots” of the dataset, thus ignoring the route of each moving object between these sampled points. Another line of research, tries to identify patterns that are valid for the entire lifespan of the moving objects [13, 18, 3, 21]. However, discovering clusters of complete trajectories can overlook significant patterns that might exist only for some portions of their lifespan. The following motivating example shows the merits of subtrajectory clustering.

Example 1**.**

(Subtrajectory clustering)* Figure 1(a) illustrates six trajectories moving in the xy-plane, where each one of them has a different origin-destination pair. More specifically, these pairs are $A\rightarrow{B}$, $A\rightarrow{C}$, $A\rightarrow{D}$, $B\rightarrow{A}$, $B\rightarrow{C}$ and $B\rightarrow{D}$. These six trajectories have the same starting time and similar speed. A typical trajectory clustering technique would fail to identify any clusters. However, the goal of a subtrajectory clustering method is to identify 4 clusters ($A\rightarrow{O}$ (red), $B\rightarrow{O}$ (blue), $O\rightarrow{C}$ (purple), $O\rightarrow{D}$ (orange)) and 2 outliers ($O\rightarrow{A}$ and $O\rightarrow{B}$ (black)), as depicted in Figures 1(b).*

The problem of subtrajectory clustering is shown to be NP-Hard (cf. [1]). In addition, the objects to be clustered are not known beforehand (as in entire-trajectory – from now on – clustering algorithms), but have to be identified through a trajectory segmentation procedure. Efforts that try to deal with this problem in a centralized way do exist. More specifically, an approach that segments the trajectories based on their geometric features, and then clusters them by ignoring the temporal dimension is presented in [9]. Instead, the authors in [20] take into account the temporal dimension, and the segmentation of a trajectory takes place whenever the density of its spatiotemporal “neighborhood” changes significantly. The segmentation phase is followed by a sampling phase, where the most representative subtrajectories are selected and finally the clusters are built “around” these representatives. A similar approach is adopted in [1], where the goal is to identify common portions between trajectories,with respect to some constraints and/or objectives, thus taking into account the “neighborhood” of each trajectory. These common subtrajectories are then clustered and each cluster is represented by a pathlet, which is a point sequence that is not necessarily a subsequence of an actual trajectory.

Unfortunately, applying centralized algorithms for subtrajectory clustering (e.g., [20, 9, 1]) over massive data in a scalable way is far from straightforward. This calls for parallel and distributed algorithms that address the scalability requirements. In this context, one challenge is how to partition the data in such a way so that each node can perform its computation independently, thus minimizing the communication cost between nodes, which is a cost that can turn out to be a serious bottleneck. Another challenge, related to partitioning, is how to achieve load balancing, in order to balance the load fairly between the different nodes. Yet another challenge is to minimize the iterations of data processing, which are typically required in clustering algorithms. Interestingly, there have been some recent efforts towards mining mobility data in a distributed way, such as mining co-movement patterns [5], identifying frequent patterns [21] or adapting already existing distributed solutions to trajectory data [3], yet no approach for distributed subtrajectory clustering exists as of now.

Motivated by these limitations, we study the Distributed Subtrajectory Clustering (DSC) problem, which has not been addressed yet in a scalable and efficient way. Moreover, salient features of our approach include: (a) the discovery of clusters of subtrajectories, instead of whole trajectories, (b) spatio-temporal clustering, instead of spatial only, and (c) support of trajectories with variable sampling rate, length and with temporal displacement.

Our main contributions are the following:

• •

We formally define the problem of Distributed Subtrajectory Clustering, investigate its properties and discuss the main challenges.

• •

We propose two neighborhood-aware trajectory segmentation algorithms, which are tailored to DSC problem, covering different application requirements.

• •

We design an efficient and scalable solution for the problem of Distributed Subtrajectory Clustering.

• •

We perform an extensive experimental study, where the performance and the effectiveness of the proposed algorithms is evaluated by using a synthetic and two large, real trajectory datasets from different domains (urban and maritime). The merits of our solution are demonstrated with respect to two state of the art subtrajectory clustering algorithms, [20] and [9].

The rest of the paper is organized as follows. In Section 2 we provide an overview of the relevant literature. Subsequently, in Section 3 we introduce the DSC problem, in Section 4 we present our proposed solution and in Section 5 we perform a complexity analysis of the algorithms that constitute our solution. Then, in Section 6, we present the results of our experimental study. We conclude the paper in Section 7.

2 Related Work

In recent years, an increased research interest has been observed in knowledge discovery out of mobility data. Towards this direction, several mining methods have been proposed, which can be categorized to co-movement pattern discovery, trajectory clustering, sequential patterns and periodic patterns. In this section, we focus in the first two categories of patterns that are directly related to our work.

Co-movement patterns. One of the first approaches for identifying such collective mobility behavior is the so-called flock pattern [8, 25]. Inspired by this, a less “strict” definition of flocks was proposed in [7] where the notion of a moving cluster was introduced. There are several related works that emerged from the above ideas, like the approaches of convoys [6, 15], swarms [11], platoons [10], traveling companion [24] and gathering pattern [27].

However, all of the aforementioned approaches are centralized and cannot scale to massive datasets. In this direction, the problem of efficient convoy discovery was studied both in centralized [15] and distributed environment by employing the MapReduce programming model [14]. An approach that defines a new generalized mobility pattern is presented in [5]. In more detail, the general co-movement pattern (GCMP), is proposed, which models various co-movement patterns in a unified way and is deployed on a modern distributed platform (i.e., Apache Spark) to tackle the scalability issue. Even though all of these approaches provide explicit definitions of several mined patterns, their main limitation is that they search for specific collective behaviors, defined by respective parameters. Nevertheless, none of the above techniques tackles the subtrajectory clustering problem.

Trajectory clustering. Most of the aforementioned approaches operate at specific predefined temporal “snapshots” of the dataset, thus ignoring the route of each moving object between these “snapshots”. Another line of research, tries to discover groups of either entire or portions of trajectories considering their routes. A typical strategy in dealing with trajectory clustering is to transform trajectories to a multi-dimensional space and then apply well-known clustering algorithms such as OPTICS [2] and DBSCAN [4]. Alternatively, another approach is to define an appropriate similarity function and embed it to an extensible clustering algorithm. In this direction, there are several approaches whose goal is to group whole trajectories, including T-OPTICS [13], that incorporates a trajectory similarity function into the OPTICS [2] algorithm. CenTR-I-FCM [18], a variant of Fuzzy C-means, proposes a specialized similarity function that aims to tackle the inherent uncertainty of trajectory data.

Nevertheless, trajectory clustering is a computationally intensive operation and centralized solutions cannot scale to massive datasets. In this context, [3] introduces a scalable GPU-based trajectory clustering approach which is based on OPTICS [2]. Moreover, [21] attempts to identify frequent movement patterns from the trajectories of moving objects. More specifically, they propose a MapReduce approach by employing quadtree-based hierarchical grid in order to discover complex patterns of different granularity.

Subtrajectory clustering. Nonetheless, discovering clusters of complete trajectories can overlook significant patterns that might exist only for portions of their lifespan. To deal with this, another line of research has emerged, that of Subtrajectory Clustering. The predominant approach here is TraClus [9], a partition-and-group framework for clustering 2D moving objects (i.e. TraClus ignores the time dimension) that enables the discovery of common subtrajectories. The algorithm first partitions trajectories to directed segments (i.e., subtrajectories) whenever the shape of a trajectory changes significantly, by employing the minimum description length (MDL) principle. Subsequently, the resulting subtrajectories are clustered by employing a modified version of the DBSCAN algorithm, which is applicable to directed segments. Finally, for each identified cluster the algorithm calculates a “fictional” representative trajectory that best describes the corresponding cluster.

A more recent approach to the problem of subtrajectory clustering, is S2T-Clustering [20], where the goal is to partition trajectories into subtrajectories and then form groups of similar ones, while, at the same time, separate the ones that fit into no group, called outliers. It consists of two phases: a Neighborhood-aware Trajectory Segmentation (NaTS) phase and a Sampling, Clustering and Outlier (SaCO) detection phase. In NaTS the trajectories are split to subtrajectories by applying a voting and segmentation process that detects homogenized subtrajectories w.r.t. the density of their neighborhood, in contrast with TraClus where the splitting is performed based on the geometric attributes of the trajectories. In SaCO the most representative subtrajectories are selected to serve as the seeds of the clusters, around which the clusters are formed (also, the outliers are isolated). A slightly different approach is presented in QuT-Clustering [19] and [23], where the goal is, given a a temporal period of interest $W$, to efficiently retrieve the clusters and outliers at subtrajectory level, that temporally intersect $W$. In order to achieve this, a hierarchical structure, called ReTraTree (for Representative Trajectory Tree) that effectively indexes a dataset for subtrajectory clustering purposes, is built and utilized.

An alternative viewpoint to the problem of subtrajectory clustering is presented in [1], where the goal is to identify “common” portions between trajectories, w.r.t. some constraints and/or objectives, cluster these “common” subtrajectories and represent each cluster as a pathlet, which is a point sequence that is not necessarily a subsequence of an actual trajectory. A pathlet can be viewed as a portion of a path that is traversed by many trajectories. In order to solve this problem, the authors in [1] prove that this problem is NP-Hard and propose some approximation algorithms with theoretical guarantees, concerning the quality of the solution and the running time. Similarly, in [28] the goal is to identify corridors, which are frequent routes traversed by a significant number of moving objects. As already mentioned, all of the above subtrajectory clustering approaches are centralized and cannot scale to the size of today’s trajectory data.

3 Problem Formulation

Given a set $D$ of moving object trajectories, a trajectory $r\in D$ is a sequence of timestamped locations $\{r_{1},\dots,r_{N}\}$. Each $r_{i}=(loc_{i},t_{i})$ represents the $i$-th sampled point, $i\in{1,\dots,N}$ of trajectory $r$, where $N$ denotes the length of $r$ (i.e. the number of points it consists of). Moreover, $loc_{i}$ denotes the spatial location (2D or 3D) and $t_{i}$ the time coordinate of point $r_{i}$, respectively. A subtrajectory $r_{i,j}$ is a sub-sequence $\{r_{i},\dots,r_{j}\}$ of $r$ which represents the movement of the object between $t_{i}$ and $t_{j}$ where $i<j$ and $i,j\in{1,\dots,N}$. Let $d_{s}(r_{i},s_{j})$ denote the spatial distance between two points $r_{i}\in r$, $s_{j}\in s$. In our case we adopted the Euclidean distance, however, other metric distance functions might be applied. Also, let $d_{t}(r_{i},s_{j})$ denote the temporal distance, defined as $|r_{i}.t-s_{j}.t|$. Furthermore, let $\Delta t_{r}$ symbolize the duration of trajectory $r$ (similarly for subtrajectories).

3.1 Similarity between (sub)trajectories

Subtrajectory clustering relies on the use of a similarity function between subtrajectories. Although various similarity measures have been defined in literature, our choice of similarity function is motivated by the following (desired) requirements:

• Variable sampling rate and lack of alignment. We make the realistic assumption that the trajectories do not have a fixed sampling rate and that different trajectories might not report their position at the same timestamp.
• Variable trajectory length. We also assume that different trajectories might have different length (i.e. number of samples). This specification excludes euclidean-based similarity measures which deal with trajectories of equal length.
• Temporal displacement. A property that a desired similarity measure for (sub)trajectory clustering should hold, is to allow trajectories that have some temporal displacement to participate to the same cluster.
• Symmetry. Given a pair of (sub)trajectories $r$ and $s$, an appropriate similarity measure between $r$ and $s$ should have the property of symmetry (i.e. $Sim(r,s)$=$Sim(s,r)$).
• Efficiency. The computation of the similarity should be efficient enough in order to be able to deal with massive volumes of data, without compromising the quality of the results.

In order to meet with the aforementioned specifications we utilize the Longest Common Subsequence (LCSS) for trajectories, as defined in [26]. However, other trajectory similarity functions, which meet with the specifications set, are also applicable. More specifically, the LCSS utilizes two parameters, the parameter $\epsilon_{t}$ indicating the temporal range wherein the method searches to match a specific point, and the $\epsilon_{sp}$ parameter which is a distance threshold to indicate whether two points match or not. Hence, the similarity between two (sub)trajectories $r$ and $s$ is defined as:

[TABLE]

where $min(|r|,|s|)$ is the length of the longest common subsequence. Moreover, it holds that $Sim(r,s)=Sim(s,r)$.

However, LCSS returns the length of the longest common subsequence, which means that for a given point $r_{i}\in r$ that is matched with a specific point $s_{j}\in s$ the LCSS will consider the similarity between $r_{i}$ and $s_{j}$ as 1, regardless of their actual distance $d_{s}(r_{i},s_{j})$, which could vary from 0 to $\epsilon_{sp}$. Put differently, LCSS considers as equally similar all the points that exist within an $\epsilon_{sp}$ range from $r$, which is a fact that might compromise the quality of the clustering results. Ideally, given two matching points $r_{i}\in r$ and $s_{j}\in s$, $s_{j}$ ($r_{i}$, respectively) should contribute to $LCSS_{\epsilon_{t},\epsilon_{sp}}(r,s)$, proportionally to the distance $d_{s}(r_{i},s_{j})$. For this reason, we propose a “weighted” LCSS similarity between trajectories, that incorporates the aforementioned distance proportionality. In more detail, for each discovered longest common subsequence the similarity is defined as:

[TABLE]

where $(r_{k},s_{k})$ is a pair of matched points.

3.2 A Closer Look to the Subtrajectory Clustering Problem

Our approach to subtrajectory clustering splits the problem in three steps. The first step is to retrieve for each trajectory $r\in D$, all the moving objects, with their respective portion of movement, that moved close enough in space and time with $r$, for at least some time duration. Actually, this first step is a well-defined problem in the literature of mobility data management, known as subtrajectory join, and more specifically the case of self-join. In detail, the subtrajectory join will return for each pair of (sub)trajectories, all the common subsequencies that have at least some time duration, which are actually candidates for the longest common subsequence. Formally:

Problem 1**.**

(Subtrajectory Join) Given a temporal tolerance $\epsilon_{t}$, a spatial threshold $\epsilon_{sp}$ and a time duration $\delta t$, retrieve all pairs of subtrajectories $(r^{\prime},s^{\prime})\in D$ such that: (a) for each pair $\Delta t_{r^{\prime}},\Delta t_{s^{\prime}}\geq\delta t$, (b) $\forall r_{i}\in r^{\prime}$ there exists at least one $s_{j}\in s^{\prime}$ so that $d_{s}(r_{i},s_{j})\leq\epsilon_{sp}$ and $d_{t}(r_{i},s_{j})\leq\epsilon_{t}$, and (c) $\forall s_{j}\in s^{\prime}$ there exist at least one $r_{i}\in r^{\prime}$ so that $d_{s}(s_{j},r_{i})\leq\epsilon_{sp}$ and $d_{t}(s_{j},r_{i})\leq\epsilon_{t}$.

Figure 2 illustrates two trajectories $r$ and $s$ and their respective matching subtrajectories ($r_{4,8},s_{3,7}$). Each point of a trajectory defines a spatiotemporal ’neighborhood’ area around it, i.e. a cylinder of radius $\epsilon_{sp}$ and height $\epsilon_{t}$. In order for a pair of subtrajectories to be considered matching, each point of a subtrajectory must have at least one point of the other subtrajectory in its neighborhood, thus making the result symmetrical. Furthermore the duration of the match should be at least $\delta t$.

The second step takes as input the result of the first step, which is actually a trajectory and neighboring trajectories and aims at segmenting each trajectory $r\in D$ into a set of subtrajectories. The way that a trajectory is segmented into subtrajectories is neighbourhood-aware, meaning that a trajectory will be segmented every time its neighbourhood changes significantly, so as to result in homogeneous subtrajectories (w.r.t. their surrounding moving objects). Returning to Example 1, trajectory $A\rightarrow{D}$ should be segmented to $A\rightarrow{O}$ and $O\rightarrow{D}$, since at $O$ the cardinality and the composition of its neighbourhood changes significantly. The problem of trajectory segmentation can now be formulated as follows.

Problem 2**.**

(Trajectory Segmentation) Given a trajectory $r$, identify the set of timestamps $CP$ (cutting points), where the density (or alternatively the composition) of the neighborhood of $r$ changes significantly. Then according to $CP$, $r$ is partitioned to a set of subtrajectories $\{r^{\prime}_{1},\dots,r^{\prime}_{M}\}$, where $M=|CP|+1$ is the number of subtrajectories for a given trajectory $r$, such that $r=\bigcup_{k=1}^{M}r^{\prime}_{k}$ and $k\in[1,M]$.

Given the output of Problem 1, applying a trajectory segmentation algorithm for the trajectories $D$ will result in a new set of subtrajectories $D^{\prime}$.

The third step takes as input $D^{\prime}$ and the goal is to create clusters (whose cardinality is unknown) of similar subtrajectories and at the same time identify subtrajectories that are significantly dissimilar from the others (outliers). More specifically, let $C=\{C_{1},\dots,C_{K}\}$ denote the clustering, where $K$ is the number of clusters, and for every pair of clusters $C_{i}$ and $C_{j}$, with $i,j\in[1,K]$, it holds that $C_{i}\cap C_{j}=\text{\O}$. Now, let us assume that each cluster $C_{i}\in C$ is represented by one subtrajectory, called Representative, denoted as $R_{i}$. Actually, the problem of clustering is to discover clusters of objects such that the intra-cluster similarity is maximized and the inter-cluster similarity is minimized. Therefore, the problem of subtrajectory clustering can be formulated as an optimization problem as follows.

Problem 3**.**

(Subtrajectory Clustering and Outlier Detection) Given a set of subtrajectories $D^{\prime}$, partition $D^{\prime}$ into a set of clusters $C$ and a set of outliers $O$, where $D^{\prime}=C\cup O$, in such a way so that the Sum of Similarity between Cluster members and cluster Representatives (SSCR) is maximized:

[TABLE]

However, trying to solve Problem 3 by maximizing Equation (3) is not trivial, since the problem to segment trajectories to subtrajectories, select the set of representatives $R$ and its cardinality $|R|$ that maximizes Equation (3), has combinatorial complexity.

3.3 Distributed Subtrajectory Clustering

In this paper, we address the challenging problem of subtrajectory clustering in a distributed setting, where the dataset $D$ is stored distributed in different nodes, and centralized processing is prohibitively expensive.

Problem 4**.**

(Distributed Subtrajectory Clustering) Given a distributed set of trajectories, $D=\cup_{i=1}^{P}D_{i}$, where $P$ is the number of partitions of $D$, perform the subtrajectory clustering task in a parallel manner.

Actually, Problem 4 can be broken down to solving Problems 1, 2 and 3 (in that order) in a parallel/distributed way. In the following, we adopt this approach and outline a solution that is based on MapReduce.

4 Problem Solution

4.1 Overview

An overview of our approach is presented in Algorithm 1. Initially, we Repartition the data into $P$ equi-sized, temporally-sorted partitions (files), which are going to be used as input for the join algorithm in order to perform the subtrajectory join in a distributed way (line 3). Note that this is actually a preprocessing step that only needs to take place once for each dataset $D$. However, it is essential as it enables load balancing, by addressing the issue of temporal skewness in the input data. Subsequently, for each partition $D_{i}\in\cup_{i=1}^{P}D_{i}$ and for each trajectory we discover parts of other trajectories that moved close enough in space an time (line 5). Successively, we group by trajectory in order to perform the subtrajectory join (line 8). At this phase, since our data is already grouped by trajectory, we also perform trajectory segmentation in order to split each trajectory to subtrajectories (line 9). In turn, we utilize the temporal partitions created during the Repartition phase and re-group the data by temporal partition. For each $D_{i}\in\cup_{i=1}^{P}D_{i}$ we calculate the similarity between subtrajectories and perform the clustering procedure (line 12). At this point we should mention that if a subtrajectory intersects the borders of two partitions, then it is replicated in both of them. This will result in having duplicate and possibly contradicting results. For this reason, as a final step, we treat this case by utilizing the Refine Results procedure (line 14). Finally, a set $C$ of clusters and a set $O$ of outliers are produced.

4.2 Distributed Subtrajectory Join

As already mentioned, the first step is to perform the subtrajectory join in a distributed way. For this reason, we exploit the work presented in [22], coined DTJ, which introduces an efficient and highly scalable approach to deal with Problem 1, by means of MapReduce. More specifically, DTJ is comprised of a Repartitioning phase and a Query phase.

The Repartitioning phase is a preprocessing step that takes place only once and it is independent of the actual parameters of the problem, namely $\epsilon_{sp}$, $\epsilon_{t}$, and $\delta t$. The idea is to construct an equi-depth histogram based on the temporal dimension, where each of the $M$ bins contain the same number of points and the borders of each bin correspond to a temporal interval $[t_{i},t_{j})$. The histogram is constructed by taking a sample of the input data111In Hadoop, this is achieved using the InputSampler and TotalOrderPartitioner.. Then, the input data is partitioned to processing tasks based on the temporal intervals of the histogram bins. This guarantees temporal locality in each partition, as well as equi-sized partitions, thus balancing the load fairly.

In the Query phase, the actual join processing takes place. It consists of two steps, the Join and the Refine step, which are implemented as a Map and a Reduce function respectively. The output of this MapReduce job is for each trajectory $r\in D$ all the moving objects, with their respective portion of movement, that moved close enough in space and time for at least some time duration. In more detail, the output of DTJ is per trajectory and the tuples are of the form $<refTrajPoint_{i},\{MatchingPoints\}>$, where $refTrajPoint_{i}$ is the i-th point of the reference trajectory, with $i\in[1,N]$ and $MatchingPoints$ is a list of points of other trajectories that have been identified as join results by the DTJ query. In Figure 3, the DTJ query corresponds to Job 1 until the Refine() procedure.

For more technical details about the algorithms involved in DTJ and an extensive experimental study, we refer to [22].

4.3 Distributed Trajectory Segmentation

The Trajectory Segmentation algorithm (TSA) takes as input a single trajectory, along with information about its neighborhood, and partitions it to a set of subtrajectories. In this paper, we propose two alternative segmentation algorithms.

The first algorithm, coined $TSA_{1}$, identifies the beginning of a new subtrajectory whenever the density of its neighborhood changes significantly. Such a segmentation algorithm is reminiscent of the flock definition [8], where the identified groups need to be composed of at least $m$ objects. For this purpose, we use the concept of voting as a measure of density of the surrounding area of a trajectory. For a given point $r_{i}$ and any trajectory $s$, the voting $V(r_{i})$ is defined as:

[TABLE]

where, $s_{k}$ is the matching point of $s$ with $r_{i}$, as emitted by the subtrajectory join procedure. For a trajectory $r$ that consists of $N$ points $\{r_{1},\dots,r_{N}\}$, we compute its normalized voting vector $\overline{V}(r)$ as follows:

[TABLE]

Finally, the voting of a trajectory (or subtrajectory) is defined as:

[TABLE]

The second segmentation algorithm, coined $TSA_{2}$, identifies the beginning of a new subtrajectory whenever the composition of its neighborhood changes substantially. This segmentation algorithm is reminiscent of the moving cluster definition [7], where the identified groups need to share a sufficient number of common objects. Such an algorithm does not take as input the $\overline{V}(r)[]$ but instead, for each point $r_{i}\in r$, it takes as input a list $L(r_{i})[]$ of the trajectory ids that have been produced as output by the DTJ procedure.

The following example explains intuitively the difference between the two segmentation algorithms.

Example 2**.**

Consider the example of Figure 4(a) that illustrates five trajectories: $A\rightarrow{B}$, $A\rightarrow{C}$, $A\rightarrow{D}$, $C\rightarrow{B}$ and $D\rightarrow{B}$. Figures 4(b) and (c) depict the result of $TSA_{1}$ and $TSA_{2}$, respectively. In more detail, we can observe that both $TSA_{1}$ and $TSA_{2}$ segmented trajectory $A\rightarrow{D}$ to subtrajectories $A\rightarrow{O}$ and $O\rightarrow{D}$, due to the fact that after $O$, both the density and the composition of the neighborhood changes. The same holds for trajectories $A\rightarrow{C}$, $C\rightarrow{B}$ and $D\rightarrow{B}$, which are segmented to subtrajectories $A\rightarrow{O}$, $O\rightarrow{C}$, $C\rightarrow{O}$, $O\rightarrow{B}$, $D\rightarrow{O}$ and $O\rightarrow{B}$. However, when it comes to trajectory $A\rightarrow{B}$, we can observe that while $TSA_{2}$ segments it to subtrajectories $A\rightarrow{O}$ and $O\rightarrow{B}$, $TSA_{1}$ does not perform any segmentation. This is due to the fact that, after $O$, even though the density of the neighborhood remains the same (i.e. 3 moving objects), the composition of the neighborhood changes completely. In a subsequent step this will drive the clustering algorithm to identify, in the case of $TSA_{1}$ a flock-like cluster from $A$ to $B$, while in the case of $TSA_{2}$ two moving clusters from $A$ to $O$ and from $O$ to $B$.

Both segmentation algorithms share a common methodology, which employs two consecutive sliding windows $W_{1}$ and $W_{2}$ of size $w$ (i.e. $w$ samples) to estimate the point $r_{i}\in CP$ (cutting point) where the “difference” between the two windows is maximized. This methodology has been successfully applied in the past on signal segmentation [17, 16]. To exemplify, let us consider trajectory $A\rightarrow{D}$ of Example 2. For simplicity, we assume that the voting of the specific trajectory from $A$ to $O$ is 3 and from $O$ to $D$ is 1. Figure 5 illustrates the two sliding windows $W_{1}$ and $W_{2}$ that traverse the voting signal of trajectory $A\rightarrow{D}$.

Trajectory segmentation. Since the output of the DTJ algorithm is per trajectory, it is straightforward to give it as input to TSA which operates at the level of a trajectory. Moreover, the segmentation is performed in an embarrassingly parallel way, due to the fact that each trajectory can be processed by a different reduce task independently from others, as depicted in Figure 3. In more detail, for a given trajectory $r\in D$, $TSA_{1}$ first calculates the normalized voting vector $\overline{V}(r)[]$ and then performs the segmentation by utilizing it. Apart from $\overline{V}(r)[]$, the input of the TSA algorithm is two additional parameters: $w$ and $\tau$. The output is a vector $CP[]$, which keeps the starting position of each subtrajectory of $r$.

In more detail, as presented in Algorithm 2, two consecutive sliding windows of size $w$ are created over $\overline{V}(r)[]$, named $W_{1}$ and $W_{2}$ (line 4). These sliding windows move forward in time until $\overline{V}(r)[]$ is traversed. Here, $N$ is the number of points of trajectory $r\in D$. Then, for each window, the average normalized voting is computed (lines 5-6) and their absolute difference is stored in $d[]$, which is an array that stores all the differences between the sliding windows (line 7). Subsequently, we examine whether the current difference $d[n]$ is larger than the maximum difference $d_{max}$ and we update $d_{max}$ accordingly (line 8). Finally, if the difference $d[n]$ is higher than a threshold $\tau$ and is locally maximized, then, at that point, we segment the trajectory and we store the starting position of the new subtrajectory to $CP[]$ (lines 9-10).

On the other hand, the input of $TSA_{2}$ is a list of lists $L(r)[]$ for each $r\in D$. Similarly, two consecutive sliding windows $W_{1}$ and $W_{2}$ of size $w$ are created (line 4). Then, for each window, the union of lists is computed and stored in $l_{1}$ and $l_{2}$, respectively (lines 5-6). Successively, the Jaccard dissimilarity between $l_{1}$ and $l_{2}$ is computed and is stored to $d[]$, which is an array that stores all the similarities between the sliding windows (line 7). From then on, the algorithm is identical to $TSA_{1}$.

Similar subtrajectories. After trajectory segmentation, the next step is to calculate the similarity between all the pairs of subtrajectories, using Equation 2. This cannot be done completely after the segmentation at the Reducer phase of Job 1, illustrated in Figure 3, because at that point each reduce function has information only about the segmentation of the reference trajectory to subtrajectories. For this reason, at this point we cannot calculate the denominator of Equation 2. However, for each subtrajectory $r^{\prime}\in r$, where $r$ is the reference trajectory, we can calculate the similarity between the matching points (enumerator of Equation 2).

In more detail the output of each reduce function (Job 1 Figure 3) is a relation, called STP, which holds a set of key-value pairs of the form $<(r^{\prime}.ID,s.ID),\{(s_{f}.t,Sim(s_{f},r^{\prime}))$ $\dots$ $(s_{l}.t,Sim(s_{l},r^{\prime}))\}>$, where $s_{f},s_{l}$ are the temporal first and last point, respectively, of trajectory $s$ that “matches” with subtrajectory $r^{\prime}$. Moreover, in a separate relation, coined ST, we hold some extra information for each subtrajectory. More specifically, the tuples of $ST$ are key-value pairs, where the key is the subtrajectory identifier $<ID>$ and the value is of the form $<t_{s},t_{e},V,Card>$, where $t_{s}$ ($t_{e}$) is the starting time (ending time, respectively) of the subtrajectory, $V$ is the voting and $Card$ is the number of points which constitute the specific subtrajectory. Due to the fact that these two relations can be pretty large, we need to partition them into smaller files. In order to achieve this, we broadcast the load balanced temporal partitions that were created during the Repartitioning phase of DTJ. As illustrated in Figure 3, each reducer loads these partitions and assigns each subtrajectory (tuple of ST and STP) to all the partitions with which it temporally intersects. Subsequently, the tuples are grouped by temporal partition and each group is fed to a Mapper.

At this point, each Mapper has now all the information needed to calculate the similarity between all the pairs of subtrajectories (Equation 2), for each temporal partition separately. The similarity between subtrajectories is output in a new relation, called SP. Each tuple of this relation holds information about a subtrajectory $r^{\prime}$ and its similarity with all the other subtrajectories, whenever this similarity is larger than zero. More specifically, SP contains a set of key-value pairs where the key is the ID of the subtrajectory $(r^{\prime}.ID)$ and the value is a list $AdjLst$ containing elements of the form $(s^{\prime}.ID,Sim)$, where $s^{\prime}$ is a subtrajectory for which it holds that $Sim(r^{\prime},s^{\prime})>0$.

4.4 Distributed Clustering

Clustering. After having calculated the similarity between all pairs of subtrajectories for each temporal partition, we can proceed to the actual clustering and outlier detection procedure. The output of the similarity calculation process, namely $SP$, is actually an adjacency list. The intuition behind the proposed solution to Problem 3 is to select as cluster representatives, highly voted subtrajectories (Equation 6) that are not similar with the already selected representatives $R_{i}\in R$. Then, we assign each subtrajectory $r^{\prime}_{k}$ to the $R_{i}$ (and hence $C_{i}$) with which it has the maximum similarity $Sim(r^{\prime}_{k},R_{i})$.

The input of the clustering algorithm is $SP$, $ST$ and parameters $k$ and $\alpha$ and the output is the set of clusters $C$ and the set of outliers $O$. More specifically, $k$ is a threshold for setting a lower bound on the voting of a representative. This prevents the algorithm from identifying clusters with small support. Parameter $\alpha$ is a similarity threshold used to assign subtrajectories to cluster representatives. It ensures that a subtrajectory assigned to a cluster has sufficient similarity with the representative of the cluster. This actually poses a lower bound to the average distance between the representatives and the cluster members and, consequently, guarantees a minimum quality in the identified clusters (intra-cluster distance).

Lemma 1**.**

The average distance $\overline{d_{s}(r^{\prime},s^{\prime})}$, between a representative subtrajectory $r^{\prime}$ and a cluster member $s^{\prime}$ will always be at most $\epsilon_{sp}\cdot(1-\alpha)$.

[TABLE]

To begin with, we want to traverse the subtrajectories by their voting, in descending order (i.e. highly voted subtrajectories first). In order to achieve this, we need to sort $ST$ by $V$ (line 3). Subsequently, for each subtrajectory $st\in ST$ we examine whether it is already assigned to cluster (line 5). If $st$ is not assigned to any cluster and the voting of $st$ is less than $k$, then we add $st$ to the outliers set (line 21). Otherwise, we create a new cluster and consider $st$ as the representative (lines 6-7). Successively, we consult relation $SP$ and retrieve the adjacency list of $st$ (line 8). Then, for each element $l$ that belongs to the adjacency list of $st$, we examine if it is assigned to any cluster. If not, we investigate whether the similarity between $l$ and $st$ is greater or equal than the similarity threshold $\alpha$. If not, we add $l$ to the outlier set $O$, otherwise we assign it to the cluster led by $st$ and remove it from the outliers $O$, in case $l\in O$ (lines 9-13). If $l$ is assigned to a cluster, we examine whether the similarity of $l$ with $st$ is greater than the similarity with the representative of the cluster that $l$ is currently assigned. If this is the case, then we remove $l$ from the current cluster and assign it to the cluster led by $st$ (lines 17-19). Finally, we concatenate $C$ with $R$ (line 22) so as to return, except from the outlier set $O$, both cluster members and representatives.

Refinement of Results. At this point we successfully accomplished to deal with Problem 3 for each temporal partition. However, this might result in having duplicates due to the fact that each subtrajectory that temporally intersects multiple partitions is replicated to each one of them. The actual problem that lies here is not the duplicate elimination problem itself but the fact that the result for such a subtrajectory might be contradicting in different partitions. In more detail, for each partition, the clustering procedure will decide whether a subtrajectory is a Representative ($Repr$), a Cluster Member ($Cl$) or an Outlier ($Out$). Hence, for each intersecting subtrajectory $q$ and for each pair of consecutive partitions $(i,j)$ with which $q$ intersects, $q$ can have the following pairs of states: (a) $Out$-$Out$, (b) $Repr$-$Repr$, (c) $Cl$-$Cl$, (d) $Repr$-$Cl$ ($Cl$-$Repr$), (e) $Repr$-$O$ ($O$-$Repr$) and (f) $Cl$-$O$ ($O$-$Cl$).

In order to implement the above procedure we need to have all the information concerning the intersecting subtrajectories ($C$ and $O$) for all the Partitions sorted in time. To do this, we group the trajectories according to whether they are intersecting or not. As illustrated in Figure 3, the non-intersecting are emitted, since they are not affected, while the intersecting subtrajectories get sorted by partition. Hence, a Reducer will receive all the required information to make the appropriate decisions. In more detail, we sweep through the temporal dimension and for each pair of consecutive partitions we make the appropriate decisions.

For each of the above cases, as depicted in Algorithm 5, a decision has to be made, in order to eliminate duplicates and provide the correct result according to the problem definition. More specifically, in case of (a), $q$ is marked as outlier in both partitions, hence, we only need to eliminate duplicates. In case of (b), the two clusters are “merged”, since all of the subtrajectories that belong to them are similar “enough” with $q$, which is the representative of both clusters. In case of (c), let us assume that $q$ belongs to cluster $C_{i}(R(q))$ in Partition $i$ and $C_{i+1}(R(q))$ in Partition $i+1$. Then, $q$ is assigned to the cluster with which it has the largest similarity with its representative. In case of (d), $q$ remains to be a cluster representative and is removed from the cluster $C$ in which it is a member. Finally, in case of (e) and (f), $q$ is removed from $O$.

5 Complexity Analysis

The purpose of this section is to analyse and provide insight to the complexity of the different algorithms that are involved to the solution to the Distributed Subtrajectory Clustering problem, presented in this paper.

DTJ: The complexity of the Join algorithm is roughly $O(|D|log_{2}Q)$, with $Q$ being the average number of points per spatial index partition and $Q<<|D|$. The complexity of the Refine algorithm is $O(T\cdot SW\cdot dt\cdot l)$, where $T$ is the average number of points per trajectory, $SW$ is the average number of points contained in a $\delta t+2\epsilon_{t}$ window, $dt$ the average number of points contained in a $\delta t$ window and $l$ is average the size of the $MatchingPoints$ list. For more details about the complexity of the algorithms involved in DTJ please refer to [22].

Segmentation: The complexity of the $TSA_{1}$ algorithm is $O(l\cdot|T|)$, where $l$ is average the size of the “matching” list and $|T|$ is the average number of points per trajectory. The reason that we include $l$ to this analysis is that in order to perform $TSA_{1}$, we first need to calculate the normalized voting vector. The complexity of the $TSA_{2}$ algorithm is also $O(l\cdot|T|)$, since $l_{1}$ and $l_{2}$ are already sorted by trajectory id and the list intersection can take place in linear time to the size of the lists.

Clustering: The complexity of $Clustering$ algorithm is $O(|ST|\cdot log|ST|+|ST|\cdot|L|)$, with $|ST|$ being the number of subtrajectories, $|L|$ the average size of the adjacency list $AdjLst$ and $|ST|\cdot log|ST|$ is the sorting cost. Here, we should mention that $|ST|<<|D|$. Furthermore, $ST$ and $SP$ are implemented as HashMaps, hence key search has an $O(1)$ time complexity. The complexity of the $RefineResults$ algorithm is $O(M\cdot|P|\cdot|I|)$, where $M$ is the number of temporal partitions, $|P|$ is the average number of intersecting subtrajectories per partition and $I$ is the average size of the intersection. We should mention, here, that the intersection between two consecutive partitions is performed in linear time by utilizing HashSets sets.

6 Experimental Study

In this section, we present the findings of our experimental evaluation. The experiments were conducted in a 49 node Hadoop 2.7.2 cluster, provided by * okeanos*222IAAS service for the Greek Research and Academic Community https://okeanos.grnet.gr/home/. The master node consists of 8 CPU cores, 8 GB of RAM and 60 GB of HDD while each slave node is comprised of 4 CPU cores, 4 GB of RAM and 60 GB of HDD. Our configuration enables each slave node to launch 4 containers, thus up to 192 tasks (Map or Reduce) can be launched simultaneously. For our experimental study, we employed two real datasets that will assist us to evaluate the performance, scalability and effectiveness of our solution. Furthermore, we utilized a synthetic dataset that simulates the case of Figure 1 in order to verify that our solution operates as anticipated, given a dataset with a known ground truth. The real datasets are from two different domains, namely the urban and the maritime domain. In more detail, the first one, named SIS333This private dataset was kindly provided by Gruppo Sistematica SpA, is a 27GB proprietary insurance dataset of moving objects around Rome and Tuscany area, that contains approximately $2.2\times 10^{7}$ trajectories that correspond to $7.2\times 10^{8}$ points. The second one, coined Brest444https://zenodo.org/record/1167595#.XKHTyaRRVPa, is a 650MB publicly available AIS dataset of vessels moving in the wider Brest area, consisting approximately of $3.65\times 10^{5}$ trajectories that correspond $17\times 10^{6}$ points.

Our experimental methodology is as follows: Initially, in Section 6.2 we verify the correctness of our solution by applying it to a dataset with a known ground truth and compare our findings with T-OPTICS [13], a well-known entire trajectory clustering technique. Moreover, we compare our solution with TraClus [9] and S2T-Clustering [20], two state of the art subtrajectory clustering methods. Subsequently, in Section 6.3, we study the scalability of our solution by varying (a) the dataset size, and (b) the number of cluster nodes. Finally, in Section 6.4, we perform a sensitivity analysis in order to evaluate the effect of setting different values to the parameters of our solution, in terms of execution time and quality. Table 1 shows the experimental setting, where we vary the following parameters: $\epsilon_{sp}$, $\epsilon_{t}$, $\delta t$, $w$, $\tau$, $\alpha$ and $k$ and measure their effect in the performance and the effectiveness of our algorithms. We should mention that the default segmentation algorithm in our experimental study is $TSA_{1}$.

6.1 Parameter Setting

Setting the different parameters for different datasets can turn out to be an arbitrary procedure, which, in turn, can jeopardise the quality of the clustering results. For this reason, we provide some simple rules for setting the parameters relatively to the dataset being clustered, that do not compromise the quality of the results. In more detail, $\epsilon_{sp}$ can be set as a percentage of the dataset diameter. This, however, can be problematic when dealing with datasets having large spatial variation in their density (e.g. ports in the maritime domain). For this reason, we utilized the partitioning provided by the spatial index (QuadTree) of DTJ and calculated $\epsilon_{sp}$ for each point, as a percentage of the diameter of the cell of the QuadTree to which it belongs. Moreover, $\epsilon_{t}$ and $\delta t$ are calculated relatively to the average duration between two consecutive trajectory samples ($\approx$ 1200 sec for SIS and $\approx$ 950 sec for AIS Brest).

Parameter $w$ sets the size of the windows $W_{1}$ and $W_{2}$ upon which some measure is calculated. Small values on $w$ can affect the robustness of the estimation, thus resulting to over-segmentation. On the other hand, large values of $w$ can result to overlooking some cutting points due to the large window size. It has been observed that for $w\approx 20$ the robustness of the estimation is not affected and the size of the window is small enough so as not to overlook any cutting points. Concerning parameter $\tau$, our experiments show that the best result in terms of quality is achieved for $\tau\approx 0.4$ Finally, the values of $\alpha$ and $k$ can be set “around” the mean value of the similarity and the voting of the temporal partition, respectively, in terms of standard deviation. In fact, it has been observed that the average similarity and voting can produce clustering results of good quality. For more details about the effect, in terms of quality, of setting different values to the parameters of our solution, please refer to Section 6.4

6.2 Comparison with related work

Initially, so as to verify that our solution operates as expected, we utilize a synthetic dataset555The original dataset was found in [12] that simulates the case of Figure 1. The only difference is that the two outliers mentioned there ($O\rightarrow{A}$ and $O\rightarrow{B}$), will now form clusters. Hence, the ground truth for the synthetic cluster becomes $A\rightarrow{O}$, $B\rightarrow{O}$, $O\rightarrow{C}$, $O\rightarrow{D}$, $O\rightarrow{A}$ and $O\rightarrow{B}$.

In fact, as depicted in Figure 6(a), T-OPTICS identifies the six original routes: $A\rightarrow{B}$ (in red), $A\rightarrow{C}$ (in blue), $A\rightarrow{D}$ (in orange), $B\rightarrow{A}$ (in yellow), $B\rightarrow{C}$ (in light blue) and $B\rightarrow{D}$ (in purple). On the other hand, DSC identifies, with $Accuracy=100\%$ and $F$-$measure=1$, the six expected clusters of subtrajectories: $A\rightarrow{O}$(in red), $B\rightarrow{O}$ (in yellow), $O\rightarrow{C}$ (in blue), $O\rightarrow{D}$ (in light blue), $O\rightarrow{A}$ (in purple) and $O\rightarrow{B}$ (in green).

Subsequently, we compare DSC with two state of the art subtrajectory clustering algorithms, S2T-Clustering and TraClus. The metric that we employ in order to evaluate the quality of the outcome of the clustering procedure is the well-known RMSE metric, which is actually a measure of intra-cluster distance between the representatives and the cluster members. Hence the larger the RMSE, the lower the intra-cluster distance and consequently the quality of the clustering. It is obvious that, under this definition, RMSE is equivalent to SSRC (Equation 3). In order to perform this experiment, we utilized the 20% of each dataset which was further partitioned in 4 portions (25%, 50%, 75%, 100%). This choice was necessary because the centralized implementations of S2T-Clustering and TraClus could not scale with the full size of the datasets that we utilized.

As illustrated in Figure 7, DSC outperforms, in terms of RMSE, both TraClus and S2T-Clustering. In more detail, TraClus presents the largest RMSE which is somehow anticipated, since the specific algorithm utilizes a density-based approach to cluster subtrajectories, which in turn, through cluster expansion, can lead to spatially extended clusters. On the other hand, S2T-Clustering presents smaller RMSE than TraClus, due to the fact that it adopts a distance-based approach and discovers more compact clusters. However, DSC results in smaller RMSE than S2T-Clustering, mostly due to the fact that in the latter, two trajectories might end-up in the same cluster even if they have small “matching portions”. However, in DSC this “matching portions” should have a minimum ($\delta t$) duration.

6.3 Performance and Scalability

Initially, we vary the size of our datasets and measure the execution time of our algorithms. We show the impact of the individual steps: Join, RSE, Clustering and RefineResult using stacked bars. To study the effect of dataset size, we created 4 portions (20%, 40%, 60%, 80%) of the original datasets. RSE stands for the Refine and Segmentation procedure (Figure 3, Job 1, Reduce phase). As illustrated in Figures 8(a) and (b), as the size of the dataset increases, DSC appears to scale linearly. Subsequently, we keep the size of the datasets fixed (at 100%) and vary the number of nodes. As the number of nodes increases and the dataset size remains the same, it is expected that the execution time will decrease. Indeed, as depicted in Figures 8(c) and (d), as the number of nodes increases, DSC presents linear speedup. This linear behaviour, is somehow anticipated due to the fact that the DSC approach is dominated by DTJ, in terms of execution time, which presents linear speedup, as shown in [22].

Investigating further the performance of the different steps of our proposal, we can observe that, as expected, the execution time of the whole procedure is dominated by the Join step (Figure 3, Job 1, Map phase), followed by RSE. Finally, as anticipated, the Clustering and the RefineResults step (Figure 3, Job 2) present very good performance, since the computationally intensive part of the similarity matrix calculation has already been done as part of the previous steps.

6.4 Sensitivity Analysis

In this section, we perform a sensitivity analysis of all the involved parameters. More specifically, we vary each parameter presented in Table 1, while keeping the rest of them in their default value (bold), and we measure their effect in the execution time and the quality of the clustering results, in terms of RMSE. Figures  9(a) and (b) show that the parameters that appear to have a significant impact on execution time are $\epsilon_{t}$ and $\epsilon_{sp}$. This is justified from the fact that these parameters actually affect significantly the complexity of the Join step (Figure 3, Job 1, Map phase), which is the dominant cost of DSC. Another parameter that seems to have a perceivable effect on the execution time, is $\delta t$, which in fact “filters” the results of DTJ, thus fewer data reach the next steps.

Regarding the quality of the clustering results, as illustrated in Figure  9(c) and (d), all the parameters seem to have an effect over it. In more detail, the larger the values of $\epsilon_{t}$ and $\epsilon_{sp}$, the larger the RMSE. This behaviour is expected since we allow objects that are further away from a representative to participate to the same cluster. In contrast, as $\delta t$ increases, the RMSE decreases, which is also anticipated since it sets a lower bound to the longest common subsequence. Furthermore, all the parameters that control the segmentation have the same effect on the RMSE, i.e. the smaller (in length) the subtrajectories, the smaller the RMSE. This shows that breaking trajectories to subtrajectories has a positive effect on the quality of the clustering and justifies the motivation of our work. Moreover, as $\alpha$ increases the RMSE decreases, since for small values of $\alpha$, less similar objects are allowed to participate in a cluster. Finally, the larger the $k$ the smaller the RMSE, since it disallows the identification of clusters with small support.

7 Conclusions

In this paper, we addressed the problem of Distributed Subtrajectory Clustering by building upon a scalable subtrajectory join query operator in order to tackle the problem in an efficient manner. Subsequently, we proposed two alternative trajectory segmentation algorithms. Finally, we proposed a distributed clustering algorithm where the clusters are identified in a parallel manner and get refined as a final step. Our experimental study was performed on a synthetic and two large real datasets of trajectories from the urban and the maritime domain. As for future work, we plan to extend our solution with properties of density-based clustering algorithms. Furthermore, since our algorithm employs a single pass from the data we will investigate the possibility of addressing the same problem in a streaming environment.

8 Acknowledgements

This work was partially supported by projects datACRON (grant agreement No 687591), Track&Know (grant agreement No 780754) and MASTER (Marie Sklowdoska-Curie agreement N. 777695), which have received funding from the EU Horizon 2020 R&I Programme.

Appendix A Appendix

Proof of Lemma 1

Proof.

[TABLE]

∎