private double getPMulticluster(List<List<Integer>> clusters, int numRestarts) { if (false) { Graph g = new EdgeListGraph(); List<Node> latents = new ArrayList<Node>(); for (int i = 0; i < clusters.size(); i++) { GraphNode latent = new GraphNode("L" + i); latent.setNodeType(NodeType.LATENT); latents.add(latent); g.addNode(latent); List<Node> cluster = variablesForIndices(clusters.get(i)); for (int j = 0; j < cluster.size(); j++) { g.addNode(cluster.get(j)); g.addDirectedEdge(latent, cluster.get(j)); } } SemPm pm = new SemPm(g); // pm.fixOneLoadingPerLatent(); SemOptimizerPowell semOptimizer = new SemOptimizerPowell(); semOptimizer.setNumRestarts(numRestarts); SemEstimator est = new SemEstimator(cov, pm, semOptimizer); est.setScoreType(SemIm.ScoreType.Fgls); est.estimate(); return est.getEstimatedSem().getPValue(); } else { double max = Double.NEGATIVE_INFINITY; for (int i = 0; i < numRestarts; i++) { Mimbuild2 mimbuild = new Mimbuild2(); List<List<Node>> _clusters = new ArrayList<List<Node>>(); for (List<Integer> _cluster : clusters) { _clusters.add(variablesForIndices(_cluster)); } List<String> names = new ArrayList<String>(); for (int j = 0; j < clusters.size(); j++) { names.add("L" + j); } mimbuild.search(_clusters, names, cov); double c = mimbuild.getpValue(); if (c > max) max = c; } return max; } }
private double getP(List<Integer> cluster, int numRestarts) { if (true) { Node latent = new GraphNode("L"); latent.setNodeType(NodeType.LATENT); Graph g = new EdgeListGraph(); g.addNode(latent); List<Node> measures = variablesForIndices(cluster); for (Node node : measures) { g.addNode(node); g.addDirectedEdge(latent, node); } SemPm pm = new SemPm(g); // pm.fixOneLoadingPerLatent(); SemOptimizerPowell semOptimizer = new SemOptimizerPowell(); semOptimizer.setNumRestarts(numRestarts); SemEstimator est = new SemEstimator(cov, pm, semOptimizer); est.setScoreType(SemIm.ScoreType.Fgls); est.estimate(); return est.getEstimatedSem().getPValue(); } else { double max = Double.NEGATIVE_INFINITY; for (int i = 0; i < numRestarts; i++) { Mimbuild2 mimbuild = new Mimbuild2(); List<List<Node>> clusters1 = new ArrayList<List<Node>>(); clusters1.add(variablesForIndices(new ArrayList<Integer>(cluster))); List<String> names = new ArrayList<String>(); names.add("L"); mimbuild.search(clusters1, names, cov); double c = mimbuild.getpValue(); if (c > max) max = c; } return max; } }
private double getClusterP2(List<Node> c) { Graph g = new EdgeListGraph(c); Node l = new GraphNode("L"); l.setNodeType(NodeType.LATENT); g.addNode(l); for (Node n : c) { g.addDirectedEdge(l, n); } SemPm pm = new SemPm(g); SemEstimator est; if (dataModel instanceof DataSet) { est = new SemEstimator((DataSet) dataModel, pm, new SemOptimizerEm()); } else { est = new SemEstimator((CovarianceMatrix) dataModel, pm, new SemOptimizerEm()); } SemIm estIm = est.estimate(); double pValue = estIm.getPValue(); return pValue == 1 ? Double.NaN : pValue; }
/** * Constructs a new standardized SEM IM from the freeParameters in the given SEM IM. * * @param im Stop asking me for these things! The given SEM IM!!! * @param initialization CALCULATE_FROM_SEM if the initial values will be calculated from the * given SEM IM; INITIALIZE_FROM_DATA if data will be simulated from the given SEM, * standardized, and estimated. */ public StandardizedSemIm(SemIm im, Initialization initialization) { this.semPm = new SemPm(im.getSemPm()); this.semGraph = new SemGraph(semPm.getGraph()); semGraph.setShowErrorTerms(true); if (semGraph.existsDirectedCycle()) { throw new IllegalArgumentException("The cyclic case is not handled."); } if (initialization == Initialization.CALCULATE_FROM_SEM) { // This code calculates the new coefficients directly from the old ones. edgeParameters = new HashMap<Edge, Double>(); List<Node> nodes = im.getVariableNodes(); TetradMatrix impliedCovar = im.getImplCovar(true); for (Parameter parameter : im.getSemPm().getParameters()) { if (parameter.getType() == ParamType.COEF) { Node a = parameter.getNodeA(); Node b = parameter.getNodeB(); int aindex = nodes.indexOf(a); int bindex = nodes.indexOf(b); double vara = impliedCovar.get(aindex, aindex); double stda = Math.sqrt(vara); double varb = impliedCovar.get(bindex, bindex); double stdb = Math.sqrt(varb); double oldCoef = im.getEdgeCoef(a, b); double newCoef = (stda / stdb) * oldCoef; edgeParameters.put(Edges.directedEdge(a, b), newCoef); } else if (parameter.getType() == ParamType.COVAR) { Node a = parameter.getNodeA(); Node b = parameter.getNodeB(); Node exoa = semGraph.getExogenous(a); Node exob = semGraph.getExogenous(b); double covar = im.getErrCovar(a, b) / Math.sqrt(im.getErrVar(a) * im.getErrVar(b)); edgeParameters.put(Edges.bidirectedEdge(exoa, exob), covar); } } } else { // This code estimates the new coefficients from simulated data from the old model. DataSet dataSet = im.simulateData(1000, false); TetradMatrix _dataSet = dataSet.getDoubleData(); _dataSet = DataUtils.standardizeData(_dataSet); DataSet dataSetStandardized = ColtDataSet.makeData(dataSet.getVariables(), _dataSet); SemEstimator estimator = new SemEstimator(dataSetStandardized, im.getSemPm()); SemIm imStandardized = estimator.estimate(); edgeParameters = new HashMap<Edge, Double>(); for (Parameter parameter : imStandardized.getSemPm().getParameters()) { if (parameter.getType() == ParamType.COEF) { Node a = parameter.getNodeA(); Node b = parameter.getNodeB(); double coef = imStandardized.getEdgeCoef(a, b); edgeParameters.put(Edges.directedEdge(a, b), coef); } else if (parameter.getType() == ParamType.COVAR) { Node a = parameter.getNodeA(); Node b = parameter.getNodeB(); Node exoa = semGraph.getExogenous(a); Node exob = semGraph.getExogenous(b); double covar = -im.getErrCovar(a, b) / Math.sqrt(im.getErrVar(a) * im.getErrVar(b)); edgeParameters.put(Edges.bidirectedEdge(exoa, exob), covar); } } } this.measuredNodes = Collections.unmodifiableList(semPm.getMeasuredNodes()); }