TUCKET: A Tensor Time Series Data Structure for Efficient and Accurate Factor Analysis over Time Ranges

TL;DR

TUCKET addresses the challenge of efficient and accurate Tucker decomposition range queries on evolving tensor time series with streaming updates. It introduces a stream-segment-tree data structure that prunes the hit set and stitches preprocessed subtensor decompositions, achieving range-query time $O(r^p D s + r^{2p-2}(D+L) + \log T)$ with $s=O(\log L)$ and height $O(\log T)$. The approach yields near-linear space $O((prD+r^p)T + rT\log T)$ and amortized update cost, while empirical evaluation shows at least 3x lower latency and 1.4x smaller reconstruction error than Zoom-Tucker on real datasets. TUCKET's GPU-accelerated stitching and pruning yield strong practical impact for online, large-scale tensor time-series analytics and provides a foundation for future extensions to other tensor decompositions and sparse data.

Abstract

Tucker decomposition has been widely used in a variety of applications to obtain latent factors of tensor data. In these applications, a common need is to compute Tucker decomposition for a given time range. Furthermore, real-world tensor time series are typically evolving in the time dimension. Such needs call for a data structure that can efficiently and accurately support range queries of Tucker decomposition and stream updates. Unfortunately, existing methods do not support either range queries or stream updates. This challenging problem has remained open for years prior to our work. To solve this challenging problem, we propose TUCKET, a data structure that can efficiently and accurately handle both range queries and stream updates. Our key idea is to design a new data structure that we call a stream segment tree by generalizing the segment tree, a data structure that was originally invented for computational geometry. For a range query of length $L$, our TUCKET can find $O(\log L)$ nodes (called the hit set) from the tree and efficiently stitch their preprocessed decompositions to answer the range query. We also propose an algorithm to optimally prune the hit set via an approximation of subtensor decomposition. For the $T$-th stream update, our TUCKET modifies only amortized $O(1)$ nodes and only $O(\log T)$ nodes in the worst case. Extensive evaluation demonstrates that our TUCKET consistently achieves the highest efficiency and accuracy across four large-scale datasets. Our TUCKET achieves at least 3 times lower latency and at least 1.4 times smaller reconstruction error than Zoom-Tucker on all datasets.

Figures (9)

• Figure 1: Case study on Air Quality data (see Section \ref{['subsec:exp-case-study']})
• Figure 2: Illustration of range queries of Tucker decomposition. It is inefficient to directly apply Tucker-ALS for each range query from scratch. Instead, we aim to design a data structure that can efficiently and accurately answer range queries of Tucker decomposition without re-computing from scratch for each query.
• Figure 3: Illustration of our TUCKET over timespan $[0,9)$. It has height $5=\lceil\log_29\rceil+1$. When answering a range query $[T_\textnormal{s},T_\textnormal{e})=[1,6)$ with pruning threshold $\theta=0.7$, node $\langle4\rangle$ is a partial hit because $|[1,6)\cap[0,4)|=|[1,4)|\ge 0.7|[0,4)|$, and node $\langle10\rangle$ is an entire hit because $[4,6)\subseteq[1,6)$.
• Figure 4: Comparison in the latency of range queries. Our TUCKET (green dotted line) consistently achieves the lowest latency for all query ranges while the performance of other methods varies drastically across datasets.
• Figure 5: Scalability tests

Theorems & Definitions (10)

• lemma 1: Hit set v.s. height
• theorem 1: Logarithmic height
• proposition 1: Space complexity
• theorem 2: Optimality & complexity of Algorithm \ref{['alg:recall']}
• lemma 2: Time complexity of the temporal mode
• lemma 3: Time complexity of the non-temporal modes
• proposition 2: Error bound
• proposition 3: Time complexity
• theorem 3: Logarithmic height
• proposition 4: Time complexity