@Override
public void write(DataOutput out) throws IOException {
out.writeInt(neighbors.size());
IntIterator neighborsIt = neighbors.iterator();
while (neighborsIt.hasNext()) {
out.writeInt(neighborsIt.nextInt());
}
}
@Override
public boolean containsAny(Object set) {
IntOpenHashSet setInt = (IntOpenHashSet) set;
for (int i = 0; i < this._length; i++)
if (setInt.contains(((TermIntList) _mTermList).getPrimitiveValue(_buf[i]))) return true;
return false;
}
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 NullWritable getEdgeValue(IntWritable targetVertexId) {
if (neighbors.contains(targetVertexId.get())) {
return NullWritable.get();
} else {
return null;
}
}
@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());
}
}
@Override
public int size() {
return neighbors.size();
}
@Override
public void remove(IntWritable targetVertexId) {
neighbors.remove(targetVertexId.get());
}
@Override
public void add(Edge<IntWritable, NullWritable> edge) {
neighbors.add(edge.getTargetVertexId().get());
}
@Override
public void trim() {
neighbors.trim();
}
/**
* 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;
}
