Accurate multi-label classification of thoracic diseases from chest X-rays continues to be challenging due to strong inter-class correlations and limited generalization of traditional convolutional approaches. In this work, we propose a Causal-Aware Swin Transformer (CAST) framework that integrates causal inference components with Masked Autoencoder (MAE) pretraining, for better representation learning on the NIH ChestX-ray14 dataset. In particular, we develop a Causal Attention module that explicitly learns the causal contribution of latent features while contrasting original and counterfactual representations, allowing the network to focus on cues related to the disease while suppressing spurious correlations. The Swin Transformer backbone, initialized with MAE pretraining, also enhances the model's ability to learn hierarchically from limited supervision. Our empirical evidence shows improved classification performance in 14 categories of thoracic disease, achieving higher mean AUC than existing state-of-the-art methods. This proposed framework highlights the effectiveness of combining causal reasoning with transformer based methods as a promising approach for interpretable and robust multi-label modeling for medical image classification.

As software systems scale, fault detection and localization become increasingly complex due to intricate module interactions. Logging is essential for diagnosis, yet an analysis of 1158 bug reports from the Bugs.jar dataset shows that faultrelated variables have only 13.16% log coverage, leading to incomplete diagnostics, prolonged troubleshooting, and higher maintenance costs. Existing logging enhancement methods focus on source code analysis during development, lacking adaptability to deployed systems, while runtime modifications are often costly and impractical. To address these challenges, this paper presents VarFR, a novel bytecode-level approach for dynamically tracking fault-related variables and enhancing log coverage without modifying the source code. VarFR employs a recommendation model that constructs a bytecode multi-feature fusion graph by integrating bytecode semantics, method control flow, and local variable metadata. By improving fault observability at the bytecode level, the proposed approach has the potential to facilitate debugging, reduce maintenance overhead, and enhance software adaptability, thereby supporting the long-term evolution of software systems. Experimental results on the Bugs.jar dataset demonstrate that VarFR significantly outperforms baseline models in fault-related variable recommendation, underscoring its effectiveness in improving software maintainability and reliability.

Service-oriented architectures involve complex interactions, making failure detection and diagnosis challenging. Traditional static log statements often miss critical variables and lack runtime flexibility, resulting in limited observability. To address this, we propose a bytecode-level variable monitoring approach using the ASM library. Our tool transparently instruments service bytecode, enabling dynamic, source-free monitoring with minimal overhead. We further introduce a fusion model that analyzes bytecode semantics and structure to recommend critical variables at runtime. This enhances service observability and supports more efficient failure diagnosis.

Script event prediction involves inferring subsequent events in a sequence from incomplete scripts. Despite the success of models pretrained with external knowledge, challenges persist. Discourse-based methods capture only explicit event relations, missing implicit ones, and constructing knowledge bases is costly and time-consuming. In contrast, models without external knowledge often focus on token-level semantics, overlooking critical event-level information. To address these limitations, we propose a contrastive fine-tuning model based on semantic similarity of general sentence embeddings. Our approach calculates similarity between generated and candidate sentences using an event-level blank infilling strategy during pre-training, eliminating the need for external knowledge. Fine-tuning is performed with a custom contrastive loss based on semantic similarity, enabling event prediction without reliance on external knowledge or added model complexity. Experiments on the Multi-Choice Narrative Cloze (MCNC) task demonstrate that our method outperforms state-of-the-art baselines. Even without pre-training, our fine-tuning approach matches the performance of competitive models.

The task of converting monolithic programs to mi-croservices architecture is complex, hindered by the intertwined nature of program control and data flows. Conventional methods for microservice extraction often fall short in capturing the essen-tial connections within a monolithic structure and in propagating properties to distant neighbors for effective clustering. To address these issues, we introduce an innovative graph-based deep clustering technique that utilizes both control flow and data flow graphs. This approach offers a thorough analysis of class interactions within monolithic applications, facilitating accurate identification and extraction of microservices. Furthermore, we present the Microservice Extraction Graph Neural Network (MEGNN), an advanced graph attention network designed to enhance message transmission depth and enable nodes to assimilate features from k-hop neighbors. This method extends the reach of message distribution across node chains and mitigates the issue of feature homogenization, leading to more cohesive clustering of related nodes and improving the quality of microservices extraction. Experimental evaluations on data from three publicly accessible Java monolithic programs confirm that our proposed method surpasses existing techniques in microservices extraction efficacy.

Microservices architecture, known for its advantages in scalability and availability, presents challenges in pinpointing failure causes due to its inherent complexity. Traditional root cause analysis (RCA) methods often lack comprehensive insights into anomaly detection and exhibit shortcomings in finegrained anomaly localization. To address these gaps, we propose RootScan, an innovative framework tailored for fine-grained and interpretable root cause analysis in microservices. Our approach features an event-based observability model that unifies multimodal data (traces, metrics, and logs) into a structured event flow, providing a holistic view of system behavior. Then, we leverage the interpretability of generative networks to detect anomalies from the event flow level to feature level, yielding valuable clues for subsequent root cause analysis. Further, we explore anomaly propagation patterns to precisely trace root causes at fine-grained levels (container, microservice and component). We validate our proposal using an open-source dataset and benchmark microservice environment. Experimental results demonstrate the superiority of our approach, markedly enhancing RCA accuracy and reliability in microservices environments.

Convolutional Neural Network (CNN) and Transformer architectures have been extensively applied in the domain of remote sensing image super-resolution. However, to achieve optimal performance, many existing methods are designed with a large number of parameters, thereby increasing the complexity of the model and hindering practical deployment. To address this issue, we propose an innovative model that synergizes CNN and Transformer architectures while employing a minimal number of their respective modules. This approach significantly reduces the parameter count while maintaining superior performance. Firstly, by constructing additional shallow feature representations as input, we enhance the feature extraction capabilities for individual images. Secondly, we utilize residual connections between various modules to integrate multi-scale, high-dimensional feature information, thus ensuring efficient transmission. Finally, the image reconstruction module is employed to restore the high-resolution image. Experimental results show that FCTNet significantly outperforms existing methods while maintaining a substantially lower parameter count, as demonstrated through evaluations on two public datasets.

