/** 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);
}
}
public static Graph weightedRandomGraph(int n, int e) {
List<Node> nodes = new ArrayList<Node>();
for (int i = 0; i < n; i++) nodes.add(new GraphNode("X" + i));
Graph graph = new EdgeListGraph(nodes);
for (int e0 = 0; e0 < e; e0++) {
int i1 = weightedRandom(nodes, graph);
// int i2 = RandomUtil.getInstance().nextInt(n);
int i2 = weightedRandom(nodes, graph);
if (!(shortestPath(nodes.get(i1), nodes.get(i2), graph) < 9)) {
e0--;
continue;
}
if (i1 == i2) {
e0--;
continue;
}
Edge edge = Edges.undirectedEdge(nodes.get(i1), nodes.get(i2));
if (graph.containsEdge(edge)) {
e0--;
continue;
}
graph.addEdge(edge);
}
for (Edge edge : graph.getEdges()) {
Node n1 = edge.getNode1();
Node n2 = edge.getNode2();
if (!graph.isAncestorOf(n2, n1)) {
graph.removeEdge(edge);
graph.addDirectedEdge(n1, n2);
} else {
graph.removeEdge(edge);
graph.addDirectedEdge(n2, n1);
}
}
return graph;
}
private void calcStats() {
// Graph resultGraph = getAlgorithmRunner().getResultGraph();
IGesRunner runner = (IGesRunner) getAlgorithmRunner();
if (runner.getTopGraphs().isEmpty()) {
throw new IllegalArgumentException(
"No patterns were recorded. Please adjust the number of " + "patterns to store.");
}
Graph resultGraph = runner.getTopGraphs().get(runner.getIndex()).getGraph();
if (getAlgorithmRunner().getDataModel() instanceof DataSet) {
// resultGraph may be the output of a PC search.
// Such graphs sometimes contain doubly directed edges.
// /We converte such edges to directed edges here.
// For the time being an orientation is arbitrarily selected.
Set<Edge> allEdges = resultGraph.getEdges();
for (Edge edge : allEdges) {
if (edge.getEndpoint1() == Endpoint.ARROW && edge.getEndpoint2() == Endpoint.ARROW) {
// Option 1 orient it from node1 to node2
resultGraph.setEndpoint(edge.getNode1(), edge.getNode2(), Endpoint.ARROW);
// Option 2 remove such edges:
resultGraph.removeEdge(edge);
}
}
Pattern pattern = new Pattern(resultGraph);
PatternToDag ptd = new PatternToDag(pattern);
Graph dag = ptd.patternToDagMeekRules();
DataSet dataSet = (DataSet) getAlgorithmRunner().getDataModel();
String report;
if (dataSet.isContinuous()) {
report = reportIfContinuous(dag, dataSet);
} else if (dataSet.isDiscrete()) {
report = reportIfDiscrete(dag, dataSet);
} else {
throw new IllegalArgumentException("");
}
JScrollPane dagWorkbenchScroll = dagWorkbenchScroll(dag);
modelStatsText.setLineWrap(true);
modelStatsText.setWrapStyleWord(true);
modelStatsText.setText(report);
removeStatsTabs();
tabbedPane.addTab("DAG in pattern", dagWorkbenchScroll);
tabbedPane.addTab("DAG Model Statistics", modelStatsText);
}
}
public static Graph bestGuessCycleOrientation(Graph graph, IndependenceTest test) {
while (true) {
List<Node> cycle = GraphUtils.directedCycle(graph);
if (cycle == null) {
break;
}
LinkedList<Node> _cycle = new LinkedList<Node>(cycle);
Node first = _cycle.getFirst();
Node last = _cycle.getLast();
_cycle.addFirst(last);
_cycle.addLast(first);
int _j = -1;
double minP = Double.POSITIVE_INFINITY;
for (int j = 1; j < _cycle.size() - 1; j++) {
int i = j - 1;
int k = j + 1;
Node x = test.getVariable(_cycle.get(i).getName());
Node y = test.getVariable(_cycle.get(j).getName());
Node z = test.getVariable(_cycle.get(k).getName());
test.isIndependent(x, z, Collections.singletonList(y));
System.out.println("Testing " + x + " _||_ " + z + " | " + y);
double p = test.getPValue();
System.out.println("p = " + p);
if (p < minP) {
_j = j;
minP = p;
}
}
Node x = _cycle.get(_j - 1);
Node y = _cycle.get(_j);
Node z = _cycle.get(_j + 1);
graph.removeEdge(x, y);
graph.removeEdge(z, y);
graph.addDirectedEdge(x, y);
graph.addDirectedEdge(z, y);
}
return graph;
}
/** Orients according to background knowledge. */
public static void pcOrientbk(Knowledge bk, Graph graph, List<Node> nodes) {
TetradLogger.getInstance().log("info", "Staring BK Orientation.");
for (Iterator<KnowledgeEdge> it = bk.forbiddenEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge edge = it.next();
// match strings to variables in the graph.
Node from = translate(edge.getFrom(), nodes);
Node to = translate(edge.getTo(), nodes);
if (from == null || to == null) {
continue;
}
if (graph.getEdge(from, to) == null) {
continue;
}
// Orient to-->from
graph.removeEdge(from, to);
graph.addDirectedEdge(from, to);
graph.setEndpoint(from, to, Endpoint.TAIL);
graph.setEndpoint(to, from, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(to, from)));
}
for (Iterator<KnowledgeEdge> it = bk.requiredEdgesIterator(); it.hasNext(); ) {
KnowledgeEdge edge = it.next();
// match strings to variables in this graph
Node from = translate(edge.getFrom(), nodes);
Node to = translate(edge.getTo(), nodes);
if (from == null || to == null) {
continue;
}
if (graph.getEdge(from, to) == null) {
continue;
}
// Orient from-->to
graph.setEndpoint(to, from, Endpoint.TAIL);
graph.setEndpoint(from, to, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(from, to)));
}
TetradLogger.getInstance().log("info", "Finishing BK Orientation.");
}
private void uncorrelationExogenousVariables() {
Graph graph = getWorkbench().getGraph();
Set<Edge> edges = graph.getEdges();
for (Edge edge : edges) {
if (Edges.isBidirectedEdge(edge)) {
try {
graph.removeEdge(edge);
} catch (Exception e) {
// Ignore.
}
}
}
}
private Graph pickDag(Graph graph) {
SearchGraphUtils.basicPattern(graph, false);
addRequiredEdges(graph);
boolean containsUndirected;
do {
containsUndirected = false;
for (Edge edge : graph.getEdges()) {
if (Edges.isUndirectedEdge(edge)) {
containsUndirected = true;
graph.removeEdge(edge);
Edge _edge = Edges.directedEdge(edge.getNode1(), edge.getNode2());
graph.addEdge(_edge);
}
}
meekOrient(graph, getKnowledge());
} while (containsUndirected);
return graph;
}
/** Do an actual deletion (Definition 13 from Chickering, 2002). */
private void delete(Node x, Node y, List<Node> subset, Graph graph, double bump) {
Edge trueEdge = null;
if (trueGraph != null) {
Node _x = trueGraph.getNode(x.getName());
Node _y = trueGraph.getNode(y.getName());
trueEdge = trueGraph.getEdge(_x, _y);
}
if (log && verbose) {
Edge oldEdge = graph.getEdge(x, y);
String label = trueGraph != null && trueEdge != null ? "*" : "";
TetradLogger.getInstance()
.log(
"deletedEdges",
(graph.getNumEdges() - 1)
+ ". DELETE "
+ oldEdge
+ " "
+ subset
+ " ("
+ bump
+ ") "
+ label);
out.println(
(graph.getNumEdges() - 1)
+ ". DELETE "
+ oldEdge
+ " "
+ subset
+ " ("
+ bump
+ ") "
+ label);
} else {
int numEdges = graph.getNumEdges() - 1;
if (numEdges % 50 == 0) out.println(numEdges);
}
graph.removeEdge(x, y);
for (Node h : subset) {
Edge oldEdge = graph.getEdge(y, h);
graph.removeEdge(y, h);
graph.addDirectedEdge(y, h);
if (log) {
TetradLogger.getInstance()
.log("directedEdges", "--- Directing " + oldEdge + " to " + graph.getEdge(y, h));
}
if (verbose) {
out.println("--- Directing " + oldEdge + " to " + graph.getEdge(y, h));
}
if (Edges.isUndirectedEdge(graph.getEdge(x, h))) {
if (!graph.isAdjacentTo(x, h))
throw new IllegalArgumentException("Not adjacent: " + x + ", " + h);
oldEdge = graph.getEdge(x, h);
graph.removeEdge(x, h);
graph.addDirectedEdge(x, h);
if (log) {
TetradLogger.getInstance()
.log("directedEdges", "--- Directing " + oldEdge + " to " + graph.getEdge(x, h));
}
if (verbose) {
out.println("--- Directing " + oldEdge + " to " + graph.getEdge(x, h));
}
}
}
}
// serial.
private void insert(Node x, Node y, List<Node> t, Graph graph, double bump) {
if (graph.isAdjacentTo(x, y)) {
return; // The initial graph may already have put this edge in the graph.
// throw new IllegalArgumentException(x + " and " + y + " are already adjacent in
// the graph.");
}
Edge trueEdge = null;
if (trueGraph != null) {
Node _x = trueGraph.getNode(x.getName());
Node _y = trueGraph.getNode(y.getName());
trueEdge = trueGraph.getEdge(_x, _y);
}
graph.addDirectedEdge(x, y);
if (log) {
String label = trueGraph != null && trueEdge != null ? "*" : "";
TetradLogger.getInstance()
.log(
"insertedEdges",
graph.getNumEdges()
+ ". INSERT "
+ graph.getEdge(x, y)
+ " "
+ t
+ " "
+ bump
+ " "
+ label);
} else {
int numEdges = graph.getNumEdges() - 1;
if (verbose) {
if (numEdges % 50 == 0) out.println(numEdges);
}
}
if (verbose) {
String label = trueGraph != null && trueEdge != null ? "*" : "";
out.println(
graph.getNumEdges()
+ ". INSERT "
+ graph.getEdge(x, y)
+ " "
+ t
+ " "
+ bump
+ " "
+ label);
} else {
int numEdges = graph.getNumEdges() - 1;
if (verbose) {
if (numEdges % 50 == 0) out.println(numEdges);
}
}
for (Node _t : t) {
Edge oldEdge = graph.getEdge(_t, y);
if (oldEdge == null) throw new IllegalArgumentException("Not adjacent: " + _t + ", " + y);
graph.removeEdge(_t, y);
graph.addDirectedEdge(_t, y);
if (log && verbose) {
TetradLogger.getInstance()
.log("directedEdges", "--- Directing " + oldEdge + " to " + graph.getEdge(_t, y));
out.println("--- Directing " + oldEdge + " to " + graph.getEdge(_t, y));
}
}
}
////////////////////////////////////////////
// RFCI Algorithm 4.4 (Colombo et al, 2012)
// Orient colliders
////////////////////////////////////////////
private void ruleR0_RFCI(List<Node[]> rTuples) {
List<Node[]> lTuples = new ArrayList<Node[]>();
List<Node> nodes = graph.getNodes();
///////////////////////////////
// process tuples in rTuples
while (!rTuples.isEmpty()) {
Node[] thisTuple = rTuples.remove(0);
Node i = thisTuple[0];
Node j = thisTuple[1];
Node k = thisTuple[2];
final List<Node> nodes1 = getSepset(i, k);
if (nodes1 == null) continue;
List<Node> sepSet = new ArrayList<Node>(nodes1);
sepSet.remove(j);
boolean independent1 = false;
if (knowledge.noEdgeRequired(i.getName(), j.getName())) // if BK allows
{
try {
independent1 = independenceTest.isIndependent(i, j, sepSet);
} catch (Exception e) {
independent1 = true;
}
}
boolean independent2 = false;
if (knowledge.noEdgeRequired(j.getName(), k.getName())) // if BK allows
{
try {
independent2 = independenceTest.isIndependent(j, k, sepSet);
} catch (Exception e) {
independent2 = true;
}
}
if (!independent1 && !independent2) {
lTuples.add(thisTuple);
} else {
// set sepSets to minimal separating sets
if (independent1) {
setMinSepSet(sepSet, i, j);
graph.removeEdge(i, j);
}
if (independent2) {
setMinSepSet(sepSet, j, k);
graph.removeEdge(j, k);
}
// add new unshielded tuples to rTuples
for (Node thisNode : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(thisNode);
if (independent1) // <i, ., j>
{
if (adjacentNodes.contains(i) && adjacentNodes.contains(j)) {
Node[] newTuple = {i, thisNode, j};
rTuples.add(newTuple);
}
}
if (independent2) // <j, ., k>
{
if (adjacentNodes.contains(j) && adjacentNodes.contains(k)) {
Node[] newTuple = {j, thisNode, k};
rTuples.add(newTuple);
}
}
}
// remove tuples involving either (if independent1) <i, j>
// or (if independent2) <j, k> from rTuples
Iterator<Node[]> iter = rTuples.iterator();
while (iter.hasNext()) {
Node[] curTuple = iter.next();
if ((independent1 && (curTuple[1] == i) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent2 && (curTuple[1] == k) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent1 && (curTuple[1] == j) && ((curTuple[0] == i) || (curTuple[2] == i)))
|| (independent2
&& (curTuple[1] == j)
&& ((curTuple[0] == k) || (curTuple[2] == k)))) {
iter.remove();
}
}
// remove tuples involving either (if independent1) <i, j>
// or (if independent2) <j, k> from lTuples
iter = lTuples.iterator();
while (iter.hasNext()) {
Node[] curTuple = iter.next();
if ((independent1 && (curTuple[1] == i) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent2 && (curTuple[1] == k) && ((curTuple[0] == j) || (curTuple[2] == j)))
|| (independent1 && (curTuple[1] == j) && ((curTuple[0] == i) || (curTuple[2] == i)))
|| (independent2
&& (curTuple[1] == j)
&& ((curTuple[0] == k) || (curTuple[2] == k)))) {
iter.remove();
}
}
}
}
///////////////////////////////////////////////////////
// orient colliders (similar to original FCI ruleR0)
for (Node[] thisTuple : lTuples) {
Node i = thisTuple[0];
Node j = thisTuple[1];
Node k = thisTuple[2];
List<Node> sepset = getSepset(i, k);
if (sepset == null) {
continue;
}
if (!sepset.contains(j) && graph.isAdjacentTo(i, j) && graph.isAdjacentTo(j, k)) {
if (!isArrowpointAllowed(i, j)) {
continue;
}
if (!isArrowpointAllowed(k, j)) {
continue;
}
graph.setEndpoint(i, j, Endpoint.ARROW);
graph.setEndpoint(k, j, Endpoint.ARROW);
printWrongColliderMessage(i, j, k, "R0_RFCI");
}
}
}
