349,932 research outputs found
Anytime coalition structure generation on synergy graphs
We consider the coalition structure generation (CSG) problem on synergy graphs, which arises in many practical applications where communication constraints, social or trust relationships must be taken into account when forming coalitions. We propose a novel representation of this problem based on the concept of edge contraction, and an innovative branch and bound approach (CFSS), which is particularly efficient when applied to a general class of characteristic functions. This new model provides a non-redundant partition of the search space, hence allowing an effective parallelisation. We evaluate CFSS on two benchmark functions, the edge sum with coordination cost and the collective energy purchasing functions, comparing its performance with the best algorithm for CSG on synergy graphs: DyCE. The latter approach is centralised and cannot be efficiently parallelised due to the exponential memory requirements in the number of agents, which limits its scalability (while CFSS memory requirements are only polynomial). Our results show that, when the graphs are very sparse, CFSS is 4 orders of magnitude faster than DyCE. Moreover, CFSS is the first approach to provide anytime approximate solutions with quality guarantees for very large systems (i.e., with more than 2700 agents
Evolving test instances of the Hamiltonian completion problem
Predicting and comparing algorithm performance on graph instances is
challenging for multiple reasons. First, there is usually no standard set of
instances to benchmark performance. Second, using existing graph generators
results in a restricted spectrum of difficulty and the resulting graphs are
usually not diverse enough to draw sound conclusions. That is why recent work
proposes a new methodology to generate a diverse set of instances by using an
evolutionary algorithm. We can then analyze the resulting graphs and get key
insights into which attributes are most related to algorithm performance. We
can also fill observed gaps in the instance space in order to generate graphs
with previously unseen combinations of features. This methodology is applied to
the instance space of the Hamiltonian completion problem using two different
solvers, namely the Concorde TSP Solver and a multi-start local search
algorithm.Comment: 12 pages, 12 figures, minor revisions in section
Anytime Coalition Structure Generation on Scale-Free and Community Networks
We consider the coalition structure generation (CSG) problem on synergy graphs, which arises in many practical applications where communication constraints, social or trust relationships must be taken into account when forming coalitions. We propose a novel representation of this problem based on the concept of edge contraction, and an innovative branch and bound approach (CFSS), which is particularly efficient when applied to a general class of
characteristic functions. This new model provides a non-redundant partition of the search space, hence allowing an effective parallelisation. We evaluate CFSS on two benchmark functions, the edge sum with coordination cost and the
collective energy purchasing functions, comparing its performance with the best algorithm for CSG on synergy graphs: DyCE. The latter approach is centralised and cannot be efficiently parallelised due to the exponential memory requirements in the number of agents, which limits its scalability (while CFSS memory requirements are only polynomial). Our results show that, when the graphs are very sparse, CFSS is 4 orders of magnitude faster than DyCE. Moreover, CFSS is the first approach to provide anytime approximate solutions with quality guarantees for very large systems (i.e., with more than 2700 agents).Cerquides and Rodríguez-Aguilar are funded by projects COR (TIN2012-38876-C02-01), AT (CSD2007-0022), and the Generalitat of Catalunya grant 2009-SGR-1434. This work was supported by the EPSRC-Funded ORCHID Project EP/I011587/1Peer Reviewe
Anytime coalition structure generation on synergy graphs
We consider the coalition structure generation (CSG) problem on synergy graphs, which arises in many practical applications where communication constraints, social or trust relationships must be taken into account when forming coalitions. We propose a novel representation of this problem based on the concept of edge contraction, and an innovative branch and bound approach (CFSS), which is particularly efficient when applied to a general class of characteristic functions. This new model provides a non-redundant partition of the search space, hence allowing an effective paralleli-sation. We evaluate CFSS on two benchmark functions, the edge sum with coordination cost and the collective energy purchasing functions, comparing its performance with the best algorithm for CSG on synergy graphs: DyCE. The latter approach is centralised and cannot be efficiently parallelised due to the exponential memory requirements in the number of agents, which limits its scalability (while CFSS memory requirements are only polynomial). Our results show that, when the graphs are very sparse, CFSS is 4 orders of magnitude faster than DyCE. Moreover, CFSS is the first approach to provide anytime approximate solutions with quality guarantees for very large systems (i.e., with more than 2700 agents). Copyright © 2014, International Foundation for Autonomous Agents and Multiagent Systems (www.ifaamas.org). All rights reserved.Cerquides and Rodríguez-Aguilar are funded by projects COR (TIN2012-38876-C02-01), AT (CSD2007-0022), and the Generalitat of Catalunya grant 2009-SGR-1434. This work was supported by the EPSRC-Funded ORCHID Project EP/I011587/1Peer Reviewe
Fast and Lean Immutable Multi-Maps on the JVM based on Heterogeneous Hash-Array Mapped Tries
An immutable multi-map is a many-to-many thread-friendly map data structure
with expected fast insert and lookup operations. This data structure is used
for applications processing graphs or many-to-many relations as applied in
static analysis of object-oriented systems. When processing such big data sets
the memory overhead of the data structure encoding itself is a memory usage
bottleneck. Motivated by reuse and type-safety, libraries for Java, Scala and
Clojure typically implement immutable multi-maps by nesting sets as the values
with the keys of a trie map. Like this, based on our measurements the expected
byte overhead for a sparse multi-map per stored entry adds up to around 65B,
which renders it unfeasible to compute with effectively on the JVM.
In this paper we propose a general framework for Hash-Array Mapped Tries on
the JVM which can store type-heterogeneous keys and values: a Heterogeneous
Hash-Array Mapped Trie (HHAMT). Among other applications, this allows for a
highly efficient multi-map encoding by (a) not reserving space for empty value
sets and (b) inlining the values of singleton sets while maintaining a (c)
type-safe API.
We detail the necessary encoding and optimizations to mitigate the overhead
of storing and retrieving heterogeneous data in a hash-trie. Furthermore, we
evaluate HHAMT specifically for the application to multi-maps, comparing them
to state-of-the-art encodings of multi-maps in Java, Scala and Clojure. We
isolate key differences using microbenchmarks and validate the resulting
conclusions on a real world case in static analysis. The new encoding brings
the per key-value storage overhead down to 30B: a 2x improvement. With
additional inlining of primitive values it reaches a 4x improvement
GloVeNoR - Global Vectors for Node Representations
A graph is a very powerful abstract data type that can be used to model entities (nodes) and relationships (edges). Many real world networks like biological, computer and friendship networks can be represented as graphs. Graphs can be mined to extract interesting patterns and interactions between the participating entities. Recently, various Artificial Intelligence (AI) and Machine Learning (ML) techniques are used for this purpose. In order to do that, the nodes of a graph have to be represented as low dimensional feature vectors. Node embedding is the process of generating a �-dimensional feature vector corresponding to each node of a graph, such that the structurally similar nodes remain close in the �-dimensional space.
There are many state-of-the-art methods, like node2vec and DeepWalk to com- pute node embeddings. These techniques borrow methods like the Skip-Gram model, used in the domain of Natural Language Processing (NLP) to compute word embed- dings. This project explores the idea of porting the GloVe (Global Vectors for Word Representation) model, a popular technique for word embeddings, to a new method called GloVeNoR to compute node embeddings in a graph. We evaluate the model’s quality by comparing it with node2vec and DeepWalk on the problem of community detection on five different data sets. We observe that GloVeNoR discovers similar or better communities than the other existing models on all the datasets
Algebraic and tropical curves: comparing their moduli spaces
We construct the moduli space for equivalence classes of n-pointed tropical
curves of genus g, together with its compactification given by weighted
tropical curves, and establish some of its basic topological properties. We
compare it to the moduli spaces of smooth and stable algebraic curves, from the
combinatorial, the topological, and the Teichm\"uller point of view. The paper
is written in an expository style, and it generalizes some results contained in
sections 4-6 of arXiv:1001.2815v3.Comment: Changes in numbering to match the published versio
- …