The increasing software vulnerabilities underscore the urgency of effective vulnerability detection for safeguarding security and socio-economic stability. Existing pre-trained model-based methods for vulnerability detection often suffer from limitations such as the compression of high-dimensional features and the omission of valuable semantic label information, which collectively compromise performance metrics and fine-tuning efficacy. To address these issues, we propose a novel methodology for fine-tuning pre-trained models using prompt learning. By projecting classification labels as prompts into a high-dimensional feature space, our model preserves essential spatial structures and optimizes the fine-tuning process more effectively. To further enhance classification performance, we design a specialized prompt network for learning adaptable prompts, along with a code encoder network that synergistically captures the semantic and structural nuances of code. Extensive empirical evaluation on two publicly available datasets, SARD and CodeXGLUE demonstrates significant improvements in classification performance and prompt optimization compared to existing state-of-the-art models. Specifically, our method achieves an accuracy of 87.98% on the SARD dataset and 70.97% on the CodeXGLUE dataset, marking a remarkable improvement over state-of-the-art solutions.

Issue reports in software repositories serve as a vital channel for users to report problems, bugs, and provide valuable suggestions for project improvements. Issues are typically assigned a diverse range of labels, enabling categorization and organization. However, the manual labeling of these reports becomes laborious and challenging due to the sheer volume of projects and issue reports. Existing automatic labeling solutions often rely on text matching or multi-classification approaches, which may overlook label dependencies and contextual correlations, compromising the accuracy and relevance of issue classification. To address this challenge, we propose an innovative framework named GlobalTagNet that enhances the automation of issue label assignment. Our approach leverages the power of Heterogeneous Graph Transformer (HGT) to explore label dependencies and semantics. By utilizing hierarchical graph structures, our model captures global label dependencies and correlations, enabling effective learning of label relationships from a holistic perspective. Furthermore, our approach enables the integration of information across multiple levels of the graph, facilitating more accurate inference of label relationships. We conducted comprehensive experiments to assess the effectiveness of our proposed approach. The experimental results unequivocally demonstrate that our method surpasses the performance of baseline solutions, achieving a remarkable improvement of up to 6% in Accuracy, and 8% in F1-score.

The utilization of text classification techniques has demonstrated great promise in the field of detecting consumer fraud based on consumer reviews. However, persistent challenges remain in handling large samples at the borders and identifying unforeseen fraud behaviors. To address these challenges, we propose a novel approach that combines a channel biattention convolutional neural network (CNN) with a pretrained language model. Specifically, we propose a similarity computation module for implicitly learning a metric matrix to characterize the similarity between prior knowledge and consumer reviews in vector space. Through this process, the model is able to learn and understand the relationship between prior knowledge and corresponding samples during training, thereby improving its ability to identify unforeseen fraudulent behaviors. Additionally, we propose a channel biattention CNN module to adaptively emphasize the importance of relevant prior knowledge to enhance the model’s ability to accurately classify boundary samples. To ensure effective model training, we expand and organize a real-world dataset, reducing noise and increasing the number of fraud samples available for analysis. Experimental results demonstrate that our approach achieves state-of-the-art performance in fraud detection. Notably, our model is capable of detecting unforeseen fraud cases without the need for retraining or fine-tuning, making it highly adaptable and efficient in practical applications.

We propose a robust and automatic method to construct manifold cages for 3D triangular meshes. The cage contains hundreds of triangles to tightly enclose the input mesh without self-intersections. To generate such cages, our algorithm consists of two phases: (1) construct manifold cages satisfying the tightness, enclosing, and intersection-free requirements and (2) reduce mesh complexities and approximation errors without violating the enclosing and intersection-free requirements. To theoretically make the first stage have those properties, we combine the conformal tetrahedral meshing and tetrahedral mesh subdivision. The second step is a constrained remeshing process using explicit checks to ensure that the enclosing and intersection-free constraints are always satisfied. Both phases use a hybrid coordinate representation, i.e., rational numbers and floating point numbers, combined with exact arithmetic and floating point filtering techniques to guarantee the robustness of geometric predicates with a favorable speed. We extensively test our method on a data set of over 8500 models, demonstrating robustness and performance. Compared to other state-of-the-art methods, our method possesses much stronger robustness.

In today’s urban transportation landscape, the accurate and timely prediction of traffic conditions holds immense significance for optimizing traffic flow and resource allocation. However, conventional centralized methods for traffic prediction come with the drawback of data collection from various roads, a process that can introduce latency and privacy concerns. To address these pressing challenges, our innovative approach seamlessly integrates road spatiotemporal data, edge computing, and privacy protection inspired by federated learning. We utilize Long Short-Term Memory (LSTM) networks to make real-time predictions of vehicle speeds on individual road segments. Furthermore, we introduce Graph Neural Networks (GNN) to effectively amalgamate predictive insights from the target road and its neighboring roads, effectively capturing intricate spatial relationships within traffic data. Our approach excels in reducing data requirements and alleviating computational burdens, enabling straightforward deployment on edge servers tailored to individual road segments. Most importantly, it prioritizes privacy by circumventing the exchange of raw data, instead opting for the selective sharing of predictions between segments. Our rigorous experimental results demonstrate that our approach outperforms traditional federated averaging algorithms, underscoring its remarkable security attributes while achieving superior predictive accuracy.

