Customer segmentation plays a crucial role in credit risk assessment by dividing users into specific risk levels based on their credit scores. Previous methods fail to comprehensively consider the stability in the segmentation process, resulting in frequent changes and inconsistencies in users' risk levels over time. This increases potential risks to a company. To this end, this paper at first introduces and formalizes the concept of stability regret in the segmentation process. However, evaluating stability is challenging due to its black-box nature and the computational burden posed by vast user data sets. To address these challenges, this paper proposes a large-scale stable customer segmentation approach named LASCA. LASCA consists of two phases: high-quality dataset construction (HDC) and reliable data-driven optimization (RDO). Specifically, HDC utilizes an evolutionary algorithm to collect high-quality binning solutions. RDO subsequently builds a reliable surrogate model to search for the most stable binning solution based on the collected dataset. Extensive experiments conducted on real-world large-scale datasets (up to 0.8 billion) show that LASCA surpasses the state-of-the-art binning methods in finding the most stable binning solution. Notably, HDC greatly enhances data quality by 50%. RDO efficiently discovers more stable binning solutions with a 36% improvement in stability, accelerating the optimization process by 25 times via data-driven evaluation. Currently, LASCA has been successfully deployed in the large-scale credit risk assessment system of Alipay.

Decision rules have been widely applied in industrial applications such as finance, medicine, and biology, due to the critical requirement of interpretability. In order to make decision rules easier and more widely used in financial scenarios, an automatic intelligent rule system with rule learning and rule management capabilities is needed. However, the rule system for financial applications has distinctive challenges both in algorithms and systems. From the algorithm perspective, due to the characteristics of the financial data and scenarios, the rule learning algorithm faces the class-imbalanced issue, the scalability issue, and the diversity of optimization objectives. From the system perspective, a flexible rule learning and management framework is needed to adapt to fast-changing financial applications with heterogenous data, and engineering optimization is required to ensure the time and space efficiency of rule learning. In this work, we focus on developing a Rule-based Decision System (RDS) to deal with the algorithmic and systematic challenges mentioned above. RDS covers the full life cycle of the decision rules, including the rule learning module, rule management module, and rule deployment module. Moreover, the rule system offers an interactive interface to allow users to integrate the expert experiences into the decision rules and realize the human-in-the-loop. The RDS has been deployed on one of the world’s largest trading and money transfer platforms, serving hundreds of millions of users and transactions.

Credit risk assessment, which aims at identifying high-risk users, plays a critical role in financial institutions. A common method is to use the greedy strategy to generate an interpretable rule set to classify all the users into high-risk or non-risk users. During each iteration, the greedy strategy utilizes a pre-defined indicator function to evaluate which rule is the best and then adds it to the rule set. However, in reality, the indicator function is designed manually and requires much domain knowledge and expert experience. Worse still, we need to design a suitable indicator for every situation, which is tedious and time-consuming work. This motivates us to propose a self-adaptive indicator that can be adapted to different situations without too much human intervention. In this paper, we see the indicator as a weighted sum of several sub-indicators. By tuning the weights, the indicator can be adapted to different situations automatically. That is, we transform this indicator selection problem into a weights tuning problem. To find the best weight of self-adaptive indicators, machine learning methods and black-box optimization are utilized. The experimental results demonstrated that our self-adaptive indicator can select a better rule set to identify more high-risk users compared to the human-defined indicator.

The problem of performance ranking in configurable systems is to find the optimal (near-optimal) configurations with the best performance. This problem is challenging due to the large search space of potential configurations and the cost of manually examining configurations. Existing methods, such as the rank-based method, use a progressive strategy to sample configurations to reduce the cost of examining configurations. This sampling strategy is guided by frequent and random trials and may fail in balancing the number of samples and the ranking difference (i.e., the minimum of actual ranks in the predicted ranking). In this paper, we proposed a sampling method, namely MoConfig, which uses multi-objective optimization to minimize the number of samples and the ranking difference. Each solution in MoConfig is a sampling set of configurations and can be directly used as the input of existing methods of performance ranking. We conducted experiments on 20 datasets from real-world configurable systems. Experimental results demonstrate that MoConfig can sample fewer configurations and rank better than the existing rank-based method. We also compared the results by four algorithms of multi-objective optimization and found that NSGA-II performs well. Our proposed method can be used to improve the ranking difference and reduce the number of samples in building predictive models of performance ranking.

