Algorithmic Techniques for Processing Data Streams

We give a survey at some algorithmic techniques for processing data streams. After covering the basic methods of sampling and sketching, we present more evolved procedures that resort on those basic ones. In particular, we examine algorithmic schemes for similarity mining, the concept of group testing, and techniques for clustering and summarizing data streams

Bayesian Regularization based Neural Network Tool for Software Effort Estimation

Rapid growth of software industry leads to need of new technologies. Software effort estimation is one of the areas that need more concentration. Exact estimation is always a challenging task. Effort Estimation techniques are broadly classified into algorithmic and non-algorithmic techniques. An algorithmic model provides a mathematical equation for estimation which is based upon the analysis of data gathered from previously developed projects and Non-algorithmic techniques are based on new approaches, such as Soft Computing Techniques. Effective handling of cost is a basic need for any Software Organization. The main tasks for Software development estimation are determining the effort, cost and schedule of developing the project under consideration. Underestimation of project done knowingly just to win contract results into loses and also the poor quality project. So, accurate cost estimation leads to effective control of time and budget during software development. This paper presents the performance analysis of different training algorithms of neural network in effort estimation. For sake of ease, we have developed a tool in MATLAB and at last proved that Bayesian Regularization [20] gives more accurate results than other training algorithms

Simple and Effective Type Check Removal through Lazy Basic Block Versioning

Dynamically typed programming languages such as JavaScript and Python defer type checking to run time. In order to maximize performance, dynamic language VM implementations must attempt to eliminate redundant dynamic type checks. However, type inference analyses are often costly and involve tradeoffs between compilation time and resulting precision. This has lead to the creation of increasingly complex multi-tiered VM architectures. This paper introduces lazy basic block versioning, a simple JIT compilation technique which effectively removes redundant type checks from critical code paths. This novel approach lazily generates type-specialized versions of basic blocks on-the-fly while propagating context-dependent type information. This does not require the use of costly program analyses, is not restricted by the precision limitations of traditional type analyses and avoids the implementation complexity of speculative optimization techniques. We have implemented intraprocedural lazy basic block versioning in a JavaScript JIT compiler. This approach is compared with a classical flow-based type analysis. Lazy basic block versioning performs as well or better on all benchmarks. On average, 71% of type tests are eliminated, yielding speedups of up to 50%. We also show that our implementation generates more efficient machine code than TraceMonkey, a tracing JIT compiler for JavaScript, on several benchmarks. The combination of implementation simplicity, low algorithmic complexity and good run time performance makes basic block versioning attractive for baseline JIT compilers

Stronger Baselines for Trustable Results in Neural Machine Translation

Interest in neural machine translation has grown rapidly as its effectiveness has been demonstrated across language and data scenarios. New research regularly introduces architectural and algorithmic improvements that lead to significant gains over "vanilla" NMT implementations. However, these new techniques are rarely evaluated in the context of previously published techniques, specifically those that are widely used in state-of-theart production and shared-task systems. As a result, it is often difficult to determine whether improvements from research will carry over to systems deployed for real-world use. In this work, we recommend three specific methods that are relatively easy to implement and result in much stronger experimental systems. Beyond reporting significantly higher BLEU scores, we conduct an in-depth analysis of where improvements originate and what inherent weaknesses of basic NMT models are being addressed. We then compare the relative gains afforded by several other techniques proposed in the literature when starting with vanilla systems versus our stronger baselines, showing that experimental conclusions may change depending on the baseline chosen. This indicates that choosing a strong baseline is crucial for reporting reliable experimental results.Comment: To appear at the Workshop on Neural Machine Translation (WNMT

GRASP: A New Search Algorithm for Satisfiability

This paper introduces GRASP (Generic search Algorithm J3r the Satisfiabilily Problem), an integrated algorithmic J3amework 30r SAT that unifies several previously proposed searchpruning techniques and jcilitates identification of additional ones. GRASP is premised on the inevitability of conflicts during search and its most distinguishingjature is the augmentation of basic backtracking search with a powerful conflict analysis procedure. Analyzing conflicts to determine their causes enables GRASP to backtrack non-chronologically to earlier levels in the search tree, potentially pruning large portions of the search space. In addition, by 'ecording" the causes of conflicts, GRASP can recognize and preempt the occurrence of similar conflicts later on in the search. Einally, straighrward bookkeeping of the causali y chains leading up to conflicts a/lows GRASP to identij) assignments that are necessary jr a solution to be found. Experimental results obtained jom a large number of benchmarks, including many J3om the field of test pattern generation, indicate that application of the proposed conflict analysis techniques to SAT algorithms can be extremely ejctive jr a large number of representative classes of SAT instances