API recommendation has been widely used to enhance developers’ efficiency in software development. However, existing API recommendation methods for dynamic languages such as Python usually suffer from the limitations of incorrect type inference and lack of rich contextual semantics. To address these issues, we propose in this paper a novel approach, PyBartRec, to recommend APIs for Python programs concerning their rich semantics. Instead of analyzing the data flow information only, our approach utilizes a Transformer-based pre-trained model to extract the semantic features of Python code snippets. Such contextual information allows our approach to recommend correct APIs even when the APIs are not included in the local data flow information. We also use such information to perform a post-processing type inference. By narrowing the range of candidate types, our approach can recommend APIs accurately even in the failure scenarios of type inference. We evaluated PyBartRec in eight popular Python projects and the experimental results show that our approach significantly outperforms the state-of-the-art solutions. In particular, the average top-1 accuracy and average top-10 accuracy of PyBartRec within the same project are over 40%, and 60%, respectively. In cross-project recommendation, the MRR of PyBartRec is also over 40%.

Deep learning Transformer architectures play a critical role in developing advanced code prediction models, which are essential in modern Integrated Development Environments (IDEs). Nevertheless, these architectures encounter a significant challenge in effectively capturing and utilizing the structural information present in Abstract Syntax Trees (ASTs). To tackle this challenge, we propose an innovative approach that leverages AST structural matrices to enhance Transformers for source code prediction. Specifically, we integrate three types of AST structural matrices - the R matrix, A&S matrix, and MVG matrix - into the attention module of the Transformer to effectively capture the structural information within ASTs. To ensure optimal utilization, we have devised a range of strategies and integration methods tailored specifically for the attention module. To assess the effectiveness of our proposal, we conduct empirical studies using a standard Python dataset. The results demonstrate that incorporating AST structural matrices significantly enhances the accuracy of code prediction models, leading to an overall improvement from 73.18% to 75.10%. Furthermore, we conduct an in-depth analysis of the impact of each matrix type, offering a comprehensive understanding of their application scenarios. This insightful analysis provides valuable guidance on how to effectively leverage each matrix type in various contexts.

Many geometric optimization problems contain manifold constraints that restrict the optimized vertices on some specified manifold surface. The constraints are highly nonlinear and non-convex, therefore existing methods usually suffer from a breach of condition or low optimization quality. In this article, we present a novel divide-and-conquer methodology for manifold-constrained geometric optimization problems. Central to our methodology is to use local parameterizations to decouple the optimization with hard constraints, which transforms nonlinear constraints into linear constraints. We decompose the input mesh into a set of developable or nearly-developable overlapping patches with disc topology, then flatten each patch into the planar domain with very low isometric distortion, optimize vertices with linear constraints and recover the patch. Finally, we project it onto the constrained manifold surface. We demonstrate the applicability and robustness of our methodology through a variety of geometric optimization tasks. Experimental results show that our method performs much better than existing methods.

The code clone detection method based on semantic similarity has important value in software engineering tasks (e.g., software evolution, software reuse). Traditional code clone detection technologies pay more attention to the similarity of code at the syntax level, and less attention to the semantic similarity of the code. As a result, candidate codes similar in semantics are ignored. To address this issue, we propose a code clone detection method based on semantic similarity. By treating code as a series of interdependent events that occur continuously, we design a model namely EDAM to encode code semantic information based on event embedding and event dependency. The EDAM model uses the event embedding method to model the execution characteristics of program statements and the data dependence information between all statements. In this way, we can embed the program semantic information into a vector and use the vector to detect codes similar in semantics. Experimental results show that the performance of our EDAM model is superior to state-of-the-art open source models for code clone detection.

Matching APP reviews with bug reports can help APP developers to quickly identify new bugs from the users’ feedback. Existing solutions represent the semantics of APP reviews and bug reports via carefully designed features and models, the performance of which however depends heavily on the manually designed model and the training data set. Large-scale pretrained models can well capture the semantics of text and have demonstrated their success in many NLP tasks. Inspired by this, we explore the effect of various pretrained models on the matching accuracy of app review and bug report. We conduct a systematic study to analyze the factors of four major pretrained models (including T5, Sentence T5, Sentence MiniLM, Sentence BERT and so on) on the matching accuracy. We find that the accuracy of Sentence T5 and Sentence MiniLM in four open source applications is significantly greater than that of the state-of-the-art approach DeepMatcher. Based on the findings, we design a novel approach to match the APP reviews with bug reports based on the pretrained model Sentence T5 and Sentence MiniLM to calculate the sentence similarity. We test it on four open source applications and the results show that our method outperforms the existing solution. On average, the precision of Sentence T5 and Sentence MiniLM are increased by 17% and 13%, respectively, and the hit ratio are increased by 15% and 14%, respectively.

Mobile application markets usually enact policies to describe in detail the minimum requirements that an application should comply with. User comments on mobile applications contain a large amount of information that can be used to find out APP's violations of market policies in a cost-effective way. Existing state-of-the-art methods match user comments with the violations of market policies based on well-designed syntax rules, which however cannot well capture the semantics of user comments and cannot be generalized to the scenarios not covered by the rules. To address this issue, we propose an innovative method, UBC-BERT, to detect undesired behavior from user comments based on their semantics. By incorporating sentence embeddings with attention, we train a classification model for 21 groups of undesirable behaviors based on the fine-tuning of a pre-trained model BERT-BASE. The experimental results show that our solution outperforms the baseline solutions in terms of a higher precision(up to 60.5% more).

Distributed cache is one of the most important components in cloud computing and microservice systems. Adding cache components to the microservice system can significantly improve the concurrency and throughput of the whole microservice framework, and effectively promote the overall performance of the microservice system. However, traditional caching algorithm can easily lead to the imbalance of cache resource allocation in microservice system, thus affecting the performance of the microservice system. We study the basic architecture of cache in microservice platform, and propose the mathematical model of distributed cache and the probability distribution model of data access in microservice platform. Next, based on the above mathematical model, we design a cache replacement algorithm based on dynamic constraints in microservice platform. The algorithm can effectively solve a series of problems of traditional algorithms in microservice platform, making the algorithm more suitable for the environment of microservice architecture. We evaluate and verify the algorithm on the simulation software platform. Experimental results show that the algorithm meets the performance requirements of high cache hit rate, high concurrency and high throughput in the microservice platform, and is significantly better than the traditional cache algorithms.