GitHub is a widely used collaborative platform for global software development. A pull request plays an important role in bridging code changes with version controlling. Developers can freely and parallelly submit pull requests to base branches and wait for the merge of their contributions. However, several developers may submit pull requests to edit the same lines of code; such pull requests result in a latent collaborative conflict. We refer such pull requests that tend to change the same lines and remain open during an overlapping time period to as competing pull requests. In this paper, we conduct a study on 9,476 competing pull requests from 60 Java repositories in GitHub. The data are collected by mining pull requests that are submitted in 2017 from top Java projects with the most forks. We explore how multiple pull requests change the same code via answering four research questions, including the distribution of competing pull requests, the involved developers, the changed lines of code, and the impact on pull request integration. Our study shows that there indeed exist competing pull requests in GitHub: in 45 out of 60 repositories, over 31% of pull requests belong to competing pull requests; 20 repositories have more than 100 groups of competing pull requests, each of which is submitted by over five developers; 42 repositories have over 10% of competing pull requests with over 10 same lines of code. Meanwhile, we observe that attributes of competing pull requests do not have strong impacts on pull request integration, comparing with other types of pull requests. Our study provides a preliminary analysis for further research that aims to detect and eliminate conflicts among competing pull requests.

In this paper, we examine retiming and pipelining in the context of system-level optimization techniques. Our main contributions are: (a) functionally equivalent retiming and delay balancing as necessary techniques for pipelining and retiming system-level graphs while maintaining numerical fidelity, and (b) clock-rate pipelining, as a new technique that leverages the knowledge of multi-rate design spec to pipeline multi-cycle paths. All these techniques have been implemented within HDL Coder™, a tool that generates synthesizable HDL code from Simulink ® and MATLAB®.

FPGA-based acceleration of molecular dynamics (MD) has been the subject of several recent studies. Implementing long-range forces, however, has only recently been addressed. Here we describe a solution based on the multigrid method. We show that multigrid is, in general, an excellent match to FPGAs: the primary operations take advantage of the large number of independently addressable RAMs and the efficiency with which complex systolic structures can be implemented. The multigrid accelerator has been integrated into our existing MD system, and an overall performance gain of 5x to 7x has been obtained, depending on hardware configuration and reference code. The simulation accuracy is comparable to the original double precision serial code.

The authors describe a new pipeline for computing non-bonded forces and its integration into the ProtoMol molecular dynamics (MD) code. There are several innovations: a novel interpolation strategy, including use of higher order terms; coefficient generation with orthonormal functions; the introduction of "semi-floating point" numbering; and various issues related to system integration. As a result, we are able to model far more particle types, without relying on complex buffering, and obtain higher accuracy than previously. A two pipeline accelerator has been implemented on a 2004-era Xilinx VirtexII Pro VP70, integrated into ProtoMol, and tested with an enzyme inhibitor model having 8000 particles and 26 particle types. Despite performing all O(n) work on the host PC, as well as the data conversion and communication overhead, this implementation yields 5.5x to 15.7x speed-ups over a 2.8GHz PC (depending on whether cell lists are used), and with accuracy comparable to the serial code

Approximate string matching is fundamental to bioinformatics, and has been the subject of numerous FPGA acceleration studies. We address issues with respect to FPGA implementations of both BLAST- and dynamic programming- (DP) based methods. Our primary contributions are two new algorithms for emulating the seeding and extension phases of BLAST. These operate in a single pass through a database at streaming rate (110 Maa/sec on a VP70 for query sizes up to 600 and 170 Maa/sec on a Virtex4 for query sizes up to 1024), and with no preprocessing other than loading the query string. Further, they use very high sensitivity with no slowdown. While current DP-based methods also operate at streaming rate, generating results can be cumbersome. We address this with a new structure for data extraction. We present results from several implementations

FPGA-based acceleration of molecular dynamics (MD) has been the subject of several recent studies. The paper describes a new non-bonded force computation pipeline implemented on a 2004-era COTS FPGA board and its integration into the ProtoMol MD code. There are several innovations: a novel interpolation strategy; the introduction of a "semi-floating point" format; and various issues related to system integration. As a result, the authors are able to model far more particle types, without relying on complex buffering, and obtain higher accuracy than previously. A two pipeline accelerator has been implemented on a Xilinx VirtexII Pro VP70, integrated into ProtoMol, and tested with an enzyme inhibitor model having 8000 particles and 26 particle types. Despite performing all O(n) work on the host PC, as well as the data conversion and communication overhead, this implementation yields a 5.5times speed-up over a 2.8GHz PC, and with accuracy comparable to the serial code

Molecular dynamics (MD) is of central importance to computational chemistry and its myriad applications. In this paper we show that, at even a preliminary stage of development, MD can be implemented efficiently on a COTS FPGA board, and that a 57x speed-up over a PC implementation can be obtained. We sketch our FPGA implementation and describe how performance tuning and precision management could double this factor.

Molecular dynamics (MD) is of central importance to computational chemistry. Here we show that MD can be implemented efficiently on a COTS FPGA board, and that speed-ups from 31/spl times/ to 88/spl times/ over a PC implementation can be obtained. Although the amount of speed-up depends on the stability required, 46/spl times/ can be obtained with virtually no detriment, and the upper end of the range is apparently viable in many cases. We sketch our FPGA implementations and describe the effects of precision on the trade-off between performance and quality of the MD simulation.

We show how an application of central importance to computational biochemistry can be implemented efficiently on an FPGA. This requires reformulating the algorithm and taking advantage of application characteristics to maximize device utilization.