scholarly journals From high-level inference algorithms to efficient code

2019 ◽  
Vol 3 (ICFP) ◽  
pp. 1-30 ◽  
Author(s):  
Rajan Walia ◽  
Praveen Narayanan ◽  
Jacques Carette ◽  
Sam Tobin-Hochstadt ◽  
Chung-chieh Shan
Keyword(s):  
Inference Algorithms ◽  
Efficient Code ◽  
High Level

NENOK — A SOFTWARE ARCHITECTURE FOR GENERIC INFERENCE

2010 ◽  
Vol 19 (01) ◽  
pp. 65-99 ◽  
Author(s):  
MARC POULY
Keyword(s):  
Programming Languages ◽  
Software Library ◽  
Inference Process ◽  
Software Projects ◽  
Open Problems ◽  
Constraint Systems ◽  
Fast Prototyping ◽  
Inference Algorithms ◽  
Key Competences ◽  
High Level

Computing inference from a given knowledgebase is one of the key competences of computer science. Therefore, numerous formalisms and specialized inference routines have been introduced and implemented for this task. Typical examples are Bayesian networks, constraint systems or different kinds of logic. It is known today that these formalisms can be unified under a common algebraic roof called valuation algebra. Based on this system, generic inference algorithms for the processing of arbitrary valuation algebras can be defined. Researchers benefit from this high level of abstraction to address open problems independently of the underlying formalism. It is therefore all the more astonishing that this theory did not find its way into concrete software projects. Indeed, all modern programming languages for example provide generic sorting procedures, but generic inference algorithms are still mythical creatures. NENOK breaks a new ground and offers an extensive library of generic inference tools based on the valuation algebra framework. All methods are implemented as distributed algorithms that process local and remote knowledgebases in a transparent manner. Besides its main purpose as software library, NENOK also provides a sophisticated graphical user interface to inspect the inference process and the involved graphical structures. This can be used for educational purposes but also as a fast prototyping architecture for inference formalisms.

scholarly journals Implied Constraints for Automaton Constraints

10.29007/m767 ◽  
2018 ◽  
Author(s):  
Maria Andreina Francisco ◽  
Pierre Flener ◽  
Justin Pearson
Keyword(s):  
Constraint Programming ◽  
Specific Choice ◽  
Inference Algorithms ◽  
Line Process ◽  
Implied Constraints ◽  
High Level ◽  
Process Constraints ◽  
Automated Tool

Automata allow many constraints on sequences of variables to be specified in a high-level way for constraint programming solvers. An automaton with accumulators induces a decomposition of the specified constraint into a conjunction of constraints with existing inference algorithms, called propagators. Towards improving propagation, we design a fully automated tool that selects, in an off-line process, constraints that are implied by such a decomposition. We show that a suitable problem-specific choice among the tool-selected implied constraints can considerably improve solving time and propagation, both on a decomposition in isolation and on entire constraint problems containing the decomposition.

From natural semantics to C: A formal derivation of two STG machines

2009 ◽  
Vol 19 (1) ◽  
pp. 47-94 ◽  
Author(s):  
ALBERTO DE LA ENCINA ◽  
RICARDO PEÑA
Keyword(s):  
Functional Programming ◽  
Functional Language ◽  
Levels Of Abstraction ◽  
Additional Information ◽  
Formal Derivation ◽  
Derivation Step ◽  
Starting Point ◽  
Efficient Code ◽  
Lazy Semantics ◽  
High Level

AbstractThe Spineless Tag-less G-machine (STG machine) was defined as the target abstract machine for compiling the lazy functional language Haskell. It is at the heart of the Glasgow Haskell Compiler (GHC) which is claimed to be the Haskell compiler that generates the most efficient code. A high-level description of the STG machine can be found in Peyton Jones (In Journal of Functional programming, 2(2), 127–202, 1992), Marlow & Peyton Jones (In Sigplan Not., 39(9), 4–5, 2004), and Marlow & Peyton Jones (In Journal of Functional Programming, 16(4–5), 415–449, 2006). Should the reader be interested in a more detailed view, then the only additional information available is the Haskell code of GHC and the C code of its runtime system.It is hard to prove that this machine correctly implements the lazy semantics of Haskell. Part of the problem lies in the fact that the STG machine executes a bare-bones functional language, called STGL, much lower level than Haskell. Therefore, part of the correctness should be—and it is—established by showing that the translation from Haskell to STGL preserves Haskell's semantics.The other part involves showing that the STG machine correctly implements the lazy semantics of STGL. In this paper we provide a step-by-step formal derivation of the STG machine and of its compilation to C, starting from a natural semantics of STGL. Thus, our starting point is higher level than the descriptions found Peyton Jones (In Journal of Functional programming, 2(2), 127–202, 1992) and Marlow & Peyton Jones (In Sigplan Not., 39(9), 4–5, 2004), and our arrival point is lower level than those works. Additionally, there has been substantial changes between the so-called push/enter model of the STG machine described in Peyton Jones (In Journal of Functional programming, 2(2), 127–202, 1992), and the eval/apply model of the STG machine described in Marlow & Peyton Jones (In Sigplan Not., 39(9), 4–5, 2004). So, in fact, we derive two machines instead of one, starting from the same initial semantics.At each step we provide enough intuitions and explanations in order to understand the refinement, and then the formal definitions and statements proving that the derivation step is sound and complete. The main contribution of the paper is to show that an efficient machine such as the STG can be presented, understood, and formally reasoned about at different levels of abstraction.