Sentiment analysis plays an indispensable role to help understand people’s opinions automatically based on their reviews. Existing research on sentiment analysis mainly focuses on film reviews, e-commerce reviews and other fields. These work cannot be applied to analyze the sentiment of travel reviews directly because the mainstream commodity review dataset is richer and more regular than that of travel review dataset. More specifically, the special characteristic of travel reviews makes existing solutions fail to achieve satisfactory results. To address this issue, we first construct a travel review data set for sentiment analysis. Then, we conduct a systematic study to investigate and compare the factors that may affect the accuracy of sentiment analysis for travel reviews. Based on the study findings, we design a lightweight Glove-BiLSTM-CNN model and BERT-BiLSTM-CNN to analyze the sentiment for travel reviews. Experimental results show that our proposed models outperform the baseline solutions.

The rapid development of tourism economy has brought new challenges such as the prevention of consumer fraud for smart city applications. Traditional fraud detection approaches such as telecommunication fraud and credit card fraud detection need a data set containing both the normal behavior and abnormal behavior. Therefore, they are incompetent to address such challenges in the tourism market where the data set is open and very few records of fraud behaviors are available. To address this issue, we propose a P-feature conversion algorithm to construct third-party features to expose the outliers. These features reveal the internal characteristics of different businesses and their useful internal connections. Then, we build a fraud detection model for tourism based on the Local Outlier Factor anomaly detection algorithm. Experimental results show that our model can effectively identify fraudulent merchants in the tourism market.

Different news events have different effects on stock price changes. If they are simply fed to the neural network for prediction, the accuracy will be affected. We propose a method to predict stock price trend based on time series news information. First, we extract events from news text and represent them as dense vectors by event embedding technique. Further-more, we employ attention mechanism to figure out event is the main cause of the price fluctuation. Then, we use a Gated Recurrent Unit to model the influence of events on stock market. Experimental results show that our model achieve a certain improvement on S&P500 index compared to baseline methods.

Stock trend forecasting plays a great role in maximizing the profit of stock investment. However, due to the high volatility and non-stationarity of the stock market, accurate trend prediction is very difficult. With the development of the Internet and deep learning technology, people can use deep learning methods to reveal market trends and volatility from the explosive information on the Internet. Unfortunately, there is a large amount of content related to the stock market, and a large part of it is useless information. As a result, how to extract the effective information and combine this information as different characteristics to effectively predict stock trends has become the biggest challenge. In order to cope with these challenges, we use TextCNN as the news text feature extractor for feature extraction of news information, and propose a prediction method based on multi-feature fusion: Bi-LSTNAA, to predict the Chinese stock market. Extensive experiments on actual stock market data show that the our method has a greater improvement in the accuracy of stock trend prediction.

Sentiment analysis (SA) has been applied to various fields of software engineering (SE), such as app reviews, stack overflow Q&A website and API comments. General SA tools are trained based on movie or product review data. Research has shown that these SA tools can produce negative results when applied to the field of SE. In order to overcome the above limitations, developers need to customize tools (e.g., SentiStrength-SE, SentiCR, Senti4SD). In recent years, the pre-trained transformer-based models have brought great breakthroughs in the field of natural language processing. Therefore, we intend to fine-tune the pre-trained model BERT for downstream text classification tasks. We compare the performance of SE-specific tools. Meanwhile, we also studied the performance of SE-specific tools in a cross-platform setting. Experimental results show that our approach (BERT-FT) outperforms the existing state-of-the-art models in terms of F1-scores.

A geometric mapping establishes a correspondence between two domains. Since no real object has zero or negative volume, such a mapping is required to be inversion-free. Computing inversion-free mappings is a fundamental task in numerous computer graphics and geometric processing applications, such as deformation, texture mapping, mesh generation, and others. This task is usually formulated as a non-convex, nonlinear, constrained optimization problem. Various methods have been developed to solve this optimization problem. As well as being inversion-free, different applications have various further requirements. We expand the discussion in two directions to (i) problems imposing specific constraints and (ii) combinatorial problems. This report provides a systematic overview of inversion-free mapping construction, a detailed discussion of the construction methods, including their strengths and weaknesses, and a description of open problems in this research field.

We propose a novel method to model and fabricate shapes using a small set of specified discrete equivalence classes of triangles. The core of our modeling technique is a fabrication-error-driven remeshing algorithm. Given a triangle and a template triangle, which are coplanar and have one-to-one corresponding vertices, we define their similarity error from a manufacturing point of view as follows: the minimizer of the maximum of the three distances between the corresponding pair of vertices concerning a rigid transformation. To compute the similarity error, we convert it into an easy-to-compute form. Then, a greedy remeshing method is developed to optimize the topology and geometry of the input mesh to minimize the fabrication error defined as the maximum similarity error of all triangles. Besides, constraints are enforced to ensure the similarity between input and output shapes and the smoothness of the resulting shapes. Since the fabrication error has been considered during the modeling process, the fabrication process is easy to proceed. To assist users in performing fabrication using common materials and tools manually, we present a straightforward manufacturing solution. The feasibility and practicability of our method are demonstrated over various examples, including seven physical manufacturing models with only nine template triangles.

Service oriented architecture (SOA) provides a flexible platform to build collaborative Internet applications by composing existing self-contained and autonomous services. However, the implicit interactions among the concurrently provisioned services may introduce interference to Internet applications and cause them behave abnormally. It is thus desirable to isolate services to safeguard their application consistency. Existing approaches mostly address this problem by restricting concurrent execution of services to avoid all the implicit interactions. These approaches, however, compromise the performance and flexibility of Internet applications due to the long running nature of services. This paper presents Sifter, a new service isolation strategy for Internet applications. We devise in this strategy a novel static approach to analyze the potential implicit interactions among the services and their impacts on the consistency of the associated Internet applications. By locating only those afflicted implicit interactions that may violate the application consistency, a novel approach based on exception handling and behavior constraints is customized to involved services to eliminate their impacts. We show that this approach exempts the consistency property of Internet applications from being interfered at runtime. The experimental results show that our approach has a better performance than existing solutions.

