3,262 research outputs found
A Simple Parallel and Distributed Sampling Technique: Local Glauber Dynamics
Sampling constitutes an important tool in a variety of areas: from machine learning and combinatorial optimization to computational physics and biology. A central class of sampling algorithms is the Markov Chain Monte Carlo method, based on the construction of a Markov chain with the desired sampling distribution as its stationary distribution. Many of the traditional Markov chains, such as the Glauber dynamics, do not scale well with increasing dimension. To address this shortcoming, we propose a simple local update rule based on the Glauber dynamics that leads to efficient parallel and distributed algorithms for sampling from Gibbs distributions.
Concretely, we present a Markov chain that mixes in O(log n) rounds when Dobrushin\u27s condition for the Gibbs distribution is satisfied. This improves over the LubyGlauber algorithm by Feng, Sun, and Yin [PODC\u2717], which needs O(Delta log n) rounds, and their LocalMetropolis algorithm, which converges in O(log n) rounds but requires a considerably stronger mixing condition. Here, n denotes the number of nodes in the graphical model inducing the Gibbs distribution, and Delta its maximum degree. In particular, our method can sample a uniform proper coloring with alpha Delta colors in O(log n) rounds for any alpha >2, which almost matches the threshold of the sequential Glauber dynamics and improves on the alpha>2 + sqrt{2} threshold of Feng et al
PROPAGATE: a seed propagation framework to compute Distance-based metrics on Very Large Graphs
We propose PROPAGATE, a fast approximation framework to estimate
distance-based metrics on very large graphs such as the (effective) diameter,
the (effective) radius, or the average distance within a small error. The
framework assigns seeds to nodes and propagates them in a BFS-like fashion,
computing the neighbors set until we obtain either the whole vertex set (the
diameter) or a given percentage (the effective diameter). At each iteration, we
derive compressed Boolean representations of the neighborhood sets discovered
so far. The PROPAGATE framework yields two algorithms: PROPAGATE-P, which
propagates all the seeds in parallel, and PROPAGATE-s which propagates the
seeds sequentially. For each node, the compressed representation of the
PROPAGATE-P algorithm requires bits while that of PROPAGATE-S only bit.
Both algorithms compute the average distance, the effective diameter, the
diameter, and the connectivity rate within a small error with high probability:
for any and using sample nodes, the error for the average distance is
bounded by , the error for the
effective diameter and the diameter are bounded by , and the error for the connectivity rate is bounded
by where is the diameter and is a measure of
connectivity of the graph. The time complexity is , where is the number of edges of the
graph. The experimental results show that the PROPAGATE framework improves the
current state of the art both in accuracy and speed. Moreover, we
experimentally show that PROPAGATE-S is also very efficient for solving the All
Pair Shortest Path problem in very large graphs
On the Hardware Implementation of Triangle Traversal Algorithms for Graphics Processing
Current GPU architectures provide impressive processing rates in graphical applications because of their specialized graphics pipeline. However, little attention has been paid to the analysis and study of different hardware architectures to implement speciļ¬c pipeline stages. In this work we have identiļ¬ed one of the key stages in the graphics pipeline, the triangle traversal procedure, and we have implemented three different algorithms in hardware: bounding-box, zig-zag and Hilbert curve-based. The experimental results show that important area-performance trade-offs can be met when implementing key image processing algorithms in hardwar
Distributed Computing with Channel Noise
A group of users want to run a distributed protocol over a network where communication occurs via private point-to-point channels. Unfortunately, an adversary, who knows , is able to maliciously flip bits on the channels. Can we efficiently simulate in the presence of such an adversary?
We show that this is possible, even when , the number of bits sent in , and , the number of bits flipped by the adversary are not known in advance. In particular, we show how to create a robust version of that 1) fails with probability at most , for any ; and 2) sends bits, where the notation hides a term multiplying .
Additionally, we show how to improve this result when the average message size is not constant. In particular, we give an algorithm that sends bits. This algorithm is adaptive in that it does not require a priori knowledge of . We note that if is , then this improved algorithm sends only bits, and is therefore within a constant factor of optimal
- ā¦