scholarly journals Grafs: declarative graph analytics

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-32
Author(s):  
Farzin Houshmand ◽  
Mohsen Lesani ◽  
Keval Vora
Keyword(s):  
High Performance ◽  
Large Scale ◽  
Kernel Functions ◽  
Runtime Systems ◽  
Graph Processing ◽  
Large Graphs ◽  
Graph Analytics ◽  
Efficient Code ◽  
High Level ◽  
Abstract Interface

Graph analytics elicits insights from large graphs to inform critical decisions for business, safety and security. Several large-scale graph processing frameworks feature efficient runtime systems; however, they often provide programming models that are low-level and subtly different from each other. Therefore, end users can find implementation and specially optimization of graph analytics error-prone and time-consuming. This paper regards the abstract interface of the graph processing frameworks as the instruction set for graph analytics, and presents Grafs, a high-level declarative specification language for graph analytics and a synthesizer that automatically generates efficient code for five high-performance graph processing frameworks. It features novel semantics-preserving fusion transformations that optimize the specifications and reduce them to three primitives: reduction over paths, mapping over vertices and reduction over vertices. Reductions over paths are commonly calculated based on push or pull models that iteratively apply kernel functions at the vertices. This paper presents conditions, parametric in terms of the kernel functions, for the correctness and termination of the iterative models, and uses these conditions as specifications to automatically synthesize the kernel functions. Experimental results show that the generated code matches or outperforms handwritten code, and that fusion accelerates execution.

scholarly journals From Support Propagation to Belief Propagation in Constraint Programming

2019 ◽  
Vol 66 ◽  
Author(s):  
Gilles Pesant
Keyword(s):  
Constraint Programming ◽  
Belief Propagation ◽  
Combinatorial Problems ◽  
Global Constraints ◽  
Inference Algorithms ◽  
Shared Variables ◽  
Shared Information ◽  
Individual Variables ◽  
High Level ◽  
Search Guidance

The distinctive driving force of constraint programming to solve combinatorial problems has been a privileged access to problem structure through the high-level models it uses. From that exposed structure in the form of so-called global constraints, powerful inference algorithms have shared information between constraints by propagating it through shared variables’ domains, traditionally by removing unsupported values. This paper investigates a richer propagation medium made possible by recent work on counting solutions inside constraints. Beliefs about individual variable-value assignments are exchanged between contraints and iteratively adjusted. It generalizes standard support propagation and aims to converge to the true marginal distributions of the solutions over individual variables. Its advantage over standard belief propagation is that the higher-level models featuring large-arity (global) constraints do not tend to create as many cycles, which are known to be problematic for convergence. The necessary architectural changes to a constraint programming solver are described and an empirical study of the proposal is conducted on its implementation. We find that it provides close approximations to the true marginals and that it significantly improves search guidance.

A primitive-based strategy for producing efficient code for very high level programs

1993 ◽  
Vol 19 (1) ◽  
pp. 41-50 ◽  
Author(s):  
Wai-Mee Ching ◽  
Paul Carini ◽  
Dz-Ching Ju
Keyword(s):  
Efficient Code ◽  
High Level ◽  
Very High

scholarly journals Identification of Relations between BDI Logic and BDI Agents

2011 ◽  
Vol 44 (1) ◽  
pp. 21-28
Author(s):  
Arvids Grabovskis ◽  
Janis Grundspenkis
Keyword(s):  
Intelligent Agent ◽  
Main Idea ◽  
Theorem Prover ◽  
Bdi Agents ◽  
Agent Architectures ◽  
Advantages And Disadvantages ◽  
Inference Algorithms ◽  
Bdi Logic ◽  
High Level ◽  
Mental Objects

Identification of Relations between BDI Logic and BDI AgentsBDI (Beliefs, Desires, Intentions) is one of the most popular intelligent agent architectures which was inspired by multi-modal BDI logics. The main idea behind BDI is to implement system's behaviour by specifying it as a set of mental objects. This allows designing systems at a high level of abstraction which come closer to a human-like thinking. Although this architecture has been rapidly developing for about 20 years, its relevance to BDI logic is still arguable. This paper describes the basics of modal logic and main inference algorithms. Main concepts of BDI agents are presented and their relationships with BDI logic are discussed. Finally advantages and disadvantages of implementing BDI interpreter as a theorem prover are discussed.