Semantic code clone detection is an important yet challenging task in software engineering. Traditional methods rely on expert experience and cannot automatically determine which features are better for semantic code clone detection. Moreover, the program dynamics (e.g., the execution characteristics and execution order of statements) are not considered in these methods. As a result, this limits their ability to detect semantic clones. To address this issue, we propose a code clone detection method based on event embedding tree and Graph Attention Network. Our method uses a program control flow graph to capture the execution characteristics of each statement and extract the context relationship of different statements in the control flow. Based on such information, our method can calculate the functional similarity of two pieces of code, thereby identifying semantically similar code fragments. Experimental results show that our method is superior to state-of-the-art open source methods for Type-3 (syntactic) / Type-4 (semantic) clone detection.

The development of intelligent transportation systems usually needs to predict the traffic conditions under a large data volume. Existing approaches usually use a single source of data and the impacts of the neighborhood road sections are not concerned. As a result, their prediction accuracy is usually compromised. To address this issue, we propose a recurrent neural network to predict the road conditions simultaneously concerning the information of multiple road sections at the same time. By perceiving the connectivity between multiple road sections and capturing their mutual influence, our model can significantly improve the prediction accuracy. The experiments based on two real-life dataset shows that our model outperforms the baseline model.

Abstract As high‐precision 3D scanners become more and more widespread, it is easy to obtain very‐large‐scale meshes containing at least millions of vertices. However, processing these very‐large‐scale meshes is still a very challenging task due to memory limitations. This paper focuses on a fundamental geometric processing task, i.e., bijective parameterization construction. To this end, we present a spline‐enhanced method to compute bijective and low distortion parameterizations for very‐large‐scale disk topology meshes. Instead of computing descent directions using the mesh vertices as variables, we estimate descent directions for each vertex by optimizing a proxy energy defined in spline spaces. Since the spline functions contain a small set of control points, it significantly decreases memory requirement. Besides, a divide‐and‐conquer method is proposed to obtain bijective initializations, and a submesh‐based optimization strategy is developed to reduce distortion further. The capability and feasibility of our method are demonstrated over various complex models. Compared to the existing methods for bijective parameterizations of very‐large‐scale meshes, our method exhibits better scalability and requires much less memory.

Abstract We present a novel method to construct short cuts for parameterizations with low isometric distortion. The algorithm contains two steps: (i) detect feature points, where the distortion is usually concentrated; and (ii) construct a cut by connecting the detected feature points. Central to each step is a greedy method. After generating a redundant feature point set, a greedy filtering process is performed to identify the feature points required for low isometric distortion parameterizations. This filtering process discards the feature points that are useless for distortion reduction while still enabling us to obtain low isometric distortion. Next, we formulate the process of connecting the detected feature points as a Steiner tree problem. To find an approximate solution, we first successively and greedily produce a collection of auxiliary points. Then, a cut is constructed by connecting the feature points and auxiliary points. In the 26,299 test cases in which an exact solution to the Steiner tree problem is available, the length of the cut obtained by our method is on average 0.17% longer than optimal. Compared to state‐of‐the‐art cut construction methods, our method is one order of magnitude faster and generates shorter cuts while achieving similar isometric distortion.

We propose a novel method to efficiently compute bijective parameterizations with low distortion on disk topology meshes. Our method relies on a second-order solver. To design an efficient solver, we develop two key techniques. First, we propose a coarse shell to substantially reduce the number of collision constraints that are used to guarantee overlap-free boundaries. During the optimization process, the shell ensures the Hessian matrix with a fixed nonzero structure and a low density, thereby significantly accelerating the optimization. The second is a triangle inequality-based barrier function that effectively ensures non-intersecting boundaries. Our barrier function is C ∞ inside the locally supported region and its convex second-order approximation is able to be analytically obtained. Compared to state-of-the-art methods for optimizing bijective parameterizations, our method exhibits better scalability and is about six times faster. The performance of our bijective parameterization algorithm is comparable to state-of-the-art methods of locally flip-free parameterizations. A large number of experimental results have shown the capability and feasibility of our method.

We present a novel algorithm to refine an input atlas with bounded packing efficiency. Central to this method is the use of the axis-aligned structure that converts the general polygon packing problem to a rectangle packing problem, which is easier to achieve high packing efficiency. Given a parameterized mesh with no flipped triangles, we propose a new angle-driven deformation strategy to transform it into a set of axis-aligned charts, which can be decomposed into rectangles by the motorcycle graph algorithm. Since motorcycle graphs are not unique, we select the one balancing the trade-off between the packing efficiency and chart boundary length, while maintaining bounded packing efficiency. The axis-aligned chart often contains greater distortion than the input, so we try to reduce the distortion while bounding the packing efficiency and retaining bijection. We demonstrate the efficacy of our method on a data set containing over five thousand complex models. For all models, our method is able to produce packed atlases with bounded packing efficiency; for example, when the packing efficiency bound is set to 80%, we elongate the boundary length by an average of 78.7% and increase the distortion by an average of 0.0533%. Compared to state-of-the-art methods, our method is much faster and achieves greater packing efficiency.

We propose a novel approach, calledProgressive Parameterizations, to compute foldover-free parameterizations with low isometric distortion on disk topology meshes. Instead of using the input mesh as a reference to define the objective function, we introduce a progressive reference that contains bounded distortion to the parameterized mesh and is as close as possible to the input mesh. After optimizing the bounded distortion energy between the progressive reference and the parameterized mesh, the parameterized mesh easily approaches the progressive reference, thereby also coming close to the input. By iteratively generating the progressive reference and optimizing the bounded distortion energy to update the parameterized mesh, our algorithm achieves high-quality parameterizations with strong practical reliability and high efficiency. We have demonstrated that our algorithm succeeds on a massive test data set containing over 20712 complex disk topology meshes. Compared to the state-of-the-art methods, our method has achieved higher computational efficiency and practical reliability.

