Sequential Classification by Exploring Levels of Abstraction

AbstractIn the paper we describe a sequential classification scheme that iteratively explores levels of abstraction in the description of examples. These levels of abstraction represent attribute values of increasing precision. Specifically, we assume attribute values constitute an ontology (i.e., attribute value ontology) reflecting a domain-specific background knowledge, where more general values subsumes more precise ones. While there are approaches that consider levels of abstraction during learning, the novelty of our proposal consists in exploring levels of abstraction when classifying new examples. The described scheme is essential when tests that increase precision of example description are associated with costs – such a situation is often encountered in medical diagnosis. Experimental evaluation of the proposed classification scheme combined with ontological Bayes classifier (i.e., a näıve Bayes classifier expanded to handle attribute value ontologies) demonstrates that the classification accuracy obtained at higher levels of abstraction (i.e., more general description of classified examples) converges very quickly to the classification accuracy for classified examples represented precisely. This finding indicates we should be able to reduce the number of tests and thus limit their cost without deterioration of the prediction accuracy

Software Model Checking with Explicit Scheduler and Symbolic Threads

In many practical application domains, the software is organized into a set of threads, whose activation is exclusive and controlled by a cooperative scheduling policy: threads execute, without any interruption, until they either terminate or yield the control explicitly to the scheduler. The formal verification of such software poses significant challenges. On the one side, each thread may have infinite state space, and might call for abstraction. On the other side, the scheduling policy is often important for correctness, and an approach based on abstracting the scheduler may result in loss of precision and false positives. Unfortunately, the translation of the problem into a purely sequential software model checking problem turns out to be highly inefficient for the available technologies. We propose a software model checking technique that exploits the intrinsic structure of these programs. Each thread is translated into a separate sequential program and explored symbolically with lazy abstraction, while the overall verification is orchestrated by the direct execution of the scheduler. The approach is optimized by filtering the exploration of the scheduler with the integration of partial-order reduction. The technique, called ESST (Explicit Scheduler, Symbolic Threads) has been implemented and experimentally evaluated on a significant set of benchmarks. The results demonstrate that ESST technique is way more effective than software model checking applied to the sequentialized programs, and that partial-order reduction can lead to further performance improvements.Comment: 40 pages, 10 figures, accepted for publication in journal of logical methods in computer scienc