scholarly journals A Cyber Physical System Crowdsourcing Inference Method Based on Tempering: An Advancement in Artificial Intelligence Algorithms

2021 ◽  
Vol 2021 ◽  
pp. 1-11
Author(s):  
Jia Liu ◽  
Mingchu Li ◽  
William C. Tang ◽  
Sardar M. N. Islam
Keyword(s):  
Ground Truth ◽  
Difficulty Level ◽  
Local Optimum ◽  
Inference Method ◽  
Real World Data ◽  
Local Optima ◽  
Physical Systems ◽  
Inference Algorithms ◽  
High Level ◽  
Better Than

Activity selection is critical for the smart environment and Cyber-Physical Systems (CPSs) that can provide timely and intelligent services, especially as the number of connected devices is increasing at an unprecedented speed. As it is important to collect labels by various agents in the CPSs, crowdsourcing inference algorithms are designed to help acquire accurate labels that involve high-level knowledge. However, there are some limitations in the algorithm in the existing literature such as incurring extra budget for the existing algorithms, inability to scale appropriately, requiring the knowledge of prior distribution, difficulties to implement these algorithms, or generating local optima. In this paper, we provide a crowdsourcing inference method with variational tempering that obtains ground truth as well as considers both the reliability of workers and the difficulty level of the tasks and ensure a local optimum. The numerical experiments of the real-world data indicate that our novel variational tempering inference algorithm performs better than the existing advancing algorithms. Therefore, this paper provides a new efficient algorithm in CPSs and machine learning, and thus, it makes a new contribution to the literature.

scholarly journals State-Space Abstractions for Probabilistic Inference: A Systematic Review

2018 ◽  
Vol 63 ◽  
pp. 789-848 ◽  
Author(s):  
Stefan Lüdtke ◽  
Max Schröder ◽  
Frank Krüger ◽  
Sebastian Bader ◽  
Thomas Kirste
Keyword(s):  
State Space ◽  
Probabilistic Inference ◽  
Future Research ◽  
Lifted Inference ◽  
Research Areas ◽  
Research Fields ◽  
Compact Representations ◽  
Inference Algorithms ◽  
Human Behavior Recognition ◽  
High Level

Tasks such as social network analysis, human behavior recognition, or modeling biochemical reactions, can be solved elegantly by using the probabilistic inference framework. However, standard probabilistic inference algorithms work at a propositional level, and thus cannot capture the symmetries and redundancies that are present in these tasks. Algorithms that exploit those symmetries have been devised in different research fields, for example by the lifted inference-, multiple object tracking-, and modeling and simulation-communities. The common idea, that we call state space abstraction, is to perform inference over compact representations of sets of symmetric states. Although they are concerned with a similar topic, the relationship between these approaches has not been investigated systematically. This survey provides the following contributions. We perform a systematic literature review to outline the state of the art in probabilistic inference methods exploiting symmetries. From an initial set of more than 4,000 papers, we identify 116 relevant papers. Furthermore, we provide new high-level categories that classify the approaches, based on common properties of the approaches. The research areas underlying each of the categories are introduced concisely. Researchers from different fields that are confronted with a state space explosion problem in a probabilistic system can use this classification to identify possible solutions. Finally, based on this conceptualization, we identify potentials for future research, as some relevant application domains are not addressed by current approaches.

Transcription factor/DNA interactions visualized by electron spectroscopic imaging

1992 ◽  
Vol 50 (1) ◽  
pp. 450-451
Author(s):  
David P. Bazett-Jones ◽  
Mark L. Brown
Keyword(s):  
Transcription Factor ◽  
Dna Sequences ◽  
Transcription Initiation ◽  
Molecular Mechanisms ◽  
Phosphorus Content ◽  
Spectroscopic Imaging ◽  
Electron Spectroscopic Imaging ◽  
Dna Backbone ◽  
Two Parameters ◽  
High Level

A multisubunit RNA polymerase enzyme is ultimately responsible for transcription initiation and elongation of RNA, but recognition of the proper start site by the enzyme is regulated by general, temporal and gene-specific trans-factors interacting at promoter and enhancer DNA sequences. To understand the molecular mechanisms which precisely regulate the transcription initiation event, it is crucial to elucidate the structure of the transcription factor/DNA complexes involved. Electron spectroscopic imaging (ESI) provides the opportunity to visualize individual DNA molecules. Enhancement of DNA contrast with ESI is accomplished by imaging with electrons that have interacted with inner shell electrons of phosphorus in the DNA backbone. Phosphorus detection at this intermediately high level of resolution (≈lnm) permits selective imaging of the DNA, to determine whether the protein factors compact, bend or wrap the DNA. Simultaneously, mass analysis and phosphorus content can be measured quantitatively, using adjacent DNA or tobacco mosaic virus (TMV) as mass and phosphorus standards. These two parameters provide stoichiometric information relating the ratios of protein:DNA content.

Sign in / Sign up

Export Citation Format

Share Document