Computing clouds have become the platform of choice for the deployment and execution of scientific workflows. Due to the uncertainty and unpredictability of scientific exploration, the execution plan for a scientific workflow may vary from the definition. It is therefore of great significance to be able to discover actual workflows from execution histories (event logs) to reproduce experimental results and to establish provenance. However, most existing process mining techniques focus on discovering control flow-oriented business processes in a centralized environment, and thus, they are mostly inapplicable to the discovery of data flow-oriented, unstructured scientific workflows in distributed cloud environments. In this paper, we present Scientific Workflow Mining as a Service (SWMaaS) to support both intra-cloud and inter-cloud scientific workflow mining. The approach is implemented as a ProM plug-in and is evaluated on event logs derived from real-world scientific workflows. Through experimental results, we demonstrate the effectiveness and efficiency of our approach.

Process mining, especially process discovery, has been utilized to extract process models from event logs. One challenge faced by process discovery is to identify concurrency effectively. State-of-the-art approaches employ activity orders in traces to undertake process discovery and they require stringent completeness notions of event logs. Thus, they may fail to extract appropriate processes when event logs cannot meet the completeness criteria. To address this problem, we propose in this paper a novel technique which leverages activity dependences in traces. Based on the observation that activities with no dependencies can be executed in parallel, our technique is in a position to discover processes with concurrencies even if the logs fail to meet the completeness criteria. That is, our technique calls for a weaker notion of completeness. We evaluate our technique through experiments on both real-world and synthetic event logs, and the conformance checking results demonstrate the effectiveness of our technique and its relative advantages compared with state-of-the-art approaches.

The large-scale dynamic cloud computing environment has raised great challenges for fault diagnosis in Web applications: First, fluctuating workloads cause traditional application models to change over time; second, modeling the behaviors of complex applications usually requires domain knowledge which is difficult to obtain; third, managing large-scale applications manually is impractical for operators. To address these issues, this paper proposes an automatic fault (F) diagnosis (D) framework for (4) Web applications in cloud (C) computing (FD4C). In this paper, we propose an online incremental clustering method to recognize access behavior patterns. We also use correlation analysis to model the correlations between the workloads and application performance/resource utilization metrics in a specific access behavior pattern. FD4C detects faults by discovering the abrupt changes of correlation coefficients with control charts. Then, FD4C identifies the fault-related metrics using a feature selection method. To evaluate our proposal, we inject typical faults into TPC-W benchmark and apply FD4C to diagnose the injected faults. The experimental results show that FD4C can effectively detect the typical faults and accurately locate the metrics related to the faults.

Virtualization greatly improves resource utilization in IaaS platforms, but it also introduces potential interference between virtual machines (VMs). For example, VMs may suffer from performance degradation, when they are located in one host and compete for sharing physical resources. Thus, how to efficiently monitor and quantify the VMs interference becomes a key challenge for IaaS providers. In this paper, we present Vmon, a system to transparently monitor and quantify the interference between VMs with the hardware performance counters (HPCs). By collecting the HPCs of different VMs and exploring the LLC miss rates within HPCs, Vmon analyzes the relationship between the LLC miss rates and VM performance degradation to predict the interference between different resource-intensive VMs, and mitigate the VMs interference. The experimental results show that Vmon predicts the performance degradation in the accuracy of more than 90% with less than 10% performance overhead.

Despite suffering from inefficiency and flexibility limitations, the filter-based routing (FBR) algorithm is widely used in content-based publish/subscribe (pub/sub) systems. To address its limitations, we propose a dynamic destination-based routing algorithm called D-DBR, which decomposes pub/sub into two independent parts: Content-based matching and destination based multicasting. D-DBR exhibits low event matching cost and high efficiency, flexibility, and robustness for event routing in small-scale overlays. To improve its scalability to large-scale overlays, we further extend D-DBR to a new routing algorithm called MERC. MERC divides the overlay into interconnected clusters and applies content-based and destination-based mechanisms to route events inter- and intra-cluster, respectively. We implemented all algorithms in the PADRES pub/sub system. Experimental results show that our algorithms outperform the FBR algorithm.

As an exchange foundation of cloud software services, the cloud marketplace plays an important role to promote the capability and creativity of cloud services. However, existing cloud marketplaces are usually based on online stores operated by some particular companies. Users are usually required to get involved in their particular ecosystems, seriously restricting their creativity and competition. Moreover, these marketplaces lack efficient and flexible service publishing and discovery mechanisms. Therefore, this makes them difficult to handle a huge number of dynamic cloud service exchanges efficiently. To address this issue, we propose in this paper an open cloud marketplace middleware system for cloud software services based on a service publishing and subscription model. This model extends traditional content-based distributed publish/subscribe paradigm. By introducing the matching mechanism of multidimensional contents such as service functionality, service behavior, and quality of service etc, a new distributed publish/subscribe paradigm for service publishing and subscription is proposed. This new paradigm allows service providers to publish their services to and allows service consumers to subscribe services from the open marketplace based on service descriptions and requirements. We illustrate the design of the open cloud marketplace and present our preliminary results.

Despite suffering from inefficiency and flexibility limitations, the filter-based routing (FBR) algorithm is widely used in content-based publish/subscribe (pub/sub) systems. To address its limitations, we propose a dynamic destination-based routing algorithm called D-DBR, which decomposes pub/sub into two independent parts: Content-based matching and destination-based multicasting. D-DBR exhibits low event matching cost and high efficiency, flexibility, and robustness for event routing in small scale overlays. To boost scalability, we further complement D-DBR with a new routing algorithm called MERC. MERC divides the overlay into interconnected clusters and applies content-based and destination-based mechanisms to route events inter- and intra-cluster, respectively. We implemented all algorithms in the PADRES pub/sub system. Experimental results show that our algorithms outperform FBR in terms of improving event dissemination throughput by up to 700% and reducing the end-to-end latency by up to 55%.

