/** * Builds the DAG over the set of variables given with the naive Bayes structure */ @Override protected void buildDAG() { dag = new DAG(vars); dag.getParentSets().stream().filter(w -> !w.getMainVar().equals(classVar)).forEach(w -> w.addParent(classVar)); }
dagLDA.setName("LDA"); dagLDA.getParentSet(word).addParent(topicIndicator); .map(pSet -> pSet.getMainVar().getDistributionType().<EF_ConditionalDistribution>newEFConditionalDistribution(pSet.getParents())) .collect(Collectors.toList());
/** * 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); }
/** * Sets the dynamic DAG for this this DynamicPlateauStructure. * @param dbnModel a {@link DynamicDAG} object. */ public void setDBNModel(DynamicDAG dbnModel) { this.dbnModel = dbnModel; List<EF_ConditionalDistribution> distTim0 = this.dbnModel.getParentSetsTime0().stream().map(pSet -> pSet.getMainVar().getDistributionType().<EF_ConditionalDistribution>newEFConditionalDistribution(pSet.getParents())).collect(Collectors.toList()); this.setEFBayesianNetworkTime0(new EF_LearningBayesianNetwork(distTim0)); List<EF_ConditionalDistribution> distTimT = this.dbnModel.getParentSetsTimeT().stream().map(pSet -> pSet.getMainVar().getDistributionType().<EF_ConditionalDistribution>newEFConditionalDistribution(pSet.getParents())).collect(Collectors.toList()); this.setEFBayesianNetworkTimeT(new EF_LearningBayesianNetwork(distTimT)); }
/** * 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(); }
/** * Builds the DAG over the set of variables given with the structure of the model */ @Override protected void buildDAG() { dag = new DAG(vars); // add the links between the attributes (features) List<Variable> attrVars = vars.getListOfVariables(); for (int i=0; i<attrVars.size()-1; i++){ for(int j=i+1; j<attrVars.size(); j++) { // Add the links dag.getParentSet(attrVars.get(i)).addParent(attrVars.get(j)); } } }
dag.getParentSet(staticVar).addParent(variables.getVariableByName(groupedClassName + "_t" + Integer.toString(mergedClassVarIndex - 1))); }); List<Variable> parents0 = dynamicDAG.getParentSetTime0(dynVar).getParents(); parents0.stream().filter(parent -> parent.equals(MAPvariable)).forEach(parentaux2 -> dag.getParentSet(staticVar0).addParent(variables.getVariableByName(groupedClassName + "_t0"))); parents0.stream().filter(parent -> !parent.equals(MAPvariable)).forEach(parentaux2 -> dag.getParentSet(staticVar0).addParent(variables.getVariableByName(parentaux2.getName() + "_t0"))); List<Variable> parents = dynamicDAG.getParentSetTimeT(dynVar).getParents(); parentsInterface.stream().filter(parent -> parent.equals(MAPvariable)).forEach(parentVar -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(groupedClassName + "_t" + Integer.toString(indexMAPReplication - 1)))); parentsInterface.stream().filter(parent -> !parent.equals(MAPvariable)).forEach(parentVar -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(parentVar.getName().replace("_Interface", "_t" + Integer.toString(timeStep - 1))))); parentsNotInterface.stream().filter(parent -> parent.equals(MAPvariable)).forEach(parentVar -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(groupedClassName + "_t" + Integer.toString(indexMAPReplication)))); parentsNotInterface.stream().filter(parent -> !parent.equals(MAPvariable)).forEach(parentVar -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(parentVar.getName() + "_t" + Integer.toString(timeStep))));
if (dag.getParentSetTime0(var2).contains(var1) || !var2.getDistributionType().isParentCompatible(var1) || dag.getParentSetTime0(var2).getNumberOfParents()>=3) continue; dag.getParentSetTime0(var2).addParent(var1); dagLinks++; if (dag.getParentSetTimeT(var2).contains(var1) || !var2.getDistributionType().isParentCompatible(var1) || dag.getParentSetTimeT(var2).getNumberOfParents()>=3) continue; dag.getParentSetTimeT(var2).addParent(var1); dagLinks++; dag.getParentSetTimeT(variable).addParent(variable.getInterfaceVariable());
Variable var2 = nonConnectedVars.get(random.nextInt(nonConnectedVars.size())); if (var1.getVarID()<var2.getVarID() && dag.getParentSetTime0(var2).getNumberOfParents()==0 && var2.getDistributionType().isParentCompatible(var1)) dag.getParentSetTime0(var2).addParent(var1); else if (var2.getVarID()<var1.getVarID() && dag.getParentSetTime0(var1).getNumberOfParents()==0 && var1.getDistributionType().isParentCompatible(var2)) dag.getParentSetTime0(var1).addParent(var2); else continue; Variable var2 = nonConnectedVars.get(random.nextInt(nonConnectedVars.size())); if (var1.getVarID()<var2.getVarID() && dag.getParentSetTimeT(var2).getNumberOfParents()==0 && var2.getDistributionType().isParentCompatible(var1)) dag.getParentSetTimeT(var2).addParent(var1); else if (var2.getVarID()<var1.getVarID() && dag.getParentSetTimeT(var1).getNumberOfParents()==0 && var1.getDistributionType().isParentCompatible(var2)) dag.getParentSetTimeT(var1).addParent(var2); else continue;
/** * Sets the distribution of a normal variable with multinomial parents in the AMIDST model from the corresponding * distribution in the Hugin model. * For each assignment of the multinomial parents, a univariate normal is set. * @param huginVar the Hugin variable with the distribution to be converted. * @throws ExceptionHugin */ private void setNormal_MultinomialParents(Node huginVar) throws ExceptionHugin { int indexNode = this.huginBN.getNodes().indexOf(huginVar); Variable amidstVar = this.amidstBN.getVariables().getVariableById(indexNode); List<Variable> conditioningVariables = this.amidstBN.getDAG().getParentSet(amidstVar).getParents(); int numParentAssignments = MultinomialIndex.getNumberOfPossibleAssignments(conditioningVariables); Normal_MultinomialParents dist = this.amidstBN.getConditionalDistribution(amidstVar); for (int i = 0; i < numParentAssignments; i++) { Normal normal = dist.getNormal(i); this.setNormal(huginVar, normal, i); } }
Variable staticVar_current = variables.getVariableByName(groupedClassName + "_t1"); Variable staticVar_interface = variables.getVariableByName(groupedClassName + "_t0"); List<Variable> parents = bn.getDAG().getParentSet(staticVar_current).getParents(); ConditionalDistribution conDist_dynamic = Serialization.deepCopy(conDistT); Variable staticVar_current = variables.getVariableByName(groupedClassName + "_t2"); Variable staticVar_interface = variables.getVariableByName(groupedClassName + "_t1"); List<Variable> parents = bn.getDAG().getParentSet(staticVar_current).getParents(); ConditionalDistribution conDist_dynamic = Serialization.deepCopy(conDistT); generalConditionalDistTimeT = new Multinomial_MultinomialParents(staticVar, bn.getDAG().getParentSet(staticVar).getParents()); Variable staticVar0 = variables.getVariableByName(groupedClassName + "_t1"); Variable staticVar0_interface = variables.getVariableByName(groupedClassName + "_t0"); List<Variable> parents = bn.getDAG().getParentSet(staticVar0).getParents(); ConditionalDistribution conDist_dynamic = Serialization.deepCopy(model.getConditionalDistributionsTimeT().get(dynVar.getVarID())); ConditionalDistribution conditionalDistTime1 = groupedDistributionMAPVariableTimeT(dynVar, staticVar0, staticVar0_interface.getNumberOfStates(), parents, conDist_dynamic, modelNumber); Variable staticVar1 = variables.getVariableByName(groupedClassName + "_t" + Integer.toString(timeStep)); ConditionalDistribution conditionalDistribution = Serialization.deepCopy(generalConditionalDistTimeT); conditionalDistribution.setConditioningVariables(dag.getParentSet(staticVar1).getParents()); conditionalDistribution.setVar(staticVar1); bn.setConditionalDistribution(staticVar1, conditionalDistribution); List<Variable> parents1 = bn.getDAG().getParentSet(staticVar1).getParents(); List<Variable> dynVariablesWithClassParent = dynVariables.stream().filter(var -> !var.equals(MAPvariable)).filter(var -> dynamicDAG.getParentSetTime0(var).contains(MAPvariable)).collect(Collectors.toList()); List<Variable> dynVariablesNoClassParent = dynVariables.stream().filter(var -> !var.equals(MAPvariable)).filter(var -> !dynamicDAG.getParentSetTime0(var).contains(MAPvariable)).collect(Collectors.toList());
public void addParent(Variable var) { if (!mainVar.getDistributionType().isParentCompatible(var)){ throw new IllegalArgumentException("Adding a parent of type "+var.getDistributionTypeEnum().toString()+ " which is not compatible " + "with children variable of type "+this.mainVar.getDistributionTypeEnum().toString()); } if (this.contains(var)) { throw new IllegalArgumentException("Trying to add a duplicated parent"); } vars.add(var); if (!var.isInterfaceVariable() && !parentSetTime0.get(mainVar.getVarID()).contains(var)) { ((ParentSetImpl) parentSetTime0.get(mainVar.getVarID())).vars.add(var); } }
/** * Builds the DAG over the set of variables given with the naive Bayes structure */ @Override protected void buildDAG() { //Obtain the predictive attributes List<Variable> attrVars = vars.getListOfVariables().stream() .filter(v -> !v.equals(classVar)).collect(Collectors.toList()); //Create the hidden variabels hiddenMultinomial = vars.newMultinomialVariable("M", numStatesHidden); contHiddenList = new ArrayList<Variable>(); for(int i=0; i<numContinuousHidden; i++) { contHiddenList.add(vars.newGaussianVariable("Z"+Integer.toString(i))); } dag = new DAG(vars); //arcs from the class to the hidden variables dag.getParentSet(hiddenMultinomial).addParent(classVar); contHiddenList.stream().forEach(z -> dag.getParentSet(z).addParent(classVar)); //arcs from the hidden vars to each attribute attrVars.stream().forEach(x->dag.getParentSet(x).addParent(hiddenMultinomial)); for (Variable z : contHiddenList) { attrVars.stream().forEach(x->dag.getParentSet(x).addParent(z)); } } /*
dynamicDAG.getParentSetTime0(dynVar).getParents().stream().forEach(parentaux2 -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(parentaux2.getName() + "_t0"))); } else { final int final_i=i; dynamicDAG.getParentSetTimeT(dynVar).getParents().stream().filter(parentVar -> parentVar.isInterfaceVariable()).forEach(parentVar -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(parentVar.getName().replace("_Interface", "_t" + Integer.toString(final_i - 1))))); dynamicDAG.getParentSetTimeT(dynVar).getParents().stream().filter(parentVar -> !parentVar.isInterfaceVariable()).forEach(parentVar -> dag.getParentSet(staticVar).addParent(variables.getVariableByName(parentVar.getName() + "_t" + Integer.toString(final_i))));
.filter(p -> p.getMainVar().isObservable()) .map(p -> p.getMainVar().getName()) .collect(Collectors.toList()); .flatMap(p -> p.getParents().stream()) .filter(v -> v.isInterfaceVariable()) .map( v -> this.dynamicDAG.getDynamicVariables().getVariableFromInterface(v)) .flatMap(p -> p.getParents().stream()) .filter(v -> v.isInterfaceVariable()) .map(v -> v.getName())
if (dag.getParentSetTime0(var2).contains(var1) || !var2.getDistributionType().isParentCompatible(var1) || dag.getParentSetTime0(var2).getNumberOfParents()>=3) { iter++; continue; dag.getParentSetTime0(var2).addParent(var1); dagLinks++; if (dag.getParentSetTimeT(var2).contains(var1) || !var2.getDistributionType().isParentCompatible(var1) || dag.getParentSetTimeT(var2).getNumberOfParents()>=3){ iter++; continue; dag.getParentSetTimeT(var2).addParent(var1); dagLinks++; iter++; dag.getParentSetTimeT(variable).addParent(variable.getInterfaceVariable());
/** * Sets the distribution of a multinomial variable with multinomial parents in the AMIDST model * from the corresponding distribution in the Hugin model. * @param huginVar the Hugin variable with the distribution to be converted. * @throws ExceptionHugin */ private void setMultinomial_MultinomialParents(Node huginVar) throws ExceptionHugin { int indexNode = this.huginBN.getNodes().indexOf(huginVar); Variable amidstVar = this.amidstBN.getVariables().getVariableById(indexNode); int numStates = amidstVar.getNumberOfStates(); double[] huginProbabilities = huginVar.getTable().getData(); List<Variable> parents = this.amidstBN.getDAG().getParentSet(amidstVar).getParents(); int numParentAssignments = MultinomialIndex.getNumberOfPossibleAssignments(parents); for (int i = 0; i < numParentAssignments; i++) { double[] amidstProbabilities = new double[numStates]; for (int k = 0; k < numStates; k++) { amidstProbabilities[k] = huginProbabilities[i * numStates + k]; } Multinomial_MultinomialParents dist = this.amidstBN.getConditionalDistribution(amidstVar); dist.getMultinomial(i).setProbabilities(amidstProbabilities); } }
@Override protected void buildDAG() { Variable superParentVar = vars.newMultinomialVariable("superParentVar",getNumStates()); dag = new DAG(vars); dag.getParentSets() .stream() .filter(w -> !w.getMainVar().equals(classVar)) .filter(w -> !w.getMainVar().equals(superParentVar)) .forEach(w -> { w.addParent(classVar); w.addParent(superParentVar); }); dag.getParentSet(superParentVar).addParent(classVar); }
/** * Builds the graph */ @Override protected void buildDAG() { List<Variable> observableVariables = new ArrayList<>(); List<Variable> latentVariables = new ArrayList<>(); vars.forEach(observableVariables::add); Variable discreteLatentVar = vars.newMultinomialVariable("DiscreteLatentVar",numberOfStatesLatentDiscreteVar); IntStream.range(0,numberOfLatentVariables).forEach(i -> { Variable latentVar = vars.newGaussianVariable("LatentVar" + i); latentVariables.add(latentVar); }); dag = new DAG(vars); for (Variable variable : observableVariables) { dag.getParentSet(variable).addParent(discreteLatentVar); latentVariables.forEach(latentVariable -> dag.getParentSet(variable).addParent(latentVariable)); } }
dagLDA.setName("LDA"); dagLDA.getParentSet(word).addParent(topicIndicator); .map(pSet -> pSet.getMainVar().getDistributionType().<EF_ConditionalDistribution>newEFConditionalDistribution(pSet.getParents())) .collect(Collectors.toList());