MasterMovelets: discovering heterogeneous movelets for multiple aspect trajectory classification

Abstract

In the last few years trajectory classification has been applied to many real problems, basically considering the dimensions of space and time or attributes inferred from these dimensions. However, with the explosion of social media data and the advances in the semantic enrichment of mobility data, a new type of trajectory data has emerged, and the trajectory spatio-temporal points have now multiple and heterogeneous semantic dimensions. By semantic dimensions we mean any type of information that is neither spatial nor temporal. As a consequence, new classification methods are needed to deal with this new type of data. The main challenge is how to automatically select and combine the data dimensions and to discover the subtrajectories that better discriminate the class. In this paper we propose MasterMovelets, a new parameter-free method for trajectory classification which finds the best trajectory partition and dimension combination for robust high dimensional trajectory classification. Experimental results show that our approach outperforms state-of-the-art methods by reducing the classification error up to $63\%$, indicating that our proposal is very promising for multidimensional sequence data classification.

Appendices

Appendix A: Computing element distance vectors

In this “Appendix” we detail the function $ComputeElementDistanceVectors()$, introduced in Algorithm 1, for computing element distance vectors. This function computes the distance between all dimensions of trajectory elements in $T$ and all elements in $\mathbf{T }$, and is detailed in Algorithm 4. This algorithm has as input the multidimensional trajectory $T$ and the set of multidimensional trajectories $\mathbf{T }$, and as the output a 4-dimensional array $A_1$ containing all element distance values.

Algorithm 4 computes for trajectory $T$ the distance between all multidimensional trajectory elements in $T$ and all trajectory elements in $\mathbf{T }$ and stores the distance values in a 4-dimensional array, called $A_1$ (lines 2 to 12). In this loop, the algorithm explores each trajectory point in $T$ at position $j$ (lines 4 to 11) and for the $j$-th trajectory point in $T$ it explores, for each dimension $d$, each trajectory point in $T_i$ at position $k$ (lines 5 to 10). In the most internal loop it performs the distance computation between the $j$-th trajectory point in $T$ and the $k$-th trajectory point in $T_i$, represented by $T[j]$ and $T_i[k]$, respectively, at dimension $d$ (line 7). The distance function $ElementDistance()$ is specific for each dimension. After computing the distance value, it calculates and stores the square of the distance value into $A$. The 4-dimensional array $A$ is indexed by $i$, $j$, $d$, and $k$, in order to store for the $i$-th trajectory the distance values between all pairs $T[j]$ and $T_i[k]$, at dimension $d$.

Appendix B: Computing subtrajectory distance vectors

In this “Appendix” we detail the function $ComputeSubtrajectoryDistanceVectors()$, introduced in Algorithm 1, for computing subtrajectory distance vectors. This function computes the distance between all subtrajectories of length $w$ in $T$ and all subtrajectories in the set $\mathbf{T }$ with the same length. Computing distance between trajectory elements and subtrajectories taking into account multiple dimensions in an efficient way requires using a dynamic programming strategy, to avoid repeating distance computation. It uses the subtrajectory distance values calculated for length $(w-1)$ and the element distance values in $A_1$ to compute the subtrajectory distance values for length $w$. This function is detailed in Algorithm 5, that has as input the multidimensional trajectory $T$, the set of multidimensional trajectories $\mathbf{T }$, the arrays $A_{w-1}$ and $A_1$, which are the subtrajectory distance values calculated for length $(w-1)$ and the element distance values, respectively, and $w$ that is the length of the subtrajectory distances to be calculated. The output of this algorithm is a new array $A_{w}$ containing the distance values for a subtrajectory of length $w$.

Similarly to algorithm 4, the four nested loops of Algorithm 5 compute the distances between all subtrajectories of length $w$ in $T$ and all subtrajectories of length $w$ in $\mathbf{T }$ in all dimensions. This computation is fulfilled with a simple sum of the distance of the subtrajectories of length $(w-1)$ with the distance between the next element of the two subtrajectories of length $(w-1)$ and the result is stored in the array $A_w$ (lines 7 to 10).