/** Get a graph and direct only the unshielded colliders. */
public static void basicPattern(Graph graph) {
Set<Edge> undirectedEdges = new HashSet<Edge>();
NEXT_EDGE:
for (Edge edge : graph.getEdges()) {
Node head = null, tail = null;
if (edge.getEndpoint1() == Endpoint.ARROW && edge.getEndpoint2() == Endpoint.TAIL) {
head = edge.getNode1();
tail = edge.getNode2();
} else if (edge.getEndpoint2() == Endpoint.ARROW && edge.getEndpoint1() == Endpoint.TAIL) {
head = edge.getNode2();
tail = edge.getNode1();
}
if (head != null) {
for (Node node : graph.getParents(head)) {
if (node != tail && !graph.isAdjacentTo(tail, node)) {
continue NEXT_EDGE;
}
}
undirectedEdges.add(edge);
}
}
for (Edge nextUndirected : undirectedEdges) {
Node node1 = nextUndirected.getNode1(), node2 = nextUndirected.getNode2();
graph.removeEdge(nextUndirected);
graph.addUndirectedEdge(node1, node2);
}
}
/** Initializes the lists of parents and parent dimension for the given variable. */
private void initializeNode(int nodeIndex) {
Node node = nodes[nodeIndex];
// Set up parents array. Should store the parents of
// each node as ints in a particular order.
Graph graph = getBayesPm().getDag();
List<Node> parentList = new ArrayList<Node>(graph.getParents(node));
int[] parentArray = new int[parentList.size()];
for (int i = 0; i < parentList.size(); i++) {
parentArray[i] = getNodeIndex(parentList.get(i));
}
// Sort parent array.
Arrays.sort(parentArray);
parents[nodeIndex] = parentArray;
// Setup dimensions array for parents.
int[] dims = new int[parentArray.length];
for (int i = 0; i < dims.length; i++) {
Node parNode = nodes[parentArray[i]];
dims[i] = getBayesPm().getNumCategories(parNode);
}
parentDims[nodeIndex] = dims;
}
// ===========================SCORING METHODS===================//
public double scoreDag(Graph graph) {
Graph dag = new EdgeListGraphSingleConnections(graph);
buildIndexing(graph);
double score = 0.0;
for (Node y : dag.getNodes()) {
Set<Node> parents = new HashSet<Node>(dag.getParents(y));
int nextIndex = -1;
for (int i = 0; i < getVariables().size(); i++) {
nextIndex = hashIndices.get(variables.get(i));
}
int parentIndices[] = new int[parents.size()];
Iterator<Node> pi = parents.iterator();
int count = 0;
while (pi.hasNext()) {
Node nextParent = pi.next();
parentIndices[count++] = hashIndices.get(nextParent);
}
if (this.isDiscrete()) {
score += localDiscreteScore(nextIndex, parentIndices);
} else {
score += localSemScore(nextIndex, parentIndices);
}
}
return score;
}
/**
* Transforms a maximally directed pattern (PDAG) represented in graph <code>g</code> into an
* arbitrary DAG by modifying <code>g</code> itself. Based on the algorithm described in
* Chickering (2002) "Optimal structure identification with greedy search" Journal of Machine
* Learning Research. R. Silva, June 2004
*/
public static void pdagToDag(Graph g) {
Graph p = new EdgeListGraph(g);
List<Edge> undirectedEdges = new ArrayList<Edge>();
for (Edge edge : g.getEdges()) {
if (edge.getEndpoint1() == Endpoint.TAIL
&& edge.getEndpoint2() == Endpoint.TAIL
&& !undirectedEdges.contains(edge)) {
undirectedEdges.add(edge);
}
}
g.removeEdges(undirectedEdges);
List<Node> pNodes = p.getNodes();
do {
Node x = null;
for (Node pNode : pNodes) {
x = pNode;
if (p.getChildren(x).size() > 0) {
continue;
}
Set<Node> neighbors = new HashSet<Node>();
for (Edge edge : p.getEdges()) {
if (edge.getNode1() == x || edge.getNode2() == x) {
if (edge.getEndpoint1() == Endpoint.TAIL && edge.getEndpoint2() == Endpoint.TAIL) {
if (edge.getNode1() == x) {
neighbors.add(edge.getNode2());
} else {
neighbors.add(edge.getNode1());
}
}
}
}
if (neighbors.size() > 0) {
Collection<Node> parents = p.getParents(x);
Set<Node> all = new HashSet<Node>(neighbors);
all.addAll(parents);
if (!GraphUtils.isClique(all, p)) {
continue;
}
}
for (Node neighbor : neighbors) {
Node node1 = g.getNode(neighbor.getName());
Node node2 = g.getNode(x.getName());
g.addDirectedEdge(node1, node2);
}
p.removeNode(x);
break;
}
pNodes.remove(x);
} while (pNodes.size() > 0);
}
/** Evaluate the Insert(X, Y, T) operator (Definition 12 from Chickering, 2002). */
private double insertEval(Node x, Node y, List<Node> t, List<Node> naYX, Graph graph) {
Set<Node> set1 = new HashSet<Node>(naYX);
set1.addAll(t);
List<Node> paY = graph.getParents(y);
set1.addAll(paY);
Set<Node> set2 = new HashSet<Node>(set1);
set1.add(x);
return scoreGraphChange(y, set1, set2);
}
// Can be done concurrently.
private double deleteEval(Node x, Node y, List<Node> h, List<Node> naYX, Graph graph) {
List<Node> paY = graph.getParents(y);
Set<Node> paYMinuxX = new HashSet<Node>(paY);
paYMinuxX.remove(x);
Set<Node> set1 = new HashSet<Node>(naYX);
set1.removeAll(h);
set1.addAll(paYMinuxX);
Set<Node> set2 = new HashSet<Node>(naYX);
set2.removeAll(h);
set2.addAll(paY);
return scoreGraphChange(y, set1, set2);
}