Whitening the testing of service-oriented applications can provide service consumers confidence on how well an application has been tested. However, to protect business interests of service providers and to prevent information leakage, the implementation details of services are usually invisible to service consumers. This makes it challenging to determine the test coverage of a service composition as a whole and design test cases effectively. To address this problem, we propose an approach to whiten the testing of service compositions based on events exposed by services. By deriving event interfaces to explore only necessary test coverage information from service implementations, our approach allows service consumers to determine test coverage based on selected events exposed by services at runtime without releasing the service implementation details. We also develop an approach to design test cases effectively based on event interfaces concerning both effectiveness and information leakage. The experimental results show that our approach outperforms existing testing approaches for service compositions with up to 49 percent more test coverage and an up to 24 percent higher fault-detection rate. Moreover, our solution can trade off effectiveness, efficiency, and information leakage for test case generation.

In-memory data grid (IMDG) is a novel data processing middleware for Internetware. It provides higher scalability and performance compared with traditional rational database. However, because the data stored in IMDG must follow the key/value data model, new challenges have been proposed. One important aspect is that IMDG does not support standard data accessing languages such as JPA and SQL, and application developers must design their programs according to the peculiarities of an IMDG product. This results in complex and error-prone code, especially for the programmers who have no deep understanding of IMDG. In this paper, we propose a data accessing reference architecture for IMDG and a methodology to design and implement its data accessing layer. In this methodology, data accessing engine construction, data model designation and join operation supporting are presented. Moreover, following this methodology, we develop and implement a JPA compatible data accessing engine for Hazelcast as a case study, which proves the feasibility of our approach.

Runtime monitoring of Web service compositions has been widely acknowledged as a significant approach to understand and guarantee the quality of services. However, existing runtime monitoring solutions consider only the constraints on the sequence of messages exchanged between partner services and ignore the actual data contents inside the messages. As a result, it is difficult to monitor some dynamic properties such as how message data of interest is processed between different participants. To address this issue, we propose an efficient, non-intrusive online monitoring approach to dynamically analyze data-centric properties for service-oriented applications involving multiple participants. By introducing Par-BCL - a Parametric Behavior Constraint Language for web services - to define monitoring parameters, various data-centric temporal behavior properties for Web services can be specified and monitored. This approach broadens the monitored patterns to include not only message exchange orders, but also the data contents bound to the parameters. To reduce runtime overhead, we statically analyze the monitored properties to generate parameter state machine from the event pattern automata to optimize monitoring. The experiments show that our solution is efficient and promising.

Context-aware applications automatically adapt their behavior according to environmental conditions, also known as contexts. However, in practice contexts are often inaccurate, noisy or even inconsistent (e.g., two RFID readers may report different numbers for the same set of goods processed). These kinds of problematic contexts may cause context-aware applications to behave abnormally or even fail. It is thus desirable to detect and resolve context inconsistency. In this paper, we propose a hybrid approach to detect problematic contexts and resolve resulting context inconsistencies with the help of context-aware application semantics. By combining low-level context inconsistency resolution with high-level application error recovery, our approach can resolve the inconsistent contexts more effectively. Moreover, error recovery cost for context-aware applications is reduced. Our experimental results show that our approach outperforms existing approaches in terms of more accurate inconsistency resolution and less error recovery cost.

In service-oriented architectures (SOA), independently developed Web services can be dynamically composed. However, the composition is prone to producing semantically conflicting interactions among the services. For example, in an interdepartmental business collaboration through Web services, the decision by the marketing department to clear out the inventory might be inconsistent with the decision by the operations department to increase production. Resolving semantic conflicts is challenging especially when services are loosely coupled and their interactions are not carefully governed. To address this problem, we propose a novel distributed service choreography framework. We deploy safety constraints to prevent conflicting behavior and enforce reliable and efficient service interactions via federated publish/subscribe messaging, along with strategic placement of distributed choreography agents and coordinators to minimize runtime overhead. Experimental results show that our framework prevents semantic conflicts with negligible overhead and scales better than a centralized approach by up to 60%.

Runtime monitoring of Web service compositions with WS-BPEL has been widely acknowledged as a significant approach to understand and guarantee the quality of services. However, most existing monitoring technologies only track patterns related to the execution of an individual process. As a result, the possible inconsistency failure caused by implicit interactions among concurrent process instances cannot be detected. To address this issue, this paper proposes an approach to specify the behavior properties related to shared resources for web service compositions and verify their consistency with the aid of a parametric stateful aspect extension to WS-BPEL. Parameters are introduced in pattern specification, which allows monitoring not only events but also their values bound to the parameters at runtime to keep track of data flow among concurrent process instances. An efficient implementation is also provided to reduce the runtime overhead of monitoring and event observation. Our experiments show that the proposed approach is promising.

The advent of Internet technology introduces a revolution to software application and development paradigms. Traditional software development and application patterns have been shifted to Internet-based service sharing and collaboration among partners all over the Internet. This imposes new challenges and complexity in the lifecycle of software development, deployment and maintenance. Middleware, an intermediate layer to abstract the homogeneity and hide the difference of underlying systems, can be used to reduce the complexity for Internet application development. In this paper, we exploit the needs of middleware support for Internet-based applications from a service perspective. We investigate the potential requirements and features of Internetware, and the state-of-the-art solutions. We also analyze the remaining issues, the challenges and potential future research directions.

Pervasive computing environments typically change frequently in terms of available resources and their properties. Applications in pervasive computing use contexts to capture these changes and adapt their behaviors accordingly. However, contexts available to these applications may be abnormal or imprecise due to environmental noises. This may result in context inconsistencies, which imply that contexts conflict with each other. The inconsistencies may set such an application into a wrong state or lead the application to misadjust its behavior. It is thus desirable to detect and resolve the context inconsistencies in a timely way. One popular approach is to detect context inconsistencies when contexts breach certain consistency constraints. Existing constraint checking techniques recheck the entire expression of each affected consistency constraint upon context changes. When a changed context affects only a constraint's subexpression, rechecking the entire expression can adversely delay the detection of other context inconsistencies. This article proposes a rigorous approach to identifying the parts of previous checking results that are reusable without entire rechecking. We evaluated our work on the Cabot middleware through both simulation experiments and a case study. The experimental results reported that our approach achieved over a fifteenfold performance improvement on context inconsistency detection than conventional approaches.

