A Compilation Target for Probabilistic Programming Languages

Forward inference techniques such as sequential Monte Carlo and particle Markov chain Monte Carlo for probabilistic programming can be implemented in any programming language by creative use of standardized operating system functionality including processes, forking, mutexes, and shared memory. Exploiting this we have defined, developed, and tested a probabilistic programming language intermediate representation language we call probabilistic C, which itself can be compiled to machine code by standard compilers and linked to operating system libraries yielding an efficient, scalable, portable probabilistic programming compilation target. This opens up a new hardware and systems research path for optimizing probabilistic programming systems.Comment: In Proceedings of the 31st International Conference on Machine Learning (ICML), 201

Data Assimilation by Artificial Neural Networks for an Atmospheric General Circulation Model: Conventional Observation

This paper presents an approach for employing artificial neural networks (NN) to emulate an ensemble Kalman filter (EnKF) as a method of data assimilation. The assimilation methods are tested in the Simplified Parameterizations PrimitivE-Equation Dynamics (SPEEDY) model, an atmospheric general circulation model (AGCM), using synthetic observational data simulating localization of balloon soundings. For the data assimilation scheme, the supervised NN, the multilayer perceptrons (MLP-NN), is applied. The MLP-NN are able to emulate the analysis from the local ensemble transform Kalman filter (LETKF). After the training process, the method using the MLP-NN is seen as a function of data assimilation. The NN were trained with data from first three months of 1982, 1983, and 1984. A hind-casting experiment for the 1985 data assimilation cycle using MLP-NN were performed with synthetic observations for January 1985. The numerical results demonstrate the effectiveness of the NN technique for atmospheric data assimilation. The results of the NN analyses are very close to the results from the LETKF analyses, the differences of the monthly average of absolute temperature analyses is of order 0.02. The simulations show that the major advantage of using the MLP-NN is better computational performance, since the analyses have similar quality. The CPU-time cycle assimilation with MLP-NN is 90 times faster than cycle assimilation with LETKF for the numerical experiment.Comment: 17 pages, 16 figures, monthly weather revie

Radiation-Induced Error Criticality in Modern HPC Parallel Accelerators

In this paper, we evaluate the error criticality of radiation-induced errors on modern High-Performance Computing (HPC) accelerators (Intel Xeon Phi and NVIDIA K40) through a dedicated set of metrics. We show that, as long as imprecise computing is concerned, the simple mismatch detection is not sufficient to evaluate and compare the radiation sensitivity of HPC devices and algorithms. Our analysis quantifies and qualifies radiation effects on applications’ output correlating the number of corrupted elements with their spatial locality. Also, we provide the mean relative error (dataset-wise) to evaluate radiation-induced error magnitude. We apply the selected metrics to experimental results obtained in various radiation test campaigns for a total of more than 400 hours of beam time per device. The amount of data we gathered allows us to evaluate the error criticality of a representative set of algorithms from HPC suites. Additionally, based on the characteristics of the tested algorithms, we draw generic reliability conclusions for broader classes of codes. We show that arithmetic operations are less critical for the K40, while Xeon Phi is more reliable when executing particles interactions solved through Finite Difference Methods. Finally, iterative stencil operations seem the most reliable on both architectures.This work was supported by the STIC-AmSud/CAPES scientific cooperation program under the EnergySFE research project grant 99999.007556/2015-02, EU H2020 Programme, and MCTI/RNP-Brazil under the HPC4E Project, grant agreement n° 689772. Tested K40 boards were donated thanks to Steve Keckler, Timothy Tsai, and Siva Hari from NVIDIA.Postprint (author's final draft

GPGPU implementation of modal parameter tracking by particle based Kalman filter

International audienceThis paper presents a method based on the use of Bayesian modal parameter recursive estimation basedon a particular Kalman filter algorithm with decoupled distributions for mass and stiffness. ParticularKalman filtering is a combination of two widely used Bayesian estimation methods working together:the particle filter (also called sequential Monte Carlo samplings) and the Kalman filter. Usual systemidentification techniques for civil and mechanical structures assume the availability of large set of dataderived from a stationary quasi steady structure. On the opposite, several scenarios involve time varyingstructures. For example, due to interaction with aerodynamics in aeronautics, some critical parametermay have to be monitored, for instability monitoring (leading possibly to flutter) of in flight data due tofuel consumption and speed change. This relates to the monitoring of time varying structural parameterssuch as frequencies and damping ratios. The main idea of a particular Kalman filter is to considerstochastic particles evolving in the parameter space. For each particle, a corresponding linear state isrecursively estimated by applying a Kalman filter to the mechanical system, whose modal parametersare driven by the evolution of this time-varying particle. The weight of each particle is computed fromthe likelihood of the parameter sample it represents and its corresponding state. This result in a bank ofadaptive coupled Kalman filters combined with their particle filter. However, the system parametrizationis relatively large. In order to provide fast and convincing results for large time varying structure, suchas an airplane, the execution time of the method has to be improved. In particular, the particle evolutionscan be run in parallel, Within the Cloud2sm project, A Quadro k6000 card of 3072 cores clocked to 3GB/s has been used. This paper will show a GPGPU implementation of the particular Kalman filter andthe first results will be discussed