Online social networks have emerged as prominent platforms for individuals to rapidly share ideas and perspectives. However, their swift dissemination capabilities also make them powerful channels for the spread of misinformation. Such dissemination results in substantial economic and societal harm, highlighting the need for effective suppression. To support this practical demand, this paper investigates the influence minimization (IMIN) and blocker minimization (BM) problems. The IMIN problem aims to find a node set of size k (the given budget) to block, such that the reduction in influence spread of a given seed set S is maximized. The BM problem is the dual of IMIN, aiming to find a node set of minimum cardinality to block, such that the threshold condition is satisfied, i.e., the reduction in influence spread of S is not less than the given threshold η . Both problems are NP-hard and involve a non-submodular objective function. Existing IMIN solutions incur high computational costs and offer no approximation guarantees on influence spread reduction. To fill the gap, we build upon the sandwich strategy to develop the first efficient algorithm with data-dependent approximation guarantees for IMIN. In particular, we design non-trivial (1-1/e-ϵ ) -approximation algorithms to optimize the proposed submodular bounding functions. For the BM problem, the existing solution is of limited effectiveness and lacks theoretical guarantees for both node set cardinality and threshold condition satisfaction. In this paper, we design a heuristic and two bicriteria approximation algorithms to address the BM problem. The heuristic is efficient and satisfies the threshold condition, but fails to ensure near-optimal cardinality. The two approximation algorithms both provide guarantees on cardinality: the first attains a tighter approximation ratio at the expense of efficiency, while the second yields a slightly weaker ratio with improved efficiency. Finally, comprehensive experiments on 9 real-world datasets are conducted to validate the efficiency and effectiveness of the proposed techniques.
We study the distinctiveness maximization problem for datasets assemblage: assembling a set of datasets from a repository that satisfies a user-specified target schema and query set under a budget constraint, while maximizing the number of distinct tuples. This problem is NP-hard in two scenarios: (i) when the repository contains datasets conforming to the target schema, and (ii) when no dataset individually satisfies the schema and candidates must be constructed through joins. For the first scenario, a greedy algorithm with exact distinctiveness computation achieves a (1-e^-1)/2 -approximation ratio, but is costly due to exhaustive tuple-wise marginal gain computation. We therefore propose an efficient machine learning (ML)-based method that directly estimates the marginal distinctiveness gain of each candidate dataset, avoiding costly exact computations. For the second scenario, we integrate a column-level merging technique into our ML framework to construct candidate datasets and estimate their distinctiveness without physically materializing join results, supporting efficient assemblage over heterogeneous datasets. Extensive experiments on real-world data pools show that our methods consistently outperform relevant baselines in effectiveness, efficiency, and scalability. A downstream case study on two ML tasks further shows that our approach identifies datasets with more useful tuples and improves ML performance.
Text-to-Vis is an emerging task in the data engineering and mining area that aims to automatically generate data visualizations from natural language questions (NLQs). Despite their progress, existing text-to-vis models often heavily rely on lexical matching between words in the questions and tokens in data schemas. This overreliance on lexical matching may lead to a diminished level of model robustness against input variations. In this study, we thoroughly examine the robustness of current text-to-vis models, an area that has not previously been explored. In particular, we construct the first robustness dataset nvBench-Rob, which contains diverse lexical and phrasal variations based on the original text-to-vis benchmark nvBench. Then, we found that the performance of existing text-to-vis models on this new dataset dramatically drops, implying that these methods exhibit inadequate robustness overall. To this end, we propose a novel framework based on Retrieval-Augmented Generation (RAG) technique, named GRED, specifically designed to address input perturbations in these two variants. The framework consists of three parts: NLQ-Retrieval Generator, Visualization Query-Retrieval Retuner and Annotation-based Debugger, which are used to tackle the challenges posed by natural language variants, programming style differences and data schema variants, respectively. Furthermore, we extend the framework, named C C, which further mitigates the uncertainty in visualization caused by ambiguous NLQ. It chooses the clause with the largest expected reduction of uncertainty under an elicited heuristic candidate-confidence measure and interacts with users for clarification to resolve ambiguity. This targeted interaction ensures that the resulting visualization more accurately reflects the user’s actual intent. Extensive experimental evaluations show that, compared to the state-of-the-art model Prompt4Vis in the Text-to-Vis field, GRED and C C perform better in terms of model robustness, with more than 40
Formal feature explanations strictly maintain perfect conformity but are intractable to compute, while heuristic methods are much faster but can lead to problematic explanations due to lack of conformity guarantees. We propose relative keys that have the best of both worlds. Relative keys associate feature explanations with a context, and warrant perfect conformity over the context as formal explanations do, whilst being orders of magnitudes faster and working for complex blackbox models. Based on it, we develop , an add-on for database systems to compute explanations of models they host, with provably bounded conformity and succinctness. We show that computing the most succinct relative keys is -complete and develop various algorithms for it with performance guarantees. Using 10 real-life datasets and 8 state-of-the-art explanation methods, we demonstrate that explains cases where existing methods cannot, and provides more succinct explanations with perfect conformity for cases they can; moreover, it is 2 orders of magnitude faster.
Answering an unbounded number of multi-dimensional range queries while preserving privacy is a significant problem that has been the focus of recent studies since range queries serve as a core component of many data analysis tasks. Existing techniques that use local differential privacy (LDP), which adds noise to users’ data locally, make assumptions that significantly affect utility. In particular, they assume that all attributes in a dataset are correlated and materialize all pair-wise grids/trees. Moreover, they assume that each pair-wise correlation is equally relevant when answering queries. These assumptions result in a low signal/noise ratio, especially for datasets with a large number of attributes. To address the deficiency of existing techniques, we propose a new approach to answer multi-dimensional range queries that leverages multi-dimensional correlations and workload characteristics to selectively choose the data that is collected under the LDP model. Our approach first leverages the availability of a small number of DP users to build a correlation model to determine how attributes are correlated. Then, we use the notion of multi-dimensional grids to capture multi-dimensional correlations. That allows us to materialize fewer grids, boosting the signal/noise ratio. Finally, we propose a new optimization step that makes use of available workload characteristics to identify the user distribution that minimizes the total error when answering multi-dimensional queries among users during the grid assignment process. We conduct extensive experiments on real and synthetic datasets and demonstrate the superiority of our method over existing approaches.
Spatial range joins have many applications, including geographic information systems, location-based social networking services, neuroscience, and visualization. However, joins incur not only expensive computational costs but also too large result sets. A practical and reasonable approach to alleviating these issues is to return random samples of the join results. Although this is promising and sufficient for many applications involving spatial range joins, efficiently computing random samples is not trivial. This is because we must obtain random join samples without running spatial range joins. We address this challenging problem for the first time and aim at designing time- and space-efficient algorithms. First, we design baseline algorithms that employ existing random sampling techniques and show that they are not efficient. We then propose a new data structure that can deal with our problem in Õ(n + m + t) expected time and O(n+m) space, where n and m are the sizes of two point sets and t is the required number of samples. Furthermore, we devise a new streaming algorithm that obtains t random samples in Õ(n + m + t) expected time and O(m+t) space for the case where one dataset consists of n streaming points. We conduct extensive experiments using four real spatial datasets, and the results demonstrate that our algorithms are significantly faster than the baselines in most tests.
Explanation techniques such as local interpretable model-agnostic explanation (LIME) provide reasons behind decisions made by machine-learning models. These methods typically use a set of features and their values as inputs and identify those that significantly influence the final decision. However, machine-learning models for entity matching operate on two sets of tokens or records, each representing an entity, to determine whether they refer to the same real-world entity. Explanations for entity-matching decisions are more convincing when they highlight contributing pairs of tokens within the pair of records, rather than focusing on individual tokens alone. In this sense, existing explanation techniques are insufficient for entity matching. Therefore, we propose a new method, Pair INterpretation for Entity matching (PINE), which takes two records as input, and outputs correlated token pairs as an explanation for an entity-matching decision. Our extensive experiments on public datasets demonstrate that the extracted token pairs exhibit strong correlations and serve as interpretable evidence for matching records.
Unsupervised representation learning (URL) has great potential for multivariate time series analytics due to its capability to learn generalizable representation for many downstream tasks without using expensive labels. However, existing URL methods usually adopt the models originally designed for other domains (e.g. vision and language) to encode the time series data and rely on strong assumptions to design learning objectives, which limits their representation ability. To address these problems, we propose a novel URL framework for multivariate time series that aims to learn shapelet-based representation specific to time series via contrastive learning. To the best of our knowledge, we are the first to explore shapelet-based embedding in general-purpose URL. To achieve this goal, we particularly design a unified shapelet-based encoder and a novel learning objective of multi-grained contrasting and multi-scale alignment, and develop a data augmentation library to improve the generalization. To further enable efficient training under constrained GPU memory based on the widely used activation checkpointing (AC) technique, considering the limitations of existing general AC planning methods, we propose the first memory-aware AC planner customized for our shapelet-based model. We conduct extensive experiments using tens of real-world datasets and evaluate our proposal on many downstream tasks, e.g., classification, clustering, anomaly detection, etc. The results demonstrate the superiority of our method against not only URL competitors, but also techniques specially designed for downstream tasks, and showcase the effectiveness of our AC planner in improving training efficiency with limited GPU memory. Our code has been made publicly available at https://github.com/real2fish/CSL .
Due to the increasing demand for extreme-scale time-series data workloads in data centers, it is required to build a high-performance semantic caching that leverages the semantics and results of historical queries to answer new queries. Existing caching solutions either ignore query semantics, offering suboptimal performance, or focus only on specific scenarios with limited functionality. In this paper, we summarize time-series query patterns and propose the definition of semantic time-series caching for the first time. Accordingly, we present STsCache, a semantic time-series caching system on hybrid memory–flash storage. We propose a series of optimizations, such as slab-based semantic data management, semantic index, semantic value-driven batch eviction, deduplication insertion, and lazy compaction. We evaluated STsCache via benchmarks and production environments. STsCache can increase throughput of popular time-series databases (InfluxDB, TimescaleDB) by 4.8-10.8 × and reduce latency by 79.9 × , reduce latency by 59.4
We show that LLMs benefit from succinct, distilled documentation of SQL constructs that can be retrieved on demand—avoiding the need to parse and chunk web documentation or overload context windows with full manuals. Using DuckDB as our primary case study, we analyze query logs from MotherDuck, a cloud analytics platform built on DuckDB, to show that real-world SQL extends far beyond analytical queries, with users frequently employing dialect-specific functionality that LLMs struggle with. We develop DuckDB-DocBench to evaluate six LLMs, finding that without additional knowledge they achieve only around 60
Attributed community search (ACS) aims to identify subgraphs satisfying both structural cohesiveness and attribute homogeneity in attributed graphs, given a query consisting of query nodes and query attributes. Previously, algorithmic approaches deal with ACS through a two-stage paradigm, which suffers from structural inflexibility and attribute irrelevance. To overcome these limitations, learning-based approaches have recently been proposed to learn both structures and attributes simultaneously as a one-stage paradigm. However, these approaches train a transductive model that assumes the graph used for inference on unseen queries is the same as the graph used for training. That limits the generalization and adaptation of these approaches to different heterogeneous graphs. In this paper, we propose a new framework, Inductive Attributed Community Search, ^+ , based on inductive learning, which can infer new queries for different communities and graphs. Specifically, ^+ employs an encoder-decoder neural architecture to handle one ACS task at a time, where a task consists of a graph with only a few queries and their corresponding ground-truth. We design a three-phase workflow, ‘training, adaptation, inference refinement’, that learns a shared model to absorb and induce prior effective common knowledge about ACS across different tasks. The shared model can then swiftly adapt to a new task with a small number of ground-truth labels. We conduct substantial experiments on 8 real-world datasets to verify the effectiveness of ^+ . Our approach ^+ achieves average absolute improvements of 29.96% in -score for ACS tasks.
The minimum spanning tree (MST) problem is a fundamental graph problem with widespread applications. However, most existing research on MST focuses on graphs without temporal annotations. This paper investigates the MST problem in the context of temporal graphs. Given an undirected weighted temporal graph, the goal is to compute the MST of the graph within a time window. To overcome the inefficiency of the online algorithm, we propose several index-based query algorithms with provable complexity bounds. Experiments on real-world datasets demonstrate that the proposed methods significantly outperform the baseline online algorithm. Notably, the Γ_b index, which balances query efficiency and space usage, achieves an average 57× speedup over the online algorithm, while incurring only a 2.82× space overhead on large datasets compared to the original graph. Overall, the proposed indices offer strong performance both theoretically and empirically.
Hypergraph decomposition is a fundamental problem in hypergraph analysis which breaks down hypergraphs into cohesive subgraphs and functional units with dense interactions. Hyperedge intersections and overlaps capture the unique property of shared elements (vertices) between groups (hyperedges) in hypergraphs, revealing cohesive substructures not apparent when focusing solely on individual connections. Despite the significance of hyperedge overlap as a measure of hypergraph cohesiveness, existing models for hypergraph decomposition fail to capture this feature. In this paper, we study the problem of hypergraph decomposition with intersection bounds. We propose the (k, s)-core, a new cohesive subgraph model incorporating both a vertex degree constraint k and a hyperedge intersection constraint s. This model includes two types: (1) strong (k, s)-cores, where connected hyperedges share at least s vertices, enforcing strong hyperedge overlap, and (2) weak (k, s)-cores, where hyperedges are connected through s-walks, allowing for a looser overlap. We prove that our definition of (k, s)-cores exhibits uniqueness and hierarchical properties. Based on the properties, we develop two decomposition algorithms: a bottom-up algorithm for strong (k, s)-cores, which uses a heuristic hyperedge removal mechanism to maintain consistent decomposition results and employs a union-find data structure for efficient connectivity identification, and a top-down algorithm for weak (k, s)-cores that preserves the subgraph containment relationship. Our algorithms achieve traversal efficiency by processing each hyperedge in the hypergraph only once. Additionally, all (k, s)-cores can be efficiently stored with minimal memory overhead. Comprehensive experiments and case studies show that the (k, s)-core model outperforms existing methods in capturing cohesive subgraphs with overlaps in hypergraphs. Furthermore, the proposed algorithms demonstrate high efficiency and scalability, making them well-suited for real-world hypergraphs.
Developing stateful cloud applications, such as low-latency workflows and microservices with strict consistency requirements, remains arduous for programmers. The Stateful Functions-as-a-Service (SFaaS) paradigm aims to serve these use cases. However, existing approaches provide weak transactional guarantees or perform expensive external state accesses requiring inefficient transactional protocols that increase execution latency. In this paper, we present Styx, a novel dataflow-based SFaaS runtime that executes serializable transactions consisting of stateful functions that form arbitrary call-graphs with exactly-once guarantees. Styx extends a deterministic transactional protocol by contributing: i) a function acknowledgment scheme to determine transaction boundaries required in SFaaS workloads, ii) a function-execution caching mechanism, and iii) an early-commit reply mechanism that substantially reduces transaction execution latency. In addition, Styx’s elasticity supports state migration for load balancing using scale-up and scale-down operations when workloads introduce uneven overhead among workers. Experiments with the YCSB, TPC-C, and Deathstar benchmarks show that Styx outperforms state-of-the-art approaches by achieving at least one order of magnitude higher throughput while exhibiting near-linear scalability and low latency. Moreover, state migration experiments with YCSB and TPC-C show that Styx’s approach to state migration outperforms the baseline, a stop and restart migration approach tailored to Styx, by adapting swiftly to workload changes while maintaining low latency.
In this paper, we investigate Diversity-aware k-Maximum Inner Product Search (DkMIPS), an essential problem in recommendation and information retrieval tasks where balancing relevance and diversity is crucial for user satisfaction and engagement. Vanilla kMIPS prioritizes relevance over diversity, often yielding highly homogeneous search results. In addition, existing DkMIPS methods remain limited in effectiveness and efficiency. To address these issues, we introduce a novel DkMIPS formulation that integrates relevance and diversity into a unified objective, with a controllable parameter λ that allows users to adjust the level of diversity to their specific needs. We propose two scan-based algorithms, Greedy and DualGreedy, that leverage submodularity to provide DkMIPS results with theoretical guarantees. Furthermore, we incorporate a lightweight Ball-Cone Tree (BC-Tree) index to improve the query efficiency of Greedy and DualGreedy. Extensive experiments on real-world datasets for recommendation and document retrieval tasks show that our proposed algorithms consistently achieve a better balance between diversity and relevance than several state-of-the-art kMIPS and DkMIPS methods, while outperforming existing DkMIPS methods in terms of efficiency and scalability. Our code is publicly available at https://github.com/HuangQiang/DiverseMIPS .
Graph Neural Networks (GNNs) have become essential for solving graph-level tasks, such as classification and regression, across diverse domains including social networks and biology. However, existing GNNs struggle with the expressivity that captures complex structural patterns, and the generalization that ensures robust performance on diverse and noisy datasets. To address these challenges, we propose a novel GNN model that integrates a k-path rooted subgraph encoder, an adaptive graph contrastive learning approach, and a consistency-aware loss. The k-path rooted subgraph encoder enhances expressivity by capturing and distinguishing intricate substructures, with theoretical guarantees for counting paths and cycles. The adaptive graph contrastive learning framework improves generalization by generating domain-aware graph augmentations based on edge importance, while the consistency-aware loss ensures task-relevant properties are preserved across augmented views. Extensive experiments on 26 datasets spanning graph classification, regression, and realistic scenarios such as noise, class imbalance, and few-shot learning show that our model achieves superior performance against 18 state-of-the-art GNN models in both effectiveness and efficiency. The code is released in https://anonymous.4open.science/r/GEGNN .
Traditional rank-aware processing assumes a dataset that contains available options to cover a specific need (e.g., restaurants, hotels, etc) and users who browse that dataset via top-k queries with linear scoring functions, i.e., by ranking the options according to the weighted sum of their attributes, for a set of given weights. In practice, however, user preferences (weights) may only be estimated with bounded accuracy, or may be inherently imprecise due to the inability of a human user to specify exact weight values with absolute accuracy. Motivated by this, we define the constrained-preference top-k ( CT ) query. Given an approximate description of the weight values, CT reports all options that may belong to the top-k set. Our CT algorithm assumes that the dataset is indexed with a general-purpose index (e.g., an R-tree) and delivers efficient processing, be it when data and index are in memory, or on the disk. Furthermore, we delve deeper into the special and highly practical case of CT for top-record sets (i.e., k=1 ), termed CT^1 , and devise a specialized method for it. Our CT^1 algorithm offers node-access optimality, i.e., a guarantee to access the minimum number of index nodes. This translates to optimal I/O cost (in the disk-based scenario) and to significant computation savings (which is relevant in both the disk-based and the memory-based scenarios).
Most large enterprises build predefined data pipelines and execute them periodically to process operational data using SQL queries for various tasks. A key issue in minimizing the overall makespan of these pipelines is the efficient scheduling of varying concurrent queries within the pipelines. Existing tools mainly rely on simple heuristic rules due to the difficulty of expressing the complex features and mutual influences of queries. The latest reinforcement learning (RL) based methods have the potential to capture these patterns from feedback, but it is non-trivial to apply them directly due to the large scheduling space, high sampling cost, poor sample utilization, and limited generalization ability. Motivated by these challenges, we propose BQSched ^+ , a generalizable RL-based Scheduler for varying Batch concurrent Queries. Specifically, we design a grouped attention-based state representation that captures the complex query patterns efficiently by incorporating the interaction patterns of different query groups and supports varying batch queries. We also propose IQ-PPO-m, an auxiliary task-enhanced proximal policy optimization (PPO) algorithm with multi-task balancing, to fully exploit the rich signals of Individual Query completion in logs and enable the learned policy to adapt to varying query sets. Based on the RL framework above, we further introduce three optimization strategies, including adaptive masking to prune the action space, scheduling gain-based query clustering to deal with large query sets, and an incremental simulator to reduce sampling cost. Extensive experiments show that BQSched ^+ can significantly improve the efficiency and stability of batch query scheduling, while also achieving remarkable scalability and generalizability in both data and queries. For example, across all DBMSs and scales tested, BQSched ^+ reduces the overall makespan of batch queries on TPC-DS benchmark by an average of 34 ^+ is available at https://github.com/chxu2000/BQSched .
