private List<String> getNames(List<Node> nodes) {
List<String> names = new ArrayList<String>();
for (Node node : nodes) {
names.add(node.getName());
}
return names;
}
public static Graph erdosRenyiGraph(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 = RandomUtil.getInstance().nextInt(n);
int i2 = RandomUtil.getInstance().nextInt(n);
if (i1 == i2) {
e0--;
continue;
}
Edge edge = Edges.undirectedEdge(nodes.get(i1), nodes.get(i2));
if (graph.containsEdge(edge)) {
e0--;
continue;
}
graph.addEdge(edge);
}
return graph;
}
private Graph structure(Graph mim) {
List<Node> latents = new ArrayList<Node>();
for (Node node : mim.getNodes()) {
if (node.getNodeType() == NodeType.LATENT) {
latents.add(node);
}
}
return mim.subgraph(latents);
}
private boolean dConnected(Graph graph, String x, String y, String... z) {
Node _x = graph.getNode(x);
Node _y = graph.getNode(y);
List<Node> _z = new ArrayList<Node>();
for (String name : z) {
_z.add(graph.getNode(name));
}
return graph.isDConnectedTo(_x, _y, _z);
}
public void testAlternativeGraphs() {
// UniformGraphGenerator gen = new UniformGraphGenerator(UniformGraphGenerator.ANY_DAG);
// gen.setNumNodes(100);
// gen.setMaxEdges(200);
// gen.setMaxDegree(30);
// gen.setMaxInDegree(30);
// gen.setMaxOutDegree(30);
//// gen.setNumIterations(3000000);
// gen.setResamplingDegree(10);
//
// gen.generate();
//
// Graph graph = gen.getDag();
Graph graph = weightedRandomGraph(250, 400);
List<Integer> degreeCounts = new ArrayList<Integer>();
Map<Integer, Integer> degreeCount = new HashMap<Integer, Integer>();
for (Node node : graph.getNodes()) {
int degree = graph.getNumEdges(node);
degreeCounts.add(degree);
if (degreeCount.get(degree) == null) {
degreeCount.put(degree, 0);
}
degreeCount.put(degree, degreeCount.get(degree) + 1);
}
Collections.sort(degreeCounts);
System.out.println(degreeCounts);
List<Integer> _degrees = new ArrayList<Integer>(degreeCount.keySet());
Collections.sort(_degrees);
for (int i : _degrees) {
int j = degreeCount.get(i);
// System.out.println(i + " " + j);
System.out.println(log(i + 1) + " " + log(j));
}
System.out.println("\nCPL = " + characteristicPathLength(graph));
Graph erGraph = erdosRenyiGraph(200, 200);
System.out.println("\n ER CPL = " + characteristicPathLength(erGraph));
}
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;
}
/** Tests to see if d separation facts are symmetric. */
public void testDSeparation2() {
EdgeListGraphSingleConnections graph =
new EdgeListGraphSingleConnections(
new Dag(GraphUtils.randomGraph(7, 0, 14, 30, 15, 15, true)));
List<Node> nodes = graph.getNodes();
int depth = -1;
for (int i = 0; i < nodes.size(); i++) {
for (int j = i; j < nodes.size(); j++) {
Node x = nodes.get(i);
Node y = nodes.get(j);
List<Node> theRest = new ArrayList<Node>(nodes);
// theRest.remove(x);
// theRest.remove(y);
DepthChoiceGenerator gen = new DepthChoiceGenerator(theRest.size(), depth);
int[] choice;
while ((choice = gen.next()) != null) {
List<Node> z = new LinkedList<Node>();
for (int k = 0; k < choice.length; k++) {
z.add(theRest.get(choice[k]));
}
boolean dConnectedTo = graph.isDConnectedTo(x, y, z);
boolean dConnectedTo1 = graph.isDConnectedTo(y, x, z);
if (dConnectedTo != dConnectedTo1) {
System.out.println(x + " d connected to " + y + " given " + z);
System.out.println(graph);
System.out.println("dconnectedto = " + dConnectedTo);
System.out.println("dconnecteto1 = " + dConnectedTo1);
fail();
}
}
}
}
}
/** Get all nodes that are connected to Y by an undirected edge and not adjacent to X. */
private static List<Node> getTNeighbors(Node x, Node y, Graph graph) {
List<Edge> yEdges = graph.getEdges(y);
List<Node> tNeighbors = new ArrayList<Node>();
for (Edge edge : yEdges) {
if (!Edges.isUndirectedEdge(edge)) {
continue;
}
Node z = edge.getDistalNode(y);
if (graph.isAdjacentTo(z, x)) {
continue;
}
tNeighbors.add(z);
}
return tNeighbors;
}
/**
* Find all nodes that are connected to Y by an undirected edge that are adjacent to X (that is,
* by undirected or directed edge).
*/
private static List<Node> getNaYX(Node x, Node y, Graph graph) {
List<Edge> yEdges = graph.getEdges(y);
List<Node> nayx = new ArrayList<Node>();
for (Edge edge : yEdges) {
if (!Edges.isUndirectedEdge(edge)) {
continue;
}
Node z = edge.getDistalNode(y);
if (!graph.isAdjacentTo(z, x)) {
continue;
}
nayx.add(z);
}
return nayx;
}
/** Tests to see if d separation facts are symmetric. */
public void testDSeparation() {
EdgeListGraphSingleConnections graph =
new EdgeListGraphSingleConnections(
new Dag(GraphUtils.randomGraph(7, 0, 7, 30, 15, 15, true)));
System.out.println(graph);
List<Node> nodes = graph.getNodes();
int depth = -1;
for (int i = 0; i < nodes.size(); i++) {
for (int j = i + 1; j < nodes.size(); j++) {
Node x = nodes.get(i);
Node y = nodes.get(j);
List<Node> theRest = new ArrayList<Node>(nodes);
theRest.remove(x);
theRest.remove(y);
DepthChoiceGenerator gen = new DepthChoiceGenerator(theRest.size(), depth);
int[] choice;
while ((choice = gen.next()) != null) {
List<Node> z = new LinkedList<Node>();
for (int k = 0; k < choice.length; k++) {
z.add(theRest.get(choice[k]));
}
if (graph.isDSeparatedFrom(x, y, z) != graph.isDSeparatedFrom(y, x, z)) {
fail(
SearchLogUtils.independenceFact(x, y, z)
+ " should have same d-sep result as "
+ SearchLogUtils.independenceFact(y, x, z));
}
}
}
}
}
public void rtest3() {
Node x = new GraphNode("X");
Node y = new GraphNode("Y");
Node z = new GraphNode("Z");
Node w = new GraphNode("W");
List<Node> nodes = new ArrayList<Node>();
nodes.add(x);
nodes.add(y);
nodes.add(z);
nodes.add(w);
Graph g = new EdgeListGraph(nodes);
g.addDirectedEdge(x, y);
g.addDirectedEdge(x, z);
g.addDirectedEdge(y, w);
g.addDirectedEdge(z, w);
Graph maxGraph = null;
double maxPValue = -1.0;
ICovarianceMatrix maxLatentCov = null;
Graph mim = DataGraphUtils.randomMim(g, 8, 0, 0, 0, true);
// Graph mim = DataGraphUtils.randomSingleFactorModel(5, 5, 8, 0, 0, 0);
Graph mimStructure = structure(mim);
SemPm pm = new SemPm(mim);
System.out.println("\n\nTrue graph:");
System.out.println(mimStructure);
SemImInitializationParams params = new SemImInitializationParams();
params.setCoefRange(0.5, 1.5);
SemIm im = new SemIm(pm, params);
int N = 1000;
DataSet data = im.simulateData(N, false);
CovarianceMatrix cov = new CovarianceMatrix(data);
for (int i = 0; i < 1; i++) {
ICovarianceMatrix _cov = DataUtils.reorderColumns(cov);
List<List<Node>> partition;
FindOneFactorClusters fofc = new FindOneFactorClusters(_cov, TestType.TETRAD_WISHART, .001);
fofc.search();
partition = fofc.getClusters();
System.out.println(partition);
List<String> latentVarList = reidentifyVariables(mim, data, partition, 2);
Mimbuild2 mimbuild = new Mimbuild2();
mimbuild.setAlpha(0.001);
// mimbuild.setMinimumSize(5);
// To test knowledge.
// Knowledge knowledge = new Knowledge2();
// knowledge.setEdgeForbidden("L.Y", "L.W", true);
// knowledge.setEdgeRequired("L.Y", "L.Z", true);
// mimbuild.setKnowledge(knowledge);
Graph mimbuildStructure = mimbuild.search(partition, latentVarList, _cov);
double pValue = mimbuild.getpValue();
System.out.println(mimbuildStructure);
System.out.println("P = " + pValue);
System.out.println("Latent Cov = " + mimbuild.getLatentsCov());
if (pValue > maxPValue) {
maxPValue = pValue;
maxGraph = new EdgeListGraph(mimbuildStructure);
maxLatentCov = mimbuild.getLatentsCov();
}
}
System.out.println("\n\nTrue graph:");
System.out.println(mimStructure);
System.out.println("\nBest graph:");
System.out.println(maxGraph);
System.out.println("P = " + maxPValue);
System.out.println("Latent Cov = " + maxLatentCov);
System.out.println();
}
