@Override protected void buildDAG() { //Obtain the predictive attributes List<Variable> attrVars = variables.getListOfDynamicVariables().stream() .filter(v -> !v.equals(classVar)).collect(Collectors.toList()); //Create the hidden variabels hiddenMultinomial = variables.newMultinomialDynamicVariable("M", numStatesHidden); contHiddenList = new ArrayList<Variable>(); for(int i=0; i<numContinuousHidden; i++) { contHiddenList.add(variables.newGaussianDynamicVariable("Z"+Integer.toString(i))); } dynamicDAG = new DynamicDAG(variables); //arcs from the class to the hidden variables dynamicDAG.getParentSetTimeT(hiddenMultinomial).addParent(classVar); contHiddenList.stream().forEach(z -> dynamicDAG.getParentSetTimeT(z).addParent(classVar)); //arcs from the hidden vars to each attribute attrVars.stream().forEach(x->dynamicDAG.getParentSetTimeT(x).addParent(hiddenMultinomial)); for (Variable z : contHiddenList) { attrVars.stream().forEach(x->dynamicDAG.getParentSetTimeT(x).addParent(z)); } //Add dynamic links on class and continuous layer dynamicDAG.getParentSetTimeT(classVar).addParent(classVar.getInterfaceVariable()); for (Variable variable : contHiddenList) { dynamicDAG.getParentSetTimeT(variable).addParent(variable.getInterfaceVariable()); } }
/** * Returns a textual representation of the parent set of this DynamicDAG. * @return a String description of the parent set of this DynamicDAG. */ public String toString() { StringBuilder str = new StringBuilder(); str.append("\nDynamic DAG at Time 0\n"); for (Variable var : this.getDynamicVariables()) { str.append(var.getName() + " has "+ this.getParentSetTime0(var).getNumberOfParents() + " parent(s): " + this.parentSetTime0.get(var.getVarID()).toString() + "\n"); } str.append("\nDynamic DAG at Time T\n"); for (Variable var : this.getDynamicVariables()) { str.append(var.getName() + " has "+ this.getParentSetTimeT(var).getNumberOfParents() + " parent(s): " + this.getParentSetTimeT(var).toString() + "\n"); } return str.toString(); }
/** * Return the list of non-observed and temporally connected variables for time T. * @return a {@code List} of {@link Variable}. */ private List<Variable> getTargetVarsTimeT(){ return this.model.getDynamicVariables().getListOfDynamicVariables().stream() .filter(var -> !var.isInterfaceVariable()) .filter(var -> Utils.isMissingValue(this.assignment.getValue(var))) .filter(var -> { boolean notContainInterfaceVar = true; for (Variable variable : this.model.getDynamicDAG().getParentSetTimeT(var)) { notContainInterfaceVar = notContainInterfaceVar && !variable.isInterfaceVariable(); } return !notContainInterfaceVar; }) .collect(Collectors.toList()); }
@Override protected void buildDAG() { /*number of continuous hidden variable*/ int numHiddenVars=3; /** Create a set of dynamic variables from the given attributes**/ variables = new DynamicVariables(attributes); /* List of continuous hidden vars*/ List<Variable> gaussianHiddenVars = new ArrayList<>(); for(int i=0; i<numHiddenVars; i++) { Variable Hi = variables.newGaussianDynamicVariable("gaussianHiddenVar" + i); gaussianHiddenVars.add(Hi); } DynamicDAG dynamicDAG = new DynamicDAG(this.variables); for (Variable h : gaussianHiddenVars) { dynamicDAG.getParentSetTimeT(h).addParent(h.getInterfaceVariable()); } for (Variable variable: variables) { if (gaussianHiddenVars.contains(variable)) continue; for (Variable h : gaussianHiddenVars) { dynamicDAG.getParentSetTimeT(variable).addParent(h); } } //This is needed to maintain coherence in the DynamicModel class. this.variables = variables; this.dynamicDAG = dynamicDAG; }
/** * Sets the MAP variable for this DynamicMAPInference. * @param MAPvariable a valid {@link Variable} object. */ public void setMAPvariable(Variable MAPvariable) { boolean parents0 = model.getDynamicDAG().getParentSetTime0(MAPvariable).getNumberOfParents()>0; boolean parentsT = model.getDynamicDAG().getParentSetTimeT(MAPvariable).getParents().stream().anyMatch(parent -> !parent.isInterfaceVariable()); if (parents0 || parentsT) { System.out.println("Error: The dynamic MAP variable must not have parents"); System.exit(-5); } if (!MAPvariable.isMultinomial()) { System.out.println("Error: The dynamic MAP variable must be multinomial"); System.exit(-10); } this.MAPvariable = MAPvariable; this.MAPvarName = MAPvariable.getName(); }
throw new UnsupportedOperationException("Invalid configuration: all the input variables must be " + "discrete"); dynamicDAG.getParentSetTimeT(discreteHiddenVar).addParent(inputVar); for (Variable outputVar : outputVars) { dynamicDAG.getParentSetTimeT(outputVar).addParent(inputVar); dynamicDAG.getParentSetTimeT(outputVar).addParent(discreteHiddenVar); dynamicDAG.getParentSetTimeT(discreteHiddenVar).addParent(discreteHiddenVar.getInterfaceVariable()); for(int j=i+1; j<inputVars.size(); j++) { dynamicDAG.getParentSetTime0(inputVars.get(i)).addParent(inputVars.get(j)); dynamicDAG.getParentSetTimeT(inputVars.get(i)).addParent(inputVars.get(j)); for(int j=i+1; j<outputVars.size(); j++) { dynamicDAG.getParentSetTime0(outputVars.get(i)).addParent(outputVars.get(j)); dynamicDAG.getParentSetTimeT(outputVars.get(i)).addParent(outputVars.get(j));
@Override protected void buildDAG() { Variable discreteHiddenVar = this.variables.newMultinomialDynamicVariable("discreteHiddenVar", getNumStatesHiddenVar()); dynamicDAG = new DynamicDAG(this.variables); dynamicDAG.getParentSetsTimeT() .stream() .filter(w -> w.getMainVar() != discreteHiddenVar) .forEach(w -> w.addParent(discreteHiddenVar)); dynamicDAG.getParentSetTimeT(discreteHiddenVar).addParent(discreteHiddenVar.getInterfaceVariable()); /* * Learn full covariance matrix */ if(!isDiagonal()) { List<Variable> observedVars = this.variables.getListOfDynamicVariables() .stream() .filter(v -> !v.equals(discreteHiddenVar)) .peek(v-> { if(v.isMultinomial()) throw new UnsupportedOperationException("Full covariance matrix cannot be used with" + " multinomial attributes"); }) .collect(Collectors.toList()); for (int i=0; i<observedVars.size()-1; i++){ for(int j=i+1; j<observedVars.size(); j++) { dynamicDAG.getParentSetTime0(observedVars.get(i)).addParent(observedVars.get(j)); dynamicDAG.getParentSetTimeT(observedVars.get(i)).addParent(observedVars.get(j)); } } } }
}); dynamicDAG.getParentSetTimeT(discreteHiddenVar).addParent(discreteHiddenVar.getInterfaceVariable()); for(int j=i+1; j<observedVars.size(); j++) { dynamicDAG.getParentSetTime0(observedVars.get(i)).addParent(observedVars.get(j)); dynamicDAG.getParentSetTimeT(observedVars.get(i)).addParent(observedVars.get(j));
dag.getParentSetTimeT(sensorT1).addParent(temperature); dag.getParentSetTimeT(sensorT2).addParent(temperature); dag.getParentSetTimeT(sensorSmoke).addParent(smoke); dag.getParentSetTimeT(temperature).addParent(fire); dag.getParentSetTimeT(temperature).addParent(temperature.getInterfaceVariable()); dag.getParentSetTimeT(smoke).addParent(fire); dag.getParentSetTimeT(smoke).addParent(smoke.getInterfaceVariable()); dag.getParentSetTimeT(fire).addParent(fire.getInterfaceVariable());
globalDynamicDAG.getParentSetTimeT(variable).addParent(classVariable); for (int i = 0; i < this.numberOfGlobalVars ; i++) { globalDynamicDAG.getParentSetTimeT(variable).addParent(hiddenVars.get(i)); this.globalDynamicDAG.getParentSetTimeT(classVariable).addParent(classVariable.getInterfaceVariable()); System.out.println(globalDynamicDAG.toString());
/** * In this example we show how to create an input-outputString KF with Gaussian mixtures (as in Figure 4.29 of Deliverable 2.1). */ public static void VerdandeInputOutputHMM() throws IOException { DataStream<DynamicDataInstance> data = DynamicDataStreamLoader.loadFromFile("datasets/simulated/syntheticDataVerdandeScenario3.arff"); Attribute attDepth = data.getAttributes().getAttributeByName("depth"); Attribute attGammaDiff = data.getAttributes().getAttributeByName("gammaDiff"); DynamicVariables dynamicVariables = new DynamicVariables(); Variable observedDepth = dynamicVariables.newDynamicVariable(attDepth); Variable observedGammaDiff = dynamicVariables.newDynamicVariable(attGammaDiff); Variable formationNo = dynamicVariables.newMultinomialLogisticDynamicVariable("FormationNo", 2); Variable shift = dynamicVariables.newMultinomialDynamicVariable("Shift",2); DynamicDAG dynamicDAG = new DynamicDAG(dynamicVariables); dynamicDAG.getParentSetTimeT(formationNo).addParent(observedDepth); dynamicDAG.getParentSetTimeT(formationNo).addParent(dynamicVariables.getInterfaceVariable(formationNo)); //TODO Error trying to add a duplicate parent. A -> B <- Aclone. We are considering A and AClone the same variables? Is that right? dynamicDAG.getParentSetTimeT(shift).addParent(formationNo); //dynamicDAG.getParentSetTimeT(shift).addParent(dynamicVariables.getInterfaceVariable(formationNo)); dynamicDAG.getParentSetTimeT(shift).addParent(dynamicVariables.getInterfaceVariable(shift)); dynamicDAG.getParentSetTimeT(observedGammaDiff).addParent(shift); System.out.println("-------------------------------------\n"); System.out.println("Input-outputString HMM (Figure 4.31 of D2.1)\n"); System.out.println(dynamicDAG.toString()); DynamicBayesianNetwork dbn = new DynamicBayesianNetwork(dynamicDAG); System.out.println(dbn.toString()); DynamicBayesianNetworkWriter.save(dbn, "networks/simulated/HuginVerdandeIOHMM.dbn"); }
/** * Initializes the distributions of this DynamicBayesianNetwork. * The initialization is performed for each variable at time ) and T depending on its distribution type * as well as the distribution type of its parent set (if that variable has parents). */ private void initializeDistributions() { //Parents should have been assigned before calling this method (from dynamicmodelling.models) this.distributionsTime0 = new ArrayList(this.getDynamicVariables().getNumberOfVars()); this.distributionsTimeT = new ArrayList(this.getDynamicVariables().getNumberOfVars()); for (Variable var : this.getDynamicVariables()) { int varID = var.getVarID(); /* Distributions at time t */ this.distributionsTimeT.add(varID, var.newConditionalDistribution(this.dynamicDAG.getParentSetTimeT(var).getParents())); this.dynamicDAG.getParentSetTimeT(var).blockParents(); /* Distributions at time 0 */ this.distributionsTime0.add(varID, var.newConditionalDistribution(this.dynamicDAG.getParentSetTime0(var).getParents())); this.dynamicDAG.getParentSetTime0(var).blockParents(); } //distributionsTimeT = Collections.unmodifiableList(this.distributionsTimeT); //distributionsTime0 = Collections.unmodifiableList(this.distributionsTime0); }
/** * Returns the DAG at time T of this DynamicDAG. * @return a {@link DAG} object. */ public DAG toDAGTimeT(){ List<Variable> allVariables = new ArrayList<>(); allVariables.addAll(this.getDynamicVariables().getListOfDynamicVariables()); allVariables.addAll(this.getDynamicVariables().getListOfInterfaceVariables()); Variables staticVariables = Variables.auxiliarBuilder(allVariables); DAG dag = new DAG(staticVariables); dag.setName(this.getName()); for (Variable dynamicVariable : dynamicVariables) { for (Variable parent : this.getParentSetTimeT(dynamicVariable)) { dag.getParentSet(dynamicVariable).addParent(parent); } } return dag; }
/** * Generates a Dynamic Naive Bayes DAG with a Multinomial class variable. * @param numberClassStates the number of states for the class variable. * @param connectChildrenTemporally a {@code boolean} that indicates whether the children are connected temporally or not. * @return a {@link DynamicDAG} object. */ public static DynamicDAG generateDynamicNaiveBayesDAG(int numberClassStates, boolean connectChildrenTemporally){ DynamicVariables dynamicVariables = new DynamicVariables(); //class variable which is always discrete Variable classVar = dynamicVariables.newMultinomialDynamicVariable(classVarName, numberClassStates); //Discrete variables IntStream.range(1, numberOfDiscreteVars+1) .forEach(i -> dynamicVariables.newMultinomialDynamicVariable(discreteVarName + i, DynamicBayesianNetworkGenerator.numberOfStates)); //Continuous variables IntStream.range(1,numberOfContinuousVars+1) .forEach(i -> dynamicVariables.newGaussianDynamicVariable(continuousVarName + i)); DynamicDAG dag = new DynamicDAG(dynamicVariables); dag.getParentSetsTimeT().stream() .filter(var -> var.getMainVar().getVarID()!=classVar.getVarID()) .forEach(w -> { w.addParent(classVar); if (connectChildrenTemporally) { w.addParent(dynamicVariables.getInterfaceVariable(w.getMainVar())); } } ); dag.getParentSetTimeT(classVar).addParent(dynamicVariables.getInterfaceVariable(classVar)); return dag; }
.filter(var -> { boolean notContainInterfaceVar = true; for (Variable variable : this.model.getDynamicDAG().getParentSetTimeT(var)) { notContainInterfaceVar = notContainInterfaceVar && !variable.isInterfaceVariable();
public static DynamicBayesianNetwork createDBN1(int numVars) throws Exception { DynamicVariables dynamicVariables = new DynamicVariables(); Variable classVar = dynamicVariables.newMultinomialDynamicVariable("C", 2); for (int i = 0; i < numVars; i++) { dynamicVariables.newGaussianDynamicVariable("A" + i); } DynamicDAG dag = new DynamicDAG(dynamicVariables); for (int i = 0; i < numVars; i++) { dag.getParentSetTimeT(dynamicVariables.getVariableByName("A" + i)).addParent(classVar); if (connectDBN) dag.getParentSetTimeT(dynamicVariables.getVariableByName("A" + i)).addParent(dynamicVariables.getVariableByName("A" + i).getInterfaceVariable()); } //dag.getParentSetTimeT(classVar).addParent(classVar.getInterfaceVariable()); dag.setName("dbn1"); DynamicBayesianNetwork dbn = new DynamicBayesianNetwork(dag); dbn.randomInitialization(new Random(1)); return dbn; }
public static List<Variable> getCausalOrderTimeT(DynamicDAG dag){ DynamicVariables variables = dag.getDynamicVariables(); int nNrOfAtts = variables.getNumberOfVars(); List<Variable> order = new ArrayList(); boolean[] bDone = new boolean[variables.getNumberOfVars()]; for (Variable var: variables){ bDone[var.getVarID()] = false; } for (int iAtt = 0; iAtt < nNrOfAtts; iAtt++) { boolean allParentsDone = false; for (Variable var2 : variables){ if (!bDone[var2.getVarID()]) { allParentsDone = true; for (Variable parent: dag.getParentSetTimeT(var2)) { if (parent.isInterfaceVariable()) continue; allParentsDone = allParentsDone && bDone[parent.getVarID()]; } if (allParentsDone){ order.add(var2); bDone[var2.getVarID()] = true; } } } } return order; }
/** * This method returns a DynamicDAG object with naive Bayes structure for the given attributes. * @param attributes object of the class Attributes * @param classIndex integer value indicating the possition of the class * @return object of the class DynamicDAG */ public static DynamicDAG getNaiveBayesStructure(Attributes attributes, int classIndex){ //We create a Variables object from the attributes of the data stream DynamicVariables dynamicVariables = new DynamicVariables(attributes); //We define the predicitive class variable Variable classVar = dynamicVariables.getVariableById(classIndex); //Then, we create a DAG object with the defined model header DynamicDAG dag = new DynamicDAG(dynamicVariables); //We set the links of the DAG. dag.getParentSetsTimeT().stream() .filter(var -> var.getMainVar().getVarID()!=classVar.getVarID()) .forEach(w -> { w.addParent(classVar); //Connect children in consecutive time steps w.addParent(dynamicVariables.getInterfaceVariable(w.getMainVar())); } ); //Connect the class variable in consecutive time steps dag.getParentSetTimeT(classVar).addParent(dynamicVariables.getInterfaceVariable(classVar)); return dag; }
/** * Learns the dynamic graphical structure for this DynamicNaiveBayesClassifier given an input data stream. * @param dataStream a {@link DataStream} of {@link DynamicDataInstance}s. * @return a {@link DynamicDAG} object. */ private DynamicDAG dynamicNaiveBayesStructure(DataStream<DynamicDataInstance> dataStream){ DynamicVariables dynamicVariables = new DynamicVariables(dataStream.getAttributes()); Variable classVar = dynamicVariables.getVariableById(this.getClassVarID()); DynamicDAG dag = new DynamicDAG(dynamicVariables); dag.getParentSetsTimeT().stream() .filter(w -> w.getMainVar().getVarID() != classVar.getVarID()) .forEach(w -> { w.addParent(classVar); if(isConnectChildrenTemporally()) w.addParent(dynamicVariables.getInterfaceVariable(w.getMainVar())); }); dag.getParentSetTimeT(classVar).addParent(dynamicVariables.getInterfaceVariable(classVar)); return dag; }
/** * Sets the Hugin model structure from the AMIDST Dynamic DAG. * @param amidstDBN the Dynamic Bayesian network model in AMIDST format. * @throws ExceptionHugin */ private void setStructure (DynamicBayesianNetwork amidstDBN) throws ExceptionHugin { DynamicDAG dynamicDAG = amidstDBN.getDynamicDAG(); DynamicVariables dynamicVariables = amidstDBN.getDynamicVariables(); List<Variable> amidstVars = dynamicVariables.getListOfDynamicVariables(); for (Variable amidstChild: amidstVars){ List<Variable> amidstParents = dynamicDAG.getParentSetTimeT(amidstChild).getParents(); Node huginChild = this.huginDBN.getNodeByName(amidstChild.getName()); for(Variable amidstParent: amidstParents) { if(amidstParent.isInterfaceVariable()) { huginChild.addParent(huginChild.getTemporalClone()); } else { //Variable Node huginParent = this.huginDBN.getNodeByName(amidstParent.getName()); huginChild.addParent(huginParent); Node huginParentClone = huginParent.getTemporalClone(); Node huginChildClone = huginChild.getTemporalClone(); huginChildClone.addParent(huginParentClone); } } } }