@Override
public void readFields(DataInput in) throws IOException {
int numEdges = in.readInt();
initialize(numEdges);
for (int i = 0; i < numEdges; ++i) {
neighbors.add(in.readInt());
}
}
protected void populateCandidateParents(
Int2ObjectOpenHashMap<IntOpenHashSet> candidateParentsPerNode, IntOpenHashSet chunk) {
for (int v : chunk) {
IntOpenHashSet candidateParents = new IntOpenHashSet();
Int2ObjectOpenHashMap<IntArrayList> cPlusV = auxiliary.getCplusOnline(v);
if (cPlusV != null) {
for (int action : cPlusV.keySet()) {
for (int u : cPlusV.get(action)) {
candidateParents.add(u);
}
}
}
candidateParentsPerNode.put(v, candidateParents);
}
}
@Override
public void add(Edge<IntWritable, NullWritable> edge) {
neighbors.add(edge.getTargetVertexId().get());
}
/**
* For a specific sub-set of blocks (child nodes), find a 'base' subset of parents for which the
* block's logLikelihood is not -Infinity
*
* @param candidateParentsPerNode
* @param chosenArcsPerNode
* @param setOfBlocks
* @return
*/
protected double getOutOfMinusInfinity(
Int2ObjectOpenHashMap<IntOpenHashSet> candidateParentsPerNode,
Int2ObjectOpenHashMap<ObjectOpenHashSet<Arc>> chosenArcsPerNode,
IntOpenHashSet setOfBlocks,
TIntDoubleHashMap logLPerNode) {
double totalLogL = 0;
ProgressLogger pl = new ProgressLogger(LOGGER, ProgressLogger.TEN_SECONDS, "blocks");
pl.start("Begin initializing, to avoid zero likelihood, using set-cover heuristic");
pl.expectedUpdates = setOfBlocks.size();
int nArcs = 0;
for (int v : setOfBlocks) {
pl.update();
IntOpenHashSet vParents = candidateParentsPerNode.get(v);
Int2ObjectOpenHashMap<IntOpenHashSet> parentActions =
new Int2ObjectOpenHashMap<IntOpenHashSet>();
Int2ObjectOpenHashMap<IntArrayList> cPlusV = auxiliary.getCplusOnline(v);
Int2ObjectOpenHashMap<IntArrayList> cMinusV = auxiliary.getCminusOnline(v);
if (cPlusV != null) {
IntSet actions = cPlusV.keySet();
// Heuristic: first add the parents that participate in A+ for
// most actions
for (int action : actions) {
for (int u : cPlusV.get(action)) {
if (!parentActions.containsKey(u)) {
parentActions.put(u, new IntOpenHashSet());
}
parentActions.get(u).add(action);
}
}
}
KeepMaximum km = new KeepMaximum();
km.addAllKey2Listsize(parentActions);
IntOpenHashSet baseSetOfParents = new IntOpenHashSet();
double logL = Double.NEGATIVE_INFINITY;
while (logL == Double.NEGATIVE_INFINITY && (km.getMaximumKey() != -1)) {
int u = km.getMaximumKey();
if (baseSetOfParents.contains(u)) {
throw new IllegalStateException("Attempted to add twice the same parent");
}
baseSetOfParents.add(u);
logL = blockLogLikelihood(v, cPlusV, cMinusV, baseSetOfParents);
IntOpenHashSet uActions = parentActions.get(u);
for (int parent : vParents) {
parentActions.get(parent).removeAll(uActions);
}
vParents.remove(u);
parentActions.remove(u);
km.reset();
km.addAllKey2Listsize(parentActions);
}
// keep track of the likelihood
totalLogL += logL;
if (logLPerNode != null) {
logLPerNode.put(v, logL);
}
chosenArcsPerNode.put(v, new ObjectOpenHashSet<Arc>());
for (int u : baseSetOfParents) {
nArcs++;
chosenArcsPerNode.get(v).add(new Arc(u, v));
}
}
pl.stop("Done initialization. Added " + nArcs + " arcs, logLikelihood=" + totalLogL);
return totalLogL;
}