In context-ware computing paradigm, context-aware middleware plays a key role. The middleware collects and manipulates contexts from environments, providing context-aware applications well-defined interfaces to adapt their behaviors when environments change. However, some minor difference in the implementation of context-aware middleware may cause the same context-aware application behave differently. Such behavior deviation may lead to serious problems or even disasters for a context-aware application. It is thus desirable to check whether a mobile context-aware application behaves consistently before moving it from one middleware to another, or whether a context-aware application still works correctly when upgrading the underlying middleware? Existing approaches for context-aware applications are not adequate for detecting such behavior deviation because these approaches do not consider the impacts of the difference in the middleware implementation. In this paper, we study the strategies in the implementation of context-aware middleware and their impacts on the behavior of context-aware applications. By exploring the implied scenarios where a context-aware application may behave differently, new testing approach is proposed to detect the behavior deviation of a context-aware application running on different middleware by generating test cases to cover these implied scenarios.

Atomicity is a highly desirable property for achieving application consistency in service compositions. To achieve atomicity, a service composition should satisfy the atomicity sphere, a structural criterion for the backend processes of involved services. Existing analysis techniques for atomicity sphere generally assume complete knowledge of all involved backend processes. Such an assumption is invalid when some service providers do not release all details of their backend processes to service consumers outside the organizations. To address this problem, we propose a process algebraic framework to publish atomicity-equivalent public views from the backend processes. These public views extract relevant task properties and reveal only partial process details that service providers need to expose. Our framework enables the analysis of atomicity sphere for service compositions using these public views instead of their backend processes. This allows service consumers to choose suitable services such that their composition satisfies the atomicity sphere without disclosing the details of their backend processes. Based on the theoretical result, we present algorithms to construct atomicity-equivalent public views and to analyze the atomicity sphere for a service composition. Two case studies from supply chain and insurance domains are given to evaluate our proposal and demonstrate the applicability of our approach.

Context-awareness allows pervasive applications to adapt to changeable computing environments. Contexts, the pieces of information that capture the characteristics of environments, are often error-prone and inconsistent due to noises. Various strategies have been proposed to enable automatic context inconsistency resolution. They are formulated on different assumptions that may not hold in practice. This causes applications to be less context-aware to different extents. In this paper, we investigate such impacts and propose our new resolution strategy. We conducted experiments to compare our work with major existing strategies. The results showed that our strategy is both effective in resolving context inconsistencies and promising in its support of applications using contexts.

Context-awareness is a capability that allows applications in pervasive computing to adapt themselves continuously to changing contexts of their environments. However, contexts from physical environments may be inconsistent. It affects the correctness of these applications. Existing resolution strategies for context inconsistency have diverse adverse impacts on the context awareness of applications, such as feeding different amounts of contexts to the applications. In this paper, we examine the impacts of inconsistency resolution and study the extent to which their effects on context-awareness can be reduced. We conduct simulation experiments of two pervasive computing applications. The experimental results show that existing inconsistency resolution strategies adversely affect the context-awareness of applications. This motivates the importance of deploying an impact-oriented approach to respect context-awareness in inconsistency resolution.

Atomicity is a desirable property that safeguards application consistency for service compositions. A service composition exhibiting this property could either complete or cancel itself without any side effects. It is possible to achieve this property for a service composition by selecting suitable web services to form an atomicity sphere. However, this property might still be breached at runtime due to the interference between various service compositions caused by implicit interactions. Existing approaches to addressing this problem by restricting concurrent execution of services to avoid all implicit interactions however compromise the performance of service compositions due to the long running nature of web services. In this paper, we propose a novel static approach to analyzing the implicit interactions a web service may incur and their impacts on the atomicity property in each of its service compositions. By locating afflicted implicit interactions in a service composition, behavior constraints based on property propagation are formulated as local safety properties, which can then be enforced by the affected web services at runtime to suppress the impacts of the afflicted implicit interactions. We show that the satisfaction of these safety properties exempts the atomicity property of this service composition from being interfered by other services at runtime. The approach is illustrated using two service applications.

Exception handling resolves inconsistency by backward or forward error recovery methods or both in Business-to-Business (B2B) process collaboration. To avoid committing irrevocable tasks followed by exceptions, B2B processes, which guarantee the atomicity sphere property, are attractive. While atomicity sphere ensures its outcomes to be either all or nothing, conflicting local recoveries may lead to global B2B inconsistencies. Existing (global) analysis techniques however mandate every process unveiling all individual tasks. Such an analysis is infeasible when some business parties refuse to disclose their process details for privacy or business reasons. To address this problem, we propose a process algebraic technique to prove, construct, and check atomicity-equivalent public views from B2B processes. By checking atomicity spheres in the composition of these public views, business parties can identify suitable services that respect their individual and overall atomicity requirements. An example based on a real-life multilateral supply chain process is included.

Atomicity is a desirable property for business processes to conduct transactions in Business-to-Business (B2B) collaboration. Although it is possible to reason about atomicity of B2B collaboration using the public views, yet such reasoning requires the presence of a trustworthy party who has complete knowledge of these views. It is inapplicable when some parties may want to keep the confidentiality of their collaborative partners for privacy and other business reasons, or the trustworthy party is not available. To address this problem, we propose a novel approach that allows each party to jointly conduct local atomicity checking with its direct partners. It is based on iterative forwarding and regression of compensability properties between each pair of direct partners. This approach is applied to a case study based on a real-life insurance process in the motor damage claims domain.